/*
	Вернет 1, если строка содержит любой нормальный ИП
*/

stock isTextHaveAnyIP ( string[] )
{
	for ( new pos, digits; string[pos] > 0; pos++ )
	{
		switch ( string[pos] )
		{
			case '0'..'9', 'o', 'O', 'о', 'О' :		{ if ( ++digits > 2 ) return 1; }
			case 30..47, 91..96, 123..183, 185..191 :	{ continue; }
			default :					{ digits = 0; }
		}
	}

	return 0;
}

stock swap(&x,&y)
{
  new c = x;
  x = y;
  y = c;
}

stock ZMapCheckLOS(Float:x1, Float:y1, Float:z1, Float:x2, Float:y2, Float:z2)
{
	new Float: distance = GetDistanceBetweenPoints(x1, y1, z1, x2, y2, z1); // вычислить расстояние между точками в 2D
	new Float: rotation = GetRotationBetweenPoints(x1, y1, x2, y2);			// вычислить арктангенс между точками
	new Float: z_per_meter = (z2 - z1) / distance;	// это число = на сколько изменяется Z на каждый метр расстояния
	new Float: sin = floatsin(-rotation, degrees);
	new Float: cos = floatcos(-rotation, degrees);
	
	new Float: check_dist = 0.0;		// текущее расстояние пути проверки от точки 1 к точке 2
	
	while(check_dist < distance)
	{
		check_dist += 1.0;
		
		new Float:z_zmap;
		ZMapFindZ(x1 + (check_dist * sin), y1 + (check_dist * cos), z_zmap);
		
		// чтобы отследить визуально, где кончается "видимая" дистанция :)
		// CreateObject(1559, x1 + (check_dist * sin), y1 + (check_dist * cos), z1 + (check_dist * z_per_meter), 0, 0, 0);
		
		if(z1 + (check_dist * z_per_meter) < z_zmap)
		{
			return 0;
		}
	}
	return 1;
}

stock Float:GetDistanceBetweenPoints(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2)
{
	x1 -= x2;
	y1 -= y2;
	z1 -= z2;
	return floatsqroot((x1 * x1) + (y1 * y1) + (z1 * z1));
}

stock Float:GetRotationBetweenPoints(Float:x1, Float:y1, Float:x2, Float:y2)
return Float:(180-atan2(x1-x2,y1-y2));

stock getPlayerName(playerid, del=0) {
	new name[MAX_PLAYER_NAME];
	GetPlayerName(playerid, name, MAX_PLAYER_NAME);
	if(del) name[strfind(name, "_")] = ' ';
	return name;
}

//
stock SendFormattedMessage(playerid, color, fstring[], {Float, _}:...)
{
    // This is the number of parameters which are not variable that are passed
    // to this function (i.e. the number of named parameters).
    static const
        STATIC_ARGS = 3;
    // Get the number of variable arguments.
    new
        n = (numargs() - STATIC_ARGS) * BYTES_PER_CELL;
    if (n)
    {
        new
            message[128],
            arg_start,
            arg_end;

        // Load the real address of the last static parameter. Do this by
        // loading the address of the last known static parameter and then
        // adding the value of [FRM].
        #emit CONST.alt        fstring
        #emit LCTRL          5
        #emit ADD
        #emit STOR.S.pri        arg_start

        // Load the address of the last variable parameter. Do this by adding
        // the number of variable parameters on the value just loaded.
        #emit LOAD.S.alt        n
        #emit ADD
        #emit STOR.S.pri        arg_end

        // Push the variable arguments. This is done by loading the value of
        // each one in reverse order and pushing them. I'd love to be able to
        // rewrite this to use the values of pri and alt for comparison,
        // instead of having to constantly load and reload two variables.
        do
        {
            #emit LOAD.I
            #emit PUSH.pri
            arg_end -= BYTES_PER_CELL;
            #emit LOAD.S.pri      arg_end
        }
        while (arg_end > arg_start);

        // Push the static format parameters.
        #emit PUSH.S          fstring
        #emit PUSH.C          128
        #emit PUSH.ADR         message

        // Now push the number of arguments passed to format, including both
        // static and variable ones and call the function.
        n += BYTES_PER_CELL * 3;
        #emit PUSH.S          n
        #emit SYSREQ.C         format

        // Remove all data, including the return value, from the stack.
        n += BYTES_PER_CELL;
        #emit LCTRL          4
        #emit LOAD.S.alt        n
        #emit ADD
        #emit SCTRL          4

        return SendClientMessage(playerid, color, message);
    }
    else
    {
        return SendClientMessage(playerid, color, fstring);
    }
}

#define BYTES_PER_CELL (cellbits / 8)

new PlayerName[MAX_PLAYERS][MAX_PLAYER_NAME];

GetPlayerName(playerid, PlayerName[playerid], MAX_PLAYER_NAME);

new WeaponName[47][32];

for(new i; i<47; i++)
    {
    if(i == 0) WeaponName[i] = "Fists";
    else if(i == 18) WeaponName[i] = "Molotov";
    else if(i == 44) WeaponName[i] = "Nightvision Goggles";
    else if(i == 45) WeaponName[i] = "Thermal Goggles";
    else GetWeaponName(i, WeaponName[i], 32);
    }

stock upackcell(&cell, value, bit_start, max_bits)
{
    new mask;

    if (bit_start > 0)
    {
        mask = (cellmax << (bit_start + max_bits - 1) |
          (cellmax >> (cellbits - bit_start)));
        cell &= mask;
        cell |= ~mask & (value << (bit_start));
    }
    else
    {
        mask = (cellmax << (max_bits - 1));
        cell &= mask;
        cell |= ~mask & value;
    }
    return value;
}

stock uunpackcell(cell, bit_start, max_bits)
{
    if (bit_start > 0)
        return ((cell & ~(cellmax << bit_start + max_bits - 1)) >> bit_start);
    else
        return (cell & ~(cellmax << bit_start + max_bits - 1));
}

stock spackcell(&cell, value, bit_start, max_bits)
{
    return upackcell(cell, ~value, bit_start, max_bits);
}

stock sunpackcell(cell, bit_start, max_bits)
{
    return ~uunpackcell(cell, bit_start, max_bits);
}

new random3[5];
new Float:random0 = (random3[gTeam[playerid]] * 3.14) / (8.0 / 2.0);
new Float:random1 = floatcos(random0) * 3.0;
new Float:random2 = floatsin(random0) * 3.0;

random3[gTeam[playerid]]++;
random3[gTeam[playerid]] = random3[gTeam[playerid]] % 8;

new gTeam[MAX_PLAYERS];
new Base = 1;

new Float: SetSpawn[2][4] ={
{1733.6282,1068.9877,10.8203,91.8597},
{1661.1990,911.2530,10.7113,3.2558}
};

public OnPlayerSpawn(playerid)
{
    SetPlayerBase(playerid);
    return 1;
}

public SetPlayerBase(playerid)
{
new Float:random0 = (random3[gTeam[playerid]] * 3.14) / (8.0 / 2.0);
new Float:random1 = floatcos(random0) * 3.0;
new Float:random2 = floatsin(random0) * 3.0;

random3[gTeam[playerid]]++;
random3[gTeam[playerid]] = random3[gTeam[playerid]] % 8;
if(Base == 1) {
if(gTeam[playerid] == T_DEF) {
SetPlayerPos(playerid, random1 + SetSpawn[0][0], random2 + SetSpawn[0][1], SetSpawn[0][2]);
SetPlayerFacingAngle(playerid, SetSpawn[0][3]);
}
if(gTeam[playerid] == T_ATT) {
SetPlayerPos(playerid, random1 + SetSpawn[1][0], random2 + SetSpawn[1][1], SetSpawn[0][2]);
SetPlayerFacingAngle(playerid, SetSpawn[1][3]);
}
}
return 1;
}