2. 程式人生 > >java實現2048小遊戲

java實現2048小遊戲

阿新 • • 發佈：2019-01-16

學習Java基礎有一段時間了，一直想做個小的桌面程式練下手，最近自己有點時間用Java寫了一個2048的桌面程式，和大家分享一下！！！

遊戲效果展示：


1、設計思想

AppFrame.java遊戲的啟動類，只調用了一個MainFrame的構造方法

MainFrame.java遊戲的介面類，在構造方法中做了所有的初始化操作

MyKeyListener遊戲的控制類，繼承自Java中的KeyListener，實現上下左右移動的控制。

程式中的元件除了newGame按鈕之外基本都是JLable元件，空塊就是上面黃色沒有數字的塊，空快、2、4、8、16……都是通過修改JLabel的背景圖片來實現的。遊戲實現整體基本沒有太大的難度，重要的邏輯在程式碼中也有相應的解釋說明。

2、在eclipse中建立如下所示的檔案和目錄結構


由於時間有限，沒有截到512以後的圖片，但是遊戲是編寫完成的，有興趣的可以自己完善下，把512以後的圖片進行截圖按照上面的命名方式存到numberimage資料夾下即可。已有的圖片我也會同時上傳上去，方便大家自己練習。

3、三個類的原始碼及程式碼的解釋

主程式啟動類AppFrame.java，只有一個MainFrame的構造方法

package cn.tzfe.app;

import cn.tzfe.view.MainFrame;

public class AppFrame
{
	public static void main(String[] args)
	{
		MainFrame mainFrame = new MainFrame();
		mainFrame.setVisible(true);
	}
}
程式類MainFrame.java，包括初始化UI、資料、監聽等 
package cn.tzfe.view;

import java.awt.Cursor;
import java.awt.Desktop;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.net.URI;
import java.util.Random;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;

import cn.tzfe.listener.MyKeyListener;

public class MainFrame extends JFrame
{
	//為了下面圖片和元件的方便使用，將資源基本都定義在一起
	private static ImageIcon mainFrameIcon;//遊戲視窗背景圖片
	private static ImageIcon logoIcon;	   //白色背景的2048圖片
	private static ImageIcon scoreIcon;	   //score圖片
	private static ImageIcon bestIcon;	   //best圖片
	private static ImageIcon newGameIcon;  //newGame按鈕圖片
	private static ImageIcon emptyIcon;	   //空塊（零塊）
	private static ImageIcon twoIcon;      //2塊
	private static ImageIcon fourIcon;	   //4塊
	
	private JLabel logo_Label;				//2048Lable
	private JLabel contact_Label;			//HOW TO PLAY Label
	private JLabel score_Label;				//scoreLabel
	private static JLabel scoreText_Label;	//scoreTextLabel
	private JLabel best_Label;				//bestLabel
	private static JLabel bestText_Label;	//bestTextLabel
	private JButton newgameBtn;				//newGame按鈕
	private JLabel back_Label;				//主窗體背景元件
	private static int[][] block_Data = new int[4][4];	//一個二維int陣列資料域
	private static JLabel[][] block_Lable = new JLabel[4][4];	//一個二維元件塊域和上面陣列對應，各個數字塊的移動與合併就是操作者兩個陣列共同的結果
	
	//定義一個靜態塊，將所需要初始化的圖片一次性初始化完畢，只初始化0、2、4塊的原因是最初只會出現這三種塊
	static
	{
		mainFrameIcon = new ImageIcon("mainframebg.png");
		logoIcon = new ImageIcon("logo.png");
		scoreIcon = new ImageIcon("score.png");
		bestIcon = new ImageIcon("best.png");
		newGameIcon = new ImageIcon("newgame.png");
		emptyIcon = new ImageIcon("numberimage/0.png");
		twoIcon = new ImageIcon("numberimage/2.png");
		fourIcon = new ImageIcon("numberimage/4.png");
		
	}
	//MainFrame的構造方法，在Swing中有這麼一個問題在窗體中放置圖片時，先放置的圖片在最上層，後放置的在下層。
	//所以要先初始化遊戲塊，最後初始化窗體的背景。
	public MainFrame()
	{
		//初始化窗體大小位置等（設定窗體佈局方式為自由佈局）
		initBasic();
		//初始化開始遊戲安按鈕，得分，最好成績等
		initNewGame();
		//初始化空塊
		initEmptyBlocks();
		//初始化兩個初始值（2或4）到block_Data陣列中，並設定block_Label中對應塊的影象
		initData();
		//初始化事件監聽
		initListener();
		//初始化窗體背景
		initFrameBackGround();
		setVisible(true);
	}
	private void initListener()
	{
		//HOW TO PLAY?元件增加監聽，設定為模擬超連結的那種方式
		contact_Label.addMouseListener(new MouseAdapter()
		{
			//滑鼠進入設定顏色為藍色並新增下劃線，和提示資訊
			public void mouseEntered(MouseEvent e)
			{
				contact_Label.setText("<html><font color='blue'><u>"+contact_Label.getText()+"</u></font></html>");
				contact_Label.setToolTipText("You will open the official website of 2048.");
			}
			//滑鼠移出設定為原來的文字，並將提示資訊設定為""
			public void mouseExited(MouseEvent e)
			{
				contact_Label.setText("HOW TO PLAY?");
				contact_Label.setToolTipText("");
			}
			//滑鼠單擊開啟2048的官網
			public void mouseClicked(MouseEvent e)
			{
				try
				{
					Desktop.getDesktop().browse(new URI("http://2048game.com/"));
				} catch (Exception ex)
				{
					ex.printStackTrace();
				}
			}
		});
		//newGame按鈕設定滑鼠放上去時變成手型樣式
		newgameBtn.setCursor(new Cursor(Cursor.HAND_CURSOR));
		//newGame按鈕繫結觸發事件，即開始依據新遊戲
		newgameBtn.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent e)
			{
				//清空block_Label,全部設定為空塊，並設定block_Data資料都為0
				reSetBlocks();
				//初始化兩個隨機數（2或4），並重新整理介面
				initData();
			}
		});
		//增加鍵盤事件，並將資料陣列傳入
		newgameBtn.addKeyListener(new MyKeyListener(block_Data));
	}
	
	//重置每個塊元素
	public static void reSetBlocks()
	{
		for(int i=0; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				block_Lable[i][j].setIcon(emptyIcon);
				block_Data[i][j] = 0;
			}
		}
	}

	//呼叫兩次生成隨機塊的方法
	public static void initData()
	{
		for(int n=0; n<2; n++)
		{
			createOneRandomNumber();
		}
	}

	//由於每次移動後，都要生成一個隨機塊，所以單獨定義一個方法來生成隨機塊，生成2或4的概率是4:1
	//將生成的數存放到block_Data中，並設定對應元件的圖片
	public static void createOneRandomNumber()
	{
		int i,j;
		Random random = new Random();
		i = random.nextInt(4);
		j = random.nextInt(4);
		while(true)
		{
			if(block_Data[i][j] == 0)
			{
				break;
			}
			else
			{
				i = random.nextInt(4);
				j = random.nextInt(4);
			}
		}
		block_Data[i][j] = random.nextDouble() > 0.2 ? 2 : 4;
		if(block_Data[i][j] == 2)
		{
			block_Lable[i][j].setIcon(twoIcon);
		}else
		{
			block_Lable[i][j].setIcon(fourIcon);
		}
	}
	//初始化16個0塊（空塊），30和166都是自己調試出的左邊距和上邊距，塊元素的寬和高都是90，塊之間的
	//間隔是10，所以平均出來每一個塊元素的位置都是加上95，這個自己在紙上畫圖很容易理解。
	//比較難理解的是，此時初始化塊的順序是按照列初始化的，所以如block_Data[0][3]就表示的是第0列，
	//第三行的那個元素，這個點必須要區分清楚，否則在判斷移動問題的邏輯就比較混亂了。
	private void initEmptyBlocks()
	{
		//設定16個空塊，設定每個塊的位置，將塊新增到主介面中
		for(int i=0; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				block_Lable[i][j] = new JLabel(emptyIcon);
				block_Lable[i][j].setBounds(30+i*95, 166+j*95, 90, 90);
				this.add(block_Lable[i][j]);
			}
		}
	}
	
	//初始化介面上部分元件，並新增到合適的位置，setBounds(x,y,width,height)方法用於設定元件
	//在窗體中的絕對位置和元件的大小。位置基本沒有什麼說的，這個基本都是靠自己調試出來的，不熟悉的話
	//除錯幾個元件就差不多掌握了，大小就基本上都設定為JLabel中圖片的大小即可。
	private void initNewGame()
	{
		logo_Label = new JLabel(logoIcon);
		logo_Label.setBounds(10, 25, 224, 84);
		this.add(logo_Label);
		contact_Label = new JLabel("HOW TO PLAY?");
		contact_Label.setBounds(10, 110, 224, 20);
		this.add(contact_Label);
		newgameBtn = new JButton(newGameIcon);
		newgameBtn.setBounds(280, 80, 142, 44);
		this.add(newgameBtn);
		score_Label = new JLabel(scoreIcon);
		best_Label = new JLabel(bestIcon);
		score_Label.setBounds(280, 25, 60, 24);
		best_Label.setBounds(360, 25, 60, 24);
		this.add(score_Label);
		this.add(best_Label);
		scoreText_Label = new JLabel("0");
		bestText_Label = new JLabel("0");
		scoreText_Label.setBounds(290, 55, 60, 24);
		bestText_Label.setBounds(370, 55, 60, 24);
		this.add(scoreText_Label);
		this.add(bestText_Label);
	}

	private void initFrameBackGround()
	{
		back_Label = new JLabel(mainFrameIcon);
		back_Label.setBounds(6, 6, 420, 556);
		this.add(back_Label);
	}

	private void initBasic()
	{
		this.setTitle("2048game");	//設定標題
		this.setSize(450, 614);		//設定窗體大小
		this.setLocation(700, 200);	//設定窗體顯示位置
		this.setLayout(null);		//設定窗體佈局方式為自由佈局方式（自由佈局就可以按照畫素位置去放置元件）
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);	//設定窗體x為預設關閉視窗
	}
//根據資料陣列來重新整理遊戲介面，使視覺效果和真實資料是一致的，reFreshScore是在每次移動後重新整理當前得分
	public static void upDateUI(int[][] block_Data)
	{
		for(int i=0; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				block_Lable[i][j].setIcon(new ImageIcon("numberimage/"+block_Data[i][j]+".png"));
			}
		}
	}
	public static void reFreshScore()
	{
		int max = block_Data[0][0];
		for(int i=0; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				if(block_Data[i][j] > max)
				{
					max = block_Data[i][j];
				}
			}
		}
		scoreText_Label.setText(max+"");
	}

	
}

MyKeyListener實現遊戲的邏輯控制

package cn.tzfe.listener;

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JOptionPane;
import cn.tzfe.view.MainFrame;

//繼承Java中的KeyListener介面，實現裡面的抽象方法，主要是鍵被釋放時處理遊戲邏輯
public class MyKeyListener implements KeyListener
{
	//定義一個二維陣列用於接收從MainFrame傳入的陣列
	private int[][] block_Data;
	public MyKeyListener(int[][] block_Data)
	{
		this.block_Data = block_Data;
	}
	public void keyTyped(KeyEvent e)
	{
	}
	public void keyPressed(KeyEvent e)
	{
	}
	//有鍵被按下時的呼叫邏輯
	public void keyReleased(KeyEvent e)
	{
		//獲取到鍵盤按鍵的code值（左上右下分別對應37、38、39、40）
		int keyCode = e.getKeyCode();
		if(keyCode >=37 && keyCode<=40)
		{
			//分別從四個方向處理4個按鍵時的邏輯，以下以向左移動為例來解釋
			//若按下的是左鍵，並且當前介面能夠向左移動，執行向左移動的方法
			if(keyCode == 37 && canMoveLeft())
			{
				//真正向左移動的方法
				MoveLeft();
				MainFrame.createOneRandomNumber();
			}
			else if(keyCode == 39 && canMoveRight())
			{
				MoveRight();
				MainFrame.createOneRandomNumber();
			}
			else if(keyCode == 38 && canMoveUp())
			{
				MoveUp();
				MainFrame.createOneRandomNumber();
			}
			else if(keyCode == 40 && canMoveDown())
			{
				MoveDown();
				MainFrame.createOneRandomNumber();
			}
			//重新整理介面和當前得分和判斷遊戲是否結束
			MainFrame.upDateUI(block_Data);
			MainFrame.reFreshScore();
			isGameOver();
		}
	}
	private void isGameOver()
	{
		//勝利
		for(int i=0; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				if(block_Data[i][j] == 256)
				{
					int result = JOptionPane.showConfirmDialog(null, "恭喜您，遊戲勝利，再來一局？", "遊戲結果",JOptionPane.YES_NO_OPTION);
					if(result == 0)
					{
						MainFrame.reSetBlocks();
						MainFrame.initData();
					}
					else
					{
						System.exit(0);
					}
					return;
				}
			}
		}
		//失敗
		if(block_DataIsFull() && !canMove())
		{
			int result = JOptionPane.showConfirmDialog(null, "很遺憾您輸了,再來一局？", "遊戲結果", JOptionPane.YES_NO_OPTION);
			if(result == 0)
			{
				MainFrame.reSetBlocks();
				MainFrame.initData();
			}
			else
			{
				System.exit(0);
			}
			return;
		}
	}
	private boolean block_DataIsFull()
	{
		for(int i=0; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				if(block_Data[i][j] == 0)
				{
					return false;
				}
			}
		}
		return true;
	}
	private boolean canMove()
	{
		return canMoveLeft() || canMoveUp() || canMoveUp() || canMoveDown();
	}
	private void MoveDown()
	{
		for(int i=0; i<4; i++)
		{
			for(int j=2; j>=0; j--)
			{
				if(isNeedMoveDown(i, j))
				{
					int k;
					for(k=j+1; k<4;)
					{
						if(block_Data[i][k] == 0)
						{
							k++;
							continue;
						}
						if(block_Data[i][k] == block_Data[i][j])
						{
							block_Data[i][k] = 2 * block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
						else
						{
							block_Data[i][k-1] = block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
					}
					if(k==4)
					{
						block_Data[i][k-1] = block_Data[i][j];
						block_Data[i][j] = 0;
					}
				}
			}
		}
	}
	private void MoveUp()
	{
		for(int i=0; i<4; i++)
		{
			for(int j=1; j<4; j++)
			{
				if(isNeedMoveUp(i,j))
				{
					int k;
					for(k=j-1; k>=0;)
					{
						if(block_Data[i][k] == 0)
						{
							k--;
							continue;
						}
						if(block_Data[i][k] == block_Data[i][j])
						{
							block_Data[i][k] = 2 * block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
						else
						{
							block_Data[i][k+1] = block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
					}
					if(k<0)
					{
						block_Data[i][k+1] = block_Data[i][j];
						block_Data[i][j] = 0;
					}
				}
			}
		}
	}
	private void MoveRight()
	{
		for(int j=0; j<4; j++)
		{
			for(int i=2; i>=0; i--)
			{
				if(isNeedMoveRight(i,j))
				{
					int k;
					for(k=i+1; k<4;)
					{
						if(block_Data[k][j] == 0)
						{
							k++;
							continue;
						}
						if(block_Data[k][j] == block_Data[i][j])
						{
							block_Data[k][j] = 2 * block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
						else
						{
							block_Data[k-1][j] = block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
					}
					if(k == 4)
					{
						block_Data[k-1][j] = block_Data[i][j];
						block_Data[i][j] = 0;
					}
				}
			}
		}
		
	}
	//真正向左移動的方法。處理思想是遍歷除了最左邊一列的所有塊，判斷該塊是否需要移動，若需要則移動
	//若不需要，則繼續遍歷下一個元素塊
	private void MoveLeft()
	{
		for(int j=0; j<4; j++)
		{
			for(int i=1; i<4; i++)
			{
				//先判斷當前block_Data[i][j]是否需要移動,需要拿另一個變數k用來查詢當前塊需要
				//移動到的最終位置
				if(isNeedMoveLeft(i,j))
				{
					int k;
					for(k=i-1; k>=0;)
					{
						//向左查詢，若為0則繼續查詢
						if(block_Data[k][j] == 0)
						{
							k--;
							continue;
						}
						//在左邊找到相同的合併
						if(block_Data[k][j] == block_Data[i][j])
						{
							block_Data[k][j] = 2 * block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
						//沒有找到相同的移動到相對較左的位置
						else
						{
							block_Data[k+1][j] = block_Data[i][j];
							block_Data[i][j] = 0;
							break;
						}
					}
					//在左側方向沒有找到相同的，並且已經找到最左邊，則移動當前塊到最左邊的位置
					if(k<0)
					{
						block_Data[k+1][j] = block_Data[i][j];
						block_Data[i][j] = 0;
					}
				}
			}
		}
	}
	
	private boolean isNeedMoveRight(int i, int j)
	{
		if(block_Data[i][j]!=0&&(block_Data[i+1][j]==0||block_Data[i][j]==block_Data[i+1][j]))
		{
			return true;
		}
		return false;
	}
	private boolean isNeedMoveLeft(int i, int j)
	{
		if(block_Data[i][j]!=0&&(block_Data[i-1][j]==0||block_Data[i][j]==block_Data[i-1][j]))
		{
			return true;
		}
		return false;
	}
	private boolean isNeedMoveUp(int i, int j)
	{
		if(block_Data[i][j]!=0&&(block_Data[i][j-1]==0||block_Data[i][j]==block_Data[i][j-1]))
		{
			return true;
		}
		return false;
	}
	private boolean isNeedMoveDown(int i, int j)
	{
		if(block_Data[i][j]!=0&&(block_Data[i][j+1]==0||block_Data[i][j]==block_Data[i][j+1]))
		{
			return true;
		}
		return false;
	}
	//判斷整個介面是否能夠向左移動
	private boolean canMoveLeft()
	{
		//判斷邏輯：遍歷當前介面的塊元素，如果當前塊不是0 &&（當前塊的左邊塊是0或當前塊的左邊塊和當前塊相同，則返回true）
		for(int i=1; i<4; i++)
		{
			for(int j=0; j<4; j++)
			{
				if(block_Data[i][j]!=0&&(block_Data[i-1][j]==0||block_Data[i][j]==block_Data[i-1][j]))
				{
					return true;
				}
			}
		}
		return false;
	}
	//判斷整個介面是否能夠向右移動
	private boolean canMoveRight()
	{
		for(int i=2; i>=0; i--)
		{
			for(int j=0; j<4; j++)
			{
				if(block_Data[i][j]!=0&&(block_Data[i+1][j]==0||block_Data[i][j]==block_Data[i+1][j]))
				{
					return true;
				}
			}
		}
		return false;
	}
	//判斷整個介面能否向上移動
	public boolean canMoveUp()
	{
		for(int j=1; j<4; j++)
		{
			for(int i=0; i<4; i++)
			{
				if(block_Data[i][j]!=0&&(block_Data[i][j-1]==0||block_Data[i][j]==block_Data[i][j-1]))
				{
					return true;
				}
			}
		}
		return false;
	}
	//判斷整個介面能否向下移動
		public boolean canMoveDown()
		{
			for(int j=2; j>=0; j--)
			{
				for(int i=0; i<4; i++)
				{
					if(block_Data[i][j]!=0&&(block_Data[i][j+1]==0||block_Data[i][j]==block_Data[i][j+1]))
					{
						return true;
					}
				}
			}
			return false;
		}
}

部落格圖片資源不好上傳，若需要專案圖片資源，請直接加博主QQ2819160952，博主會第一時間給大家分享的。

相關推薦

java實現2048小遊戲

學習Java基礎有一段時間了，一直想做個小的桌面程式練下手，最近自己有點時間用Java寫了一個2048的桌面程式，和大家分享一下！！！ 遊戲效果展示： 1、設計思想 AppFrame.java遊戲的啟動類，只調用了一個MainFrame的構造方法 MainFrame.ja

C語言介面實現2048小遊戲

這是我在大一第二學期（兩年前）為了參加比賽，自學後寫的一個Dome，拿出來和大家分享一下，程式碼為兩年前的程式碼，未改動，優化以及各式可能很一般，請見諒。 #include "stdio.h" #include "stdlib.h" #include "time.h" #d

JQuery初體驗-JavaScript實現2048小遊戲PC端

目錄 效果圖 遊戲頁面 遊戲頁面樣式 遊戲基礎邏輯 遊戲動畫邏輯 遊戲主邏輯 遊戲互動邏輯 效果圖： 遊戲頁面： <!DOCTYPE html> <html lang="en"> <head> <

C++實現2048小遊戲（控制檯版的）

無聊，在公司寫了個2048小遊戲的程式，聊以自娛。（事實是我手機壞了，沒得玩）。 很簡單，直接上程式碼了。 #include <iostream> #include <windows.h> #include <ctime> using

js實現2048小遊戲

最近同學參加宣講會，說有個公司要求是寫一個2048小遊戲，參考了一點網上的程式碼以後，自己寫了一個。 寫的思路如下： 1.設定好HTML佈局。大盒子巢狀小盒子，這塊沒什麼可說的。 2.實現遊戲初始化，生成一開始的兩個小塊。這裡就要實現生成隨機2或4，還

C語言在linux終端下實現2048小遊戲：第二版

原來我轉載過一個機遇ncurses的2048，今天無聊自己手寫了一個，看下我的目錄結構： $ tree ../2048/ ../2048/ ├── 2048.c ├── 2048.h └── main.c 0 directories, 3 files 2048.h

學Android--實現2048小遊戲

1、遊戲佈局(activity_main.xml) 首先在xml檔案中實現遊戲的整體佈局 (1)新增兩個TextView用來顯示分數 <LinearLayout android:layout_width="match_pare

C#實現2048小遊戲

要實現這個簡單的小遊戲主要在於實現一個方向移動 數字的移動及合併該如何處理 然後其它方向的邏輯是相同的 我做的這個基本功能實現了 主要分為三個類 Box.cs格子類（一些格子裡儲存的資料，行下標，列下標，是否合併過的開關。。） Grid.cs網格類（主要演算法在裡

C++實現2048小遊戲

程式碼如下： #define _CRT_SECURE_NO_WARNINGS//去掉編譯器內部擴增問題#include<stdio.h>#include<stdlib.h>#include<math.h>#include<graphics.h>//需要下載圖形庫

2048小遊戲主要算法實現

mes 方向 時間限制 上下左右 print ron weight color ges http://acm.tzc.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=4681 4681: 2

C語言實現簡易2048小遊戲

blog 而在 而是 null 移動 是我 我們 空指針 主體 一直很喜歡玩這個小遊戲，簡單的遊戲中包含運氣與思考與策略，喜歡這種簡約又不失內涵的遊戲風格。於是萌生了用C語言實現一下的想法。 具體代碼是模仿這個：https://www.cnblogs.com/judgeyo

用C++、Qt實現的小遊戲2048

圖片 explicit AC 向上 類的構造函數 += cli 而後 遊戲 窗口布局與遊戲截圖： 實現思路： 1.使用二維數組模擬整個遊戲網格，並將二維數組中每個數的大小用作遊戲中每個網格中的數據。 2.將對遊戲的數據及數據的操作（即玩家的操

【java】JavaFX從零開始實現拼圖小遊戲

最近java課老師佈置了一個作業：製作一個拼圖小遊戲，關鍵老師自己說javaGUI程式設計沒用，講課的時候好像跳過了（沒去上課不過我猜應該沒講吧），現在又叫我們做這些，實在是哭笑不得。 得了吧，老師的任務只能老老實實完成對吧，但是我又想到像Swing這些工具包已經基本上被淘汰了，做出來的頁面有點

C語言實現最簡單的2048小遊戲

網上解釋很多了，直接上程式碼吧，這個功能很簡單，易於學習，後期有時間會完善功能 #include<stdio.h> #include<stdlib.h> #include<string.h> #define Key_Up 0x4800

[原始碼和文件分享]基於Python的PyGame庫實現的2048小遊戲

一、簡介 2048的遊戲規則很簡單，每次可以選擇上下左右其中一個方向去滑動，每滑動一次，所有的數字方塊都會往滑動的方向靠攏外，系統也會在空白的地方亂數出現一個數字方塊，相同數字的方塊在靠攏、相撞時會相加。系統給予的數字方塊不是2就是4，玩家要想辦法在這小小的16格範圍中湊出“2048”這個數字方

lua實現一個2048小遊戲

用lua寫了個在consle上執行的2048，這裡簡單說下是如何實現的。（原始碼地址：http://download.csdn.net/detail/c_boy_lu/9393255） 1.實現一

用java做一個2048小遊戲

昨天，自己突發奇想，能不能在忙碌的學習裡抽一點時間來做一點事情，然後，我就有了一個要做一個2048小遊戲的想法。說真的，java我已經認真學習了一段時間了，現在也剛剛學到Swing，雖然做這個2048還有很多東西沒有學習過，但是，一邊學一邊做才是我們菜鳥的樣子吧。 做這個東

C語言實現的2048小遊戲

給大一新生寫的一個小遊戲。 缺點：函式名稱和功能略微不對應，函式功能寫得比較亂，時間記錄有誤差，可擴充套件性弱。 優點：通過幾個配置陣列，將單位方塊移動的函式縮短到30行以內。 #include <stdio.h> #include <windows.h&

Java 2048 小遊戲 原始碼

import java.awt.Color; import java.awt.EventQueue; //import java.awt.BorderLayout; //import java.awt.FlowLayout; import java.awt.Font; i

2048小遊戲Python3.6.5實現

這個2048遊戲是我自學python以後寫的， 用了幾天時間。 其中的某些方法可能寫的很笨， 也可能還存在各種BUG， 歡迎各位評論指出。 下面貼出完整程式碼供大家學習交流。 import random #遊戲分數 gameScore = 0 #遊戲矩陣 matrix