X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=qcsrc%2Fcommon%2Fnotifications.qc;h=c2420d4435ba7bdc7ca4647edcbfb015164ba9eb;hb=def24368510d38164b0f6756a1cd5e3bb82f67a8;hp=d1dba4f3e02634583f288bfa806907c544e13bdb;hpb=e6bc209c0d1918c8f36ffa4c09daf4d969fa2b06;p=xonotic%2Fxonotic-data.pk3dir.git

diff --git a/qcsrc/common/notifications.qc b/qcsrc/common/notifications.qc
index d1dba4f3e..c2420d443 100644
--- a/qcsrc/common/notifications.qc
+++ b/qcsrc/common/notifications.qc
@@ -1,6 +1,6 @@
 // ================================================
 //  Unified notification system, written by Samual
-//  Last updated: June, 2013
+//  Last updated: August, 2013
 // ================================================
 
 string Get_Notif_TypeName(float net_type)
@@ -32,6 +32,25 @@ entity Get_Notif_Ent(float net_type, float net_name)
 	return world;
 }
 
+#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
+
 string Notification_CheckArgs_TypeName(float net_type, float net_name)
 {
 	// check supplied type and name for errors
@@ -85,14 +104,19 @@ string Notification_CheckArgs(
 		}
 		
 		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); }
+			if not(teamplay)
+				{ checkargs = sprintf("%sTeamplay not active!", checkargs); }
 			else if(IS_NOT_A_CLIENT(client))
-			{
-				if(broadcast == NOTIF_TEAM) { checkargs = sprintf("%sNo client provided!", checkargs); }
-				else { checkargs = sprintf("%sException can't be a non-client!", checkargs); }
-			}
+				{ checkargs = sprintf("%sException can't be a non-client!", checkargs); }
 			break;
 		}
 		
@@ -160,7 +184,6 @@ float Notification_ShouldSend(float broadcast, entity to_client, entity other_cl
 		case NOTIF_ALL: // send to everyone
 		{
 			return TRUE;
-			break;
 		}
 		case NOTIF_ALL_EXCEPT: // send to everyone except X person and their spectators
 		{
@@ -175,8 +198,8 @@ float Notification_ShouldSend(float broadcast, entity to_client, entity other_cl
 			) { return TRUE; }
 			break;
 		}
-		default: { return FALSE; }
 	}
+	return FALSE;
 }
 
 #endif
@@ -430,15 +453,14 @@ void Create_Notification_Entity(
 	float typeid,
 	float nameid,
 	string namestring,
-	float anncename,
-	float infoname,
-	float centername,
-	float channel,
+	float strnum,
+	float flnum,
+	/* MSG_ANNCE */
+	float channel, 
 	string snd,
 	float vol,
 	float position,
-	float strnum,
-	float flnum,
+	/* MSG_INFO & MSG_CENTER */
 	string args,
 	string hudargs,
 	string icon,
@@ -446,6 +468,13 @@ void Create_Notification_Entity(
 	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)
@@ -454,40 +483,34 @@ void Create_Notification_Entity(
 	//  Global Entity Setup
 	// =====================
 	entity notif = spawn();
-	string typestring = "";
 	switch(typeid)
 	{
 		case MSG_ANNCE:
 		{
-			typestring = "MSG_ANNCE";
 			msg_annce_notifs[nameid - 1] = notif;
 			notif.classname = "msg_annce_notification";
 			break;
 		}
 		case MSG_INFO:
 		{
-			typestring = "MSG_INFO";
 			msg_info_notifs[nameid - 1] = notif;
 			notif.classname = "msg_info_notification";
 			break;
 		}
 		case MSG_CENTER:
 		{
-			typestring = "MSG_CENTER";
 			msg_center_notifs[nameid - 1] = notif;
 			notif.classname = "msg_center_notification";
 			break;
 		}
 		case MSG_MULTI:
 		{
-			typestring = "MSG_MULTI";
 			msg_multi_notifs[nameid - 1] = notif;
 			notif.classname = "msg_multi_notification";
 			break;
 		}
 		case MSG_CHOICE:
 		{
-			typestring = "MSG_CHOICE";
 			msg_choice_notifs[nameid - 1] = notif;
 			notif.classname = "msg_choice_notification";
 			break;
@@ -507,9 +530,12 @@ void Create_Notification_Entity(
 		}
 	}
 	notif.nent_default = var_default;
-	notif.nent_name = strzone(namestring);
-	notif.nent_id = nameid;
 	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;
@@ -755,10 +781,109 @@ void Create_Notification_Entity(
 
 		case MSG_CHOICE:
 		{
+			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:
+					{
+						print(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;
+		default:
+		{
+			print(sprintf(
+				strcat(
+					"^1NOTIFICATION WITH IMPROPER TYPE: ",
+					"^7net_type = %d, net_name = %s.\n"
+				),
+				typeid,
+				namestring
+			));
+			notif_error = TRUE;
+			break;
+		}
 	}
 
 	// now check to see if any errors happened 
@@ -770,10 +895,28 @@ void Create_Notification_Entity(
 }
 
 
-// =========================================
-//  Cvar Handling With 'dumpnotifs' Command
-// =========================================
+// ===============
+//  Cvar Handling
+// ===============
 
+// used by MSG_CHOICE to build list of choices
+#ifdef SVQC
+void Notification_GetCvars(void)
+{
+	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)
+		);
+	}
+}
+#endif
+
+// used to output notifications.cfg file
 void Dump_Notifications(float fh, float alsoprint)
 {
 	#define NOTIF_WRITE(a) { \
@@ -786,6 +929,15 @@ void Dump_Notifications(float fh, float alsoprint)
 				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( \
@@ -872,8 +1024,9 @@ void Dump_Notifications(float fh, float alsoprint)
 		e = Get_Notif_Ent(MSG_CHOICE, i);
 		if not(e) { backtrace("Dump_Notifications(): Missing notification entity!\n"); return; }
 		
-		NOTIF_WRITE_ENTITY(
-			"Notification control cvar: 0 = off, 1 = trigger option A subcall, 2 = trigger option B subcall"
+		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"
 		);
 	}
 
@@ -886,21 +1039,6 @@ void Dump_Notifications(float fh, float alsoprint)
 		"(You can also set this cvar to 2 to force ALL notifications to be printed to the chatbox)"
 	);
 	
-	NOTIF_WRITE_HARDCODED(
-		"ctf_capture_verbose", "0",
-		"Show extra information when someone captures a flag"
-	);
-	
-	NOTIF_WRITE_HARDCODED(
-		"ctf_pickup_enemy_verbose", "0",
-		"Show extra information if an enemy picks up a flag"
-	);
-	
-	NOTIF_WRITE_HARDCODED(
-		"ctf_pickup_team_verbose", "0",
-		"Show extra information if a team mate picks up a flag"
-	);
-	
 	NOTIF_WRITE_HARDCODED(
 		"debug", "0",
 		"Print extra debug information on all notification function calls "
@@ -913,11 +1051,6 @@ void Dump_Notifications(float fh, float alsoprint)
 		"If a notification fails upon initialization, cause a Host_Error to stop the program"
 	);
 	
-	NOTIF_WRITE_HARDCODED(
-		"frag_verbose", "1",
-		"Show extra information when you frag someone (or when you are fragged"
-	);
-	
 	NOTIF_WRITE_HARDCODED(
 		"item_centerprinttime", "1.5",
 		"How long to show item information centerprint messages (like 'You got the Electro' or such)"
@@ -934,12 +1067,6 @@ void Dump_Notifications(float fh, float alsoprint)
 		"Amount of time that notification entities last on the server during runtime (In seconds)"
 	);
 	
-	NOTIF_WRITE_HARDCODED(
-		"server_allows_frag_verbose", "1",
-		"Server side cvar for showing extra information in frag messages... 0 = no extra frag information, "
-		"1 = frag information only in warmup, 2 = frag information allowed all the time"
-	);
-	
 	NOTIF_WRITE_HARDCODED(
 		"server_allows_location", "1",
 		"Server side cvar for allowing death messages to show location information too"
@@ -1013,13 +1140,6 @@ void Dump_Notifications(float fh, float alsoprint)
 	#undef NOTIF_WRITE
 }
 
-#ifdef SVQC
-void Notification_GetCvars()
-{
-	GetCvars_handleFloat(get_cvars_s, get_cvars_f, FRAG_VERBOSE, "notification_frag_verbose");
-}
-#endif
-
 
 // ===============================
 //  Frontend Notification Pushing
@@ -1078,7 +1198,16 @@ string Local_Notification_sprintf(
 			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]);
+	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
@@ -1211,7 +1340,8 @@ void Local_Notification_centerprint_generic(
 		MakeConsoleSafe(input),
 		durcnt,
 		f1, f2,
-		stof(arg_slot[0]), stof(arg_slot[1])
+		stof(arg_slot[0]),
+		stof(arg_slot[1])
 	));
 	#endif
 	centerprint_generic(cpid, input, stof(arg_slot[0]), stof(arg_slot[1]));
@@ -1220,48 +1350,59 @@ void Local_Notification_centerprint_generic(
 
 void Local_Notification(float net_type, float net_name, ...count)
 {
+	// check if this should be aborted
+	if(net_name == NOTIF_ABORT)
+	{
+		#ifdef NOTIFICATIONS_DEBUG
+		Debug_Notification(sprintf(
+			"Local_Notification(%s, %s, ...);\n",
+			Get_Notif_TypeName(net_type),
+			"NOTIF_ABORT"
+		));
+		#endif
+		return;
+	}
+	
 	// 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)
+	if(checkargs != "")
 	{
 		#ifdef NOTIFICATIONS_DEBUG
 		Debug_Notification(sprintf(
-			"Local_Notification(%s, %s): Entity was disabled...\n",
+			"Local_Notification(%s, %d, ...);\n",
 			Get_Notif_TypeName(net_type),
-			notif.nent_name
+			Get_Notif_Ent(net_type, net_name).nent_name
 		));
 		#endif
+		backtrace(sprintf("Incorrect usage of Local_Notification: %s\n", checkargs));
 		return;
 	}
-	
-	if((notif.nent_stringcount + notif.nent_floatcount) > count)
+
+	// retreive entity of this notification
+	entity notif = Get_Notif_Ent(net_type, net_name);
+	if not(notif)
 	{
-		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
+		#ifdef NOTIFICATIONS_DEBUG
+		Debug_Notification(sprintf(
+			"Local_Notification(%s, %d, ...);\n",
+			Get_Notif_TypeName(net_type),
+			net_name
 		));
+		#endif
+		backtrace("Local_Notification: Could not find notification entity!\n");
 		return;
 	}
-	else if((notif.nent_stringcount + notif.nent_floatcount) < count)
+
+	// check if the notification is enabled
+	if not(notif.nent_enabled)
 	{
-		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
+		#ifdef NOTIFICATIONS_DEBUG
+		Debug_Notification(sprintf(
+			"Local_Notification(%s, %s, ...): Entity was disabled...\n",
+			Get_Notif_TypeName(net_type),
+			notif.nent_name
 		));
+		#endif
 		return;
 	}
 
@@ -1284,6 +1425,39 @@ void Local_Notification(float net_type, float net_name, ...count)
 	));
 	#endif
 	
+	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;
+	}
+	
 	switch(net_type)
 	{
 		case MSG_ANNCE:
@@ -1376,6 +1550,30 @@ void Local_Notification(float net_type, float net_name, ...count)
 			#endif
 			break;
 		}
+
+		case MSG_CHOICE:
+		{
+			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); 
+		}
 	}
 }
 
@@ -1513,18 +1711,18 @@ 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(%d, '%s', %s, %d);\n",
-		broadcast,
+		"Kill_Notification(%s, '%s', %s, %d);\n",
+		Get_Notif_BroadcastName(broadcast),
 		client.netname,
 		(net_type ? Get_Notif_TypeName(net_type) : "0"),
 		net_name
 	));
 	#endif
+	
+	string checkargs = Notification_CheckArgs(broadcast, client, 1, 1);
+	if(checkargs != "") { backtrace(sprintf("Incorrect usage of Kill_Notification: %s\n", checkargs)); return; }
 
 	entity notif, net_notif;
 	float killed_cpid = NO_CPID;
@@ -1607,38 +1805,52 @@ void Send_Notification(
 	float net_type, float net_name,
 	...count)
 {
+	// check if this should be aborted
+	if(net_name == NOTIF_ABORT)
+	{
+		#ifdef NOTIFICATIONS_DEBUG
+		Debug_Notification(sprintf(
+			"Send_Notification(%s, '%s', %s, %s, ...);\n",
+			Get_Notif_BroadcastName(broadcast),
+			client.classname,
+			Get_Notif_TypeName(net_type),
+			"NOTIF_ABORT"
+		));
+		#endif
+		return;
+	}
+	
 	// check supplied broadcast, target, type, and name for errors
 	string checkargs = Notification_CheckArgs(broadcast, client, net_type, net_name);
-	if(checkargs != "") { 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) { backtrace("Send_Notification: Could not find notification entity!\n"); return; }
-
-	if((notif.nent_stringcount + notif.nent_floatcount) > count)
+	if(checkargs != "")
 	{
-		backtrace(sprintf(
-			strcat(
-				"Not enough arguments for Send_Notification(%d, %s, %s, ...)! ",
-				"stringcount(%d) + floatcount(%d) > count(%d)\n", 
-				"Check the definition and function call for accuracy...?\n"
-			),
-			broadcast, Get_Notif_TypeName(net_type), notif.nent_name,
-			notif.nent_stringcount, notif.nent_floatcount, count
+		#ifdef NOTIFICATIONS_DEBUG
+		Debug_Notification(sprintf(
+			"Send_Notification(%s, '%s', %s, %s, ...);\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;
 	}
-	else if((notif.nent_stringcount + notif.nent_floatcount) < count)
+
+	// retreive entity of this notification
+	entity notif = Get_Notif_Ent(net_type, net_name);
+	if not(notif)
 	{
-		backtrace(sprintf(
-			strcat(
-				"Too many arguments for Send_Notification(%d, %s, %s, ...)! ",
-				"stringcount(%d) + floatcount(%d) < count(%d)\n",
-				"Check the definition and function call for accuracy...?\n"
-			),
-			broadcast, Get_Notif_TypeName(net_type), notif.nent_name,
-			notif.nent_stringcount, notif.nent_floatcount, count
+		#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;
 	}
 
@@ -1653,15 +1865,72 @@ void Send_Notification(
 
 	#ifdef NOTIFICATIONS_DEBUG
 	Debug_Notification(sprintf(
-		"Send_Notification(%d, %s, %s, %s, %s);\n",
-		broadcast,
-		Get_Notif_TypeName(net_type),
-		notif.nent_name,
+		"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
 
+	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(
+				#ifdef NOTIFICATIONS_DEBUG
+				"%s, '%s', %s, %s",
+				Get_Notif_BroadcastName(broadcast),
+				#else
+				"%d, '%s', %s, %s",
+				broadcast,
+				#endif
+				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(
+				#ifdef NOTIFICATIONS_DEBUG
+				"%s, '%s', %s, %s",
+				Get_Notif_BroadcastName(broadcast),
+				#else
+				"%d, '%s', %s, %s",
+				broadcast,
+				#endif
+				client.classname,
+				Get_Notif_TypeName(net_type),
+				notif.nent_name
+			),
+			notif.nent_stringcount,
+			notif.nent_floatcount,
+			count
+		));
+		return;
+	}
+
 	if(
 		server_is_dedicated
 		&&
@@ -1690,54 +1959,46 @@ void Send_Notification(
 	{
 		// 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
+		// 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))
-				{
-					switch(client.msg_choice_choices[net_name])
-					{
-						case 1: found_choice = notif.nent_choicea;
-						case 2: found_choice = notif.nent_choiceb;
-						default: return; // nothing to do here, client disables this
-					}
-					Send_Notification_WOVA(
-						NOTIF_ONE_ONLY,
-						client,
-						found_choice.nent_net_type,
-						found_choice.nent_net_name,
-						s1, s2, s3, s4,
-						f1, f2, f3, f4);
-				}
+					{ RECURSE_FROM_CHOICE(client, return) }
 				break;
 			}
-			
 			default:
 			{
 				entity to;
 				FOR_EACH_REALCLIENT(to)
-				{
-					if(Notification_ShouldSend(broadcast, to, client))
-					{
-						switch(client.msg_choice_choices[net_name])
-						{
-							case 1: found_choice = notif.nent_choicea;
-							case 2: found_choice = notif.nent_choiceb;
-							default: continue; // nothing to do here, client disables this
-						}
-						Send_Notification_WOVA(
-							NOTIF_ONE_ONLY,
-							to,
-							found_choice.nent_net_type,
-							found_choice.nent_net_name,
-							s1, s2, s3, s4,
-							f1, f2, f3, f4);
-					}
-				}
+					{ if(Notification_ShouldSend(broadcast, to, client))
+						{ RECURSE_FROM_CHOICE(to, continue) } }
 				break;
 			}
 		}
@@ -1775,6 +2036,40 @@ void Send_Notification(
 
 // 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)
+{
+	#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
+}
+
+// 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,
@@ -1784,10 +2079,14 @@ void Send_Notification_WOVA(
 	
 	#ifdef NOTIFICATIONS_DEBUG
 	Debug_Notification(sprintf(
-		"Send_Notification_WOVA(%d, %s, %s, %s, %s);\n",
-		broadcast,
-		Get_Notif_TypeName(net_type),
-		notif.nent_name,
+		"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)
 	));