qcsrc/common/notifications/all.qc

   1 #include "all.qh"
   2 #if defined(CSQC)
   3         #include <client/announcer.qh>
   4 #elif defined(MENUQC)
   5 #elif defined(SVQC)
   6         #include <common/constants.qh>
   7         #include <common/net_linked.qh>
   8         #include <common/teams.qh>
   9         #include <server/autocvars.qh>
  10         #include <server/constants.qh>
  11         #include <server/defs.qh>
  12         #include <server/mutators/_mod.qh>
  13 #endif
  14
  15 // ================================================
  16 //  Unified notification system, written by Samual
  17 //  Last updated: August, 2013
  18 // ================================================
  19
  20 #ifdef SVQC
  21 string Notification_CheckArgs(
  22         NOTIF broadcast, entity client)
  23 {
  24         // check supplied broadcast and target for errors
  25         switch (broadcast)
  26         {
  27                 case NOTIF_ONE:
  28                 case NOTIF_ONE_ONLY:
  29                 {
  30                         if (IS_NOT_A_CLIENT(client)) {
  31                                 return "No client provided!";
  32                         }
  33                         break;
  34                 }
  35
  36                 case NOTIF_ALL_EXCEPT:
  37                 {
  38                         if (IS_NOT_A_CLIENT(client)) {
  39                                 return "Exception can't be a non-client!";
  40                         }
  41                         break;
  42                 }
  43
  44                 case NOTIF_ALL:
  45                 {
  46                         if (client) {
  47                                 return "Entity provided when NULL was required!";
  48                         }
  49                         break;
  50                 }
  51
  52                 case NOTIF_TEAM:
  53                 {
  54                         if (!teamplay) {
  55                                 return "Teamplay not active!";
  56                         } else if (!client.team) {
  57                                 // checkargs = sprintf("%sNo team provided!", checkargs);
  58                         }
  59                         break;
  60                 }
  61
  62                 case NOTIF_TEAM_EXCEPT:
  63                 {
  64                         if (!teamplay) {
  65                                 return "Teamplay not active!";
  66                         } else if (IS_NOT_A_CLIENT(client)) {
  67                                 return "Exception can't be a non-client!";
  68                         }
  69                         break;
  70                 }
  71
  72                 default:
  73                 {
  74                         return sprintf("Improper broadcast: %d!", broadcast);
  75                 }
  76         }
  77         return "";
  78 }
  79
  80 bool Notification_ShouldSend(NOTIF broadcast, entity to_client, entity other_client)
  81 {
  82         switch (broadcast)
  83         {
  84                 case NOTIF_ONE:
  85                         return (
  86                                 (to_client == other_client)
  87                                 ||
  88                                 (IS_SPEC(to_client) && (to_client.enemy == other_client))
  89                         );
  90                 case NOTIF_ONE_ONLY:
  91                         return (to_client == other_client);
  92                 case NOTIF_TEAM:
  93                         return (
  94                                 (to_client.team == other_client.team)
  95                                 ||
  96                                 (
  97                                         IS_SPEC(to_client)
  98                                         &&
  99                                         (to_client.enemy.team == other_client.team)
 100                                 )
 101                         );
 102                 case NOTIF_TEAM_EXCEPT:
 103                         return (
 104                                 (to_client != other_client)
 105                                 &&
 106                                 (
 107                                         (to_client.team == other_client.team)
 108                                         ||
 109                                         (
 110                                                 IS_SPEC(to_client)
 111                                                 &&
 112                                                 (
 113                                                         (to_client.enemy != other_client)
 114                                                         &&
 115                                                         (to_client.enemy.team == other_client.team)
 116                                                 )
 117                                         )
 118                                 )
 119                         );
 120                 case NOTIF_ALL:
 121                         return true;
 122                 case NOTIF_ALL_EXCEPT:
 123                         return (
 124                                 (to_client != other_client)
 125                                 &&
 126                                 !(
 127                                         IS_SPEC(to_client)
 128                                         &&
 129                                         (to_client.enemy == other_client)
 130                                 )
 131                         );
 132                 default:
 133                         return false;
 134         }
 135 }
 136
 137 #endif
 138
 139 // ===============================
 140 //  Initialization Core Functions
 141 // ===============================
 142
 143 // used by restartnotifs command to initialize notifications
 144 void Destroy_Notification_Entity(entity notif)
 145 {
 146         if (notif.nent_name != "") strunzone(notif.nent_name);
 147         if (notif.nent_snd != "") strunzone(notif.nent_snd);
 148         if (notif.nent_args != "") strunzone(notif.nent_args);
 149         if (notif.nent_hudargs != "") strunzone(notif.nent_hudargs);
 150         if (notif.nent_icon != "") strunzone(notif.nent_icon);
 151         if (notif.nent_durcnt != "") strunzone(notif.nent_durcnt);
 152         if (notif.nent_string != "") strunzone(notif.nent_string);
 153         delete(notif);
 154 }
 155
 156 void Destroy_All_Notifications()
 157 {
 158         // kill all networked notifications and centerprints
 159         #ifdef SVQC
 160         Kill_Notification(NOTIF_ALL, NULL, MSG_Null, CPID_Null);
 161         #else
 162         reset_centerprint_messages();
 163         #endif
 164
 165         // kill all real notification entities
 166         FOREACH(Notifications, true, { Destroy_Notification_Entity(it); });
 167 }
 168
 169 string Process_Notif_Line(
 170         MSG typeId,
 171         bool chat,
 172         string input,
 173         string notiftype,
 174         string notifname,
 175         string stringtype)
 176 {
 177         #ifdef CSQC
 178         if(typeId == MSG_INFO)
 179         {
 180                 if((chat && autocvar_notification_allow_chatboxprint)
 181                         || (autocvar_notification_allow_chatboxprint == 2))
 182                 {
 183                         // pass 1: add ETX char at beginning of line
 184                         input = strcat("\{3}", input);
 185
 186                         // pass 2: add ETX char at end of each new line (so that
 187                         // messages with multiple lines are put through chatbox too)
 188                         input = strreplace("\n", "\n\{3}", input);
 189
 190                         // pass 3: strip trailing ETX char
 191                         if(substring(input, (strlen(input) - 1), 1) == "\{3}")
 192                                 { input = substring(input, 0, (strlen(input) - 1)); }
 193                 }
 194         }
 195         #endif
 196
 197         // done to both MSG_INFO and MSG_CENTER
 198         if(substring(input, (strlen(input) - 1), 1) == "\n")
 199         {
 200                 LOG_INFOF(
 201                         (
 202                                 "^1TRAILING NEW LINE AT END OF NOTIFICATION: "
 203                                 "^7net_type = %s, net_name = %s, string = %s."
 204                         ),
 205                         notiftype,
 206                         notifname,
 207                         stringtype
 208                 );
 209                 notif_error = true;
 210                 input = substring(input, 1, (strlen(input) - 1));
 211         }
 212
 213         return input;
 214 }
 215
 216 string Process_Notif_Args(
 217         float arg_type,
 218         string args,
 219         string notiftype,
 220         string notifname)
 221 {
 222         string selected, remaining = args;
 223         float sel_num = 0;
 224
 225         for (;(remaining != "");)
 226         {
 227                 selected = car(remaining); remaining = cdr(remaining);
 228
 229                 switch(arg_type)
 230                 {
 231                         case 1: // normal args
 232                         {
 233                                 if(sel_num == NOTIF_MAX_ARGS)
 234                                 {
 235                                         LOG_INFOF(
 236                                                 (
 237                                                         "^1NOTIFICATION HAS TOO MANY ARGUMENTS: "
 238                                                         "^7net_type = %s, net_name = %s, max args = %d."
 239                                                 ),
 240                                                 notiftype,
 241                                                 notifname,
 242                                                 NOTIF_MAX_ARGS
 243                                         );
 244                                         notif_error = true;
 245                                         break;
 246                                 }
 247
 248                                 switch(strtolower(selected))
 249                                 {
 250                                         #define ARG_CASE_ARG_CS_SV_HA(selected,result) case selected: ++sel_num; break;
 251                                         #define ARG_CASE_ARG_CS_SV_DC(selected,result) case selected: ++sel_num; break;
 252                                         #define ARG_CASE_ARG_CS_SV(selected,result)    case selected: ++sel_num; break;
 253                                         #define ARG_CASE_ARG_CS(selected,result)       case selected: ++sel_num; break;
 254                                         #define ARG_CASE_ARG_SV(selected,result)       case selected: ++sel_num; break;
 255                                         #define ARG_CASE_ARG_DC(selected,result)
 256                                         #define ARG_CASE(prog,selected,result)         ARG_CASE_##prog(selected,result)
 257                                         NOTIF_ARGUMENT_LIST
 258                                         #undef ARG_CASE
 259                                         #undef ARG_CASE_ARG_DC
 260                                         #undef ARG_CASE_ARG_SV
 261                                         #undef ARG_CASE_ARG_CS
 262                                         #undef ARG_CASE_ARG_CS_SV
 263                                         #undef ARG_CASE_ARG_CS_SV_DC
 264                                         #undef ARG_CASE_ARG_CS_SV_HA
 265                                         default:
 266                                         {
 267                                                 LOG_INFOF(
 268                                                         (
 269                                                                 "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: "
 270                                                                 "^7net_type = %s, net_name = %s, args arg = '%s'."
 271                                                         ),
 272                                                         notiftype,
 273                                                         notifname,
 274                                                         selected
 275                                                 );
 276                                                 notif_error = true;
 277                                                 break;
 278                                         }
 279                                 }
 280                                 break;
 281                         }
 282                         case 2: // hudargs
 283                         {
 284                                 if(sel_num == NOTIF_MAX_HUDARGS)
 285                                 {
 286                                         LOG_INFOF(
 287                                                 (
 288                                                         "^1NOTIFICATION HAS TOO MANY ARGUMENTS: "
 289                                                         "^7net_type = %s, net_name = %s, max hudargs = %d."
 290                                                 ),
 291                                                 notiftype,
 292                                                 notifname,
 293                                                 NOTIF_MAX_HUDARGS
 294                                         );
 295                                         notif_error = true;
 296                                         break;
 297                                 }
 298
 299                                 switch(strtolower(selected))
 300                                 {
 301                                         #define ARG_CASE_ARG_CS_SV_HA(selected,result) case selected: ++sel_num; break;
 302                                         #define ARG_CASE_ARG_CS_SV_DC(selected,result)
 303                                         #define ARG_CASE_ARG_CS_SV(selected,result)
 304                                         #define ARG_CASE_ARG_CS(selected,result)
 305                                         #define ARG_CASE_ARG_SV(selected,result)
 306                                         #define ARG_CASE_ARG_DC(selected,result)
 307                                         #define ARG_CASE(prog,selected,result)         ARG_CASE_##prog(selected,result)
 308                                         NOTIF_ARGUMENT_LIST
 309                                         #undef ARG_CASE
 310                                         #undef ARG_CASE_ARG_DC
 311                                         #undef ARG_CASE_ARG_SV
 312                                         #undef ARG_CASE_ARG_CS
 313                                         #undef ARG_CASE_ARG_CS_SV
 314                                         #undef ARG_CASE_ARG_CS_SV_DC
 315                                         #undef ARG_CASE_ARG_CS_SV_HA
 316                                         default:
 317                                         {
 318                                                 LOG_INFOF(
 319                                                         (
 320                                                                 "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: "
 321                                                                 "^7net_type = %s, net_name = %s, hudargs arg = '%s'."
 322                                                         ),
 323                                                         notiftype,
 324                                                         notifname,
 325                                                         selected
 326                                                 );
 327                                                 notif_error = true;
 328                                                 break;
 329                                         }
 330                                 }
 331                                 break;
 332                         }
 333                         case 3: // durcnt
 334                         {
 335                                 if(sel_num == NOTIF_MAX_DURCNT)
 336                                 {
 337                                         LOG_INFOF(
 338                                                 (
 339                                                         "^1NOTIFICATION HAS TOO MANY ARGUMENTS: "
 340                                                         "^7net_type = %s, net_name = %s, max durcnt = %d."
 341                                                 ),
 342                                                 notiftype,
 343                                                 notifname,
 344                                                 NOTIF_MAX_DURCNT
 345                                         );
 346                                         notif_error = true;
 347                                         break;
 348                                 }
 349
 350                                 switch(strtolower(selected))
 351                                 {
 352                                         #define ARG_CASE_ARG_CS_SV_HA(selected,result)
 353                                         #define ARG_CASE_ARG_CS_SV_DC(selected,result) case selected: ++sel_num; break;
 354                                         #define ARG_CASE_ARG_CS_SV(selected,result)
 355                                         #define ARG_CASE_ARG_CS(selected,result)
 356                                         #define ARG_CASE_ARG_SV(selected,result)
 357                                         #define ARG_CASE_ARG_DC(selected,result)       case selected: ++sel_num; break;
 358                                         #define ARG_CASE(prog,selected,result)         ARG_CASE_##prog(selected,result)
 359                                         NOTIF_ARGUMENT_LIST
 360                                         #undef ARG_CASE
 361                                         #undef ARG_CASE_ARG_DC
 362                                         #undef ARG_CASE_ARG_SV
 363                                         #undef ARG_CASE_ARG_CS
 364                                         #undef ARG_CASE_ARG_CS_SV
 365                                         #undef ARG_CASE_ARG_CS_SV_DC
 366                                         #undef ARG_CASE_ARG_CS_SV_HA
 367                                         default:
 368                                         {
 369                                                 if(ftos(stof(selected)) != "") { ++sel_num; }
 370                                                 else
 371                                                 {
 372                                                         LOG_INFOF(
 373                                                                 (
 374                                                                         "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: "
 375                                                                         "^7net_type = %s, net_name = %s, durcnt arg = '%s'."
 376                                                                 ),
 377                                                                 notiftype,
 378                                                                 notifname,
 379                                                                 selected
 380                                                         );
 381                                                         notif_error = true;
 382                                                 }
 383                                                 break;
 384                                         }
 385                                 }
 386                                 break;
 387                         }
 388                 }
 389         }
 390         return args;
 391 }
 392
 393 void Create_Notification_Entity(entity notif,
 394         float var_default,
 395         float var_cvar,
 396         MSG typeId,
 397         string namestring,
 398         int teamnum)
 399 {
 400         // =====================
 401         //  Global Entity Setup
 402         // =====================
 403         notif.nent_default = var_default;
 404         notif.nent_enabled = (var_cvar >= 1);
 405         notif.nent_type = typeId;
 406         notif.nent_name = strzone(namestring);
 407         notif.nent_teamnum = teamnum;
 408
 409         // Other pre-notif-setup requisites
 410         notif_error = false;
 411
 412         switch (typeId)
 413         {
 414                 case MSG_ANNCE:
 415                 case MSG_INFO:
 416                 case MSG_CENTER:
 417                 case MSG_MULTI:
 418                 case MSG_CHOICE:
 419                         break;
 420                 default:
 421                         LOG_INFOF(
 422                                 (
 423                                         "^1NOTIFICATION WITH IMPROPER TYPE: "
 424                                         "^7net_type = %d, net_name = %s."
 425                                 ),
 426                                 typeId,
 427                                 namestring
 428                         );
 429                         notif_error = true;
 430                         break;
 431         }
 432
 433         // now check to see if any errors happened
 434         if (notif_error)
 435         {
 436                 notif.nent_enabled = false; // disable the notification so it can't cause trouble
 437                 notif_global_error = true; // throw the red flag that an error happened on init
 438         }
 439 }
 440
 441 #define AnnouncerFilename(snd) sprintf("announcer/%s/%s.wav", AnnouncerOption(), snd)
 442
 443 void Create_Notification_Entity_Annce(entity notif,
 444                                                                                 float var_cvar,
 445                                                                                 string namestring,
 446                                                                                 /* MSG_ANNCE */
 447                                                                                 float channel,
 448                                                                                 string snd,
 449                                                                                 float vol,
 450                                                                                 float position)
 451                 {
 452                         // Set MSG_ANNCE information and handle precaching
 453                         #ifdef CSQC
 454                         MSG typeId = MSG_ANNCE;
 455                         if (!(GENTLE && (var_cvar == 1)))
 456                         {
 457                                 if(snd != "")
 458                                 {
 459                                         if(notif.nent_enabled)
 460                                         {
 461                                                 precache_sound(AnnouncerFilename(snd));
 462                                                 notif.nent_channel = channel;
 463                                                 notif.nent_snd = strzone(snd);
 464                                                 notif.nent_vol = vol;
 465                                                 notif.nent_position = position;
 466                                         }
 467                                 }
 468                                 else
 469                                 {
 470                                         string typestring = Get_Notif_TypeName(typeId);
 471                                         LOG_INFOF(
 472                                                 (
 473                                                         "^1NOTIFICATION WITH NO SOUND: "
 474                                                         "^7net_type = %s, net_name = %s."
 475                                                 ),
 476                                                 typestring,
 477                                                 namestring
 478                                         );
 479                                         notif_error = true;
 480                                 }
 481                         }
 482                         else { notif.nent_enabled = false; }
 483                         #else
 484                         notif.nent_enabled = false;
 485                         #endif
 486
 487                 }
 488
 489 void Create_Notification_Entity_InfoCenter(entity notif,
 490                                                                                         float var_cvar,
 491                                                                                         string namestring,
 492                                                                                         int strnum,
 493                                                                                         int flnum,
 494                                                                                         /* MSG_INFO & MSG_CENTER */
 495                                                                                         string args,
 496                                                                                         string hudargs,
 497                                                                                         string icon,
 498                                                                                         CPID cpid,
 499                                                                                         string durcnt,
 500                                                                                         string normal,
 501                                                                                         string gentle)
 502                 {
 503                         MSG typeId = notif.nent_type;
 504                         // Set MSG_INFO and MSG_CENTER string/float counts
 505                         notif.nent_stringcount = strnum;
 506                         notif.nent_floatcount = flnum;
 507
 508                         // Only initialize arguments if we're either a client or on a dedicated server
 509                         #ifdef SVQC
 510                         float should_process_args = server_is_dedicated;
 511                         #else
 512                         float should_process_args = true;
 513                         #endif
 514                         string typestring = Get_Notif_TypeName(typeId);
 515                         if(should_process_args)
 516                         {
 517                                 // ========================
 518                                 //  Process Main Arguments
 519                                 // ========================
 520                                 if(strnum + flnum)
 521                                 {
 522                                         if(args != "")
 523                                         {
 524                                                 notif.nent_args = strzone(
 525                                                         Process_Notif_Args(1, args, typestring, namestring));
 526                                         }
 527                                         else if((hudargs == "") && (durcnt ==""))
 528                                         {
 529                                                 LOG_INFOF(
 530                                                         (
 531                                                                 "^1NOTIFICATION HAS ARG COUNTS BUT NO ARGS OR HUDARGS OR DURCNT: "
 532                                                                 "^7net_type = %s, net_name = %s, strnum = %d, flnum = %d"
 533                                                         ),
 534                                                         typestring,
 535                                                         namestring,
 536                                                         strnum,
 537                                                         flnum
 538                                                 );
 539                                                 notif_error = true;
 540                                         }
 541                                 }
 542                                 else if(args != "")
 543                                 {
 544                                         notif.nent_args = strzone(
 545                                                 Process_Notif_Args(1, args, typestring, namestring));
 546                                 }
 547
 548
 549                                 // =======================================
 550                                 //  Process HUD and Centerprint Arguments
 551                                 //    Only processed on CSQC, as these
 552                                 //    args are only for HUD features.
 553                                 // =======================================
 554                                 #ifdef CSQC
 555                                 if(hudargs != "")
 556                                 {
 557                                         notif.nent_hudargs = strzone(
 558                                                 Process_Notif_Args(2, hudargs, typestring, namestring));
 559
 560                                         if(icon != "") { notif.nent_icon = strzone(icon); }
 561                                         else
 562                                         {
 563                                                 LOG_INFOF(
 564                                                         (
 565                                                                 "^1NOTIFICATION HAS HUDARGS BUT NO ICON: "
 566                                                                 "^7net_type = %s, net_name = %s."
 567                                                         ),
 568                                                         typestring,
 569                                                         namestring
 570                                                 );
 571                                                 notif_error = true;
 572                                         }
 573                                 }
 574                                 else if(icon != "")
 575                                 {
 576                                         LOG_WARNF(
 577                                                 (
 578                                                         "^1NOTIFICATION HAS ICON BUT NO HUDARGS: "
 579                                                         "^7net_type = %s, net_name = %s.\n"
 580                                                 ),
 581                                                 typestring,
 582                                                 namestring
 583                                         );
 584                                         notif_error = true;
 585                                 }
 586
 587                                 if (durcnt != "")
 588                                 {
 589                                         notif.nent_durcnt = strzone(Process_Notif_Args(3, durcnt, typestring, namestring));
 590
 591                                         if (cpid == CPID_Null && durcnt != "0 0")
 592                                         {
 593                                                 LOG_WARNF(
 594                                                         (
 595                                                                 "Notification has durcnt but no cpid: "
 596                                                                 "net_type = %s, net_name = %s."
 597                                                         ),
 598                                                         typestring,
 599                                                         namestring
 600                                                 );
 601                                                 notif_error = true;
 602                                         }
 603                                 }
 604                                 notif.nent_cpid = cpid;
 605                                 #endif
 606
 607
 608                                 // ======================
 609                                 //  Process Notif String
 610                                 // ======================
 611                                 #define SET_NOTIF_STRING(string,stringname) MACRO_BEGIN \
 612                                         notif.nent_string = strzone(CCR( \
 613                                                 Process_Notif_Line( \
 614                                                         typeId, \
 615                                                         (var_cvar > 1), \
 616                                                         string, \
 617                                                         typestring, \
 618                                                         namestring, \
 619                                                         stringname \
 620                                                 )) \
 621                                         ); \
 622                                 MACRO_END
 623
 624                                 if(GENTLE)
 625                                 {
 626                                         if(gentle != "") { SET_NOTIF_STRING(gentle, "GENTLE"); }
 627                                         else if(normal != "") { SET_NOTIF_STRING(normal, "NORMAL"); }
 628                                 }
 629                                 else if(normal != "") { SET_NOTIF_STRING(normal, "NORMAL"); }
 630                                 #undef SET_NOTIF_STRING
 631
 632                                 // Check to make sure a string was chosen
 633                                 if(notif.nent_string == "")
 634                                 {
 635                                         LOG_INFOF(
 636                                                 (
 637                                                         "^1EMPTY NOTIFICATION: "
 638                                                         "^7net_type = %s, net_name = %s."
 639                                                 ),
 640                                                 typestring,
 641                                                 namestring
 642                                         );
 643                                         notif_error = true;
 644                                 }
 645                         }
 646                 }
 647
 648 void Create_Notification_Entity_Multi(entity notif,
 649                                                                                 float var_cvar,
 650                                                                                 string namestring,
 651                                                                                 /* MSG_MULTI */
 652                                                                                 Notification anncename,
 653                                                                                 Notification infoname,
 654                                                                                 Notification centername)
 655                 {
 656                         MSG typeId = MSG_MULTI;
 657                         // Set MSG_MULTI string/float counts
 658                         if (!anncename && !infoname && !centername)
 659                         {
 660                                 string typestring = Get_Notif_TypeName(typeId);
 661                                 LOG_INFOF(
 662                                         (
 663                                                 "^1NOTIFICATION WITH NO SUBCALLS: "
 664                                                 "^7net_type = %s, net_name = %s."
 665                                         ),
 666                                         typestring,
 667                                         namestring
 668                                 );
 669                                 notif_error = true;
 670                         }
 671                         else
 672                         {
 673                                 // announcements don't actually need any arguments, so lets not even count them.
 674                                 if (anncename) { notif.nent_msgannce = anncename; }
 675
 676                                 float infoname_stringcount = 0, infoname_floatcount = 0;
 677                                 float centername_stringcount = 0, centername_floatcount = 0;
 678
 679                                 if (infoname)
 680                                 {
 681                                         notif.nent_msginfo = infoname;
 682                                         infoname_stringcount = notif.nent_msginfo.nent_stringcount;
 683                                         infoname_floatcount = notif.nent_msginfo.nent_floatcount;
 684                                 }
 685
 686                                 if (centername)
 687                                 {
 688                                         notif.nent_msgcenter = centername;
 689                                         centername_stringcount = notif.nent_msgcenter.nent_stringcount;
 690                                         centername_floatcount = notif.nent_msgcenter.nent_floatcount;
 691                                 }
 692
 693                                 // set the requirements of THIS notification to the totals of its subcalls
 694                                 notif.nent_stringcount = max(infoname_stringcount, centername_stringcount);
 695                                 notif.nent_floatcount = max(infoname_floatcount, centername_floatcount);
 696                         }
 697                 }
 698
 699 void Create_Notification_Entity_Choice(entity notif,
 700                                                                                 float var_cvar,
 701                                                                                 string namestring,
 702                                                                                 /* MSG_CHOICE */
 703                                                                                 float challow_def,
 704                                                                                 float challow_var,
 705                                                                                 MSG chtype,
 706                                                                                 Notification optiona,
 707                                                                                 Notification optionb)
 708                 {
 709                         MSG typeId = MSG_CHOICE;
 710                         if (chtype == MSG_Null || !optiona || !optionb)
 711                         {
 712                                 string typestring = Get_Notif_TypeName(typeId);
 713                                 LOG_INFOF(
 714                                         (
 715                                                 "^1NOTIFICATION IS MISSING CHOICE PARAMS: "
 716                                                 "^7net_type = %s, net_name = %s."
 717                                         ),
 718                                         typestring,
 719                                         namestring
 720                                 );
 721                                 notif_error = true;
 722                         }
 723                         else
 724                         {
 725                                 notif.nent_optiona = optiona;
 726                                 notif.nent_optionb = optionb;
 727                                 notif.nent_challow_def = challow_def; // 0: never allowed, 1: allowed in warmup, 2: always allowed
 728                                 notif.nent_challow_var = challow_var; // 0: never allowed, 1: allowed in warmup, 2: always allowed
 729                                 notif.nent_stringcount = max(notif.nent_optiona.nent_stringcount, notif.nent_optionb.nent_stringcount);
 730                                 notif.nent_floatcount = max(notif.nent_optiona.nent_floatcount, notif.nent_optionb.nent_floatcount);
 731
 732                                 /*#ifdef NOTIFICATIONS_DEBUG
 733                                 Debug_Notification(sprintf(
 734                                         "Create_Notification_Entity(...): MSG_CHOICE: %s\n%s\n%s\n",
 735                                         notif.nent_name,
 736                                         sprintf(
 737                                                 "^ optiona: %s %s : %d %d",
 738                                                 Get_Notif_TypeName(notif.nent_optiona.nent_type),
 739                                                 notif.nent_optiona.nent_name,
 740                                                 notif.nent_optiona.nent_stringcount,
 741                                                 notif.nent_optiona.nent_floatcount
 742                                         ),
 743                                         sprintf(
 744                                                 "^ optionb: %s %s : %d %d",
 745                                                 Get_Notif_TypeName(notif.nent_optionb.nent_type),
 746                                                 notif.nent_optionb.nent_name,
 747                                                 notif.nent_optionb.nent_stringcount,
 748                                                 notif.nent_optionb.nent_floatcount
 749                                         )
 750                                 ));
 751                                 #endif*/
 752                         }
 753                 }
 754
 755
 756 // ===============
 757 //  Cvar Handling
 758 // ===============
 759
 760 // used by MSG_CHOICE to build list of choices
 761 #ifdef SVQC
 762 void Notification_GetCvars(entity this)
 763 {
 764         FOREACH(Notifications, it.nent_type == MSG_CHOICE, {
 765                 GetCvars_handleFloat(
 766                         this,
 767                         CS(this),
 768                         get_cvars_s,
 769                         get_cvars_f,
 770                         msg_choice_choices[it.nent_choice_idx],
 771                         sprintf("notification_%s", Get_Notif_CvarName(it))
 772                 );
 773         });
 774 }
 775 #endif
 776
 777 /** used to output notifications.cfg file */
 778 void Dump_Notifications(int fh, bool alsoprint)
 779 {
 780         #define NOTIF_WRITE(str) write_String_To_File(fh, str, alsoprint)
 781
 782         #define NOTIF_WRITE_ENTITY(e, description) \
 783                 NOTIF_WRITE(sprintf( \
 784                         "seta notification_%s \"%d\" \"%s\"\n", \
 785                         Get_Notif_CvarName(e), e.nent_default, description \
 786                 ))
 787
 788         #define NOTIF_WRITE_ENTITY_CHOICE(e, descriptiona, descriptionb) \
 789                 NOTIF_WRITE(sprintf( \
 790                         "seta notification_%s \"%d\" \"%s\"\n" \
 791                         "seta notification_%s_ALLOWED \"%d\" \"%s\"\n", \
 792                         Get_Notif_CvarName(e), e.nent_default, descriptiona, \
 793                         Get_Notif_CvarName(e), e.nent_challow_def, descriptionb \
 794                 ))
 795
 796         #define NOTIF_WRITE_HARDCODED(cvar, default, description) \
 797                 NOTIF_WRITE(sprintf( \
 798                         "seta notification_%s \"%s\" \"%s\"\n", \
 799                         cvar, default, description \
 800                 ))
 801
 802         // Note: This warning only applies to the notifications.cfg file that is output...
 803         // You ARE supposed to manually edit this function to add i.e. hard coded
 804         // notification variables for mutators or game modes or such and then
 805         // regenerate the notifications.cfg file from the new code.
 806
 807         NOTIF_WRITE("// ********************************************** //\n");
 808         NOTIF_WRITE("// ** WARNING - DO NOT MANUALLY EDIT THIS FILE ** //\n");
 809         NOTIF_WRITE("// **                                          ** //\n");
 810         NOTIF_WRITE("// **  This file is automatically generated    ** //\n");
 811         NOTIF_WRITE("// **  by code with the command 'dumpnotifs'.  ** //\n");
 812         NOTIF_WRITE("// **                                          ** //\n");
 813         NOTIF_WRITE("// **  If you add a new notification, please   ** //\n");
 814         NOTIF_WRITE("// **  regenerate this file with that command  ** //\n");
 815         NOTIF_WRITE("// **  making sure that the output matches     ** //\n");
 816         NOTIF_WRITE("// **  with the lists and defaults in code.    ** //\n");
 817         NOTIF_WRITE("// **                                          ** //\n");
 818         NOTIF_WRITE("// ********************************************** //\n");
 819
 820         // These notifications will also append their string as a comment...
 821         // This is not necessary, and does not matter if they vary between config versions,
 822         // it is just a semi-helpful tool for those who want to manually change their user settings.
 823
 824         int NOTIF_ANNCE_COUNT = 0; FOREACH(Notifications, it.nent_type == MSG_ANNCE, { ++NOTIF_ANNCE_COUNT; });
 825         NOTIF_WRITE(sprintf("\n// MSG_ANNCE notifications (count = %d):\n", NOTIF_ANNCE_COUNT));
 826         FOREACH(Notifications, it.nent_type == MSG_ANNCE && (!it.nent_teamnum || it.nent_teamnum == NUM_TEAM_1), {
 827                 NOTIF_WRITE_ENTITY(it,
 828                         "0 = disabled, 1 = enabled if gentle mode is off, 2 = always enabled"
 829                 );
 830         });
 831
 832         int NOTIF_INFO_COUNT = 0; FOREACH(Notifications, it.nent_type == MSG_INFO, { ++NOTIF_INFO_COUNT; });
 833         NOTIF_WRITE(sprintf("\n// MSG_INFO notifications (count = %d):\n", NOTIF_INFO_COUNT));
 834         FOREACH(Notifications, it.nent_type == MSG_INFO && (!it.nent_teamnum || it.nent_teamnum == NUM_TEAM_1), {
 835                 NOTIF_WRITE_ENTITY(it,
 836                         "0 = off, 1 = print to console, "
 837                         "2 = print to console and chatbox (if notification_allow_chatboxprint is enabled)"
 838                 );
 839         });
 840
 841         int NOTIF_CENTER_COUNT = 0; FOREACH(Notifications, it.nent_type == MSG_CENTER, { ++NOTIF_CENTER_COUNT; });
 842         NOTIF_WRITE(sprintf("\n// MSG_CENTER notifications (count = %d):\n", NOTIF_CENTER_COUNT));
 843         FOREACH(Notifications, it.nent_type == MSG_CENTER && (!it.nent_teamnum || it.nent_teamnum == NUM_TEAM_1), {
 844                 NOTIF_WRITE_ENTITY(it,
 845                         "0 = off, 1 = centerprint"
 846                 );
 847         });
 848
 849         int NOTIF_MULTI_COUNT = 0; FOREACH(Notifications, it.nent_type == MSG_MULTI, { ++NOTIF_MULTI_COUNT; });
 850         NOTIF_WRITE(sprintf("\n// MSG_MULTI notifications (count = %d):\n", NOTIF_MULTI_COUNT));
 851         FOREACH(Notifications, it.nent_type == MSG_MULTI && (!it.nent_teamnum || it.nent_teamnum == NUM_TEAM_1), {
 852                 NOTIF_WRITE_ENTITY(it,
 853                         "Enable this multiple notification"
 854                 );
 855         });
 856
 857         int NOTIF_CHOICE_COUNT = 0; FOREACH(Notifications, it.nent_type == MSG_CHOICE, { ++NOTIF_CHOICE_COUNT; });
 858         NOTIF_WRITE(sprintf("\n// MSG_CHOICE notifications (count = %d):\n", NOTIF_CHOICE_COUNT));
 859         FOREACH(Notifications, it.nent_type == MSG_CHOICE && (!it.nent_teamnum || it.nent_teamnum == NUM_TEAM_1), {
 860                 NOTIF_WRITE_ENTITY_CHOICE(it,
 861                         "Choice for this notification 0 = off, 1 = default message, 2 = verbose message",
 862                         "Allow choice for this notification 0 = off, 1 = only in warmup mode, 2 = always"
 863                 );
 864         });
 865
 866         // edit these to match whichever cvars are used for specific notification options
 867         NOTIF_WRITE("\n// HARD CODED notification variables:\n");
 868
 869         NOTIF_WRITE_HARDCODED(
 870                 "allow_chatboxprint", "1",
 871                 "Allow INFO notifications to be printed to chat box "
 872                 "0 = do not allow, "
 873                 "1 = allow only if allowed by individual notification_INFO* cvars, "
 874                 "2 = force all INFO notifications to be printed to the chatbox"
 875         );
 876
 877         NOTIF_WRITE_HARDCODED(
 878                 "debug", "0",
 879                 "Print extra debug information on all notification function calls "
 880                 "(Requires -DNOTIFICATIONS_DEBUG flag to be enabled on QCSRC compilation)... "
 881                 "0 = disabled, 1 = dprint, 2 = print"
 882         );
 883
 884         NOTIF_WRITE_HARDCODED(
 885                 "errors_are_fatal", "1",
 886                 "If a notification fails upon initialization, cause a Host_Error to stop the program"
 887         );
 888
 889         NOTIF_WRITE_HARDCODED(
 890                 "item_centerprinttime", "1.5",
 891                 "How long to show item information centerprint messages (like 'You got the Electro' or such)"
 892         );
 893
 894         NOTIF_WRITE_HARDCODED(
 895                 "lifetime_mapload", "10",
 896                 "Amount of time that notification entities last immediately at mapload (in seconds) "
 897                 "to help prevent notifications from being lost on early init (like gamestart countdown)"
 898         );
 899
 900         NOTIF_WRITE_HARDCODED(
 901                 "lifetime_runtime", "0.5",
 902                 "Amount of time that notification entities last on the server during runtime (In seconds)"
 903         );
 904
 905         NOTIF_WRITE_HARDCODED(
 906                 "server_allows_location", "1",
 907                 "Server side cvar for allowing death messages to show location information too"
 908         );
 909
 910         NOTIF_WRITE_HARDCODED(
 911                 "show_location", "0",
 912                 "Append location information to MSG_INFO death/kill messages"
 913         );
 914
 915         NOTIF_WRITE_HARDCODED(
 916                 "show_location_string", "",
 917                 "Replacement string piped into sprintf, "
 918                 "so you can do different messages like this: ' at the %s' or ' (near %s)'"
 919         );
 920
 921         NOTIF_WRITE_HARDCODED(
 922                 "show_sprees", "1",
 923                 "Print information about sprees in death/kill messages"
 924         );
 925
 926         NOTIF_WRITE_HARDCODED(
 927                 "show_sprees_center", "1",
 928                 "Show spree information in MSG_CENTER messages... "
 929                 "0 = off, 1 = target (but only for first victim) and attacker"
 930         );
 931
 932         NOTIF_WRITE_HARDCODED(
 933                 "show_sprees_center_specialonly", "1",
 934                 "Don't show spree information in MSG_CENTER messages if it isn't an achievement"
 935         );
 936
 937         NOTIF_WRITE_HARDCODED(
 938                 "show_sprees_info", "3",
 939                 "Show spree information in MSG_INFO messages... "
 940                 "0 = off, 1 = target only, 2 = attacker only, 3 = target and attacker"
 941         );
 942
 943         NOTIF_WRITE_HARDCODED(
 944                 "show_sprees_info_newline", "1",
 945                 "Show attacker spree information for MSG_INFO messages on a separate line than the death notification itself"
 946         );
 947
 948         NOTIF_WRITE_HARDCODED(
 949                 "show_sprees_info_specialonly", "1",
 950                 "Don't show attacker spree information in MSG_INFO messages if it isn't an achievement"
 951         );
 952
 953         NOTIF_WRITE(sprintf(
 954                 (
 955                         "\n// Notification counts (total = %d): "
 956                         "MSG_ANNCE = %d, MSG_INFO = %d, MSG_CENTER = %d, MSG_MULTI = %d, MSG_CHOICE = %d\n"
 957                 ),
 958                 (
 959                         NOTIF_ANNCE_COUNT +
 960                         NOTIF_INFO_COUNT +
 961                         NOTIF_CENTER_COUNT +
 962                         NOTIF_MULTI_COUNT +
 963                         NOTIF_CHOICE_COUNT
 964                 ),
 965                 NOTIF_ANNCE_COUNT,
 966                 NOTIF_INFO_COUNT,
 967                 NOTIF_CENTER_COUNT,
 968                 NOTIF_MULTI_COUNT,
 969                 NOTIF_CHOICE_COUNT
 970         ));
 971         #undef NOTIF_WRITE_HARDCODED
 972         #undef NOTIF_WRITE_ENTITY
 973         #undef NOTIF_WRITE
 974 }
 975
 976
 977 // ===============================
 978 //  Frontend Notification Pushing
 979 // ===============================
 980
 981 string Local_Notification_sprintf(
 982         string input, string args,
 983         string s1, string s2, string s3, string s4,
 984         int f1, float f2, float f3, float f4)
 985 {
 986         #ifdef NOTIFICATIONS_DEBUG
 987         Debug_Notification(sprintf(
 988                 "Local_Notification_sprintf('%s^7', '%s', %s, %s);\n",
 989                 MakeConsoleSafe(input),
 990                 args,
 991                 MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
 992                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
 993         ));
 994         #endif
 995
 996         for (int sel_num = 0; sel_num < NOTIF_MAX_ARGS; ++sel_num) { arg_slot[sel_num] = ""; }
 997
 998         for (int sel_num = 0; (args != ""); )
 999         {
1000                 string selected = car(args); args = cdr(args);
1001                 NOTIF_HIT_MAX(NOTIF_MAX_ARGS, "Local_Notification_sprintf");
1002                 string tmp_s; // used by NOTIF_ARGUMENT_LIST
1003                 switch (strtolower(selected))
1004                 {
1005                         #define ARG_CASE_ARG_CS_SV_HA(selected, result) case selected: arg_slot[sel_num++] = result; break;
1006                         #define ARG_CASE_ARG_CS_SV_DC(selected, result) case selected: arg_slot[sel_num++] = result; break;
1007                         #define ARG_CASE_ARG_CS_SV(selected, result)    case selected: arg_slot[sel_num++] = result; break;
1008 #ifdef CSQC
1009                         #define ARG_CASE_ARG_CS(selected, result)       case selected: arg_slot[sel_num++] = result; break;
1010                         #define ARG_CASE_ARG_SV(selected, result)
1011 #else
1012                         #define ARG_CASE_ARG_CS(selected, result)
1013                         #define ARG_CASE_ARG_SV(selected, result)       case selected: arg_slot[sel_num++] = result; break;
1014 #endif
1015                         #define ARG_CASE_ARG_DC(selected, result)
1016                         #define ARG_CASE(prog, selected, result)        ARG_CASE_##prog(selected, result)
1017                         NOTIF_ARGUMENT_LIST
1018                         #undef ARG_CASE
1019                         #undef ARG_CASE_ARG_DC
1020                         #undef ARG_CASE_ARG_SV
1021                         #undef ARG_CASE_ARG_CS
1022                         #undef ARG_CASE_ARG_CS_SV
1023                         #undef ARG_CASE_ARG_CS_SV_DC
1024                         #undef ARG_CASE_ARG_CS_SV_HA
1025                         default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_ARGS, "Local_Notification_sprintf")
1026                 }
1027         }
1028         return sprintf(
1029                 strcat(input, "\n"),
1030                 arg_slot[0],
1031                 arg_slot[1],
1032                 arg_slot[2],
1033                 arg_slot[3],
1034                 arg_slot[4],
1035                 arg_slot[5],
1036                 arg_slot[6]
1037         );
1038 }
1039
1040 #ifdef CSQC
1041 void Local_Notification_sound(int soundchannel, string soundfile, float soundvolume, float soundposition)
1042 {
1043         if ((soundfile != prev_soundfile) || (time >= (prev_soundtime + autocvar_cl_announcer_antispam)))
1044         {
1045                 #ifdef NOTIFICATIONS_DEBUG
1046                 Debug_Notification(sprintf(
1047                         "Local_Notification_sound(%f, '%s', %f, %f);\n",
1048                         soundchannel,
1049                         AnnouncerFilename(soundfile),
1050                         soundvolume,
1051                         soundposition
1052                 ));
1053                 #endif
1054
1055                 _sound(NULL, soundchannel, AnnouncerFilename(soundfile), soundvolume, soundposition);
1056
1057                 strcpy(prev_soundfile, soundfile);
1058                 prev_soundtime = time;
1059         }
1060         else
1061         {
1062                 #ifdef NOTIFICATIONS_DEBUG
1063                 Debug_Notification(sprintf(
1064                         (
1065                                 "Local_Notification_sound(%f, '%s', %f, %f) "
1066                                 "^1BLOCKED BY ANTISPAM:^7 prevsnd: '%s', timediff: %f, limit: %f\n"
1067                         ),
1068                         soundchannel,
1069                         AnnouncerFilename(soundfile),
1070                         soundvolume,
1071                         soundposition,
1072                         prev_soundfile,
1073                         (time - prev_soundtime),
1074                         autocvar_cl_announcer_antispam
1075                 ));
1076                 #endif
1077         }
1078 }
1079
1080 void Local_Notification_HUD_Notify_Push(
1081         string icon, string hudargs,
1082         string s1, string s2, string s3, string s4,
1083         float f1, float f2, float f3, float f4)
1084 {
1085         arg_slot[0] = ""; arg_slot[1] = "";
1086
1087         for (int sel_num = 0; (hudargs != ""); )
1088         {
1089                 string selected = car(hudargs); hudargs = cdr(hudargs);
1090                 NOTIF_HIT_MAX(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push");
1091                 switch (strtolower(selected))
1092                 {
1093                         #define ARG_CASE_ARG_CS_SV_HA(selected, result) case selected: arg_slot[sel_num++] = result; break;
1094                         #define ARG_CASE_ARG_CS_SV_DC(selected, result)
1095                         #define ARG_CASE_ARG_CS_SV(selected, result)
1096                         #define ARG_CASE_ARG_CS(selected, result)
1097                         #define ARG_CASE_ARG_SV(selected, result)
1098                         #define ARG_CASE_ARG_DC(selected, result)
1099                         #define ARG_CASE(prog, selected, result)        ARG_CASE_##prog(selected, result)
1100                         NOTIF_ARGUMENT_LIST
1101                         #undef ARG_CASE
1102                         #undef ARG_CASE_ARG_DC
1103                         #undef ARG_CASE_ARG_SV
1104                         #undef ARG_CASE_ARG_CS
1105                         #undef ARG_CASE_ARG_CS_SV
1106                         #undef ARG_CASE_ARG_CS_SV_DC
1107                         #undef ARG_CASE_ARG_CS_SV_HA
1108                         default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push")
1109                 }
1110         }
1111         #ifdef NOTIFICATIONS_DEBUG
1112         Debug_Notification(sprintf(
1113                 "Local_Notification_HUD_Notify_Push('%s^7', '%s', %s, %s, %s);\n",
1114                 icon,
1115                 hudargs,
1116                 MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1117                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4),
1118                 MakeConsoleSafe(sprintf("'%s^7', '%s^7'", stof(arg_slot[0]), stof(arg_slot[1])))
1119         ));
1120         #endif
1121         HUD_Notify_Push(icon, arg_slot[0], arg_slot[1]);
1122 }
1123
1124 void Local_Notification_centerprint_generic(
1125         string input, string durcnt,
1126         CPID cpid, float f1, float f2)
1127 {
1128         arg_slot[0] = ""; arg_slot[1] = "";
1129
1130         for (int sel_num = 0; (durcnt != ""); )
1131         {
1132                 string selected = car(durcnt); durcnt = cdr(durcnt);
1133                 NOTIF_HIT_MAX(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic");
1134                 switch (strtolower(selected))
1135                 {
1136                         #define ARG_CASE_ARG_CS_SV_HA(selected, result)
1137                         #define ARG_CASE_ARG_CS_SV_DC(selected, result) case selected: arg_slot[sel_num++] = result; break;
1138                         #define ARG_CASE_ARG_CS_SV(selected, result)
1139                         #define ARG_CASE_ARG_CS(selected, result)
1140                         #define ARG_CASE_ARG_SV(selected, result)
1141                         #define ARG_CASE_ARG_DC(selected, result)       case selected: arg_slot[sel_num++] = result; break;
1142                         #define ARG_CASE(prog, selected, result)        ARG_CASE_##prog(selected,result)
1143                         NOTIF_ARGUMENT_LIST
1144                         #undef ARG_CASE
1145                         #undef ARG_CASE_ARG_DC
1146                         #undef ARG_CASE_ARG_SV
1147                         #undef ARG_CASE_ARG_CS
1148                         #undef ARG_CASE_ARG_CS_SV
1149                         #undef ARG_CASE_ARG_CS_SV_DC
1150                         #undef ARG_CASE_ARG_CS_SV_HA
1151                         default:
1152                         {
1153                                 if (/* wtf */ ftos(stof(selected)) != "") { arg_slot[sel_num++] = selected; }
1154                                 else { NOTIF_HIT_UNKNOWN(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic") }
1155                                 break;
1156                         }
1157                 }
1158         }
1159         #ifdef NOTIFICATIONS_DEBUG
1160         Debug_Notification(sprintf(
1161                 "Local_Notification_centerprint_generic('%s^7', '%s', %d, %d, %d, %d);\n",
1162                 MakeConsoleSafe(input),
1163                 durcnt,
1164                 f1, f2,
1165                 stof(arg_slot[0]),
1166                 stof(arg_slot[1])
1167         ));
1168         #endif
1169         centerprint_generic(ORDINAL(cpid), input, stof(arg_slot[0]), stof(arg_slot[1]));
1170 }
1171 #endif
1172
1173 void Local_Notification(MSG net_type, Notification net_name, ...count)
1174 {
1175         // retreive entity of this notification
1176         entity notif = net_name;
1177         if (!notif)
1178         {
1179                 #ifdef NOTIFICATIONS_DEBUG
1180                 Debug_Notification(sprintf(
1181                         "Local_Notification(%s, NULL, ...);\n",
1182                         Get_Notif_TypeName(net_type)
1183                 ));
1184                 #endif
1185                 LOG_WARNF("Incorrect usage of Local_Notification: %s", "Null notification");
1186                 return;
1187         }
1188
1189         // check if the notification is enabled
1190         if (!notif.nent_enabled)
1191         {
1192                 #ifdef NOTIFICATIONS_DEBUG
1193                 Debug_Notification(sprintf(
1194                         "Local_Notification(%s, %s, ...): Entity was disabled...\n",
1195                         Get_Notif_TypeName(net_type),
1196                         notif.nent_name
1197                 ));
1198                 #endif
1199                 return;
1200         }
1201
1202         string s1 = CCR((notif.nent_stringcount > 0) ? ...(0, string) : "");
1203         string s2 = CCR((notif.nent_stringcount > 1) ? ...(1, string) : "");
1204         string s3 = CCR((notif.nent_stringcount > 2) ? ...(2, string) : "");
1205         string s4 = CCR((notif.nent_stringcount > 3) ? ...(3, string) : "");
1206         float f1 =  ((notif.nent_floatcount  > 0) ? ...((notif.nent_stringcount + 0), float) : 0);
1207         float f2 =  ((notif.nent_floatcount  > 1) ? ...((notif.nent_stringcount + 1), float) : 0);
1208         float f3 =  ((notif.nent_floatcount  > 2) ? ...((notif.nent_stringcount + 2), float) : 0);
1209         float f4 =  ((notif.nent_floatcount  > 3) ? ...((notif.nent_stringcount + 3), float) : 0);
1210
1211         #ifdef NOTIFICATIONS_DEBUG
1212         Debug_Notification(sprintf(
1213                 "Local_Notification(%s, %s, %s, %s);\n",
1214                 Get_Notif_TypeName(net_type),
1215                 notif.nent_name,
1216                 MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1217                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
1218         ));
1219         #endif
1220
1221         if ((notif.nent_stringcount + notif.nent_floatcount) != count)
1222         {
1223                 backtrace(sprintf(
1224                         (
1225                                 "Arguments mismatch for Local_Notification(%s, %s, ...)! "
1226                                 "stringcount(%d) + floatcount(%d) != count(%d)\n"
1227                                 "Check the definition and function call for accuracy...?\n"
1228                         ),
1229                         Get_Notif_TypeName(net_type),
1230                         notif.nent_name,
1231                         notif.nent_stringcount,
1232                         notif.nent_floatcount,
1233                         count
1234                 ));
1235                 return;
1236         }
1237
1238         switch (net_type)
1239         {
1240                 case MSG_ANNCE:
1241                 {
1242                         #ifdef CSQC
1243                         Local_Notification_sound(notif.nent_channel, notif.nent_snd, notif.nent_vol, notif.nent_position);
1244                         #else
1245                         backtrace("MSG_ANNCE on server?... Please notify Samual immediately!\n");
1246                         #endif
1247                         break;
1248                 }
1249
1250                 case MSG_INFO:
1251                 {
1252                         print(
1253                                 Local_Notification_sprintf(
1254                                         notif.nent_string,
1255                                         notif.nent_args,
1256                                         s1, s2, s3, s4,
1257                                         f1, f2, f3, f4)
1258                         );
1259                         #ifdef CSQC
1260                         if (notif.nent_icon != "")
1261                         {
1262                                 if (notif.nent_iconargs != "")
1263                                 {
1264                                         string s = Local_Notification_sprintf(
1265                                                 notif.nent_icon,notif.nent_iconargs,
1266                                                 s1, s2, s3, s4, f1, f2, f3, f4);
1267                                         // remove the trailing newline
1268                                         notif.nent_icon = strzone(substring(s, 0, -1));
1269                                 }
1270                                 Local_Notification_HUD_Notify_Push(
1271                                         notif.nent_icon,
1272                                         notif.nent_hudargs,
1273                                         s1, s2, s3, s4,
1274                                         f1, f2, f3, f4);
1275                         }
1276                         #endif
1277                         break;
1278                 }
1279
1280                 #ifdef CSQC
1281                 case MSG_CENTER:
1282                 {
1283                         Local_Notification_centerprint_generic(
1284                                 Local_Notification_sprintf(
1285                                         notif.nent_string,
1286                                         notif.nent_args,
1287                                         s1, s2, s3, s4,
1288                                         f1, f2, f3, f4),
1289                                 notif.nent_durcnt,
1290                                 notif.nent_cpid,
1291                                 f1, f2);
1292                         break;
1293                 }
1294                 #endif
1295
1296                 case MSG_MULTI:
1297                 {
1298                         if (notif.nent_msginfo && notif.nent_msginfo.nent_enabled)
1299                         {
1300                                 Local_Notification_WOVA(
1301                                         MSG_INFO,
1302                                         notif.nent_msginfo,
1303                                         notif.nent_msginfo.nent_stringcount,
1304                                         notif.nent_msginfo.nent_floatcount,
1305                                         s1, s2, s3, s4,
1306                                         f1, f2, f3, f4);
1307                         }
1308                         #ifdef CSQC
1309                         if (notif.nent_msgannce && notif.nent_msgannce.nent_enabled)
1310                         {
1311                                 Local_Notification_WOVA(
1312                                         MSG_ANNCE,
1313                                         notif.nent_msgannce,
1314                                         0, 0,
1315                                         "", "", "", "",
1316                                         0, 0, 0, 0);
1317                         }
1318                         if (notif.nent_msgcenter && notif.nent_msgcenter.nent_enabled)
1319                         {
1320                                 Local_Notification_WOVA(
1321                                         MSG_CENTER,
1322                                         notif.nent_msgcenter,
1323                                         notif.nent_msgcenter.nent_stringcount,
1324                                         notif.nent_msgcenter.nent_floatcount,
1325                                         s1, s2, s3, s4,
1326                                         f1, f2, f3, f4);
1327                         }
1328                         #endif
1329                         break;
1330                 }
1331
1332                 case MSG_CHOICE:
1333                 {
1334                         entity found_choice = notif.nent_optiona;
1335                         if (notif.nent_challow_var && (warmup_stage || (notif.nent_challow_var == 2))) {
1336                                 switch (cvar(sprintf("notification_%s", Get_Notif_CvarName(notif))))
1337                                 {
1338                                         case 1: break;
1339                                         case 2: found_choice = notif.nent_optionb; break;
1340                                         default: return; // not enabled anyway
1341                                 }
1342                         }
1343
1344                         Local_Notification_WOVA(
1345                                 found_choice.nent_type,
1346                                 found_choice,
1347                                 found_choice.nent_stringcount,
1348                                 found_choice.nent_floatcount,
1349                                 s1, s2, s3, s4,
1350                                 f1, f2, f3, f4);
1351                 }
1352         }
1353 }
1354
1355 // WOVA = Without Variable Arguments
1356 void Local_Notification_WOVA(
1357         MSG net_type, Notification net_name,
1358         float stringcount, float floatcount,
1359         string s1, string s2, string s3, string s4,
1360         float f1, float f2, float f3, float f4)
1361 {
1362         #define VARITEM(stringc, floatc, args) \
1363                 if ((stringcount == stringc) && (floatcount == floatc)) \
1364                 { Local_Notification(net_type, net_name, args); return; }
1365         EIGHT_VARS_TO_VARARGS_VARLIST
1366         #undef VARITEM
1367         Local_Notification(net_type, net_name); // some notifications don't have any arguments at all
1368 }
1369
1370
1371 // =========================
1372 //  Notification Networking
1373 // =========================
1374
1375 /** networked as a linked entity to give newly connecting clients some notification context */
1376 REGISTER_NET_LINKED(ENT_CLIENT_NOTIFICATION)
1377
1378 #ifdef CSQC
1379 NET_HANDLE(ENT_CLIENT_NOTIFICATION, bool is_new)
1380 {
1381         make_pure(this);
1382         MSG net_type = ENUMCAST(MSG, ReadByte());
1383         int net_name = ReadShort();
1384     return = true;
1385
1386         if (net_type == MSG_CENTER_KILL)
1387     {
1388         if (!is_new) return;
1389         // killing
1390         #ifdef NOTIFICATIONS_DEBUG
1391         Debug_Notification(sprintf(
1392             "Read_Notification(%d) at %f: net_type = %s, cpid = %d\n",
1393             is_new,
1394             time,
1395             Get_Notif_TypeName(net_type),
1396             net_name
1397         ));
1398         #endif
1399         int _net_name = net_name;
1400         CPID net_name = ENUMCAST(CPID, _net_name);
1401         if (net_name == CPID_Null) {
1402             // kill all
1403             reset_centerprint_messages();
1404         } else {
1405             // kill group
1406             centerprint_generic(ORDINAL(net_name), "", 0, 0);
1407         }
1408         return;
1409     }
1410
1411         Notification notif = Get_Notif_Ent(net_type, net_name);
1412
1413         #ifdef NOTIFICATIONS_DEBUG
1414         Debug_Notification(sprintf(
1415                 "Read_Notification(%d) at %f: net_type = %s, net_name = %s (%d)\n",
1416                 is_new,
1417                 time,
1418                 Get_Notif_TypeName(net_type),
1419                 notif.registered_id,
1420                 net_name
1421         ));
1422         #endif
1423
1424     if (!notif) {
1425         backtrace("Read_Notification: Could not find notification entity!\n");
1426         return false;
1427     }
1428
1429     string s1 = ((notif.nent_stringcount > 0) ? ReadString() : "");
1430     string s2 = ((notif.nent_stringcount > 1) ? ReadString() : "");
1431     string s3 = ((notif.nent_stringcount > 2) ? ReadString() : "");
1432     string s4 = ((notif.nent_stringcount > 3) ? ReadString() : "");
1433     float f1 = ((notif.nent_floatcount > 0) ? ReadLong() : 0);
1434     float f2 = ((notif.nent_floatcount > 1) ? ReadLong() : 0);
1435     float f3 = ((notif.nent_floatcount > 2) ? ReadLong() : 0);
1436     float f4 = ((notif.nent_floatcount > 3) ? ReadLong() : 0);
1437
1438     if (!is_new) return;
1439     Local_Notification_WOVA(
1440         net_type, notif,
1441         notif.nent_stringcount,
1442         notif.nent_floatcount,
1443         s1, s2, s3, s4,
1444         f1, f2, f3, f4);
1445 }
1446 #endif
1447
1448 #ifdef SVQC
1449 void Net_Notification_Remove(entity this)
1450 {
1451         #ifdef NOTIFICATIONS_DEBUG
1452         Debug_Notification(sprintf(
1453                 "Net_Notification_Remove() at %f: %s '%s - %s' notification\n",
1454                 time,
1455                 ((this.nent_net_name == -1) ? "Killed" : "Removed"),
1456                 Get_Notif_TypeName(this.nent_net_type),
1457                 this.owner.nent_name
1458         ));
1459         #endif
1460         for (int i = 0; i < this.nent_stringcount; ++i) { strfree(this.nent_strings[i]); }
1461         delete(this);
1462 }
1463
1464 bool Net_Write_Notification(entity this, entity client, int sf)
1465 {
1466         if (!Notification_ShouldSend(this.nent_broadcast, client, this.nent_client)) return false;
1467         WriteHeader(MSG_ENTITY, ENT_CLIENT_NOTIFICATION);
1468         WriteByte(MSG_ENTITY, ORDINAL(this.nent_net_type));
1469         WriteShort(MSG_ENTITY, this.nent_net_name);
1470         for (int i = 0; i < this.nent_stringcount; ++i) { WriteString(MSG_ENTITY, this.nent_strings[i]); }
1471         for (int i = 0; i < this.nent_floatcount; ++i) { WriteLong(MSG_ENTITY, this.nent_floats[i]); }
1472         return true;
1473 }
1474
1475 void Kill_Notification(
1476         NOTIF broadcast, entity client,
1477         /** message group, MSG_Null for all */
1478         MSG net_type,
1479         /** cpid group, CPID_Null for all */
1480         CPID net_cpid)
1481 {
1482         #ifdef NOTIFICATIONS_DEBUG
1483         Debug_Notification(sprintf(
1484                 "Kill_Notification(%s, '%s', %s, %d);\n",
1485                 Get_Notif_BroadcastName(broadcast),
1486                 client.netname,
1487                 (net_type ? Get_Notif_TypeName(net_type) : "0"),
1488                 net_cpid
1489         ));
1490         #endif
1491
1492         string checkargs = Notification_CheckArgs(broadcast, client);
1493         if (checkargs != "") { LOG_WARNF("Incorrect usage of Kill_Notification: %s", checkargs); return; }
1494
1495         entity net_notif = new_pure(net_kill_notification);
1496         net_notif.nent_broadcast = broadcast;
1497         net_notif.nent_client = client;
1498         net_notif.nent_net_type = MSG_CENTER_KILL;
1499         net_notif.nent_net_name = ORDINAL(net_cpid);
1500         Net_LinkEntity(net_notif, false, autocvar_notification_lifetime_runtime, Net_Write_Notification);
1501
1502         IL_EACH(g_notifications,
1503                 (it.owner.nent_type == net_type || net_type == MSG_Null) && (it.owner.nent_cpid == net_cpid || net_cpid == CPID_Null),
1504                 {
1505                         it.nent_net_name = -1;
1506                         it.nextthink = time;
1507                 }
1508         );
1509 }
1510
1511 void Send_Notification(
1512         NOTIF broadcast, entity client,
1513         MSG net_type, Notification net_name,
1514         ...count)
1515 {
1516     if (broadcast != NOTIF_ALL && broadcast != NOTIF_ALL_EXCEPT && !IS_REAL_CLIENT(client)) return;
1517         entity notif = net_name;
1518         string parms = sprintf("%s, '%s', %s, %s",
1519                 Get_Notif_BroadcastName(broadcast),
1520                 client.classname,
1521                 Get_Notif_TypeName(net_type),
1522                 net_name.registered_id
1523         );
1524         #ifdef NOTIFICATIONS_DEBUG
1525         Debug_Notification(sprintf("Send_Notification(%s, ...%d);\n", parms, count));
1526         #endif
1527
1528         if (!notif)
1529         {
1530                 LOG_WARN("Send_Notification: Could not find notification entity!");
1531                 return;
1532         }
1533
1534         // check supplied broadcast, target, type, and name for errors
1535         string checkargs = Notification_CheckArgs(broadcast, client);
1536     if (!net_name) { checkargs = sprintf("No notification provided! %s", checkargs); }
1537         if (checkargs != "")
1538         {
1539                 LOG_WARNF("Incorrect usage of Send_Notification: %s", checkargs);
1540                 return;
1541         }
1542
1543         string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : "");
1544         string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : "");
1545         string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : "");
1546         string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : "");
1547         float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0);
1548         float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0);
1549         float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0);
1550         float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0);
1551
1552         #ifdef NOTIFICATIONS_DEBUG
1553         Debug_Notification(sprintf(
1554                 "Send_Notification(%s, %s, %s);\n",
1555                 parms,
1556                 MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1557                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
1558         ));
1559         #endif
1560
1561         if ((notif.nent_stringcount + notif.nent_floatcount) != count)
1562         {
1563                 LOG_WARNF(
1564                         "Argument mismatch for Send_Notification(%s, ...)! "
1565                         "stringcount(%d) + floatcount(%d) != count(%d)\n"
1566                         "Check the definition and function call for accuracy...?\n",
1567                         parms,
1568                         notif.nent_stringcount,
1569                         notif.nent_floatcount,
1570                         count
1571                 );
1572                 return;
1573         }
1574
1575         if (server_is_dedicated
1576                 && (broadcast == NOTIF_ALL || broadcast == NOTIF_ALL_EXCEPT)
1577                 && !(net_type == MSG_ANNCE || net_type == MSG_CENTER)
1578         )
1579         {
1580                 Local_Notification_WOVA(
1581                         net_type, net_name,
1582                         notif.nent_stringcount,
1583                         notif.nent_floatcount,
1584                         s1, s2, s3, s4,
1585                         f1, f2, f3, f4);
1586         }
1587
1588         if (net_type == MSG_CHOICE)
1589         {
1590                 // THIS GETS TRICKY... now we have to cycle through each possible player (checking broadcast)
1591                 // and then do an individual NOTIF_ONE_ONLY recursive call for each one depending on their option...
1592                 // It's slow, but it's better than the alternatives:
1593                 //   1. Constantly networking all info and letting client decide
1594                 //   2. Manually handling each separate call on per-usage basis (See old CTF usage of verbose)
1595                 entity found_choice;
1596
1597                 #define RECURSE_FROM_CHOICE(ent,action) MACRO_BEGIN \
1598                         if (notif.nent_challow_var && (warmup_stage || (notif.nent_challow_var == 2))) { \
1599                                 switch (CS(ent).msg_choice_choices[net_name.nent_choice_idx]) \
1600                                 { \
1601                                         case 1: found_choice = notif.nent_optiona; break; \
1602                                         case 2: found_choice = notif.nent_optionb; break; \
1603                                         default: action; \
1604                                 } \
1605                         } else { \
1606                                 found_choice = notif.nent_optiona; \
1607                         } \
1608                         Send_Notification_WOVA( \
1609                                 NOTIF_ONE_ONLY, \
1610                                 ent, \
1611                                 found_choice.nent_type, \
1612                                 found_choice, \
1613                                 found_choice.nent_stringcount, \
1614                                 found_choice.nent_floatcount, \
1615                                 s1, s2, s3, s4, \
1616                                 f1, f2, f3, f4); \
1617                 MACRO_END
1618
1619                 switch (broadcast)
1620                 {
1621                         case NOTIF_ONE_ONLY: // we can potentially save processing power with this broadcast method
1622                         {
1623                                 if (IS_REAL_CLIENT(client)) {
1624                                         RECURSE_FROM_CHOICE(client, return);
1625                                 }
1626                                 break;
1627                         }
1628                         default:
1629                         {
1630                                 FOREACH_CLIENT(IS_REAL_CLIENT(it) && Notification_ShouldSend(broadcast, it, client), {
1631                                         RECURSE_FROM_CHOICE(it, continue);
1632                                 });
1633                                 break;
1634                         }
1635                 }
1636         }
1637         else
1638         {
1639                 entity net_notif = new_pure(net_notification);
1640                 IL_PUSH(g_notifications, net_notif);
1641                 net_notif.owner = notif;
1642                 net_notif.nent_broadcast = broadcast;
1643                 net_notif.nent_client = client;
1644                 net_notif.nent_net_type = net_type;
1645                 net_notif.nent_net_name = notif.m_id;
1646                 net_notif.nent_stringcount = notif.nent_stringcount;
1647                 net_notif.nent_floatcount = notif.nent_floatcount;
1648
1649                 for (int i = 0; i < net_notif.nent_stringcount; ++i) {
1650                         net_notif.nent_strings[i] = strzone(...(i, string));
1651                 }
1652                 for (int i = 0; i < net_notif.nent_floatcount; ++i) {
1653                         net_notif.nent_floats[i] = ...((net_notif.nent_stringcount + i), float);
1654                 }
1655
1656                 setthink(net_notif, Net_Notification_Remove);
1657                 net_notif.nextthink = (time > autocvar_notification_lifetime_mapload)
1658                         ? (time + autocvar_notification_lifetime_runtime)
1659                         : autocvar_notification_lifetime_mapload;
1660
1661                 Net_LinkEntity(net_notif, false, 0, Net_Write_Notification);
1662         }
1663 }
1664
1665 // WOVA = Without Variable Arguments
1666 void Send_Notification_WOVA(
1667         NOTIF broadcast, entity client,
1668         MSG net_type, Notification net_name,
1669         float stringcount, float floatcount,
1670         string s1, string s2, string s3, string s4,
1671         float f1, float f2, float f3, float f4)
1672 {
1673         #ifdef NOTIFICATIONS_DEBUG
1674         entity notif = net_name;
1675         Debug_Notification(sprintf(
1676                 "Send_Notification_WOVA(%s, %d, %d, %s, %s);\n",
1677                 sprintf(
1678                         "%s, '%s', %s, %s",
1679                         Get_Notif_BroadcastName(broadcast),
1680                         client.classname,
1681                         Get_Notif_TypeName(net_type),
1682                         notif.nent_name
1683                 ),
1684                 stringcount,
1685                 floatcount,
1686                 MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1687                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
1688         ));
1689         #endif
1690
1691         #define VARITEM(stringc, floatc, args) \
1692                 if ((stringcount == stringc) && (floatcount == floatc)) \
1693                 { Send_Notification(broadcast, client, net_type, net_name, args); return; }
1694         EIGHT_VARS_TO_VARARGS_VARLIST
1695         #undef VARITEM
1696         Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all
1697 }
1698
1699 // WOCOVA = Without Counts Or Variable Arguments
1700 void Send_Notification_WOCOVA(
1701         NOTIF broadcast, entity client,
1702         MSG net_type, Notification net_name,
1703         string s1, string s2, string s3, string s4,
1704         float f1, float f2, float f3, float f4)
1705 {
1706         entity notif = net_name;
1707
1708         #ifdef NOTIFICATIONS_DEBUG
1709         Debug_Notification(sprintf(
1710                 "Send_Notification_WOCOVA(%s, %s, %s);\n",
1711                 sprintf(
1712                         "%s, '%s', %s, %s",
1713                         Get_Notif_BroadcastName(broadcast),
1714                         client.classname,
1715                         Get_Notif_TypeName(net_type),
1716                         notif.nent_name
1717                 ),
1718                 MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1719                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
1720         ));
1721         #endif
1722
1723         #define VARITEM(stringc, floatc, args) \
1724                 if ((notif.nent_stringcount == stringc) && (notif.nent_floatcount == floatc)) \
1725                 { Send_Notification(broadcast, client, net_type, net_name, args); return; }
1726         EIGHT_VARS_TO_VARARGS_VARLIST
1727         #undef VARITEM
1728         Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all
1729 }
1730 #endif // ifdef SVQC