[red_bull2oo6]

Hi, we meet again.
I have this little problem.

This is my code

PHP Code:

/* Plugin generated by AMXX-Studio */

    #include < amxmodx >
    #include < engine >
    #include < fun >
    
    #pragma semicolon 1
    
    new const
        PLUGIN_NAME[ ]         = "Blank Spawns",
        PLUGIN_VERSION[ ]     = "1.0";
    
    new const
        PLUGIN_TAG[ ]        = "|Plugin Tag:";
        
    enum _:iSpawns
    {
        NULL,
        TERO,
        CT
    }
    
    new Float:g_fOrigins[ iSpawns ][ 64 ][ 3 ];
    new g_iSpawns[ iSpawns ];
    
    
    new bool:g_bUserIsBlanked[ 33 ];
            
public plugin_init( )
{
    register_plugin
    (
        PLUGIN_NAME,
        PLUGIN_VERSION,
        "Askhanar"
    );
    
    GetSpawnsOrigins( );
    // Add your code here...
    
}

public client_PreThink( id )
{
    if( !is_user_alive( id ) )
        return;
        
    static Float:fOrigin[ 3 ];
    
    
    
    entity_get_vector( id, EV_VEC_origin, fOrigin );
    
    static Float:fDistance, Float:fClosest;
    
    fClosest = 9999.0;
    switch( get_user_team( id ) )
    {
        case 1:
        {
            for( new i = 0; i < g_iSpawns[ CT ]; i++ )
            {
                fDistance = get_distance_f( fOrigin, g_fOrigins[ CT ][ i ] );
                if( fDistance < fClosest )
                    fClosest = fDistance;
            }
            
        }
        case 2:
        {
            for( new i = 0; i < g_iSpawns[ TERO ]; i++ )
            {
                fDistance = get_distance_f( fOrigin, g_fOrigins[ TERO ][ i ] );
                if( fDistance < fClosest )
                    fClosest = fDistance;
            }
            
        }
    }
    
    if( fClosest <= 255.0 && !g_bUserIsBlanked[ id ] )
    {
        
        g_bUserIsBlanked[ id ] = true;
        set_user_hitzones( id, 0, 0 );
        client_print( id, print_chat, "%s You are now fireing blanks!", PLUGIN_TAG );
        client_print( id, print_chat, "%s %.3f", PLUGIN_TAG, fClosest );
        
    }
    else if( fClosest > 255.0 && g_bUserIsBlanked[ id ] )
    {
        g_bUserIsBlanked[ id ] = false;
        set_user_hitzones( id, 0, 255 );
        client_print( id, print_chat, "%s You're not fireing blanks anymore!", PLUGIN_TAG );
        client_print( id, print_chat, "%s %.3f", PLUGIN_TAG, fClosest );
    }
}

stock Float:get_distance_float( const Float:fOrigin[ 3 ], const Float:flOrigin[ 3 ] )
{
    return ( ( fOrigin[ 0 ] - flOrigin[ 0 ] ) + ( fOrigin[ 1 ] - flOrigin[ 1 ] ) );
}

GetSpawnsOrigins( )
{
    new iEnt;
    while( ( iEnt = find_ent_by_class( iEnt, "info_player_deathmatch") ) )
    {
        if( iEnt > 0 && ++g_iSpawns[ TERO ] < 64 )
        {
            entity_get_vector( iEnt, EV_VEC_origin, g_fOrigins[ TERO ][ g_iSpawns[ TERO ] ] );
            g_iSpawns[ TERO ]++;
        }
    }
    
    iEnt = -1;
    while( ( iEnt = find_ent_by_class( iEnt, "info_player_start") ) )
    {
        if( iEnt > 0 && ++g_iSpawns[ CT ] < 64 )
        {
            entity_get_vector( iEnt, EV_VEC_origin, g_fOrigins[ CT ][ g_iSpawns[ CT ] ] );
            g_iSpawns[ CT ]++;
        }
    }
    
    /*log_amx( "Loaded %i T and %i CT", g_iSpawns[ TERO ], g_iSpawns[ CT ] );
    
    for( new i = 0; i < g_iSpawns[ TERO ]; i++ )
        log_amx( "[T %i] %f %f %f", i +1, g_fOrigins[ TERO ][ i ][ 0 ], g_fOrigins[ TERO ][ 1 ], g_fOrigins[ TERO ][ 2 ] );
        
    for( new i = 0; i < g_iSpawns[ CT ]; i++ )
        log_amx( "[CT %i] %f %f %f", i +1, g_fOrigins[ CT ][ i ][ 0 ], g_fOrigins[ CT ][ 1 ], g_fOrigins[ CT ][ 2 ] );
    
    */
} 


On de_dust2, when i walk around upside CT spawn ( see screenshot ) i get blanks ..
Click for ScreenShot ( imgur )

what can i do to check only horizontal distance ( x & y.. i mean forward/backward & right/left ) ?

[fysiks]

get_distance_f() gives the straight-line distance between two points (in 3 dimensions). If you need to get the x and y distances then you should do it manually using the to points (simple subtraction of the corresponding values).

[claudiuhks]

PHP Code:

/***
*
*    Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*    
*    This product contains software technology licensed from Id 
*    Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
*    All Rights Reserved.
*
*   Use, distribution, and modification of this source code and/or resulting
*   object code is restricted to non-commercial enhancements to products from
*   Valve LLC.  All other use, distribution, or modification is prohibited
*   without written permission from Valve LLC.
*
****/
#ifndef VECTOR_H
#define VECTOR_H

//=========================================================
// 2DVector - used for many pathfinding and many other 
// operations that are treated as planar rather than 3d.
//=========================================================
class Vector2D
{
public:
    inline Vector2D(void): x(0.0), y(0.0)                            { }
    inline Vector2D(float X, float Y): x(0.0), y(0.0)                { x = X; y = Y; }
    inline Vector2D operator+(const Vector2D& v)    const    { return Vector2D(x+v.x, y+v.y);    }
    inline Vector2D operator-(const Vector2D& v)    const    { return Vector2D(x-v.x, y-v.y);    }
    inline Vector2D operator*(float fl)                const    { return Vector2D(x*fl, y*fl);    }
    inline Vector2D operator/(float fl)                const    { return Vector2D(x/fl, y/fl);    }
    
    inline float Length(void)                        const    { return sqrt(x*x + y*y );        }

    inline Vector2D Normalize ( void ) const
    {
        // Vector2D vec2;

        float flLen = Length();
        if ( flLen == 0 )
        {
            return Vector2D( 0, 0 );
        }
        else
        {
            flLen = 1 / flLen;
            return Vector2D( x * flLen, y * flLen );
        }
    }

    vec_t    x, y;
};

inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
inline Vector2D operator*(float fl, const Vector2D& v)    { return v * fl; }

//=========================================================
// 3D Vector
//=========================================================
class Vector                        // same data-layout as engine's vec3_t,
{                                //        which is a vec_t[3]
public:
    // Construction/destruction
    inline Vector(void): x(0.0), y(0.0), z(0.0)                    { }
    inline Vector(float X, float Y, float Z): x(0.0), y(0.0), z(0.0)    { x = X; y = Y; z = Z;                }
    //inline Vector(double X, double Y, double Z)        { x = (float)X; y = (float)Y; z = (float)Z;    }
    //inline Vector(int X, int Y, int Z)                { x = (float)X; y = (float)Y; z = (float)Z;    }
    inline Vector(const Vector& v): x(0.0), y(0.0), z(0.0)        { x = v.x; y = v.y; z = v.z;                } 
    inline Vector(float rgfl[3]): x(0.0), y(0.0), z(0.0)        { x = rgfl[0]; y = rgfl[1]; z = rgfl[2];    }

    // Operators
    inline Vector operator-(void) const                { return Vector(-x,-y,-z);                }
    inline int operator==(const Vector& v) const    { return x==v.x && y==v.y && z==v.z;    }
    inline int operator!=(const Vector& v) const    { return !(*this==v);                    }
    inline Vector operator+(const Vector& v) const    { return Vector(x+v.x, y+v.y, z+v.z);    }
    inline Vector operator-(const Vector& v) const    { return Vector(x-v.x, y-v.y, z-v.z);    }
    inline Vector operator*(float fl) const            { return Vector(x*fl, y*fl, z*fl);        }
    inline Vector operator/(float fl) const            { return Vector(x/fl, y/fl, z/fl);        }
    
    // Methods
    inline void CopyToArray(float* rgfl) const        { rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
    inline float Length(void) const                    { return sqrt(x*x + y*y + z*z); }
    operator float *()                                { return &x; } // Vectors will now automatically convert to float * when needed
    operator const float *() const                    { return &x; } // Vectors will now automatically convert to float * when needed
    inline Vector Normalize(void) const
    {
        float flLen = Length();
        if (flLen == 0) return Vector(0,0,1); // ????
        flLen = 1 / flLen;
        return Vector(x * flLen, y * flLen, z * flLen);
    }

    inline Vector2D Make2D ( void ) const
    {
        Vector2D    Vec2;

        Vec2.x = x;
        Vec2.y = y;

        return Vec2;
    }
    inline float Length2D(void) const                    { return sqrt(x*x + y*y); }

    // Members
    vec_t x, y, z;
};
inline Vector operator*(float fl, const Vector& v)    { return v * fl; }
inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }



#endif 


PHP Code:

void Function(void) {
  Vector2D m, n;
  float len = (m - n).Length();
} 


Vector.h content, hope it helps.
Length2d request was made for AMX Mod X development build.

[avril-lavigne]

today I used entity_range

it works 100%

[fysiks]

Originally Posted by avril-lavigne today I used entity_range it works 100%

Based on the documentation, that give a distance in 3D and is not what the OP is asking for.

[red_bull2oo6]

@fysiks i'll try your idea tonight when i reach home.
@claudiuhsk i suk at c++ and i don't really understand.
@avril-lavighe i think i tried it..

i'll edit later. ty for your answers.

[claudiuhks]

Originally Posted by red_bull2oo6 @fysiks i'll try your idea tonight when i reach home. @claudiuhsk i suk at c++ and i don't really understand. @avril-lavighe i think i tried it.. i'll edit later. ty for your answers.

PHP Code:

stock math_CancelApplicate(Vector[3])
{
  Vector[2] = 0;
}

stock math_CancelApplicateF(Float:Vector[3])
{
  Vector[2] = 0.0;
}

stock math_Distance2D(VectorA[3], VectorB[3])
{
  math_CancelApplicate(VectorA);
  math_CancelApplicate(VectorB);

  return get_distance(VectorA, VectorB);
}

stock Float:math_DistanceF2D(Float:VectorA[3], Float:VectorB[3])
{
  math_CancelApplicateF(VectorA);
  math_CancelApplicateF(VectorB);

  return get_distance_f(VectorA, VectorB);
} 


[red_bull2oo6]

thanks a lot
works flawlessly now.

i tried to set the z axe to 9999.0 and nothing happened, never tried to set it to NULL