qcsrc/client/hud/panel/strafehud.qc

   1 // Name:   StrafeHUD
   2 // Author: Juhu
   3
   4 #include "strafehud.qh"
   5
   6 #include <client/autocvars.qh>
   7 #include <client/miscfunctions.qh>
   8 #include <common/animdecide.qh>
   9 #include <common/ent_cs.qh>
  10 #include <common/mapinfo.qh>
  11 #include <common/mapobjects/trigger/swamp.qh>
  12 #include <common/physics/movetypes/movetypes.qh>
  13 #include <common/physics/player.qh>
  14 #include <lib/csqcmodel/cl_player.qh>
  15
  16 bool strafehud_fwd = true;
  17 float strafehud_demo_angle = -37;
  18 float strafehud_demo_direction = 1;
  19 float strafehud_demo_time = 0;
  20 float strafehud_state_onground_time = 0;
  21 float strafehud_state_strafekeys_time = 0;
  22 bool strafehud_state_onground = true;
  23 bool strafehud_state_strafekeys = false;
  24 bool strafehud_turn = false;
  25 float strafehud_turnangle;
  26
  27 void HUD_StrafeHUD()
  28 {
  29     entity strafeplayer;
  30
  31     if(!autocvar__hud_configure)
  32     {
  33         if(!autocvar_hud_panel_strafehud) return;
  34         if(spectatee_status == -1 && (autocvar_hud_panel_strafehud == 1 || autocvar_hud_panel_strafehud == 3)) return;
  35         if(autocvar_hud_panel_strafehud == 3 && !(ISGAMETYPE(RACE) || ISGAMETYPE(CTS))) return;
  36     }
  37
  38     HUD_Panel_LoadCvars();
  39
  40     if (autocvar_hud_panel_strafehud_dynamichud)
  41         HUD_Scale_Enable();
  42     else
  43         HUD_Scale_Disable();
  44     HUD_Panel_DrawBg();
  45     if(panel_bg_padding)
  46     {
  47         panel_pos  += '1 1 0' * panel_bg_padding;
  48         panel_size -= '2 2 0' * panel_bg_padding;
  49     }
  50
  51     if(spectatee_status > 0)
  52     {
  53         strafeplayer = CSQCModel_server2csqc(player_localentnum - 1);
  54     }
  55     else
  56     {
  57         strafeplayer = csqcplayer;
  58     }
  59
  60     // draw strafehud
  61     if(csqcplayer && strafeplayer)
  62     {
  63         // autocvars
  64         float strafehud_bar_alpha                  = autocvar_hud_panel_strafehud_bar_alpha;
  65         vector strafehud_bar_color                 = autocvar_hud_panel_strafehud_bar_color;
  66         vector strafehud_bestangle_color           = autocvar_hud_panel_strafehud_indicator_color;
  67         vector strafehud_bestangle_opposite_color  = autocvar_hud_panel_strafehud_indicator_switch_color;
  68         vector strafehud_good_color                = autocvar_hud_panel_strafehud_good_color;
  69         vector strafehud_warning_color             = autocvar_hud_panel_strafehud_warning_color;
  70         vector strafehud_alert_color               = autocvar_hud_panel_strafehud_alert_color;
  71         vector strafehud_direction_color           = autocvar_hud_panel_strafehud_direction_color;
  72         float strafehud_timeout_air                = autocvar_hud_panel_strafehud_timeout_air;    // timeout for slick ramps
  73         float strafehud_timeout_ground             = autocvar_hud_panel_strafehud_timeout_ground; // timeout for strafe jumping in general
  74         float strafehud_timeout_strafe             = autocvar_hud_panel_strafehud_timeout_strafe; // timeout for jumping with strafe keys only
  75         float strafehud_indicator_minspeed         = autocvar_hud_panel_strafehud_indicator_minspeed;
  76
  77         // physics
  78         float  strafehud_onground                  = strafeplayer == csqcplayer ? IS_ONGROUND(strafeplayer) : !(strafeplayer.anim_implicit_state & ANIMIMPLICITSTATE_INAIR);
  79         float  strafehud_speed                     = !autocvar__hud_configure ? vlen(vec2(csqcplayer.velocity)) : 1337; // use local csqcmodel entity for this even when spectating, flickers too much otherwise
  80         float  strafehud_maxspeed_crouch_mod       = IS_DUCKED(strafeplayer) ? .5 : 1;
  81         float  strafehud_maxspeed_swamp_mod        = strafeplayer.in_swamp ? strafeplayer.swamp_slowdown : 1;
  82         float  strafehud_maxspeed_phys             = strafehud_onground ? PHYS_MAXSPEED(strafeplayer) : PHYS_MAXAIRSPEED(strafeplayer);
  83         float  strafehud_maxspeed                  = !autocvar__hud_configure ? (strafehud_maxspeed_phys * strafehud_maxspeed_crouch_mod * strafehud_maxspeed_swamp_mod) : 320;
  84         float  strafehud_vel_angle                 = vectoangles(strafeplayer.velocity).y;
  85         float  strafehud_view_angle                = view_angles.y + 180;
  86         float  strafehud_angle;
  87         float  strafehud_direction;
  88         vector strafehud_movement                  = PHYS_INPUT_MOVEVALUES(strafeplayer);
  89         int    strafehud_keys                      = STAT(PRESSED_KEYS);
  90         float  strafehud_wishangle;
  91         float  strafehud_moveangle;
  92
  93         // HUD
  94         float  strafehud_hudangle;
  95         vector strafehud_currentangle_color        = strafehud_warning_color;
  96         vector strafehud_currentangle_size         = '0 0 0';
  97         float  strafehud_currentangle_offset;
  98         vector strafehud_bestangle_size            = '0 0 0';
  99         bool   strafehud_bestangle_anywhere        = false;
 100         float  strafehud_bestangle                 = 0;
 101         float  strafehud_bestangle_offset;
 102         float  strafehud_bestangle_opposite_offset;
 103         float  strafehud_accelzone_offset;
 104         vector strafehud_accelzone_size            = panel_size;
 105         float  strafehud_overturn_offset;
 106         vector strafehud_overturn_size             = panel_size;
 107         float  strafehud_mirrorangle;
 108         float  strafehud_mirror_overturn_offset;
 109         vector strafehud_mirror_overturn_size      = panel_size;
 110         vector strafehud_direction_size_vertical   = '0 0 0';
 111         vector strafehud_direction_size_horizontal = '0 0 0';
 112         float  strafehud_maxangle;
 113         float  strafehud_range_minangle;
 114
 115         // determine whether the player is strafing forwards or backwards
 116         if(strafeplayer == csqcplayer) // if entity is local player
 117         {
 118             if(strafehud_movement_x > 0)
 119             {
 120                 strafehud_fwd = true;
 121             }
 122             else if(strafehud_movement_x < 0)
 123             {
 124                 strafehud_fwd = false;
 125             }
 126         }
 127         else // alternatively determine direction by querying pressed keys
 128         {
 129             if((strafehud_keys & KEY_FORWARD) && !(strafehud_keys & KEY_BACKWARD))
 130             {
 131                 strafehud_fwd = true;
 132             }
 133             else if(!(strafehud_keys & KEY_FORWARD) && (strafehud_keys & KEY_BACKWARD))
 134             {
 135                 strafehud_fwd = false;
 136             }
 137         }
 138
 139         // determine player wishdir
 140         if(strafeplayer == csqcplayer) // if entity is local player
 141         {
 142             if(strafehud_movement_x == 0)
 143             {
 144                 if(strafehud_movement_y < 0)
 145                 {
 146                     strafehud_wishangle = -90;
 147                 }
 148                 else if(strafehud_movement_y > 0)
 149                 {
 150                     strafehud_wishangle = 90;
 151                 }
 152                 else
 153                 {
 154                     strafehud_wishangle = 0;
 155                 }
 156             }
 157             else
 158             {
 159                 if(strafehud_movement_y == 0)
 160                 {
 161                     strafehud_wishangle = 0;
 162                 }
 163                 else
 164                 {
 165                     strafehud_wishangle = RAD2DEG * atan2(strafehud_movement_y, strafehud_movement_x);
 166                 }
 167             }
 168         }
 169         else // alternatively calculate wishdir by querying pressed keys
 170         {
 171             if(strafehud_keys & KEY_FORWARD)
 172             {
 173                 strafehud_wishangle = 45;
 174             }
 175             else if(strafehud_keys & KEY_BACKWARD)
 176             {
 177                 strafehud_wishangle = 135;
 178             }
 179             else
 180             {
 181                 strafehud_wishangle = 90;
 182             }
 183             if(strafehud_keys & KEY_LEFT)
 184             {
 185                 strafehud_wishangle *= -1;
 186             }
 187             else if(!(strafehud_keys & KEY_RIGHT))
 188             {
 189                 strafehud_wishangle = 0;
 190             }
 191         }
 192
 193         // determine minimum required angle to display full strafe range
 194         strafehud_range_minangle = fabs(strafehud_wishangle) % 90; // maximum range is 90 degree
 195         if(strafehud_range_minangle > 45) // minimum angle range is 45
 196         {
 197             strafehud_range_minangle = 45 - fabs(strafehud_wishangle) % 45;
 198         }
 199         strafehud_range_minangle = 90 - strafehud_range_minangle; // calculate value which is never >90 or <45
 200
 201         if(autocvar_hud_panel_strafehud_angle == 0)
 202         {
 203             if(autocvar__hud_configure)
 204             {
 205                 strafehud_hudangle = 45;
 206             }
 207             else
 208             {
 209                 strafehud_hudangle = strafehud_range_minangle; // use minimum angle required if dynamically setting hud angle
 210             }
 211         }
 212         else
 213         {
 214             strafehud_hudangle = bound(1, fabs(autocvar_hud_panel_strafehud_angle), 360) / 2; // limit HUD range to 360 degrees, higher values don't make sense and break the code
 215         }
 216
 217         // detecting strafe turning
 218         if(!autocvar__hud_configure)
 219         {
 220             if(strafehud_onground != strafehud_state_onground)
 221             {
 222                 strafehud_state_onground_time = time;
 223             }
 224             strafehud_state_onground = strafehud_onground;
 225             if((fabs(strafehud_wishangle) == 90) != strafehud_state_strafekeys)
 226             {
 227                 strafehud_state_strafekeys_time = time;
 228             }
 229             strafehud_state_strafekeys = fabs(strafehud_wishangle) == 90;
 230             if((strafehud_keys & KEY_FORWARD) || (strafehud_keys & KEY_BACKWARD))
 231             {
 232                 strafehud_turn = false;
 233             }
 234             else if(strafehud_onground)
 235             {
 236                 if((time - strafehud_state_onground_time) >= strafehud_timeout_ground)
 237                 {
 238                     strafehud_turn = false;
 239                 }
 240             }
 241             else // air strafe only
 242             {
 243                 if(fabs(strafehud_wishangle) == 90)
 244                 {
 245                     if((time - strafehud_state_onground_time) >= strafehud_timeout_air)
 246                     {
 247                         strafehud_turn = true; // CPMA turning
 248                         strafehud_turnangle = strafehud_wishangle;
 249                     }
 250                 }
 251                 else if((time - strafehud_state_strafekeys_time) >= strafehud_timeout_strafe)
 252                 {
 253                     strafehud_turn = false;
 254                 }
 255             }
 256             if(strafehud_turn)
 257             {
 258                 strafehud_maxspeed = PHYS_MAXAIRSTRAFESPEED(strafeplayer) * strafehud_maxspeed_swamp_mod; // no crouching here because it doesn't affect air strafing
 259                 strafehud_wishangle = strafehud_turnangle;
 260             }
 261         }
 262
 263         strafehud_indicator_minspeed = strafehud_indicator_minspeed < 0 ? strafehud_maxspeed + .1 : strafehud_indicator_minspeed;
 264
 265         // add a background to the strafe-o-meter
 266         if(panel_size.x != 0 && panel_size.y != 0)
 267         {
 268             HUD_Panel_DrawProgressBar(panel_pos, panel_size, "progressbar", 1, 0, 0, strafehud_bar_color, strafehud_bar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 269         }
 270
 271         // get current strafing angle ranging from -180° to +180°
 272         if(!autocvar__hud_configure)
 273         {
 274             if(!strafehud_fwd) strafehud_wishangle += strafehud_wishangle < 0 ? 180 : strafehud_wishangle > 0 ? -180 : 0;
 275             if(strafehud_speed > 0)
 276             {
 277                 if(!strafehud_fwd) strafehud_view_angle += strafehud_view_angle < 0 ? 180 : strafehud_view_angle > 0 ? -180 : 0;
 278                 strafehud_angle = strafehud_view_angle - strafehud_vel_angle;
 279
 280                 if     (strafehud_angle >  180) strafehud_angle = -360 + strafehud_angle;
 281                 else if(strafehud_angle < -180) strafehud_angle =  360 + strafehud_angle;
 282
 283                 strafehud_angle = 180 - strafehud_angle;
 284                 if(strafehud_angle > 180)
 285                 {
 286                     strafehud_angle = -fabs(360 - strafehud_angle);
 287                 }
 288
 289                 // making the hud less flickery in case of rounding errors
 290                 if(strafehud_angle > 179.9 || strafehud_angle < -179.9)
 291                 {
 292                     strafehud_currentangle_color = strafehud_alert_color;
 293                     strafehud_angle = 0;
 294                 }
 295                 if(strafehud_angle < .1 && strafehud_angle > -.1)
 296                 {
 297                     strafehud_angle = 0;
 298                 }
 299             }
 300             else
 301             {
 302                 strafehud_angle = 0;
 303             }
 304         }
 305         else // simulate turning for HUD setup
 306         {
 307             if(autocvar__hud_panel_strafehud_demo && ((time - strafehud_demo_time) >= .025))
 308             {
 309                 strafehud_demo_time = time;
 310                 strafehud_demo_angle += 1 * strafehud_demo_direction;
 311                 if(fabs(strafehud_demo_angle) >= 55)
 312                 {
 313                     strafehud_demo_direction = -strafehud_demo_direction;
 314                 }
 315             }
 316             strafehud_angle = strafehud_demo_angle;
 317             strafehud_wishangle = 45 * (strafehud_demo_angle > 0 ? 1 : -1);
 318         }
 319
 320         if (autocvar_v_flipped)
 321         {
 322             strafehud_angle = -strafehud_angle;
 323             strafehud_wishangle = -strafehud_wishangle;
 324         }
 325
 326         strafehud_moveangle = strafehud_angle + strafehud_wishangle;
 327
 328         if(strafehud_wishangle != 0)
 329         {
 330             strafehud_direction = strafehud_wishangle > 0 ? 1 : -1;
 331         }
 332         else
 333         {
 334             strafehud_direction = strafehud_moveangle > 0 ? 1 : strafehud_moveangle < 0 ? -1 : 0;
 335         }
 336
 337         // decelerating at this angle
 338         strafehud_maxangle = 90 - fabs(strafehud_wishangle);
 339         // best angle to strafe at
 340         strafehud_bestangle = (strafehud_speed > strafehud_maxspeed ? acos(strafehud_maxspeed / strafehud_speed) : 0) * RAD2DEG * (strafehud_direction < 0 ? -1 : 1) - strafehud_wishangle;
 341         // various offsets and size calculations of hud indicators elements
 342         // best strafe acceleration angle
 343         strafehud_bestangle_offset          = floor( strafehud_bestangle/strafehud_hudangle * panel_size.x/2 + panel_size.x/2 + .5);
 344         strafehud_bestangle_opposite_offset = floor(-strafehud_bestangle/strafehud_hudangle * panel_size.x/2 + panel_size.x/2 + .5);
 345         strafehud_bestangle_size.x = floor(panel_size.x * .01 + .5);
 346         strafehud_bestangle_size.y = panel_size.y;
 347         // current angle
 348         strafehud_currentangle_offset = floor(bound(-strafehud_hudangle, strafehud_angle, strafehud_hudangle)/strafehud_hudangle * panel_size.x/2 + panel_size.x/2 + .5);
 349         strafehud_currentangle_size.x = floor(panel_size.x * .005 + .5);
 350         strafehud_currentangle_size.y = floor(panel_size.y * 1.5 + .5);
 351         // direction indicator
 352         strafehud_direction_size_vertical.x = floor(panel_size.x * .0075 + .5);
 353         strafehud_direction_size_vertical.y = panel_size.y;
 354         strafehud_direction_size_horizontal.x = floor(strafehud_direction_size_vertical.x * 3 + .5);
 355         strafehud_direction_size_horizontal.y = strafehud_direction_size_vertical.x;
 356         // overturn
 357         strafehud_mirrorangle = strafehud_maxangle + strafehud_hudangle - 180; // how many degrees of overturn area are on the opposite side of the hud
 358         strafehud_overturn_size.x = floor((panel_size.x * (strafehud_hudangle - strafehud_maxangle) / strafehud_hudangle) / 2 + .5);
 359         strafehud_mirror_overturn_size.x = floor(panel_size.x * strafehud_mirrorangle / (strafehud_hudangle * 2) + .5);
 360
 361         // mark the ideal strafe angle
 362         if(strafehud_speed >= strafehud_indicator_minspeed) // draw indicators if strafing is required to gain speed
 363         {
 364             if (fabs(strafehud_bestangle) <= strafehud_hudangle) // don't draw angle indicator and acceleration zones if outside of hud range
 365             {
 366                 if (strafehud_direction != 0) // only draw acceleration zones if strafe direction can be determined
 367                 {
 368                     // calculate zone in which strafe acceleration happens
 369                     if(strafehud_direction < 0) // moving left
 370                     {
 371                         strafehud_accelzone_offset = 0;
 372                         strafehud_accelzone_size.x = strafehud_bestangle_offset;
 373                     }
 374                     else // moving right
 375                     {
 376                         strafehud_accelzone_offset = strafehud_bestangle_offset + strafehud_bestangle_size.x;
 377                         strafehud_accelzone_size.x = panel_size.x - strafehud_accelzone_offset;
 378                     }
 379
 380                     if(strafehud_hudangle > strafehud_maxangle) // draw overturn area and move acceleration zone
 381                     {
 382                         if(strafehud_direction < 0) // moving left
 383                         {
 384                             // calculate offset of overturn area
 385                             strafehud_overturn_offset = 0;
 386                             // move/adjust acceleration zone
 387                             strafehud_accelzone_offset += strafehud_overturn_size.x;
 388                             strafehud_accelzone_size.x -= strafehud_overturn_size.x;
 389                             // calculate the remainder of the overturn zone on the opposite side
 390                             strafehud_mirror_overturn_offset = panel_size.x - strafehud_mirror_overturn_size.x;
 391                         }
 392                         else // moving right
 393                         {
 394                             // calculate offset of overturn area
 395                             strafehud_overturn_offset = panel_size.x - strafehud_overturn_size.x;
 396                             // adjust acceleration zone
 397                             strafehud_accelzone_size.x -= strafehud_overturn_size.x;
 398                             // calculate the remainder of the overturn zone on the opposite side
 399                             strafehud_mirror_overturn_offset = 0;
 400                         }
 401                         // draw overturn area
 402                         if(strafehud_overturn_size.x != 0 && strafehud_overturn_size.y != 0)
 403                         {
 404                             HUD_Panel_DrawProgressBar(panel_pos + eX * strafehud_overturn_offset, strafehud_overturn_size, "progressbar", 1, 0, 0, strafehud_alert_color, strafehud_bar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 405                         }
 406                         // draw remaining overturn area on the opposite side if there is any (180 degree in total)
 407                         if(strafehud_mirrorangle > 0 && strafehud_mirror_overturn_size.x != 0 && strafehud_mirror_overturn_size.y != 0)
 408                         {
 409                             HUD_Panel_DrawProgressBar(panel_pos + eX * strafehud_mirror_overturn_offset, strafehud_mirror_overturn_size, "progressbar", 1, 0, 0, strafehud_alert_color, strafehud_bar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 410                         }
 411                     }
 412
 413                     // draw acceleration zone
 414                     if(strafehud_accelzone_size.x != 0 && strafehud_accelzone_size.y != 0)
 415                     {
 416                         HUD_Panel_DrawProgressBar(panel_pos + eX * strafehud_accelzone_offset, strafehud_accelzone_size, "progressbar", 1, 0, 0, strafehud_bestangle_color, strafehud_bar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 417                     }
 418
 419                     // draw the direction indicator caps at the sides of the hud
 420                     // vertical line
 421                     drawfill(panel_pos + eX * (strafehud_direction < 0 ? -strafehud_direction_size_vertical.x : panel_size.x), strafehud_direction_size_vertical, strafehud_direction_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 422                     // top horizontal line
 423                     drawfill(panel_pos + eX * (strafehud_direction < 0 ? -strafehud_direction_size_vertical.x : panel_size.x - strafehud_direction_size_horizontal.x + strafehud_direction_size_vertical.x) - eY * strafehud_direction_size_horizontal.y, strafehud_direction_size_horizontal, strafehud_direction_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 424                     // bottom horizontal line
 425                     drawfill(panel_pos + eX * (strafehud_direction < 0 ? -strafehud_direction_size_vertical.x : panel_size.x - strafehud_direction_size_horizontal.x + strafehud_direction_size_vertical.x) + eY * panel_size.y, strafehud_direction_size_horizontal, strafehud_direction_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 426
 427                     // draw opposite best strafe angle
 428                     drawfill(panel_pos + eX * (strafehud_bestangle_opposite_offset - (-strafehud_direction < 0 ? strafehud_bestangle_size.x : 0)), strafehud_bestangle_size, strafehud_bestangle_opposite_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 429                     // draw current best strafe angle
 430                     drawfill(panel_pos + eX * (strafehud_bestangle_offset - (strafehud_direction < 0 ? strafehud_bestangle_size.x : 0)), strafehud_bestangle_size, strafehud_bestangle_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 431                 }
 432                 else
 433                 {
 434                     // draw best angles for acceleration
 435                     drawfill(panel_pos + eX * (strafehud_bestangle_opposite_offset - strafehud_bestangle_size.x), strafehud_bestangle_size, strafehud_bestangle_opposite_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 436                     drawfill(panel_pos + eX * (strafehud_bestangle_offset), strafehud_bestangle_size, strafehud_bestangle_opposite_color, panel_fg_alpha, DRAWFLAG_NORMAL);
 437                 }
 438             }
 439         }
 440         else
 441         {
 442             strafehud_bestangle_anywhere = true; // no indicators, moving forward should suffice to gain speed
 443         }
 444
 445         // draw the actual strafe angle
 446         if (!strafehud_bestangle_anywhere) // player gains speed with strafing
 447         {
 448             if ((strafehud_direction > 0 && strafehud_angle >= strafehud_bestangle) ||
 449                 (strafehud_direction < 0 && strafehud_angle <= strafehud_bestangle))
 450             strafehud_currentangle_color = strafehud_good_color;
 451         }
 452
 453         if (fabs(strafehud_moveangle) > 89.9) // player is overturning
 454         {
 455             strafehud_currentangle_color = strafehud_alert_color;
 456         }
 457
 458         if (strafehud_speed <= (strafehud_maxspeed + .1) && strafehud_currentangle_color != strafehud_alert_color) // player gains speed without strafing
 459         {
 460             strafehud_currentangle_color = strafehud_good_color;
 461         }
 462
 463         drawfill(panel_pos - '0 1 0'*floor(panel_size.y * .25 + .5) + eX * (strafehud_currentangle_offset - strafehud_currentangle_size.x/2), strafehud_currentangle_size, strafehud_currentangle_color, autocvar_hud_panel_strafehud_angle_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 464     }
 465 }