cardcollections.cs

C#纸牌游戏,做的还是比较精致的.值得学习.

using System;
using System.Collections;
using System.Drawing;
using System.Windows.Forms;
namespace CardGame
{
	public class CardCollections:CollectionBase
	{
		public const int MinHSpace=11;
		public const int MinVSpace=8;

		public static int HSpace=MinHSpace;
		public static int VSpace=MinVSpace;

		public static Panel gamePanel=null;

		protected Card baseCard=null;
		protected Point location=new Point(MinHSpace,MinVSpace);

		protected Point acceptOffsetPoint;
		protected Point backOffsetPoint;

		public delegate void CardAddDelegate(Card card,CardCollections cardsGroup);
		public event CardAddDelegate CardAdd;

		public delegate void CardRemoveDelegate(Card card);
		public event CardRemoveDelegate CardRemove;

		public static bool CanUndo=false;
		public static bool StartUndo=false;
		public static bool Undoing=false;
		private static History history=new History();

		public class History
		{
			public Card[] LastChangeCards=null;
			public CardCollections LastChangeCardsGroup=null;
			public bool AscOrder=false;
		}

		public int Left
		{
			get
			{
				return location.X;
			}
			set
			{
				Location=new Point(value,location.Y);
			}
		}
		public int Top
		{
			get
			{
				return location.Y;
			}
			set
			{
				Location=new Point(location.X,value);
			}
		}
		public Point Location
		{
			get
			{
				return location;
			}
			set
			{
				if(!location.Equals(value))
				{
					foreach(Card card in this)
					{
						card.Location=new Point(card.Left+value.X-baseCard.Left,card.Top+value.Y-baseCard.Top);
					}
					if(baseCard!=null)baseCard.Location=value;
				}
				location=value;
			}
		}

		public Point AcceptOffsetPoint
		{
			get
			{
				return acceptOffsetPoint;
			}
			set
			{
				acceptOffsetPoint=value;
			}
		}

		public Point BackOffsetPoint
		{
			get
			{
				return backOffsetPoint;
			}
		}

		public Card Peek()
		{
			if(Count==0)return null;
			return this[Count-1];
		}

		public CardCollections(Card baseCard,Point location):base()
		{
			this.baseCard=baseCard;
			this.location=location;
			if(this.baseCard!=null)
			{
				this.baseCard.Location=this.location;
				this.baseCard.CardsGroup=this;
				CardCollections.gamePanel.Controls.Add(this.baseCard);
			}
		}

		public Card BaseCard
		{
			get
			{
				return baseCard;
			}
			set
			{
				baseCard=value;
			}
		}

		public Card this[int index]
		{
			get
			{
				return (Card)base.InnerList[index];
			}
		}
		public void CopyTo(int index,Array array,int arrayIndex,int count)
		{
			base.InnerList.CopyTo(index,array,arrayIndex,count);
		}

		public static void Undo()
		{
			if(CanUndo)
			{
				if(history.LastChangeCards!=null&&history.LastChangeCardsGroup!=null)
				{
					Undoing=true;
					history.LastChangeCardsGroup.AddRange(history.LastChangeCards[0].CardsGroup,history.LastChangeCards[0].CardsGroup.Count-history.LastChangeCards.Length,history.LastChangeCards.Length,history.AscOrder);
					Undoing=false;
				}
				CanUndo=false;
			}
		}

		public virtual bool Add(Card card)
		{
			CardCollections cardsGroup=card.CardsGroup;
			if(cardsGroup!=null)cardsGroup.Remove(card);
			if(card.IsFace)
			{
				if(CanAcceptCard(card)||Undoing)
				{
					if(this.Count==0)
					{
						card.Location=this.BaseCard.Location;
					}
					else
					{
						Card c=this[Count-1];
						if(c.IsFace)
						{
							card.Location=new Point(c.Location.X+this.acceptOffsetPoint.X,c.Location.Y+this.acceptOffsetPoint.Y);
						}
						else
						{
							card.Location=new Point(c.Location.X+this.backOffsetPoint.X,c.Location.Y+this.backOffsetPoint.Y);
						}
					}
				}
				else
				{
					cardsGroup.Add(card);
					return false;
				}
			}
			else
			{
				if(this.Count==0)
				{
					card.Location=this.BaseCard.Location;
				}
				else
				{
					Card c=this[Count-1];
					card.Location=new Point(c.Location.X+this.backOffsetPoint.X,c.Location.Y+this.backOffsetPoint.Y);
				}
			}
			card.Index=Count;
			
			base.InnerList.Add(card);
			history.LastChangeCardsGroup=card.CardsGroup;
			card.CardsGroup=this;
			if(gamePanel!=null&&!gamePanel.Controls.Contains(card))gamePanel.Controls.Add(card);
			if(card.Parent!=null)card.Parent.Controls.SetChildIndex(card,0);
			if(StartUndo)CanUndo=true;
			history.LastChangeCards=new Card[]{card};

			if(CardAdd!=null)CardAdd(card,cardsGroup);
			return true;
			
		}
		
		public virtual bool AddRange(CardCollections cardsList,int index,int length,bool ascOrder)
		{
			Card[] cardarr=new Card[length];
			cardsList.CopyTo(index,cardarr,0,length);

			ArrayList addedCards=new ArrayList();

			bool result=true;
			if(ascOrder)
			{
				for(int i=0;i<cardarr.Length;i++)
				{
					if(Add(cardarr[i]))
					{
						addedCards.Add(history.LastChangeCards[0]);
					}
					else
					{
						result=false;
					}
				}
			}
			else
			{
				for(int i=cardarr.Length-1;i>=0;i--)
				{
					if(Add(cardarr[i]))
					{
						addedCards.Add(history.LastChangeCards[0]);
					}
					else
					{
						result=false;
					}
				}
			}
			if(result)
			{
				if(addedCards.Count==length)
				{
					history.LastChangeCards=new Card[length];
					addedCards.CopyTo(history.LastChangeCards);
					history.AscOrder=ascOrder;
				}
			}
			return result;

		}
		public virtual bool Remove(Card card)
		{
			if(card!=null&&base.InnerList.Contains(card))
			{
				if(CardRemove!=null)CardRemove(card);
				base.InnerList.Remove(card);
				return true;
			}
			return false;
		}
		protected override void OnClear()
		{
			foreach(Card card in this)
			{
				card.CardsGroup=null;
			}
		}
		public virtual bool CanAcceptCard(Card card)
		{
			return false;
		}
	}

	public class NormalCardCollections:CardCollections
	{
		public NormalCardCollections():this(null)
		{
		}

		public NormalCardCollections(Card baseCard):this(baseCard,baseCard.Location)
		{
			
		}

		public NormalCardCollections(Point location):this(null,location)
		{
			
		}

		public NormalCardCollections(Card baseCard,Point location):base(baseCard,location)
		{
			
		}

		public new NormalCard this[int index]
		{
			get
			{
				return (NormalCard)base[index];
			}
		}

		public NormalCard this[int faceNum,NormalCard.NormalCardFaceType faceType]
		{
			get
			{
				return (NormalCard)base[(faceNum-1)*4+(int)faceType];
			}
		}

		public new NormalCard Peek()
		{
			return (NormalCard)base.Peek();
		}

		public override bool CanAcceptCard(Card card)
		{
			if(card.IsFace)return true;
			return false;
		}
	}

	public class BackSenderCollections:NormalCardCollections
	{
		public BackSenderCollections(Card baseCard):base(baseCard,new Point(CardCollections.HSpace,CardCollections.VSpace))
		{
			backOffsetPoint=new Point(2,1);
		}

		public override bool Add(Card card)
		{
			if(card.IsFace)card.ShowBack();
			if(this.Count>0)
			{
				Card c=this[0];
				int n=Convert.ToInt32(this.Count/10);
				if(base.Add(card))
				{
					card.Location=new Point(c.Location.X+n*this.backOffsetPoint.X,c.Location.Y+n*this.backOffsetPoint.Y);
					return true;
				}
				return false;
			}
			return base.Add(card);
		}
	}


	public class FaceSenderCollections:NormalCardCollections
	{
		public FaceSenderCollections(Card baseCard):base(baseCard,new Point(2*CardCollections.HSpace+Cards.CardImageSize.Width,CardCollections.VSpace))
		{
			backOffsetPoint=new Point(2,1);
		}

		public override bool Add(Card card)
		{
			if(!card.IsFace)card.ShowFace();
			if(this.Count>0)
			{
				int n=Convert.ToInt32(this.Count/10);
				if(base.Add(card))
				{
					card.Location=new Point(baseCard.Left+n*this.backOffsetPoint.X,baseCard.Top+n*this.backOffsetPoint.Y);
					return true;
				}
				return false;
			}
			return base.Add(card);
		}

		private ArrayList undoCards=new ArrayList();

		public void AddRange(CardCollections cardsList,int index,int length)
		{
			Card[] cardarr=new Card[length];
			cardsList.CopyTo(index,cardarr,0,length);

			if(base.AddRange(cardsList,index,length,false))
			{
				int n=0;
				undoCards.Clear();
				for(int i=0;i<this.Count-length;i++)
				{
					n=Convert.ToInt32(i/10);
					Card card=(Card)this[i];
					Point point=new Point(baseCard.Left+n*backOffsetPoint.X,baseCard.Top+n*backOffsetPoint.Y);
					if(!card.Location.Equals(point))
					{
						undoCards.Add(card);
						card.Location=point;
					}
				}
				for(int i=this.Count-length;i<this.Count;i++)
				{
					int j=this.Count-i-1;
					int k=length-j-1;
					cardarr[j].Location
						=new Point(baseCard.Left+n*backOffsetPoint.X+k*acceptOffsetPoint.X,baseCard.Top+n*backOffsetPoint.Y+k*acceptOffsetPoint.Y);
				}
			}
		}

		public override bool Remove(Card card)
		{
			if(CardCollections.Undoing&&undoCards.Count>0)
			{
				CardCollections group=card.CardsGroup;
				int n=Convert.ToInt32(card.Index/10);
				Point point=new Point(baseCard.Left+n*backOffsetPoint.X,baseCard.Top+n*backOffsetPoint.Y);
				if(card.Location==point)
				{
					if(base.Remove(card))
					{
						for(int i=0;i<undoCards.Count;i++)
						{
							Card c1=(Card)undoCards[i];
							Card c2=group[c1.Index-1];
							c1.Location=new Point(c2.Left+group.AcceptOffsetPoint.X,c2.Top+group.AcceptOffsetPoint.Y);
						}
						undoCards.Clear();
						return true;
					}
					return false;
				}
			}
			return base.Remove(card);
		}
	}

	public class UnDealtCollections:NormalCardCollections
	{
		public UnDealtCollections(Card baseCard,int left):base(baseCard,new Point(left,2*CardCollections.VSpace+Cards.CardImageSize.Height))
		{
			acceptOffsetPoint=new Point(0,15);
			backOffsetPoint=new Point(0,3);
		}
		public override bool CanAcceptCard(Card card)
		{
			if(base.CanAcceptCard(card)&&card is NormalCard)
			{
				NormalCard card1=(NormalCard)card;
				NormalCard card2=(NormalCard)this.Peek();
				if(card2==null)
				{
					if(card1.FaceNum==13)
						return true;
				}
				else if(card1.FaceNum+1==card2.FaceNum&&card1.FaceType!=card2.FaceType&&(int)card1.FaceType+(int)card2.FaceType!=3)
				{
					return true;
				}
			}
			return false;
		}
	}

	public class DealtCollections:NormalCardCollections
	{
		private static int dealtCount=0;
		public static event EventHandler AllDealt;

		public DealtCollections(Card baseCard,int left):base(baseCard,new Point(left,CardCollections.VSpace))
		{
			
		}
		
		public override bool CanAcceptCard(Card card)
		{
			if(base.CanAcceptCard(card)&&card is NormalCard)
			{
				NormalCard card1=(NormalCard)card;
				NormalCard card2=(NormalCard)this.Peek();
				if(card2==null)
				{
					if(card1.FaceNum==1)
						return true;
				}
				else if(card1.FaceNum-1==card2.FaceNum&&card1.FaceType==card2.FaceType)
				{
					return true;
				}
			}
			return false;
		}

		public override bool Add(Card card)
		{
			if(base.Add(card))
			{
				dealtCount++;
				if(dealtCount==52)
				{
					if(AllDealt!=null)AllDealt(this,EventArgs.Empty);
				}
				return true;
			}
			return false;
		}

		public override bool Remove(Card card)
		{
			if(base.Remove(card))
			{
				return true;
			}
			return false;
		}

		protected override void OnClear()
		{
			dealtCount-=Count;
			base.OnClear();
		}

	}

}