ActionTowerDefense/ActionTowerDefense/Assets/Scripts/CameraController.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CameraController : MonoBehaviour
{
    public float offsetX = 5, offsetY = 3, offsetZ = -16;
    public float lerpValue = 3.5f;

    [HideInInspector]
    public Vector3 targetPos;
    [HideInInspector]
    public Vector3 leftTargetPos;
    [HideInInspector]
    public Vector3 rightTargetPos;
    [HideInInspector]
    public Vector3 cameraPos;

    public Camera mainCamera;
    public Camera leftCamera;
    public Camera rightCamera;

    public float maxView = 20;
    [HideInInspector]
    public float view;
    public float minDistance = 20;
    public float splitDistance = 30;
    public float mergeDistance = 16;
    [HideInInspector]
    public float distance;
    [HideInInspector]
    public float ratio;

    public float lineMaxScale = 0.5f;

    public GameObject lineInCamera;

    public int leftID;
    public int rightID;
    public bool isSplit;

    public float rapidMpReplySpeed;

    private void Start()
    {
        //ratio = maxView / (splitDistance - minDistance);
    }
    private void Update()
    {
        //µ÷²ÎÓÃ
        ratio = maxView / (splitDistance - minDistance);
        //

        PlayerController player0 = PlayersInput.instance[0];
        PlayerController player1 = PlayersInput.instance[1];

        if (player0 == null)
        {
            targetPos = Vector3.zero + new Vector3(0, offsetY, offsetZ);
        }
        else if (player1 == player0)
        {
            if (player0.isRevive)
            {
                targetPos = new Vector3(140, offsetY, offsetZ);
            }
            else
            {
                targetPos = CameraTargetMove(player0);
            }
            
        }
        else
        {
            if(player0.isRevive && player1.isRevive)
            {
                targetPos = new Vector3(140, offsetY, offsetZ);
                if (isSplit)
                {
                    CameraSplit(true);
                }
                return;
            }
            else if (player0.isRevive)
            {
                targetPos = CameraTargetMove(player1);
                if (isSplit)
                {
                    CameraSplit(true);
                }
                return;
            }
            if (player1.isRevive)
            {
                targetPos = CameraTargetMove(player0);
                if (isSplit)
                {
                    CameraSplit(true);
                }
                return;
            }
            Vector3 player0Pos = player0.transform.position;
            Vector3 player1Pos = player1.transform.position;
            distance = Vector3.Distance(player0Pos, player1Pos);

            if (player0Pos.x < player1Pos.x)
            {
                leftTargetPos = CameraTargetMove(player0);
                leftID = 0;
                rightTargetPos = CameraTargetMove(player1);
                rightID = 1;
            }
            else
            {
                leftTargetPos = CameraTargetMove(player1);
                leftID = 1;
                rightTargetPos = CameraTargetMove(player0);
                rightID = 0;
            }

            view = Mathf.Clamp((distance - minDistance) * ratio, 0, maxView);
            if (distance < mergeDistance)
            {
                if (isSplit)
                {
                    CameraSplit(true);
                }        
            }
            else
            {
                lineInCamera.transform.localScale = new Vector3(Mathf.Clamp(
                    (distance - mergeDistance) * 0.01f, 0, lineMaxScale), 10, 1);
                targetPos =
                    Vector3.Lerp(leftCamera.transform.position, rightCamera.transform.position, 0.5f);
            }
            if (distance > splitDistance)
            {
                if (!isSplit)
                {
                    CameraSplit(false);
                }
            }
            else
            {
                targetPos =
                    Vector3.Lerp(player0Pos, player1Pos, 0.5f) + new Vector3(0, offsetY, offsetZ);
            }

        }
    }
    private void FixedUpdate()
    {
        if (PlayersInput.instance[1] == null)
        {
            mainCamera.transform.position =
                Vector3.Lerp(mainCamera.transform.position, targetPos, lerpValue * Time.deltaTime);
        }
        else
        {
            if (lineInCamera.activeSelf)
            {
                cameraPos = targetPos;
            }
            else
            {
                cameraPos = Vector3.Lerp(mainCamera.transform.position,
                    targetPos, lerpValue * Time.deltaTime);
            }

            mainCamera.transform.position = new Vector3(cameraPos.x, cameraPos.y,offsetZ - view);
            leftCamera.transform.position = Vector3.Lerp(leftCamera.transform.position,
                leftTargetPos, lerpValue * Time.deltaTime);
            rightCamera.transform.position = Vector3.Lerp(rightCamera.transform.position,
                rightTargetPos, lerpValue * Time.deltaTime);

        }

    }
    public void CameraSplit(bool flag)
    {
        if (flag)
        {
            mainCamera.enabled = true;
            leftCamera.enabled = false;
            rightCamera.enabled = false;
            lineInCamera.SetActive(false);
            isSplit = false;
            PlayersInput.instance[0].RapidReplyMp(rapidMpReplySpeed);
            PlayersInput.instance[1].RapidReplyMp(rapidMpReplySpeed);
        }
        else
        {
            mainCamera.enabled = false;
            leftCamera.enabled = true;
            rightCamera.enabled = true;
            lineInCamera.SetActive(true);
            isSplit = true;
            PlayersInput.instance[0].NormalReplyMp();
            PlayersInput.instance[1].NormalReplyMp();
        }
    }
    Vector3 CameraTargetMove(PlayerController player)
    {
        Vector3 skewPos;
        if (player.bodyTrans.localScale.x > 0)
        {
            skewPos = player.transform.position + new Vector3(-offsetX, offsetY, offsetZ);
        }
        else
        {
            skewPos = player.transform.position + new Vector3(offsetX, offsetY, offsetZ);
        }
        return skewPos;
    }
}