斗地主项目总结

一、运行流程

　　开始界面

　　1. 点击开始游戏按钮，执行 PlayPanel 类 startClick 函数，

/// <summary>
/// 开始游戏按钮响应函数
/// </summary>
private void startClick()
{
    Dispatch(AreaCode.UI, UIEvent.START_PANEL_ACTIVE, true);      
}

 

　　该函数向 UI 层发送 START_PANEL_ACTIVE 事件，传输消息 true。

　　然后是 StartPanel 类 Execute 函数，

public override void Execute(int eventCode, object message)
{
    switch (eventCode)
    {
        case UIEvent.START_PANEL_ACTIVE:
            setPanelActive((bool)message);
            break;
        default:
            break;
    }
}

　　该函数接收消息，调用 setPanelActive 函数显示开始游戏面板。

　　点击注册账号按钮流程类似。

 

　　登录界面：

 

　　2. 点击登录按钮，执行 StartPanel 类 loginClick 函数，

/// <summary>
/// 登录按钮的点击事件处理
/// </summary>
private void loginClick()
{
    // 若用户名输入为空
    if (string.IsNullOrEmpty(inputAccount.text))
    {
        promptMsg.Change("用户名输入为空", Color.red);
        Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
        return;
    }  
    // 若密码输入为空
    if (string.IsNullOrEmpty(inputPassword.text))      
    {
        promptMsg.Change("密码输入为空", Color.red);
        Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
        return;
    }
    // 若密码输入不是4到16位
    if(inputPassword.text.Length < 4
        || inputPassword.text.Length > 16)
    {
        promptMsg.Change("密码输入不是4到16位", Color.red);
        Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
        return;
    }

    //需要和服务器交互了
    AccountDto dto = new AccountDto(inputAccount.text, inputPassword.text);
    socketMsg.Change(OpCode.ACCOUNT, AccountCode.LOGIN, dto);
    Dispatch(AreaCode.NET, 0, socketMsg);
}

 

 

 

 

　　该函数先验证输入是否符合规定，若不符合，则输出相应消息；若符合，则与服务器交互。

　　输出相应消息实现，自定义消息类 PromptMsg，

/// <summary>
/// 提示窗口
/// </summary>
class PromptMsg
{
    public string text;
    public Color color;

    public PromptMsg()
    {

    }

    public PromptMsg(string text, Color color)
    {
        this.text = text;
        this.color = color;
    }

    /// <summary>
    /// 改变属性，防止多次 new 
    /// </summary>
    /// <param name="text"></param>
    /// <param name="color"></param>
    public void Change(string text, Color color)
    {
        this.text = text;
        this.color = color;
    }
}

 

 

 　　然后向 UI 层发送 PROMPT_MSG 事件，

　　然后是 PromptPanel 类 Execute 函数接收消息，

public override void Execute(int eventCode, object message)
{
    switch (eventCode)
    {
        case UIEvent.PROMPT_MSG:                    // 提示信息
            PromptMsg msg = message as PromptMsg;
            PromptMessage(msg.text, msg.color);
            break;
        default:
            break;
    }
}

　　通过 PromptMessage 函数显示提醒效果，

/// <summary>
/// 提示消息
/// </summary>
/// <param name="text">显示文字</param>
/// <param name="color">显示颜色</param>
private void PromptMessage(string text, Color color)
{
    txt.text = text;
    txt.color = color;
    cg.alpha = 0;
    StartCoroutine(PromptAnim());       // 播放动画
}

 

 

 

　　从上面两个事件流程可得出 UI 事件的一般流程为：

　　首先为每个面板创建一个脚本来控制该面板，之后再 Awake 函数里使用 Bind 函数注册事件码，

void Awake()
{
    Bind(UIEvent.START_PANEL_ACTIVE);           // 注册事件码
}

 

　　 然后添加 Execute 函数来接收外界发送的事件，

public override void Execute(int eventCode, object message)
{
    switch (eventCode)
    {
        default:
            break;
    }
}

　　那么当我们需要实现某一事件的时候，只需要调用 Dispatch 函数来发送想发送的消息即可。

/// <summary>
/// 开始游戏按钮响应函数
/// </summary>
private void startClick()
{
    Dispatch(AreaCode.UI, UIEvent.START_PANEL_ACTIVE, true);      
}

 

 

 　　那么，如何与服务器交互呢？

　　首先也需要自定义消息类 AccountDto（服务器端生成），

[Serializable]
public class AccountDto
{
    public string Account;
    public string Password;

    public AccountDto();
    public AccountDto(string acc, string pwd);
}

　　和实际传输的信息类 SocketMsg，

/// <summary>
/// 网络消息
///     作用：发送的时候 都要发送这个类
/// </summary>
public class SocketMsg
{
    /// <summary>
    /// 操作码
    /// </summary>
    public int OpCode { get; set; }

    /// <summary>
    /// 子操作
    /// </summary>
    public int SubCode { get; set; }

    /// <summary>
    /// 参数
    /// </summary>
    public object Value { get; set; }

    public SocketMsg()
    {

    }

    public SocketMsg(int opCode, int subCode, object value)
    {
        this.OpCode = opCode;
        this.SubCode = subCode;
        this.Value = value;
    }

    public void Change(int opCode, int subCode, object value)
    {
        this.OpCode = opCode;
        this.SubCode = subCode;
        this.Value = value;
    }
}

 

 　　接下来是把发送消息这个事件和发送的内容使用 Dispatch 派发出去

 　　NetManager 类中的 Execute 函数接收事件，并向服务器发送信息，

public override void Execute(int eventCode, object message)
{
    switch (eventCode)
    {
        case 0:             // 发送消息
            client.Send(message as SocketMsg);
            break;
        default:
            break;
    }
}

 

　　这时候服务器已经收到消息了， 服务器端 NetMsgCenter 类 OnReceive 函数接收到消息，并执行相应的逻辑，

public void OnReceive(ClientPeer client, SocketMsg msg)
{
    switch (msg.OpCode)
    {
        case OpCode.ACCOUNT:
            account.OnReceive(client, msg.SubCode, msg.Value);
            break;
        case OpCode.USER:
            user.OnReceive(client, msg.SubCode, msg.Value);
            break;
        case OpCode.MATCH:
            match.OnReceive(client, msg.SubCode, msg.Value);
            break;
        case OpCode.CHAT:
            chat.OnReceive(client, msg.SubCode, msg.Value);
            break;
        case OpCode.FIGHT:
            fight.OnReceive(client, msg.SubCode, msg.Value);
            break;
        default:
            break;
    }
}

 

　　我们发送的消息的 OpCode 为 ACCOUNT，所以会调用 account.OnReceive 函数，

public void OnReceive(ClientPeer client, int subCode, object value)
{
    switch (subCode)
    {
        case AccountCode.REGIST_CREQ:
            {
                AccountDto dto = value as AccountDto;
                //Console.WriteLine(dto.Account);
                //Console.WriteLine(dto.Password);
                regist(client, dto.Account, dto.Password);
            }
            break;
        case AccountCode.LOGIN:
            {
                AccountDto dto = value as AccountDto;
                //Console.WriteLine(dto.Account);
                //Console.WriteLine(dto.Password);
                login(client, dto.Account, dto.Password);
            }
            break;
        default:
            break;
    }
}

 

 

 　　我们发送的消息的 subCode 为 LOGIN，所以会调用 login 函数，

/// <summary>
/// 登录
/// </summary>
/// <param name="client"></param>
/// <param name="account"></param>
/// <param name="password"></param>
private void login(ClientPeer client, string account, string password)
{
    SingleExecute.Instance.Execute(() =>                    // 单线程
    {
        if (!accountCache.IsExist(account))
        {
            //表示账号不存在
            //client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, "账号不存在");
            client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, -1);
            return;
        }

        if (accountCache.IsOnline(account))
        {
            //表示账号在线
            //client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, "账号在线");
            client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, -2);
            return;
        }

        if (!accountCache.IsMatch(account, password))
        {
            //表示账号密码不匹配
            //client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, "账号密码不匹配");
            client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, -3);
            return;
        }

        //登陆成功
        accountCache.Online(client, account);
        //client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, "登陆成功");
        client.Send(OpCode.ACCOUNT, AccountCode.LOGIN, 0);
    });
}

　　该函数验证账号密码，并向客户端发送相应的消息，

　　那么客户端已经收到回复了，客户端 NetManager 类 ProcessSocketMsg 函数会处理该消息，

private void ProcessSocketMsg(SocketMsg msg)
{
    switch (msg.OpCode)
    {
        case OpCode.ACCOUNT :
            accountHandler.OnReceive(msg.SubCode, msg.Value);
            break;
        case OpCode.USER:
            userHandler.OnReceive(msg.SubCode, msg.Value);
            break;
        case OpCode.MATCH:
            matchHandler.OnReceive(msg.SubCode, msg.Value);
            break;
        default:
            break;
    }
}

 

 　　然后根据接收到的消息会调用 AccountHandler 类的 OnReceive 函数，

public override void OnReceive(int subCode, object message)
{
    switch (subCode)
    {
        case AccountCode.LOGIN:                 // 登录
            LoginResponce((int)message);
            break;
        case AccountCode.REGIST_SRES:           // 注册
            RegistResponce((int)message);
            break;
        default:
            break;
    }
}

　　根据 sunCode 会调用 LoginResponce 函数，

// 处理登录信息
private void LoginResponce(int value)
{
    switch (value)
    {
        case 0:
            //promptMsg.Change("登录成功", Color.green);
            //Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
            // 跳到下一个场景
            LoadSceneMsg msg = new LoadSceneMsg(1,
                delegate()          // 匿名委托
                {
                    // 加载游戏信息
                    SocketMsg socketMsg = new SocketMsg(OpCode.USER, UserCode.GET_INFO_CREQ, null);
                    Dispatch(AreaCode.NET, 0, socketMsg);
                    Debug.Log("场景加载完成！");
                }
                );
            Dispatch(AreaCode.SCENE, SceneEvent.LOAD_SCENE, msg);
            break;
        case -1:
            promptMsg.Change("账号不存在", Color.red);
            Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
            break;
        case -2:
            promptMsg.Change("账号在线", Color.red);
            Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
            break;
        case -3:
            promptMsg.Change("账号密码不匹配", Color.red);
            Dispatch(AreaCode.UI, UIEvent.PROMPT_MSG, promptMsg);
            break;
        default:
            break;
    }

　　该函数根据接收到的消息给出相应提示信息。

　　这就是一个相对完整的客户端服务器交互。