java版 简易斗地主(五)

Rule类
最重要的一个类了.
1是判断出牌是否合法,同时 判断是什么牌型
2对比 两幅牌的大小

public class Rule {

    public static int compare(ThrowLog d1, ArrayList<ThrowLog> all) {
        try{
            if(all.size()==0) {
                return  1;
            }
            ThrowLog t = all.get(all.size()-1);
            if(d1.getIndex()>t.getIndex()) {
                return 1;
            }
            if(d1.getIndex()<t.getIndex()) {
                return -1;
            }

            if(d1.getPokerGroup()!= t.getPokerGroup()) {
                return -1;
            }

            if(d1.getLength()!=t.getLength()) {
                return -1;
            }

            if(d1.getValue()>t.getValue()) {
                return 1;
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }

    public static RuleCheckResult check(List<Poker> c) {
        RuleCheckResult r = null;
        try{
            switch (c.size()) {
                case 1:
                    return new RuleCheckResult(PokerGroup.Single,c.get(0).getValue());
                case 2:
                    r = isDuad(c.get(0),c.get(1));
                    if (r.isValid()) {
                        return r;
                    }
                    r = isRocket(c.get(0),c.get(1));
                    if (r.isValid()) {
                        return r;
                    }
                    return new RuleCheckResult(PokerGroup.Unvalid,-1);
                case 3:
                    r = isThree(c.get(0),c.get(1),c.get(2));
                    if (r.isValid()) {
                        return r;
                    }
                    return new RuleCheckResult(PokerGroup.Unvalid,-1);
                case 4:
                    r = isThree(c);
                    if (r.isValid()) {
                        return r;
                    }
                    r = isBomb(c);
                    if (r.isValid()) {
                        return r;
                    }
                    return new RuleCheckResult(PokerGroup.Unvalid,-1);
                case 5:
                    r = isThree(c);
                    if (r.isValid()) {
                        return r;
                    }
                    r = isStraightFlush(c);
                    if (r.isValid()) {
                        return r;
                    }
                case 6:
                    r = isFour(c);
                    if (r.isValid()) {
                        return r;
                    }
                case 7:
                case 8:
                    r = isFour(c);
                    if (r.isValid()) {
                        return r;
                    }
                default:
                    r = isStraightFlush(c);
                    if (r.isValid()) {
                        return r;
                    }
                    r = isStraightFlush2(c);
                    if (r.isValid()) {
                        return r;
                    }
                    r = isStraightFlush3(c);
                    if (r.isValid()) {
                        return r;
                    }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
        return new RuleCheckResult(PokerGroup.Unvalid,-1);
    }

    public static RuleCheckResult isDuad(Poker p1, Poker p2) {
        int r =  Objects.equals(p1.getValue(),p2.getValue())?p1.getValue():-1;
        return new RuleCheckResult(PokerGroup.Duad,r);
    }

    public static RuleCheckResult isRocket(Poker p1, Poker p2) {
        int r = (Objects.equals(p1.getType(),"王") && Objects.equals(p2.getType(),"王"))?p1.getValue():-1;
        return new RuleCheckResult(PokerGroup.Rocket,r);
    }

    public static RuleCheckResult isBomb(List<Poker> list) {
        int r = -1;
        if(list.size()==4) {
            Multiset<Integer> ms = HashMultiset.create();
            for (Poker poker : list) {
                ms.add(poker.getValue());
            }
            List<Integer> values =  new ArrayList<>(ms.elementSet());
            if(values.size()==1) {
                return new RuleCheckResult(PokerGroup.Bomb,values.get(0));
            }
        }
        return new RuleCheckResult(PokerGroup.Bomb,r);
    }

    public static RuleCheckResult isThree(Poker p1, Poker p2, Poker p3) {
        int r = (Objects.equals(p1.getValue(),p2.getValue()) && Objects.equals(p1.getValue(),p3.getValue()))?p1.getValue():-1;
        return new RuleCheckResult(PokerGroup.Three,r);
    }

    public static RuleCheckResult isThree(List<Poker> list) {
        int r = -1;
        if(list.size()<=2) {
            new RuleCheckResult(PokerGroup.Three,r);
        }
        if(list.size()==3) {
            return isThree(list.get(0),list.get(1),list.get(2));
        }

        Multiset<Integer> ms = HashMultiset.create();
        for (Poker poker : list) {
            ms.add(poker.getValue());
        }
        List<Integer> values =  new ArrayList<>(ms.elementSet());

        if(list.size()==4 && values.size()==2) {
            if(ms.count(values.get(0))==3 && ms.count(values.get(1))==1) {
                return new RuleCheckResult(PokerGroup.ThreeWithSingle,values.get(0));
            }
            if(ms.count(values.get(0))==1 && ms.count(values.get(1))==3) {
                return new RuleCheckResult(PokerGroup.ThreeWithSingle,values.get(1));
            }
        }
        if(list.size()==5 && values.size()==2) {
            if(ms.count(values.get(0))==3 && ms.count(values.get(1))==2) {
                return new RuleCheckResult(PokerGroup.ThreeWithDuad,values.get(0));
            }
            if(ms.count(values.get(0))==2 && ms.count(values.get(1))==3) {
                return new RuleCheckResult(PokerGroup.ThreeWithDuad,values.get(1));
            }
        }
        return new RuleCheckResult(PokerGroup.Three,r);
    }

    public static RuleCheckResult isFour(List<Poker> list) {
        int r = -1;
        if(list.size()!=6 || list.size()!=8) {
            return new RuleCheckResult(PokerGroup.FourWithSingle2,r);
        }
        Multiset<Integer> ms = HashMultiset.create();
        for (Poker poker : list) {
            ms.add(poker.getValue());
        }
        List<Integer> values =  new ArrayList<>(ms.elementSet());
        List<Integer> lefts =  new ArrayList<>();
        List<Integer> right =  new ArrayList<>();
        for (int i = 0; i < values.size(); i++) {
            if(ms.count(values.get(i)) != 4) {
                right.add(values.get(i));
            }else {
                lefts.add(values.get(i));
            }
        }
        if(lefts.size()!=1) {
            return new RuleCheckResult(PokerGroup.FourWithSingle2,r);
        }
        if(right.size()==1 && ms.count(right.get(0))==2) {
            return new RuleCheckResult(PokerGroup.FourWithSingle2,r);
        }
        if(right.size()==2 && ms.count(right.get(0))==1 && ms.count(right.get(1))==1) {
            return new RuleCheckResult(PokerGroup.FourWithSingle2,lefts.get(0));
        }
        if(right.size()==2 && ms.count(right.get(0))==2 && ms.count(right.get(1))==2) {
            return new RuleCheckResult(PokerGroup.FourWithDuad2,lefts.get(0));
        }
        return new RuleCheckResult(PokerGroup.FourWithSingle2,r);
    }

    public static RuleCheckResult isStraightFlush(List<Poker> list) {
        int r = -1;
        if(list.size()<=4 || list.size()>=13) {
            return new RuleCheckResult(PokerGroup.StraightFlush,r);
        }
        Collections.sort(list);
        for (int i = 1; i < list.size(); i++) {
            if(list.get(i).getValue()-list.get(i-1).getValue() != 1) {
                return new RuleCheckResult(PokerGroup.StraightFlush,r);
            }
        }
        return new RuleCheckResult(PokerGroup.StraightFlush,list.get(0).getValue(),list.size());
    }

    public static RuleCheckResult isStraightFlush2(List<Poker> list) {
        int r = -1;
        if(list.size()<=5) {
            return new RuleCheckResult(PokerGroup.StraightFlush2,r);
        }
        Multiset<Integer> ms = HashMultiset.create();
        for (Poker poker : list) {
            ms.add(poker.getValue());
        }
        List<Integer> values =  new ArrayList<>(ms.elementSet());
        Collections.sort(values);
        for (int i = 1; i < values.size(); i++) {
            if(values.get(i)-values.get(i-1) != 1) {
                return new RuleCheckResult(PokerGroup.StraightFlush2,r);
            }
            if(ms.count(values.get(i)) != 2) {
                return new RuleCheckResult(PokerGroup.StraightFlush2,r);
            }
        }
        return new RuleCheckResult(PokerGroup.StraightFlush2,list.get(0).getValue(),values.size());
    }

    public static RuleCheckResult isStraightFlush3(List<Poker> list) {
        int r = -1;
        if(list.size()<=5) {
            return new RuleCheckResult(PokerGroup.StraightFlush3,r);
        }
        Multiset<Integer> ms = HashMultiset.create();
        for (Poker poker : list) {
            ms.add(poker.getValue());
        }
        List<Integer> values =  new ArrayList<>(ms.elementSet());
        Collections.sort(values);
        List<Integer> lefts =  new ArrayList<>();
        List<Integer> right =  new ArrayList<>();
        for (int i = 0; i < values.size(); i++) {
            if(ms.count(values.get(i)) != 3) {
                right.add(values.get(i));
            }else {
                lefts.add(values.get(i));
            }
        }
        if(lefts.size()<=1 || lefts.size()!=right.size() || ms.count(right.get(0))>=3) {
            return new RuleCheckResult(PokerGroup.StraightFlush3,r);
        }

        for (int i = 1; i < lefts.size(); i++) {
            if(lefts.get(i)-lefts.get(i-1) != 1) {
                return new RuleCheckResult(PokerGroup.StraightFlush3,r);
            }
            if(ms.count(right.get(i)) != ms.count(right.get(i-1))) {
                return new RuleCheckResult(PokerGroup.StraightFlush3,r);
            }
        }
        int cc = ms.count(right.get(0));
        if(cc==0) {
            return new RuleCheckResult(PokerGroup.StraightFlush3,lefts.get(0),lefts.size());
        }else if(cc==1) {
            return new RuleCheckResult(PokerGroup.StraightFlush3WithSingle,lefts.get(0),lefts.size());
        }else if(cc==2) {
            return new RuleCheckResult(PokerGroup.StraightFlush3WithDuad,lefts.get(0),lefts.size());
        }
        return new RuleCheckResult(PokerGroup.StraightFlush3,r);
    }


}

RuleCheckResult类
存储比较和校验结果

public class RuleCheckResult {

    public RuleCheckResult(PokerGroup pg, Integer value) {
        this.value = value;
        this.length = 1;
        this.pokerGroup = pg;
        this.valid = (pg.getIndex()>=1)&&(value.intValue()>=1);
    }

    public RuleCheckResult(PokerGroup pg, Integer value, Integer length) {
        this.value = value;
        this.length = length;
        this.pokerGroup = pg;
        this.valid = (pg.getIndex()>=1)&&(value.intValue()>=1);
    }

    private boolean valid;

    private PokerGroup pokerGroup;

    private Integer value;

    private Integer length;
}