仿LOL项目开发第六天

仿LOL项目开发第六天

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　by草帽

OK，因为更新模块已经处理好了，接着开始登陆的编写。那么我们就需要状态机的管理。

所谓状态机就是在哪个状态执行那个状态的代码逻辑：

那么我们开始编写GameStateManager来管理:

我们先在DefineCommon里面定义游戏状态类型：

    /// <summary>
    /// 游戏状态
    /// </summary>
    public enum GameStateType
    {
        GS_Continue,//中间状态，也就是说介于两个状态转换的中间状态
        GS_Login,//登陆状态
        GS_User,//创建用户状态
        GS_Lobby,//大厅，类似于LOL主界面状态
        GS_Room,//创建房间状态
        GS_Hero,//选择英雄
        GS_Loading,//加载状态
        GS_Play,//对战状态
        GS_Over,//对战结束
    }

有分这么多个状态，如果还有其他状态以后再加：

然后在GameStateManager里面搞个字典缓存这些状态。这个管理方式和WindowManage十分的相似。

using UnityEngine;
using System.Collections.Generic;
using Game;
using Game.Common;
/// <summary>
/// 游戏状态管理器
/// </summary>
public class GameStateManager : Singleton<GameStateManager>
{
    public Dictionary<GameStateType, IGameState> m_dicGameStates;
    IGameState m_oCurrentState;

    public IGameState CurrentState 
    {
        get { return this.m_oCurrentState; }
    }
    public GameStateManager()
    {
        m_dicGameStates = new Dictionary<GameStateType, IGameState>();
        m_dicGameStates.Add(GameStateType.GS_Login, new LoginState());
    }
    /// <summary>
    /// 改变游戏状态
    /// </summary>
    /// <param name="stateType"></param>
    public void ChangeGameStateTo(GameStateType stateType)
    {
        if (m_oCurrentState != null && m_oCurrentState.GetStateType() != GameStateType.GS_Loading && m_oCurrentState.GetStateType() == stateType)
            return;

        if (m_dicGameStates.ContainsKey(stateType))
        {
            if (m_oCurrentState != null)
            {
                m_oCurrentState.Exit();//先退出上个状态
            }

            m_oCurrentState = m_dicGameStates[stateType];
            m_oCurrentState.Enter();//进入这个状态
        }
    }
    /// <summary>
    /// 进入默认状态，默认为登陆状态
    /// </summary>
    public void EnterDefaultState()
    {
        ChangeGameStateTo(GameStateType.GS_Login);
    }
    public void FixedUpdate(float fixedDeltaTime)
    {
        if (m_oCurrentState != null)
        {
            m_oCurrentState.FixedUpdate(fixedDeltaTime);
        }
    }
    public void Update(float fDeltaTime)
    {
        GameStateType nextStateType = GameStateType.GS_Continue;
        if (m_oCurrentState != null)
        {
            nextStateType = m_oCurrentState.Update(fDeltaTime);
        }

        if (nextStateType > GameStateType.GS_Continue)
        {
            ChangeGameStateTo(nextStateType);
        }
    }
    public IGameState getState(GameStateType type)
    {
        if (!m_dicGameStates.ContainsKey(type))
        {
            return null;
        }
        return m_dicGameStates[type];
    }
}

我们抽象出所有的状态公有的方法属性：IGameState接口：

也符合面向接口编程原则。好处我之前讲过了。

IGameState：

using UnityEngine;
using System.Collections;
using Game.Common;
/// <summary>
/// 游戏状态接口
/// </summary>
public interface IGameState
{
    GameStateType GetStateType();//获取实现类的状态类型
    void SetStateTo(GameStateType gsType);//设置实现类的状态类型（改变状态）
    void Enter();//进入实现类的状态，做主要状态的逻辑处理
    GameStateType Update(float fDeltaTime);//状态改变，返回改变后的状态
    void FixedUpdate(float fixedDeltaTime);//固定更新状态
    void Exit();//退出该状态
}

然后编写实现接口的子实现类，这里我们先写LoginState：

using UnityEngine;
using System.Collections;
using Game.Common;
/// <summary>
/// 登陆游戏状态
/// </summary>
public class LoginState : IGameState
{
    GameStateType m_eStateTo;
    public LoginState()
    {
 
    }
    public GameStateType GetStateType() 
    {
        return GameStateType.GS_Login;
    }
    public void SetStateTo(GameStateType stateType)
    {
        this.m_eStateTo = stateType;
    }
    public void Enter()
    {
        SetStateTo(GameStateType.GS_Continue);
        LoginCtrl.singleton.Enter();
    }
    public void Exit()
    {
        LoginCtrl.singleton.Exit();
    }
    public void FixedUpdate(float fixedDeltaTime)
    {
 
    }
    public GameStateType Update(float fDeltaTime)
    {
        return m_eStateTo;
    }
}

然后在GameStateManager的构造方法，添加到缓存字典里面。

OK，这个状态机，假如说我们调用GameStateManager的ChangeStateTo（你想要的状态类型），那么就会执行你想要的状态实现类的Enter方法。

所以我们在LoginState的Enter编写我们登陆的逻辑，因为LoginState主要是管理状态改变的，所以我们为了类的单一职责，吧所有登陆逻辑放在：LoginCtrl控制类里面。

    public void Enter()
    {
        SetStateTo(GameStateType.GS_Continue);//先转到中间状态
        LoginCtrl.singleton.Enter();
    }

LoginCtrl:

OK，写到这里，我们之后当我知道版本更新完成或者根本不需要更新，就直接弹出登陆UI的用户名输入框界面。

那么，我们就得写个LoginWindow来管理登陆UI，所以先写LoginWindow：

using UnityEngine;
using System.Collections;
using Game.Common;
using Utility;
using System;
/// <summary>
/// 登陆界面UI
/// </summary>
public class LoginWindow : BaseWindow 
{
    public LoginWindow()
    {
        this.mResName = "Guis/LoginWindow";
        this.mResident = false;
    }
    public override void Init()
    {
        EventCenter.AddListener(EGameEvent.eGameEvent_LoginEnter, Show);
        EventCenter.AddListener(EGameEvent.eGameEvent_LoginExit, Hide);
    }
    public override void Realse()
    {
        EventCenter.RemoveListener(EGameEvent.eGameEvent_LoginEnter, Show);
        EventCenter.RemoveListener(EGameEvent.eGameEvent_LoginExit,Hide);
    }
    protected override void InitWidget()
    {

    }
    protected override void RealseWidget()
    {
        
    }
    protected override void OnAddListener()
    {

    }
    protected override void OnRemoveListener()
    {
        
    }
    public override void OnEnable()
    {
        
    }
    public override void OnDisable()
    {
        
    }
    public override void Update(float deltaTime)
    {
        base.Update(deltaTime);
    }
}

OK，我们在LoginWindow里面添加显示登陆界面和隐藏登陆界面事件监听。

首先，我们知道，玩LOL的时候，当我们登陆成功之后，还要选择游戏大区服务器。所以我们把选择服务器归入到登陆界面来管理。

所以我们还是需要制作一个SelectServer界面，这里我也随便搞了下界面：

未完待续。。。。。。没时间以后继续

OK，终于暑假了，又有时间来写了，隔了好久的时间，我可能落下很多步骤，如果有不明白的童鞋，欢迎在下方留言。

接着讲，我们选择服务器的界面还没有制作，所以首先我们先来制作这个界面。

粗略的看下这界面的结构：

1.背景图片

2.左边的服务器列表

3.右边的图标和各个按钮

4.蓝色的服务器背景

大致就是这些，OK，我们看下Unity中的Hire窗口物体结构：

我们着重来看下ServerList的制作，其他的读者可以自行理解，然后搭建起来。

首先来看下ServerList：

我将他分为两个部分，第一个部分是上面的推荐服，第二个部分是下面的电信联通具体服。

制作好之后，吧他拖到Prefabs文件夹下面，然后拖到我们之前做好的登陆界面当做子物体。

然后把他的Panel设置为不激活状态。因为我们默认进入到登陆界面只显示输入用户名和密码，不显示选择服务器界面。等到我们正确的验证密码之后，然后才进入到选择服务器界面。

OK，大致的界面讲解完成了，我们开始写代码。在写代码之前，先来分析下看，因为这个服务器动态的，也就是说假如一个服务器进行维护或者繁忙，我们这边应该实时的知道。

所以，当我们进入到选择服务器界面的时候，应该接收到服务器发送来的服务器实时的数据信息，然后客户端才动态加载这些服务器列表。

所以我们代码怎么写？怎么样才能做到动态加载不确定数量的服务器列表。这里NGUI的UITable和UIGrid有点坑，我们如果想实例化一个子物体给UITable，他是不会动态刷新的，所以我决定自己再封装一层NGUI的代码，形成自己的一套UI管理。

我们在Window文件夹下面，新建一个UIObject文件夹，里面存放着所以和UI相关的接口和类，如XUISprite.cs实际上就是封装的NGUi的UISprite脚本。

可以看到我已经封装了这么多，可能有些童鞋会问了，既然NGui的都可以用，为什么还这么麻烦，自己封装一层。

这个封装确实很有必要：

1.方便操作，可以根据我们需要的功能进行扩展。就拿这个UITable来说，如果我们需要实时更新里面的Item，我们每在一处添加，都要得写好多代码，如果我们封装起来，一个方法就搞定。

2.可扩展性强。可以看到我们每个UI都有自己的一个接口，实现了依赖倒置原则。如果我们想要使用UGUi作为UI框架，我们只需要修改下，底层的代码，高层调用者就不需要改动代码，如果不使用的话，高层要高到死为止。

好处大致就是这么多。OK，我先来贴贴代码，我把所有的代码贴出来：

IXUIObject.cs

 

using UnityEngine;
using System.Collections;
/// <summary>
/// 所有UI物体公共的接口
/// </summary>
public interface IXUIObject
{
    Transform CacheTransform
    {
        get;
    }
    GameObject CacheGameObject
    {
        get;
    }
    IXUIObject Parent
    {
        get;
        set;
    }
    string Tip
    {
        get;
        set;
    }
    object TipParam
    {
        get;
        set;
    }
    bool IsVisible();
    void SetVisible(bool bVisible);
    IXUIObject GetUIObject(string strPath);
    void Highlight(bool bTrue);
}

XUIObjectBase.cs:

 

using UnityEngine;
using System.Collections;
/// <summary>
/// 继承MOnoBehavior的UI物体
/// </summary>
public abstract class XUIObjectBase : MonoBehaviour,IXUIObject 
{
    private bool m_bInit = false;
    public string m_strTipText = "";
    protected float m_fAlpha = 1f;
    private Transform m_cacheTransform;
    private GameObject m_cacheGameObject;
    private IXUIObject m_parent;
    public Transform CacheTransform
    {
        get 
        {
            if (this.m_cacheTransform == null) 
            {
                this.m_cacheTransform = base.transform;
            }
            return this.m_cacheTransform;
        }
    }
    public GameObject CacheGameObject
    {
        get 
        {
            if (this.m_cacheGameObject == null)
            {
                this.m_cacheGameObject = base.gameObject;
            }
            return this.m_cacheGameObject;
        }
    }
    public object TipParam
    {
        get;
        set;
    }
    public string Tip 
    {
        get { return this.m_strTipText; }
        set { this.m_strTipText = value; }
    }
    public virtual float Alpha 
    {
        get 
        {
            return this.m_fAlpha;
        }
        set 
        {
            this.m_fAlpha = value;
        }
    }
    public virtual IXUIObject Parent 
    {
        get 
        {
            return this.m_parent;
        }
        set 
        {
            this.m_parent = value;
        }
    }
    public bool IsInited 
    {
        get { return this.m_bInit; }
        set { this.m_bInit = value; }
    }
    public virtual void Init()
    {
        this.m_bInit = true;
    }
    public bool IsVisible()
    {
        return base.gameObject.activeInHierarchy;
    }
    public virtual void SetVisible(bool bVisible)
    {

    }
    public virtual void Highlight(bool bTrue)
    {
 
    }
    public virtual IXUIObject GetUIObject(string strPath) 
    {
        return null;
    }
    public virtual void OnAwake()
    {

    }
    public virtual void OnStart()
    {
 
    }
    public virtual void OnUpdate()
    {
 
    }
    public virtual void _OnClick()
    {
 
    }
    private void Awake()
    {
        OnAwake();
    }
    private void Start()
    {
        if (!this.m_bInit)
        {
            Init();
        }
        OnStart();
    }
    private void Update()
    {
        OnUpdate();
    }
    private void OnClick()
    {
        this._OnClick();
    }
    private void OnEnable()
    {
 
    }
    private void OnDisable()
    {
 
    }
}

这个脚本是每个UI必须的，比如NGUi的脚本都是挂在UI物体上的。所以我们自己封装的脚本也是如此。

注意到没有中间有用到：

TipParam：这个是提示参数类

 

using UnityEngine;
using System.Collections;
using Game.Common;
/// <summary>
/// 提示参数类
/// </summary>
public class TipParam 
{
    //提示信息
    public string Tip
    {
        get;
        set;
    }
    //提示类型，有普通提示（技能装备等）和标题提示（没有带复杂内容，只有一行字）
    public TipEnumType TipType
    {
        get;
        set;
    }
    public TipParam()
    {
        TipType = TipEnumType.eTipType_Common;
    }
}

这个主要是处理界面提示用的。

XUIObject.cs:

 

using UnityEngine;
using System.Collections;

public abstract class XUIObject : XUIObjectBase
{
    public override void OnAwake()
    {
        base.OnAwake();
    }
    public override void OnStart()
    {
        base.OnStart();
    }
    public override void OnUpdate()
    {
        base.OnUpdate();
    }
    public override void Init()
    {
        base.Init();
    }
    public override void SetVisible(bool bVisible)
    {
        NGUITools.SetActiveSelf(base.gameObject, bVisible);
    }
}

OK,我们开始写具体的UI类：先写UIList和UIListItem也就是Table或者Grid他对应着UIList，他下面的子物体对应着UIListItem。

由于UIListItem可能他的子物体有UISprite和UILabel等等，所以我们在写他之前先写UISprite：

因为我们写程序最好要依赖接口编程，所以写个IXUISprite接口：

 

using UnityEngine;
using System.Collections;

public interface IXUISprite : IXUIObject
{
    Color Color
    {
        get;
        set;
    }
    string SpriteName
    {
        get;
    }
    IXUIAtlas UIAtlas
    {
        get;
    }
    /// <summary>
    /// 播放UI动画
    /// </summary>
    /// <param name="bLoop"></param>
    /// <returns></returns>
    bool PlayFlash(bool bLoop);
    void SetEnable(bool bEnable);
    /// <summary>
    /// 设置UISprite
    /// </summary>
    /// <param name="strSpriteName"></param>
    /// <returns></returns>
    bool SetSprite(string strSpriteName);
    bool SetSprite(string strSpriteName, string strAtlas);
    /// <summary>
    /// 停止UI动画
    /// </summary>
    /// <returns></returns>
    bool StopFlash();
}　　

 

 注意到没有，我们Sprite可能会用到UIAtlas，所以我们得再写个UIAtlas：

IXUIAtlas：

 

using UnityEngine;
using System.Collections;
public interface IXUIAtlas
{   
    UIAtlas Atlas
    {
        get;
        set;
    }
}

XUIAtlas:

 

using UnityEngine;
using System.Collections;

public class XUIAtlas : MonoBehaviour,IXUIAtlas
{
    private UIAtlas m_uiAtlas;
    public UIAtlas Atlas 
    {
        get
        {
            return this.m_uiAtlas;
        }
        set
        {
            this.m_uiAtlas = value;
        }
    }
    private void Awake()
    {
        this.m_uiAtlas = base.GetComponent<UIAtlas>();
        if (null == this.m_uiAtlas)
        {
            Debug.LogError("null == m_uiAtlas");
        }
    }
}

XUISprite:

 

using UnityEngine;
using System.Collections;
using Game.Common;
[AddComponentMenu("XUI/XUISprite")]
public class XUISprite : XUIObject,IXUIObject,IXUISprite
{
    private string m_spriteNameCached = string.Empty;
    private string m_atlasNameCached = string.Empty;
    private UISprite m_uiSprite;
    private UISpriteAnimation m_uiSpriteAnimation;
    private ResourceUnit m_oAltasUnit;
    private IXLog m_log = XLog.GetLog<XUISprite>();
    public override float Alpha
    {
        get
        {
            if (null != this.m_uiSprite)
            {
                return this.m_uiSprite.alpha;
            }
            return 0f;
        }
        set
        {
            if (null != this.m_uiSprite)
            {
                this.m_uiSprite.alpha = value;
            }
        }
    }
    public Color Color 
    {
        get 
        {
            if (this.m_uiSprite != null)
            {
                return this.m_uiSprite.color;
            }
            return Color.white;
        }
        set 
        {
            if (this.m_uiSprite != null)
            {
                this.m_uiSprite.color = value;
            }
        }
    }
    public string SpriteName
    {
        get
        {
            if (null != this.m_uiSprite)
            {
                return this.m_uiSprite.spriteName;
            }
            return null;
        }
    }
    public IXUIAtlas UIAtlas 
    {
        get 
        {
            if (null == this.m_uiSprite)
            {
                return null;
            }
            if (null == this.m_uiSprite.atlas)
            {
                return null;
            }
            return this.m_uiSprite.atlas.GetComponent<XUIAtlas>();
        }
    }


    public override void Init()
    {
        base.Init();
        this.m_uiSprite = base.GetComponent<UISprite>();
        if (null == this.m_uiSprite)
        {
            Debug.LogError("null == m_uiSprite");
        }
        this.m_uiSpriteAnimation = base.GetComponent<UISpriteAnimation>();
    }
    /// <summary>
    /// 播放动画
    /// </summary>
    /// <param name="bLoop"></param>
    /// <returns></returns>
    public bool PlayFlash(bool bLoop)
    {
        if (null == this.m_uiSpriteAnimation)
        {
            return false;
        }
        this.m_uiSpriteAnimation.loop = bLoop;
        this.m_uiSpriteAnimation.ResetToBeginning();
        this.m_uiSpriteAnimation.enabled = true;
        this.m_uiSprite.enabled = true;
        return true;
    }
    /// <summary>
    /// 停止动画
    /// </summary>
    /// <returns></returns>
    public bool StopFlash()
    {
        if (null == this.m_uiSpriteAnimation)
        {
            return false;
        }
        this.m_uiSpriteAnimation.enabled = false;
        return true;
    }
    /// <summary>
    /// 设置UISprite
    /// </summary>
    /// <param name="strSprite"></param>
    /// <param name="strAltas"></param>
    /// <returns></returns>
    public bool SetSprite(string strSprite, string strAltas)
    {
        if (null == this.m_uiSprite)
        {
            return false;
        }
        //如果缓存图集已经存在了，那么就直接设置
        if (this.m_atlasNameCached.Equals(strAltas))
        {
            this.m_spriteNameCached = strSprite;
            this.m_uiSprite.spriteName = strSprite;
            this.m_uiSprite.enabled = true;
            return true;
        }
        this.m_spriteNameCached = strSprite;
        this.m_atlasNameCached = strAltas;
        this.PrepareAtlas(strAltas, strSprite);
        return true;
    }
    /// <summary>
    /// 设置默认图集的UISprite
    /// </summary>
    /// <param name="strSpriteName"></param>
    /// <returns></returns>
    public bool SetSprite(string strSpriteName)
    {
        if (null == this.m_uiSprite)
        {
            return false;
        }
        if (!string.IsNullOrEmpty(this.m_atlasNameCached))
        {
            this.SetSprite(this.m_atlasNameCached, strSpriteName);
        }
        else 
        {
            this.m_uiSprite.spriteName = strSpriteName;
        }
        return true;
    }
    public void SetEnable(bool bEnable)
    {
        Collider compent = base.GetComponent<Collider>();
        if (compent != null)
        {
            compent.enabled = bEnable;
        }
    }
    private void OnDestroy()
    {
        if (this.m_oAltasUnit != null)
        {
            this.m_oAltasUnit.Dispose();
            this.m_oAltasUnit = null;
        }
    }
    private void PrepareAtlas(string strAltas, string strSprite)
    {
        m_oAltasUnit = ResourceManager.Instance.LoadImmediate(strAltas, ResourceType.PREFAB);
        GameObject obj = m_oAltasUnit.Asset as GameObject;
        UIAtlas uiAtals = obj.GetComponent<UIAtlas>();
        if (null == uiAtals)
        {
            this.m_log.Error("加载图集的时候出错!!");
            return;
        }
        this.m_uiSprite.atlas = uiAtals;
        this.m_uiSprite.spriteName = strSprite;
        this.m_uiSprite.enabled = true;
    }
}

可以看到XUISprite提供4个主要接口：

1.SetSprite(string strSpriteName)---->设置Sprite，在默认的Alta中

2.SetSprite(string strSpriteName,string strAtlas)---->设置Sprite，在指定的Atlas中

3.PlayFlash(bool bLoop)---->是否播放UI帧动画

4.StopFlash()----->停止播放UI帧动画

写完Sprite之后，我们写

IXUIListItem：

 

using UnityEngine;
using System.Collections.Generic;
public interface IXUIListItem :IXUIObject
{
    int Id
    {
        get;
        set;
    }
    long GUID
    {
        get;
        set;
    }
    int Index
    {
        get;
        set;
    }
    bool IsSelected
    {
        get;
        set;
    }
    Dictionary<string, XUIObjectBase> AllXUIObject
    {
        get;
    }
    bool SetText(string strId,string strContent);
    void SetSelected(bool bTrue);
    void SetEnableSelect(bool bEnable);
    void SetIconSprite(string strSprite);
    void SetIconSprite(string strSprite, string strAtlas);
    void SetIconTexture(string strTexture);
    void SetColor(Color color);
    void SetEnable(bool bEnable);
    void Clear();
}

XUIListItem.cs：

 

using UnityEngine;
using System.Collections.Generic;
using UILib;
using Game.Common;
[AddComponentMenu("XUI/XUIListItem")]
public class XUIListItem : XUIObject,IXUIObject,IXUIListItem
{
    private UISprite m_uiSpriteIcon;
    private UILabel[] m_uiLabels;
    private UITexture m_uiTextureIcon;
    private UIButton m_uiButton;
    private UIToggle m_uiToggle;
    private UITexture[] m_uiTextures;
    private UISprite[] m_uiSprites;
    private XUISprite m_uiSpriteFlash;
    private Dictionary<string, XUIObjectBase> m_dicId2UIObject = new Dictionary<string, XUIObjectBase>();
    protected Collider m_colldier;
    private Color m_highlightColor = Color.clear;
    public int m_unId;
    private int m_unIndex = -1;
    private long m_GUID;


    public int Id 
    {
        get { return this.m_unId; }
        set 
        { 
            this.m_unId = value;
        }
    }
    public int Index 
    {
        get { return this.m_unIndex; }
        set { this.m_unIndex = value; }
    }
    public long GUID 
    {
        get { return this.m_GUID; }
        set { this.m_GUID = value; }
    }
    public XUIList ParentXUIList 
    {
        get 
        {
            XUIList xUIlist = this.Parent as XUIList;
            if (null == xUIlist)
            {
                Debug.LogError("null == uiList");
            }
            return xUIlist;
        }
    }
    public bool IsSelected 
    {
        get 
        {
            return this.m_uiToggle != null && this.m_uiToggle.value;
        }
        set
        {
            if (this.m_uiToggle != null && this.m_uiToggle.value != value)
            {
                this.m_uiToggle.Set(value);
                if (value)
                {
                    this.ParentXUIList.SelectItem(this, false);
                }else
                {
                    this.ParentXUIList.UnSelectItem(this, false);
                }
            }
        }
    }
    public Dictionary<string, XUIObjectBase> AllXUIObject
    {
        get { return this.m_dicId2UIObject; }
    }

    public void SetSelected(bool bTrue)
    {
        if (this.m_uiToggle != null && this.m_uiToggle.value != bTrue)
        {
            this.m_uiToggle.Set(bTrue);
        }
    }
    public void SetEnableSelect(bool bEnable)
    {
        if (!bEnable && this.m_uiToggle != null)
        {
            this.m_uiToggle.value = false;
        }
        this.Highlight(bEnable);
        if (this.m_uiToggle != null)
        {
            this.m_uiToggle.enabled = bEnable;
        }
    }
    private void OnSelectStateChange()
    {
        bool bSelected = this.m_uiToggle.value;
        if (bSelected)
        {
            //List选择该item
            this.ParentXUIList.OnSelectItem(this);
        }
        else 
        {
            //List不选择该item
            this.ParentXUIList.OnUnSelectItem(this);
        }
    }
    public void SetIconSprite(string strSprite)
    {
        if (null != this.m_uiSpriteIcon)
        {
            this.m_uiSpriteIcon.spriteName = strSprite.Substring(strSprite.LastIndexOf("\\") + 1);
            this.m_uiSpriteIcon.enabled = true;
        }
        XUISprite xUISprite = this.GetUIObject("Sprite_Icon") as XUISprite;
        if (null != xUISprite)
        {
            xUISprite.SetSprite(strSprite);
        }
    }
    public void SetIconSprite(string strSprite, string strAtlas)
    {
        XUISprite xUISprite = this.GetUIObject("Sprite_Icon") as XUISprite;
        if (null != xUISprite)
        {
            xUISprite.SetSprite(strSprite, strAtlas);
        }
    }
    public void SetIconTexture(string strTexture)
    {
        XUITexture xUITexture = this.GetUIObject("Texture_Icon") as XUITexture;
        if (xUITexture != null)
        {
            xUITexture.SetTexture(strTexture);
        }
    }
    public bool SetText(string strId, string strText)
    {
        IXUILabel label = this.GetUIObject(strId) as IXUILabel;
        if (label != null)
        {
            label.SetText(strText);
            return true;
        }
        return false;
    }
    public void SetColor(Color color)
    {
        if (this.m_uiSpriteIcon != null)
        {
            this.m_uiSpriteIcon.color = color;
        }
        if (this.m_uiTextureIcon != null)
        {
            this.m_uiTextureIcon.color = color;
        }
    }
    public void SetEnable(bool bEnable)
    {
        if (this.m_colldier != null)
        {
            this.m_colldier.enabled = bEnable;
        }
        if (this.m_uiButton != null)
        {
            this.m_uiButton.enabled = bEnable;
        }
    }
    public void Clear()
    {
        this.m_unId = 0;
        UILabel[] uiLabels = this.m_uiLabels;
        for (int i = 0; i < uiLabels.Length; i++)
        {
            UILabel uILabel = uiLabels[i];
            uILabel.text = string.Empty;
        }
        if (null != this.m_uiSpriteIcon)
        {
            this.m_uiSpriteIcon.enabled = false;
        }
        if (null != this.m_uiTextureIcon)
        {
            this.m_uiTextureIcon.enabled = false;
        }
        this.Tip = string.Empty;
        this.TipParam = null;
    }
    public override void Init()
    {
        base.Init();
        WidgetFactory.FindAllUIObjects(base.transform, this, ref m_dicId2UIObject);
        foreach (var uiObject in this.m_dicId2UIObject.Values)
        {
            uiObject.Parent = this;
            if (!uiObject.IsInited)
            {
                uiObject.Init();
            }
        }
        if (null == this.m_uiSpriteIcon)
        {
            Transform tran = base.transform.FindChild("Sprite_Icon");
            if (tran != null)
            {
                this.m_uiSpriteIcon = tran.GetComponent<UISprite>();
            }
        }
        if (null == this.m_uiTextureIcon)
        {
            Transform tran1 = base.transform.FindChild("Texture_Icon");
            if (tran1 != null)
            {
                this.m_uiTextureIcon = tran1.GetComponent<UITexture>();
            }
        }
        this.m_colldier = base.GetComponent<Collider>();
        this.m_uiLabels = base.GetComponentsInChildren<UILabel>();
        this.m_uiToggle = base.GetComponent<UIToggle>();
        this.m_uiButton = base.GetComponent<UIButton>();
        this.m_uiSprites = base.GetComponentsInChildren<UISprite>(true);
        this.m_uiTextures = base.GetComponentsInChildren<UITexture>(true);
        this.m_uiSpriteFlash = this.GetUIObject("Sprite_Flash") as XUISprite;
        if (this.m_uiToggle != null)
        {
            EventDelegate.Add(this.m_uiToggle.onChange, this.OnSelectStateChange);
        }
        this.Highlight(false);
    }
    public override IXUIObject GetUIObject(string strPath)
    {
        if (strPath == null)
        {
            return null;
        }
        string key = strPath;
        int num = strPath.LastIndexOf('/');
        if (num >= 0)
        {
            key = strPath.Substring(num + 1);
        }
        XUIObjectBase result = null;
        if (this.m_dicId2UIObject.TryGetValue(key, out result))
        {
            return result;
        }
        return null;
    }
    public override void Highlight(bool bTrue)
    {
        base.Highlight(bTrue);
        if (this.m_uiSpriteFlash != null)
        {
            if (!bTrue)
            {
                this.m_uiSpriteFlash.StopFlash();
            }
            else 
            {
                this.m_uiSpriteFlash.PlayFlash(true);
            }
        }
    }
    public override void _OnClick()
    {
        base._OnClick();
        this.ParentXUIList._OnClick(this);
    }
}

注意了，细心的童鞋可能看到，这个Item他的子物体假如是Sprite，那么他的命名必须是：

Sprite_Icon

如果子物体是Texture，那么命名必须是：

Texture_Icon

如果子物体是有带动画的Sprite，必须命名为:

Sprite_Flash

还有如果这个Item是可以选择的，必须添加UIToggle脚本，具体读者自己看代码。OK，接着我们写

IXUIList：

 

using UnityEngine;
using System.Collections.Generic;
using Game.Common;
public interface IXUIList : IXUIObject
{
    int Count
    {
        get;
    }
    int GetSelectedIndex();
    void SetSelectedIndex(int nIndex);
    void SetSelectedItemByIndex(List<int> listItemIndex);
    void SetSelectedItemById(int unId);
    void SetSelectedItemById(List<int> listItemId);
    IXUIListItem GetSelectedItem();
    IXUIListItem[] GetSelectedItems();
    IXUIListItem GetItemById(int unId, bool bVisible);
    IXUIListItem GetItemByGUID(long ulId);
    IXUIListItem[] GetAllItems();
    IXUIListItem GetItemByIndex(int nIndex);
    IXUIListItem AddListItem(GameObject obj);
    IXUIListItem AddListItem();
    bool DelItemById(int unId);
    bool DelItemByIndex(int nIndex);
    bool DelItem(IXUIListItem iUIListItem);
    void SetEnable(bool bEnable);
    void SetEnableSelect(bool bEnable);
    void SetEnableSelect(List<int> listIds);
    void Highlight(List<int> listIds);
    void Refresh();
    void OnSelectItem(XUIListItem listItem);
    void SelectItem(XUIListItem listItem, bool bTrigerEvent);
    void OnUnSelectItem(XUIListItem listItem);
    void UnSelectItem(XUIListItem listItem, bool bTrigerEvent);
    void RegisterListOnSelectEventHandler(ListSelectEventHandler handler);
    void RegisterListOnUnSelectEventHandler(ListSelectEventHandler handler);
    void RegisterListOnClickEventHandler(ListOnClickEventHandler handler);
    void Clear();
}

 

可能会有出错，因为我们ListSelectEventHandler委托类型还没有声明，我们到DefineCommon中定义这两个委托类型：

 

public delegate bool ListSelectEventHandler(IXUIListItem listItem);
public delegate bool ListOnClickEventHandler(IXUIListItem listItem);

 

 

XUIList.cs:

using UnityEngine;
using System.Collections.Generic;
using System;
using Game.Common;
[AddComponentMenu("XUI/XUIList")]
public class XUIList : XUIObject, IXUIObject,IXUIList
{
    public GameObject m_prefabListItem;
    public bool m_bMultiSelect;
    private bool m_bHasAddItem;
    private List<XUIListItem> m_listXUIListItem = new List<XUIListItem>();
    private List<XUIListItem> m_listXUIListItemSelected = new List<XUIListItem>();
    private ListSelectEventHandler m_eventhandlerOnSelect;
    private ListSelectEventHandler m_eventhandlerOnUnSelect;
    private ListOnClickEventHandler m_eventhandlerOnClick;
    private UIGrid m_uiGrid;
    private UITable m_uiTable;
    public int Count 
    {
        get
        {
            if (null == this.m_listXUIListItem)
            {
                return 0;
            }
            return this.m_listXUIListItem.Count;
        }
    }

    public override void Init()
    {
        base.Init();
        this.m_listXUIListItem.Clear();
        this.m_listXUIListItemSelected.Clear();
        for (int i = 0; i < base.transform.childCount; i++)
        {
            Transform child = base.transform.GetChild(i);
            XUIListItem component = child.GetComponent<XUIListItem>();
            if (component == null)
            {
                Debug.LogError("null == uiListitem");
            }
            else 
            {
                component.Parent = this;
                this.m_listXUIListItem.Add(component);
            }
            this.m_listXUIListItem.Sort(new Comparison<XUIListItem>(XUIList.SortByName));
            int num = 0;
            foreach (XUIListItem current in this.m_listXUIListItem)
            {
                current.name = string.Format("{0:0000}", num);
                current.Index = num;
                current.Id = num;
                if (!current.IsInited)
                {
                    current.Init();
                }
                UIToggle component2 = current.GetComponent<UIToggle>();
                if (current.IsSelected)
                {
                    this.m_listXUIListItemSelected.Add(current);
                }
                num++;
            }
            this.m_uiGrid = base.GetComponent<UIGrid>();
            if (null != this.m_uiGrid)
            {
                this.m_uiGrid.Reposition();
            }
            this.m_uiTable = base.GetComponent<UITable>();
            if (null != this.m_uiTable)
            {
                this.m_uiTable.Reposition();
            }
        }
    }
    public int GetSelectedIndex()
    {
        if (this.m_listXUIListItemSelected.Count > 0)
        {
            return this.m_listXUIListItemSelected[0].Index;
        }
        return -1;
    }
    public void SetSelectedIndex(int nIndex)
    {
        XUIListItem selectedItem = this.GetItemByIndex(nIndex) as XUIListItem;
        this.SetSelectedItem(selectedItem);
        //this.FocusIndex(nIndex);
    }
    public void SetSelectedItemByIndex(List<int> listItemIndex)
    {
        if (this.m_bMultiSelect)
        {
            this.m_listXUIListItemSelected.Clear();
            foreach (XUIListItem current in this.m_listXUIListItem)
            {
                if (listItemIndex != null && listItemIndex.Contains(current.Index))
                {
                    current.SetSelected(true);
                    this.m_listXUIListItemSelected.Add(current);
                }
                else
                {
                    current.SetSelected(false);
                }
            }
        }
        else
        {
            Debug.LogError("false == m_bMultiSelect");
        }
    }
    public void SetSelectedItemById(int unId)
    {
        XUIListItem selectedItem = this.GetItemById(unId) as XUIListItem;
        this.SetSelectedItem(selectedItem);
    }
    public void SetSelectedItemById(List<int> listItemId)
    {
        if (this.m_bMultiSelect)
        {
            this.m_listXUIListItemSelected.Clear();
            foreach (XUIListItem current in this.m_listXUIListItem)
            {
                if (listItemId != null && listItemId.Contains(current.Id))
                {
                    current.SetSelected(true);
                    this.m_listXUIListItemSelected.Add(current);
                }
                else
                {
                    current.SetSelected(false);
                }
            }
        }
        else
        {
            Debug.LogError("false == m_bMultiSelect");
        }
    }
    public void SetSelectedItem(XUIListItem uiListItem)
    {
        foreach (XUIListItem current in this.m_listXUIListItemSelected)
        {
            current.SetSelected(false);
        }
        this.m_listXUIListItemSelected.Clear();
        if (null != uiListItem)
        {
            uiListItem.SetSelected(true);
            this.m_listXUIListItemSelected.Add(uiListItem);
        }
    }
    public IXUIListItem GetItemByIndex(int nIndex)
    {
        if (this.m_listXUIListItem == null)
        {
            return null;
        }
        if (0 > nIndex || nIndex >= this.m_listXUIListItem.Count)
        {
            return null;
        }
        return this.m_listXUIListItem[nIndex];
    }
    public IXUIListItem GetSelectedItem()
    {
        if (this.m_listXUIListItemSelected.Count > 0)
        {
            return this.m_listXUIListItemSelected[0];
        }
        return null;
    }
    public IXUIListItem[] GetSelectedItems()
    {
        return this.m_listXUIListItemSelected.ToArray();
    }
    public IXUIListItem GetItemById(int unId)
    {
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            if (unId == current.Id)
            {
                return current;
            }
        }
        return null;
    }
    public IXUIListItem GetItemById(int unId, bool bVisible)
    {
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            if (unId == current.Id && current.IsVisible() == bVisible)
            {
                return current;
            }
        }
        return null;
    }
    public IXUIListItem GetItemByGUID(long ulId)
    {
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            if (ulId == current.GUID)
            {
                return current;
            }
        }
        return null;
    }
    public IXUIListItem[] GetAllItems()
    {
        return this.m_listXUIListItem.ToArray();
    }
    public IXUIListItem AddListItem(GameObject obj)
    {
        if (null == obj)
        {
            return null;
        }
        GameObject gameObject = UnityEngine.Object.Instantiate(obj) as GameObject;
        gameObject.name = string.Format("{0:0000}", this.Count);
        gameObject.transform.parent = base.transform;
        gameObject.transform.localPosition = Vector3.zero;
        gameObject.transform.localScale = Vector3.one;
        gameObject.transform.localRotation = Quaternion.identity;
        NGUITools.SetLayer(gameObject, this.CacheGameObject.layer);
        UIToggle component = gameObject.GetComponent<UIToggle>();
        XUIListItem xUIListItem = gameObject.GetComponent<XUIListItem>();
        if (null == xUIListItem)
        {
            //Debug.LogError("null == uiListItem");
            xUIListItem = gameObject.AddComponent<XUIListItem>();
        }
        xUIListItem.Index = this.Count;
        xUIListItem.Id = xUIListItem.Index;
        xUIListItem.Parent = this;
        if (!xUIListItem.IsInited)
        {
            xUIListItem.Init();
        }
        this.m_listXUIListItem.Add(xUIListItem);
        this.m_bHasAddItem = true;
        this.Refresh();
        return xUIListItem;
    }
    public IXUIListItem AddListItem()
    {
        if (null != this.m_prefabListItem)
        {
            return this.AddListItem(this.m_prefabListItem);
        }
        return null;
    }
    public bool DelItemById(int unId)
    {
        IXUIListItem itemById = this.GetItemById(unId);
        return this.DelItem(itemById);
    }
    public bool DelItemByIndex(int nIndex)
    {
        IXUIListItem itemByIndex = this.GetItemByIndex(nIndex);
        return this.DelItem(itemByIndex);
    }
    public bool DelItem(IXUIListItem iUIListItem)
    {
        XUIListItem xUIListItem = iUIListItem as XUIListItem;
        if (null == xUIListItem)
        {
            return false;
        }
        this.m_listXUIListItemSelected.Remove(xUIListItem);
        int index = xUIListItem.Index;
        for (int i = index + 1; i < this.Count; i++)
        {
            this.m_listXUIListItem[i].name = string.Format("{0:0000}", i - 1);
            this.m_listXUIListItem[i].Index = i - 1;
        }
        this.m_listXUIListItem.Remove(xUIListItem);
        xUIListItem.gameObject.transform.parent = null;
        UnityEngine.Object.Destroy(xUIListItem.gameObject);
        this.Refresh();
        return true;
    }
    public void Clear()
    {
        if (this.m_listXUIListItem == null)
        {
            return;
        }
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            current.gameObject.transform.parent = null;
            UnityEngine.Object.Destroy(current.gameObject);
        }
        this.m_listXUIListItemSelected.Clear();
        this.m_listXUIListItem.Clear();
        this.Refresh();
    }
    public void SetEnable(bool bEnable)
    {
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            current.SetEnable(bEnable);
        }
    }
    public void SetEnableSelect(bool bEnable)
    {
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            current.SetEnableSelect(bEnable);
        }
        if (!bEnable)
        {
            this.m_listXUIListItemSelected.Clear();
        }
    }
    public void SetEnableSelect(List<int> listIds)
    {
        if (listIds == null)
        {
            return;
        }
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            if (listIds.Contains(current.Id))
            {
                current.SetEnableSelect(true);
            }
            else
            {
                current.SetEnableSelect(false);
            }
        }
        this.m_listXUIListItemSelected.RemoveAll((XUIListItem x) => !listIds.Contains(x.Id));
    }
    public override void Highlight(bool bTrue)
    {
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            current.Highlight(bTrue);
        }
    }
    public void Highlight(List<int> listIds)
    {
        this.Highlight(false);
        if (listIds == null)
        {
            return;
        }
        foreach (XUIListItem current in this.m_listXUIListItem)
        {
            if (listIds.Contains(current.Id))
            {
                current.Highlight(true);
            }
        }
    }
    public void Refresh()
    {
        if (null != this.m_uiGrid)
        {
            this.m_uiGrid.repositionNow = true;
        }
        if (null != this.m_uiTable)
        {
            this.m_uiTable.repositionNow = true;
        }
        this.RefreshAllItemStatus();
    }
    public void OnSelectItem(XUIListItem listItem)
    {
        this.SelectItem(listItem, true);
    }
    public void SelectItem(XUIListItem listItem, bool bTrigerEvent)
    {
        if (null == listItem)
        {
            return;
        }
        if (this.m_listXUIListItemSelected.Contains(listItem))
        {
            return;
        }
        if (!this.m_bMultiSelect)
        {
            this.m_listXUIListItemSelected.Clear();
        }
        this.m_listXUIListItemSelected.Add(listItem);
        //触发选择委托
        if (bTrigerEvent && this.m_eventhandlerOnSelect != null)
        {
            this.m_eventhandlerOnSelect(listItem);
        }
    }
    public void OnUnSelectItem(XUIListItem listItem)
    {
        this.UnSelectItem(listItem, true);
    }
    public void UnSelectItem(XUIListItem listItem, bool bTrigerEvent)
    {
        if (null == listItem)
        {
            return;
        }
        if (!this.m_listXUIListItemSelected.Contains(listItem))
        {
            return;
        }
        this.m_listXUIListItemSelected.Remove(listItem);
        //不选择委托
        if (bTrigerEvent && this.m_eventhandlerOnUnSelect != null)
        {
            this.m_eventhandlerOnUnSelect(listItem);
        }
    }
    public void RegisterListOnSelectEventHandler(ListSelectEventHandler handler)
    {
        this.m_eventhandlerOnSelect = handler;
    }
    public void RegisterListOnUnSelectEventHandler(ListSelectEventHandler handler)
    {
        this.m_eventhandlerOnUnSelect = handler;
    }
    public void RegisterListOnClickEventHandler(ListOnClickEventHandler handler)
    {
        this.m_eventhandlerOnClick = handler;
    }
    public void _OnClick(XUIListItem item)
    {
        if (this.GetSelectedIndex() != item.Index)
        {
            this.SelectItem(item, false);
        }
        if (this.m_eventhandlerOnClick != null)
        {
            this.m_eventhandlerOnClick(item);
        }
    }
    public static int SortByName(XUIListItem a, XUIListItem b)
    {
        return string.Compare(a.name, b.name);
    }
    private void RefreshAllItemStatus()
    {
        int num = this.GetSelectedIndex();
        if (num < 0)
        {
            this.SetSelectedIndex(0);
        }
    }
}

　　

可以看都XUIList封装了好多处理Item的方法，具体的读者可以自行阅读代码，这里我们只需要知道怎么用就行了。

OK,封装好了之后，我们回到UI界面，把我们自己定义的这些组件添加到对应的UI组件中。

这里我们电信的Grid，我添加自己定义的XUIList组件。

然后他的子物体Item，我添加了XUIListItem组件和UIToggle组件。

然后将Item拖到Prefab当成预制物，然后到XUiList中设置Prefab ListItem变量为这个预制物。可以看上图的XUIList我已经添加了。

这个Prefab ListItem有什么用呢？

这要是我们动态添加item的时候，他就会实例化这个预制物。也就是我们前提设置好要动态添加的item。

OK，其他的组件自己自行添加。

同理，联通的那个UIGrid也是类似的。讲完这个自己封装的UI框架，我们继续回到游戏主题。

开始写LoginWindow.cs

这节一多，下节继续。。。。。。