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
1039                         {
1040                                 print(sprintf(
1041                                         "Read_Notification(%d) at %f: ^1TRIED TO KILL NO_CPID CENTERPRINT!\n",
1042                                         is_new,
1043                                         time
1044                                 ));
1045                         }
1046                 }
1047         }
1048         else
1049         {
1050                 notif = Get_Notif_Ent(net_type, net_name);
1051                 if not(notif) { backtrace("Read_Notification: Could not find notification entity!\n"); return; }
1052
1053                 #ifdef NOTIFICATIONS_DEBUG
1054                 dprint(sprintf(
1055                         "Read_Notification(%d) at %f: net_type = %s, net_name = %s\n",
1056                         is_new,
1057                         time,
1058                         Get_Notif_TypeName(net_type),
1059                         notif.nent_name
1060                 ));
1061                 #endif
1062
1063                 string s1 = ((0 < notif.nent_stringcount) ? ReadString() : "");
1064                 string s2 = ((1 < notif.nent_stringcount) ? ReadString() : "");
1065                 string s3 = ((2 < notif.nent_stringcount) ? ReadString() : "");
1066                 string s4 = ((3 < notif.nent_stringcount) ? ReadString() : "");
1067                 float f1 = ((0 < notif.nent_floatcount) ? ReadLong() : 0);
1068                 float f2 = ((1 < notif.nent_floatcount) ? ReadLong() : 0);
1069                 float f3 = ((2 < notif.nent_floatcount) ? ReadLong() : 0);
1070                 float f4 = ((3 < notif.nent_floatcount) ? ReadLong() : 0);
1071
1072                 if(is_new)
1073                 {
1074                         Local_Notification_WOVA(
1075                                 net_type, net_name,
1076                                 notif.nent_stringcount,
1077                                 notif.nent_floatcount,
1078                                 s1, s2, s3, s4,
1079                                 f1, f2, f3, f4);
1080                 }
1081         }
1082 }
1083 #endif
1084
1085 #ifdef SVQC
1086 void Net_Notification_Remove()
1087 {
1088         if not(self) { dprint(sprintf("Net_Notification_Remove() at %f: Missing self!?\n", time)); return; }
1089
1090         #ifdef NOTIFICATIONS_DEBUG
1091         dprint(sprintf(
1092                 "Net_Notification_Remove() at %f: %s '%s - %s' notification\n",
1093                 time,
1094                 ((self.nent_net_name == -1) ? "Killed" : "Removed"),
1095                 Get_Notif_TypeName(self.nent_net_type),
1096                 self.owner.nent_name
1097         ));
1098         #endif
1099
1100         float i;
1101         for(i = 0; i < 4; ++i) { if(self.nent_strings[i]) { strunzone(self.nent_strings[i]); } }
1102         remove(self);
1103 }
1104
1105 float Net_Write_Notification(entity client, float sf)
1106 {
1107         float i, send = FALSE;
1108
1109         switch(self.nent_broadcast)
1110         {
1111                 case NOTIF_ONE: // send to one client and their spectator
1112                 {
1113                         if(
1114                                 (client == self.nent_client)
1115                                 ||
1116                                 (
1117                                         IS_SPEC(client)
1118                                         &&
1119                                         (client.enemy == self.nent_client)
1120                                 )
1121                         ) { send = TRUE; }
1122                         break;
1123                 }
1124                 case NOTIF_ONE_ONLY: // send ONLY to one client
1125                 {
1126                         if(client == self.nent_client) { send = TRUE; }
1127                         break;
1128                 }
1129                 case NOTIF_TEAM: // send only to X team and their spectators
1130                 {
1131                         if(
1132                                 (client.team == self.nent_client.team)
1133                                 ||
1134                                 (
1135                                         IS_SPEC(client)
1136                                         &&
1137                                         (client.enemy.team == self.nent_client.team)
1138                                 )
1139                         ) { send = TRUE; }
1140                         break;
1141                 }
1142                 case NOTIF_TEAM_EXCEPT: // send only to X team and their spectators, except for Y person and their spectators
1143                 {
1144                         if(
1145                                 (client != self.nent_client)
1146                                 &&
1147                                 (
1148                                         (client.team == self.nent_client.team)
1149                                         ||
1150                                         (
1151                                                 IS_SPEC(client)
1152                                                 &&
1153                                                 (
1154                                                         (client.enemy != self.nent_client)
1155                                                         &&
1156                                                         (client.enemy.team == self.nent_client.team)
1157                                                 )
1158                                         )
1159                                 )
1160                         ) { send = TRUE; }
1161                         break;
1162                 }
1163                 case NOTIF_ALL: // send to everyone
1164                 {
1165                         send = TRUE;
1166                         break;
1167                 }
1168                 case NOTIF_ALL_EXCEPT: // send to everyone except X person and their spectators
1169                 {
1170                         if(
1171                                 (client != self.nent_client)
1172                                 &&
1173                                 !(
1174                                         IS_SPEC(client)
1175                                         &&
1176                                         (client.enemy == self.nent_client)
1177                                 )
1178                         ) { send = TRUE; }
1179                         break;
1180                 }
1181                 default: { send = FALSE; break; }
1182         }
1183
1184         if(send)
1185         {
1186                 WriteByte(MSG_ENTITY, ENT_CLIENT_NOTIFICATION);
1187                 WriteByte(MSG_ENTITY, self.nent_net_type);
1188                 WriteShort(MSG_ENTITY, self.nent_net_name);
1189                 for(i = 0; i < self.nent_stringcount; ++i) { WriteString(MSG_ENTITY, self.nent_strings[i]); }
1190                 for(i = 0; i < self.nent_floatcount; ++i) { WriteLong(MSG_ENTITY, self.nent_floats[i]); }
1191         }
1192
1193         return send;
1194 }
1195
1196 void Kill_Notification(
1197         float broadcast, entity client,
1198         float net_type, float net_name)
1199 {
1200         string checkargs = Notification_CheckArgs(broadcast, client, 1, 1);
1201         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Kill_Notification: %s\n", checkargs)); return; }
1202
1203         #ifdef NOTIFICATIONS_DEBUG
1204         dprint(sprintf(
1205                 "Kill_Notification(%d, '%s', %d, %d);\n",
1206                 broadcast,
1207                 client.netname,
1208                 net_type,
1209                 net_name
1210         ));
1211         #endif
1212
1213         entity notif, net_notif;
1214         float killed_cpid = NO_CPID;
1215
1216         switch(net_type)
1217         {
1218                 case 0:
1219                 {
1220                         killed_cpid = 0; // kill ALL centerprints
1221                         break;
1222                 }
1223
1224                 case MSG_CENTER:
1225                 {
1226                         if(net_name)
1227                         {
1228                                 entity notif = Get_Notif_Ent(net_type, net_name);
1229                                 if not(notif) { backtrace("Kill_Notification: Could not find notification entity!\n"); return; }
1230                                 killed_cpid = notif.nent_cpid;
1231                         }
1232                         else
1233                         {
1234                                 killed_cpid = 0; // kill ALL centerprints
1235                         }
1236                         break;
1237                 }
1238
1239                 case MSG_CENTER_CPID:
1240                 {
1241                         killed_cpid = net_name;
1242                         break;
1243                 }
1244         }
1245
1246         if(killed_cpid != NO_CPID)
1247         {
1248                 net_notif = spawn();
1249                 net_notif.classname = "net_kill_notification";
1250                 net_notif.nent_broadcast = broadcast;
1251                 net_notif.nent_client = client;
1252                 net_notif.nent_net_type = MSG_CENTER_CPID;
1253                 net_notif.nent_net_name = killed_cpid;
1254                 Net_LinkEntity(net_notif, FALSE, autocvar_notification_lifetime_runtime, Net_Write_Notification);
1255         }
1256
1257         for(notif = world; (notif = find(notif, classname, "net_notification"));)
1258         {
1259                 if(net_type)
1260                 {
1261                         if(killed_cpid != NO_CPID)
1262                         {
1263                                 if(notif.owner.nent_cpid == killed_cpid)
1264                                 {
1265                                         notif.nent_net_name = -1;
1266                                         notif.nextthink = time;
1267                                 }
1268                                 else { continue; } // we ARE looking for a specific CPID, don't kill everything else too
1269                         }
1270                         else if(notif.nent_net_type == net_type)
1271                         {
1272                                 if(net_name)
1273                                 {
1274                                         if(notif.nent_net_name == net_name) { notif.nent_net_name = -1; notif.nextthink = time; }
1275                                         else { continue; } // we ARE looking for a certain net_name, don't kill everything else too
1276                                 }
1277                                 else { notif.nent_net_name = -1; notif.nextthink = time; }
1278                         }
1279                         else { continue; } // we ARE looking for a certain net_type, don't kill everything else too
1280                 }
1281                 else { notif.nent_net_name = -1; notif.nextthink = time; }
1282         }
1283 }
1284
1285 void Send_Notification(
1286         float broadcast, entity client,
1287         float net_type, float net_name,
1288         ...count)
1289 {
1290         // check supplied broadcast, target, type, and name for errors
1291         string checkargs = Notification_CheckArgs(broadcast, client, net_type, net_name);
1292         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Send_Notification: %s\n", checkargs)); return; }
1293
1294         // retreive counts for the arguments of this notification
1295         entity notif = Get_Notif_Ent(net_type, net_name);
1296         if not(notif) { backtrace("Send_Notification: Could not find notification entity!\n"); return; }
1297
1298         if((notif.nent_stringcount + notif.nent_floatcount) > count)
1299         {
1300                 backtrace(sprintf(
1301                         strcat(
1302                                 "Not enough arguments for Send_Notification(%d, %s, %s, ...)! ",
1303                                 "stringcount(%d) + floatcount(%d) > count(%d)\n",
1304                                 "Check the definition and function call for accuracy...?\n"
1305                         ),
1306                         broadcast, Get_Notif_TypeName(net_type), notif.nent_name,
1307                         notif.nent_stringcount, notif.nent_floatcount, count
1308                 ));
1309                 return;
1310         }
1311         else if((notif.nent_stringcount + notif.nent_floatcount) < count)
1312         {
1313                 backtrace(sprintf(
1314                         strcat(
1315                                 "Too many arguments for Send_Notification(%d, %s, %s, ...)! ",
1316                                 "stringcount(%d) + floatcount(%d) < count(%d)\n",
1317                                 "Check the definition and function call for accuracy...?\n"
1318                         ),
1319                         broadcast, Get_Notif_TypeName(net_type), notif.nent_name,
1320                         notif.nent_stringcount, notif.nent_floatcount, count
1321                 ));
1322                 return;
1323         }
1324
1325         #ifdef NOTIFICATIONS_DEBUG
1326         string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : "");
1327         string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : "");
1328         string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : "");
1329         string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : "");
1330         float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0);
1331         float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0);
1332         float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0);
1333         float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0);
1334         dprint(sprintf(
1335                 "Send_Notification(%d, %s, %s, %s, %s);\n",
1336                 broadcast,
1337                 Get_Notif_TypeName(net_type),
1338                 notif.nent_name,
1339                 strreplace("\n", "\\n", sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)),
1340                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
1341         ));
1342         #endif
1343
1344         entity net_notif = spawn();
1345         net_notif.owner = notif;
1346         net_notif.classname = "net_notification";
1347         net_notif.nent_broadcast = broadcast;
1348         net_notif.nent_client = client;
1349         net_notif.nent_net_type = net_type;
1350         net_notif.nent_net_name = net_name;
1351         net_notif.nent_stringcount = notif.nent_stringcount;
1352         net_notif.nent_floatcount = notif.nent_floatcount;
1353
1354         float i;
1355         for(i = 0; i < net_notif.nent_stringcount; ++i) { net_notif.nent_strings[i] = strzone(...(i, string)); }
1356         for(i = 0; i < net_notif.nent_floatcount; ++i) { net_notif.nent_floats[i] = ...((net_notif.nent_stringcount + i), float); }
1357
1358         net_notif.think = Net_Notification_Remove;
1359         net_notif.nextthink =
1360                 ((time > autocvar_notification_lifetime_mapload)
1361                 ?
1362                         (time + autocvar_notification_lifetime_runtime)
1363                         :
1364                         autocvar_notification_lifetime_mapload
1365                 );
1366
1367         Net_LinkEntity(net_notif, FALSE, 0, Net_Write_Notification);
1368
1369         if(server_is_dedicated && (broadcast == NOTIF_ALL || broadcast == NOTIF_ALL_EXCEPT) && (net_type != MSG_CENTER))
1370         {
1371                 Local_Notification_WOVA(
1372                         net_type, net_name,
1373                         notif.nent_stringcount,
1374                         notif.nent_floatcount,
1375                         IFSTR(0), IFSTR(1), IFSTR(2), IFSTR(3),
1376                         IFFL(0), IFFL(1), IFFL(2), IFFL(3));
1377         }
1378 }
1379
1380 // WOVA = Without Variable Arguments
1381 void Send_Notification_WOVA(
1382         float broadcast, entity client,
1383         float net_type, float net_name,
1384         string s1, string s2, string s3, string s4,
1385         float f1, float f2, float f3, float f4)
1386 {
1387         entity notif = Get_Notif_Ent(net_type, net_name);
1388
1389         #ifdef NOTIFICATIONS_DEBUG
1390         dprint(sprintf(
1391                 "Send_Notification_WOVA(%d, %s, %s, %s, %s - %d %d);\n",
1392                 broadcast,
1393                 Get_Notif_TypeName(net_type),
1394                 notif.nent_name,
1395                 sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4),
1396                 sprintf("%d, %d, %d, %d", f1, f2, f3, f4),
1397                 notif.nent_stringcount, notif.nent_floatcount
1398         ));
1399         #endif
1400
1401         #define VARITEM(stringc,floatc,args) \
1402                 if((notif.nent_stringcount == stringc) && (notif.nent_floatcount == floatc)) \
1403                         { Send_Notification(broadcast, client, net_type, net_name, args); return; }
1404         EIGHT_VARS_TO_VARARGS_VARLIST
1405         #undef VARITEM
1406         Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all
1407 }
1408 #endif // ifdef SVQC