using System.Collections; 
 | 
using System.Collections.Generic; 
 | 
using UnityEngine; 
 | 
using vnxbqy.UI; 
 | 
  
 | 
public class CreateRoleBehaviour 
 | 
{ 
 | 
    public State state { get; private set; } 
 | 
  
 | 
    CreateRoleTimeLine showTimeLine = new CreateRoleTimeLine(); 
 | 
    List<SFXController> sfxControllers = new List<SFXController>(); 
 | 
  
 | 
    GameObject behaviour; 
 | 
    ActorShadowCaster shadow; 
 | 
    CreateRoleHeroPlatform platform; 
 | 
  
 | 
    public void Show(CreateRoleScriptableObject.RoleShowParams showParams) 
 | 
    { 
 | 
        if (behaviour == null) 
 | 
        { 
 | 
            var prefab = SceneLoader.LoadCreateRole(showParams.platformPrefabName); 
 | 
            behaviour = GameObject.Instantiate(prefab, showParams.platformPosition, Quaternion.identity); 
 | 
            behaviour.name = showParams.platformPrefabName; 
 | 
            shadow = behaviour.GetComponentInChildren<ActorShadowCaster>(); 
 | 
            platform = behaviour.GetComponentInChildren<CreateRoleHeroPlatform>(); 
 | 
            platform.transform.localScale = showParams.platformScale; 
 | 
            var camera = behaviour.GetComponent<Camera>("CreateRoleCamera"); 
 | 
            if (camera != null) 
 | 
            { 
 | 
                camera.SetActive(false); 
 | 
            } 
 | 
        } 
 | 
  
 | 
        shadow.SetActive(false); 
 | 
        platform.transform.localEulerAngles = new Vector3(0, 180, 0); 
 | 
        platform.ForbidSeconds(showParams.animationDuration); 
 | 
        CreateRoleManager.Instance.LoadModel(showParams.job, (bool ok, UnityEngine.Object @object) => 
 | 
        { 
 | 
            if (ok) 
 | 
            { 
 | 
                var model = @object as GameObject; 
 | 
                model.transform.SetParentEx(platform.transform, Vector3.zero, Quaternion.identity, Vector3.one * showParams.scale); 
 | 
  
 | 
                switch (showParams.enterPictureType) 
 | 
                { 
 | 
                    case CreateRoleScriptableObject.EnterPictureType.OutIn: 
 | 
                        model.SetActive(false); 
 | 
                        break; 
 | 
                    case CreateRoleScriptableObject.EnterPictureType.Stand: 
 | 
                        model.SetActive(true); 
 | 
                        shadow.SetActive(true); 
 | 
                        shadow.Cast(model.transform); 
 | 
                        break; 
 | 
                } 
 | 
  
 | 
                ReleaseEffects(); 
 | 
                state = State.RoutimeShow; 
 | 
  
 | 
                showTimeLine.ClearNode(); 
 | 
                showTimeLine.AddNone(0f, () => 
 | 
                { 
 | 
                    if (showParams.enterPictureType == CreateRoleScriptableObject.EnterPictureType.OutIn) 
 | 
                    { 
 | 
                        model.SetActive(true); 
 | 
                    } 
 | 
  
 | 
                    var animator = model.GetComponent<Animator>(); 
 | 
                    animator.Play(showParams.animation); 
 | 
                }); 
 | 
  
 | 
                showTimeLine.AddNone(0.1f, () => 
 | 
                { 
 | 
                    if (showParams.enterPictureType == CreateRoleScriptableObject.EnterPictureType.OutIn) 
 | 
                    { 
 | 
                        shadow.SetActive(true); 
 | 
                        shadow.Cast(model.transform); 
 | 
                    } 
 | 
                }); 
 | 
  
 | 
                foreach (var effect in showParams.persistentEffects) 
 | 
                { 
 | 
                    showTimeLine.AddNone(0f, () => 
 | 
                    { 
 | 
                        PlayEffect(model.transform, effect); 
 | 
                    }); 
 | 
                } 
 | 
  
 | 
                showTimeLine.AddNone(0f, () => 
 | 
                { 
 | 
                    PlayEffect(model.transform, showParams.showEffect); 
 | 
                }); 
 | 
  
 | 
                showTimeLine.AddNone(2f, () => 
 | 
                { 
 | 
                    WindowCenter.Instance.Open<CreateRoleWin>(); 
 | 
                }); 
 | 
  
 | 
                showTimeLine.OnComplete(() => { state = State.Idle; }); 
 | 
                showTimeLine.Begin(); 
 | 
            } 
 | 
        }); 
 | 
    } 
 | 
  
 | 
    public void SetActive(bool active) 
 | 
    { 
 | 
        if (behaviour != null) 
 | 
        { 
 | 
            behaviour.transform.SetActive(active); 
 | 
        } 
 | 
    } 
 | 
  
 | 
    public void Dispose() 
 | 
    { 
 | 
        showTimeLine.Dispose(); 
 | 
        ReleaseEffects(); 
 | 
  
 | 
        showTimeLine = null; 
 | 
        behaviour = null; 
 | 
        shadow = null; 
 | 
        platform = null; 
 | 
    } 
 | 
  
 | 
    public void ReleaseEffects() 
 | 
    { 
 | 
        for (var i = sfxControllers.Count - 1; i >= 0; i--) 
 | 
        { 
 | 
            SFXPlayUtility.Instance.Release(sfxControllers[i]); 
 | 
        } 
 | 
  
 | 
        sfxControllers.Clear(); 
 | 
    } 
 | 
  
 | 
    private void PlayEffect(Transform model, int effectId) 
 | 
    { 
 | 
        var config = EffectConfig.Get(effectId); 
 | 
        Transform parent = null; 
 | 
        if (!string.IsNullOrEmpty(config.nodeName)) 
 | 
        { 
 | 
            parent = model.transform.GetChildTransformDeeply(config.nodeName); 
 | 
        } 
 | 
        else 
 | 
        { 
 | 
            parent = model.transform; 
 | 
        } 
 | 
  
 | 
        sfxControllers.Add(SFXPlayUtility.Instance.Play(effectId, parent)); 
 | 
    } 
 | 
  
 | 
    public enum State 
 | 
    { 
 | 
        Idle, 
 | 
        EnterShow, 
 | 
        RoutimeShow, 
 | 
    } 
 | 
  
 | 
} 
 |