home *** CD-ROM | disk | FTP | other *** search
/ Game Level Design / GLDesign.bin / Software / UnrealEngine2Runtime / UE2Runtime-22262001_Demo.exe / Engine / Classes / PlayerInput.uc < prev    next >
Text File  |  2003-06-23  |  8KB  |  331 lines
  1. //=============================================================================
  2. // PlayerInput
  3. // Object within playercontroller that manages player input.
  4. // only spawned on client
  5. //=============================================================================
  6.  
  7. class PlayerInput extends Object within PlayerController
  8.     config(User)
  9.     native
  10.     transient;
  11.  
  12. var globalconfig    bool    bInvertMouse;
  13.  
  14. var bool        bWasForward;    // used for doubleclick move 
  15. var bool        bWasBack;
  16. var bool        bWasLeft;
  17. var bool        bWasRight;
  18. var bool        bEdgeForward;
  19. var bool        bEdgeBack;
  20. var bool        bEdgeLeft;
  21. var bool         bEdgeRight;
  22. var    bool        bAdjustSampling;
  23.  
  24. // Mouse smoothing
  25. var globalconfig byte   MouseSmoothingMode;
  26. var globalconfig float  MouseSmoothingStrength;
  27. var globalconfig float    MouseSensitivity;
  28. var globalconfig float  MouseSamplingTime;
  29. var globalconfig float  MouseAccelThreshold;
  30.  
  31. var float SmoothedMouse[2], ZeroTime[2], SamplingTime[2], MaybeTime[2], OldSamples[4];
  32. var int MouseSamples[2];
  33.  
  34. var    float DoubleClickTimer; // max double click interval for double click move
  35. var globalconfig float    DoubleClickTime;
  36.  
  37. //=============================================================================
  38. // Input related functions.
  39.  
  40. function bool InvertLook();
  41.  
  42. // Postprocess the player's input.
  43. event PlayerInput( float DeltaTime )
  44. {
  45.     local float FOVScale, MouseScale;
  46.                 
  47.     // Ignore input if we're playing back a client-side demo.
  48.     if( Outer.bDemoOwner && !Outer.default.bDemoOwner )
  49.         return;
  50.                 
  51.     // Check for Double click move
  52.     // flag transitions
  53.     bEdgeForward = (bWasForward ^^ (aBaseY > 0));
  54.     bEdgeBack = (bWasBack ^^ (aBaseY < 0));
  55.     bEdgeLeft = (bWasLeft ^^ (aStrafe < 0));
  56.     bEdgeRight = (bWasRight ^^ (aStrafe > 0));
  57.     bWasForward = (aBaseY > 0);
  58.     bWasBack = (aBaseY < 0);
  59.     bWasLeft = (aStrafe < 0);
  60.     bWasRight = (aStrafe > 0);
  61.     
  62.     // Smooth and amplify mouse movement
  63.     FOVScale = DesiredFOV * 0.01111; // 0.01111 = 1/90
  64.     MouseScale = MouseSensitivity * FOVScale;
  65.     aMouseX = SmoothMouse(aMouseX*MouseScale, DeltaTime,bXAxis,0);
  66.     aMouseY = SmoothMouse(aMouseY*MouseScale, DeltaTime,bYAxis,1);
  67.  
  68.     aMouseX = AccelerateMouse(aMouseX);
  69.     aMouseY = AccelerateMouse(aMouseY);
  70.  
  71.     // adjust keyboard and joystick movements
  72.     aLookUp *= FOVScale;
  73.     aTurn   *= FOVScale;
  74.  
  75.     // Remap raw x-axis movement.
  76.     if( bStrafe!=0 ) // strafe
  77.         aStrafe += aBaseX * 7.5 + aMouseX;
  78.     else // forward
  79.         aTurn  += aBaseX * FOVScale + aMouseX;
  80.     aBaseX = 0;
  81.  
  82.     // Remap mouse y-axis movement.
  83.     if( (bStrafe == 0) && (bAlwaysMouseLook || (bLook!=0)) )
  84.     {
  85.         // Look up/down.
  86.         if ( bInvertMouse )
  87.             aLookUp -= aMouseY;
  88.         else
  89.             aLookUp += aMouseY;
  90.     }
  91.     else // Move forward/backward.
  92.         aForward += aMouseY;
  93.  
  94.     if ( bSnapLevel != 0 )
  95.     {
  96.         bCenterView = true;
  97.         bKeyboardLook = false;
  98.     }
  99.     else if (aLookUp != 0)
  100.     {
  101.         bCenterView = false;
  102.         bKeyboardLook = true;
  103.     }
  104.     else if ( bSnapToLevel && !bAlwaysMouseLook )
  105.     {
  106.         bCenterView = true;
  107.         bKeyboardLook = false;
  108.     }
  109.  
  110.     // Remap other y-axis movement.
  111.     if ( bFreeLook != 0 )
  112.     {
  113.         bKeyboardLook = true;
  114.         aLookUp += 0.5 * aBaseY * FOVScale;
  115.     }
  116.     else
  117.         aForward += aBaseY;
  118.         
  119.     aBaseY = 0;
  120.  
  121.     // Handle walking.
  122.     HandleWalking();
  123. }
  124.  
  125. exec function SetSmoothingMode(byte B)
  126. {
  127.     MouseSmoothingMode = B;
  128.     log("Smoothing mode "$MouseSmoothingMode);
  129. }
  130.  
  131. exec function SetSmoothingStrength(float F)
  132. {
  133.     MouseSmoothingStrength = FClamp(F,0,1);
  134. }
  135.  
  136. function float AccelerateMouse(float aMouse)
  137. {
  138.     local float Accel;
  139.     
  140.     if ( abs(aMouse) == 0 )
  141.         return 0;
  142.         
  143.     Accel = MouseAccelThreshold * MouseSensitivity;
  144.     if ( abs(aMouse) < Accel )
  145.     {
  146.         if ( abs(aMouse) < 0.1 * Accel )
  147.             aMouse *= 0.1;
  148.         else
  149.             aMouse = aMouse * abs(aMouse)/Accel;
  150.     }
  151.     return aMouse;
  152. }
  153.  
  154. function float SmoothMouse(float aMouse, float DeltaTime, out byte SampleCount, int Index)
  155. {
  156.     local int i, sum;
  157.  
  158.     if ( MouseSmoothingMode == 0 )
  159.         return aMouse;
  160.  
  161.     if ( aMouse == 0 )
  162.     {
  163.         ZeroTime[Index] += DeltaTime;
  164.         if ( ZeroTime[Index] < MouseSamplingTime )
  165.         {
  166.             SamplingTime[Index] += DeltaTime; 
  167.             MaybeTime[Index] += DeltaTime;
  168.             aMouse = SmoothedMouse[Index];
  169.         }
  170.         else
  171.         {
  172.             if ( bAdjustSampling && (MouseSamples[Index] > 9) )
  173.             {
  174.                 SamplingTime[Index] -= MaybeTime[Index];
  175.                 MouseSamplingTime = 0.9 * MouseSamplingTime + 0.1 * SamplingTime[Index]/MouseSamples[Index];
  176.             }
  177.             SamplingTime[Index] = 0;
  178.             SmoothedMouse[Index] = 0;
  179.             MouseSamples[Index] = 0;
  180.         }
  181.     }
  182.     else
  183.     {
  184.         MaybeTime[Index] = 0;
  185.  
  186.         if ( SmoothedMouse[Index] != 0 )
  187.         {
  188.             MouseSamples[Index] += SampleCount;
  189.             if ( DeltaTime > MouseSamplingTime * (SampleCount + 1) )
  190.                 SamplingTime[Index] += MouseSamplingTime * SampleCount; 
  191.             else
  192.             {
  193.                 SamplingTime[Index] += DeltaTime; 
  194.                 aMouse = aMouse * DeltaTime/(MouseSamplingTime * SampleCount);
  195.             }
  196.         }
  197.         else
  198.             SamplingTime[Index] = 0.5 * MouseSamplingTime;
  199.  
  200.         SmoothedMouse[Index] = aMouse/SampleCount;
  201.         ZeroTime[Index] = 0;
  202.     }
  203.     SampleCount = 0;
  204.  
  205.     if ( MouseSmoothingMode > 1 )
  206.     {
  207.         if ( aMouse == 0 )
  208.         {
  209.             // stop in next tick
  210.             for ( i=0; i<3; i++ )
  211.             {
  212.                 sum += (i+1) * 0.1;
  213.                 aMouse += sum * OldSamples[i];
  214.                 OldSamples[i] = 0;
  215.             }
  216.             OldSamples[3] = 0;
  217.         }
  218.         else
  219.         {
  220.             aMouse = 0.4 * aMouse;
  221.             OldSamples[3] = aMouse;
  222.             for ( i=0; i<3; i++ )
  223.             {
  224.                 aMouse += (i+1) * 0.1 * OldSamples[i];
  225.                 OldSamples[i] = OldSamples[i+1];
  226.             }
  227.  
  228.         }
  229.     }
  230.     return aMouse;
  231. }
  232.  
  233. function UpdateSensitivity(float F)
  234. {
  235.     MouseSensitivity = FMax(0,F);
  236.     default.MouseSensitivity = MouseSensitivity; 
  237.     class'PlayerInput'.static.StaticSaveConfig();
  238. }
  239.  
  240. function UpdateAccel(float F)
  241. {
  242.     MouseAccelThreshold = FMax(0,f);
  243.     default.MouseAccelThreshold = MouseAccelThreshold;
  244.     class'PlayerInput'.static.StaticSaveConfig();
  245. }
  246.  
  247. function UpdateSmoothing( int Mode )
  248. {
  249.     MouseSmoothingMode = Mode;
  250.     default.MouseSmoothingMode = MouseSmoothingMode;
  251.     class'PlayerInput'.static.StaticSaveConfig();
  252. }
  253.  
  254. function ChangeSnapView( bool B )
  255. {
  256.     bSnapToLevel = B;
  257. }
  258.  
  259. // check for double click move
  260. function Actor.eDoubleClickDir CheckForDoubleClickMove(float DeltaTime)
  261. {
  262.     local Actor.eDoubleClickDir DoubleClickMove, OldDoubleClick;
  263.  
  264.     if ( DoubleClickDir == DCLICK_Active )
  265.         DoubleClickMove = DCLICK_Active;
  266.     else
  267.         DoubleClickMove = DCLICK_None;
  268.     if (DoubleClickTime > 0.0)
  269.     {
  270.         if ( DoubleClickDir == DCLICK_Active )
  271.         {
  272.             if ( (Pawn != None) && (Pawn.Physics == PHYS_Walking) )
  273.             {
  274.                 DoubleClickTimer = 0;
  275.                 DoubleClickDir = DCLICK_Done;
  276.             }
  277.         }
  278.         else if ( DoubleClickDir != DCLICK_Done )
  279.         {
  280.             OldDoubleClick = DoubleClickDir;
  281.             DoubleClickDir = DCLICK_None;
  282.  
  283.             if (bEdgeForward && bWasForward)
  284.                 DoubleClickDir = DCLICK_Forward;
  285.             else if (bEdgeBack && bWasBack)
  286.                 DoubleClickDir = DCLICK_Back;
  287.             else if (bEdgeLeft && bWasLeft)
  288.                 DoubleClickDir = DCLICK_Left;
  289.             else if (bEdgeRight && bWasRight)
  290.                 DoubleClickDir = DCLICK_Right;
  291.  
  292.             if ( DoubleClickDir == DCLICK_None)
  293.                 DoubleClickDir = OldDoubleClick;
  294.             else if ( DoubleClickDir != OldDoubleClick )
  295.                 DoubleClickTimer = DoubleClickTime + 0.5 * DeltaTime;
  296.             else 
  297.                 DoubleClickMove = DoubleClickDir;
  298.         }
  299.  
  300.         if (DoubleClickDir == DCLICK_Done)
  301.         {
  302.             DoubleClickTimer = FMin(DoubleClickTimer-DeltaTime,0);
  303.             if (DoubleClickTimer < -0.35) 
  304.             {
  305.                 DoubleClickDir = DCLICK_None;
  306.                 DoubleClickTimer = DoubleClickTime;
  307.             }
  308.         }        
  309.         else if ((DoubleClickDir != DCLICK_None) && (DoubleClickDir != DCLICK_Active))
  310.         {
  311.             DoubleClickTimer -= DeltaTime;            
  312.             if (DoubleClickTimer < 0)
  313.             {
  314.                 DoubleClickDir = DCLICK_None;
  315.                 DoubleClickTimer = DoubleClickTime;
  316.             }
  317.         }
  318.     }
  319.     return DoubleClickMove;
  320. }
  321.  
  322. defaultproperties
  323. {
  324.      bAdjustSampling=true
  325.      MouseSamplingTime=+0.008333
  326.      MouseSmoothingStrength=+0.3
  327.      MouseSmoothingMode=1
  328.      MouseSensitivity=3.000000
  329.     MouseAccelThreshold=100.0
  330.      DoubleClickTime=0.250000
  331. }