Announcement

Collapse
No announcement yet.

Changing the GoodKarma Script/updating it?

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

    Changing the GoodKarma Script/updating it?

    I was checking over the old GoodKarma script a while back and forgot to post this idea , but seeing as how its not been updated as it was given to killing floor , and killing floor was released publically , i was wondering if anyone had tried or thought of modifying the script so that it was more up todate?

    Just so you can see what i mean ...

    //NetKActor as part of the GoodKarma package
    //Build 10 Beta 2 Release
    //By: Jonathan Zepp
    //Original code based of the LawDogsKActor code available from unreal wiki (Thank You!)
    //This is intended to add full server playability, and make karma a universal tool.
    //Changes to bot pathing have also been made to put some sense into their empty heads...

    class NetKActor extends KActor
    placeable;

    var() float UpdateInterval; //The update speed over the net if NOT moving but active
    var() bool bBlockedPath ; //Enables Basic bot-pathing
    var() bool bCriticalObject ; //Will Always function despite server physics detail (not functional)
    var() float moveDistance ; //associated with bBlockedPath, how far the object must move for the bots to pass it
    var() bool bCollisionDamage ; //Enables damage when colliding with a player/vehicle/thing with health
    var() float DamageSpeed ; //Minimum speed to deal damage
    var() class<DamageType> HitDamageType ; //Damage type associated with bCollisionDamage
    var() float HitDamageScale ; //Relitive impact damage modifier

    var float NextNetUpdateTime;
    var KRigidBodyState KState, KRepState;
    var bool bNewKState;
    var int StateCount, LastStateCount;
    var vector startLocation ;
    var Keypoint SemiAwesome ;

    replication
    {
    unreliable if(Role == ROLE_Authority)
    KRepState, StateCount, SemiAwesome, startLocation;
    }

    simulated function PreBeginPlay()
    {
    Super.PreBeginPlay() ;
    if(bBlockedPath)
    SemiAwesome = spawn(class'shootTarget', self) ;
    }

    function Tick(float Delta)
    {
    if(!KIsAwake())
    PackState();
    }

    //Pack current state to be replicated
    function PackState()
    {
    local bool bChanged;

    KGetRigidBodyState(KState);

    bChanged = Level.TimeSeconds > NextNetUpdateTime;
    bChanged = bChanged || VSize(KRBVecToVector(KState.Position) - KRBVecToVector(KRepState.Position)) > 3;
    bChanged = bChanged || VSize(KRBVecToVector(KState.LinVel) - KRBVecToVector(KRepState.LinVel)) > 1;
    bChanged = bChanged || VSize(KRBVecToVector(KState.AngVel) - KRBVecToVector(KRepState.AngVel)) > 1;

    if(bChanged)
    {
    if(UpdateInterval >= 0.3)
    NextNetUpdateTime = Level.TimeSeconds + UpdateInterval ;
    else
    NextNetUpdateTime = Level.TimeSeconds + 0.3 ;
    KRepState = KState;
    StateCount++;
    if(stateCount < 2)
    startLocation = KRBVecToVector(KRepState.position);
    if(SemiAwesome != None && stateCount > 2) //Does it need to go away?
    {
    if(VSize(startLocation - KRBVecToVector(KRepState.Position)) > moveDistance)
    {
    SemiAwesome.Destroy() ;
    //DEBUG
    log(Tag$"'s shoot target has been removed!") ;
    log(Tag$" is "$VSize(startLocation - KRBVecToVector(KRepState.Position))$" units forom its original position!") ;
    }
    }
    //DEBUG
    //log(Tag$"'s next update time: "$NextNetUpdateTime$" Net-Update Count: "$StateCount) ;
    }
    else
    return;
    }

    //New state recieved.
    simulated event PostNetReceive()
    {
    if(StateCount == LastStateCount)
    return;
    }

    //Apply new state.
    simulated event bool KUpdateState(out KRigidBodyState newState)
    {
    //This should never get called on the server - but just in case!
    if(Role == ROLE_Authority || StateCount == LastStateCount)
    return false;

    //Apply received data as new position of actor.
    newState = KRepState;
    StateCount = LastStateCount;

    return true;
    }

    event RanInto(Actor Other)
    {
    local vector Momentum;
    local float Speed;
    if(bCollisionDamage && Other != None)
    {
    if (Pawn(Other) == None || Vehicle(Other) != None || Other == Instigator || Other.Role != ROLE_Authority)
    return;

    Speed = VSize(Velocity);
    if (Speed > DamageSpeed)
    {
    Momentum += Speed * 0.25 * Other.Mass * Normal(Velocity cross vect(0,0,1));
    Other.TakeDamage(int(Speed * 0.075 * HitDamageScale), Instigator, Other.Location, Momentum, HitDamageType);
    //DEBUG
    log(Tag$" injured "$Other.Tag$"!") ;
    }
    }
    }
    ^That is the old script .... and this one ...

    #2
    Rest of script sorry for Triple post

    //NetKActor as part of the GoodKarma package
    //Build 134 Beta 4.5 Release
    //By: Jonathan Zepp
    //Original code based of the LawDogsKActor code available from unreal wiki (Thank You!)
    //Though the current version has been SEVERELY modified, and modified some more.
    //This is intended to add full server playability, and make karma a universal tool.
    //Changes to bot pathing have also been made to put some sense into their empty heads...

    class NetKActor extends KActor
    placeable;

    #exec OBJ LOAD FILE="..\Sounds\WeaponSounds.uax"

    //Edit in default properties in UnrealEd

    var() bool bBlockedPath ; //Enables Basic bot-pathing
    var() bool bCriticalObject ; //Will Always function despite server physics detail (not fully functional)
    var() float moveDistance ; //associated with bBlockedPath, how far the object must move for the bots to pass it
    var() array<Sound> HitSounds ; //A sound to play on impact
    var() byte RelativeImpactVolume ; //The relative sound volume of the hit sound
    var() bool bShoveable ; //Can the object be shoved by a player?
    var() name BlockedPath ; //The name of the associated blocked path
    var() float ShoveModifier; //A multiplier to change how hard the object is shoved
    var() bool bPuntable ; //Allows a NetKActor to be punted
    var() int requiredPuntStrength ; //A value which must be met by the actor calling the DeclarePunt function for a punt to be accepted
    var() bool bEnableSpinProtection ; //Overrides standard karma features to make shoving the object always work properly, not reccomended on all objects, especially long ones, unless they have trouble.
    var() float hitSoundRepeatModifier ; //How much more often will hit sounds play?

    var(Damage) bool bCollisionDamage ; //Enables damage when colliding with a player/vehicle/thing with health
    var(Damage) float DamageSpeed ; //Minimum speed to deal damage
    var(Damage) class<DamageType> HitDamageType ; //Damage type associated with bCollisionDamage
    var(Damage) float HitDamageScale ; //Relative impact damage modifier
    var(Damage) int initialHealth ; //The starting health of an object
    var(Damage) int damageAbsorbtionAmount ; //Absorbs this much damage off each hit.
    var(Damage) bool limitDamagingClass ; //Only allows the constrained class to deal damage (and push it around)
    var(Damage) class<Weapon> DamageConstraintClass ; //The constraint class (only allowed class to damage it)

    var(Destruction) int explodeDamage ; //When dieing, how much damage does it deal to its fragments/people near it
    var(Destruction) float explodeRadius ; //How close does something have to be to be damaged when dieing
    var(Destruction) int explodeForce ; //How hard does it push fragments and other objects when dieing
    var(Destruction) bool bDestroyable ; //Does health and damage apply to this object?
    var(Destruction) sound DestructionSound ; //Sound played when the object is destroyed
    var(Destruction) byte DestructionVolume ; //Volume of the destruction sound
    var(Destruction) class<DoorExplode> DestroyedEffect; //The effect created when the object is destroyed
    var(Destruction) vector EffectOffset ; //Where the effect is in relation to the object when destroyed
    var(Destruction) bool bOrientDestructionEffect ; //Does the destruction effect have the same orientation as the hit which killed it?
    var(Destruction) float DestroyedMass ; //What the mass is when destroyed
    var(Destruction) float DestroyedDamping ; //What the damping is when destroyed
    var(Destruction) float DestroyedFriction ; //What the friction is when destroyed
    var(Destruction) float DestroyedBuoyancy ; //What the buoyancy is when destroyed
    var(Destruction) float DestroyedRestitution ; //What the restitution is when destroyed
    var(Destruction) StaticMesh DestroyedStaticMesh ; //The static mesh used for the object after it is destroyed (anything but none enables the 5 destroyed karma changing values)

    var(Respawning) float PreRespawnEffectTime ; //How long before the object respawns will the respawn effect play?
    var(Respawning) bool bRespawnEffect ; //Will a respawn effect play?
    var(Respawning) class<emitter> RespawnEffect ; //The effect spawned when the object respawns
    var(Respawning) bool bInactivityReset ; //Will the object reset automatically if moved and then idle?
    var(Respawning) float inactivityTimeout ; //How long of idleness will trigger an inactivity Reset?
    var(Respawning) sound RespawnSound ; //Sound played when the object is respawned
    var(Respawning) byte RespawnVolume ; //Volume of the respawning sound
    var(Respawning) float AutoRespawnTime ; //How long after it is destroyed does it wait to respawn on its own (-1 means it dosen't respawn)

    //Internal

    var vector startLocation ;
    var KRigidBodyState KState, KRepState, initialKState;
    var bool bPendingPunt, bPendingRespawn, bRespawnEffectPlayed, bInactive, bWaitTillMove, notifyPlayHit, bDead ;
    var int StateCount, LastStateCount, Health ;
    var actor Punter ;
    var float PuntTimeout, respawnClock, inactiveClock, lastShoveTimer, replaySoundClock ;
    var rotator startRotation, hitDirection ;
    var float initialRest, initialFric, initialMass, initialDampLin, initialDampAng, initialBuoy ;
    var StaticMesh initialMesh ;
    var byte clientPlay ; //0 for nothing, 1 for death emitters, 2 for respawn emitter

    // shadow variables
    var Projector Shadow;
    var ShadowProjector PlayerShadow;
    var globalconfig bool bBlobShadow;
    var () bool bKActorShadows;

    // ZOMG paint stains!
    /*
    var (Stains) bool bLeaveStains;
    var (Stains) float StainStreakInterval;
    var transient float LastStreakTime;
    var (Stains) float StainSpeedThreshold;
    */
    //var Actor LastTouchedActor;


    var vector DieVect;
    var vector lasthitlocation;
    var pawn lastinstigatedby,LastStander;



    replication
    {
    reliable if(Role == ROLE_Authority)
    KRepState, StateCount, bDead, Health, hitDirection, clientPlay ;
    reliable if(Role == ROLE_Authority)
    clientDeathEmitters, clientRespawnEmitter ,DestroyedEffect;
    reliable if(bNetInitial)
    startRotation, startLocation ;
    }

    function PreBeginPlay()
    {
    startLocation = Location ;
    startRotation = Rotation ;
    KGetRigidBodyState(initialKState) ;
    if(!bCriticalObject && Level.PhysicsDetailLevel == PDL_Low)
    SetPhysics(PHYS_None) ;
    initialRest = KParams.KRestitution ;
    initialFric = KParams.KFriction ;
    initialMass = (KarmaParams(KParams)).KMass ;
    initialDampLin = (KarmaParams(KParams)).KLinearDamping ;
    initialDampAng = (KarmaParams(KParams)).KAngularDamping ;
    initialBuoy = (KarmaParams(KParams)).KBuoyancy ;
    initialMesh = getObject(StaticMesh) ;
    respawn() ;
    }

    simulated function PostNetBeginPlay()
    {

    if ( bKActorShadows == true)
    {

    PlayerShadow = Spawn(class'ShadowProjector',Self,'',Location);
    PlayerShadow.ShadowActor = self;
    PlayerShadow.bBlobShadow = bBlobShadow;
    PlayerShadow.LightDirection = Normal(vect(1,1,3));
    PlayerShadow.LightDistance = 320;
    PlayerShadow.MaxTraceDistance = 350;
    PlayerShadow.InitShadow();

    PlayerShadow.bShadowActive = true;
    }

    // hardcode destruction effect to Material


    if (SurfaceType == EST_Metal)
    {
    DestroyedEffect = class'DoorExplodeMetalStandard';
    DestructionSound = Sound'PatchSounds.MetalCrash';
    }
    else
    if (SurfaceType == EST_Wood)
    DestroyedEffect = class'DoorExplodeWoodStandard';
    else
    DestroyedEffect = none;


    }

    function respawn()
    {
    setPhysics(PHYS_None) ;
    setLocation(StartLocation) ;
    setRotation(startRotation) ;
    SetStaticMesh(initialMesh) ;
    SetPhysics(PHYS_Karma) ;
    SetCollision(true, true, true) ;
    KSetMass(initialMass) ;
    KSetRestitution(initialRest) ;
    KSetDampingProps(initialDampLin, initialDampAng) ;
    KSetFriction(initialFric) ;
    (KarmaParams(KParams)).KBuoyancy = initialBuoy ;
    KRepState = initialKState ;
    Health = initialHealth ;
    bBlockedPath = default.bBlockedPath ;
    bPendingPunt = false ;
    bHidden = false ;
    bPendingRespawn = false ;
    if(bRespawnEffect && !bRespawnEffectPlayed)
    clientPlay = 2 ;
    bRespawnEffectPlayed = false ;
    bWaitTillMove = true ;
    inactiveClock = -999.0 ;
    bDead = false ;
    lastShoveTimer = 0.0 ;
    if(!((KarmaParams(KParams)).KStartEnabled))
    {
    KRepState.linVel = KRBVecFromVector(Vect(0,0,0)) ;
    KRepState.angVel = KRBVecFromVector(Vect(0,0,0)) ;
    }
    lastStateCount = StateCount ;
    //DEBUG
    //log("Respawn at "$Location$" Karma: "$KRBVecToVector(KRepState.Position)) ;
    //log(tag$" respawned at "$location$" and should be at "$startLocation) ;
    }

    function bool declarePunt(Actor newPunter, float maxTimeTo, bool bPriority, int Strength)
    {
    if(!bPuntable)
    return false ;
    if(((Punter != none && PuntTimeout <= level.timeSeconds) || Punter == none || bPriority) && Strength > RequiredPuntStrength)
    {
    Punter = newPunter ;
    PuntTimeout = level.timeSeconds + maxTimeTo ;
    bInactive = false ;
    return true ;
    }
    return false ;
    }

    simulated event Bump(Actor Other)
    {
    local vector Shove;
    local int damage ;
    local float Speed;
    local class<damageType> damageTypeClass ;
    // local KFBloodSplatter Streak;
    // local vector WallHit, WallNormal;
    // local Actor WallActor;


    if(Pawn(Other) == None || Other.role != ROLE_Authority)
    return ;
    if(limitDamagingClass && (Other != DamageConstraintClass))
    return ;
    if(bShoveable == false)
    return ;
    if(lastShoveTimer > level.timeSeconds)
    return ;
    This is only half of the new one

    Comment


      #3
      This is the rest of the newer script

      // no spinning wildly when people stand on you!
      if (pawn(Other) != none && pawn(Other).Base == self)
      {
      LastStander = pawn(Other);
      return;
      }


      if(!KIsAwake())
      KWake() ;



      damageTypeClass = class'DamTypeKick' ;
      damage = 3 ;



      /*
      if (bLeaveStains && Speed > StainSpeedThreshold)
      {
      StainStreakInterval -= (0.001 * VSize(Velocity));

      if (Other != none && Other.bWorldGeometry)
      WallActor = Trace(WallHit, WallNormal, Location + 50 * Velocity, Location, false);

      //Log(WallActor);

      if ( WallActor != None && Level.TimeSeconds > LastStreakTime + StainStreakInterval)
      {
      Streak= spawn(class 'KFMod.KFBloodSplatter',,,WallHit * (WallNormal + VRand()), rotator(-WallNormal));
      if (Streak != none)
      Streak.SetRotation(Rotator(Velocity));

      LastStreakTime = Level.TimeSeconds;
      }
      }
      */

      /*
      if (Other.IsA('KFHumanPawn'))
      {
      SetPhysics(PHYS_None);
      Other.attachtobone(self,'Bone_weapon');
      }
      */

      if(PuntTimeout >= level.timeSeconds && bPuntable)
      {
      if(Punter == Other)
      {
      damageTypeClass = class'DamTypePunt' ;
      damage = 9 ;
      }
      }
      else
      Punter = None ;

      Speed = VSize(Other.Velocity);
      Shove = (Normal(Other.Velocity) / (Mass * 0.4)) * ShoveModifier ;
      if(Other.Velocity.Z < -90.0)
      {
      Shove.Z *= 0.5 ;
      Shove.X *= 0.8 ;
      Shove.Y *= 0.8 ;
      }
      if(IsInWater(Other))
      {
      Shove.Z *= 0.75 ;
      Shove.X *= 0.5 ;
      Shove.Y *= 0.5 ;
      }
      if(shove.z == 0.0)
      shove.z = (1.6 / Mass) * 0.4 * ShoveModifier;
      if(bEnableSpinProtection)
      TakeDamage(damage, Pawn(Other), vect(0,0,0), Shove, damageTypeClass) ;
      else
      TakeDamage(damage, Pawn(Other), location, Shove, damageTypeClass) ;



      lastShoveTimer = level.timeSeconds + 0.1 ;
      }

      simulated event RanInto(Actor Other)
      {
      local vector Momentum;
      local float Speed;

      // if (Other.bWorldGeometry)
      // LastTouchedActor = Other;

      if(bCollisionDamage && Other != None && lastShoveTimer <= level.timeSeconds)
      {

      if ((Pawn(Other) == None) || (Vehicle(Other) != None) || Other == Instigator || Other.Role != ROLE_Authority)
      return;

      Speed = VSize(Velocity) ;

      //log(Velocity) ;

      if (Speed > DamageSpeed)
      {
      Momentum += Speed * 0.25 * Other.Mass * Normal(Velocity cross vect(0,0,1));
      Other.TakeDamage(int(Speed * 0.045 * HitDamageScale), Instigator, Other.Location, Momentum, HitDamageType);
      if(HitSounds.length != 0)
      notifyPlayHit = true ;
      //DEBUG
      //log(Tag$" injured "$Other.Tag$" dealing "$(int(Speed * 0.048 * HitDamageScale))$" Damage!") ;
      Velocity.z = Velocity.z * 0.45 ;
      if((Speed * 0.045 * HitDamageScale) >= 70)
      TakeDamage(3, instigator, Location, ((Velocity * -0.85) / (Mass + 1)), class'GoodKarma.DamTypeKick') ;
      else
      TakeDamage(7, instigator, Location, ((Velocity * -0.65) / (Mass + 1)), class'GoodKarma.DamTypeKick') ;
      }
      else if(Pawn(Other) != None)
      TakeDamage(4, instigator, Location, (Velocity * -1.03), class'GoodKarma.DamTypeKick') ;
      lastShoveTimer = level.TimeSeconds + 0.07 ;

      //log(Velocity) ;
      }

      //DEBUG
      //log(Tag$" is now moving at "$Velocity) ;
      }

      function TakeDamage(int Damage, Pawn instigatedBy, Vector hitlocation,
      Vector momentum, class<DamageType> damageType)
      {
      local vector ApplyImpulse;


      if(limitDamagingClass && (instigatedBy.Weapon != DamageConstraintClass))
      return ;

      lasthitlocation = hitlocation;
      lastinstigatedby = instigatedBy;

      Damage = Damage - DamageAbsorbtionAmount ;

      if(Damage < 0)
      Damage = 0 ;

      Health = Health - Damage ;

      if(Health <= 0 && bDestroyable && !bPendingRespawn)
      die() ;




      if(damageType.default.KDamageImpulse > 0)
      {
      if(VSize(momentum) < 0.001)
      {
      return;
      }
      ApplyImpulse = Normal(momentum) * damageType.default.KDamageImpulse;
      //DEBUG
      //log("********************") ;
      //log(ApplyImpulse) ;
      KAddImpulse(ApplyImpulse, hitlocation) ;
      }
      hitDirection = rotator(momentum) ;
      //DEBUG
      //log("TakeDamage") ;
      }

      function bool IsInWater(Actor Other)
      {
      local PhysicsVolume V;

      ForEach Other.TouchingActors(class'PhysicsVolume',V)
      {
      if(V.bWaterVolume == true)
      return true ;
      }
      return false;
      }



      simulated function KImpact(actor other, vector pos, vector impactVel, vector impactNorm)
      {
      Super.KImpact(Other,pos,impactVel,impactNorm);

      if (VSize(Velocity) != 0)
      {
      if(HitSounds.length != 0 )
      playServerHit();
      }
      }




      simulated function Tick(float Delta)
      {
      local pawn Stander;

      if(clientPlay != 0)
      {
      switch(clientPlay)
      {
      case 1: clientDeathEmitters() ;
      break ;
      case 2: clientRespawnEmitter() ;
      break ;
      default:log("clientPlay invalid value") ;
      }
      clientPlay = 0 ;
      }
      PackState();
      if(bPendingRespawn && respawnClock <= level.timeSeconds)
      respawn() ;
      if(bPendingRespawn && bRespawnEffect && !bRespawnEffectPlayed && (level.timeSeconds >= (respawnClock - PreRespawnEffectTime)))
      {
      clientPlay = 2 ;
      playServerSoundRespawn() ;
      bRespawnEffectPlayed = true ;
      }
      if(bPendingDelete)
      {
      die() ;
      bPendingDelete = false ;
      }
      if(bInactive && bInactivityReset && !bWaitTillMove)
      {
      if(inactiveClock == -999.0)
      inactiveClock = inactivityTimeout + level.timeSeconds ;
      else if(inactiveClock <= level.timeSeconds)
      {
      //DEBUG
      //log(tag$" is pending inactivity respawn") ;
      bPendingRespawn = true ;
      respawnClock = level.TimeSeconds + 1.5 ;
      inactiveClock = -999.0 ;
      }
      }

      // If someone's standing on me, i can't go flying.

      if (VSize(Velocity) != 0)
      {
      foreach BasedActors( class 'pawn',Stander)
      {
      if (Stander != none)
      {
      //Log("I'm being stood on. Halting movement");
      Velocity = vect(0,0,0);
      }
      }
      }

      // No super speeding objects

      if (Mass >= 0.5 && VSize(Velocity) > 100)
      Velocity *= 0.5;



      }

      //Pack current state to be replicated
      function PackState()
      {
      local bool bChanged;

      if(!KIsAwake())
      return;

      KGetRigidBodyState(KState);

      bChanged = false ;
      bChanged = bChanged || VSize(KRBVecToVector(KState.Position) - KRBVecToVector(KRepState.Position)) > 2.5;
      bChanged = bChanged || VSize(KRBVecToVector(KState.LinVel) - KRBVecToVector(KRepState.LinVel)) > 0.5;
      bChanged = bChanged || VSize(KRBVecToVector(KState.AngVel) - KRBVecToVector(KRepState.AngVel)) > 0.5;

      if(bChanged)
      {
      KRepState = KState;
      StateCount++;

      if(bBlockedPath && stateCount > 1) //Does it need to trigger the blocked path?
      {
      if(VSize(startLocation - KRBVecToVector(KRepState.Position)) > moveDistance)
      {
      bBlockedPath=false ;
      TriggerEvent(BlockedPath, self, None) ; //DO IT!
      //DEBUG
      log(Tag$" is "$VSize(startLocation - KRBVecToVector(KRepState.Position))$" units from its original position!") ;
      }
      }
      bInactive = false ;
      bWaitTillMove = false ;
      }
      else
      {
      bInactive = true ;
      return;
      }
      }

      simulated event PostNetReceive()
      {
      if(StateCount == LastStateCount)
      return;
      }

      simulated event bool KUpdateState(out KRigidBodyState newState)
      {
      if(StateCount == LastStateCount)
      return false;
      newState = KRepState;
      lastStateCount = StateCount ;
      return true;
      }

      /*
      simulated function UsedBy( Pawn user )
      {
      Log("I was just used...and I liked it");

      if (KFHumanPawn(user) != none)
      {
      SetPhysics(PHYS_None);
      user.AttachToBone( self, 'Bone_weapon' );
      }
      }
      */


      simulated function Die()
      {
      DieVect = lasthitlocation-lastinstigatedBy.location;

      //DEBUG
      //log("Die at "$location) ;
      bDead = true ;
      if(bDestroyable)
      {
      playServerSoundDestroy() ;

      if ( DestroyedEffect!=None && EffectIsRelevant(Location,false) )
      DestroyedEffect.Static.Boom(Self,rotator(DieVect)) ;

      ClientDeathEmitters();

      //DestroyedFX();
      HurtRadius(explodeDamage ,explodeRadius, class'DamTypeKick', explodeForce, Location) ;
      if(DestroyedStaticMesh == none)
      {
      bHidden = true ;
      SetPhysics(PHYS_None) ;
      SetCollision(false, false, false) ;
      Health = 0 ;
      Punter = none ;
      bPendingPunt = false ;
      }
      else
      {
      KWake() ;
      SetStaticMesh(DestroyedStaticMesh) ;
      KSetMass(DestroyedMass) ;
      KSetRestitution(DestroyedRestitution) ;
      KSetDampingProps(DestroyedDamping, DestroyedDamping) ;
      KSetFriction(DestroyedFriction) ;
      (KarmaParams(KParams)).KBuoyancy = DestroyedBuoyancy ;
      Health = 1 ;
      }
      }
      else
      {
      bHidden = true ;
      SetPhysics(PHYS_None) ;
      SetCollision(false, false, false) ;
      Health = 0 ;
      Punter = none ;
      bPendingPunt = false ;
      }
      if(AutoRespawnTime != -1)
      {
      bPendingRespawn = true ;
      respawnClock = level.timeseconds + AutoRespawnTime ;
      bInactive = false ;
      }
      clientPlay = 1 ;
      }




      function playServerSoundDestroy()
      {
      PlaySound(DestructionSound, SLOT_None, DestructionVolume) ;
      //log("Server-SoundDestroy") ;
      }

      function playServerSoundRespawn()
      {
      PlaySound(RespawnSound, SLOT_None, RespawnVolume) ;
      //log("Server-SoundRespawn") ;
      }

      function playServerHit()
      {
      local int a ;
      local float b ;

      if(replaySoundClock <= level.TimeSeconds)
      {
      a = Rand(HitSounds.length) ;
      b = rand(4) * 0.1 ;
      PlaySound(HitSounds[a] , SLOT_None, RelativeImpactVolume);
      notifyPlayHit = false ;
      replaySoundClock = level.timeSeconds + ((0.55 + b) * hitSoundRepeatModifier) ;
      }
      //log("Server-SoundHit") ;
      }

      simulated event FellOutOfWorld(eKillZType KillType)
      {Die() ;}

      function StaticMesh getObject(StaticMesh A)
      { return A ;}

      simulated function ClientDeathEmitters()
      {
      if( DestroyedEffect==None || level.NetMode!=NM_DedicatedServer)
      return;
      if(bOrientDestructionEffect)
      DestroyedEffect.Static.Boom(Self,hitDirection);
      else DestroyedEffect.Static.Boom(Self,hitDirection);
      }

      simulated function ClientRespawnEmitter()
      {
      if(level.NetMode != NM_DedicatedServer)
      return ;
      Spawn(RespawnEffect,,,startLocation + EffectOffset) ;
      //log("Client-EmittersRespawn") ;
      }

      Comment


        #4
        Post your huge (not overhuge though) codes and logs to http://www.pastebin.com/ instead of triple posting...
        But this seems to be interesting. What does this code actually do? And what do you want to get?

        Comment


          #5
          The code its self was created to simulate Karma physics over a network and online , in a game. What the first code is , is the public released version of the 2nd beta of it , i could not get my hands on the 4th public beta.

          After the 4th Beta , it was given to the Makers of the Killing Floor modification to improve and finish , and its currently now in its 4.5th beta (which was publically distributed with Killing Floor , but runs on their mod only) . The latest beta featured in the modification allows you to interact with your karma scenery actors , you can push them using your weight , things react as they would in Half life 2 , and its all done to work over a network too, aswell as this it gives scenery real time shadows that project onto the scenery actors.

          What i was wondering someone would attempt to try is taking the important sections that control, Shadow projection , physics and pushing effects and copy them to the other older beta that works , thus making a public released working version of the script so everyone can benefit from realistic physics.

          Comment


            #6
            I actually stumbled on this thread searching for something entirely different, but since I wrote it and have released a more recent version, I may be able to help.


            The newest revision, or the 'Full download' contains all old versions, all source code for the newest unfinished/unreleased version, the test maps, and the documentation. It's been a while since I've worked on it, but if you have specific questions I could potentially answer.

            The download can be found on my website, here:
            http://www.medpants.com/pages/Projects.html

            Under the GoodKarma section.

            Comment


              #7
              Hey Masta , thanks for stumbling on this , as i was desperate , the latest beta you sent a link to works like a charm for the project i am currently working on.

              Comment


                #8
                i backported this to work on Land of the Dead, but I get absolutely no action online

                hm, it seems to work for local client in listen mode, but in dedicated, i get no movement at all (haven't tested on network clients of a listen server yet)

                Comment


                  #9
                  Originally posted by Blade[UG] View Post
                  i backported this to work on Land of the Dead, but I get absolutely no action online

                  hm, it seems to work for local client in listen mode, but in dedicated, i get no movement at all (haven't tested on network clients of a listen server yet)
                  Happens when you have "HighDetailOnly" on Karam Params.

                  Comment


                    #10
                    bHighDetailOnly is False, as well as bClientOnly being False, but i'm not getting any simulation on the server. Since you said that, I did go and try changing the Level's Physics detail to High, but still didn't get anything.

                    I had a much older version of this script working, but I'm not seeing what difference between this one and that one would be causing it :|

                    hmm. I copied the working script straight over the non-working one, and still non-working. Is there something in the level (besides Physics Detail) or in the INI that could affect this, when run on a server? it works great on standalone ..

                    I can't just use the working package, because it's dependent upon giant chunks of a total conversion, but i want it to be seperate .. meh. :|


                    ooops, figured it out...
                    apparently had to replace the actor in the map with the latest version, because apparently map-placed objects make a duplicate of the KParams, and use that, rather than the KParams specified in the Begin Class in defaultprops. So, it was using the old ver of the KParams that did not have bClientOnly falsed.

                    now, just to figure out why it's simulating at a snail's pace.

                    Comment

                    Working...
                    X