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

Runes of Quake 0.5

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

На карте в определённых местах появляется случайные руны (5ти видов).
Руну можно подобрать, она даст свой эффект игроку и будет действовать определённое время.
С помощью специального меню, можно вручную настроить точки появлений рун.

.sma
#define RUNE_DEBUG_MODE - Debug режим, для вывода координат рун.
#define RUNE_SPAWN_TIME - Создание рун через определённое время.
#define RUNE_PICK_UP_INFO - Выводить ли информацию о поднятой руне.
#define RUNE_PICK_UP_SCREEN_FADE - Подсвечивать ли экран (соответствующем цветом), когда игрок подбирает руну.
#define RUNE_SET_POS_ACCESS - Флаг который должен иметь игрок, чтобы расставлять позиции для рун.
#define RUNE_DMG__FACTOR - Множитель урона.
#define RUNE_DMG__TIME_EFFECT- Время действия эффекта увеличенного урона.
#define RUNE_PROTECT__ABSORPTION - Процентное соотношение поглощения урона при попадании в радиационную жидкость.
#define RUNE_PROTECT__TIME_EFFECT - Время действия эффекта поглощения урона.
#define RUNE_REGEN__HP - Количество HP в 1 секунду.
#define RUNE_REGEN__MAX_HP - Придел жизней для регенерации.
#define RUNE_REGEN__TIME_EFFECT - Время действия эффекта регенерации здоровья.
#define RUNE_INVISE__TIME_EFFECT- Время действия эффекта невидимости.
#define RUNE_SPEED__FACTOR - Множитель скорости.
#define RUNE_SPEED__TIME_EFFECT- Время действия эффекта скорости.

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

Команды:

say "/setrune" - открыть меню для настройки позиций.

.sma / .sp

#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <hamsandwich>

#if AMXX_VERSION_NUM < 183
	#include <colorchat>
#else
	#define DontChange print_team_default
#endif

#pragma semicolon							1

#define PLUGIN_NAME							"[CS] Runes of Quake"
#define PLUGIN_VERS							"0.5"
#define PLUGIN_AUTH							"81x08"

#define IsPlayer(%0)						(%0 && %0 <= g_iMaxPlayers)

#define MAX_PLAYERS							32

#define XO_PLAYER							5
#define PDATA_SAFE							2

#define OFFSET_TEAM							114

#define MsgId_ScreenFade					98

#define TASK_PLAYER_RUNE_EFFECT				100

#if !defined Ham_CS_Player_ResetMaxSpeed
	#define Ham_CS_Player_ResetMaxSpeed		Ham_Item_PreFrame
#endif

// #define RUNE_DEBUG_MODE

#define RUNE_PICK_UP_INFO
#define RUNE_PICK_UP_SCREEN_FADE

#define RUNE_SPAWN_TIME						Float: 20.0

#define RUNE_SET_POS_ACCESS					ADMIN_RCON

#define RUNE_DMG__FACTOR					Float: 2.0
#define RUNE_DMG__TIME_EFFECT				10

#define RUNE_PROTECT__ABSORPTION			50
#define RUNE_PROTECT__TIME_EFFECT			15

#define RUNE_REGEN__HP						4
#define RUNE_REGEN__MAX_HP					100.0
#define RUNE_REGEN__TIME_EFFECT				8

#define RUNE_INVISE__TIME_EFFECT			10

#define RUNE_SPEED__FACTOR					Float: 1.5
#define RUNE_SPEED__TIME_EFFECT				15

#define RUNE_HUD_INFO_POS					0.65, 0.865
#define RUNE_HUD_INFO_COLOR					38, 97, 156

enum _: ENUM_DATA_POS	{
	POS_X,
	POS_Y,
	POS_Z
};

enum _: ENUM_DATA_RUNE	{
	RUNE_NULL,

RUNE_DMG,
	RUNE_PROTECT,
	RUNE_REGEN,
	RUNE_INVISE,
	RUNE_SPEED,
	
	RUNE_MAX
};

enum _: ENUM_DATA_RUNE_SETTINGS	{
	bool: RUNE_MODE,
	RUNE_SOUND[64],
	RUNE_COLOR[3],
	RUNE_ALPHA
};

new g_RuneSettings[ENUM_DATA_RUNE][ENUM_DATA_RUNE_SETTINGS] = {
	'^0',
	
	/* [Вкл | Выкл]		[Звук]				     [Цвет ScreenFade] 		[Яркость ScreenFade] */
	{true,			"rune/damage.wav", 			{66,	170,	255},		140},
	{true,			"rune/protection.wav", 		{255,	210,	128},		140},
	{true,			"rune/regeneration.wav", 	{255,	0,		0},			140},
	{true,			"rune/invisible.wav", 		{255,	255,	255},		140},
	{true,			"rune/speed.wav", 			{255,	215,	0},			140},
	
	'^0'
};

new const g_szRuneMdl[] = "models/rune/rune.mdl";
new const g_szEyesMdl[] = "models/rune/eyes.mdl";

new g_iCountRune,
	g_iMaxPlayers,
	g_iSyncHudRuneInfo,
	g_iArraySizeRunePosition;

new g_bRuneEdit;

new g_szFileDir[128];

new gp_iRune[MAX_PLAYERS + 1 char],
	gp_iRuneTimeEffect[MAX_PLAYERS + 1 char][ENUM_DATA_RUNE];

new gp_iEyesId[MAX_PLAYERS + 1 char];

new Array: g_aRunePosition;

/*================================================================================
 [PLUGIN]
=================================================================================*/
public plugin_precache()	{
	new iRuneCount;
	for(new iCount = RUNE_NULL + 1; iCount < RUNE_MAX; iCount++)	{
		if(g_RuneSettings[iCount][RUNE_MODE])	{
			iRuneCount++;
			precache_sound(g_RuneSettings[iCount][RUNE_SOUND]);
		}
	}
	
	if(iRuneCount)	{
		precache_model(g_szRuneMdl);
		precache_model(g_szEyesMdl);
	} else UTIL_LogToFile("[Warning] All runes have been disabled. The plugin moved into pause mode.");
}

public plugin_init()	{
	/* [PLUGIN] */
	register_plugin(PLUGIN_NAME, PLUGIN_VERS, PLUGIN_AUTH);

/* [LOGEVENT] */
	register_logevent("LogEventHook_RoundEnd",		2,	"1=Round_End");
	
	#if !defined RUNE_SPAWN_TIME
		register_logevent("LogEventHook_RoundStart",	2,	"1=Round_Start");
	#endif

register_logevent("LogEventHook_RestartGame",	2,	"1=Game_Commencing", "1&Restart_Round_");

/* [ENGINE] */
	register_touch("rune", "player", "TouchHook_Rune_Player");

/* [HAMSANDWICH] */
	RegisterHam(Ham_Killed, "player", "HamHook_Player_Killed_Post", true);
	RegisterHam(Ham_TraceAttack, "player", "HamHook_Player_TraceAttack_Pre", false);
	RegisterHam(Ham_CS_Player_ResetMaxSpeed, "player", "HamHook_CS_Player_ResetMaxSpeed", true);

/* [CLCMD] */
	register_clcmd("say /setrune", "ClCmd_SetPositionRune");
	
	/* [MENUCMD] */
	register_menucmd(register_menuid("Show_SetPositionRune"), MENU_KEY_1|MENU_KEY_2|MENU_KEY_3|MENU_KEY_4|MENU_KEY_5|MENU_KEY_0, "Handler_SetPositionRune");
	
	/* [OTHER] */
	g_iMaxPlayers = get_maxplayers();
	g_iSyncHudRuneInfo = CreateHudSyncObj();
	
	#if defined RUNE_SPAWN_TIME
		set_task(RUNE_SPAWN_TIME, "funcRandomSpawnRune", .flags = "b");
	#endif
	
	register_dictionary("rune.txt");
}

public plugin_cfg()	{
	g_aRunePosition = ArrayCreate(ENUM_DATA_POS);

formatex(g_szFileDir, charsmax(g_szFileDir), "addons/amxmodx/configs/rune");

if(!(dir_exists(g_szFileDir)))
		mkdir(g_szFileDir);
	
	new szMapName[32];
	get_mapname(szMapName, charsmax(szMapName));
	
	formatex(g_szFileDir, charsmax(g_szFileDir), "%s/%s.ini", g_szFileDir, szMapName);
	
	new iFile = fopen(g_szFileDir, "rt");
	if(iFile)	{
		new szBuffer[128], szPosition[ENUM_DATA_POS][6];
		new Float: fPosition[ENUM_DATA_POS];
		
		while(!(feof(iFile)))	{
			fgets(iFile, szBuffer, charsmax(szBuffer));
			trim(szBuffer);
			
			if(!(szBuffer[0]) || szBuffer[0] == ';')
				continue;
			
			parse(szBuffer, szPosition[POS_X], charsmax(szPosition[]), szPosition[POS_Y], charsmax(szPosition[]), szPosition[POS_Z], charsmax(szPosition[]));
			
			fPosition[POS_X] = str_to_float(szPosition[POS_X]);
			fPosition[POS_Y] = str_to_float(szPosition[POS_Y]);
			fPosition[POS_Z] = str_to_float(szPosition[POS_Z]);
			
			ArrayPushArray(g_aRunePosition, fPosition);
		}
		
		fclose(iFile);
		
		g_iArraySizeRunePosition = ArraySize(g_aRunePosition);
	}
}

/*================================================================================
 [CLIENT]
=================================================================================*/
public client_disconnect(pId)	{
	if(gp_iRune[pId])	{
		gp_iRune[pId] = RUNE_NULL;
		
		if(gp_iEyesId[pId])	{
			funcRemoveEnt(gp_iEyesId[pId]);
			gp_iEyesId[pId] = 0;
		}
		
		for(new iCount = RUNE_NULL; iCount < RUNE_MAX; iCount++)
			gp_iRuneTimeEffect[pId][iCount] = 0;

remove_task(pId + TASK_PLAYER_RUNE_EFFECT);
	}
}

/*================================================================================
 [LOGEVENT]
=================================================================================*/
public LogEventHook_RoundStart()
	funcRandomSpawnRune();

public LogEventHook_RestartGame()
	LogEventHook_RoundEnd();

public LogEventHook_RoundEnd()	{
	for(new iIndex = 1; iIndex <= g_iMaxPlayers; iIndex++)	{
		if(gp_iRune[iIndex])	{
			if(gp_iRune[iIndex] & (1 << RUNE_INVISE))	{
				if(gp_iEyesId[iIndex])	{
					funcRemoveEnt(gp_iEyesId[iIndex]);
					gp_iEyesId[iIndex] = 0;
				}
				
				UTIL_SetPlayerRendering(iIndex, kRenderFxNone, Float: {0.0, 0.0, 0.0}, kRenderNormal, 0.0);
			}
			
			gp_iRune[iIndex] = RUNE_NULL;

for(new iCount = RUNE_NULL; iCount < RUNE_MAX; iCount++)
				gp_iRuneTimeEffect[iIndex][iCount] = 0;

remove_task(iIndex + TASK_PLAYER_RUNE_EFFECT);
		}
	}
	
	#if !defined RUNE_SPAWN_TIME
		funcRemoveEnt();
	#endif
}

/*================================================================================
 [ENGINE]
=================================================================================*/
public TouchHook_Rune_Player(const eId, const pId)	{
	new iRune = entity_get_int(eId, EV_INT_iuser1);
	
	if(gp_iRune[pId] == RUNE_NULL)
		set_task(1.0, "taskPlayerRuneEffect", pId + TASK_PLAYER_RUNE_EFFECT, .flags = "b");

gp_iRune[pId] |= (1 << iRune);
	
	switch(iRune)	{
		case RUNE_DMG:	{
			gp_iRuneTimeEffect[pId][RUNE_DMG] += RUNE_DMG__TIME_EFFECT;
			
			#if defined RUNE_PICK_UP_INFO
				client_print_color(pId, DontChange, "%L", pId, "ROQ_TAKE_RUNE_DMG", RUNE_DMG__FACTOR, RUNE_DMG__TIME_EFFECT);
			#endif
		}
		case RUNE_PROTECT:	{
			gp_iRuneTimeEffect[pId][RUNE_PROTECT] += RUNE_PROTECT__TIME_EFFECT;
			
			#if defined RUNE_PICK_UP_INFO
				client_print_color(pId, DontChange, "%L", pId, "ROQ_TAKE_RUNE_PROTECT", RUNE_PROTECT__ABSORPTION, RUNE_PROTECT__TIME_EFFECT);
			#endif
		}
		case RUNE_REGEN:	{
			gp_iRuneTimeEffect[pId][RUNE_REGEN] += RUNE_REGEN__TIME_EFFECT;
			
			#if defined RUNE_PICK_UP_INFO
				client_print_color(pId, DontChange, "%L", pId, "ROQ_TAKE_RUNE_REGEN", RUNE_REGEN__HP, RUNE_REGEN__TIME_EFFECT);
			#endif
		}
		case RUNE_INVISE: {
			gp_iRuneTimeEffect[pId][RUNE_INVISE] += RUNE_INVISE__TIME_EFFECT;
			
			UTIL_SetPlayerRendering(pId, kRenderFxGlowShell, Float: {0.0, 0.0, 0.0}, kRenderTransAlpha, 0.0);
			
			#if defined RUNE_PICK_UP_INFO
				client_print_color(pId, DontChange, "%L", pId, "ROQ_TAKE_RUNE_INVISE", RUNE_INVISE__TIME_EFFECT);
			#endif
			
			if(!(gp_iEyesId[pId]))	{
				gp_iEyesId[pId] = create_entity("func_wall");
				if(is_valid_ent(gp_iEyesId[pId]))	{
					entity_set_model(gp_iEyesId[pId], g_szEyesMdl);
					
					entity_set_edict(gp_iEyesId[pId], EV_ENT_aiment, pId);
					
					if(pev_valid(pId) == PDATA_SAFE)
						entity_set_int(gp_iEyesId[pId], EV_INT_body, get_pdata_int(pId, OFFSET_TEAM, XO_PLAYER) + 1);

entity_set_int(gp_iEyesId[pId], EV_INT_sequence, 0);
					entity_set_int(gp_iEyesId[pId], EV_INT_movetype, MOVETYPE_FOLLOW);
				}
			}
		}
		case RUNE_SPEED: {
			gp_iRuneTimeEffect[pId][RUNE_SPEED] += RUNE_SPEED__TIME_EFFECT;

ExecuteHamB(Ham_CS_Player_ResetMaxSpeed, pId);
			
			#if defined RUNE_PICK_UP_INFO
				client_print_color(pId, DontChange, "%L", pId, "ROQ_TAKE_RUNE_SPEED", RUNE_SPEED__FACTOR, RUNE_SPEED__TIME_EFFECT);
			#endif
		}
	}

#if defined RUNE_PICK_UP_SCREEN_FADE
		UTIL_ScreenFade(pId, (1<<12), (1<<12), 0, g_RuneSettings[iRune][RUNE_COLOR][0], g_RuneSettings[iRune][RUNE_COLOR][1], g_RuneSettings[iRune][RUNE_COLOR][2], g_RuneSettings[iRune][RUNE_ALPHA]);
	#endif
	
	client_cmd(pId, "stopsound");
	client_cmd(pId, "spk %s", g_RuneSettings[iRune][RUNE_SOUND]);
	
	remove_entity(eId);
}

/*================================================================================
 [HAMSANDWICH]
=================================================================================*/
public HamHook_Player_Killed_Post(const vId, const aId)	{
	if(gp_iRune[vId])	{
		if(gp_iRune[vId] & (1 << RUNE_INVISE))	{
			if(gp_iEyesId[vId])	{
				funcRemoveEnt(gp_iEyesId[vId]);
				gp_iEyesId[vId] = 0;
			}
			
			UTIL_SetPlayerRendering(vId, kRenderFxNone, Float: {0.0, 0.0, 0.0}, kRenderNormal, 0.0);
		}

gp_iRune[vId] = RUNE_NULL;

for(new iCount = RUNE_NULL; iCount < RUNE_MAX; iCount++)
			gp_iRuneTimeEffect[vId][iCount] = 0;

remove_task(vId + TASK_PLAYER_RUNE_EFFECT);
	}
}

public HamHook_Player_TraceAttack_Pre(const vId, const aId, Float: fDamage, const Float: fDeriction[3], const iTraceHandle, const iBitDamage)	{
	if(IsPlayer(aId) && vId != aId)	{
		if(gp_iRune[aId] & (1 << RUNE_DMG))
			SetHamParamFloat(3, fDamage * RUNE_DMG__FACTOR);
		
		if(gp_iRune[vId] & (1 << RUNE_PROTECT) && iBitDamage & DMG_ACID|DMG_SONIC|DMG_SHOCK|DMG_DROWN|DMG_NERVEGAS|DMG_RADIATION|DMG_SLOWBURN|DMG_SLOWFREEZE|DMG_ENERGYBEAM)
			SetHamParamFloat(3, (fDamage * RUNE_PROTECT__ABSORPTION) / 100);
	}
	
	return HAM_IGNORED;
}

public HamHook_CS_Player_ResetMaxSpeed(const pId)	{
	if(gp_iRune[pId] & (1 << RUNE_SPEED))
		entity_set_float(pId, EV_FL_maxspeed, entity_get_float(pId, EV_FL_maxspeed) * RUNE_SPEED__FACTOR);
	
	return HAM_IGNORED;
}

/*================================================================================
 [CLCMD]
=================================================================================*/
public ClCmd_SetPositionRune(const pId)
	return (get_user_flags(pId) & RUNE_SET_POS_ACCESS) ? Show_SetPositionRune(pId) : PLUGIN_HANDLED;

/*================================================================================
 [MENUCMD]
=================================================================================*/
Show_SetPositionRune(const pId)	{
	new szMenu[360], iBitKeys = MENU_KEY_1|MENU_KEY_5|MENU_KEY_0;
	new iLen = formatex(szMenu, charsmax(szMenu), "\y[Rune] \wНастройка позиций \d| Всего позиций \r[ %s%d \r]^n^n", g_iArraySizeRunePosition ? "\y" : "\d", g_iArraySizeRunePosition);

iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[1] \wРежим \r[ \d%s \r]^n^n", g_bRuneEdit ? "Редактирование" : "Игровой");
	
	if(g_bRuneEdit)	{
		iBitKeys |= MENU_KEY_2;
		iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[2] \wПоставить позицию^n");
		
		if(g_iArraySizeRunePosition)	{
			iBitKeys |= MENU_KEY_3|MENU_KEY_4;
			
			iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[3] \wУдалить все позиции^n");
			iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[4] \wУдалить руну под прицелом^n^n");
		} else {
			iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[3] \dУдалить все позиции^n");
			iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[4] \dУдалить руну под прицелом^n^n");
		}
	} else {
		iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[2] \dПоставить позицию^n");
		iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[3] \dУдалить все позиции^n");
		iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[4] \dУдалить руну под прицелом^n^n");
	}

iLen += formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[5] \wСохранить позиции^n^n^n");

formatex(szMenu[iLen], charsmax(szMenu) - iLen, "\r[0] \wВыход");

return show_menu(pId, iBitKeys, szMenu, -1, "Show_SetPositionRune");
}

public Handler_SetPositionRune(const pId, const iKey)	{
	switch(iKey)	{
		case 0: {
			g_bRuneEdit = !g_bRuneEdit;

new eId = FM_NULLENT;
			while((eId = find_ent_by_class(eId, "rune")))	{
				entity_set_int(eId, EV_INT_solid, g_bRuneEdit ? SOLID_BBOX : SOLID_TRIGGER);
				entity_set_size(eId, Float:{-20.5, -20.5, 0.0}, Float:{20.5, 20.5, 60.5});
			}
		}
		case 1:	{
			new Float: fOrigin[3];
			UTIL_GetAimingPosition(pId, fOrigin);

g_iArraySizeRunePosition++;
			ArrayPushArray(g_aRunePosition, fOrigin);

funcCreateRune(fOrigin, false);
		}
		case 2:	{
			funcRemoveEnt();
			ArrayClear(g_aRunePosition);

g_iArraySizeRunePosition = 0;
		}
		case 3:	{
			new eId, iBody;
			get_user_aiming(pId, eId, iBody);
			
			new szClassName[6];
			entity_get_string(eId, EV_SZ_classname, szClassName, charsmax(szClassName));
			
			if(is_valid_ent(eId) && equal(szClassName, "rune"))	{
				new eIdIndex = entity_get_int(eId, EV_INT_iuser2);

new eIdObject = FM_NULLENT, eIdObjectIndex;
				while((eIdObject = find_ent_by_class(eIdObject, "rune")))	{
					eIdObjectIndex = entity_get_int(eIdObject, EV_INT_iuser2);
					if(eIdObjectIndex > eIdIndex)
						entity_set_int(eIdObject, EV_INT_iuser2, eIdObjectIndex - 1);
				}

g_iCountRune--;
				g_iArraySizeRunePosition--;

funcRemoveEnt(eId);
				ArrayDeleteItem(g_aRunePosition, eIdIndex);
			}
		}
		case 4:	{
			delete_file(g_szFileDir);

new szBuffer[128];
			new Float: fOrigin[ENUM_DATA_POS];

for(new iObject = 0; iObject < g_iArraySizeRunePosition; iObject++)	{
				ArrayGetArray(g_aRunePosition, iObject, fOrigin);

formatex(szBuffer, charsmax(szBuffer), "^"%.f^" ^"%.f^" ^"%.f^"", fOrigin[0], fOrigin[1], fOrigin[2]);
				write_file(g_szFileDir, szBuffer, -1);
			}
		}
		case 9: return PLUGIN_HANDLED;
	}
	
	return Show_SetPositionRune(pId);
}

/*================================================================================
 [TASK]
=================================================================================*/
public taskPlayerRuneEffect(pId)	{
	pId -= TASK_PLAYER_RUNE_EFFECT;

new szRuneInfo[ENUM_DATA_RUNE][64];

switch(gp_iRune[pId])	{
		case RUNE_NULL:	{
			remove_task(pId + TASK_PLAYER_RUNE_EFFECT);
			
			return PLUGIN_HANDLED;
		}
		default:	{
			if(gp_iRune[pId] & (1 << RUNE_DMG))	{
				formatex(szRuneInfo[RUNE_DMG], charsmax(szRuneInfo[]), "%L", pId, "ROQ_HUD_INFO_RUNE_DMG", gp_iRuneTimeEffect[pId][RUNE_DMG]);
				if(--gp_iRuneTimeEffect[pId][RUNE_DMG] <= 0)
					gp_iRune[pId] &= ~(1 << RUNE_DMG);
			}
			if(gp_iRune[pId] & (1 << RUNE_PROTECT))	{
				formatex(szRuneInfo[RUNE_PROTECT], charsmax(szRuneInfo[]), "%L", pId, "ROQ_HUD_INFO_RUNE_PROTECT", gp_iRuneTimeEffect[pId][RUNE_PROTECT]);
				if(--gp_iRuneTimeEffect[pId][RUNE_PROTECT] <= 0)
					gp_iRune[pId] &= ~(1 << RUNE_PROTECT);
			}
			
			if(gp_iRune[pId] & (1 << RUNE_REGEN))	{
				formatex(szRuneInfo[RUNE_REGEN], charsmax(szRuneInfo[]), "%L", pId, "ROQ_HUD_INFO_RUNE_REGEN", gp_iRuneTimeEffect[pId][RUNE_REGEN]);
				if(--gp_iRuneTimeEffect[pId][RUNE_REGEN] <= 0)
					gp_iRune[pId] &= ~(1 << RUNE_REGEN);
				else {
					static Float: fHealth; fHealth = entity_get_float(pId, EV_FL_health) + RUNE_REGEN__HP;
					fHealth > RUNE_REGEN__MAX_HP ? entity_set_float(pId, EV_FL_health, RUNE_REGEN__MAX_HP) : entity_set_float(pId, EV_FL_health, fHealth);
				}
			}

if(gp_iRune[pId] & (1 << RUNE_INVISE))	{
				formatex(szRuneInfo[RUNE_INVISE], charsmax(szRuneInfo[]), "%L", pId, "ROQ_HUD_INFO_RUNE_INVISE", gp_iRuneTimeEffect[pId][RUNE_INVISE]);
				if(--gp_iRuneTimeEffect[pId][RUNE_INVISE] <= 0)	{
					gp_iRune[pId] &= ~(1 << RUNE_INVISE);
					
					if(gp_iEyesId[pId])	{
						funcRemoveEnt(gp_iEyesId[pId]);
						gp_iEyesId[pId] = 0;
					}
					
					UTIL_SetPlayerRendering(pId, kRenderFxNone, Float: {0.0, 0.0, 0.0}, kRenderNormal, 0.0);
				}
			}
			
			if(gp_iRune[pId] & (1 << RUNE_SPEED))	{
				formatex(szRuneInfo[RUNE_SPEED], charsmax(szRuneInfo[]), "%L", pId, "ROQ_HUD_INFO_RUNE_SPEED", gp_iRuneTimeEffect[pId][RUNE_SPEED]);
				if(--gp_iRuneTimeEffect[pId][RUNE_SPEED] <= 0)	{
					gp_iRune[pId] &= ~(1 << RUNE_SPEED);
					
					ExecuteHamB(Ham_CS_Player_ResetMaxSpeed, pId);
				}
			}
		}
	}

set_hudmessage(RUNE_HUD_INFO_COLOR, RUNE_HUD_INFO_POS, 0, 0.0, 0.8, 0.2, 0.2, -1);
	ShowSyncHudMsg(pId, g_iSyncHudRuneInfo, "%L%s%s%s%s%s", pId, "ROQ_HUD_INFO_RUNE_TITLE", szRuneInfo[RUNE_DMG], szRuneInfo[RUNE_SPEED], szRuneInfo[RUNE_PROTECT], szRuneInfo[RUNE_REGEN], szRuneInfo[RUNE_INVISE]);

return PLUGIN_HANDLED;
}

/*================================================================================
 [STOCK]
=================================================================================*/
public funcRandomSpawnRune()	{
	if(!(g_iArraySizeRunePosition))
		return PLUGIN_HANDLED;
	
	funcRemoveEnt();

new Array: aRuneRandomPos = ArrayCreate(ENUM_DATA_POS);
	for(new iCount = 0, Float: fOrigin[ENUM_DATA_POS]; iCount < g_iArraySizeRunePosition; iCount++)	{
		ArrayGetArray(g_aRunePosition, iCount, fOrigin);
		ArrayPushArray(aRuneRandomPos, fOrigin);
	}

#if defined RUNE_DEBUG_MODE
		log_amx("============================");
	#endif

for(new iCount = 0, iRandomPos = 0, Float: fOrigin[ENUM_DATA_POS]; iCount < g_iArraySizeRunePosition; iCount++)	{
		iRandomPos = random(ArraySize(aRuneRandomPos));
		ArrayGetArray(aRuneRandomPos, iRandomPos, fOrigin);
		ArrayDeleteItem(aRuneRandomPos, iRandomPos);
		
		#if defined RUNE_DEBUG_MODE
			log_amx("[Rune - %d] - [%f] [%f] [%f]", iCount, fOrigin[0], fOrigin[1], fOrigin[2]);
		#endif
		
		funcCreateRune(fOrigin);
	}
	
	ArrayDestroy(aRuneRandomPos);
	
	return PLUGIN_HANDLED;
}

static stock funcCreateRune(const Float: fOrigin[3], const bool: bRandom = true)	{
	new eId = create_entity("info_target");
	if(is_valid_ent(eId))	{
		entity_set_origin(eId, fOrigin);
		entity_set_model(eId, g_szRuneMdl);

new iRuneRandom;
		do iRuneRandom = random_num(RUNE_NULL + 1, RUNE_MAX - 1);
		while (!(g_RuneSettings[iRuneRandom][RUNE_MODE]));

entity_set_int(eId, EV_INT_body, iRuneRandom);
		entity_set_int(eId, EV_INT_iuser1, iRuneRandom);
		entity_set_int(eId, EV_INT_iuser2, g_iCountRune);
		entity_set_int(eId, EV_INT_solid, g_bRuneEdit ? SOLID_BBOX : SOLID_TRIGGER);
		
		entity_set_float(eId, EV_FL_framerate, 1.0);
		
		entity_set_string(eId, EV_SZ_classname, "rune");
		
		entity_set_size(eId, Float:{-20.5, -20.5, 0.0}, Float:{20.5, 20.5, 60.5});

drop_to_floor(eId);
		
		if(bRandom) ArraySetArray(g_aRunePosition, g_iCountRune, fOrigin);
		
		g_iCountRune++;
	}
}

static stock funcRemoveEnt(eId = FM_NULLENT)	{
	if(eId != -1) entity_set_int(eId, EV_INT_flags, entity_get_int(eId, EV_INT_flags) | FL_KILLME);
	else {
 		g_iCountRune = 0;
		
		while((eId = find_ent_by_class(eId, "rune")))
			entity_set_int(eId, EV_INT_flags, entity_get_int(eId, EV_INT_flags) | FL_KILLME);
	}
}

/*================================================================================
 [UTIL]
=================================================================================*/
static stock UTIL_ScreenFade(const pId, const iDuration, const iHoldTime, const iFlags, const iRed, const iBlue, const iGreen, const iAlpha, const iReliable = 0)	{
	message_begin(iReliable ? MSG_ONE : MSG_ONE_UNRELIABLE, MsgId_ScreenFade, .player = pId);
	{
		write_short(iDuration);
		write_short(iHoldTime);
		write_short(iFlags);
		write_byte(iRed);
		write_byte(iBlue);
		write_byte(iGreen);
		write_byte(iAlpha);
	}

message_end();
}

static stock UTIL_GetAimingPosition(const pId, const Float: fReturn[3])	{
	new Float: fVecStart[3], Float: fVecEnd[3];
	
	entity_get_vector(pId, EV_VEC_origin, fVecStart);
	entity_get_vector(pId, EV_VEC_view_ofs, fVecEnd);
	
	fVecStart[0] += fVecEnd[0];
	fVecStart[1] += fVecEnd[1];
	fVecStart[2] += fVecEnd[2];
	
	entity_get_vector(pId, EV_VEC_v_angle, fVecEnd);

engfunc(EngFunc_MakeVectors, fVecEnd);
	global_get(glb_v_forward, fVecEnd);

fVecEnd[0] = fVecStart[0] + fVecEnd[0] * 8192.0;
	fVecEnd[1] = fVecStart[1] + fVecEnd[1] * 8192.0;
	fVecEnd[2] = fVecStart[2] + fVecEnd[2] * 8192.0;

engfunc(EngFunc_TraceLine, fVecStart, fVecEnd, DONT_IGNORE_MONSTERS, pId, 0);
	get_tr2(0, TR_vecEndPos, fReturn);
}

static stock UTIL_SetPlayerRendering(const pId, const iRenderFx, const Float: fColor[3], const iRenderMode, const Float: fRenderAmt)	{
	entity_set_int(pId, EV_INT_renderfx, iRenderFx);

entity_set_vector(pId, EV_VEC_rendercolor, fColor);
	
	entity_set_int(pId, EV_INT_rendermode, iRenderMode);
	
	entity_set_float(pId, EV_FL_renderamt, fRenderAmt);
}

static stock UTIL_LogToFile(const szError[], any:...)	{
	new szLog[64], szData[24];
	get_time("roq_error_%Y%m%d.log", szData, charsmax(szData));
	formatex(szLog, charsmax(szLog), "addons/amxmodx/logs/%s", szData);
	log_to_file(szLog, szError);
	
	pause("ad");
}

Загрузил ADEPT

2020-02-23 20:14:26

Скачать

195.211.60.213:27015

УКРАЇНА - Б А Н Д Е Р Ш Т А Т - [2000 FPS] 18+

195.211.60.213:27018

В І Л Ь Н А - У К Р А Ї Н А [ RYZEN 9 - 5.7 GHZ ]

195.211.60.213:27016

(Д) (І) (В) (О) (Ч) (А) - (В) (Л) (А) (Д) (А) | 18+

195.211.60.213:27017

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

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

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

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