IDC资讯中心
file: cardcollection.cs
using system;
using system.diagnostics ;
namespace bigeagle.games.cards
{
/// <summary>
/// 牌集合
/// <br>author: bigeagle</br>
/// <br>date: 2002/4/19</br>
/// <br>history: 2002/4/19</br>
/// </summary>
public class cardcollection : system.collections.icollection
{
#region 成员变量
/// <summary>
/// 牌数组
/// </summary>
protected card[] m_arrcards ;
/// <summary>
/// 大小
/// </summary>
protected int m_intsize ;
/// <summary>
/// 最后一个有效元素的索引
/// </summary>
protected int m_intcapacity ;
#endregion
#region 构造函数
/// <summary>
/// 构造函数
/// </summary>
public cardcollection()
{
this.m_arrcards = new card[16] ;
this.m_intcapacity = -1 ;
this.m_intsize = 0 ;
}
#endregion
#region 类方法
/// <summary>
/// 重新设置容量
/// </summary>
/// <param name="capacity">要设置的容量</param>
private void setcapacity(int capacity)
{
card[] cards = new card[capacity];
if (this.m_intsize > 0)
{
if (this.m_intcapacity > 0)
{
array.copy(this.m_arrcards , 0 , cards , 0, this.m_intsize) ;
}
// else
// {
// array.copy(this.m_arrcards , 0 , cards , 0, this.m_arrcards.length);
// array.copy(this.m_arrcards , 0 , cards , this.m_arrcards.length, this.m_intcapacity);
// }
}
//this.m_intsize = capacity ;
this.m_arrcards = cards ;
//this.m_intcapacity = this.m_intsize -1 ;
}
/// <summary>
/// 取得元素
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
internal object getelement(int i)
{
if(i < 0 || i >= this.m_intsize)
{
throw(new indexoutofrangeexception()) ;
}
return this.m_arrcards[i] ;
}
/// <summary>
/// 添加一个元素
/// </summary>
/// <param name="a_objcard"></param>
public void add(card a_objcard)
{
foreach(card c in this.m_arrcards)
{
if(c != null && c.equals(a_objcard))
{
throw(new cardalreadyexistsexception(c , "牌已经存在")) ;
}
}
if (this.m_intcapacity == this.m_arrcards.length -1)
{
int newcapacity = this.m_arrcards.length + 16 ;
setcapacity(newcapacity);
}
this.m_intcapacity ++ ;
this.m_arrcards[this.m_intcapacity] = a_objcard;
this.m_intsize ++ ;
//this.m_intcapacity ++ ;
//this.m_intsize ++ ;
}
/// <summary>
/// 删除元素
/// </summary>
/// <param name="a_objcard">要删除的card对象</param>
public void remove(card a_objcard)
{
card[] cards = new card[this.m_arrcards.length] ;
int intindex = -1 ;
for(int i = 0 ; i < this.m_arrcards.length ; i ++)
{
if(a_objcard == this.m_arrcards[i])
{
intindex = i ;
break ;
}
}
if(intindex == -1)
{
throw(new cardnotfoundexception(a_objcard , "集合中未找到指定对象")) ;
}
else
{
removeat(intindex) ;
}
}//end method
/// <summary>
/// 删除元素
/// </summary>
/// <param name="a_intindex">要删除元素的索引</param>
public void removeat(int a_intindex)
{
card[] cards = new card[this.m_arrcards.length] ;
if(a_intindex < 0 || a_intindex > this.m_intsize – 1)
{
throw(new indexoutofrangeexception()) ;
}
else
{
if(a_intindex > 0)
{
array.copy(this.m_arrcards , 0 , cards , 0 , a_intindex) ;
array.copy(this.m_arrcards , a_intindex + 1 , cards
, a_intindex , this.m_arrcards.length – a_intindex -1) ;
}
else
{
array.copy(this.m_arrcards , 1 , cards , 0 , this.m_arrcards.length – 1) ;
}
this.m_arrcards = cards ;
this.m_intcapacity — ;
this.m_intsize — ;
}
}
/// <summary>
/// 排序
/// </summary>
/// <param name="a_bisreverse">排序方向，为真则从大到小排列，否则从小到大排列</param>
// public void sort(bool a_bisreverse)
// {
// card temp = new card() ;
// for(int i = 0 ; i < this.m_arrcards.length ; i ++)
// {
//
// }
// }
#endregion//end 类方法
#region 重写父接口方法。
/// <summary>
/// 拷贝数组
/// </summary>
/// <param name="array">数组对象</param>
/// <param name="index">索引</param>
public void copyto(system.array array, int index)
{
this.m_arrcards.copyto(array , index) ;
}
/// <summary>
/// 取得有效元素数
/// </summary>
public int count
{
get
{
return this.m_intsize ;
}
}
public bool issynchronized
{
get
{
return false ;
}
}
public object syncroot
{
get
{
return this;
}
}
public system.collections.ienumerator getenumerator()
{
return (new cardenumerator(this)) ;
}
/// <summary>
/// 重载取得哈希值
/// </summary>
/// <returns></returns>
public override int gethashcode()
{
int result = 0 ;
for(int i = 0 ; i < this.m_intsize ; i ++)
{
result += this.m_arrcards[i].gethashcode() ;
}
return result;
}
#endregion
#region 静态方法
/// <summary>
/// 取得一副牌
/// </summary>
/// <param name="a_bincludejoker"></param>
/// <returns></returns>
public static cardcollection generatecards(bool a_bincludejoker)
{
//临时数组
cardcollection temp = new cardcollection() ;
//产生一个顺序牌集合
if(a_bincludejoker)
{
temp.add(new joker()) ;
temp.add(new vicejoker()) ;
}
card card ;
for(int i = 0 ; i < 4 ; i ++)
{
for(int j = 14 ; j > 1 ; j –)
{
card = new card() ;
card.colors = (cardcolors)i ;
card.number = (cardnumbers)j ;
temp.add(card) ;
}
}
return temp ;
}//end method
/// <summary>
/// 生成一副随机顺序的牌
/// </summary>
/// <param name="a_bincludejoker">是否包括大小王</param>
/// <returns>一副牌，如果包括大小王返回54张牌，否则返回52张</returns>
public static cardcollection generaterandomcards(bool a_bincludejoker)
{
//结果
cardcollection result = new cardcollection() ;
//临时数组
cardcollection temp = new cardcollection() ;
//总共产生的牌数
int intcardcount = a_bincludejoker ? 54 : 52 ;
temp = cardcollection.generatecards(a_bincludejoker) ;
//随机排出顺序
//用时间做种子数，用unchecked关键字防止溢出
int seed = unchecked((int)datetime.now.ticks) ;
random random = new random(seed) ;
int index = 0 ;
while(temp.count > 0)
{
index = random.next(temp.count) ;
result.add(temp[index]) ;
temp.removeat(index) ;
}
return result ;
}//end method
#endregion
#region 索引器
/// <summary>
/// 索引器
/// </summary>
public card this[int index]
{
get
{
if(index < 0 || index > this.count)
{
throw(new indexoutofrangeexception()) ;
}
return this.m_arrcards[index] ;
}
set
{
if(index < 0 || index > this.count)
{
throw(new indexoutofrangeexception()) ;
}
this.m_arrcards[index] = value ;
}
}
#endregion
#region 嵌套类
/// <summary>
/// 牌集合迭代
/// <br>author: bigeagle</br>
/// <br>date: 2002/4/19</br>
/// <br>history: 2002/4/19</br>
/// </summary>
public class cardenumerator : system.collections.ienumerator
{
private cardcollection m_objcollection;
private int m_intindex;
private object m_objcurrentelement;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="a_objcardcollection"></param>
internal cardenumerator(cardcollection a_objcardcollection)
{
this.m_objcollection = a_objcardcollection ;
this.m_intindex = 0 ;
this.m_objcurrentelement = this.m_objcollection.m_arrcards ;
if (this.m_objcollection.m_intsize == 0)
this.m_intindex = -1;
}
/// <summary>
/// 移到下一个元素
/// </summary>
/// <returns>如果索引小于0返回假，否则返回真</returns>
public bool movenext()
{
if (this.m_intindex < 0)
{
this.m_objcurrentelement = this.m_objcollection.m_arrcards ;
return false;
}
this.m_objcurrentelement = this.m_objcollection.getelement(this.m_intindex) ;
this.m_intindex ++ ;
if (this.m_intindex == this.m_objcollection.m_intsize)
{
this.m_intindex = -1;
}
return true;
}
/// <summary>
/// 重置
/// </summary>
public void reset()
{
if (this.m_objcollection.m_intsize == 0)
{
this.m_intindex = -1;
}
else
{
this.m_intindex = 0;
}
this.m_objcurrentelement = this.m_objcollection.m_arrcards ;
}
/// <summary>
/// 当前元素
/// </summary>
public object current
{
get
{
if (this.m_objcurrentelement == this.m_objcollection.m_arrcards)
{
if (this.m_intindex == 0)
throw new invalidoperationexception("无效操作");
else
throw new invalidoperationexception("无效操作");
}
return this.m_objcurrentelement ;
}
}
}//end class
#endregion
}//endclass
}//end namespace
