qcsrc/common/notifications.qc

   1 // ================================================
   2 //  Unified notification system, written by Samual
   3 //  Last updated: February, 2013
   4 // ================================================
   5
   6 #ifndef MENUQC
   7 string arg_slot[8];
   8 string Fill_Notif_Args(string args, string input,
   9         string s1, string s2, string s3, string s4,
  10         float f1, float f2, float f3, float f4)
  11 {
  12         dprint(sprintf("Fill_Notif_Args('%s', '%s', %s, %s, %s, %s, %d, %d, %d, %d);\n",
  13                 args, input, s1, s2, s3, s4, f1, f2, f3, f4));
  14
  15         string selected, remaining = args;
  16         float sel_num = 0;
  17
  18         #ifdef CSQC
  19         string tmp_s;
  20         #endif
  21
  22         if((remaining != "") && (input != ""))
  23         {
  24                 for(;remaining;)
  25                 {
  26                         selected = car(remaining); remaining = cdr(remaining);
  27
  28                         switch(strtolower(selected))
  29                         {
  30                                 #define ADD_ARG_CASE(selected,result) case selected: { arg_slot[sel_num] = result; ++sel_num; break; }
  31
  32                                 ADD_ARG_CASE("s1", s1)
  33                                 ADD_ARG_CASE("s2", s2)
  34                                 ADD_ARG_CASE("s3", s3)
  35                                 ADD_ARG_CASE("s4", s4)
  36                                 ADD_ARG_CASE("f1", ftos(f1))
  37                                 ADD_ARG_CASE("f2", ftos(f2))
  38                                 ADD_ARG_CASE("f3", ftos(f3))
  39                                 ADD_ARG_CASE("f4", ftos(f4))
  40
  41                                 #ifdef CSQC // CSQC replacements
  42                                 ADD_ARG_CASE("pass_key",                ((((tmp_s = getcommandkey("pass", "+use")) != "pass") && !(strstrofs(tmp_s, "not bound", 0) >= 0)) ? sprintf(CCR(_(" ^F1(Press %s)")), tmp_s) : ""))
  43                                 ADD_ARG_CASE("frag_ping",               ((f2 != BOT_PING) ? sprintf(CCR(_("\n(Ping ^2%d^BG)")), f2) : ""))
  44                                 ADD_ARG_CASE("frag_stats",              sprintf(CCR(_("\n(Health ^1%d^BG / Armor ^2%d^BG)%s")), f1, f2, ((f3 != BOT_PING) ? sprintf(CCR(_(" (Ping ^2%d^BG)")), f3) : "")))
  45                                 //ADD_ARG_CASE("frag_pos",              ((Should_Print_Score_Pos(f1)) ? sprintf("\n^BG%s", Read_Score_Pos(f1)) : ""))
  46                                 ADD_ARG_CASE("spree_cen",               (((f1 == 3) || (f1 == 5) || (f1 == 10) || (f1 == 15) || (f1 == 20) || (f1 == 25) || (f1 == 30)) ? sprintf(normal_or_gentle(_("%d frag spree! "), _("%d score spree! ")), f1) : ""))
  47                                 ADD_ARG_CASE("spree_inf",               (((f1 == 3) || (f1 == 5) || (f1 == 10) || (f1 == 15) || (f1 == 20) || (f1 == 25) || (f1 == 30)) ? sprintf(normal_or_gentle(_("%d frag spree! "), _("%d score spree! ")), f1) : ""))
  48                                 ADD_ARG_CASE("spree_end",               ((f1 >= 3) ? sprintf(normal_or_gentle(_(", ending their %d frag spree"), _(", ending their %d score spree")), f1) : ""))
  49                                 ADD_ARG_CASE("spree_lost",              ((f1 >= 3) ? sprintf(normal_or_gentle(_(", losing their %d frag spree"), _(", losing their %d score spree")), f1) : ""))
  50                                 ADD_ARG_CASE("death_team",              Team_ColoredFullName(f1 - 1))
  51                                 ADD_ARG_CASE("weapon_name",     ftos(f1)) // weaponorder[f1].netname
  52
  53                                 #else // SVQC replacements
  54                                 ADD_ARG_CASE("spree_inf",               (((f1 == 3) || (f1 == 5) || (f1 == 10) || (f1 == 15) || (f1 == 20) || (f1 == 25) || (f1 == 30)) ? sprintf(normal_or_gentle(_("%d frag spree! "), _("%d score spree! ")), f1) : ""))
  55                                 ADD_ARG_CASE("spree_end",               ((f1 >= 3) ? sprintf(normal_or_gentle(_(", ending their %d frag spree"), _(", ending their %d score spree")), f1) : ""))
  56                                 ADD_ARG_CASE("spree_lost",              ((f1 >= 3) ? sprintf(normal_or_gentle(_(", losing their %d frag spree"), _(", losing their %d score spree")), f1) : ""))
  57                                 ADD_ARG_CASE("death_team",              Team_ColoredFullName(f1))
  58                                 ADD_ARG_CASE("weapon_name",             ftos(f1)) // weaponorder[f1].netname
  59                                 #endif
  60
  61                                 #undef ADD_ARG_CASE
  62                                 default: { print("Hit unknown token in selected string! '", selected, "'\n"); break; }
  63                         }
  64                         if(sel_num == 7) { print("Hit maximum arguments!\n"); break; }
  65                 }
  66
  67                 return sprintf(CCR(input), arg_slot[0], arg_slot[1], arg_slot[2], arg_slot[3], arg_slot[4], arg_slot[5], arg_slot[6], arg_slot[7]);
  68         }
  69
  70         return "";
  71 }
  72
  73 entity Get_Notif_Ent(float net_type, float net_name)
  74 {
  75         switch(net_type)
  76         {
  77                 case MSG_INFO: return msg_info_notifs[net_name - 1];
  78                 case MSG_CENTER: return msg_center_notifs[net_name - 1];
  79                 case MSG_WEAPON: return msg_weapon_notifs[net_name - 1];
  80                 case MSG_DEATH: return msg_death_notifs[net_name - 1];
  81         }
  82         return world;
  83 }
  84
  85 string Get_Field_Value(float field, float net_type, float net_name)
  86 {
  87         entity e = Get_Notif_Ent(net_type, net_name);
  88
  89         dprint(sprintf("Get_Field_Value(%d, %d, %d); - name=%s, stringcount=%d, floatcount=%d...\n", field, net_type, net_name, e.nent_name, e.nent_stringcount, e.nent_floatcount));
  90
  91         switch(net_type)
  92         {
  93                 case F_NAME: { return e.nent_name; }
  94                 case F_INFVAL: { return ftos(e.nent_infoname); }
  95                 case F_CENVAL: { return ftos(e.nent_centername); }
  96                 case F_STRNUM: { return ftos(e.nent_stringcount); }
  97                 case F_FLNUM: { return ftos(e.nent_stringcount); }
  98         }
  99
 100         return "";
 101 }
 102
 103 // get the actual name of a notification and return it as a string
 104 /*string Get_Field_Value(float field, float net_type, float net_name)
 105 {
 106         #ifdef NOTIFICATIONS_DEBUG
 107                 dprint(sprintf("Get_Field_Value(%d, %d, %d);\n", field, net_type, net_name));
 108         #endif
 109
 110         #define GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) switch(field) { \
 111                         case F_NAME: { return VAR_TO_TEXT(name); } \
 112                         case F_STRNUM: { return ftos(strnum); } \
 113                         case F_FLNUM: { return ftos(flnum); } }
 114
 115         #define GET_FIELD_VALUE_OUTPUT_PAIR(field,name,infoname,centername,strnum,flnum) switch(field) { \
 116                         case F_NAME: { return VAR_TO_TEXT(name); } \
 117                         case F_INFNAME: { return VAR_TO_TEXT(infoname); } \
 118                         case F_CENNAME: { return VAR_TO_TEXT(centername); } \
 119                         case F_INFVAL: { return ftos(infoname); } \
 120                         case F_CENVAL: { return ftos(centername); } \
 121                         case F_STRNUM: { return ftos(strnum); } \
 122                         case F_FLNUM: { return ftos(flnum); } }
 123
 124         #define CLPSE_GETVALUE(name,arg,earg) \
 125                 #if name != NO_MSG \
 126                         arg \
 127                 #else \
 128                         earg \
 129                 #endif
 130
 131         switch(net_type)
 132         {
 133                 case MSG_INFO:
 134                 {
 135                         #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) case name: { GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) }
 136                         NOTIF_SWITCH_LIST(MSG_INFO, net_name, return "")
 137                         #undef MSG_INFO_NOTIF
 138                         break;
 139                 }
 140                 case MSG_CENTER:
 141                 {
 142                         #define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) case name: { GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) }
 143                         NOTIF_SWITCH_LIST(MSG_CENTER, net_name, return "")
 144                         #undef MSG_CENTER_NOTIF
 145                         break;
 146                 }
 147                 case MSG_WEAPON:
 148                 {
 149                         #define MSG_WEAPON_NOTIF(name,infoname,centername) case name: { GET_FIELD_VALUE_OUTPUT_PAIR(field,name, \
 150                                 CLPSE_GETVALUE(infoname, infoname, NO_MSG), CLPSE_GETVALUE(centername, centername, NO_MSG), \
 151                                 max(CLPSE_GETVALUE(infoname, stof(Get_Field_Value(F_STRNUM, MSG_INFO, infoname)), 0), CLPSE_GETVALUE(centername, stof(Get_Field_Value(F_STRNUM, MSG_CENTER, centername)), 0)), \
 152                                 max(CLPSE_GETVALUE(infoname, stof(Get_Field_Value(F_FLNUM, MSG_INFO, infoname)), 0), CLPSE_GETVALUE(centername, stof(Get_Field_Value(F_FLNUM, MSG_CENTER, centername)), 0))) }
 153                         NOTIF_SWITCH_LIST(MSG_WEAPON, net_name, return "")
 154                         #undef MSG_WEAPON_NOTIF
 155                         break;
 156                 }
 157                 case MSG_DEATH:
 158                 {
 159                         #define MSG_DEATH_NOTIF(name,infoname,centername) case name: { GET_FIELD_VALUE_OUTPUT_PAIR(field,name, \
 160                                 CLPSE_GETVALUE(infoname, infoname, NO_MSG), CLPSE_GETVALUE(centername, centername, NO_MSG), \
 161                                 max(CLPSE_GETVALUE(infoname, stof(Get_Field_Value(F_STRNUM, MSG_INFO, infoname)), 0), CLPSE_GETVALUE(centername, stof(Get_Field_Value(F_STRNUM, MSG_CENTER, centername)), 0)), \
 162                                 max(CLPSE_GETVALUE(infoname, stof(Get_Field_Value(F_FLNUM, MSG_INFO, infoname)), 0), CLPSE_GETVALUE(centername, stof(Get_Field_Value(F_FLNUM, MSG_CENTER, centername)), 0))) }
 163                         NOTIF_SWITCH_LIST(MSG_DEATH, net_name, return "")
 164                         #undef MSG_DEATH_NOTIF
 165                         break;
 166                 }
 167         }
 168
 169         #undef GET_FIELD_VALUE_OUTPUT
 170         #undef GET_FIELD_VALUE_OUTPUT_PAIR
 171         #undef CLPSE_GETVALUE
 172         return "";
 173 }*/
 174 #endif // ifndef MENUQC
 175
 176
 177 // ===============================
 178 //  Frontend Notification Pushing
 179 // ===============================
 180
 181 void Dump_Notifications(float fh, float alsoprint)
 182 {
 183         float MSG_INFO_NOTIFS = 0, MSG_CENTER_NOTIFS = 0, MSG_WEAPON_NOTIFS = 0, MSG_DEATH_NOTIFS = 0;
 184         string notif_msg;
 185
 186         #define NOTIF_WRITE(type,name,text) { \
 187                 ++##type##_NOTIFS; \
 188                 notif_msg = sprintf("seta %s 1 // %s - %s\n", #name, #type, strreplace("\n", "\\n", text)); \
 189                 fputs(fh, notif_msg); \
 190                 if(alsoprint) { print(strreplace("^", "^^", notif_msg)); } }
 191
 192         #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) NOTIF_WRITE(MSG_INFO, name, normal)
 193         MSG_INFO_NOTIFICATIONS
 194         #undef MSG_INFO_NOTIF
 195
 196         #define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) NOTIF_WRITE(MSG_CENTER, name, normal)
 197         MSG_CENTER_NOTIFICATIONS
 198         #undef MSG_CENTER_NOTIF
 199
 200         #define MSG_WEAPON_NOTIF(name,infoname,centername) NOTIF_WRITE(MSG_WEAPON, name, \
 201                 sprintf("infoname: %s, centername: %s", VAR_TO_TEXT(infoname), VAR_TO_TEXT(centername)))
 202         MSG_WEAPON_NOTIFICATIONS
 203         #undef MSG_WEAPON_NOTIF
 204
 205         #define MSG_DEATH_NOTIF(name,infoname,centername) NOTIF_WRITE(MSG_DEATH, name, \
 206                 sprintf("infoname: %s, centername: %s", VAR_TO_TEXT(infoname), VAR_TO_TEXT(centername)))
 207         MSG_DEATH_NOTIFICATIONS
 208         #undef MSG_DEATH_NOTIF
 209
 210         print(sprintf("Notification counts: MSG_INFO = %d, MSG_CENTER = %d, MSG_WEAPON = %d, MSG_DEATH = %d\n",
 211                 MSG_INFO_NOTIFS, MSG_CENTER_NOTIFS, MSG_WEAPON_NOTIFS, MSG_DEATH_NOTIFS));
 212
 213         return;
 214         #undef NOTIF_WRITE
 215 }
 216
 217 #ifndef MENUQC
 218 #ifdef CSQC
 219 void HUD_Notify_Push(string icon, string attacker, string victim)
 220 {
 221         if(icon != "")
 222         {
 223                 --kn_index;
 224                 if (kn_index == -1) { kn_index = KN_MAX_ENTRIES-1; }
 225                 killnotify_times[kn_index] = time;
 226
 227                 // icon
 228                 if(killnotify_icon[kn_index]) { strunzone(killnotify_icon[kn_index]); }
 229                 killnotify_icon[kn_index] = strzone(icon);
 230
 231                 // attacker
 232                 if(killnotify_attackers[kn_index]) { strunzone(killnotify_attackers[kn_index]); }
 233                 killnotify_attackers[kn_index] = strzone(attacker);
 234
 235                 // victim
 236                 if(killnotify_victims[kn_index]) { strunzone(killnotify_victims[kn_index]); }
 237                 killnotify_victims[kn_index] = strzone(victim);
 238         }
 239 }
 240 #endif // ifdef CSQC
 241
 242 void Local_Notification(float net_type, float net_name, ...count)
 243 {
 244         // check supplied type and name for errors
 245         #ifdef NOTIFICATIONS_DEBUG
 246         {
 247                 #define CHECKARG_TYPENAME(type) case MSG_##type##: \
 248                         { if(!net_name || (net_name > NOTIF_##type##_COUNT)) \
 249                         { checkargs = sprintf("Improper name: %d!", net_name); } break; }
 250
 251                 string checkargs = "";
 252                 switch(net_type)
 253                 {
 254                         CHECKARG_TYPENAME(INFO)
 255                         CHECKARG_TYPENAME(CENTER)
 256                         CHECKARG_TYPENAME(WEAPON)
 257                         CHECKARG_TYPENAME(DEATH)
 258
 259                         default: { checkargs = sprintf("Improper type: %d!", checkargs, net_type); break; }
 260                 }
 261                 #undef CHECKARG_TYPENAME
 262
 263                 if(checkargs != "") { backtrace(sprintf("Incorrect usage of Local_Notification: %s\n", checkargs)); return; }
 264         }
 265         #endif
 266
 267         float stringcount = stof(Get_Field_Value(F_STRNUM, net_type, net_name));
 268         float floatcount = stof(Get_Field_Value(F_FLNUM, net_type, net_name));
 269
 270         string s1 = ((0 < stringcount) ? ...(0, string) : NO_STR_ARG);
 271         string s2 = ((1 < stringcount) ? ...(1, string) : NO_STR_ARG);
 272         string s3 = ((2 < stringcount) ? ...(2, string) : NO_STR_ARG);
 273         string s4 = ((3 < stringcount) ? ...(3, string) : NO_STR_ARG);
 274         float f1 = ((stringcount < count) ? ...(stringcount, float) : NO_FL_ARG);
 275         float f2 = (((stringcount + 1) < count) ? ...((stringcount + 1), float) : NO_FL_ARG);
 276         float f3 = (((stringcount + 2) < count) ? ...((stringcount + 2), float) : NO_FL_ARG);
 277         float f4 = (((stringcount + 3) < count) ? ...((stringcount + 3), float) : NO_FL_ARG);
 278
 279         #ifdef NOTIFICATIONS_DEBUG
 280         {
 281                 dprint(sprintf("Local_Notification(%d, %s, %s, %s, %s, %s, %d, %d, %d, %d);\n",
 282                         net_type, Get_Field_Value(F_NAME, net_type, net_name),
 283                         s1, s2, s3, s4, f1, f2, f3, f4));
 284
 285                 if((stringcount + floatcount) > count)
 286                         { backtrace(sprintf("Not enough arguments for Local_Notification! stringcount(%d) + floatcount(%d) > count(%d) \
 287                         \nCheck the notification definition and function call for accuracy...?\n", stringcount, floatcount, count)); return; }
 288                 else if((stringcount + floatcount) < count)
 289                         { backtrace(sprintf("Too many arguments for Local_Notification! stringcount(%d) + floatcount(%d) < count(%d) \
 290                         \nCheck the notification definition and function call for accuracy...?\n", stringcount, floatcount, count)); return; }
 291         }
 292         #endif
 293
 294
 295         switch(net_type)
 296         {
 297                 case MSG_INFO:
 298                 {
 299                         #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) \
 300                                 case name: { CHECK_AUTOCVAR(name) \
 301                                 { \
 302                                         print(sprintf(CCR(normal_or_gentle(normal, gentle)), args)); \
 303                                         #ifdef CSQC \
 304                                                 if(icon != "") { HUD_Notify_Push(icon, hudargs); } \
 305                                         #endif \
 306                                 } return; }
 307
 308                         NOTIF_SWITCH_LIST(MSG_INFO, net_name, return)
 309
 310                         #undef MSG_INFO_NOTIF
 311                         break;
 312                 }
 313                 #ifdef CSQC
 314                 case MSG_CENTER:
 315                 {
 316                         #define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) \
 317                                 case name: { CHECK_AUTOCVAR(name) \
 318                                 { \
 319                                         centerprint_generic(HANDLE_CPID(cpid), sprintf(CCR(normal_or_gentle(normal, gentle)), args), durcnt); \
 320                                 } return; }
 321
 322                         NOTIF_SWITCH_LIST(MSG_CENTER, net_name, return)
 323
 324                         #undef MSG_CENTER_NOTIF
 325                         break;
 326                 }
 327                 #endif
 328                 case MSG_WEAPON:
 329                 {
 330                         #define MSG_WEAPON_NOTIF(name,infoname,centername) \
 331                                 case name: { CHECK_AUTOCVAR(name) \
 332                                 { \
 333                                         #if infoname != NO_MSG \
 334                                                 Local_Notification_Without_VarArgs(MSG_INFO, infoname, \
 335                                                         stof(Get_Field_Value(F_STRNUM, MSG_INFO, infoname)), \
 336                                                         stof(Get_Field_Value(F_FLNUM, MSG_INFO, infoname)), \
 337                                                         s1, s2, s3, s4, f1, f2, f3, f4); \
 338                                         #endif \
 339                                         #ifdef CSQC \
 340                                                 #if centername != NO_MSG \
 341                                                         Local_Notification_Without_VarArgs(MSG_CENTER, centername, \
 342                                                                 stof(Get_Field_Value(F_STRNUM, MSG_CENTER, centername)), \
 343                                                                 stof(Get_Field_Value(F_FLNUM, MSG_CENTER, centername)), \
 344                                                                 s1, s2, s3, s4, f1, f2, f3, f4); \
 345                                                 #endif \
 346                                         #endif \
 347                                 } return; }
 348
 349                         NOTIF_SWITCH_LIST(MSG_WEAPON, net_name, return)
 350
 351                         #undef MSG_WEAPON_NOTIF
 352                         break;
 353                 }
 354                 case MSG_DEATH:
 355                 {
 356                         #define MSG_DEATH_NOTIF(name,infoname,centername) \
 357                                 case name: { CHECK_AUTOCVAR(name) \
 358                                 { \
 359                                         #if infoname != NO_MSG \
 360                                                 Local_Notification_Without_VarArgs(MSG_INFO, infoname, \
 361                                                         stof(Get_Field_Value(F_STRNUM, MSG_INFO, infoname)), \
 362                                                         stof(Get_Field_Value(F_FLNUM, MSG_INFO, infoname)), \
 363                                                         s1, s2, s3, s4, f1, f2, f3, f4); \
 364                                         #endif \
 365                                         #ifdef CSQC \
 366                                                 #if centername != NO_MSG \
 367                                                         Local_Notification_Without_VarArgs(MSG_CENTER, centername, \
 368                                                                 stof(Get_Field_Value(F_STRNUM, MSG_CENTER, centername)), \
 369                                                                 stof(Get_Field_Value(F_FLNUM, MSG_CENTER, centername)), \
 370                                                                 s1, s2, s3, s4, f1, f2, f3, f4); \
 371                                                 #endif \
 372                                         #endif \
 373                                 } return; }
 374
 375                         NOTIF_SWITCH_LIST(MSG_DEATH, net_name, return)
 376
 377                         #undef MSG_DEATH_NOTIF
 378                         break;
 379                 }
 380         }
 381 }
 382
 383 void Local_Notification_Without_VarArgs(float net_type, float net_name,
 384         float stringcount, float floatcount,
 385         string s1, string s2, string s3, string s4,
 386         float f1, float f2, float f3, float f4)
 387 {
 388         #define VARITEM(stringc,floatc,args) if((stringcount == stringc) && (floatcount == floatc)) { Local_Notification(net_type, net_name, args); return; }
 389         EIGHT_VARS_TO_VARARGS_VARLIST
 390         #undef VARITEM
 391
 392         Local_Notification(net_type, net_name); // some notifications don't have any arguments at all
 393 }
 394
 395
 396 // =========================
 397 //  Notification Networking
 398 // =========================
 399
 400 #ifdef CSQC
 401 void Read_Notification(float is_new)
 402 {
 403         float net_type = ReadByte();
 404         float net_name = ReadShort();
 405
 406         float stringcount = stof(Get_Field_Value(F_STRNUM, net_type, net_name));
 407         float floatcount = stof(Get_Field_Value(F_FLNUM, net_type, net_name));
 408
 409         string s1 = ((stringcount >= 1) ? ReadString() : NO_STR_ARG);
 410         string s2 = ((stringcount >= 2) ? ReadString() : NO_STR_ARG);
 411         string s3 = ((stringcount >= 3) ? ReadString() : NO_STR_ARG);
 412         string s4 = ((stringcount == 4) ? ReadString() : NO_STR_ARG);
 413         float f1 = ((floatcount >= 1) ? ReadLong() : NO_FL_ARG);
 414         float f2 = ((floatcount >= 2) ? ReadLong() : NO_FL_ARG);
 415         float f3 = ((floatcount >= 3) ? ReadLong() : NO_FL_ARG);
 416         float f4 = ((floatcount == 4) ? ReadLong() : NO_FL_ARG);
 417
 418         #ifdef NOTIFICATIONS_DEBUG
 419                 dprint(sprintf("Read_Notification(%d) at %f: net_name = %s.\n", is_new, time, Get_Field_Value(F_NAME, net_type, net_name)));
 420         #endif
 421
 422         if(is_new) { Local_Notification_Without_VarArgs(net_type, net_name, stringcount, floatcount, s1, s2, s3, s4, f1, f2, f3, f4); }
 423 }
 424 #endif
 425
 426 #ifdef SVQC
 427 void Notification_Remove()
 428 {
 429         float i;
 430         for(i = 0; i < 4; ++i) { if(self.nent_strings[i]) { strunzone(self.nent_strings[i]); } }
 431         remove(self);
 432 }
 433
 434 float Write_Notification(entity client, float sf)
 435 {
 436         float i, send = FALSE;
 437
 438         switch(self.nent_broadcast)
 439         {
 440                 case NOTIF_ONE: { if((client == self.nent_client) || (client.classname == STR_SPECTATOR && client.enemy == self.nent_client)) { send = TRUE; } break; }
 441                 case NOTIF_ONE_ONLY: { if(client == self.nent_client) { send = TRUE; } break; }
 442                 case NOTIF_TEAM: { if((client.team == self.nent_client.team) || (client.classname == STR_SPECTATOR && client.enemy.team == self.nent_client.team)) { send = TRUE; } break; }
 443                 case NOTIF_TEAM_EXCEPT: { if(((client != self.nent_client) && (client.team == self.nent_client.team) && !(client.classname == STR_SPECTATOR && client.enemy == self.nent_client))) { send = TRUE; } break; }
 444                 case NOTIF_ANY: { send = TRUE; break; }
 445                 case NOTIF_ANY_EXCEPT: { if((client != self.nent_client) && !(client.classname == STR_SPECTATOR && client.enemy == self.nent_client)) { send = TRUE; } break; }
 446                 default: { send = FALSE; break; }
 447         }
 448
 449         if(send)
 450         {
 451                 WriteByte(MSG_ENTITY, ENT_CLIENT_NOTIFICATION);
 452                 WriteByte(MSG_ENTITY, self.nent_net_type);
 453                 WriteShort(MSG_ENTITY, self.nent_net_name);
 454                 for(i = 0; i < self.nent_stringcount; ++i) { WriteString(MSG_ENTITY, self.nent_strings[i]); }
 455                 for(i = 0; i < self.nent_floatcount; ++i) { WriteLong(MSG_ENTITY, self.nent_floats[i]); }
 456         }
 457
 458         return send;
 459 }
 460
 461 void Send_Notification(float broadcast, entity client,
 462         float net_type, float net_name, ...count)
 463 {
 464         // check supplied broadcast, target, type, and name for errors
 465         #ifdef NOTIFICATIONS_DEBUG
 466         {
 467                 #define CHECKARG_TYPENAME(type) case MSG_##type##: \
 468                         { if(!net_name || (net_name > NOTIF_##type##_COUNT)) \
 469                         { checkargs = sprintf("Improper name: %d!", net_name); } break; }
 470
 471                 string checkargs = "";
 472                 switch(net_type)
 473                 {
 474                         CHECKARG_TYPENAME(INFO)
 475                         CHECKARG_TYPENAME(CENTER)
 476                         CHECKARG_TYPENAME(WEAPON)
 477                         CHECKARG_TYPENAME(DEATH)
 478
 479                         default: { checkargs = sprintf("Improper type: %d!", checkargs, net_type); break; }
 480                 }
 481                 #undef CHECKARG_TYPENAME
 482
 483                 if(checkargs != "") { checkargs = strcat(checkargs, " "); }
 484                 switch(broadcast)
 485                 {
 486                         case NOTIF_ONE:
 487                         case NOTIF_ONE_ONLY: { if(clienttype(client) == CLIENTTYPE_NOTACLIENT) { checkargs = sprintf("%sNo client provided!", checkargs); } break; }
 488                         case NOTIF_ANY_EXCEPT: { if(clienttype(client) == CLIENTTYPE_NOTACLIENT) { checkargs = sprintf("%sException can't be a non-client!", checkargs); } break; }
 489                         case NOTIF_ANY: { if(client) { checkargs = sprintf("%sEntity provided when world was required!", checkargs); } break; }
 490
 491                         case NOTIF_TEAM:
 492                         case NOTIF_TEAM_EXCEPT:
 493                         {
 494                                 if not(teamplay) { checkargs = sprintf("%sTeamplay not active!", checkargs); }
 495                                 else if(clienttype(client) == CLIENTTYPE_NOTACLIENT)
 496                                 {
 497                                         if(broadcast == NOTIF_TEAM) { checkargs = sprintf("%sNo client provided!", checkargs); }
 498                                         else { checkargs = sprintf("%sException can't be a non-client!", checkargs); }
 499                                 }
 500                                 break;
 501                         }
 502
 503                         default: { checkargs = sprintf("%sImproper broadcast: %d!", checkargs, broadcast); break; }
 504                 }
 505
 506                 if(checkargs != "") { backtrace(sprintf("Incorrect usage of Send_Notification: %s\n", checkargs)); return; }
 507         }
 508         #endif
 509
 510         // retreive counts for the arguments of this notification
 511         float stringcount = stof(Get_Field_Value(F_STRNUM, net_type, net_name));
 512         float floatcount = stof(Get_Field_Value(F_FLNUM, net_type, net_name));
 513
 514         entity e = Get_Notif_Ent(net_type, net_name);
 515         print(sprintf("stringcount from ent: %d... floatcount from ent: %d\n", e.nent_stringcount, e.nent_floatcount));
 516
 517         #ifdef NOTIFICATIONS_DEBUG
 518         {
 519                 dprint(sprintf("Send_Notification(%d, %d, %s, stringcount: %d, floatcount: %d, varargs: %d);\n",
 520                         broadcast, net_type, Get_Field_Value(F_NAME, net_type, net_name), stringcount, floatcount, count));
 521
 522                 if((stringcount + floatcount) > count)
 523                         { backtrace(sprintf(strcat("Not enough arguments for Send_Notification! stringcount(%d) + floatcount(%d) > count(%d)\n",
 524                         "Check the notification definition and function call for accuracy...?\n"), stringcount, floatcount, count)); return; }
 525                 else if((stringcount + floatcount) < count)
 526                         { backtrace(sprintf(strcat("Too many arguments for Send_Notification! stringcount(%d) + floatcount(%d) < count(%d)\n",
 527                         "Check the notification definition and function call for accuracy...?\n"), stringcount, floatcount, count)); return; }
 528         }
 529         #endif
 530
 531         entity notif = spawn();
 532         notif.nent_broadcast = broadcast;
 533         notif.nent_client = client;
 534         notif.nent_net_type = net_type;
 535         notif.nent_net_name = net_name;
 536         notif.nent_stringcount = stringcount;
 537         notif.nent_floatcount = floatcount;
 538
 539         float i;
 540
 541         for(i = 0; i < stringcount; ++i) { notif.nent_strings[i] = strzone(...(i, string)); }
 542         for(i = 0; i < floatcount; ++i) { notif.nent_floats[i] = ...((stringcount + i), float); }
 543
 544         notif.think = Notification_Remove;
 545         notif.nextthink = (time + 0.5);
 546
 547         Net_LinkEntity(notif, FALSE, 0, Write_Notification);
 548
 549         if((!server_is_local) && (broadcast == NOTIF_ANY || broadcast == NOTIF_ANY_EXCEPT) && (net_type != MSG_CENTER))
 550                 { Local_Notification_Without_VarArgs(net_type, net_name, stringcount, floatcount,
 551                         IFSTR(0), IFSTR(1), IFSTR(2), IFSTR(3), IFFL(0), IFFL(1), IFFL(2), IFFL(3)); }
 552 }
 553
 554 void Send_Notification_Without_VarArgs(float broadcast, entity client,
 555         float net_type, float net_name,
 556         float stringcount, float floatcount,
 557         string s1, string s2, string s3, string s4,
 558         float f1, float f2, float f3, float f4)
 559 {
 560         #define VARITEM(stringc,floatc,args) if((stringcount == stringc) && (floatcount == floatc)) { Send_Notification(broadcast, client, net_type, net_name, args); return; }
 561         EIGHT_VARS_TO_VARARGS_VARLIST
 562         #undef VARITEM
 563
 564         Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all
 565 }
 566
 567 void Send_Notification_Legacy_Wrapper(float broadcast, entity client,
 568         float net_type, float net_name,
 569         string s1, string s2,
 570         float f1, float f2, float f3)
 571 {
 572         float stringcount = stof(Get_Field_Value(F_STRNUM, net_type, net_name));
 573         float floatcount = stof(Get_Field_Value(F_FLNUM, net_type, net_name));
 574         Send_Notification_Without_VarArgs(broadcast, client, net_type, net_name, stringcount, floatcount, s1, s2, NO_STR_ARG, NO_STR_ARG, f1, f2, f3, NO_FL_ARG);
 575 }
 576
 577
 578 // =============================
 579 //  LEGACY NOTIFICATION SYSTEMS
 580 // =============================
 581
 582 void Send_CSQC_Centerprint_Generic(entity e, float id, string s, float duration, float countdown_num)
 583 {
 584         if ((clienttype(e) == CLIENTTYPE_REAL) && (e.flags & FL_CLIENT))
 585         {
 586                 msg_entity = e;
 587                 WRITESPECTATABLE_MSG_ONE({
 588                         WriteByte(MSG_ONE, SVC_TEMPENTITY);
 589                         WriteByte(MSG_ONE, TE_CSQC_CENTERPRINT_GENERIC);
 590                         WriteByte(MSG_ONE, id);
 591                         WriteString(MSG_ONE, s);
 592                         if (id != 0 && s != "")
 593                         {
 594                                 WriteByte(MSG_ONE, duration);
 595                                 WriteByte(MSG_ONE, countdown_num);
 596                         }
 597                 });
 598         }
 599 }
 600 void Send_CSQC_Centerprint_Generic_Expire(entity e, float id)
 601 {
 602         Send_CSQC_Centerprint_Generic(e, id, "", 1, 0);
 603 }
 604 #endif // ifdef SVQC
 605 #endif // ifndef MENUQC