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

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) {
    }

}

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//不能出牌
}

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];// 单张
}

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>(); //炸弹
}

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