X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fnotifications.qc;h=eb15b95500d2a3e72e67e4ffcc146cb5a5d5edd6;hb=0002fa66b4a599c568bdea331019d139aea21122;hp=1ce6948a9c745507081e30f4e6e5f7cb77f4abe9;hpb=effddd622847731ce697f7be9db7f6b574c1497d;p=xonotic%2Fxonotic-data.pk3dir.git diff --git a/qcsrc/common/notifications.qc b/qcsrc/common/notifications.qc index 1ce6948a9c..fc9137db98 100644 --- a/qcsrc/common/notifications.qc +++ b/qcsrc/common/notifications.qc @@ -1,488 +1,1130 @@ // ================================================ // Unified notification system, written by Samual -// Last updated: November, 2012 +// Last updated: August, 2013 // ================================================ -// main types/groups of notifications -#define MSG_INFO 1 // "Global" information messages (sent to console, and notify panel if it has an icon) -#define MSG_CENTER 2 // "Personal" centerprint messages -#define MSG_WEAPON 3 // "Personal" weapon messages (like "You got the Nex", sent to weapon notify panel) -#define MSG_DEATH 4 // "Personal" AND "Global" death messages - -#define NO_STR_ARG "" -#define NO_FL_ARG -12345 -#define NO_MSG -12345 +string Get_Notif_TypeName(float net_type) +{ + switch(net_type) + { + case MSG_ANNCE: return "MSG_ANNCE"; + case MSG_INFO: return "MSG_INFO"; + case MSG_CENTER: return "MSG_CENTER"; + case MSG_CENTER_CPID: return "MSG_CENTER_CPID"; + case MSG_MULTI: return "MSG_MULTI"; + case MSG_CHOICE: return "MSG_CHOICE"; + } + backtrace(sprintf("Get_Notif_TypeName(%d): Improper net type!\n", net_type)); + return ""; +} -#define F_NAME 1 -#define F_STRNUM 2 -#define F_FLNUM 3 +entity Get_Notif_Ent(float net_type, float net_name) +{ + switch(net_type) + { + case MSG_ANNCE: return msg_annce_notifs[net_name - 1]; + case MSG_INFO: return msg_info_notifs[net_name - 1]; + case MSG_CENTER: return msg_center_notifs[net_name - 1]; + case MSG_MULTI: return msg_multi_notifs[net_name - 1]; + case MSG_CHOICE: return msg_choice_notifs[net_name - 1]; + } + backtrace(sprintf("Get_Notif_Ent(%d, %d): Improper net type!\n", net_type, net_name)); + return world; +} -#define BOT_PING -1 +#ifdef SVQC +#ifdef NOTIFICATIONS_DEBUG +string Get_Notif_BroadcastName(float broadcast) +{ + switch(broadcast) + { + case NOTIF_ONE: return "NOTIF_ONE"; + case NOTIF_ONE_ONLY: return "NOTIF_ONE_ONLY"; + case NOTIF_ALL_EXCEPT: return "NOTIF_ALL_EXCEPT"; + case NOTIF_ALL: return "NOTIF_ALL"; + case NOTIF_TEAM: return "NOTIF_TEAM"; + case NOTIF_TEAM_EXCEPT: return "NOTIF_TEAM_EXCEPT"; + } + backtrace(sprintf("Get_Notif_BroadcastName(%d): Improper broadcast!\n", broadcast)); + return ""; +} +#endif +#endif -// Since this is code uses macro processors to list notifications, -// the normal compiler sees these checks as "constant" and throws -// a warning. We have to get around this by using another function. -#define NOTIF_MATCH(a,b) if(min(NOTIF_MAX, a) == b) +string Notification_CheckArgs_TypeName(float net_type, float net_name) +{ + // check supplied type and name for errors + string checkargs = ""; + #define CHECKARG_TYPENAME(type) case MSG_##type##: \ + { if(!net_name || (net_name > NOTIF_##type##_COUNT)) \ + { checkargs = sprintf("Improper name: %d!", net_name); } break; } + switch(net_type) + { + CHECKARG_TYPENAME(ANNCE) + CHECKARG_TYPENAME(INFO) + CHECKARG_TYPENAME(CENTER) + CHECKARG_TYPENAME(MULTI) + CHECKARG_TYPENAME(CHOICE) + default: { checkargs = sprintf("Improper type: %d!", checkargs, net_type); break; } + } + #undef CHECKARG_TYPENAME + return checkargs; +} -#ifdef CSQC -/* - Acquire special information to generate for display in the - notification from variables networked to the client. - Macro descriptions: - PASS_KEY: find the keybind for "passing" or "dropping" in CTF game mode - FRAG_SPREE: find out if the player is on a kill spree/how many kills they have - FRAG_PING: show the ping of a player - FRAG_STATS: show health/armor/ping of a player - FRAG_POS: show score status and position in the match of a player - DEATH_TEAM: show the full name of the team a player is switching from -*/ -string got_commandkey; -#define PASS_KEY ((((got_commandkey = getcommandkey("pass", "+use")) != "pass") && !(strstrofs(got_commandkey, "not bound", 0) >= 0)) ? sprintf(CCR(_(" ^F1(Press %s)")), got_commandkey) : "") -#define FRAG_SPREE (((f1 == 3) || (f1 == 5) || (f1 == 10) || (f1 == 15) || (f1 == 20) || (f1 == 25) || (f1 == 30)) ? sprintf(normal_or_gentle(_("%d kill spree! "), _("%d score spree! ")), f1) : "") -#define FRAG_PING ((f2 != BOT_PING) ? sprintf(CCR(_("\n(Ping ^2%d^BG)")), f2) : "") -#define 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) : "")) -//#define FRAG_POS ((Should_Print_Score_Pos(f1)) ? sprintf("\n^BG%s", Read_Score_Pos(f1)) : "") -#define DEATH_TEAM Team_ColoredFullName(TEAM_SV_TO_CL(f1)) - -// NO_CPID normally has a variable value, so we need to check and see -// whether a notification uses it. If so, cancel out the centerprint ID. -#define HANDLE_CPID(cpid) ((min(NOTIF_MAX, cpid) == NO_CPID) ? FALSE : cpid) - -// client-side handling of cvars -#define ADD_CSQC_AUTOCVAR(name) var float autocvar_notification_##name = TRUE; -#define CHECK_AUTOCVAR(name) if(autocvar_notification_##name) -#else - -// allow sending of notifications to also pass through to spectators (specifically for centerprints) #ifdef SVQC -#define DEATH_TEAM Team_ColoredFullName(f1) +string Notification_CheckArgs( + float broadcast, entity client, + float net_type, float net_name) +{ + // check supplied broadcast, target, type, and name for errors + string checkargs = Notification_CheckArgs_TypeName(net_type, net_name); + if(checkargs != "") { checkargs = strcat(checkargs, " "); } + switch(broadcast) + { + case NOTIF_ONE: + case NOTIF_ONE_ONLY: + { + if(IS_NOT_A_CLIENT(client)) + { checkargs = sprintf("%sNo client provided!", checkargs); } + break; + } + + case NOTIF_ALL_EXCEPT: + { + if(IS_NOT_A_CLIENT(client)) + { checkargs = sprintf("%sException can't be a non-client!", checkargs); } + break; + } + + case NOTIF_ALL: + { + if(client) + { checkargs = sprintf("%sEntity provided when world was required!", checkargs); } + break; + } + + case NOTIF_TEAM: + { + if not(teamplay) { checkargs = sprintf("%sTeamplay not active!", checkargs); } + //else if not(client.team) { checkargs = sprintf("%sNo team provided!", checkargs); } + break; + } + + case NOTIF_TEAM_EXCEPT: + { + if not(teamplay) { checkargs = sprintf("%sTeamplay not active!", checkargs); } + else if(IS_NOT_A_CLIENT(client)) { checkargs = sprintf("%sException can't be a non-client!", checkargs); } + break; + } + + default: { checkargs = sprintf("%sImproper broadcast: %d!", checkargs, broadcast); break; } + } + return checkargs; +} -#define WRITESPECTATABLE_MSG_ONE_VARNAME(varname,statement) entity varname; varname = msg_entity; FOR_EACH_REALCLIENT(msg_entity) if(msg_entity == varname || (msg_entity.classname == STR_SPECTATOR && msg_entity.enemy == varname)) statement msg_entity = varname -#define WRITESPECTATABLE_MSG_ONE(statement) WRITESPECTATABLE_MSG_ONE_VARNAME(oldmsg_entity, statement) -#define WRITESPECTATABLE(msg,statement) if(msg == MSG_ONE) { WRITESPECTATABLE_MSG_ONE(statement); } else statement float WRITESPECTATABLE_workaround = 0 -#endif +float Notification_ShouldSend(float broadcast, entity to_client, entity other_client) +{ + switch(broadcast) + { + case NOTIF_ONE: // send to one client and their spectator + { + if( + (to_client == other_client) + || + ( + IS_SPEC(to_client) + && + (to_client.enemy == other_client) + ) + ) { return TRUE; } + break; + } + case NOTIF_ONE_ONLY: // send ONLY to one client + { + if(to_client == other_client) { return TRUE; } + break; + } + case NOTIF_TEAM: // send only to X team and their spectators + { + if( + (to_client.team == other_client.team) + || + ( + IS_SPEC(to_client) + && + (to_client.enemy.team == other_client.team) + ) + ) { return TRUE; } + break; + } + case NOTIF_TEAM_EXCEPT: // send only to X team and their spectators, except for Y person and their spectators + { + if( + (to_client != other_client) + && + ( + (to_client.team == other_client.team) + || + ( + IS_SPEC(to_client) + && + ( + (to_client.enemy != other_client) + && + (to_client.enemy.team == other_client.team) + ) + ) + ) + ) { return TRUE; } + break; + } + case NOTIF_ALL: // send to everyone + { + return TRUE; + } + case NOTIF_ALL_EXCEPT: // send to everyone except X person and their spectators + { + if( + (to_client != other_client) + && + !( + IS_SPEC(to_client) + && + (to_client.enemy == other_client) + ) + ) { return TRUE; } + break; + } + } + return FALSE; +} -// do nothing for the other programs, they don't need cvars (those are just for the clients) -#define ADD_CSQC_AUTOCVAR(name) #endif +// =============================== +// Initialization Core Functions +// =============================== -/* - If BELOW negative maxplayers, you dropped a place lower - If below 0, you are tied for that place - If above 0, you are holding that place alone - If above positive maxplayers, you moved up a place -* -float Should_Print_Score_Pos - -string Read_Score_Pos(float num) +// used by restartnotifs command to initialize notifications +void Destroy_Notification_Entity(entity notif) { - + if(notif.nent_name != "") { strunzone(notif.nent_name); } + if(notif.nent_snd != "") { strunzone(notif.nent_snd); } + if(notif.nent_args != "") { strunzone(notif.nent_args); } + if(notif.nent_hudargs != "") { strunzone(notif.nent_hudargs); } + if(notif.nent_icon != "") { strunzone(notif.nent_icon); } + if(notif.nent_durcnt != "") { strunzone(notif.nent_durcnt); } + if(notif.nent_string != "") { strunzone(notif.nent_string); } + remove(notif); } -float Form_Score_Pos(entity player) +void Destroy_All_Notifications(void) { - return -}*/ - -// ==================================== -// Notifications List and Information -// ==================================== -/*(name,strnum,flnum,args,cpid,cennor,cengen,infargs,hudargs,icon,infnor,infgen) - List of all notifications (including identifiers and display information) - Possible Tokens: name, centername, infoname, strnum, flnum, args, hudargs, icon, cpid, durcnt, normal, gentle - Format Specifications: - MSG_INFO: - name: VAR: Name of notification - strnum: FLOAT: Number of STRING arguments (so that networking knows how many to send/receive) - flnum: FLOAT: Number of FLOAT arguments (so that networking knows how many to send/receive) - args: MISC: Arguments for sprintf(string, args), if no args needed then use "" - hudargs: XPND2(STRING, STRING): arguments for names in notify messages - icon: STRING: icon string name for the hud notify panel, "" if no icon is used - normal: STRING: Normal message (string for sprintf when gentle messages are NOT enabled) - gentle: STRING: Gentle message (string for sprintf when gentle messages ARE enabled) - MSG_CENTER: - name: VAR: Name of notification - strnum: FLOAT: Number of STRING arguments (so that networking knows how many to send/receive) - flnum: FLOAT: Number of FLOAT arguments (so that networking knows how many to send/receive) - args: MISC: Arguments for sprintf(string, args), if no args needed then use "" - cpid: FLOAT: centerprint ID number (CPID_*), NO_CPID if no CPID is needed - durcnt: XPND2(FLOAT, FLOAT): Duration/Countdown: extra arguments for centerprint messages - normal: STRING: Normal message (string for sprintf when gentle messages are NOT enabled) - gentle: STRING: Gentle message (string for sprintf when gentle messages ARE enabled) - MSG_DEATH: - name: VAR: Name of chaining notification - centername: VAR: Name of centerprint notification for reference - infoname: VAR: Name of info notification for reference - - Messages with ^F1, ^BG, ^TC, etc etc in them will replace those strings - with colors according to the cvars the user has chosen. This allows for - users to create unique color profiles for their HUD, giving more customization - options to HUD designers and end users who want such a feature. - - Check out the function calls for string CCR(...) and - string TCR(...) to better understand how these codes work. - - Guidlines (please try and follow these): - -ALWAYS start the string with a color, preferably background. - -ALWAYS reset a color after a name (this way they don't set it for the whole string). - -NEVER re-declare an event twice. - -NEVER add or remove fields from the format, it SHOULD already work. - -MSG_INFO messages must ALWAYS end with a new line: \n - -Be clean and simple with your notification naming, - nothing too long for the name field... Abbreviations are your friend. :D - -Keep the spacing as clean as possible... if the arguments are abnormally long, - it's okay to go out of line a bit... but try and keep it clean still. - -Sort the notifications in the most appropriate order for their tasks. - TODO: ? centerprint IDs are given priority based on their order (first being highest priority going downwards) - -ARIRE unir frk jvgu lbhe bja zbgure. (gvc sbe zvxrrhfn) -- Don't pay attention to this ^_^ -*/ - -// weaponorder[f1].netname - -#define MULTITEAM_INFO(prefix,teams,strnum,flnum,args,hudargs,icon,normal,gentle) \ - MSG_INFO_NOTIF(prefix##RED, strnum, flnum, args, hudargs, sprintf(icon, strtolower(STR_TEAM_1)), TCR(normal, COL_TEAM_1, strtoupper(STR_TEAM_1)), TCR(gentle, COL_TEAM_1, strtoupper(STR_TEAM_1))) \ - MSG_INFO_NOTIF(prefix##BLUE, strnum, flnum, args, hudargs, sprintf(icon, strtolower(STR_TEAM_2)), TCR(normal, COL_TEAM_2, strtoupper(STR_TEAM_2)), TCR(gentle, COL_TEAM_2, strtoupper(STR_TEAM_2))) \ - #if teams >= 3 \ - MSG_INFO_NOTIF(prefix##YELLOW, strnum, flnum, args, hudargs, sprintf(icon, strtolower(STR_TEAM_3)), TCR(normal, COL_TEAM_3, strtoupper(STR_TEAM_3)), TCR(gentle, COL_TEAM_3, strtoupper(STR_TEAM_3))) \ - #endif \ - #if teams >= 4 \ - MSG_INFO_NOTIF(prefix##PINK, strnum, flnum, args, hudargs, sprintf(icon, strtolower(STR_TEAM_4)), TCR(normal, COL_TEAM_4, strtoupper(STR_TEAM_4)), TCR(gentle, COL_TEAM_4, strtoupper(STR_TEAM_4))) \ - #endif -#define MSG_INFO_NOTIFICATIONS \ - MSG_INFO_NOTIF(INFO_EMPTY, 0, 0, NO_STR_ARG, XPND2("", ""), "", "", "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_CUSTOM, 1, 0, s1, XPND2(s1, ""), "notify_death", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_GENERIC, 1, 0, s1, XPND2(s1, ""), "notify_void", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_SELFKILL, 1, 0, s1, XPND2(s1, ""), "notify_selfkill", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_SUICIDE, 1, 0, s1, XPND2(s1, ""), "notify_selfkill", _("^F1%s^K1 couldn't take it anymore\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_NOAMMO, 1, 0, s1, XPND2(s1, ""), "notify_outofammo", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_ROT, 1, 0, s1, XPND2(s1, ""), "notify_death", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_CAMP, 1, 0, s1, XPND2(s1, ""), "notify_camping", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_BETRAYAL, 1, 1, s1, XPND2("", ""), "", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_TEAMCHANGE, 1, 1, XPND2(s1, DEATH_TEAM), XPND2("", ""), "", _("^F1%s^K1 switched to the %s\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_AUTOTEAMCHANGE, 1, 1, XPND2(s1, DEATH_TEAM), XPND2("", ""), "", _("^F1%s^K1 was moved into the %s\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_FALL, 1, 0, s1, XPND2(s1, ""), "notify_fall", _("^F1%s^K1 hit the ground with a crunch\n"), _("^F1%s^K1 hit the ground with a bit too much force\n")) \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_DROWN, 1, 0, s1, XPND2(s1, ""), "notify_water", _("^F1%s^K1 couldn't catch their breath\n"), _("^F1%s^K1 was in the water for too long\n")) \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_LAVA, 1, 0, s1, XPND2(s1, ""), "notify_lava", _("^F1%s^K1 turned into hot slag\n"), _("^F1%s^K1 found a hot place\n")) \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_SLIME, 1, 0, s1, XPND2(s1, ""), "notify_slime", _("^F1%s^K1 was slimed\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_SHOOTING_STAR, 1, 0, s1, XPND2(s1, ""), "notify_shootingstar", _("^F1%s^K1\n"), "") \ - MSG_INFO_NOTIF(INFO_DEATH_SELF_SWAMP, 1, 0, s1, XPND2("", ""), "", _("^F1%s^K1\n"), "") \ - MULTITEAM_INFO(INFO_SCORES_, 4, 0, 0, NO_STR_ARG, XPND2("", ""), "", _("^TC^TT ^BGteam scores!\n"), "") \ - MULTITEAM_INFO(INFO_CTF_FLAGRETURN_DROPPED_, 2, 0, 0, NO_STR_ARG, XPND2("", ""), "", _("^BGThe ^TC^TT^BG flag was dropped in the base and returned itself\n"), "") \ - MULTITEAM_INFO(INFO_CTF_FLAGRETURN_DAMAGED_, 2, 0, 0, NO_STR_ARG, XPND2("", ""), "", _("^BGThe ^TC^TT^BG flag was destroyed and returned to base\n"), "") \ - MULTITEAM_INFO(INFO_CTF_FLAGRETURN_SPEEDRUN_, 2, 0, 1, f1/100, XPND2("", ""), "", _("^BGThe ^TC^TT^BG flag became impatient after ^F1%.2f^BG seconds and returned itself\n"), "") \ - MULTITEAM_INFO(INFO_CTF_FLAGRETURN_NEEDKILL_, 2, 0, 0, NO_STR_ARG, XPND2("", ""), "", _("^BGThe ^TC^TT^BG flag fell somewhere it couldn't be reached and returned to base\n"), "") \ - MULTITEAM_INFO(INFO_CTF_FLAGRETURN_ABORTRUN_, 2, 0, 0, NO_STR_ARG, XPND2("", ""), "", _("^BGThe ^TC^TT^BG flag was returned to base by its owner\n"), "") \ - MULTITEAM_INFO(INFO_CTF_FLAGRETURN_TIMEOUT_, 2, 0, 0, NO_STR_ARG, XPND2("", ""), "", _("^BGThe ^TC^TT^BG flag has returned to the base\n"), "") \ - MULTITEAM_INFO(INFO_CTF_PICKUP_, 2, 1, 0, s1, XPND2(s1, ""), "notify_%s_taken", _("^BG%s^BG got the ^TC^TT^BG flag\n"), "") \ - MULTITEAM_INFO(INFO_CTF_RETURN_, 2, 1, 0, s1, XPND2(s1, ""), "notify_%s_returned", _("^BG%s^BG returned the ^TC^TT^BG flag\n"), "") \ - MULTITEAM_INFO(INFO_CTF_LOST_, 2, 1, 0, s1, XPND2(s1, ""), "notify_%s_lost", _("^BG%s^BG lost the ^TC^TT^BG flag\n"), "") \ - MULTITEAM_INFO(INFO_CTF_CAPTURE_, 2, 1, 0, s1, XPND2(s1, ""), "notify_%s_captured", _("^BG%s^BG captured the ^TC^TT^BG flag\n"), "") \ - MULTITEAM_INFO(INFO_CTF_CAPTURE_TIME_, 2, 1, 1, XPND2(s1, f1/100), XPND2(s1, ""), "notify_%s_captured", _("^BG%s^BG captured the ^TC^TT^BG flag in ^F1%.2f^BG seconds\n"), "") \ - MULTITEAM_INFO(INFO_CTF_CAPTURE_BROKEN_, 2, 2, 2, XPND4(s1, f1/100, s2, f2/100), XPND2(s1, ""), "notify_%s_captured", _("^BG%s^BG captured the ^TC^TT^BG flag in ^F1%.2f^BG seconds, breaking ^BG%s^BG's previous record of ^F2%.2f^BG seconds\n"), "") \ - MULTITEAM_INFO(INFO_CTF_CAPTURE_UNBROKEN_, 2, 2, 2, XPND4(s1, f1/100, s2, f2/100), XPND2(s1, ""), "notify_%s_captured", _("^BG%s^BG captured the ^TC^TT^BG flag in ^F2%.2f^BG seconds, failing to break ^BG%s^BG's previous record of ^F1%.2f^BG seconds\n"), "") - -#define MULTITEAM_CENTER(prefix,teams,strnum,flnum,args,cpid,durcnt,normal,gentle) \ - MSG_CENTER_NOTIF(prefix##RED, strnum, flnum, args, cpid, durcnt, TCR(normal, COL_TEAM_1, strtoupper(STR_TEAM_1)), TCR(gentle, COL_TEAM_1, strtoupper(STR_TEAM_1))) \ - MSG_CENTER_NOTIF(prefix##BLUE, strnum, flnum, args, cpid, durcnt, TCR(normal, COL_TEAM_2, strtoupper(STR_TEAM_2)), TCR(gentle, COL_TEAM_2, strtoupper(STR_TEAM_2))) \ - #if teams >= 3 \ - MSG_CENTER_NOTIF(prefix##YELLOW, strnum, flnum, args, cpid, durcnt, TCR(normal, COL_TEAM_3, strtoupper(STR_TEAM_3)), TCR(gentle, COL_TEAM_3, strtoupper(STR_TEAM_3))) \ - #endif \ - #if teams >= 4 \ - MSG_CENTER_NOTIF(prefix##PINK, strnum, flnum, args, cpid, durcnt, TCR(normal, COL_TEAM_4, strtoupper(STR_TEAM_4)), TCR(gentle, COL_TEAM_4, strtoupper(STR_TEAM_4))) \ - #endif -#define MSG_CENTER_NOTIFICATIONS \ - MSG_CENTER_NOTIF(CENTER_EMPTY, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), "", "") \ - MSG_CENTER_NOTIF(CENTER_CTF_CAPTURESHIELD_SHIELDED, 0, 0, NO_STR_ARG, CPID_CTF_CAPSHIELD, XPND2(0, 0), _("^BGYou are now ^F1shielded^BG from the flag\n^BGfor ^F2too many unsuccessful attempts^BG to capture.\n^BGMake some defensive scores before trying again."), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_CAPTURESHIELD_FREE, 0, 0, NO_STR_ARG, CPID_CTF_CAPSHIELD, XPND2(0, 0), _("^BGYou are now free.\n^BGFeel free to ^F2try to capture^BG the flag again\n^BGif you think you will succeed."), "") \ - MULTITEAM_CENTER(CENTER_CTF_PASS_OTHER_, 2, 2, 0, XPND2(s1, s2), CPID_CTF_PASS, XPND2(0, 0), _("^BG%s^BG passed the ^TC^TT^BG flag to %s"), "") \ - MULTITEAM_CENTER(CENTER_CTF_PASS_SENT_, 2, 1, 0, s1, CPID_CTF_PASS, XPND2(0, 0), _("^BGYou passed the ^TC^TT^BG flag to %s"), "") \ - MULTITEAM_CENTER(CENTER_CTF_PASS_RECEIVED_, 2, 1, 0, s1, CPID_CTF_PASS, XPND2(0, 0), _("^BGYou received the ^TC^TT^BG flag from %s"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_PASS_REQUESTING, 1, 0, s1, CPID_CTF_PASS, XPND2(0, 0), _("^BGRequesting %s^BG to pass you the flag"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_PASS_REQUESTED, 1, 0, XPND2(s1, PASS_KEY), CPID_CTF_PASS, XPND2(0, 0), _("^BG%s^BG requests you to pass the flag%s"), "") \ - MULTITEAM_CENTER(CENTER_CTF_RETURN_, 2, 0, 0, NO_STR_ARG, CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGYou returned the ^TC^TT^BG flag!"), "") \ - MULTITEAM_CENTER(CENTER_CTF_CAPTURE_, 2, 0, 0, NO_STR_ARG, CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGYou captured the ^TC^TT^BG flag!"), "") \ - MULTITEAM_CENTER(CENTER_CTF_PICKUP_, 2, 0, 0, NO_STR_ARG, CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGYou got the ^TC^TT^BG flag!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_PICKUP_TEAM, 1, 0, s1, CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGYour %steam mate^BG got the flag! Protect them!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_PICKUP_TEAM_VERBOSE, 2, 0, XPND3(s1, s2, s1), CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGYour %steam mate (^BG%s%s)^BG got the flag! Protect them!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_PICKUP_ENEMY, 1, 0, s1, CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGThe %senemy^BG got your flag! Retrieve it!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_PICKUP_ENEMY_VERBOSE, 2, 0, XPND3(s1, s2, s1), CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGThe %senemy (^BG%s%s)^BG got your flag! Retrieve it!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_STALEMATE_CARRIER, 0, 0, NO_STR_ARG, CPID_STALEMATE, XPND2(0, 0), _("^BGStalemate! Enemies can now see you on radar!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_STALEMATE_OTHER, 0, 0, NO_STR_ARG, CPID_STALEMATE, XPND2(0, 0), _("^BGStalemate! Flag carriers can now be seen by enemies on radar!"), "") \ - MSG_CENTER_NOTIF(CENTER_CTF_FLAG_THROW_PUNISH, 0, 1, f1, CPID_CTF_LOWPRIO, XPND2(0, 0), _("^BGToo many flag throws! Throwing disabled for %d seconds."), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_CUSTOM, 2, 0, XPND2(s1, s2), NO_CPID, XPND2(0, 0), _("^K1You were %s, %s"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_GENERIC, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1Watch your step!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_SELFKILL, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You killed your own dumb self!"), _("^K1You need to be more careful!")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_SUICIDE, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You committed suicide!"), _("^K1You ended it all!")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_NOAMMO, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You were killed for running out of ammo..."), _("^K1You are respawning for running out of ammo...")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_ROT, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You grew too old without taking your medicine"), _("^K1You need to preserve your health")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_CAMP, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1Die camper!"), _("^K1Reconsider your tactics, camper!")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_BETRAYAL, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1Don't shoot your team mates!"), _("^K1Don't go against your team mates!")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_TEAMCHANGE, 0, 1, DEATH_TEAM, NO_CPID, XPND2(0, 0), _("^BGYou are now on: %s"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_AUTOTEAMCHANGE, 0, 1, DEATH_TEAM, NO_CPID, XPND2(0, 0), _("^BGYou have been moved into a different team\nYou are now on: %s"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_FALL, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You hit the ground with a crunch!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_DROWN, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You couldn't catch your breath in time!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_LAVA, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You couldn't stand the heat!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_SLIME, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You melted away in slime!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_SHOOTING_STAR, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You became a shooting star!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_SELF_SWAMP, 0, 0, NO_STR_ARG, NO_CPID, XPND2(0, 0), _("^K1You got stuck in a swamp!"), "") \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAG, 1, 1, XPND2(FRAG_SPREE, s1), NO_CPID, XPND2(0, 0), _("^K3%sYou fragged ^BG%s"), _("^K3%sYou scored against ^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAGGED, 1, 0, s1, NO_CPID, XPND2(0, 0), _("^K1You were fragged by ^BG%s"), _("^K1You were scored against by ^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAG, 1, 1, XPND2(FRAG_SPREE, s1), NO_CPID, XPND2(0, 0), _("^K1%sYou typefragged ^BG%s"), _("^K1%sYou scored against ^BG%s^K1 while they were typing")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAGGED, 1, 0, s1, NO_CPID, XPND2(0, 0), _("^K1You were typefragged by ^BG%s"), _("^K1You were scored against by ^BG%s^K1 while typing!")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAG_FIRST, 1, 0, s1, NO_CPID, XPND2(0, 0), _("^K3First blood! You fragged ^BG%s"), _("^K3First score! You scored against ^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAGGED_FIRST, 1, 0, s1, NO_CPID, XPND2(0, 0), _("^K1First victim! You were fragged by ^BG%s"), _("^K1First casualty! You were scored against by ^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAG_FIRST, 1, 0, s1, NO_CPID, XPND2(0, 0), _("^K1First blood! You typefragged ^BG%s"), _("^K1First score! You scored against ^BG%s^K1 while they were typing")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAGGED_FIRST, 1, 0, s1, NO_CPID, XPND2(0, 0), _("^K1First victim! You were typefragged by ^BG%s"), _("^K1First casualty! You were scored against by ^BG%s^K1 while typing!")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAG_VERBOSE, 1, 2, XPND3(FRAG_SPREE, s1, FRAG_PING), NO_CPID, XPND2(0, 0), _("^K3You fragged ^BG%s^BG%s"), _("^K3You scored against ^BG%s^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAGGED_VERBOSE, 1, 3, XPND2(s1, FRAG_STATS), NO_CPID, XPND2(0, 0), _("^K1You were fragged by ^BG%s^BG%s"), _("^K1You were scored against by ^BG%s^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAG_VERBOSE, 1, 2, XPND3(FRAG_SPREE, s1, FRAG_PING), NO_CPID, XPND2(0, 0), _("^K1You typefragged ^BG%s^BG%s"), _("^K1You scored against ^BG%s^K1 while they were typing^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAGGED_VERBOSE, 1, 3, XPND2(s1, FRAG_STATS), NO_CPID, XPND2(0, 0), _("^K1You were typefragged by ^BG%s^BG%s"), _("^K1You were scored against by ^BG%s^K1 while typing^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAG_FIRST_VERBOSE, 1, 1, s1, NO_CPID, XPND2(0, 0), _("^K3First blood! You fragged ^BG%s"), _("^K3First score! You scored against ^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_FRAGGED_FIRST_VERBOSE, 1, 3, s1, NO_CPID, XPND2(0, 0), _("^K1First victim! You were fragged by ^BG%s"), _("^K1First casualty! You were scored against by ^BG%s")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAG_FIRST_VERBOSE, 1, 1, s1, NO_CPID, XPND2(0, 0), _("^K1First blood! You typefragged ^BG%s"), _("^K1First score! You scored against ^BG%s^K1 while they were typing")) \ - MSG_CENTER_NOTIF(CENTER_DEATH_MURDER_TYPEFRAGGED_FIRST_VERBOSE, 1, 3, s1, NO_CPID, XPND2(0, 0), _("^K1First victim! You were typefragged by ^BG%s"), _("^K1First casualty! You were scored against by ^BG%s^K1 while typing!")) - -#define MSG_WEAPON_NOTIFICATIONS \ - MSG_WEAPON_NOTIF(DEATH_MARBLES_LOST3, 2, 1, XPND3(s1, s2, f1), _("^F1%s^BG lost their marbles against ^F1%s^BG using the ^F2%s^BG\n"), "") - -#define MSG_DEATH_NOTIFICATIONS \ - MSG_DEATH_NOTIF(DEATH_SELF_CUSTOM, CENTER_DEATH_SELF_CUSTOM, INFO_DEATH_SELF_CUSTOM) \ - MSG_DEATH_NOTIF(DEATH_SELF_GENERIC, CENTER_DEATH_SELF_GENERIC, INFO_DEATH_SELF_GENERIC) \ - MSG_DEATH_NOTIF(DEATH_SELF_SELFKILL, CENTER_DEATH_SELF_SELFKILL, INFO_DEATH_SELF_SELFKILL) \ - MSG_DEATH_NOTIF(DEATH_SELF_SUICIDE, CENTER_DEATH_SELF_SUICIDE, INFO_DEATH_SELF_SUICIDE) \ - MSG_DEATH_NOTIF(DEATH_SELF_NOAMMO, CENTER_DEATH_SELF_NOAMMO, INFO_DEATH_SELF_NOAMMO) \ - MSG_DEATH_NOTIF(DEATH_SELF_ROT, CENTER_DEATH_SELF_ROT, INFO_DEATH_SELF_ROT) \ - MSG_DEATH_NOTIF(DEATH_SELF_CAMP, CENTER_DEATH_SELF_CAMP, INFO_DEATH_SELF_CAMP) \ - MSG_DEATH_NOTIF(DEATH_SELF_BETRAYAL, CENTER_DEATH_SELF_BETRAYAL, INFO_DEATH_SELF_BETRAYAL) \ - MSG_DEATH_NOTIF(DEATH_SELF_TEAMCHANGE, CENTER_DEATH_SELF_TEAMCHANGE, INFO_DEATH_SELF_TEAMCHANGE) \ - MSG_DEATH_NOTIF(DEATH_SELF_AUTOTEAMCHANGE, CENTER_DEATH_SELF_AUTOTEAMCHANGE, INFO_DEATH_SELF_AUTOTEAMCHANGE) \ - MSG_DEATH_NOTIF(DEATH_SELF_FALL, CENTER_DEATH_SELF_FALL, INFO_DEATH_SELF_FALL) \ - MSG_DEATH_NOTIF(DEATH_SELF_DROWN, CENTER_DEATH_SELF_DROWN, INFO_DEATH_SELF_DROWN) \ - MSG_DEATH_NOTIF(DEATH_SELF_LAVA, CENTER_DEATH_SELF_LAVA, INFO_DEATH_SELF_LAVA) \ - MSG_DEATH_NOTIF(DEATH_SELF_SLIME, CENTER_DEATH_SELF_SLIME, INFO_DEATH_SELF_SLIME) \ - MSG_DEATH_NOTIF(DEATH_SELF_SHOOTING_STAR, CENTER_DEATH_SELF_SHOOTING_STAR, INFO_DEATH_SELF_SHOOTING_STAR) \ - MSG_DEATH_NOTIF(DEATH_SELF_SWAMP, CENTER_DEATH_SELF_SWAMP, INFO_DEATH_SELF_SWAMP) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAG, CENTER_DEATH_MURDER_FRAG, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAGGED, CENTER_DEATH_MURDER_FRAGGED, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAG, CENTER_DEATH_MURDER_TYPEFRAG, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAGGED, CENTER_DEATH_MURDER_TYPEFRAGGED, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAG_FIRST, CENTER_DEATH_MURDER_FRAG_FIRST, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAGGED_FIRST, CENTER_DEATH_MURDER_FRAGGED_FIRST, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAG_FIRST, CENTER_DEATH_MURDER_TYPEFRAG_FIRST, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAGGED_FIRST, CENTER_DEATH_MURDER_TYPEFRAGGED_FIRST, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAG_VERBOSE, CENTER_DEATH_MURDER_FRAG_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAGGED_VERBOSE, CENTER_DEATH_MURDER_FRAGGED_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAG_VERBOSE, CENTER_DEATH_MURDER_TYPEFRAG_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAGGED_VERBOSE, CENTER_DEATH_MURDER_TYPEFRAGGED_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAG_FIRST_VERBOSE, CENTER_DEATH_MURDER_FRAG_FIRST_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_FRAGGED_FIRST_VERBOSE, CENTER_DEATH_MURDER_FRAGGED_FIRST_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAG_FIRST_VERBOSE, CENTER_DEATH_MURDER_TYPEFRAG_FIRST_VERBOSE, NO_MSG) \ - MSG_DEATH_NOTIF(DEATH_MURDER_TYPEFRAGGED_FIRST_VERBOSE, CENTER_DEATH_MURDER_TYPEFRAGGED_FIRST_VERBOSE, NO_MSG) - + entity notif; + float i; -// ==================================== -// Initialization/Create Declarations -// ==================================== - -#define NOTIF_FIRST 1 -#define NOTIF_MAX 1024 // limit of recursive functions with ACCUMULATE_FUNCTION -float NOTIF_INFO_COUNT; -float NOTIF_CENTER_COUNT; -float NOTIF_WEAPON_COUNT; -float NOTIF_DEATH_COUNT; -float NOTIF_CPID_COUNT; - -#define MSG_INFO_NOTIF(name,strnum,flnum,args,icon,normal,gentle) \ - ADD_CSQC_AUTOCVAR(name) \ - float name; \ - void RegisterNotification_##name() \ - { \ - SET_FIELD_COUNT(name, NOTIF_FIRST, NOTIF_INFO_COUNT) \ - CHECK_MAX_COUNT(name, NOTIF_MAX, NOTIF_INFO_COUNT, "notifications") \ - } \ - ACCUMULATE_FUNCTION(RegisterNotifications, RegisterNotification_##name) - -#define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) \ - ADD_CSQC_AUTOCVAR(name) \ - float name; \ - float cpid; \ - void RegisterNotification_##name() \ - { \ - SET_FIELD_COUNT(name, NOTIF_FIRST, NOTIF_CENTER_COUNT) \ - SET_FIELD_COUNT(cpid, NOTIF_FIRST, NOTIF_CPID_COUNT) \ - CHECK_MAX_COUNT(name, NOTIF_MAX, NOTIF_CENTER_COUNT, "notifications") \ - } \ - ACCUMULATE_FUNCTION(RegisterNotifications, RegisterNotification_##name) - -#define MSG_WEAPON_NOTIF(name,strnum,flnum,args,normal,gentle) \ - ADD_CSQC_AUTOCVAR(name) \ - float name; \ - void RegisterNotification_##name() \ - { \ - SET_FIELD_COUNT(name, NOTIF_FIRST, NOTIF_WEAPON_COUNT) \ - CHECK_MAX_COUNT(name, NOTIF_MAX, NOTIF_WEAPON_COUNT, "notifications") \ - } \ - ACCUMULATE_FUNCTION(RegisterNotifications, RegisterNotification_##name) - -#define MSG_DEATH_NOTIF(name,centername,infoname) \ - ADD_CSQC_AUTOCVAR(name) \ - float name; \ - void RegisterNotification_##name() \ - { \ - SET_FIELD_COUNT(name, NOTIF_FIRST, NOTIF_DEATH_COUNT) \ - CHECK_MAX_COUNT(name, NOTIF_MAX, NOTIF_DEATH_COUNT, "notifications") \ - } \ - ACCUMULATE_FUNCTION(RegisterNotifications, RegisterNotification_##name) - -// NOW we actually activate the declarations -MSG_INFO_NOTIFICATIONS -MSG_CENTER_NOTIFICATIONS -MSG_WEAPON_NOTIFICATIONS -MSG_DEATH_NOTIFICATIONS -#undef MSG_INFO_NOTIF -#undef MSG_CENTER_NOTIF -#undef MSG_WEAPON_NOTIF -#undef MSG_DEATH_NOTIF - -// ====================== -// Supporting Functions -// ====================== - -// select between the normal or the gentle message string based on client (or server) settings -string normal_or_gentle(string normal, string gentle) -{ - #ifndef MENUQC - #ifdef CSQC - if(autocvar_cl_gentle || autocvar_cl_gentle_messages) - #else - if(autocvar_sv_gentle) - #endif - return ((gentle != "") ? gentle : normal); - else - return normal; + #define DESTROY_LOOP(type,count) \ + for(i = 1; i <= count; ++i) \ + { \ + notif = Get_Notif_Ent(type, i); \ + if not(notif) { backtrace("Destroy_All_Notifications(): Missing notification entity!\n"); return; } \ + Destroy_Notification_Entity(notif); \ + } + + // kill all networked notifications and centerprints + #ifdef SVQC + Kill_Notification(NOTIF_ALL, world, 0, 0); #else - return normal; + reset_centerprint_messages(); #endif + + // kill all real notification entities + DESTROY_LOOP(MSG_ANNCE, NOTIF_ANNCE_COUNT) + DESTROY_LOOP(MSG_INFO, NOTIF_INFO_COUNT) + DESTROY_LOOP(MSG_CENTER, NOTIF_CENTER_COUNT) + DESTROY_LOOP(MSG_MULTI, NOTIF_MULTI_COUNT) + DESTROY_LOOP(MSG_CHOICE, NOTIF_CHOICE_COUNT) + #undef DESTROY_LOOP } -float notif_stringcount(string s1, string s2) +string Process_Notif_Line( + float typeid, + float chat, + string input, + string notiftype, + string notifname, + string stringtype) { - float stringcount; - if(s1 != NO_STR_ARG) ++stringcount; - if(s2 != NO_STR_ARG) ++stringcount; - return stringcount; + #ifdef CSQC + if(typeid == MSG_INFO) + { + if((chat && autocvar_notification_allow_chatboxprint) + || (autocvar_notification_allow_chatboxprint == 2)) + { + // pass 1: add ETX char at beginning of line + input = strcat("\{3}", input); + + // pass 2: add ETX char at end of each new line (so that + // messages with multiple lines are put through chatbox too) + input = strreplace("\n", "\n\{3}", input); + + // pass 3: strip trailing ETX char + if(substring(input, (strlen(input) - 1), 1) == "\{3}") + { input = substring(input, 0, (strlen(input) - 1)); } + } + } + #endif + + // done to both MSG_INFO and MSG_CENTER + if(substring(input, (strlen(input) - 1), 1) == "\n") + { + print(sprintf( + strcat( + "^1TRAILING NEW LINE AT END OF NOTIFICATION: ", + "^7net_type = %s, net_name = %s, string = %s.\n" + ), + notiftype, + notifname, + stringtype + )); + notif_error = TRUE; + input = substring(input, 1, (strlen(input) - 1)); + } + + return input; } -float notif_floatcount(float f1, float f2, float f3) +string Process_Notif_Args( + float arg_type, + string args, + string notiftype, + string notifname) { - float floatcount; - if(f1 != NO_FL_ARG) ++floatcount; - if(f2 != NO_FL_ARG) ++floatcount; - if(f3 != NO_FL_ARG) ++floatcount; - return floatcount; + string selected, remaining = args; + float sel_num = 0; + + for(;(remaining != "");) + { + selected = car(remaining); remaining = cdr(remaining); + + switch(arg_type) + { + case 1: // normal args + { + if(sel_num == NOTIF_MAX_ARGS) + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS TOO MANY ARGUMENTS: ", + "^7net_type = %s, net_name = %s, max args = %d.\n" + ), + notiftype, + notifname, + NOTIF_MAX_ARGS + )); + notif_error = TRUE; + break; + } + + switch(strtolower(selected)) + { + #define ARG_CASE(prog,selected,result) \ + #if (prog != ARG_DC) \ + case selected: { ++sel_num; break; } \ + #endif + NOTIF_ARGUMENT_LIST + #undef ARG_CASE + default: + { + print(sprintf( + strcat( + "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: ", + "^7net_type = %s, net_name = %s, args arg = '%s'.\n" + ), + notiftype, + notifname, + selected + )); + notif_error = TRUE; + break; + } + } + break; + } + case 2: // hudargs + { + if(sel_num == NOTIF_MAX_HUDARGS) + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS TOO MANY ARGUMENTS: ", + "^7net_type = %s, net_name = %s, max hudargs = %d.\n" + ), + notiftype, + notifname, + NOTIF_MAX_HUDARGS + )); + notif_error = TRUE; + break; + } + + switch(strtolower(selected)) + { + #define ARG_CASE(prog,selected,result) \ + #if (prog == ARG_CS_SV_HA) \ + case selected: { ++sel_num; break; } \ + #endif + NOTIF_ARGUMENT_LIST + #undef ARG_CASE + default: + { + print(sprintf( + strcat( + "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: ", + "^7net_type = %s, net_name = %s, hudargs arg = '%s'.\n" + ), + notiftype, + notifname, + selected + )); + notif_error = TRUE; + break; + } + } + break; + } + case 3: // durcnt + { + if(sel_num == NOTIF_MAX_DURCNT) + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS TOO MANY ARGUMENTS: ", + "^7net_type = %s, net_name = %s, max durcnt = %d.\n" + ), + notiftype, + notifname, + NOTIF_MAX_DURCNT + )); + notif_error = TRUE; + break; + } + + switch(strtolower(selected)) + { + #define ARG_CASE(prog,selected,result) \ + #if (prog == ARG_CS_SV_DC) || (prog == ARG_DC) \ + case selected: { ++sel_num; break; } \ + #endif + NOTIF_ARGUMENT_LIST + #undef ARG_CASE + default: + { + if(ftos(stof(selected)) != "") { ++sel_num; } + else + { + print(sprintf( + strcat( + "^1NOTIFICATION WITH UNKNOWN TOKEN IN ARGUMENT STRING: ", + "^7net_type = %s, net_name = %s, durcnt arg = '%s'.\n" + ), + notiftype, + notifname, + selected + )); + notif_error = TRUE; + } + break; + } + } + break; + } + } + } + return args; } -// get the actual name of a notification and return it as a string -string Get_Field_Value(float field, float net_type, float net_name) +void Create_Notification_Entity( + float var_default, + float var_cvar, + float typeid, + float nameid, + string namestring, + float strnum, + float flnum, + /* MSG_ANNCE */ + float channel, + string snd, + float vol, + float position, + /* MSG_INFO & MSG_CENTER */ + string args, + string hudargs, + string icon, + float cpid, + string durcnt, + string normal, + string gentle, + /* MSG_MULTI */ + float anncename, + float infoname, + float centername, + /* MSG_CHOICE */ + float challow_def, + float challow_var, + float chtype, + float optiona, + float optionb) { - string output; - - #define GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) \ - if(field == F_NAME) { output = VAR_TO_TEXT(name); } \ - else if(field == F_STRNUM) { output = ftos(strnum); } \ - else if(field == F_FLNUM) { output = ftos(flnum); } - - switch(net_type) + // ===================== + // Global Entity Setup + // ===================== + entity notif = spawn(); + switch(typeid) { + case MSG_ANNCE: + { + msg_annce_notifs[nameid - 1] = notif; + notif.classname = "msg_annce_notification"; + break; + } case MSG_INFO: { - #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) \ - { NOTIF_MATCH(name, net_name) { GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) } } - MSG_INFO_NOTIFICATIONS - #undef MSG_INFO_NOTIF + msg_info_notifs[nameid - 1] = notif; + notif.classname = "msg_info_notification"; + break; + } + case MSG_CENTER: + { + msg_center_notifs[nameid - 1] = notif; + notif.classname = "msg_center_notification"; + break; + } + case MSG_MULTI: + { + msg_multi_notifs[nameid - 1] = notif; + notif.classname = "msg_multi_notification"; + break; + } + case MSG_CHOICE: + { + msg_choice_notifs[nameid - 1] = notif; + notif.classname = "msg_choice_notification"; break; } + + default: + { + error(sprintf( + strcat( + "^1NOTIFICATION WITH IMPROPER TYPE: ", + "^7net_type = %d, net_name = %s.\n" + ), + typeid, + namestring + )); + return; // It's not possible to recover from this one + } + } + notif.nent_default = var_default; + notif.nent_enabled = (1 <= var_cvar); + notif.nent_type = typeid; + notif.nent_id = nameid; + notif.nent_name = strzone(namestring); + + string typestring = Get_Notif_TypeName(typeid); + + // Other pre-notif-setup requisites + notif_error = FALSE; + + // ==================== + // Notification Setup + // ==================== + switch(typeid) + { + case MSG_ANNCE: + { + // Set MSG_ANNCE information and handle precaching + #ifdef CSQC + if not(GENTLE && (var_cvar == 1)) + { + if(snd != "") + { + if(notif.nent_enabled) + { + precache_sound(sprintf("announcer/%s/%s.wav", autocvar_cl_announcer, snd)); + notif.nent_channel = channel; + notif.nent_snd = strzone(snd); + notif.nent_vol = vol; + notif.nent_position = position; + } + } + else + { + print(sprintf( + strcat( + "^1NOTIFICATION WITH NO SOUND: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + } + else { notif.nent_enabled = FALSE; } + #else + notif.nent_enabled = FALSE; + #endif + + break; + } + + case MSG_INFO: case MSG_CENTER: { - #define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) \ - { NOTIF_MATCH(name, net_name) { GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) } } - MSG_CENTER_NOTIFICATIONS - #undef MSG_CENTER_NOTIF + // Set MSG_INFO and MSG_CENTER string/float counts + notif.nent_stringcount = strnum; + notif.nent_floatcount = flnum; + + // Only initialize arguments if we're either a client or on a dedicated server + #ifdef SVQC + float should_process_args = server_is_dedicated; + #else + float should_process_args = TRUE; + #endif + + if(should_process_args) + { + // ======================== + // Process Main Arguments + // ======================== + if(strnum + flnum) + { + if(args != "") + { + notif.nent_args = strzone( + Process_Notif_Args(1, args, typestring, namestring)); + } + else if((hudargs == "") && (durcnt =="")) + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS ARG COUNTS BUT NO ARGS OR HUDARGS OR DURCNT: ", + "^7net_type = %s, net_name = %s, strnum = %d, flnum = %d\n" + ), + typestring, + namestring, + strnum, + flnum + )); + notif_error = TRUE; + } + } + else if(args != "") + { + notif.nent_args = strzone( + Process_Notif_Args(1, args, typestring, namestring)); + } + + + // ======================================= + // Process HUD and Centerprint Arguments + // Only processed on CSQC, as these + // args are only for HUD features. + // ======================================= + #ifdef CSQC + if(hudargs != "") + { + notif.nent_hudargs = strzone( + Process_Notif_Args(2, hudargs, typestring, namestring)); + + if(icon != "") { notif.nent_icon = strzone(icon); } + else + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS HUDARGS BUT NO ICON: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + } + else if(icon != "") + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS ICON BUT NO HUDARGS: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + + if(durcnt != "") + { + notif.nent_durcnt = strzone( + Process_Notif_Args(3, durcnt, typestring, namestring)); + + if(cpid != NO_MSG) { notif.nent_cpid = cpid; } + else + { + print(sprintf( + strcat( + "^1NOTIFICATION HAS DURCNT BUT NO CPID: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + } + else if(cpid != NO_MSG) { notif.nent_cpid = cpid; } + #endif + + + // ====================== + // Process Notif String + // ====================== + #define SET_NOTIF_STRING(string,stringname) \ + notif.nent_string = strzone(CCR( \ + Process_Notif_Line( \ + typeid, \ + (var_cvar > 1), \ + string, \ + typestring, \ + namestring, \ + stringname \ + )) \ + ); + + if(GENTLE) + { + if(gentle != "") { SET_NOTIF_STRING(gentle, "GENTLE") } + else if(normal != "") { SET_NOTIF_STRING(normal, "NORMAL") } + } + else if(normal != "") { SET_NOTIF_STRING(normal, "NORMAL") } + + #undef SET_NOTIF_STRING + + // Check to make sure a string was chosen + if(notif.nent_string == "") + { + print(sprintf( + strcat( + "^1EMPTY NOTIFICATION: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + } + break; } - case MSG_WEAPON: + + case MSG_MULTI: { - #define MSG_WEAPON_NOTIF(name,strnum,flnum,args,normal,gentle) \ - { NOTIF_MATCH(name, net_name) { GET_FIELD_VALUE_OUTPUT(field,name,strnum,flnum) } } - MSG_WEAPON_NOTIFICATIONS - #undef MSG_WEAPON_NOTIF + // Set MSG_MULTI string/float counts + if((anncename == NO_MSG) && (infoname == NO_MSG) && (centername == NO_MSG)) + { + print(sprintf( + strcat( + "^1NOTIFICATION WITH NO SUBCALLS: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + else + { + // announcements don't actually need any arguments, so lets not even count them. + if(anncename != NO_MSG) { notif.nent_msgannce = msg_annce_notifs[anncename - 1]; } + + float infoname_stringcount = 0, infoname_floatcount = 0; + float centername_stringcount = 0, centername_floatcount = 0; + + if(infoname != NO_MSG) + { + notif.nent_msginfo = msg_info_notifs[infoname - 1]; + infoname_stringcount = notif.nent_msginfo.nent_stringcount; + infoname_floatcount = notif.nent_msginfo.nent_floatcount; + } + + if(centername != NO_MSG) + { + notif.nent_msgcenter = msg_center_notifs[centername - 1]; + centername_stringcount = notif.nent_msgcenter.nent_stringcount; + centername_floatcount = notif.nent_msgcenter.nent_floatcount; + } + + // set the requirements of THIS notification to the totals of its subcalls + notif.nent_stringcount = max(infoname_stringcount, centername_stringcount); + notif.nent_floatcount = max(infoname_floatcount, centername_floatcount); + } + break; } - case MSG_DEATH: + + case MSG_CHOICE: { - #define MSG_DEATH_NOTIF(name,centername,infoname) \ - { NOTIF_MATCH(name, net_name) { GET_FIELD_VALUE_OUTPUT(field,name, \ - max(stof(Get_Field_Value(F_STRNUM, MSG_CENTER, centername)), stof(Get_Field_Value(F_STRNUM, MSG_INFO, infoname))), \ - max(stof(Get_Field_Value(F_FLNUM, MSG_CENTER, centername)), stof(Get_Field_Value(F_FLNUM, MSG_INFO, infoname)))) } } - MSG_DEATH_NOTIFICATIONS - #undef MSG_DEATH_NOTIF + if((chtype == NO_MSG) || (optiona == NO_MSG) || (optionb == NO_MSG)) + { + print(sprintf( + strcat( + "^1NOTIFICATION IS MISSING CHOICE PARAMS: ", + "^7net_type = %s, net_name = %s.\n" + ), + typestring, + namestring + )); + notif_error = TRUE; + } + else + { + switch(chtype) + { + case MSG_ANNCE: + { + notif.nent_optiona = msg_annce_notifs[optiona - 1]; + notif.nent_optionb = msg_annce_notifs[optionb - 1]; + break; + } + case MSG_INFO: + { + notif.nent_optiona = msg_info_notifs[optiona - 1]; + notif.nent_optionb = msg_info_notifs[optionb - 1]; + break; + } + case MSG_CENTER: + { + notif.nent_optiona = msg_center_notifs[optiona - 1]; + notif.nent_optionb = msg_center_notifs[optionb - 1]; + break; + } + case MSG_MULTI: + { + notif.nent_optiona = msg_multi_notifs[optiona - 1]; + notif.nent_optionb = msg_multi_notifs[optionb - 1]; + break; + } + case MSG_CHOICE: // should we REALLY allow nested options?... + { + notif.nent_optiona = msg_choice_notifs[optiona - 1]; + notif.nent_optionb = msg_choice_notifs[optionb - 1]; + break; + } + + default: + { + error(sprintf( + strcat( + "^1NOTIFICATION WITH IMPROPER TYPE: ", + "^7net_type = %d, net_name = %s.\n" + ), + typeid, + namestring + )); + notif_error = TRUE; + break; + } + } + notif.nent_challow_def = challow_def; // 0: never allowed, 1: allowed in warmup, 2: always allowed + notif.nent_challow_var = challow_var; // 0: never allowed, 1: allowed in warmup, 2: always allowed + notif.nent_stringcount = max(notif.nent_optiona.nent_stringcount, notif.nent_optionb.nent_stringcount); + notif.nent_floatcount = max(notif.nent_optiona.nent_floatcount, notif.nent_optionb.nent_floatcount); + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Create_Notification_Entity(...): MSG_CHOICE: %s\n%s\n%s\n", + notif.nent_name, + sprintf( + "^ optiona: %s %s : %d %d", + Get_Notif_TypeName(notif.nent_optiona.nent_type), + notif.nent_optiona.nent_name, + notif.nent_optiona.nent_stringcount, + notif.nent_optiona.nent_floatcount + ), + sprintf( + "^ optionb: %s %s : %d %d", + Get_Notif_TypeName(notif.nent_optionb.nent_type), + notif.nent_optionb.nent_name, + notif.nent_optionb.nent_stringcount, + notif.nent_optionb.nent_floatcount + ) + )); + #endif + } break; } + + default: print("DAFUQ?\n"); notif_error = TRUE; break; } - #undef GET_FIELD_VALUE_OUTPUT - return output; + // now check to see if any errors happened + if(notif_error) + { + notif.nent_enabled = FALSE; // disable the notification so it can't cause trouble + notif_global_error = TRUE; // throw the red flag that an error happened on init + } } -// team code replace -string TCR(string input, string teamcolor, string teamtext) +// =============== +// Cvar Handling +// =============== + +// used by MSG_CHOICE to build list of choices +#ifdef SVQC +void Notification_GetCvars(void) { - input = strreplace("^TC", teamcolor, input); - input = strreplace("^TT", teamtext, input); - return input; + float i; + for(i = 0; i <= NOTIF_CHOICE_COUNT; ++i) + { + GetCvars_handleFloat( + get_cvars_s, + get_cvars_f, + msg_choice_choices[i], + sprintf("notification_%s", msg_choice_notifs[i].nent_name) + ); + } + + GetCvars_handleFloat(get_cvars_s, get_cvars_f, FRAG_VERBOSE, "notification_frag_verbose"); } +#endif -// color code replace, place inside of sprintf and parse the string -string CCR(string input) +// used to output notifications.cfg file +void Dump_Notifications(float fh, float alsoprint) { - // foreground/normal colors - input = strreplace("^F1", "^2", input); // primary priority (important names, etc) - input = strreplace("^F2", "^3", input); // secondary priority (items, locations, numbers, etc) - - // "kill" colors - input = strreplace("^K1", "^1", input); // "bad" or "dangerous" text (death messages against you, kill notifications, etc) - input = strreplace("^K2", "^3", input); // similar to above, but less important... OR, a highlight out of above message type - input = strreplace("^K3", "^4", input); // "good" or "beneficial" text (you fragging someone, etc) - - // background colors - input = strreplace("^BG", "^7", input); // neutral/unimportant text - input = strreplace("^N", "^7", input); // "none"-- reset to white... - return input; -} + #define NOTIF_WRITE(a) { \ + fputs(fh, a); \ + if(alsoprint) { print(a); } } + #define NOTIF_WRITE_ENTITY(description) { \ + notif_msg = \ + sprintf( \ + "seta notification_%s \"%d\" \"%s\"\n", \ + e.nent_name, e.nent_default, description \ + ); \ + NOTIF_WRITE(notif_msg) } + #define NOTIF_WRITE_ENTITY_CHOICE(descriptiona,descriptionb) { \ + notif_msg = \ + sprintf( \ + "seta notification_%s \"%d\" \"%s\"\n" \ + "seta notification_%s_ALLOWED \"%d\" \"%s\"\n", \ + e.nent_name, e.nent_default, descriptiona, \ + e.nent_name, e.nent_challow_def, descriptionb \ + ); \ + NOTIF_WRITE(notif_msg) } + #define NOTIF_WRITE_HARDCODED(cvar,default,description) { \ + notif_msg = \ + sprintf( \ + "seta notification_%s \"%s\" \"%s\"\n", \ + cvar, default, description \ + ); \ + NOTIF_WRITE(notif_msg) } + + string notif_msg; + float i; + entity e; + + // Note: This warning only applies to the notifications.cfg file that is output... + + // You ARE supposed to manually edit this function to add i.e. hard coded + // notification variables for mutators or game modes or such and then + // regenerate the notifications.cfg file from the new code. + + NOTIF_WRITE("// ********************************************** //\n"); + NOTIF_WRITE("// ** WARNING - DO NOT MANUALLY EDIT THIS FILE ** //\n"); + NOTIF_WRITE("// ** ** //\n"); + NOTIF_WRITE("// ** This file is automatically generated ** //\n"); + NOTIF_WRITE("// ** by code with the command 'dumpnotifs'. ** //\n"); + NOTIF_WRITE("// ** ** //\n"); + NOTIF_WRITE("// ** If you add a new notification, please ** //\n"); + NOTIF_WRITE("// ** regenerate this file with that command ** //\n"); + NOTIF_WRITE("// ** making sure that the output matches ** //\n"); + NOTIF_WRITE("// ** with the lists and defaults in code. ** //\n"); + NOTIF_WRITE("// ** ** //\n"); + NOTIF_WRITE("// ********************************************** //\n"); + + // These notifications will also append their string as a comment... + // This is not necessary, and does not matter if they vary between config versions, + // it is just a semi-helpful tool for those who want to manually change their user settings. + + NOTIF_WRITE(sprintf("\n// MSG_ANNCE notifications (count = %d):\n", NOTIF_ANNCE_COUNT)); + for(i = 1; i <= NOTIF_ANNCE_COUNT; ++i) + { + e = Get_Notif_Ent(MSG_ANNCE, i); + if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; } + + NOTIF_WRITE_ENTITY( + "Notification control cvar: 0 = disabled, 1 = enabled if gentle mode is off, 2 = always enabled)" + ); + } + NOTIF_WRITE(sprintf("\n// MSG_INFO notifications (count = %d):\n", NOTIF_INFO_COUNT)); + for(i = 1; i <= NOTIF_INFO_COUNT; ++i) + { + e = Get_Notif_Ent(MSG_INFO, i); + if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; } + + NOTIF_WRITE_ENTITY( + "Notification control cvar: 0 = off, 1 = print to console, " + "2 = print to console and chatbox (if notification_allow_chatboxprint is enabled)" + ); + } -// ============================= -// Debug/Maintenance Functions -// ============================= + NOTIF_WRITE(sprintf("\n// MSG_CENTER notifications (count = %d):\n", NOTIF_CENTER_COUNT)); + for(i = 1; i <= NOTIF_CENTER_COUNT; ++i) + { + e = Get_Notif_Ent(MSG_CENTER, i); + if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; } + + NOTIF_WRITE_ENTITY( + "Notification control cvar: 0 = off, 1 = centerprint" + ); + } -#define NOTIF_Write(type,name,text) fputs(fh, (sprintf("seta %s 1 // %s - %s\n", name, type, strreplace("\n", "\\n", text)))) -void Dump_Notifications(float fh) -{ - #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) { NOTIF_Write("MSG_INFO", VAR_TO_TEXT(name), normal); } - #define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) { NOTIF_Write("MSG_CENTER", VAR_TO_TEXT(name), normal); } - #define MSG_WEAPON_NOTIF(name,strnum,flnum,args,normal,gentle) { NOTIF_Write("MSG_WEAPON", VAR_TO_TEXT(name), normal); } - #define MSG_DEATH_NOTIF(name,centername,infoname) { NOTIF_Write("MSG_DEATH", VAR_TO_TEXT(name), sprintf("centername: %s, infoname: %s", VAR_TO_TEXT(centername), VAR_TO_TEXT(infoname))); } - MSG_INFO_NOTIFICATIONS - MSG_CENTER_NOTIFICATIONS - MSG_WEAPON_NOTIFICATIONS - MSG_DEATH_NOTIFICATIONS - #undef MSG_INFO_NOTIF - #undef MSG_CENTER_NOTIF - #undef MSG_WEAPON_NOTIF - #undef MSG_DEATH_NOTIF + NOTIF_WRITE(sprintf("\n// MSG_MULTI notifications (count = %d):\n", NOTIF_MULTI_COUNT)); + for(i = 1; i <= NOTIF_MULTI_COUNT; ++i) + { + e = Get_Notif_Ent(MSG_MULTI, i); + if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; } + + NOTIF_WRITE_ENTITY( + "Notification control cvar: 0 = off, 1 = trigger subcalls" + ); + } + + NOTIF_WRITE(sprintf("\n// MSG_CHOICE notifications (count = %d):\n", NOTIF_CHOICE_COUNT)); + for(i = 1; i <= NOTIF_CHOICE_COUNT; ++i) + { + e = Get_Notif_Ent(MSG_CHOICE, i); + if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; } + + NOTIF_WRITE_ENTITY_CHOICE( + "Notification control cvar: 0 = off, 1 = trigger option A subcall, 2 = trigger option B subcall", + "Notification control cvar: 0 = off, 1 = allowed in warmup mode, 2 = always allowed" + ); + } + + // edit these to match whichever cvars are used for specific notification options + NOTIF_WRITE("\n// HARD CODED notification variables:\n"); + + NOTIF_WRITE_HARDCODED( + "allow_chatboxprint", "1", + "Allow notifications to be printed to chat box by setting notification cvar to 2 " + "(You can also set this cvar to 2 to force ALL notifications to be printed to the chatbox)" + ); + + NOTIF_WRITE_HARDCODED( + "debug", "0", + "Print extra debug information on all notification function calls " + "(Requires -DNOTIFICATIONS_DEBUG flag to be enabled on QCSRC compilation)... " + "0 = disabled, 1 = dprint, 2 = print" + ); + + NOTIF_WRITE_HARDCODED( + "errors_are_fatal", "1", + "If a notification fails upon initialization, cause a Host_Error to stop the program" + ); + + NOTIF_WRITE_HARDCODED( + "item_centerprinttime", "1.5", + "How long to show item information centerprint messages (like 'You got the Electro' or such)" + ); + + NOTIF_WRITE_HARDCODED( + "lifetime_mapload", "10", + "Amount of time that notification entities last immediately at mapload (in seconds) " + "to help prevent notifications from being lost on early init (like gamestart countdown)" + ); + + NOTIF_WRITE_HARDCODED( + "lifetime_runtime", "0.5", + "Amount of time that notification entities last on the server during runtime (In seconds)" + ); + + NOTIF_WRITE_HARDCODED( + "server_allows_location", "1", + "Server side cvar for allowing death messages to show location information too" + ); + + NOTIF_WRITE_HARDCODED( + "show_location", "0", + "Append location information to MSG_INFO death/kill messages" + ); + + NOTIF_WRITE_HARDCODED( + "show_location_string", "", + "Replacement string piped into sprintf, " + "so you can do different messages like this: ' at the %s' or ' (near %s)'" + ); + + NOTIF_WRITE_HARDCODED( + "show_sprees", "1", + "Print information about sprees in death/kill messages" + ); + + NOTIF_WRITE_HARDCODED( + "show_sprees_center", "1", + "Show spree information in MSG_CENTER messages... " + "0 = off, 1 = target (but only for first victim) and attacker" + ); + + NOTIF_WRITE_HARDCODED( + "show_sprees_center_specialonly", "1", + "Don't show spree information in MSG_CENTER messages if it isn't an achievement" + ); + + NOTIF_WRITE_HARDCODED( + "show_sprees_info", "3", + "Show spree information in MSG_INFO messages... " + "0 = off, 1 = target only, 2 = attacker only, 3 = target and attacker" + ); + + NOTIF_WRITE_HARDCODED( + "show_sprees_info_newline", "1", + "Show attacker spree information for MSG_INFO messages on a separate line than the death notification itself" + ); + + NOTIF_WRITE_HARDCODED( + "show_sprees_info_specialonly", "1", + "Don't show attacker spree information in MSG_INFO messages if it isn't an achievement" + ); + + NOTIF_WRITE(sprintf( + strcat( + "\n// Notification counts (total = %d): ", + "MSG_ANNCE = %d, MSG_INFO = %d, MSG_CENTER = %d, MSG_MULTI = %d, MSG_CHOICE = %d\n" + ), + ( + NOTIF_ANNCE_COUNT + + NOTIF_INFO_COUNT + + NOTIF_CENTER_COUNT + + NOTIF_MULTI_COUNT + + NOTIF_CHOICE_COUNT + ), + NOTIF_ANNCE_COUNT, + NOTIF_INFO_COUNT, + NOTIF_CENTER_COUNT, + NOTIF_MULTI_COUNT, + NOTIF_CHOICE_COUNT + )); + return; + #undef NOTIF_WRITE_HARDCODED + #undef NOTIF_WRITE_ENTITY + #undef NOTIF_WRITE } @@ -490,93 +1132,414 @@ void Dump_Notifications(float fh) // Frontend Notification Pushing // =============================== +#ifdef NOTIFICATIONS_DEBUG +void Debug_Notification(string input) +{ + switch(autocvar_notification_debug) + { + case 1: { dprint(input); break; } + case 2: { print(input); break; } + } +} +#endif + +string Local_Notification_sprintf( + string input, string args, + string s1, string s2, string s3, string s4, + float f1, float f2, float f3, float f4) +{ + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Local_Notification_sprintf('%s^7', '%s', %s, %s);\n", + MakeConsoleSafe(input), + args, + MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)), + sprintf("%d, %d, %d, %d", f1, f2, f3, f4) + )); + #endif + + string selected; + float sel_num; + for(sel_num = 0; sel_num < NOTIF_MAX_ARGS; ++sel_num) { arg_slot[sel_num] = ""; } + + string tmp_s; + + for(sel_num = 0;(args != "");) + { + selected = car(args); args = cdr(args); + NOTIF_HIT_MAX(NOTIF_MAX_ARGS, "Local_Notification_sprintf") + switch(strtolower(selected)) + { + #define ARG_CASE(prog,selected,result) \ + #ifdef CSQC \ + #if (prog != ARG_SV) && (prog != ARG_DC) \ + case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \ + #endif \ + #else \ + #if (prog != ARG_CS) && (prog != ARG_DC) \ + case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \ + #endif \ + #endif + NOTIF_ARGUMENT_LIST + #undef ARG_CASE + default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_ARGS, "Local_Notification_sprintf") + } + } + return sprintf( + strcat(input, "\n"), + arg_slot[0], + arg_slot[1], + arg_slot[2], + arg_slot[3], + arg_slot[4], + arg_slot[5], + arg_slot[6] + ); +} + #ifdef CSQC -#define KN_MAX_ENTRIES 10 -float kn_index; -float killnotify_times[KN_MAX_ENTRIES]; -string killnotify_icon[KN_MAX_ENTRIES]; -string killnotify_attackers[KN_MAX_ENTRIES]; -string killnotify_victims[KN_MAX_ENTRIES]; -// 0 = "Y [used by] X", 1 = "X [did action to] Y" -void HUD_Notify_Push(string icon, string attacker, string victim) +void Local_Notification_sound( + float soundchannel, string soundfile, + float soundvolume, float soundposition) { - if(icon != "") + if((soundfile != prev_soundfile) || (time >= (prev_soundtime + autocvar_cl_announcer_antispam))) { - --kn_index; - if (kn_index == -1) { kn_index = KN_MAX_ENTRIES-1; } - killnotify_times[kn_index] = time; + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Local_Notification_sound(world, %f, '%s', %f, %f);\n", + soundchannel, + sprintf( + "announcer/%s/%s.wav", + autocvar_cl_announcer, + soundfile + ), + soundvolume, + soundposition + )); + #endif + + sound( + world, + soundchannel, + sprintf( + "announcer/%s/%s.wav", + autocvar_cl_announcer, + soundfile + ), + soundvolume, + soundposition + ); + + if(prev_soundfile) { strunzone(prev_soundfile); } + prev_soundfile = strzone(soundfile); + prev_soundtime = time; + } + else + { + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + strcat( + "Local_Notification_sound(world, %f, '%s', %f, %f) ", + "^1BLOCKED BY ANTISPAM:^7 prevsnd: '%s', timediff: %f, limit: %f\n" + ), + soundchannel, + sprintf( + "announcer/%s/%s.wav", + autocvar_cl_announcer, + soundfile + ), + soundvolume, + soundposition, + prev_soundfile, + (time - prev_soundtime), + autocvar_cl_announcer_antispam + )); + #endif + } +} - // icon - if(killnotify_icon[kn_index]) { strunzone(killnotify_icon[kn_index]); } - killnotify_icon[kn_index] = strzone(icon); +void Local_Notification_HUD_Notify_Push( + string icon, string hudargs, + string s1, string s2, string s3, string s4) +{ + string selected; + float sel_num; + arg_slot[0] = ""; arg_slot[1] = ""; + + for(sel_num = 0;(hudargs != "");) + { + selected = car(hudargs); hudargs = cdr(hudargs); + NOTIF_HIT_MAX(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push") + switch(strtolower(selected)) + { + #define ARG_CASE(prog,selected,result) \ + #if (prog == ARG_CS_SV_HA) \ + case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \ + #endif + NOTIF_ARGUMENT_LIST + #undef ARG_CASE + default: NOTIF_HIT_UNKNOWN(NOTIF_MAX_HUDARGS, "Local_Notification_HUD_Notify_Push") + } + } + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Local_Notification_HUD_Notify_Push('%s^7', '%s', %s, %s);\n", + icon, + hudargs, + MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)), + MakeConsoleSafe(sprintf("'%s^7', '%s^7'", stof(arg_slot[0]), stof(arg_slot[1]))) + )); + #endif + HUD_Notify_Push(icon, arg_slot[0], arg_slot[1]); +} - // attacker - if(killnotify_attackers[kn_index]) { strunzone(killnotify_attackers[kn_index]); } - killnotify_attackers[kn_index] = strzone(attacker); +void Local_Notification_centerprint_generic( + string input, string durcnt, + float cpid, float f1, float f2) +{ + string selected; + float sel_num; + arg_slot[0] = ""; arg_slot[1] = ""; - // victim - if(killnotify_victims[kn_index]) { strunzone(killnotify_victims[kn_index]); } - killnotify_victims[kn_index] = strzone(victim); + for(sel_num = 0;(durcnt != "");) + { + selected = car(durcnt); durcnt = cdr(durcnt); + NOTIF_HIT_MAX(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic") + switch(strtolower(selected)) + { + #define ARG_CASE(prog,selected,result) \ + #if (prog == ARG_CS_SV_DC) || (prog == ARG_DC) \ + case selected: { arg_slot[sel_num] = result; ++sel_num; break; } \ + #endif + NOTIF_ARGUMENT_LIST + #undef ARG_CASE + default: + { + if(ftos(stof(selected)) != "") { arg_slot[sel_num] = selected; ++sel_num; } + else { NOTIF_HIT_UNKNOWN(NOTIF_MAX_DURCNT, "Local_Notification_centerprint_generic") } + break; + } + } } + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Local_Notification_centerprint_generic('%s^7', '%s', %d, %d, %d, %d);\n", + MakeConsoleSafe(input), + durcnt, + f1, f2, + stof(arg_slot[0]), + stof(arg_slot[1]) + )); + #endif + centerprint_generic(cpid, input, stof(arg_slot[0]), stof(arg_slot[1])); } +#endif -void Local_Notification(float net_type, float net_name, string s1, string s2, float f1, float f2, float f3) +void Local_Notification(float net_type, float net_name, ...count) { + // check supplied type and name for errors + string checkargs = Notification_CheckArgs_TypeName(net_type, net_name); + if(checkargs != "") { backtrace(sprintf("Incorrect usage of Local_Notification: %s\n", checkargs)); return; } + + entity notif = Get_Notif_Ent(net_type, net_name); + if not(notif) { backtrace("Local_Notification: Could not find notification entity!\n"); return; } + if not(notif.nent_enabled) + { + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Local_Notification(%s, %s): Entity was disabled...\n", + Get_Notif_TypeName(net_type), + notif.nent_name + )); + #endif + return; + } + + if((notif.nent_stringcount + notif.nent_floatcount) > count) + { + backtrace(sprintf( + strcat( + "Not enough arguments for Local_Notification(%s, %s, ...)! ", + "stringcount(%d) + floatcount(%d) > count(%d)\n", + "Check the definition and function call for accuracy...?\n" + ), + Get_Notif_TypeName(net_type), + notif.nent_name, + notif.nent_stringcount, + notif.nent_floatcount, + count + )); + return; + } + else if((notif.nent_stringcount + notif.nent_floatcount) < count) + { + backtrace(sprintf( + strcat( + "Too many arguments for Local_Notification(%s, %s, ...)! ", + "stringcount(%d) + floatcount(%d) < count(%d)\n", + "Check the definition and function call for accuracy...?\n" + ), + Get_Notif_TypeName(net_type), + notif.nent_name, + notif.nent_stringcount, + notif.nent_floatcount, + count + )); + return; + } + + string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : ""); + string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : ""); + string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : ""); + string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : ""); + float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0); + float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0); + float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0); + float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0); + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Local_Notification(%s, %s, %s, %s);\n", + Get_Notif_TypeName(net_type), + notif.nent_name, + MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)), + sprintf("%d, %d, %d, %d", f1, f2, f3, f4) + )); + #endif + switch(net_type) { + case MSG_ANNCE: + { + #ifdef CSQC + Local_Notification_sound( + notif.nent_channel, + notif.nent_snd, + notif.nent_vol, + notif.nent_position + ); + #else + backtrace("MSG_ANNCE on server?... Please notify Samual immediately!\n"); + #endif + break; + } + case MSG_INFO: { - #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) \ - { NOTIF_MATCH(name, net_name) CHECK_AUTOCVAR(name) \ - { \ - print(sprintf(CCR(normal_or_gentle(normal, gentle)), args)); \ - if(strtolower(icon) != "") { HUD_Notify_Push(icon, hudargs); } \ - } } - MSG_INFO_NOTIFICATIONS - #undef MSG_INFO_NOTIF + print( + Local_Notification_sprintf( + notif.nent_string, + notif.nent_args, + s1, s2, s3, s4, + f1, f2, f3, f4) + ); + #ifdef CSQC + if(notif.nent_icon != "") + { + Local_Notification_HUD_Notify_Push( + notif.nent_icon, + notif.nent_hudargs, + s1, s2, s3, s4); + } + #endif break; } + + #ifdef CSQC case MSG_CENTER: { - #define MSG_CENTER_NOTIF(name,strnum,flnum,args,cpid,durcnt,normal,gentle) \ - { NOTIF_MATCH(name, net_name) CHECK_AUTOCVAR(name) \ - { \ - centerprint_generic(HANDLE_CPID(cpid), sprintf(CCR(normal_or_gentle(normal, gentle)), args), durcnt); \ - } } - MSG_CENTER_NOTIFICATIONS - #undef MSG_CENTER_NOTIF + Local_Notification_centerprint_generic( + Local_Notification_sprintf( + notif.nent_string, + notif.nent_args, + s1, s2, s3, s4, + f1, f2, f3, f4), + notif.nent_durcnt, + notif.nent_cpid, + f1, f2); break; } - case MSG_WEAPON: + #endif + + case MSG_MULTI: { - #define MSG_WEAPON_NOTIF(name,strnum,flnum,args,normal,gentle) \ - { NOTIF_MATCH(name, net_name) CHECK_AUTOCVAR(name) \ - { \ - print("unhandled\n"); \ - } } - MSG_WEAPON_NOTIFICATIONS - #undef MSG_WEAPON_NOTIF + if(notif.nent_msginfo) + if(notif.nent_msginfo.nent_enabled) + { + Local_Notification_WOVA( + MSG_INFO, + notif.nent_msginfo.nent_id, + notif.nent_msginfo.nent_stringcount, + notif.nent_msginfo.nent_floatcount, + s1, s2, s3, s4, + f1, f2, f3, f4); + } + #ifdef CSQC + if(notif.nent_msgannce) + if(notif.nent_msgannce.nent_enabled) + { + Local_Notification_WOVA( + MSG_ANNCE, + notif.nent_msgannce.nent_id, + 0, 0, + "", "", "", "", + 0, 0, 0, 0); + } + if(notif.nent_msgcenter) + if(notif.nent_msgcenter.nent_enabled) + { + Local_Notification_WOVA( + MSG_CENTER, + notif.nent_msgcenter.nent_id, + notif.nent_msgcenter.nent_stringcount, + notif.nent_msgcenter.nent_floatcount, + s1, s2, s3, s4, + f1, f2, f3, f4); + } + #endif break; } - case MSG_DEATH: + + case MSG_CHOICE: { - #define MSG_DEATH_NOTIF(name,centername,infoname) \ - { NOTIF_MATCH(name, net_name) CHECK_AUTOCVAR(name) \ - { \ - #if centername != NO_MSG \ - Local_Notification(MSG_CENTER, centername, s1, s2, f1, f2, f3); \ - #endif \ - #if infoname != NO_MSG \ - Local_Notification(MSG_INFO, infoname, s1, s2, f1, f2, f3); \ - #endif \ - } } - MSG_DEATH_NOTIFICATIONS - #undef MSG_DEATH_NOTIF - break; + entity found_choice; + + if(notif.nent_challow_var && (warmup_stage || (notif.nent_challow_var == 2))) + { + switch(cvar_string(sprintf("notification_%s", notif.nent_name))) + { + case 1: found_choice = notif.nent_optiona; break; + case 2: found_choice = notif.nent_optionb; break; + default: return; // not enabled anyway + } + } + else { found_choice = notif.nent_optiona; } + + Local_Notification_WOVA( + found_choice.nent_type, + found_choice.nent_id, + found_choice.nent_stringcount, + found_choice.nent_floatcount, + s1, s2, s3, s4, + f1, f2, f3, f4); } } } -#endif + +// WOVA = Without Variable Arguments +void Local_Notification_WOVA( + float net_type, float net_name, + float stringcount, float floatcount, + string s1, string s2, string s3, string s4, + float f1, float f2, float f3, float f4) +{ + #define VARITEM(stringc,floatc,args) \ + if((stringcount == stringc) && (floatcount == floatc)) \ + { Local_Notification(net_type, net_name, args); return; } + EIGHT_VARS_TO_VARARGS_VARLIST + #undef VARITEM + Local_Notification(net_type, net_name); // some notifications don't have any arguments at all +} // ========================= @@ -584,164 +1547,480 @@ void Local_Notification(float net_type, float net_name, string s1, string s2, fl // ========================= #ifdef CSQC -void Read_Notification(void) +void Read_Notification(float is_new) { float net_type = ReadByte(); float net_name = ReadShort(); - float stringcount = stof(Get_Field_Value(F_STRNUM, net_type, net_name)); - float floatcount = stof(Get_Field_Value(F_FLNUM, net_type, net_name)); + entity notif; - print("stringcount = ", ftos(stringcount), ", floatcount = ", ftos(floatcount), ".\n"); + if(net_type == MSG_CENTER_CPID) + { + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Read_Notification(%d) at %f: net_type = %s, net_name = %d\n", + is_new, + time, + Get_Notif_TypeName(net_type), + net_name + )); + #endif + + if(is_new) + { + if(net_name == 0) { reset_centerprint_messages(); } + else if(net_name != NO_CPID) + { + // in this case, net_name IS the cpid we want to kill + centerprint_generic(net_name, "", 0, 0); + } + else + { + backtrace(sprintf( + "Read_Notification(%d) at %f: ^1TRIED TO KILL NO_CPID CENTERPRINT!\n", + is_new, + time + )); + } + } + } + else + { + notif = Get_Notif_Ent(net_type, net_name); + if not(notif) { backtrace("Read_Notification: Could not find notification entity!\n"); return; } + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Read_Notification(%d) at %f: net_type = %s, net_name = %s\n", + is_new, + time, + Get_Notif_TypeName(net_type), + notif.nent_name + )); + #endif + + string s1 = ((0 < notif.nent_stringcount) ? ReadString() : ""); + string s2 = ((1 < notif.nent_stringcount) ? ReadString() : ""); + string s3 = ((2 < notif.nent_stringcount) ? ReadString() : ""); + string s4 = ((3 < notif.nent_stringcount) ? ReadString() : ""); + float f1 = ((0 < notif.nent_floatcount) ? ReadLong() : 0); + float f2 = ((1 < notif.nent_floatcount) ? ReadLong() : 0); + float f3 = ((2 < notif.nent_floatcount) ? ReadLong() : 0); + float f4 = ((3 < notif.nent_floatcount) ? ReadLong() : 0); - Local_Notification(net_type, net_name, - ((stringcount >= 1) ? ReadString() : ""), - ((stringcount == 2) ? ReadString() : ""), - ((floatcount >= 1) ? ReadLong() : 0), - ((floatcount >= 2) ? ReadLong() : 0), - ((floatcount == 3) ? ReadLong() : 0)); + if(is_new) + { + Local_Notification_WOVA( + net_type, net_name, + notif.nent_stringcount, + notif.nent_floatcount, + s1, s2, s3, s4, + f1, f2, f3, f4); + } + } } #endif #ifdef SVQC -void Send_Notification(entity client, float broadcast, float net_type, float net_name, string s1, string s2, float f1, float f2, float f3) +void Net_Notification_Remove() +{ + if not(self) { backtrace(sprintf("Net_Notification_Remove() at %f: Missing self!?\n", time)); return; } + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Net_Notification_Remove() at %f: %s '%s - %s' notification\n", + time, + ((self.nent_net_name == -1) ? "Killed" : "Removed"), + Get_Notif_TypeName(self.nent_net_type), + self.owner.nent_name + )); + #endif + + float i; + for(i = 0; i < 4; ++i) { if(self.nent_strings[i]) { strunzone(self.nent_strings[i]); } } + remove(self); +} + +float Net_Write_Notification(entity client, float sf) { - if(net_type && net_name) + if(Notification_ShouldSend(self.nent_broadcast, client, self.nent_client)) { - //print("notification: ", Get_Field_Value(F_NAME, net_type, net_name), ": ", ftos(net_name), ".\n"); + float i; + WriteByte(MSG_ENTITY, ENT_CLIENT_NOTIFICATION); + WriteByte(MSG_ENTITY, self.nent_net_type); + WriteShort(MSG_ENTITY, self.nent_net_name); + for(i = 0; i < self.nent_stringcount; ++i) { WriteString(MSG_ENTITY, self.nent_strings[i]); } + for(i = 0; i < self.nent_floatcount; ++i) { WriteLong(MSG_ENTITY, self.nent_floats[i]); } + return TRUE; + } + else { return FALSE; } +} - float stringcount = stof(Get_Field_Value(F_STRNUM, net_type, net_name)); - float floatcount = stof(Get_Field_Value(F_FLNUM, net_type, net_name)); - - if(notif_stringcount(s1, s2) > stringcount) { backtrace("Too many string arguments for notification!\n"); return; } - if(notif_floatcount(f1, f2, f3) > floatcount) { backtrace("Too many float arguments for notification!\n"); return; } +void Kill_Notification( + float broadcast, entity client, + float net_type, float net_name) +{ + string checkargs = Notification_CheckArgs(broadcast, client, 1, 1); + if(checkargs != "") { backtrace(sprintf("Incorrect usage of Kill_Notification: %s\n", checkargs)); return; } + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Kill_Notification(%s, '%s', %s, %d);\n", + Get_Notif_BroadcastName(broadcast), + client.netname, + (net_type ? Get_Notif_TypeName(net_type) : "0"), + net_name + )); + #endif - if(broadcast == MSG_ONE) + entity notif, net_notif; + float killed_cpid = NO_CPID; + + switch(net_type) + { + case 0: { - if(client && (clienttype(client) == CLIENTTYPE_REAL) && (client.flags & FL_CLIENT)) - { - // personal/direct notification sent to ONE person and their spectators - msg_entity = client; - WRITESPECTATABLE_MSG_ONE({ - WriteByte(MSG_ONE, SVC_TEMPENTITY); - WriteByte(MSG_ONE, TE_CSQC_NOTIFICATION); - WriteByte(MSG_ONE, net_type); - WriteShort(MSG_ONE, net_name); - if(stringcount >= 1) { WriteString(MSG_ONE, s1); } - if(stringcount == 2) { WriteString(MSG_ONE, s2); } - if(floatcount >= 1) { WriteLong(MSG_ONE, f1); } - if(floatcount >= 2) { WriteLong(MSG_ONE, f2); } - if(floatcount == 3) { WriteLong(MSG_ONE, f3); } - }); - } + killed_cpid = 0; // kill ALL centerprints + break; } - else if(broadcast == MSG_ALL) + + case MSG_CENTER: { - // global notification sent to EVERYONE - WriteByte(MSG_ALL, SVC_TEMPENTITY); - WriteByte(MSG_ALL, TE_CSQC_NOTIFICATION); - WriteByte(MSG_ALL, net_type); - WriteShort(MSG_ALL, net_name); - if(stringcount >= 1) { WriteString(MSG_ALL, s1); } - if(stringcount == 2) { WriteString(MSG_ALL, s2); } - if(floatcount >= 1) { WriteLong(MSG_ALL, f1); } - if(floatcount >= 2) { WriteLong(MSG_ALL, f2); } - if(floatcount == 3) { WriteLong(MSG_ALL, f3); } + if(net_name) + { + entity notif = Get_Notif_Ent(net_type, net_name); + if not(notif) { backtrace("Kill_Notification: Could not find notification entity!\n"); return; } + + if(notif.nent_cpid) + killed_cpid = notif.nent_cpid; + else + killed_cpid = NO_CPID; + } + else + { + killed_cpid = 0; // kill ALL centerprints + } + break; } - else { backtrace("Unknown MSG_ type to write with!\n"); } - if(!server_is_local && (net_type == MSG_INFO)) + case MSG_CENTER_CPID: { - #define MSG_INFO_NOTIF(name,strnum,flnum,args,hudargs,icon,normal,gentle) \ - { NOTIF_MATCH(name, net_name) { print(sprintf(CCR(normal_or_gentle(normal, gentle)), args)); } } - MSG_INFO_NOTIFICATIONS - #undef MSG_INFO_NOTIF + killed_cpid = net_name; + break; } } - else { backtrace("Incorrect usage of Send_Notification!\n"); } -} -void Send_Notification_ToTeam(float targetteam, entity except, float net_type, float net_name, string s1, string s2, float f1, float f2, float f3) -{ - entity tmp_entity; - FOR_EACH_REALCLIENT(tmp_entity) + if(killed_cpid != NO_CPID) + { + net_notif = spawn(); + net_notif.classname = "net_kill_notification"; + net_notif.nent_broadcast = broadcast; + net_notif.nent_client = client; + net_notif.nent_net_type = MSG_CENTER_CPID; + net_notif.nent_net_name = killed_cpid; + Net_LinkEntity(net_notif, FALSE, autocvar_notification_lifetime_runtime, Net_Write_Notification); + } + + for(notif = world; (notif = find(notif, classname, "net_notification"));) { - if(tmp_entity.classname == STR_PLAYER) - if(tmp_entity.team == targetteam) - if(tmp_entity != except) + if(net_type) { - Send_Notification(tmp_entity, MSG_ONE, net_type, net_name, s1, s2, f1, f2, f3); + if((killed_cpid != NO_CPID) && (notif.nent_net_type == MSG_CENTER)) + { + if(notif.owner.nent_cpid == killed_cpid) + { + notif.nent_net_name = -1; + notif.nextthink = time; + } + else { continue; } // we ARE looking for a specific CPID, don't kill everything else too + } + else if(notif.nent_net_type == net_type) + { + if(net_name) + { + if(notif.nent_net_name == net_name) { notif.nent_net_name = -1; notif.nextthink = time; } + else { continue; } // we ARE looking for a certain net_name, don't kill everything else too + } + else { notif.nent_net_name = -1; notif.nextthink = time; } + } + else { continue; } // we ARE looking for a certain net_type, don't kill everything else too } + else { notif.nent_net_name = -1; notif.nextthink = time; } } } -// WARNING: use this ONLY if you need exceptions or want to exclude spectators, otherwise use Send_Notification(world, MSG_ALL, ...) -void Send_Notification_ToAll(entity except, float spectators, float net_type, float net_name, string s1, string s2, float f1, float f2, float f3) +void Send_Notification( + float broadcast, entity client, + float net_type, float net_name, + ...count) { - entity tmp_entity; - FOR_EACH_REALCLIENT(tmp_entity) + // check supplied broadcast, target, type, and name for errors + string checkargs = Notification_CheckArgs(broadcast, client, net_type, net_name); + if(checkargs != "") { - if((tmp_entity.classname == STR_PLAYER) || spectators) - if(tmp_entity != except) - { - Send_Notification(tmp_entity, MSG_ONE, net_type, net_name, s1, s2, f1, f2, f3); - } + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Send_Notification(%s, '%s', %s, %d, ...);\n", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + Get_Notif_Ent(net_type, net_name).nent_name + )); + #endif + backtrace(sprintf("Incorrect usage of Send_Notification: %s\n", checkargs)); + return; } -} + // retreive counts for the arguments of this notification + entity notif = Get_Notif_Ent(net_type, net_name); + if not(notif) + { + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Send_Notification(%s, '%s', %s, %d, ...);\n", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + net_name + )); + #endif + backtrace("Send_Notification: Could not find notification entity!\n"); + return; + } -// ============================= -// LEGACY NOTIFICATION SYSTEMS -// ============================= + string s1 = ((0 < notif.nent_stringcount) ? ...(0, string) : ""); + string s2 = ((1 < notif.nent_stringcount) ? ...(1, string) : ""); + string s3 = ((2 < notif.nent_stringcount) ? ...(2, string) : ""); + string s4 = ((3 < notif.nent_stringcount) ? ...(3, string) : ""); + float f1 = ((0 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 0), float) : 0); + float f2 = ((1 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 1), float) : 0); + float f3 = ((2 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 2), float) : 0); + float f4 = ((3 < notif.nent_floatcount) ? ...((notif.nent_stringcount + 3), float) : 0); + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Send_Notification(%s, %s, %s);\n", + sprintf( + "%s, '%s', %s, %s", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + notif.nent_name + ), + MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)), + sprintf("%d, %d, %d, %d", f1, f2, f3, f4) + )); + #endif -void Send_KillNotification(string s1, string s2, string s3, float msg, float type) -{ - WriteByte(MSG_ALL, SVC_TEMPENTITY); - WriteByte(MSG_ALL, TE_CSQC_KILLNOTIFY); - WriteString(MSG_ALL, s1); - WriteString(MSG_ALL, s2); - WriteString(MSG_ALL, s3); - WriteShort(MSG_ALL, msg); - WriteByte(MSG_ALL, type); -} + if((notif.nent_stringcount + notif.nent_floatcount) > count) + { + backtrace(sprintf( + strcat( + "Not enough arguments for Send_Notification(%s, ...)! ", + "stringcount(%d) + floatcount(%d) > count(%d)\n", + "Check the definition and function call for accuracy...?\n" + ), + sprintf( + "%s, '%s', %s, %s", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + notif.nent_name + ), + notif.nent_stringcount, + notif.nent_floatcount, + count + )); + return; + } + else if((notif.nent_stringcount + notif.nent_floatcount) < count) + { + backtrace(sprintf( + strcat( + "Too many arguments for Send_Notification(%s, ...)! ", + "stringcount(%d) + floatcount(%d) < count(%d)\n", + "Check the definition and function call for accuracy...?\n" + ), + sprintf( + "%s, '%s', %s, %s", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + notif.nent_name + ), + notif.nent_stringcount, + notif.nent_floatcount, + count + )); + return; + } -// Function is used to send a generic centerprint whose content CSQC gets to decide (gentle version or not in the below cases) -void Send_CSQC_KillCenterprint(entity e, string s1, string s2, float msg, float type) -{ - if (clienttype(e) == CLIENTTYPE_REAL) - { - msg_entity = e; - WRITESPECTATABLE_MSG_ONE({ - WriteByte(MSG_ONE, SVC_TEMPENTITY); - WriteByte(MSG_ONE, TE_CSQC_KILLCENTERPRINT); - WriteString(MSG_ONE, s1); - WriteString(MSG_ONE, s2); - WriteShort(MSG_ONE, msg); - WriteByte(MSG_ONE, type); - }); + if( + server_is_dedicated + && + ( + broadcast == NOTIF_ALL + || + broadcast == NOTIF_ALL_EXCEPT + ) + && + !( + net_type == MSG_ANNCE + || + net_type == MSG_CENTER + ) + ) + { + Local_Notification_WOVA( + net_type, net_name, + notif.nent_stringcount, + notif.nent_floatcount, + s1, s2, s3, s4, + f1, f2, f3, f4); } -} -void Send_CSQC_Centerprint_Generic(entity e, float id, string s, float duration, float countdown_num) -{ - if ((clienttype(e) == CLIENTTYPE_REAL) && (e.flags & FL_CLIENT)) - { - msg_entity = e; - WRITESPECTATABLE_MSG_ONE({ - WriteByte(MSG_ONE, SVC_TEMPENTITY); - WriteByte(MSG_ONE, TE_CSQC_CENTERPRINT_GENERIC); - WriteByte(MSG_ONE, id); - WriteString(MSG_ONE, s); - if (id != 0 && s != "") + if(net_type == MSG_CHOICE) + { + // THIS GETS TRICKY... now we have to cycle through each possible player (checking broadcast) + // and then do an individual NOTIF_ONE_ONLY recursive call for each one depending on their option... + // It's slow, but it's better than the alternatives: + // 1. Constantly networking all info and letting client decide + // 2. Manually handling each separate call on per-usage basis (See old CTF usage of verbose) + entity found_choice; + + #define RECURSE_FROM_CHOICE(ent,action) \ + if(notif.nent_challow_var && (warmup_stage || (notif.nent_challow_var == 2))) \ + { \ + switch(ent.msg_choice_choices[net_name]) \ + { \ + case 1: found_choice = notif.nent_optiona; break; \ + case 2: found_choice = notif.nent_optionb; break; \ + default: action; \ + } \ + } \ + else { found_choice = notif.nent_optiona; } \ + Send_Notification_WOVA( \ + NOTIF_ONE_ONLY, \ + ent, \ + found_choice.nent_type, \ + found_choice.nent_id, \ + found_choice.nent_stringcount, \ + found_choice.nent_floatcount, \ + s1, s2, s3, s4, \ + f1, f2, f3, f4); + + switch(broadcast) + { + case NOTIF_ONE_ONLY: // we can potentially save processing power with this broadcast method + { + if(IS_REAL_CLIENT(client)) + { RECURSE_FROM_CHOICE(client, return) } + break; + } + default: { - WriteByte(MSG_ONE, duration); - WriteByte(MSG_ONE, countdown_num); + entity to; + FOR_EACH_REALCLIENT(to) + { if(Notification_ShouldSend(broadcast, to, client)) + { RECURSE_FROM_CHOICE(to, continue) } } + break; } - }); + } + } + else + { + entity net_notif = spawn(); + net_notif.owner = notif; + net_notif.classname = "net_notification"; + net_notif.nent_broadcast = broadcast; + net_notif.nent_client = client; + net_notif.nent_net_type = net_type; + net_notif.nent_net_name = net_name; + net_notif.nent_stringcount = notif.nent_stringcount; + net_notif.nent_floatcount = notif.nent_floatcount; + + float i; + for(i = 0; i < net_notif.nent_stringcount; ++i) + { net_notif.nent_strings[i] = strzone(...(i, string)); } + for(i = 0; i < net_notif.nent_floatcount; ++i) + { net_notif.nent_floats[i] = ...((net_notif.nent_stringcount + i), float); } + + net_notif.think = Net_Notification_Remove; + net_notif.nextthink = + ((time > autocvar_notification_lifetime_mapload) + ? + (time + autocvar_notification_lifetime_runtime) + : + autocvar_notification_lifetime_mapload + ); + + Net_LinkEntity(net_notif, FALSE, 0, Net_Write_Notification); } } -void Send_CSQC_Centerprint_Generic_Expire(entity e, float id) + +// WOVA = Without Variable Arguments +void Send_Notification_WOVA( + float broadcast, entity client, + float net_type, float net_name, + float stringcount, float floatcount, + string s1, string s2, string s3, string s4, + float f1, float f2, float f3, float f4) { - Send_CSQC_Centerprint_Generic(e, id, "", 1, 0); + #ifdef NOTIFICATIONS_DEBUG + entity notif = Get_Notif_Ent(net_type, net_name); + Debug_Notification(sprintf( + "Send_Notification_WOVA(%s, %d, %d, %s, %s);\n", + sprintf( + "%s, '%s', %s, %s", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + notif.nent_name + ), + stringcount, + floatcount, + MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)), + sprintf("%d, %d, %d, %d", f1, f2, f3, f4) + )); + #endif + + #define VARITEM(stringc,floatc,args) \ + if((stringcount == stringc) && (floatcount == floatc)) \ + { Send_Notification(broadcast, client, net_type, net_name, args); return; } + EIGHT_VARS_TO_VARARGS_VARLIST + #undef VARITEM + Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all } -#endif + +// WOCOVA = Without Counts Or Variable Arguments +void Send_Notification_WOCOVA( + float broadcast, entity client, + float net_type, float net_name, + string s1, string s2, string s3, string s4, + float f1, float f2, float f3, float f4) +{ + entity notif = Get_Notif_Ent(net_type, net_name); + + #ifdef NOTIFICATIONS_DEBUG + Debug_Notification(sprintf( + "Send_Notification_WOCOVA(%s, %s, %s);\n", + sprintf( + "%s, '%s', %s, %s", + Get_Notif_BroadcastName(broadcast), + client.classname, + Get_Notif_TypeName(net_type), + notif.nent_name + ), + MakeConsoleSafe(sprintf("'%s^7', '%s^7', '%s^7', '%s^7'", s1, s2, s3, s4)), + sprintf("%d, %d, %d, %d", f1, f2, f3, f4) + )); + #endif + + #define VARITEM(stringc,floatc,args) \ + if((notif.nent_stringcount == stringc) && (notif.nent_floatcount == floatc)) \ + { Send_Notification(broadcast, client, net_type, net_name, args); return; } + EIGHT_VARS_TO_VARARGS_VARLIST + #undef VARITEM + Send_Notification(broadcast, client, net_type, net_name); // some notifications don't have any arguments at all +} +#endif // ifdef SVQC