В этой статье я расскажу
как установить звуки для каждого зомби, через мод ZP 4.3 CS 1.6
Статья уровня копи-паст, следовательно делайте как написано, и тогда у Вас все получится.
Ищем файл zombie_plague40.sma и открываем его через любой редактор кода, в моем случае это будет Notepad++
Далее находим строку: // 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;
}
Звук
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;
}
}
Названия звуков в
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)
}
Пути к звукам в Моде
Zombie Plague:
Находим:
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
Самые наблюдательные из Вас наверное заметили два массива под звук nemesis_pain, находим и удаляем один из них:
-----------------------------------------------------------
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)
}
}
-----------------------------------------------------------
Компилируем, ставим, играем.
Уважаемый посетитель, Вы зашли на сайт как незарегистрированный пользователь. Мы рекомендуем Вам зарегистрироваться либо войти на сайт под своим именем.
fascinatedelati
sossisuka
alawz
[ZP/ZE] Extra Item — Barlog XI
[ZP] Extra Item — Galil Maverick
[ZP] Extra Item — Sha Wujing Dual Handgu
Dhud Advert
[ZP] Extra Item — Vulcanus-11
[ZP] Extra Item — Hunter Killer X-7
[KF] Добавляем оружие в ServerPerks