Java+Swing实现斗地主游戏
一、系统介绍
本系统实现扑克的分发，抢地主，电脑自动出牌等功能。
二、系统展示
1.扑克分发
2.抢地主
3.出牌
4.游戏胜利
三、系统实现
Card.java
package com.sjsq;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
/**
*
* 扑克管理类
*
* @author shuijianshiqing
*
* @date 2020-09-09 20:41
*
*/
public class Card extends JLabel implements MouseListener {
Main main;// Main类的引用
String name;// 图片url名字
boolean up;// 是否正反面
boolean canClick = false;// 是否可被点击
boolean clicked = false;// 是否点击过
public Card(Main m, String name, boolean up) {
this.main = m;
this.name = name;
this.up = up;
if (this.up)
this.turnFront();
else {
this.turnRear();
}
this.setSize(71, 96);
this.setVisible(true);
this.addMouseListener(this);
}
// 正面
public void turnFront() {
this.setIcon(new ImageIcon("images/" + name + ".gif"));
this.up = true;
}
// 反面
public void turnRear() {
this.setIcon(new ImageIcon("images/rear.gif"));
this.up = false;
}
@Override
public void mouseClicked(MouseEvent e) {
if (canClick) {
Point from = this.getLocation();
int step; // 移动的距离
if (clicked)
step = -30;
else {
step = 30;
}
clicked = !clicked; // 反向
// 当被选中的时候，向前移动一步/后退一步
Common.move(this, from, new Point(from.x, from.y - step), 10);
}
}
public void mouseEntered(MouseEvent arg0) {
}
public void mouseExited(MouseEvent arg0) {
}
public void mousePressed(MouseEvent arg0) {
}
public void mouseReleased(MouseEvent arg0) {
}
}
CardType.java
package com.sjsq;
/**
*
* 出牌类型
*
* @author shuijianshiqing
*
* @date 2020-09-09 20:44
*
*/
public enum CardType {
c1,//单牌。
c2,//对子。
c3,//3不带。
c4,//炸弹。
c31,//3带1。
c32,//3带2。
c411,//4带2个单，或者一对
c422,//4带2对
c123,//连子。
c1122,//连队。
c111222,//飞机。
c11122234,//飞机带单排.
c1112223344,//飞机带对子.
c0//不能出牌
}
Common.java
package com.sjsq;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
*
* 各类判断函数
*
* @author shuijianshiqing
*
* @date 2020-09-09 20:52
*
*/
public class Common {
// 判断牌型
public static CardType jugdeType(List<Card> list) {
// 因为之前排序过所以比较好判断
int len = list.size();
// 单牌,对子，3不带，4个一样炸弹
if (len <= 4) { // 如果第一个和最后个相同，说明全部相同
if (list.size() > 0 && Common.getValue(list.get(0)) == Common.getValue(list.get(len - 1))) {
switch (len) {
case 1:
return CardType.c1;
case 2:
return CardType.c2;
case 3:
return CardType.c3;
case 4:
return CardType.c4;
}
}
// 双王,炸弹
if (len == 2 && Common.getColor(list.get(1)) == 5 && Common.getColor(list.get(0)) == 5)
return CardType.c4;
// 当第一个和最后个不同时,3带1
if (len == 4 && ((Common.getValue(list.get(0)) == Common.getValue(list.get(len - 2)))
|| Common.getValue(list.get(1)) == Common.getValue(list.get(len - 1))))
return CardType.c31;
else {
return CardType.c0;
}
}
// 当5张以上时，连字，3带2，飞机，2顺，4带2等等
if (len >= 5) {// 现在按相同数字最大出现次数
Card_index card_index = new Card_index();
for (int i = 0; i < 4; i++)
card_index.a[i] = new ArrayList<Integer>();
// 求出各种数字出现频率
Common.getMax(card_index, list); // a[0,1,2,3]分别表示重复1,2,3,4次的牌
// 3带2 -----必含重复3次的牌
if (card_index.a[2].size() == 1 && card_index.a[1].size() == 1 && len == 5)
return CardType.c32;
// 4带2(单,双)
if (card_index.a[3].size() == 1 && len == 6)
return CardType.c411;
// 4带2对
if (card_index.a[3].size() == 1 && card_index.a[1].size() == 2 && len == 8)
return CardType.c422;
// 顺子,保证不存在王
if ((Common.getColor(list.get(0)) != 5) && (card_index.a[0].size() == len)
&& (Common.getValue(list.get(0)) - Common.getValue(list.get(len - 1)) == len - 1))
return CardType.c123;
// 连队
if (card_index.a[1].size() == len / 2 && len % 2 == 0 && len / 2 >= 3
&& (Common.getValue(list.get(0)) - Common.getValue(list.get(len - 1)) == (len / 2 - 1)))
return CardType.c1122;
// 飞机
if (card_index.a[2].size() == len / 3 && (len % 3 == 0)
&& (Common.getValue(list.get(0)) - Common.getValue(list.get(len - 1)) == (len / 3 - 1)))
return CardType.c111222;
// 飞机带n单,n/2对
if (card_index.a[2].size() == len / 4 && ((Integer) (card_index.a[2].get(len / 4 - 1))
- (Integer) (card_index.a[2].get(0)) == len / 4 - 1))
return CardType.c11122234;
// 飞机带n双
if (card_index.a[2].size() == len / 5 && card_index.a[2].size() == len / 5
&& ((Integer) (card_index.a[2].get(len / 5 - 1)) - (Integer) (card_index.a[2].get(0)) == len / 5
- 1))
return CardType.c1112223344;
}
return CardType.c0;
}
// 移动效果的函数,用于发牌
public static void move(Card card, Point from, Point to, int t) {
if (to.x != from.x) {
double k = (1.0) * (to.y - from.y) / (to.x - from.x);
double b = to.y - to.x * k;
int flag = 0;// 判断向左还是向右移动步幅
if (from.x < to.x) {
if (t % 3 == 2) {
flag = 3;
} else {
flag = 10;
}
} else {
if (t % 3 == 2) {
flag = -3;
} else {
flag = -10;
}
}
for (int i = from.x; Math.abs(i - to.x) > 20; i += flag) {
double y = k * i + b;// 这里主要用的数学中的线性函数
System.out.println(y + "=" + k + "*" + i + "+" + b);
card.setLocation(i, (int) y);
try {
Thread.sleep(20); // 延迟，可自己设置
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 位置校准
card.setLocation(to);
}
// 对list排序
public static void order(List<Card> list) {
Collections.sort(list, new Comparator<Card>() {
public int compare(Card o1, Card o2) {
// TODO Auto-generated method stub
int a1 = Integer.parseInt(o1.name.substring(0, 1));// 花色
int a2 = Integer.parseInt(o2.name.substring(0, 1));
int b1 = Integer.parseInt(o1.name.substring(2, o1.name.length()));// 数值
int b2 = Integer.parseInt(o2.name.substring(2, o2.name.length()));
int flag = 0;
// 如果是王的话
if (a1 == 5)
b1 += 100;
if (a1 == 5 && b1 == 1)
b1 += 50;
if (a2 == 5)
b2 += 100;
if (a2 == 5 && b2 == 1)
b2 += 50;
// 如果是A或者2
if (b1 == 1)
b1 += 20;
if (b2 == 1)
b2 += 20;
if (b1 == 2)
b1 += 30;
if (b2 == 2)
b2 += 30;
flag = b2 - b1;
if (flag == 0) {
return a2 - a1;
} else {
return flag;
}
}
});
}
// 重新定位 flag代表电脑1 ,2 或者是我
public static void rePosition(Main m, List<Card> list, int flag) {
Point p = new Point();
if (flag == 0) {
p.x = 50;
p.y = (450 / 2) - (list.size() + 1) * 15 / 2;
}
if (flag == 1) {// 我的排序 _y=450 width=830
p.x = (800 / 2) - (list.size() + 1) * 21 / 2;
p.y = 450;
}
if (flag == 2) {
p.x = 700;
p.y = (450 / 2) - (list.size() + 1) * 15 / 2;
}
int len = list.size();
for (int i = 0; i < len; i++) {
Card card = list.get(i);
Common.move(card, card.getLocation(), p, 10);
m.container.setComponentZOrder(card, 0);
if (flag == 1)
p.x += 21;
else
p.y += 15;
}
}
// 地主牌权值，看是否抢地主
public static int getScore(List<Card> list) {
int count = 0;
for (int i = 0, len = list.size(); i < len; i++) {
Card card = list.get(i);
if (card.name.substring(0, 1).equals("5")) {
// System.out.println(card.name.substring(0, 1));
count += 5;
}
if (card.name.substring(2, card.name.length()).equals("2")) {
// System.out.println(2);
count += 2;
}
}
return count;
}
// 返回花色
public static int getColor(Card card) {
return Integer.parseInt(card.name.substring(0, 1));
}
// 返回值
public static int getValue(Card card) {
int i = Integer.parseInt(card.name.substring(2, card.name.length()));
if (card.name.substring(2, card.name.length()).equals("2"))
i += 13;
if (card.name.substring(2, card.name.length()).equals("1"))
i += 13;
if (Common.getColor(card) == 5)
i += 2;// 是王
return i;
}
// 得到最大相同数
public static void getMax(Card_index card_index, List<Card> list) {
int count[] = new int[14];// 1-13各算一种,王算第14种
for (int i = 0; i < 14; i++)
count[i] = 0;
for (int i = 0; i < list.size(); i++) {
if (Common.getColor(list.get(i)) == 5)
count[13]++;
else
count[Common.getValue(list.get(i)) - 1]++;
}
for (int i = 0; i < 14; i++) {
switch (count[i]) {
case 1:
card_index.a[0].add(i + 1);
break;
case 2:
card_index.a[1].add(i + 1);
break;
case 3:
card_index.a[2].add(i + 1);
break;
case 4:
card_index.a[3].add(i + 1);
break;
}
}
}
// 拆牌
public static Model getModel(List<Card> list) {
// 先复制一个list
List<Card> list2 = new ArrayList<Card>(list);
Model model = new Model();
// ------先拆炸弹
Common.getBoomb(list2, model); // ok
// ------拆3带
Common.getThree(list2, model);
// 拆飞机
Common.getPlane(list2, model);
// ------拆对子
Common.getTwo(list2, model);
// 拆连队
Common.getTwoTwo(list2, model);
// 拆顺子
Common.get123(list2, model);
// 拆单
Common.getSingle(list2, model);
return model;
}
// 拆连子
public static void get123(List<Card> list, Model model) {
List<Card> del = new ArrayList<Card>();// 要删除的Cards
if (list.size() > 0 && (Common.getValue(list.get(0)) < 7 || Common.getValue(list.get(list.size() - 1)) > 10))
return;
if (list.size() < 5)
return;
for (int i = 0, len = list.size(); i < len; i++) {
int k = i;
for (int j = i; j < len; j++) {
if (Common.getValue(list.get(i)) - Common.getValue(list.get(j)) == j - i) {
k = j;
}
}
if (k - i >= 4) {
String s = "";
for (int j = i; j < k; j++) {
s += list.get(j).name + ",";
del.add(list.get(j));
}
s += list.get(k).name;
del.add(list.get(k));
model.a123.add(s);
i = k;
}
}
list.removeAll(del);
}
// 拆双顺
public static void getTwoTwo(List<Card> list, Model model) {
List<String> del = new ArrayList<String>();// 要删除的Cards
// 从model里面的对子找
List<String> l = model.a2;
if (l.size() < 3)
return;
Integer s[] = new Integer[l.size()];
for (int i = 0, len = l.size(); i < len; i++) {
String[] name = l.get(i).split(",");
s[i] = Integer.parseInt(name[0].substring(2, name[0].length()));
}
// s0,1,2,3,4 13,9,8,7,6
for (int i = 0, len = l.size(); i < len; i++) {
int k = i;
for (int j = i; j < len; j++) {
if (s[i] - s[j] == j - i)
k = j;
}
if (k - i >= 2)// k=4 i=1
{// 说明从i到k是连队
String ss = "";
for (int j = i; j < k; j++) {
ss += l.get(j) + ",";
del.add(l.get(j));
}
ss += l.get(k);
model.a112233.add(ss);
del.add(l.get(k));
i = k;
}
}
l.removeAll(del);
}
// 拆飞机
public static void getPlane(List<Card> list, Model model) {
List<String> del = new ArrayList<String>();// 要删除的Cards
// 从model里面的3带找
List<String> l = model.a3;
if (l.size() < 2)
return;
Integer s[] = new Integer[l.size()];
for (int i = 0, len = l.size(); i < len; i++) {
String[] name = l.get(i).split(",");
s[i] = Integer.parseInt(name[0].substring(2, name[0].length()));
}
for (int i = 0, len = l.size(); i < len; i++) {
int k = i;
for (int j = i; j < len; j++) {
if (s[i] - s[j] == j - i)
k = j;
}
if (k != i) {// 说明从i到k是飞机
String ss = "";
for (int j = i; j < k; j++) {
ss += l.get(j) + ",";
del.add(l.get(j));
}
ss += l.get(k);
model.a111222.add(ss);
del.add(l.get(k));
i = k;
}
}
l.removeAll(del);
}
// 拆炸弹
public static void getBoomb(List<Card> list, Model model) {
List<Card> del = new ArrayList<Card>();// 要删除的Cards
// 王炸
if (list.size() >= 2 && Common.getColor(list.get(0)) == 5 && Common.getColor(list.get(1)) == 5) {
model.a4.add(list.get(0).name + "," + list.get(1).name); // 按名字加入
del.add(list.get(0));
del.add(list.get(1));
}
// 如果王不构成炸弹咋先拆单
if (Common.getColor(list.get(0)) == 5 && Common.getColor(list.get(1)) != 5) {
del.add(list.get(0));
model.a1.add(list.get(0).name);
}
list.removeAll(del);
// 一般的炸弹
for (int i = 0, len = list.size(); i < len; i++) {
if (i + 3 < len && Common.getValue(list.get(i)) == Common.getValue(list.get(i + 3))) {
String s = list.get(i).name + ",";
s += list.get(i + 1).name + ",";
s += list.get(i + 2).name + ",";
s += list.get(i + 3).name;
model.a4.add(s);
for (int j = i; j <= i + 3; j++)
del.add(list.get(j));
i = i + 3;
}
}
list.removeAll(del);
}
// 拆3带
public static void getThree(List<Card> list, Model model) {
List<Card> del = new ArrayList<Card>();// 要删除的Cards
// 连续3张相同
for (int i = 0, len = list.size(); i < len; i++) {
if (i + 2 < len && Common.getValue(list.get(i)) == Common.getValue(list.get(i + 2))) {
String s = list.get(i).name + ",";
s += list.get(i + 1).name + ",";
s += list.get(i + 2).name;
model.a3.add(s);
for (int j = i; j <= i + 2; j++)
del.add(list.get(j));
i = i + 2;
}
}
list.removeAll(del);
}
// 拆对子
public static void getTwo(List<Card> list, Model model) {
List<Card> del = new ArrayList<Card>();// 要删除的Cards
// 连续2张相同
for (int i = 0, len = list.size(); i < len; i++) {
if (i + 1 < len && Common.getValue(list.get(i)) == Common.getValue(list.get(i + 1))) {
String s = list.get(i).name + ",";
s += list.get(i + 1).name;
model.a2.add(s);
for (int j = i; j <= i + 1; j++)
del.add(list.get(j));
i = i + 1;
}
}
list.removeAll(del);
}
// 拆单牌
public static void getSingle(List<Card> list, Model model) {
List<Card> del = new ArrayList<Card>();// 要删除的Cards
// 1
for (int i = 0, len = list.size(); i < len; i++) {
model.a1.add(list.get(i).name);
del.add(list.get(i));
}
list.removeAll(del);
}
// 隐藏之前出过的牌
public static void hideCards(List<Card> list) {
for (int i = 0, len = list.size(); i < len; i++) {
list.get(i).setVisible(false);
}
}
// 检查牌的是否能出
public static int checkCards(List<Card> c, List<Card>[] current) {
// 找出当前最大的牌是哪个电脑出的,c是点选的牌
List<Card> currentlist = (current[0].size() > 0) ? current[0] : current[2];
CardType cType = Common.jugdeType(c);
// 如果张数不同直接过滤
if (cType != CardType.c4 && c.size() != currentlist.size())
return 0;
// 比较我的出牌类型
if (Common.jugdeType(c) != Common.jugdeType(currentlist)) {
return 0;
}
// 比较出的牌是否要大
// 王炸弹
if (cType == CardType.c4) {
if (c.size() == 2)
return 1;
if (currentlist.size() == 2)
return 0;
}
// 单牌,对子,3带,4炸弹
if (cType == CardType.c1 || cType == CardType.c2 || cType == CardType.c3 || cType == CardType.c4) {
if (Common.getValue(c.get(0)) <= Common.getValue(currentlist.get(0))) {
return 0;
} else {
return 1;
}
}
// 顺子,连队，飞机裸
if (cType == CardType.c123 || cType == CardType.c1122 || cType == CardType.c111222) {
if (Common.getValue(c.get(0)) <= Common.getValue(currentlist.get(0)))
return 0;
else
return 1;
}
// 按重复多少排序
// 3带1,3带2 ,飞机带单，双,4带1,2,只需比较第一个就行，独一无二的
if (cType == CardType.c31 || cType == CardType.c32 || cType == CardType.c411 || cType == CardType.c422
|| cType == CardType.c11122234 || cType == CardType.c1112223344) {
List<Card> a1 = Common.getOrder2(c); // 我出的牌
List<Card> a2 = Common.getOrder2(currentlist);// 当前最大牌
if (Common.getValue(a1.get(0)) < Common.getValue(a2.get(0)))
return 0;
}
return 1;
}
// 按照重复次数排序
public static List getOrder2(List<Card> list) {
List<Card> list2 = new ArrayList<Card>(list);
List<Card> list3 = new ArrayList<Card>();
// List<Integer> list4=new ArrayList<Integer>();
int len = list2.size();
int a[] = new int[20];// 记录数
for (int i = 0; i < 20; i++)
a[i] = 0;
for (int i = 0; i < len; i++) {
a[Common.getValue(list2.get(i))]++;
}
int max = 0;
for (int i = 0; i < 20; i++) {
max = 0;
for (int j = 19; j >= 0; j--) {
if (a[j] > a[max])
max = j;
}
for (int k = 0; k < len; k++) {
if (Common.getValue(list2.get(k)) == max) {
list3.add(list2.get(k));
}
}
list2.remove(list3);
a[max] = 0;
}
return list3;
}
}
class Card_index {
List a[] = new ArrayList[4];// 单张
}
Model.java
package com.sjsq;
import java.util.ArrayList;
import java.util.List;
/**
*
* 扑克类型List类
*
* @author shuijianshiqing
*
* @date 2020-09-09 20:47
*
*/
public class Model {
//一组牌
int value; //权值
int num;// 手数 (几次能够走完，没有挡的情况下)
List<String> a1=new ArrayList<String>(); //单张
List<String> a2=new ArrayList<String>(); //对子
List<String> a3=new ArrayList<String>(); //3带
List<String> a123=new ArrayList<String>(); //连子
List<String> a112233=new ArrayList<String>(); //连牌
List<String> a111222=new ArrayList<String>(); //飞机
List<String> a4=new ArrayList<String>(); //炸弹
}
NewSwing.java
package com.sjsq;
import javax.swing.SwingUtilities;
public class NewSwing {
}
Time.java
package com.sjsq;
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.SwingUtilities;
public class Time extends Thread {
Main main;
boolean isRun = true;
int i = 10;
public Time(Main m, int i) {
this.main = m;
this.i = i;
}
@Override
public void run() {
while (i > -1 && isRun) {
main.time[1].setText("倒计时:" + i--);
second(1);// 等一秒
}
if (i == -1)// 正常终结，说明超时
main.time[1].setText("不抢");
main.landlord[0].setVisible(false);
main.landlord[1].setVisible(false);
for (Card card2 : main.playerList[1])
card2.canClick = true;// 可被点击
// 如果自己抢到地主
if (main.time[1].getText().equals("抢地主")) {
// 得到地主牌
main.playerList[1].addAll(main.lordList);
openlord(true);
second(2);// 等待五秒
Common.order(main.playerList[1]);
Common.rePosition(main, main.playerList[1], 1);
setlord(1);
} else {
// 电脑选地主
if (Common.getScore(main.playerList[0]) < Common.getScore(main.playerList[2])) {
main.time[2].setText("抢地主");
main.time[2].setVisible(true);
setlord(2);// 设定地主
openlord(true);// 把地主牌翻开
second(3);
main.playerList[2].addAll(main.lordList);
Common.order(main.playerList[2]);
Common.rePosition(main, main.playerList[2], 2);
openlord(false);
} else {
main.time[0].setText("抢地主");
main.time[0].setVisible(true);
setlord(0);// 设定地主
openlord(true);
second(3);
main.playerList[0].addAll(main.lordList);
Common.order(main.playerList[0]);
Common.rePosition(main, main.playerList[0], 0);
// openlord(false);
}
}
// 选完地主后 关闭地主按钮
main.landlord[0].setVisible(false);
main.landlord[1].setVisible(false);
turnOn(false);
for (int i = 0; i < 3; i++) {
main.time[i].setText("不要");
main.time[i].setVisible(false);
}
// 开始游戏 根据地主不同顺序不同
main.turn = main.dizhuFlag;
while (true) {
if (main.turn == 1) // 我
{
turnOn(true);// 出牌按钮 --我出牌
timeWait(30, 1);// 我自己的定时器
System.out.println("我出牌");
turnOn(false);// 选完关闭
main.turn = (main.turn + 1) % 3;
if (win())// 判断输赢
break;
}
if (main.turn == 0) {
computer0();
main.turn = (main.turn + 1) % 3;
if (win())// 判断输赢
break;
}
if (main.turn == 2) {
computer2();
main.turn = (main.turn + 1) % 3;
if (win())// 判断输赢
break;
}
}
}
// 等待i秒
public void second(int i) {
try {
Thread.sleep(i * 1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 地主牌翻看
public void openlord(boolean is) {
for (int i = 0; i < 3; i++) {
if (is)
main.lordList.get(i).turnFront(); // 地主牌翻看
else {
main.lordList.get(i).turnRear(); // 地主牌闭合
}
main.lordList.get(i).canClick = true;// 可被点击
}
}
// 设定地主
public void setlord(int i) {
Point point = new Point();
if (i == 1)// 我是地主
{
point.x = 80;
point.y = 430;
main.dizhuFlag = 1;// 设定地主
}
if (i == 0) {
point.x = 80;
point.y = 20;
main.dizhuFlag = 0;
}
if (i == 2) {
point.x = 700;
point.y = 20;
main.dizhuFlag = 2;
}
main.dizhu.setLocation(point);
main.dizhu.setVisible(true);
}
// 打开出牌按钮
public void turnOn(boolean flag) {
main.publishCard[0].setVisible(flag);
main.publishCard[1].setVisible(flag);
}
// 电脑0走牌(我代表1)
public void computer0() {
timeWait(3, 0); // 定时
ShowCard(0); // 出牌
}
// 电脑2走牌(我代表1)
public void computer2() {
timeWait(3, 2); // 定时
ShowCard(2); // 出牌
}
// 走牌
public void ShowCard(int role) {
Model model = Common.getModel(main.playerList[role]);
// 待走的牌
List<String> list = new ArrayList<String>();
// 如果是主动出牌
if (main.time[(role + 1) % 3].getText().equals("不要") && main.time[(role + 2) % 3].getText().equals("不要")) {
// 有单出单 (除开3带，飞机能带的单牌)
if (model.a1.size() > (model.a111222.size() * 2 + model.a3.size())) {
list.add(model.a1.get(model.a1.size() - 1));
} // 有对子出对子 (除开3带，飞机)
else if (model.a2.size() > (model.a111222.size() * 2 + model.a3.size())) {
list.add(model.a2.get(model.a2.size() - 1));
} // 有顺子出顺子
else if (model.a123.size() > 0) {
list.add(model.a123.get(model.a123.size() - 1));
} // 有3带就出3带，没有就出光3
else if (model.a3.size() > 0) {
// 3带单,且非关键时刻不能带王，2
if (model.a1.size() > 0) {
list.add(model.a1.get(model.a1.size() - 1));
} // 3带对
else if (model.a2.size() > 0) {
list.add(model.a2.get(model.a2.size() - 1));
}
list.add(model.a3.get(model.a3.size() - 1));
} // 有双顺出双顺
else if (model.a112233.size() > 0) {
list.add(model.a112233.get(model.a112233.size() - 1));
} // 有飞机出飞机
else if (model.a111222.size() > 0) {
String name[] = model.a111222.get(0).split(",");
// 带单
if (name.length / 3 <= model.a1.size()) {
list.add(model.a111222.get(model.a111222.size() - 1));
for (int i = 0; i < name.length / 3; i++)
list.add(model.a1.get(i));
} else if (name.length / 3 <= model.a2.size())// 带双
{
list.add(model.a111222.get(model.a111222.size() - 1));
for (int i = 0; i < name.length / 3; i++)
list.add(model.a2.get(i));
}
// 有炸弹出炸弹
} else if (model.a4.size() > 0) {
// 4带2,1
int sizea1 = model.a1.size();
int sizea2 = model.a2.size();
if (sizea1 >= 2) {
list.add(model.a1.get(sizea1 - 1));
list.add(model.a1.get(sizea1 - 2));
list.add(model.a4.get(0));
} else if (sizea2 >= 2) {
list.add(model.a2.get(sizea1 - 1));
list.add(model.a2.get(sizea1 - 2));
list.add(model.a4.get(0));
} else {// 直接炸
list.add(model.a4.get(0));
}
}
} // 如果是跟牌
else {
List<Card> player = main.currentList[(role + 2) % 3].size() > 0 ? main.currentList[(role + 2) % 3]
: main.currentList[(role + 1) % 3];// 当前出的牌
CardType cType = Common.jugdeType(player);// 桌面别人出的牌
// 如果是单牌
if (cType == CardType.c1) {
AI_1(model.a1, player, list, role);
} // 如果是对子
else if (cType == CardType.c2) {
AI_1(model.a2, player, list, role);
} // 3带
else if (cType == CardType.c3) {
AI_1(model.a3, player, list, role);
} // 炸弹
else if (cType == CardType.c4) {
AI_1(model.a4, player, list, role);
} // 如果是3带1
else if (cType == CardType.c31) {
// 偏家 涉及到拆牌
// if((role+1)%3==main.dizhuFlag)
AI_2(model.a3, model.a1, player, list, role);
} // 如果是3带2
else if (cType == CardType.c32) {
// 偏家
// if((role+1)%3==main.dizhuFlag)
AI_2(model.a3, model.a2, player, list, role);
} // 如果是4带11
else if (cType == CardType.c411) {
AI_5(model.a4, model.a1, player, list, role);
}
// 如果是4带22
else if (cType == CardType.c422) {
AI_5(model.a4, model.a2, player, list, role);
}
// 顺子
else if (cType == CardType.c123) {
AI_3(model.a123, player, list, role);
}
// 双顺
else if (cType == CardType.c1122) {
AI_3(model.a112233, player, list, role);
}
// 飞机带单
else if (cType == CardType.c11122234) {
AI_4(model.a111222, model.a1, player, list, role);
}
// 飞机带对
else if (cType == CardType.c1112223344) {
AI_4(model.a111222, model.a2, player, list, role);
}
// 炸弹
if (list.size() == 0) {
int len4 = model.a4.size();
if (len4 > 0)
list.add(model.a4.get(len4 - 1));
}
}
// 定位出牌
main.currentList[role].clear();
if (list.size() > 0) {
Point point = new Point();
if (role == 0)
point.x = 200;
if (role == 2)
point.x = 550;
point.y = (400 / 2) - (list.size() + 1) * 15 / 2;// 屏幕中部
// 将name转换成Card
for (int i = 0, len = list.size(); i < len; i++) {
List<Card> cards = getCardByName(main.playerList[role], list.get(i));
for (Card card : cards) {
Common.move(card, card.getLocation(), point, 10);
point.y += 15;
main.currentList[role].add(card);
main.playerList[role].remove(card);
}
}
Common.rePosition(main, main.playerList[role], role);
} else {
main.time[role].setVisible(true);
main.time[role].setText("不要");
}
for (Card card : main.currentList[role])
card.turnFront();
}
// 按name获得Card，方便从Model取出
public List<Card> getCardByName(List<Card> list, String n) {
String[] name = n.split(",");
List<Card> cardsList = new ArrayList<Card>();
int j = 0;
for (int i = 0, len = list.size(); i < len; i++) {
if (j < name.length && list.get(i).name.equals(name[j])) {
cardsList.add(list.get(i));
i = 0;
j++;
}
}
return cardsList;
}
// 顺子
public void AI_3(List<String> model, List<Card> player, List<String> list, int role) {
for (int i = 0, len = model.size(); i < len; i++) {
String[] s = model.get(i).split(",");
if (s.length == player.size() && getValueInt(model.get(i)) > Common.getValue(player.get(0))) {
list.add(model.get(i));
return;
}
}
}
// 飞机带单，双
public void AI_4(List<String> model1, List<String> model2, List<Card> player, List<String> list, int role) {
// 排序按重复数
player = Common.getOrder2(player);
int len1 = model1.size();
int len2 = model2.size();
if (len1 < 1 || len2 < 1)
return;
for (int i = 0; i < len1; i++) {
String[] s = model1.get(i).split(",");
String[] s2 = model2.get(0).split(",");
if ((s.length / 3 <= len2) && (s.length * (3 + s2.length) == player.size())
&& getValueInt(model1.get(i)) > Common.getValue(player.get(0))) {
list.add(model1.get(i));
for (int j = 1; j <= s.length / 3; j++)
list.add(model2.get(len2 - j));
}
}
}
// 4带1，2
public void AI_5(List<String> model1, List<String> model2, List<Card> player, List<String> list, int role) {
// 排序按重复数
player = Common.getOrder2(player);
int len1 = model1.size();
int len2 = model2.size();
if (len1 < 1 || len2 < 2)
return;
for (int i = 0; i < len1; i++) {
if (getValueInt(model1.get(i)) > Common.getValue(player.get(0))) {
list.add(model1.get(i));
for (int j = 1; j <= 2; j++)
list.add(model2.get(len2 - j));
}
}
}
// 单牌，对子，3个，4个,通用
public void AI_1(List<String> model, List<Card> player, List<String> list, int role) {
// 顶家
if ((role + 1) % 3 == main.dizhuFlag) {
for (int i = 0, len = model.size(); i < len; i++) {
if (getValueInt(model.get(i)) > Common.getValue(player.get(0))) {
list.add(model.get(i));
break;
}
}
} else {// 偏家
for (int len = model.size(), i = len - 1; i >= 0; i--) {
if (getValueInt(model.get(i)) > Common.getValue(player.get(0))) {
list.add(model.get(i));
break;
}
}
}
}
// 3带1,2,4带1,2
public void AI_2(List<String> model1, List<String> model2, List<Card> player, List<String> list, int role) {
// model1是主牌,model2是带牌,player是玩家出的牌,,list是准备回的牌
// 排序按重复数
player = Common.getOrder2(player);
int len1 = model1.size();
int len2 = model2.size();
// 如果有王直接炸了
if (len1 > 0 && model1.get(0).length() < 10) {
list.add(model1.get(0));
System.out.println("王炸");
return;
}
if (len1 < 1 || len2 < 1)
return;
for (int len = len1, i = len - 1; i >= 0; i--) {
if (getValueInt(model1.get(i)) > Common.getValue(player.get(0))) {
list.add(model1.get(i));
break;
}
}
list.add(model2.get(len2 - 1));
if (list.size() < 2)
list.clear();
}
// 延时，模拟时钟
public void timeWait(int n, int player) {
if (main.currentList[player].size() > 0)
Common.hideCards(main.currentList[player]);
if (player == 1)// 如果是我，10秒到后直接下一家出牌
{
int i = n;
while (main.nextPlayer == false && i >= 0) {
// main.container.setComponentZOrder(main.time[player], 0);
main.time[player].setText("倒计时:" + i);
main.time[player].setVisible(true);
second(1);
i--;
}
if (i == -1) {
main.time[player].setText("超时");
}
main.nextPlayer = false;
} else {
for (int i = n; i >= 0; i--) {
second(1);
// main.container.setComponentZOrder(main.time[player], 0);
main.time[player].setText("倒计时:" + i);
main.time[player].setVisible(true);
}
}
main.time[player].setVisible(false);
}
// 通过name估值
public int getValueInt(String n) {
String name[] = n.split(",");
String s = name[0];
int i = Integer.parseInt(s.substring(2, s.length()));
if (s.substring(0, 1).equals("5"))
i += 3;
if (s.substring(2, s.length()).equals("1") || s.substring(2, s.length()).equals("2"))
i += 13;
return i;
}
// 判断输赢
public boolean win() {
for (int i = 0; i < 3; i++) {
if (main.playerList[i].size() == 0) {
String s;
if (i == 1) {
s = "恭喜你，胜利了!";
} else {
s = "恭喜电脑" + i + ",赢了! 你的智商有待提高哦";
}
JOptionPane.showMessageDialog(main, s);
return true;
}
}
return false;
}
}
四、其他
1.其他系统实现
JavaWeb系统系列实现
Java+JSP实现学生图书管理系统
Java+JSP实现学生信息管理系统
Java+JSP实现用户信息管理系统
Java+Servlet+JSP实现航空订票系统
Java+Servlet+JSP实现房屋租赁管理系统
Java+Servlet+JSP实现学生选课管理系统
Java+Servlet+JSP实现宠物诊所管理系统
Java+Servlet+JSP实现学生成绩管理系统1
Java+Servlet+JSP实现学生成绩管理系统2
Java+SSM+Easyui实现网上考试系统
Java+SSH+Bootstrap实现在线考试系统
Java+Springboot+H-ui实现营销管理系统
Java+Springboot+Mybatis+Bootstrap实现网上商城系统
JavaSwing系统系列实现
Java+Swing实现斗地主游戏
Java+Swing实现图书管理系统
Java+Swing实现医院管理系统
Java+Swing实现考试管理系统
Java+Swing实现仓库管理系统1
Java+Swing实现仓库管理系统2
Java+Swing实现通讯录管理系统
Java+Swing实现停车场管理系统
Java+Swing实现学生信息管理系统
Java+Swing实现学生宿舍管理系统
Java+Swing实现学生选课管理系统
Java+Swing实现学生成绩管理系统
Java+Swing实现学校教材管理系统
Java+Swing实现学校教务管理系统
Java+Swing实现企业人事管理系统
Java+Swing实现电子相册管理系统
Java+Swing实现自助取款机(ATM)系统
Java+Swing实现超市管理系统-TXT存储信息
Java+Swing实现宠物商店管理系统-TXT存储信息
Java+Swing实现自助取款机(ATM)系统-TXT存储信息
2.获取源码
点击以下链接获取源码。
Java+Swing实现斗地主游戏源码
3.运行项目
请点击以下链接，部署你的项目。
Eclipse如何导入JavaSwing项目超详细教程
4.备注
如有侵权请联系我删除。
5.联系博主
左侧关注微信公众号，里面有Java教程和一些Java资源。如果此文对您有帮助，请关注加点赞，谢谢！
1829
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
