View difference between Paste ID: CSiX3tNh and zaes8j7R

 #include <sourcemod>
 #include <sdktools>
 #include <chat-processor>
 #include <colorvariables>
 
 #pragma semicolon 1
 #pragma newdecls required
 
-#define PLUGIN_VERSION		"1.11almostreadyforrelease"
+#define PLUGIN_VERSION		"1.0.1"
 
 public Plugin myinfo = {
-	name		= "[Source 2013] Chat-Processor Module: Chat Tags",
+	name        = "[Source 2013] Chat-Processor Module: Chat Tags",
-	author	  = "404 (abrandnewday)",
+	author      = "404 (abrandnewday)",
 	description = "Processes chat and provides colors and tags for Source 2013 games",
-	version	 = PLUGIN_VERSION,
+	version     = PLUGIN_VERSION,
-	url		 = "http://www.unfgaming.net"
+	url         = "http://www.unfgaming.net"
 };
 
 #define MAXLENGTH_NAME_NEW 256
 
 Handle hColorForward;
 Handle hNameForward;
 Handle hTagForward;
 Handle hApplicationForward;
 Handle hMessageForward;
 Handle hPreLoadedForward;
 Handle hLoadedForward;
-#define MAXLENGTH_256 256
+
-#define MAXLENGTH_32 32
+
 char g_strTag[MAXPLAYERS + 1][32];
-char g_strTag[MAXPLAYERS + 1][MAXLENGTH_256];
+char g_strTagColor[MAXPLAYERS + 1][32];
-char g_strTagColor[MAXPLAYERS + 1][MAXLENGTH_32];
+char g_strUsernameColor[MAXPLAYERS + 1][12];
-char g_strUsernameColor[MAXPLAYERS + 1][MAXLENGTH_32];
+char g_strChatColor[MAXPLAYERS + 1][12];
-char g_strTextColor[MAXPLAYERS + 1][MAXLENGTH_32];
+
 char g_strDefaultTag[MAXPLAYERS + 1][32];
-char g_strDefaultTag[MAXPLAYERS + 1][MAXLENGTH_256];
+char g_strDefaultTagColor[MAXPLAYERS + 1][32];
-char g_strDefaultTagColor[MAXPLAYERS + 1][MAXLENGTH_32];
+char g_strDefaultUsernameColor[MAXPLAYERS + 1][12];
-char g_strDefaultUsernameColor[MAXPLAYERS + 1][MAXLENGTH_32];
+char g_strDefaultChatColor[MAXPLAYERS + 1][12];
-char g_strDefaultTextColor[MAXPLAYERS + 1][MAXLENGTH_32];
+
 KeyValues kvConfigFile = null;
 
 enum CPT_ColorType {
 	CPT_TagColor,
 	CPT_NameColor,
 	CPT_ChatColor
-	CPT_TextColor
+
 
 #define COLOR_NONE		-1
 #define COLOR_GREEN		-2
 #define COLOR_OLIVE		-3
 #define COLOR_TEAM		-4
 
 #define UPDATE_FILE		"chatcolors.txt"
 
 
 public APLRes AskPluginLoad2(Handle hMyself, bool bLate, char[] strError, int iErrMax)
 {
 	CreateNative("CPT_GetColor", Native_GetColor);
 	CreateNative("CPT_SetColor", Native_SetColor);
 	CreateNative("CPT_GetTag", Native_GetTag);
 	CreateNative("CPT_SetTag", Native_SetTag);
 	CreateNative("CPT_ResetColor", Native_ResetColor);
 	CreateNative("CPT_ResetTag", Native_ResetTag);
 
 	RegPluginLibrary("cpt");
 
 	return APLRes_Success;
 }
 
-	RegAdminCmd("sm_printenginecodes", Command_PrintEngineCodes, ADMFLAG_ROOT, "Prints all available engine codes");
+
 {
 	RegAdminCmd("sm_reloadtags", Command_ReloadConfig, ADMFLAG_CONFIG, "Reloads Custom Chat Colors config file");
 	hColorForward = CreateGlobalForward("CPT_OnChatColor", ET_Event, Param_Cell);
 	hNameForward = CreateGlobalForward("CPT_OnNameColor", ET_Event, Param_Cell);
 	hTagForward = CreateGlobalForward("CPT_OnTagApplied", ET_Event, Param_Cell);
 	hApplicationForward = CreateGlobalForward("CPT_OnColor", ET_Event, Param_Cell, Param_String, Param_Cell);
 	hMessageForward = CreateGlobalForward("CPT_OnChatMessage", ET_Ignore, Param_Cell, Param_String, Param_Cell);
 	hPreLoadedForward = CreateGlobalForward("CPT_OnUserConfigPreLoaded", ET_Event, Param_Cell);
 	hLoadedForward = CreateGlobalForward("CPT_OnUserConfigLoaded", ET_Ignore, Param_Cell);
 	hConfigReloadedForward = CreateGlobalForward("CPT_OnConfigReloaded", ET_Ignore);
 	LoadConfig();
 }
 
 void LoadConfig()
 {
 	if(kvConfigFile != null)
 	{
 		delete kvConfigFile;
 	}
 	kvConfigFile = new KeyValues("chat_processor_tags");
 	char strPath[64];
 	BuildPath(Path_SM, strPath, sizeof(strPath), "configs/chat-processor-tags.cfg");
 	if(!kvConfigFile.ImportFromFile(strPath))
 	{
 		SetFailState("Config file missing");
 	}
 	for(int i = 1; i <= MaxClients; i++)
 	{
 		if(!IsClientInGame(i) || IsFakeClient(i))
 		{
 			continue;
 		}
 		ClearValues(i);
 		OnClientPostAdminCheck(i);
 	}
 }
 
 public Action Command_ReloadConfig(int iClient, int iArgs)
 {
 	LoadConfig();
 	LogAction(iClient, -1, "Reloaded Chat-Processor Tags config file");
 	ReplyToCommand(iClient, "[CPT] Reloaded config file.");
 	Call_StartForward(hConfigReloadedForward);
 	Call_Finish();
 	return Plugin_Handled;
 }
-public Action Command_PrintEngineCodes(int iClient, int iArgs)
+
 stock void ClearValues(int iClient)
-	CPrintToChat(iClient, "\x01Test of x01");
+
-	CPrintToChat(iClient, "\x02Test of x02");
+
-	CPrintToChat(iClient, "\x03Test of x03");
+
-	CPrintToChat(iClient, "\x04Test of x04");
+
-	CPrintToChat(iClient, "\x05Test of x05");
+	Format(g_strChatColor[iClient], sizeof(g_strChatColor[]), "");
-	CPrintToChat(iClient, "\x06Test of x06");
+
-	CPrintToChat(iClient, "\x07Test of x07");
+
-	CPrintToChat(iClient, "\x08Test of x08");
+
-	CPrintToChat(iClient, "\x09Test of x09");
+
-	CPrintToChat(iClient, "\x0ATest of x0A");
+	Format(g_strDefaultChatColor[iClient], sizeof(g_strDefaultChatColor[]), "");
-	CPrintToChat(iClient, "\x0BTest of x0B");
+
-	CPrintToChat(iClient, "\x0CTest of x0C");
+
-	CPrintToChat(iClient, "\x0DTest of x0D");
+
-	CPrintToChat(iClient, "\x0ETest of x0E");
+
-	CPrintToChat(iClient, "\x0FTest of x0F");
+
-	CPrintToChat(iClient, "\x10Test of x10");
+
 
 public void OnClientDisconnect(int iClient)
 {
 	ClearValues(iClient); // On connect and on disconnect, just to be safe
 }
 
 public void OnClientPostAdminCheck(int iClient)
 {
-	Format(g_strTextColor[iClient], sizeof(g_strTextColor[]), "");
+
 	{
 		return; // Another plugin wants to block this
 	}
 
-	Format(g_strDefaultTextColor[iClient], sizeof(g_strDefaultTextColor[]), "");
+
 	char strAuthId2[32];
 	GetClientAuthId(iClient, AuthId_Steam2, strAuthId2, sizeof(strAuthId2));
 	kvConfigFile.Rewind();
 	if(!kvConfigFile.JumpToKey(strAuthId2))
 	{
 		kvConfigFile.Rewind();
 		kvConfigFile.GotoFirstSubKey();
 		AdminId iAdmin = GetUserAdmin(iClient);
 		AdminFlag fFlag;
 		char strConfigFlag[2];
 		char strSection[32];
 		bool bFound = false;
 		do
 		{
 			kvConfigFile.GetSectionName(strSection, sizeof(strSection));
 			kvConfigFile.GetString("flag", strConfigFlag, sizeof(strConfigFlag));
 			if(strlen(strConfigFlag) > 1)
 			{
 				LogError("Multiple flags given in section \"%s\", which is not allowed. Using first character.", strSection);
 			}
 			if(strlen(strConfigFlag) == 0 && StrContains(strSection, "STEAM_", false) == -1 && StrContains(strSection, "[U:1:", false) == -1)
 			{
 				bFound = true;
 				break;
 			}
 			if(!FindFlagByChar(strConfigFlag[0], fFlag))
 			{
 				if(strlen(strConfigFlag) > 0)
 				{
 					LogError("Invalid flag given for section \"%s\", skipping", strSection);
 				}
 				continue;
 			}
 			if(GetAdminFlag(iAdmin, fFlag))
 			{
 				bFound = true;
 				break;
 			}
 		} while(kvConfigFile.GotoNextKey());
 		if(!bFound)
 		{
 			return;
 		}
 	}
 	char strClientTagColor[12];
 	char strClientNameColor[12];
 	char strClientChatColor[12];
 	kvConfigFile.GetString("tag", g_strTag[iClient], sizeof(g_strTag[]));
 	kvConfigFile.GetString("tagcolor", strClientTagColor, sizeof(strClientTagColor));
 	kvConfigFile.GetString("namecolor", strClientNameColor, sizeof(strClientNameColor));
 	kvConfigFile.GetString("textcolor", strClientChatColor, sizeof(strClientChatColor));
 	ReplaceString(strClientTagColor, sizeof(strClientTagColor), "#", "");
 	ReplaceString(strClientNameColor, sizeof(strClientNameColor), "#", "");
 	ReplaceString(strClientChatColor, sizeof(strClientChatColor), "#", "");
 	int iTagLength = strlen(strClientTagColor);
 	int iNameLength = strlen(strClientNameColor);
 	int iChatLength = strlen(strClientChatColor);
 	if(iTagLength == 6 || iTagLength == 8 || StrEqual(strClientTagColor, "T", false) || StrEqual(strClientTagColor, "G", false) || StrEqual(strClientTagColor, "O", false))
 	{
 		strcopy(g_strTagColor[iClient], sizeof(g_strTagColor[]), strClientTagColor);
 	}
 	if(iNameLength == 6 || iNameLength == 8 || StrEqual(strClientNameColor, "G", false) || StrEqual(strClientNameColor, "O", false))
 	{
 		strcopy(g_strUsernameColor[iClient], sizeof(g_strUsernameColor[]), strClientNameColor);
 	}
-	/* Color Handling */
+	if(iChatLength == 6 || iChatLength == 8 || StrEqual(strClientChatColor, "T", false) || StrEqual(strClientChatColor, "G", false) || StrEqual(strClientChatColor, "O", false))
 	{
-	// Define tag/name/text color strings
+		strcopy(g_strChatColor[iClient], sizeof(g_strChatColor[]), strClientChatColor);
 	}
 	strcopy(g_strDefaultTag[iClient], sizeof(g_strDefaultTag[]), g_strTag[iClient]);
-	char strClientTextColor[12];
+
 	strcopy(g_strDefaultUsernameColor[iClient], sizeof(g_strDefaultUsernameColor[]), g_strUsernameColor[iClient]);
 	strcopy(g_strDefaultChatColor[iClient], sizeof(g_strDefaultChatColor[]), g_strChatColor[iClient]);
 	Call_StartForward(hLoadedForward);
 	Call_PushCell(iClient);
-	kvConfigFile.GetString("textcolor", strClientTextColor, sizeof(strClientTextColor));
+
 }
-	// Replace #'s
+
 forward Action OnChatMessage(int& author, Handle recipients, eChatFlags& flag, char[] name, char[] message, bool& bProcessColors, bool& bRemoveColors);
 {
-	ReplaceString(strClientTextColor, sizeof(strClientTextColor), "#", "");
+
 }
-	int iTagColorLength = strlen(strClientTagColor);
+
-	int iNameColorLength = strlen(strClientNameColor);
+forward void OnChatMessagePost(int author, Handle recipients, eChatFlags flag, const char[] name, const char[] message, bool bProcessColors, bool bRemoveColors);
-	int iTextColorLength = strlen(strClientTextColor);
+
 	char strNewName[MAXLENGTH_NAME_NEW];
-	if(iTagColorLength == 6 /* RGB */
+	strcopy(strNewName, sizeof(strNewName), name);
-	|| iTagColorLength == 8 /* RGBA */
+
-	|| StrEqual(strClientTagColor, "T", false) /* Team-Colored */
+	char strNewMessage[MAXLENGTH_MESSAGE];
-	|| StrEqual(strClientTagColor, "G", false) /* Green */
+	strcopy(strNewMessage, sizeof(strNewMessage), message);
-	|| StrEqual(strClientTagColor, "O", false) /* Olive */)
+
 	if(CheckForward(iAuthor, strNewMessage, CPT_NameColor))
 	{
 		if(StrEqual(g_strUsernameColor[iAuthor], "G", false))
-	if(iNameColorLength == 6 /* RGB */
+
-	|| iNameColorLength == 8 /* RGBA */
+			Format(strNewName, MAXLENGTH_NAME_NEW, "\x04%s", strName);
-	|| StrEqual(strClientNameColor, "T", false) /* Team-Colored */
+
-	|| StrEqual(strClientNameColor, "G", false) /* Green */
+
-	|| StrEqual(strClientNameColor, "O", false) /* Olive */)
+
 			Format(strNewName, MAXLENGTH_NAME_NEW, "\x05%s", strName);
 		}
 		else if(strlen(g_strUsernameColor[iAuthor]) == 6)
-	if(iTextColorLength == 6 /* RGB */
+
-	|| iTextColorLength == 8 /* RGBA */
+			Format(strNewName, MAXLENGTH_NAME_NEW, "\x07%s%s", g_strUsernameColor[iAuthor], strName);
-	|| StrEqual(strClientTextColor, "T", false) /* Team-Color */
+
-	|| StrEqual(strClientTextColor, "G", false) /* Green */
+
-	|| StrEqual(strClientTextColor, "O", false) /* Olive */)
+
 			Format(strNewName, MAXLENGTH_NAME_NEW, "\x08%s%s", g_strUsernameColor[iAuthor], strName);
-		strcopy(g_strTextColor[iClient], sizeof(g_strTextColor[]), strClientTextColor);
+
 		else
 		{
 			Format(strNewName, MAXLENGTH_NAME_NEW, "\x03%s", strName); // team color by default!
 		}
-	strcopy(g_strDefaultTextColor[iClient], sizeof(g_strDefaultTextColor[]), g_strTextColor[iClient]);
+
 	else
 	{
 		Format(strNewName, MAXLENGTH_NAME_NEW, "\x03%s", strName); // team color by default!
 	}
 	if(CheckForward(iAuthor, strNewMessage, CPT_TagColor))
-public Action OnChatMessage(int& iAuthor, ArrayList hRecipients, eChatFlags& fFlag, char[] strName, char[] strMessage, bool& bProcessColors, bool& bRemoveColors)
+
 		if(strlen(g_strTag[iAuthor]) > 0)
-	bRemoveColors = true;
+
 			if(StrEqual(g_strTagColor[iAuthor], "T", false))
 			{
-
+				Format(strNewName, MAXLENGTH_NAME_NEW, "\x03%s%s", g_strTag[iAuthor], strName);
-public void OnChatMessagePost(int iAuthor, ArrayList hRecipients, eChatFlags fFlag, const char[] strName, const char[] strMessage, bool bProcessColors, bool bRemoveColors)
+
 			else if(StrEqual(g_strTagColor[iAuthor], "G", false))
-	char strNewName[MAXLENGTH_256];
+
-	strcopy(strNewName, sizeof(strNewName), strName);
+				Format(strNewName, MAXLENGTH_NAME_NEW, "\x04%s%s", g_strTag[iAuthor], strName);
-
+
-	char strNewMessage[MAXLENGTH_256];
+
-	strcopy(strNewMessage, sizeof(strNewMessage), strMessage);
+
-
+				Format(strNewName, MAXLENGTH_NAME_NEW, "\x05%s%s", g_strTag[iAuthor], strName);
 			}
 			else if(strlen(g_strTagColor[iAuthor]) == 6)
-		if(StrEqual(g_strUsernameColor[iAuthor], "T", false))
+
 				Format(strNewName, MAXLENGTH_NAME_NEW, "\x07%s%s%s", g_strTagColor[iAuthor], g_strTag[iAuthor], strName);
-			// Team Colored
+
-			Format(strNewName, MAXLENGTH_256, "\x03%s", strNewName);
+
 			{
 				Format(strNewName, MAXLENGTH_NAME_NEW, "\x08%s%s%s", g_strTagColor[iAuthor], g_strTag[iAuthor], strName);
 			}
-			// Green
+
-			Format(strNewName, MAXLENGTH_256, "\x04%s", strNewName);
+
 				Format(strNewName, MAXLENGTH_NAME_NEW, "%s\x01%s", g_strTag[iAuthor], strName);
 			}
 		}
-			// Olive
+
-			Format(strNewName, MAXLENGTH_256, "\x05%s", strNewName);
+
 	if(strlen(g_strChatColor[iAuthor]) > 0 && CheckForward(iAuthor, strNewMessage, CPT_ChatColor))
 	{
 		if(StrEqual(g_strChatColor[iAuthor], "T", false))
-			// RGB
+
-			Format(strNewName, MAXLENGTH_256, "\x07%s%s", g_strUsernameColor[iAuthor], strNewName);
+			Format(strNewMessage, MAXLENGTH_MESSAGE, "\x03%s", strNewMessage);
 		}
 		else if(StrEqual(g_strChatColor[iAuthor], "G", false))
 		{
-			// RGBA
+			Format(strNewMessage, MAXLENGTH_MESSAGE, "\x04%s", strNewMessage);
-			Format(strNewName, MAXLENGTH_256, "\x08%s%s", g_strUsernameColor[iAuthor], strNewName);
+
 		else if(StrEqual(g_strChatColor[iAuthor], "O", false))
 		{
 			Format(strNewMessage, MAXLENGTH_MESSAGE, "\x05%s", strNewMessage);
-			// Team-Colored by default
+
-			Format(strNewName, MAXLENGTH_256, "\x03%s", strNewName);
+		else if(strlen(g_strChatColor[iAuthor]) == 6)
 		{
 			Format(strNewMessage, MAXLENGTH_MESSAGE, "\x07%s%s", g_strChatColor[iAuthor], strNewMessage);
 		}
 		else if(strlen(g_strChatColor[iAuthor]) == 8)
-		// Team-Colored by default
+
-		Format(strNewName, MAXLENGTH_256, "\x03%s", strNewName);
+			Format(strNewMessage, MAXLENGTH_MESSAGE, "\x08%s%s", g_strChatColor[iAuthor], strNewMessage);
 		}
 	}
-	// Check if the tag color string is above 0 characters
+
-	if(strlen(g_strTagColor[iAuthor]) > 0 && CheckForward(iAuthor, strNewMessage, CPT_TagColor))
+
 	GetGameFolderName(strGame, sizeof(strGame));
-		// Check if tag length is more than 0
+
 	{
 		Format(strName, MAXLENGTH_NAME_NEW, "\x01\x0B%s", strName);
-			if(strlen(g_strTagColor[iAuthor]) == 6)
+
 
-				// RGB
+
-				Format(strNewName, MAXLENGTH_256, "\x07%s%s%s", g_strTagColor[iAuthor], g_strTag[iAuthor], strNewName);
+
 	Call_PushStringEx(strNewMessage, MAXLENGTH_MESSAGE, SM_PARAM_STRING_UTF8|SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);
 	Call_PushCell(MAXLENGTH_MESSAGE);
-
+
-				// RGBA
+
-				Format(strNewName, MAXLENGTH_256, "\x08%s%s%s", g_strTagColor[iAuthor], g_strTag[iAuthor], strNewName);
+	CPrintToChat(iAuthor, "%s{default} : %s", strNewName, strNewMessage);
 }
-			else if(StrEqual(g_strTagColor[iAuthor], "T", false))
+
 stock bool CheckForward(int iAuthor, const char[] strMessage, CPT_ColorType tType)
-				// Team-Colored
+
-				Format(strNewName, MAXLENGTH_256, "\x03%s%s", g_strTag[iAuthor], strNewName);
+
 	Call_StartForward(hApplicationForward);
 	Call_PushCell(iAuthor);
 	Call_PushString(strMessage);
-				// Green
+
-				Format(strNewName, MAXLENGTH_256, "\x04%s%s", g_strTag[iAuthor], strNewName);
+
 	if(aResult >= Plugin_Handled)
 	{
 		return false;
-				// Olive
+
-				Format(strNewName, MAXLENGTH_256, "\x05%s%s", g_strTag[iAuthor], strNewName);
+
 	// Compatibility
 	switch(tType)
 	{
-				// Default Handling
+
-				Format(strNewName, MAXLENGTH_256, "%s\x03%s", g_strTag[iAuthor], strNewName);
+
 			return TagForward(iAuthor);
 		}
 		case CPT_NameColor:
 		{
 			return NameForward(iAuthor);
-		// Team-Colored by default
+
-		Format(strNewName, MAXLENGTH_256, "%s\x03%s", g_strTag[iAuthor], strNewName);
+		case CPT_ChatColor:
 		{
-
+
-	if(strlen(g_strTextColor[iAuthor]) > 0 && CheckForward(iAuthor, strNewMessage, CPT_TextColor))
+
 	}
-		if(StrEqual(g_strTextColor[iAuthor], "T", false))
+
 	return true;
-			// Team-Colored
+
-			Format(strNewMessage, MAXLENGTH_256, "\x03%s", strNewMessage);
+
 stock bool ColorForward(int iAuthor)
-		else if(StrEqual(g_strTextColor[iAuthor], "G", false))
+
 	Action aResult = Plugin_Continue;
-			// Green
+
-			Format(strNewMessage, MAXLENGTH_256, "\x04%s", strNewMessage);
+
 	Call_Finish(aResult);
-		else if(StrEqual(g_strTextColor[iAuthor], "O", false))
+
 	{
-			// Olive
+
-			Format(strNewMessage, MAXLENGTH_256, "\x05%s", strNewMessage);
+
 
-		else if(strlen(g_strTextColor[iAuthor]) == 6)
+
 }
-			// RGB
+
-			Format(strNewMessage, MAXLENGTH_256, "\x07%s%s", g_strTextColor[iAuthor], strNewMessage);
+
 {
-		else if(strlen(g_strTextColor[iAuthor]) == 8)
+
 	Call_StartForward(hNameForward);
-			// RGBA
+
-			Format(strNewMessage, MAXLENGTH_256, "\x08%s%s", g_strTextColor[iAuthor], strNewMessage);
+
 	if(aResult >= Plugin_Handled)
 	{
 		return false;
-			// White by default
+
-			Format(strNewMessage, MAXLENGTH_256, "\x01%s", strNewMessage);
+
 	return true;
 }
 
 stock bool TagForward(int iAuthor)
-		// White by default
+
-		Format(strNewMessage, MAXLENGTH_256, "\x01%s", strNewMessage);
+
 	Call_StartForward(hTagForward);
-
+
 	Call_Finish(aResult);
 	if(aResult >= Plugin_Handled)
 	{
 		return false;
-		// CS:GO specific name formatting
+
-		Format(strNewName, MAXLENGTH_256, "\x01\x0B%s", strNewName);
+
 	return true;
 }
-	CPrintToChat(iAuthor, "%s : %s", strNewName, strNewMessage);
+
-	PrintToServer("%s : %s", strNewName, strNewMessage);
+
-
+
 	Action aResult = Plugin_Continue;
 	Call_StartForward(hPreLoadedForward);
-	Call_PushStringEx(strNewMessage, MAXLENGTH_256, SM_PARAM_STRING_UTF8|SM_PARAM_STRING_COPY, SM_PARAM_COPYBACK);
+
-	Call_PushCell(MAXLENGTH_256);
+
 	if(aResult >= Plugin_Handled)
 	{
 		return false;
 	}
 
 	return true;
 }
 
 public int Native_GetColor(Handle hPlugin, int NumParams)
 {
 	int iClient = GetNativeCell(1);
 	if(iClient < 1 || iClient > MaxClients || !IsClientInGame(iClient))
 	{
 		ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client is not in game");
 		return COLOR_NONE;
 	}
 	switch(GetNativeCell(2))
 	{
 		case CPT_TagColor:
 		{
 			if(StrEqual(g_strTagColor[iClient], "T", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_TEAM;
 			}
 			else if(StrEqual(g_strTagColor[iClient], "G", false))
 			{
-		case CPT_TextColor:
+
 				return COLOR_GREEN;
 			}
 			else if(StrEqual(g_strTagColor[iClient], "O", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_OLIVE;
 			}
 			else if(strlen(g_strTagColor[iClient]) == 6 || strlen(g_strTagColor[iClient]) == 8)
 			{
 				SetNativeCellRef(3, strlen(g_strTagColor[iClient]) == 8);
 				return StringToInt(g_strTagColor[iClient], 16);
 			}
 			else
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_NONE;
 			}
 		}
 		case CPT_NameColor:
 		{
 			if(StrEqual(g_strUsernameColor[iClient], "G", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_GREEN;
 			}
 			else if(StrEqual(g_strUsernameColor[iClient], "O", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_OLIVE;
 			}
 			else if(strlen(g_strUsernameColor[iClient]) == 6 || strlen(g_strUsernameColor[iClient]) == 8)
 			{
 				SetNativeCellRef(3, strlen(g_strUsernameColor[iClient]) == 8);
 				return StringToInt(g_strUsernameColor[iClient], 16);
 			}
 			else
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_TEAM;
 			}
 		}
 		case CPT_ChatColor:
 		{
 			if(StrEqual(g_strChatColor[iClient], "T", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_TEAM;
 			}
 			else if(StrEqual(g_strChatColor[iClient], "G", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_GREEN;
 			}
 			else if(StrEqual(g_strChatColor[iClient], "O", false))
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_OLIVE;
 			}
 			else if(strlen(g_strChatColor[iClient]) == 6 || strlen(g_strChatColor[iClient]) == 8)
 			{
 				SetNativeCellRef(3, strlen(g_strChatColor[iClient]) == 8);
 				return StringToInt(g_strChatColor[iClient], 16);
 			}
 			else
 			{
 				SetNativeCellRef(3, false);
 				return COLOR_NONE;
 			}
 		}
 	}
 	return COLOR_NONE;
 }
 
 public int Native_SetColor(Handle hPlugin, int iNumParams)
 {
 	int iClient = GetNativeCell(1);
 	if(iClient < 1 || iClient > MaxClients || !IsClientInGame(iClient))
 	{
 		ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client is not in game");
 		return false;
 	}
 	char strColor[32];
 	if(GetNativeCell(3) < 0)
 	{
 		switch(GetNativeCell(3))
 		{
 			case COLOR_GREEN:
 			{
 				Format(strColor, sizeof(strColor), "G");
 			}
 			case COLOR_OLIVE:
 			{
 				Format(strColor, sizeof(strColor), "O");
 			}
 			case COLOR_TEAM:
 			{
 				Format(strColor, sizeof(strColor), "T");
 			}
 			case COLOR_NONE:
 			{
 				Format(strColor, sizeof(strColor), "");
 			}
 		}
 	}
 	else
 	{
 		if(!GetNativeCell(4))
 		{
 			// No alpha
 			Format(strColor, sizeof(strColor), "%06X", GetNativeCell(3));
 		}
 		else
 		{
 			// Alpha specified
 			Format(strColor, sizeof(strColor), "%08X", GetNativeCell(3));
 		}
 	}
 	if(strlen(strColor) != 6 && strlen(strColor) != 8 && !StrEqual(strColor, "G", false) && !StrEqual(strColor, "O", false) && !StrEqual(strColor, "T", false))
 	{
 		return false;
 	}
 	switch(GetNativeCell(2))
 	{
 		case CPT_TagColor:
 		{
-		case CPT_TextColor:
+
 		}
-			if(StrEqual(g_strTextColor[iClient], "T", false))
+
 		{
 			strcopy(g_strUsernameColor[iClient], sizeof(g_strUsernameColor[]), strColor);
 		}
 		case CPT_ChatColor:
-			else if(StrEqual(g_strTextColor[iClient], "G", false))
+
 			strcopy(g_strChatColor[iClient], sizeof(g_strChatColor[]), strColor);
 		}
 	}
 	return true;
-			else if(StrEqual(g_strTextColor[iClient], "O", false))
+
 
 public int Native_GetTag(Handle hPlugin, int iNumParams)
 {
 	int iClient = GetNativeCell(1);
-			else if(strlen(g_strTextColor[iClient]) == 6 || strlen(g_strTextColor[iClient]) == 8)
+
 	{
-				SetNativeCellRef(3, strlen(g_strTextColor[iClient]) == 8);
+
-				return StringToInt(g_strTextColor[iClient], 16);
+
 	}
 	SetNativeString(2, g_strTag[iClient], GetNativeCell(3));
 }
 
 public int Native_SetTag(Handle hPlugin, int iNumParams)
 {
 	int iClient = GetNativeCell(1);
 	if(iClient < 1 || iClient > MaxClients || !IsClientInGame(iClient))
 	{
 		ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client is not in game");
 		return;
 	}
 	GetNativeString(2, g_strTag[iClient], sizeof(g_strTag[]));
 }
 
 public int Native_ResetColor(Handle hPlugin, int iNumParams)
 {
 	int iClient = GetNativeCell(1);
 	if(iClient < 1 || iClient > MaxClients || !IsClientInGame(iClient))
 	{
 		ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client is not in game");
 		return;
 	}
 	switch(GetNativeCell(2))
 	{
 		case CPT_TagColor:
 		{
 			strcopy(g_strTagColor[iClient], sizeof(g_strTagColor[]), g_strDefaultTagColor[iClient]);
 		}
 		case CPT_NameColor:
 		{
 			strcopy(g_strUsernameColor[iClient], sizeof(g_strUsernameColor[]), g_strDefaultUsernameColor[iClient]);
 		}
 		case CPT_ChatColor:
 		{
 			strcopy(g_strChatColor[iClient], sizeof(g_strChatColor[]), g_strDefaultChatColor[iClient]);
 		}
 	}
 }
 
 public int Native_ResetTag(Handle hPlugin, int iNumParams)
 {
 	int iClient = GetNativeCell(1);
 	if(iClient < 1 || iClient > MaxClients || !IsClientInGame(iClient))
 	{
 		ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client is not in game");
 		return;
 	}
 	strcopy(g_strTag[iClient], sizeof(g_strTag[]), g_strDefaultTag[iClient]);
 }