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

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

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

Находим:
    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 = Ваш путь к звукам/Ваш звук