qcsrc/common/notifications.qc

   1 // ================================================
   2 //  Unified notification system, written by Samual
   3 //  Last updated: February, 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_WEAPON: return "MSG_WEAPON";
  13                 case MSG_DEATH: return "MSG_DEATH";
  14         }
  15         backtrace(sprintf("Get_Notif_TypeName(%d): Improper net type!\n", net_type));
  16         return "your ass";
  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_WEAPON: return msg_weapon_notifs[net_name - 1];
  26                 case MSG_DEATH: return msg_death_notifs[net_name - 1];
  27         }
  28         backtrace(sprintf("Get_Notif_Ent(%d, %d): Improper net type!\n", net_type, net_name));
  29         return world;
  30 }
  31
  32 string Notification_CheckArgs_TypeName(float net_type, float net_name)
  33 {
  34         // check supplied type and name for errors
  35         string checkargs = "";
  36         #define CHECKARG_TYPENAME(type) case MSG_##type##: \
  37                 { if(!net_name || (net_name > NOTIF_##type##_COUNT)) \
  38                 { checkargs = sprintf("Improper name: %d!", net_name); } break; }
  39         switch(net_type)
  40         {
  41                 CHECKARG_TYPENAME(INFO)
  42                 CHECKARG_TYPENAME(CENTER)
  43                 CHECKARG_TYPENAME(WEAPON)
  44                 CHECKARG_TYPENAME(DEATH)
  45                 default: { checkargs = sprintf("Improper type: %d!", checkargs, net_type); break; }
  46         }
  47         #undef CHECKARG_TYPENAME
  48         return checkargs;
  49 }
  50
  51 #ifdef SVQC
  52 string Notification_CheckArgs(float broadcast, entity client, 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_ANY_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_ANY:
  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 //  Frontend Notification Pushing
 101 // ===============================
 102
 103 void Dump_Notifications(float fh, float alsoprint)
 104 {
 105         #define NOTIF_WRITE(a) { \
 106                 fputs(fh, a); \
 107                 if(alsoprint) { print(a); } }
 108         #define NOTIF_WRITE_ENTITY(name,default,description) { \
 109                 notif_msg = \
 110                         sprintf( \
 111                                 "seta notification_%s \"%d\" \"%s\"\n", \
 112                                 name, default, description \
 113                         ); \
 114                 NOTIF_WRITE(notif_msg) }
 115         #define NOTIF_WRITE_HARDCODED(cvar,default,description) { \
 116                 notif_msg = \
 117                         sprintf( \
 118                                 "seta notification_%s \"%s\" \"%s\"\n", \
 119                                 cvar, default, description \
 120                         ); \
 121                 NOTIF_WRITE(notif_msg) }
 122
 123         string notif_msg;
 124         float i;
 125         entity e;
 126
 127         // Note: This warning only applies to the notifications.cfg file that is output...
 128
 129         // You ARE supposed to manually edit this function to add i.e. hard coded
 130         // notification variables for mutators or game modes or such and then
 131         // regenerate the notifications.cfg file from the new code.
 132
 133         NOTIF_WRITE("// ********************************************** //\n");
 134         NOTIF_WRITE("// ** WARNING - DO NOT MANUALLY EDIT THIS FILE ** //\n");
 135         NOTIF_WRITE("// **                                          ** //\n");
 136         NOTIF_WRITE("// **  This file is automatically generated    ** //\n");
 137         NOTIF_WRITE("// **  by code with the command 'dumpnotifs'.  ** //\n");
 138         NOTIF_WRITE("// **                                          ** //\n");
 139         NOTIF_WRITE("// **  If you add a new notification, please   ** //\n");
 140         NOTIF_WRITE("// **  regenerate this file with that command  ** //\n");
 141         NOTIF_WRITE("// **  making sure that the output matches     ** //\n");
 142         NOTIF_WRITE("// **  with the lists and defaults in code.    ** //\n");
 143         NOTIF_WRITE("// **                                          ** //\n");
 144         NOTIF_WRITE("// ********************************************** //\n");
 145
 146         // These notifications will also append their string as a comment...
 147         // This is not necessary, and does not matter if they vary between config versions,
 148         // it is just a semi-helpful tool for those who want to manually change their user settings.
 149
 150         NOTIF_WRITE(sprintf("\n// MSG_INFO notifications (count = %d):\n", NOTIF_INFO_COUNT));
 151         for(i = 1; i <= NOTIF_INFO_COUNT; ++i)
 152         {
 153                 e = Get_Notif_Ent(MSG_INFO, i);
 154                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 155                 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)");
 156         }
 157
 158         NOTIF_WRITE(sprintf("\n// MSG_CENTER notifications (count = %d):\n", NOTIF_CENTER_COUNT));
 159         for(i = 1; i <= NOTIF_CENTER_COUNT; ++i)
 160         {
 161                 e = Get_Notif_Ent(MSG_CENTER, i);
 162                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 163                 NOTIF_WRITE_ENTITY(e.nent_name, e.nent_default, "Notification control cvar: 0 = off, 1 = centerprint");
 164         }
 165
 166         NOTIF_WRITE(sprintf("\n// MSG_WEAPON notifications (count = %d):\n", NOTIF_WEAPON_COUNT));
 167         for(i = 1; i <= NOTIF_WEAPON_COUNT; ++i)
 168         {
 169                 e = Get_Notif_Ent(MSG_WEAPON, i);
 170                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 171                 NOTIF_WRITE_ENTITY(e.nent_name, e.nent_default, "Notification control cvar: 0 = off, 1 = trigger subcalls");
 172         }
 173
 174         NOTIF_WRITE(sprintf("\n// MSG_DEATH notifications (count = %d):\n", NOTIF_DEATH_COUNT));
 175         for(i = 1; i <= NOTIF_DEATH_COUNT; ++i)
 176         {
 177                 e = Get_Notif_Ent(MSG_DEATH, i);
 178                 if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 179                 NOTIF_WRITE_ENTITY(e.nent_name, e.nent_default, "Notification control cvar: 0 = off, 1 = trigger subcalls");
 180         }
 181
 182         // edit these to match whichever cvars are used for specific notification options
 183         NOTIF_WRITE("\n// HARD CODED notification variables:\n");
 184         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)");
 185         NOTIF_WRITE_HARDCODED("show_location",                                          "0",    "Append location information to MSG_INFO death/kill messages");
 186         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)'");
 187         NOTIF_WRITE_HARDCODED("show_sprees",                                            "1",    "Print information about sprees in death/kill messages");
 188         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");
 189         NOTIF_WRITE_HARDCODED("show_sprees_center_specialonly",         "1",    "Don't show spree information in MSG_CENTER messages if it isn't an achievement");
 190         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");
 191         NOTIF_WRITE_HARDCODED("show_sprees_info_newline",                       "0",    "Show attacker spree information for MSG_INFO messages on a separate line than the death notification itself");
 192         NOTIF_WRITE_HARDCODED("show_sprees_info_specialonly",           "1",    "Don't show attacker spree information in MSG_INFO messages if it isn't an achievement");
 193         NOTIF_WRITE_HARDCODED("item_centerprinttime",                           "1.5",  "How long to show item information centerprint messages (like 'You got the Electro' or such)");
 194         NOTIF_WRITE_HARDCODED("errors_are_fatal",                                       "1",    "If a notification fails upon initialization, cause a Host_Error to stop the program");
 195         NOTIF_WRITE_HARDCODED("ctf_pickup_team_verbose",                        "0",    "Show extra information if a team mate picks up a flag");
 196         NOTIF_WRITE_HARDCODED("ctf_pickup_enemy_verbose",                       "0",    "Show extra information if an enemy picks up a flag");
 197         NOTIF_WRITE_HARDCODED("ctf_capture_verbose",                            "0",    "Show extra information when someone captures a flag");
 198         NOTIF_WRITE_HARDCODED("frag_verbose",                                           "1",    "Show extra information when you frag someone (or when you are fragged");
 199         NOTIF_WRITE_HARDCODED("lifetime_runtime",                                       "0.5",  "Amount of time that notification entities last on the server during runtime (In seconds)");
 200         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)");
 201
 202         NOTIF_WRITE(sprintf("\n// Notification counts (total = %d): MSG_INFO = %d, MSG_CENTER = %d, MSG_WEAPON = %d, MSG_DEATH = %d\n",
 203                 (NOTIF_INFO_COUNT + NOTIF_CENTER_COUNT + NOTIF_WEAPON_COUNT + NOTIF_DEATH_COUNT),
 204                 NOTIF_INFO_COUNT, NOTIF_CENTER_COUNT, NOTIF_WEAPON_COUNT, NOTIF_DEATH_COUNT));
 205
 206         return;
 207         #undef NOTIF_WRITE_HARDCODED
 208         #undef NOTIF_WRITE_ENTITY
 209         #undef NOTIF_WRITE
 210 }
 211
 212 #ifdef SVQC
 213 void Notification_GetCvars()
 214 {
 215         GetCvars_handleFloat(get_cvars_s, get_cvars_f, FRAG_VERBOSE, "notification_frag_verbose");
 216 }
 217 #endif
 218
 219 string Local_Notification_sprintf(string input, string args,
 220         string s1, string s2, string s3, string s4,
 221         float f1, float f2, float f3, float f4)
 222 {
 223         #ifdef NOTIFICATIONS_DEBUG
 224         dprint(
 225                 sprintf("Local_Notification_sprintf('%s^7', '%s', %s, %s);\n",
 226                         strreplace("\n", "\\n", input),
 227                         args,
 228                         sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4),
 229                         sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
 230                 )
 231         );
 232         #endif
 233
 234         string selected;
 235         float sel_num;
 236         for(sel_num = 0; sel_num < NOTIF_MAX_ARGS; ++sel_num) { arg_slot[sel_num] = ""; }
 237
 238         string tmp_s;
 239
 240         for(sel_num = 0;(args != "");)
 241         {
 242                 selected = car(args); args = cdr(args);
 243                 NOTIF_HIT_MAX(NOTIF_MAX_ARGS, "Local_Notification_sprintf")
 244                 switch(strtolower(selected))
 245                 {
 246                         #define ARG_CASE(prog,selected,result) \
 247                                 #ifdef CSQC \
 248                                         #if (prog != ARG_SV) && (prog != ARG_DC) \
 249                                                 case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 250                                         #endif \
 251                                 #else \
 252                                         #if (prog != ARG_CS) && (prog != ARG_DC) \
 253                                                 case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 254                                         #endif \
 255                                 #endif
 256                         NOTIF_ARGUMENT_LIST
 257                         #undef ARG_CASE
 258                         default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_ARGS, "Local_Notification_sprintf")
 259                 }
 260         }
 261         return sprintf(input, arg_slot[0], arg_slot[1], arg_slot[2], arg_slot[3], arg_slot[4], arg_slot[5], arg_slot[6]);
 262 }
 263
 264 #ifdef CSQC
 265 void Local_Notification_HUD_Notify_Push(string icon, string hudargs, string s1, string s2, string s3, string s4)
 266 {
 267         string selected;
 268         float sel_num;
 269         arg_slot[0] = ""; arg_slot[1] = "";
 270
 271         for(sel_num = 0;(hudargs != "");)
 272         {
 273                 selected = car(hudargs); hudargs = cdr(hudargs);
 274                 NOTIF_HIT_MAX(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push")
 275                 switch(strtolower(selected))
 276                 {
 277                         #define ARG_CASE(prog,selected,result) \
 278                                 #if (prog == ARG_CS_SV_HA) \
 279                                         case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 280                                 #endif
 281                         NOTIF_ARGUMENT_LIST
 282                         #undef ARG_CASE
 283                         default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push")
 284                 }
 285         }
 286         HUD_Notify_Push(icon, arg_slot[0], arg_slot[1]);
 287 }
 288
 289 void Local_Notification_centerprint_generic(string input, string durcnt, float cpid, float f1, float f2)
 290 {
 291         string selected;
 292         float sel_num;
 293         arg_slot[0] = ""; arg_slot[1] = "";
 294
 295         for(sel_num = 0;(durcnt != "");)
 296         {
 297                 selected = car(durcnt); durcnt = cdr(durcnt);
 298                 NOTIF_HIT_MAX(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic")
 299                 switch(strtolower(selected))
 300                 {
 301                         #define ARG_CASE(prog,selected,result) \
 302                                 #if (prog == ARG_CS_SV_DC) || (prog == ARG_DC) \
 303                                         case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \
 304                                 #endif
 305                         NOTIF_ARGUMENT_LIST
 306                         #undef ARG_CASE
 307                         default:
 308                         {
 309                                 if(ftos(stof(selected)) != "") { arg_slot[sel_num] = selected; ++sel_num; }
 310                                 else { NOTIF_HIT_UNKNOWN(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic") }
 311                                 break;
 312                         }
 313                 }
 314         }
 315         centerprint_generic(cpid, input, stof(arg_slot[0]), stof(arg_slot[1]));
 316 }
 317 #endif
 318
 319 void Local_Notification(float net_type, float net_name, ...count)
 320 {
 321         // check supplied type and name for errors
 322         string checkargs = Notification_CheckArgs_TypeName(net_type, net_name);
 323         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Local_Notification: %s\n", checkargs)); return; }
 324
 325         entity notif = Get_Notif_Ent(net_type, net_name);
 326         if not(notif) { backtrace("Local_Notification: Could not find notification entity!\n"); return; }
 327
 328         #ifdef NOTIFICATIONS_DEBUG
 329         if not(notif.nent_enabled) { dprint(sprintf("Local_Notification(%s, %s): Entity was disabled...\n", Get_Notif_TypeName(net_type), notif.nent_name)); return; }
 330         #endif
 331
 332         if((notif.nent_stringcount + notif.nent_floatcount) > count)
 333         {
 334                 backtrace(sprintf(
 335                         strcat(
 336                                 "Not enough arguments for Local_Notification(%s, %s, ...)! ",
 337                                 "stringcount(%d) + floatcount(%d) > count(%d)\n",
 338                                 "Check the definition and function call for accuracy...?\n"
 339                         ),
 340                         Get_Notif_TypeName(net_type), notif.nent_name, notif.nent_stringcount, notif.nent_floatcount, count));
 341                 return;
 342         }
 343         else if((notif.nent_stringcount + notif.nent_floatcount) < count)
 344         {
 345                 backtrace(sprintf(
 346                         strcat(
 347                                 "Too many arguments for Local_Notification(%s, %s, ...)! ",
 348                                 "stringcount(%d) + floatcount(%d) < count(%d)\n",
 349                                 "Check the definition and function call for accuracy...?\n"
 350                         ),
 351                         Get_Notif_TypeName(net_type), notif.nent_name, notif.nent_stringcount, notif.nent_floatcount, count));
 352                 return;
 353         }
 354
 355         string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : "");
 356         string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : "");
 357         string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : "");
 358         string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : "");
 359         float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0);
 360         float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0);
 361         float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0);
 362         float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0);
 363
 364         #ifdef NOTIFICATIONS_DEBUG
 365         dprint(
 366                 sprintf("Local_Notification(%s, %s, %s, %s);\n",
 367                         Get_Notif_TypeName(net_type),
 368                         notif.nent_name,
 369                         sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4),
 370                         sprintf("%d, %d, %d, %d", f1, f2, f3, f4)
 371                 )
 372         );
 373         #endif
 374
 375         switch(net_type)
 376         {
 377                 case MSG_INFO:
 378                 {
 379                         print(
 380                                 Local_Notification_sprintf(
 381                                         notif.nent_string,
 382                                         notif.nent_args,
 383                                         s1, s2, s3, s4,
 384                                         f1, f2, f3, f4)
 385                         );
 386                         #ifdef CSQC
 387                         if(notif.nent_icon != "")
 388                         {
 389                                 Local_Notification_HUD_Notify_Push(
 390                                         notif.nent_icon,
 391                                         notif.nent_hudargs,
 392                                         s1, s2, s3, s4);
 393                         }
 394                         #endif
 395                         break;
 396                 }
 397
 398                 #ifdef CSQC
 399                 case MSG_CENTER:
 400                 {
 401                         Local_Notification_centerprint_generic(
 402                                 Local_Notification_sprintf(
 403                                         notif.nent_string,
 404                                         notif.nent_args,
 405                                         s1, s2, s3, s4,
 406                                         f1, f2, f3, f4),
 407                                 notif.nent_durcnt,
 408                                 notif.nent_cpid,
 409                                 f1, f2);
 410                         break;
 411                 }
 412                 #endif
 413
 414                 case MSG_WEAPON:
 415                 case MSG_DEATH:
 416                 {
 417                         if(notif.nent_msginfo)
 418                         if(notif.nent_msginfo.nent_enabled)
 419                         {
 420                                 Local_Notification_WOVA(
 421                                         MSG_INFO,
 422                                         notif.nent_msginfo.nent_id,
 423                                         notif.nent_msginfo.nent_stringcount,
 424                                         notif.nent_msginfo.nent_floatcount,
 425                                         s1, s2, s3, s4,
 426                                         f1, f2, f3, f4);
 427                         }
 428                         #ifdef CSQC
 429                         if(notif.nent_msgcenter)
 430                         if(notif.nent_msgcenter.nent_enabled)
 431                         {
 432                                 Local_Notification_WOVA(
 433                                         MSG_CENTER,
 434                                         notif.nent_msgcenter.nent_id,
 435                                         notif.nent_msgcenter.nent_stringcount,
 436                                         notif.nent_msgcenter.nent_floatcount,
 437                                         s1, s2, s3, s4,
 438                                         f1, f2, f3, f4);
 439                         }
 440                         #endif
 441                         break;
 442                 }
 443         }
 444 }
 445
 446 // WOVA = Without Variable Arguments
 447 void Local_Notification_WOVA(float net_type, float net_name,
 448         float stringcount, float floatcount,
 449         string s1, string s2, string s3, string s4,
 450         float f1, float f2, float f3, float f4)
 451 {
 452         #define VARITEM(stringc,floatc,args) \
 453                 if((stringcount == stringc) && (floatcount == floatc)) \
 454                         { Local_Notification(net_type, net_name, args); return; }
 455         EIGHT_VARS_TO_VARARGS_VARLIST
 456         #undef VARITEM
 457         Local_Notification(net_type, net_name); // some notifications don't have any arguments at all
 458 }
 459
 460
 461 // =========================
 462 //  Notification Networking
 463 // =========================
 464
 465 #ifdef CSQC
 466 void Read_Notification(float is_new)
 467 {
 468         float net_type = ReadByte();
 469         float net_name = ReadShort();
 470
 471         if(net_type == MSG_CENTER_KILL)
 472         {
 473                 if(is_new)
 474                 {
 475                         if(net_name == 0) { reset_centerprint_messages(); }
 476                         else
 477                         {
 478                                 entity notif = Get_Notif_Ent(MSG_CENTER, net_name);
 479                                 if not(notif) { backtrace("Read_Notification: Could not find notification entity!\n"); return; }
 480                                 centerprint_generic(notif.nent_cpid, "", 0, 0);
 481                         }
 482                 }
 483         }
 484         else
 485         {
 486                 entity notif = Get_Notif_Ent(net_type, net_name);
 487                 if not(notif) { backtrace("Read_Notification: Could not find notification entity!\n"); return; }
 488
 489                 #ifdef NOTIFICATIONS_DEBUG
 490                 dprint(sprintf("Read_Notification(%d) at %f: net_type = %s, net_name = %s\n", is_new, time, Get_Notif_TypeName(net_type), notif.nent_name));
 491                 #endif
 492
 493                 string s1 = ((0 < notif.nent_stringcount) ? ReadString() : "");
 494                 string s2 = ((1 < notif.nent_stringcount) ? ReadString() : "");
 495                 string s3 = ((2 < notif.nent_stringcount) ? ReadString() : "");
 496                 string s4 = ((3 < notif.nent_stringcount) ? ReadString() : "");
 497                 float f1 = ((0 < notif.nent_floatcount) ? ReadLong() : 0);
 498                 float f2 = ((1 < notif.nent_floatcount) ? ReadLong() : 0);
 499                 float f3 = ((2 < notif.nent_floatcount) ? ReadLong() : 0);
 500                 float f4 = ((3 < notif.nent_floatcount) ? ReadLong() : 0);
 501
 502                 if(is_new)
 503                 {
 504                         Local_Notification_WOVA(
 505                                 net_type, net_name,
 506                                 notif.nent_stringcount,
 507                                 notif.nent_floatcount,
 508                                 s1, s2, s3, s4,
 509                                 f1, f2, f3, f4);
 510                 }
 511         }
 512 }
 513 #endif
 514
 515 #ifdef SVQC
 516 void Net_Notification_Remove()
 517 {
 518         float i;
 519         for(i = 0; i < 4; ++i) { if(self.nent_strings[i]) { strunzone(self.nent_strings[i]); } }
 520         remove(self);
 521 }
 522
 523 float Net_Write_Notification(entity client, float sf)
 524 {
 525         float i, send = FALSE;
 526
 527         switch(self.nent_broadcast)
 528         {
 529                 case NOTIF_ONE: // send to one client and their spectator
 530                 {
 531                         if(
 532                                 (client == self.nent_client)
 533                                 ||
 534                                 (
 535                                         (client.classname == STR_SPECTATOR)
 536                                         &&
 537                                         (client.enemy == self.nent_client)
 538                                 )
 539                         ) { send = TRUE; }
 540                         break;
 541                 }
 542                 case NOTIF_ONE_ONLY: // send ONLY to one client
 543                 {
 544                         if(client == self.nent_client) { send = TRUE; }
 545                         break;
 546                 }
 547                 case NOTIF_TEAM: // send only to X team and their spectators
 548                 {
 549                         if(
 550                                 (client.team == self.nent_client.team)
 551                                 ||
 552                                 (
 553                                         (client.classname == STR_SPECTATOR)
 554                                         &&
 555                                         (client.enemy.team == self.nent_client.team)
 556                                 )
 557                         ) { send = TRUE; }
 558                         break;
 559                 }
 560                 case NOTIF_TEAM_EXCEPT: // send only to X team and their spectators, except for Y person and their spectators
 561                 {
 562                         if(
 563                                 (client != self.nent_client)
 564                                 &&
 565                                 (
 566                                         (client.team == self.nent_client.team)
 567                                         ||
 568                                         (
 569                                                 (client.classname == STR_SPECTATOR)
 570                                                 &&
 571                                                 (
 572                                                         (client.enemy != self.nent_client)
 573                                                         &&
 574                                                         (client.enemy.team == self.nent_client.team)
 575                                                 )
 576                                         )
 577                                 )
 578                         ) { send = TRUE; }
 579                         break;
 580                 }
 581                 case NOTIF_ANY: // send to everyone
 582                 {
 583                         send = TRUE;
 584                         break;
 585                 }
 586                 case NOTIF_ANY_EXCEPT: // send to everyone except X person and their spectators
 587                 {
 588                         if(
 589                                 (client != self.nent_client)
 590                                 &&
 591                                 !(
 592                                         (client.classname == STR_SPECTATOR)
 593                                         &&
 594                                         (client.enemy == self.nent_client)
 595                                 )
 596                         ) { send = TRUE; }
 597                         break;
 598                 }
 599                 default: { send = FALSE; break; }
 600         }
 601
 602         if(send)
 603         {
 604                 WriteByte(MSG_ENTITY, ENT_CLIENT_NOTIFICATION);
 605                 WriteByte(MSG_ENTITY, self.nent_net_type);
 606                 WriteShort(MSG_ENTITY, self.nent_net_name);
 607                 for(i = 0; i < self.nent_stringcount; ++i) { WriteString(MSG_ENTITY, self.nent_strings[i]); }
 608                 for(i = 0; i < self.nent_floatcount; ++i) { WriteLong(MSG_ENTITY, self.nent_floats[i]); }
 609         }
 610
 611         return send;
 612 }
 613
 614 void Kill_Notification(float broadcast, entity client, float net_type, float net_name)
 615 {
 616         string checkargs = Notification_CheckArgs(broadcast, client, net_type, 1);
 617         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Kill_Notification: %s\n", checkargs)); return; }
 618
 619         entity notif;
 620
 621         // if this is a centerprint, we must tell the client
 622         // to kill the cpid in the centerprint queue
 623         if(net_type == MSG_CENTER)
 624         {
 625                 notif = spawn();
 626                 notif.classname = "net_kill_notification";
 627                 notif.nent_broadcast = broadcast;
 628                 notif.nent_client = client;
 629                 notif.nent_net_type = MSG_CENTER_KILL;
 630                 notif.nent_net_name = net_name;
 631                 Net_LinkEntity(notif, FALSE, autocvar_notification_lifetime_runtime, Net_Write_Notification);
 632         }
 633
 634         for(notif = world; (notif = find(notif, classname, "net_notification"));)
 635         {
 636                 // now kill the old send notification entity
 637                 if(notif.nent_net_type == net_type)
 638                 {
 639                         if(net_name)
 640                                 { if(notif.nent_net_name == net_name) { notif.think(); } }
 641                         else
 642                                 { notif.think(); }
 643
 644                         #ifdef NOTIFICATIONS_DEBUG
 645                         print(sprintf("killed '%s'\n", notif.classname));
 646                         #endif
 647                 }
 648         }
 649 }
 650
 651 void Send_Notification(float broadcast, entity client,
 652         float net_type, float net_name, ...count)
 653 {
 654         // check supplied broadcast, target, type, and name for errors
 655         string checkargs = Notification_CheckArgs(broadcast, client, net_type, net_name);
 656         if(checkargs != "") { backtrace(sprintf("Incorrect usage of Send_Notification: %s\n", checkargs)); return; }
 657
 658         // retreive counts for the arguments of this notification
 659         entity notif = Get_Notif_Ent(net_type, net_name);
 660         if not(notif) { backtrace("Send_Notification: Could not find notification entity!\n"); return; }
 661
 662         if((notif.nent_stringcount + notif.nent_floatcount) > count)
 663         {
 664                 backtrace(sprintf(
 665                         strcat(
 666                                 "Not enough arguments for Send_Notification(%d, %s, %s, ...)! ",
 667                                 "stringcount(%d) + floatcount(%d) > count(%d)\n",
 668                                 "Check the definition and function call for accuracy...?\n"
 669                         ),
 670                         broadcast, Get_Notif_TypeName(net_type), notif.nent_name, notif.nent_stringcount, notif.nent_floatcount, count));
 671                 return;
 672         }
 673         else if((notif.nent_stringcount + notif.nent_floatcount) < count)
 674         {
 675                 backtrace(sprintf(
 676                         strcat(
 677                                 "Too many arguments for Send_Notification(%d, %s, %s, ...)! ",
 678                                 "stringcount(%d) + floatcount(%d) < count(%d)\n",
 679                                 "Check the definition and function call for accuracy...?\n"
 680                         ),
 681                         broadcast, Get_Notif_TypeName(net_type), notif.nent_name, notif.nent_stringcount, notif.nent_floatcount, count));
 682                 return;
 683         }
 684
 685         #ifdef NOTIFICATIONS_DEBUG
 686         string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : "");
 687         string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : "");
 688         string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : "");
 689         string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : "");
 690         float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0);
 691         float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0);
 692         float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0);
 693         float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0);
 694         dprint(
 695                 sprintf("Send_Notification(%d, %s, %s, %s, %s - %d %d);\n",
 696                         broadcast,
 697                         Get_Notif_TypeName(net_type),
 698                         notif.nent_name,
 699                         sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4),
 700                         sprintf("%d, %d, %d, %d", f1, f2, f3, f4),
 701                         notif.nent_stringcount, notif.nent_floatcount
 702                 )
 703         );
 704         #endif
 705
 706         entity net_notif = spawn();
 707         net_notif.classname = "net_notification";
 708         net_notif.nent_broadcast = broadcast;
 709         net_notif.nent_client = client;
 710         net_notif.nent_net_type = net_type;
 711         net_notif.nent_net_name = net_name;
 712         net_notif.nent_stringcount = notif.nent_stringcount;
 713         net_notif.nent_floatcount = notif.nent_floatcount;
 714
 715         float i;
 716         for(i = 0; i < net_notif.nent_stringcount; ++i) { net_notif.nent_strings[i] = strzone(...(i, string)); }
 717         for(i = 0; i < net_notif.nent_floatcount; ++i) { net_notif.nent_floats[i] = ...((net_notif.nent_stringcount + i), float); }
 718
 719         net_notif.think = Net_Notification_Remove;
 720         net_notif.nextthink =
 721                 ((time > autocvar_notification_lifetime_mapload)
 722                 ?
 723                         (time + autocvar_notification_lifetime_runtime)
 724                         :
 725                         autocvar_notification_lifetime_mapload
 726                 );
 727
 728         Net_LinkEntity(net_notif, FALSE, 0, Net_Write_Notification);
 729
 730         if(server_is_dedicated && (broadcast == NOTIF_ANY || broadcast == NOTIF_ANY_EXCEPT) && (net_type != MSG_CENTER))
 731         {
 732                 Local_Notification_WOVA(
 733                         net_type, net_name,
 734                         notif.nent_stringcount,
 735                         notif.nent_floatcount,
 736                         IFSTR(0), IFSTR(1), IFSTR(2), IFSTR(3),
 737                         IFFL(0), IFFL(1), IFFL(2), IFFL(3));
 738         }
 739 }
 740
 741 // WOVA = Without Variable Arguments
 742 void Send_Notification_WOVA(float broadcast, entity client,
 743         float net_type, float net_name,
 744         string s1, string s2, string s3, string s4,
 745         float f1, float f2, float f3, float f4)
 746 {
 747         entity notif = Get_Notif_Ent(net_type, net_name);
 748
 749         #ifdef NOTIFICATIONS_DEBUG
 750         dprint(
 751                 sprintf("Send_Notification_WOVA(%d, %s, %s, %s, %s - %d %d);\n",
 752                         broadcast,
 753                         Get_Notif_TypeName(net_type),
 754                         notif.nent_name,
 755                         sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4),
 756                         sprintf("%d, %d, %d, %d", f1, f2, f3, f4),
 757                         notif.nent_stringcount, notif.nent_floatcount
 758                 )
 759         );
 760         #endif
 761
 762         #define VARITEM(stringc,floatc,args) \
 763                 if((notif.nent_stringcount == stringc) && (notif.nent_floatcount == floatc)) \
 764                         { Send_Notification(broadcast, client, net_type, net_name, args); return; }
 765         EIGHT_VARS_TO_VARARGS_VARLIST
 766         #undef VARITEM
 767         Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all
 768 }
 769
 770
 771 // =============================
 772 //  LEGACY NOTIFICATION SYSTEMS
 773 // =============================
 774
 775 void Send_CSQC_Centerprint_Generic(entity e, float id, string s, float duration, float countdown_num)
 776 {
 777         if ((clienttype(e) == CLIENTTYPE_REAL) && (e.flags & FL_CLIENT))
 778         {
 779                 msg_entity = e;
 780                 WRITESPECTATABLE_MSG_ONE({
 781                         WriteByte(MSG_ONE, SVC_TEMPENTITY);
 782                         WriteByte(MSG_ONE, TE_CSQC_CENTERPRINT_GENERIC);
 783                         WriteByte(MSG_ONE, id);
 784                         WriteString(MSG_ONE, s);
 785                         if (id != 0 && s != "")
 786                         {
 787                                 WriteByte(MSG_ONE, duration);
 788                                 WriteByte(MSG_ONE, countdown_num);
 789                         }
 790                 });
 791         }
 792 }
 793 #endif // ifdef SVQC