Enviar respuesta 
[GUIA] Funcion: AddToFullPack
Autor Mensaje
meTaLiCroSS Sin conexión
Miembro Destacado


Buen Tutorial AMXX Support Pensador Trebol verde 1k
Mensajes: 1,420
Registro en: Oct 2013
Reputación: 52
Mensaje: #1
[GUIA] Funcion: AddToFullPack
La intro del HLSDK:

Cita:/*
AddToFullPack

Return 1 if the entity state has been filled in for the ent and the entity will be propagated to the client, 0 otherwise
*/

Para no empezar con explicaciones cientificas ni porquerias pintando un cuadro perfecto, usare un vocabulario flexible y entendible.

AddToFullPack (escrita como pfnAddToFullPack) es una función importada del engine, la cual es llamada por el mod. (cada mod configura la funcion a su gusto). Esta puede ser hookeada por el módulo Fakemeta.

Esta se encarga de realizar una tarea completa: Codifica todos los datos de visibilidad a importar de las entidades, a todos los jugadores. Es por esta razon, que la funcion AddToFullPack es llamada multiples veces por frame, ya que por cada jugador, es llamada ésta por cada entidad (incluyendo otros jugadores), siendo una funcion bien pesada. Proud.

Vamos por la declaracion de la funcion y sus argumentos.

Declaracion de AddToFullPack en el HLSDK:

Código PHP:
int AddToFullPackstruct entity_state_s *stateint eedict_t *entedict_t *hostint hostflagsint playerunsigned char *pSet 

Declaracion de AddToFullPack como función en Pawn, siendo previamente transformada por el módulo:

Código PHP:
public AddToFullPack(stateeenthosthostflagsplayerpSet

► Arg: state

Es una copia de la estructura entity_state_s, la cual *para ser mejor comprendida* vendrian siendo los entvars (pevs) de datos de visualizacion que afectarían el físico de las entidades enviadas.
Unas muy obvias por ejemplo son origin y angles, gracias a este par el cliente procesa la posicion y los angulos de vista de las entidades y jugadores. Son los datos necesarios que el cliente necesita para poder procesar graficamente las entidades (y también para predecirlas).

Como es una estructura que no es manipulada por alguna native, se crearon especificamente las natives get_es y set_es (es -> entity_state) que permiten obtener y cambiar estos valores. (tal asi como la estructura entvars_s es manipulada por la native (set_)pev/entity_(s/g)et_*)

La declaracion de esta estructura en el HLSDK es:

Código PHP:
struct entity_state_s
{
// Fields which are filled in by routines outside of delta compression
    
int            entityType;
    
// Index into cl_entities array for this entity.
    
int            number;      
    
float        msg_time;

    
// Message number last time the player/entity state was updated.
    
int            messagenum;        

    
// Fields which can be transitted and reconstructed over the network stream
    
vec3_t        origin;
    
vec3_t        angles;

    
int            modelindex;
    
int            sequence;
    
float        frame;
    
int            colormap;
    
short        skin;
    
short        solid;
    
int            effects;
    
float        scale;

    
byte        eflags;
    
    
// Render information
    
int            rendermode;
    
int            renderamt;
    
color24        rendercolor;
    
int            renderfx;

    
int            movetype;
    
float        animtime;
    
float        framerate;
    
int            body;
    
byte        controller[4];
    
byte        blending[4];
    
vec3_t        velocity;

    
// Send bbox down to client for use during prediction.
    
vec3_t        mins;    
    
vec3_t        maxs;

    
int            aiment;
    
// If owned by a player, the index of that player ( for projectiles ).
    
int            owner

    
// Friction, for prediction.
    
float        friction;       
    
// Gravity multiplier
    
float        gravity;        

// PLAYER SPECIFIC
    
int            team;
    
int            playerclass;
    
int            health;
    
qboolean    spectator;  
    
int         weaponmodel;
    
int            gaitsequence;
    
// If standing on conveyor, e.g.
    
vec3_t        basevelocity;   
    
// Use the crouched hull, or the regular player hull.
    
int            usehull;        
    
// Latched buttons last time state updated.
    
int            oldbuttons;     
    
// -1 = in air, else pmove entity number
    
int            onground;        
    
int            iStepLeft;
    
// How fast we are falling
    
float        flFallVelocity;  

    
float        fov;
    
int            weaponanim;

    
// Parametric movement overrides
    
vec3_t                startpos;
    
vec3_t                endpos;
    
float                impacttime;
    
float                starttime;

    
// 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;
}; 

(Si bien se percatan, vendrian siendo los entvars especificos que afectan la visibilidad de las entidades. A simple vista son entendibles la mayoria.)

Para poder acceder a estos mediante las natives (s/g)et_es, se creo la siguiente enumeracion que van dentro del segundo argumento de ambas natives:

Código PHP:
enum EntityState
{
    
// Fields which are filled in by routines outside of delta compression
    
ES_EntityType,        // int
    // Index into cl_entities array for this entity
    
ES_Number,            // int
    
ES_MsgTime,            // float
    
    // Message number last time the player/entity state was updated
    
ES_MessageNum,        // int
    
    // Fields which can be transitted and reconstructed over the network stream
    
ES_Origin,            // float array[3]
    
ES_Angles,            // float array[3]
    
    
ES_ModelIndex,        // int
    
ES_Sequence,        // int
    
ES_Frame,            // float
    
ES_ColorMap,        // int
    
ES_Skin,            // short
    
ES_Solid,            // short
    
ES_Effects,            // int 
    
ES_Scale,            // float
    
ES_eFlags,            // byte
    
    // Render information
    
ES_RenderMode,        // int
    
ES_RenderAmt,        // int
    
ES_RenderColor,        // byte array[3], RGB value
    
ES_RenderFx,        // int
    
    
ES_MoveType,        // int
    
ES_AnimTime,        // float
    
ES_FrameRate,        // float
    
ES_Body,            // int
    
ES_Controller,        // byte array[4]
    
ES_Blending,        // byte array[4]
    
ES_Velocity,        // float array[3]
    
    // Send bbox down to client for use during prediction
    
ES_Mins,            // float array[3]
    
ES_Maxs,            // float array[3]
    
    
ES_AimEnt,            // int
    // If owned by a player, the index of that player (for projectiles)
    
ES_Owner,            // int
    
    // Friction, for prediction
    
ES_Friction,        // float
    // Gravity multiplier
    
ES_Gravity,            // float
    
    // PLAYER SPECIFIC
    
ES_Team,            // int
    
ES_PlayerClass,        // int
    
ES_Health,            // int
    
ES_Spectator,        // bool
    
ES_WeaponModel,        // int
    
ES_GaitSequence,    // int
    // If standing on conveyor, e.g.
    
ES_BaseVelocity,    // float array[3]
    // Use the crouched hull, or the regular player hull
    
ES_UseHull,            // int
    // Latched buttons last time state updated
    
ES_OldButtons,        // int
    // -1 = in air, else pmove entity number
    
ES_OnGround,        // int
    
ES_iStepLeft,        // int
    // How fast we are falling
    
ES_flFallVelocity,    // float
    
    
ES_FOV,                // float
    
ES_WeaponAnim,        // int    
    
    // Parametric movement overrides
    
ES_StartPos,        // float array[3]
    
ES_EndPos,            // float array[3]
    
ES_ImpactTime,        // float
    
ES_StartTime,        // float
    
    // For mods
    
ES_iUser1,            // int
    
ES_iUser2,            // int
    
ES_iUser3,            // int
    
ES_iUser4,            // int
    
ES_fUser1,            // float
    
ES_fUser2,            // float
    
ES_fUser3,            // float
    
ES_fUser4,            // float
    
ES_vUser1,            // float array[3]
    
ES_vUser2,            // float array[3]
    
ES_vUser3,            // float array[3]
    
ES_vUser4            // float array[3]
}; 

► Arg: e

Este es el index de la entidad que vamos a procesar.

► Arg: ent

A diferencia de e, ent es lo mismo solo que internamente es un puntero a la estructura edict_s de la entidad que vamos a procesar, pero como en Pawn las entidades son manejadas directamente con sus indexes, este argumento es transformado al index de la entidad, siendo lo mismo ent con e.

Pero por razones de comodidad, utiliza ent por sobre e.

► Arg: host

Este es el jugador al cual se le procesaran todas las entidades del servidor. Siempre va a ser un player (daaaah). Con respecto a este jugador, se ve si la entidad debe ser necesariamente procesada o no.

► Arg: hostflags

Valdrá 1 si la cvar cl_lw del host es distinta a 0. De no serlo, valdrá 0.

*** La cvar cl_lw en un jugador define si tiene su prediccion activada (para mejor fluidez). ***

► Arg: player

Valdrá 1 si ent es un jugador. De no serlo, valdrá 0.

Esto es simplemente para ahorrar una llamada más para detectar si es veridicamente un player o no. Yao ming

► Arg: pSet

Whatdone

pSet es un puntero al PVS del host , seteado en la funcion exportada SetupVisibility (llamada en cada jugador antes de llamar multiples veces AddToFullPack) con respecto a la posicion del jugador. PVS significa "Potentially Visible Set", que vendria siendo "Conjunto Potencialmente Visible" (el traductor se portó bien). La logica implementada, es simple: "Si una entidad se encuentra en el PVS de un jugador, será enviada al mismo jugador; de no serlo, no se enviará", así evitando el envio innecesario de paquetes al player con informacion que no servira. (es por esto que algunos cheats muestran jugadores hasta un cierto punto.)

return (int)

Si la funcion le devuelve 1 al engine, la entidad será transmitida al cliente.
Si la funcion le devuelve 0 al engine, no será transmitida.

*** Este valor puede ser obtenido con get_orig_retval() hookeando la funcion en Post. ***

*** Se puede hacer override del return, utilizando forward_return(FMV_CELL, ...) hookeando la funcion en Pre. ***

__________________________________________________________

Ya con la mayoria de estos datos aclarados, puedo ceder a mostrar la función escrita en el HLSDK (en C++) que filtra las entidades que deben ser enviadas y que no.

/// = comentario mio

Código PHP:
/*
AddToFullPack

Return 1 if the entity state has been filled in for the ent and the entity will be propagated to the client, 0 otherwise

state is the server maintained copy of the state info that is transmitted to the client
a MOD could alter values copied into state to send the "host" a different look for a particular entity update, etc.
e and ent are the entity that is being added to the update, if 1 is returned
host is the player's edict of the player whom we are sending the update to
player is 1 if the ent/e is a player and 0 otherwise
pSet is either the PAS or PVS that we previous set up.  We can use it to ask the engine to filter the entity against the PAS or PVS.
we could also use the pas/ pvs that we set in SetupVisibility, if we wanted to.  Caching the value is valid in that case, but still only for the current frame
*/
int AddToFullPackstruct entity_state_s *stateint eedict_t *entedict_t *hostint hostflagsint playerunsigned char *pSet )
{
    
int                    i;

    
// don't send if flagged for NODRAW and it's not the host getting the message
    
if ( ( ent->v.effects == EF_NODRAW ) &&
         ( 
ent != host ) ) 
        return 
0/// es por eso que con el flag EF_NODRAW en _effects, uno no ve a la entidad.

    // Ignore ents without valid / visible models
    
if ( !ent->v.modelindex || !STRINGent->v.model ) )
        return 
0/// si la entidad no tiene model, para que necesitamos saber de ella?

    // Don't send spectators to other players
    
if ( ( ent->v.flags FL_SPECTATOR ) && ( ent != host ) )
    {
        return 
0/// desde cuando los espectadores se han visto? jajaja
    
}

    
// Ignore if not the host and not touching a PVS/PAS leaf
    // If pSet is NULL, then the test will always succeed and the entity will be added to the update
    
if ( ent != host )
    {
        if ( !
ENGINE_CHECK_VISIBILITY( (const struct edict_s *)entpSet ) ) /// en esta funcion especifica, es donde el engine pregunta si la entidad esta en el PVS del host, lo que explique arriba
        
{
            return 
0;
        }
    }


    
// Don't send entity to local client if the client says it's predicting the entity itself.
    
if ( ent->v.flags FL_SKIPLOCALHOST 
    {
        if ( ( 
hostflags ) && ( ent->v.owner == host ) )
            return 
0/// si ent tiene el flag FL_SKIPLOCALHOST, tiene como owner al host, y host tiene la cvar cl_lw activada, no se enviara la entidad (alguna caracteristica oculta quizas)
    
}
    
    if ( 
host->v.groupinfo )
    {
        
/// Aqui hay un pequeño juego con groupinfo. Es algo dificil de entender pero luego de unas variadas lecturas del codigo se entendera.
        
        
UTIL_SetGroupTracehost->v.groupinfoGROUP_OP_AND );

        
// Should always be set, of course
        
if ( ent->v.groupinfo )
        {
            if ( 
g_groupop == GROUP_OP_AND /// siempre sera GROUP_OP_AND, ya que previamente setea el groupop asi
            
{
                if ( !(
ent->v.groupinfo host->v.groupinfo ) )
                    return 
0;
            }
            else if ( 
g_groupop == GROUP_OP_NAND )
            {
                if ( 
ent->v.groupinfo host->v.groupinfo )
                    return 
0;
            }
        }
        
        
/// En conclusion:
        /// Si el jugador tiene un groupinfo seteado (un bit al azar, definido por los modders)
        /// Y si la entidad tambien tiene un groupinfo seteado
        /// La entidad seria transmitida, si ambos tienen el mismo bit asignado.
        
        
UTIL_UnsetGroupTrace();
    }

    
/// Esta es la parte hardcore, donde se copian muchos entvars a la estructura que sera procesada por el engine.
    
memsetstate0sizeof( *state ) );

    
// Assign index so we can track this entity from frame to frame and
    //  delta from it.
    
state->number      e;
    
state->entityType ENTITY_NORMAL;
    
    
// Flag custom entities.
    
if ( ent->v.flags FL_CUSTOMENTITY /// las entidades "beams" son un poco magicas, ya que algunas con definir su posicion y un angulo provocan un rayo laser hasta donde choque, y es gracias a esto
    
{
        
state->entityType ENTITY_BEAM;
    }

    
// 
    // Copy state data
    //

    // Round animtime to nearest millisecond
    
state->animtime   = (int)(1000.0 ent->v.animtime ) / 1000.0;

    
memcpystate->originent->v.originsizeof( float ) );
    
memcpystate->anglesent->v.anglessizeof( float ) );
    
memcpystate->minsent->v.minssizeof( float ) );
    
memcpystate->maxsent->v.maxssizeof( float ) );

    
memcpystate->startposent->v.startpossizeof( float ) );
    
memcpystate->endposent->v.endpossizeof( float ) );

    
state->impacttime ent->v.impacttime;
    
state->starttime ent->v.starttime;

    
state->modelindex ent->v.modelindex;
        
    
state->frame      ent->v.frame;

    
state->skin       ent->v.skin;
    
state->effects    ent->v.effects;

    
// This non-player entity is being moved by the game .dll and not the physics simulation system
    //  make sure that we interpolate it's position on the client if it moves
    
if ( !player &&
         
ent->v.animtime &&
         
ent->v.velocity] == && 
         
ent->v.velocity] == && 
         
ent->v.velocity] == )
    {
        
state->eflags |= EFLAG_SLERP;
    }

    
state->scale      ent->v.scale;
    
state->solid      ent->v.solid;
    
state->colormap   ent->v.colormap;

    
state->movetype   ent->v.movetype;
    
state->sequence   ent->v.sequence;
    
state->framerate  ent->v.framerate;
    
state->body       ent->v.body;

    for (
04i++)
    {
        
state->controller[i] = ent->v.controller[i];
    }

    for (
02i++)
    {
        
state->blending[i]   = ent->v.blending[i];
    }

    
state->rendermode    ent->v.rendermode;
    
state->renderamt     ent->v.renderamt
    
state->renderfx      ent->v.renderfx;
    
state->rendercolor.ent->v.rendercolor.x;
    
state->rendercolor.ent->v.rendercolor.y;
    
state->rendercolor.ent->v.rendercolor.z;

    
state->aiment 0;
    if ( 
ent->v.aiment )
    {
        
state->aiment ENTINDEXent->v.aiment );
    }

    
state->owner 0;
    if ( 
ent->v.owner )
    {
        
int owner ENTINDEXent->v.owner );
        
        
// Only care if owned by a player
        
if ( owner >= && owner <= gpGlobals->maxClients )
        {
            
state->owner owner;    
        }
    }

    
// HACK:  Somewhat...
    // Class is overridden for non-players to signify a breakable glass object ( sort of a class? )
    
if ( !player )
    {
        
/// Activado este valor en las entidades "func_breakable", se vera que sus decals de balas seran agujeros de vidrios.
        /// https://amxmodx-es.com/Thread-como-remover-las-puertas-ventanas-del-map?pid=36803#pid36803
        
state->playerclass  ent->v.playerclass;
    }

    
// Special stuff for players only
    
if ( player )
    {
        
memcpystate->basevelocityent->v.basevelocitysizeof( float ) );

        
state->weaponmodel  MODEL_INDEXSTRINGent->v.weaponmodel ) );
        
state->gaitsequence ent->v.gaitsequence;
        
state->spectator ent->v.flags FL_SPECTATOR;
        
state->friction     ent->v.friction;

        
state->gravity      ent->v.gravity;
//        state->team            = ent->v.team;
//        
        
state->usehull      = ( ent->v.flags FL_DUCKING ) ? 0;
        
state->health        ent->v.health;
    }

    return 
1;


Y aqui un intento mio de mostrar como es utilizado pfnAddToFullPack en el engine, dentro de la funcion SV_WriteEntitiesToClient() (con mucha ayuda de OSHLDS, OpenHLDS, y un decompilado parcial de engine_i686.so)

Código PHP:
#define MAX_PACKET_ENTITIES 256

void SV_WriteEntitiesToClient(client_t *clientsizebuf_t *msg
{
   
unsigned int iclientflagsvisible_entitiesisplayer;

   
byte *pvs, *pas, *pvs_ptr;
   
client_t *loopclient;
   
edict_t *ent

   entity_state_t 
*entity_state_ptrentities[MAX_PACKET_ENTITIES];

   
pvs NULL;
   
pas NULL;

   
gEntityInterface.pfnSetupVisibility(client->targetclient->edict, &pvs, &pas);
  
   
// code code ...

   
visible_entities 0;
   
clientflags = (client->cl_lw != 0);
   
pvs_ptr pvs;

   for(
1sv.num_edictsi++) 
   {
      
ent = &sv.edicts[i];

      if(
&& svs.allocated_client_slots
         
isplayer 1;
      else 
         
isplayer 0;

      if(
isplayer != 0
      {
         
loopclient = &svs.clients[i-1];
         if((
loopclient->active == && loopclient->spawned == 0) || loopclient->hltv != 0
            continue;
      }

      if(
visible_entities MAX_PACKET_ENTITIES
      {
         
Con_Printf("Too many entities in visible packet list.\n");
         break;
      }

      
entity_state_ptr = &entities[visible_entities];
      if(
gEntityInterface.pfnAddToFullPack(entity_state_ptrientclient->edictclientflagsisplayerpvs_ptr)) 
      {
         
visible_entities++;
      }
   }
   
   
// code code...


Con el codigo parcial escrito arriba se entiende un poco mejor el caso. SV_WriteEntitiesToClient() es llamado en cada jugador, y esta es llamada todos los frames.

Y asi es como al final, todas las entidades filtradas son comprimidas y enviadas al cliente.

__________________________________________________________

Ya con la mayoria explicada, podemos pasar a filosofar un poco la utilidad de esta misma funcion.
  • Gracias a AddToFullPack podemos hacer que ciertos users vean distintas cosas que a otros jugadores. Dicho este detalle, es por que siempre asocian esta funcion con, por ejemplo, jugadores que pueden ser vistos por unos pocos.
  • Como esta explicado, es una funcion que, se repite por cada jugador, y dentro de esta, pregunta por cada entidad. Date una idea de cuantas veces es llamado AddToFullPack por frame, con 32 players, habiendo cerca de 50 entidades presentes. Aquí es donde debes hablar de optimizacion real Roflmao
  • ¿Alguna vez has llegado al punto de tener multiples entidades presentes en el juego, y terminas no viendo a todos? Claro, es porque hay un limite de 256 entidades que pueden ser transferidas al cliente en un frame.
  • AddToFullPack esta ubicado al final de la rutina del engine que realiza cada frame.
  • El argumento pSet, que es un puntero al PVS del host de la funcion, puede ser usado adjunto la funcion exportada CheckVisibility (la misma que vez arriba como ENGINE_CHECK_VISIBILITY), ya que esta requiere un puntero de un PVS, para verificar si una entidad esta en el conjunto potencialmente visible de la posicion del jugador.
  • ¿Alguna vez te preguntaste como funcionan los wallhack? Bueno, creo que aqui es donde llegas a aclarar un poco esa duda. ¿Como crees que los otros jugadores (especificamente en cualquier juego) son transmitidos a los que juegan? Los wallhacks aprovechan esos datos para ser mostrados pese esten detras de una muralla o no. OJO que el Conjunto Potencialmente Visible, como se describe a si mismo, no dice que son las entidades que esta viendo o no, si no las que "potencialmente puede ver" (daaaah)


Despues pondré unos ejemplos maliciosos de que cosillas puedes hacer con esta funcion Proud

Espero les haya gustado (quien sea lo haya leido entero) esta guia que me costo un tiempo escribiendo a la velocidad de la luz (?), cualquier duda pueden preguntar como también corregirme algún detalle que haya errado/olvidado.

(Este mensaje fue modificado por última vez en: 20/09/2014 08:53 PM por meTaLiCroSS.)
20/09/2014 12:46 AM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
Mario AR. Sin conexión
Super Mario 64


Plugin developer Donador Medalla de aportes 1k
Mensajes: 1,235
Registro en: Feb 2014
Reputación: 61
Mensaje: #2
RE: [GUIA] Funcion AddToFullPack
Aunque no entendí una mierda (Yao ming), excelente tuto!

(10/05/2019 08:23 PM)Niper.-. escribió:  Trap no son tus putas trap es mi equipo tumbando el foro de amxmodx hey tumbando el foro hey tumbando el foroooo ya saben todos nos llevamos todos los pluginsss..

(18/02/2019 03:08 PM)Neeeeeeeeeel.- escribió:  Shit

(28/02/2015 03:27 AM)sasske escribió:  Vete al diablo detallista de mierda Oh god why

(26/12/2018 02:45 PM)[R]ak escribió:  yo solo te veo en whatsapp agarrando culos.. nose..

(09/06/2017 12:59 AM)kikizon2 escribió:  Quiero que leas las reglas, y si fuese posible que saltaras de un 10mo piso, pls.

(21/04/2017 01:27 AM)Chamo. escribió:  Cuanto hay que pagar para estar en tu firma TrolleyesThats what she said?

(20/04/2017 11:56 PM)matrix123 escribió:  Patrocinas rehlds? Es de lo único que hablas, mañana seguro te llegan remeras de rehlds, mandame una Whatever

(26/04/2017 08:47 PM)Dieguito escribió:  al que me salga con latinservers le meto un sugisaki por el c***

(26/02/2017 08:02 PM)meTaLiCroSS escribió:  La misma aritmetica se aplica con los Strings falsos que inventé ("trivago" y "pajarussel").

(13/02/2017 07:41 PM)Heber[$]ource escribió:  es nuvpawn, nos esta ddoseando con su sega genesis

(06/01/2015 10:47 PM)meTaLiCroSS escribió:  
(06/01/2015 10:40 PM)wiD escribió:  este chileno culiau :whatever;
¿Que?

(29/04/2016 11:44 PM)wiD escribió:  Te juro que si te tengo enfrente primero te piso con el auto y despues te meo en la boca.

(16/07/2014 06:38 PM)wiD escribió:  Mongito dame su name que quiero un chip para pegar todo cocow

(18/03/2015 02:04 PM)ErikMav94 escribió:  
(18/03/2015 02:03 PM)mongito100 escribió:  Son todos putos
escribís como el orto :trolleyes;

[Anti] escribió:Olle tranquilo cerebrito

(03/04/2015 12:16 AM)Treki escribió:  
(03/04/2015 12:11 AM)Sugisaki escribió:  cual plug?, el arkshine o el de arkshine?

Fixed*

(09/03/2015 09:49 PM)Moroha escribió:  Suspendieron al abaricioso platero de kikizon :trolleyes;

(26/05/2014 08:31 PM)ivan escribió:  hola quiero hacer combo para el party uso el de rank

(22/08/2014 11:41 PM)Store.gh escribió:  Join team de jeropito? A vos t hace falta un pito..

(26/02/2015 01:01 AM)meTaLiCroSS escribió:  
(26/02/2015 12:54 AM)sasske escribió:  Salida del horno nueva versión, que obsesionado estoy :3
PD: Me olvide de darle los créditos a metal xD, pobre metal xd
Da igual, dejalo como una enseñanza jejej no te llorare por unos creditos ehhmm hud...

(18/01/2015 12:31 AM)[R]ak escribió:  no me critican.. solo dicen boludeces

(05/01/2015 12:43 AM)roccoxx escribió:  Sentado en dust pensando como fui tan gil ♪
Image
(Este mensaje fue modificado por última vez en: 01/03/2015 11:52 PM por Mario AR..)
20/09/2014 01:16 AM
Visita su sitio web Encuentra todos sus mensajes Cita este mensaje en tu respuesta
NikKOo31 Sin conexión
Miembro


Plugin developer
Mensajes: 188
Registro en: Jan 2014
Reputación: 6
Mensaje: #3
RE: [GUIA] Funcion AddToFullPack
Faltó una aplicación práctica Gran sonrisa

Excelente tuto!

Whatdone
20/09/2014 01:32 AM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
meTaLiCroSS Sin conexión
Miembro Destacado


Buen Tutorial AMXX Support Pensador Trebol verde 1k
Mensajes: 1,420
Registro en: Oct 2013
Reputación: 52
Mensaje: #4
RE: [GUIA] Funcion AddToFullPack
(20/09/2014 01:32 AM)NikKOo31 escribió:  Faltó una aplicación práctica Gran sonrisa

Excelente tuto!

(20/09/2014 12:46 AM)meTaLiCroSS escribió:  Despues pondré unos ejemplos maliciosos de que cosillas puedes hacer con esta funcion Proud

Y de todas maneras es una guia, no un tutorial Yao ming para las infinidades de cosas que puedes hacer, sería mejor que, o pidas un ejemplo, o revises los millones que hay creyendo que entendiste en algo

20/09/2014 01:37 AM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
NikKOo31 Sin conexión
Miembro


Plugin developer
Mensajes: 188
Registro en: Jan 2014
Reputación: 6
Mensaje: #5
RE: [GUIA] Funcion AddToFullPack
(20/09/2014 01:37 AM)meTaLiCroSS escribió:  Y de todas maneras es una guia, no un tutorial Yao ming para las infinidades de cosas que puedes hacer, sería mejor que, o pidas un ejemplo, o revises los millones que hay creyendo que entendiste en algo

Me hacés sentir Genius

Ahora buscaré ejemplos Triste Whatdone

Whatdone
20/09/2014 01:56 AM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
alan_el_more Sin conexión
Miembro Destacado


Plugin developer
Mensajes: 986
Registro en: Oct 2013
Reputación: 16
Mensaje: #6
RE: [GUIA] Funcion AddToFullPack
Te ganaste mi -1. Horrible usuario.
Andate del foro, nadie te necesita.


Ni te molestes en enviarme un mensaje privado para pedirme ayuda porque NO lo voy a contestar.
Gracias por su atención.
20/09/2014 08:08 AM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
meTaLiCroSS Sin conexión
Miembro Destacado


Buen Tutorial AMXX Support Pensador Trebol verde 1k
Mensajes: 1,420
Registro en: Oct 2013
Reputación: 52
Mensaje: #7
RE: [GUIA] Funcion AddToFullPack
Oh god why

20/09/2014 12:15 PM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
roccoxx Sin conexión
Miembro Destacado


Plugin developer Trebol purpura 1k
Mensajes: 1,159
Registro en: Oct 2013
Reputación: 18
Mensaje: #8
RE: [GUIA] Funcion AddToFullPack
muy bueno, lastima que es una funcion asi de pesada como lo aclaraste arriba y no dan muchas ganas de usarla Whatdone, me lo lei entero xD, me quedo una incognita: que con los conocimientos que vos tenes, que ejemplos maliciosos nos vas a mostrar jaja ( le prendia fuego la pc al player )

igual lo mas complicado y que todavia no me queda bien es el ultimo argumento descripto arriba como pSet, es muy confuso jaja

futuro ingeniero agrónomo.

tutoriales-allied
buscas un zp?

"La imitación es la forma más sincera de admiración con la que puede pagar la mediocridad a la grandeza"

volví a vender plugins, contactame
(Este mensaje fue modificado por última vez en: 20/09/2014 12:18 PM por roccoxx.)
20/09/2014 12:17 PM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
RauliTop Sin conexión
Miembro Héroe


El protector 1k
Mensajes: 1,961
Registro en: Oct 2013
Reputación: 36
Mensaje: #9
RE: [GUIA] Funcion AddToFullPack
(20/09/2014 12:46 AM)meTaLiCroSS escribió:  [*]¿Alguna vez has llegado al punto de tener multiples entidades presentes en el juego, y terminas no viendo a todos? Claro, es porque hay un limite de 256 entidades que pueden ser transferidas al cliente en un frame.

puede ser que afecte a los jugadores y que a veces sean invisibles?

se podría arreglar?

(17/04/2015 03:36 PM)Neeeeeeeeeel.- escribió:  No se va a volver a conectar a internet en toda su puta vida... nadie sube porno a mi foro y vive para contarlo.
20/09/2014 01:00 PM
Encuentra todos sus mensajes Cita este mensaje en tu respuesta
Destro Sin conexión
Anti-cheat Team


Buen Tutorial Plugin developer Pensador Plugin popular
Mensajes: 820
Registro en: Oct 2013
Reputación: 4
Mensaje: #10
RE: [GUIA] Funcion AddToFullPack
Dudo que afecte a los jugadores ya que tienen el index mas bajo y son los primeros en se procesados

(Este mensaje fue modificado por última vez en: 20/09/2014 02:19 PM por Destro.)
20/09/2014 02:02 PM
Visita su sitio web Encuentra todos sus mensajes Cita este mensaje en tu respuesta
Enviar respuesta 


Salto de foro:


Usuario(s) navegando en este tema: 1 invitado(s)

Contáctanos | Allied Modders en español | Volver arriba | Volver al contenido | Archivo (Modo simple) | Sindicación RSS