网页游戏五子棋(1) 基础类实现

基础的类：

Dipper.Games.Room 这是游戏房间基础类，相关游戏从这里继承

namespace Dipper.Games
{
    public class Room
    {
        protected Min.Lu.SqlHelper mySql = new Min.Lu.SqlHelper();//数据库的包裹类
        protected int _roomId; //房间ID
        protected string _roomName; //房间名字
        protected int _roomPeopleOnline; //房间在线玩家数
        protected string _roomState; //房间状态 1.进行中 2.开放中
        protected Player[] _roomPlayer; //房间玩家数组
        protected int _roomPeopleMax; //房间最大人数，游戏的不同，游戏玩家数量不通，用来判定房间状态

        public Player[] RoomPlayer
        {
            get { return _roomPlayer; }
        }

        public int RoomPeopleMax
        {
            get { return _roomPeopleMax; }
        }

        public int RoomId
        {
            get { return _roomId; }
        }

        public string RoomName
        {
            get { return _roomName; }
        }

        public int RoomPeopleOnline
        {
            get { return _roomPeopleOnline; }
        }

        public string RoomState
        {
            get { return this._roomState; }
            set { this._roomState = value; }
        }

        public Room(int roomId, string roomName, string roomState, int roomPeopleMax)
        {
            this._roomId = roomId;
            this._roomName = roomName;
            this._roomState = roomState;
            this._roomPeopleOnline = 0;
            this._roomPeopleMax = roomPeopleMax;
            this._roomPlayer = new Player[roomPeopleMax];
        }
        //desktopid 玩家的游戏ID，指的是你所在游戏桌面的ID
        public virtual void SubPlayer(int desktopId)
        {
            if (_roomPlayer[desktopId].IsAuto)
            {
                this.SubPlayer(_roomPlayer[desktopId].UserNext); //isAuto 是否托管，在五子棋中相当于是否人机对战，如果是这里会在你离开游戏后，删除
            }
            _roomPlayer[desktopId] = null;
            this._roomPeopleOnline--;
            for (int i = 0; i < _roomPlayer.Length - 1; i++)
            {//玩家离开后，对玩家数组进行排序，排序的目的就是让玩家桌面ID等于玩家数组ID
                for (int j = 0; j < _roomPlayer.Length - 1; j++)
                {
                    if (_roomPlayer[j] == null)
                    {
                        _roomPlayer[j] = _roomPlayer[j + 1];
                        _roomPlayer[j + 1] = null;
                    }
                    else
                    {
                        _roomPlayer[j].IsReady = false;
                    }
                }
            }
            this._roomState = "开放中";
        }

        public virtual int AddPlayer(Player player)
        {
            for (int i = 0; i < _roomPlayer.Length; i++)
            {
                if (_roomPlayer[i] != null)
                {
                    if (_roomPlayer[i].Equals(player))
                    {
                        return i;
                    }
                    this._roomPeopleOnline++;
                }
                else
                {
                    if (i == _roomPlayer.Length - 1)
                    {
                        this._roomState = "进行中";
                    }
                    else
                    {
                        this._roomState = "开放中";
                    }
                    _roomPlayer[i] = player; //增加一个玩家
                    _roomPlayer[i].DesktopId = i; //赋值桌面ID
                    _roomPlayer[i].UserPrevious = i == 0 ? _roomPlayer.Length - 1 : i - 1; //玩家的上家ID
                    _roomPlayer[i].UserNext = i == _roomPlayer.Length - 1 ? 0 : i + 1; //玩家的下家ID
                    return i;
                }
            }
            return -1;
        }

        public int First()
        {//产生哪个玩家先开始的随机数
            Random rand = new Random();
            return rand.Next(this._roomPeopleMax);
        }
    }
}

 

Dipper.Games.Player 游戏玩家的类

namespace Dipper.Games
{
    public class Player
    {
        private int _userId; /用户ID
        private string _userName; //用户名称
        private int _userPrevious; //上一个玩家ID
        private int _userNext; //下一个玩家ID
        private bool _isFirst; //是否先开局
        private int _userTime; //玩家剩余时间，超过此时间就判为输
        private int _desktopId; //桌面ID，其实就是房间用户数组ID
        private bool _isReady; //是否准备好了
        private bool _isAuto; //是否托管，在五子棋里就是人机对战
        private int _userTeam; //玩家分组，主要指在多人对战里，玩家所在的组，用来最后分钱用的
        private int _moneyAnte; //游戏赌注
        private int _moneySum; //玩家输赢的赌注

        public int UserTime
        {
            get { return _userTime; }
            set { _userTime = value; }
        }

        public bool IsFirst
        {
            get { return _isFirst; }
            set { _isFirst = value; }
        }

        public int UserTeam
        {
            get { return _userTeam; }
            set { _userTeam = value; }
        }
        
        public int MoneyAnte
        {
            set { _moneyAnte = value; }
            get { return _moneyAnte; }
        }

        public int MoneySum
        {
            get { return _moneySum; }
        }

        public Player(int userId, string userName, int desktopId, bool isReady, bool isAuto, int moneyAnte, int userPrevious, int userNext, int userTime)
        {
            this._userId = userId;
            this._userName = userName;
            this._desktopId = desktopId;
            this._isReady = isReady;
            this._moneyAnte = moneyAnte;
            this._isAuto = isAuto;
            this._userPrevious = userPrevious;
            this._userNext = userNext;
            this._moneySum = 0;
            this._userTime = userTime;
            this._isFirst = false;
        }

        public int UserId
        {
            get { return this._userId; }
        }

        public string UserName
        {
            get { return this._userName; }
        }

        public int UserPrevious
        {
            get { return this._userPrevious; }
            set { this._userPrevious = value; }
        }

        public int UserNext
        {
            get { return this._userNext; }
            set { this._userNext = value; }
        }

        public bool IsReady
        {
            set { this._isReady = value; }
            get { return this._isReady; }
       
        }

        public bool IsAuto
        {
            set { this._isAuto = value; }
            get { return this._isAuto; }
        }

        public int DesktopId
        {
            get { return this._desktopId; }
            set { this._desktopId = value; }
        }

        public void AddMoney(int money)
        {
            this._moneySum += money;
            try
            {/*向数据库写数据*/}
            catch { }
        }

        public void AddMoney()
        {
            this.AddMoney(this._moneyAnte);
        }

        public void SubMoney(int money)
        {
            this._moneySum -= money;
            try
            {/*向数据库写数据*/}
            catch { }
        }

        public void SubMoney()
        {
            this.SubMoney(this._moneyAnte);
        }

        public override bool Equals(object obj)
        {
            try
            {
                Player player = obj as Player;
                return this.UserId == player.UserId;
            }
            catch
            {
                return false;
            }
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public override string ToString()
        {
            return "<a href=\"#" + this._userId + "\">" + this._userName + "</a>";
        }
    }
}

 

Dipper.Games.DynamicListAttribute 这作用是当向bin文件夹添加某个游戏的dll的时候，后自动在游戏列表中的相应位置显示出了，相当于游戏插件的功能，不重要

namespace Dipper.Games
{
    [AttributeUsage(AttributeTargets.Class)]
    public class DynamicListAttribute : System.Attribute
    {
        private string _listUrl;
        private int _listIndex;

        public int ListIndex
        {
            get { return _listIndex; }
        }

        public string ListUrl
        {
            get { return _listUrl; }
        }

        public DynamicListAttribute(string listText, string listUrl, int listIndex)
        {
            _listIndex = listIndex;
            _listUrl = "<div class=\"left3\"><a href=\"" + listUrl + "\" target=\"main\">" + listText + "</a></div>";
        }
    }
}