MultiDodging2k4v4.DodgeHandler

//=============================================================================
// DodgeHandler
// Copyright (c) 2003-2004 by Wormbo <wormbo@onlinehome.de>
//
// Re-enables dodging after player performed a dodging move.
//=============================================================================


class DodgeHandler extends HudOverlay;


//=============================================================================
// Variables
//=============================================================================

// movement modifications

// configured values
var int  MaxDodgesPerJump;
var bool bAlwaysAllowDodgeDoubleJump;
var bool bFastDodging;
var bool bGatherJumpStats;

var int              NumDodgesPerJump;
var PlayerController Controller;
var PlayerInput      PlayerInput;
var xPawn            Pawn;
var Vehicle          Vehicle;
var EDoubleClickDir  LastDoubleClickDir;
var EPhysics         LastPhysics;


// stats
var bool  bShowStats;
var float TopOffset;
var color TextColor, LastColor, MaxColor, LastDiffColor, DiffColor, ActiveGraphColor;
var float MinTeleportDist;

// maximum values
var float MaxSpeed, MaxSpeedXY;           // speed, horizontal speed
var rangevector MaxSpeedAxes;             // highest/lowest speed component values
var float MaxJumpDist, MaxJumpHeightDiff; // horizontal jump distance, actual height difference
var float MaxPathLength;                  // length of path traveled (path can be made visible with player trails)
var range MaxJumpHeight;                  // highest/lowest point of the jump relative to height of the jump spot
var float MaxAirTime;                     // longest time in air

// values from last jump
var float LastSpeed, LastSpeedXY;
var rangevector LastSpeedAxes;
var float LastJumpDist, LastJumpHeightDiff;
var float LastPathLength;
var range LastJumpHeight;
var float LastAirTime;

// current values
var float CurSpeed, CurSpeedXY;
var vector CurSpeedAxes;
var float CurJumpDist, CurJumpHeight;
var float CurPathLength;
var float CurHeight;                      // height above ground
var float CurAirTime;
var EPhysics CurPhysics;
var float CurGravity;

var vector JumpStart, LastTickLocation;
var float JumpStartTime;
var bool bJumping;


//=============================================================================
// Replication
//=============================================================================

replication
{
  reliable if ( Role == ROLE_Authority && bNetOwner )
    Controller, Pawn, MaxDodgesPerJump, bAlwaysAllowDodgeDoubleJump,
    bFastDodging, bGatherJumpStats, bShowStats;
  
  reliable if ( bNetDirty && bNetOwner && bGatherJumpStats && Role == ROLE_Authority )
    MaxSpeed, MaxSpeedXY, MaxSpeedAxes, MaxAirTime, MaxJumpDist, MaxJumpHeight,
    MaxJumpHeightDiff, LastSpeed, LastSpeedXY, LastSpeedAxes, LastAirTime,
    LastJumpDist, LastJumpHeight, LastJumpHeightDiff;
}


//=============================================================================
// PostBeginPlay
//
// Initializes the Controller variable.
//=============================================================================

function PostBeginPlay()
{
  Controller = PlayerController(Owner);
  Super.PostBeginPlay();
}


//=============================================================================
// PostNetBeginPlay
//
// Registers the HUD display.
//=============================================================================

simulated function PostNetBeginPlay()
{
  if ( Controller != None ) {
    foreach AllObjects(class'PlayerInput', PlayerInput)
      if ( PlayerInput.Outer == Controller )
        break;
    if ( PlayerInput != None && PlayerInput.Outer != Controller )
      PlayerInput = None;
    
    if ( bGatherJumpStats && Controller.MyHud != None ) {
      Controller.MyHud.AddHudOverlay(Self);
      SetOwner(Controller);
    }
  }
  Super.PostNetBeginPlay();
}


//=============================================================================
// Destroyed
//
// Unregister the HudOverlay.
//=============================================================================

simulated function Destroyed()
{
  if ( Controller != None && Controller.MyHud != None )
    Controller.MyHud.RemoveHudOverlay(self);
}


//=============================================================================
// PostRender
//
// Draws jump stats.
//=============================================================================

simulated function Render(Canvas C)
{
  local float XL1, XL2, YL;
  
  if ( !bShowStats || Controller == None || Pawn == None && Vehicle == None || Controller.ViewTarget != Pawn && Controller.ViewTarget != Vehicle )
    return;
  
  C.Reset();
  C.Style = 1;
  C.Font = C.SmallFont;
  C.TextSize("-00000", XL1, YL);
  C.TextSize(" -00000.00", XL2, YL);

//-----------------------------------------------------------------------------  

  C.DrawColor = TextColor;
  C.SetPos(0, C.ClipY * TopOffset + 0);
  C.DrawText("Speed");
  DrawDecimalNumberAt(C, CurSpeed,  XL1,           C.ClipY * TopOffset + 20,, 1);
  if (Pawn != None)
  {
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 10);
	  C.DrawText("current/last jump's max/prev. max");
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastSpeed, XL1 + XL2,     C.ClipY * TopOffset + 20,, 1);
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxSpeed,  XL1 + XL2 * 2, C.ClipY * TopOffset + 20,, 1);
  }
  C.DrawColor = TextColor;
  C.SetPos(0, C.ClipY * TopOffset + 35);
  C.DrawText("Horizontal Speed");
  DrawDecimalNumberAt(C, CurSpeedXY,  XL1,           C.ClipY * TopOffset + 55,, 1);
  if (Pawn != None)
  {
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 45);
	  C.DrawText("current/last jump's max/prev. max");
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastSpeedXY, XL1 + XL2,     C.ClipY * TopOffset + 55,, 1);
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxSpeedXY,  XL1 + XL2 * 2, C.ClipY * TopOffset + 55,, 1);
  }
  C.DrawColor = TextColor;
  C.SetPos(0, C.ClipY * TopOffset + 70);
  C.DrawText("Vertical Speed");
  DrawDecimalNumberAt(C, CurSpeedAxes.Z,      XL1,           C.ClipY * TopOffset + 90,, 1);
  if (Pawn != None)
  {
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 80);
	  C.DrawText("current/prev. min/prev. max");
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxSpeedAxes.Z.Min,  XL1 + XL2,     C.ClipY * TopOffset + 90,, 1);
	  DrawDecimalNumberAt(C, MaxSpeedAxes.Z.Max,  XL1 + XL2 * 2, C.ClipY * TopOffset + 90,, 1);
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 100);
	  C.DrawText("last jump's min/max");
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastSpeedAxes.Z.Min, XL1 + XL2,     C.ClipY * TopOffset + 110,, 1);
	  DrawDecimalNumberAt(C, LastSpeedAxes.Z.Max, XL1 + XL2 * 2, C.ClipY * TopOffset + 110,, 1);
	  
	//-----------------------------------------------------------------------------  

	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 145);
	  C.DrawText("Jump Horizontal Distance");
	  C.SetPos(0, C.ClipY * TopOffset + 155);
	  C.DrawText("current/last jump's max/prev. max");
	  DrawDecimalNumberAt(C, CurJumpDist,  XL1,           C.ClipY * TopOffset + 165,, 1);
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastJumpDist, XL1 + XL2,     C.ClipY * TopOffset + 165,, 1);
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxJumpDist,  XL1 + XL2 * 2, C.ClipY * TopOffset + 165,, 1);
	  
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 180);
	  C.DrawText("Jump Travel Distance");
	  C.SetPos(0, C.ClipY * TopOffset + 190);
	  C.DrawText("current/last jump's max/prev. max");
	  DrawDecimalNumberAt(C, CurPathLength,  XL1,           C.ClipY * TopOffset + 200,, 1);
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastPathLength, XL1 + XL2,     C.ClipY * TopOffset + 200,, 1);
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxPathLength,  XL1 + XL2 * 2, C.ClipY * TopOffset + 200,, 1);
	  
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 215);
	  C.DrawText("Jump Height");
	  DrawDecimalNumberAt(C, CurJumpHeight,      XL1,           C.ClipY * TopOffset + 235,, 1);
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 225);
	  C.DrawText("current");
	  C.SetPos(0, C.ClipY * TopOffset + 245);
	  C.DrawText("last jump's min / max / diff");
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastJumpHeight.Min, XL1,           C.ClipY * TopOffset + 255,, 1);
	  DrawDecimalNumberAt(C, LastJumpHeight.Max, XL1 + XL2,     C.ClipY * TopOffset + 255,, 1);
	  C.DrawColor = LastDiffColor;
	  DrawDecimalNumberAt(C, LastJumpHeightDiff, XL1 + XL2 * 2, C.ClipY * TopOffset + 255,, 1);
	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 265);
	  C.DrawText("prev. min / prev. max / prev. max diff");
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxJumpHeight.Min,  XL1,           C.ClipY * TopOffset + 275,, 1);
	  DrawDecimalNumberAt(C, MaxJumpHeight.Max,  XL1 + XL2,     C.ClipY * TopOffset + 275,, 1);
	  C.DrawColor = DiffColor;
	  DrawDecimalNumberAt(C, MaxJumpHeightDiff,  XL1 + XL2 * 2, C.ClipY * TopOffset + 275,, 1);
	  
	//-----------------------------------------------------------------------------  

	  C.DrawColor = TextColor;
	  C.SetPos(0, C.ClipY * TopOffset + 300);
	  C.DrawText("Air Time");
	  C.SetPos(0, C.ClipY * TopOffset + 310);
	  C.DrawText("current/last jump's max/prev. max");
	  DrawDecimalNumberAt(C, CurAirTime,  XL1,           C.ClipY * TopOffset + 320,, 3);
	  C.DrawColor = LastColor;
	  DrawDecimalNumberAt(C, LastAirTime, XL1 + XL2,     C.ClipY * TopOffset + 320,, 3);
	  C.DrawColor = MaxColor;
	  DrawDecimalNumberAt(C, MaxAirTime,  XL1 + XL2 * 2, C.ClipY * TopOffset + 320,, 3);
  }
  C.DrawColor = TextColor;
  C.SetPos(0, C.ClipY * TopOffset + 335);
  C.DrawText("Height Above Ground");
  DrawDecimalNumberAt(C, CurHeight,  XL1, C.ClipY * TopOffset + 345,, 1);
  C.SetPos(0, C.ClipY * TopOffset + 355);
  C.DrawText("Gravity");
  DrawDecimalNumberAt(C, CurGravity,  XL1, C.ClipY * TopOffset + 365,, 1);
  C.DrawScreenText("   ("$string(CurGravity / -class'PhysicsVolume'.default.Gravity.Z)@"g)", XL1 / C.SizeX, (C.ClipY * TopOffset + 365) / C.SizeY, DP_UpperLeft);
}


//=============================================================================
// DrawDecimalNumberAt
//
// Draws a decimal number with the decimal point at the specified position.
//=============================================================================

static final function DrawDecimalNumberAt(Canvas C, float Value, float X, float Y, optional bool bClipped, optional int Precision)
{
  local int IntPart;
  local float FloatPart;
  local float XL, YL, OldX, OldY;
  local string IntString, FloatString;
  
  OldX = C.CurX; OldY = C.CurY;
  
  if ( Precision == 0 )
    Precision = 2; // default UT2k3 setting
  else
    Precision = Max(Precision, 1);  // otherwise Canvas.DrawScreenText should be used
  
  if ( Value < 0 ) {
    IntString = "-";
    Value *= -1;
  }
  IntPart = int(Value);
  FloatPart = Value - IntPart;
  IntString = IntString $ string(IntPart);
  FloatString = string(int(FloatPart * 10 ** Precision));
  while (Len(FloatString) < Precision)
    FloatString = "0" $ FloatString;
  
  C.TextSize(IntString, XL, YL);
  C.SetPos(X - XL, Y);
  if ( !bClipped )
    C.DrawText(IntString$"."$FloatString);
  else
    C.DrawTextClipped(IntString$"."$FloatString);
  
  C.SetPos(OldX, OldY);  // reset draw position
}


//=============================================================================
// ResetAll
//
// Reset all stats.
//=============================================================================

function ResetAll()
{
  ResetSpeed();
  ResetJump();
}


//=============================================================================
// ResetSpeed
//
// Reset speed stats.
//=============================================================================

function ResetSpeed()
{
  local rangevector ZeroRangeVector;
  
  MaxSpeed = 0;
  MaxSpeedXY = 0;
  MaxSpeedAxes = ZeroRangeVector;
  
  LastSpeed = 0;
  LastSpeedXY = 0;
  LastSpeedAxes = ZeroRangeVector;
}


//=============================================================================
// ResetJump
//
// Reset jump stats.
//=============================================================================

function ResetJump()
{
  local range ZeroRange;
  
  MaxAirTime = 0;
  MaxJumpDist = 0;
  MaxJumpHeight = ZeroRange;
  MaxJumpHeightDiff = 0;
  MaxPathLength = 0;
  
  LastAirTime = 0;
  LastJumpDist = 0;
  LastJumpHeight = ZeroRange;
  LastJumpHeightDiff = 0;
  LastPathLength = 0;
}


//=============================================================================
// Tick
//
// Re-enables dodging if it's disabled after a previous dodge.
//=============================================================================

simulated function Tick(float DeltaTime)
{
	local vector HitLocation, HitNormal;	// for Trace()
	local bool bTeleported, bWasActive;
	
  if ( Controller == None ) { // player left the game
    if ( Level.NetMode != NM_Client )
      Destroy();
    return;
  }
  
  if ( xPawn(Controller.Pawn) != None && Controller.Pawn != Pawn ) {
    // player respawned, reinitialize current stats
    Pawn = xPawn(Controller.Pawn);
    CurPhysics = Pawn.Physics;
  }
  else if (Vehicle(Controller.Pawn) != None && Controller.Pawn != Vehicle)
  {
	  Vehicle = Vehicle(Controller.Pawn);
	  CurPhysics = Pawn.Physics;
  }
  if ( bGatherJumpStats ) {
    if ( Controller.Pawn == Pawn ) {
      if ( VSize(LastTickLocation - Controller.Pawn.Location) > MinTeleportDist )
        bTeleported = True;
      // check for start of jump
      if ( Pawn.Physics == PHYS_Falling && CurPhysics != PHYS_Falling ) {
        JumpStart = PawnLocation();
        JumpStartTime = Level.TimeSeconds;
        LastTickLocation = Controller.Pawn.Location;
        CurPhysics = PHYS_Falling;
      }
      // check for end of jump
      if ( Pawn.Physics != PHYS_Falling && CurPhysics == PHYS_Falling ) {
        CurPhysics = Pawn.Physics;
      }
      
      // current speed values
      CurSpeedAxes = Pawn.Velocity;
      CurSpeed = VSize(CurSpeedAxes);
      CurSpeedXY = VSize(CurSpeedAxes * vect(1,1,0));
      
      // current jump values
      if ( CurPhysics == PHYS_Falling && !bTeleported ) {
        CurJumpDist = VSize(vect(1,1,0) * (PawnLocation() - JumpStart));
        CurJumpHeight = PawnLocation().Z - JumpStart.Z;
        CurAirTime = Level.TimeSeconds - JumpStartTime;
        CurPathLength += VSize(Controller.Pawn.Location - LastTickLocation);
      }
      else {
        CurJumpDist = 0;
        CurJumpHeight = 0;
        CurPathLength = 0;
        CurAirTime = 0;
      }
      
      // current height above ground
      Trace(HitLocation, HitNormal, Pawn.Location - 10000 * vect(0,0,1), Pawn.Location, True);
      CurHeight = Abs(PawnLocation().Z - HitLocation.Z);
      CurGravity = -Pawn.PhysicsVolume.Gravity.Z;
      
      LastTickLocation = Controller.Pawn.Location;
    }
	else if (Controller.Pawn == Vehicle)
	{
      CurSpeedAxes = Vehicle.Velocity;
      CurSpeed = VSize(CurSpeedAxes);
      CurSpeedXY = VSize(CurSpeedAxes * vect(1,1,0));
      
      // current height above ground
      Trace(HitLocation, HitNormal, Vehicle.Location - 10000 * vect(0,0,1), Vehicle.Location, True);
      CurHeight = Abs(PawnLocation().Z - HitLocation.Z);
      CurGravity = -Vehicle.PhysicsVolume.Gravity.Z;
	}
    
    if ( Role == ROLE_Authority ) {
      // compare best speeds
      if ( MaxSpeed < CurSpeed )
        MaxSpeed = CurSpeed;
      if ( MaxSpeedXY < CurSpeedXY )
        MaxSpeedXY = CurSpeedXY;
      if ( MaxSpeedAxes.X.Max < CurSpeedAxes.X )
        MaxSpeedAxes.X.Max = CurSpeedAxes.X;
      if ( MaxSpeedAxes.Y.Max < CurSpeedAxes.Y )
        MaxSpeedAxes.Y.Max = CurSpeedAxes.Y;
      if ( MaxSpeedAxes.Z.Max < CurSpeedAxes.Z )
        MaxSpeedAxes.Z.Max = CurSpeedAxes.Z;
      if ( MaxSpeedAxes.X.Min > CurSpeedAxes.X )
        MaxSpeedAxes.X.Min = CurSpeedAxes.X;
      if ( MaxSpeedAxes.Y.Min > CurSpeedAxes.Y )
        MaxSpeedAxes.Y.Min = CurSpeedAxes.Y;
      if ( MaxSpeedAxes.Z.Min > CurSpeedAxes.Z )
        MaxSpeedAxes.Z.Min = CurSpeedAxes.Z;
      
      // check for start of jump
      if ( !bJumping && CurPhysics == PHYS_Falling ) {
        bJumping = True;
        
        // compare last jump's values to best values
        if ( MaxJumpDist < LastJumpDist )
          MaxJumpDist = LastJumpDist;
        if ( MaxJumpHeightDiff < LastJumpHeightDiff )
          MaxJumpHeightDiff = LastJumpHeightDiff;
        if ( MaxJumpHeight.Max < LastJumpHeight.Max )
          MaxJumpHeight.Max = LastJumpHeight.Max;
        if ( MaxJumpHeight.Min > LastJumpHeight.Min )
          MaxJumpHeight.Min = LastJumpHeight.Min;
        if ( MaxPathLength < LastPathLength )
          MaxPathLength = LastPathLength;
        if ( MaxAirTime < LastAirTime )
          MaxAirTime = LastAirTime;
        
        ResetLastJumpValues();
      }
      else if ( bJumping ) {
        if ( CurPhysics != PHYS_Falling )
          bJumping = False;
        else {
          if ( LastSpeed < CurSpeed )
            LastSpeed = CurSpeed;
          if ( LastSpeedXY < CurSpeedXY )
            LastSpeedXY = CurSpeedXY;
          if ( LastSpeedAxes.X.Max < CurSpeedAxes.X )
            LastSpeedAxes.X.Max = CurSpeedAxes.X;
          if ( LastSpeedAxes.Y.Max < CurSpeedAxes.Y )
            LastSpeedAxes.Y.Max = CurSpeedAxes.Y;
          if ( LastSpeedAxes.Z.Max < CurSpeedAxes.Z )
            LastSpeedAxes.Z.Max = CurSpeedAxes.Z;
          if ( LastSpeedAxes.X.Min > CurSpeedAxes.X )
            LastSpeedAxes.X.Min = CurSpeedAxes.X;
          if ( LastSpeedAxes.Y.Min > CurSpeedAxes.Y )
            LastSpeedAxes.Y.Min = CurSpeedAxes.Y;
          if ( LastSpeedAxes.Z.Min > CurSpeedAxes.Z )
            LastSpeedAxes.Z.Min = CurSpeedAxes.Z;
        }
      }
      
      // compare this jump's current values to this jump's best values
      if ( LastJumpDist < CurJumpDist )
        LastJumpDist = CurJumpDist;
      if ( LastPathLength < CurPathLength )
        LastPathLength = CurPathLength;
      if ( LastJumpHeight.Max < CurJumpHeight )
        LastJumpHeight.Max = CurJumpHeight;
      if ( LastJumpHeight.Min > CurJumpHeight )
        LastJumpHeight.Min = CurJumpHeight;
      LastJumpHeightDiff = LastJumpHeight.Max - LastJumpHeight.Min;
      if ( LastAirTime < CurAirTime )
        LastAirTime = CurAirTime;
    }
  }
  
  if ( Pawn != None && Pawn.Physics == PHYS_Walking )
    NumDodgesPerJump = MaxDodgesPerJump;
  
  //log(PlayerInput.DoubleClickTimer @ PlayerInput.DoubleClickTime @ Controller.DoubleClickDir @ LastDoubleClickDir @ CurPhysics);
  if ( bFastDodging && PlayerInput != None && PlayerInput.DoubleClickTimer < PlayerInput.DoubleClickTime
      && Controller.DoubleClickDir == DCLICK_None && LastDoubleClickDir > DCLICK_None
      && LastDoubleClickDir < DCLICK_Active ) {
    if ( Controller.DoubleClickDir == DCLICK_Active )
      bWasActive = True;
    PlayerInput.DoubleClickTimer = PlayerInput.DoubleClickTime;
    Controller.DoubleClickDir = LastDoubleClickDir;
  }
  
  if ( bWasActive || Controller.DoubleClickDir == DCLICK_Active ) {
    if ( NumDodgesPerJump != 0 ) {
      NumDodgesPerJump--;
      if ( !bFastDodging || !bWasActive )
        Controller.ClearDoubleClick();
      Controller.DoubleClickDir = DCLICK_None;
    }
    if ( bAlwaysAllowDodgeDoubleJump && Pawn != None && Pawn.MultiJumpRemaining == 0 )
      Pawn.MultiJumpRemaining = 1;
  }
  LastDoubleClickDir = Controller.DoubleClickDir;
}


//=============================================================================
// PawnLocation
//
// Calculates the player's foot location.
//=============================================================================

simulated function vector PawnLocation()
{
  return Pawn.Location - vect(0,0,1) * Pawn.CollisionHeight;
}


//=============================================================================
// ResetLastJumpValues
//
// Resets the last jump's statistics.
//=============================================================================

function ResetLastJumpValues()
{
  local rangevector ZeroRangeVector;
  local range ZeroRange;
  
  LastSpeed = 0;
  LastSpeedXY = 0;
  LastSpeedAxes = ZeroRangeVector;
  LastJumpDist = 0;
  LastJumpHeightDiff = 0;
  LastPathLength = 0;
  LastJumpHeight = ZeroRange;
  LastAirTime = 0;
}


//=============================================================================
// Default properties
//=============================================================================

defaultproperties
{
     bShowStats=True
     TopOffset=0.150000
     TextColor=(B=255,G=255,R=255,A=255)
     LastColor=(B=255,G=255,R=128,A=255)
     MaxColor=(B=128,G=255,R=255,A=255)
     LastDiffColor=(B=255,G=192,R=128,A=255)
     DiffColor=(B=128,G=192,R=255,A=255)
     ActiveGraphColor=(G=128,R=255,A=255)
     MinTeleportDist=150.000000
     bOnlyRelevantToOwner=True
     bReplicateMovement=False
     bSkipActorPropertyReplication=True
     RemoteRole=ROLE_SimulatedProxy
     bAlwaysTick=True
}