Allied Modders en español

Versión completa: Comprobar valores de pev's
Actualmente estas viendo una versión simplificada de nuestro contenido. Ver la versión completa con el formato correcto.
Hola,

Me gustaría saber como comprobar el valor de un pev, algo como esto:

Código PHP:
int AddToFullPack_Post(entity_state_s pEntityStateintedict_t pEntityedict_t pHostintint Playerunsigned char *) {
    if(
pEntity->iuser3.value == 35) {
        
    }


Ya se que eso no funciona, es simplemente un ejemplo para que entiendan lo que busco.


En pawn sería como esto:

Código PHP:
iVar pev(pEntitypev_iuser3); // Fakemeta
iVar entity_get_int(pEntityEV_INT_iuser3); // Engine 
Código PHP:
if(pEntity->v.iuser3 == 35

Código PHP:
typedef struct entvars_s
{
    
string_t    classname;
    
string_t    globalname;

    
vec3_t        origin;
    
vec3_t        oldorigin;
    
vec3_t        velocity;
    
vec3_t        basevelocity;
    
vec3_t      clbasevelocity;  // Base velocity that was passed in to server physics so 
                                 //  client can predict conveyors correctly.  Server zeroes it, so we need to store here, too.
    
vec3_t        movedir;

    
vec3_t        angles;            // Model angles
    
vec3_t        avelocity;        // angle velocity (degrees per second)
    
vec3_t        punchangle;        // auto-decaying view angle adjustment
    
vec3_t        v_angle;        // Viewing angle (player only)

    // For parametric entities
    
vec3_t        endpos;
    
vec3_t        startpos;
    
float        impacttime;
    
float        starttime;

    
int            fixangle;        // 0:nothing, 1:force view angles, 2:add avelocity
    
float        idealpitch;
    
float        pitch_speed;
    
float        ideal_yaw;
    
float        yaw_speed;

    
int            modelindex;
    
string_t    model;

    
int            viewmodel;        // player's viewmodel
    
int            weaponmodel;    // what other players see
    
    
vec3_t        absmin;        // BB max translated to world coord
    
vec3_t        absmax;        // BB max translated to world coord
    
vec3_t        mins;        // local BB min
    
vec3_t        maxs;        // local BB max
    
vec3_t        size;        // maxs - mins

    
float        ltime;
    
float        nextthink;

    
int            movetype;
    
int            solid;

    
int            skin;            
    
int            body;            // sub-model selection for studiomodels
    
int         effects;
    
    
float        gravity;        // % of "normal" gravity
    
float        friction;        // inverse elasticity of MOVETYPE_BOUNCE
    
    
int            light_level;

    
int            sequence;        // animation sequence
    
int            gaitsequence;    // movement animation sequence for player (0 for none)
    
float        frame;            // % playback position in animation sequences (0..255)
    
float        animtime;        // world time when frame was set
    
float        framerate;        // animation playback rate (-8x to 8x)
    
byte        controller[4];    // bone controller setting (0..255)
    
byte        blending[2];    // blending amount between sub-sequences (0..255)

    
float        scale;            // sprite rendering scale (0..255)

    
int            rendermode;
    
float        renderamt;
    
vec3_t        rendercolor;
    
int            renderfx;

    
float        health;
    
float        frags;
    
int            weapons;  // bit mask for available weapons
    
float        takedamage;

    
int            deadflag;
    
vec3_t        view_ofs;    // eye position

    
int            button;
    
int            impulse;

    
edict_t        *chain;            // Entity pointer when linked into a linked list
    
edict_t        *dmg_inflictor;
    
edict_t        *enemy;
    
edict_t        *aiment;        // entity pointer when MOVETYPE_FOLLOW
    
edict_t        *owner;
    
edict_t        *groundentity;

    
int            spawnflags;
    
int            flags;
    
    
int            colormap;        // lowbyte topcolor, highbyte bottomcolor
    
int            team;

    
float        max_health;
    
float        teleport_time;
    
float        armortype;
    
float        armorvalue;
    
int            waterlevel;
    
int            watertype;
    
    
string_t    target;
    
string_t    targetname;
    
string_t    netname;
    
string_t    message;

    
float        dmg_take;
    
float        dmg_save;
    
float        dmg;
    
float        dmgtime;
    
    
string_t    noise;
    
string_t    noise1;
    
string_t    noise2;
    
string_t    noise3;
    
    
float        speed;
    
float        air_finished;
    
float        pain_finished;
    
float        radsuit_finished;
    
    
edict_t        *pContainingEntity;

    
int            playerclass;
    
float        maxspeed;

    
float        fov;
    
int            weaponanim;

    
int            pushmsec;

    
int            bInDuck;
    
int            flTimeStepSound;
    
int            flSwimTime;
    
int            flDuckTime;
    
int            iStepLeft;
    
float        flFallVelocity;

    
int            gamestate;

    
int            oldbuttons;

    
int            groupinfo;

    
// For mods
    
int            iuser1;
    
int            iuser2;
    
int            iuser3;
    
int            iuser4;
    
float        fuser1;
    
float        fuser2;
    
float        fuser3;
    
float        fuser4;
    
vec3_t        vuser1;
    
vec3_t        vuser2;
    
vec3_t        vuser3;
    
vec3_t        vuser4;
    
edict_t        *euser1;
    
edict_t        *euser2;
    
edict_t        *euser3;
    
edict_t        *euser4;
entvars_t
Vale, muchas gracias, la v. viene a significar value o nada que ver?
supongo que vendría a significar "vars" de entity vars
Código PHP:
struct edict_s
{
    
qboolean    free;
    
int            serialnumber;
    
link_t        area;                // linked to a division node or leaf
    
    
int            headnode;            // -1 to use normal leaf check
    
int            num_leafs;
    
short        leafnums[MAX_ENT_LEAFS];

    
float        freetime;            // sv.time when the object was freed

    
void*        pvPrivateData;        // Alloced and freed by engine, used by DLLs

    
entvars_t    v;                    // C exported fields from progs

    // other fields from progs come immediately after
}; 
Gracias nuevamente!