手机java游戏怎么看源代码_谁能给我一个手机游戏的源代码啊

最新推荐文章于 2024-02-20 21:33:16 发布
最新推荐文章于 2024-02-20 21:33:16 发布
阅读量1.3k 收藏
点赞数
文章标签： 手机java游戏怎么看源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34545862/article/details/114609383
版权

展开全部

这个地址也有，不过直接给你吧，这样比较好

先给你看看主要的类吧

package Game;

import DreamBubbleMidlet;

import java.io.IOException;

import java.util.Enumeration;

import java.util.Hashtable;

import javax.microedition.lcdui.Graphics;

import javax.microedition.lcdui.Image;

import javax.microedition.lcdui.game.GameCanvas;

import javax.microedition.lcdui.game.LayerManager;

import javax.microedition.lcdui.game.Sprite;

public class Game extends GameCanvas implements Runnable {

protected DreamBubbleMidlet dreamBubbleMidlet;

protected Graphics g;

protected Image loadingImage;

protected Image pauseImage;

protected Image cursorImage;

protected Image jackStateImage;

protected Image johnStateImage;

protected Image numberImage;

protected Sprite cursor;

protected Sprite number;

protected LayerManager cursorManager;

protected LayerManager numberManager;

protected Hashtable bombTable;

protected Map map;

protected LayerManager gameLayerManager;

protected Role player;

protected Sprite playerGhost;

protected int screenWidth;

protected int screenHeight;

protected int delay = 50;

protected int[][] bornPlace;

protected int chooseIndex;

protected int stageIndex = 1;

protected int gameClock;

protected int loadPercent;

protected boolean isPause;

protected boolean isEnd;

protected boolean isPlaying;

protected boolean isLoading;

protected Thread mainThread;

public Game(DreamBubbleMidlet dreamBubbleMidlet) {

super(false);

this.setFullScreenMode(true);

this.dreamBubbleMidlet = dreamBubbleMidlet;

this.screenWidth = this.getWidth();

this.screenHeight = this.getHeight();

try {

this.loadingImage = Image.createImage("/Game/Loading.png");

this.pauseImage = Image.createImage("/Game/Pause.png");

this.cursorImage = Image.createImage("/Game/Cursor.png");

this.jackStateImage = Image.createImage("/State/JackState.png");

this.johnStateImage = Image.createImage("/State/JohnState.png");

this.numberImage = Image.createImage("/State/Number.png");

} catch (IOException e) {

e.printStackTrace();

}

this.g = this.getGraphics();

}

public void loadStage(int stage) {

this.isEnd = false;

this.isPause = false;

this.isPlaying = false;

this.gameLayerManager = new LayerManager();

this.cursorManager = new LayerManager();

this.numberManager = new LayerManager();

this.bombTable = new Hashtable();

this.cursor = new Sprite(this.cursorImage, 32, 32);

this.number = new Sprite(this.numberImage, 12, 10);

this.loadPercent = 20;

sleep();

loadMap(stage);

this.loadPercent = 40;

sleep();

loadPlayer();

this.loadPercent = 60;

sleep();

this.gameLayerManager.append(map.getBombLayer());

this.gameLayerManager.append(map.getBuildLayer());

this.gameLayerManager.append(map.getToolLayer());

this.gameLayerManager.append(map.getFloorLayer());

this.gameLayerManager.setViewWindow(0, -5, screenWidth,

Global.MAP_HEIGHT + 5);

this.cursorManager.append(cursor);

this.numberManager.append(number);

this.loadPercent = 80;

sleep();

this.loadPercent = 100;

sleep();

isPlaying = true;

}

public void run() {

while (!e69da5e887aa3231313335323631343130323136353331333239303766isEnd) {

long beginTime = System.currentTimeMillis();

this.drawScreen();

long endTime = System.currentTimeMillis();

if (endTime - beginTime < this.delay) {

try {

Thread.sleep(this.delay - (endTime - beginTime));

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public void loadMap(int stage) {

switch (stage) {

case 0:

this.map = new Map(Global.MAP_BLOCK);

this.bornPlace = Global.MAP_BLOCK_BORNPLACE;

break;

case 1:

this.map = new Map(Global.MAP_FACTORY);

this.bornPlace = Global.MAP_FACTORY_BORNPLACE;

break;

case 2:

this.map = new Map(Global.MAP_FOREST);

this.bornPlace = Global.MAP_FOREST_BORNPLACE;

break;

case 3:

this.map = new Map(Global.MAP_PIRATE);

this.bornPlace = Global.MAP_PIRATE_BORNPLACE;

break;

case 4:

this.map = new Map(Global.MAP_FAUBOURG);

this.bornPlace = Global.MAP_FAUBOURG_BORNPLACE;

break;

}

}

public void loadPlayer() {

this.player = SingleGameRole.createSingleGameRole(this, Global.JACK,

this.bornPlace[0][0], this.bornPlace[0][1]);

this.gameLayerManager.append(player);

try {

this.playerGhost = new Sprite(Image.createImage("/Character/Jack.png"),

this.player.width, this.player.height);

this.gameLayerManager.append(playerGhost);

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public void playerUpdate() {

if(!this.player.isAlive)

this.playerGhost.setVisible(false);

this.playerGhost.setFrame(this.player.getFrame());

this.player.updateRole();

}

public void bombUpdate() {

Enumeration enu = this.bombTable.keys();

while (enu.hasMoreElements()) {

String key = (String) enu.nextElement();

Bomb bomb = (Bomb) (bombTable.get(key));

if (bomb.isvisable) {

bomb.update();

} else {

bombTable.remove(key);

bomb = null;

}

}

}

public void mapUpdate() {

this.map.update();

}

public void drawScreen() {

if (gameClock < 10000)

gameClock++;

else

gameClock = 0;

if (!this.isLoading) {

if (!isPause) {

this.operate();

this.bombUpdate();

this.playerUpdate();

this.mapUpdate();

g.setColor(0x000000);

g.fillRect(0, 0, getWidth(), getHeight());

this.drawState();

gameLayerManager.paint(g, 0, this.screenHeight

- Global.MAP_HEIGHT - 5);

} else {

this.drawPauseFrame();

}

} else {

this.drawLoadingFrame();

}

this.flushGraphics();

}

public void drawFailScreen() {

}

public void drawState() {

if (this.player.type == Global.JACK) {

g.drawImage(jackStateImage, 60, 5, Graphics.TOP | Graphics.LEFT);

}

if (this.player.type == Global.JOHN) {

g.drawImage(johnStateImage, 60, 5, Graphics.TOP | Graphics.LEFT);

}

this.number.setFrame(this.player.bombNums);

this.numberManager.paint(g, 101, 15);

this.number.setFrame(this.player.speed);

this.numberManager.paint(g, 133, 15);

this.number.setFrame(this.player.power);

this.numberManager.paint(g, 165, 15);

}

protected void drawPauseFrame() {

g.setColor(0x000000);

g.fillRect(0, 0, getWidth(), getHeight());

this.drawState();

if (gameClock % 5 == 0)

this.cursor.setFrame((this.cursor.getFrame() + 1) % 4);

this.gameLayerManager.paint(g, 0, this.screenHeight - Global.MAP_HEIGHT

- 5);

this.cursorManager.paint(g, screenWidth / 2 - pauseImage.getWidth() / 2

- 32, screenHeight / 2 - pauseImage.getHeight() / 2

+ this.chooseIndex * 33 + 24);

g.drawImage(pauseImage, screenWidth / 2, screenHeight / 2,

Graphics.HCENTER | Graphics.VCENTER);

}

protected void drawLoadingFrame() {

g.setColor(66, 70, 246);

g.fillRect(0, 0, screenWidth, screenHeight);

g.drawImage(loadingImage, screenWidth / 2, 2 * screenHeight / 5,

Graphics.HCENTER | Graphics.VCENTER);

g.setColor(0, 255, 0);

g.fillRect((screenWidth - 120) / 2, 2 * screenHeight / 3,

(this.loadPercent * 120) / 100, 10);

g.setColor(255, 0, 0);

g.drawRect((screenWidth - 120) / 2, 2 * screenHeight / 3, 120, 10);

}

public void showMe() {

new Loading(this.stageIndex);

if (this.mainThread == null) {

mainThread = new Thread(this);

mainThread.start();

}

this.dreamBubbleMidlet.show(this);

}

public void operate() {

int keyStates = getKeyStates();

this.playerGhost.setPosition(this.player.xCoodinate, this.player.yCoodinate);

if ((keyStates & DOWN_PRESSED) != 0) {

this.player.walk(Global.SOUTH);

} else {

if ((keyStates & UP_PRESSED) != 0) {

this.player.walk(Global.NORTH);

} else {

if ((keyStates & RIGHT_PRESSED) != 0) {

this.player.walk(Global.EAST);

} else {

if ((keyStates & LEFT_PRESSED) != 0) {

this.player.walk(Global.WEST);

}

}

}

}

}

protected void keyPressed(int key) {

if (!this.isPlaying)

return;

if (!this.isPause && key == -7) {// 右键

this.chooseIndex = 0;

this.pauseGame();

return;

}

if (key == 35) {// #键

this.nextStage();

return;

}

if (key == 42) {// *键

this.preStage();

return;

}

if (this.isPause) {

switch (key) {

case -1:

case -3:

if (this.chooseIndex == 0)

this.chooseIndex = 2;

else

this.chooseIndex = (this.chooseIndex - 1) % 3;

break;

case -2:

case -4:

this.chooseIndex = (this.chooseIndex + 1) % 3;

break;

case -5:// 确认键

case -6:// 左软键

switch (chooseIndex) {

case 0:

this.continueGame();

break;

case 1:

this.restart();

break;

case 2:

this.endGame();

break;

}

break;

default:

break;

}

} else {

switch (key) {

case 53:

case -5:// 确认键

this.player.setBomb(this.player.getRow(), this.player.getCol());

break;

}

}

}

public void restart() {

new Loading(this.stageIndex);

}

public void continueGame() {

this.isPause = false;

this.player.play();

}

public void pauseGame() {

this.isPause = true;

this.player.stop();

}

public void endGame() {

this.isEnd = true;

this.mainThread = null;

System.gc();

try {

Thread.sleep(500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

this.dreamBubbleMidlet.menu.showMe();

}

public void nextStage() {

if (this.stageIndex < 4) {

this.stageIndex++;

}

new Loading(this.stageIndex);

}

public void preStage() {

if (this.stageIndex > 0) {

this.stageIndex--;

}

new Loading(this.stageIndex);

}

class Loading implements Runnable {

private Thread innerThread;

private int stageIndex;

public Loading(int stageIndex) {

this.stageIndex = stageIndex;

innerThread = new Thread(this);

innerThread.start();

}

public void run() {

isLoading = true;

loadPercent = 0;

System.gc();

loadStage(stageIndex);

isLoading = false;

}

}

public void sleep() {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

这个是游戏主体类

下面是游戏的人物类

package Game;

import javax.microedition.lcdui.Image;

import javax.microedition.lcdui.game.Sprite;

public abstract class Role extends Sprite {

/**

* 人物的基本属性

*/

protected int type;

protected int xCoodinate;

protected int yCoodinate;

protected int row;

protected int col;

protected int width;

protected int height;

protected int speed;

protected int status;

protected boolean isCanOperate = false;

protected boolean isAlive = true;

/**

* 人物放置炸弹的基本属性

*/

protected int power;

protected int bombNums;

protected int characterClock = 0;

protected int deadTime = 0;

protected Game game;

protected Role(Image image, int width, int Height, Game game) {

super(image, width, Height);

this.game = game;

}

/**

* 人物拾起道具

* @param tool

*/

public abstract void pickupTool(int tool);

/**

* 碰撞检测以及坐标的改变,如果对行走条件有特殊需求，既可以在这里写自己的条件

* @param direction

*/

public abstract void collisionCheck(int direction);

public void updateRole() {

if (this.characterClock < 10000) {

this.characterClock++;

} else {

this.characterClock = 100;

}

int row = this.getRow();

int col = this.getCol();

if (this.isAlive) {

int tool = this.game.map.getToolLayer().getCell(col, row);

if (tool > 0) {

this.pickupTool(tool);

this.game.map.getToolLayer().setCell(col, row, 0);

}

if (this.game.map.hasFeature(row, col, Global.DEADLY)) {

this.isAlive = false;

return;

}

if (this.status == Global.BORN

&& this.characterClock > Global.BORN_TIME) {

this.status = Global.SOUTH;

this.setFrame(Global.SOUTH * 6);

this.isCanOperate = true;

}

if (this.status == Global.BORN) {

if (this.characterClock % 2 == 0)

this.setFrame(Global.BORN * 6 + (this.getFrame() - 1) % 4);

return;

}

} else {

this.isCanOperate = false;

if (this.deadTime <= 20) {

this.deadTime++;

} else {

this.deadTime = 100;

this.setVisible(false);

return;

}

if (this.characterClock % 2 == 0) {

if (this.getFrame() < Global.DEAD * 6) {

this.setFrame(Global.DEAD * 6);

} else {

if (this.getFrame() < 29) {

this.setFrame(this.getFrame() + 1);

} else {

if (this.characterClock % 4 == 0) {

this.setFrame(29);

this.setVisible(true);

} else {

this.setVisible(false);

}

}

}

}

}

}

public void walk(int direction) {

if (!isAlive)

return;

if (!isCanOperate)

return;

if(direction==9) return;

this.collisionCheck(direction);

if (this.characterClock % 2 == 0) {

if (this.status == direction) {

this.setFrame(this.status * 6 + (this.getFrame() + 1) % 6);

} else {

this.status = direction;

this.setFrame(this.status * 6);

}

}

this.setPosition(xCoodinate, yCoodinate);

}

public void stop() {

this.isCanOperate = false;

}

public void play() {

this.isCanOperate = true;

}

public abstract void setBomb(int row, int col);

public void increaseBomb() {

if (this.bombNums < Global.MAX_BOMB_NUMBER)

this.bombNums++;

}

public int getRow() {

return getRow(getBottomY(yCoodinate) - Global.MAP_CELL / 2);

}

public int getCol() {

return getCol(xCoodinate + Global.MAP_CELL / 2);

}

protected int getBottomY(int y) {

return y + this.height - 1;

}

protected int getRightX(int x) {

return x + Global.MAP_CELL - 1;

}

protected int getPreY(int y) {

return getBottomY(y) + 1 - Global.MAP_CELL;

}

protected int getRow(int x) {

return x / Global.MAP_CELL;

}

protected int getCol(int y) {

return y / Global.MAP_CELL;

}

}

我的QQ是609419340

看不明白的可以随时来问我哦，还可以当时传给你撒

2Q==

已赞过

已踩过<

你对这个回答的评价是？

评论

收起

PayMillet
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
suku.rar_手机游戏_数独_数独 JAVA_数独源代码
09-14
java手机游戏数独源代码
Java进阶：如何反编译jar包获取源码
热门推荐
55555的博客
10-08 2万+
某些没有提供源码的历史遗留项目，或者第三方jar包，我们常常需要进行二开，但是又没有源码，这时就需要进行反编译获取到项目源码。当然也不是所有的jar都能反编译的，某些做了防编译处理的则不能，但对于我们历史遗留的项目进行反编译则是完全可行的今天我们就来看看如何进行反编译。
千款小游戏源码，直接打包微信小游戏、iOS、Android！赶紧收藏
最新发布
奎特尔星球
02-20 777
很多人还不知道 Cocos Store 资源商城，它是国内最大的小游戏资源平台。上面有大量免费游戏源码可以下载，比如下图的《赛博朋克》，项目中包含大量模型、贴图，还有游戏源代码，通过Cocos引擎可以直接在浏览器上玩。本文就带你从Cocos引擎的下载、安装、到游戏源码运行，Let's Go！！！01 下载 Cocos Dashboard打开浏览器，进入 Cocos Store 资源商城，找到比如 ...
Java提取游戏_[工具]JP游戏资源提取工具Crass和源代码
weixin_33458169的博客
02-26 1077
crass简介Crass是Crage和Assage两个工具的集合。Crage是使用cui插件扩展的游戏资源提取器；而Assage是使用aui插件扩展的游戏资源封装程序。只要使用cui或aui插件，就可以提取或封装插件所对应的封包文件。对于普通的使用者，可以使用CrageGUI，通过图形界面进行资源提取；crage也为高级用户提供了控制台程序；有关crage的更多使用说明参见INSTALL.txt；...
java游戏源码合集，已整理成文档
weixin_57992300的博客
07-11 2050
什么是 Arthas？ Arthas 是一款开源在线诊断工具，采用命令行交互模式，支持 web 端在线诊断，同时提供丰富的 Tab 自动补全功能，进一步方便进行问题的定位和诊断。这是一款开源一年多 GitHub star 2 万，99% 的阿里研发小哥都在用的 Java 终极诊断利器！相对比直接下载使用，我推荐开发者可以试一下通过 IDE插件 Cloud Toolkit 中使用Arthas 来实现一键远程诊断功能。 得益于 Arthas 强大且丰富的功能，让 Arthas 能做的事情超乎想象。下面仅仅列举几
wuziqi.rar_Java代码五子棋_j2me_java 手机 游戏 代码_手机游戏
09-24
一个J2ME的五子棋手机游戏源代码，大家共享~~~~~~~~
Java手机游戏大富翁源代码+注释
06-06
Java手机游戏大富翁源代码+注释
JAVA五子棋手机网络对战游戏的设计与实现(源代码+论文).zip
08-12
JAVA五子棋手机网络对战游戏的设计与实现(源代码+论文) 五子棋手机网络对战游戏的设计与实现 摘 要 在现代社会中,手机及其它无线设备越来越多的走进普通老百姓的工作和生活。 随着3G技术的普及与应用，基于Java开发...
Java手机游戏扫雷源代码
03-16
内容索引:JAVA源码,游戏娱乐,手机游戏,Java游戏,扫雷　这个游戏是西门子6688i手机上的，很早的一款游戏，全部源代码。源代码中包含一个简易的资源察看器，可以查看游戏中所使用的二进制图片。
最新45款Java手机游戏开发源代码免费下载
03-04
最新45款Java手机游戏开发源代码免费下载, 含超级玛丽，斗地主等经典游戏，适合新手入门学习！
手机游戏java代码
04-09
J2ME是java的手机版本。学好J2ME，搞手机开发，前途无量。
一款安卓手机游戏源码
05-08
安卓手机格斗游戏源码 朋友做的
Java 45款游戏源代码-45款Java手机游戏开发源代码
12-04
最新45款Java手机游戏开发源代码免费下载 Java 45款游戏源代码-45款Java手机游戏开发源代码
最新45款Java手机游戏开发源代码下载
06-11
最新45款Java手机游戏开发源代码
一个简单的游戏源代码
爪哇米工作室陈跃峰的移动开发博客
09-08 1万+
  一个简单的游戏源代码作者：陈跃峰出自：http://blog.csdn.net/mailbomb        实现一个简单的翻牌游戏，每次最多翻开两个数字，如果数字相同则消失，否则两个数字不显示，可以继续游戏。       游戏规则如下：       1、游戏数据使用两个一维数组存储：u       map存储逻辑数据u       displayMap存储绘
手机java游戏怎么看源代码_mainmenu.java
weixin_40002846的博客
02-25 778
import java.io.InputStream;import java.util.Random;import javax.microedition.io.Connector;import javax.microedition.io.file.FileConnection;import javax.microedition.lcdui.Canvas;import javax.microedit...
java手机游戏堡垒的设计与开发免费源代码+LW
bwwork的博客
08-30 841
初始情况下，游戏菜单有5个选项，它们分别是开始游戏、游戏说明和排行榜、设置、关于。选择开始新游戏则进入游戏，在游戏中如果按下非游戏键则中断游戏返回菜单，此时菜单中增加了一个继续游戏的选项，可以返回游戏也可以重新开始新的游戏。J2ME程序都是从MIDlet类开始执行，系统在执行MIDlet程序时，首先构造一个MIDlet类型的对象，然后使程序进入到暂停状态，按照生命周期的规定，系统会自动调用MIDlet对象的startApp方法使程序进入到运行状态，开始程序的执行。游戏中玩家通过不断的闯关，来解救公主。...
java赛车小游戏代码_java版赛车小游戏源代码
05-30
很抱歉，我并不能提供你Java赛车小游戏的源代码。但是，我可以给你一些指导，帮助你开始编写这个游戏。 首先，你需要确定游戏的基本规则和玩法。例如，玩家需要控制赛车避开障碍物，尽可能地前进，得到高分。还需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值