	ГЛАВНАЯ	УСЛУГИ	ПЛАГИНЫ	КАРТЫ	REBUY	SCANMON	CASSA	SALE	ФОРУМ	МОНИТОР	HELP	КОНТАКТ

HEALTH/ARMOR-STATIONS

Теги: Скачать плагины csСерверные

Полезный плагин для CSMD серверов bully

Cvar"s-команды:
~HA_maxhealth - Сколько здоровья находится в станции здоровья для каждого [число HP] (0-100) (по умолчанию: 40 HP)
~HA_maxplayerhealth - Сколько максимальное здоровья игрок может зарядить за 1раз использования [100 - 255] (по условию: 255 HP)
~HA_healthpersec - скорость зарядки здоровья [1-?] (по условию: 4 HP (1.6 в сек))
~HA_maxarmor -Сколько брони находится в ArmorStation для каждого [число AP] (0-100) (по умолчанию: 40 AP)
~HA_maxplayerarmor - Набор максимальное количество брони игрок может зарядить(за несколько раз) [100 - 255] (по условию: 255 AP)
~HA_armorpersec -Установите количество AP, которое игрок получает [1-?] (по умолчанию: 4 AP должны быть 8-12 AP в секунду),
~HA_healthreloadtime - Как долго игрок должен ждать, пока он не может использовать ту же станцию снова(перезарядка станции) [число в секундах] (по умолчанию: 30 секунд)
~HA_armorreloadtime - Как долго игрок должен ждать, перезарядку брони в станции [число в секундах] (по условию: 30 секунд)
~HA_gloweffect - станция здоровья находиться в красной сфере,а брони в синей оболочке [0|1] (on|off) (по умолчанию: 1)-смотреть скрин

Компилятор: 1.8.2 +ZIP 1125

Команды:

"+place_station" - поставить аптечку(нужно удерживать)

"push_station" - втавить в стену (чтобы "торчала" только панель)

"pull_station" - "выдвинуть" из стены("чтоб из стены торчал/был выдвинут на стену"Wink

"del_station" - удалить ранее установленный раздатчик

.sma / .sp

/**********************************************************************************
* 									Health/Armor-Stations
*
*
* Author: regalis (regalis1@gmx.de)
*
*
*	Version: 0.3.5
*
*
*
*	Description:
*		Do you know HalfLife Deathmatch?
*		There are Stations to recharge your Health and you Armor.
*		Now you can have these Station in Counterstrike too!
*		Place the Stations you want where you want ;)
*
*		To place a Station make sure you are an admin and bind a key to "+place_station".
*		Now press the key and aim at where you want to place the station, release the key to choose which sort of station you want to place.
*		With the commands "push_station" and "pull_station" you can pull or push the station in the direction you are looking.
*		If you have choosen the station which fits your needs you can save it to the config-file which is automaticaly created for each map.
*		That all...
*		To use these Stations just stand near it and press your USE-key (standard: E)
*		The reloading of the Station is triggered as soon as the Station gets empty!
*
*
*
*
*	Admin-Commands:
*		"+place_station" - Place an Health/Armor-Station on the wall in front of you
*		"push_station" - Move the Health/Armor-Station away of you
*		"pull_station" - Move the Health/Armor-Station closer to you
*		"del_station" - Delete the Healt/Armor-Station at which you aim
*
*
*
* CVARS:
*		HA_maxhealth - How much health is in a HealthStation for everyone [number of HP](0-100) (Default: 40 HP)
*		HA_maxplayerhealth - Set the maximum amount of health a player can charge [100 - 255] (Default: 255 HP)
*		HA_healthpersec - Set the amount of HP a player get per chargecycle [1 - ?] (Default: 4 HP should be 8-12 HP per second) 
*		HA_maxarmor - How much armor is in a ArmorStation for everyone [number of AP]	(0-100)	(Default: 40 AP)
*		HA_maxplayerarmor - Set the maximum amount of armor a player can charge [100 - 255] (Default: 255 AP)
*		HA_armorpersec - Set the amount of AP a player get per chargecycle [1 - ?] (Default: 4 AP should be 8-12 AP per second)
*		HA_healthreloadtime - How long the player have to wait till he can use the same HealthStation again [number in seconds](Default: 30 sec)
*		HA_armorreloadtime - How long the player have to wait till he can use the same ArmorStation again [number in seconds]	(Default: 30 sec)
*		HA_gloweffect - Let the HealthStations glow red and the ArmorStations glow blue [0|1]	(on|off) (Default: 1)
*		
*
*
*	Requirements:
*		Fakemeta-Modul
*
*
*
*	Changelog:
*		v0.1:
*			@ initial release
*
*		v0.2:
*			! Fixed a sound bug
*			+ Added support for newly placed station giving HP/AP
*			+ Added 4 new CVARS for more customization
*
*		v0.3:
*			- Removed static declaration for global Variables
*			- Removed "stock" for functions
*			+ Added a function to delete placed stations
*			+ Added real armor to the stations (only for Counterstrike)
*		
*		v0.3.1:
*			! fixed a bug with realarmor(it is only for CounterStrike)
*
*		v0.3.5:
*			!fixed a bug when you placed a station at the sky/ceiling the server crashed...now it is handled
*
*
* Known Bugs:
*		- At some placing angles the station looks black
*			(Workaround: Just place it from another angle)
*
*
*	TODO:
*		- maybe optimizing a little
*
*
*	Credits:
*		stupok69 for his nice In-Game-Ads where i have taken the Station placing (http://forums.alliedmods.net/showthread.php?p=424583)
*		Cheap_suit for his help here: (http://forums.alliedmods.net/showpost.php?p=482976&postcount=4)
*		Alka for the help on fixing the bug with the "placing at the sky/ceiling"
*		Simon Logic for his idea with Armour-Absence-Fix Plugin here: (http://forums.alliedmods.net/showthread.php?t=55591)
*		VEN for his fakemeta_util.inc here: (http://forums.alliedmods.net/showthread.php?t=28284)
*		PM for his xs.inc
*
*
***********************************************************************************/
#include <amxmodx>
#include <amxmisc>
#include <fakemeta>

//++++++++++++++++++++
//+++++ DEFINES ++++++
//++++++++++++++++++++
// Define the offset for the Armor manipulation stock
#if cellbits == 32
	#define OFFSET_ARMORTYPE 112
#else
	#define OFFSET_ARMORTYPE 137
#endif
#define OFFSET_LINUX 5

#define CONFIGFOLDER "HA-Stations"
#define PLACESTEPFREQUENCY 10
#define DISTANCE 3.0
#define ADMIN_ACCESS_LEVEL ADMIN_BAN
#define MAXPLAYERS 32
#define MAXMEDKITS 15
#define MAXRECHARGES 15
#define MEDKITCLASS "ha_medkit"
#define RECHARGECLASS "ha_recharge"
#define SND_STOP (1<<5)

// Define the Author :P 
#define PLUGIN "Healt&Armor-Stations"
#define VERSION "0.3.5"
#define AUTHOR "regalis"

//+++++++++++++++++++++++++++++
//+++++ GLOBAL VARIABLES ++++++
//+++++++++++++++++++++++++++++
// The models
new const g_models[][] =
{
	"models/HealthArmor-Stations/HealthStation.mdl",
	"models/HealthArmor-Stations/ArmorStation.mdl"
}
new const gModelIndex = sizeof g_models;

// The Glow colors
new const Float:g_colors[][3] = {
	{255.0, 0.0, 0.0},
	{0.0, 0.0, 255.0}
}

// ################## FOR FUTURE USAGE #################
//new static bool:g_restart_attempt[33];
// ################## FOR FUTURE USAGE #################

//+++++ MESSAGE IDs ++++++
new g_umsgA;
//new g_msgM;
	
	
//+++++ Adminstuff + Filehandling +++++
new g_prethink_placestepper;
new g_curmodeltype;
new g_entity;
new g_curAdjuster = -1;
new Float:g_aimOrigin[3][3];
new Float:g_entity_angles[3];
new g_file_name[256]
new g_map_name[32];
new bool:g_adjusting = false;

//+++++ Deleting +++++
new g_del_num;
new g_del_models[MAXMEDKITS+MAXRECHARGES];
new Float:g_del_origins[MAXMEDKITS+MAXRECHARGES][3];
new Float:g_del_angles[MAXMEDKITS+MAXRECHARGES][3];

//+++++ Checking the usage +++++
new Float:g_nextstep[MAXPLAYERS+1];
new Float:g_chargesteppfrequency = 0.5;
new bool:g_faraway;
new g_cvar_gloweffect;

// Medkit
new Float:g_medkit_coords[MAXMEDKITS][3];
new Float:g_medkit_angles[MAXMEDKITS][3];
new g_medkit_id[MAXMEDKITS];
new g_medkit_count;

// Recharge
new Float:g_recharge_coords[MAXRECHARGES][3];
new Float:g_recharge_angles[MAXRECHARGES][3];
new g_recharge_id[MAXRECHARGES];
new g_recharge_count;

//+++++ Healthhandling +++++
new g_medkit_value[MAXMEDKITS][MAXPLAYERS+1];
new bool:g_snd_medkit[MAXMEDKITS][MAXPLAYERS+1];
new g_cvar_maxhealth;
new g_cvar_maxplayerhealth;
new g_cvar_healthpersec
new Float:g_cvar_medkitreloadtime;
new g_pHealth[MAXPLAYERS+1];

//+++++ Armorhandling +++++
new g_recharge_value[MAXRECHARGES][MAXPLAYERS+1];
new bool:g_snd_recharge[MAXRECHARGES][MAXPLAYERS+1];
new g_cvar_maxarmor;
new g_cvar_maxplayerarmor;
new g_cvar_armorpersec;
new Float:g_cvar_rechargereloadtime;
new g_pArmor[MAXPLAYERS+1];

//+++++ GLOBAL CVAR POINTER ++++++
new gcvar_maxhealth;
new gcvar_maxplayerhealth;
new gcvar_medkitreloadtime;
new gcvar_healthpersec
new gcvar_maxarmor;
new gcvar_maxplayerarmor;
new gcvar_rechargereloadtime;
new gcvar_armorpersec;
new gcvar_gloweffect;

//++++++++++++++++++++++++
//+++++ PLUGIN-INIT ++++++
//++++++++++++++++++++++++
public plugin_init()
{
	register_plugin(PLUGIN, VERSION, AUTHOR);
	register_cvar(PLUGIN, VERSION, FCVAR_SERVER);
	
	//+++++ cvar pointer ++++++
	gcvar_maxhealth = register_cvar("HA_maxhealth", "40");
	gcvar_maxplayerhealth = register_cvar("HA_maxplayerhealth", "255");
	gcvar_healthpersec = register_cvar("HA_healthpersec", "4")
	gcvar_maxarmor = register_cvar("HA_maxarmor", "40");
	gcvar_maxplayerarmor = register_cvar("HA_maxplayerarmor", "255");
	gcvar_armorpersec = register_cvar("HA_armorpersec", "4");
	gcvar_medkitreloadtime = register_cvar("HA_healthreloadtime", "30");
	gcvar_rechargereloadtime = register_cvar("HA_armorreloadtime", "30");
	gcvar_gloweffect = register_cvar("HA_gloweffect", "1");
	
	//+++++ Admin Commands +++++
	register_clcmd("+place_station", "cmd_place_station", ADMIN_ACCESS_LEVEL);
	register_clcmd("-place_station", "cmd_place_station", ADMIN_ACCESS_LEVEL);
	register_clcmd("pull_station", "pull_station", ADMIN_ACCESS_LEVEL);
	register_clcmd("push_station", "push_station", ADMIN_ACCESS_LEVEL);
	register_clcmd("del_station", "del_station", ADMIN_ACCESS_LEVEL);
	
	//+++++ Menu Commands +++++
	register_menucmd(register_menuid("save_menu"), (1<<0)|(1<<1), "action_save");
	register_menucmd(register_menuid("select_menu"), 1023, "action_select");
	
	//################## FOR FUTURE USAGE #################
	/*
	//+++++ Client Commands ++++++
	register_clcmd("fullupdate", "clcmd_fullupdate");
	//+++++ Events ++++++
	register_event("ResetHUD", "event_hud_reset", "be");
	register_event("TextMsg", "event_restart_attempt", "a", "2=#Game_will_restart_in");
	*/
	//################## FOR FUTURE USAGE #################
	
	//+++++ Message ID +++++
	g_umsgA = get_user_msgid("ArmorType");
	//g_umsgM = get_user_msgid("Money");
	
	//+++++ Logevents ++++++
	register_logevent("event_roundStart", 2, "1=Round_Start");
	register_logevent("event_round_end", 2, "1=Round_End");
	
	//+++++ Forwards +++++
	register_forward(FM_PlayerPreThink, "PreThink");
	
	//+++++ Read the Config +++++
	readCvars();
	
	//+++++ Load the saved Stations +++++
	load_saved_stations(g_file_name);
}

//++++++++++++++++++++++++++++
//+++++ PLUGIN-PRECACHE ++++++
//++++++++++++++++++++++++++++
public plugin_precache()
{
	new configs_dir[64];
	get_configsdir(configs_dir, 63);
	get_mapname(g_map_name, 31);
	
	// Save the Configfilename in a global variable
	formatex(g_file_name, 255, "%s/%s", configs_dir, CONFIGFOLDER);
	if(!dir_exists(g_file_name)) mkdir(g_file_name);
	formatex(g_file_name, 255, "%s/%s/%s.txt", configs_dir, CONFIGFOLDER, g_map_name);
	
	// Precache the models
	for(new m = 0; m < gModelIndex; m++) engfunc(EngFunc_PrecacheModel,g_models[m]);
	
	
	// Precache the sounds
	precache_sound("HealthArmor-Stations/ArmorRecharge.wav");
	precache_sound("HealthArmor-Stations/ArmorRechargeOk.wav");
	precache_sound("HealthArmor-Stations/ArmorRechargeNo.wav");
	precache_sound("HealthArmor-Stations/HealthRecharge.wav");
	precache_sound("HealthArmor-Stations/HealthRechargeOk.wav");
	precache_sound("HealthArmor-Stations/HealthRechargeNo.wav");
}

//*****************************************************************************************************************
//****************************************   G E N E R A L S T U F F   ********************************************
//*****************************************************************************************************************

//################## FOR FUTURE USAGE #################
/* 
//+++++ CLIENT COMMAND FULLUPDATE ++++++
public clcmd_fullupdate()
{
	return PLUGIN_HANDLED_MAIN;
}

//+++++ Event RESTART-ATTEMPT ++++++
public event_restart_attempt()
{
	new players[32], num;
	get_players(players, num, "a");
	for (new i; i < num; ++i)
	{
		g_restart_attempt[players[i]] = true;
	}
}

//+++++ Event HUD-RESET ++++++
public event_hud_reset(id)
{
	if (g_restart_attempt[id])
	{
		g_restart_attempt[id] = false;
		return;
	}
	event_player_spawn(id);
}

//+++++ Event PLAYERSPAWN ++++++
public event_player_spawn(id)
{
	// nothing to do...maybe later ;)
}
*/
//################## FOR FUTURE USAGE #################

//+++++ Event ROUNDSTART ++++++
public event_roundStart()
{
	readCvars();
	resetStations();
}

public event_round_end()
{
	resetStations();
}

//+++++ READ THE CVARS +++++++
readCvars()
{
	// Putting the CVARS in the global variables
	g_cvar_maxarmor = get_pcvar_num(gcvar_maxarmor);
	g_cvar_maxplayerarmor = get_pcvar_num(gcvar_maxplayerarmor);
	g_cvar_armorpersec = get_pcvar_num(gcvar_armorpersec);
	g_cvar_maxhealth = get_pcvar_num(gcvar_maxhealth);
	g_cvar_maxplayerhealth = get_pcvar_num(gcvar_maxplayerhealth);
	g_cvar_healthpersec = get_pcvar_num(gcvar_healthpersec);
	g_cvar_rechargereloadtime = get_pcvar_float(gcvar_rechargereloadtime);
	g_cvar_medkitreloadtime = get_pcvar_float(gcvar_medkitreloadtime);
	g_cvar_gloweffect = get_pcvar_num(gcvar_gloweffect);
}

//*****************************************************************************************************************
//*****************************************   S T A T I O N H A N D L I N G   *************************************
//*****************************************************************************************************************

//+++++ RESET THE STATIONS +++++++
resetStations()
{
	for (new i=0; i < 32; i++)
	{
		// Reset medkit-Stations to the cvar value
		for(new m = 0; m < g_medkit_count; m++)
		{
			if(task_exists(434774+i+m))	 remove_task(434774+i+m);
			g_medkit_value[m][i] = g_cvar_maxhealth;
			if(g_snd_medkit[m][i])
			{
				emit_sound(g_medkit_id[m], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				g_snd_medkit[m][i] = false;
			}
		}
		
		// Reset recharge-Stations to the cvar value
		for(new r = 0; r < g_recharge_count; r++)
		{
			if(task_exists(477434+i+r))	 remove_task(477434+i+r);
			g_recharge_value[r][i] = g_cvar_maxarmor;
			if(g_snd_recharge[r][i])
			{
				emit_sound(g_recharge_id[r], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				g_snd_recharge[r][i] = false;
			}
		}
	}
}

//+++++ RESET A HEALTH STATION +++++
public reset_HealthStation(param[2])
{
	// Get the params
	new id = param[0];
	new number = param[1];
	
	// Reset the value of the certain Station to the value stored in the cvar
	g_medkit_value[number][id] = g_cvar_maxhealth;
}

//+++++ RESET A ARMOR STATION +++++
public reset_ArmorStation(param[2])
{
	// Get the params
	new id = param[0];
	new number = param[1];
	
	// Reset the value of the certain Station to the value stored in the cvar
	g_recharge_value[number][id] = g_cvar_maxarmor;
}

remove_stations()
{
	new ent = -1;
	while((ent = engfunc(EngFunc_FindEntityByString, -1, "classname", MEDKITCLASS)) != 0)
	{
		if(pev_valid(ent))
		{
			engfunc(EngFunc_RemoveEntity, ent);
		}
	}
	ent = -1;
	while((ent = engfunc(EngFunc_FindEntityByString, -1, "classname", RECHARGECLASS)) != 0)
	{
		if(pev_valid(ent))
		{
			engfunc(EngFunc_RemoveEntity, ent);
		}
	}
	g_del_num = 0;
	g_medkit_count = 0;
	g_recharge_count = 0;
}

//*****************************************************************************************************************
//********************************   H E A L T H - A R M O R H A N D L I N G  *************************************
//*****************************************************************************************************************

//+++++ Give the player health +++++
GiveHealth(id, number)
{
	if(g_medkit_value[number][id] > 0)
	{
		// The HealthValue in the current station for this player is more than 0
		g_pHealth[id] = pev(id, pev_health); // Get the player health
		if(g_pHealth[id] <= g_cvar_maxplayerhealth-g_cvar_healthpersec)
		{
			g_medkit_value[number][id] -= g_cvar_healthpersec; // subtract the given Healthvalue from the Health-Station value
			set_pev(id, pev_health, float(g_pHealth[id]+g_cvar_healthpersec)); // Give the player the Health
			if(!g_snd_medkit[number][id])
			{
				emit_sound(g_medkit_id[number], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
			}
		}
		else
		{
			if(g_pHealth[id] == g_cvar_maxplayerhealth)
			{
				emit_sound(g_medkit_id[number], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				emit_sound(g_medkit_id[number], CHAN_STREAM, "HealthArmor-Stations/HealthRechargeNo.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
			}
			else
			{
				set_pev(id, pev_health, float(g_cvar_maxplayerhealth));
				emit_sound(g_medkit_id[number], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				emit_sound(id, CHAN_STREAM, "HealthArmor-Stations/HealthRechargeOk.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
			}
		}
	}
	else
	{
		emit_sound(g_medkit_id[number], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
		emit_sound(g_medkit_id[number], CHAN_STREAM, "HealthArmor-Stations/HealthRechargeNo.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
		// Health-Station is empty
		if(!task_exists(434774+id+number))
		{
			new param[2];
			param[0] = id;
			param[1] = number;
			// Plan a task to refresh the Health-Station value
			set_task(g_cvar_medkitreloadtime, "reset_HealthStation", 434774+id+number, param, 2);
		}
	}
}

//+++++ Give the player armor +++++
GiveArmor(id, number)
{
	if(g_recharge_value[number][id] > 0)
	{
		// The ArmorValue in the current station for this player is more than 0
		g_pArmor[id] = pev(id, pev_armorvalue); // Get the player armor
		if(g_pArmor[id] <= g_cvar_maxplayerarmor-g_cvar_armorpersec)
		{
			// Player have a lower ArmorValue than 100
			g_recharge_value[number][id] -= g_cvar_armorpersec;	// Subtract the given armor from the Armor-Station value
			if(!get_pdata_int(id, OFFSET_ARMORTYPE, OFFSET_LINUX)) set_realarmor(id);
			set_pev(id, pev_armorvalue, float(g_pArmor[id]+g_cvar_armorpersec)); // Give the player the Armor
			
			if(!g_snd_recharge[number][id])
			{
				emit_sound(g_recharge_id[number], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
			}
		}
		else
		{
			if(g_pArmor[id] == g_cvar_maxplayerarmor)
			{
				emit_sound(g_recharge_id[number], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				emit_sound(g_recharge_id[number], CHAN_STREAM, "HealthArmor-Stations/ArmorRechargeNo.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
			}
			else
			{
				set_pev(id, pev_armorvalue, float(g_cvar_maxplayerarmor)); // If player have between 96-100 Armor set it to 100
				emit_sound(g_recharge_id[number], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				emit_sound(id, CHAN_STREAM, "HealthArmor-Stations/ArmorRechargeOk.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
			}
		}
	}
	else
	{
		emit_sound(g_recharge_id[number], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
		emit_sound(g_recharge_id[number], CHAN_STREAM, "HealthArmor-Stations/ArmorRechargeNo.wav", 1.0, ATTN_NORM, 0, PITCH_NORM);
		// Armor-Station is empty
		if(!task_exists(477434+id+number))
		{
			new param[2];
			param[0] = id;
			param[1] = number;
			// Plan a task to refresh the Armor-Station value
			set_task(g_cvar_rechargereloadtime, "reset_ArmorStation", 477434+id+number, param, 2);
		}
	}
}

//*****************************************************************************************************************
//*****************************************   F I L E H A N D L I N G   *******************************************
//*****************************************************************************************************************

//+++++ SAVE POSITION TO FILE ++++++
public save_pos()
{
	new text[256];
	
	get_configsdir(g_file_name, 255);
	format(g_file_name, 255, "%s/%s/%s.txt", g_file_name, CONFIGFOLDER, g_map_name);
	
	pev(g_entity, pev_angles, g_entity_angles);
	formatex(text, 255, "^n%s^norigin %f %f %f^nangles %f %f %f", g_models[g_curmodeltype], g_aimOrigin[2][0], g_aimOrigin[2][1], g_aimOrigin[2][2], g_entity_angles[0], g_entity_angles[1], g_entity_angles[2]);
	write_file(g_file_name, text);
	
	if(g_curmodeltype == 0)
	{
		g_medkit_coords[g_medkit_count][0] = g_aimOrigin[2][0];
		g_medkit_coords[g_medkit_count][1] = g_aimOrigin[2][1];
		g_medkit_coords[g_medkit_count][2] = g_aimOrigin[2][2];
		g_medkit_angles[g_medkit_count][0] = g_entity_angles[0];
		g_medkit_angles[g_medkit_count][1] = g_entity_angles[1];
		g_medkit_angles[g_medkit_count][2] = g_entity_angles[2];
		g_medkit_id[g_medkit_count] = g_entity;
		g_medkit_count++;
	}
	else
	{
		g_recharge_coords[g_recharge_count][0] = g_aimOrigin[2][0];
		g_recharge_coords[g_recharge_count][1] = g_aimOrigin[2][1];
		g_recharge_coords[g_recharge_count][2] = g_aimOrigin[2][2];
		g_recharge_angles[g_recharge_count][0] = g_entity_angles[0];
		g_recharge_angles[g_recharge_count][1] = g_entity_angles[1];
		g_recharge_angles[g_recharge_count][2] = g_entity_angles[2];
		g_recharge_id[g_recharge_count] = g_entity;
		g_recharge_count++;
	}	
	g_entity = 0;
	resetStations();
}

//+++++ LOAD THE SAVED Stations ++++++
load_saved_stations(file_name[])
{
	new lastread = 0;
	new file_handle = fopen(file_name, "r");
	
	if(!file_handle) return PLUGIN_HANDLED;
		
	new file_text[64];
	new ent, str_value[3][16];
	
	while(!feof(file_handle))
	{
		fgets(file_handle, file_text, 63);
		trim(file_text);
		
		if(equal(file_text, "//", 2) || !file_text[0]) continue;
		
		if(contain(file_text, "HealthStation.mdl") != -1)
		{
			if(!file_exists(file_text))
			{
				log_amx("Error: Failed to load HealthStation.mdl, model does not exist.", file_text);
				continue;
			}
			ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
			engfunc(EngFunc_SetModel, ent, file_text);
			set_pev(ent, pev_classname, MEDKITCLASS);
			set_pev(ent, pev_controller_0, 125);
			set_pev(ent, pev_controller_1, 125);
			set_pev(ent, pev_controller_2, 125);
			set_pev(ent, pev_controller_3, 125);
			set_pev(ent, pev_solid, 2);
			
			setGlow(ent);
			g_medkit_id[g_medkit_count] = ent;
			lastread = 1;
		}
		else if(contain(file_text, "ArmorStation.mdl") != -1)
		{
			if(!file_exists(file_text))
			{
				log_amx("Error: Failed to load ArmorStation.mdl, model does not exist.");
				continue;
			}
			ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
			engfunc(EngFunc_SetModel, ent, file_text);
			set_pev(ent, pev_classname, RECHARGECLASS);
			set_pev(ent, pev_controller_0, 125);
			set_pev(ent, pev_controller_1, 125);
			set_pev(ent, pev_controller_2, 125);
			set_pev(ent, pev_controller_3, 125);
			set_pev(ent, pev_solid, 2);
			
			setGlow(ent);
			g_recharge_id[g_recharge_count] = ent;
			lastread = 2;
		}
		else if(equal(file_text, "origin", 6))
		{
			parse(file_text[6], str_value[0], 15, str_value[1], 15, str_value[2], 15);
			
			switch(lastread)
			{
				case 1:
				{
					g_medkit_coords[g_medkit_count][0] = str_to_float(str_value[0]);
					g_medkit_coords[g_medkit_count][1] = str_to_float(str_value[1]);
					g_medkit_coords[g_medkit_count][2] = str_to_float(str_value[2]);
					engfunc(EngFunc_SetOrigin, ent, g_medkit_coords[g_medkit_count]);
				}
				case 2:
				{
					g_recharge_coords[g_recharge_count][0] = str_to_float(str_value[0]);
					g_recharge_coords[g_recharge_count][1] = str_to_float(str_value[1]);
					g_recharge_coords[g_recharge_count][2] = str_to_float(str_value[2]);
					engfunc(EngFunc_SetOrigin, ent, g_recharge_coords[g_recharge_count]);					
				}
			}		
		}
		else if(equal(file_text, "angles", 6))
		{
			parse(file_text[6], str_value[0], 15, str_value[1], 15, str_value[2], 15);
			
			switch(lastread)
			{
				case 1:
				{
					g_medkit_angles[g_medkit_count][0] = str_to_float(str_value[0]);
					g_medkit_angles[g_medkit_count][1] = str_to_float(str_value[1]);
					g_medkit_angles[g_medkit_count][2] = str_to_float(str_value[2]);
					set_pev(ent, pev_angles, g_medkit_angles[g_medkit_count]);
					
					new Float:mins[3] = {-2.0, -2.0, 38.0};
					new Float:maxs[3] = {2.0, 2.0, 42.0};
					engfunc(EngFunc_SetSize, ent, mins, maxs);
					g_medkit_count++;
				}
				case 2:
				{
					g_recharge_angles[g_recharge_count][0] = str_to_float(str_value[0]);
					g_recharge_angles[g_recharge_count][1] = str_to_float(str_value[1]);
					g_recharge_angles[g_recharge_count][2] = str_to_float(str_value[2]);
					set_pev(ent, pev_angles, g_recharge_angles[g_recharge_count]);
					
					new Float:mins[3] = {-2.0, -2.0, 38.0};
					new Float:maxs[3] = {2.0, 2.0, 42.0};
					engfunc(EngFunc_SetSize, ent, mins, maxs);
					g_recharge_count++;
				}
			}	
			lastread = 0;
		}
	}
	fclose(file_handle);
	resetStations();
	return PLUGIN_HANDLED;
}

delete_saved_stations(num, del_class)
{
	get_configsdir(g_file_name, 255);
	format(g_file_name, 255, "%s/%s/%s.txt", g_file_name, CONFIGFOLDER, g_map_name);
	new file_handle = fopen(g_file_name, "r");
	if(!file_handle) return PLUGIN_HANDLED;
	
	new del_medkit_num;
	new del_recharge_num;
	new file_text[64];
	new str_value[3][16];
	
	while(!feof(file_handle))
	{
		fgets(file_handle, file_text, 63);
		trim(file_text);
		
		if(equal(file_text, "//", 2) || !file_text[0]) continue;
		
		if(contain(file_text, "HealthStation.mdl") != -1)
		{
			if(del_medkit_num != num)
			{
				g_del_models[g_del_num] = 0;
				del_medkit_num++;
			}
			else if(del_class == 1)
			{
				fgets(file_handle, file_text, 63);
				fgets(file_handle, file_text, 63);
				del_medkit_num++;
			}
			else
			{
				g_del_models[g_del_num] = 0;
				del_medkit_num++;
			}
		}
		
		else if(contain(file_text, "ArmorStation.mdl") != -1)
		{
			if(del_recharge_num != num)
			{
				g_del_models[g_del_num] = 1;
				del_recharge_num++;
			}
			else if(del_class == 2)
			{
				fgets(file_handle, file_text, 63);
				fgets(file_handle, file_text, 63);
				del_recharge_num++;
			}
			else
			{
				g_del_models[g_del_num] = 1;
				del_recharge_num++;
			}
		}
		
		else if(equal(file_text, "origin", 6))
		{
			parse(file_text[6], str_value[0], 15, str_value[1], 15, str_value[2], 15);
			g_del_origins[g_del_num][0] = str_to_float(str_value[0]);
			g_del_origins[g_del_num][1] = str_to_float(str_value[1]);
			g_del_origins[g_del_num][2] = str_to_float(str_value[2]);
		}
		
		else if(equal(file_text, "angles", 6))
		{
			parse(file_text[6], str_value[0], 15, str_value[1], 15, str_value[2], 15);
			g_del_angles[g_del_num][0] = str_to_float(str_value[0]);
			g_del_angles[g_del_num][1] = str_to_float(str_value[1]);
			g_del_angles[g_del_num][2] = str_to_float(str_value[2]);
			g_del_num++;
		}
	}
	
	fclose(file_handle);
	save_stations_again();
	
	return PLUGIN_HANDLED;
}

public save_stations_again()
{
	new text[256];	
	get_configsdir(g_file_name, 255);
	format(g_file_name, 255, "%s/%s/%s.txt", g_file_name, CONFIGFOLDER, g_map_name);
	new tmpfile = fopen(g_file_name,"w");
	
	for(new i = 0; i < g_del_num; ++i)
	{
		formatex(text, 255, "^n%s^norigin %f %f %f^nangles %f %f %f^n", g_models[g_del_models[i]], g_del_origins[i][0], g_del_origins[i][1], g_del_origins[i][2], g_del_angles[i][0], g_del_angles[i][1], g_del_angles[i][2]);
		fputs(tmpfile,text);
	}
	
	fclose(tmpfile);
	resetStations();
	remove_stations();
	load_saved_stations(g_file_name);
}

//*****************************************************************************************************************
//*********************************************   P R E T H I N K  ************************************************
//*****************************************************************************************************************

public PreThink(id)
{
	//+++++ PLACING STUFF (ADMIN) +++++
	if(g_adjusting && id == g_curAdjuster)
	{
		if(g_prethink_placestepper++ > PLACESTEPFREQUENCY)
		{
			if(!is_aiming_at_sky(id))
			{
				get_aim_origin(id, g_aimOrigin[2]);
	
				if(equal_f(g_aimOrigin[1], g_aimOrigin[2]) < 3)
				{
					if(pev_valid(g_entity))
					{
						engfunc(EngFunc_SetOrigin, g_entity, g_aimOrigin[2]);
						move_station(id, 3);
						
						static Float:normal[3], Float:player_origin[3], Float:test_origin[3];
						
						normal = cross_product(diff_f(g_aimOrigin[0], g_aimOrigin[1]), diff_f(g_aimOrigin[2], g_aimOrigin[1]));
						vector_to_angle(normal, g_entity_angles);
						
						minimize_normal(normal);
						test_origin = sum_f(g_aimOrigin[2], normal);
						pev(id, pev_origin, player_origin);
						
						if(get_distance_f(player_origin, test_origin) > get_distance_f(player_origin, g_aimOrigin[2]))
						{
							set_pev(g_entity, pev_angles, g_entity_angles);
						}
					}	
				}
				if(equal_f(g_aimOrigin[1], g_aimOrigin[2]) < 2 && get_distance_f(g_aimOrigin[2], g_aimOrigin[1]) > 5.0)
				{
					g_aimOrigin[0] = g_aimOrigin[1];
					g_aimOrigin[1] = g_aimOrigin[2];
				}
				g_prethink_placestepper = 0;
			}
		}
	}
	//+++++###+++++ CHECKING STUFF (STATIONS) +++++###+++++
	new Float:gametime = get_gametime();
	if(g_nextstep[id] < gametime)		// is it time for the next check?
	{		
		//~~ Check medkit-Stationstatus ~~
		for(new m = 0; m < g_medkit_count; m++)
		{
			if(pev_valid(g_medkit_id[m]))
			{
				if(ent_distance(id, g_medkit_id[m]) < 30)
				{
					// Player is near a Health-Station
					g_faraway = false;
					if(is_in_viewcone(id, g_medkit_coords[m]))
					{
						// Player is looking at a Health-Station
						if(pev(id, pev_button) & IN_USE)
						{
							// Player is pressing USE-button near a Health-Station
							GiveHealth(id, m);
							g_snd_medkit[m][id] = true;
						}
						else if(g_snd_medkit[m][id] == true)
						{
							emit_sound(g_medkit_id[m], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
							g_snd_medkit[m][id] = false;
						}
					}
					else if(g_snd_medkit[m][id] == true)
					{
						emit_sound(g_medkit_id[m], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
						g_snd_medkit[m][id] = false;
					}
				}
				else
				{
					if(ent_distance(id, g_medkit_id[m]) > 100 && g_faraway)
					{
						g_faraway = true;
						g_snd_medkit[m][id] = false;
					}
					if(g_snd_medkit[m][id] == true) emit_sound(g_medkit_id[m], CHAN_WEAPON, "HealthArmor-Stations/HealthRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				}
			}
			else
			{
				log_amx("Error: Failure in map config! Please make a new one. (Health-Station nr: %d failed to load)",m);
			}
		}
		//~~ Check recharge-Stationstatus ~~
		for(new r = 0; r < g_recharge_count; r++)
		{
			if(pev_valid(g_recharge_id[r]))
			{
				if(ent_distance(id, g_recharge_id[r]) < 30)
				{
					// Player is near a Recharge-Station
					g_faraway = false;
					if(is_in_viewcone(id, g_recharge_coords[r]))
					{
						// Player is looking at a Recharge-Station
						if(pev(id, pev_button) & IN_USE)
						{
							// Player is pressing USE-Button near a Recharge-Station
							GiveArmor(id, r);
							g_snd_recharge[r][id] = true;							
						}
						else if(g_snd_recharge[r][id] == true)
						{
							emit_sound(g_recharge_id[r], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
							g_snd_recharge[r][id] = false;
						}
					}
					else if(g_snd_recharge[r][id] == true)
					{
						emit_sound(g_recharge_id[r], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
						g_snd_recharge[r][id] = false;
					}
				}
				else
				{
					if(ent_distance(id, g_recharge_id[r]) > 100 && g_faraway)
					{
						g_faraway = true;
						g_snd_recharge[r][id] = false;
					}
					if(g_snd_recharge[r][id] == true) emit_sound(g_recharge_id[r], CHAN_WEAPON, "HealthArmor-Stations/ArmorRecharge.wav", 1.0, ATTN_NORM, SND_STOP, PITCH_NORM);
				}
			}
			else
			{
				log_amx("Error: Failure in map config! Please make a new one. (Armor-Station nr: %d failed to load)",r);
			}	
		}
		//~~ Calculate the next Checking time ~~
		if(g_faraway) g_chargesteppfrequency = 1.0;
		else g_chargesteppfrequency = 0.2;
		g_nextstep[id] = gametime + g_chargesteppfrequency; //Add a little delay for checking
		g_faraway = true;
	}
	return FMRES_HANDLED;
}

//*****************************************************************************************************************
//*************************************************   M E N U S   *************************************************
//*****************************************************************************************************************

// Display the Selection Menu
public display_select(id)
{	
	static szMenuBody[224];
	new nKeys;
	if((g_medkit_count < MAXMEDKITS) && (g_recharge_count < MAXRECHARGES))
	{
		nKeys = (1<<9)|(1<<7)|(1<<1)|(1<<0);
		formatex(szMenuBody, 223, "Choose a type: ^n^n1. medkit^n2. recharge^n^n8. Save this Position!^n^n0. Exit");
	}
	else if((g_medkit_count < MAXMEDKITS) && (g_recharge_count == MAXRECHARGES))
	{
		nKeys = (1<<9)|(1<<7)|(1<<1)|(1<<0);
		formatex(szMenuBody, 223, "Choose a type: ^n^n1. medkit^n2. \rrecharge\w^n^n8. Save this Position!^n^n0. Exit");		
	}
	else if((g_recharge_count < MAXRECHARGES) && (g_medkit_count == MAXMEDKITS)) 
	{
		nKeys = (1<<9)|(1<<7)|(1<<1)|(1<<0);
		formatex(szMenuBody, 223, "Choose a type: ^n^n1. \rmedkit\w^n2. recharge^n^n8. Save this Position!^n^n0. Exit");		
	}
	else if((g_medkit_count == MAXMEDKITS) && (g_recharge_count == MAXRECHARGES))
	{
		nKeys = (1<<9)|(1<<7)|(1<<1)|(1<<0);
		formatex(szMenuBody, 223, "You have all available Stations placed!^n^n1. \rmedkit\w^n2. \rrecharge\w^n^n8. \rSave this Position!\w^n^n0. Exit");
	}
	show_menu(id, nKeys, szMenuBody, -1, "select_menu" );
	return;
}

// Check what Key was pressed in the Selection Menu
public action_select(id, key)
{
	switch(key)
	{
		case 0: // medkit
		{
			if(g_medkit_count < MAXMEDKITS && pev_valid(g_entity))
			{
				g_curmodeltype = 0;
				engfunc(EngFunc_SetModel, g_entity, g_models[g_curmodeltype]);
				set_pev(g_entity, pev_classname, MEDKITCLASS);
				new Float:mins[3] = {-2.0, -2.0, 38.0};
				new Float:maxs[3] = {2.0, 2.0, 42.0};
				engfunc(EngFunc_SetSize, g_entity, mins, maxs);
				setGlow(g_entity);
				display_select(id);
			}else display_select(id);
		}
		case 1: // recharge
		{
			if(g_recharge_count < MAXRECHARGES && pev_valid(g_entity))
			{
				g_curmodeltype = 1;
				engfunc(EngFunc_SetModel, g_entity, g_models[g_curmodeltype]);
				set_pev(g_entity, pev_classname, RECHARGECLASS);
				new Float:mins[3] = {-2.0, -2.0, 38.0};
				new Float:maxs[3] = {2.0, 2.0, 42.0};
				engfunc(EngFunc_SetSize, g_entity, mins, maxs);				
				setGlow(g_entity);
				display_select(id);
			}else display_select(id);
		}
		case 7:	
		{
			if((g_recharge_count < MAXRECHARGES) || (g_medkit_count < MAXMEDKITS))
			{
				display_save(id);
			}else	display_select(id);
		}
		case 9:	if(pev_valid(g_entity)) engfunc(EngFunc_RemoveEntity, g_entity);
	}
}

// Display the Save Menu
public display_save(id)
{
	show_menu(id, (1<<0)|(1<<1), "Save this Medkit/Recharger?^n^n1. Yes, save it.^n2. No, delete it.^n", -1, "save_menu");
}

// Check what Key was pressed in the Save Menu
public action_save(id, key)
{
	switch (key)
	{
		case 0: save_pos();
		case 1:
		{
			if(pev_valid(g_entity))
			{
				engfunc(EngFunc_RemoveEntity, g_entity);
			}
		}
	}
}

//*****************************************************************************************************************
//***************************************   E N T I T Y H A N D L I N G   *****************************************
//*****************************************************************************************************************

//+++++ PLACE STATION ++++++
public cmd_place_station(id)
{
	if(!(get_user_flags(id) & ADMIN_ACCESS_LEVEL))
	{
		client_print(id, print_console, "You do not have access to this command.");
		return PLUGIN_HANDLED;
	}
	g_curAdjuster = id;
	new cmd[2];
	read_argv(0, cmd, 1);
	switch(cmd[0])
	{
		case '+':
		{
			if(g_adjusting)
			{
				log_amx("Error: Someone is already placing an Medkit/Recharge");
				client_print(0, print_chat, "Error: Another user is already placing an Medkit/Recharge");
				return PLUGIN_HANDLED;
			}
			if(pev_valid(g_entity)) engfunc(EngFunc_RemoveEntity, g_entity);
			if(!pev_valid(g_entity))
			{
				if(g_medkit_count < MAXMEDKITS || g_recharge_count < MAXRECHARGES) entcreate();
				else
				{
					log_amx("Error: You have placed all available Medkits/Recharges");
					client_print(0, print_chat, "Error: You have placed all available Medkits/Recharges");
					return PLUGIN_HANDLED;
				}
			}
			g_adjusting = true;
		}
		case '-':
		{
			g_adjusting = false;
			if(pev_valid(g_entity) && g_entity != 0) display_select(id);
		}
	}
	return PLUGIN_HANDLED;
}

//+++++ DELETE STATION +++++
public del_station(id)
{
	if(!(get_user_flags(id) & ADMIN_ACCESS_LEVEL))
	{
		client_print(id, print_console, "You do not have access to this command.");
		return PLUGIN_HANDLED;
	}
	
	new ent = get_ent_in_aim_radius(id, 30.0);
	new num = get_station_num(ent);
	
	if(num == -1) return PLUGIN_HANDLED_MAIN;
	
	new class[33];
	pev(ent, pev_classname, class, 32);
	if(equal(class, MEDKITCLASS)) delete_saved_stations(num, 1);
	else delete_saved_stations(num, 2);
	return PLUGIN_CONTINUE;
}

//+++++ CREATE ENTITY ++++++
public entcreate()
{		
	if(g_medkit_count == MAXMEDKITS) g_curmodeltype = 1;
	if(g_recharge_count == MAXRECHARGES) g_curmodeltype = 0;
	
	g_entity = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"));
	engfunc(EngFunc_SetModel, g_entity, g_models[g_curmodeltype]);
	
	if(g_curmodeltype == 0) set_pev(g_entity, pev_classname, MEDKITCLASS);
	else set_pev(g_entity, pev_classname, RECHARGECLASS);
	
	set_pev(g_entity, pev_controller_0, 125);
	set_pev(g_entity, pev_controller_1, 125);
	set_pev(g_entity, pev_controller_2, 125);
	set_pev(g_entity, pev_controller_3, 125);
	
	new Float:mins[3] = {-2.0, -2.0, 38.0};
	new Float:maxs[3] = {2.0, 2.0, 42.0};
	engfunc(EngFunc_SetSize, g_entity, mins, maxs);
	
	set_pev(g_entity, pev_solid, 2);
	
	setGlow(g_entity);
}

//+++++ LET THE STATION GLOW +++++
setGlow(ent)
{
	if(g_cvar_gloweffect && pev_valid(ent))
	{
		new class[32];
		pev(ent, pev_classname, class, 31);
		set_pev(ent, pev_renderfx, kRenderFxHologram);
		if(equal(class, MEDKITCLASS)) set_pev(ent, pev_rendercolor, g_colors[0]); // red for the Medkit-Station
		else set_pev(ent, pev_rendercolor, g_colors[1]); // blue for the Recharge-Station

set_pev(ent, pev_renderfx, kRenderFxGlowShell);
		set_pev(ent, pev_renderamt, 255.0);
		set_pev(ent, pev_rendermode, kRenderTransAlpha);
	}
}

//+++++ MOVE THE ENTITY ++++++
public pull_station(id)
{
	move_station(id, 1);
}

public push_station(id)
{
	move_station(id, 2);
}

public move_station(id, flag)
{
	if(!(get_user_flags(id) & ADMIN_ACCESS_LEVEL))
	{
		client_print(id, print_console, "You do not have access to this command.");
		return PLUGIN_HANDLED;
	}
	if(pev_valid(g_entity))
	{
		static Float:player_origin[3], Float:distance[3], greatest;
		pev(id, pev_origin, player_origin);
		distance[0] = abs_f(player_origin[0] - g_aimOrigin[2][0]);
		distance[1] = abs_f(player_origin[1] - g_aimOrigin[2][1]);
		distance[2] = abs_f(player_origin[2] - g_aimOrigin[2][2]);
		for(new i = 0; i < 3; i++)
		{
			if(distance[i] > distance[greatest]) greatest = i;
		}
		switch(flag)
		{
			case 1: {g_aimOrigin[2][greatest] += (player_origin[greatest] > g_aimOrigin[2][greatest] ? DISTANCE : -DISTANCE);}
			case 2: {g_aimOrigin[2][greatest] -= (player_origin[greatest] > g_aimOrigin[2][greatest] ? DISTANCE : -DISTANCE);}
			case 3: {g_aimOrigin[2][greatest] += (player_origin[greatest] > g_aimOrigin[2][greatest] ? 2.0 : -2.0);}
		}
		engfunc(EngFunc_SetOrigin, g_entity, g_aimOrigin[2]);
	}
	return 1;
}

//*****************************************************************************************************************
//************************************************   F U N C T I O N S  *******************************************
//*****************************************************************************************************************

//+++++ Taken from fakemeta_util.inc (very nice! many thanks to VEN from http://forums.alliedmods.net/index.php +++++
bool:is_in_viewcone(index, const Float:point[3])
{
	new Float:angles[3]
	pev(index, pev_angles, angles)
	engfunc(EngFunc_MakeVectors, angles)
	global_get(glb_v_forward, angles)
	angles[2] = 0.0

new Float:origin[3], Float:diff[3], Float:norm[3]
	pev(index, pev_origin, origin)
	vec_sub(point, origin, diff)
	diff[2] = 0.0
	vec_normalize(diff, norm)

new Float:dot, Float:fov
	dot = vec_dot(norm, angles)
	pev(index, pev_fov, fov)
	if (dot >= floatcos(fov * M_PI / 360))
		return true

return false
}

get_aim_origin(index, Float:origin[3])
{
	static Float:start[3], Float:view_ofs[3];
	pev(index, pev_origin, start);
	pev(index, pev_view_ofs, view_ofs);
	vec_add(start, view_ofs, start);
	
	static Float:dest[3];
	pev(index, pev_v_angle, dest);
	engfunc(EngFunc_MakeVectors, dest);
	global_get(glb_v_forward, dest);
	vec_mul_scalar(dest, 9999.0, dest);
	vec_add(start, dest, dest);
	
	engfunc(EngFunc_TraceLine, start, dest, 0, index, 0);
	get_tr2(0, TR_vecEndPos, origin);
	
	return 1;
}

bool:is_aiming_at_sky(index)
{
	new target, temp;
	get_user_aiming(index,target,temp);
	if(engfunc(EngFunc_PointContents,target) == CONTENTS_SKY) return true;
	return false;
}

get_ent_in_aim_radius(index, Float:radius) 
{
	static Float:start[3], Float:view_ofs[3];
	static Float:dest[3], Float:origin[3], entclass[32];
	new ent = -1;
	
	pev(index, pev_origin, start)
	pev(index, pev_view_ofs, view_ofs)
	vec_add(start, view_ofs, start)
	pev(index, pev_v_angle, dest)
	engfunc(EngFunc_MakeVectors, dest)
	global_get(glb_v_forward, dest)
	vec_mul_scalar(dest, 9999.0, dest)
	vec_add(start, dest, dest)
	engfunc(EngFunc_TraceLine, start, dest, 0, index, 0)
	get_tr2(0, TR_vecEndPos, origin)
	while((ent = engfunc(EngFunc_FindEntityInSphere, ent, origin, radius)) != 0)
	{
		pev(ent, pev_classname, entclass, 32)
		if(equal(entclass, MEDKITCLASS) || equal(entclass, RECHARGECLASS)) return ent;
	}
	return 0
}

Float:ent_distance(ent1, ent2)
{
	new Float:mins1[3], Float:maxs1[3];
	new Float:mins2[3], Float:maxs2[3];
	new Float:dist[3];
	pev(ent1, pev_absmin, mins1);
	pev(ent1, pev_absmax, maxs1);
	pev(ent2, pev_absmin, mins2);
	pev(ent2, pev_absmax, maxs2);
	for (new i = 0; i < 3; ++i)
	{
		if (mins1[i] > maxs2[i]) dist[i] = mins1[i] - maxs2[i];
		else if (mins2[i] > maxs1[i]) dist[i] = mins2[i] - maxs1[i];
	}
	return vector_length(dist);
}

/*bool:is_visible(index, const Float:point[3], ignoremonsters = 0)
{
	new Float:start[3], Float:view_ofs[3];
	pev(index, pev_origin, start);
	pev(index, pev_view_ofs, view_ofs);
	vec_add(start, view_ofs, start);

engfunc(EngFunc_TraceLine, start, point, ignoremonsters, index, 0);

new Float:fraction;
	get_tr2(0, TR_flFraction, fraction);
	if (fraction == 1.0)
		return true;

return false;
}*/

minimize_normal(Float:normal[3])
{
	normal[0] /= 10.0;
	normal[1] /= 10.0;
	normal[2] /= 10.0;
	return 1;
}

Float:abs_f(Float:x)
{
	if(x < 0) return (-1.0 * x);
	return x;
}

equal_f(Float:origin1[3], Float:origin2[3])
{
	new num_equal = (origin1[0] == origin2[0] ? 1 : 0);
	num_equal += (origin1[1] == origin2[1] ? 1 : 0);
	num_equal += (origin1[2] == origin2[2] ? 1 : 0);
	return num_equal;
}

Float:sum_f(Float:origin1[3], Float:origin2[3])
{
	new Float:result[3];
	result[0] = origin1[0] + origin2[0];
	result[1] = origin1[1] + origin2[1];
	result[2] = origin1[2] + origin2[2];
	return result;
}

Float:diff_f(Float:origin1[3], Float:origin2[3])
{
	new Float:result[3];
	result[0] = origin1[0] - origin2[0];
	result[1] = origin1[1] - origin2[1];
	result[2] = origin1[2] - origin2[2];
	return result;
}

Float:cross_product(Float:origin1[3], Float:origin2[3])
{
	new Float:result[3];
	result[0] = origin1[1]*origin2[2] - origin1[2]*origin2[1];
	result[1] = origin1[2]*origin2[0] - origin1[0]*origin2[2];
	result[2] = origin1[0]*origin2[1] - origin1[1]*origin2[0];
	return result;
}

//+++++ Taken from xs.inc (very nice! Many thanks to PM from http://forums.alliedmods.net/index.php +++++
vec_add(const Float:in1[], const Float:in2[], Float:out[])
{
	out[0] = in1[0] + in2[0];
	out[1] = in1[1] + in2[1];
	out[2] = in1[2] + in2[2];
}

vec_sub(const Float:in1[], const Float:in2[], Float:out[])
{
	out[0] = in1[0] - in2[0];
	out[1] = in1[1] - in2[1];
	out[2] = in1[2] - in2[2];
}

vec_mul_scalar(const Float:vec[], Float:scalar, Float:out[])
{
	out[0] = vec[0] * scalar;
	out[1] = vec[1] * scalar;
	out[2] = vec[2] * scalar;
}

vec_normalize(const Float:vec[], Float:out[])
{
	new Float:invlen = xs_rsqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]);
	out[0] = vec[0] * invlen;
	out[1] = vec[1] * invlen;
	out[2] = vec[2] * invlen;
}

Float:xs_rsqrt(Float:x)
{
	return 1.0 / floatsqroot(x);
}
	
Float:vec_dot(const Float:vec1[], const Float:vec2[])
{
	return vec1[0]*vec2[0] + vec1[1]*vec2[1] + vec1[2]*vec2[2];
}

get_station_num(id)
{
	for(new m = 0; m < g_medkit_count; m++)
		if(g_medkit_id[m] == id) return m;

for(new r = 0; r < g_recharge_count; r++)
		if(g_recharge_id[r] == id) return r;

return -1;
}

//+++++ Manipulate the user armor ++++++
set_realarmor(id, armor=2)
{
	if(is_module_loaded("cstrike") != -1)
	{
		set_pdata_int(id, OFFSET_ARMORTYPE, armor, OFFSET_LINUX);
		message_begin(MSG_ONE, g_umsgA, {0,0,0}, id);
		write_byte(1);
		message_end();
	}
}

Загрузил Pasha6987

2019-05-11 15:43:40

Скачать

Данная иконка означает, что плагин был проверен администрацией хостинга на тестовом сервере, и проблем с ним не было выявлено. Рекомендуем ставить исключительно проверенные плагины.

Плагин загружен на сервер, но проверка еще не была проведена.

Игровые сервера	Дополнительные услуги		Инфо	Сообщество

Counter-Strike 1.6 Counter-Strike: Source Left 4 Dead 2 Counter-Strike: GO Garry's Mod Remote	VDS/VPS Dedicated Remote Вебхостинг CASSA	Scanmon Fast DL Backup	Help Тарифы Партнерка Новости Оферта	Форум Мониторинг Плагины^new vk.com steam Telegram