Game.java
package com;
/**
* 遊戲的全局接口
* @author nt
*/
public interface Game {
String PLATFORM_NAME = "青鳥遊戲大廳";
String PLATFORM_VERSION = "1.0.1";
String FGF_NAME = "炸金花";
}
Player.java
package com;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 玩家基本信息類
* @author nt
*/
public class Player {
/**
* 定義一個玩家信息數據庫
*/
public static Map<String, Player> PLAYERS = new HashMap<String, Player>();
static {
for (int i = 0; i < 20; i++) {
int num = i + 1;
String numCode = (num < 10) ? ("0" + num) : (num + "");
String playerName = "PLAYER" + numCode;
PLAYERS.put(playerName, new Player(playerName));
}
}
// 玩家的賬號
private String playeName;
// 玩家的積分
private int score;
// 玩家的遊戲日誌
private List<String> gameLogs = new ArrayList<String>();
public String getPlayeName() {
return playeName;
}
public void setPlayeName(String playeName) {
this.playeName = playeName;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public List<String> getGameLogs() {
return gameLogs;
}
public void setGameLogs(List<String> gameLogs) {
this.gameLogs = gameLogs;
}
public Player() {
super();
}
/**
* 根據賬號名生成一個玩家對象
* @param playeName
*/
public Player(String playeName) {
super();
this.playeName = playeName;
}
@Override
public String toString() {
return this.playeName;
}
}
Card.java
package com.card;
/**
* 所有牌的父類
* @author nt
*/
public class Card {
private String cardName;
public String getCardName() {
return cardName;
}
public void setCardName(String cardName) {
this.cardName = cardName;
}
}
CardGameRuleService.java
package com.card;
/**
* 牌類遊戲的規則接口
* @author nt
*/
public interface CardGameRuleService {
/**
* 雙方手牌的大小比較方法
* @param cardHand1
* @param cardHand2
* @return
*/
int rule(CardHand cardHand1, CardHand cardHand2);
}
CardGameService.java
package com.card;
import java.util.ArrayList;
import java.util.List;
public abstract class CardGameService {
// 一副牌
public List<Card> cards;
// 所有玩家的手牌集合
public List<CardHand> playersCards;
// 遊戲名稱
private String gameName;
// 玩家數量
private int playerNums;
// 房間號
private String roomCode;
// 當前房間的遊戲回合
private int round;
/**
* 洗牌方法
*/
public void shuffle() {
setRound(getRound() + 1);
cards = new ArrayList<Card>();
playersCards = new ArrayList<CardHand>();
}
/**
* 發牌方法
*/
public abstract void deal();
/**
* 關閉牌局
*/
public abstract void close();
/**
* Getter & Setter
* @return
*/
public List<Card> getCards() {
return cards;
}
public void setCards(List<Card> cards) {
this.cards = cards;
}
public List<CardHand> getPlayersCards() {
return playersCards;
}
public void setPlayersCards(List<CardHand> playersCards) {
this.playersCards = playersCards;
}
public String getGameName() {
return gameName;
}
public void setGameName(String gameName) {
this.gameName = gameName;
}
public int getPlayerNums() {
return playerNums;
}
public void setPlayerNums(int playerNums) {
this.playerNums = playerNums;
}
public String getRoomCode() {
return roomCode;
}
public void setRoomCode(String roomCode) {
this.roomCode = roomCode;
}
public int getRound() {
return round;
}
public void setRound(int round) {
this.round = round;
}
}
CardHand.java
package com.card;
/**
* 牌類遊戲的手牌超級父接口,只實現需要完成比較的接口定義
* @author nt
*/
public interface CardHand extends Comparable<CardHand>{
}
Poker.java
package com.card;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 定義撲克牌類 要實現Comparable接口,讓撲克牌具備可比的規則功能
* @author nt
*/
public class Poker extends Card implements Comparable<Poker> {
// 所有花色數組
public static String[] TYPES = { "♦", "♣", "♥", "♠" };
// 所有點數數組
public static String[] POINTS = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A" };
// 花色權值
public static Map<String, Integer> TYPES_VALUES = new HashMap<String, Integer>();
// 點數權值
public static Map<String, Integer> POINTS_VALUES = new HashMap<String, Integer>();
static {
for (int i = 0; i < TYPES.length; i++) {
TYPES_VALUES.put(TYPES[i], i + 1);
}
for (int i = 0; i < POINTS.length; i++) {
POINTS_VALUES.put(POINTS[i], i + 2);
}
}
// 花色
private String type;
// 牌點
private String point;
public Poker(String tp) {
// 給花色賦值
this.type = tp.substring(0, 1);
// 給點數賦值
this.point = tp.substring(1);
}
@Override
public String toString() {
String rs = this.type + this.point;
if (rs.length() == 2)
rs += " ";
return rs;
}
@Override
public int compareTo(Poker o) {
// 先比點數,點數權值大則,小則小,相同點數,比花色權值
if (o.getPointValue() > this.getPointValue())
return -1;
if (o.getPointValue() < this.getPointValue())
return 1;
if (o.getTypeValue() > this.getTypeValue())
return -1;
if (o.getTypeValue() < this.getTypeValue())
return 1;
return 0;
}
/**
* Getter & Setter
* @return
*/
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getPoint() {
return point;
}
public void setPoint(String point) {
this.point = point;
}
// 獲取花色權值
public Integer getTypeValue() {
return TYPES_VALUES.get(this.type);
}
// 獲取點數權值
public Integer getPointValue() {
return POINTS_VALUES.get(this.point);
}
}
FgfCardHand.java
package com.card.fgf;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.Player;
import com.card.CardHand;
import com.card.Poker;
public class FgfCardHand implements CardHand {
public static Map<Integer, String> HAND_TYPES = new HashMap<Integer, String>();
static {
HAND_TYPES.put(1, "單散牌");
HAND_TYPES.put(2, "對子牌");
HAND_TYPES.put(3, "順子牌");
HAND_TYPES.put(4, "亂金牌");
HAND_TYPES.put(5, "順金牌");
HAND_TYPES.put(6, "豹子牌");
}
public static int HAND_TYPE_VALUE_DSP = 1;
public static int HAND_TYPE_VALUE_DZP = 2;
public static int HAND_TYPE_VALUE_LSP = 3;
public static int HAND_TYPE_VALUE_LJP = 4;
public static int HAND_TYPE_VALUE_SJP = 5;
public static int HAND_TYPE_VALUE_BZP = 6;
private String playerName;
private Poker poker1;
private Poker poker2;
private Poker poker3;
private int cardsType;
public FgfCardHand() {
super();
}
public FgfCardHand(String playerName, Poker poker1, Poker poker2, Poker poker3) {
super();
this.playerName = playerName;
List<Poker> pokers = new ArrayList<Poker>();
pokers.add(poker1);
pokers.add(poker2);
pokers.add(poker3);
Collections.sort(pokers);
this.poker1 = pokers.get(0);
this.poker2 = pokers.get(1);
this.poker3 = pokers.get(2);
this.cardsType = getCardsType();
}
@Override
public String toString() {
int score = Player.PLAYERS.get(this.playerName).getScore();
return (this.playerName + " : " + HAND_TYPES.get(this.cardsType) + "[" + this.poker1 + ", " + this.poker2 + ", " + this.poker3 + "]\t當前積分:" + score);
}
@Override
public int compareTo(CardHand o) {
FgfCardHand cardHand = (FgfCardHand) o;
return FgfGameRuleService.getInstance().rule(cardHand, this);
}
/**
* Getter & Setter
* @return
*/
public String getPlayerName() {
return playerName;
}
public void setPlayerName(String playerName) {
this.playerName = playerName;
}
public Poker getPoker1() {
return poker1;
}
public void setPoker1(Poker poker1) {
this.poker1 = poker1;
}
public Poker getPoker2() {
return poker2;
}
public void setPoker2(Poker poker2) {
this.poker2 = poker2;
}
public Poker getPoker3() {
return poker3;
}
public void setPoker3(Poker poker3) {
this.poker3 = poker3;
}
public int getCardsType() {
if (this.poker1.getPointValue() == this.poker2.getPointValue()
&& this.poker2.getPointValue() == this.poker3.getPointValue()) {
return HAND_TYPE_VALUE_BZP;
}
if (this.poker1.getTypeValue() == this.poker2.getTypeValue()
&& this.poker2.getTypeValue() == this.poker3.getTypeValue()) {
if ((this.poker3.getPointValue() - this.poker2.getPointValue()) == 1
&& (this.poker2.getPointValue() - this.poker1.getPointValue()) == 1) {
return HAND_TYPE_VALUE_SJP;
} else {
return HAND_TYPE_VALUE_LJP;
}
}
if ((this.poker3.getPointValue() - this.poker2.getPointValue()) == 1
&& (this.poker2.getPointValue() - this.poker1.getPointValue()) == 1) {
return HAND_TYPE_VALUE_LSP;
}
if (this.poker1.getPointValue() == this.poker2.getPointValue()
|| this.poker2.getPointValue() == this.poker3.getPointValue()) {
return HAND_TYPE_VALUE_DZP;
}
return HAND_TYPE_VALUE_DSP;
}
}
FgfGameRuleService
package com.card.fgf;
import com.card.CardGameRuleService;
import com.card.CardHand;
public class FgfGameRuleService implements CardGameRuleService {
private static FgfGameRuleService instance = new FgfGameRuleService();
private FgfGameRuleService() {}
public static FgfGameRuleService getInstance() {
return instance;
}
@Override
public int rule(CardHand cardHand1, CardHand cardHand2) {
FgfCardHand fgf1 = (FgfCardHand) cardHand1;
FgfCardHand fgf2 = (FgfCardHand) cardHand2;
if (fgf1.getCardsType() > fgf2.getCardsType())
return 1;
if (fgf1.getCardsType() < fgf2.getCardsType())
return -1;
if (fgf1.getCardsType() == FgfCardHand.HAND_TYPE_VALUE_BZP) {
if (fgf1.getPoker1().getPointValue() > fgf2.getPoker1().getPointValue())
return 1;
if (fgf1.getPoker1().getPointValue() < fgf2.getPoker1().getPointValue())
return -1;
}
if (fgf1.getCardsType() == FgfCardHand.HAND_TYPE_VALUE_SJP) {
if (fgf1.getPoker3().getPointValue() > fgf2.getPoker3().getPointValue())
return 1;
if (fgf1.getPoker3().getPointValue() < fgf2.getPoker3().getPointValue())
return -1;
}
if (fgf1.getCardsType() == FgfCardHand.HAND_TYPE_VALUE_LJP) {
if (fgf1.getPoker3().getPointValue() > fgf2.getPoker3().getPointValue())
return 1;
if (fgf1.getPoker3().getPointValue() < fgf2.getPoker3().getPointValue())
return -1;
if (fgf1.getPoker2().getPointValue() > fgf2.getPoker2().getPointValue())
return 1;
if (fgf1.getPoker2().getPointValue() < fgf2.getPoker2().getPointValue())
return -1;
if (fgf1.getPoker1().getPointValue() > fgf2.getPoker1().getPointValue())
return 1;
if (fgf1.getPoker1().getPointValue() < fgf2.getPoker1().getPointValue())
return -1;
}
if (fgf1.getCardsType() == FgfCardHand.HAND_TYPE_VALUE_LSP) {
if (fgf1.getPoker3().getPointValue() > fgf2.getPoker3().getPointValue())
return 1;
if (fgf1.getPoker3().getPointValue() < fgf2.getPoker3().getPointValue())
return -1;
}
if (fgf1.getCardsType() == FgfCardHand.HAND_TYPE_VALUE_DZP) {
if (fgf1.getPoker2().getPointValue() > fgf2.getPoker2().getPointValue())
return 1;
if (fgf1.getPoker2().getPointValue() < fgf2.getPoker2().getPointValue())
return -1;
int fgf1Dp = 0;
int fgf2Dp = 0;
if (fgf1.getPoker1().getPointValue() == fgf1.getPoker2().getPointValue()) {
fgf1Dp = fgf1.getPoker3().getPointValue();
} else {
fgf1Dp = fgf1.getPoker1().getPointValue();
}
if (fgf2.getPoker1().getPointValue() == fgf2.getPoker2().getPointValue()) {
fgf2Dp = fgf2.getPoker3().getPointValue();
} else {
fgf2Dp = fgf2.getPoker1().getPointValue();
}
if (fgf1Dp > fgf2Dp)
return 1;
if (fgf1Dp < fgf2Dp)
return -1;
}
if (fgf1.getCardsType() == FgfCardHand.HAND_TYPE_VALUE_DSP) {
if (fgf1.getPoker3().getPointValue() > fgf2.getPoker3().getPointValue())
return 1;
if (fgf1.getPoker3().getPointValue() < fgf2.getPoker3().getPointValue())
return -1;
if (fgf1.getPoker2().getPointValue() > fgf2.getPoker2().getPointValue())
return 1;
if (fgf1.getPoker2().getPointValue() < fgf2.getPoker2().getPointValue())
return -1;
if (fgf1.getPoker1().getPointValue() > fgf2.getPoker1().getPointValue())
return 1;
if (fgf1.getPoker1().getPointValue() < fgf2.getPoker1().getPointValue())
return -1;
}
return 0;
}
}
FgfGameService.java
package com.card.fgf;
import com.Game;
import com.Player;
import com.card.CardGameService;
import com.card.CardHand;
import com.card.Poker;
import java.util.Collections;
public class FgfGameService extends CardGameService implements Game {
public FgfGameService(int playerNums) {
String room = "FGF" + System.currentTimeMillis();
this.setRoomCode(room);
this.setPlayerNums(playerNums);
System.out.println("=========" + PLATFORM_NAME + "(" + PLATFORM_VERSION + ")" + "-" + FGF_NAME + "=========");
System.out.println("房間號:" + this.getRoomCode() + " 玩家數量:" + this.getPlayerNums());
}
@Override
public void shuffle() {
super.shuffle();
System.out.println("\n\n" + "===============" + " 輪次(" + this.getRound() + ") 洗牌中 " + "==============");
for (String type : Poker.TYPES) {
for (String point : Poker.POINTS) {
String tp = type + point;
Poker poker = new Poker(tp);
cards.add(poker);
}
}
Collections.shuffle(cards);
}
@Override
public void deal() {
int k = 0;
for (int i = 1; i <= this.getPlayerNums(); i++) {
String playerName = "PLAYER" + (i < 10 ? ("0" + i) : (i + ""));
Poker poker1 = null;
Poker poker2 = null;
Poker poker3 = null;
for (int j = 0; j < 3; j++) {
if (j == 0) {
poker1 = (Poker) this.cards.get(k);
}
if (j == 1) {
poker2 = (Poker) this.cards.get(k);
}
if (j == 2) {
poker3 = (Poker) this.cards.get(k);
}
k++;
}
FgfCardHand cardHand = new FgfCardHand(playerName, poker1, poker2, poker3);
playersCards.add(cardHand);
}
for (CardHand hand : playersCards) {
FgfCardHand fgfHand = (FgfCardHand) hand;
System.out.println(fgfHand);
}
}
@Override
public void close() {
System.out.println("\n\n" + "===============" + " 輪次(" + this.getRound() + ") 結算 " + "===============");
Collections.sort(this.playersCards);
int i = 0;
for (CardHand hand : playersCards) {
FgfCardHand fgfHand = (FgfCardHand) hand;
int score = playersCards.size() - i++;
int currentScore = Player.PLAYERS.get(fgfHand.getPlayerName()).getScore();
currentScore += score;
Player.PLAYERS.get(fgfHand.getPlayerName()).setScore(currentScore);
System.out.println(fgfHand);
}
}
}
Client.java
package com.card.client;
import com.card.fgf.FgfGameService;
public class Client {
public static void main(String[] args) {
FgfGameService fgfService = new FgfGameService(5);
for (int i = 0; i < 10; i++) {
fgfService.shuffle();
fgfService.deal();
fgfService.close();
}
}
}