как установить звуки для каждого зомби, через мод ZP 4.3 CS 1.6

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

    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)

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)
    }

Находим:
           // 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)

Находим:
   // 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;
    }

Находим:
// 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)
    }
}

Находим:
   // 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;
    }

Находим:
       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)
        }

Находим:
   // 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)
    }

Находим:
   // 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;
        }
    }

Находим:
   // 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)
                    }
                }

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)
                    }
                }
-----------------------------------------------------------