java简易小程序--打扑克

最新推荐文章于 2024-04-11 22:55:59 发布
最新推荐文章于 2024-04-11 22:55:59 发布
阅读量8.4k 收藏
点赞数
分类专栏： java后端 文章标签： java 开发语言 小程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kedat/article/details/122435349
版权

对牌进行处理:

package wed.poke;

import wed.Clear;

import java.awt.*;
import java.awt.event.InputEvent;
import java.util.*;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Random;
import java.util.HashMap;


public class 牌库 {
    private char[] hs={'♤' ,'♧' ,'♡' ,'♢'};
    private String[] sum={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
    private ArrayList<String> ay=new ArrayList();
    private ArrayList<String> rk=new ArrayList();
    public ArrayList<String> p1=new ArrayList();
    public ArrayList<String> p2=new ArrayList();
    public ArrayList<String> p3=new ArrayList();
    private Random r=new Random();
    Scanner sc=new Scanner(System.in);
    HashMap<String,Integer> pz = new HashMap();

    public  static void clear() {
        try
        {
            Robot r = new Robot();
            r.mouseMove(500, 750);
            r.mousePress(InputEvent.BUTTON3_DOWN_MASK);
            r.mouseRelease(InputEvent.BUTTON3_DOWN_MASK);
            r.mouseMove(510, 810);
            r.mousePress(InputEvent.BUTTON1_DOWN_MASK);
            r.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
        }
        catch (AWTException e)
        {
            e.printStackTrace();
        }
    }

    public  void setup(){
        int t;
        for(int i=0;i<4;i++)
        {
            for(int x=0;x<13;x++)
            {
                ay.add(hs[i]+sum[x]);
                pz.put(hs[i]+sum[x],x+1);
            }
        }
        ay.add("Queen");
        pz.put("Queen",14);
        ay.add("King");
        pz.put("King",15);
        pz.put("0",0);
    }

    public void re(){
        int i=54;
        String a,b;
        while(i!=0){
            a=ay.remove(r.nextInt(53));
            b=ay.remove(r.nextInt(53));
            ay.add(a);
            ay.add(b);
            i--;
        }
    }

    public void see(){
        for(int i=0;i<54;i++){
            System.out.printf("%s ",ay.get(i));
        }
    }

    public void setplay(){
        int i=54;
        String s;
        while(i!=0){
            s=ay.remove(r.nextInt(i));
            p1.add(s);
            i--;
            s=ay.remove(r.nextInt(i));
            p2.add(s);
            i--;
            s=ay.remove(r.nextInt(i));
            p3.add(s);
            i--;
        }
    }

    public void start(){
        int i=2;
        String[] s={"0","0"};
        String[] pl={"p1","p2"};
        while(true){
            Clear.cls();
            System.out.println("\np1: "+p1);
            System.out.printf("\np1:   ");
            s[i%2]=sc.next();
            pl[i%2]="p1";
            if(s[i%2].equals("过")){
                System.out.printf("\n请重新出牌:     ");
                continue;
            }
            if(pl[i%2].equals(pl[(i-1)%2])){
                i++;
                break;
            }
            else{
                if(p1.contains(s[i%2])){
                    if(pz.get(s[i%2])>pz.get(s[(i-1)%2])){
                        p1.remove(s[i%2]);
                        i++;
                        break;
                    }
                    else{
                        System.out.printf("\n请重新出牌:   ");
                    }
                }
                else{
                    System.out.printf("\n请重新出牌:    ");
                }
            }
        }
        while(!p1.isEmpty()||!p2.isEmpty()&&!p3.isEmpty()){
            while(true&&!p2.isEmpty()){
                Clear.cls();
                System.out.println("\np2: "+p2);
                System.out.println("\n"+pl[(i-1)%2]+":    "+s[(i-1)%2]);
                System.out.printf("\np2:   ");
                s[i%2]=sc.next();
                pl[i%2]="p2";
                if(s[i%2].equals("过")){
                    if(pl[i%2].equals(pl[(i-1)%2])){
                        System.out.printf("\n请重新出牌:     ");
                        continue;
                    }
                    break;
                }
                if(pl[i%2].equals(pl[(i-1)%2])){
                    if(!p2.remove(s[i%2])){
                        System.out.printf("\n请重新出牌:     ");
                        continue;
                    }
                    if(p2.isEmpty()) {
                        rk.add("p2");
                        if(p1.isEmpty()){
                            rk.add("p3");
                            p3.clear();
                        }
                        if(p3.isEmpty()){
                            rk.add("p1");
                            p1.clear();
                        }
                        pl[i%2]="p3";
                    }
                    i++;
                    break;
                }
                else{
                    if(p2.contains(s[i%2])){
                        if(pz.get(s[i%2])>pz.get(s[(i-1)%2])){
                            p2.remove(s[i%2]);
                            if(p2.isEmpty()) {
                                rk.add("p2");
                                if(p1.isEmpty()){
                                    rk.add("p3");
                                    p3.clear();
                                }
                                if(p3.isEmpty()){
                                    rk.add("p1");
                                    p1.clear();
                                }
                                pl[i%2]="p3";
                            }
                            i++;
                            break;
                        }
                        else{
                            System.out.printf("\n请重新出牌:   ");
                        }
                    }
                    else{
                        System.out.printf("\n请重新出牌:    ");
                    }
                }
            }
            while(true&&!p3.isEmpty()){
                Clear.cls();
                System.out.println("\np3: "+p3);
                System.out.println("\n"+pl[(i-1)%2]+":    "+s[(i-1)%2]);
                System.out.printf("\np3:   ");
                s[i%2]=sc.next();
                pl[i%2]="p3";
                if(s[i%2].equals("过")){
                    if(pl[i%2].equals(pl[(i-1)%2])){
                        System.out.printf("\n请重新出牌:     ");
                        continue;
                    }
                    break;
                }
                if(pl[i%2].equals(pl[(i-1)%2])){
                    if(!p3.remove(s[i%2])){
                        System.out.printf("\n请重新出牌:     ");
                        continue;
                    }
                    if(p3.isEmpty()) {
                        rk.add("p3");
                        if(p1.isEmpty()){
                            rk.add("p2");
                            p2.clear();
                        }
                        if(p2.isEmpty()){
                            rk.add("p1");
                            p1.clear();
                        }
                        pl[i%2]="p1";
                    }
                    i++;
                    break;
                }
                else{
                    if(p3.contains(s[i%2])){
                        if(pz.get(s[i%2])>pz.get(s[(i-1)%2])){
                            p3.remove(s[i%2]);
                            if(p3.isEmpty()) {
                                rk.add("p3");
                                if(p1.isEmpty()){
                                    rk.add("p2");
                                    p2.clear();
                                }
                                if(p2.isEmpty()){
                                    rk.add("p1");
                                    p1.clear();
                                }
                                pl[i%2]="p1";
                            }
                            i++;
                            break;
                        }
                        else{
                            System.out.printf("\n请重新出牌:   ");
                        }
                    }
                    else{
                        System.out.printf("\n请重新出牌:    ");
                    }
                }
            }
            while(true&&!p1.isEmpty()){
                Clear.cls();
                System.out.println("\np1: "+p1);
                System.out.println("\n"+pl[(i-1)%2]+":    "+s[(i-1)%2]);
                System.out.printf("\np1:   ");
                s[i%2]=sc.next();
                pl[i%2]="p1";
                if(s[i%2].equals("过")){
                    if(pl[i%2].equals(pl[(i-1)%2])){
                        System.out.printf("\n请重新出牌:     ");
                        continue;
                    }
                    break;
                }

                if(pl[i%2].equals(pl[(i-1)%2])){
                    if(!p1.remove(s[i%2])){
                        System.out.printf("\n请重新出牌:     ");
                        continue;
                    }
                    if(p1.isEmpty()) {
                        rk.add("p1");
                        if(p2.isEmpty()){
                            rk.add("p3");
                            p3.clear();
                        }
                        if(p3.isEmpty()){
                            rk.add("p2");
                            p2.clear();
                        }
                        pl[i%2]="p2";
                    }
                    i++;
                    break;
                }
                else{
                    if(p1.contains(s[i%2])){
                        if(pz.get(s[i%2])>pz.get(s[(i-1)%2])){
                            p1.remove(s[i%2]);
                            if(p1.isEmpty()) {
                                rk.add("p1");
                                if(p2.isEmpty()){
                                    rk.add("p3");
                                    p3.clear();
                                }
                                if(p3.isEmpty()){
                                    rk.add("p2");
                                    p2.clear();
                                }
                                pl[i%2]="p2";
                            }
                            i++;
                            break;
                        }
                        else{
                            System.out.printf("\n请重新出牌:   ");
                        }
                    }
                    else{
                        System.out.printf("\n请重新出牌:    ");
                    }
                }
            }
        }
    }
    public void end(){
        Clear.cls();
        System.out.println("\nFirst:    "+rk.get(0));
        System.out.println("\nSecond:    "+rk.get(1));
        System.out.println("\nThird:    "+rk.get(2));
    }

}

用到的清屏操作：

编译器idea      控制台清空快捷键  ctrl+alt+backspace

package wed;
import java.awt.*;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;

public class Clear {
    public static void cls(){
        try{
            Robot r=new Robot();
            r.setAutoDelay(100);
            r.mouseMove(500,700);
            r.mousePress(KeyEvent.BUTTON1_DOWN_MASK);
            r.mouseRelease(KeyEvent.BUTTON1_DOWN_MASK);
            r.setAutoDelay(50);
            r.keyPress(KeyEvent.VK_CONTROL);
            r.keyPress(KeyEvent.VK_ALT);
            r.keyPress(KeyEvent.VK_BACK_SPACE);
            r.keyRelease(KeyEvent.VK_CONTROL);
            r.keyRelease(KeyEvent.VK_ALT);
            r.keyRelease(KeyEvent.VK_BACK_SPACE);
        }catch(AWTException e){
            e.printStackTrace();
        }
    }
}

主体程序：

package wed.poke;
import wed.Clear;

import java.util.Scanner;
public class 发牌员 {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        牌库 pk=new 牌库();
        pk.setup();
        pk.re();
        pk.setplay();
        System.out.printf("\np1: ");
        for(int i=0;i<18;i++){
            System.out.printf("%s ",pk.p1.get(i));
        }
        System.out.printf("\np2: ");
        for(int i=0;i<18;i++){
            System.out.printf("%s ",pk.p2.get(i));
        }
        System.out.printf("\np3: ");
        for(int i=0;i<18;i++){
            System.out.printf("%s ",pk.p3.get(i));
        }
        Clear.cls();

        pk.start();
        pk.end();
        try {
            Thread.sleep( 10000 );
        } catch (Exception e){
            System.exit( 0 ); //退出程序
        }

    }


}

Re_Dreamer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
直播App的开发超简单 3步就完成
JerryWu145的专栏
01-19 6万+
不知道从什么时候开始，“女主播”这个关键词频频出现在我们身边，花式直播App层出不穷。从直播玩游戏、唱歌到直播吃饭、睡觉、化妆日常生活。网上有一批美女在不遗余力的展现自己生活的细节，就因为背后有一群粉丝愿意花时间和金钱去看。 直播App的火爆点燃了创业的一个新的热潮，电商、O2O甚至P2P都那么过时。今年就是要玩直播，玩VR/AR才够潮！小编听说有人声称开发一款直播App不仅
多人在线游戏开发心得(服务器端)
软若石（I Will Get What I Want.）Asp.Net,Ajax,C#,Javascript
04-14 4839
bromon原创　版权所有　　一个多人在线的棋牌类网络游戏的项目临近尾声，我参与了该项目的整个设计流程，并且完成了90%的核心代码。关于这个项目，有很多地方值得聊一聊。本系列不打算把这个项目将得多么详细规范，那是设计文档应该描述的，我打算只说说一些值得注意的地方。这个项目的一个特别之处是，客户端是手机，用户通过移动网络与服务器通信。和PC相比，手机的处理能力极弱，而且网络流量费用昂贵。因为除了要考
《安卓最佳免费应用》
热门推荐
拾贝者
08-20 5万+
http://xbeta.info/android.htm 《安卓最佳免费应用》 安卓最佳免费应用: 家庭和办公 　　办公套件 – Documents To Go | Google Docs | 　　PDF阅读器 – Adobe Reader | 　　电子书阅读器 – Moon+ Reader | Laputa Reader | 　　日历 – Jorte | Calendar Pad
打扑克直播软件app开发：直播如何和游戏结合？
chenie0562的专栏
04-23 7950
直播软件app开发已成为当今最热门的开发领域之一。在这个快速发展的市场中，如何让你的直播软件脱颖而出？一种方法是将直播与游戏结合起来。在这篇文章中，我们将探讨如何开发一个打扑克直播软件，并分享一些关于视频直播app源码的想法。
2020秋招笔试题总结（华为、360、京东、中兴、快手、字节跳动、阿里、拼多多、腾讯、VIVO）~持续更新
学习猴
08-16 1万+
目录 1.华为 1.1全量和已占用字符集合 1.2解析逻辑字符串 1.3比特块 1.4文本解析 1.5社交软件好友度 2.360 2.1表面积 2.2寻找子串 2.3散步 3.京东 3.1最多能完成排序的块 3.2考场安排 4.中兴 4.1工资按频次排序 4.2维克多博士问题 5.快手 5.1可以升级的版本号 5.2计算累计平方和 5.3合并两个内容流 5...
翻扑克牌-微信小程序-项目源码
10-27
这是一个微信小程序项目源码，翻扑克牌游戏，可使用微信开发者工具选小程序打开，正常编译运行，请放心下载。 相关学习参考文章(https://blog.csdn.net/zs1028/article/details/134083333) 在此游戏能学到什么： -...
java扑克牌算法-报告.doc
05-25
java扑克牌算法-报告.doc
微信小程序-24点游戏
03-15
游戏难度分初、中、高三个等级，默认初级；每局游戏自动生成4个随机数（已经验证可算出24点，超过2种算法的算初级，只有一种为高难度，只有两种的算中等难度），通过...本次尝试用到了小程序的数据缓存存储、读取以及用
java-西游记扑克牌游戏.zip
最新发布
06-15
该资源内项目源码是个人的课程设计、毕业设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请...
java-程序扑克牌.doc
06-26
java-程序扑克牌.doc
零知识扑克牌游戏开发教程【ZK Poker】
跨链技术践行者
07-31 4270
零知识证明是实现去中心化的一个重要工具。当平台透明存储数据时 我们应当如何保证隐私？当为了扩容而引入链下交易时，我们如何在 链上进行验证？零知识证明在解决这些问题时可以发挥重要的作用。 这个教程的目的是帮助你探索circom/snarkjs的更多可能性，我们 将学习如何开发一个基于零知识证明的扑克牌游戏。 当谈及零知识电路开发时，我们有很多可选的库。实现我发现iden3开发的circom和snarkjs 对于零知识证明的新手很友好：电路很容易编写，整个零知识证明框架 的运行也很简单，不需要复杂的环境。
文章：从玩扑克到软件开发
cpongo011702
05-08 270
世上本无银弹。我们虽深知这一点，但我们的行为却常常与之不符。你是否会觉得自己所用的语言、工具或者过程总好过别家？Jay Fields在文中说道，“对症下药，量体裁衣”。正确的决策会因环境、人以及其他因素而异。本文论及影响决策过程的众多因素：学习文化、技能水平、团队协作、不完备的信息、衡量标准以及上下文。 \u0026#xD; Jay在文中针对这些主题与他从前的职业——专业牌手进行了逐一比较。他...
本版1年以内的所有 面经题目
weixin_30606669的博客
01-13 3万+
不敢保证全部涵盖，大部分的都在。 我自己找了一遍，大家一起用着都方便。 不过只是含有题目的帖子 我才包含进来了，只分享经验没贴题目的 我都没有包含 进来。 大家复习着方便。 1. 一个sorted interger Array[1...N], 已知范围 1...N+1. 已知一个数字missing。 找该数字。 把原题改为unsorted，找mi...
P5356 YNOI2017 由乃打扑克 (分块
weixin_45539557的博客
05-06 3178
P5356 YNOI2017 由乃打扑克 题意： 区间加，区间第k大数 思路： 主席树又无法维护，考虑数列分块 区间查询 显然数列分块后直接统计答案的话，块的贡献是不独立且不正确的，一个块的kkk小值不一定是另一个块内kkk小值，线段树上求kkk小本质是利用二分统计个数。所以我们也考虑二分答案，统计所有块小于等于该数的总数有多少个，假如小于k的话，二分的答案太小了，否则太大了。 这样的话查询是O(logw(n/B∗logB+B))O(logw(n/B*logB+B))O(logw(n/B∗logB+B)
直播平台软件开发的前端如何实现整套视频直播技术流程
云豹直播源码
09-14 1728
直播平台软件开发的前端如何实现整套视频直播技术流程 正文 下面按照目录大纲来一个一个讲解。 1. 直播技术的介绍 直播技术涵盖很广，现如今大家广泛了解的就有视频网站的个人直播、手机直播、安防方面的摄像头监控等会使用到直播的技术。 下面先出一张概念图，介绍直播流程中的各个技术环节。可以理解分为采集端、流媒体服务器以及播放端；还需要了解什么是推流，什么是拉流。 采集端：顾名思义是视频的源头，视频的采集一般都是从真实的摄像头中得到的。例如移动端设别、PC端设备的摄像头以及一些摄像头设备； 流媒体
基于AndroidStudio开发的扑克牌计算24点APP
weixin_73562709的博客
04-11 418
基于AndroidStudio开发的扑克牌计算24点APP 功能实现 已知一副扑克牌有54张，去除大王和小王，剩余52张。在其中抽取4张牌，利用加减乘除进行计算得到24，除法必须能够除尽。编写程序从一副扑克牌，选择4张，进行计算是否能得到24。如果可以，排序列出可能的计算表达式，可能有多种计算形式。
直播app开发必备五步流程
chenie0562的专栏
05-10 4983
直播app开发搭建是最近几年比较火的技术，本文从技术角度分析一套直播app开发必备的几个流程。 从主播录制视频开始到最后直播间播放，涉及到的流程包括： 音视频采集—>编码和封装—>推流到流媒体服务器—>流媒体服务器播流分发—>直播间播放器播放 1.音视频采集 采集是第一步，一般通过pc摄像头，手机摄像头等方式获取原始视频数据，采集的格式很一般为原始的YUV格式，需要经过后续处理才能推送到服务端。 2.编码和封装 在编码封装前一般会做视频的美颜处理，音频的混音降噪处理...
ArrayList实现玩扑克牌（代码版）
weixin_61436104的博客
12-02 1090
实现玩扑克牌
模拟扑克牌大小软件_扑克与软件工程
cumi6497的博客
07-08 2027
模拟扑克牌大小软件by Jeff Meyerson 杰夫·梅耶森(Jeff Meyerson) 扑克与软件工程 (Poker and Software Engineering) As a poker player becomes a software engineer, certain trends about human-computer interaction become apparen...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值