как настроить звуки для зомби через сам мод Zombie Plague в CS 1.6

new Array:class_sound_infect, Array:class_sound_pain, Array:class_sound_die, Array:class_sound_fall,
Array:class_sound_miss_slash, Array:class_sound_miss_wall, Array:class_sound_hit_normal, Array:class_sound_hit_stab,
Array:class_sound_idle, Array:class_sound_idle_last, Array:class_sound_burn

new Array:pointer_class_sound_infect, Array:pointer_class_sound_pain, Array:pointer_class_sound_die,
Array:pointer_class_sound_fall, Array:pointer_class_sound_miss_slash, Array:pointer_class_sound_miss_wall,
Array:pointer_class_sound_hit_normal, Array:pointer_class_sound_hit_stab, Array:pointer_class_sound_idle,
Array:pointer_class_sound_idle_last, Array:pointer_class_sound_burn

class_sound_infect = ArrayCreate(64, 1)
class_sound_pain = ArrayCreate(64, 1)
class_sound_die = ArrayCreate(64, 1)
class_sound_fall = 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)
class_sound_idle = ArrayCreate(64, 1)
class_sound_idle_last = ArrayCreate(64, 1)
class_sound_burn = ArrayCreate(64, 1)
pointer_class_sound_infect = ArrayCreate(10, 1)
pointer_class_sound_pain = ArrayCreate(10, 1)
pointer_class_sound_die = ArrayCreate(10, 1)
pointer_class_sound_fall = ArrayCreate(10, 1)
pointer_class_sound_miss_slash = ArrayCreate(10, 1)
pointer_class_sound_miss_wall = ArrayCreate(10, 1)
pointer_class_sound_hit_normal = ArrayCreate(10, 1)
pointer_class_sound_hit_stab = ArrayCreate(10, 1)
pointer_class_sound_idle = ArrayCreate(10, 1)
pointer_class_sound_idle_last = ArrayCreate(10, 1)
pointer_class_sound_burn = ArrayCreate(10, 1)

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_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_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)
}
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_burn); i++)
{
    ArrayGetString(class_sound_burn, i, buffer, charsmax(buffer))
    engfunc(EngFunc_PrecacheSound, buffer)
}

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

if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
{
if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a')
{
if (g_nemesis[id])
{
ArrayGetString(nemesis_miss_slash, random_num(0, ArraySize(nemesis_miss_slash) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
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')
{
if (sample[17] == 'w')
{
if (g_nemesis[id])
{
ArrayGetString(nemesis_miss_wall, random_num(0, ArraySize(nemesis_miss_wall) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
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;
}
if (g_nemesis[id])
{
ArrayGetString(nemesis_hit_normal, random_num(0, ArraySize(nemesis_hit_normal) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
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')
{
if (g_nemesis[id])
{
ArrayGetString(nemesis_hit_stab, random_num(0, ArraySize(nemesis_hit_stab) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
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;
}
}

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))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
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;
}

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))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
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;
}
return FMRES_IGNORED;
}

// 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)
}
else
{
fm_set_user_health(id, ArrayGetCell(g_zclass_hp, g_zombieclass[id]))
if (!g_frozen[id]) set_pev(id, pev_gravity, Float:ArrayGetCell(g_zclass_grav, g_zombieclass[id]))

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)

set_hudmessage(255, 0, 0, HUD_INFECT_X, HUD_INFECT_Y, 0, 0.0, 5.0, 1.0, 1.0, -1)

if (infector)
show_dhudmessage(0, "%L", LANG_PLAYER, "NOTICE_INFECT2", g_playername[id], g_playername[infector])
else
show_dhudmessage(0, "%L", LANG_PLAYER, "NOTICE_INFECT", g_playername[id])
}
}
else
{
// Silent mode, no HUD messages, no infection sounds

// 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)
}
else
{
fm_set_user_health(id, ArrayGetCell(g_zclass_hp, g_zombieclass[id]))
if (!g_frozen[id]) set_pev(id, pev_gravity, Float:ArrayGetCell(g_zclass_grav, g_zombieclass[id]))

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)
}
}
else
{
// Silent mode, no HUD messages, no infection sounds

else if (equal(key, "ZOMBIE PAIN"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE DIE"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE FALL"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE MISS SLASH"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE MISS WALL"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE HIT NORMAL"))
{
pos = 0

arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE HIT STAB"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE IDLE"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE IDLE LAST"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
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, "ZOMBIE BURN"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
trim(key)
trim(value)

ArrayPushString(class_sound_burn, key)
temparr[pos++] = ArraySize(class_sound_burn) - 1
}

ArrayPushArray(pointer_class_sound_burn, temparr)
}
}
if (file) fclose(file)
}