Project_2018_Frozen/Unity_2018_Frozen/Assets/Frozen/Script/CharacterBehaviour.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class CharacterBehaviour : MonoBehaviour
{

    [SerializeField]
    private bool standby = true;


    [Range(0, 15)]
    public float disappearTime = 5;

    //public Material mat;

    public Area area;
    public List<Area> AppearArea = new List<Area>();

    Vector2 wallRoi;
    float origin_height = 0.0f;
    [SerializeField]
    private RectTransform fakeButton;

    private const float checktriggerColliderTime = 0.5f;
    private float triggerColliderTimer;

    [SerializeField]
    List<CharacterDummy> specificPositions = new List<CharacterDummy>();

    [SerializeField, Range(0, 1)]
    float roaming = 0.0f;
    float roaming_seed = 0.0f;

    [Header("Direct Show Player")]
    [SerializeField]
    bool isStandbyLoop = true;
    public DShowClip standbyClip;
    public List<DShowClip> triggerClips = new List<DShowClip>();
    int trigger_clip_index = 0;
    [SerializeField]
    private DShowMoviePlayer[] players;
    //private MeshRenderer m_meshRender;
    public Color color;
    private bool isSleep;

    public float videoStopTime = 1.5f;

    const int TRIGGER = 0;
    const int STANDBY = 1;

    int Status { get { return System.Convert.ToInt32(standby); } }


    List<MeshRenderer> renderers;
    
    

    private void Awake()
    {
        renderers = new List<MeshRenderer>();
        renderers.AddRange(GetComponentsInChildren<MeshRenderer>());
        if (renderers.Count != 2)
            Debug.LogWarningFormat("{0} renderer count is {1}", gameObject.name, renderers.Count);
        //m_meshRender = GetComponent<MeshRenderer>();
        //mat = new Material(Shader.Find("Unlit/ColorTransparent"));
        //m_meshRender.material = mat;


        origin_height = transform.position.y;

        InitialiseDSPlayer();
    }

    void InitialiseDSPlayer()
    {
        CreateDSPlayer(triggerClips[0]);
        CreateDSPlayer(standbyClip);
        players = GetComponentsInChildren<DShowMoviePlayer>();
    }

    void CreateDSPlayer(DShowClip clip)
    {
        GameObject triggerObj = new GameObject(clip.name);
        triggerObj.transform.parent = this.transform;
        var player = triggerObj.AddComponent<DShowMoviePlayer>();
        player.VideoAsset = clip;
        player.Load();
    }

    void InitialTouchButton()
    {
        if (fakeButton != null)
            return;
        GameObject obj = new GameObject(gameObject.name);
        obj.transform.parent = GameObject.Find("Final Canvas").transform;
        fakeButton = obj.AddComponent<RectTransform>();
        fakeButton.anchorMin = new Vector2(0, 0);
        fakeButton.anchorMax = new Vector2(0, 0);
        fakeButton.pivot = new Vector2(0.5f, 0.5f);
        var standby_scale = renderers[STANDBY].transform.localScale;
        fakeButton.sizeDelta = new Vector2(standby_scale.x, standby_scale.y) * FrozenScreenToWorldSpace.Instance.finalPixelsByMeter;
        fakeButton.anchoredPosition3D = new Vector3(0, 0, 0);
        fakeButton.localScale = Vector3.one;
        fakeButton.gameObject.AddComponent<RawImage>();
        fakeButton.GetComponent<RawImage>().color = new Color(1, 1, 1, 0);
        TouchArea touch_area = fakeButton.gameObject.AddComponent<TouchArea>();
        touch_area.PointerDown.AddListener((data) => { Trigger(data); });
        touch_area.PointerDrag.AddListener((data) => { Trigger(data); });
    }

    private void Start()
    {
        foreach (var rdr in renderers)
        {
            //rdr.sharedMaterial = new Material(rdr.sharedMaterial);
            rdr.material.mainTextureScale = new Vector2(1, -1);
            rdr.material.mainTextureOffset = new Vector2(0, -1);
        }
    }

    private void OnEnable()
    {
        standby = true;
        isSleep = false;
        StartCoroutine(PlayStandbyOnStart());
        InitialTouchButton();
        StartCoroutine(RandomPosNoTriggerOther());
        color = new Color(1, 1, 1, 0);
        StartCoroutine(Sleep());
        if (fakeButton != null)
            fakeButton.gameObject.SetActive(true);
    }

    private void OnDisable()
    {
        if (fakeButton != null)
            fakeButton.gameObject.SetActive(false);
    }

    IEnumerator PlayStandbyOnStart()
    {
        DShowMoviePlayer player = CurrentPlayer;
        player.Loop = isStandbyLoop;
        while (!player.IsPlaying)
        {
            player.Play();
            renderers[STANDBY].material.mainTexture = player.Texture;
            yield return null;
        }
    }
    
    void Update()
    {
        /*
        if (Input.GetKeyDown(KeyCode.R))
        {
            if (!isTriggerCollider)
                StartCoroutine(RandomPosNoTriggerOther());
        }  
        */
        UpdateMaterial();

        if (isSleep == false)
        {
            if (standby == false)
            {
                CheckPlayFinished();

                var mat = renderers[STANDBY].material;
                float a = Mathf.Lerp(mat.color.a, 0.0f, Time.deltaTime);
                mat.color = new Color(1, 1, 1, a);
            }
            else if (standby && roaming > 0.0f)
            {
                UpdateRoamingPosition();
                UpdateWallRoiFromPosition();
                UpdateButtonPos();
            }
                
        }

        if (isTriggerCollider)
            CheckTriggerCollider();
    }

    void CheckTriggerCollider()
    {
        triggerColliderTimer -= Time.deltaTime;
        if (triggerColliderTimer <= 0)
            isTriggerCollider = false;
    }

    void UpdateRoamingPosition()
    {
        float noise = Mathf.PerlinNoise(Time.time * 0.4f, roaming_seed) > 0.5f ? 1.0f : -1.0f;
        noise *= roaming * Time.deltaTime;
        //float padding = transform.localScale.x * 0.5f;
        float padding = renderers[TRIGGER].transform.localScale.x * 0.5f;
        Vector3 pos = transform.position;
        switch (area)
        {
            case Area.TopWall:
                {
                    float minmax = Mathf.Abs(padding - FrozenScreenToWorldSpace.Instance.width * 0.5f);
                    float x = Mathf.Clamp(pos.x + noise, -minmax, minmax);
                    transform.position = new Vector3(x, pos.y, pos.z);
                }
                break;
            case Area.LeftWall:
            case Area.RightWall:
                {
                    float minmax = Mathf.Abs(padding - FrozenScreenToWorldSpace.Instance.length * 0.5f);
                    float z = Mathf.Clamp(pos.z + noise, -minmax, minmax);
                    transform.position = new Vector3(pos.x, pos.y, z);
                }
                break;
        }
    }

    void UpdateMaterial()
    {
        var mat = CurrentRenderer.material;
        mat.mainTexture = CurrentPlayer.Texture;
        mat.SetColor("_Color", color);
    }

    void CheckPlayFinished()
    {
        if (CurrentPlayer.IsFinished)
        {
            StartCoroutine(Sleep());
        }
    }

    void RandomAppearWall()
    {
        Vector3 newPos = Vector3.zero;
        area = AppearArea[Random.Range(0, AppearArea.Count)];
        Quaternion q = new Quaternion();
        if (area == Area.LeftWall)
        {
            newPos.x = -FrozenScreenToWorldSpace.Instance.width / 2;
            q.SetLookRotation(Vector3.left);
        }
        if (area == Area.RightWall)
        {
            newPos.x = FrozenScreenToWorldSpace.Instance.width / 2;
            q.SetLookRotation(Vector3.right);
        }
        if (area == Area.TopWall)
        {
            newPos.z = FrozenScreenToWorldSpace.Instance.length / 2;
            q.SetLookRotation(Vector3.forward);
        }
        transform.rotation = q;
        transform.position = newPos + FrozenScreenToWorldSpace.Instance.Position;
        RandomPos();
    }

    void RandomPos()
    {
        float minX = renderers[TRIGGER].transform.localScale.x / 2;
#if true
        switch (area)
        {
            case Area.TopWall:
                wallRoi.x = Random.Range(minX, FrozenScreenToWorldSpace.Instance.width - minX) / FrozenScreenToWorldSpace.Instance.width;
                break;
            case Area.LeftWall:
            case Area.RightWall:
                wallRoi.x = Random.Range(minX, FrozenScreenToWorldSpace.Instance.length - minX) / FrozenScreenToWorldSpace.Instance.length;
                break;
        }
#else
        Vector3 randomPos = transform.localPosition;
        if (randomPos.x == 0)
            wallRoi.x = Random.Range(minX, FrozenScreenToWorldSpace.Instance.width - minX) / FrozenScreenToWorldSpace.Instance.width;
        else
            wallRoi.x = Random.Range(minX, FrozenScreenToWorldSpace.Instance.length - minX) / FrozenScreenToWorldSpace.Instance.length;
#endif
        wallRoi.y = origin_height / FrozenScreenToWorldSpace.Instance.height;
        UpdatePos();
        UpdateButtonPos();
    }

    void UpdatePos()
    {
#if true
        Vector3 n_pos = transform.position;
        switch (area)
        {
            case Area.TopWall:
                n_pos.x = Mathf.Lerp(-FrozenScreenToWorldSpace.Instance.width / 2, FrozenScreenToWorldSpace.Instance.width / 2, wallRoi.x);
                break;
            case Area.LeftWall:
            case Area.RightWall:
                n_pos.z = Mathf.Lerp(-FrozenScreenToWorldSpace.Instance.length / 2, FrozenScreenToWorldSpace.Instance.length / 2, wallRoi.x);
                break;
        }
        n_pos.y = Mathf.Lerp(0.0f, FrozenScreenToWorldSpace.Instance.height, wallRoi.y);
        transform.position = n_pos + FrozenScreenToWorldSpace.Instance.Position;
#else
        Vector3 n_pos = transform.localPosition;

        if (area == Area.TopWall)
            n_pos.x = Mathf.Lerp(-FrozenScreenToWorldSpace.Instance.width / 2, FrozenScreenToWorldSpace.Instance.width / 2, wallRoi.x);
        else
            n_pos.z = Mathf.Lerp(-FrozenScreenToWorldSpace.Instance.length / 2, FrozenScreenToWorldSpace.Instance.length / 2, wallRoi.x);
        n_pos.y = Mathf.Lerp(0, (float)FrozenScreenToWorldSpace.Instance.height, wallRoi.y);
        transform.localPosition = n_pos;
#endif
        //SetButtonPos();
    }

    void UpdateButtonPos()
    {
        //Vector2 newScreenPos = FrozenScreenToWorldSpace.Instance.GetFinalScreenPos(area, wallRoi);
        var roi = FrozenScreenToWorldSpace.Instance.GetWallRoiFromPosition(area, renderers[STANDBY].transform.position);
        Vector2 newScreenPos = FrozenScreenToWorldSpace.Instance.GetFinalScreenPos(area, roi);
        fakeButton.anchoredPosition = newScreenPos;
    }

    void SetSpecificPos()
    {
        int pos_index = Random.Range(0, specificPositions.Count);
        var dummy = specificPositions[pos_index];
        area = dummy.area;
        transform.position = dummy.transform.position;
        transform.rotation = dummy.transform.rotation;
        UpdateWallRoiFromPosition();
        UpdateButtonPos();
    }

    void UpdateWallRoiFromPosition()
    {
        wallRoi = FrozenScreenToWorldSpace.Instance.GetWallRoiFromPosition(area, transform.position);
    }

    private void Trigger(PointerEventData data)
    {
        if (!standby || isSleep)
            return;
        standby = false;
        CurrentPlayer.Play();
        CurrentRenderer.material.mainTexture = CurrentPlayer.Texture;
    }

    void Idle()
    {
        standby = true;
        CurrentPlayer.Play();
    }

    DShowMoviePlayer CurrentPlayer { get { return players[Status]; } }
    MeshRenderer CurrentRenderer { get { return renderers[Status]; } }

    IEnumerator Sleep()
    {
        standby = false;
        isSleep = true;
        yield return StartCoroutine(WaitVideoStopTimeFadeOut());
        yield return new WaitForSeconds(GetDisappear());
        yield return StartCoroutine(RandomPosNoTriggerOther());
        yield return StartCoroutine(WaitVideoStandbyFadeIn());
        isSleep = false;
        Idle();
    }

    IEnumerator Fade(float targetA)
    {
        float value = 0;
        float origin = color.a;
        while (value < 1)
        {
            value = Mathf.Clamp(value + Time.deltaTime, 0, 1);
            color.a = Mathf.Lerp(origin, targetA, value);
            yield return null;
        }
        color.a = targetA;
    }

    IEnumerator WaitVideoStandbyFadeIn()
    {
        standby = true;
        CurrentPlayer.Play();
        CurrentRenderer.material.mainTexture = CurrentPlayer.Texture;
        yield return StartCoroutine(Fade(1));
    }

    IEnumerator WaitVideoStopTimeFadeOut()
    {
        yield return new WaitForSeconds(videoStopTime);
        yield return StartCoroutine(Fade(0));
        CurrentPlayer.Pause();
        CurrentPlayer.Frame = 0;
    }


    public bool isTriggerCollider;

    private void OnTriggerExit(Collider other)
    {
        isTriggerCollider = false;
    }

    void OnTriggerStay(Collider other)
    {
        isTriggerCollider = true;
        triggerColliderTimer = checktriggerColliderTime;
    }

    private void OnTriggerEnter(Collider other)
    {
        isTriggerCollider = true;
        triggerColliderTimer = checktriggerColliderTime;
    }


    public float GetDisappear()
    {
        return disappearTime;
        /*
        float distime = disappearTime - Random.Range(0, disappearTime / 2);
        distime = disappearTime * distime - distime * distime + 0.5f * distime;
        return distime;
        */
    }

    IEnumerator RandomPosNoTriggerOther()
    {
        if (specificPositions.Count > 0)
        {
            SetSpecificPos();
            yield return null;
        }
        else
        {
            RandomAppearWall();
            yield return new WaitForSeconds(0.1f);
            while (isTriggerCollider)
            {
                RandomAppearWall();
                yield return null;
            }
        }
        
        roaming_seed = Random.Range(0.0f, 1.0f);

        trigger_clip_index = ++trigger_clip_index % triggerClips.Count;
        players[0].VideoAsset = triggerClips[trigger_clip_index];

        yield return null;
    }
}