黄金点游戏之客户端(homework-05)

0. 摘要

　　之前我们玩了2次黄金数游戏，我也幸运的得到了一本《代码大全》，嘿嘿。这次的作业是一个Client/Server程序，自动化完成多轮重复游戏。

我完成了Client部分，使用C#编写。下面简要阐述。

1. 总体设计：

　　思考后，我认为这个客户端程序要能满足如下要求：

　　1. 保证信息传输到服务器。如果发送的信息没有得到相应，应可以不断重试。

　　2. 一定的错误恢复能力，当因网络问题错过某些回合，应该可以跳过而继续运行。

　　3. 恰当的算法，提供相对准确的黄金数字预测。

　　4. 具有自动获取可用端口能力，使得20个客户端同时开启能够不冲突的与服务器连接。

　　除此之外，为了确保游戏执行期间不出现漏洞（如假冒身份发送数字等），客户端还具有如下考虑：

　　1. 游戏开始前，使用ID和密码注册。

　　2. 等待回合开始；只有当接收到服务器新回合开始的消息，且新回合的序号大于上一次的序号时，才开始计算和条过程。提交信息附带了本客户端的用户名密码。当然，服务器也可以根据客户端的IP和端口判断身份。这里考虑万一不得不更换网络并继续进行回合的情况。

　　3. 每次发送消息均要等待服务器返回确认信息，并且是当前消息的确认信息。在未收到反馈时，启用一个线程不断重试发送。

　　4. 当服务器停止游戏，客户端不再进入发送线程和等待线程。

　　5. 客户端可以停止游戏。不论如何停止客户端，客户端需要正常告知服务器退出游戏。以避免服务器重试发送新回合开始消息。

　　6. 客户端提供GUI，可自定义服务器IP和端口，不填写默认为本地。随时显示当前状态，便于观察和调试。

2. 端口设计

　　基于上述考虑，我的客户端/服务器通讯协议为：

　　str = TYPE + ";" + OP1 + ";" + OP2 + ";" + OP3;

　　这是一条类似指令的收发字符串。各各数值使用分好分割。其中TYPE指明消息类型，包含以下信息：

　　客户端注册，

　　服务器注册确认，

　　服务器开始新回合，

　　客户端提交数字，

　　服务器确认收到提交数字，

　　服务器停止游戏。

　　具体来说，我们为每一个消息举个例子：

　　1. 客户端以ID为11061128，密码123456向服务器注册：

　　　　　　str = "1;11061128;123456"

　　2.服务器收到这个注册，注册成功:

　　　　　　str = "2"

　　3.服务器开始第5个回合，开始提交数字。上一回合的黄金数是17：

　　　　　　str = "3;5;17"

　　4.客户端提交第5回合的数字11，并验证身份：

　　　　　　str = "4;5;11;11061128;123456"

　　5.服务器收到第5回合提交的数字，正在等待他人提交：

　　　　　　str = "5;5"

　　6.服务器停止游戏：

　　　　　　str = "6";

3. 线程调度

　　客户端完成相关逻辑是通过一个控制线程调动其他线程的起止。线程有：

　　control线程：循环的状态机，直到停止。此线程一直运行。

　　receive线程：需要接受服务器确认结果时候，一直运行直到收到相应信息，完成等待。

　　其他线程：完成各自信息发送的功能，与前两者同时进行。当收到相应确认信息时，线程停止，不再重试发送信息。（一遍不断的发信息，一遍看服务器收到没有）。

4. 测试结果

　　经过为服务器的测试，客户端已经可以正确运行。下图的客户端Log显示了状态机、信息收发的情况，正常。通过服务器读取客户端发来的消息，并发送正确指令，测试正常：

　　客户端：

　　

　　服务器显示客户端发来的连接和信息：

　　

5. 主要代码

　　下面是主要代码部分。该部分代码的重点是状态机、线程调度和信息收发：

　　

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Data;
 using System.Drawing;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
 using System.IO;

 namespace AsyncTcpServer
 {
     public partial class mainForm : Form
     {

         const int STATE_REGISTER = ;
         const int STATE_REGISTER_OK = ;
         const int STATE_NEW_ROUND = ;
         const int STATE_SUBMIT = ;
         const int STATE_SUBMIT_OK = ;
         const int STATE_SERVER_STOP = ;
         const int INTERVAL = ;

         const string TYPE_REGISTER = "";
         const string TYPE_REGISTER_OK = "";
         const string TYPE_NEW_ROUND = "";
         const string TYPE_SUBMIT = "";
         const string TYPE_SUBMIT_OK = "";
         const string TYPE_SERVER_STOP = "";

         const string    DEFAULT_SERVER_IP = "192.168.1.2";
         const int       DEFAULT_SERVER_PORT =  ;
         const string    DEFAULT_USER_ID = "";
         const string    DEFAULT_USER_PASSWD = "";

         private string ip_input = DEFAULT_SERVER_IP;
         private int port = DEFAULT_SERVER_PORT;
         private string id = DEFAULT_USER_ID;
         private string passwd = DEFAULT_USER_PASSWD;

         private int tstate = ;
         private int State = STATE_REGISTER;
         private int Round = ;
         private int[] PrevRslt = new int[];
         private int PrevRslt_idx = ;
         private int GoldPoint;
         private string[] rcvs;
         private bool isRunning = false;

         private TcpClient client = null;
         private StreamWriter sw;
         private StreamReader sr;
         private Service service;
         private NetworkStream netStream;

         Thread threadRegister;
         Thread threadSubmit;
         Thread threadReceive;
         Thread threadWaitNewRound;
         Thread threadControl;

         public mainForm()
         {
             InitializeComponent();
             service = new Service(lb_log, sw);
         }

         private void btn_start_Click(object sender, EventArgs e)
         {
             if (isRunning == true)
             {
                 service.SetListBox("Already running, Press STOP first");
                 return;
             }

             if (String.Compare(tb_svr_IP.Text, "IP") != )
             {
                 ip_input = tb_svr_IP.Text.Trim();
             }
             if (String.Compare(tb_svr_port.Text, "PORT") != )
             {
                 port = Int32.Parse(tb_svr_port.Text.Trim());
             }
             if (String.Compare(tb_id.Text, "ID") != )
             {
                 id = tb_id.Text.Trim();
             }
             if (String.Compare(tb_passwd.Text, "PASSWORD") != )
             {
                 passwd = tb_passwd.Text.Trim();
             }
             IPAddress serverIP = IPAddress.Parse(ip_input);
             client = new TcpClient();
             try
             {
                 client.Connect(serverIP, port);
             }
             catch (System.Exception ex)
             {
                 service.SetListBox(ex.Message);
                 return;
             }
             try
             {
                 netStream = client.GetStream();
             }
             catch (System.Exception ex)
             {
                 service.SetListBox(ex.Message);
                 return;
             }
             sr = new StreamReader(netStream, System.Text.Encoding.UTF8);
             sw = new StreamWriter(netStream, System.Text.Encoding.UTF8);
             service = new Service(lb_log, sw);
             isRunning = true;
             threadControl = new Thread(new ThreadStart(control));
             threadControl.Start();
         }

         private void control()
         {
             threadRegister = new Thread(new ThreadStart(Register));
             //threadSubmit = new Thread(new ThreadStart(Cal_and_Submit));
             threadReceive = new Thread(new ThreadStart(ReceiveData));
             //threadWaitNewRound = new Thread(new ThreadStart(WaitNewRound));
             //threadWaitNewRound.Start(); threadReceive.Suspend();
             //threadSubmit.Start(); threadSubmit.Suspend();

             while (isRunning == true)
             {
                 if (tstate == ) //wait finish
                 {
                     threadWaitNewRound.Abort();
                     tstate = ;
                 }
                 else if(tstate == )//waiting
                 {
                     continue;
                 }
                 //nothing to wait
                 switch (State)
                 {
                     case STATE_REGISTER:
                         threadRegister.Start();
                         threadRegister.Join();
                         State = STATE_REGISTER_OK;
                         break;
                     case STATE_REGISTER_OK:
                         threadWaitNewRound = new Thread(new ThreadStart(WaitNewRound));
                         threadWaitNewRound.Start();
                         threadWaitNewRound.Join();
                         tstate = ;
                         State = STATE_NEW_ROUND;/////
                         break;
                     case STATE_NEW_ROUND:
                         threadSubmit = new Thread(new ThreadStart(Cal_and_Submit));
                         threadSubmit.Start();
                         threadSubmit.Join();
                         State = STATE_SUBMIT_OK;
                         break;
                     case STATE_SUBMIT_OK:
                         threadWaitNewRound = new Thread(new ThreadStart(WaitNewRound));
                         threadWaitNewRound.Start();
                         threadWaitNewRound.Join();
                         State = STATE_NEW_ROUND;
                         tstate = ;
                         break;
                     case STATE_SERVER_STOP:
                         service.SetListBox("Server Stop");
                         endMission();
                         break;
                     default:
                         break;
                 }
             }
         }

         private void ReceiveData()
         {
             while (isRunning == true)
             {
                 string receiveString = null;
                 try
                 {
                     receiveString = sr.ReadLine();
                 }
                 catch (Exception e)
                 {
                     service.SetListBox(e.Message);
                 }

                 if (receiveString == null)
                 {
                     //
                     service.SetListBox("wait to re receive");
                     //
                     Thread.Sleep(INTERVAL);
                     continue;
                 }
                 //
                 service.SetListBox("recieved" + receiveString);
                 //
                 rcvs = receiveString.Split(';');
                 switch (rcvs[])
                 {
                     case TYPE_REGISTER_OK:
                         State = STATE_REGISTER_OK;
                         break;
                     case TYPE_SUBMIT_OK:
                         if (Round == Int32.Parse(rcvs[]))
                         {
                             State = STATE_SUBMIT_OK;
                         }
                         break;
                     case TYPE_NEW_ROUND:
                         if (Round == Int32.Parse(rcvs[]) - )
                         {
                             State = STATE_NEW_ROUND;
                         }
                         break;
                     case TYPE_SERVER_STOP:
                         State = STATE_SERVER_STOP;
                         service.SetListBox("Server Stop");
                         tstate = ;
                         endMission();
                         break;
                     default:
                         break;
                 }
             }
         }

         private void Register()
         {
             threadReceive.Start();
             String str = TYPE_REGISTER + ";" + id + ";" + passwd;
             service.SendToServer(str);
             while (isRunning && State != STATE_REGISTER_OK)
             {
                 //
                 service.SetListBox("re register");
                 //
                 Thread.Sleep(INTERVAL);
                 service.SendToServer(str);
             }
             threadReceive.Suspend();
         }

         private void WaitNewRound()
         {
             threadReceive.Resume();
             while (isRunning && State != STATE_NEW_ROUND)
             {
                 //
                 service.SetListBox("waiting");
                 //
                 Thread.Sleep(INTERVAL);
             }
             Round++;
             PrevRslt[PrevRslt_idx++] = Int32.Parse(rcvs[]);
             threadReceive.Suspend();
             tstate = ;
         }

         private void Cal_and_Submit()
         {
             threadReceive.Resume();
             GoldPoint = calculate();
             string str = TYPE_SUBMIT + ";" + Round.ToString() + ";" + GoldPoint.ToString();
             service.SendToServer(str);
             while (isRunning && State != STATE_SUBMIT_OK)
             {
                 Thread.Sleep(INTERVAL);
                 //
                 service.SetListBox("submitting");
                 //
                 service.SendToServer(str);
             }
             threadReceive.Suspend();
         }
         private int calculate()
         {
             //
             service.SetListBox("calculation");
             //
             if (Round == )
             {
                 return ;
             }
             else
             return (int)(PrevRslt[PrevRslt_idx] * 0.618);
         }

         private void btn_stop_Click(object sender, EventArgs e)
         {
             endMission();
         }

         private void mainForm_FormClosing(object sender, FormClosingEventArgs e)
         {
             endMission();
         }

         private void endMission()
         {
             //
             service.SetListBox("ending mission");
             //
             if (isRunning)
             {
                 netStream.Close();
                 client.Close();
             }
             isRunning = false;
         }
     }
 }

　　下一次作业，客户端将完善线程操作（弃用已经过时的suspend和resume方法），并使用最小二乘法逼近黄金点曲线的方法来预测数值。