Грешка error 010: invalid function or declaration

[smurfavr]

Като се опитам да компилирам плъгина локално изкарва тази грешка. Като го компилирам онлайн не показва никаква грешка.На какво се дължи това и как да го оправя?

Код за потвърждение: Избери целия код

//// 1laser_tripmine_Teams_Color.amxx
// D:\server-batman\valve\addons\amxmodx\scripting\1laser_tripmine_Teams_Color.a
mxx(1) : error 010: invalid function or declaration

► Покажи скъсения текст

Код за потвърждение: Избери целия код

#pragma semicolon 1
#pragma ctrlchar '\'

#include <amxmodx>
#include <fakemeta_util>
#include <hamsandwich>
#include <xs>

#define PLUGIN "Lasermine/TripMine TeamColor"
#define VERSION "1.1"
#define AUTHOR "KORD_12.7, Gauss, PomanoB, KORD_12.7"

#define TRIPMINE_LASER		pev_iuser4
#define TRIPMINE_OWNER		pev_iuser3
#define TRIPMINE_BEAM		pev_iuser2
#define TRIPMINE_SPARKS_DELAY	pev_fuser4
#define TRIPMINE_BLOOD_DELAY	pev_fuser3
#define TRIPMINE_FRACTION_OLD	pev_fuser2

#define MAX_PLAYERS		32

#define IsPlayer(%1) (1 <= %1 <= g_MaxPlayers)
 

enum TRIPMINE
{
	TRIPMINE_MODE,
	Float: TRIPMINE_DELAY,
	
	TRIPMINE_END
};
 
new const 
m_flPowerUp = 166,
m_vecEnd_x = 170,
m_vecEnd_y = 171,
m_vecEnd_z = 172,
m_pBeam = 176,
extraoffset_linux = 4,

SPRITE_BLOOD[] = "sprites/blood.spr",
SPRITE_BLOOD2[] = "sprites/bloodspray.spr";

new 
m_iBlood[2],
g_MaxPlayers,
g_Tripmines[MAX_PLAYERS + 1][TRIPMINE_END],

pcvar_lasermine_enable,
pcvar_lasermine_laser_damage,
pcvar_lasermine_laser_color,
pcvar_lasermine_laser_width,
pcvar_lasermine_laser_noise,
pcvar_lasermine_laser_bright;

new
Array: g_Colors,
g_CvarTripmineRender,
g_CvarLaserColor,
g_CvarLaserBrightness,
g_IsRandomRGB, 
g_BrightCached,
g_RGB[3];

public plugin_init() 
{
	register_plugin(PLUGIN, VERSION, AUTHOR);
	register_cvar("lasermines/tripmine_version", VERSION, FCVAR_SPONLY | FCVAR_SERVER | FCVAR_UNLOGGED);

	register_forward(FM_CmdStart, "fw_CmdStart");
	register_forward(FM_TraceLine, "fw_TraceLine", 1);
	register_forward(FM_AddToFullPack, "fwdAddToFullPack", 1);
	
	RegisterHam(Ham_Spawn, "monster_tripmine", "Tripmine_Spawn_Post", 1);
	RegisterHam(Ham_Think, "monster_tripmine", "Tripmine_Think_Post", 1);
	
	pcvar_lasermine_enable = register_cvar("lasermine_enable", "1");
	pcvar_lasermine_laser_damage = register_cvar("lasermine_laser_damage", "60.0");
	pcvar_lasermine_laser_color = register_cvar("lasermine_laser_color", "255000000");
	pcvar_lasermine_laser_width = register_cvar("lasermine_laser_width", "10");
	pcvar_lasermine_laser_noise = register_cvar("lasermine_laser_noise", "0");
	pcvar_lasermine_laser_bright = register_cvar("lasermine_laser_brightness", "64");
	
	g_CvarLaserColor = register_cvar("tripmine_laser_color", "random");
	g_CvarLaserBrightness = register_cvar("tripmine_laser_brightness", "200");
	g_CvarTripmineRender = register_cvar("tripmine_render", "1");

	g_Colors = ArrayCreate(3);
	
	g_MaxPlayers = get_maxplayers();
}

public plugin_precache()
{
	m_iBlood[0] = precache_model(SPRITE_BLOOD);
	m_iBlood[1] = precache_model(SPRITE_BLOOD2);
}

public plugin_cfg()
{
	new color[16];
	get_pcvar_string(g_CvarLaserColor, color, charsmax(color));
	
	if(equali(color, "random"))
	{
		g_IsRandomRGB = 1;
		
		new i, maxEnt = global_get(glb_maxEntities);
		
		for(i = 0; i < maxEnt; i++) 
			ArrayPushArray(g_Colors, {0, 0, 0});
	}
	else
	{
		g_IsRandomRGB = 0;
		
		new r[4], g[4], b[4]; trim(color);
		parse(color, r, charsmax(r), g, charsmax(g), b, charsmax(b));
		
		g_RGB[0] = str_to_num(r);
		g_RGB[1] = str_to_num(g);
		g_RGB[2] = str_to_num(b);
	}
	
	g_BrightCached = get_pcvar_num(g_CvarLaserBrightness);
}

public plugin_end()
{
	ArrayDestroy(g_Colors);
}

public fw_TraceLine(Float:start[3], Float:dest[3], ignore_monsters, ent, ptr)
{
	if (!pev_valid(ent))
		return FMRES_IGNORED;

	static classname[32];
	pev(ent, pev_classname, classname, charsmax(classname));
	
	if (equali(classname, "monster_tripmine") && pev(ent, TRIPMINE_LASER))
	{	
		if (get_pdata_float(ent, m_flPowerUp, extraoffset_linux) < get_gametime())
		{
			set_tr2(ptr, TR_flFraction, 0.0001);
			return FMRES_HANDLED;
		}
	}
	
	return FMRES_IGNORED;
}

public fw_CmdStart(id, UC_Handle, seed)
{
	if (!is_user_alive(id) || !get_pcvar_num(pcvar_lasermine_enable) || get_user_weapon(id) != HLW_TRIPMINE)
		return FMRES_IGNORED;
		
	static buttons; buttons = get_uc(UC_Handle, UC_Buttons);	
	static Float:gametime; gametime = get_gametime();
		
	if (buttons & IN_ATTACK)
	{
		g_Tripmines[id][TRIPMINE_MODE] = 0;
	}
	else if (buttons & IN_ATTACK2 && g_Tripmines[id][TRIPMINE_DELAY] < gametime)
	{	
		new ptr = create_tr2();
		
		new Float: vecSrc[3];
		new Float: vecAiming[3];
		new Float: fraction;

		GetGunPosition(id, vecSrc);
		velocity_by_aim(id, 128, vecAiming);
		xs_vec_add(vecAiming, vecSrc, vecAiming);
		
		engfunc(EngFunc_TraceLine, vecSrc, vecAiming, DONT_IGNORE_MONSTERS, id, ptr);
		
		get_tr2(ptr, TR_flFraction, fraction); 
		free_tr2(ptr);

		if (fraction < 1.0)
		{
			UTIL_PlayWeaponAnimation(id, 6);
			
			g_Tripmines[id][TRIPMINE_MODE] = 1;
			g_Tripmines[id][TRIPMINE_DELAY] = _:(gametime + 0.3);
			
			ExecuteHamB(Ham_Weapon_PrimaryAttack, fm_get_user_weapon_entity(id, HLW_TRIPMINE));
		}
	}	
		
	return FMRES_IGNORED;	
}

public Tripmine_Spawn_Post(ent)
{
	if (pev_valid(ent))
	{
		new rgb[3];
		new id = pev(ent, pev_owner);
		if(g_IsRandomRGB)
		{				
			if(pev_valid(id))
			{
				new team = get_user_team(id);
				
				if(team==0)
					rgb = {0,255,0};
				if(team==1)
					rgb = {0,0,255};
				if(team==2)
					rgb = {255,0,0};
					
			}
		
			ArraySetArray(g_Colors, ent, rgb);
		}
		else
		{
			rgb[0] = g_RGB[0];
			rgb[1] = g_RGB[1];
			rgb[2] = g_RGB[2];
		}
		
		if(get_pcvar_num(g_CvarTripmineRender))
			fm_set_rendering(ent, kRenderFxGlowShell, rgb[0], rgb[1], rgb[2], kRenderNormal, 16);
		
		if (g_Tripmines[id][TRIPMINE_MODE])
			set_pev(ent, pev_dmg, get_pcvar_float(pcvar_lasermine_laser_damage));
		
		set_pev(ent, TRIPMINE_LASER, g_Tripmines[id][TRIPMINE_MODE]);
		set_pev(ent, TRIPMINE_OWNER, id);
	}
	
	return HAM_IGNORED;
}

public Tripmine_Think_Post(ent)
{
	static Float: flTime;
	if (!pev_valid(ent) || !pev(ent, TRIPMINE_LASER) || get_pdata_float(ent, m_flPowerUp, extraoffset_linux) > (flTime = get_gametime()))
		return HAM_IGNORED;
	
	set_pev(ent, pev_nextthink, flTime + 0.05);
	
	static beam; beam = get_pdata_cbase(ent, m_pBeam, extraoffset_linux);
	if (!pev_valid(beam)) return HAM_IGNORED;
			
	if (!pev(ent, TRIPMINE_BEAM))
	{
		new Float: rgb[3];
		GetBeamColor(rgb);
		
		set_pev(beam, pev_rendercolor, rgb);
		set_pev(beam, pev_scale, get_pcvar_float(pcvar_lasermine_laser_width));
		set_pev(beam, pev_body, get_pcvar_num(pcvar_lasermine_laser_noise));
		set_pev(beam, pev_renderamt, get_pcvar_float(pcvar_lasermine_laser_bright));
		
		set_pev(ent, TRIPMINE_BEAM, 1);
	}
			
	static Float: vecEnd[3];
	static Float: origin[3];
	static Float: fraction;
	static Float: damage;
	
	static ptr, pHit;
		
	pev(ent, pev_origin, origin);
	pev(ent, pev_dmg, damage);
		
	vecEnd[0] = get_pdata_float(ent, m_vecEnd_x, extraoffset_linux);
	vecEnd[1] = get_pdata_float(ent, m_vecEnd_y, extraoffset_linux);
	vecEnd[2] = get_pdata_float(ent, m_vecEnd_z, extraoffset_linux);
	
	ptr = create_tr2();
	
	engfunc(EngFunc_TraceLine, origin, vecEnd, DONT_IGNORE_MONSTERS, ent, ptr);
	
	get_tr2(ptr, TR_vecEndPos, vecEnd);
	get_tr2(ptr, TR_flFraction, fraction);
	
	pHit = get_tr2(ptr, TR_pHit);
	
	if (fraction < 1.0)
	{
		get_tr2(ptr, TR_vecEndPos, vecEnd);
		
		if (pev_valid(pHit))
		{
			static Float: BloodDelay; 
			pev(ent, TRIPMINE_BLOOD_DELAY, BloodDelay);
			
			if (BloodDelay  < flTime) // Say no to "Overflow 500 temporary ents" :D
			{
				set_pev(ent, TRIPMINE_BLOOD_DELAY, flTime + 0.1);
				UTIL_MakeBlood(vecEnd, damage, pHit);
			}
			
			ExecuteHamB(Ham_TakeDamage, pHit, ent, pev(ent, TRIPMINE_OWNER), damage, DMG_ENERGYBEAM | DMG_ALWAYSGIB);
		}
	}
	
	free_tr2(ptr);
	
	static Float: fractionOld; 
	pev(ent, TRIPMINE_FRACTION_OLD, fractionOld);
	
	if (fractionOld != fraction)
	{
		RelinkBeam(beam, vecEnd, vecEnd, origin);
		set_pev(ent, TRIPMINE_FRACTION_OLD, fraction);
	}
	
	static Float: SparksDelay; 
	pev(ent, TRIPMINE_SPARKS_DELAY, SparksDelay);
	
	if (SparksDelay  < flTime && !IsPlayer(pHit))
	{
		set_pev(ent, TRIPMINE_SPARKS_DELAY, flTime + 0.1);
		
		message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
		write_byte(TE_SPARKS);
		engfunc(EngFunc_WriteCoord, vecEnd[0]);
		engfunc(EngFunc_WriteCoord, vecEnd[1]);
		engfunc(EngFunc_WriteCoord, vecEnd[2]);
		message_end();
	}
	
	return HAM_IGNORED;	
}

public fwdAddToFullPack(es, e, ent, host, flags, player, set)
{
	if(pev_valid(ent))
	{
		static classname[32];
		pev(ent, pev_classname, classname, charsmax(classname));
		
		if(equali(classname, "beam"))
		{
			static ent2;
			ent2 = pev(ent, pev_skin);

			if(pev_valid(ent2))
			{   
				pev(ent2, pev_classname, classname, charsmax(classname));
				
				if(equali(classname, "monster_tripmine"))
				{
					static rgb[3]; ArrayGetArray(g_Colors, ent2, rgb);
					set_es(es, ES_RenderColor, rgb);
					
					set_es(es, ES_RenderAmt, g_BrightCached);
					set_es(es, ES_Body, 0);
					
					return FMRES_HANDLED;
				}
			}
		}
	}
	
	return FMRES_IGNORED;
}

RelinkBeam(const beam, const Float: Origin[3], const Float: startPos[3], const Float: endPos[3])
{
	static Float: mins[3], Float: maxs[3];
	
	mins[0] = floatmin(startPos[0], endPos[0]);
	mins[1] = floatmin(startPos[1], endPos[1]);
	mins[2] = floatmin(startPos[2], endPos[2]);
	
	maxs[0] = floatmax(startPos[0], endPos[0]);
	maxs[1] = floatmax(startPos[1], endPos[1]);
	maxs[2] = floatmax(startPos[2], endPos[2]);
	
	xs_vec_sub(mins, Origin, mins);
	xs_vec_sub(maxs, Origin, maxs);
	
	set_pev(beam, pev_mins, mins);
	set_pev(beam, pev_maxs, maxs);
	
	engfunc(EngFunc_SetSize, beam, mins, maxs);
	engfunc(EngFunc_SetOrigin, beam, Origin);
}

GetBeamColor(Float: rgb[3])
{
	new color_str[10], color, red, green, blue;
	get_pcvar_string(pcvar_lasermine_laser_color, color_str, charsmax(color_str));
		
	color = str_to_num(color_str);
	red = color / 1000000;
	color %= 1000000;
	green = color / 1000;
	blue = color % 1000;
		
	rgb[0] = float(red);
	rgb[1] = float(green);
	rgb[2] = float(blue);
}

stock GetGunPosition(const player, Float:origin[3] )
{
	new Float:viewOfs[3];
	
	pev(player, pev_origin, origin);
	pev(player, pev_view_ofs, viewOfs);
    
	xs_vec_add( origin, viewOfs, origin);
}

stock UTIL_PlayWeaponAnimation(const Player, const Sequence)
{
	set_pev(Player, pev_weaponanim, Sequence);
	
	message_begin(MSG_ONE_UNRELIABLE, SVC_WEAPONANIM, .player = Player);
	write_byte(Sequence);
	write_byte(pev(Player, pev_body));
	message_end();
}

stock UTIL_MakeBlood(const Float:vTraceEnd[3], const Float:Damage, const hitEnt) 
{
	new bloodColor = ExecuteHam(Ham_BloodColor, hitEnt);
	if (bloodColor == -1) return;

	new amount = floatround(Damage); amount *= 2;
	
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY);
	write_byte(TE_BLOODSPRITE);
	engfunc(EngFunc_WriteCoord, vTraceEnd[0]);
	engfunc(EngFunc_WriteCoord, vTraceEnd[1]);
	engfunc(EngFunc_WriteCoord, vTraceEnd[2]);
	write_short(m_iBlood[1]);
	write_short(m_iBlood[0]);
	write_byte(bloodColor);
	write_byte(min(max(3, amount/10), 16));
	message_end();
}

[OciXCrom]

Кодировката на .sma файла е грешна. Смени я на UTF-8 without BOM (или само UTF-8, не си спомням точно, опитай с двете).

[smurfavr]

Беше на UTF-8 и я смених на bom,но няма разлика при компилирането.

[OciXCrom]

Опитай с ANSI. Ако не става, направо вземи друг .sma файл който се компилира и премести кода в него.

[smurfavr]

Така вече не дава грешка.