实验项目名称:纸牌游戏 

实验目的:

设计一个简单的CardGames程序,运用面向对象封装、继承、抽象类、抽象方法、多态、动态绑定等概念。

实验目标与要求:

参考windows的纸牌游戏

使用语言:java

实验内容:

单人纸牌游戏,牌桌上有7个堆共28张牌,第一堆1张牌,第二堆2张,。。。第77张,每一堆的第一张牌朝上,其他朝下。牌桌上还有4suitpiles,一个deck card堆和一个discard card堆,布局如下(参考windows的纸牌游戏)

 

程序的总体设计:

利用CRC (Class,Responsibility,and Collaboration) 方法来设计,由于实验是自己一人独立完成,在设计时没有多人参与crc设计,自己扮演了多个角色。

UML图:

 

 

 

 

 

主要代码及其说明:

1.     发配算法:

位于solitaire.game.Game类里面

 
  1. static
  2.         //初始化纸牌 
  3.         allCard = new ArrayList<Card>(); 
  4.         for (int i = 0; i < 4; i++) 
  5.             for (int j = 0; j <= 12; j++)  
  6.                 allCard.add(new Card(j, i)); 
  7.         Random generator = new Random(); 
  8.         for (int i = 0; i < 52; i++) { 
  9.             int j = Math.abs(generator.nextInt() % 52); 
  10.                 // swap the two card values 
  11.             Card temp = allCard.get(i); 
  12.             allCard.set(i, allCard.get(j)); 
  13.             allCard.set(j, temp); 
  14.         } 
  15.         //初始化牌堆 
  16.         allPiles = new CardPile[13]; 
  17.         suitPile = new SuitPile[4]; 
  18.         tablePile = new TablePile[7]; 
  19.             // then fill them in 
  20.         allPiles[0] = deckPile = new DeckPile(20040); 
  21.         allPiles[1] = discardPile = new DiscardPile(200+Card.width+5040); 
  22.         for (int i = 0; i < 4; i++) 
  23.             allPiles[2+i] = suitPile[i] = 
  24.                 new SuitPile(200+Card.width+50 + Card.width + 150 + (40+Card.width) * i, 40); 
  25.         for (int i = 0; i < 7; i++) 
  26.             allPiles[6+i] = tablePile[i] = 
  27.                 new TablePile(200 + (50+Card.width) * i, 40 + Card.height + 40, i);  
  28.         for (int i = 0; i < 7; i++){ 
  29.             ArrayList<Card> al = new ArrayList<Card>(); 
  30.             for(int j = 0;j < tablePile[i].getCardNum();j++){ 
  31.                 al.add(allCard.remove(allCard.size()-1)); 
  32.             } 
  33.             tablePile[i].addCard(al); 
  34.             tablePile[i].setCardNum(tablePile[i].getNotFlipNum()+1); 
  35.             //System.out.println(tablePile[i].getCardNum()); 
  36.             tablePile[i].top().setFaceup(true); 
  37.         } 
  38.         int rest =  allCard.size(); 
  39.         for(int i = 0;i < rest;i++ ){ 
  40.             deckPile.addCard(allCard.remove(allCard.size()-1)); 
  41.             //System.out.println( i); 
  42.         } 
  43.         moveCard = new MoveCardPile(); 
  44.     } 

说明:该算法先创建52张纸牌(Card)对象,并放置allCardArrayList)中,然后模拟现实当中的洗牌操作,主要是利用javaRandom来打乱allCard里牌的排列顺序,然后初始化各个牌堆类: deckPile, discardPile, tablePile, suitPile, moveCard。此外还建了一个数组allPilesCardPile[]),用于存储所有的牌堆类。最后将allCard中的纸牌牌(Card)对象分发至各个堆里。

2. select方法(solitaire.pile. CardPile):

传给该函数坐标用于判断点中该牌堆中的某张纸牌(还有个include方法用于判断是否点中牌堆),其中因为TablePile要支持选中多张纸牌,要改写CardPile的方法。

CardPileselect方法:

 
  1. public int select (int tx, int ty) { 
  2.  
  3.     if(includes(tx,ty)){ 
  4.  
  5.        if(isEmpty()) 
  6.  
  7.            return -2
  8.  
  9.        else 
  10.  
  11.            return thePile.size() - 1
  12.  
  13.     } 
  14.  
  15.     else 
  16.  
  17.        return -1
  18.  

TablePileselect方法:

 
  1. public int select(int tx, int ty) { 
  2.  
  3.        // TODO Auto-generated method stub 
  4.  
  5.        if(!(isEmpty())){ 
  6.  
  7.        int beginX,beginY,endX,endY; 
  8.  
  9.        //System.out.println(notFlipNum+"  "+cardNum); 
  10.  
  11.        beginX = x  ; 
  12.  
  13.        beginY = y + unFlipCardSeparation * notFlipNum; 
  14.  
  15.        endX = x + Card.width; 
  16.  
  17.        endY =  beginY  + unFlipCardSeparation * notFlipNum + separation * (thePile.size() - 1 - notFlipNum) + Card.height; 
  18.  
  19.        boolean flip_include =  beginX <= tx && tx <= endX && beginY <= ty && ty <= endY; 
  20.  
  21.        //System.out.println(beginY+"   "+endY); 
  22.  
  23.        if(flip_include){ 
  24.  
  25.          
  26.  
  27.         int c = (ty - beginY)/separation + notFlipNum; 
  28.  
  29.         if(c >= thePile.size()){ 
  30.  
  31.            c =  thePile.size() - 1
  32.  
  33.         } 
  34.  
  35.         return c;//从零开始 
  36.  
  37.        } 
  38.  
  39.        else 
  40.  
  41.            return -1
  42.  
  43.        } 
  44.  
  45.        else 
  46.  
  47.            return -1
  48.  
  49.     } 
  50.  
  51.   

3. isCanAdd方法

用于判断某张纸牌是否可以放于SuitePileTablePile

CardPile类:

 
  1. public boolean isCanAdd(Card card){ 
  2.  
  3.     return false
  4.  

SuitePile类:

 
  1. public boolean isCanAdd(Card card) { 
  2.  
  3.         // TODO Auto-generated method stub 
  4.  
  5.         if (isEmpty()) 
  6.  
  7.             return card.getNum() == 0; 
  8.  
  9.         Card toptopCard = top(); 
  10.  
  11.         return (card.getType() == topCard.getType()) && 
  12.  
  13.             (card.getNum() ==  topCard.getNum() + 1); 
  14.  
  15.         
  16.  
  17.     } 

Tablepile类:

 
  1. public boolean isCanAdd(Card card){ 
  2.  
  3.         // TODO Auto-generated method stub 
  4.  
  5.         if ( isEmpty()) 
  6.  
  7.             return card.getNum() == 12; 
  8.  
  9.         Card toptopCard = top(); 
  10.  
  11.         return (card.getColor() != topCard.getColor()) && 
  12.  
  13.             (card.getNum() ==  topCard.getNum()-1 ); 
  14.  
  15.     } 

4. refreshTablePile

用于刷新Tablepile,主要用于处理一走TablePile中的纸牌时剩余纸牌都是背面的时候,将最上面的纸牌翻转过来。

 
  1. public static void refreshTablePile(){ 
  2.  
  3.     //  System.out.println("refreshTablePile"); 
  4.  
  5.            
  6.  
  7.         for(int i=0;i<7;i++){ 
  8.  
  9.             if(tablePile[i].top() != null
  10.  
  11.             if(!(tablePile[i].top().isFaceup())){ 
  12.  
  13.                 tablePile[i].top().setFaceup(true); 
  14.  
  15.                 tablePile[i].setNotFlipNum(tablePile[i].getNotFlipNum()-1); 
  16.  
  17.             } 
  18.  
  19.         } 
  20.  
  21.     } 

实验截图:

 实验心得:

结合课堂上的学习,利用了面向对象的思想:继承,多态(改写,多台变量),范型等等,对面向对象思想有了更好的把握。

后来学习了设计原则,我觉得还得自己写的代码违背了许多原则,例如Game里面的CardPile不是抽象的,应将其声明为抽象的以便让其他类依赖抽象。此外我觉得可利用mvc架构来设计纸牌游戏,利用观察者模式来处理model的更改来更新view,用组成模式来设计view,利用策略模式来设计control。目前只初步设计了一下新的纸牌游戏。