qcsrc/common/notifications.qc

   1 // ================================================
   2 //  Unified notification system, written by Samual
   3 //  Last updated: March, 2013
   4 // ================================================
   5
   6 string Get_Notif_TypeName(float net_type)
   7 {
   8         switch(net_type)
   9         {
  10                 case MSG_INFO: return "MSG_INFO";
  11                 case MSG_CENTER: return "MSG_CENTER";
  12                 case MSG_CENTER_CPID: return "MSG_CENTER_CPID";
  13                 case MSG_MULTI: return "MSG_MULTI";
  14         }
  15         backtrace(sprintf("Get_Notif_TypeName(%d): Improper net type!\n", net_type));
  16         return "";
  17 }
  18
  19 entity Get_Notif_Ent(float net_type, float net_name)
  20 {
  21         switch(net_type)
  22         {
  23                 case MSG_INFO: return msg_info_notifs[net_name - 1];
  24                 case MSG_CENTER: return msg_center_notifs[net_name - 1];
  25                 case MSG_MULTI: return msg_multi_notifs[net_name - 1];
  26         }
  27         backtrace(sprintf("Get_Notif_Ent(%d, %d): Improper net type!\n", net_type, net_name));
  28         return world;
  29 }
  30
  31 string Notification_CheckArgs_TypeName(float net_type, float net_name)
  32 {
  33         // check supplied type and name for errors
  34         string checkargs = "";
  35         #define CHECKARG_TYPENAME(type) case MSG_##type##: \
  36                 { if(!net_name || (net_name > NOTIF_##type##_COUNT)) \
  37                 { checkargs = sprintf("Improper name: %d!", net_name); } break; }
  38         switch(net_type)
  39         {
  40                 CHECKARG_TYPENAME(INFO)
  41                 CHECKARG_TYPENAME(CENTER)
  42                 CHECKARG_TYPENAME(MULTI)
  43                 default: { checkargs = sprintf("Improper type: %d!", checkargs, net_type); break; }
  44         }
  45         #undef CHECKARG_TYPENAME
  46         return checkargs;
  47 }
  48
  49 #ifdef SVQC
  50 string Notification_CheckArgs(
  51         float broadcast, entity client,
  52         float net_type, float net_name)
  53 {
  54         // check supplied broadcast, target, type, and name for errors
  55         string checkargs = Notification_CheckArgs_TypeName(net_type, net_name);
  56         if(checkargs != "") { checkargs = strcat(checkargs, " "); }
  57         switch(broadcast)
  58         {
  59                 case NOTIF_ONE:
  60                 case NOTIF_ONE_ONLY:
  61                 {
  62                         if(IS_NOT_A_CLIENT(client))
  63                                 { checkargs = sprintf("%sNo client provided!", checkargs); }
  64                         break;
  65                 }
  66
  67                 case NOTIF_ALL_EXCEPT:
  68                 {
  69                         if(IS_NOT_A_CLIENT(client))
  70                                 { checkargs = sprintf("%sException can't be a non-client!", checkargs); }
  71                         break;
  72                 }
  73
  74                 case NOTIF_ALL:
  75                 {
  76                         if(client)
  77                                 { checkargs = sprintf("%sEntity provided when world was required!", checkargs); }
  78                         break;
  79                 }
  80
  81                 case NOTIF_TEAM:
  82                 case NOTIF_TEAM_EXCEPT:
  83                 {
  84                         if not(teamplay) { checkargs = sprintf("%sTeamplay not active!", checkargs); }
  85                         else if(IS_NOT_A_CLIENT(client))
  86                         {
  87                                 if(broadcast == NOTIF_TEAM) { checkargs = sprintf("%sNo client provided!", checkargs); }
  88                                 else { checkargs = sprintf("%sException can't be a non-client!", checkargs); }
  89                         }
  90                         break;
  91                 }
  92
  93                 default: { checkargs = sprintf("%sImproper broadcast: %d!", checkargs, broadcast); break; }
  94         }
  95         return checkargs;
  96 }
  97 #endif
  98
  99 // ===============================
 100 //  Initialization Core Functions
 101 // ===============================
 102
 103 // used by restartnotifs command to initialize notifications
 104 void Destroy_Notification_Entity(entity notif)
 105 {
 106         if(notif.nent_name != "") { strunzone(notif.nent_name); }
 107         if(notif.nent_args != "") { strunzone(notif.nent_args); }
 108         if(notif.nent_hudargs != "") { strunzone(notif.nent_hudargs); }
 109         if(notif.nent_icon != "") { strunzone(notif.nent_icon); }
 110         if(notif.nent_durcnt != "") { strunzone(notif.nent_durcnt); }
 111         if(notif.nent_string != "") { strunzone(notif.nent_string); }
 112         remove(notif);
 113 }
 114
 115 void Destroy_All_Notifications(void)
 116 {
 117         entity notif;
 118         float i;
 119
 120         #define DESTROY_LOOP(type,count) \
 121                 for(i = 1; i <= count; ++i) \
 122                 { \
 123                         notif = Get_Notif_Ent(type, i); \
 124                         if not(notif) { backtrace("Destroy_All_Notifications(): Missing notification entity!\n"); return; } \
 125                         Destroy_Notification_Entity(notif); \
 126                 }
 127
 128         // kill all networked notifications
 129         #ifdef SVQC
 130         Kill_Notification(NOTIF_ALL, world, 0, 0);
 131         #endif
 132
 133         // kill all real notification entities
 134         DESTROY_LOOP(MSG_INFO, NOTIF_INFO_COUNT)
 135         DESTROY_LOOP(MSG_CENTER, NOTIF_CENTER_COUNT)
 136         DESTROY_LOOP(MSG_MULTI, NOTIF_MULTI_COUNT)
 137         #undef DESTROY_LOOP
 138 }
 139
 140 string Process_Notif_Line(
 141         float msg_is_info,
 142         float chat,
 143         string input,
 144         string notiftype,
 145         string notifname,
 146         string stringtype)
 147 {
 148         if(msg_is_info)
 149         {
 150                 #ifdef CSQC
 151                 if((chat && autocvar_notification_allow_chatboxprint)
 152                         || (autocvar_notification_allow_chatboxprint == 2))
 153                 {
 154                         // pass 1: add ETX char at beginning of line
 155                         input = strcat("\{3}", input);
 156
 157                         // pass 2: add ETX char at end of each new line (so that
 158                         // messages with multiple lines are put through chatbox too)
 159                         input = strreplace("\n", "\n\{3}", input);
 160
 161                         // pass 3: strip trailing ETX char
 162                         if(substring(input, (strlen(input) - 1), 1) == "\{3}")
 163                                 { input = substring(input, 0, (strlen(input) - 1)); }
 164                 }
 165                 #endif
 166                 if(substring(input, (strlen(input) - 1), 1) != "\n")
 167                 {
 168                         print(sprintf(
 169                                 strcat(
 170                                         "^1MISSING/BROKEN NEW LINE AT END OF NOTIFICATION: ",
 171                                         "^7net_type = %s, net_name = %s, string = %s.\n"
 172                                 ),
 173                                 notiftype,
 174                                 notifname,
 175                                 stringtype
 176                         ));
 177                         notif_error = TRUE;
 178                         return strcat(input, "\n");
 179                 }
 180         }
 181         return input;
 182 }
 183
 184 string Process_Notif_Args(
 185         float arg_type,
 186         string args,
 187         string notiftype,
 188         string notifname)
 189 {
 190         string selected, remaining = args;
 191         float sel_num = 0;
 192
 193         for(;(remaining != "");)
 194         {
 195                 selected = car(remaining); remaining = cdr(remaining);
 196
 197                 switch(arg_type)
 198                 {
 199                         case 1: // normal args
 200                         {
 201                                 if(sel_num == NOTIF_MAX_ARGS)
 202                                 {
 203                                         print(sprintf(
 204                                                 strcat(
 205                                                         "^1NOTIFICATION HAS TOO MANY ARGUMENTS: ",
 206                                                         "^7net_type = %s, net_name = %s, max args = %d.\n"
 207                                                 ),
 208                                                 notiftype,
 209                                                 notifname,
 210                                                 NOTIF_MAX_ARGS
 211                                         ));
 212                                         notif_error = TRUE;
 213                                         break;
 214                                 }
 215
 216                                 switch(strtolower(selected))
 217                                 {
 218                                         #define ARG_CASE(prog,selected,result) \
 219                                                 #if (prog != ARG_DC) \
 220                                                         case selected: { ++sel_num; break; } \
 221                                                 #endif
 222                                         NOTIF_ARGUMENT_LIST
 223                                         #undef ARG_CASE
 224                                         default:
 225                                         {
 226                                                 print(sprintf(
 227                                                         strcat(
 228                                                                 "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: ",
 229                                                                 "^7net_type = %s, net_name = %s, args arg = '%s'.\n"
 230                                                         ),
 231                                                         notiftype,
 232                                                         notifname,
 233                                                         selected
 234                                                 ));
 235                                                 notif_error = TRUE;
 236                                                 break;
 237                                         }
 238                                 }
 239                                 break;
 240                         }
 241                         case 2: // hudargs
 242                         {
 243                                 if(sel_num == NOTIF_MAX_HUDARGS)
 244                                 {
 245                                         print(sprintf(
 246                                                 strcat(
 247                                                         "^1NOTIFICATION HAS TOO MANY ARGUMENTS: ",
 248                                                         "^7net_type = %s, net_name = %s, max hudargs = %d.\n"
 249                                                 ),
 250                                                 notiftype,
 251                                                 notifname,
 252                                                 NOTIF_MAX_HUDARGS
 253                                         ));
 254                                         notif_error = TRUE;
 255                                         break;
 256                                 }
 257
 258                                 switch(strtolower(selected))
 259                                 {
 260                                         #define ARG_CASE(prog,selected,result) \
 261                                                 #if (prog == ARG_CS_SV_HA) \
 262                                                         case selected: { ++sel_num; break; } \
 263                                                 #endif
 264                                         NOTIF_ARGUMENT_LIST
 265                                         #undef ARG_CASE
 266                                         default:
 267                                         {
 268                                                 print(sprintf(
 269                                                         strcat(
 270                                                                 "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: ",
 271                                                                 "^7net_type = %s, net_name = %s, hudargs arg = '%s'.\n"
 272                                                         ),
 273                                                         notiftype,
 274                                                         notifname,
 275                                                         selected
 276                                                 ));
 277                                                 notif_error = TRUE;
 278                                                 break;
 279                                         }
 280                                 }
 281                                 break;
 282                         }
 283                         case 3: // durcnt
 284                         {
 285                                 if(sel_num == NOTIF_MAX_DURCNT)
 286                                 {
 287                                         print(sprintf(
 288                                                 strcat(
 289                                                         "^1NOTIFICATION HAS TOO MANY ARGUMENTS: ",
 290                                                         "^7net_type = %s, net_name = %s, max durcnt = %d.\n"
 291                                                 ),
 292                                                 notiftype,
 293                                                 notifname,
 294                                                 NOTIF_MAX_DURCNT
 295                                         ));
 296                                         notif_error = TRUE;
 297                                         break;
 298                                 }
 299
 300                                 switch(strtolower(selected))
 301                                 {
 302                                         #define ARG_CASE(prog,selected,result) \
 303                                                 #if (prog == ARG_CS_SV_DC) || (prog == ARG_DC) \
 304                                                         case selected: { ++sel_num; break; } \
 305                                                 #endif
 306                                         NOTIF_ARGUMENT_LIST
 307                                         #undef ARG_CASE
 308                                         default:
 309                                         {
 310                                                 if(ftos(stof(selected)) != "") { ++sel_num; }
 311                                                 else
 312                                                 {
 313                                                         print(sprintf(
 314                                                                 strcat(
 315                                                                         "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: ",
 316                                                                         "^7net_type = %s, net_name = %s, durcnt arg = '%s'.\n"
 317                                                                 ),
 318                                                                 notiftype,
 319                                                                 notifname,
 320                                                                 selected
 321                                                         ));
 322                                                         notif_error = TRUE;
 323                                                 }
 324                                                 break;
 325                                         }
 326                                 }
 327                                 break;
 328                         }
 329                 }
 330         }
 331         return args;
 332 }
 333
 334 void Create_Notification_Entity(
 335         float var_default,
 336         float var_cvar,
 337         float typeid,
 338         float nameid,
 339         string namestring,
 340         float infoname,
 341         float centername,
 342         float strnum,
 343         float flnum,
 344         string args,
 345         string hudargs,
 346         string icon,
 347         float cpid,
 348         string durcnt,
 349         string normal,
 350         string gentle,
 351         float msg_is_info,
 352         float msg_is_multi)
 353 {
 354         // =====================
 355         //  Global Entity Setup
 356         // =====================
 357         entity notif = spawn();
 358         string typestring = "";
 359         switch(typeid)
 360         {
 361                 case MSG_INFO:
 362                 {
 363                         typestring = "MSG_INFO";
 364                         msg_info_notifs[nameid - 1] = notif;
 365                         notif.classname = "msg_info_notification";
 366                         break;
 367                 }
 368                 case MSG_CENTER:
 369                 {
 370                         typestring = "MSG_CENTER";
 371                         msg_center_notifs[nameid - 1] = notif;
 372                         notif.classname = "msg_center_notification";
 373                         break;
 374                 }
 375                 case MSG_MULTI:
 376                 {
 377                         typestring = "MSG_MULTI";
 378                         msg_multi_notifs[nameid - 1] = notif;
 379                         notif.classname = "MSG_MULTI_notification";
 380                         break;
 381                 }
 382
 383                 default:
 384                 {
 385                         error(sprintf(
 386                                 strcat(
 387                                         "^1NOTIFICATION WITH IMPROPER TYPE: ",
 388                                         "^7net_type = %d, net_name = %s.\n"
 389                                 ),
 390                                 typeid,
 391                                 namestring
 392                         ));
 393                         return; // It's not possible to recover from this one
 394                 }
 395         }
 396         notif.nent_default = var_default;
 397         notif.nent_name = strzone(namestring);
 398         notif.nent_id = nameid;
 399         notif.nent_enabled = (1 <= var_cvar);
 400
 401         // Other pre-notif-setup requisites
 402         notif_error = FALSE;
 403
 404         // ====================
 405         //  Notification Setup
 406         // ====================
 407         if(msg_is_multi)
 408         {
 409                 // Set MSG_MULTI string/float counts
 410                 if((infoname == NO_MSG) && (centername == NO_MSG))
 411                 {
 412                         print(sprintf(
 413                                 strcat(
 414                                         "^1NOTIFICATION WITH NO SUBCALLS: ",
 415                                         "^7net_type = %s, net_name = %s.\n"
 416                                 ),
 417                                 typestring,
 418                                 namestring
 419                         ));
 420                         notif_error = TRUE;
 421                 }
 422                 else
 423                 {
 424                         float infoname_stringcount = 0, infoname_floatcount = 0;
 425                         float centername_stringcount = 0, centername_floatcount = 0;
 426
 427                         if(infoname != NO_MSG)
 428                         {
 429                                 notif.nent_msginfo = msg_info_notifs[infoname - 1];
 430                                 infoname_stringcount = notif.nent_msginfo.nent_stringcount;
 431                                 infoname_floatcount = notif.nent_msginfo.nent_floatcount;
 432                         }
 433
 434                         if(centername != NO_MSG)
 435                         {
 436                                 notif.nent_msgcenter = msg_center_notifs[centername - 1];
 437                                 centername_stringcount = notif.nent_msgcenter.nent_stringcount;
 438                                 centername_floatcount = notif.nent_msgcenter.nent_floatcount;
 439                         }
 440
 441                         // set the requirements of THIS notification to the totals of its subcalls
 442                         notif.nent_stringcount = max(infoname_stringcount, centername_stringcount);
 443                         notif.nent_floatcount = max(infoname_floatcount, centername_floatcount);
 444                 }
 445         }
 446         else
 447         {
 448                 // Set MSG_INFO and MSG_CENTER string/float counts
 449                 notif.nent_stringcount = strnum;
 450                 notif.nent_floatcount = flnum;
 451
 452                 // Only initialize arguments if we're either a client or on a dedicated server
 453                 #ifdef SVQC
 454                 float should_process_args = server_is_dedicated;
 455                 #else
 456                 float should_process_args = TRUE;
 457                 #endif
 458
 459                 if(should_process_args)
 460                 {
 461                         // ========================
 462                         //  Process Main Arguments
 463                         // ========================
 464                         if(strnum + flnum)
 465                         {
 466                                 if(args != "")
 467                                 {
 468                                         notif.nent_args = strzone(
 469                                                 Process_Notif_Args(1, args, typestring, namestring));
 470                                 }
 471                                 else if((hudargs == "") && (durcnt ==""))
 472                                 {
 473                                         print(sprintf(
 474                                                 strcat(
 475                                                         "^1NOTIFICATION HAS ARG COUNTS BUT NO ARGS OR HUDARGS OR DURCNT: ",
 476                                                         "^7net_type = %s, net_name = %s, strnum = %d, flnum = %d\n"
 477                                                 ),
 478                                                 typestring,
 479                                                 namestring,
 480                                                 strnum,
 481                                                 flnum
 482                                         ));
 483                                         notif_error = TRUE;
 484                                 }
 485                         }
 486                         else if(args != "")
 487                         {
 488                                 notif.nent_args = strzone(
 489                                         Process_Notif_Args(1, args, typestring, namestring));
 490                         }
 491
 492
 493                         // =======================================
 494                         //  Process HUD and Centerprint Arguments
 495                         //    Only processed on CSQC, as these
 496                         //    args are only for HUD features.
 497                         // =======================================
 498                         #ifdef CSQC
 499                         if(hudargs != "")
 500                         {
 501                                 notif.nent_hudargs = strzone(
 502                                         Process_Notif_Args(2, hudargs, typestring, namestring));
 503
 504                                 if(icon != "") { notif.nent_icon = strzone(icon); }
 505                                 else
 506                                 {
 507                                         print(sprintf(
 508                                                 strcat(
 509                                                         "^1NOTIFICATION HAS HUDARGS BUT NO ICON: ",
 510                                                         "^7net_type = %s, net_name = %s.\n"
 511                                                 ),
 512                                                 typestring,
 513                                                 namestring
 514                                         ));
 515                                         notif_error = TRUE;
 516                                 }
 517                         }
 518                         else if(icon != "")
 519                         {
 520                                 print(sprintf(
 521                                         strcat(
 522                                                 "^1NOTIFICATION HAS ICON BUT NO HUDARGS: ",
 523                                                 "^7net_type = %s, net_name = %s.\n"
 524                                         ),
 525                                         typestring,
 526                                         namestring
 527                                 ));
 528                                 notif_error = TRUE;
 529                         }
 530
 531                         if(durcnt != "")
 532                         {
 533                                 notif.nent_durcnt = strzone(
 534                                         Process_Notif_Args(3, durcnt, typestring, namestring));
 535
 536                                 if(cpid != NO_MSG) { notif.nent_cpid = cpid; }
 537                                 else
 538                                 {
 539                                         print(sprintf(
 540                                                 strcat(
 541                                                         "^1NOTIFICATION HAS DURCNT BUT NO CPID: ",
 542                                                         "^7net_type = %s, net_name = %s.\n"
 543                                                 ),
 544                                                 typestring,
 545                                                 namestring
 546                                         ));
 547                                         notif_error = TRUE;
 548                                 }
 549                         }
 550                         else if(cpid != NO_CPID) { notif.nent_cpid = cpid; }
 551                         #endif
 552
 553
 554                         // ======================
 555                         //  Process Notif String
 556                         // ======================
 557                         #define SET_NOTIF_STRING(string,stringname) \
 558                                 notif.nent_string = strzone(CCR( \
 559                                         Process_Notif_Line( \
 560                                                 msg_is_info, \
 561                                                 (var_cvar > 1), \
 562                                                 string, \
 563                                                 typestring, \
 564                                                 namestring, \
 565                                                 stringname \
 566                                         )) \
 567                                 );
 568
 569                         if(GENTLE)
 570                         {
 571                                 if(gentle != "") { SET_NOTIF_STRING(gentle, "GENTLE") }
 572                                 else if(normal != "") { SET_NOTIF_STRING(normal, "NORMAL") }
 573                         }
 574                         else if(normal != "") { SET_NOTIF_STRING(normal, "NORMAL") }
 575
 576                         #undef SET_NOTIF_STRING
 577
 578                         // Check to make sure a string was chosen
 579                         if(notif.nent_string == "")
 580                         {
 581                                 print(sprintf(
 582                                         strcat(
 583                                                 "^1EMPTY NOTIFICATION: ",
 584                                                 "^7net_type = %s, net_name = %s.\n"
 585                                         ),
 586                                         typestring,
 587                                         namestring
 588                                 ));
 589                                 notif_error = TRUE;
 590                         }
 591                 }
 592         }
 593
 594         // now check to see if any errors happened
 595         if(notif_error)
 596         {
 597                 notif.nent_enabled = FALSE; // disable the notification so it can't cause trouble
 598                 notif_global_error = TRUE; // throw the red flag that an error happened on init
 599         }
 600 }
 601
 602
 603 // =========================================
 604 //  Cvar Handling With 'dumpnotifs' Command
 605 // =========================================
 606
 607 void Dump_Notifications(float fh, float alsoprint)
 608 {
 609         #define NOTIF_WRITE(a) { \
 610                 fputs(fh, a); \
 611                 if(alsoprint) { print(a); } }
 612         #define NOTIF_WRITE_ENTITY(name,default,description) { \
 613                 notif_msg = \
 614                         sprintf( \
 615                                 "seta notification_%s \"%d\" \"%s\"\n", \
 616                                 name, default, description \
 617                         ); \
 618                 NOTIF_WRITE(notif_msg) }
 619         #define NOTIF_WRITE_HARDCODED(cvar,default,description) { \
 620                 notif_msg = \
 621                         sprintf( \
 622                                 "seta notification_%s \"%s\" \"%s\"\n", \
 623                                 cvar, default, description \
 624                         ); \
 625                 NOTIF_WRITE(notif_msg) }
 626
 627         string notif_msg;
 628         float i;
 629         entity e;
 630
 631         // Note: This warning only applies to the notifications.cfg file that is output...
 632
 633         // You ARE supposed to manually edit this function to add i.e. hard coded
 634         // notification variables for mutators or game modes or such and then
 635         // regenerate the notifications.cfg file from the new code.
 636
 637         NOTIF_WRITE("// ********************************************** //\n");
 638         NOTIF_WRITE("// ** WARNING - DO NOT MANUALLY EDIT THIS FILE ** //\n");
 639         NOTIF_WRITE("// **                                          ** //\n");
 640         NOTIF_WRITE("// **  This file is automatically generated    ** //\n");
 641         NOTIF_WRITE("// **  by code with the command 'dumpnotifs'.  ** //\n");
 642         NOTIF_WRITE("// **                                          ** //\n");
 643         NOTIF_WRITE("// **  If you add a new notification, please   ** //\n");
 644         NOTIF_WRITE("// **  regenerate this file with that command  ** //\n");
 645         NOTIF_WRITE("// **  making sure that the output matches     ** //\n");
 646         NOTIF_WRITE("// **  with the lists and defaults in code.    ** //\n");
 647         NOTIF_WRITE("// **                                          ** //\n");
 648         NOTIF_WRITE("// ********************************************** //\n");
 649
 650         // These notifications will also append their string as a comment...
 651         // This is not necessary, and does not matter if they vary between config versions,
 652         // it is just a semi-helpful tool for those who want to manually change their user settings.
 653
 654         NOTIF_WRITE(sprintf("\n// MSG_INFO notifications (count = %d):\n", NOTIF_INFO_COUNT));
 655         for(i = 1; i <= NOTIF_INFO_COUNT; ++i)
 656         {
 657                 e = Get_Notif_Ent(MSG_INFO, i);
 658                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 659                 NOTIF_WRITE_ENTITY(e.nent_name, e.nent_default, "Notification control cvar: 0 = off, 1 = print to console, 2 = print to console and chatbox (if notification_allow_chatboxprint is enabled)");
 660         }
 661
 662         NOTIF_WRITE(sprintf("\n// MSG_CENTER notifications (count = %d):\n", NOTIF_CENTER_COUNT));
 663         for(i = 1; i <= NOTIF_CENTER_COUNT; ++i)
 664         {
 665                 e = Get_Notif_Ent(MSG_CENTER, i);
 666                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 667                 NOTIF_WRITE_ENTITY(e.nent_name, e.nent_default, "Notification control cvar: 0 = off, 1 = centerprint");
 668         }
 669
 670         NOTIF_WRITE(sprintf("\n// MSG_MULTI notifications (count = %d):\n", NOTIF_MULTI_COUNT));
 671         for(i = 1; i <= NOTIF_MULTI_COUNT; ++i)
 672         {
 673                 e = Get_Notif_Ent(MSG_MULTI, i);
 674                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 675                 NOTIF_WRITE_ENTITY(e.nent_name, e.nent_default, "Notification control cvar: 0 = off, 1 = trigger subcalls");
 676         }
 677
 678         // edit these to match whichever cvars are used for specific notification options
 679         NOTIF_WRITE("\n// HARD CODED notification variables:\n");
 680         NOTIF_WRITE_HARDCODED("allow_chatboxprint",                             "1",    "Allow notifications to be printed to chat box by setting notification cvar to 2 (You can also set this cvar to 2 to force ALL notifications to be printed to the chatbox)");
 681         NOTIF_WRITE_HARDCODED("show_location",                                          "0",    "Append location information to MSG_INFO death/kill messages");
 682         NOTIF_WRITE_HARDCODED("show_location_string",                           "",     "Replacement string piped into sprintf, so you can do different messages like this: ' at the %s' or ' (near %s)'");
 683         NOTIF_WRITE_HARDCODED("show_sprees",                                            "1",    "Print information about sprees in death/kill messages");
 684         NOTIF_WRITE_HARDCODED("show_sprees_center",                             "1",    "Show spree information in MSG_CENTER messages... 0 = off, 1 = target (but only for first victim) and attacker");
 685         NOTIF_WRITE_HARDCODED("show_sprees_center_specialonly",         "1",    "Don't show spree information in MSG_CENTER messages if it isn't an achievement");
 686         NOTIF_WRITE_HARDCODED("show_sprees_info",                                       "3",    "Show spree information in MSG_INFO messages... 0 = off, 1 = target only, 2 = attacker only, 3 = target and attacker");
 687         NOTIF_WRITE_HARDCODED("show_sprees_info_newline",                       "1",    "Show attacker spree information for MSG_INFO messages on a separate line than the death notification itself");
 688         NOTIF_WRITE_HARDCODED("show_sprees_info_specialonly",           "1",    "Don't show attacker spree information in MSG_INFO messages if it isn't an achievement");
 689         NOTIF_WRITE_HARDCODED("item_centerprinttime",                           "1.5",  "How long to show item information centerprint messages (like 'You got the Electro' or such)");
 690         NOTIF_WRITE_HARDCODED("errors_are_fatal",                                       "1",    "If a notification fails upon initialization, cause a Host_Error to stop the program");
 691         NOTIF_WRITE_HARDCODED("ctf_pickup_team_verbose",                        "0",    "Show extra information if a team mate picks up a flag");
 692         NOTIF_WRITE_HARDCODED("ctf_pickup_enemy_verbose",                       "0",    "Show extra information if an enemy picks up a flag");
 693         NOTIF_WRITE_HARDCODED("ctf_capture_verbose",                            "0",    "Show extra information when someone captures a flag");
 694         NOTIF_WRITE_HARDCODED("frag_verbose",                                           "1",    "Show extra information when you frag someone (or when you are fragged");
 695         NOTIF_WRITE_HARDCODED("lifetime_runtime",                                       "0.5",  "Amount of time that notification entities last on the server during runtime (In seconds)");
 696         NOTIF_WRITE_HARDCODED("lifetime_mapload",                                       "10",   "Amount of time that notification entities last immediately at mapload (in seconds) to help prevent notifications from being lost on early init (like gamestart countdown)");
 697
 698         NOTIF_WRITE(sprintf(
 699                 strcat(
 700                         "\n// Notification counts (total = %d): ",
 701                         "MSG_INFO = %d, MSG_CENTER = %d, MSG_MULTI = %d\n"
 702                 ),
 703                 (
 704                         NOTIF_INFO_COUNT +
 705                         NOTIF_CENTER_COUNT +
 706                         NOTIF_MULTI_COUNT
 707                 ),
 708                 NOTIF_INFO_COUNT,
 709                 NOTIF_CENTER_COUNT,
 710                 NOTIF_MULTI_COUNT
 711         ));
 712
 713         return;
 714         #undef NOTIF_WRITE_HARDCODED
 715         #undef NOTIF_WRITE_ENTITY
 716         #undef NOTIF_WRITE
 717 }
 718
 719 #ifdef SVQC
 720 void Notification_GetCvars()
 721 {
 722         GetCvars_handleFloat(get_cvars_s, get_cvars_f, FRAG_VERBOSE, "notification_frag_verbose");
 723 }
 724 #endif
 725
 726
 727 // ===============================
 728 //  Frontend Notification Pushing
 729 // ===============================
 730
 731 string Local_Notification_sprintf(
 732         string input, string args,
 733         string s1, string s2, string s3, string s4,
 734         float f1, float f2, float f3, float f4)
 735 {
 736         #ifdef NOTIFICATIONS_DEBUG
 737         dprint(sprintf(
 738                 "Local_Notification_sprintf('%s^7', '%s', %s, %s);\n",
 739                 strreplace("\n", "\\n", input),
 740                 args,
 741                 strreplace("\n", "\\n", sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
 742                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
 743         ));
 744         #endif
 745
 746         string selected;
 747         float sel_num;
 748         for(sel_num = 0; sel_num < NOTIF_MAX_ARGS; ++sel_num) { arg_slot[sel_num] = ""; }
 749
 750         string tmp_s;
 751
 752         for(sel_num = 0;(args != "");)
 753         {
 754                 selected = car(args); args = cdr(args);
 755                 NOTIF_HIT_MAX(NOTIF_MAX_ARGS, "Local_Notification_sprintf")
 756                 switch(strtolower(selected))
 757                 {
 758                         #define ARG_CASE(prog,selected,result) \
 759                                 #ifdef CSQC \
 760                                         #if (prog != ARG_SV) && (prog != ARG_DC) \
 761                                                 case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 762                                         #endif \
 763                                 #else \
 764                                         #if (prog != ARG_CS) && (prog != ARG_DC) \
 765                                                 case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 766                                         #endif \
 767                                 #endif
 768                         NOTIF_ARGUMENT_LIST
 769                         #undef ARG_CASE
 770                         default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_ARGS, "Local_Notification_sprintf")
 771                 }
 772         }
 773         return sprintf(input, arg_slot[0], arg_slot[1], arg_slot[2], arg_slot[3], arg_slot[4], arg_slot[5], arg_slot[6]);
 774 }
 775
 776 #ifdef CSQC
 777 void Local_Notification_HUD_Notify_Push(
 778         string icon, string hudargs,
 779         string s1, string s2, string s3, string s4)
 780 {
 781         string selected;
 782         float sel_num;
 783         arg_slot[0] = ""; arg_slot[1] = "";
 784
 785         for(sel_num = 0;(hudargs != "");)
 786         {
 787                 selected = car(hudargs); hudargs = cdr(hudargs);
 788                 NOTIF_HIT_MAX(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push")
 789                 switch(strtolower(selected))
 790                 {
 791                         #define ARG_CASE(prog,selected,result) \
 792                                 #if (prog == ARG_CS_SV_HA) \
 793                                         case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 794                                 #endif
 795                         NOTIF_ARGUMENT_LIST
 796                         #undef ARG_CASE
 797                         default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push")
 798                 }
 799         }
 800         #ifdef NOTIFICATIONS_DEBUG
 801         dprint(sprintf(
 802                 "Local_Notification_HUD_Notify_Push('%s^7', '%s', %s, %s);\n",
 803                 icon,
 804                 hudargs,
 805                 strreplace("\n", "\\n", sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
 806                 strreplace("\n", "\\n", sprintf("'%s^7', '%s^7'", stof(arg_slot[0]), stof(arg_slot[1])))
 807         ));
 808         #endif
 809         HUD_Notify_Push(icon, arg_slot[0], arg_slot[1]);
 810 }
 811
 812 void Local_Notification_centerprint_generic(
 813         string input, string durcnt,
 814         float cpid, float f1, float f2)
 815 {
 816         string selected;
 817         float sel_num;
 818         arg_slot[0] = ""; arg_slot[1] = "";
 819
 820         for(sel_num = 0;(durcnt != "");)
 821         {
 822                 selected = car(durcnt); durcnt = cdr(durcnt);
 823                 NOTIF_HIT_MAX(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic")
 824                 switch(strtolower(selected))
 825                 {
 826                         #define ARG_CASE(prog,selected,result) \
 827                                 #if (prog == ARG_CS_SV_DC) || (prog == ARG_DC) \
 828                                         case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 829                                 #endif
 830                         NOTIF_ARGUMENT_LIST
 831                         #undef ARG_CASE
 832                         default:
 833                         {
 834                                 if(ftos(stof(selected)) != "") { arg_slot[sel_num] = selected; ++sel_num; }
 835                                 else { NOTIF_HIT_UNKNOWN(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic") }
 836                                 break;
 837                         }
 838                 }
 839         }
 840         #ifdef NOTIFICATIONS_DEBUG
 841         dprint(sprintf(
 842                 "Local_Notification_centerprint_generic('%s^7', '%s', %d, %d, %d, %d);\n",
 843                 strreplace("\n", "\\n", input),
 844                 durcnt,
 845                 f1, f2,
 846                 stof(arg_slot[0]), stof(arg_slot[1])
 847         ));
 848         #endif
 849         centerprint_generic(cpid, input, stof(arg_slot[0]), stof(arg_slot[1]));
 850 }
 851 #endif
 852
 853 void Local_Notification(float net_type, float net_name, ...count)
 854 {
 855         // check supplied type and name for errors
 856         string checkargs = Notification_CheckArgs_TypeName(net_type, net_name);
 857         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Local_Notification: %s\n", checkargs)); return; }
 858
 859         entity notif = Get_Notif_Ent(net_type, net_name);
 860         if not(notif) { backtrace("Local_Notification: Could not find notification entity!\n"); return; }
 861
 862         #ifdef NOTIFICATIONS_DEBUG
 863         if not(notif.nent_enabled)
 864         {
 865                 dprint(sprintf(
 866                         "Local_Notification(%s, %s): Entity was disabled...\n",
 867                         Get_Notif_TypeName(net_type),
 868                         notif.nent_name
 869                 ));
 870                 return;
 871         }
 872         #endif
 873
 874         if((notif.nent_stringcount + notif.nent_floatcount) > count)
 875         {
 876                 backtrace(sprintf(
 877                         strcat(
 878                                 "Not enough arguments for Local_Notification(%s, %s, ...)! ",
 879                                 "stringcount(%d) + floatcount(%d) > count(%d)\n",
 880                                 "Check the definition and function call for accuracy...?\n"
 881                         ),
 882                         Get_Notif_TypeName(net_type), notif.nent_name,
 883                         notif.nent_stringcount, notif.nent_floatcount, count
 884                 ));
 885                 return;
 886         }
 887         else if((notif.nent_stringcount + notif.nent_floatcount) < count)
 888         {
 889                 backtrace(sprintf(
 890                         strcat(
 891                                 "Too many arguments for Local_Notification(%s, %s, ...)! ",
 892                                 "stringcount(%d) + floatcount(%d) < count(%d)\n",
 893                                 "Check the definition and function call for accuracy...?\n"
 894                         ),
 895                         Get_Notif_TypeName(net_type), notif.nent_name,
 896                         notif.nent_stringcount, notif.nent_floatcount, count
 897                 ));
 898                 return;
 899         }
 900
 901         string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : "");
 902         string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : "");
 903         string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : "");
 904         string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : "");
 905         float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0);
 906         float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0);
 907         float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0);
 908         float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0);
 909
 910         #ifdef NOTIFICATIONS_DEBUG
 911         dprint(sprintf(
 912                 "Local_Notification(%s, %s, %s, %s);\n",
 913                 Get_Notif_TypeName(net_type),
 914                 notif.nent_name,
 915                 strreplace("\n", "\\n", sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
 916                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
 917         ));
 918         #endif
 919
 920         switch(net_type)
 921         {
 922                 case MSG_INFO:
 923                 {
 924                         print(
 925                                 Local_Notification_sprintf(
 926                                         notif.nent_string,
 927                                         notif.nent_args,
 928                                         s1, s2, s3, s4,
 929                                         f1, f2, f3, f4)
 930                         );
 931                         #ifdef CSQC
 932                         if(notif.nent_icon != "")
 933                         {
 934                                 Local_Notification_HUD_Notify_Push(
 935                                         notif.nent_icon,
 936                                         notif.nent_hudargs,
 937                                         s1, s2, s3, s4);
 938                         }
 939                         #endif
 940                         break;
 941                 }
 942
 943                 #ifdef CSQC
 944                 case MSG_CENTER:
 945                 {
 946                         Local_Notification_centerprint_generic(
 947                                 Local_Notification_sprintf(
 948                                         notif.nent_string,
 949                                         notif.nent_args,
 950                                         s1, s2, s3, s4,
 951                                         f1, f2, f3, f4),
 952                                 notif.nent_durcnt,
 953                                 notif.nent_cpid,
 954                                 f1, f2);
 955                         break;
 956                 }
 957                 #endif
 958
 959                 case MSG_MULTI:
 960                 {
 961                         if(notif.nent_msginfo)
 962                         if(notif.nent_msginfo.nent_enabled)
 963                         {
 964                                 Local_Notification_WOVA(
 965                                         MSG_INFO,
 966                                         notif.nent_msginfo.nent_id,
 967                                         notif.nent_msginfo.nent_stringcount,
 968                                         notif.nent_msginfo.nent_floatcount,
 969                                         s1, s2, s3, s4,
 970                                         f1, f2, f3, f4);
 971                         }
 972                         #ifdef CSQC
 973                         if(notif.nent_msgcenter)
 974                         if(notif.nent_msgcenter.nent_enabled)
 975                         {
 976                                 Local_Notification_WOVA(
 977                                         MSG_CENTER,
 978                                         notif.nent_msgcenter.nent_id,
 979                                         notif.nent_msgcenter.nent_stringcount,
 980                                         notif.nent_msgcenter.nent_floatcount,
 981                                         s1, s2, s3, s4,
 982                                         f1, f2, f3, f4);
 983                         }
 984                         #endif
 985                         break;
 986                 }
 987         }
 988 }
 989
 990 // WOVA = Without Variable Arguments
 991 void Local_Notification_WOVA(
 992         float net_type, float net_name,
 993         float stringcount, float floatcount,
 994         string s1, string s2, string s3, string s4,
 995         float f1, float f2, float f3, float f4)
 996 {
 997         #define VARITEM(stringc,floatc,args) \
 998                 if((stringcount == stringc) && (floatcount == floatc)) \
 999                         { Local_Notification(net_type, net_name, args); return; }
1000         EIGHT_VARS_TO_VARARGS_VARLIST
1001         #undef VARITEM
1002         Local_Notification(net_type, net_name); // some notifications don't have any arguments at all
1003 }
1004
1005
1006 // =========================
1007 //  Notification Networking
1008 // =========================
1009
1010 #ifdef CSQC
1011 void Read_Notification(float is_new)
1012 {
1013         float net_type = ReadByte();
1014         float net_name = ReadShort();
1015
1016         entity notif;
1017
1018         if(net_type == MSG_CENTER_CPID)
1019         {
1020                 #ifdef NOTIFICATIONS_DEBUG
1021                 dprint(sprintf(
1022                         "Read_Notification(%d) at %f: net_type = %s, net_name = %d\n",
1023                         is_new,
1024                         time,
1025                         Get_Notif_TypeName(net_type),
1026                         net_name
1027                 ));
1028                 #endif
1029
1030                 if(is_new)
1031                 {
1032                         if(net_name == 0) { reset_centerprint_messages(); }
1033                         else if(net_name != NO_CPID)
1034                         {
1035                                 // in this case, net_name IS the cpid we want to kill
1036                                 centerprint_generic(net_name, "", 0, 0);
1037                         }
1038                         else { print("Read_Notification(%d) at %f: ^1TRIED TO KILL NO_CPID CENTERPRINT!\n"); }
1039                 }
1040         }
1041         else
1042         {
1043                 notif = Get_Notif_Ent(net_type, net_name);
1044                 if not(notif) { backtrace("Read_Notification: Could not find notification entity!\n"); return; }
1045
1046                 #ifdef NOTIFICATIONS_DEBUG
1047                 dprint(sprintf(
1048                         "Read_Notification(%d) at %f: net_type = %s, net_name = %s\n",
1049                         is_new,
1050                         time,
1051                         Get_Notif_TypeName(net_type),
1052                         notif.nent_name
1053                 ));
1054                 #endif
1055
1056                 string s1 = ((0 < notif.nent_stringcount) ? ReadString() : "");
1057                 string s2 = ((1 < notif.nent_stringcount) ? ReadString() : "");
1058                 string s3 = ((2 < notif.nent_stringcount) ? ReadString() : "");
1059                 string s4 = ((3 < notif.nent_stringcount) ? ReadString() : "");
1060                 float f1 = ((0 < notif.nent_floatcount) ? ReadLong() : 0);
1061                 float f2 = ((1 < notif.nent_floatcount) ? ReadLong() : 0);
1062                 float f3 = ((2 < notif.nent_floatcount) ? ReadLong() : 0);
1063                 float f4 = ((3 < notif.nent_floatcount) ? ReadLong() : 0);
1064
1065                 if(is_new)
1066                 {
1067                         Local_Notification_WOVA(
1068                                 net_type, net_name,
1069                                 notif.nent_stringcount,
1070                                 notif.nent_floatcount,
1071                                 s1, s2, s3, s4,
1072                                 f1, f2, f3, f4);
1073                 }
1074         }
1075 }
1076 #endif
1077
1078 #ifdef SVQC
1079 void Net_Notification_Remove()
1080 {
1081         if not(self) { dprint(sprintf("Net_Notification_Remove() at %f: Missing self!?\n", time)); return; }
1082
1083         #ifdef NOTIFICATIONS_DEBUG
1084         dprint(sprintf(
1085                 "Net_Notification_Remove() at %f: %s '%s - %s' notification\n",
1086                 time,
1087                 ((self.nent_net_name == -1) ? "Killed" : "Removed"),
1088                 Get_Notif_TypeName(self.nent_net_type),
1089                 self.owner.nent_name
1090         ));
1091         #endif
1092
1093         float i;
1094         for(i = 0; i < 4; ++i) { if(self.nent_strings[i]) { strunzone(self.nent_strings[i]); } }
1095         remove(self);
1096 }
1097
1098 float Net_Write_Notification(entity client, float sf)
1099 {
1100         float i, send = FALSE;
1101
1102         switch(self.nent_broadcast)
1103         {
1104                 case NOTIF_ONE: // send to one client and their spectator
1105                 {
1106                         if(
1107                                 (client == self.nent_client)
1108                                 ||
1109                                 (
1110                                         (client.classname == STR_SPECTATOR)
1111                                         &&
1112                                         (client.enemy == self.nent_client)
1113                                 )
1114                         ) { send = TRUE; }
1115                         break;
1116                 }
1117                 case NOTIF_ONE_ONLY: // send ONLY to one client
1118                 {
1119                         if(client == self.nent_client) { send = TRUE; }
1120                         break;
1121                 }
1122                 case NOTIF_TEAM: // send only to X team and their spectators
1123                 {
1124                         if(
1125                                 (client.team == self.nent_client.team)
1126                                 ||
1127                                 (
1128                                         (client.classname == STR_SPECTATOR)
1129                                         &&
1130                                         (client.enemy.team == self.nent_client.team)
1131                                 )
1132                         ) { send = TRUE; }
1133                         break;
1134                 }
1135                 case NOTIF_TEAM_EXCEPT: // send only to X team and their spectators, except for Y person and their spectators
1136                 {
1137                         if(
1138                                 (client != self.nent_client)
1139                                 &&
1140                                 (
1141                                         (client.team == self.nent_client.team)
1142                                         ||
1143                                         (
1144                                                 (client.classname == STR_SPECTATOR)
1145                                                 &&
1146                                                 (
1147                                                         (client.enemy != self.nent_client)
1148                                                         &&
1149                                                         (client.enemy.team == self.nent_client.team)
1150                                                 )
1151                                         )
1152                                 )
1153                         ) { send = TRUE; }
1154                         break;
1155                 }
1156                 case NOTIF_ALL: // send to everyone
1157                 {
1158                         send = TRUE;
1159                         break;
1160                 }
1161                 case NOTIF_ALL_EXCEPT: // send to everyone except X person and their spectators
1162                 {
1163                         if(
1164                                 (client != self.nent_client)
1165                                 &&
1166                                 !(
1167                                         (client.classname == STR_SPECTATOR)
1168                                         &&
1169                                         (client.enemy == self.nent_client)
1170                                 )
1171                         ) { send = TRUE; }
1172                         break;
1173                 }
1174                 default: { send = FALSE; break; }
1175         }
1176
1177         if(send)
1178         {
1179                 WriteByte(MSG_ENTITY, ENT_CLIENT_NOTIFICATION);
1180                 WriteByte(MSG_ENTITY, self.nent_net_type);
1181                 WriteShort(MSG_ENTITY, self.nent_net_name);
1182                 for(i = 0; i < self.nent_stringcount; ++i) { WriteString(MSG_ENTITY, self.nent_strings[i]); }
1183                 for(i = 0; i < self.nent_floatcount; ++i) { WriteLong(MSG_ENTITY, self.nent_floats[i]); }
1184         }
1185
1186         return send;
1187 }
1188
1189 void Kill_Notification(
1190         float broadcast, entity client,
1191         float net_type, float net_name)
1192 {
1193         string checkargs = Notification_CheckArgs(broadcast, client, 1, 1);
1194         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Kill_Notification: %s\n", checkargs)); return; }
1195
1196         #ifdef NOTIFICATIONS_DEBUG
1197         dprint(sprintf(
1198                 "Kill_Notification(%d, '%s', %d, %d);\n",
1199                 broadcast,
1200                 client.netname,
1201                 net_type,
1202                 net_name
1203         ));
1204         #endif
1205
1206         entity notif, net_notif;
1207         float killed_cpid = NO_CPID;
1208
1209         switch(net_type)
1210         {
1211                 case 0:
1212                 {
1213                         killed_cpid = 0; // kill ALL centerprints
1214                         break;
1215                 }
1216
1217                 case MSG_CENTER:
1218                 {
1219                         if(net_name)
1220                         {
1221                                 entity notif = Get_Notif_Ent(net_type, net_name);
1222                                 if not(notif) { backtrace("Kill_Notification: Could not find notification entity!\n"); return; }
1223                                 killed_cpid = notif.nent_cpid;
1224                         }
1225                         else
1226                         {
1227                                 killed_cpid = 0; // kill ALL centerprints
1228                         }
1229                         break;
1230                 }
1231
1232                 case MSG_CENTER_CPID:
1233                 {
1234                         killed_cpid = net_name;
1235                         break;
1236                 }
1237         }
1238
1239         if(killed_cpid != NO_CPID)
1240         {
1241                 net_notif = spawn();
1242                 net_notif.classname = "net_kill_notification";
1243                 net_notif.nent_broadcast = broadcast;
1244                 net_notif.nent_client = client;
1245                 net_notif.nent_net_type = MSG_CENTER_CPID;
1246                 net_notif.nent_net_name = killed_cpid;
1247                 Net_LinkEntity(net_notif, FALSE, autocvar_notification_lifetime_runtime, Net_Write_Notification);
1248         }
1249
1250         for(notif = world; (notif = find(notif, classname, "net_notification"));)
1251         {
1252                 if(net_type)
1253                 {
1254                         if(killed_cpid != NO_CPID)
1255                         {
1256                                 if(notif.owner.nent_cpid == killed_cpid)
1257                                 {
1258                                         notif.nent_net_name = -1;
1259                                         notif.nextthink = time;
1260                                 }
1261                                 else { continue; } // we ARE looking for a specific CPID, don't kill everything else too
1262                         }
1263                         else if(notif.nent_net_type == net_type)
1264                         {
1265                                 if(net_name)
1266                                 {
1267                                         if(notif.nent_net_name == net_name) { notif.nent_net_name = -1; notif.nextthink = time; }
1268                                         else { continue; } // we ARE looking for a certain net_name, don't kill everything else too
1269                                 }
1270                                 else { notif.nent_net_name = -1; notif.nextthink = time; }
1271                         }
1272                         else { continue; } // we ARE looking for a certain net_type, don't kill everything else too
1273                 }
1274                 else { notif.nent_net_name = -1; notif.nextthink = time; }
1275         }
1276 }
1277
1278 void Send_Notification(
1279         float broadcast, entity client,
1280         float net_type, float net_name,
1281         ...count)
1282 {
1283         // check supplied broadcast, target, type, and name for errors
1284         string checkargs = Notification_CheckArgs(broadcast, client, net_type, net_name);
1285         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Send_Notification: %s\n", checkargs)); return; }
1286
1287         // retreive counts for the arguments of this notification
1288         entity notif = Get_Notif_Ent(net_type, net_name);
1289         if not(notif) { backtrace("Send_Notification: Could not find notification entity!\n"); return; }
1290
1291         if((notif.nent_stringcount + notif.nent_floatcount) > count)
1292         {
1293                 backtrace(sprintf(
1294                         strcat(
1295                                 "Not enough arguments for Send_Notification(%d, %s, %s, ...)! ",
1296                                 "stringcount(%d) + floatcount(%d) > count(%d)\n",
1297                                 "Check the definition and function call for accuracy...?\n"
1298                         ),
1299                         broadcast, Get_Notif_TypeName(net_type), notif.nent_name,
1300                         notif.nent_stringcount, notif.nent_floatcount, count
1301                 ));
1302                 return;
1303         }
1304         else if((notif.nent_stringcount + notif.nent_floatcount) < count)
1305         {
1306                 backtrace(sprintf(
1307                         strcat(
1308                                 "Too many arguments for Send_Notification(%d, %s, %s, ...)! ",
1309                                 "stringcount(%d) + floatcount(%d) < count(%d)\n",
1310                                 "Check the definition and function call for accuracy...?\n"
1311                         ),
1312                         broadcast, Get_Notif_TypeName(net_type), notif.nent_name,
1313                         notif.nent_stringcount, notif.nent_floatcount, count
1314                 ));
1315                 return;
1316         }
1317
1318         #ifdef NOTIFICATIONS_DEBUG
1319         string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : "");
1320         string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : "");
1321         string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : "");
1322         string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : "");
1323         float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0);
1324         float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0);
1325         float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0);
1326         float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0);
1327         dprint(sprintf(
1328                 "Send_Notification(%d, %s, %s, %s, %s);\n",
1329                 broadcast,
1330                 Get_Notif_TypeName(net_type),
1331                 notif.nent_name,
1332                 strreplace("\n", "\\n", sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1333                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
1334         ));
1335         #endif
1336
1337         entity net_notif = spawn();
1338         net_notif.owner = notif;
1339         net_notif.classname = "net_notification";
1340         net_notif.nent_broadcast = broadcast;
1341         net_notif.nent_client = client;
1342         net_notif.nent_net_type = net_type;
1343         net_notif.nent_net_name = net_name;
1344         net_notif.nent_stringcount = notif.nent_stringcount;
1345         net_notif.nent_floatcount = notif.nent_floatcount;
1346
1347         float i;
1348         for(i = 0; i < net_notif.nent_stringcount; ++i) { net_notif.nent_strings[i] = strzone(...(i, string)); }
1349         for(i = 0; i < net_notif.nent_floatcount; ++i) { net_notif.nent_floats[i] = ...((net_notif.nent_stringcount + i), float); }
1350
1351         net_notif.think = Net_Notification_Remove;
1352         net_notif.nextthink =
1353                 ((time > autocvar_notification_lifetime_mapload)
1354                 ?
1355                         (time + autocvar_notification_lifetime_runtime)
1356                         :
1357                         autocvar_notification_lifetime_mapload
1358                 );
1359
1360         Net_LinkEntity(net_notif, FALSE, 0, Net_Write_Notification);
1361
1362         if(server_is_dedicated && (broadcast == NOTIF_ALL || broadcast == NOTIF_ALL_EXCEPT) && (net_type != MSG_CENTER))
1363         {
1364                 Local_Notification_WOVA(
1365                         net_type, net_name,
1366                         notif.nent_stringcount,
1367                         notif.nent_floatcount,
1368                         IFSTR(0), IFSTR(1), IFSTR(2), IFSTR(3),
1369                         IFFL(0), IFFL(1), IFFL(2), IFFL(3));
1370         }
1371 }
1372
1373 // WOVA = Without Variable Arguments
1374 void Send_Notification_WOVA(
1375         float broadcast, entity client,
1376         float net_type, float net_name,
1377         string s1, string s2, string s3, string s4,
1378         float f1, float f2, float f3, float f4)
1379 {
1380         entity notif = Get_Notif_Ent(net_type, net_name);
1381
1382         #ifdef NOTIFICATIONS_DEBUG
1383         dprint(sprintf(
1384                 "Send_Notification_WOVA(%d, %s, %s, %s, %s - %d %d);\n",
1385                 broadcast,
1386                 Get_Notif_TypeName(net_type),
1387                 notif.nent_name,
1388                 sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4),
1389                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4),
1390                 notif.nent_stringcount, notif.nent_floatcount
1391         ));
1392         #endif
1393
1394         #define VARITEM(stringc,floatc,args) \
1395                 if((notif.nent_stringcount == stringc) && (notif.nent_floatcount == floatc)) \
1396                         { Send_Notification(broadcast, client, net_type, net_name, args); return; }
1397         EIGHT_VARS_TO_VARARGS_VARLIST
1398         #undef VARITEM
1399         Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all
1400 }
1401 #endif // ifdef SVQC