本篇文章给大家谈谈安卓小游戏源码网，以及app游戏源码对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、谁能给我一个手机游戏的源代码啊
• 2、游戏源码哪买的
• 3、哪里有APP、Android游戏开发及商业等源代码？
• 4、请问哪里有android SRPG(SLG)战棋类游戏源码下载?求高手解答，万分感谢！
• 5、开发手游的代码

谁能给我一个手机游戏的源代码啊

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

先给你看看主要的类吧

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 (!isEnd) {

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

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

游戏源码哪买的

百度、长游分享网。

游戏源码可以在百度、长游分享网购买。他们的源码都是经过人工审核上架的，价格实惠，如果没有你想要的源码，可以去他们的在线求助求，有人发如果能用就会上架的。

游戏源码是指可编译运行出游戏的代码。源代码：是代码的分支，某种意义上来说，源代码相当于代码。现代程序语言中，源代码可以书籍或磁带形式出现，但最为常用格式是文本文件，这种典型格式的目的是为了编译出计算机程序。

哪里有APP、Android游戏开发及商业等源代码？

github：各种源码都有。

国内其他网站的源码，大部分比较栏，但大部分都收费。游戏的源码你就别想了，烂的一点也没法用，只有app的源码，可以参考一些技术点的实现。

请问哪里有android SRPG(SLG)战棋类游戏源码下载?求高手解答，万分感谢！

搜素开源项目

google代码搜索

开源代码搜索

android现在是社交，小工具之类的开源多

开发手游的代码

4.1游戏的的思路、构想

4.1.1游戏想法的产生

相信大家一定都在8位机机上玩过《冒险岛》这款游戏，非常有趣味性。

游戏中玩家通过不断的闯关，来解救公主。在每个关都很很多的怪物阻挡着你，所以需要运用各种机关或者秘籍来杀死它们。杀死他们的同时还可以获得各种奖励，加生命，加血等，增加了游戏的趣味性。

如图2所示：

这款《冒险岛》游戏的实现相对于其他RPG或者网络版手机游戏稍简单一些，适合初学者作为练习，所以我决定编写一款类似的手机游戏。

由于之前对手机游戏的编程知识以及游戏的设计只有初步的了解，因此，我们在游戏的构架和思路上经历了几个阶段。

这款《冒险岛》游戏的实现相对于其他RPG或者网络版手机游戏稍简单一些，适合初学者作为练习，所以我决定编写一款类似的手机游戏。

由于之前对手机游戏的编程知识以及游戏的设计只有初步的了解，因此，我们在游戏的构架和思路上经历了几个阶段。

4.1.2对游戏设计的初步认识

刚开始我们只对J2ME有初步的了解。这时我们只是模仿之前在PC上看到的游戏，用语言把游戏的实现感性的描述为几大部分：

游戏界面系统：包括游戏开始界面；游戏开局界面；游戏运行界面；游戏结束界面。

游戏元素：菜单类；画布类；人物类；排行榜类。

4.1.3模块成型阶段

在进一步熟悉了J2ME知识后，对框架做出了一些修改，逐步把游戏的基本功能确定。游戏依次进入加载界面；主菜单；游戏运行界面；游戏结束界面。

具体实现的功能为：

1．主菜单，有如下选项：

（1）开始游戏——进入游戏界面。

（2）声音——设置声音的有无选项。

（3）帮助——介绍游戏的玩法。

（4）排行榜——玩家所得分数的排行榜。

（5）关于——用来显示说明信息以及背景图片。

2．游戏运行界面，包括：

游戏界面；目前游戏得分；游戏关数；生命次数；

3．游戏结束界面：游戏结束后，显示一行说明信息，然后退回到菜单。

游戏的主要模块为：

1．游戏主MIDlet（GameMIDlet）——对游戏生命周期的判断；对画布类的调用；管理游戏程序中各个屏幕之间的转换。

2．游戏画布（MyGame）——对游戏所用变量，常量的设定；游戏的初始化；游戏中精灵运动轨迹的控制；精灵与砖块的碰撞检测以及砖块状态的控制；游戏中各关卡的基本设定；游戏中对按键状态的处理。

3．菜单类——游戏中菜单事件的处理。

4．GameOgre类——游戏中怪物的类。

5．GamePlayer类——玩家控制的精灵类。

6．GameRMS类——用于实现分数排行榜。

7．PlayMusic类——用于实现音乐的播放。

8．MySet类——声音大小的设置。

4.2 程序的类结构

程序一共有8个主要类，其中菜单类负责各个屏幕的切换。程序的类结构如图3所示：

4.3 游戏的流程图

进入游戏菜单。初始情况下，游戏菜单有5个选项，它们分别是开始游戏、游戏说明和排行榜、设置、关于。选择开始新游戏则进入游戏，在游戏中如果按下非游戏键则中断游戏返回菜单，此时菜单中增加了一个继续游戏的选项，可以返回游戏也可以重新开始新的游戏。在菜单中选择游戏说明或者高分记录，则进入相应的屏幕，他们都能用“后退”软键返回菜单。菜单中的退出选项用于退出程序。游戏的流程如图4所示：

4.4.1主类GameMIDlet的实现

MIDlet是最核心的类。MIDlet程序有三种状态：

1．暂停状态

2．运行状态

3．销毁状态

J2ME程序都是从MIDlet类开始执行，系统在执行MIDlet程序时，首先构造一个MIDlet类型的对象，然后使程序进入到暂停状态，按照生命周期的规定，系统会自动调用MIDlet对象的startApp方法使程序进入到运行状态，开始程序的执行。

下图是运行时显示的画布对象:

首先，先要创建MIDlet类型的对象，下面我们来看对象的构造方法：

//主程序构造方法

public GameMIDlet()

{

rs = null;

RecordName = “GameRMS”;

GameMenu.display = Display.getDisplay(this) ;

GameMenu.midlet = this;

}

java

开发语言

oppo手机型号及价格

精选推荐

广告

JAVA基于J2ME的手机游戏开发(文档+源代码).zip

0下载·0评论

2022年1月27日

JAVA基于J2ME的手机游戏开发免费

717阅读·0评论·0点赞

2022年8月23日

JAVA五子棋手机网络对战游戏的设计与实现(源代码+论文)

568阅读·2评论·0点赞

2022年12月5日

J2ME手机游戏引擎程序结构简述

170阅读·0评论·0点赞

2021年9月12日

最新45款Java手机游戏开发源代码免费下载

10下载·0评论

2019年3月4日

经典50个Java手机游戏源码.7z

3下载·0评论

2022年7月8日

无敌版游戏下载

精选推荐

广告

java手机小游戏源码_Java手机版数独小游戏（J2me）JAVA游戏源码下载

435阅读·0评论·0点赞

2021年3月14日

java 300行代码 冒险闯关小游戏（代码+讲解）

2637阅读·1评论·6点赞

2022年9月9日

java俄罗斯方块代码_【俄罗斯方块java】分享一个Java写的俄罗斯方块源码 算法简单(300行) 注释详细!...

304阅读·0评论·0点赞

2021年3月5日

java小游戏源码_分享几款java小游戏源码

4921阅读·0评论·4点赞

2021年3月5日

java手机游戏开发如何_用JAVA开发手机游戏需要如何构建开发环境？

1209阅读·0评论·0点赞

2021年2月26日

《精通Java手机游戏与应用程序设计》源码

35阅读·0评论·0点赞

2022年3月24日

java怎么制作游戏，看完这篇彻底明白了

4803阅读·0评论·2点赞

2021年6月29日

泡泡堂代码 JAVA_Java手机游戏泡泡堂源码

566阅读·0评论·1点赞

2021年3月14日

十款经典游戏的Java版本（开源）

19.0W阅读·95评论·214点赞

2014年12月7日

飞翔的小鸟--Java小游戏实战（代码完整）

1.1W阅读·13评论·50点赞

2021年4月5日

Vue——获取后端json数据中的URL并通过按钮跳转到此URL

1683阅读·4评论·0点赞

2021年2月5日

java安卓游戏源码下载_77个安卓游戏 android源码

801阅读·0评论·0点赞

2021年3月15日

去首页

看看更多热门内容

关于安卓小游戏源码网和app游戏源码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。