Звуки зомби через мод.

// Zombie sounds
new Array:class_sound_infect, Array:class_sound_pain, Array:class_sound_idle, 
Array:class_sound_idle_last, Array:class_sound_die, Array:class_sound_fall, 
Array:class_sound_madness, Array:class_sound_burn, Array:class_sound_miss_slash, 
Array:class_sound_miss_wall, Array:class_sound_hit_normal, Array:class_sound_hit_stab, 
Array:pointer_class_sound_infect, Array:pointer_class_sound_pain, Array:pointer_class_sound_idle, 
Array:pointer_class_sound_idle_last, Array:pointer_class_sound_die, Array:pointer_class_sound_fall, 
Array:pointer_class_sound_madness, Array:pointer_class_sound_burn, Array:pointer_class_sound_miss_slash, 
Array:pointer_class_sound_miss_wall, Array:pointer_class_sound_hit_normal, Array:pointer_class_sound_hit_stab 

// Nemesis sounds
new Array:nemesis_pain, Array:nemesis_idle, Array:nemesis_die, 
Array:nemesis_fall, Array:nemesis_miss_slash, Array:nemesis_miss_wall, 
Array:nemesis_hit_normal, Array:nemesis_hit_stab 

	nemesis_pain = ArrayCreate(64, 1) 
	nemesis_idle = ArrayCreate(64, 1)
	nemesis_die = ArrayCreate(64, 1)
	nemesis_fall = ArrayCreate(64, 1)
	nemesis_miss_slash = ArrayCreate(64, 1) 
	nemesis_miss_wall = ArrayCreate(64, 1)
	nemesis_hit_normal = ArrayCreate(64, 1)
	nemesis_hit_stab = ArrayCreate(64, 1)
	class_sound_infect = ArrayCreate(64, 1)
	class_sound_pain = ArrayCreate(64, 1)
	class_sound_idle = ArrayCreate(64, 1)
	class_sound_idle_last = ArrayCreate(64, 1)
	class_sound_die = ArrayCreate(64, 1)
	class_sound_fall = ArrayCreate(64, 1)
	class_sound_madness = ArrayCreate(64, 1)
	class_sound_burn = ArrayCreate(64, 1)
	class_sound_miss_slash = ArrayCreate(64, 1)
	class_sound_miss_wall = ArrayCreate(64, 1)
	class_sound_hit_normal = ArrayCreate(64, 1)
	class_sound_hit_stab = ArrayCreate(64, 1)
	pointer_class_sound_infect = ArrayCreate(10, 1)
	pointer_class_sound_pain = ArrayCreate(10, 1)
	pointer_class_sound_idle = ArrayCreate(10, 1)
	pointer_class_sound_idle_last = ArrayCreate(10, 1)
	pointer_class_sound_die = ArrayCreate(10, 1)
	pointer_class_sound_fall = ArrayCreate(64, 1)
	pointer_class_sound_madness = ArrayCreate(10, 1)
	pointer_class_sound_burn = ArrayCreate(10, 1)
	pointer_class_sound_miss_slash = ArrayCreate(64, 1)
	pointer_class_sound_miss_wall = ArrayCreate(64, 1)
	pointer_class_sound_hit_normal = ArrayCreate(64, 1)
	pointer_class_sound_hit_stab = ArrayCreate(64, 1)

 for (i = 0; i < ArraySize(nemesis_pain); i++) { ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_idle); i++) { ArrayGetString(nemesis_idle, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_die); i++) { ArrayGetString(nemesis_die, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_fall); i++) { ArrayGetString(nemesis_fall, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_miss_slash); i++) { ArrayGetString(nemesis_miss_slash, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_miss_wall); i++) { ArrayGetString(nemesis_miss_wall, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_hit_normal); i++) { ArrayGetString(nemesis_hit_normal, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(nemesis_hit_stab); i++) { ArrayGetString(nemesis_hit_stab, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_infect); i++) { ArrayGetString(class_sound_infect, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_pain); i++) { ArrayGetString(class_sound_pain, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_idle); i++) { ArrayGetString(class_sound_idle, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_idle_last); i++) { ArrayGetString(class_sound_idle_last, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_die); i++) { ArrayGetString(class_sound_die, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_fall); i++) { ArrayGetString(class_sound_fall, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_madness); i++) { ArrayGetString(class_sound_madness, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_burn); i++) { ArrayGetString(class_sound_burn, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_miss_slash); i++) { ArrayGetString(class_sound_miss_slash, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_miss_wall); i++) { ArrayGetString(class_sound_miss_wall, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_hit_normal); i++) { ArrayGetString(class_sound_hit_normal, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(class_sound_hit_stab); i++) { ArrayGetString(class_sound_hit_stab, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } 

 Находим: // Infection sound ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound)) emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) Заменяем на: // Infection sound static pointers[10], end ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) Ниже находим: // Infection sound ArrayGetString(zombie_infect, random_num(0, ArraySize(zombie_infect) - 1), sound, charsmax(sound)) emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) Так же заменяем на: // Infection sound static pointers[10], end ArrayGetArray(pointer_class_sound_infect, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_infect, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) 

 Находим: // Zombie being hit if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't') { if (g_nemesis[id]) { ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) } else { ArrayGetString(zombie_pain, random_num(0, ArraySize(zombie_pain) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) } return FMRES_SUPERCEDE; } Заменяем на: // Zombie being hit if (sample[7] == 'b' && sample[8] == 'h' && sample[9] == 'i' && sample[10] == 't') { if (g_nemesis[id]) { ArrayGetString(nemesis_pain, random_num(0, ArraySize(nemesis_pain) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) } else { static pointers[10], end ArrayGetArray(pointer_class_sound_pain, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_pain, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) } return FMRES_SUPERCEDE; } 

 Находим: // Play idle zombie sounds public zombie_play_idle(taskid) { // Round ended/new one starting if (g_endround || g_newround) return; static sound[64] // Last zombie? if (g_lastzombie[ID_BLOOD]) { ArrayGetString(zombie_idle_last, random_num(0, ArraySize(zombie_idle_last) - 1), sound, charsmax(sound)) emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } else { ArrayGetString(zombie_idle, random_num(0, ArraySize(zombie_idle) - 1), sound, charsmax(sound)) emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } } Заменяем на: // Play idle zombie sounds public zombie_play_idle(taskid) { // Round ended/new one starting if (g_endround || g_newround) return; static sound[64] // Last zombie? if (g_lastzombie[ID_BLOOD]) { static pointers[10], end ArrayGetArray(pointer_class_sound_idle_last, g_zombieclass[ID_BLOOD], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_idle_last, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } else if(g_nemesis[ID_BLOOD]) { ArrayGetString(nemesis_idle, random_num(0, ArraySize(nemesis_idle) - 1), sound, charsmax(sound)) emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } else { static pointers[10], end ArrayGetArray(pointer_class_sound_idle, g_zombieclass[ID_BLOOD], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_idle, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(ID_BLOOD, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } } 

 Находим: // Zombie dies if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a'))) { ArrayGetString(zombie_die, random_num(0, ArraySize(zombie_die) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } // Zombie falls off if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l') { ArrayGetString(zombie_fall, random_num(0, ArraySize(zombie_fall) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } Заменяем на: // Zombie dies if (sample[7] == 'd' && ((sample[8] == 'i' && sample[9] == 'e') || (sample[8] == 'e' && sample[9] == 'a'))) { if(g_nemesis[id]) ArrayGetString(nemesis_die, random_num(0, ArraySize(nemesis_die) - 1), sound, charsmax(sound)) else { static pointers[10], end ArrayGetArray(pointer_class_sound_die, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_die, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) } emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } // Zombie falls off if (sample[10] == 'f' && sample[11] == 'a' && sample[12] == 'l' && sample[13] == 'l') { if(g_nemesis[id]) ArrayGetString(nemesis_fall, random_num(0, ArraySize(nemesis_fall) - 1), sound, charsmax(sound)) else { static pointers[10], end ArrayGetArray(pointer_class_sound_fall, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_fall, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) } emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } 

 Находим: case EXTRA_MADNESS: // Zombie Madness { // Increase madness purchase count for this round g_madnesscounter++ g_nodamage[id] = true set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b") set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD) static sound[64] ArrayGetString(zombie_madness, random_num(0, ArraySize(zombie_madness) - 1), sound, charsmax(sound)) emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } Заменяем на: case EXTRA_MADNESS: // Zombie Madness { // Increase madness purchase count for this round g_madnesscounter++ g_nodamage[id] = true set_task(0.1, "zombie_aura", id+TASK_AURA, _, _, "b") set_task(get_pcvar_float(cvar_madnessduration), "madness_over", id+TASK_BLOOD) static sound[64] static pointers[10], end ArrayGetArray(pointer_class_sound_madness, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_madness, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(id, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } 

 Находим: // Randomly play burning zombie scream sounds (not for nemesis) if (!g_nemesis[ID_BURN] && !random_num(0, 20)) { static sound[64] ArrayGetString(grenade_fire_player, random_num(0, ArraySize(grenade_fire_player) - 1), sound, charsmax(sound)) emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } Заменяем на: // Randomly play burning zombie scream sounds (not for nemesis) if (!g_nemesis[ID_BURN] && !random_num(0, 20)) { static sound[64] static pointers[10], end ArrayGetArray(pointer_class_sound_burn, g_zombieclass[ID_BURN], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_burn, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) emit_sound(ID_BURN, CHAN_VOICE, sound, 1.0, ATTN_NORM, 0, PITCH_NORM) } 

 Находим: // Zombie attacks with knife if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i') { if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash { ArrayGetString(zombie_miss_slash, random_num(0, ArraySize(zombie_miss_slash) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit { if (sample[17] == 'w') // wall { ArrayGetString(zombie_miss_wall, random_num(0, ArraySize(zombie_miss_wall) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } else { ArrayGetString(zombie_hit_normal, random_num(0, ArraySize(zombie_hit_normal) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } } if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab { ArrayGetString(zombie_hit_stab, random_num(0, ArraySize(zombie_hit_stab) - 1), sound, charsmax(sound)) emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } } Заменяем на: // Zombie attacks with knife if (sample[8] == 'k' && sample[9] == 'n' && sample[10] == 'i') { if (sample[14] == 's' && sample[15] == 'l' && sample[16] == 'a') // slash { if(g_nemesis[id]) ArrayGetString(nemesis_miss_slash, random_num(0, ArraySize(nemesis_miss_slash) - 1), sound, charsmax(sound)) else { static pointers[10], end ArrayGetArray(pointer_class_sound_miss_slash, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_miss_slash, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) } emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } if (sample[14] == 'h' && sample[15] == 'i' && sample[16] == 't') // hit { if (sample[17] == 'w') // wall { if(g_nemesis[id]) ArrayGetString(nemesis_miss_wall, random_num(0, ArraySize(nemesis_miss_wall) - 1), sound, charsmax(sound)) else { static pointers[10], end ArrayGetArray(pointer_class_sound_miss_wall, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_miss_wall, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) } emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } else { if(g_nemesis[id]) ArrayGetString(nemesis_hit_normal, random_num(0, ArraySize(nemesis_hit_normal) - 1), sound, charsmax(sound)) else { static pointers[10], end ArrayGetArray(pointer_class_sound_hit_normal, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_hit_normal, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) } emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } } if (sample[14] == 's' && sample[15] == 't' && sample[16] == 'a') // stab { if(g_nemesis[id]) ArrayGetString(nemesis_hit_stab, random_num(0, ArraySize(nemesis_hit_stab) - 1), sound, charsmax(sound)) else { static pointers[10], end ArrayGetArray(pointer_class_sound_hit_stab, g_zombieclass[id], pointers) for (new i; i < 10; i++) { if (pointers[i] != -1) end = i } ArrayGetString(class_sound_hit_stab, random_num(pointers[0], pointers[end]), sound, charsmax(sound)) } emit_sound(id, channel, sound, volume, attn, flags, pitch) return FMRES_SUPERCEDE; } } 

 Находим: // Parse if present if (file_exists(path)) { // Open zombie classes file for reading file = fopen(path, "rt") while (file && !feof(file)) { // Read one line at a time fgets(file, linedata, charsmax(linedata)) // Replace newlines with a null character to prevent headaches replace(linedata, charsmax(linedata), "^n", "") // Blank line or comment if (!linedata[0] || linedata[0] == ';') continue; // New class starting if (linedata[0] == '[') { // Remove first and last characters (braces) linedata[strlen(linedata) - 1] = 0 copy(linedata, charsmax(linedata), linedata[1]) // Store its real name for future reference ArrayPushString(g_zclass2_realname, linedata) continue; } // Get key and value(s) strtok(linedata, key, charsmax(key), value, charsmax(value), '=') // Trim spaces trim(key) trim(value) if (equal(key, "NAME")) ArrayPushString(g_zclass2_name, value) else if (equal(key, "INFO")) ArrayPushString(g_zclass2_info, value) else if (equal(key, "MODELS")) { // Set models start index ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel)) // Parse class models while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to class models array ArrayPushString(g_zclass2_playermodel, key) ArrayPushCell(g_zclass2_modelindex, -1) } // Set models end index ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel)) } else if (equal(key, "CLAWMODEL")) ArrayPushString(g_zclass2_clawmodel, value) else if (equal(key, "HEALTH")) ArrayPushCell(g_zclass2_hp, str_to_num(value)) else if (equal(key, "SPEED")) ArrayPushCell(g_zclass2_spd, str_to_num(value)) else if (equal(key, "GRAVITY")) ArrayPushCell(g_zclass2_grav, str_to_float(value)) else if (equal(key, "KNOCKBACK")) ArrayPushCell(g_zclass2_kb, str_to_float(value)) } if (file) fclose(file) } Заменяем на: // Parse if present if (file_exists(path)) { // Open zombie classes file for reading file = fopen(path, "rt") while (file && !feof(file)) { static pos, temparr[64] // Read one line at a time fgets(file, linedata, charsmax(linedata)) // Replace newlines with a null character to prevent headaches replace(linedata, charsmax(linedata), "^n", "") // Blank line or comment if (!linedata[0] || linedata[0] == ';') continue; // New class starting if (linedata[0] == '[') { // Remove first and last characters (braces) linedata[strlen(linedata) - 1] = 0 copy(linedata, charsmax(linedata), linedata[1]) // Store its real name for future reference ArrayPushString(g_zclass2_realname, linedata) continue; } // Get key and value(s) strtok(linedata, key, charsmax(key), value, charsmax(value), '=') // Trim spaces trim(key) trim(value) if (equal(key, "NAME")) ArrayPushString(g_zclass2_name, value) else if (equal(key, "INFO")) ArrayPushString(g_zclass2_info, value) else if (equal(key, "MODELS")) { // Set models start index ArrayPushCell(g_zclass2_modelsstart, ArraySize(g_zclass2_playermodel)) // Parse class models while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to class models array ArrayPushString(g_zclass2_playermodel, key) ArrayPushCell(g_zclass2_modelindex, -1) } // Set models end index ArrayPushCell(g_zclass2_modelsend, ArraySize(g_zclass2_playermodel)) } else if (equal(key, "CLAWMODEL")) ArrayPushString(g_zclass2_clawmodel, value) else if (equal(key, "HEALTH")) ArrayPushCell(g_zclass2_hp, str_to_num(value)) else if (equal(key, "SPEED")) ArrayPushCell(g_zclass2_spd, str_to_num(value)) else if (equal(key, "GRAVITY")) ArrayPushCell(g_zclass2_grav, str_to_float(value)) else if (equal(key, "KNOCKBACK")) ArrayPushCell(g_zclass2_kb, str_to_float(value)) else if (equal(key, "INFECT")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_infect, key) temparr[pos++] = ArraySize(class_sound_infect) - 1 } ArrayPushArray(pointer_class_sound_infect, temparr) } else if (equal(key, "BURN")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_burn, key) temparr[pos++] = ArraySize(class_sound_burn) - 1 } ArrayPushArray(pointer_class_sound_burn, temparr) } else if (equal(key, "PAIN")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_pain, key) temparr[pos++] = ArraySize(class_sound_pain) - 1 } ArrayPushArray(pointer_class_sound_pain, temparr) } else if (equal(key, "DIE")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_die, key) temparr[pos++] = ArraySize(class_sound_die) - 1 } ArrayPushArray(pointer_class_sound_die, temparr) } else if (equal(key, "IDLE")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_idle, key) temparr[pos++] = ArraySize(class_sound_idle) - 1 } ArrayPushArray(pointer_class_sound_idle, temparr) } else if (equal(key, "IDLE LAST")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_idle_last, key) temparr[pos++] = ArraySize(class_sound_idle_last) - 1 } ArrayPushArray(pointer_class_sound_idle_last, temparr) } else if (equal(key, "MISS SLASH")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_miss_slash, key) temparr[pos++] = ArraySize(class_sound_miss_slash) - 1 } ArrayPushArray(pointer_class_sound_miss_slash, temparr) } else if (equal(key, "MISS WALL")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_miss_wall, key) temparr[pos++] = ArraySize(class_sound_miss_wall) - 1 } ArrayPushArray(pointer_class_sound_miss_wall, temparr) } else if (equal(key, "HIT NORMAL")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_hit_normal, key) temparr[pos++] = ArraySize(class_sound_hit_normal) - 1 } ArrayPushArray(pointer_class_sound_hit_normal, temparr) } else if (equal(key, "HIT STAB")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_hit_stab, key) temparr[pos++] = ArraySize(class_sound_hit_stab) - 1 } ArrayPushArray(pointer_class_sound_hit_stab, temparr) } else if (equal(key, "FALL")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_fall, key) temparr[pos++] = ArraySize(class_sound_fall) - 1 } ArrayPushArray(pointer_class_sound_fall, temparr) } else if (equal(key, "MADNESS")) { pos = 0 arrayset(temparr, -1, sizeof(temparr)) while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) ArrayPushString(class_sound_madness, key) temparr[pos++] = ArraySize(class_sound_madness) - 1 } ArrayPushArray(pointer_class_sound_madness, temparr) } } if (file) fclose(file) } 

 Находим: save_customization() { new i, k, buffer[512] // Build zombie classes file path new path[64] get_configsdir(path, charsmax(path)) format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE) // Open zombie classes file for appending data new file = fopen(path, "at"), size = ArraySize(g_zclass_name) // Add any new zombie classes data at the end if needed for (i = 0; i < size; i++) { if (ArrayGetCell(g_zclass_new, i)) { // Add real name ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^n[%s]", buffer) fputs(file, buffer) // Add caption ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^nNAME = %s", buffer) fputs(file, buffer) // Add info ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^nINFO = %s", buffer) fputs(file, buffer) // Add models for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++) { if (k == ArrayGetCell(g_zclass_modelsstart, i)) { // First model, overwrite buffer ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer)) } else { // Successive models, append to buffer ArrayGetString(g_zclass_playermodel, k, path, charsmax(path)) format(buffer, charsmax(buffer), "%s , %s", buffer, path) } } format(buffer, charsmax(buffer), "^nMODELS = %s", buffer) fputs(file, buffer) // Add clawmodel ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer) fputs(file, buffer) // Add health formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i)) fputs(file, buffer) // Add speed formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i)) fputs(file, buffer) // Add gravity formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i)) fputs(file, buffer) // Add knockback formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f^n", Float:ArrayGetCell(g_zclass_kb, i)) fputs(file, buffer) } } Заменяем на: save_customization() { new i, k, buffer[512] // Build zombie classes file path new path[64] get_configsdir(path, charsmax(path)) format(path, charsmax(path), "%s/%s", path, ZP_ZOMBIECLASSES_FILE) // Open zombie classes file for appending data new file = fopen(path, "at"), size = ArraySize(g_zclass_name) // Add any new zombie classes data at the end if needed for (i = 0; i < size; i++) { if (ArrayGetCell(g_zclass_new, i)) { // Add real name ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^n[%s]", buffer) fputs(file, buffer) // Add caption ArrayGetString(g_zclass_name, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^nNAME = %s", buffer) fputs(file, buffer) // Add info ArrayGetString(g_zclass_info, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^nINFO = %s", buffer) fputs(file, buffer) // Add models for (k = ArrayGetCell(g_zclass_modelsstart, i); k < ArrayGetCell(g_zclass_modelsend, i); k++) { if (k == ArrayGetCell(g_zclass_modelsstart, i)) { // First model, overwrite buffer ArrayGetString(g_zclass_playermodel, k, buffer, charsmax(buffer)) } else { // Successive models, append to buffer ArrayGetString(g_zclass_playermodel, k, path, charsmax(path)) format(buffer, charsmax(buffer), "%s , %s", buffer, path) } } format(buffer, charsmax(buffer), "^nMODELS = %s", buffer) fputs(file, buffer) // Add clawmodel ArrayGetString(g_zclass_clawmodel, i, buffer, charsmax(buffer)) format(buffer, charsmax(buffer), "^nCLAWMODEL = %s", buffer) fputs(file, buffer) // Add health formatex(buffer, charsmax(buffer), "^nHEALTH = %d", ArrayGetCell(g_zclass_hp, i)) fputs(file, buffer) // Add speed formatex(buffer, charsmax(buffer), "^nSPEED = %d", ArrayGetCell(g_zclass_spd, i)) fputs(file, buffer) // Add gravity formatex(buffer, charsmax(buffer), "^nGRAVITY = %.2f", Float:ArrayGetCell(g_zclass_grav, i)) fputs(file, buffer) // Add knockback formatex(buffer, charsmax(buffer), "^nKNOCKBACK = %.2f", Float:ArrayGetCell(g_zclass_kb, i)) fputs(file, buffer) // Add infect sound fputs(file, "^nINFECT = zombie_plague/zombie_infec1.wav , zombie_plague/zombie_infec2.wav , zombie_plague/zombie_infec3.wav") // Add burn sound fputs(file, "^nBURN = zombie_plague/zombie_burn3.wav , zombie_plague/zombie_burn4.wav , zombie_plague/zombie_burn5.wav , zombie_plague/zombie_burn6.wav , zombie_plague/zombie_burn7.wav") // Add pain sound fputs(file, "^nPAIN = zombie_plague/zombie_pain1.wav , zombie_plague/zombie_pain2.wav , zombie_plague/zombie_pain3.wav , zombie_plague/zombie_pain4.wav , zombie_plague/zombie_pain5.wav") // Add die sound fputs(file, "^nDIE = zombie_plague/zombie_die1.wav , zombie_plague/zombie_die2.wav , zombie_plague/zombie_die3.wav , zombie_plague/zombie_die4.wav , zombie_plague/zombie_die5.wav") // Add idle sound fputs(file, "^nIDLE = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav") // Add idle last sound fputs(file, "^nIDLE LAST = zombie_plague/zombie_brains1.wav , zombie_plague/zombie_brains2.wav") // Add miss slash sound fputs(file, "^nMISS SLASH = weapons/knife_slash1.wav , weapons/knife_slash2.wav") // Add miss wall sound fputs(file, "^nMISS WALL = weapons/knife_hitwall1.wav") // Add hit normal sound fputs(file, "^nHIT NORMAL = weapons/knife_hit1.wav , weapons/knife_hit2.wav , weapons/knife_hit3.wav , weapons/knife_hit4.wav") // Add hit stab sound fputs(file, "^nHIT STAB = weapons/knife_stab.wav") // Add fall sound fputs(file, "^nFALL = zombie_plague/zombie_fall1.wav") // Add madness sound fputs(file, "^nMADNESS = zombie_plague/zombie_madness1.wav^n") } } 

 Находим: else if (equal(key, "WIN NO ONE")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(sound_win_no_one, key) ArrayPushCell(sound_win_no_one_ismp3, equal(key[strlen(key)-4], ".mp3") ? 1 : 0) } } Добавляем ниже: else if (equal(key, "NEMESIS PAIN")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_pain, key) } } else if (equal(key, "NEMESIS IDLE")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_idle, key) } } else if (equal(key, "NEMESIS DIE")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_die, key) } } else if (equal(key, "NEMESIS FALL")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_fall, key) } } else if (equal(key, "NEMESIS MISS SLASH")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_miss_slash, key) } } else if (equal(key, "NEMESIS MISS WALL")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_miss_wall, key) } } else if (equal(key, "NEMESIS HIT NORMAL")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_hit_normal, key) } } else if (equal(key, "NEMESIS HIT STAB")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_hit_stab, key) } } 

 Находим в // Customization vars и удаляем: Array:zombie_infect, Array:zombie_pain, Array:zombie_idle, Array:zombie_idle_last, Array:zombie_die, Array:zombie_fall, Array:zombie_madness, Array:grenade_fire_player, Array:zombie_miss_slash, Array:zombie_miss_wall, Array:zombie_hit_normal, Array:zombie_hit_stab, Находим в public plugin_precache() и удаляем: zombie_infect = ArrayCreate(64, 1) zombie_pain = ArrayCreate(64, 1) zombie_idle = ArrayCreate(64, 1) zombie_idle_last = ArrayCreate(64, 1) zombie_die = ArrayCreate(64, 1) zombie_fall = ArrayCreate(64, 1) zombie_madness = ArrayCreate(64, 1) grenade_fire_player = ArrayCreate(64, 1) zombie_miss_slash = ArrayCreate(64, 1) zombie_miss_wall = ArrayCreate(64, 1) zombie_hit_normal = ArrayCreate(64, 1) zombie_hit_stab = ArrayCreate(64, 1) for (i = 0; i < ArraySize(zombie_infect); i++) { ArrayGetString(zombie_infect, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_pain); i++) { ArrayGetString(zombie_pain, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_idle); i++) { ArrayGetString(zombie_idle, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_idle_last); i++) { ArrayGetString(zombie_idle_last, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_die); i++) { ArrayGetString(zombie_die, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_fall); i++) { ArrayGetString(zombie_fall, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_madness); i++) { ArrayGetString(zombie_madness, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(grenade_fire_player); i++) { ArrayGetString(grenade_fire_player, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_miss_slash); i++) { ArrayGetString(zombie_miss_slash, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_miss_wall); i++) { ArrayGetString(zombie_miss_wall, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_hit_normal); i++) { ArrayGetString(zombie_hit_normal, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } for (i = 0; i < ArraySize(zombie_hit_stab); i++) { ArrayGetString(zombie_hit_stab, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } Находим в case SECTION_SOUNDS: и удаляем: else if (equal(key, "ZOMBIE INFECT")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_infect, key) } } else if (equal(key, "ZOMBIE PAIN")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_pain, key) } } else if (equal(key, "ZOMBIE IDLE")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_idle, key) } } else if (equal(key, "ZOMBIE IDLE LAST")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_idle_last, key) } } else if (equal(key, "ZOMBIE DIE")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_die, key) } } else if (equal(key, "ZOMBIE FALL")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_fall, key) } } else if (equal(key, "ZOMBIE MADNESS")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_madness, key) } } else if (equal(key, "GRENADE FIRE PLAYER")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(grenade_fire_player, key) } } else if (equal(key, "ZOMBIE MISS SLASH")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_miss_slash, key) } } else if (equal(key, "ZOMBIE MISS WALL")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_miss_wall, key) } } else if (equal(key, "ZOMBIE HIT NORMAL")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_hit_normal, key) } } else if (equal(key, "ZOMBIE HIT STAB")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(zombie_hit_stab, key) } } 

 NEMESIS HIT STAB = Ваш путь к звукам/Ваш звук.wav NEMESIS HIT NORMAL = Ваш путь к звукам/Ваш звук.wav NEMESIS MISS WALL = Ваш путь к звукам/Ваш звук.wav NEMESIS MISS SLASH = Ваш путь к звукам/Ваш звук.wav NEMESIS PAIN = Ваш путь к звукам/Ваш звук.wav NEMESIS DIE = Ваш путь к звукам/Ваш звук.wav NEMESIS IDLE = Ваш путь к звукам/Ваш звук.wav 

 ----------------------------------------------------------- Array:nemesis_pain, ----------------------------------------------------------- nemesis_pain = ArrayCreate(64, 1) ----------------------------------------------------------- for (i = 0; i < ArraySize(nemesis_pain); i++) { ArrayGetString(nemesis_pain, i, buffer, charsmax(buffer)) engfunc(EngFunc_PrecacheSound, buffer) } ----------------------------------------------------------- else if (equal(key, "NEMESIS PAIN")) { // Parse sounds while (value[0] != 0 && strtok(value, key, charsmax(key), value, charsmax(value), ',')) { // Trim spaces trim(key) trim(value) // Add to sounds array ArrayPushString(nemesis_pain, key) } } -----------------------------------------------------------