qcsrc/common/mutators/mutator/itemstime/itemstime.qc

   1 #include "itemstime.qh"
   2
   3 REGISTER_MUTATOR(itemstime, true);
   4
   5 #ifdef GAMEQC
   6 REGISTER_NET_TEMP(itemstime)
   7 #endif
   8
   9 #ifdef SVQC
  10 void IT_Write(entity e, int i, float f) {
  11     if (!IS_REAL_CLIENT(e)) return;
  12     msg_entity = e;
  13     WriteHeader(MSG_ONE, itemstime);
  14     WriteByte(MSG_ONE, i);
  15     WriteFloat(MSG_ONE, f);
  16 }
  17 #endif
  18
  19 #ifdef CSQC
  20 // reserve one more spot for superweapons time
  21 float ItemsTime_time[REGISTRY_MAX(Items) + 1];
  22 float ItemsTime_availableTime[REGISTRY_MAX(Items) + 1];
  23 NET_HANDLE(itemstime, bool isNew)
  24 {
  25     int i = ReadByte();
  26     float f = ReadFloat();
  27     return = true;
  28     ItemsTime_time[i] = f;
  29 }
  30
  31 NET_HANDLE(TE_CSQC_TOTALSHARDS, bool isNew)
  32 {
  33         // for RJZ
  34         total_shards = ReadInt24_t();
  35
  36         return = true;
  37 }
  38
  39 #endif
  40
  41 #ifdef CSQC
  42
  43 STATIC_INIT(ItemsTime_Init) {
  44         FOREACH(Items, true, {
  45                 ItemsTime_time[it.m_id] = -1;
  46         });
  47         ItemsTime_time[REGISTRY_MAX(Items)] = -1;
  48 }
  49
  50 int autocvar_hud_panel_itemstime = 2;
  51 float autocvar_hud_panel_itemstime_dynamicsize = 1;
  52 float autocvar_hud_panel_itemstime_ratio = 2;
  53 //bool autocvar_hud_panel_itemstime_dynamichud    = true;
  54 int autocvar_hud_panel_itemstime_iconalign;
  55 bool autocvar_hud_panel_itemstime_progressbar = 0;
  56 float autocvar_hud_panel_itemstime_progressbar_maxtime = 30;
  57 string autocvar_hud_panel_itemstime_progressbar_name = "progressbar";
  58 float autocvar_hud_panel_itemstime_progressbar_reduced;
  59 bool autocvar_hud_panel_itemstime_hidespawned = 1;
  60 bool autocvar_hud_panel_itemstime_hidebig = false;
  61 int autocvar_hud_panel_itemstime_text = 1;
  62 #define hud_panel_itemstime_hidebig autocvar_hud_panel_itemstime_hidebig
  63 #else
  64 #define hud_panel_itemstime_hidebig false
  65 #endif
  66
  67 bool Item_ItemsTime_SpectatorOnly(GameItem it)
  68 {
  69     return (false
  70     || it == ITEM_ArmorMega     || (it == ITEM_ArmorBig && !hud_panel_itemstime_hidebig)
  71     || it == ITEM_HealthMega    || (it == ITEM_HealthBig && !hud_panel_itemstime_hidebig)
  72     );
  73 }
  74
  75 bool Item_ItemsTime_Allow(GameItem it)
  76 {
  77     return (false
  78     || it.instanceOfPowerup
  79     || Item_ItemsTime_SpectatorOnly(it)
  80     );
  81 }
  82
  83 #ifdef SVQC
  84
  85 // reserve one more spot for superweapons time
  86 float it_times[REGISTRY_MAX(Items) + 1];
  87
  88 STATIC_INIT(ItemsTime_Init) {
  89         FOREACH(Items, Item_ItemsTime_Allow(it), {
  90                 it_times[it.m_id] = -1;
  91         });
  92         it_times[REGISTRY_MAX(Items)] = -1;
  93 }
  94
  95 void Item_ItemsTime_ResetTimes()
  96 {
  97     FOREACH(Items, Item_ItemsTime_Allow(it), {
  98         it_times[it.m_id] = (it_times[it.m_id] == -1) ? -1 : 0;
  99     });
 100     it_times[REGISTRY_MAX(Items)] = (it_times[REGISTRY_MAX(Items)] == -1) ? -1 : 0;
 101 }
 102
 103 void Item_ItemsTime_ResetTimesForPlayer(entity e)
 104 {
 105     FOREACH(Items, Item_ItemsTime_Allow(it), {
 106         IT_Write(e, it.m_id, (it_times[it.m_id] == -1) ? -1 : 0);
 107     });
 108     IT_Write(e, REGISTRY_MAX(Items), (it_times[REGISTRY_MAX(Items)] == -1) ? -1 : 0);
 109 }
 110
 111 void Item_ItemsTime_SetTimesForPlayer(entity e)
 112 {
 113     FOREACH(Items, Item_ItemsTime_Allow(it), {
 114         IT_Write(e, it.m_id, it_times[it.m_id]);
 115     });
 116     IT_Write(e, REGISTRY_MAX(Items), it_times[REGISTRY_MAX(Items)]);
 117 }
 118
 119 void Item_ItemsTime_SetTime(entity e, float t)
 120 {
 121     if (!autocvar_sv_itemstime)
 122         return;
 123
 124     GameItem item = e.itemdef;
 125     if (item.instanceOfGameItem)
 126     {
 127                 if (!item.instanceOfWeaponPickup)
 128                         it_times[item.m_id] = t;
 129                 else if (STAT(WEAPONS, e) & WEPSET_SUPERWEAPONS)
 130                         it_times[REGISTRY_MAX(Items)] = t;
 131     }
 132 }
 133
 134 void Item_ItemsTime_SetTimesForAllPlayers()
 135 {
 136     FOREACH_CLIENT(IS_REAL_CLIENT(it) && (warmup_stage || !IS_PLAYER(it) || autocvar_sv_itemstime == 2), { Item_ItemsTime_SetTimesForPlayer(it); });
 137 }
 138
 139 float Item_ItemsTime_UpdateTime(entity e, float t)
 140 {
 141     bool isavailable = (t == 0);
 142     IL_EACH(g_items, it != e,
 143     {
 144         if(!(it.itemdef == e.itemdef || ((STAT(WEAPONS, e) & WEPSET_SUPERWEAPONS) && (STAT(WEAPONS, it) & WEPSET_SUPERWEAPONS))))
 145             continue;
 146         if (it.scheduledrespawntime <= time)
 147             isavailable = true;
 148         else if (t == 0 || it.scheduledrespawntime < t)
 149             t = it.scheduledrespawntime;
 150     });
 151     if (isavailable)
 152         t = -t; // let know the client there's another available item
 153     return t;
 154 }
 155
 156 MUTATOR_HOOKFUNCTION(itemstime, reset_map_global)
 157 {
 158     Item_ItemsTime_ResetTimes();
 159     // ALL the times need to be reset before .reset()ing each item
 160     // since Item_Reset schedules respawn of superweapons and powerups
 161     IL_EACH(g_items, it.reset,
 162     {
 163         Item_ItemsTime_SetTime(it, 0);
 164     });
 165     Item_ItemsTime_SetTimesForAllPlayers();
 166 }
 167
 168 MUTATOR_HOOKFUNCTION(itemstime, MakePlayerObserver)
 169 {
 170     entity player = M_ARGV(0, entity);
 171
 172     Item_ItemsTime_SetTimesForPlayer(player);
 173 }
 174
 175 MUTATOR_HOOKFUNCTION(itemstime, ClientConnect, CBC_ORDER_LAST)
 176 {
 177     entity player = M_ARGV(0, entity);
 178
 179         if(IS_PLAYER(player))
 180         {
 181                 // client became player on connection skipping putObserverInServer step
 182                 if (IS_REAL_CLIENT(player))
 183                 if (warmup_stage || autocvar_sv_itemstime == 2)
 184                         Item_ItemsTime_SetTimesForPlayer(player);
 185         }
 186 }
 187
 188 MUTATOR_HOOKFUNCTION(itemstime, PlayerSpawn)
 189 {
 190     if (warmup_stage || autocvar_sv_itemstime == 2) return;
 191     entity player = M_ARGV(0, entity);
 192
 193     Item_ItemsTime_ResetTimesForPlayer(player);
 194 }
 195
 196 #endif
 197
 198 #ifdef CSQC
 199
 200 // ItemsTime (#22)
 201
 202 void HUD_ItemsTime_Export(int fh)
 203 {
 204         // allow saving cvars that aesthetically change the panel into hud skin files
 205         HUD_Write_Cvar("hud_panel_itemstime_iconalign");
 206         HUD_Write_Cvar("hud_panel_itemstime_progressbar");
 207         HUD_Write_Cvar("hud_panel_itemstime_progressbar_name");
 208         HUD_Write_Cvar("hud_panel_itemstime_progressbar_reduced");
 209         HUD_Write_Cvar("hud_panel_itemstime_text");
 210         HUD_Write_Cvar("hud_panel_itemstime_ratio");
 211         HUD_Write_Cvar("hud_panel_itemstime_dynamicsize");
 212 }
 213
 214 // for RJZ
 215 void DrawItemsTimeItemFixed(vector myPos, vector mySize, float ar, string item_icon, float t, vector color)
 216 {
 217         vector picpos, numpos;
 218     if (autocvar_hud_panel_itemstime_iconalign)
 219     {
 220         numpos = myPos;
 221         picpos = myPos + eX * (ar - 1) * mySize_y;
 222     }
 223     else
 224     {
 225         numpos = myPos + eX * mySize_y;
 226         picpos = myPos;
 227     }
 228
 229     drawstring_aspect(numpos, (t < 0 ? "-" : ftos(t)), vec2(((ar - 1)/ar) * mySize.x, mySize.y), color, panel_fg_alpha, DRAWFLAG_NORMAL);
 230     drawpic_aspect(picpos, item_icon, '1 1 0' * mySize_y, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 231 }
 232
 233 void DrawItemsTimeItem(vector myPos, vector mySize, float ar, string item_icon, float item_time, bool item_available, float item_availableTime)
 234 {
 235     float t = 0;
 236     vector color = '0 0 0';
 237     float picalpha;
 238
 239     if (autocvar_hud_panel_itemstime_hidespawned == 2)
 240         picalpha = 1;
 241     else if (item_available)
 242         picalpha = blink(0.85, 0.15, 5);
 243     else
 244         picalpha = 0.5;
 245     t = floor(item_time - time + 0.999);
 246     if (t < 5)
 247         color = '0.7 0 0';
 248     else if (t < 10)
 249         color = '0.7 0.7 0';
 250     else
 251         color = '1 1 1';
 252
 253     vector picpos, numpos;
 254     if (autocvar_hud_panel_itemstime_iconalign)
 255     {
 256         numpos = myPos;
 257         picpos = myPos + eX * (ar - 1) * mySize_y;
 258     }
 259     else
 260     {
 261         numpos = myPos + eX * mySize_y;
 262         picpos = myPos;
 263     }
 264
 265     if (t > 0 && autocvar_hud_panel_itemstime_progressbar)
 266     {
 267         vector p_pos, p_size;
 268         if (autocvar_hud_panel_itemstime_progressbar_reduced)
 269         {
 270             p_pos = numpos;
 271             p_size = vec2(((ar - 1)/ar) * mySize.x, mySize.y);
 272         }
 273         else
 274         {
 275             p_pos = myPos;
 276             p_size = mySize;
 277         }
 278         HUD_Panel_DrawProgressBar(p_pos, p_size, autocvar_hud_panel_itemstime_progressbar_name, t/autocvar_hud_panel_itemstime_progressbar_maxtime, 0, autocvar_hud_panel_itemstime_iconalign, color, autocvar_hud_progressbar_alpha * panel_fg_alpha, DRAWFLAG_NORMAL);
 279     }
 280
 281     if(autocvar_hud_panel_itemstime_text)
 282     {
 283         if(t > 0)
 284             drawstring_aspect(numpos, ftos(t), vec2(((ar - 1)/ar) * mySize.x, mySize.y), color, panel_fg_alpha, DRAWFLAG_NORMAL);
 285         else if(precache_pic("gfx/hud/default/checkmark")) // COMPAT: check if this image exists, as 0.8.1 clients lack it
 286             drawpic_aspect_skin(numpos, "checkmark", vec2((ar - 1) * mySize.y, mySize.y), '1 1 1', panel_fg_alpha * picalpha, DRAWFLAG_NORMAL);
 287         else // legacy code, if the image is missing just center the icon
 288             picpos.x = myPos.x + mySize.x / 2 - mySize.y / 2;
 289     }
 290     if (item_availableTime)
 291         drawpic_aspect_skin_expanding(picpos, item_icon, '1 1 0' * mySize_y, '1 1 1', panel_fg_alpha * picalpha, DRAWFLAG_NORMAL, item_availableTime);
 292     drawpic_aspect_skin(picpos, item_icon, '1 1 0' * mySize_y, '1 1 1', panel_fg_alpha * picalpha, DRAWFLAG_NORMAL);
 293 }
 294
 295 float Item_ItemsTime_GetTime(int item)
 296 {
 297     if(autocvar__hud_configure)
 298     {
 299         switch(item)
 300         {
 301             case ITEM_ArmorMega.m_id: return time + 0;
 302             case ITEM_HealthMega.m_id: return time + 8;
 303             case ITEM_Strength.m_id: return time + 0;
 304             case ITEM_Shield.m_id: return time + 4;
 305         }
 306
 307         return -1; // don't show others
 308     }
 309     else
 310         {
 311                 float game_starttime = STAT(GAMESTARTTIME);
 312                 float timeout_last = STAT(TIMEOUT_LAST);
 313
 314                 if(ItemsTime_time[item] > 0 && game_starttime < time)
 315                         if(timeout_last)
 316                                 return ItemsTime_time[item] + game_starttime - timeout_last + time;
 317                         else
 318                                 return ItemsTime_time[item] + game_starttime;
 319                 else
 320                         return ItemsTime_time[item];
 321         }
 322 }
 323
 324 void HUD_ItemsTime()
 325 {
 326     if (!autocvar__hud_configure)
 327     {
 328         if (!(
 329             (autocvar_hud_panel_itemstime == 1 && spectatee_status != 0)
 330         ||      (autocvar_hud_panel_itemstime == 2 && (spectatee_status != 0 || warmup_stage || STAT(ITEMSTIME) == 2))
 331             )) { return; }
 332     }
 333
 334     int count = 0;
 335     if (autocvar_hud_panel_itemstime_hidespawned == 1)
 336     {
 337         FOREACH(Items, Item_ItemsTime_Allow(it), {
 338             count += (Item_ItemsTime_GetTime(it.m_id) > time || -Item_ItemsTime_GetTime(it.m_id) > time);
 339         });
 340         count += (Item_ItemsTime_GetTime(REGISTRY_MAX(Items)) > time || -Item_ItemsTime_GetTime(REGISTRY_MAX(Items)) > time);
 341     }
 342     else if (autocvar_hud_panel_itemstime_hidespawned == 2)
 343     {
 344         FOREACH(Items, Item_ItemsTime_Allow(it), {
 345             count += (Item_ItemsTime_GetTime(it.m_id) > time);
 346         });
 347         count += (Item_ItemsTime_GetTime(REGISTRY_MAX(Items)) > time);
 348     }
 349     else
 350     {
 351         FOREACH(Items, Item_ItemsTime_Allow(it), {
 352             count += (Item_ItemsTime_GetTime(it.m_id) != -1);
 353         });
 354         count += (Item_ItemsTime_GetTime(REGISTRY_MAX(Items)) != -1);
 355     }
 356     // for RJZ
 357     if (total_shards != -1)
 358                 count++;
 359
 360     if (count == 0)
 361         return;
 362
 363     HUD_Panel_LoadCvars();
 364
 365     vector pos, mySize;
 366     pos = panel_pos;
 367     mySize = panel_size;
 368
 369     if (panel_bg_padding)
 370     {
 371         pos += '1 1 0' * panel_bg_padding;
 372         mySize -= '2 2 0' * panel_bg_padding;
 373     }
 374
 375     float rows, columns;
 376     float ar = max(2, autocvar_hud_panel_itemstime_ratio) + 1;
 377     rows = HUD_GetRowCount(count, mySize, ar);
 378     columns = ceil(count/rows);
 379
 380     vector itemstime_size = vec2(mySize.x / columns, mySize.y / rows);
 381
 382     vector offset = '0 0 0';
 383     float newSize;
 384     if (autocvar_hud_panel_itemstime_dynamicsize)
 385     {
 386         if (autocvar__hud_configure)
 387         if (hud_configure_menu_open != 2)
 388             HUD_Panel_DrawBg(); // also draw the bg of the entire panel
 389
 390         // reduce panel to avoid spacing items
 391         if (itemstime_size.x / itemstime_size.y < ar)
 392         {
 393             newSize = rows * itemstime_size.x / ar;
 394             pos.y += (mySize.y - newSize) / 2;
 395             mySize.y = newSize;
 396             itemstime_size.y = mySize.y / rows;
 397         }
 398         else
 399         {
 400             newSize = columns * itemstime_size.y * ar;
 401             pos.x += (mySize.x - newSize) / 2;
 402             mySize.x = newSize;
 403             itemstime_size.x = mySize.x / columns;
 404         }
 405         panel_pos = pos - '1 1 0' * panel_bg_padding;
 406         panel_size = mySize + '2 2 0' * panel_bg_padding;
 407     }
 408     else
 409     {
 410         if (itemstime_size.x/itemstime_size.y > ar)
 411         {
 412             newSize = ar * itemstime_size.y;
 413             offset.x = itemstime_size.x - newSize;
 414             pos.x += offset.x/2;
 415             itemstime_size.x = newSize;
 416         }
 417         else
 418         {
 419             newSize = 1/ar * itemstime_size.x;
 420             offset.y = itemstime_size.y - newSize;
 421             pos.y += offset.y/2;
 422             itemstime_size.y = newSize;
 423         }
 424     }
 425
 426     if (total_shards != -1)
 427                 panel_size.y += itemstime_size.y * 0.5;
 428
 429     HUD_Scale_Enable();
 430     HUD_Panel_DrawBg();
 431
 432     float row = 0, column = 0;
 433     bool item_available;
 434     int id = 0;
 435     string icon = "";
 436     FOREACH(Items, Item_ItemsTime_Allow(it) && Item_ItemsTime_GetTime(it.m_id) != -1, {
 437         id = it.m_id;
 438         icon = it.m_icon;
 439
 440
 441 LABEL(iteration)
 442         float item_time = Item_ItemsTime_GetTime(id);
 443         if (item_time < -1)
 444         {
 445             item_available = true;
 446             item_time = -item_time;
 447         }
 448         else
 449             item_available = (item_time <= time);
 450
 451         if (Item_ItemsTime_GetTime(id) >= 0)
 452         {
 453             if (time <= Item_ItemsTime_GetTime(id))
 454                 ItemsTime_availableTime[id] = 0;
 455             else if (ItemsTime_availableTime[id] == 0)
 456                 ItemsTime_availableTime[id] = time;
 457         }
 458         else if (ItemsTime_availableTime[id] == 0)
 459             ItemsTime_availableTime[id] = time;
 460
 461         float f = (time - ItemsTime_availableTime[id]) * 2;
 462         f = (f > 1) ? 0 : bound(0, f, 1);
 463
 464         if (autocvar_hud_panel_itemstime_hidespawned == 1)
 465             if (!(Item_ItemsTime_GetTime(id) > time || -Item_ItemsTime_GetTime(id) > time))
 466                 continue;
 467
 468         if (autocvar_hud_panel_itemstime_hidespawned == 2)
 469             if (!(Item_ItemsTime_GetTime(id) > time))
 470                 continue;
 471
 472         DrawItemsTimeItem(pos + vec2(column * (itemstime_size.x + offset.x), row * (itemstime_size.y + offset.y)), itemstime_size, ar, icon, item_time, item_available, f);
 473         ++row;
 474         if (row >= rows)
 475         {
 476             row = 0;
 477             column = column + 1;
 478         }
 479         if(id == REGISTRY_MAX(Items)) // can happen only in the last fake iteration
 480                 break;
 481     });
 482
 483         // for RJZ
 484         if(total_shards != -1) {
 485                 DrawItemsTimeItemFixed(pos + vec2(column * (itemstime_size.x + offset.x), row * (itemstime_size.y + offset.y) + itemstime_size.y * 0.5), itemstime_size, ar, "gfx/shards.tga", total_shards, '0.16 0.7 0.83');
 486                 ++row;
 487                 if (row >= rows)
 488                 {
 489                         row = 0;
 490                         column = column + 1;
 491                 }
 492         }
 493
 494     // add another fake iteration for superweapons time
 495     if(id < REGISTRY_MAX(Items) && Item_ItemsTime_GetTime(REGISTRY_MAX(Items)) != -1)
 496     {
 497                 id = REGISTRY_MAX(Items);
 498                 icon = "superweapons";
 499                 goto iteration;
 500     }
 501 }
 502
 503 #endif