[CS 1.6] Как сделать свои звуки для зомби? [ZP 4.3]



В данной статье, я покажу как можно добавить свои звуки для зомби класса

Делаем звуки зомби через мод.
После данной статьи, можно добавлять звуки у зомби через .ini файл

Находим строку: // Customization vars и добавляем выше неё:
// Zombie sounds
new Array:class_sound_infect, Array:class_sound_pain, Array:class_sound_idle,
Array:class_sound_idle_last, Array:class_sound_die, Array:class_sound_fall,
Array:class_sound_madness, Array:class_sound_burn, Array:class_sound_miss_slash,
Array:class_sound_miss_wall, Array:class_sound_hit_normal, Array:class_sound_hit_stab,
Array:pointer_class_sound_infect, Array:pointer_class_sound_pain, Array:pointer_class_sound_idle,
Array:pointer_class_sound_idle_last, Array:pointer_class_sound_die, Array:pointer_class_sound_fall,
Array:pointer_class_sound_madness, Array:pointer_class_sound_burn, Array:pointer_class_sound_miss_slash,
Array:pointer_class_sound_miss_wall, Array:pointer_class_sound_hit_normal, Array:pointer_class_sound_hit_stab

// Nemesis sounds
new Array:nemesis_pain, Array:nemesis_idle, Array:nemesis_die,
Array:nemesis_fall, Array:nemesis_miss_slash, Array:nemesis_miss_wall,
Array:nemesis_hit_normal, Array:nemesis_hit_stab
В public plugin_precache() находим строку: // Allow registering stuff now и выше добавляем:
    nemesis_pain = ArrayCreate(64, 1)
    nemesis_idle = ArrayCreate(64, 1)
    nemesis_die = ArrayCreate(64, 1)
    nemesis_fall = ArrayCreate(64, 1)
    nemesis_miss_slash = ArrayCreate(64, 1)
    nemesis_miss_wall = ArrayCreate(64, 1)
    nemesis_hit_normal = ArrayCreate(64, 1)
    nemesis_hit_stab = ArrayCreate(64, 1)
    class_sound_infect = ArrayCreate(64, 1)
    class_sound_pain = ArrayCreate(64, 1)
    class_sound_idle = ArrayCreate(64, 1)
    class_sound_idle_last = ArrayCreate(64, 1)
    class_sound_die = ArrayCreate(64, 1)
    class_sound_fall = ArrayCreate(64, 1)
    class_sound_madness = ArrayCreate(64, 1)
    class_sound_burn = ArrayCreate(64, 1)
    class_sound_miss_slash = ArrayCreate(64, 1)
    class_sound_miss_wall = ArrayCreate(64, 1)
    class_sound_hit_normal = ArrayCreate(64, 1)
    class_sound_hit_stab = ArrayCreate(64, 1)
    pointer_class_sound_infect = ArrayCreate(10, 1)
    pointer_class_sound_pain = ArrayCreate(10, 1)
    pointer_class_sound_idle = ArrayCreate(10, 1)
    pointer_class_sound_idle_last = ArrayCreate(10, 1)
    pointer_class_sound_die = ArrayCreate(10, 1)
    pointer_class_sound_fall = ArrayCreate(64, 1)
    pointer_class_sound_madness = ArrayCreate(10, 1)
    pointer_class_sound_burn = ArrayCreate(10, 1)
    pointer_class_sound_miss_slash = ArrayCreate(64, 1)
    pointer_class_sound_miss_wall = ArrayCreate(64, 1)
    pointer_class_sound_hit_normal = ArrayCreate(64, 1)
    pointer_class_sound_hit_stab = ArrayCreate(64, 1)
Находим в public plugin_precache() строку // Custom sounds и добавляем звуки Немезиде и Зомби аналогично звуку Pain
    for (i = 0; i < ArraySize(nemesis_pain); i++)
    {
        ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_idle); i++)
    {
        ArrayGetString(nemesis_idle, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_die); i++)
    {
        ArrayGetString(nemesis_die, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_fall); i++)
    {
        ArrayGetString(nemesis_fall, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_miss_slash); i++)
    {
        ArrayGetString(nemesis_miss_slash, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_miss_wall); i++)
    {
        ArrayGetString(nemesis_miss_wall, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_hit_normal); i++)
    {
        ArrayGetString(nemesis_hit_normal, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(nemesis_hit_stab); i++)
    {
        ArrayGetString(nemesis_hit_stab, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_infect); i++)
    {
        ArrayGetString(class_sound_infect, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_pain); i++)
    {
        ArrayGetString(class_sound_pain, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_idle); i++)
    {
        ArrayGetString(class_sound_idle, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_idle_last); i++)
    {
        ArrayGetString(class_sound_idle_last, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_die); i++)
    {
        ArrayGetString(class_sound_die, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_fall); i++)
    {
        ArrayGetString(class_sound_fall, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_madness); i++)
    {
        ArrayGetString(class_sound_madness, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_burn); i++)
    {
        ArrayGetString(class_sound_burn, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_miss_slash); i++)
    {
        ArrayGetString(class_sound_miss_slash, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_miss_wall); i++)
    {
        ArrayGetString(class_sound_miss_wall, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_hit_normal); i++)
    {
        ArrayGetString(class_sound_hit_normal, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
    for (i = 0; i < ArraySize(class_sound_hit_stab); i++)
    {
        ArrayGetString(class_sound_hit_stab, i, buffer, charsmax(buffer))
        engfunc(EngFunc_PrecacheSound, buffer)
    }
Звук INFECT:
Находим:
            // Infection sound
            ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound))
            emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Заменяем на:
            // Infection sound
            static pointers[10], end
            ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers)
            
            for (new i; i < 10; i++)
            {
                if (pointers[i] != -1)
                end = i
            }
            ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
            emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)

Ниже находим:
            // Infection sound
            ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound))
            emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Так же заменяем на:
            // Infection sound
            static pointers[10], end
            ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers)
            
            for (new i; i < 10; i++)
            {
                if (pointers[i] != -1)
                end = i
            }
            ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
            emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Звук PAIN:
Находим:
    // Zombie being hit
    if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't')
    {
        if (g_nemesis[id])
        {
            ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound))
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
        }
        else
        {
            ArrayGetString(zombie_pain, random_num(0, ArraySize(zombie_pain) - 1), sound, charsmax(sound))
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
        }
        return FMRES_SUPERCEDE;
    }
Заменяем на:
    // Zombie being hit
    if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't')
    {
        if (g_nemesis[id])
        {
            ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound))
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
        }
        else
        {
            static pointers[10], end
            ArrayGetArray(pointer_class_sound_pain, g_zombieclass[id], pointers)
            
            for (new i; i < 10; i++)
            {
                if (pointers[i] != -1)
                end = i
            }
            ArrayGetString(class_sound_pain, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
        }
        return FMRES_SUPERCEDE;
    }
Звук IDLE и IDLE LAST:
Находим:
// Play idle zombie sounds
public zombie_play_idle(taskid)
{
    // Round ended/new one starting
    if (g_endround || g_newround)
        return;
    
    static sound[64]
    
    // Last zombie?
    if (g_lastzombie[ID_BLOOD])
    {
        ArrayGetString(zombie_idle_last, random_num(0, ArraySize(zombie_idle_last) - 1), sound, charsmax(sound))
        emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
    else
    {
        ArrayGetString(zombie_idle, random_num(0, ArraySize(zombie_idle) - 1), sound, charsmax(sound))
        emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
}
Заменяем на:
// Play idle zombie sounds
public zombie_play_idle(taskid)
{
    // Round ended/new one starting
    if (g_endround || g_newround)
        return;
    
    static sound[64]
    
    // Last zombie?
    if (g_lastzombie[ID_BLOOD])
    {
        static pointers[10], end
        ArrayGetArray(pointer_class_sound_idle_last, g_zombieclass[ID_BLOOD], pointers)
        
        for (new i; i < 10; i++)
        {
            if (pointers[i] != -1)
            end = i
        }
        ArrayGetString(class_sound_idle_last, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
        emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
    else if(g_nemesis[ID_BLOOD])
    {
        ArrayGetString(nemesis_idle, random_num(0, ArraySize(nemesis_idle) - 1), sound, charsmax(sound))
        emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
    else
    {
        static pointers[10], end
        ArrayGetArray(pointer_class_sound_idle, g_zombieclass[ID_BLOOD], pointers)

        for (new i; i < 10; i++)
        {
            if (pointers[i] != -1)
            end = i
        }
        ArrayGetString(class_sound_idle, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
        emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
}
Звук DIE и FALL:
Находим:
    // Zombie dies
    if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a')))
    {
        ArrayGetString(zombie_die, random_num(0, ArraySize(zombie_die) - 1), sound, charsmax(sound))
        emit_sound(id, channel, sound, volume, attn, flags, pitch)
        return FMRES_SUPERCEDE;
    }

    // Zombie falls off
    if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l')
    {
        ArrayGetString(zombie_fall, random_num(0, ArraySize(zombie_fall) - 1), sound, charsmax(sound))
        emit_sound(id, channel, sound, volume, attn, flags, pitch)
        return FMRES_SUPERCEDE;
    }
Заменяем на:
    // Zombie dies
    if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a')))
    {
        if(g_nemesis[id])
            ArrayGetString(nemesis_die, random_num(0, ArraySize(nemesis_die) - 1), sound, charsmax(sound))
        else {    
            static pointers[10], end
            ArrayGetArray(pointer_class_sound_die, g_zombieclass[id], pointers)
            
            for (new i; i < 10; i++)
            {
                if (pointers[i] != -1)
                    end = i
            }
            ArrayGetString(class_sound_die, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
        }
        emit_sound(id, channel, sound, volume, attn, flags, pitch)
        return FMRES_SUPERCEDE;
    }

    // Zombie falls off
    if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l')
    {
        if(g_nemesis[id])
            ArrayGetString(nemesis_fall, random_num(0, ArraySize(nemesis_fall) - 1), sound, charsmax(sound))
        else {
            static pointers[10], end
            ArrayGetArray(pointer_class_sound_fall, g_zombieclass[id], pointers)
            
            for (new i; i < 10; i++)
            {
                if (pointers[i] != -1)
                end = i
            }
            ArrayGetString(class_sound_fall, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
        }
        emit_sound(id, channel, sound, volume, attn, flags, pitch)
        return FMRES_SUPERCEDE;
    }
Звук BURN:
Находим:
    // Randomly play burning zombie scream sounds (not for nemesis)
    if (!g_nemesis[ID_BURN] && !random_num(0, 20))
    {
        static sound[64]
        ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound))
        emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
Заменяем на:
    // Randomly play burning zombie scream sounds (not for nemesis)
    if (!g_nemesis[ID_BURN] && !random_num(0, 20))
    {
        static sound[64]
        static pointers[10], end
        ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers)
        
        for (new i; i < 10; i++)
        {
            if (pointers[i] != -1)
            end = i
        }
        ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
        emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
Звук MADNESS:
Находим:
        case EXTRA_MADNESS: // Zombie Madness
        {
            // Increase madness purchase count for this round
            g_madnesscounter++
            
            g_nodamage[id] = true
            set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b")
            set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD)
            
            static sound[64]
            ArrayGetString(zombie_madness, random_num(0, ArraySize(zombie_madness) - 1), sound, charsmax(sound))
            emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
        }
Заменяем на:
        case EXTRA_MADNESS: // Zombie Madness
        {
            // Increase madness purchase count for this round
            g_madnesscounter++
            
            g_nodamage[id] = true
            set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b")
            set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD)
            
            static sound[64]
            static pointers[10], end
            ArrayGetArray(pointer_class_sound_madness, g_zombieclass[id], pointers)
            
            for (new i; i < 10; i++)
            {
                if (pointers[i] != -1)
                end = i
            }
            ArrayGetString(class_sound_madness, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
            emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
        }
Звук BURN:
Находим:
    // Randomly play burning zombie scream sounds (not for nemesis)
    if (!g_nemesis[ID_BURN] && !random_num(0, 20))
    {
        static sound[64]
        ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound))
        emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
Заменяем на:
    // Randomly play burning zombie scream sounds (not for nemesis)
    if (!g_nemesis[ID_BURN] && !random_num(0, 20))
    {
        static sound[64]
        static pointers[10], end
        ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers)
        
        for (new i; i < 10; i++)
        {
            if (pointers[i] != -1)
            end = i
        }
        ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
        emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
    }
Звуки MISS SLASHMISS WALLHIT NORMALHIT STAB:
Находим:
    // Zombie attacks with knife
    if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
    {
        if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash
        {
            ArrayGetString(zombie_miss_slash, random_num(0, ArraySize(zombie_miss_slash) - 1), sound, charsmax(sound))
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
            return FMRES_SUPERCEDE;
        }
        if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit
        {
            if (sample[17] == 'w') // wall
            {
                ArrayGetString(zombie_miss_wall, random_num(0, ArraySize(zombie_miss_wall) - 1), sound, charsmax(sound))
                emit_sound(id, channel, sound, volume, attn, flags, pitch)
                return FMRES_SUPERCEDE;
            }
            else
            {
                ArrayGetString(zombie_hit_normal, random_num(0, ArraySize(zombie_hit_normal) - 1), sound, charsmax(sound))
                emit_sound(id, channel, sound, volume, attn, flags, pitch)
                return FMRES_SUPERCEDE;
            }
        }
        if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab
        {
            ArrayGetString(zombie_hit_stab, random_num(0, ArraySize(zombie_hit_stab) - 1), sound, charsmax(sound))
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
            return FMRES_SUPERCEDE;
        }
    }
Заменяем на:
    // Zombie attacks with knife
    if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
    {
        if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash
        {
            if(g_nemesis[id])
                ArrayGetString(nemesis_miss_slash, random_num(0, ArraySize(nemesis_miss_slash) - 1), sound, charsmax(sound))
            else {
                static pointers[10], end
                ArrayGetArray(pointer_class_sound_miss_slash, g_zombieclass[id], pointers)
    
                for (new i; i < 10; i++)
                {
                    if (pointers[i] != -1)
                        end = i
                }
                ArrayGetString(class_sound_miss_slash, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
            }
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
            return FMRES_SUPERCEDE;
        }
        if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit
        {
            if (sample[17] == 'w') // wall
            {
                if(g_nemesis[id])
                    ArrayGetString(nemesis_miss_wall, random_num(0, ArraySize(nemesis_miss_wall) - 1), sound, charsmax(sound))
                else {
                    static pointers[10], end
                    ArrayGetArray(pointer_class_sound_miss_wall, g_zombieclass[id], pointers)
            
                    for (new i; i < 10; i++)
                    {
                        if (pointers[i] != -1)
                            end = i
                    }
                    ArrayGetString(class_sound_miss_wall, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
                }
                emit_sound(id, channel, sound, volume, attn, flags, pitch)
                return FMRES_SUPERCEDE;
            }
            else
            {
                if(g_nemesis[id])
                    ArrayGetString(nemesis_hit_normal, random_num(0, ArraySize(nemesis_hit_normal) - 1), sound, charsmax(sound))
                else {                
                    static pointers[10], end
                    ArrayGetArray(pointer_class_sound_hit_normal, g_zombieclass[id], pointers)
            
                    for (new i; i < 10; i++)
                    {
                        if (pointers[i] != -1)
                            end = i
                    }
                    ArrayGetString(class_sound_hit_normal, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
                }
                emit_sound(id, channel, sound, volume, attn, flags, pitch)
                return FMRES_SUPERCEDE;
            }
        }
        if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab
        {
            if(g_nemesis[id])
                ArrayGetString(nemesis_hit_stab, random_num(0, ArraySize(nemesis_hit_stab) - 1), sound, charsmax(sound))
            else {    
                static pointers[10], end
                ArrayGetArray(pointer_class_sound_hit_stab, g_zombieclass[id], pointers)
            
                for (new i; i < 10; i++)
                {
                    if (pointers[i] != -1)
                        end = i
                }
                ArrayGetString(class_sound_hit_stab, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
            }
            emit_sound(id, channel, sound, volume, attn, flags, pitch)
            return FMRES_SUPERCEDE;
        }
    }
Названия звуков в zp_zombieclasses.ini:
Находим:
    // Parse if present
    if (file_exists(path))
    {
        // Open zombie classes file for reading
        file = fopen(path, "rt")
        
        while (file && !feof(file))
        {
            // Read one line at a time
            fgets(file, linedata, charsmax(linedata))
            
            // Replace newlines with a null character to prevent headaches
            replace(linedata, charsmax(linedata), "^n", "")
            
            // Blank line or comment
            if (!linedata[0] || linedata[0] == ';') continue;
            
            // New class starting
            if (linedata[0] == '[')
            {
                // Remove first and last characters (braces)
                linedata[strlen(linedata) - 1] = 0
                copy(linedata, charsmax(linedata), linedata[1])
                
                // Store its real name for future reference
                ArrayPushString(g_zclass2_realname, linedata)
                continue;
            }
            
            // Get key and value(s)
            strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
            
            // Trim spaces
            trim(key)
            trim(value)
            
            if (equal(key, "NAME"))
                ArrayPushString(g_zclass2_name, value)
            else if (equal(key, "INFO"))
                ArrayPushString(g_zclass2_info, value)
            else if (equal(key, "MODELS"))
            {
                // Set models start index
                ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel))
                
                // Parse class models
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    // Add to class models array
                    ArrayPushString(g_zclass2_playermodel, key)
                    ArrayPushCell(g_zclass2_modelindex, -1)
                }
                
                // Set models end index
                ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel))
            }
            else if (equal(key, "CLAWMODEL"))
                ArrayPushString(g_zclass2_clawmodel, value)
            else if (equal(key, "HEALTH"))
                ArrayPushCell(g_zclass2_hp, str_to_num(value))
            else if (equal(key, "SPEED"))
                ArrayPushCell(g_zclass2_spd, str_to_num(value))
            else if (equal(key, "GRAVITY"))
                ArrayPushCell(g_zclass2_grav, str_to_float(value))
            else if (equal(key, "KNOCKBACK"))
                ArrayPushCell(g_zclass2_kb, str_to_float(value))
        }
        if (file) fclose(file)
    }
Заменяем на:
    // Parse if present
    if (file_exists(path))
    {
        // Open zombie classes file for reading
        file = fopen(path, "rt")
        
        while (file && !feof(file))
        {
            static pos, temparr[64]

            // Read one line at a time
            fgets(file, linedata, charsmax(linedata))
            
            // Replace newlines with a null character to prevent headaches
            replace(linedata, charsmax(linedata), "^n", "")
            
            // Blank line or comment
            if (!linedata[0] || linedata[0] == ';') continue;
            
            // New class starting
            if (linedata[0] == '[')
            {
                // Remove first and last characters (braces)
                linedata[strlen(linedata) - 1] = 0
                copy(linedata, charsmax(linedata), linedata[1])
                
                // Store its real name for future reference
                ArrayPushString(g_zclass2_realname, linedata)
                continue;
            }
            
            // Get key and value(s)
            strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
            
            // Trim spaces
            trim(key)
            trim(value)
            
            if (equal(key, "NAME"))
                ArrayPushString(g_zclass2_name, value)
            else if (equal(key, "INFO"))
                ArrayPushString(g_zclass2_info, value)
            else if (equal(key, "MODELS"))
            {
                // Set models start index
                ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel))
                
                // Parse class models
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    // Add to class models array
                    ArrayPushString(g_zclass2_playermodel, key)
                    ArrayPushCell(g_zclass2_modelindex, -1)
                }
                
                // Set models end index
                ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel))
            }
            else if (equal(key, "CLAWMODEL"))
                ArrayPushString(g_zclass2_clawmodel, value)
            else if (equal(key, "HEALTH"))
                ArrayPushCell(g_zclass2_hp, str_to_num(value))
            else if (equal(key, "SPEED"))
                ArrayPushCell(g_zclass2_spd, str_to_num(value))
            else if (equal(key, "GRAVITY"))
                ArrayPushCell(g_zclass2_grav, str_to_float(value))
            else if (equal(key, "KNOCKBACK"))
                ArrayPushCell(g_zclass2_kb, str_to_float(value))
            else if (equal(key, "INFECT"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
            
                    ArrayPushString(class_sound_infect, key)
                    temparr[pos++] = ArraySize(class_sound_infect) - 1
                }
                ArrayPushArray(pointer_class_sound_infect, temparr)
            }
            else if (equal(key, "BURN"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_burn, key)
                    temparr[pos++] = ArraySize(class_sound_burn) - 1
                }
                ArrayPushArray(pointer_class_sound_burn, temparr)
            }
            else if (equal(key, "PAIN"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_pain, key)
                    temparr[pos++] = ArraySize(class_sound_pain) - 1
                }
                ArrayPushArray(pointer_class_sound_pain, temparr)
            }
            else if (equal(key, "DIE"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_die, key)
                    temparr[pos++] = ArraySize(class_sound_die) - 1
                }
                ArrayPushArray(pointer_class_sound_die, temparr)
            }
            else if (equal(key, "IDLE"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_idle, key)
                    temparr[pos++] = ArraySize(class_sound_idle) - 1
                }
                ArrayPushArray(pointer_class_sound_idle, temparr)
            }
            else if (equal(key, "IDLE LAST"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_idle_last, key)
                    temparr[pos++] = ArraySize(class_sound_idle_last) - 1
                }
                ArrayPushArray(pointer_class_sound_idle_last, temparr)
            }
            else if (equal(key, "MISS SLASH"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_miss_slash, key)
                    temparr[pos++] = ArraySize(class_sound_miss_slash) - 1
                }
                ArrayPushArray(pointer_class_sound_miss_slash, temparr)
            }
            else if (equal(key, "MISS WALL"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_miss_wall, key)
                    temparr[pos++] = ArraySize(class_sound_miss_wall) - 1
                }
                ArrayPushArray(pointer_class_sound_miss_wall, temparr)
            }
            else if (equal(key, "HIT NORMAL"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_hit_normal, key)
                    temparr[pos++] = ArraySize(class_sound_hit_normal) - 1
                }
                ArrayPushArray(pointer_class_sound_hit_normal, temparr)
            }
            else if (equal(key, "HIT STAB"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_hit_stab, key)
                    temparr[pos++] = ArraySize(class_sound_hit_stab) - 1
                }
                ArrayPushArray(pointer_class_sound_hit_stab, temparr)
            }
            else if (equal(key, "FALL"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_fall, key)
                    temparr[pos++] = ArraySize(class_sound_fall) - 1
                }
                ArrayPushArray(pointer_class_sound_fall, temparr)
            }
            else if (equal(key, "MADNESS"))
            {
                pos = 0
                arrayset(temparr, -1, sizeof(temparr))
                while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                {
                    // Trim spaces
                    trim(key)
                    trim(value)
                    
                    ArrayPushString(class_sound_madness, key)
                    temparr[pos++] = ArraySize(class_sound_madness) - 1
                }
                ArrayPushArray(pointer_class_sound_madness, temparr)
            }
        }
        if (file) fclose(file)
    }

Пути к звукам в Моде:
Находим:
save_customization()
{
     new i, k, buffer[512]
     
     // Build zombie classes file path
     new path[64]
     get_configsdir(path, charsmax(path))
     format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE)
     
     // Open zombie classes file for appending data
     new file = fopen(path, "at"), size = ArraySize(g_zclass_name)
     
     // Add any new zombie classes data at the end if needed
     for (i = 0; i < size; i++)
     {
          if (ArrayGetCell(g_zclass_new, i))
          {
                // Add real name
                ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^n[%s]", buffer)
                fputs(file, buffer)
                
                // Add caption
                ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^nNAME = %s", buffer)
                fputs(file, buffer)
                
                // Add info
                ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^nINFO = %s", buffer)
                fputs(file, buffer)
                
                // Add models
                for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++)
                {
                     if (k == ArrayGetCell(g_zclass_modelsstart, i))
                     {
                          // First model, overwrite buffer
                          ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer))
                     }
                     else
                     {
                          // Successive models, append to buffer
                          ArrayGetString(g_zclass_playermodel, k, path, charsmax(path))
                          format(buffer, charsmax(buffer), "%s , %s", buffer, path)
                     }
                }
                format(buffer, charsmax(buffer), "^nMODELS = %s", buffer)
                fputs(file, buffer)
                
                // Add clawmodel
                ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer)
                fputs(file, buffer)
                
                // Add health
                formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i))
                fputs(file, buffer)
                
                // Add speed
                formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i))
                fputs(file, buffer)
                
                // Add gravity
                formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i))
                fputs(file, buffer)
                
                // Add knockback
                formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f^n", Float:ArrayGetCell(g_zclass_kb, i))
                fputs(file, buffer)
          }
     }
Заменяем на:
save_customization()
{
     new i, k, buffer[512]
     
     // Build zombie classes file path
     new path[64]
     get_configsdir(path, charsmax(path))
     format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE)
     
     // Open zombie classes file for appending data
     new file = fopen(path, "at"), size = ArraySize(g_zclass_name)
     
     // Add any new zombie classes data at the end if needed
     for (i = 0; i < size; i++)
     {
          if (ArrayGetCell(g_zclass_new, i))
          {
                // Add real name
                ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^n[%s]", buffer)
                fputs(file, buffer)
                
                // Add caption
                ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^nNAME = %s", buffer)
                fputs(file, buffer)
                
                // Add info
                ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^nINFO = %s", buffer)
                fputs(file, buffer)
                
                // Add models
                for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++)
                {
                     if (k == ArrayGetCell(g_zclass_modelsstart, i))
                     {
                          // First model, overwrite buffer
                          ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer))
                     }
                     else
                     {
                          // Successive models, append to buffer
                          ArrayGetString(g_zclass_playermodel, k, path, charsmax(path))
                          format(buffer, charsmax(buffer), "%s , %s", buffer, path)
                     }
                }
                format(buffer, charsmax(buffer), "^nMODELS = %s", buffer)
                fputs(file, buffer)
                
                // Add clawmodel
                ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer))
                format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer)
                fputs(file, buffer)
                
                // Add health
                formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i))
                fputs(file, buffer)
                
                // Add speed
                formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i))
                fputs(file, buffer)
                
                // Add gravity
                formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i))
                fputs(file, buffer)
                
                // Add knockback
                formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f", Float:ArrayGetCell(g_zclass_kb, i))
                fputs(file, buffer)

                // Add infect sound
                fputs(file, "^nINFECT = zombie_plague/zombie_infec1.wav , zombie_plague/zombie_infec2.wav , zombie_plague/zombie_infec3.wav")
                
                // Add burn sound
                fputs(file, "^nBURN = zombie_plague/zombie_burn3.wav , zombie_plague/zombie_burn4.wav , zombie_plague/zombie_burn5.wav , zombie_plague/zombie_burn6.wav , zombie_plague/zombie_burn7.wav")
                
                // Add pain sound
                fputs(file, "^nPAIN = zombie_plague/zombie_pain1.wav , zombie_plague/zombie_pain2.wav , zombie_plague/zombie_pain3.wav , zombie_plague/zombie_pain4.wav , zombie_plague/zombie_pain5.wav")
                
                // Add die sound
                fputs(file, "^nDIE = zombie_plague/zombie_die1.wav , zombie_plague/zombie_die2.wav , zombie_plague/zombie_die3.wav , zombie_plague/zombie_die4.wav , zombie_plague/zombie_die5.wav")
                
                // Add idle sound
                fputs(file, "^nIDLE = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav")
                
                // Add idle last sound
                fputs(file, "^nIDLE LAST = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav")
                
                // Add miss slash sound
                fputs(file, "^nMISS SLASH = weapons/knife_slash1.wav , weapons/knife_slash2.wav")
                
                // Add miss wall sound
                fputs(file, "^nMISS WALL = weapons/knife_hitwall1.wav")
                
                // Add hit normal sound
                fputs(file, "^nHIT NORMAL = weapons/knife_hit1.wav , weapons/knife_hit2.wav , weapons/knife_hit3.wav , weapons/knife_hit4.wav")
                
                // Add hit stab sound
                fputs(file, "^nHIT STAB = weapons/knife_stab.wav")

                // Add fall sound
                fputs(file, "^nFALL = zombie_plague/zombie_fall1.wav")

                // Add madness sound
                fputs(file, "^nMADNESS = zombie_plague/zombie_madness1.wav^n")
          }
     }
Названия звуков немезиды в файле:
Находим:
                     else if (equal(key, "WIN NO ONE"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(sound_win_no_one, key)
                                ArrayPushCell(sound_win_no_one_ismp3, equal(key[strlen(key)-4], ".mp3") ? 1 : 0)
                          }
                     }
Добавляем ниже:
                     else if (equal(key, "NEMESIS PAIN"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_pain, key)
                          }
                     }
                     else if (equal(key, "NEMESIS IDLE"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_idle, key)
                          }
                     }
                     else if (equal(key, "NEMESIS DIE"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_die, key)
                          }
                     }
                     else if (equal(key, "NEMESIS FALL"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_fall, key)
                          }
                     }
                     else if (equal(key, "NEMESIS MISS SLASH"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_miss_slash, key)
                          }
                     }
                     else if (equal(key, "NEMESIS MISS WALL"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_miss_wall, key)
                          }
                     }
                     else if (equal(key, "NEMESIS HIT NORMAL"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_hit_normal, key)
                          }
                     }
                     else if (equal(key, "NEMESIS HIT STAB"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_hit_stab, key)
                          }
                     }
Вырезаем стандартные звуки из мода:
Находим в // Customization vars и удаляем:
Array:zombie_infect,
Array:zombie_pain,
Array:zombie_idle,
Array:zombie_idle_last,
Array:zombie_die,
Array:zombie_fall,
Array:zombie_madness,
Array:grenade_fire_player,
Array:zombie_miss_slash,
Array:zombie_miss_wall,
Array:zombie_hit_normal,
Array:zombie_hit_stab,

Находим в public plugin_precache() и удаляем:
     zombie_infect = ArrayCreate(64, 1)
     zombie_pain = ArrayCreate(64, 1)
     zombie_idle = ArrayCreate(64, 1)
     zombie_idle_last = ArrayCreate(64, 1)
     zombie_die = ArrayCreate(64, 1)
     zombie_fall = ArrayCreate(64, 1)
     zombie_madness = ArrayCreate(64, 1)
     grenade_fire_player = ArrayCreate(64, 1)
     zombie_miss_slash = ArrayCreate(64, 1)
     zombie_miss_wall = ArrayCreate(64, 1)
     zombie_hit_normal = ArrayCreate(64, 1)
     zombie_hit_stab = ArrayCreate(64, 1)

     for (i = 0; i < ArraySize(zombie_infect); i++)
     {
          ArrayGetString(zombie_infect, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_pain); i++)
     {
          ArrayGetString(zombie_pain, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_idle); i++)
     {
          ArrayGetString(zombie_idle, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_idle_last); i++)
     {
          ArrayGetString(zombie_idle_last, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_die); i++)
     {
          ArrayGetString(zombie_die, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_fall); i++)
     {
          ArrayGetString(zombie_fall, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_madness); i++)
     {
          ArrayGetString(zombie_madness, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(grenade_fire_player); i++)
     {
          ArrayGetString(grenade_fire_player, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_miss_slash); i++)
     {
          ArrayGetString(zombie_miss_slash, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_miss_wall); i++)
     {
          ArrayGetString(zombie_miss_wall, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_hit_normal); i++)
     {
          ArrayGetString(zombie_hit_normal, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
     for (i = 0; i < ArraySize(zombie_hit_stab); i++)
     {
          ArrayGetString(zombie_hit_stab, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
Находим в case SECTION_SOUNDS: и удаляем:
                     else if (equal(key, "ZOMBIE INFECT"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_infect, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE PAIN"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_pain, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE IDLE"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_idle, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE IDLE LAST"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_idle_last, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE DIE"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_die, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE FALL"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_fall, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE MADNESS"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_madness, key)
                          }
                     }
                     else if (equal(key, "GRENADE FIRE PLAYER"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(grenade_fire_player, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE MISS SLASH"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_miss_slash, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE MISS WALL"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_miss_wall, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE HIT NORMAL"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_hit_normal, key)
                          }
                     }
                     else if (equal(key, "ZOMBIE HIT STAB"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(zombie_hit_stab, key)
                          }
                     }
В zombieplague.ini добавляем:
NEMESIS HIT STAB = Ваш путь к звукам/Ваш звук.wav
NEMESIS HIT NORMAL = Ваш путь к звукам/Ваш звук.wav
NEMESIS MISS WALL = Ваш путь к звукам/Ваш звук.wav
NEMESIS MISS SLASH = Ваш путь к звукам/Ваш звук.wav
NEMESIS PAIN = Ваш путь к звукам/Ваш звук.wav
NEMESIS DIE = Ваш путь к звукам/Ваш звук.wav
NEMESIS IDLE = Ваш путь к звукам/Ваш звук.wav
Удаляем лишнее:
-----------------------------------------------------------
Array:nemesis_pain,
-----------------------------------------------------------
nemesis_pain = ArrayCreate(64, 1)
-----------------------------------------------------------
     for (i = 0; i < ArraySize(nemesis_pain); i++)
     {
          ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer))
          engfunc(EngFunc_PrecacheSound, buffer)
     }
-----------------------------------------------------------
                     else if (equal(key, "NEMESIS PAIN"))
                     {
                          // Parse sounds
                          while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
                          {
                                // Trim spaces
                                trim(key)
                                trim(value)
                                
                                // Add to sounds array
                                ArrayPushString(nemesis_pain, key)
                          }
                     }
-----------------------------------------------------------
скачать dle 12.0





Внимание!

Здесь вы можете приобрести сборку сервера CS 1.6, по самым низким ценам!

Перейти в магазин
20%

Скидка на все Товары
в нашем магазине до 1.06.2019

Специально для тебя - Гость 

Сотрудничество

Онлайн чат
sliman
sliman
14:16:52

hi
Keb74
Keb74
3 июля 2022

Ребят есть у кого старый сервер [ZP] CSO* Сервер, BlackCat, дайте пожалуйста скачать, очень надо
Multipower
Multipower
11 сентября 2021

I can't download so why did I sign up?
xiaowenzi
xiaowenzi
10 декабря 2019

When can the website author download it?
xiaowenzi
xiaowenzi
10 декабря 2019

When will it be available for download
KInDER
KInDER
17 октября 2019

Ну допустим?
Nunf
Nunf
14 октября 2019

Есть у кого еще? "Скрипт продажи плагинов by Greyko"
moana
moana
6 октября 2019

porque cuando yo quiero descargar armas pagina en blanco zp extra intens no puedo
Линар Сайетов
Линар Сайетов
6 октября 2019

kak skachivat extra items
Buckzone
Buckzone
30 сентября 2019

Новая информация в группе VK (Блок снизу)
Buckzone
Buckzone
30 сентября 2019

1dasdasdasd
abuzer444
abuzer444
26 сентября 2019

eyvallah
pisyuvarkin
pisyuvarkin
9 сентября 2019

как добавить в меню вид инфекции?
кто сможет помочь?
Aspirin
Aspirin
9 сентября 2019

Nice
xiaowenzi
xiaowenzi
7 сентября 2019

Such a good website Why can't I download it?
Lil270
Lil270
2 сентября 2019

allanur2003tm,
а ты и не скачаешь сайт мертв
Lil270
Lil270
2 сентября 2019

Цитата: Gazinur Gram

Gazinur Gram

никак, сайт мертв
Gazinur Gram
Gazinur Gram
29 августа 2019

всем привет как скачать [CS 1.6] Extra Item - Awp Asimov (Винтовка)
NikitkaPlay
NikitkaPlay
26 августа 2019

У меня такая же фигня
allanur2003tm
allanur2003tm
23 августа 2019

не магу скачать файл вот

Forbidden
You don't have permission to access /uploads/files/2019-05/1558870142_vulcanus-1.rar on this server.
Lil270
Lil270
17 августа 2019

FLOKI TV,
это как
FLOKI TV
FLOKI TV
9 августа 2019

Как изменить исходники у меня не изменяеться ?
sublime
sublime
3 августа 2019

carlostk,
никак! Проект мертв! И все удалено!
carlostk
carlostk
3 августа 2019

как скачать
Rainbowdash98
Rainbowdash98
1 августа 2019

That right i can't download any old Extra Item and Plugins for my Zombie Plague any more help me this one admin
Azaza
Azaza
24 июля 2019

проблемы на сайте
madosking
madosking
16 июля 2019

HELP
You don't have permission to access /uploads/files/2019-04/1554837425_3699_bb_shop.rar on this server.
porki69
porki69
12 июля 2019

Как скачать, пишет нет доступа
slo2faz
slo2faz
9 июля 2019

как скачать
Ulianovich
Ulianovich
3 июля 2019

Алекс, отпиши в ЛС wink
aplyc
aplyc
22 июня 2019

сайт продают
aplyc
aplyc
22 июня 2019

у всех так
xiaowenzi
xiaowenzi
22 июня 2019

Почему у меня больше нет доступа к скачиванию
Irruka17
Irruka17
21 июня 2019

smile smile smile smile smile smile
5.T.R
5.T.R
17 июня 2019

why i can't download anything from the site it says forbiden
alabamaster1337
alabamaster1337
15 июня 2019

игровые автоматы? спасибо я кекнул
xiaowenzi
xiaowenzi
13 июня 2019

код безопасности что я хочу загрузить новости
Smiley GaMeS
Smiley GaMeS
12 июня 2019

для zp 4.3
Smiley GaMeS
Smiley GaMeS
12 июня 2019

у кого-нибудь есть плагин dual phantom slayer из ксо?
Ulianovich
Ulianovich
10 июня 2019

И как оно
xman2030
xman2030
10 июня 2019

Лошара laughing
DARKFEAL
DARKFEAL
8 июня 2019

Чекаем первый пост в закрепе!
УаJiиев РуСтЕm

подскажите чё делать когдда я скачал плагин да, но там mdl как зделать так чтобы оружия или что та там другое переместить их в магазин или в привелегии скажите пожалуйста я тут новенький помогите мне по Братски пацаны и администряция и т.д. я буду вам очень благодарен.
xiaowenzi
xiaowenzi
30 мая 2019

Who can share Extra Items CSO M1887
xiaowenzi
xiaowenzi
29 мая 2019

Who Can Share the 2009 CSO Light Bomb Model
xiaowenzi
xiaowenzi
28 мая 2019

Who has infected model display plug-in v_infection.mdl
22810
22810
27 мая 2019

Zombie Class - Charger
SMA cannot covert AMXX
Artur Macovetchi
Artur Macovetchi
25 мая 2019

здарова
logo200
logo200
22 мая 2019

здарова
Laur
Laur
22 мая 2019

hi all

Только зарегистрированные посетители могут писать в чате.

Статистика
  • Сейчас на сайте: 2
  • Пользователей: 0
  • Гостей: 2
[ ]
Основа для вашей сборки
ReHLDS 3.4.0.654

ReHLDS (Reverse-engineered) - это новый шаг вперед, который дает второе дыхание нашим серверам. ReHLDS работает в 2 раза быстрей, чем HLDS.

AmxModx 1.8.3

AMXModX - это Metamod дополнение, которое позволяет создавать новые модификации для Half-Life на языке Pawn

Reunion 0.1.92

Reunion является продолжением Dproto для ReHLDS. Это metamod плагин, который позволяет заходить 47/48 Non-Steam на сервер.

Revoice 0.1.0.32

Revoice - это Metamod plugin, который дает возможность общения голосовым чатом между non-steam и steam клиентами.

Metamod-r 1.3.0.127

Новый Metamod-r содержит огромное количество оптимизаций производительности и намного более чистый код. Ядро было написано с использованием JIT-компилятора.

ReAuthCheck 0.1.6

ReAuthCheck - это Metamod плагин, который занимается проверкой ваших игроков на валидность, с помощью данного модуля для REHLDS вы сможете защитить свой сервер от ботов, которые постоянно спамят рекламу или просто забивают слот на сервере!

Информация

Добро пожаловать на ZOMBIE-DEV.RU!

Для того чтобы стать полноценным пользователем нашего портала, вам необходимо пройти регистрацию.
Зарегистрироваться
Создайте собственную учетную запить!

Пройти регистрацию
Авторизоваться
Уже зарегистрированны? А ну-ка живо авторизуйтесь!

Войти на сайт