_TheStrongestSnail/TheStrongestSnail/Assets/Scripts/Battle_Royale/PlayerMove.cs

using System.Collections;
using UnityEngine;
using UnityEngine.UI;
using DG.Tweening;

public class PlayerMove : MonoBehaviour
{
    public Transform objectToMove;      // Ҫ<>ƶ<EFBFBD><C6B6>Ķ<EFBFBD><C4B6><EFBFBD>
    public Transform[] pathPoints;      // ·<><C2B7><EFBFBD>ϵĵ<CFB5><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    public float duration = 5f;         // <20>ƶ<EFBFBD><C6B6>ij<EFBFBD><C4B3><EFBFBD>ʱ<EFBFBD><CAB1>
    public bool isLooping = false;      // <20>Ƿ<EFBFBD>ѭ<EFBFBD><D1AD>·<EFBFBD><C2B7>
    int startIndex = 0;
    int endIndex = 0;
    public string room_id;
    public float Speed;
    public Transform EndPos;

    public Transform TypeEndPos0;
    public Transform TypeEndPos1;
    public Transform TypeEndPos2;
    public Transform TypeEndPos3;
    public Transform TypeEndPos4;
    public Transform TypeEndPos5;
    public Transform TypeEndPos6;

    public Transform JumpPos;

    public Transform Pos1Parent;
    public Transform Pos2Parent;
    public Transform Pos3Parent;
    public Transform Pos4Parent;
    public Transform Pos5Parent;
    public Transform Pos6Parent;

    public Transform OutParent;

    public Transform ReturnPos;//<2F><><EFBFBD>ص<EFBFBD>λ<EFBFBD><CEBB>

    public bool IsBoos;

    public AllHouseContro allHouseContro;

    public Transform SelfTextTrans;
    public Transform SelfImage;
    public bool IsOtherWoniu;
    private void Start()
    {
        Speed = 2f;
        


    }
    public void MoveOutParent()
    {
        // <20><>¼ԭʼ<D4AD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD><EFBFBD>


        // <20><> childObject <20><>Ϊ<EFBFBD>µ<EFBFBD> parentObject <20><><EFBFBD>ӽڵ㣬<DAB5><E3A3AC><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>λ<EFBFBD><CEBB>
        objectToMove.SetParent(OutParent);
        objectToMove.SetAsLastSibling();


    }
    public void MoveInParent(Transform Parent)
    {
        objectToMove.SetParent(Parent);
        objectToMove.SetAsFirstSibling();
    }

    public void JudgeEnd()
    {
        if (EndPos == TypeEndPos1)
        {
            
            if (!IsBoos)
            {
                objectToMove.GetComponent<PlayerMovePos>().HouseId = 1;
            }
            else
            {
                GetComponent<BossContro>().HouseId = 1;
            }
        }
        else if (EndPos == TypeEndPos2) 
        {

            
            if (!IsBoos)
            {
                objectToMove.GetComponent<PlayerMovePos>().HouseId = 2;
            }
            else
            {
                GetComponent<BossContro>().HouseId = 2;
            }
        }
        else if(EndPos == TypeEndPos3)
        {
            
            if (!IsBoos)
            {
                objectToMove.GetComponent<PlayerMovePos>().HouseId = 3;
            }
            else
            {
                GetComponent<BossContro>().HouseId = 3;
            }
        }
        else if (EndPos == TypeEndPos4)
        {
          
            if (!IsBoos)
            {
                objectToMove.GetComponent<PlayerMovePos>().HouseId = 4;
            }
            else
            {
                GetComponent<BossContro>().HouseId = 4;
            }
        }
        else if (EndPos == TypeEndPos5)
        {
           
            if (!IsBoos)
            {
                objectToMove.GetComponent<PlayerMovePos>().HouseId = 5;
            }
            else
            {
                GetComponent<BossContro>().HouseId = 5;
            }
        }
        else if (EndPos == TypeEndPos6)
        {
            
            if (!IsBoos)
            {
                objectToMove.GetComponent<PlayerMovePos>().HouseId = 6;
            }
            else
            {
                GetComponent<BossContro>().HouseId = 6;
            }
        }

        
    }


    public void SetParentToHouse()
    {
        if (EndPos == TypeEndPos1)
        {
            MoveInParent(Pos1Parent);
           
        }
        else if (EndPos == TypeEndPos2)
        {

            MoveInParent(Pos2Parent);
           
        }
        else if (EndPos == TypeEndPos3)
        {
            MoveInParent(Pos3Parent);
            
        }
        else if (EndPos == TypeEndPos4)
        {
            MoveInParent(Pos4Parent);
           
        }
        else if (EndPos == TypeEndPos5)
        {
            MoveInParent(Pos5Parent);
           
        }
        else if (EndPos == TypeEndPos6)
        {
            MoveInParent(Pos6Parent);
           
        }


    }


    public void ReturnStartPos()//<2F>ص<EFBFBD><D8B5><EFBFBD>ʼ<EFBFBD><CABC>
    {
        EndPos = ReturnPos;
        StartMove();
    }


    public bool JudagePos1()
    {
        if (EndPos==TypeEndPos1)
        {
            return true ;
        }
        return false;
    }

    public void StartMove()
    {
        
        
        // <20><>ȡ·<C8A1><C2B7><EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD>е<EFBFBD><D0B5><EFBFBD>λ<EFBFBD><CEBB>
       
        for (int i = 0; i < pathPoints.Length; i++)
        {
            if (!IsBoos&& objectToMove.GetComponent<PlayerMovePos>().StartPos == pathPoints[i])
            {
                startIndex = i;
                Debug.Log("Startindex"+i);

            }
            else if (IsBoos && GetComponent<BossContro>().BoosStartPos== pathPoints[i])
            {
                startIndex = i;
                Debug.Log("Startindex" + i);
            }

            if (EndPos == pathPoints[i])
            {
                endIndex = i;
                Debug.Log("Endindex" + i);
            }
        }

        

        if (endIndex>startIndex)
        {
            duration=(endIndex-startIndex)/Speed;
            Vector3[] waypoints = new Vector3[endIndex-startIndex+1];
                for (int i=startIndex,j=0;j< pathPoints.Length&&i<=endIndex; i++,j++)
                 {
                    if (!JudagePos1() && pathPoints[i]==JumpPos)
                    {
                    waypoints[j] = pathPoints[i - 1].position;
                    continue;
                    
                    }
                waypoints[j]=pathPoints[i].position;
           
                }
                OnMove(waypoints);
        }
        else if(endIndex < startIndex)
        {
            duration = (startIndex-endIndex) / Speed;
            Vector3[] waypoints = new Vector3[startIndex-endIndex + 1];
            for (int i = startIndex, j = 0; j < pathPoints.Length && i >= endIndex; i--, j++)
            {
               
                if (!JudagePos1() && pathPoints[i] == JumpPos)
                {
                    waypoints[j] = pathPoints[i+1].position;
                    continue;

                }
                waypoints[j] = pathPoints[i].position;

            }
            OnMove(waypoints);
        }
        
       
              
       
    }


    public void AfterMove()
    {

       
        if (IsBoos||!objectToMove.GetComponent<PlayerMovePos>().IsReturn)
        {
            if (!IsBoos)
            {
                objectToMove.DOMoveY(objectToMove.position.y + 100, 0.5f).OnComplete(() => {
                    JudgeEnd();
                    SetParentToHouse();
                    objectToMove.GetComponent<PlayerMovePos>().StartPos = EndPos;


                    objectToMove.GetComponent<PlayerMovePos>().PlayAni.SetInteger("State", 0);
                    if (!IsOtherWoniu)
                    {
                        MaskContro.instance.SetMask(false);
                    }

                    
                });
            }
            else
            {
                Debug.Log("cscscscscscscscscscscs");
                JudgeEnd();
                GetComponent<BossContro>().BossAni.SetInteger("State", 0);//ֹͣ<CDA3>ƶ<EFBFBD>
                Debug.Log("nnnnnnnn");
                allHouseContro.ControOneDoorOpen(GetComponent<BossContro>().HouseId,() => {//<2F><><EFBFBD><EFBFBD>

                    GetComponent<BossContro>().BossAni.SetInteger("State", 1);
                    objectToMove.DOMoveY(objectToMove.position.y + 100, 0.5f).OnComplete(() => {//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>


                        
                            SetParentToHouse();
                            StartCoroutine(BoosAttack());
                        GetComponent<BossContro>().BoosStartPos = EndPos;
                     
                        //JudgeSuccOrFail();
                    });


                });
               
               
            }
            
        }
        else
        {
            objectToMove.GetComponent<PlayerMovePos>().IsReturn = false;//<2F><><EFBFBD><EFBFBD>
            MaskContro.instance.SetMask(false);
        }
       
        
    }


    IEnumerator BoosAttack()
    {
        GetComponent<BossContro>().BossAni.SetInteger("State", 2);
        yield return new WaitForSeconds(3f);
        GetComponent<BossContro>().BossAni.SetInteger("State", 0);

        BettingBtn.instance.GiveMoney(room_id);
        yield return new WaitForSeconds(2f);
        allHouseContro.BoosReturn();
        //JudgeSuccOrFail();
    }


    public void JudgeSuccOrFail()
    {
        Debug.Log("=000000000000000000000000000000000000000000000000");
        if (GetComponent<BossContro>().BoosStartPos == transform.GetComponent<PlayerMovePos>().StartPos && transform.GetComponent<PlayerMovePos>().HadChoise)
        {
            //BossContro.instance.BossAni.SetInteger("State", 2);//boos<6F><73><EFBFBD><EFBFBD>
            Debug.Log("ʧ<><CAA7>");//ʧ<><CAA7>
            FailPanel.instance.ShowPanel();
        }
        else if (GetComponent<BossContro>().BoosStartPos != transform.GetComponent<PlayerMovePos>().StartPos && transform.GetComponent<PlayerMovePos>().HadChoise)
        {
            Debug.Log("ʤ<><CAA4>");//ʤ<><CAA4>
            SucceePanel.instance.ShowPanel();
        }
        else
        {
            Debug.Log("û<><C3BB>ʧ<EFBFBD>ܺ<EFBFBD>ʤ<EFBFBD><CAA4>");//ʤ<><CAA4>
            foreach (GameObject item in allHouseContro.bossobj)
            {
                item.GetComponent<BossContro>().ReturnParent();
            }
        }
        //HegemonTime.instance.StartCoroutine(HegemonTime.instance.StartGame());//<2F><><EFBFBD>¼<EFBFBD><C2BC><EFBFBD>ʱ<EFBFBD><CAB1>   
    }

    public void Rotate()
    {
      
        Vector3 currentRotation = objectToMove.localEulerAngles;
        currentRotation.y += 180f;
        objectToMove.localEulerAngles = currentRotation;
        
    }

    public void OnMove(Vector3[] waypoints)
    {
        if (!IsBoos)
        {
            objectToMove.GetComponent<PlayerMovePos>().PlayAni.SetInteger("State", 1);
            if (!IsOtherWoniu)
            {
                 MaskContro.instance.SetMask(true);
            }
           
        }
        
        MoveOutParent();
        Tween pathTween = objectToMove.DOPath(waypoints, duration, PathType.Linear)
     .SetEase(Ease.Linear)  // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>Ч<EFBFBD><D0A7>
     .SetLoops(isLooping ? -1 : 0)
     .OnWaypointChange((index) =>
     {
         // <20><><EFBFBD><EFBFBD><EFBFBD>嵽<EFBFBD><E5B5BD>ij<EFBFBD><C4B3>·<EFBFBD><C2B7><EFBFBD><EFBFBD>ʱ<EFBFBD>ص<EFBFBD>
         if (index < waypoints.Length - 1)
         {
             Vector3 currentWaypoint = waypoints[index];
             Vector3 nextWaypoint = waypoints[index + 1];
             if (IsBoos)
             {
                 if (nextWaypoint.x < currentWaypoint.x && !GetComponent<BossContro>().IsLeft)
                 {
                     GetComponent<BossContro>().IsLeft = true;
                     // <20><>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ࣨ<EFBFBD><E0A3A8>Y<EFBFBD><59><EFBFBD><EFBFBD>ת180<38>ȣ<EFBFBD>
                     Rotate();
                 }
                 else if (nextWaypoint.x > currentWaypoint.x && GetComponent<BossContro>().IsLeft)
                 {
                     GetComponent<BossContro>().IsLeft = false;
                     Rotate();
                 }
             }
             else
             {
         // <20>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƿ<EFBFBD><C7B7><EFBFBD>Ҫ<EFBFBD><D2AA>ת
                     if (nextWaypoint.x < currentWaypoint.x && !objectToMove.GetComponent<PlayerMovePos>().IsLeft)
                     {
                     objectToMove.GetComponent<PlayerMovePos>().IsLeft = true;
                         // <20><>ת<EFBFBD><D7AA><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ࣨ<EFBFBD><E0A3A8>Y<EFBFBD><59><EFBFBD><EFBFBD>ת180<38>ȣ<EFBFBD>
                         Rotate();
                     }
                     else if (nextWaypoint.x > currentWaypoint.x && objectToMove.GetComponent<PlayerMovePos>().IsLeft)
                     {
                     objectToMove.GetComponent<PlayerMovePos>().IsLeft = false;
                         Rotate();
                     }
             }
            
         }
     })
     .OnComplete(AfterMove);
    }
}