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