|SOLUCIONADO| Texto acortado en menú.

[MarLeo94]

Pues la info de la clase se recorta el texto, ¿por donde hay que tocar para que se vea completo?

[totopizza]

En el código base del mod (donde se registra la native)

[hud]

Seguro estas sobrepasando el el limite de caracteres que puede mostrar un menu.

Lo que sucede es que si pasas ese limite las opciones no se muestran correctamente, pero el menu sigue funcional.

[iGznOth]

Postea el code la parte del menu, así te digo que es lo que tenes que modificar.

[MarLeo94]

A ver, la parte del menú que se muestra es esta, ¿pero habría que cambiar quizás tambien 'g_zclass_info = ArrayCreate(32, 1)' a 'g_zclass_info = ArrayCreate(64, 1)' o eso se dejaría así?

Código PHP:

// Zombie Class Menu
public show_menu_zclass(id)
{
    // Player disconnected
    if(!g_isconnected[id]) {
        return;
    }
    
    // Bots pick their zombie class randomly
    if(g_isbot[id]) {
        g_zombieclassnext[id] = random_num(0, g_zclass_i - 1)
        
        return;
    }
    
    static menuid, menu[128], class, buffer[32], buffer2[32]
    
    // Title
    formatex(menu, charsmax(menu), "%L\r", id, "MENU_ZCLASS_TITLE")
    menuid = menu_create(menu, "menu_zclass")
    
    // Class List
    for(class = 0; class < g_zclass_i; class++) {
        // Retrieve name and info
        ArrayGetString(g_zclass_name, class, buffer, charsmax(buffer))
        ArrayGetString(g_zclass_info, class, buffer2, charsmax(buffer2))
        
        // Add to menu
        if(class == g_zombieclassnext[id]) {
            formatex(menu, charsmax(menu), "\d%s %s", buffer, buffer2)
        }
        else {
            formatex(menu, charsmax(menu), "%s \y%s", buffer, buffer2)
        }
        
        buffer[0] = class
        buffer[1] = 0
        
        menu_additem(menuid, menu, buffer)
    }
    
    // Back - Next - Exit
    formatex(menu, charsmax(menu), "%L", id, "MENU_BACK")
    menu_setprop(menuid, MPROP_BACKNAME, menu)
    formatex(menu, charsmax(menu), "%L", id, "MENU_NEXT")
    menu_setprop(menuid, MPROP_NEXTNAME, menu)
    formatex(menu, charsmax(menu), "%L", id, "MENU_EXIT")
    menu_setprop(menuid, MPROP_EXITNAME, menu)
    
    // If remembered page is greater than number of pages, clamp down the value
    MENU_PAGE_ZCLASS = min(MENU_PAGE_ZCLASS, menu_pages(menuid) - 1)
    
    // Fix for AMXX custom menus
    if(pev_valid(id) == PDATA_SAFE) {
        set_pdata_int(id, OFFSET_CSMENUCODE, 0, OFFSET_LINUX)
    }
    
    menu_display(id, menuid, MENU_PAGE_ZCLASS)
} 


Viendo el codigo del menú así mas o menos y según me habéis comentado, ¿el cambio seria aquí no?

Código PHP:

static menuid, menu[128], class, buffer[32], buffer2[32] 


[Exertency]

Aumenta el tamaño de la variable buffer2, ponele 64

Código PHP:

static menuid, menu[128], class, buffer[32], buffer2[64] 


[MarLeo94]

Gracias chicos, a ver dejo solucion:

- Hay que cambiar 'g_zclass_info = ArrayCreate(32, 1)' y 'g_zclass2_info = ArrayCreate(32, 1)' por esto 'g_zclass_info = ArrayCreate(64, 1)' y 'g_zclass2_info = ArrayCreate(64, 1)'.

- Después como dice Exertency hay que cambiar 'static menuid, menu[128], class, buffer[32], buffer2[32]' por 'static menuid, menu[128], class, buffer[32], buffer2[64]'.

PD: Y ya como curiosidad, ¿la variable tiene un máximo y/o afecta en algo aumentar el numero? Ah, ¿y tiene que ser 32, 64, 128, etc... O puede ser cualquier numero?

[totopizza]

Código PHP:

/**
 * These arrays are intended to be used for a form of global storage without 
 * requiring a #define that needs to be increased each time a person needs more 
 * storage.
 * These are not designed to be used as a replacement for normal arrays, as
 * normal arrays are faster and should be used whenever possible.
 */

/**
 * Creates a handle to a dynamically sized array.
 * It is very important that the cellsize you provide matches up with the buffer sizes
 * that you pass with subsequent Array{Get,Set,Push} calls.
 *
 * @param cellsize        How many cells each entry in the array is.
 * @param reserved        How many blank entries are created immediately when the array is created.  These entries are not valid to read from until called with ArraySet.
 * @return             Handle to the array.
 */
native Array:ArrayCreate(cellsize=1, reserved=32); 


[MarLeo94]

Vale, a ver, funciona pero al cambiar de mapa se pone el menú otra vez recortado... ¿Alguna idea?

Toto, en español por favor, no me llevo muy bien con el ingles. Entonces, he hecho bien al cambiar el tamaño del Array al igual que el del buffer2, pero, ¿por qué al cambiar de mapa no funciona?

[totopizza]

Código PHP:

* @param cellsize        How many cells each entry in the array is. 


--->

Código PHP:

* @param cellsize        Cuántas celdad puede almacenar cada array 


No sé que modo estés usando (supongo que el base builder), también debes de cambiar las variables temporales en la native de registro dentro del modo

[MarLeo94]

Ehmm... No, es ZP v4.3 Fix5a, pero no he entendido lo de las variables temporales, tengo nivel bastante bajo.

PD: Sí, a ver, entendí lo de Array, pero lo que no entiendo muy bien es la lógica.

[totopizza]

Código PHP:

// Native: zp_register_zombie_class
public native_register_zombie_class(const name[], const info[], const model[], const clawmodel[], hp, speed, Float:gravity, Float:knockback)
{
    // ZP disabled
    if (!g_pluginenabled)
        return -1;
    
    // Strings passed byref
    param_convert(1)
    param_convert(2)
    param_convert(3)
    param_convert(4)
    
    // Arrays not yet initialized
    if (!g_arrays_created)
    {
        log_error(AMX_ERR_NATIVE, "[ZP-New] Can't register zombie class yet (%s)", name)
        return -1;
    }
    
    if (strlen(name) < 1)
    {
        log_error(AMX_ERR_NATIVE, "[ZP-New] Can't register zombie class with an empty name")
        return -1;
    }
    
    new index, zombieclass_name[32]
    for (index = 0; index < g_zclass_i; index++)
    {
        ArrayGetString(g_zclass_name, index, zombieclass_name, charsmax(zombieclass_name))
        if (equali(name, zombieclass_name))
        {
            log_error(AMX_ERR_NATIVE, "[ZP-New] Zombie class already registered (%s)", name)
            return -1;
        }
    }
    
    // Add the class
    ArrayPushString(g_zclass_name, name)
    ArrayPushString(g_zclass_info, info)
    
    // Using same zombie models for all classes?
    if (g_same_models_for_all)
    {
        ArrayPushCell(g_zclass_modelsstart, 0)
        ArrayPushCell(g_zclass_modelsend, ArraySize(g_zclass_playermodel))
    }
    else
    {
        ArrayPushCell(g_zclass_modelsstart, ArraySize(g_zclass_playermodel))
        ArrayPushString(g_zclass_playermodel, model)
        ArrayPushCell(g_zclass_modelsend, ArraySize(g_zclass_playermodel))
        ArrayPushCell(g_zclass_modelindex, -1)
    }
    
    ArrayPushString(g_zclass_clawmodel, clawmodel)
    ArrayPushCell(g_zclass_hp, hp)
    ArrayPushCell(g_zclass_spd, speed)
    ArrayPushCell(g_zclass_grav, gravity)
    ArrayPushCell(g_zclass_kb, knockback)
    
    // Set temporary new class flag
    ArrayPushCell(g_zclass_new, 1)
    
    // Override zombie classes data with our customizations
    new i, k, buffer[32], Float:buffer2, nummodels_custom, nummodels_default, prec_mdl[100], size = ArraySize(g_zclass2_realname)
    for (i = 0; i < size; i++)
    {
        ArrayGetString(g_zclass2_realname, i, buffer, charsmax(buffer))
        
        // Check if this is the intended class to override
        if (!equal(name, buffer))
            continue;
        
        // Remove new class flag
        ArraySetCell(g_zclass_new, g_zclass_i, 0)
        
        // Replace caption
        ArrayGetString(g_zclass2_name, i, buffer, charsmax(buffer))
        ArraySetString(g_zclass_name, g_zclass_i, buffer)
        
        // Replace info
        ArrayGetString(g_zclass2_info, i, buffer, charsmax(buffer))
        ArraySetString(g_zclass_info, g_zclass_i, buffer)
        
        // Replace models, unless using same models for all classes
        if (!g_same_models_for_all)
        {
            nummodels_custom = ArrayGetCell(g_zclass2_modelsend, i) - ArrayGetCell(g_zclass2_modelsstart, i)
            nummodels_default = ArrayGetCell(g_zclass_modelsend, g_zclass_i) - ArrayGetCell(g_zclass_modelsstart, g_zclass_i)
            
            // Replace each player model and model index
            for (k = 0; k < min(nummodels_custom, nummodels_default); k++)
            {
                ArrayGetString(g_zclass2_playermodel, ArrayGetCell(g_zclass2_modelsstart, i) + k, buffer, charsmax(buffer))
                ArraySetString(g_zclass_playermodel, ArrayGetCell(g_zclass_modelsstart, g_zclass_i) + k, buffer)
                
                // Precache player model and replace its modelindex with the real one
                formatex(prec_mdl, charsmax(prec_mdl), "models/player/%s/%s.mdl", buffer, buffer)
                ArraySetCell(g_zclass_modelindex, ArrayGetCell(g_zclass_modelsstart, g_zclass_i) + k, engfunc(EngFunc_PrecacheModel, prec_mdl))
                if (g_force_consistency == 1) force_unmodified(force_model_samebounds, {0,0,0}, {0,0,0}, prec_mdl)
                if (g_force_consistency == 2) force_unmodified(force_exactfile, {0,0,0}, {0,0,0}, prec_mdl)
                // Precache modelT.mdl files too
                copy(prec_mdl[strlen(prec_mdl)-4], charsmax(prec_mdl) - (strlen(prec_mdl)-4), "T.mdl")
                if (file_exists(prec_mdl)) engfunc(EngFunc_PrecacheModel, prec_mdl)
            }
            
            // We have more custom models than what we can accommodate,
            // Let's make some space...
            if (nummodels_custom > nummodels_default)
            {
                for (k = nummodels_default; k < nummodels_custom; k++)
                {
                    ArrayGetString(g_zclass2_playermodel, ArrayGetCell(g_zclass2_modelsstart, i) + k, buffer, charsmax(buffer))
                    ArrayInsertStringAfter(g_zclass_playermodel, ArrayGetCell(g_zclass_modelsstart, g_zclass_i) + k - 1, buffer)
                    
                    // Precache player model and retrieve its modelindex
                    formatex(prec_mdl, charsmax(prec_mdl), "models/player/%s/%s.mdl", buffer, buffer)
                    ArrayInsertCellAfter(g_zclass_modelindex, ArrayGetCell(g_zclass_modelsstart, g_zclass_i) + k - 1, engfunc(EngFunc_PrecacheModel, prec_mdl))
                    if (g_force_consistency == 1) force_unmodified(force_model_samebounds, {0,0,0}, {0,0,0}, prec_mdl)
                    if (g_force_consistency == 2) force_unmodified(force_exactfile, {0,0,0}, {0,0,0}, prec_mdl)
                    // Precache modelT.mdl files too
                    copy(prec_mdl[strlen(prec_mdl)-4], charsmax(prec_mdl) - (strlen(prec_mdl)-4), "T.mdl")
                    if (file_exists(prec_mdl)) engfunc(EngFunc_PrecacheModel, prec_mdl)
                }
                
                // Fix models end index for this class
                ArraySetCell(g_zclass_modelsend, g_zclass_i, ArrayGetCell(g_zclass_modelsend, g_zclass_i) + (nummodels_custom - nummodels_default))
            }
            
            /* --- Not needed since classes can't have more than 1 default model for now ---
            // We have less custom models than what this class has by default,
            // Get rid of those extra entries...
            if (nummodels_custom < nummodels_default)
            {
                for (k = nummodels_custom; k < nummodels_default; k++)
                {
                    ArrayDeleteItem(g_zclass_playermodel, ArrayGetCell(g_zclass_modelsstart, g_zclass_i) + nummodels_custom)
                }
                
                // Fix models end index for this class
                ArraySetCell(g_zclass_modelsend, g_zclass_i, ArrayGetCell(g_zclass_modelsend, g_zclass_i) - (nummodels_default - nummodels_custom))
            }
            */
        }
        
        // Replace clawmodel
        ArrayGetString(g_zclass2_clawmodel, i, buffer, charsmax(buffer))
        ArraySetString(g_zclass_clawmodel, g_zclass_i, buffer)
        
        // Precache clawmodel
        formatex(prec_mdl, charsmax(prec_mdl), "models/zombie_plague/%s", buffer)
        engfunc(EngFunc_PrecacheModel, prec_mdl)
        
        // Replace health
        buffer[0] = ArrayGetCell(g_zclass2_hp, i)
        ArraySetCell(g_zclass_hp, g_zclass_i, buffer[0])
        
        // Replace speed
        buffer[0] = ArrayGetCell(g_zclass2_spd, i)
        ArraySetCell(g_zclass_spd, g_zclass_i, buffer[0])
        
        // Replace gravity
        buffer2 = Float:ArrayGetCell(g_zclass2_grav, i)
        ArraySetCell(g_zclass_grav, g_zclass_i, buffer2)
        
        // Replace knockback
        buffer2 = Float:ArrayGetCell(g_zclass2_kb, i)
        ArraySetCell(g_zclass_kb, g_zclass_i, buffer2)
    }
    
    // If class was not overriden with customization data
    if (ArrayGetCell(g_zclass_new, g_zclass_i))
    {
        // If not using same models for all classes
        if (!g_same_models_for_all)
        {
            // Precache default class model and replace modelindex with the real one
            formatex(prec_mdl, charsmax(prec_mdl), "models/player/%s/%s.mdl", model, model)
            ArraySetCell(g_zclass_modelindex, ArrayGetCell(g_zclass_modelsstart, g_zclass_i), engfunc(EngFunc_PrecacheModel, prec_mdl))
            if (g_force_consistency == 1) force_unmodified(force_model_samebounds, {0,0,0}, {0,0,0}, prec_mdl)
            if (g_force_consistency == 2) force_unmodified(force_exactfile, {0,0,0}, {0,0,0}, prec_mdl)
            // Precache modelT.mdl files too
            copy(prec_mdl[strlen(prec_mdl)-4], charsmax(prec_mdl) - (strlen(prec_mdl)-4), "T.mdl")
            if (file_exists(prec_mdl)) engfunc(EngFunc_PrecacheModel, prec_mdl)
        }
        
        // Precache default clawmodel
        formatex(prec_mdl, charsmax(prec_mdl), "models/zombie_plague/%s", clawmodel)
        engfunc(EngFunc_PrecacheModel, prec_mdl)
    }
    
    // Increase registered classes counter
    g_zclass_i++
    
    // Return id under which we registered the class
    return g_zclass_i-1;
} 


Aquí:

Código PHP:

// Override zombie classes data with our customizations
    new i, k, buffer[32], Float:buffer2, nummodels_custom, nummodels_default, prec_mdl[100], size = ArraySize(g_zclass2_realname) 


[MarLeo94]

Sí, eso es Toto, muchas gracias, parece que ya se mantiene .