using UnityEngine;

public class Saw : GlobalFunctions
{
    public AudioClip setClip;
    private TypePlaying typePlaying = TypePlaying.Sound;
    private AudioBase audioBase;
    private float speed = 4f;
    private Transform tr;

    private void Awake()
    {
        audioBase = GameObject.FindWithTag("MainCamera").GetComponent<AudioBase>();
        tr = transform;
    }

    private void Update()
    {
        float s = Time.fixedDeltaTime / 0.03f * (Time.deltaTime / 0.03f);
        tr.localEulerAngles = new Vector3(0f, 0f, tr.localEulerAngles.z - speed * s);
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.collider.tag == "Player")
        {
            audioBase.SetSound(setClip, 1, 0.2f, typePlaying, false);
        }
    }

    public float GetSpeed()
    {
        return speed;
    }
}

using UnityEngine;

public class Laser : MonoBehaviour
{
    public Vector2 vector2;
    public bool active = true;
    public GameObject laserActive;
    public LineRenderer lr1;
    public Transform tr;
    public BoxCollider2D bcl;
    public Damage dmg;

    private void Start()
    {
        lr1.startColor = lr1.endColor = LaserColor();
    }

    public Color LaserColor()
    {
        Color c = new Color(0f, 0f, 0f, 1f);
        switch (dmg.GetTypeLaser().Type2int())
        {
            case 1:
                c = new Color(1f, 0f, 0f, 1f);
                break;
            case 2:
                c = new Color(0f, 1f, 0f, 1f);
                break;
            case 3:
                c = new Color(0f, 0f, 0f, 0.4901961f);
                break;
            case 4:
                c = new Color(1f, 0.8823529f, 0f, 1f);
                break;
            case 5:
                c = new Color(0.6078432f, 0.8823529f, 0f, 1f);
                break;
            case 6:
                c = new Color(1f, 0.2745098f, 0f, 1f);
                break;
        }
        return c;
    }

    private void Update()
    {
        LaserUpdate();
    }

    private void LaserUpdate()
    {
        if (active == true)
        {
            Vector2[] act1 = Points(tr.position, -tr.up);
            lr1.SetPosition(0, act1[0]);
            lr1.SetPosition(1, act1[1]);
            bcl.size = new Vector2(0.1f, 0.1f);
            bcl.offset = act1[2];
        }
        return;
    }

    private Vector2[] Points(Vector2 start, Vector2 end)
    {
        Vector2[] ret = new Vector2[3];
        RaycastHit2D hit = Physics2D.Raycast(tr.position, -tr.up, 200f);
        ret[0] = tr.position;
        ret[1] = hit.point;
        vector2 = ret[1];
        float distance = Vector2.Distance(tr.position, hit.point);
        bcl.size = new Vector2(0.1f, 0.1f);
        if (hit.collider == bcl)
        {
            ret[2] = new Vector2(0f, 0.5f);
        }
        else
        {
            ret[2] = new Vector2(0f, -distance - 0.2f);
        }
        return ret;
    }
}

using System.Collections;
using UnityEngine;

public class Explosion : GlobalFunctions
{
    public float power = 1f;
    public float radius = 5f;
    public float health = 20f;
    public float timeOffsetExplosion = 1f;
    public GameObject[] contacts = new GameObject[0];
    public Animator expAnim;
    public bool writeContacs = true;
    public AudioClip setClip;

    private float timeOffsetExplosionCount;
    private float alphaTimer;
    private bool isTimerOn = false;
    private bool firstAPEvirtual = true;
    private Collider2D cl;
    private Rigidbody2D rb;
    private SpriteRenderer sr;
    private AudioBase audioBase;
    private Explosion explosion;

    private void Awake()
    {
        audioBase = GameObject.FindWithTag("MainCamera").GetComponent<AudioBase>();
        cl = GetComponent<Collider2D>();
        rb = GetComponent<Rigidbody2D>();
        sr = GetComponent<SpriteRenderer>();
        explosion = GetComponent<Explosion>();
    }

    private void Start()
    {
        alphaTimer = sr.color.a;
        StartCoroutineTimerOffsetExplosion();
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        if (writeContacs == true)
        {
            int cont = contacts.Length;
            GameObject[] n = new GameObject[cont + 1];

            if (cont != 0)
            {
                for (int i = 0; i < cont; i++)
                {
                    n[i] = contacts[i];
                }
            }

            n[cont] = collision.gameObject;
            contacts = n;
        }
    }

    private void OnCollisionExit2D(Collision2D collision)
    {
        if (writeContacs == true)
        {
            int cont = contacts.Length;
            if (cont != 1)
            {
                int counter = 0;
                GameObject[] n = new GameObject[cont - 1];

                for (int i = 0; i < cont; i++)
                {
                    if (contacts[i] != collision.gameObject)
                    {
                        n[counter] = contacts[i];
                        counter++;
                    }
                }

                contacts = n;
            }
            else
            {
                contacts = new GameObject[0];
            }
        }
    }

    public void ActionExplosionEmulation(GameObject obj)
    {
        float damage = 0f;
        if (obj.CompareTag("Laser"))
        {
            damage = obj.GetComponent<Damage>().senDamage;
        }
        else
        {
            damage = obj.GetComponent<Power>().power;
        }

        health = health - damage;
        StartCoroutineTimerOffsetExplosion();
        return;
    }

    public void StartCoroutineTimerOffsetExplosion()
    {
        if (health <= 0f && isTimerOn == false)
        {
            isTimerOn = true;
            timeOffsetExplosionCount = timeOffsetExplosion;
            StartCoroutine(TimerOffsetExplosion(0.1f));
        }
    }

    private IEnumerator TimerOffsetExplosion(float timeTick)
    {
        yield return new WaitForSeconds(timeTick);
        timeOffsetExplosionCount = timeOffsetExplosionCount - timeTick;
        if (timeOffsetExplosionCount > 0f)
        {
            float c = timeOffsetExplosionCount / timeOffsetExplosion;
            sr.color = new Color(1f, c, c, alphaTimer);
            StartCoroutine(TimerOffsetExplosion(timeTick));
        }
        else
        {
            ExplosionAction();
        }
    }

    private void ExplosionAction()
    {
        rb.gravityScale = 0f;
        rb.velocity = Vector2.zero;
        audioBase.SetSound(setClip, 2, 1f, TypePlaying.Sound, false);
        Destroy(cl);
        CircleCollider2D c = gameObject.AddComponent<CircleCollider2D>();
        c.isTrigger = true;
        c.radius = radius;
        tag = "Explosion";
        if (PlayerPrefs.GetString("graphicsquality") != "high")
        {
            Destroy(sr);
            StartCoroutine(Off());
        }
        else
        {
            expAnim.enabled = true;
            StartCoroutine(Off2High());
        }
    }

    public IEnumerator Off()
    {
        yield return new WaitForSecondsRealtime(0.1f);
        gameObject.SetActive(false);
    }

    public IEnumerator OffHigh(CircleCollider2D c)
    {
        yield return new WaitForSecondsRealtime(0.1f);
        c.enabled = false;
    }

    public IEnumerator Off2High()
    {
        yield return new WaitForSecondsRealtime(1.5f);
        gameObject.SetActive(false);
    }

    public void APEvirtual()
    {
        int cont = contacts.Length;
        if (cont != 0 && firstAPEvirtual == true)
        {
            firstAPEvirtual = false;
            for (int i = 0; i < cont; i++)
            {
                if (contacts[i] != null)
                {
                    if (contacts[i].GetComponent<PhysicsEmulation>())
                    {
                        contacts[i].GetComponent<PhysicsEmulation>().ExplosionPhysicsEmulation(explosion);
                    }
                }
            }
        }
    }

    public void AnimFull()
    {
        sr.color = new Color(1f, 1f, 1f, 1f);
        sr.size = new Vector2(3f * radius, 3f * radius);
        return;
    }
}

using UnityEngine;

public class VelocityField : GlobalFunctions
{
    public float percent = 10f;
    public float damage = 0.01f;
    public float heal = 0.01f;
    public GameObject[] contacts = new GameObject[0];
    private HealthBar hb;

    private void Awake()
    {
        hb = GameObject.FindWithTag("MainCamera").GetComponent<Management>().healthBar;
    }

    private void FixedUpdate()
    {
        if (contacts.Length != 0)
        {
            for (int i = 0; i < contacts.Length; i++)
            {
                if (contacts[i] != null)
                {
                    if (contacts[i].GetComponent<Rigidbody2D>())
                    {
                        float s = Time.fixedDeltaTime / 0.03f;
                        Vector2 vel = contacts[i].GetComponent<Rigidbody2D>().velocity;
                        contacts[i].GetComponent<Rigidbody2D>().velocity = vel / 100f * (100f - percent * s);
                    }
                }
                else
                {
                    contacts = Remove(contacts, i);
                }
            }
        }
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.GetComponent<Rigidbody2D>())
        {
            Rigidbody2D rb2 = collision.GetComponent<Rigidbody2D>();
            if (rb2.isKinematic == false)
            {
                VelocityInput vi = collision.GetComponent<VelocityInput>();

                vi.fields = Add(vi.fields, gameObject);

                rb2.gravityScale = 0f;
                rb2.freezeRotation = true;
                vi.inVelocityField = true;
                if (collision.GetComponent<Destroy>())
                {
                    collision.GetComponent<Destroy>().ActiveTimerDeleteChange(300f);
                }
                if (collision.tag == "Player")
                {
                    hb.StartVFRad(damage);
                }

                contacts = Add(contacts, collision.gameObject);
            }
        }
    }

    public void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.GetComponent<Rigidbody2D>())
        {
            Rigidbody2D rb2 = collision.GetComponent<Rigidbody2D>();
            if (rb2.isKinematic == false)
            {
                VelocityInput vi = collision.GetComponent<VelocityInput>();

                vi.fields = Remove(vi.fields, gameObject);

                if (vi.fields.Length != 0)
                {
                    rb2.gravityScale = 0f;
                    rb2.freezeRotation = true;
                    vi.inVelocityField = true;
                }
                else
                {
                    rb2.gravityScale = 1f;
                    rb2.freezeRotation = false;
                    vi.inVelocityField = false;
                }
                if (collision.GetComponent<Destroy>())
                {
                    collision.GetComponent<Destroy>().ActiveTimerDeleteChange(60f);
                }
                if (collision.tag == "Player")
                {
                    hb.EndVFRad(heal);
                }

                contacts = Remove(contacts, collision.gameObject);
            }
        }
    }
}

using UnityEngine;

public class TrampAnim : MonoBehaviour
{
    public float speed = 0.1f;
    public float speedOffset = 0.01f;
    public float damage = 1f;
    private float sc;
    private float maxDis;
    public Vector3 start;
    public Vector3 end;
    public TrampAnim ender;
    public bool active = true;
    public bool trigPlayer = false;
    private AudioSet audioSet;
    private bool audioAct;
    private Transform tr;
    private HealthBar hb;
    public int count = 0;

    public void Start()
    {
        if (active)
        {
            tr = transform;
            maxDis = Vector2.Distance(start, end);
            sc = Vector2.Distance(tr.localPosition, start) / maxDis;
            hb = Camera.main.GetComponent<Management>().healthBar;

            audioAct = GetComponent<AudioSet>();
            if (audioAct) { audioSet = GetComponent<AudioSet>(); }
        }
    }

    public void Update()
    {
        if (active)
        {
            float s = Time.fixedDeltaTime / 0.03f * (Time.deltaTime / 0.03f);
            if (count == 0)
            {
                tr.localPosition = Vector2.MoveTowards(tr.localPosition, end, (speed * sc + speedOffset) * s);
                if (tr.localPosition == end)
                {
                    count = 1;
                    if (trigPlayer && ender.trigPlayer)
                    {
                        hb.Damage(100f, tag, Vector2.zero);
                    }
                    if (audioAct) { audioSet.SetMusic(); }
                }
            }
            else
            {
                tr.localPosition = Vector2.MoveTowards(tr.localPosition, start, (speed * sc + speedOffset) * s);
                if (tr.localPosition == start)
                {
                    count = 0;
                }
            }
            sc = Vector2.Distance(tr.localPosition, start) / maxDis;
        }
    }

    public void OnCollisionEnter2D(Collision2D collision)
    {
        Transform trans = collision.transform;
        string tag = trans.tag;
        if (tag == "Player")
        {
            trigPlayer = true;
        }
        else if (active == false)
        {
            if (trans.GetComponent<PhysicsEmulation>())
            {
                trans.GetComponent<PhysicsEmulation>().TrampAnimPhysicsEmulation(GetComponent<TrampAnim>());
            }
        }
    }

    public void OnCollisionExit2D(Collision2D collision)
    {
        string tag = collision.transform.tag;
        if (tag == "Player")
        {
            trigPlayer = false;
        }
    }
}

using System.Collections;
using UnityEngine;

public class Radiation : MonoBehaviour
{
    public bool isActiveRadiation = false;
    private Management m;
    private HealthBar hb;

    private void Awake()
    {
        gameObject.SetActive(PlayerPrefs.GetString("ai") == "off");
        m = GameObject.FindWithTag("MainCamera").GetComponent<Management>();
        hb = m.healthBar;
    }

    private void Start()
    {
        StartCoroutine(RadiationDamage());
    }

    public IEnumerator RadiationDamage()
    {
        yield return new WaitForSeconds(0.0002f);
        if (isActiveRadiation)
        {
            hb.StraightDamage(0.0002f, "Radiation");
        }
        StartCoroutine(RadiationDamage());
    }

    public void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.tag == "Player")
        {
            isActiveRadiation = true;
            hb.animator.SetBool("isVisible", true);
        }
    }

    public void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.tag == "Player")
        {
            isActiveRadiation = false;
            hb.animator.SetBool("isVisible", false);
            if (hb.healthBarImage.fillAmount == 0f)
            {
                m.StartGraphics();
            }
        }
    }

    public void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.transform.tag == "Player")
        {
            hb.animator.SetBool("isVisible", false);
            PlayerPrefs.SetString("ai", "on");
            gameObject.SetActive(false);
        }
    }
}

using UnityEngine;

public class DeathlessScript : MonoBehaviour
{
    private HealthBar hb;

    private void Awake()
    {
        hb = Camera.main.GetComponent<Management>().healthBar;
    }

    public void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.tag == "Player")
        {
            hb.Damage(10f, tag, Vector2.zero);
        }
    }
}

using UnityEngine;
using System.Collections;

public class Gate : MonoBehaviour
{
    [Header("StartSet")]
    public Vector2 gateScale = new Vector2(1, 4);
    public float speed = 0.1f;
    public bool isReverse = false;
    public bool isEnd = true;
    public Vector2 animSetGateScale = new Vector2();
    public Vector2 target = new Vector2();
    [Header("SpriteEditor")]
    public Sprite mainSprite;
    [Header("Assets")]
    public GameObject door1;
    public GameObject door2;
    private IEnumerator fixUpdate;

    private void Start()
    {
        SpriteRenderer ds1 = door1.GetComponent<SpriteRenderer>();
        SpriteRenderer ds2 = door2.GetComponent<SpriteRenderer>();
        ds1.sprite = mainSprite;
        ds2.sprite = mainSprite;
        if (isReverse == false)
        {
            animSetGateScale = target = gateScale;
        }
        fixUpdate = FixUpdate();
        SetGate(animSetGateScale);
    }

    private IEnumerator FixUpdate()
    {
        yield return new WaitForSeconds(0.03f);
        if (animSetGateScale != target)
        {
            float s = Time.fixedDeltaTime / 0.03f;
            animSetGateScale = Vector2.MoveTowards(animSetGateScale, target, speed * s);
            SetGate(animSetGateScale);
            StartCoroutine(FixUpdate());
        }
    }

    private void SetGate(Vector2 scale)
    {
        SpriteRenderer ds1 = door1.GetComponent<SpriteRenderer>();
        SpriteRenderer ds2 = door2.GetComponent<SpriteRenderer>();
        Vector2 size = new Vector2(mainSprite.texture.width, mainSprite.texture.height);
        float k = size.x / size.y;
        ds1.size = new Vector2(gateScale.x, scale.y / 2f);
        ds2.size = new Vector2(gateScale.x, scale.y / 2f);

        BoxCollider2D d1 = door1.GetComponent<BoxCollider2D>();
        BoxCollider2D d2 = door2.GetComponent<BoxCollider2D>();
        d1.size = new Vector2(gateScale.x, scale.y / 2f);
        d2.size = new Vector2(gateScale.x, scale.y / 2f);
        
        door1.transform.localScale = new Vector3(1f, 1f, 1f);
        door2.transform.localScale = new Vector3(1f, 1f, 1f);
        door1.transform.localPosition = new Vector3(0f, (gateScale.y / 2f) - (scale.y / 4f), 0f);
        door2.transform.localPosition = new Vector3(0f, -(gateScale.y / 2f) + (scale.y / 4f), 0f);
    }

    public void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.CompareTag("Player"))
        {
            if (isReverse == false)
            {
                target = Vector2.zero;
            }
            else
            {
                target = gateScale;
            }
            StopCoroutine(fixUpdate);
            fixUpdate = FixUpdate();
            StartCoroutine(fixUpdate);
        }
    }

    private void OnTriggerExit2D(Collider2D collision)
    {
        if (collision.CompareTag("Player") && isEnd == true)
        {
            if (isReverse == false)
            {
                target = gateScale;
            }
            else
            {
                target = Vector2.zero;
            }
            StopCoroutine(fixUpdate);
            fixUpdate = FixUpdate();
            StartCoroutine(fixUpdate);
        }
    }
}

public Vector2 RotateVector(Vector2 a, float offsetAngle)
{
    float power = Mathf.Sqrt(a.x * a.x + a.y * a.y);
    float angle = Mathf.Atan2(a.y, a.x) * Mathf.Rad2Deg - 90f + offsetAngle;
    return Quaternion.Euler(0, 0, angle) * Vector2.up * power;
}

using UnityEngine;
using System.Collections;

public class BasicAnimation : GlobalFunctions
{
    public AnimationType animationType = AnimationType.Infinity;
    public float speedSpeed = 0.05f;
    public float rotation = 0f;

    private bool make = true;
    private bool animMake = false;
    private bool isMoved = false;
    private Transform tr;
    private float rotationActive = 0f;

    public void SetPos(bool pos, float m)
    {
        rotationActive = rotation * (pos ? 1 : m);
    }

    private void Start()
    {
        tr = transform;
        animMake = false;
        switch (animationType)
        {
            case AnimationType.Infinity:
                make = true;
                isMoved = true;
                rotationActive = rotation;
                break;
            case AnimationType.Start:
                make = false;
                isMoved = false;
                break;
            case AnimationType.End:
                make = true;
                isMoved = true;
                rotationActive = rotation;
                break;
            case AnimationType.All: 
                make = false;
                isMoved = false;
                break;
        }
    }

    public void TimerAnim(float timer, bool anim)
    {
        StartAnim(anim);
        StartCoroutine(TimerTimerAnim(timer, anim));
    }

    private IEnumerator TimerTimerAnim(float timer, bool anim)
    {
        yield return new WaitForSeconds(timer);
        EndAnim(anim);
    }

    public void StartAnim(bool anim)
    {
        make = true;
        if (anim == true)
        {
            animMake = true;
            isMoved = true;
        }
        else
        {
            rotationActive = rotation;
        }
    }

    public void EndAnim(bool anim)
    {
        if (anim == true)
        {
            animMake = true;
            isMoved = false;
        }
        else
        {
            make = false;
            rotationActive = 0f;
        }
    }

    private void FixedUpdate()
    {
        if (animMake == true)
        {
            if (isMoved == true)
            {
                if (rotationActive != rotation)
                {
                    rotationActive = Mathf.MoveTowards(rotationActive, rotation, speedSpeed);
                }
                else
                {
                    animMake = false;
                    isMoved = false;
                }
            }
            else
            {
                if (rotationActive != 0f)
                {
                    rotationActive = Mathf.MoveTowards(rotationActive, 0f, speedSpeed);
                }
                else
                {
                    animMake = false;
                    isMoved = true;
                }
            }
        }
    }

    private void Update()
    {
        if (make == true)
        {
            float rot = tr.localEulerAngles.z;
            float s = Time.fixedDeltaTime / 0.03f * (Time.deltaTime / 0.03f);
            tr.localEulerAngles = new Vector3(0f, 0f, rot + rotationActive * s);
        }
    }
}

using UnityEngine;
using System.Collections;

public class PointsAnimation : GlobalFunctions
{
    public AnimationType animationType = AnimationType.Infinity;
    public float speedSpeedPosition = 0.001f;
    public float speedPosition = 0.1f;
    public Vector3[] pointsPosition = new Vector3[0];
    public int counterPosition = 0;

    private float speedPositionActive = 0f;
    private int pointsPositionLength = 0;
    private bool make = true;
    private bool animMake = false;
    private bool isMoved = false;
    private Transform tr;

    public void SetPos(bool pos, float m) { speedPositionActive = speedPosition * (pos ? 1 : m); }

    private void Awake()
    {
        pointsPositionLength = pointsPosition.Length;
        tr = transform;
        switch (animationType)
        {
            case AnimationType.Infinity:
                make = true;
                isMoved = true;
                speedPositionActive = speedPosition;
                break;
            case AnimationType.Start:
                make = false;
                isMoved = false;
                break;
            case AnimationType.End:
                make = true;
                isMoved = true;
                speedPositionActive = speedPosition;
                break;
            case AnimationType.All:
                make = false;
                isMoved = false;
                break;
        }
    }

    public void TimerAnim(float timer, bool anim)
    {
        StartAnim(anim);
        StartCoroutine(TimerTimerAnim(timer, anim));
    }

    private IEnumerator TimerTimerAnim(float timer, bool anim)
    {
        yield return new WaitForSeconds(timer);
        EndAnim(anim);
    }

    public void StartAnim(bool anim)
    {
        make = true;
        if (anim == true)
        {
            animMake = true;
            isMoved = true;
        }
        else
        {
            speedPositionActive = speedPosition;
        }
    }

    public void EndAnim(bool anim)
    {
        if (anim == true)
        {
            animMake = true;
            isMoved = false;
        }
        else
        {
            make = false;
            speedPositionActive = 0f;
        }
    }

    private void FixedUpdate()
    {
        if (animMake == true)
        {
            if (isMoved == true)
            {
                if (speedPositionActive != speedPosition)
                {
                    Vector2 ends = new Vector2(-speedPosition, speedPosition);
                    speedPositionActive = Mathf.MoveTowards(speedPositionActive, speedPosition, speedSpeedPosition);
                }
                else
                {
                    animMake = false;
                    isMoved = false;
                }
            }
            else
            {
                if (speedPositionActive != 0f)
                {
                    Vector2 ends = new Vector2(-speedPosition, speedPosition);
                    speedPositionActive = Mathf.MoveTowards(speedPositionActive, 0f, speedSpeedPosition);
                }
                else
                {
                    animMake = false;
                    isMoved = true;
                }
            }
        }
    }

    private void Update()
    {
        if (make)
        {
            if (tr.localPosition == pointsPosition[counterPosition])
            {
                counterPosition++;
                if (counterPosition == pointsPositionLength)
                { counterPosition = 0; }
            }
            else
            {
                float s = Time.fixedDeltaTime / 0.03f * (Time.deltaTime / 0.03f);
                tr.localPosition = Vector3.MoveTowards(tr.localPosition, pointsPosition[counterPosition], speedPositionActive * s);
            }
        }
    }
}

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
using System.Collections;

public class DebugConsole : MonoBehaviour
{
    public Animator animatorBlackScreen;
    public Language l;
    public InputField inputField;
    public Text textDebug;
    private bool access = false;

    public void AnalyzeText()
    {
        string txt = inputField.text.ToLower();
        string[] output = new string[0];
        string txtLoc = "";

        for (int i = 0; i < txt.Length; i++)
        {
            if (txt[i] == ' ')
            {
                if (txtLoc != "")
                {
                    output = Add(output, txtLoc);
                    txtLoc = "";
                }
            }
            else
            {
                txtLoc = txtLoc + txt[i];
            }
        }
        if (txtLoc != "")
        {
            output = Add(output, txtLoc);
            txtLoc = "";
        }

        Analyze(output);
    }

    public void Analyze(string[] commands)
    {
        switch (commands[0])
        {
            case "playerprefs":
                if (access == true)
                {
                    if (commands.Length < 2)
                    {
                        Log(l.ConsoleLanguage(1));//1
                    }
                    else
                    {
                        switch (commands[1])
                        {
                            case "f":
                            case "float":
                                float f = 0f;
                                if (float.TryParse(commands[3], out f))
                                {
                                    PlayerPrefs.SetFloat(commands[2], float.Parse(commands[3]));
                                    Log(l.ConsoleLanguage(2, commands[2]));//2
                                }
                                else
                                {
                                    Log(l.ConsoleLanguage(3));//3
                                }
                                break;
                            case "i":
                            case "int":
                                int i = 0;
                                if (int.TryParse(commands[3], out i))
                                {
                                    PlayerPrefs.SetInt(commands[2], int.Parse(commands[3]));
                                    Log(l.ConsoleLanguage(4, commands[2]));//4
                                }
                                else
                                {
                                    Log(l.ConsoleLanguage(5));//5
                                }
                                break;
                            case "s":
                            case "string":
                                PlayerPrefs.SetString(commands[2], commands[3]);
                                Log(l.ConsoleLanguage(6, commands[2]));//6
                                break;
                            case "clear":
                                PlayerPrefs.DeleteAll();
                                SceneManager.LoadScene(0);
                                break;
                            default:
                                Log(l.ConsoleLanguage(7, commands[1]));//7
                                break;
                        }
                    }
                }
                else
                {
                    Log(l.ConsoleLanguage(8));//8
                }
                break;
            case "next":
                if (access == true)
                {
                    if (commands.Length > 1)
                    {
                        switch (commands[1])
                        {
                            case "level":
                                int p = PlayerPrefs.GetInt("progress");
                                PlayerPrefs.SetInt("progress", p + 1);
                                Log("ok level");
                                break;
                            case "save":
                                int s = PlayerPrefs.GetInt("elevatorsave");
                                PlayerPrefs.SetInt("elevatorsave", s + 1);
                                Log("ok save");
                                break;
                            case "start":
                                PlayerPrefs.SetInt("elevatorsave", 0);
                                Log("ok start");
                                break;
                            case "end":
                                PlayerPrefs.SetInt("elevatorsave", 1);
                                Log("ok end");
                                break;
                        }
                    }
                }
                else
                {
                    Log(l.ConsoleLanguage(8));//8
                }
                break;
            case "echo":
                if (commands.Length == 1)
                {
                    Log(l.ConsoleLanguage(9));//9
                }
                else
                {
                    switch (commands[1])
                    {
                        case "vertogpro"://echo vertogpro
                            access = true;
                            Log(l.ConsoleLanguage(10));//10
                            break;
                        default:
                            Log(l.ConsoleLanguage(11));//11
                            break;
                    }
                }
                break;
            case "restart":
                if (access == true)
                {
                    SceneManager.LoadScene(0);
                }
                else
                {
                    Log(l.ConsoleLanguage(12));//12
                }
                break;
            case "authors":
                Log(l.ConsoleLanguage(13));//13
                break;
            case "discharge":
                animatorBlackScreen.SetBool("isActive", true);
                PlayerPrefs.SetString("start", "key");
                PlayerPrefs.SetString("language", "nothing");
                PlayerPrefs.SetString("graphicsquality", "medium");
                PlayerPrefs.SetFloat("sound", 0.5f);
                PlayerPrefs.SetFloat("music", 0.5f);
                PlayerPrefs.SetFloat("rotatenextlevel", 0f);
                PlayerPrefs.SetInt("elevatorsave", 0);
                PlayerPrefs.SetInt("progress", 1);
                PlayerPrefs.SetInt("deaths", 0);
                PlayerPrefs.SetInt("discharge", PlayerPrefs.GetInt("discharge") + 1);
                PlayerPrefs.SetInt("lastmenueffect", -1);
                PlayerPrefs.SetString("isshotmode", "false");
                PlayerPrefs.SetString("boss1", "life");
                PlayerPrefs.SetString("boss2", "life");
                PlayerPrefs.SetString("ai", "off");
                PlayerPrefs.SetString("boss3", "life");
                PlayerPrefs.SetString("end", "none");
                StartCoroutine(StartGame());
                break;
            case "clear":
                Clear();
                break;
            case "info":
                if (access == false)
                {
                    Log(l.ConsoleLanguage(14));//14
                }
                else
                {
                    Log(l.ConsoleLanguage(15));//15
                }
                break;
            default:
                Log(l.ConsoleLanguage(16, commands[0]));//16
                break;
        }
    }

    public void Log(object message)
    {
        textDebug.text = message.ToString();
    }

    public void Clear()
    {
        inputField.text = "";
        textDebug.text = "";
    }

    public string[] Add(string[] old, string addComponent)
    {
        string[] n = new string[old.Length + 1];

        if (old.Length != 0)
        {
            for (int i = 0; i < old.Length; i++)
            {
                n[i] = old[i];
            }
        }

        n[old.Length] = addComponent;
        return n;
    }

    public IEnumerator StartGame()
    {
        yield return new WaitForSeconds(1f);
        SceneManager.LoadSceneAsync(0);
    }
}

using UnityEngine;
using System.Collections;

public class BossManagement1 : GlobalFunctions
{
    public float hp = 100f;
    public float speed = 0.2f;
    public bool startActivated = false;
    public bool activated = false;
    public bool activatedSaw = false;
    public bool activatedAngle = false;
    public bool activatedCoroutine = true;
    private bool active;
    private float maxhp;
    public Vector2 target;
    public Vector2 targetSaw1;
    public Vector2 targetSaw2;
    public Vector2 minBorder;
    public Vector2 maxBorder;
    public DeadBoss1 deadBoss;
    public GameObject backGround;
    public GameObject healthBar;
    public Transform tr;
    public Transform sawMain;
    public Transform saw1;
    public Transform saw2;
    public Arrow arrow;
    public AudioSet setStart;
    public AudioSet setEnd;
    public Transform player;
    public Power playerPower;
    private Transform bg, hb;
    private float targethp = 0f;

    private Vector2 startMove = new Vector2(-20f, 0f);

    public void Awake()
    {
        maxhp = hp;
        bg = backGround.transform;
        hb = healthBar.transform;
    }

    public void Start()
    {
        if (PlayerPrefs.GetString("boss1") == "death")
        {
            Dead(false);
        }
    }

    public void FixedUpdate()
    {
        if (startActivated && !activatedCoroutine)
        {
            if ((Vector2)tr.position != startMove)
            {
                tr.position = Vector2.MoveTowards(tr.position, startMove, speed);
                saw1.position = Vector2.MoveTowards(saw1.position, startMove, speed);
                saw2.position = Vector2.MoveTowards(saw2.position, startMove, speed);
            }
            else
            {
                activatedCoroutine = true;
                startActivated = false;
                StartCoroutine(ActivatedOn());
            }
        }
        if (activated)
        {
            if ((Vector2)tr.position != target)
            {
                tr.position = Vector2.MoveTowards(tr.position, target, speed);
            }
            else
            {
                activated = false;
                sawMain.localScale = new Vector2(0f, 0f);
                StartCoroutine(TargetRotate());
            }
        }
        if (activatedSaw)
        {
            if ((Vector2)saw1.position != targetSaw1)
            {
                saw1.position = Vector2.MoveTowards(saw1.position, targetSaw1, speed);
            }
            else
            {
                float x = Random.Range(minBorder.x, maxBorder.x);
                float y = Random.Range(minBorder.y, maxBorder.y);
                targetSaw1 = new Vector2(x, y);
            }

            if ((Vector2)saw2.position != targetSaw2)
            {
                saw2.position = Vector2.MoveTowards(saw2.position, targetSaw2, speed);
            }
            else
            {
                float x = Random.Range(minBorder.x, maxBorder.x);
                float y = Random.Range(minBorder.y, maxBorder.y);
                targetSaw2 = new Vector2(x, y);
            }
        }
        if (activatedAngle)
        {
            Vector2 dir = player.position - tr.position;
            float angle = Mathf.Atan2(dir.y, dir.x) * Mathf.Rad2Deg;
            tr.localEulerAngles = new Vector3(0f, 0f, Mathf.LerpAngle(tr.localEulerAngles.z, angle, 0.1f));
        }
    }

    public IEnumerator TargetRotate()
    {
        yield return new WaitForSeconds(3f + 3f * hp / maxhp);
        sawMain.localScale = new Vector2(6f, 6f);
        float x = Random.Range(minBorder.x, maxBorder.x);
        float y = Random.Range(minBorder.y, maxBorder.y);
        target = new Vector2(x, y);
        activated = true;
    }

    public IEnumerator ActivatedOn()
    {
        yield return new WaitForSeconds(3f);
        sawMain.localScale = new Vector2(6f, 6f);
        target = new Vector2(Random.Range(minBorder.x, maxBorder.x), Random.Range(minBorder.y, maxBorder.y));
        targetSaw1 = new Vector2(Random.Range(minBorder.x, maxBorder.x), Random.Range(minBorder.y, maxBorder.y));
        targetSaw2 = new Vector2(Random.Range(minBorder.x, maxBorder.x), Random.Range(minBorder.y, maxBorder.y));
        activatedSaw = true;
        activated = true;
        arrow.isActive = true;
    }

    public IEnumerator ActivatedCoroutineOff()
    {
        yield return new WaitForSeconds(1f);
        activatedCoroutine = false;
        activatedAngle = true;
    }

    public void Update()
    {
        if (active == true)
        {
            if (hp != targethp)
            {
                float s = Time.fixedDeltaTime / 0.03f * (Time.deltaTime / 0.03f);
                hp = MoveToward(hp, targethp, speed * s, new Vector2(-0f, maxhp));
            }
            else
            {
                active = false;
                if (targethp == 0f)
                {
                    Dead(true);
                }
            }
        }

        UpdateHP();
    }

    public void UpdateHP()
    {
        float h = hp / maxhp;
        bg.localScale = new Vector3(5f, 0.9f, 1f);
        hb.localScale = new Vector3(4.8f * h, 0.7f, 1f);
        hb.localPosition = new Vector3(-2.4f + 4.8f * h / 2f, 0f, 0f);
    }

    private bool oneTimeMusic = true;
    public void Damage(float damage)
    {
        if (oneTimeMusic == true)
        {
            oneTimeMusic = false;
            deadBoss.StartBoss();
            deadBoss.Boom();
            setStart.SetMusic();
            startActivated = true;
            StartCoroutine(ActivatedCoroutineOff());
        }

        if (hp != 0f)
        {
            targethp = Stable2(hp - damage, 0f, maxhp);
            speed = speed + damage * 0.02f;
            active = true;
        }
    }

    public void Dead(bool boom)
    {
        active = false;
        activated = false;
        activatedSaw = false;
        startActivated = false;
        activatedAngle = false;
        activatedCoroutine = false;
        backGround.SetActive(false);
        healthBar.SetActive(false);
        sawMain.gameObject.SetActive(false);
        saw1.gameObject.SetActive(false);
        saw2.gameObject.SetActive(false);
        setEnd.SetMusic();
        arrow.obj.SetActive(false);
        PlayerPrefs.SetString("boss1", "death");
        deadBoss.Dead(tr.position, boom);
    }

    public void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.transform.CompareTag("Player"))
        {
            Damage(playerPower.power);
        }
    }
}

using System.Collections;
using UnityEngine;

public class BossManagement2 : GlobalFunctions
{
    public float hp = 100f;
    public float speed = 0.5f;
    public float speedRotate = 0.5f;
    public int stage = 1;
    public bool isAlive = true;
    public bool isActivated = false;
    public bool isMove = false;
    public bool isWorkingLaser = true;
    private float timeStamina = 0f;
    private float timeRetarget = 0f;
    public Vector2 region = Vector2.zero;
    public Vector3 target = Vector3.zero;
    
    public GameObject player;
    public Transform saw;
    public Transform laser1;
    public Transform laser2;
    public Laser laserL1;
    public Laser laserL2;
    public Transform laserOffset1;
    public Transform laserOffset2;
    public Explosion explosion;
    public GameObject explosionAsset;
    public CircleCollider2D trigStart;
    public BoxCollider2D laserDetected1;
    public BoxCollider2D laserDetected2;
    public GameObject saw1;
    public GameObject saw2;
    public Transform health;
    public Transform stamina;
    public SpriteRenderer srStamina;
    private Transform pl;
    private Transform tr;

    public Transform state;
    public Laser state1;
    public Laser state2;
    public Laser state3;
    public Laser state4;
    private Coroutine coroutineStamina;

    public SpriteRenderer bossBase;
    public SpriteRenderer laserD1;
    public SpriteRenderer laserD2;
    public Gate gateStart;
    public Gate gateEnd;
    public GameObject blockWin;
    public GameObject physicsIn;
    public GameObject stateLasers;
    public GameObject expStart;
    
    public AudioSet setStart;
    public AudioClip setEnd;
    public AudioBase audioBase;

    public void Awake()
    {
        bool isDeath = PlayerPrefs.GetString("boss2") == "death";
        blockWin.SetActive(false);
        if (isDeath)
        {
            isAlive = false;
            gateStart.isReverse = true;
            gateEnd.isReverse = true;
            physicsIn.SetActive(false);
            stateLasers.SetActive(false);
            expStart.SetActive(false);
            gameObject.SetActive(false);
        }
        else
        {
            tr = transform;
            pl = player.transform;
            timeStamina = 5.4f / speedRotate / 100f;
            timeRetarget = 5.4f / speedRotate;
            saw.localScale = Vector3.zero;
            stamina.localScale = Vector3.zero;
            srStamina.color = new Color(0f, 0.5f, 1f, 0f);
            saw1.SetActive(false);
            saw2.SetActive(false);
            LaserDisable();
            LaserBlockEnable();
        }
    }

    public void Update()
    {
        if (isAlive)
        {
            if (isActivated == true)
            {
                switch (stage)
                {
                    case 1:
                        if (isMove == true)
                        {
                            if (tr.position == target)
                            {
                                isMove = false;
                                RotatePlayer();
                                saw1.SetActive(true);
                                saw2.SetActive(true);
                                stamina.localScale = Vector3.zero;
                                srStamina.color = new Color(0f, 0.5f, 1f, 1f);
                                if (coroutineStamina != null) { StopCoroutine(coroutineStamina); }
                                coroutineStamina = StartCoroutine(StaminaAnim(timeStamina, 100));
                                StartCoroutine(Retarget1());
                            }
                            else
                            {
                                tr.position = Vector2.MoveTowards(tr.position, target, speed);
                            }
                        }
                        break;
                    case 2:
                        if (isMove == true)
                        {
                            if (tr.position == target)
                            {
                                isMove = false;
                                RotatePlayer();
                                saw.localScale = Vector3.zero;
                                saw1.SetActive(true);
                                saw2.SetActive(true);
                                stamina.localScale = Vector3.zero;
                                srStamina.color = new Color(0f, 0.5f, 1f, 1f);
                                if (coroutineStamina != null) { StopCoroutine(coroutineStamina); }
                                coroutineStamina = StartCoroutine(StaminaAnim(timeStamina, 100));
                                StartCoroutine(Retarget2());
                            }
                            else
                            {
                                tr.position = Vector2.MoveTowards(tr.position, target, speed);
                            }
                        }
                        break;
                    case 3:
                        if (isMove == true)
                        {
                            if (tr.position == target)
                            {
                                isMove = false;
                                RotatePlayer();
                                saw.localScale = Vector3.zero;
                                LaserEnable();
                                stamina.localScale = Vector3.zero;
                                srStamina.color = new Color(0f, 0.5f, 1f, 1f);
                                if (coroutineStamina != null) { StopCoroutine(coroutineStamina); }
                                coroutineStamina = StartCoroutine(StaminaAnim(timeStamina, 100));
                                StartCoroutine(Retarget3());
                            }
                            else
                            {
                                tr.position = Vector2.MoveTowards(tr.position, target, speed);
                            }
                        }
                        break;
                    case 4:
                        if (isMove == true)
                        {
                            if (tr.position == target)
                            {
                                isMove = false;
                                RotatePlayer();
                                saw.localScale = Vector3.zero;
                                LaserEnable();
                                stamina.localScale = Vector3.zero;
                                srStamina.color = new Color(0f, 0.5f, 1f, 1f);
                                if (coroutineStamina != null) { StopCoroutine(coroutineStamina); }
                                coroutineStamina = StartCoroutine(StaminaAnim(timeStamina, 100));
                                StartCoroutine(Retarget4());
                            }
                            else
                            {
                                tr.position = Vector2.MoveTowards(tr.position, target, speed);
                            }
                        }
                        break;
                    case 5:
                        if (isMove == true)
                        {
                            if (tr.position == target)
                            {
                                isMove = false;
                                RotatePlayer();
                                saw.localScale = Vector3.zero;
                                LaserEnable();
                                saw1.SetActive(false);
                                saw2.SetActive(false);
                                stamina.localScale = Vector3.zero;
                                srStamina.color = new Color(0f, 0.5f, 1f, 1f);
                                if (coroutineStamina != null) { StopCoroutine(coroutineStamina); }
                                coroutineStamina = StartCoroutine(StaminaAnim(timeStamina, 100));
                                StartCoroutine(Retarget5());
                            }
                            else
                            {
                                tr.position = Vector2.MoveTowards(tr.position, target, speed);
                            }
                        }
                        break;
                }
            }
            else
            {
                if (trigStart.enabled == false)
                {
                    isActivated = true;
                    float musicValue = PlayerPrefs.GetFloat("music");
                    audioBase.UpSound(0.01f, 5, 0, TypePlaying.Music);
                    explosion.health = 0f;
                    explosion.StartCoroutineTimerOffsetExplosion();
                    RegionDetected();
                    LaserDisable();
                    target = Target();
                }
            }
        }
    }

    public void FixedUpdate()
    {
        if (!isMove && isActivated)
        {
            laserOffset1.localEulerAngles = new Vector3(0f, 0f, laserOffset1.localEulerAngles.z + speedRotate);
            laserOffset2.localEulerAngles = new Vector3(0f, 0f, laserOffset2.localEulerAngles.z + speedRotate);
            if (isWorkingLaser)
            {
                state.localEulerAngles = new Vector3(0f, 0f, state.localEulerAngles.z + speedRotate);
            }
        }
    }

    public void RotatePlayer()
    {
        Vector2 p = pl.position;
        float angle = Mathf.Atan2(p.y, p.x) * Mathf.Rad2Deg;
        laserOffset1.localEulerAngles = new Vector3(0f, 0f, angle);
        laserOffset2.localEulerAngles = new Vector3(0f, 0f, angle - 180f);
    }

    private Vector3[] posLasers = new Vector3[] { Vector3.zero, Vector3.zero};
    public void TriggerLaserDefect(int id)
    {
        switch (id)
        {
            case 1: state1.active = false; state1.lr1.SetPositions(posLasers); break;
            case 2: state2.active = false; state2.lr1.SetPositions(posLasers); break;
            case 3: state3.active = false; state3.lr1.SetPositions(posLasers); break;
            case 4: state4.active = false; state4.lr1.SetPositions(posLasers); break;
        }
        if (!state1.active && !state2.active && !state3.active && !state4.active)
        {
            isWorkingLaser = false;
            state1.active = false;
            state2.active = false;
            state3.active = false;
            state4.active = false;
            laserL1.active = false;
            laserL2.active = false;
            laser1.localPosition = Vector2.zero;
            laser2.localPosition = Vector2.zero;
        }
    }

    public void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.transform.tag == "Player")
        {
            hp = hp - pl.GetComponent<Power>().power;
            health.localScale = new Vector2(hp / 50f, hp / 50f);
            stage = 5 - (int)(hp / 25f);
            if (stage == 4)
            {
                LaserBlockDisable();
            }
            if (hp <= 0f && isAlive == true)
            {
                audioBase.LowerSound(0.1f, 50, 0, TypePlaying.Music);
                audioBase.SetSound(setEnd, 0, 0.8f, TypePlaying.Music, true, 1f);
                GameObject deadInside = Instantiate(explosionAsset, pl.position, Quaternion.identity);
                deadInside.GetComponent<Rigidbody2D>().isKinematic = true;
                deadInside.transform.localScale = new Vector2(2f, 2f);
                Explosion exp = deadInside.GetComponent<Explosion>();
                exp.radius = 2f;
                exp.health = 0f;
                exp.timeOffsetExplosion = 3f;
                exp.StartCoroutineTimerOffsetExplosion();
                gateStart.OnTriggerEnter2D(player.GetComponent<Collider2D>());
                gateEnd.OnTriggerEnter2D(player.GetComponent<Collider2D>());
                PlayerPrefs.SetString("boss2", "death");
                blockWin.SetActive(false);
                gameObject.SetActive(false);
            }
        }
    }

    public void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.tag == "Player")
        {
            blockWin.SetActive(true);
            trigStart.enabled = false;
        }
    }

    public void LaserEnable()
    {
        if (isWorkingLaser)
        {
            laserL1.active = true;
            laserL2.active = true;
            state1.active = false;
            state2.active = false;
            state3.active = false;
            state4.active = false;
        }
        laser1.localPosition = new Vector2(0f, -1f);
        laser2.localPosition = new Vector2(0f, -1f);
        return;
    }

    public void LaserDisable()
    {
        if (isWorkingLaser)
        {
            state1.active = true;
            state2.active = true;
            state3.active = true;
            state4.active = true;
            laserL1.active = false;
            laserL2.active = false;
        }
        laser1.localPosition = Vector2.zero;
        laser2.localPosition = Vector2.zero;
        return;
    }

    public void LaserBlockEnable()
    {
        laserDetected1.enabled = true;
        laserDetected2.enabled = true;
    }

    public void LaserBlockDisable()
    {
        laserDetected1.enabled = false;
        laserDetected2.enabled = false;
    }

    public void RegionDetected()
    {
        Vector2 result = Vector2.zero;
        Vector2 pos = pl.position;
        if (pos.x > -45f & pos.x <= -30f) { result.x = 1; }
        else if (pos.x > -30f & pos.x < -5f) { result.x = 2; }
        else if (pos.x >= -5f & pos.x <= 5f) { result.x = 3; }
        else if (pos.x > 5f & pos.x <= 30f) { result.x = 4; }
        else if (pos.x >= 30f & pos.x < 45f) { result.x = 5; }

        if (pos.y > -45f & pos.y <= -30f) { result.y = 1; }
        else if (pos.y > -30f & pos.y < -5f) { result.y = 2; }
        else if (pos.y >= -5f & pos.y <= 5f) { result.y = 3; }
        else if (pos.y > 5f & pos.y <= 30f) { result.y = 4; }
        else if (pos.y >= 30f & pos.y < 45f) { result.y = 5; }
        region = result;
        return;
    }

    private readonly Vector2[] aroundCloser = new Vector2[] 
    {
        new Vector2(2, 2), new Vector2(2, 3), new Vector2(2, 4),
        new Vector2(3, 2), new Vector2(3, 4), new Vector2(4, 2),
        new Vector2(4, 3), new Vector2(4, 4)
    };

    public Vector2 Target()
    {
        Vector2 result = Vector2.zero;
        if (region == new Vector2(3, 3))
        {
            region = aroundCloser[Random.Range(0, 8)];
        }
        switch (region.x)
        {
            case 1:
                result.x = Random.Range(-45f, -32f);
                break;
            case 2:
                result.x = Random.Range(-29f, -5f);
                break;
            case 3:
                result.x = Random.Range(-5f, 5f);
                break;
            case 4:
                result.x = Random.Range(5f, 29f);
                break;
            case 5:
                result.x = Random.Range(32f, 45f);
                break;
        }
        switch (region.y)
        {
            case 1:
                result.y = Random.Range(-45f, -32f);
                break;
            case 2:
                result.y = Random.Range(-29f, -5f);
                break;
            case 3:
                result.y = Random.Range(-5f, 5f);
                break;
            case 4:
                result.y = Random.Range(5f, 29f);
                break;
            case 5:
                result.y = Random.Range(32f, 45f);
                break;
        }
        isMove = true;
        return result;
    }

    public IEnumerator StaminaAnim(float time, int count)
    {
        yield return new WaitForSeconds(time);
        float sc = hp * (100f - count) / 5000f;
        stamina.localScale = new Vector2(sc, sc);
        if (count > 1)
        {
            count = count - 1;
            coroutineStamina = StartCoroutine(StaminaAnim(time, count));
        }
    }

    public IEnumerator Retarget1()
    {
        yield return new WaitForSeconds(timeRetarget);
        srStamina.color = new Color(0f, 0.5f, 1f, 0f);
        RotatePlayer();
        saw1.SetActive(false);
        saw2.SetActive(false);
        RegionDetected();
        target = Target();
    }

    public IEnumerator Retarget2()
    {
        yield return new WaitForSeconds(timeRetarget);
        srStamina.color = new Color(0f, 0.5f, 1f, 0f);
        RotatePlayer();
        saw.localScale = new Vector2(2f, 2f);
        saw1.SetActive(false);
        saw2.SetActive(false);
        RegionDetected();
        target = Target();
    }

    public IEnumerator Retarget3()
    {
        yield return new WaitForSeconds(timeRetarget);
        srStamina.color = new Color(0f, 0.5f, 1f, 0f);
        RotatePlayer();
        saw.localScale = new Vector2(2f, 2f);
        LaserDisable();
        RegionDetected();
        target = Target();
    }

    public IEnumerator Retarget4()
    {
        yield return new WaitForSeconds(timeRetarget);
        srStamina.color = new Color(0f, 0.5f, 1f, 0f);
        RotatePlayer();
        saw.localScale = new Vector2(2f, 2f);
        LaserDisable();
        RegionDetected();
        target = Target();
    }

    public IEnumerator Retarget5()
    {
        yield return new WaitForSeconds(timeRetarget);
        srStamina.color = new Color(0f, 0.5f, 1f, 0f);
        RotatePlayer();
        saw.localScale = new Vector2(2f, 2f);
        saw1.SetActive(true);
        saw2.SetActive(true);
        LaserDisable();
        RegionDetected();
        target = Target();
    }
}

using System.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;

public class BossManagement3 : MonoBehaviour
{
    public float health = 100f;
    public Vector4[] boxs = new Vector4[0];
    public int[] saw1Fields = new int[0];
    public int[] saw2Fields = new int[0];
    public int[] saw3Fields = new int[0];
    public int[] laser1Fields = new int[0];
    public int[] laser2Fields = new int[0];
    public Transform trBoss;
    public SpriteRenderer srBoss;
    public BossTracing3 bt;
    public Transform saw1;
    public Transform saw2;
    public Transform saw3;
    public Transform laser;
    public Transform laser1;
    public Transform laser2;
    public Transform trap1;
    public Transform trap2;
    public Transform trap3;
    public Transform trap4;
    public LineRenderer lr1;
    public LineRenderer lr2;
    public TrailRenderer trail;
    public GameObject exp;
    public GameObject terminal1;
    public GameObject terminal2;
    public GameObject LaserTarget;
    public GameObject LaserMover;
    public GameObject TrapsMover;
    public GameObject SawMover;
    public GameObject SawsAroundMover;
    public Explosion explosion;
    public SpriteRenderer sr;
    public CircleCollider2D cc;
    public Animator animatorEnd;
    public bool isMove = false;
    public bool isMoveSaw1 = false;
    public bool isMoveSaw2 = false;
    public bool isMoveSaw3 = false;
    public bool isMoveLaser1 = false;
    public bool isMoveLaser2 = false;
    public bool isMoveTraps = false;
    public int loadScene = 35;
    public int fieldPlayer = 0;
    private bool isActive = true;

    private float maxHealth;
    private Vector2 target = Vector2.zero;
    private Vector2 saw1target = Vector2.zero;
    private Vector2 saw2target = Vector2.zero;
    private Vector2 saw3target = Vector2.zero;
    private Vector2 laser1target = Vector2.zero;
    private Vector2 laser2target = Vector2.zero;
    private Vector2 traptarget1 = Vector2.zero;
    private Vector2 traptarget2 = Vector2.zero;
    private Vector2 traptarget3 = Vector2.zero;
    private Vector2 traptarget4 = Vector2.zero;
    private Vector2 border = new Vector2(47f, 44.5f);
    private Vector2 borderSaw = new Vector2(46f, 43.5f);
    private Management m;
    public GameObject p { get; private set; }
    private HealthBar hb;
    private Transform tr;
    private Power ppl;
    private int lengthBoxs = 0;
    private bool isLife = true;

    public void Awake()
    {
        isActive = !(PlayerPrefs.GetString("boss1") == "life" && PlayerPrefs.GetString("boss2") == "life");
        terminal1.SetActive(!isActive);
        terminal2.SetActive(isActive);
        trail.enabled = PlayerPrefs.GetString("graphicsquality") != "low";
        m = GameObject.FindWithTag("MainCamera").GetComponent<Management>();
        lengthBoxs = boxs.Length;
        maxHealth = health;
        hb = m.healthBar;
        p = m.player;
        tr = p.transform;
        ppl = m.ppl;
        float c = health / maxHealth;
        srBoss.color = new Color(0f, 0f, c);
    }

    public void Start()
    {
        if (isActive == false) { return; }
        StartCoroutine(Mover());

        fieldPlayer = bt.BoxPos(tr.position);
        if (fieldPlayer >= 0)
        {
            Vector4 r = boxs[saw1Fields[fieldPlayer]];
            saw1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[saw2Fields[fieldPlayer]];
            saw2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[saw3Fields[fieldPlayer]];
            saw3target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[laser1Fields[fieldPlayer]];
            laser1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[laser2Fields[fieldPlayer]];
            laser2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        else
        {
            Vector4 r = boxs[Random.Range(0, lengthBoxs)];
            saw1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[Random.Range(0, lengthBoxs)];
            saw2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[Random.Range(0, lengthBoxs)];
            saw3target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[Random.Range(0, lengthBoxs)];
            laser1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
            r = boxs[Random.Range(0, lengthBoxs)];
            laser2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        TrapMover();
        StartCoroutine(Laser1AIM());
        StartCoroutine(Laser2AIM());
        isMoveSaw1 = true;
        isMoveSaw2 = true;
        isMoveSaw3 = true;
        isMoveLaser1 = true;
        isMoveLaser2 = true;
        return;
    }

    public void SawMover1()
    {
        fieldPlayer = bt.BoxPos(tr.position);
        if (fieldPlayer >= 0)
        {
            Vector4 r = boxs[saw1Fields[fieldPlayer]];
            saw1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        else
        {
            Vector4 r = boxs[Random.Range(0, lengthBoxs)];
            saw1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        isMoveSaw1 = true;
    }

    public void SawMover2()
    {
        fieldPlayer = bt.BoxPos(tr.position);
        if (fieldPlayer >= 0)
        {
            Vector4 r = boxs[saw2Fields[fieldPlayer]];
            saw2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        else
        {
            Vector4 r = boxs[Random.Range(0, lengthBoxs)];
            saw2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        isMoveSaw2 = true;
    }

    public void SawMover3()
    {
        fieldPlayer = bt.BoxPos(tr.position);
        if (fieldPlayer >= 0)
        {
            Vector4 r = boxs[saw3Fields[fieldPlayer]];
            saw3target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        else
        {
            Vector4 r = boxs[Random.Range(0, lengthBoxs)];
            saw3target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        isMoveSaw3 = true;
    }

    public void LaserMover1()
    {
        fieldPlayer = bt.BoxPos(tr.position);
        if (fieldPlayer >= 0)
        {
            Vector4 r = boxs[laser1Fields[fieldPlayer]];
            laser1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        else
        {
            Vector4 r = boxs[Random.Range(0, lengthBoxs)];
            laser1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        StartCoroutine(Laser1AIM());
        isMoveLaser1 = true;
    }

    public void LaserMover2()
    {
        fieldPlayer = bt.BoxPos(tr.position);
        if (fieldPlayer >= 0)
        {
            Vector4 r = boxs[laser2Fields[fieldPlayer]];
            laser2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        else
        {
            Vector4 r = boxs[Random.Range(0, lengthBoxs)];
            laser2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
        }
        StartCoroutine(Laser2AIM());
        isMoveLaser2 = true;
    }

    public void TrapMover()
    {
        traptarget1 = new Vector2(Random.Range(-border.x, border.x), Random.Range(-border.y, border.y));
        traptarget2 = new Vector2(-traptarget1.x, -traptarget1.y);
        traptarget3 = new Vector2(-traptarget1.x, traptarget1.y);
        traptarget4 = new Vector2(traptarget1.x, -traptarget1.y);
        isMoveTraps = true;
    }

    public IEnumerator Laser1AIM()
    {
        yield return new WaitForSeconds(0.5f);
        Vector2 diff = tr.position;
        float rot_z = Mathf.Atan2(diff.y, diff.x) * Mathf.Rad2Deg + 90f;
        laser1.rotation = Quaternion.Euler(0f, 0f, rot_z);
    }

    public IEnumerator Laser2AIM()
    {
        yield return new WaitForSeconds(0.5f);
        Vector2 diff = tr.position;
        float rot_z = Mathf.Atan2(diff.y, diff.x) * Mathf.Rad2Deg + 90f;
        laser2.rotation = Quaternion.Euler(0f, 0f, rot_z);
    }

    public IEnumerator Mover()
    {
        yield return new WaitForSeconds(7.5f);
        if (isLife)
        {
            Vector2 diff = tr.position;
            float rot_z = Mathf.Atan2(diff.y, diff.x) * Mathf.Rad2Deg + 90f;
            laser.rotation = Quaternion.Euler(0f, 0f, rot_z);
            target = bt.GetPosRaycast();
            isMove = true;
        }
    }

    public void Update()
    {
        if (isActive == false) { return; }
        float s = Time.fixedDeltaTime / (0.03f / Time.timeScale);
        if (isMove)
        {
            trBoss.position = Vector2.MoveTowards(trBoss.position, target, s * 0.5f);
            if (trBoss.position == (Vector3)target)
            {
                isMove = false;
                if (isLife)
                {
                    StartCoroutine(Mover());
                }
            }
        }
        if (isMoveSaw1)
        {
            saw1.position = Vector2.MoveTowards(saw1.position, saw1target, s * 0.1f);
            if (saw1.position == (Vector3)saw1target)
            {
                isMoveSaw1 = false;
                if (isLife)
                {
                    SawMover1();
                }
            }
        }
        if (isMoveSaw2)
        {
            saw2.position = Vector2.MoveTowards(saw2.position, saw2target, s * 0.1f);
            if (saw2.position == (Vector3)saw2target)
            {
                isMoveSaw2 = false;
                if (isLife)
                {
                    SawMover2();
                }
            }
        }
        if (isMoveSaw3)
        {
            saw3.position = Vector2.MoveTowards(saw3.position, saw3target, s * 0.1f);
            if (saw3.position == (Vector3)saw3target)
            {
                isMoveSaw3 = false;
                if (isLife)
                {
                    SawMover3();
                }
            }
        }
        if (isMoveLaser1)
        {
            laser1.position = Vector2.Lerp(laser1.position, laser1target, s * 0.1f);
            if (laser1.position == (Vector3)laser1target)
            {
                isMoveLaser1 = false;
                if (isLife)
                {
                    LaserMover1();
                }
            }
        }
        if (isMoveLaser2)
        {
            laser2.position = Vector2.Lerp(laser2.position, laser2target, s * 0.1f);
            if (laser2.position == (Vector3)laser2target)
            {
                isMoveLaser2 = false;
                if (isLife)
                {
                    LaserMover2();
                }
            }
        }
        if (isMoveTraps)
        {
            trap1.position = Vector2.MoveTowards(trap1.position, traptarget1, s * 0.1f);
            trap2.position = Vector2.MoveTowards(trap2.position, traptarget2, s * 0.1f);
            trap3.position = Vector2.MoveTowards(trap3.position, traptarget3, s * 0.1f);
            trap4.position = Vector2.MoveTowards(trap4.position, traptarget4, s * 0.1f);
            lr1.SetPosition(0, trap1.position);
            lr1.SetPosition(1, trap2.position);
            lr2.SetPosition(0, trap3.position);
            lr2.SetPosition(1, trap4.position);
            if (trap1.position == (Vector3)traptarget1)
            {
                isMoveTraps = false;
                if (isLife)
                {
                    TrapMover();
                }
            }
        }
    }

    public void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.gameObject == p)
        {
            if (isActive == false) { isActive = true; Start(); }
            if (isMove == true)
            {
                hb.StraightDamage(10f, "Boss3");
            }
            else
            {
                health = health - ppl.power;
                float c = health / maxHealth;
                srBoss.color = new Color(0f, 0f, c);
                trail.startColor = srBoss.color;
                if (health <= 0f)
                {
                    isLife = false;
                    isMove = false;
                    saw1target = trBoss.position;
                    saw2target = trBoss.position;
                    saw3target = trBoss.position;
                    isMoveSaw1 = true;
                    isMoveSaw2 = true;
                    isMoveSaw3 = true;
                    sr.enabled = false;
                    cc.enabled = false;
                    exp.SetActive(true);
                    explosion.health = 0f;
                    explosion.StartCoroutineTimerOffsetExplosion();
                    Vector2 diff = trBoss.position;
                    float rot_z = Mathf.Atan2(diff.y, diff.x) * Mathf.Rad2Deg + 90f;
                    laser.rotation = Quaternion.Euler(0f, 0f, rot_z);
                    int fieldBoss = bt.BoxPos(trBoss.position);
                    Vector4 r = boxs[laser1Fields[fieldBoss]];
                    laser1target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
                    r = boxs[laser2Fields[fieldBoss]];
                    laser2target = new Vector2(Random.Range(r.z, r.x), Random.Range(r.w, r.y));
                    StartCoroutine(Ended());
                }
            }
        }
    }
    
    public void EndedCoroutine()
    {
        if (!isActive)
        {
            //Debug.Log("End");
            isActive = true;
            StartCoroutine(Ended());
        }
    }

    public IEnumerator Ended()
    {
        yield return new WaitForSeconds(6.5f);
        if (hb.healthBarImage.fillAmount != 0f)
        {
            animatorEnd.SetBool("isActive", true);
            StartCoroutine(EndedFunction());
        }
    }

    public IEnumerator EndedFunction()
    {
        yield return new WaitForSeconds(1.5f);
        if (hb.healthBarImage.fillAmount != 0f)
        {
            PlayerPrefs.SetInt("progress", 35);
            SceneManager.LoadSceneAsync(loadScene);
        }
    }

    public void ControlDamagers(bool lt, bool lm, bool tm, bool sm, bool sam)
    {
        LaserTarget.SetActive(lt);
        LaserMover.SetActive(lm);
        TrapsMover.SetActive(tm);
        SawMover.SetActive(sm);
        SawsAroundMover.SetActive(sam);
    }
}

using UnityEngine;
using System.Collections;

public class AudioBase : GlobalFunctions
{
    public AudioSource[] layerSounds = new AudioSource[0];
    public GameObject music;
    private float musicValue, soundValue;
    private int lengthLayerSounds = 0;
    private bool soundActive = true;
    private Coroutine offsetActive;
    private int lowerSoundCoroutineCounter = 100;
    private int upSoundCoroutineCounter = 0;

    public void Awake()
    {
        soundActive = PlayerPrefs.GetString("graphicsquality") != "low";
        musicValue = PlayerPrefs.GetFloat("music");
        soundValue = PlayerPrefs.GetFloat("sound");
        lengthLayerSounds = layerSounds.Length;
        for (int i = 0; i < lengthLayerSounds; i++)
        {
            layerSounds[i].enabled = false;
        }
    }

    public void LowerSound(float timer, int upd, int id, TypePlaying typePlaying)
    {
        lowerSoundCoroutineCounter = upd;
        if (typePlaying == TypePlaying.Music)
        { StartCoroutine(LowerSoundCoroutine(timer, upd, id, musicValue)); }
        else { StartCoroutine(LowerSoundCoroutine(timer, upd, id, soundValue)); }
    }

    public void UpSound(float timer, int upd, int id, TypePlaying typePlaying)
    {
        upSoundCoroutineCounter = 0;
        if (typePlaying == TypePlaying.Music)
        { StartCoroutine(UpSoundCoroutine(timer, upd, id, musicValue)); }
        else { StartCoroutine(UpSoundCoroutine(timer, upd, id, soundValue)); }
    }

    public IEnumerator LowerSoundCoroutine(float timer, int upd, int id, float volumeSen)
    {
        yield return new WaitForSeconds(timer);
        layerSounds[id].volume = Stable2((layerSounds[id].volume / volumeSen - timer) * volumeSen, 0f, 1f);
        if (lowerSoundCoroutineCounter > 1)
        {
            StartCoroutine(LowerSoundCoroutine(timer, upd, id, volumeSen));
            lowerSoundCoroutineCounter -= 1;
        }
    }

    public IEnumerator UpSoundCoroutine(float timer, int upd, int id, float volumeSen)
    {
        yield return new WaitForSeconds(timer);
        layerSounds[id].volume = Stable2((layerSounds[id].volume / volumeSen + timer) * volumeSen, 0f, 1f);
        if (upSoundCoroutineCounter < upd)
        {
            StartCoroutine(UpSoundCoroutine(timer, upd, id, volumeSen));
            upSoundCoroutineCounter += 1;
        }
    }

    public void UpdateSound()
    {
        if (soundActive)
        {
            float time = Time.timeScale;
            for (int i = 0; i < lengthLayerSounds; i++)
            {
                AudioSource audioSource = layerSounds[i];
                if (audioSource.enabled == true)
                {
                    audioSource.pitch = time;
                }
            }
        }
    }

    public void SetSound(AudioClip audioClip, int layerSound, float volume, TypePlaying typePlaying, bool loop, float time)
    {
        StartCoroutine(SetSoundTime(audioClip, layerSound, volume, typePlaying, loop, time));
    }

    public IEnumerator SetSoundTime(AudioClip audioClip, int layerSound, float volume, TypePlaying typePlaying, bool loop, float time)
    {
        yield return new WaitForSeconds(time);
        SetSound(audioClip, layerSound, volume, typePlaying, loop);
    }

    public void SetSound(AudioClip audioClip, int layerSound, float volume, TypePlaying typePlaying, bool loop)
    {
        if (volume == 0f) { return; }
        if (soundActive)
        {
            AudioSource audioSource = layerSounds[layerSound];
            audioSource.enabled = true;
            audioSource.clip = audioClip;
            audioSource.loop = loop;
            if (typePlaying == TypePlaying.Sound)
            {
                audioSource.volume = soundValue * volume;
            }
            else
            {
                audioSource.volume = musicValue * volume;
            }
            audioSource.Play();
            if (offsetActive != null)
            {
                StopCoroutine(offsetActive);
                offsetActive = null;
            }
            if (!loop)
            {
                offsetActive = StartCoroutine(Offet(layerSound, audioClip.length, audioSource));
            }
        }
    }

    public IEnumerator Offet(int layerSound, float length, AudioSource audioSource)
    {
        yield return new WaitForSeconds(length);
        if (audioSource.clip == layerSounds[layerSound].clip)
        {
            AudioSource audioSource2 = layerSounds[layerSound];
            audioSource2.Stop();
            audioSource2.enabled = false;
        }
    }
}

[System.Serializable]
public class StringLanguageMinimize
{
    public string english = "";
    public string spanish = "";
    public string italian = "";
    public string german = "";
    public string russian = "";
    public string french = "";
    public string portuguese = "";
    public string korean = "";
    public string chinese = "";
    public string japan = "";

    public string GetString()
    {
        string ret = "";
        switch (PlayerPrefs.GetString("language"))
        {
            case "english": ret = english; break;
            case "spanish": ret = spanish; break;
            case "italian": ret = italian; break;
            case "german": ret = german; break;
            case "russian": ret = russian; break;
            case "french": ret = french; break;
            case "portuguese": ret = portuguese; break;
            case "korean": ret = korean; break;
            case "chinese": ret = chinese; break;
            case "japan": ret = japan; break;
        }
        return ret;
    }
}

[System.Serializable]
public class StringLanguage
{
    [TextArea]
    public string english = "";
    [TextArea]
    public string spanish = "";
    [TextArea]
    public string italian = "";
    [TextArea]
    public string german = "";
    [TextArea]
    public string russian = "";
    [TextArea]
    public string french = "";
    [TextArea]
    public string portuguese = "";
    [TextArea]
    public string korean = "";
    [TextArea]
    public string chinese = "";
    [TextArea]
    public string japan = "";

    public string GetString()
    {
        string ret = "";
        switch (PlayerPrefs.GetString("language"))
        {
            case "english": ret = english; break;
            case "spanish": ret = spanish; break;
            case "italian": ret = italian; break;
            case "german": ret = german; break;
            case "russian": ret = russian; break;
            case "french": ret = french; break;
            case "portuguese": ret = portuguese; break;
            case "korean": ret = korean; break;
            case "chinese": ret = chinese; break;
            case "japan": ret = japan; break;
        }
        return ret;
    }
}

using UnityEngine;

public class TipsInput : MonoBehaviour
{
    public int idTips = 0;
    public bool isPress2Read = true;
    public bool oneTime = true;
    private bool active = true;
    public GameObject[] copys;
    private Data data;
    private Press2Read p2r;
    private TipsInput ti;

    private void Awake()
    {
        data = GameObject.FindWithTag("MainCamera").GetComponent<Data>();
        p2r = GameObject.FindWithTag("Press2Read").GetComponent<Press2Read>();
        ti = GetComponent<TipsInput>();
    }

    public void OnCollisionEnter2D(Collision2D collision)
    {
        if (collision.transform.CompareTag("Player"))
        {
            if (isPress2Read == false && active == true)
            {
                Disable();
                data.SetDialoge(idTips);

                if (copys.Length != 0)
                {
                    for (int i = 0; i < copys.Length; i++)
                    {
                        copys[i].GetComponent<TipsInput>().Disable();
                    }
                }
            }
            else if (isPress2Read == true)
            {
                p2r.Active(ti);
            }
        }
    }

    public void OnCollisionExit2D(Collision2D collision)
    {
        if (isPress2Read == true)
        {
            p2r.DeActive();
        }
    }

    public void Disable()
    {
        if (oneTime == true)
        {
            active = false;
        }
        return;
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;

public class Data : GlobalFunctions
{
    public Dialoge[] dialoges;
    public DeadPhrases[] deadPhrases;
    public GamePlay[] gameplay;
    [Space]
    public Tips tips;
    public AudioBase audioBase;
    public TipsGamePlay gamePlayTips;
    public Image slowmobonus;
    public Text fpsText;
    public float scaleTips = 1f;
    public float scaleGameUI = 1f;
    public float scaleSlowMo = 1f;
    
    private float speed = 0f;
    private float target = 1f;
    private float timeDuration = 1f;
    private int updFPS = 0;

    public void Awake()
    {
        scaleTips = scaleGameUI = scaleSlowMo = 1f;
        slowmobonus.color = new Color(0f, 0f, 0f, 0f);
    }

    public void Start()
    {
        StartCoroutine(SecFPSUpdate());
    }

    public void SetDialoge(int id)
    {
        if (dialoges.Length != 0)
        {
            tips.SetActiveTrue(dialoges[id].dialogeStrings, dialoges[id].name);
        }
    }

    public void FalseP2R()
    {
        tips.SetFalse();
    }

    public string GetDeadPhrase(string typeDead)
    {
        int idType = -1;
        for (int i = 0; i < deadPhrases.Length; i++)
        {
            if (deadPhrases[i].typeDead == typeDead)
            {
                idType = i; break;
            }
        }

        if (idType == -1)
        {
            return typeDead;
        }

        int rand = Random.Range(0, deadPhrases[idType].deadPhrases.Length);
        return deadPhrases[idType].deadPhrases[rand].GetString();
    }

    public string GetDeadPhrase2()
    {
        string ret = "";
        switch (PlayerPrefs.GetString("language"))
        {
            case "english": ret = "Tap to continue"; break;
            case "spanish": ret = "Pulse para continuar"; break;
            case "italian": ret = "Tocca per continuare"; break;
            case "german": ret = "Tippen Sie, um fortzufahren"; break;
            case "russian": ret = "Нажмите для продолжения"; break;
            case "french": ret = "Appuyez sur pour continuer"; break;
            case "portuguese": ret = "Clique para continuar"; break;
            case "korean": ret = "????? ????"; break;
            case "chinese": ret = "??????"; break;
            case "japan": ret = "??????????"; break;
        }
        return ret;
    }

    public void PauseGameUI(float time)
    {
        scaleGameUI = time;
        Update();
        audioBase.UpdateSound();
    }

    public void SetGamePlayTips(int id)
    {
        if (id == -1) { gamePlayTips.SetActiveTrueSaved(); }
        else { gamePlayTips.SetActiveTrue(gameplay[id]); }
    }

    public void SlowMo(float timeDuration2, float setSlowMo, float speed2)
    {
        speed = speed2;
        target = setSlowMo;
        timeDuration = timeDuration2;
        Update();
        audioBase.UpdateSound();
    }

    public void SlowMo(float timeDuration2)
    {
        scaleSlowMo = 0.1f;
        float sb = (1f - scaleSlowMo) * 0.3921569f;
        slowmobonus.color = new Color(0f, 0f, 0f, sb);
        Update();
        audioBase.UpdateSound();
    }

    public IEnumerator EndAnim(float timeDuration)
    {
        yield return new WaitForSeconds(timeDuration);
        End();
    }

    public void End()
    {
        scaleSlowMo = 1f;
        float sb = (1f - scaleSlowMo) * 0.3921569f;
        slowmobonus.color = new Color(0f, 0f, 0f, sb);
        Update();
        audioBase.UpdateSound();
    }

    public void End2(float timeDuration2)
    {
        if (timeDuration2 == 0) { End(); return; }
        StartCoroutine(EndAnim(timeDuration2));
    }

    private void Update()
    {
        Time.timeScale = scaleTips * scaleSlowMo * scaleGameUI;
        Time.fixedDeltaTime = 0.03f * scaleSlowMo * scaleTips;
        updFPS = updFPS + 1;
        return;
    }

    private IEnumerator SecFPSUpdate()
    {
        yield return new WaitForSeconds(1f);
        fpsText.text = "FPS: " + updFPS; updFPS = 0;
        StartCoroutine(SecFPSUpdate());
    }
}

using System.Collections;
using UnityEngine.UI;
using UnityEngine;

public class Tips : GlobalFunctions
{
    public Data data;
    public Press2Read p2r;
    public GameUI gameUI;
    public GameObject obj;
    public AudioClip setClip;
    public Text nameText;
    public Text txt;
    private int textID = 0;
    private int textsID = 0;
    private AudioBase audioBase;
    private DialogeString textActive;
    private DialogeString[] textsActive;
    private bool isMass = false;
    [TextArea]
    public string end = "";
    [TextArea]
    public string endPast = "";

    public void Start()
    {
        audioBase = GameObject.FindWithTag("MainCamera").GetComponent<AudioBase>();
        data.scaleTips = 1f;
        obj.SetActive(false);
        txt.text = "";
    }

    public void SetActiveTrue(DialogeString text, StringLanguageMinimize name)
    {
        data.scaleTips = 0.1f;
        audioBase.layerSounds[0].volume /= 10f;
        obj.SetActive(true);
        nameText.text = name.GetString();
        gameUI.pauseButton.SetActive(false);
        textActive = text;
        isMass = false;
        StartCoroutine(TimerFalse());
    }

    public void SetActiveTrue(DialogeString[] texts, StringLanguageMinimize name)
    {
        data.scaleTips = 0.1f;
        audioBase.layerSounds[0].volume /= 10f;
        obj.SetActive(true);
        nameText.text = name.GetString();
        gameUI.pauseButton.SetActive(false);
        textsActive = texts;
        isMass = true;
        StartCoroutine(TimersFalse());
    }

    public IEnumerator TimerFalse(float time = 0.02f)
    {
        yield return new WaitForSecondsRealtime(time);
        string ds = textActive.dialogeString.GetString();
        if (textID < ds.Length && ds != end)
        {
            audioBase.SetSound(setClip, 1, 0.5f, TypePlaying.Sound, false);
            end = end + ds.Substring(textID, 1);
            txt.text = endPast + end;
            textID = textID + 1;

            if (textID + 1 != ds.Length && ds != end)
            {
                if (ds.Substring(textID + 1, 1) == ",")
                {
                    StartCoroutine(TimersFalse(0.1f));
                }
                else if (ds.Substring(textID + 1, 1) == ".")
                {
                    StartCoroutine(TimersFalse(0.15f));
                }
                else if (ds.Substring(textID + 1, 1) == "?")
                {
                    StartCoroutine(TimersFalse(0.15f));
                }
                else if (ds.Substring(textID + 1, 1) == ".")
                {
                    StartCoroutine(TimersFalse(0.15f));
                }
                else
                {
                    StartCoroutine(TimersFalse());
                }
            }
            else
            {
                StartCoroutine(TimersFalse());
            }
        }
        else
        {
            endPast = txt.text;
            if (textActive.isSkip)
            {
                if (textActive.skipOffset == 0f)
                {
                    SetActiveFalse();
                }
                else
                {
                    IsSkip(textActive.skipOffset);
                }
            }
        }
    }

    public IEnumerator TimersFalse(float time = 0.02f)
    {
        yield return new WaitForSecondsRealtime(time);
        string ds = textsActive[textsID].dialogeString.GetString();
        if (textID < ds.Length && ds != end)
        {
            audioBase.SetSound(setClip, 1, 0.5f, TypePlaying.Sound, false);
            end = end + ds.Substring(textID, 1);
            txt.text = endPast + end;
            textID = textID + 1;

            string ds1 = textsActive[textsID].dialogeString.GetString();
            if (textID + 1 != ds1.Length && ds1 != end)
            {
                if (ds1.Substring(textID + 1, 1) == ",")
                {
                    StartCoroutine(TimersFalse(0.1f));
                }
                else if (ds1.Substring(textID + 1, 1) == ".")
                {
                    StartCoroutine(TimersFalse(0.15f));
                }
                else if (ds1.Substring(textID + 1, 1) == "?")
                {
                    StartCoroutine(TimersFalse(0.15f));
                }
                else if (ds1.Substring(textID + 1, 1) == "!")
                {
                    StartCoroutine(TimersFalse(0.15f));
                }
                else
                {
                    StartCoroutine(TimersFalse());
                }
            }
            else
            {
                StartCoroutine(TimersFalse());
            }
        }
        else
        {
            endPast = txt.text;
            if (textsActive[textsID].isSkip)
            {
                if (textsActive[textsID].skipOffset == 0f)
                {
                    SetActiveFalse();
                }
                else
                {
                    IsSkip(textsActive[textsID].skipOffset);
                }
            }
        }
    }

    public IEnumerator IsSkip(float time)
    {
        yield return new WaitForSecondsRealtime(time);
        SetActiveFalse();
    }

    public void SetFalse()
    {
        obj.SetActive(false);
        gameUI.pauseButton.SetActive(true);
        end = "";
        endPast = "";
        txt.text = "";
        textID = textsID = 0;
        data.scaleTips = 1f;
        audioBase.layerSounds[0].volume *= 10f;
    }

    public void SetActiveFalse()
    {
        if (isMass == false)
        {
            if (textActive.dialogeString.GetString() != end)
            {
                end = textActive.dialogeString.GetString();
                if (textActive.isSkip)
                {
                    SetActiveFalse();
                }
            }
            else
            {
                obj.SetActive(false);
                gameUI.pauseButton.SetActive(true);
                end = "";
                data.scaleTips = 1f;
                audioBase.layerSounds[0].volume *= 10f;
            }
        }
        else
        {
            if (textsActive[textsID].dialogeString.GetString() != end)
            {
                if (textsActive[textsID].isStep == true)
                {
                    txt.text = end = textsActive[textsID].dialogeString.GetString();
                    if (textsActive[textsID].isSkip)
                    {
                        SetActiveFalse();
                    }
                }
                else
                {
                    end = textsActive[textsID].dialogeString.GetString();
                    txt.text = endPast + end;
                }
            }
            else
            {
                if (textsID != textsActive.Length - 1)
                {
                    textsID = textsID + 1;
                    textID = 0;
                    end = "";
                    if (textsActive[textsID].isStep == true)
                    {
                        endPast = "";
                    }
                    StartCoroutine(TimersFalse());
                }
                else
                {
                    obj.SetActive(false);
                    gameUI.pauseButton.SetActive(true);
                    p2r.UnTap();
                    end = "";
                    endPast = "";
                    txt.text = "";
                    textID = textsID = 0;
                    data.scaleTips = 1f;
                    audioBase.layerSounds[0].volume *= 10f;
                }
            }
        }
    }
}