那个是类属性，当然是自己定义的，你看看这里的代码哪一句和界面有关？
BeelineCheck也是自己写的一个判断方法，为什么要返回true或是false？
因为棋子类只负责自己的行为，不会去管界面的事，这是类的基本设计源则，
返回false表示走法不符合规则，比如说炮可能翻两座山去打子么？或是不翻山，走接吃对方的棋子？？不可能吧！
最后由控制逻辑去处理棋子类的返回值，决定是否走子并显示。

所以面象对象的思路和你现在学的过程式写的象棋是两回事。。

你再看看我们是如何放棋子在棋盘上的。

       /// <summary>
        /// 初始化棋子在棋盘中的位置
        /// </summary>
        private void InitChesses()
        {
            ClsCarriage BCarriage1 = new ClsCarriage("黑");
            BCarriage1._currPoint = chessboard[0, 0];
            chessboard[0, 0].currChess = BCarriage1;

            ClsCarriage BCarriage2 = new ClsCarriage("黑");
            BCarriage2._currPoint = chessboard[8, 0];
            chessboard[8, 0].currChess = BCarriage2;

            ClsHorse BHorse1 = new ClsHorse("黑");
            BHorse1._currPoint = chessboard[1, 0];
            chessboard[1, 0].currChess = BHorse1;

            ClsHorse BHorse2 = new ClsHorse("黑");
            BHorse2._currPoint = chessboard[7, 0];
            chessboard[7, 0].currChess = BHorse2;

            ClsElephant BElephant1 = new ClsElephant("黑");
            BElephant1._currPoint = chessboard[2, 0];
            chessboard[2, 0].currChess = BElephant1;

            ClsElephant BElephant2 = new ClsElephant("黑");
            BElephant2._currPoint = chessboard[6, 0];
            chessboard[6, 0].currChess = BElephant2;

            ClsKavass BKavass1 = new ClsKavass("黑");
            BKavass1._currPoint = chessboard[3, 0];
            chessboard[3, 0].currChess = BKavass1;

            ClsKavass BKavass2 = new ClsKavass("黑");
            BKavass2._currPoint = chessboard[5, 0];
            chessboard[5, 0].currChess = BKavass2;

            ClsKing BKing = new ClsKing("黑");
            BKing._currPoint = chessboard[4, 0];
            chessboard[4, 0].currChess = BKing;

            ClsCannon BCannon1 = new ClsCannon("黑");
            BCannon1._currPoint = chessboard[1, 2];
            chessboard[1, 2].currChess = BCannon1;

            ClsCannon BCannon2 = new ClsCannon("黑");
            BCannon2._currPoint = chessboard[7, 2];
            chessboard[7, 2].currChess = BCannon2;

            ClsSoldier BSoldier1 = new ClsSoldier(0, "黑");
            ClsSoldier BSoldier2 = new ClsSoldier(0, "黑");
            ClsSoldier BSoldier3 = new ClsSoldier(0, "黑");
            ClsSoldier BSoldier4 = new ClsSoldier(0, "黑");
            ClsSoldier BSoldier5 = new ClsSoldier(0, "黑");

            BSoldier1._currPoint = chessboard[0, 3];
            BSoldier2._currPoint = chessboard[2, 3];
            BSoldier3._currPoint = chessboard[4, 3];
            BSoldier4._currPoint = chessboard[6, 3];
            BSoldier5._currPoint = chessboard[8, 3];

            chessboard[0, 3].currChess = BSoldier1;
            chessboard[2, 3].currChess = BSoldier2;
            chessboard[4, 3].currChess = BSoldier3;
            chessboard[6, 3].currChess = BSoldier4;
            chessboard[8, 3].currChess = BSoldier5;

这样做有什么好处？为什么不采用你写的二维固定数组方式？不要忘了通过摆子可以实现摆残局。。下古谱的。

也就是说
 ClsChess.cs 棋子类
包含
ClsCannon.cs 炮类
ClsCarriage.cs 车类
ClsElephant.cs 象类
ClsHorse.cs 马类
ClsKavass.cs 士类
ClsKing.cs 王类
ClsSoldier.cs 兵类
棋子基类可以定义一些public 属性供子类继承， 每个子类可以定义一些private & protect 属性以便
处理特定的要求。完善了一个类的属性和方法就实现了类的封装吗？
我现在的问题是对类的应用比较模糊 怎么实现类与程序的衔接 说的具体点 炮能隔山打牛 那怎么让他到制定的
窗口类上去表演呢？

棋子基类提供所有棋子的基本方法和属性，以供各种具体的棋子类去继承，利用的是类继承基本特性。
这个类是怎么来的，最终是通过抽象的思维得来的，既找出具体棋子类的都具有的方法和属性得到。

这个是完整的棋子基类代码：注意里面用到的枚举，虚函数。BeelineCheck也在这里自己定义，方便调用。


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

namespace CnChess
{
    /// <summary>
    /// 棋子色彩枚举
    /// </summary>
    public enum EnumChessType
    {
        黑,
        红
    }

    /// <summary>
    /// 棋子名称枚举
    /// </summary>
    public enum EnumChessName
    {
        将,
        士,
        象,
        马,
        车,
        炮,
        兵
    }

    /// <summary>
    /// 棋子基类
    /// </summary>
    public class ClsChess
    {
        public EnumChessType _chessType;       //棋子色彩
        public EnumChessName _chessName;       //棋子名称
        public ClsPoint _currPoint;            //当前坐标点
        protected Image chessImage;            //棋子对应的图片

        public Image ChessImage
        {
            get
            {
                return chessImage;
            }
            set
            {
                chessImage = value;
            }
        }
        
        /// <summary>
        /// 棋子的移动方法,子类需要重写
        /// </summary>
        /// <param name="point"></param>
        /// <returns></returns>
        public virtual bool MoveTo(ClsPoint point)
        {
            _currPoint.currChess = null;        //把棋子拿起来

            _currPoint = point;                 //放到新的坐标点上
            point.currChess = this;             //新坐标点上的棋子替换成当前移动的棋子

            return true;
        }

        /// <summary>
        /// 判断两点间直线坐标点上有几个棋子
        /// </summary>
        /// <param name="point">新点坐标</param>
        /// <param name="offset">坐标偏移量</param>
        /// <param name="type">判断类型，true为横向判断,false为纵向判断</param>
        /// <returns>返回两点间棋子的个数</returns>
        public int BeelineCheck(ClsPoint point, int offset, bool type)
        {
            //x,y起点
            int x, y;
            //棋子计数器
            int Count = 0;

            ClsBoard board = point.ChessBoard;

            //如果新点坐标比原点坐标大，交换一下起点坐标
            if (_currPoint.point_x > point.point_x)
            {
                x = point.point_x;
            }
            else
            {
                x = _currPoint.point_x;
            }

            if (_currPoint.point_y > point.point_y)
            {
                y = point.point_y;
            }
            else
            {
                y = _currPoint.point_y;
            }

            while ((offset - 1) > 0)
            {
                //横线检查两点间棋子的个数
                if (type)
                {
                    if (board[++x, y].currChess != null)
                    {
                        Count++;
                    }

                }
                //竖线检查两点间棋子的个数
                else
                {
                    if (board[x, ++y].currChess != null)
                    {
                        Count++;
                    }
                }

                offset--;
            }
            //返回棋子的个数
            return Count;
        }
    }
}

走子最终的显示实现，其实你已经知道了，就是通过重绘棋盘点上的棋子实现的。。。难吗？不难吧？

写程序时，如果你能向偶这样多写点注释，以后不管什么时候来回顾这些代码，都是很快会理清思路的。

另外，这段虽然是C#的，但我们用纯C就不能实现类似的代码么？思考一下吧。

[ 本帖最后由 hellovfp 于 2012-5-17 14:21 编辑 ]

你的棋盘是一个chessboard[9][10]的数组吧 每个数组点chessboard[i][j].currChess = BCarriage1;这个
BCarriage1
BCarriage2
BCarriage3
BCarriage4
……应该有个具体的值吧 这个和我那个Chessman[256] 每个元素对应一个值。是 0 就表示没子 8--14表示红子类
16--22表示黑子类 应该有相通的地方吧。

是有相通之处，不过是对象数组的概念。
这些代码还是等你以后学习了Class以后再讲吧，这种设计思维不是一时半会儿就能领悟的。
只要思维打开后，用什么语言写都是差不多的，特别是带类的语言，如Java, C#, C++， OjbectC，甚至是JavaScript也可以。

    while ((offset - 1) > 0)
            {
                //横线检查两点间棋子的个数
                if (type)
                {
                    if (board[++x, y].currChess != null)
                    {
                        Count++;
                    }

                }
                //竖线检查两点间棋子的个数
                else
                {
                    if (board[x, ++y].currChess != null)
                    {
                        Count++;
                    }
                }

                offset--;
            }
            //返回棋子的个数
            return Count;

看了 这段代码才知道刚才问那个true 和 false 的问题 原来 bool type不是用来返回的 而是横竖判断的两种方式
这样就顺了 if (BeelineCheck(point, offset, true) == 1)的意思就是 if (X_BlockChess.count == 1) 哈哈。


[ 本帖最后由 有容就大 于 2012-5-17 14:39 编辑 ]

试问苍天有多高，一步登天行不行？

我们要多快好省的实现社会主义