sank

#include <hattrick_csgo>

public Plugin myinfo =
{
	name = "sank_sounds",
	author = "Hattrick HKS",
	description = "Provides Sank Sounds",
	version = "2.0",
	url = "http://hattrick.go.ro/"
};

native bool IsClientVIP(int iId);
native bool IsUserGagged(int iId);
native bool HasClientSoundsEnabled(int iId);
native Handle GetMainDbHandle();

Handle g_pKeys = INVALID_HANDLE;
Handle g_pSounds = INVALID_HANDLE;
Handle g_pPrecached = INVALID_HANDLE;
Handle g_pChances = INVALID_HANDLE;

char g_Buffer[PLATFORM_MAX_PATH] = "";
Handle g_pDb = INVALID_HANDLE;

bool g_Enabled = false;

int g_maxSoundsPerRound = 0;
char g_AccessToAvoidSankSoundsCheck[MAX_NAME_LENGTH] = "";
char g_AccessToPlaySankSoundsCheck[MAX_NAME_LENGTH] = "";

int g_Count[MAXPLAYERS + 1] = { 0, ... };

Handle __GetMainDbHandle()
{
	return CanTestFeatures() && \
			GetFeatureStatus(FeatureType_Native, "GetMainDbHandle") == FeatureStatus_Available ? \
				GetMainDbHandle() : INVALID_HANDLE;
}

public void OnPluginStart()
{
	RegConsoleCmd("say", OnSay);

	HookEventEx("announce_phase_end", DisabPlugin);
	HookEventEx("cs_intermission", DisabPlugin);
	HookEventEx("cs_win_panel_match", DisabPlugin);
	HookEventEx("start_halftime", DisabPlugin);

	HookEventEx("round_start", EnabPlugin);

	g_pKeys = CreateArray(MAX_NAME_LENGTH);
	g_pSounds = CreateArray(PLATFORM_MAX_PATH);
	g_pPrecached = CreateArray(PLATFORM_MAX_PATH);
	g_pChances = CreateArray(MAX_NAME_LENGTH);
}

public void OnClientPutInServer(int Id)
{
	static Handle pPack = INVALID_HANDLE;
	static int Iter = 0, Size = 0, Chance = 0;
	static char Steam[MAX_NAME_LENGTH], Extracted[MAX_NAME_LENGTH], \
					Object[MAX_NAME_LENGTH], Sample[PLATFORM_MAX_PATH];
	static char Container[MAX_NAME_LENGTH][PLATFORM_MAX_PATH];
	static int iContainer[MAX_NAME_LENGTH] = { 0, ... };
	static int iContainerSize = 0;

	Size = GetArraySize(g_pKeys);

	if (Size > 0 && \
			Id >= 1 && \
				Id <= MaxClients)
	{
		iContainerSize = 0;

		g_Count[Id] = 0;

		GetClientAuthId(Id, AuthId_Engine, Steam, sizeof(Steam));
		hCSGO_ExtractSteamID(Steam, Extracted, sizeof(Extracted));

		for (Iter = 0; Iter < Size; Iter++)
		{
			GetArrayString(g_pKeys, Iter, Object, sizeof(Object));

			if (StrContains(Object, Extracted, false) != -1)
			{
				GetArrayString(g_pSounds, Iter, Container[iContainerSize], PLATFORM_MAX_PATH);

				iContainer[iContainerSize++] = GetArrayCell(g_pChances, Iter);
			}
		}

		if (iContainerSize > 0)
		{
			Iter = GetRandomInt(0, iContainerSize - 1);

			FormatEx(Sample, sizeof(Sample), Container[Iter]);
			Chance = iContainer[Iter];

			if (GetRandomInt(0, Chance) == 0)
			{
				pPack = CreateDataPack();

				if (pPack != INVALID_HANDLE)
				{
					WritePackCell(pPack, Id);
					WritePackString(pPack, Sample);

					CreateTimer(GetRandomFloat(4.0, 8.0), playJoinSound, pPack);
				}
			}
		}
	}
}

public Action playJoinSound(Handle pTimer, any pPack)
{
	static int Id = INVALID_ENT_REFERENCE, Other = INVALID_ENT_REFERENCE;
	static char Sample[PLATFORM_MAX_PATH];

	ResetPack(pPack);

	Id = ReadPackCell(pPack);
	ReadPackString(pPack, Sample, sizeof(Sample));

	CloseHandle(pPack);
	pPack = INVALID_HANDLE;

	if (!g_Enabled || \
			!IsClientInGame(Id))
	{
		return Plugin_Continue;
	}

	for (Other = 1; Other <= MaxClients; Other++)
	{
		if (HasClientSoundsEnabled(Other))
		{
			hCSGO_PlaySound(Other, Sample);

			PrintToChat(Other, "*\x02 *******************************");
			PrintToChat(Other, "*\x02 BOSS\x05  %N\x02  JOINED", Id);
		}
	}

	return Plugin_Continue;
}

public void DisabPlugin(Handle pHndl, const char[] Name, bool bNoBCast)
{
	g_Enabled = false;
}

public void EnabPlugin(Handle pHndl, const char[] Name, bool bNoBCast)
{
	static int iId = INVALID_ENT_REFERENCE;

	for (iId = 1; iId <= MaxClients; iId++)
		g_Count[iId] = 0;

	g_Enabled = true;
}

public void OnMapStart()
{
	g_Enabled = false;

	LoadSankSounds();

	hCSGO_GetOptFromFileChar("configs/hattrick.core.txt", \
								"m_szAccessToPlaySankSoundsCheck", \
									g_AccessToPlaySankSoundsCheck, \
										sizeof(g_AccessToPlaySankSoundsCheck));

	hCSGO_GetOptFromFileChar("configs/hattrick.core.txt", \
								"m_szAccessToAvoidSankSoundsCheck", \
									g_AccessToAvoidSankSoundsCheck, \
										sizeof(g_AccessToAvoidSankSoundsCheck));

	g_maxSoundsPerRound = hCSGO_ClampInt(hCSGO_GetOptFromFileInt("configs/hattrick.core.txt", \
																	"m_uMaxSankSoundsPerRound"), \
												1, \
													999999);
}

public void OnMapEnd()
{
	g_Enabled = false;
}

public Action OnSay(int Client, int Args)
{
	static int Size = 0, Iterator = 0, Id = INVALID_ENT_REFERENCE, Len = 0;
	static char Arg[MAX_NAME_LENGTH], Object[MAX_NAME_LENGTH], Buffer[PLATFORM_MAX_PATH];
	static bool bDone = false;

	if (!g_Enabled || \
			!HasClientSoundsEnabled(Client) || \
				IsUserGagged(Client))
	{
		return Plugin_Continue;
	}

	if (IsClientVIP(Client) || \
			CheckCommandAccess(Client, g_AccessToPlaySankSoundsCheck, ADMFLAG_BAN))
	{
		GetCmdArgString(Arg, sizeof(Arg));

		if ((Len = hCSGO_ClearLine(Arg)) <= 32 && \
				Len > 0 && \
					StrContains(Arg, "STEAM_", false) == -1)
		{
			Size = GetArraySize(g_pKeys);

			if (Size > 0)
			{
				bDone = false;

				for (Iterator = 0; Iterator < Size; Iterator++)
				{
					GetArrayString(g_pKeys, Iterator, Object, sizeof(Object));

					if (strcmp(Arg, Object, false) == 0)
					{
						if (!hCSGO_IsWarmup() && \
								!CheckCommandAccess(Client, g_AccessToAvoidSankSoundsCheck, ADMFLAG_ROOT) && \
									g_Count[Client]++ >= g_maxSoundsPerRound)
						{
							return Plugin_Continue;
						}

						GetArrayString(g_pSounds, Iterator, Buffer, sizeof(Buffer));

						for (Id = 1; Id <= MaxClients; Id++)
						{
							if (HasClientSoundsEnabled(Id))
							{
								hCSGO_PlaySound(Id, Buffer);
							}
						}

						bDone = true;
						break;
					}
				}

				if (!bDone)
				{
					for (Iterator = 0; Iterator < Size; Iterator++)
					{
						GetArrayString(g_pKeys, Iterator, Object, sizeof(Object));

						Len = strlen(Object);

						if (strncmp(Arg, Object, Len, false) == 0)
						{
							if (Len <= 3 && \
									Arg[Len] != ' ' && \
										Arg[Len] != EOS)
							{
								continue;
							}

							if (!hCSGO_IsWarmup() && \
									!CheckCommandAccess(Client, g_AccessToAvoidSankSoundsCheck, ADMFLAG_ROOT) && \
										g_Count[Client]++ >= g_maxSoundsPerRound)
							{
								return Plugin_Continue;
							}

							GetArrayString(g_pSounds, Iterator, Buffer, sizeof(Buffer));

							for (Id = 1; Id <= MaxClients; Id++)
							{
								if (HasClientSoundsEnabled(Id))
								{
									hCSGO_PlaySound(Id, Buffer);
								}
							}

							break;
						}
					}
				}
			}
		}
	}

	return Plugin_Continue;
}

bool IsFilePrecached(char[] fileName = "")
{
	static int Size = 0, Iter = 0;
	static char Object[PLATFORM_MAX_PATH];

	Size = GetArraySize(g_pPrecached);

	if (Size < 1)
	{
		return false;
	}

	for (Iter = 0; Iter < Size; Iter++)
	{
		GetArrayString(g_pPrecached, Iter, Object, sizeof(Object));

		if (strcmp(Object, fileName, false) == 0)
		{
			return true;
		}
	}

	return false;
}

bool LoadSankSounds()
{
	static int Size = 0, Table = INVALID_STRING_TABLE;
	static char Buffer[PLATFORM_MAX_PATH * 4];
	static char Buffers[4][PLATFORM_MAX_PATH * 2];
	static Handle pFile = INVALID_HANDLE;
	static bool bKeyOK = false, bFileOK = false;
	static Handle pRes = INVALID_HANDLE;
	static char szSteam[PLATFORM_MAX_PATH] = "";
	static char szMusic[PLATFORM_MAX_PATH] = "";
	static char szError[PLATFORM_MAX_PATH] = "";

	ClearArray(g_pKeys);
	ClearArray(g_pSounds);
	ClearArray(g_pPrecached);
	ClearArray(g_pChances);

	if (Table == INVALID_STRING_TABLE)
	{
		Table = FindStringTable("soundprecache");
	}

	if (Table == INVALID_STRING_TABLE)
	{
		return false;
	}

	if (g_pDb == INVALID_HANDLE)
	{
		g_pDb = __GetMainDbHandle();

		if (g_pDb == INVALID_HANDLE)
		{
			g_pDb = SQL_Connect("main_db", true, szError, sizeof(szError));

			if (g_pDb != INVALID_HANDLE)
			{
				SQL_SetCharset(g_pDb, "utf8");
			}
		}
	}

	if (g_pDb != INVALID_HANDLE)
	{
		SQL_LockDatabase(g_pDb);
		FormatEx(g_Buffer, sizeof(g_Buffer), "DELETE FROM sm_music WHERE Stamp < %d;", GetTime() - (86400 * 7 * 3));
		pRes = SQL_Query(g_pDb, g_Buffer);
		if (pRes)
		{
			CloseHandle(pRes);
			pRes = INVALID_HANDLE;
		}
		FormatEx(g_Buffer, sizeof(g_Buffer), "SELECT Steam, Music FROM sm_music;");
		pRes = SQL_Query(g_pDb, g_Buffer);
		if (pRes)
		{
			while (SQL_FetchRow(pRes))
			{
				SQL_FetchString(pRes, 0, szSteam, sizeof(szSteam));
				SQL_FetchString(pRes, 1, szMusic, sizeof(szMusic));

				if (strlen(szSteam) > 0 && strlen(szMusic) > 0)
				{
					FormatEx(g_Buffer, sizeof(g_Buffer), "sound/sank/%s", szMusic);
					if (FileExists(g_Buffer))
					{
						PushArrayString(g_pKeys, szSteam);

						Format(szMusic, sizeof(szMusic), "*sank/%s", szMusic);
						PushArrayString(g_pSounds, szMusic);

						if (!IsFilePrecached(g_Buffer))
						{
							AddFileToDownloadsTable(g_Buffer);
							PushArrayString(g_pPrecached, g_Buffer);
							ReplaceString(g_Buffer, sizeof(g_Buffer), "sound/", "*");
							AddToStringTable(Table, g_Buffer);
						}
					}
				}
			}

			CloseHandle(pRes);
			pRes = INVALID_HANDLE;
		}
		SQL_UnlockDatabase(g_pDb);
	}

	BuildPath(Path_SM, Buffer, sizeof(Buffer), "configs/sank_sounds.txt");

	if (!FileExists(Buffer))
	{
		return false;
	}

	pFile = OpenFile(Buffer, "r");

	if (pFile == INVALID_HANDLE)
	{
		return false;
	}

	while (!IsEndOfFile(pFile) && \
				ReadFileLine(pFile, Buffer, sizeof(Buffer)))
	{
		TrimString(Buffer);

		hCSGO_FixFileLine(Buffer, sizeof(Buffer));

		if (strlen(Buffer) < 1 || \
				Buffer[0] == ';' || \
					Buffer[0] == '#' || \
						(Buffer[0] == '/' && Buffer[1] == '/'))
		{
			continue;
		}

		Size = ExplodeString(Buffer, " ", Buffers, sizeof(Buffers), sizeof(Buffers[]));

		if (Size >= 2)
		{
			bKeyOK = false, \
				bFileOK = false;

			if (hCSGO_ClearLine(Buffers[0]) > 0)
			{
				ReplaceString(Buffers[0], sizeof(Buffers[]), "|", " "), \
					bKeyOK = true;
			}

			if (hCSGO_ClearLine(Buffers[1]) > 0)
			{
				ReplaceString(Buffers[1], sizeof(Buffers[]), "|", " ");

				FormatEx(Buffer, sizeof(Buffer), Buffers[1]);
				ReplaceString(Buffer, sizeof(Buffer), "*", "sound/");

				if (!FileExists(Buffer))
				{
					LogError("Invalid Sank Sound Entry [Sound Key (\"%s\")] [Sound File (\"%s\")] - Sound File Could Not Be Found And Pre-Cached!", \
								Buffers[0], Buffer);
				}

				else
				{
					bFileOK = true;
				}
			}

			if (bKeyOK && \
					bFileOK)
			{
				PushArrayString(g_pKeys, Buffers[0]);
				PushArrayString(g_pSounds, Buffers[1]);

				if (!IsFilePrecached(Buffer))
				{
					AddToStringTable(Table, Buffers[1]);
					AddFileToDownloadsTable(Buffer);

					PushArrayString(g_pPrecached, Buffer);
				}

				if (Size >= 3 && \
						StrContains(Buffers[0], "STEAM", false) != -1)
				{
					PushArrayCell(g_pChances, StringToInt(Buffers[2]));
				}

				else
				{
					PushArrayCell(g_pChances, 0);
				}
			}
		}
	}

	CloseHandle(pFile);
	pFile = INVALID_HANDLE;

	return true;
}