В данной статье, я покажу как можно добавить свои звуки для зомби класса
Делаем звуки зомби через мод.
После данной статьи, можно добавлять звуки у зомби через .ini файл
Данная статья была удалена с одного сайта, куда её и заливали, через веб-архив я её восстановил.
Находим строку:
// Customization vars и добавляем выше неё:
// Zombie sounds
new Array:class_sound_infect, Array:class_sound_pain, Array:class_sound_idle,
Array:class_sound_idle_last, Array:class_sound_die, Array:class_sound_fall,
Array:class_sound_madness, Array:class_sound_burn, Array:class_sound_miss_slash,
Array:class_sound_miss_wall, Array:class_sound_hit_normal, Array:class_sound_hit_stab,
Array:pointer_class_sound_infect, Array:pointer_class_sound_pain, Array:pointer_class_sound_idle,
Array:pointer_class_sound_idle_last, Array:pointer_class_sound_die, Array:pointer_class_sound_fall,
Array:pointer_class_sound_madness, Array:pointer_class_sound_burn, Array:pointer_class_sound_miss_slash,
Array:pointer_class_sound_miss_wall, Array:pointer_class_sound_hit_normal, Array:pointer_class_sound_hit_stab
// Nemesis sounds
new Array:nemesis_pain, Array:nemesis_idle, Array:nemesis_die,
Array:nemesis_fall, Array:nemesis_miss_slash, Array:nemesis_miss_wall,
Array:nemesis_hit_normal, Array:nemesis_hit_stab
В
public plugin_precache() находим строку:
// Allow registering stuff now и выше добавляем:
nemesis_pain = ArrayCreate(64, 1)
nemesis_idle = ArrayCreate(64, 1)
nemesis_die = ArrayCreate(64, 1)
nemesis_fall = ArrayCreate(64, 1)
nemesis_miss_slash = ArrayCreate(64, 1)
nemesis_miss_wall = ArrayCreate(64, 1)
nemesis_hit_normal = ArrayCreate(64, 1)
nemesis_hit_stab = ArrayCreate(64, 1)
class_sound_infect = ArrayCreate(64, 1)
class_sound_pain = ArrayCreate(64, 1)
class_sound_idle = ArrayCreate(64, 1)
class_sound_idle_last = ArrayCreate(64, 1)
class_sound_die = ArrayCreate(64, 1)
class_sound_fall = ArrayCreate(64, 1)
class_sound_madness = ArrayCreate(64, 1)
class_sound_burn = ArrayCreate(64, 1)
class_sound_miss_slash = ArrayCreate(64, 1)
class_sound_miss_wall = ArrayCreate(64, 1)
class_sound_hit_normal = ArrayCreate(64, 1)
class_sound_hit_stab = ArrayCreate(64, 1)
pointer_class_sound_infect = ArrayCreate(10, 1)
pointer_class_sound_pain = ArrayCreate(10, 1)
pointer_class_sound_idle = ArrayCreate(10, 1)
pointer_class_sound_idle_last = ArrayCreate(10, 1)
pointer_class_sound_die = ArrayCreate(10, 1)
pointer_class_sound_fall = ArrayCreate(64, 1)
pointer_class_sound_madness = ArrayCreate(10, 1)
pointer_class_sound_burn = ArrayCreate(10, 1)
pointer_class_sound_miss_slash = ArrayCreate(64, 1)
pointer_class_sound_miss_wall = ArrayCreate(64, 1)
pointer_class_sound_hit_normal = ArrayCreate(64, 1)
pointer_class_sound_hit_stab = ArrayCreate(64, 1)
Находим в
public plugin_precache() строку
// Custom sounds и добавляем звуки Немезиде и Зомби аналогично звуку Pain
for (i = 0; i < ArraySize(nemesis_pain); i++)
{
ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_idle); i++)
{
ArrayGetString(nemesis_idle, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_die); i++)
{
ArrayGetString(nemesis_die, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_fall); i++)
{
ArrayGetString(nemesis_fall, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_miss_slash); i++)
{
ArrayGetString(nemesis_miss_slash, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_miss_wall); i++)
{
ArrayGetString(nemesis_miss_wall, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_hit_normal); i++)
{
ArrayGetString(nemesis_hit_normal, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(nemesis_hit_stab); i++)
{
ArrayGetString(nemesis_hit_stab, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_infect); i++)
{
ArrayGetString(class_sound_infect, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_pain); i++)
{
ArrayGetString(class_sound_pain, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_idle); i++)
{
ArrayGetString(class_sound_idle, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_idle_last); i++)
{
ArrayGetString(class_sound_idle_last, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_die); i++)
{
ArrayGetString(class_sound_die, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_fall); i++)
{
ArrayGetString(class_sound_fall, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_madness); i++)
{
ArrayGetString(class_sound_madness, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_burn); i++)
{
ArrayGetString(class_sound_burn, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_miss_slash); i++)
{
ArrayGetString(class_sound_miss_slash, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_miss_wall); i++)
{
ArrayGetString(class_sound_miss_wall, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_hit_normal); i++)
{
ArrayGetString(class_sound_hit_normal, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(class_sound_hit_stab); i++)
{
ArrayGetString(class_sound_hit_stab, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
Звук
INFECT:
Находим:
// Infection sound
ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound))
emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Заменяем на:
// Infection sound
static pointers[10], end
ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Ниже находим:
// Infection sound
ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound))
emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Так же заменяем на:
// Infection sound
static pointers[10], end
ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
Звук
PAIN:
Находим:
// Zombie being hit
if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't')
{
if (g_nemesis[id])
{
ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
else
{
ArrayGetString(zombie_pain, random_num(0, ArraySize(zombie_pain) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
return FMRES_SUPERCEDE;
}
Заменяем на:
// Zombie being hit
if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't')
{
if (g_nemesis[id])
{
ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
else
{
static pointers[10], end
ArrayGetArray(pointer_class_sound_pain, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_pain, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
}
return FMRES_SUPERCEDE;
}
Звук
IDLE и
IDLE LAST:
Находим:
// Play idle zombie sounds
public zombie_play_idle(taskid)
{
// Round ended/new one starting
if (g_endround || g_newround)
return;
static sound[64]
// Last zombie?
if (g_lastzombie[ID_BLOOD])
{
ArrayGetString(zombie_idle_last, random_num(0, ArraySize(zombie_idle_last) - 1), sound, charsmax(sound))
emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
else
{
ArrayGetString(zombie_idle, random_num(0, ArraySize(zombie_idle) - 1), sound, charsmax(sound))
emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
}
Заменяем на:
// Play idle zombie sounds
public zombie_play_idle(taskid)
{
// Round ended/new one starting
if (g_endround || g_newround)
return;
static sound[64]
// Last zombie?
if (g_lastzombie[ID_BLOOD])
{
static pointers[10], end
ArrayGetArray(pointer_class_sound_idle_last, g_zombieclass[ID_BLOOD], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_idle_last, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
else if(g_nemesis[ID_BLOOD])
{
ArrayGetString(nemesis_idle, random_num(0, ArraySize(nemesis_idle) - 1), sound, charsmax(sound))
emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
else
{
static pointers[10], end
ArrayGetArray(pointer_class_sound_idle, g_zombieclass[ID_BLOOD], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_idle, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
}
Звук
DIE и
FALL:
Находим:
// Zombie dies
if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a')))
{
ArrayGetString(zombie_die, random_num(0, ArraySize(zombie_die) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
// Zombie falls off
if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l')
{
ArrayGetString(zombie_fall, random_num(0, ArraySize(zombie_fall) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
Заменяем на:
// Zombie dies
if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a')))
{
if(g_nemesis[id])
ArrayGetString(nemesis_die, random_num(0, ArraySize(nemesis_die) - 1), sound, charsmax(sound))
else {
static pointers[10], end
ArrayGetArray(pointer_class_sound_die, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_die, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
}
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
// Zombie falls off
if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l')
{
if(g_nemesis[id])
ArrayGetString(nemesis_fall, random_num(0, ArraySize(nemesis_fall) - 1), sound, charsmax(sound))
else {
static pointers[10], end
ArrayGetArray(pointer_class_sound_fall, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_fall, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
}
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
Звук
BURN:
Находим:
// Randomly play burning zombie scream sounds (not for nemesis)
if (!g_nemesis[ID_BURN] && !random_num(0, 20))
{
static sound[64]
ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound))
emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
Заменяем на:
// Randomly play burning zombie scream sounds (not for nemesis)
if (!g_nemesis[ID_BURN] && !random_num(0, 20))
{
static sound[64]
static pointers[10], end
ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
Звук
MADNESS:
Находим:
case EXTRA_MADNESS: // Zombie Madness
{
// Increase madness purchase count for this round
g_madnesscounter++
g_nodamage[id] = true
set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b")
set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD)
static sound[64]
ArrayGetString(zombie_madness, random_num(0, ArraySize(zombie_madness) - 1), sound, charsmax(sound))
emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
Заменяем на:
case EXTRA_MADNESS: // Zombie Madness
{
// Increase madness purchase count for this round
g_madnesscounter++
g_nodamage[id] = true
set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b")
set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD)
static sound[64]
static pointers[10], end
ArrayGetArray(pointer_class_sound_madness, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_madness, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
Звук
BURN:
Находим:
// Randomly play burning zombie scream sounds (not for nemesis)
if (!g_nemesis[ID_BURN] && !random_num(0, 20))
{
static sound[64]
ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound))
emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
Заменяем на:
// Randomly play burning zombie scream sounds (not for nemesis)
if (!g_nemesis[ID_BURN] && !random_num(0, 20))
{
static sound[64]
static pointers[10], end
ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
Звуки
MISS SLASH,
MISS WALL,
HIT NORMAL,
HIT STAB:
Находим:
// Zombie attacks with knife
if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
{
if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash
{
ArrayGetString(zombie_miss_slash, random_num(0, ArraySize(zombie_miss_slash) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit
{
if (sample[17] == 'w') // wall
{
ArrayGetString(zombie_miss_wall, random_num(0, ArraySize(zombie_miss_wall) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
else
{
ArrayGetString(zombie_hit_normal, random_num(0, ArraySize(zombie_hit_normal) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
}
if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab
{
ArrayGetString(zombie_hit_stab, random_num(0, ArraySize(zombie_hit_stab) - 1), sound, charsmax(sound))
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
}
Заменяем на:
// Zombie attacks with knife
if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i')
{
if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash
{
if(g_nemesis[id])
ArrayGetString(nemesis_miss_slash, random_num(0, ArraySize(nemesis_miss_slash) - 1), sound, charsmax(sound))
else {
static pointers[10], end
ArrayGetArray(pointer_class_sound_miss_slash, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_miss_slash, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
}
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit
{
if (sample[17] == 'w') // wall
{
if(g_nemesis[id])
ArrayGetString(nemesis_miss_wall, random_num(0, ArraySize(nemesis_miss_wall) - 1), sound, charsmax(sound))
else {
static pointers[10], end
ArrayGetArray(pointer_class_sound_miss_wall, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_miss_wall, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
}
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
else
{
if(g_nemesis[id])
ArrayGetString(nemesis_hit_normal, random_num(0, ArraySize(nemesis_hit_normal) - 1), sound, charsmax(sound))
else {
static pointers[10], end
ArrayGetArray(pointer_class_sound_hit_normal, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_hit_normal, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
}
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
}
if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab
{
if(g_nemesis[id])
ArrayGetString(nemesis_hit_stab, random_num(0, ArraySize(nemesis_hit_stab) - 1), sound, charsmax(sound))
else {
static pointers[10], end
ArrayGetArray(pointer_class_sound_hit_stab, g_zombieclass[id], pointers)
for (new i; i < 10; i++)
{
if (pointers[i] != -1)
end = i
}
ArrayGetString(class_sound_hit_stab, random_num(pointers[0], pointers[end]), sound, charsmax(sound))
}
emit_sound(id, channel, sound, volume, attn, flags, pitch)
return FMRES_SUPERCEDE;
}
}
Названия звуков в
zp_zombieclasses.ini:
Находим:
// Parse if present
if (file_exists(path))
{
// Open zombie classes file for reading
file = fopen(path, "rt")
while (file && !feof(file))
{
// Read one line at a time
fgets(file, linedata, charsmax(linedata))
// Replace newlines with a null character to prevent headaches
replace(linedata, charsmax(linedata), "^n", "")
// Blank line or comment
if (!linedata[0] || linedata[0] == ';') continue;
// New class starting
if (linedata[0] == '[')
{
// Remove first and last characters (braces)
linedata[strlen(linedata) - 1] = 0
copy(linedata, charsmax(linedata), linedata[1])
// Store its real name for future reference
ArrayPushString(g_zclass2_realname, linedata)
continue;
}
// Get key and value(s)
strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
// Trim spaces
trim(key)
trim(value)
if (equal(key, "NAME"))
ArrayPushString(g_zclass2_name, value)
else if (equal(key, "INFO"))
ArrayPushString(g_zclass2_info, value)
else if (equal(key, "MODELS"))
{
// Set models start index
ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel))
// Parse class models
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to class models array
ArrayPushString(g_zclass2_playermodel, key)
ArrayPushCell(g_zclass2_modelindex, -1)
}
// Set models end index
ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel))
}
else if (equal(key, "CLAWMODEL"))
ArrayPushString(g_zclass2_clawmodel, value)
else if (equal(key, "HEALTH"))
ArrayPushCell(g_zclass2_hp, str_to_num(value))
else if (equal(key, "SPEED"))
ArrayPushCell(g_zclass2_spd, str_to_num(value))
else if (equal(key, "GRAVITY"))
ArrayPushCell(g_zclass2_grav, str_to_float(value))
else if (equal(key, "KNOCKBACK"))
ArrayPushCell(g_zclass2_kb, str_to_float(value))
}
if (file) fclose(file)
}
Заменяем на:
// Parse if present
if (file_exists(path))
{
// Open zombie classes file for reading
file = fopen(path, "rt")
while (file && !feof(file))
{
static pos, temparr[64]
// Read one line at a time
fgets(file, linedata, charsmax(linedata))
// Replace newlines with a null character to prevent headaches
replace(linedata, charsmax(linedata), "^n", "")
// Blank line or comment
if (!linedata[0] || linedata[0] == ';') continue;
// New class starting
if (linedata[0] == '[')
{
// Remove first and last characters (braces)
linedata[strlen(linedata) - 1] = 0
copy(linedata, charsmax(linedata), linedata[1])
// Store its real name for future reference
ArrayPushString(g_zclass2_realname, linedata)
continue;
}
// Get key and value(s)
strtok(linedata, key, charsmax(key), value, charsmax(value), '=')
// Trim spaces
trim(key)
trim(value)
if (equal(key, "NAME"))
ArrayPushString(g_zclass2_name, value)
else if (equal(key, "INFO"))
ArrayPushString(g_zclass2_info, value)
else if (equal(key, "MODELS"))
{
// Set models start index
ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel))
// Parse class models
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to class models array
ArrayPushString(g_zclass2_playermodel, key)
ArrayPushCell(g_zclass2_modelindex, -1)
}
// Set models end index
ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel))
}
else if (equal(key, "CLAWMODEL"))
ArrayPushString(g_zclass2_clawmodel, value)
else if (equal(key, "HEALTH"))
ArrayPushCell(g_zclass2_hp, str_to_num(value))
else if (equal(key, "SPEED"))
ArrayPushCell(g_zclass2_spd, str_to_num(value))
else if (equal(key, "GRAVITY"))
ArrayPushCell(g_zclass2_grav, str_to_float(value))
else if (equal(key, "KNOCKBACK"))
ArrayPushCell(g_zclass2_kb, str_to_float(value))
else if (equal(key, "INFECT"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_infect, key)
temparr[pos++] = ArraySize(class_sound_infect) - 1
}
ArrayPushArray(pointer_class_sound_infect, temparr)
}
else if (equal(key, "BURN"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_burn, key)
temparr[pos++] = ArraySize(class_sound_burn) - 1
}
ArrayPushArray(pointer_class_sound_burn, temparr)
}
else if (equal(key, "PAIN"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_pain, key)
temparr[pos++] = ArraySize(class_sound_pain) - 1
}
ArrayPushArray(pointer_class_sound_pain, temparr)
}
else if (equal(key, "DIE"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_die, key)
temparr[pos++] = ArraySize(class_sound_die) - 1
}
ArrayPushArray(pointer_class_sound_die, temparr)
}
else if (equal(key, "IDLE"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_idle, key)
temparr[pos++] = ArraySize(class_sound_idle) - 1
}
ArrayPushArray(pointer_class_sound_idle, temparr)
}
else if (equal(key, "IDLE LAST"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_idle_last, key)
temparr[pos++] = ArraySize(class_sound_idle_last) - 1
}
ArrayPushArray(pointer_class_sound_idle_last, temparr)
}
else if (equal(key, "MISS SLASH"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_miss_slash, key)
temparr[pos++] = ArraySize(class_sound_miss_slash) - 1
}
ArrayPushArray(pointer_class_sound_miss_slash, temparr)
}
else if (equal(key, "MISS WALL"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_miss_wall, key)
temparr[pos++] = ArraySize(class_sound_miss_wall) - 1
}
ArrayPushArray(pointer_class_sound_miss_wall, temparr)
}
else if (equal(key, "HIT NORMAL"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_hit_normal, key)
temparr[pos++] = ArraySize(class_sound_hit_normal) - 1
}
ArrayPushArray(pointer_class_sound_hit_normal, temparr)
}
else if (equal(key, "HIT STAB"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_hit_stab, key)
temparr[pos++] = ArraySize(class_sound_hit_stab) - 1
}
ArrayPushArray(pointer_class_sound_hit_stab, temparr)
}
else if (equal(key, "FALL"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_fall, key)
temparr[pos++] = ArraySize(class_sound_fall) - 1
}
ArrayPushArray(pointer_class_sound_fall, temparr)
}
else if (equal(key, "MADNESS"))
{
pos = 0
arrayset(temparr, -1, sizeof(temparr))
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
ArrayPushString(class_sound_madness, key)
temparr[pos++] = ArraySize(class_sound_madness) - 1
}
ArrayPushArray(pointer_class_sound_madness, temparr)
}
}
if (file) fclose(file)
}
Пути к звукам в
Моде:
Находим:
save_customization()
{
new i, k, buffer[512]
// Build zombie classes file path
new path[64]
get_configsdir(path, charsmax(path))
format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE)
// Open zombie classes file for appending data
new file = fopen(path, "at"), size = ArraySize(g_zclass_name)
// Add any new zombie classes data at the end if needed
for (i = 0; i < size; i++)
{
if (ArrayGetCell(g_zclass_new, i))
{
// Add real name
ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^n[%s]", buffer)
fputs(file, buffer)
// Add caption
ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^nNAME = %s", buffer)
fputs(file, buffer)
// Add info
ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^nINFO = %s", buffer)
fputs(file, buffer)
// Add models
for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++)
{
if (k == ArrayGetCell(g_zclass_modelsstart, i))
{
// First model, overwrite buffer
ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer))
}
else
{
// Successive models, append to buffer
ArrayGetString(g_zclass_playermodel, k, path, charsmax(path))
format(buffer, charsmax(buffer), "%s , %s", buffer, path)
}
}
format(buffer, charsmax(buffer), "^nMODELS = %s", buffer)
fputs(file, buffer)
// Add clawmodel
ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer)
fputs(file, buffer)
// Add health
formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i))
fputs(file, buffer)
// Add speed
formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i))
fputs(file, buffer)
// Add gravity
formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i))
fputs(file, buffer)
// Add knockback
formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f^n", Float:ArrayGetCell(g_zclass_kb, i))
fputs(file, buffer)
}
}
Заменяем на:
save_customization()
{
new i, k, buffer[512]
// Build zombie classes file path
new path[64]
get_configsdir(path, charsmax(path))
format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE)
// Open zombie classes file for appending data
new file = fopen(path, "at"), size = ArraySize(g_zclass_name)
// Add any new zombie classes data at the end if needed
for (i = 0; i < size; i++)
{
if (ArrayGetCell(g_zclass_new, i))
{
// Add real name
ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^n[%s]", buffer)
fputs(file, buffer)
// Add caption
ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^nNAME = %s", buffer)
fputs(file, buffer)
// Add info
ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^nINFO = %s", buffer)
fputs(file, buffer)
// Add models
for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++)
{
if (k == ArrayGetCell(g_zclass_modelsstart, i))
{
// First model, overwrite buffer
ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer))
}
else
{
// Successive models, append to buffer
ArrayGetString(g_zclass_playermodel, k, path, charsmax(path))
format(buffer, charsmax(buffer), "%s , %s", buffer, path)
}
}
format(buffer, charsmax(buffer), "^nMODELS = %s", buffer)
fputs(file, buffer)
// Add clawmodel
ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer))
format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer)
fputs(file, buffer)
// Add health
formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i))
fputs(file, buffer)
// Add speed
formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i))
fputs(file, buffer)
// Add gravity
formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i))
fputs(file, buffer)
// Add knockback
formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f", Float:ArrayGetCell(g_zclass_kb, i))
fputs(file, buffer)
// Add infect sound
fputs(file, "^nINFECT = zombie_plague/zombie_infec1.wav , zombie_plague/zombie_infec2.wav , zombie_plague/zombie_infec3.wav")
// Add burn sound
fputs(file, "^nBURN = zombie_plague/zombie_burn3.wav , zombie_plague/zombie_burn4.wav , zombie_plague/zombie_burn5.wav , zombie_plague/zombie_burn6.wav , zombie_plague/zombie_burn7.wav")
// Add pain sound
fputs(file, "^nPAIN = zombie_plague/zombie_pain1.wav , zombie_plague/zombie_pain2.wav , zombie_plague/zombie_pain3.wav , zombie_plague/zombie_pain4.wav , zombie_plague/zombie_pain5.wav")
// Add die sound
fputs(file, "^nDIE = zombie_plague/zombie_die1.wav , zombie_plague/zombie_die2.wav , zombie_plague/zombie_die3.wav , zombie_plague/zombie_die4.wav , zombie_plague/zombie_die5.wav")
// Add idle sound
fputs(file, "^nIDLE = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav")
// Add idle last sound
fputs(file, "^nIDLE LAST = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav")
// Add miss slash sound
fputs(file, "^nMISS SLASH = weapons/knife_slash1.wav , weapons/knife_slash2.wav")
// Add miss wall sound
fputs(file, "^nMISS WALL = weapons/knife_hitwall1.wav")
// Add hit normal sound
fputs(file, "^nHIT NORMAL = weapons/knife_hit1.wav , weapons/knife_hit2.wav , weapons/knife_hit3.wav , weapons/knife_hit4.wav")
// Add hit stab sound
fputs(file, "^nHIT STAB = weapons/knife_stab.wav")
// Add fall sound
fputs(file, "^nFALL = zombie_plague/zombie_fall1.wav")
// Add madness sound
fputs(file, "^nMADNESS = zombie_plague/zombie_madness1.wav^n")
}
}
в файле:
Находим:
else if (equal(key, "WIN NO ONE"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(sound_win_no_one, key)
ArrayPushCell(sound_win_no_one_ismp3, equal(key[strlen(key)-4], ".mp3") ? 1 : 0)
}
}
Добавляем ниже:
else if (equal(key, "NEMESIS PAIN"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_pain, key)
}
}
else if (equal(key, "NEMESIS IDLE"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_idle, key)
}
}
else if (equal(key, "NEMESIS DIE"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_die, key)
}
}
else if (equal(key, "NEMESIS FALL"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_fall, key)
}
}
else if (equal(key, "NEMESIS MISS SLASH"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_miss_slash, key)
}
}
else if (equal(key, "NEMESIS MISS WALL"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_miss_wall, key)
}
}
else if (equal(key, "NEMESIS HIT NORMAL"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_hit_normal, key)
}
}
else if (equal(key, "NEMESIS HIT STAB"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_hit_stab, key)
}
}
Вырезаем
стандартные звуки из мода:
Находим в // Customization vars и удаляем:
Array:zombie_infect,
Array:zombie_pain,
Array:zombie_idle,
Array:zombie_idle_last,
Array:zombie_die,
Array:zombie_fall,
Array:zombie_madness,
Array:grenade_fire_player,
Array:zombie_miss_slash,
Array:zombie_miss_wall,
Array:zombie_hit_normal,
Array:zombie_hit_stab,
Находим в public plugin_precache() и удаляем:
zombie_infect = ArrayCreate(64, 1)
zombie_pain = ArrayCreate(64, 1)
zombie_idle = ArrayCreate(64, 1)
zombie_idle_last = ArrayCreate(64, 1)
zombie_die = ArrayCreate(64, 1)
zombie_fall = ArrayCreate(64, 1)
zombie_madness = ArrayCreate(64, 1)
grenade_fire_player = ArrayCreate(64, 1)
zombie_miss_slash = ArrayCreate(64, 1)
zombie_miss_wall = ArrayCreate(64, 1)
zombie_hit_normal = ArrayCreate(64, 1)
zombie_hit_stab = ArrayCreate(64, 1)
for (i = 0; i < ArraySize(zombie_infect); i++)
{
ArrayGetString(zombie_infect, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_pain); i++)
{
ArrayGetString(zombie_pain, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_idle); i++)
{
ArrayGetString(zombie_idle, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_idle_last); i++)
{
ArrayGetString(zombie_idle_last, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_die); i++)
{
ArrayGetString(zombie_die, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_fall); i++)
{
ArrayGetString(zombie_fall, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_madness); i++)
{
ArrayGetString(zombie_madness, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(grenade_fire_player); i++)
{
ArrayGetString(grenade_fire_player, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_miss_slash); i++)
{
ArrayGetString(zombie_miss_slash, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_miss_wall); i++)
{
ArrayGetString(zombie_miss_wall, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_hit_normal); i++)
{
ArrayGetString(zombie_hit_normal, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
for (i = 0; i < ArraySize(zombie_hit_stab); i++)
{
ArrayGetString(zombie_hit_stab, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
Находим в case SECTION_SOUNDS: и удаляем:
else if (equal(key, "ZOMBIE INFECT"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_infect, key)
}
}
else if (equal(key, "ZOMBIE PAIN"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_pain, key)
}
}
else if (equal(key, "ZOMBIE IDLE"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_idle, key)
}
}
else if (equal(key, "ZOMBIE IDLE LAST"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_idle_last, key)
}
}
else if (equal(key, "ZOMBIE DIE"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_die, key)
}
}
else if (equal(key, "ZOMBIE FALL"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_fall, key)
}
}
else if (equal(key, "ZOMBIE MADNESS"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_madness, key)
}
}
else if (equal(key, "GRENADE FIRE PLAYER"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(grenade_fire_player, key)
}
}
else if (equal(key, "ZOMBIE MISS SLASH"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_miss_slash, key)
}
}
else if (equal(key, "ZOMBIE MISS WALL"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_miss_wall, key)
}
}
else if (equal(key, "ZOMBIE HIT NORMAL"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_hit_normal, key)
}
}
else if (equal(key, "ZOMBIE HIT STAB"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(zombie_hit_stab, key)
}
}
В
zombieplague.ini добавляем:
NEMESIS HIT STAB = Ваш путь к звукам/Ваш звук.wav
NEMESIS HIT NORMAL = Ваш путь к звукам/Ваш звук.wav
NEMESIS MISS WALL = Ваш путь к звукам/Ваш звук.wav
NEMESIS MISS SLASH = Ваш путь к звукам/Ваш звук.wav
NEMESIS PAIN = Ваш путь к звукам/Ваш звук.wav
NEMESIS DIE = Ваш путь к звукам/Ваш звук.wav
NEMESIS IDLE = Ваш путь к звукам/Ваш звук.wav
Удаляем лишнее
-----------------------------------------------------------
Array:nemesis_pain,
-----------------------------------------------------------
nemesis_pain = ArrayCreate(64, 1)
-----------------------------------------------------------
for (i = 0; i < ArraySize(nemesis_pain); i++)
{
ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer))
engfunc(EngFunc_PrecacheSound, buffer)
}
-----------------------------------------------------------
else if (equal(key, "NEMESIS PAIN"))
{
// Parse sounds
while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ','))
{
// Trim spaces
trim(key)
trim(value)
// Add to sounds array
ArrayPushString(nemesis_pain, key)
}
}
-----------------------------------------------------------
Новости
VIP файлы
PREMIUM файлы
Приватный материал
Клиент игры
Все для CS 1.6
Модели зомби для CS 1.6
Модели игроков для CS 1.6
Модели ножа для CS 1.6
Модели оружия для CS 1.6
Модели рук зомби для CS 1.6
Модели гранат для CS 1.6
Статьи
Программы
WEB Скрипты + шаблоны
Все для gamecms version all
Черный список пользователей
Hud Configurator
Доска позора
Просмотр моделей
CSO PISTOLS
CSO MACHINE GUN
CSO ZOMBIE CLASS
Скачать КС 1.6 (Рекомендуем!)
Заказать Установку сервера!
VK Admin | ВКонтакте
