Eclipse+Java+Swing实现斗地主游戏(代码)

目录

• 一、系统介绍
• 二、系统展示
• 1.扑克分发
• 2.抢地主
• 3.出牌
• 4.游戏胜利
• 三、系统实现
• Card.java
• CardType.java
• Common.java
• Model.java
• NewSwing.java

一、系统介绍

本系统实现扑克的分发，抢地主，电脑自动出牌等功能。

二、系统展示

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;
    }
}

到此这篇关于Eclipse+Java+Swing实现斗地主游戏（代码）的文章就介绍到这了,更多相关Eclipse+Java+Swing实现斗地主游戏内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！