C#中国象棋网络版源代码(四)-辅助类

1.Common.cs文件

公共类, 参考绿色注释

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;
/********************************************************************************
* 本网站内容允许非商业用途的转载，但须保持内容的原始性并以链接的方式注明出处，
* 本公司保留内容的一切权利。
* 凡注明易学原创的源代码及文档不得进行商业用途转载!!! *

*********************************************************************************
* 易学网祝您学业有成!* by www.vjsdn.com
*********************************************************************************/
namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary>
    /// 图像处理辅助类
    /// </summary>
    public class ImageHelper
   {
       /// <summary>
       /// 获取均分图片中的某一个
       /// </summary>
       public static Image GetImageByAverageIndex(Image orignal, int count, int index)
      {
          int width = orignal.Width / count;
          return CutImage(orignal, width * (index - 1), width, orignal.Height);
      }
      
       /// <summary>
       /// 获取图片一部分
       /// </summary>
       private static Image CutImage(Image orignal, int start, int width, int height)
      {
         Bitmap partImage = new Bitmap(width, height);
         Graphics g = Graphics.FromImage(partImage); //获取画板
         Rectangle srcRect = new Rectangle(start, 0, width, height); //源位置开始
         Rectangle destRect = new Rectangle(0, 0, width, height); //目标位置
          //复制图片
         g.DrawImage(orignal, destRect, srcRect, GraphicsUnit.Pixel);
         partImage.MakeTransparent(Color.FromArgb(255, 0, 255));
         g.Dispose();
          return partImage;
      }
   }
   
    /// <summary>
    /// 棋盘坐标：作为值的集合，可用结构体
    /// </summary>
    public struct ChessPoint
   {
       private int _x;
       private int _y;
      
       /// <summary>
       /// 构造函数
       /// </summary>
       public ChessPoint( int x, int y)
      {
          this._x = x;
          this._y = y;
      }
      
       /// <summary>
       /// X轴坐标
       /// </summary>
       public int X
      {
          get { return _x; }
          set { _x = value; }
      }
      
       /// <summary>
       /// Y轴坐标
       /// </summary>
       public int Y
      {
          get { return _y; }
          set { _y = value; }
      }
   }
   
    /// <summary>
    /// 吃掉老王，异常
    /// </summary>
    public class GameLoseException : Exception
   {
       public GameLoseException( string msg) : base(msg) { }
   }
   
    /// <summary>
    /// 棋子颜色
    /// </summary>
    public enum ChessColor
   {
      Red,//红
      Black//黑
   }
   
    /// <summary>
    /// 消息提示框
    /// </summary>
    public class Msg
   {
       public static bool AskQuestion( string msg)
      {
         DialogResult r;
         r = MessageBox.Show(msg, "确认",
         MessageBoxButtons.YesNo,
         MessageBoxIcon.Question,
         MessageBoxDefaultButton.Button2);
          return (r == DialogResult.Yes);
      }
      
       public static void ShowException(Exception e)
      {
          string s = e.Message;
         Warning(s);
      }
      
       public static void Warning( string msg)
      {
         System.Windows.Forms.MessageBox.Show(msg, "警告",
         MessageBoxButtons.OK,
         MessageBoxIcon.Exclamation,
         MessageBoxDefaultButton.Button1);
      }
      
       public static void ShowError( string msg)
      {
         MessageBox.Show(msg, "警告",
         MessageBoxButtons.OK,
         MessageBoxIcon.Hand,
         MessageBoxDefaultButton.Button1);
      }
      
       public static void ShowInformation( string msg)
      {
         MessageBox.Show(msg, "信息",
         MessageBoxButtons.OK,
         MessageBoxIcon.Asterisk,
         MessageBoxDefaultButton.Button1);
      }
   }
   
   
}

2.坐标(Coordinate)

一个重要的类,由棋盘像素转换为棋子坐标

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary>
    /// 坐标系转换类
    /// </summary>
    public class CoordinateHelper
   {
       private static int _cellWidth = 48;
      
       /// <summary>
       /// 根据棋盘坐标计算物理坐标
       /// </summary>
       public static Point CalculatePyshicalPoint(ChessPoint p)
      {
          return new Point(_cellWidth * p.X + 31 - 43 / 2, _cellWidth * p.Y + 31 - 43 / 2);
      }
      
       /// <summary>
       /// 转换物理坐标到棋盘坐标
       /// </summary>
       public static ChessPoint TranslatePointToChessPoint(Point p)
      {
          int x = p.X - (31 - 43 / 2);
          int y = p.Y - (31 - 43 / 2);
          return new ChessPoint(x / 49, y / 49);
      }
      
       /// <summary>
       ///反向坐标
       /// </summary>
       public static ChessPoint Reverse(ChessPoint point)
      {
          int x = Math.Abs(point.X - 8);
          int y = Math.Abs(point.Y - 9);
          return new ChessPoint(x, y);
      }
   }
}

3.控制面板(Controll Panel)

分离主界面的部分代码

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary>
    /// 控制面板,
    /// </summary>
    public class GameControlPanel
   {
       private DateTime NullDate = new DateTime(1900, 1, 1, 0, 0, 0);
       private PictureBox _redHistory;
       private PictureBox _blackHistory;
       private PictureBox _pbBegin;
       private PictureBox _pbRegret;
       private PictureBox _pbLost;
      
       private DateTime _RedGlobalTimer; //局时
       private DateTime _RedStepTimer; //步时
      
       private DateTime _BlackGlobalTimer; //局时
       private DateTime _BlackStepTimer; //步时
      
       private Timer _RedTimer;
       private Timer _BlackTimer;
      
       private SetImage _SetImage;
       private SetTimer _SetTimer;
      
       //启动计时器
       public void StartTimer(ChessColor playerColor)
      {
          if (ChessColor.Red == playerColor)
         {
            _RedStepTimer = NullDate;
            (_SetTimer.Target as Form).Invoke(_SetTimer, _RedTimer, true);
         }
          else
         {
            _BlackStepTimer = NullDate;
            (_SetTimer.Target as Form).Invoke(_SetTimer, _BlackTimer, true);
         }
      }
      
       //停用计时器
       public void StopTimer(ChessColor playerColor)
      {
          if (ChessColor.Red == playerColor)
         {
            (_SetTimer.Target as Form).Invoke(_SetTimer, _RedTimer, false);
            
            _RedGlobalTimer.AddTicks(_RedStepTimer.Ticks);
            _RedStepTimer = NullDate;
         }
          else
         {
            (_SetTimer.Target as Form).Invoke(_SetTimer, _BlackTimer, false);
            
            _BlackGlobalTimer.AddTicks(_BlackStepTimer.Ticks);
            _BlackStepTimer = NullDate;
         }
      }
      
       //构造器
       public GameControlPanel(PictureBox redHistory, PictureBox blackHistory,
      PictureBox begin, PictureBox regret, PictureBox lost, Timer red, Timer black, SetImage setImage, SetTimer setTimer)
      {
         _SetImage = setImage;
         _SetTimer = setTimer;
         
         _redHistory = redHistory;
         _blackHistory = blackHistory;
         _pbBegin = begin;
         _pbRegret = regret;
         _pbLost = lost;
         
         _RedTimer = red;
         _BlackTimer = black;
         _RedTimer.Tick += new EventHandler(RedTimer_Tick);
         _BlackTimer.Tick += new EventHandler(BlackTimer_Tick);
         
         _RedGlobalTimer = NullDate;
         _RedStepTimer = NullDate;
         _BlackGlobalTimer = NullDate;
         _BlackStepTimer = NullDate;
      }
      
       //红方计时器
       private void RedTimer_Tick( object sender, EventArgs e)
      {
         _RedStepTimer = _RedStepTimer.AddSeconds(1);
         _RedGlobalTimer = _RedGlobalTimer.AddSeconds(1);
          this.DrawTimerString(ChessColor.Red);
      }
      
       //黑方计时器
       private void BlackTimer_Tick( object sender, EventArgs e)
      {
         _BlackStepTimer = _BlackStepTimer.AddSeconds(1);
         _BlackGlobalTimer = _BlackGlobalTimer.AddSeconds(1);
          this.DrawTimerString(ChessColor.Black);
      }
      
       // 绘制显示在左边玩家信息里的棋子
       public void ShowHistory(Chess chess)
      {
          //用于显示当前玩家走的什么棋子
          //判断当前棋子是什么颜色
          if (chess.Color == ChessColor.Red)
         {
            Image img = DrawHistoryChess(_redHistory.Image, chess);
            _redHistory.Invoke(_SetImage, _redHistory, img);
         }
          else
         {
            Image img = DrawHistoryChess(_blackHistory.Image, chess);
            _blackHistory.Invoke(_SetImage, _blackHistory, img);
         }
      }
      
       /// <summary>
       /// 绘制棋子
       /// </summary>
       public static Image DrawHistoryChess(Image source, Chess chess)
      {
         Bitmap map = new Bitmap(source);
          using (Graphics hisc = Graphics.FromImage(map))
         {
            hisc.DrawImage(chess.ChessImage, 36, 20);
         }
          return map;
      }
      
       //显示计时时间
       public void DrawTimerString(ChessColor color)
      {
         Graphics g;
         Font f;
         PictureBox ori;
         DateTime global;
         DateTime step;
         
          if (ChessColor.Red == color)
         {
            ori = _redHistory;
            global = _RedGlobalTimer;
            step = _RedStepTimer;
         }
          else
         {
            ori = _blackHistory;
            global = _BlackGlobalTimer;
            step = _BlackStepTimer;
         }
         
         Bitmap bmp = ChineseChess.Res.Properties.Resources.timer;
         g = Graphics.FromImage(bmp);
         f = new System.Drawing.Font("Arial", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, (( byte)(0)));
         g.DrawString(GetTimerStr(global), f, new SolidBrush(Color.Red), 12, 6);
         g.DrawString(GetTimerStr(step), f, new SolidBrush(Color.Red), 12, 30);
         g.Dispose();
         
         Rectangle rr = new Rectangle( new Point(43, 82), bmp.Size);
         g = Graphics.FromImage(ori.Image);
         g.DrawImage(bmp, rr);
         g.Dispose();
         
         ori.Invalidate();
      }
      
       //返回 mm ss格式
       public string GetTimerStr(DateTime time)
      {
          string m = GetPad(time.Minute.ToString());
          string s = GetPad(time.Second.ToString());
          return string.Format("{0} {1}", m, s);
      }
      
       //左边补0
       private string GetPad( string s)
      {
         s = s.PadLeft(2, char.Parse("0"));
          return s.Substring(s.Length - 2, 2);
      }
      
       private ControlButtonHandle _SetButtonStart;
       private ControlButtonHandle _SetButtonLost;
       private ControlButtonHandle _SetButtonRegret;
      
       public ControlButtonHandle HSetButtonStart { get { return _SetButtonStart; } set { _SetButtonStart = value; } }
       public ControlButtonHandle HSetButtonLost { get { return _SetButtonLost; } set { _SetButtonLost = value; } }
       public ControlButtonHandle HSetButtonRegret { get { return _SetButtonRegret; } set { _SetButtonRegret = value; } }
      
       public void SetButtonStart( bool enable)
      {
         _pbBegin.Invoke(_SetButtonStart, enable);
      }
      
       public void SetButtonLost( bool enable)
      {
         _pbLost.Invoke(_SetButtonLost, enable);
      }
      
       public void SetButtonRegret( bool enable)
      {
         _pbRegret.Invoke(_SetButtonRegret, enable);
      }
      
       /// <summary>
       /// 重设控制面板
       /// </summary>
       public void Reset()
      {
          //停掉计时器
          this.StopTimer(ChessColor.Black);
          this.StopTimer(ChessColor.Red);
         
          //重画图片
         _redHistory.Invoke(_SetImage, _redHistory, ChineseChess.Res.Properties.Resources.infopane);
         _blackHistory.Invoke(_SetImage, _blackHistory, ChineseChess.Res.Properties.Resources.infopane);
      }
   }
}