void iniPiiTarget()
{
if (piiTarget == null)
{
piiTarget = GetComponent <PiiTarget>();
}
}
void iniPiiTarget()
{
if (piiTarget == null)
{
piiTarget = gameObject.GetComponent <PiiTarget>();
}
}
// Use this for initialization
void Start()
{
rigidbody = GetComponent <Rigidbody>();
piiTarget = GetComponent <PiiTarget>();
ini_setings();
ini_player();
}
void MoveNoPoint()
{
float DistPlayer = Vector3.Distance(gameObject.transform.position, player.transform.position);
if (rigidbody != null && DistPlayer > 30)
{
//Если скорость довольно маленькая
//уменьшаем радиус
if (rigidbody.velocity.magnitude < 0.02f)
{
radius_face_ray -= Time.deltaTime * speed_face_ray;
}
else
{
radius_face_ray = 2;
}
//Проверка на препятствие впереди
Ray faceNormal = new Ray(transform.position, transform.forward);
RaycastHit faceHit;
bool face_triger = false;
if (Physics.SphereCast(faceNormal, radius_face_ray, out faceHit))
{
faceTarget = faceHit.collider.gameObject.GetComponent <PiiTarget>();
if (faceHit.distance < (5 + rigidbody.velocity.magnitude * 0.7f) && faceTarget != null && faceTarget.heath > 0 && faceTarget.MinPresure >= piiTarget.MinPresure)
{
face_triger = true;
}
}
else
{
faceTarget = null;
}
//скорость
float max_speed = 3;
int revers = 1;
if (face_triger)
{
revers = -1;
}
float Stop = 1;
if (DistPlayer < DistanceNoTraceStop)
{
Stop = DistPlayer / DistanceNoTraceStop;
}
//Прибавляем скорость если она маленькая
if (rigidbody.velocity.magnitude < max_speed)
{
rigidbody.velocity = rigidbody.velocity + gameObject.transform.forward * 50f * Time.deltaTime * revers * Stop;
}
}
}
//Проверка на столкновения
void TestRigidBody()
{
if (true)
{
Collider[] collider = null;
//вытаскиваем колайдеры если их нет
if (collider == null || collider.Length <= 0)
{
//collider = Physics.OverlapCapsule(gameObject.transform.position - gameObject.transform.localScale.y * transform.up/2, gameObject.transform.position + gameObject.transform.localScale.y * transform.up/2, capsuleCollider.radius * 2 * transform.localScale.x);
collider = Physics.OverlapCapsule(gameObject.transform.position - gameObject.transform.localScale.y * transform.up / 2, gameObject.transform.position + gameObject.transform.localScale.y * transform.up / 2, 0.3f * 2 * transform.localScale.x);
}
//Если теперь колайдеры есть то проверяем их
if (collider != null && collider.Length > 0)
{
//Перебираем все колайдеры
for (int numColl = 0; numColl < collider.Length; numColl++)
{
//Пытаемся получить пи таргет из колайдера
PiiTarget colliderPiiTarget = collider[numColl].GetComponent <PiiTarget>();
if (colliderPiiTarget != null)
{
//Проверяем что это не цунами?
TsunamiPartWave tsunamiPartWave = colliderPiiTarget.GetComponent <TsunamiPartWave>();
if (tsunamiPartWave == null)
{
//Это не цунами тогда наносим урон без прибавления очков игроку, если цель еще жива
if (colliderPiiTarget.heath > 0)
{
colliderPiiTarget.heath -= DamageTargets * Time.deltaTime;
if (colliderPiiTarget.heath <= 0)
{
colliderPiiTarget.heath = 0;
colliderPiiTarget.DeathTarget();
}
}
}
//Проверяем обьект на ригид боди
Rigidbody rigidbody = colliderPiiTarget.GetComponent <Rigidbody>();
if (rigidbody != null)
{
//Тестим на мочу
PiiPrefab piiPrefab = colliderPiiTarget.GetComponent <PiiPrefab>();
if (piiPrefab == null)
{
rigidbody.velocity = rigidbody.velocity * Time.deltaTime * 4 + (transform.parent.up * 3 + transform.parent.forward * -1).normalized * SpeedTarget * Time.deltaTime;
rigidbody.freezeRotation = false;
}
}
}
}
}
}
}
void iniPiiTarget()
{
if (piiTarget == null)
{
piiTarget = GetComponent <PiiTarget>();
}
if (piiTarget != null && !ThisTarget)
{
Destroy(piiTarget);
}
}
private void OnTriggerEnter(Collider other)
{
PiiTarget target = other.GetComponent <PiiTarget>();
if (target != null)
{
target.SetTimeToDelete(20);
}
if (target != null && target.heath > 0 && target.MinPresure < Presure)
{
target.TrigerPii(Presure * 1.1f, faceController, piiController, score_Text_3D.gameObject);
player.percent_heath_last_target = target.heath / (target.get_start_heath() / 100);
//Если в это время активны частицы
if (Pii_particle != null && Pii_particle.isPlaying)
{
particle_play_now--;
particle_this_play_yn = false;
Pii_particle.Stop();
}
Destroy(gameObject);
}
//Если до урона не хватает совсем чучуть
else if (!TestToDestroyTarget && target != null && target.heath > 0 && target.MinPresure > Presure && (target.MinPresure - target.MinPresure / 3) < Presure)
{
//Проверка на урон произведена
TestToDestroyTarget = true;
target.TrigerPiiFail(score_Text_3D.gameObject);
}
else if (target == null)
{
if (Pii_particle != null && Pii_particle.isPlaying != true && particle_play_now < 3)
{
ParticleSystem.MainModule mainmod = Pii_particle.main;
mainmod.startSize = Presure * 0.05f;
mainmod.startSpeed = Presure * 0.1f;
ParticleSystem.ShapeModule shapemod = Pii_particle.shape;
shapemod.radius = distance_player * 0.05f;
Pii_particle.Play();
}
}
if (firstTriger)
{
TimeDie = TimeLive + 1.5f;
firstTriger = false;
soundObject.set_new_pii(gameObject.GetComponent <PiiPrefab>());
}
}
private void hit_piitarget(PiiTarget target, float hit)
{
target.TrigerPii(hit, null, null, hit_text);
/*
* if (target.heath > 0) {
* target.heath = target.heath - hit;
* if (target.heath <= 0) {
* target.DeathTarget();
* }
* }
*/
}
private void OnTriggerEnter(Collider other)
{
PiiTarget target = other.GetComponent <PiiTarget>();
PiiTarget piiTarget = gameObject.GetComponentInParent <PiiTarget>();
if (target != null && piiTarget != null && piiTarget != target && target.heath > 0 && target.MinPresure < (piiTarget.MinPresure))
{
//target.TrigerPii(Presure, faceController, piiController, score_Text_3D.gameObject);
target.heath -= piiTarget.MinPresure * 500 * Time.deltaTime;
if (target.heath <= 0)
{
target.DeathTarget();
}
}
}
void MovePoint()
{
//Узнаем скорость
if (rigidbody != null && target_track_point != null)
{
//Если скорость довольно маленькая
//уменьшаем радиус
if (rigidbody.velocity.magnitude < 0.02f)
{
radius_face_ray -= Time.deltaTime * speed_face_ray;
}
else
{
radius_face_ray = 2;
}
//Проверка на препятствие впереди
Ray face = new Ray(transform.position, transform.forward);
RaycastHit faceHit;
bool face_triger = false;
if (Physics.SphereCast(face, radius_face_ray, out faceHit))
{
faceTarget = faceHit.collider.gameObject.GetComponent <PiiTarget>();
if (faceHit.distance < (3 + rigidbody.velocity.magnitude * 0.7f) && faceTarget != null && faceTarget.heath > 0)
{
face_triger = true;
}
}
else
{
faceTarget = null;
}
//скорость
float max_speed = target_track_point.max_speed / 3;
int revers = 1;
//Прибавляем скорость если она маленькая
if (rigidbody.velocity.magnitude < max_speed && !face_triger)
{
rigidbody.velocity = rigidbody.velocity + gameObject.transform.forward * 50f * Time.deltaTime * revers;
}
}
}
void TestSiren_visual()
{
//Проверка жизни и выключение если умерла
PiiTarget piiTarget = gameObject.GetComponent <PiiTarget>();
if (piiTarget != null && piiTarget.heath <= 0)
{
police_active_now = false;
}
//Если нужно выключить
if (!police_active_now && police_active_old)
{
police_active_old = false;
if (siren_blue != null)
{
siren_blue.Stop();
}
if (siren_red != null)
{
siren_red.Stop();
}
}
//Если первый запуск
if (police_active_now && !police_active_old)
{
police_active_old = true;
//Запускаем первый фонарь сирены
if (siren_blue != null)
{
siren_blue.Play();
}
//Ставим таймер запуска второй сирены
pause_next_siren_play = 0.5f;
}
//Уменьшаем врямя и запускаем другую сирену если время вышло
pause_next_siren_play -= Time.deltaTime;
if (police_active_now && pause_next_siren_play <= 0 && siren_red != null && !siren_red.isPlaying)
{
siren_red.Play();
}
}
// Use this for initialization
void Start()
{
iniGameParam();
iniSeting();
rigidbody = GetComponent <Rigidbody>();
if (TrackTo != null)
{
gameObject.transform.LookAt(TrackTo.transform);
}
piiTarget = gameObject.GetComponent <PiiTarget>();
//Останавливаем фары
if (left_face != null)
{
left_face.Stop();
}
if (right_face != null)
{
right_face.Stop();
}
if (left_botm != null)
{
left_botm.Stop();
}
if (right_botm != null)
{
right_botm.Stop();
}
speed_face_ray = Random.Range(0.8f, 1.5f);
police = gameObject.GetComponent <police_car>();
//Агрессия автомобиля
Agress = Random.Range(20f, 80f);
//Создаем источник звука под клаксон
Create_BeepAudioSource();
}
// Use this for initialization
void Start()
{
source = gameObject.GetComponent <AudioSource>();
target = gameObject.GetComponent <PiiTarget>();
get_seting_game();
}
public void BOOM()
{
if (Boom.Length != 0 && Random.Range(0, 100) < Veroatnost_boom)
{
//Звук
if (audioSource != null)
{
audioSource.Stop();
audioSource.maxDistance = 2000;
audioSource.volume = 1 * seting.game.volume_all * seting.game.volume_sound;
audioSource.PlayOneShot(Boom[Random.Range(0, Boom.Length)]);
}
//Активируем партикл взрыва
if (Explore != null)
{
ParticleSystem exp = Instantiate(Explore, gameObject.transform);
exp.Play();
}
//Активируем дым
if (Smoke != null)
{
ParticleSystem smo = Instantiate(Smoke, gameObject.transform);
smo.Play();
}
size_boom_now = 0;
boom_yn = true;
for (int num = 0; num < Targets.Length; num++)
{
Targets[num] = null;
}
}
//Замена обьекта на разрушенную модель
if (DestroyPrefabObj != null)
{
//Ищем оригинальный меш в самом обьекте
MeshRenderer meshRenderer = gameObject.GetComponent <MeshRenderer>();
//Если присутствует отключаем
if (meshRenderer != null)
{
meshRenderer.enabled = false;
//колайдер
BoxCollider boxCollider = gameObject.GetComponent <BoxCollider>();
if (boxCollider != null)
{
boxCollider.enabled = false;
}
}
//создаем разрушенное
GameObject destroyObj = Instantiate(DestroyPrefabObj, gameObject.transform);
//Перемещаем
destroyObj.transform.position = gameObject.transform.position;
destroyObj.transform.localScale = new Vector3(1, 1, 1);
destroyObj.transform.rotation = new Quaternion();
}
GameObject player_obj = GameObject.FindGameObjectWithTag("Player");
float player_dist = Vector3.Distance(player_obj.transform.position, gameObject.transform.position);
//Открепляем отдельные детали обьекта
if (OblomkiChastObj != null && OblomkiChastObj.Length > 0 && player_dist < min_dist_oblomki_create)
{
//перебираем части
for (int num_oblomok = 0; num_oblomok < OblomkiChastObj.Length; num_oblomok++)
{
//Если часть существует
if (OblomkiChastObj[num_oblomok] != null && Random.Range(0, 100) < 50)
{
//Открепляем ее от объекта меняя родителя
Transform transform_parent = gameObject.GetComponentInParent <Transform>();
if (transform_parent != null)
{
//Поменяли родителя
OblomkiChastObj[num_oblomok].transform.parent = transform_parent.parent;
//Вытаскиваем ригидбоди
Rigidbody oblomok_rigidbody = OblomkiChastObj[num_oblomok].GetComponent <Rigidbody>();
//если ригид боди нету создаем
if (oblomok_rigidbody == null)
{
oblomok_rigidbody = OblomkiChastObj[num_oblomok].AddComponent <Rigidbody>();
}
//если у этого обьекта есть масса то обломок делаем частичной массы главного обьекта
Rigidbody gameobj_rigidbody = gameObject.GetComponent <Rigidbody>();
if (gameobj_rigidbody != null)
{
oblomok_rigidbody.mass = gameobj_rigidbody.mass / OblomkiChastObj.Length / 0.10f;
}
else
{
oblomok_rigidbody.mass = 1;
}
//придаем импульс
//////////////////
/*
* //считаем направление
* Vector3 vectorImpulse = Vector3.Normalize(OblomkiChastObj[num_oblomok].transform.position - gameObject.transform.position);
* //Чем массивнее тем слабее отталкивание
* float mass_koof = 0;
* if (oblomok_rigidbody.mass != 0)
* mass_koof = 1 / oblomok_rigidbody.mass;
* float dist_koof = 0;
* float distance = Vector3.Distance(gameObject.transform.position, OblomkiChastObj[num_oblomok].transform.position);
* if (distance > 0)
* dist_koof = 1 / distance;
* //Расчет силы оталкивания
* float inercia_strong = Damage * dist_koof * mass_koof * 0.02f;
* //Если сила отталкивания не слабая
* if (inercia_strong > 0.2f)
* oblomok_rigidbody.velocity += inercia_strong * vectorImpulse;
*/
//Тест бокс колайдела
BoxCollider oblomok_boxCollider = OblomkiChastObj[num_oblomok].GetComponent <BoxCollider>();
if (oblomok_boxCollider == null)
{
OblomkiChastObj[num_oblomok].AddComponent <BoxCollider>();
}
//Тест пии таргета
PiiTarget oblomok_piiTarget = OblomkiChastObj[num_oblomok].GetComponent <PiiTarget>();
if (oblomok_piiTarget == null)
{
oblomok_piiTarget = OblomkiChastObj[num_oblomok].AddComponent <PiiTarget>();
}
oblomok_piiTarget.heath = 1;
oblomok_piiTarget.MinPresure = 1000;
/*
* destroy_timer destroy_Timer = OblomkiChastObj[num_oblomok].GetComponent<destroy_timer>();
* if (destroy_Timer == null) {
* destroy_Timer = OblomkiChastObj[num_oblomok].AddComponent<destroy_timer>();
* }
* destroy_Timer.timer_starting = true;
*/
}
}
}
}
//СОздаем префабы обломков
if (OblomkiPrefabObj != null && OblomkiPrefabObj.Length > 0 && player_dist < min_dist_oblomki_create)
{
//перебираем части
for (int num_oblomok = 0; num_oblomok < OblomkiPrefabObj.Length; num_oblomok++)
{
//Если часть существует
if (OblomkiPrefabObj[num_oblomok] != null && Random.Range(0, 100) < 90)
{
//Узнаем родителя
Transform transform_parent = gameObject.GetComponentInParent <Transform>();
//Создаем обьект
GameObject OblomokObj = Instantiate(OblomkiPrefabObj[num_oblomok], transform_parent.parent);
//Меняем позицию обломка
OblomokObj.transform.position = gameObject.transform.position + new Vector3(Random.Range(0, 1), Random.Range(0, 1) + 0.25f, Random.Range(0, 1));
/////////////////////////////////////////////////////////////
//Вытаскиваем ригидбоди
Rigidbody oblomok_rigidbody = OblomokObj.GetComponent <Rigidbody>();
//если ригид боди нету создаем
if (oblomok_rigidbody == null)
{
oblomok_rigidbody = OblomokObj.AddComponent <Rigidbody>();
}
//если у этого обьекта есть масса то обломок делаем частичной массы главного обьекта
Rigidbody gameobj_rigidbody = gameObject.GetComponent <Rigidbody>();
if (gameobj_rigidbody != null)
{
oblomok_rigidbody.mass = gameobj_rigidbody.mass / OblomkiPrefabObj.Length / 0.10f;
}
else
{
oblomok_rigidbody.mass = 1;
}
//придаем импульс
//////////////////
/*
* //считаем направление
* Vector3 vectorImpulse = Vector3.Normalize(OblomokObj.transform.position - gameObject.transform.position);
* //Чем массивнее тем слабее отталкивание
* float mass_koof = 0;
* if (oblomok_rigidbody.mass != 0)
* mass_koof = 1 / oblomok_rigidbody.mass;
* float dist_koof = 0;
* float distance = Vector3.Distance(gameObject.transform.position, OblomokObj.transform.position);
* if (distance > 0)
* dist_koof = 1 / distance;
* //Расчет силы оталкивания
* float inercia_strong = Damage * dist_koof * mass_koof * 0.02f;
* //Если сила отталкивания не слабая
* if (inercia_strong > 0.2f)
* oblomok_rigidbody.velocity += inercia_strong * vectorImpulse;
*/
//Тест бокс колайдела
BoxCollider oblomok_boxCollider = OblomokObj.GetComponent <BoxCollider>();
if (oblomok_boxCollider == null)
{
OblomkiPrefabObj[num_oblomok].AddComponent <BoxCollider>();
}
//Тест пии таргета
PiiTarget oblomok_piiTarget = OblomokObj.GetComponent <PiiTarget>();
if (oblomok_piiTarget == null)
{
oblomok_piiTarget = OblomokObj.AddComponent <PiiTarget>();
}
oblomok_piiTarget.heath = 1;
oblomok_piiTarget.MinPresure = 1000;
/*
* destroy_timer destroy_Timer = OblomokObj.GetComponent<destroy_timer>();
* if (destroy_Timer == null)
* {
* destroy_Timer = OblomokObj.AddComponent<destroy_timer>();
* }
* destroy_Timer.time_to_destroy = 30f; //(min_dist_oblomki_create - player_dist) * 2;
* destroy_Timer.timer_starting = true;
*/
}
}
}
}
public void explosion_test2()
{
//Если взрыв происходит сейчас
if (boom_yn)
{
//Debug.Log("Boom");
//Если сейчас первый кадр взрыва
if (size_boom_now == 0)
{
//Получаем ригид боди взрывателя если он есть
Rigidbody rigidbody_main = gameObject.GetComponent <Rigidbody>();
if (rigidbody_main != null)
{
float mass_koof = 1 / rigidbody_main.mass;
rigidbody_main.velocity += new Vector3(0, Damage * 0.05f * mass_koof, 0);
}
//Получаем все обьекты как если бы взрыв уже произошел
Collider[] hitTargets = Physics.OverlapSphere(gameObject.transform.position, size_boom_max);
//Получаем из них все обьекты типа цель
for (int num_colider = 0; num_colider < hitTargets.Length; num_colider++)
{
PiiTarget target = hitTargets[num_colider].GetComponent <PiiTarget>();
//Если обьект типа цель
if (target != null && target.gameObject != gameObject && target_max < Targets.Length)
{
//save
Targets[target_max] = target;
target_max++;
}
}
//Все обьекты сохранены теперь нужно их отсортировать в сторону увеличения дальности
for (int num_cycle = 0; num_cycle < Targets.Length; num_cycle++)
{
for (int num_target = 0; num_target + 1 < Targets.Length && Targets[num_target + 1] != null; num_target++)
{
float now = Vector3.Distance(gameObject.transform.position, Targets[num_target].transform.position);
float next = Vector3.Distance(gameObject.transform.position, Targets[num_target + 1].transform.position);
//Если настояшая цель больше предыдущей
if (now > next)
{
//Меняем их местами
PiiTarget now_targ = Targets[num_target];
Targets[num_target] = Targets[num_target + 1];
Targets[num_target + 1] = now_targ;
}
}
}
//Если игроку важно получить урон
if (PlayerDamage)
{
//Вытаскиваем игрока
Player player = GameObject.FindGameObjectWithTag("Player").GetComponent <Player>();
float distPlayer = Vector3.Distance(player.transform.position, gameObject.transform.position);
if (distPlayer < size_boom_max)
{
float percent = distPlayer / size_boom_max;
float hit = Damage * (1 - percent);
if (player.ScoreTime > 0)
{
//Нужно ли выводить эмоцию урона
if (hit > 100)
{
player.faceController.set_butthurt_voice();
}
player.ScoreTime -= hit;
if (player.ScoreTime < 0)
{
player.ScoreTime = 0;
}
//Игрок получил урон теперь надо высветить окно урона
//расчет для отображения урона в индикаторе игрока
//Текущий поворот камеры игрока
Quaternion now_rotate_cam = player.camera.transform.rotation;
//Требуемый поворот камеры игрока для того чтобы смотреть прямо в центр
Quaternion need_rotate_cam = Quaternion.FromToRotation(player.camera.transform.position, gameObject.transform.position);
//Разница по горизонтали
float need_rot_y = need_rotate_cam.ToEulerAngles().y - now_rotate_cam.ToEulerAngles().y;
//разница по вертикали
float need_rot_x = need_rotate_cam.ToEulerAngles().x - now_rotate_cam.ToEulerAngles().x;
//Запихать в урон
if (need_rot_x < 0)
{
player.damageWindow.set_all_need(0, 0, need_rot_x * -1f, 0);
}
else
{
player.damageWindow.set_all_need(0, 0, 0, need_rot_x * 1f);
}
if (need_rot_y < 0)
{
player.damageWindow.set_all_need(need_rot_y * -1f, 0, 0, 0);
}
else
{
player.damageWindow.set_all_need(0, need_rot_y * 1f, 0, 0);
}
}
PlayerDamage = false;
}
}
}
size_boom_now = size_boom_now + Time.deltaTime * speed_boom;
//Проверяем цель на взрыв если они есть
if (target_now < target_max && size_boom_max != 0)
{
//Цикл пока не будет последняя цель в радиусе поражения
bool end_yn = false;
for (; end_yn == false;)
{
//Проверяем растояние до настоящей цели которая сейчас выделена
float size_for_target = 99999999;
//Если обьекты есть
if (target_now < Targets.Length)
{
if (gameObject != null && Targets[target_now] != null)
{
size_for_target = Vector3.Distance(gameObject.transform.position, Targets[target_now].gameObject.transform.position);
}
//Если взрыв прошел эту цель то взрываем и переключаемся на следуюшую
if (size_boom_now > size_for_target)
{
//Считаем какой урон нужно нанести
//процент расширенности
float percent = size_boom_now / size_boom_max;
float hit = Damage * (1 - percent);
float rand = Random.Range(0.2f, 2f);
//меняем цель
target_now++;
Targets[target_now - 1].TrigerPii(hit, null, null, hit_text);
//отталкиваем цель если можем
Rigidbody rigidbody = null;
if (Targets[target_now - 1] != null)
{
rigidbody = Targets[target_now - 1].GetComponent <Rigidbody>();
}
if (rigidbody != null)
{
//Чем массивнее тем слабее отталкивание
float mass_koof = 0;
if (rigidbody.mass != 0)
{
mass_koof = 1 / rigidbody.mass;
}
float dist_koof = 0;
if (size_for_target != 0)
{
dist_koof = 1 / size_for_target;
}
//считаем вектор отталкивания
Vector3 vector_damage = new Vector3(
Targets[target_now - 1].transform.position.x - gameObject.transform.position.x,
Targets[target_now - 1].transform.position.y - gameObject.transform.position.y,
Targets[target_now - 1].transform.position.z - gameObject.transform.position.z);
vector_damage = Vector3.Normalize(vector_damage);
//Расчет силы оталкивания
float inercia_strong = Damage * dist_koof * mass_koof;
//Если сила отталкивания не слабая
if (inercia_strong > 0.2f)
{
rigidbody.velocity += vector_damage * inercia_strong;
}
}
//меняем цель
//target_now++;
//Наносим урон
//hit_piitarget(Targets[target_now-1], hit * rand);
}
//Иначе завершаем цикл в этом кадре
else
{
end_yn = true;
}
}
else
{
end_yn = true;
}
}
}
//Если цели закончелись взрыв завершен
else
{
boom_yn = false;
}
}
}
public void explosion_test()
{
if (boom_yn)
{
//Если радиус еще маленький
if (size_boom_now < size_boom_max)
{
//Пытаемся взормать обьекты
//Вытаскиваем обьекты которые внутри
Collider[] hitTargets = Physics.OverlapSphere(gameObject.transform.position, size_boom_now);
//вытаскиваем цели
for (int num_hit = 0; num_hit < hitTargets.Length; num_hit++)
{
PiiTarget piinow = hitTargets[num_hit].gameObject.GetComponent <PiiTarget>();
if (piinow != null)
{
//Проверяем есть ли эта цель в списке?
bool found_yn = false;
for (int num_target = 0; num_target < Targets.Length; num_target++)
{
//Если обьект нашелся в списке
//или если эта цель сам этот обьект
if (Targets[num_target] == piinow || gameObject == piinow.gameObject)
{
found_yn = true;
num_target = Targets.Length;
}
//Если список закончелся
else if (Targets[num_target] == null)
{
num_target = Targets.Length;
}
}
//Если не нашлось
if (!found_yn)
{
//Добавляем в свободное
for (int num_target = 0; num_target < Targets.Length; num_target++)
{
if (Targets[num_target] == null)
{
//Считаем какой урон нужно нанести
//процент расширенности
float percent = size_boom_now / size_boom_max;
float hit = Damage * (1 - percent);
Targets[num_target] = piinow;
float rand = Random.Range(0.2f, 2f);
//Наносим урон
hit_piitarget(piinow, hit * rand);
num_target = 1000;
}
}
}
}
}
//Проверяем какие из этих целей нету еще в списке и наносим им урон
}
//Иначе радиус стал слишком большим отключаем взрыв
else
{
boom_yn = false;
}
//Разширяем радиус
size_boom_now = size_boom_now + Time.deltaTime * speed_boom;
}
}
// Use this for initialization
void Start()
{
//Вытаскиваем дым
smoke = GetComponentInChildren <ParticleSystem>();
target = GetComponent <PiiTarget>();
}
// Use this for initialization
void Start()
{
target = gameObject.GetComponent <PiiTarget>();
}
void RotateNoPoint()
{
//Создаем 3 луча
Ray faceLeft = new Ray(transform.position, rayLeft.transform.forward);
Ray faceRight = new Ray(transform.position, rayRight.transform.forward);
//Проверяем каждый луч сперва на разрушаемость обьекта и если нет то вытаскиваем дальность
float faceDistLeft = 999;
float faceDistRigh = 999;
float distRot = 4;
RaycastHit faceHit;
//тест дальности боковых лучей
//Левый
if (Physics.SphereCast(faceLeft, 4, out faceHit))
{
faceDistLeft = faceHit.distance;
faceTargetLeft = faceHit.collider.gameObject.GetComponent <PiiTarget>();
//Если прочность больше прочности танка
if (faceTargetLeft != null && faceTargetLeft.MinPresure < piiTarget.MinPresure)
{
faceDistLeft = distRot * 2;
}
}
else
{
faceTargetLeft = null;
}
//правий
if (Physics.SphereCast(faceRight, 4, out faceHit))
{
faceDistRigh = faceHit.distance;
faceTargetRight = faceHit.collider.gameObject.GetComponent <PiiTarget>();
//Если прочность больше прочности танка
if (faceTargetRight != null && faceTargetRight.MinPresure < piiTarget.MinPresure)
{
faceDistRigh = distRot * 2;
}
}
else
{
faceTargetRight = null;
}
TimeDistLeft = TimeDistLeft * 0.7f + faceDistLeft * 0.3f;
TimeDistRigh = TimeDistRigh * 0.7f + faceDistRigh * 0.3f;
//Дальность получена, теперь вращаем
//Если хотябы один из лучей меньше 10 то отворачиваемся от него
Debug.Log("Left " + TimeDistLeft + " | Right " + TimeDistRigh);
if (TimeDistLeft < distRot || TimeDistRigh < distRot)
{
//Отворот лева
if ((TimeDistLeft < distRot && TimeDistLeft < TimeDistRigh))
{
gameObject.transform.Rotate(0, 20 * Time.deltaTime, 0);
}
//отворот права
else if ((TimeDistRigh < distRot && TimeDistRigh < TimeDistLeft))
{
gameObject.transform.Rotate(0, -20 * Time.deltaTime, 0);
}
}
//Если препятствий нет то поворачиваемся к игроку под углом
else
{
if (rigidbody != null && player != null)
{
//Нужно ли отклонение в градусах
float distPlayer = Vector3.Distance(gameObject.transform.position, player.transform.position);
float otclonenie = OtclonenieGradus;
if (distPlayer < 200)
{
otclonenie *= distPlayer / 100;
}
Quaternion rotate_to = Quaternion.LookRotation(player.transform.position - transform.position);
rotate_to.eulerAngles = new Vector3(rotate_to.eulerAngles.x, rotate_to.eulerAngles.y + otclonenie, rotate_to.eulerAngles.z);
//rotate_to.SetEulerRotation(0, OtclonenieGradus, 0);
float old_y = transform.rotation.y;
transform.rotation = Quaternion.Lerp(transform.rotation, rotate_to, 0.5f * Time.deltaTime);
rotateNow = old_y - transform.rotation.y;
}
}
}
void TestSiren_sound()
{
if (player != null && SirenSource != null)
{
float playerDist = Vector3.Distance(gameObject.transform.position, player.transform.position);
float MaxSirenDist = 1500;
if (playerDist > MaxSirenDist)
{
playerDist = MaxSirenDist;
}
int cootnoshenie = (int)((playerDist / MaxSirenDist) * 200);
SirenSource.priority = 50 + cootnoshenie;
}
//Если сирена включена но звука нет запускаем
//Проверка жизни и выключение если умерла
PiiTarget piiTarget = gameObject.GetComponent <PiiTarget>();
pause_play_siren -= Time.deltaTime;
if (pause_play_siren < 0)
{
pause_play_siren = 0;
}
if (need_sound_yn && police_active_now && piiTarget.heath > 0 && pause_play_siren <= 0)
{
if (seting != null)
{
SirenSource.volume = 0.5f * seting.game.volume_all * seting.game.volume_sound;
}
//Если нужно длинную
if (!siren_short_need_play && (SirenSource.clip != Siren_long || SirenSource.clip == null || !SirenSource.isPlaying))
{
//Уменьшаем таймер задержки запуска
pause_long_siren -= Time.deltaTime;
if (pause_long_siren < 0)
{
SirenSource.clip = Siren_long;
SirenSource.loop = true;
SirenSource.Play();
}
}
else if (siren_short_need_play && (SirenSource.clip != Siren_short || SirenSource.clip == null || !SirenSource.isPlaying))
{
SirenSource.clip = Siren_short;
SirenSource.loop = true;
SirenSource.Play();
pause_long_siren = 1f;
}
}
GameplayParametrs gameplayParametrs = GameObject.FindGameObjectWithTag("setings_game").GetComponent <GameplayParametrs>();
if (gameplayParametrs != null)
{
if (gameplayParametrs.GameOver)
{
gameoverTime += Time.deltaTime;
}
if (gameplayParametrs.pause || gameoverTime > gameoverTimeStop)
{
SirenSource.Pause();
}
else
{
SirenSource.UnPause();
}
}
//Выключить при смерти или если звук не нужен
if ((piiTarget != null && piiTarget.heath <= 0 && SirenSource.isPlaying) || !need_sound_yn || pause_play_siren > 0)
{
SirenSource.Stop();
}
}
