#pragma semicolon 1

#define PLUGIN_AUTHOR "Totenfluch"

#define PLUGIN_VERSION "2.00"

#include <sourcemod>

#include <sdktools>

#include <autoexecconfig>

#include <store>

#include <cstrike>

#include <sdkhooks>

#include <smlib>

#include <map_workshop_functions>

#include <emitsoundany>

#include <multicolors>

#pragma newdecls required

#define MAX_Item 1024

enum Item {

Float:gXPos,

Float:gYPos,

Float:gZPos,

bool:gIsActive,

gAuraRef,

gItemRef

}

int g_eItemSpawnPoints[MAX_Item][Item];

int g_iLoadedItem = 0;

int g_iActiveItem = 0;

int g_iBlueGlow;

ArrayList randomNumbers;

/* CVARS */

Handle g_hItemPath;

char g_cItemPath[255];

Handle g_hPickupSoundPath;

char g_cPickupSoundPath[255];

Handle g_hAuraPath;

char g_cAuraPath[255];

Handle g_hPickupEffectPath;

char g_cPickupEffectPath[255];

Handle g_hPickupCredits;

int g_iPickupCredits;

Handle g_hSpawnMode;

int g_iSpawnMode;

Handle g_hSpawnAmount;

int g_iSpawnAmount;

Handle g_hMinSpawnAmount;

int g_iMinSpawnAmount;

Handle g_hMaxSpawnAmount;

int g_iMaxSpawnAmount;

Handle g_hnSpawnAmount;

int g_inSpawnAmount;

int g_iAntiExploidSpawnAmount;

Handle g_hEnableAntiAbuse;

bool g_bEnableAntiAbuse;

Handle g_hpSpawnDelay;

int g_ipSpawnDelay;

Handle g_hSoundMode;

int g_iSoundMode;

Handle g_hChatTag;

char g_cChatTag[64];

Handle g_hItemName;

char g_cItemName[64];

Handle g_hUseMySQL;

char g_cUseMySQL[64];

int g_iRespawnDelays[MAX_Item];

Handle g_hModelScale;

float g_fModelScale;

Handle g_hZAxisOffset;

float g_fZAxisOffset;

Database g_DB;

bool g_bMySQLEnabled = false;

Handle g_hOnItemPickupBasic;

Handle g_hOnItemPickupAdvanced;

public Plugin myinfo =

{

name = "Event Items Spawner",

author = PLUGIN_AUTHOR,

description = "Spawns Items that can be collected",

version = PLUGIN_VERSION,

url = "https://totenfluch.de",

};

public void OnPluginStart()

{

RegAdminCmd("sm_itemspawns", addSpawnPointsMenu, ADMFLAG_GENERIC, "Opens the Item spawn menu");

RegAdminCmd("sm_itemspawnsreload", cmdForceReload, ADMFLAG_GENERIC, "Reloads the points");

RegAdminCmd("sm_itemmaps", getLoadedMaps, ADMFLAG_GENERIC, "Prints all maps without spawnpoints");

HookEvent("round_start", onRoundStart);

LoadTranslations("eventItems.phrases");

AutoExecConfig_SetFile("eventItems");

AutoExecConfig_SetCreateFile(true);

g_hItemPath = AutoExecConfig_CreateConVar("event_itemPath", "models/coop/challenge_coin.mdl", "Itempath of Item Spawn");

g_hAuraPath = AutoExecConfig_CreateConVar("event_auraPath", "", "Particle Name of Aura (optional)");

g_hPickupEffectPath = AutoExecConfig_CreateConVar("event_PickupEffectPath", "", "Particle Name of Pickup Effect (optional)");

g_hPickupSoundPath = AutoExecConfig_CreateConVar("event_PickupSoundPath", "", "Sound to play when item is picked up");

g_hPickupCredits = AutoExecConfig_CreateConVar("event_pickupCredits", "10", "Credits awarded for Pickup");

g_hSpawnMode = AutoExecConfig_CreateConVar("event_spawnMode", "4", ">>SpawnMode<<-> 1 -> x Per Player | 2 -> Up to 10*x | 3 -> Random from min to Max | 4 -> Random with n active and p(s) delay");

g_hSpawnAmount = AutoExecConfig_CreateConVar("event_spawnAmount", "1", "Amount x for >>SpawnMode 1 AND 2<<");

g_hMinSpawnAmount = AutoExecConfig_CreateConVar("event_minSpawnAmount", "15", "Min Amount for >>SpawnMode 3<<");

g_hMaxSpawnAmount = AutoExecConfig_CreateConVar("event_maxSpawnAmount", "25", "Max Amount for >>SpawnMode 3<<");

g_hSoundMode = AutoExecConfig_CreateConVar("event_soundMode", "2", "1 -> To Client on Pickup | 2 -> Ambient sound from Position | 3 -> Sound to all");

g_hnSpawnAmount = AutoExecConfig_CreateConVar("event_nSpawnAmount", "3", "n Spawn amount for >>SpawnMode 4<<");

g_hEnableAntiAbuse = AutoExecConfig_CreateConVar("event_antiExploid", "1", "reduces amount (n) for >>4<< to the players on the server if set on 1");

g_hpSpawnDelay = AutoExecConfig_CreateConVar("event_pSpawnDelay", "300", "Spawn delay for >>SpawnMode 4<< in seconds");

g_hChatTag = AutoExecConfig_CreateConVar("event_chatTag", "GGC", "Chattag to append in front of all prints");

g_hItemName = AutoExecConfig_CreateConVar("event_itemName", "Coin", "Name of the Item for PrintToChat");

g_hUseMySQL = AutoExecConfig_CreateConVar("event_useMysql", "eventItems", "MySQL Config Name - leave blank for none");

g_hModelScale = AutoExecConfig_CreateConVar("event_modelScale", "0.65", "Scales the Model (Not working for all models!)");

g_hZAxisOffset = AutoExecConfig_CreateConVar("event_zAxisOffset", "30.0", "Moves the Item Up and Down (can be negative)");

AutoExecConfig_CleanFile();

AutoExecConfig_ExecuteFile();

}

public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max)

{

/*

Param 1 : int client

Param 2 : float x

Param 3 : float y

Param 4 : float z

*/

g_hOnItemPickupBasic = CreateGlobalForward("itemspawner_OnItemPickupBasic", ET_Ignore, Param_Cell, Param_Float, Param_Float, Param_Float);

/*

Param 1 : int client

Param 2 : float x

Param 3 : float y

Param 4 : float z

Param 5 : int received credits

Param 6 : char[255] Item Path

Param 7 : char[255] Aura

Param 8 : char[255] Effect Path

Param 9 : char[255] Sound Path

Param 10 : char[64] Item Name

*/

g_hOnItemPickupAdvanced = CreateGlobalForward("itemspawner_OnItemPickupAdvanced", ET_Ignore, Param_Cell, Param_Float, Param_Float, Param_Float, Param_Cell, Param_String, Param_String, Param_String, Param_String, Param_String);

return APLRes_Success;

}

public Action cmdForceReload(int client, int args) {

forceReload();

return Plugin_Handled;

}

public void OnClientPostAdminCheck(int client) {

if (!g_bMySQLEnabled)

return;

char playerid[20];

GetClientAuthId(client, AuthId_Steam2, playerid, sizeof(playerid));

char playername[MAX_NAME_LENGTH + 8];

GetClientName(client, playername, sizeof(playername));

char clean_playername[MAX_NAME_LENGTH * 2 + 16];

SQL_EscapeString(g_DB, playername, clean_playername, sizeof(clean_playername));

char initQuery[512];

Format(initQuery, sizeof(initQuery), "INSERT IGNORE INTO `eventItems_stats` (`Id`, `playername`, `playerid`, `amount`) VALUES (NULL, '%s', '%s', '0');", clean_playername, playerid);

SQL_TQuery(g_DB, SQLErrorCheckCallback, initQuery);

}

public void OnConfigsExecuted() {

GetConVarString(g_hItemPath, g_cItemPath, sizeof(g_cItemPath));

GetConVarString(g_hAuraPath, g_cAuraPath, sizeof(g_cAuraPath));

GetConVarString(g_hPickupEffectPath, g_cPickupEffectPath, sizeof(g_cPickupEffectPath));

GetConVarString(g_hPickupSoundPath, g_cPickupSoundPath, sizeof(g_cPickupSoundPath));

g_iPickupCredits = GetConVarInt(g_hPickupCredits);

g_iSpawnMode = GetConVarInt(g_hSpawnMode);

g_iSpawnAmount = GetConVarInt(g_hSpawnAmount);

g_iSoundMode = GetConVarInt(g_hSoundMode);

g_iMinSpawnAmount = GetConVarInt(g_hMinSpawnAmount);

g_iMaxSpawnAmount = GetConVarInt(g_hMaxSpawnAmount);

GetConVarString(g_hChatTag, g_cChatTag, sizeof(g_cChatTag));

GetConVarString(g_hItemName, g_cItemName, sizeof(g_cItemName));

g_inSpawnAmount = GetConVarInt(g_hnSpawnAmount);

g_ipSpawnDelay = GetConVarInt(g_hpSpawnDelay);

g_fModelScale = GetConVarFloat(g_hModelScale);

g_fZAxisOffset = GetConVarFloat(g_hZAxisOffset);

g_bEnableAntiAbuse = GetConVarBool(g_hEnableAntiAbuse);

g_iAntiExploidSpawnAmount = g_inSpawnAmount;

GetConVarString(g_hUseMySQL, g_cUseMySQL, sizeof(g_cUseMySQL));

if (!StrEqual(g_cUseMySQL, "")) {

char error[256];

g_DB = SQL_Connect(g_cUseMySQL, true, error, sizeof(error));

SQL_SetCharset(g_DB, "utf8");

char createTableQuery[2048];

Format(createTableQuery, sizeof(createTableQuery), "CREATE TABLE IF NOT EXISTS eventItems_stats ( Id BIGINT NOT NULL AUTO_INCREMENT , playername VARCHAR(64) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL , playerid VARCHAR(20) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL , amount INT NOT NULL , PRIMARY KEY (Id), UNIQUE KEY playerid (playerid)) ENGINE = InnoDB CHARSET=utf8 COLLATE utf8_bin;");

SQL_TQuery(g_DB, SQLErrorCheckCallback, createTableQuery);

g_bMySQLEnabled = true;

}

if (!StrEqual(g_cPickupSoundPath, ""))

PrecacheSoundAny(g_cPickupSoundPath, true);

if (g_iSpawnMode == 4)

for (int i = 0; i < g_inSpawnAmount; i++)

g_iRespawnDelays[i] = 0;

if (g_bMySQLEnabled) {

char retrieveStatsCommandString[64];

Format(retrieveStatsCommandString, sizeof(retrieveStatsCommandString), "sm_%ss", g_cItemName);

if (!CommandExists(retrieveStatsCommandString))

RegConsoleCmd(retrieveStatsCommandString, retrieveStatsCommand, "Shows the amount of Event Items you have collected");

char topListCommand[64];

Format(topListCommand, sizeof(topListCommand), "sm_%stop", g_cItemName);

if (!CommandExists(topListCommand))

RegConsoleCmd(topListCommand, getTopCollectors, "Lists the best collectors on the Server");

}

char amountCommand[64];

Format(amountCommand, sizeof(amountCommand), "sm_%samount", g_cItemName);

if (!CommandExists(amountCommand))

RegConsoleCmd(amountCommand, getItemAmount, "returns the amount of active Items");

}

public Action retrieveStatsCommand(int client, int args) {

if (g_bMySQLEnabled) {

char playerid[20];

GetClientAuthId(client, AuthId_Steam2, playerid, sizeof(playerid));

char fetchStatsQuery[256];

Format(fetchStatsQuery, sizeof(fetchStatsQuery), "SELECT amount FROM eventItems_stats WHERE playerid = '%s';", playerid);

SQL_TQuery(g_DB, fetchStatsQueryCallback, fetchStatsQuery, client);

}

return Plugin_Handled;

}

public Action getItemAmount(int client, int args) {

int activeItems = 0;

for (int i = 0; i < g_iLoadedItem; i++)

if (g_eItemSpawnPoints[i][gIsActive])

activeItems++;

CPrintToChat(client, "%t", "showActiveItems", g_cChatTag, activeItems, g_cItemName);

return Plugin_Handled;

}

public void fetchStatsQueryCallback(Handle owner, Handle hndl, const char[] error, any client) {

int amount;

while (SQL_FetchRow(hndl)) {

amount = SQL_FetchIntByName(hndl, "amount");

}

CPrintToChat(client, "%t", "showPickupAmount", g_cChatTag, amount, g_cItemName);

}

public void incrementCollectedAmount(int client) {

addToCollectedAmount(client, 1);

}

public void addToCollectedAmount(int client, int amount) {

if (g_bMySQLEnabled) {

char playerid[20];

GetClientAuthId(client, AuthId_Steam2, playerid, sizeof(playerid));

char playername[MAX_NAME_LENGTH + 8];

GetClientName(client, playername, sizeof(playername));

char clean_playername[MAX_NAME_LENGTH * 2 + 16];

SQL_EscapeString(g_DB, playername, clean_playername, sizeof(clean_playername));

char UpdateProgressQuery[1024];

Format(UpdateProgressQuery, sizeof(UpdateProgressQuery), "UPDATE `eventItems_stats` SET `amount` = amount + %i, `playername` = '%s' WHERE `eventItems_stats`.`playerid` = '%s';", amount, clean_playername, playerid);

SQL_TQuery(g_DB, SQLErrorCheckCallback, UpdateProgressQuery);

}

}

public void OnMapStart() {

forceReload();

CreateTimer(1.0, refreshTimer, _, TIMER_REPEAT | TIMER_FLAG_NO_MAPCHANGE);

}

public Action refreshTimer(Handle Timer) {

if (g_iSpawnMode == 4) {

for (int i = 0; i < g_iAntiExploidSpawnAmount; i++) {

if (g_iRespawnDelays[i] > 1) {

g_iRespawnDelays[i]--;

} else if (g_iRespawnDelays[i] == 1) {

g_iRespawnDelays[i]--;

spawnItemOnRandomSlot();

}

}

}

}

public void forceReload() {

char Path[512];

BuildPath(Path_SM, Path, sizeof(Path), "configs/event_Item");

if (!DirExists(Path))

CreateDirectory(Path, 0777);

for (int i = 0; i < MAX_Item; i++) {

g_eItemSpawnPoints[g_iLoadedItem][gXPos] = -1.0;

g_eItemSpawnPoints[g_iLoadedItem][gYPos] = -1.0;

g_eItemSpawnPoints[g_iLoadedItem][gZPos] = -1.0;

g_eItemSpawnPoints[g_iLoadedItem][gIsActive] = false;

}

g_iLoadedItem = 0;

g_iBlueGlow = PrecacheModel("sprites/blueglow1.vmt");

loadItemSpawnPoints();

}

public void spawnItem(int id) {

int eventEnt = CreateEntityByName("prop_dynamic_override");

if (eventEnt == -1)

return;

char modelPath[128];

Format(modelPath, sizeof(modelPath), g_cItemPath);

SetEntityModel(eventEnt, modelPath);

//DispatchKeyValue(eventEnt, "Solid", "6");

//SetEntProp(eventEnt, Prop_Send, "m_nSolidType", 6);

//SetEntProp(eventEnt, Prop_Data, "m_CollisionGroup", COLLISION_GROUP_PUSHAWAY);

char cId[8];

IntToString(id, cId, sizeof(cId));

SetEntPropString(eventEnt, Prop_Data, "m_iName", cId);

SetEntPropFloat(eventEnt, Prop_Send, "m_flModelScale", g_fModelScale);

DispatchSpawn(eventEnt);

float pos[3];

pos[0] = g_eItemSpawnPoints[id][gXPos];

pos[1] = g_eItemSpawnPoints[id][gYPos];

pos[2] = g_eItemSpawnPoints[id][gZPos];

pos[2] += g_fZAxisOffset;

TeleportEntity(eventEnt, pos, NULL_VECTOR, NULL_VECTOR);

Entity_SetGlobalName(eventEnt, "EventItem");

pos[2] -= g_fZAxisOffset;

GiveEntityAura(eventEnt, g_cAuraPath, pos);

int m_iRotator = CreateEntityByName("func_rotating");

DispatchKeyValueVector(m_iRotator, "origen", pos);

DispatchKeyValue(m_iRotator, "targetname", "Item");

DispatchKeyValue(m_iRotator, "maxspeed", "200");

DispatchKeyValue(m_iRotator, "friction", "0");

DispatchKeyValue(m_iRotator, "dmg", "0");

DispatchKeyValue(m_iRotator, "solid", "0");

DispatchKeyValue(m_iRotator, "spawnflags", "64");

DispatchSpawn(m_iRotator);

SetVariantString("!activator");

AcceptEntityInput(eventEnt, "SetParent", m_iRotator, m_iRotator);

AcceptEntityInput(m_iRotator, "Start");

SetEntPropEnt(eventEnt, Prop_Send, "m_hEffectEntity", m_iRotator);

HookSingleEntityOutput(eventEnt, "OnStartTouch", EntOut_OnStartTouch);

createTrigger(pos, cId);

g_eItemSpawnPoints[id][gItemRef] = EntIndexToEntRef(eventEnt);

g_eItemSpawnPoints[id][gIsActive] = true;

g_iActiveItem++;

}

public void EntOut_OnStartTouch(const char[] output, int caller, int activator, float delay)

{

if (activator < 1 || activator > MaxClients || !IsClientInGame(activator) || !IsPlayerAlive(activator))

return;

char cItemId[255];

GetEntPropString(caller, Prop_Data, "m_iName", cItemId, sizeof(cItemId));

int ItemId = StringToInt(cItemId);

if (ItemId == -1)

return;

AcceptEntityInput(caller, "kill");

g_eItemSpawnPoints[ItemId][gIsActive] = false;

AcceptEntityInput(EntRefToEntIndex(g_eItemSpawnPoints[ItemId][gItemRef]), "kill");

g_iActiveItem--;

Store_SetClientCredits(activator, Store_GetClientCredits(activator) + g_iPickupCredits);

incrementCollectedAmount(activator);

if (g_iSpawnMode == 4) {

for (int i = 0; i < g_iAntiExploidSpawnAmount; i++) {

if (g_iRespawnDelays[i] < 1) {

g_iRespawnDelays[i] = g_ipSpawnDelay;

break;

}

}

}

float pos[3];

GetClientAbsOrigin(activator, pos);

if (!StrEqual(g_cPickupSoundPath, "")) {

if (g_iSoundMode == 1)

EmitSoundToClientAny(activator, g_cPickupSoundPath, activator, SNDCHAN_STATIC, _, _, 1.0, SNDPITCH_NORMAL);

else if (g_iSoundMode == 2)

EmitAmbientSoundAny(g_cPickupSoundPath, pos, _, _, _, _, _, _);

else

EmitSoundToAllAny(g_cPickupSoundPath, activator, SNDCHAN_STATIC, _, _, 1.0, SNDPITCH_NORMAL);

}

CPrintToChat(activator, "%t", "onCoinPickup", g_cChatTag, g_cItemName, g_iPickupCredits);

triggerEffect(pos, g_cPickupEffectPath, 2.5);

Call_StartForward(g_hOnItemPickupBasic);

Call_PushCell(activator);

Call_PushFloat(g_eItemSpawnPoints[ItemId][gXPos]);

Call_PushFloat(g_eItemSpawnPoints[ItemId][gYPos]);

Call_PushFloat(g_eItemSpawnPoints[ItemId][gZPos]);

Call_Finish();

Call_StartForward(g_hOnItemPickupAdvanced);

Call_PushCell(activator);

Call_PushFloat(g_eItemSpawnPoints[ItemId][gXPos]);

Call_PushFloat(g_eItemSpawnPoints[ItemId][gYPos]);

Call_PushFloat(g_eItemSpawnPoints[ItemId][gZPos]);

Call_PushCell(g_iPickupCredits);

Call_PushString(g_cItemPath);

Call_PushString(g_cAuraPath);

Call_PushString(g_cPickupEffectPath);

Call_PushString(g_cPickupSoundPath);

Call_PushString(g_cItemName);

Call_Finish();

}

public void onRoundStart(Handle event, const char[] name, bool dontBroadcast) {

if (g_iLoadedItem == 0)

return;

randomNumbers = CreateArray(g_iLoadedItem, g_iLoadedItem);

ClearArray(randomNumbers);

for (int i = 0; i < g_iLoadedItem; i++) {

PushArrayCell(randomNumbers, i);

}

for (int i = 0; i < MAX_Item; i++) {

int index1 = GetRandomInt(0, (g_iLoadedItem - 1));

int index2 = GetRandomInt(0, (g_iLoadedItem - 1));

SwapArrayItems(randomNumbers, index1, index2);

}

if (g_iSpawnMode != 4) {

for (int i = 0; i < MAX_Item; i++) {

g_eItemSpawnPoints[i][gIsActive] = false;

}

} else {

if (g_bEnableAntiAbuse) {

if (g_inSpawnAmount > GetRealClientCount())

g_iAntiExploidSpawnAmount = GetRealClientCount();

else

g_iAntiExploidSpawnAmount = g_inSpawnAmount;

} else

g_iAntiExploidSpawnAmount = g_inSpawnAmount;

for (int n = 0; n < g_iLoadedItem; n++)

if (g_eItemSpawnPoints[n][gIsActive])

spawnItem(n);

int activeTimers = 0;

for (int i = 0; i < g_iAntiExploidSpawnAmount; i++)

if (g_iRespawnDelays[i] > 0)

activeTimers++;

int activeItems = 0;

for (int i = 0; i < g_iLoadedItem; i++)

if (g_eItemSpawnPoints[i][gIsActive])

activeItems++;

if (activeTimers + activeItems < g_iAntiExploidSpawnAmount) {

int toSpawn = g_iAntiExploidSpawnAmount - (activeTimers + activeItems);

for (int i = 0; i < toSpawn; i++)

spawnItemOnRandomSlot();

}

}

/*r*/

if (g_iSpawnMode != 1 && g_iSpawnMode != 2 && g_iSpawnMode != 3)

return;

int spawns = 0;

if (g_iSpawnMode == 1)

spawns = GetRealClientCount() * g_iSpawnAmount;

else if (g_iSpawnMode == 2)

spawns = 10 * g_iSpawnAmount;

else

spawns = GetRandomInt(g_iMinSpawnAmount, g_iMaxSpawnAmount);

if (spawns > g_iLoadedItem)

spawns = g_iLoadedItem;

for (int i = 0; i < spawns; i++) {

spawnItemOnRandomSlot();

}

CPrintToChatAll("%t", "coinSpawnOnRoundStart", g_cChatTag, spawns, g_cItemName);

}

public int spawnItemOnRandomSlot() {

if (GetArraySize(randomNumbers) == 0)

return -1;

int spawnId = GetArrayCell(randomNumbers, 0);

RemoveFromArray(randomNumbers, 0);

spawnItem(spawnId);

return spawnId;

}

public void loadItemSpawnPoints()

{

char sRawMap[PLATFORM_MAX_PATH];

char sMap[64];

GetCurrentMap(sRawMap, sizeof(sRawMap));

RemoveMapPath(sRawMap, sMap, sizeof(sMap));

char sPath[PLATFORM_MAX_PATH];

BuildPath(Path_SM, sPath, sizeof(sPath), "configs/event_Item/%s.txt", sMap);

Handle hFile = OpenFile(sPath, "r");

char sBuffer[512];

char sDatas[3][32];

if (hFile != INVALID_HANDLE)

{

while (ReadFileLine(hFile, sBuffer, sizeof(sBuffer)))

{

ExplodeString(sBuffer, ";", sDatas, 3, 32);

g_eItemSpawnPoints[g_iLoadedItem][gXPos] = StringToFloat(sDatas[0]);

g_eItemSpawnPoints[g_iLoadedItem][gYPos] = StringToFloat(sDatas[1]);

g_eItemSpawnPoints[g_iLoadedItem][gZPos] = StringToFloat(sDatas[2]);

g_iLoadedItem++;

}

CloseHandle(hFile);

}

PrintToServer("Loaded %i Item Spawn Points", g_iLoadedItem);

}

public void saveItemSpawnPoints()

{

char sRawMap[PLATFORM_MAX_PATH];

char sMap[64];

GetCurrentMap(sRawMap, sizeof(sRawMap));

RemoveMapPath(sRawMap, sMap, sizeof(sMap));

CreateDirectory("configs/event_Item", 511);

char sPath[PLATFORM_MAX_PATH];

BuildPath(Path_SM, sPath, sizeof(sPath), "configs/event_Item/%s.txt", sMap);

Handle hFile = OpenFile(sPath, "w");

if (hFile != INVALID_HANDLE)

{

for (int i = 0; i < g_iLoadedItem; i++) {

WriteFileLine(hFile, "%.2f;%.2f;%.2f;", g_eItemSpawnPoints[i][gXPos], g_eItemSpawnPoints[i][gYPos], g_eItemSpawnPoints[i][gZPos]);

}

CloseHandle(hFile);

}

if (!FileExists(sPath))

LogError("Couldn't save item spawns to file: \"%s\".", sPath);

}

public void AddLootSpawn(int client, bool vision)

{

float pos[3];

if (vision) {

float ang[3];

GetClientEyePosition(client, pos);

GetClientEyeAngles(client, ang);

TR_TraceRayFilter(pos, ang, MASK_PLAYERSOLID, RayType_Infinite, TraceRayDontHitSelf, client);

TR_GetEndPosition(pos);

} else

GetClientAbsOrigin(client, pos);

TE_SetupGlowSprite(pos, g_iBlueGlow, 10.0, 1.0, 235);

TE_SendToAll();

g_eItemSpawnPoints[g_iLoadedItem][gXPos] = pos[0];

g_eItemSpawnPoints[g_iLoadedItem][gYPos] = pos[1];

g_eItemSpawnPoints[g_iLoadedItem][gZPos] = pos[2];

g_iLoadedItem++;

PrintToChat(client, "Added new spawnpoint at |<%.2f>:<%.2f>:<%.2f>| for type: %s", pos[0], pos[1], pos[2], g_cItemName);

saveItemSpawnPoints();

}

public Action addSpawnPoints(int client, int args) {

addSpawnPointsMenu(client, args);

return Plugin_Handled;

}

public Action addSpawnPointsMenu(int client, int args)

{

char ItemText[64];

char ItemAim[64];

Format(ItemText, sizeof(ItemText), "Spawn: %s (%i)", g_cItemName, g_iLoadedItem);

Format(ItemAim, sizeof(ItemAim), "Spawn: %s (%i) [AIM]", g_cItemName, g_iLoadedItem);

Handle panel = CreatePanel();

SetPanelTitle(panel, "Add a Spawnpoint");

DrawPanelText(panel, "x-x-x-x-x-x-x-x-x-x");

DrawPanelItem(panel, ItemText);

DrawPanelItem(panel, ItemAim);

DrawPanelItem(panel, "Delete latest Spawnpoint");

DrawPanelText(panel, "-------------");

DrawPanelItem(panel, "Show Spawns");

DrawPanelItem(panel, "Close");

DrawPanelText(panel, "x-x-x-x-x-x-x-x-x-x");

SendPanelToClient(panel, client, addSpawnPointsMenuHandler, 30);

CloseHandle(panel);

return Plugin_Handled;

}

public int addSpawnPointsMenuHandler(Handle menu, MenuAction action, int client, int item)

{

if (action == MenuAction_Select)

{

if (item == 1) {

AddLootSpawn(client, false);

addSpawnPointsMenu(client, 0);

} else if (item == 2) {

AddLootSpawn(client, true);

addSpawnPointsMenu(client, 0);

} else if (item == 3) {

deleteLatestSpawn(client);

addSpawnPointsMenu(client, 0);

} else if (item == 4) {

ShowSpawns();

addSpawnPointsMenu(client, 0);

}

}

}

public void deleteLatestSpawn(int client) {

g_iLoadedItem--;

PrintToChat(client, "Deleted latest Spawn (%i left).", g_iLoadedItem);

saveItemSpawnPoints();

}

public void ShowSpawns() {

for (int i = 0; i < g_iLoadedItem; i++) {

float pos[3];

pos[0] = g_eItemSpawnPoints[i][gXPos];

pos[1] = g_eItemSpawnPoints[i][gYPos];

pos[2] = g_eItemSpawnPoints[i][gZPos];

TE_SetupGlowSprite(pos, g_iBlueGlow, 10.0, 1.0, 235);

TE_SendToAll();

}

}

public int getActiveItem() {

int count = 0;

for (int i = 0; i < g_iLoadedItem; i++) {

if (g_eItemSpawnPoints[i][gIsActive])

count++;

}

return count;

}

stock void GiveEntityAura(any ent, char aura[255], float position[3])

{

if (StrEqual(aura, ""))

return;

int AuraEntity = CreateEntityByName("info_particle_system");

DispatchKeyValue(AuraEntity, "start_active", "0");

DispatchKeyValue(AuraEntity, "effect_name", aura);

DispatchSpawn(AuraEntity);

TeleportEntity(AuraEntity, position, NULL_VECTOR, NULL_VECTOR);

ActivateEntity(AuraEntity);

SetVariantString("!activator");

AcceptEntityInput(AuraEntity, "SetParent", ent, AuraEntity, 0);

CreateTimer(0.25, Timer_Run, AuraEntity);

}

stock void triggerEffect(float pos[3], char effect[255], float duration) {

if (StrEqual(effect, ""))

return;

int spawnEffect = CreateEntityByName("info_particle_system");

DispatchKeyValue(spawnEffect, "start_active", "0");

DispatchKeyValue(spawnEffect, "effect_name", effect);

DispatchSpawn(spawnEffect);

ActivateEntity(spawnEffect);

TeleportEntity(spawnEffect, pos, NULL_VECTOR, NULL_VECTOR);

AcceptEntityInput(spawnEffect, "Start");

CreateTimer(duration, clearEffect, EntIndexToEntRef(spawnEffect));

}

public Action clearEffect(Handle Timer, any ent) {

int iEnt = EntRefToEntIndex(ent);

if (IsValidEdict(iEnt))

if (IsValidEntity(iEnt))

AcceptEntityInput(iEnt, "kill");

}

public Action Timer_Run(Handle Timer, any ent)

{

if (ent > 0 && IsValidEntity(ent))

{

AcceptEntityInput(ent, "Start");

}

}

stock int GetRealClientCount() {

int total = 0;

for (int i = 1; i <= MaxClients; i++) {

if (IsClientConnected(i) && !IsFakeClient(i)) {

total++;

}

}

return total;

}

public int createTrigger(float pos[3], char sItemName[8])

{

float fMiddle[3];

int iEnt = CreateEntityByName("trigger_multiple");

DispatchKeyValue(iEnt, "spawnflags", "64");

Format(sItemName, sizeof(sItemName), "%s", sItemName);

DispatchKeyValue(iEnt, "targetname", sItemName);

DispatchKeyValue(iEnt, "wait", "0");

DispatchSpawn(iEnt);

ActivateEntity(iEnt);

SetEntProp(iEnt, Prop_Data, "m_spawnflags", 64);

TeleportEntity(iEnt, pos, NULL_VECTOR, NULL_VECTOR);

SetEntityModel(iEnt, g_cItemPath);

float fMins[3];

float fMaxs[3];

fMins[0] = 30.0;

fMins[1] = 30.0;

fMins[2] = 30.0;

fMaxs[0] = 30.0;

fMaxs[1] = 30.0;

fMaxs[2] = 30.0;

// Have the mins always be negative

fMins[0] = fMins[0] - fMiddle[0];

if (fMins[0] > 0.0)

fMins[0] *= -1.0;

fMins[1] = fMins[1] - fMiddle[1];

if (fMins[1] > 0.0)

fMins[1] *= -1.0;

fMins[2] = fMins[2] - fMiddle[2];

if (fMins[2] > 0.0)

fMins[2] *= -1.0;

// And the maxs always be positive

fMaxs[0] = fMaxs[0] - fMiddle[0];

if (fMaxs[0] < 0.0)

fMaxs[0] *= -1.0;

fMaxs[1] = fMaxs[1] - fMiddle[1];

if (fMaxs[1] < 0.0)

fMaxs[1] *= -1.0;

fMaxs[2] = fMaxs[2] - fMiddle[2];

if (fMaxs[2] < 0.0)

fMaxs[2] *= -1.0;

SetEntPropVector(iEnt, Prop_Send, "m_vecMins", fMins);

SetEntPropVector(iEnt, Prop_Send, "m_vecMaxs", fMaxs);

SetEntProp(iEnt, Prop_Send, "m_nSolidType", 2);

int iEffects = GetEntProp(iEnt, Prop_Send, "m_fEffects");

iEffects |= 32;

SetEntProp(iEnt, Prop_Send, "m_fEffects", iEffects);

HookSingleEntityOutput(iEnt, "OnStartTouch", EntOut_OnStartTouch);

}

public bool TraceRayDontHitSelf(int entity, int mask, any data) {

if (entity == data)

return false;

return true;

}

public void SQLErrorCheckCallback(Handle owner, Handle hndl, const char[] error, any data) {

if (!StrEqual(error, ""))

LogError(error);

}

public Action getTopCollectors(int client, int args) {

if (g_DB != INVALID_HANDLE) {

char topCollectorsQuery[512];

Format(topCollectorsQuery, sizeof(topCollectorsQuery), "SELECT playername,amount FROM eventItems_stats ORDER BY amount DESC LIMIT 10;");

SQL_TQuery(g_DB, getTopCollectorsCallback, topCollectorsQuery, GetClientUserId(client));

}

return Plugin_Handled;

}

public void getTopCollectorsCallback(Handle owner, Handle hndl, const char[] error, any userid)

{

int client = GetClientOfUserId(userid);

if (hndl != INVALID_HANDLE) {

if (isValidClient(client)) {

Handle CreditsTopMenu = CreatePanel();

int index = 0;

char top_text[128];

Format(top_text, sizeof(top_text), "%T", "topMenuTitle", client, g_cItemName);

SetPanelTitle(CreditsTopMenu, top_text);

DrawPanelText(CreditsTopMenu, "^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^");

while (SQL_FetchRow(hndl)) {

char name[MAX_NAME_LENGTH + 1];

int top_points;

SQL_FetchString(hndl, 0, name, sizeof(name));

top_points = SQL_FetchInt(hndl, 1);

Format(top_text, sizeof(top_text), "%i. %s - %i %s(s)", ++index, name, top_points, g_cItemName);

DrawPanelText(CreditsTopMenu, top_text);

}

if (!index) {

return;

} else {

DrawPanelText(CreditsTopMenu, "^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^-.-^");

Format(top_text, sizeof(top_text), "Close");

DrawPanelItem(CreditsTopMenu, top_text);

}

SendPanelToClient(CreditsTopMenu, client, globalPanelHandler, 60);

}

} else {

LogError("SQL Error: %s", error);

}

}

public int globalPanelHandler(Handle menu, MenuAction action, int param1, int param2) {

if (action == MenuAction_End) {

CloseHandle(menu);

}

}

public bool isValidClient(int client) {

if (!(1 <= client <= MaxClients) || !IsClientInGame(client))

return false;

return true;

}

public Action getLoadedMaps(int client, int args)

{

char sPath[PLATFORM_MAX_PATH];

BuildPath(Path_SM, sPath, sizeof(sPath), "../../mapcycle.txt");

Handle hFile = OpenFile(sPath, "r");

char sBuffer[512];

char mBuffer[256][48];

int count = 0;

if (hFile != INVALID_HANDLE) {

while (ReadFileLine(hFile, sBuffer, sizeof(sBuffer))) {

Format(mBuffer[count], sizeof(mBuffer), sBuffer);

count++;

}

CloseHandle(hFile);

}

int fileCounter = 0;

char fileBuffer[512][48];

char Path[512];

BuildPath(Path_SM, Path, sizeof(Path), "configs/event_Item");

if (!DirExists(Path))

return Plugin_Handled;

DirectoryListing dL = OpenDirectory(Path);

while (dL.GetNext(fileBuffer[fileCounter], sizeof(fileBuffer))) {

ReplaceString(fileBuffer[fileCounter++], sizeof(fileBuffer), ".txt", "", false);

}

int notFoundCounter = 0;

char notFound[256][48];

for (int i = 0; i < count; i++) {

for (int n = 0; n < fileCounter; n++) {

if (StrEqual(fileBuffer[n], mBuffer[i]) && !StrEqual(fileBuffer[n], ""))

break;

if (n == (fileCounter - 1))

strcopy(notFound[notFoundCounter++], sizeof(notFound), mBuffer[i]);

}

}

CPrintToChat(client, "{green}Look in your console.");

PrintToConsole(client, "Maps without SpawnPoints:");

for (int i = 0; i < (notFoundCounter - 1); i++)

PrintToConsole(client, "%s", notFound[i]);

delete dL;

return Plugin_Handled;

}