2048

最新推荐文章于 2024-11-05 19:07:59 发布
最新推荐文章于 2024-11-05 19:07:59 发布
阅读量1.1w 收藏
点赞数
分类专栏： 游戏 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyl52101314/article/details/72765059
版权 
package com.tedu.Game2048;
	 
	import java.awt.BorderLayout;
	import java.awt.Color;
	import java.awt.Container;
	import java.awt.FlowLayout;
	import java.awt.GridLayout;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.util.Random;
	 
	import javax.swing.*;
	 
	@SuppressWarnings("serial")
	public class Frame extends JFrame{
	 
	    /**
	     * @param args
	     */
	    Container thisContainer; 
	    JLabel label;
	    JPanel panel1,panel2,panel3;
	//  JPanel panel3 = new JPanel();
	    JButton numBtn[][]=new JButton[4][4];
	    JButton controlBtn[]=new JButton[4];
	    JButton playAgainButton,exitButton;
	    int grid[][]=new int[4][4],score=0;
	    Action_2048 act=new Action_2048();
	     
	    public void Init(){
	        this.setBounds(280,100,500,450);//组件的x坐标，y坐标，组件的宽，组件的高
	        this.setTitle("Java版2048");
	        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	         
	        label=new JLabel("Score:");
	        label.setForeground(Color.red);//设置字的颜色
	        thisContainer=this.getContentPane();
	        panel1=new JPanel();
	        panel2=new JPanel();
	        panel3=new JPanel();
	        thisContainer.add(panel1,BorderLayout.NORTH); 
	        thisContainer.add(panel2,BorderLayout.CENTER);
	        thisContainer.add(panel3,BorderLayout.SOUTH);
	         
	        panel1.setLayout(new FlowLayout());
	        panel1.add(label);
	         
	        //对数组面板panel2布局
	        panel2.setLayout(new GridLayout(4,4));
	        for(int i=0;i<4;i++){
	            for(int j=0;j<4;j++){
	                numBtn[i][j]=new JButton();
	                grid[i][j]=0;
	                numBtn[i][j]=new JButton(String.valueOf(grid[i][j]));
	                numBtn[i][j].setFont(new java.awt.Font("Segoe UI Symbol",1, 25));
//	              设置背景色（String 字体，int 风格 ，int 字号）；
	                numBtn[i][j].setBackground(Color.CYAN);
//	              设置按钮不要边框
//	              numBtn[i][j].setBorderPainted(false);
	                //设置凸起来的按钮，很多其他的swing也可用此方法
	                numBtn[i][j].setBorder(BorderFactory.createRaisedBevelBorder());
//	              设置凹起来的按钮，很多其他的swing也可用此方法
//	              numBtn[i][j].setBorder(BorderFactory.createLoweredBevelBorder());
	                panel2.add(numBtn[i][j]);
	            }
	        }
	        int k=(int)Math.round(Math.random()*15);// 四舍五入 0<<1
	        int i=k/4;
	        int j=k%4;
	        grid[i][j]=2;
	        numBtn[i][j].setText(String.valueOf(grid[i][j]));
	         
	        //对方向控制按钮进行布局以及对"退出"、"再来一局"进行布局
	        panel3.setLayout(new FlowLayout());
	        controlBtn[0] = new JButton("↑");
	        controlBtn[1] = new JButton("↓");
	        controlBtn[2] = new JButton("←");
	        controlBtn[3] = new JButton("→");
	         
	        for(i=0;i<4;i++){
	            controlBtn[i].addActionListener(act);
	            panel3.add(controlBtn[i]);
	        }
	        playAgainButton=new JButton("再来一局"); 
	        exitButton=new JButton("退出");
	        playAgainButton.addActionListener(act);
	        exitButton.addActionListener(act);
	        panel3.add(exitButton);
	        panel3.add(playAgainButton);
	         
	 
	        this.setVisible(true);
	    }
	    class Action_2048 implements ActionListener{
	        @Override
	        public void actionPerformed(ActionEvent e) {
	            // TODO Auto-generated method stub
	            int f=0,TongGuanF=0;
	            //"↑"————controlBtn[0]
	            if(e.getSource()==controlBtn[0]){
	                int i=0,j=0,n,t[]={0,0,0,0};
	                int b[][]=new int[4][4];
	                for(i=0;i<4;i++)
	                {
	                    n=0;
	                    for(j=0;j<4;j++)
	                    {
	                        b[j][i]=grid[j][i];
	                        if(grid[j][i]!=0)
	                        {
	                            t[n++]=grid[j][i];
	                        }
	                    }
	                    for(j=0;j<4;j++)
	                    {
	                        grid[j][i]=t[j];
	                        numBtn[j][i].setText(String.valueOf(grid[j][i]));
	                        t[j]=0;     //避免下一列受上一列的影响
	                    }
	                }
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<4;j++)
	                    {
	                        if(grid[i][j]!=b[i][j])
	                        {
	                            f=1;
	                            break;
	                        }
	                    }
	                    if(f==1)
	                        break;
	                }
	 
	 
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<3;j++)
	                    {
	                        if((grid[j][i]==grid[j+1][i])&&(grid[j][i]!=0))
	                        {
	                            f=1;
	                            grid[j][i]=2*grid[j][i];
	                            numBtn[j][i].setText(String.valueOf(grid[j][i]));
	                            score+=grid[j][i];
	                            for(n=j+1;n<3;n++)
	                            {
	                                grid[n][i]=grid[n+1][i];
	                                numBtn[n][i].setText(String.valueOf(grid[n][i]));
	                            }
	                            grid[n][i]=0;
	                            numBtn[n][i].setText(String.valueOf(grid[n][i]));
	                        }
	                    }
	                }
	            }
	            if(e.getSource()==controlBtn[1]){
	                int i=0,j=0,n,t[]={0,0,0,0};
	                int b[][]=new int[4][4];
	                for(i=0;i<4;i++)
	                {
	                    n=0;
	                    for(j=0;j<4;j++)
	                    {
	                        b[j][i]=grid[j][i];
	                        if(grid[j][i]!=0)
	                        {
	                            t[n++]=grid[j][i];
	                        }
	                    }
	                    for(j=3;j>=0;j--)
	                    {
	                        if(n>0)
	                        {
	                            grid[j][i]=t[n-1];
	                            numBtn[j][i].setText(String.valueOf(grid[j][i]));
	                            n--;
	                        }else{
	                            grid[j][i]=0;       //避免下一列受上一列的影响
	                            numBtn[j][i].setText(String.valueOf(grid[j][i]));
	                        }
	                    }
	                }
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<4;j++)
	                    {
	                        if(grid[i][j]!=b[i][j])
	                        {
	                            f=1;
	                            break;
	                        }
	                    }
	                    if(f==1)
	                        break;
	                }
	 
	 
	                for(i=0;i<4;i++)
	                {
	                    for(j=3;j>0;j--)
	                    {
	                        if((grid[j][i]==grid[j-1][i])&&(grid[j][i]!=0))
	                        {
	                            f=1;
	                            grid[j][i]=2*grid[j][i];
	                            numBtn[j][i].setText(String.valueOf(grid[j][i]));
	                            score+=grid[j][i];
	                            for(n=j-1;n>0;n--)
	                            {
	                                grid[n][i]=grid[n-1][i];
	                                numBtn[n][i].setText(String.valueOf(grid[n][i]));
	                            }
	                            grid[n][i]=0;
	                            numBtn[n][i].setText(String.valueOf(grid[n][i]));
	                        }
	                    }
	                }
	            }
	            if(e.getSource()==controlBtn[2]){
	                int i=0,j=0,n,t[]={0,0,0,0};
	                int b[][]=new int[4][4];
	                for(i=0;i<4;i++)
	                {
	                    n=0;
	                    for(j=0;j<4;j++)
	                    {
	                        b[i][j]=grid[i][j];
	                        if(grid[i][j]!=0)
	                        {
	                            t[n++]=grid[i][j];
	                        }
	                    }
	                    for(j=0;j<4;j++)
	                    {
	                        grid[i][j]=t[j];
	                        numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                        t[j]=0;     //避免下一行受上一行的影响
	                    }
	                }
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<4;j++)
	                    {
	                        if(grid[i][j]!=b[i][j])
	                        {
	                            f=1;
	                            break;
	                        }
	                    }
	                    if(f==1)
	                        break;
	                }
	 
	 
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<3;j++)
	                    {
	                        if((grid[i][j]==grid[i][j+1])&&(grid[i][j]!=0))
	                        {
	                            f=1;
	                            grid[i][j]=grid[i][j]*2;
	                            numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                            score+=grid[i][j];
	                            for(n=j+1;n<3;n++)
	                            {
	                                grid[i][n]=grid[i][n+1];
	                                numBtn[i][n].setText(String.valueOf(grid[i][n]));
	                            }
	                            grid[i][n]=0;
	                            numBtn[i][n].setText(String.valueOf(grid[i][n]));
	                        }
	                    }
	                }
	            }
	            if(e.getSource()==controlBtn[3]){
	                int i=0,j=0,n,t[]={0,0,0,0};
	                int b[][]=new int[4][4];
	                for(i=0;i<4;i++)
	                {
	                    n=0;
	                    for(j=0;j<4;j++)
	                    {
	                        b[i][j]=grid[i][j];
	                        if(grid[i][j]!=0)
	                        {
	                            t[n++]=grid[i][j];
	                        }
	                    }
	                    for(j=3;j>=0;j--)
	                    {
	                        if(n>0)
	                        {
	                            grid[i][j]=t[n-1];
	                            n--;
	                            t[n]=0;
	                            numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                        }else{
	                            grid[i][j]=0;
	                            numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                        }
	                         
	                        //避免下一行受上一行的影响
	                    }
	                }
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<4;j++)
	                    {
	                        if(grid[i][j]!=b[i][j])
	                        {
	                            f=1;
	                            break;
	                        }
	                    }
	                    if(f==1)
	                        break;
	                }
	 
	 
	                for(i=0;i<4;i++)
	                {
	                    for(j=3;j>0;j--)
	                    {
	                        if((grid[i][j]==grid[i][j-1])&&(grid[i][j]!=0))
	                        {
	                            f=1;
	                            grid[i][j]=grid[i][j]*2;
	                            numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                            score+=grid[i][j];
	                            for(n=j-1;n>0;n--)
	                            {
	                                grid[i][n]=grid[i][n-1];
	                                numBtn[i][n].setText(String.valueOf(grid[i][n]));
	                            }
	                            grid[i][n]=0;
	                            numBtn[i][n].setText(String.valueOf(grid[i][n]));
	                        }
	                    }
	                }
	            }
	            if(e.getSource()==playAgainButton){
	                for(int i=0;i<4;i++){
	                    for(int j=0;j<4;j++){
	                        grid[i][j]=0;
	                        numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                    }
	                }
	                int k=(int)Math.round(Math.random()*15);
	                int i=k/4;
	                int j=k%4;
	                grid[i][j]=2;
	                numBtn[i][j].setText(String.valueOf(grid[i][j]));
	            }
	            if(e.getSource()==exitButton){
	                System.exit(0);
	            }
	             
	            //产生新数2、4
	            if(f==1){
	                int r[]=new int[16];
	                int n=0,i,j;
	                for(i=0;i<4;i++)
	                {
	                    for(j=0;j<4;j++)
	                    {
	                        if((grid[i][j]==0))
	                        {
	                            r[n]=i*4+j;
	                            n++;
	                        }
	                    }
	                }
	 
	                Random rd=new Random();
	                int k=rd.nextInt(n);//返回一个小于n的随机整数
	                i=r[k]/4;
	                j=r[k]%4;
	                if((i+j)%5!=0)
	                {
	                    grid[i][j]=2;
	                }
	                else{
	                    grid[i][j]=4;
	                }
	                numBtn[i][j].setText(String.valueOf(grid[i][j]));
	                if(score>5000){
	                    for(i=0;i<4;i++){
	                        for(j=0;j<4;j++){
	                            if(grid[i][j]==2048)
	                                TongGuanF=1;
	                        }
	                    }
	                }
	                if(TongGuanF==1)
	                    label.setText("恭喜过关！");
	                else
	                    label.setText("Score:  "+String.valueOf(score)+"分"); 
	            }
	        }
	         
	    }
	     
	    public static void main(String[] args) {
	        // TODO Auto-generated method stub
	        Frame f=new Frame();
	        f.Init();
	    }
	 
	}

2048核心算法
m0_52604787的博客
12-06 1898
2048核心算法 零元素移动至末尾 思路：从后向前依次判断，若为零，则删除，末尾追加0
逻辑地址 虚拟地址 基地址 物理地址
womanonthetr的博客
07-20 2761
逻辑地址：段偏移量 虚拟地址： 段号+页号+偏移量 or 段号+偏移量 or 页号+偏移量 基地址：段头 即段号 物理地址：实际内存中看到的地址。
2048基站
02-16
2048基站
hdoj 2048
—— 然 之
08-10 3433
http://acm.hdu.edu.cn/showproblem.php?pid=2048 DP 入门 /* 首先我们考虑，如果前面N-1个人拿的都不是自己的票，即前N-1个人满足错排，现在又来了一个人，他手里拿的是自己的票。 只要他把自己的票与其他N-1个人中的任意一个交换，就可以满足N个人的错排。这时有N-1种方法。 另外，我们考虑，如果前N-1个人不满足错排，而第N个人把自己的票
2048game:游戏网络基地
06-04
2048-安卓 这是 Gabriele Cirulli 制作的 2048 游戏的 android 端口没什么特别的，只是一个加载原始游戏本地存储的 html 文件的 webview。 我只是想让它在没有互联网的情况下立即播放（该应用程序不需要任何权限）并为我的智能手机提供快速访问图标。 如果您有任何特定于 android 的改进，请随时向 Gabriele 的原始项目或这个项目提供拉取请求。 Play 商店链接： : ＃＃建造 如果你想从源代码构建就做 git clone https://github.com/uberspot/2048-android.git cd 2048-android/ git submodule update --recursive ＃＃执照 2048-android 在许可下获得
用c++实现游戏2048---核心算法
Hanpu_Liang的博客
07-24 2432
用c++实现2048—核心算法 写在前面 这一篇主要讲如何相应操纵者给出的指令，对地图进行相应的操作。 这里我最开始的思路很简单，就是将地图的移动方式分为四种，即上(w)下(s)左(a)右(d)。 但是如果分为四个函数的话，那就太繁琐了，复用性太差，相同的代码复制四次只修改一点，十分难看，所以通过思考将四个移动方式合并成为一个移动方式就是本篇所要思考的内容。 根据指令移动地图 ...
基于Android studio的2048游戏设计源代码.zip
最新发布
11-26
基于Android studio的2048游戏设计源代码.zip基于Android studio的2048游戏设计源代码.zip基于Android studio的2048游戏设计源代码.zip基于Android studio的2048游戏设计源代码.zip基于Android studio的2048游戏设计...
qttbar2048版本
11-16
QTTabBar 2048 版本是一个针对Windows资源管理器的增强工具，它将经典的游戏2048的概念融入到了文件管理器的界面中，使得用户在浏览文件的同时可以享受到游戏的乐趣。这个版本特别提供了中文安装包，方便中国用户...
2048 ai 让你轻松达到2048 在最新的硬件上可以搜索1000万步每秒
04-10
2048 ai 让你轻松达到2048 在最新的硬件上可以搜索1000万步每秒.2048 AI 是一款旨在帮助玩家轻松达到 2048 分的人工智能程序。在最新的硬件上，该 AI 能够每秒搜索 1000 万步，为玩家提供高效的游戏决策支持。通过其...
2048源码分享
07-22
开始时棋盘内随机出现两个数字，出现的数字仅可能为2或4，玩家可以选择上下左右四个方向，若棋盘内的数字出现位移或合并，视为有效移动，玩家选择的方向上若有相同的数字则合并，每次有效移动可以同时合并，但不可以连续合并，合并所得的所有新生成数字想加即为该步的有效得分，玩家选择的方向行或列前方有空格则出现位移，每有效移动一步，棋盘的空位(无数字处)随机出现一个数字(依然可能为2或4)，棋盘被数字填满，无法进行有效移动，判负，游戏结束。 该游戏分为基础模式和疯狂模式，玩家若想进入疯狂模式，则需要在基础模式中使得卡片上的分数达到2048或者更多。疯狂模式将会给你全新的体验（可以改变游戏背景音乐和格子数，还有随机出现数），还在等什么，赶快行动起来吧！
2048核心代码
tyb333333的博客
11-05 393
2048核心代码
C# 实现2048核心算法（附思路）
热门推荐
张小艾博客
10-09 1万+
Note：想了半天开场白，发现真的不知道说啥，得，直接给您阐述思路吧。 首先最基础的，2048只有四种操作手法，就是上下左右的移动(手机上就为划屏)。但是有过一定编程基础的你肯定能想到，很明显要用一个类似方法来实现这四种操作，而不是四种完全不同的方法。所以我们完全可以先实现一种操作，进而类比到其他操作就能很快的实现这个过程。 玩家选定一个移动方向之后，我们希望看到的是相同相邻的数据相加，且所...
Python_2048核心算法
Rookie_Max的博客
01-19 4637
2048 核心算法 核心：去零操作,相邻相同则合并, 向左移动：从左向右依次取出每行数据 向右移动：从右向左依次取出每行数据 向上移动：方阵转置后向左移动再转置 向下移动：方阵转置后向右移动再转置 list_merge = [2,0,2,0] 将0元素移动到列的末尾 def zero_to_end(): """ 把list_merge中的0元素移动到末尾，其他元素相对...
算法#2048核心算法
dd00bb的博客
12-12 891
2048核心算法 需求分析 2 2 2 2 0 4 0 2 2 8 4 0 4 4 4 2 上移操作 由上到下获取第一列数据(一维数组) 。-》 2024 将0移动到末尾。-》 2240 相邻，相等的元素进行合并。将后面元素累加到前面元素上，然后将后面元素清0。-》 4040 将0移动到末尾。-》 4400 将处理后的数据还原到指定的列或行。 下移操作 由下到上获取第一列数据(一维数组) 。-》 4202 将0移动到末尾。-》 4220 相邻，相等的元素进行合并。
2048游戏核心实现
weixin_40947140的博客
08-26 1854
核心功能实现： 代码1（https://blog.csdn.net/hebtu666/article/details/81663648） def left():#向左 for i in range(4):#遍历每一行 for j in range(3):#遍历每一行的每个元素 for k in range(j+1,4):#遍历j右边的元素 ...
Android平台的2048游戏MyGame2048介绍
标题中提到的"MyGame2048.zip"意味着这是一个被压缩打包的游戏文件。通常，"zip"是文件压缩的一种格式，它能够将多个文件和文件夹打包成一个单一的压缩包，以减少文件大小，便于传输。而文件名"MyGame2048"暗示了这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值