手机游戏源码,网上下的java手机游戏源码怎么用Eclipse在电脑上运行？

手机游戏源码,网上下的java手机游戏源码怎么用Eclipse在电脑上运行？详细介绍

本文目录一览： 游戏源码是什么意思

问题一：游戏源代码什么意思 游戏源代码:游戏程序文件的代码。
源代码（也称源程序），是指一系列人类可读的计算机语言指令。 在现代程序语言中，源代码可以是以书籍或者磁带的形式出现，但最为常用的格式是文本文件，这种典型格式的目的是为了编译出计算机程序。计算机源代码的最终目的是将人类可读的文本翻译成为计算机可以执行的二进制指令，这种过程叫做编译，通过编译器完成。

问题二：游戏代码是什么意思 虽然电脑上标明是音乐文件，但是用TXT打开会发现是一串数字~没错~这就是金手指~
保存CMF格式代码:新建一个记事本，把代码复制进去，选另保存为(注意文件格式选“任意文件”)，然后选择保存地点和文件名(XXXXX.cmf)即可~
还有问题请补充~也可私聊~

问题三：请问网络游戏的源代码是什么？ 网络游戏源代码就是游戏的基础，在外行人眼里是无数行的英文和数字，其实就是一组程序。
作用当然是开发游戏啦。
手上拥有了源代码就可以制作游戏，当然如果你啥都不改，那功能就伐原来的游戏没什么两样。
现在网上你可以搜索一下网络游戏的源代码还是非常多的，但是大多数都是不完整的，也就是说你即便得到了也无法用。
另外只要这款游戏是国产的，你如果一模一样也不行，因为违反版权。
所以就算你拿到了源代码，你也要有完整的美术资源，需要让程序贴图替换上去，达到视觉上不一样的效果。世界背景和故事都要换，所有这些的成本当然不是一般的高。
好吧，即便你搞好了，那接下来你还要运营吧，运营的成本就更高了。

问题四：该游戏代码什么意思怎么解决？ 50分 这是乱码，游戏本体已经崩溃，会出现乱码可能是你私自改动了文件参数，或下载。错误，可直接删除。

问题五：源代码怎么用的啊？？有的游戏给 有的程序个给的那个 不知道你玩的啥游戏，但是看样子估计是c++代码，我英文学的不好
从英文描述中我猜测这是v c++的代码，“”在代码中表示注释，前三行是注释，其大意如下：
stdafx.cpp ：源文件，包括刚才的标准单元？
fixyou.pch将是预编译的标题
stdafx.obj将包含预编译的类型信息
“cpp”明显是c++源码文件的缩写名，而最后一行是头文件。
所谓头文件预编译，就是把一个工程(Project)中使用的一些MFC标准头文件(如Windows.H、Afxwin.H)预先编译，以后该工程编译时，不再编译这部分头文件，仅仅使用预编译的结果。这样可以加快编译速度，节省时间。
预编译头文件通过编译stdafx.cpp生成，以工程名命名，由于预编译的头文件的后缀是“pch”，所以编译结果文件是projectname.pch。
编译器通过一个头文件stdafx.h来使用预编译头文件。stdafx.h这个头文件名是可以在project的编译设置里指定的。编译器认为，所有在指令#include stdafx.h前的代码都是预编译的，它跳过#include stdafx. h指令，使用projectname.pch编译这条指令之后的所有代码。
因此，所有的CPP实现文件第一条语句都是：#include stdafx.h。
其实我学的pascal，所以对c++了解的少，如果你真的想学会他，还是自己找几本c++的书学一下，这样才能“使用”代码得心应手。

问题六：手机游戏源代码是什么，怎么使用 不知道你玩的啥游戏，但是看样子估计是c++代码，我英文学的不好
从英文描述中我猜测这是v c++的代码，“”在代码中表示注释，前三行是注释，其大意如下：
stdafx.cpp ：源文件，包括刚才的标准单元？
fixyou.pch将是预编译的标题
stdafx.obj将包含预编译的类型信息
“cpp”明显是c++源码文件的缩写名，而最后一行是头文件。
所谓头文件预编译，就是把一个工程(Project)中使用的一些MFC标准头文件(如Windows.H、Afxwin.H)预先编译，以后该工程编译时，不再编译这部分头文件，仅仅使用预编译的结果。这样快编译速度，节省时间。
预编译头文件通过编译stdafx.cpp生成，以工程名命名，由于预编译的头文件的后缀是“pch”，所以编译结果文件是projectname.pch。
编译器通过一个头文件stdafx.h来使用预编译头文件。stdafx.h这个头文件名是可以在project的编译设置里指定的。编译器认为，所有在指令#include stdafx.h前的代码都是预编译的，它跳过#include stdafx. h指令，使用projectname.pch编译这条指令之后的所有代码。
因此，所有的CPP实现文件第一条语句都是：#include stdafx.h。
其实我学的pascal，所以对c++了解的少，如果你真的想学会他，还是自己找几本c++的书学一下，这样才能“使用”代码得心应手。

问题七：什么是游戏代号？ 什么游戏？哪个美女？哪个国家？何为代号？具体点啊！我想回答！

问题八：coc部落对战里的游戏代码代表什么意思 请详细描述问题谢谢~

问题九：源代码在游戏中的作用 网络游戏源代码就是游戏的基础，在外行人眼里是无数行的英文和数字，其实就是一组程序。
作用当然是开发游戏啦。
手上拥有了源代码就可以制作游戏，当然如果你啥都不改，那功能就和原来的游戏没什么两样。
现在网上你可以搜索一下网络游戏的源代码还是非常多的，但是大多数都是不完整的，也就是说你即便得到了也无法用。
另外只要这款游戏是国产的，你如果一模一样也不行，因为违反版权。
所以就算你拿到了源代码，你也要有完整的美术资源，需要让程序贴图替换上去，达到视觉上不一样的效果。世界背景和故事都要换，所有这些的成本当然不是一般的高。
好吧，即便你搞好了，那接下来你还要运营吧，运营的成本就更高了。

问题十：手机游戏那么多代码，他们怎么找代码破解游戏的。需要学什么的才知道游戏代码的意思。 5分 你好朋友这样的情况有可能是游戏服务器问题，建议过段时间再登录，应当可以正常。

安卓手机游戏中的代码如何获得？

既然你安装了eclipse那你就可以配置sdk环境，然后建一个android project，把你的源代码放进去，选择在你自己的手机上运行就会自动安装到你手机上了。嫌麻烦的话可以发给我，我帮你运行一下直接给你app文件
需root,re管理器-system-app-systemUIapk 复制到电脑,打开方式用rar, res/drawable-xhdpi 图标文件都在里面修改了
这里将向彩民朋友介绍1些竞彩足球游戏的简单投注技能。 1、首先比较两队的本 5、注意分别哪些是“豪情球队”和“危机球队”。夺冠热门球队、卫冕
您好
获取游戏源代码需要对APK进行反编译，如果APK已经加密，无法通过反编译的方法获取源代码
目前反编译的软件有很多，您可以在腾讯电脑管家中下载，推荐使用【改之理】，一款非常好用的反编译软件，傻瓜式操作，适合新手，您百度也能搜索到
希望可以帮到您，望采纳
腾讯电脑管家企业平台：http://zhidao.baidu.com/c/guanjia/

手游源码是什么

无论我在还是不在,对你来说都没什么差异吧
什么也干不了。除了代码，你还需要各种美术素材（地图，模型，特效，贴图等），需要搭建关卡，设置好各种脚本和触发器，还要对大量内容进行测试。
游戏源代码就是游戏的基础，在外行人眼里是无数行的英文和数字，其实就是一组程序。
作用当然是开发游戏啦。
手上拥有了源代码就可以制作游戏，当然如果你啥都不改，那功能就和原来的游戏没什么两样。
现在网上你可以搜索一下网络游戏的源代码还是非常多的，但是大多数都是不完整的，也就是说你即便得到了也无法用。
就算你拿到了源代码，你也要有完整的美术资源，需要让程序贴图替换上去，达到视觉上不一样的效果。世界背景和故事都要换，所有这些的成本当然不是一般的高。
最后是运营，运营的成本就更高了。

手机游戏源代码是什么，怎么使用

不知道你玩的啥游戏，但是看样子估计是c++代码，我英文学的不好
从英文描述中我猜测这是v c++的代码，“//”在代码中表示注释，前三行是注释，其大意如下：
stdafx.cpp ：源文件，包括刚才的标准单元？
fixyou.pch将是预编译的标题
stdafx.obj将包含预编译的类型信息
“cpp”明显是c++源码文件的缩写名，而最后一行是头文件。
所谓头文件预编译，就是把一个工程(Project)中使用的一些MFC标准头文件(如Windows.H、Afxwin.H)预先编译，以后该工程编译时，不再编译这部分头文件，仅仅使用预编译的结果。这样快编译速度，节省时间。
预编译头文件通过编译stdafx.cpp生成，以工程名命名，由于预编译的头文件的后缀是“pch”，所以编译结果文件是projectname.pch。
编译器通过一个头文件stdafx.h来使用预编译头文件。stdafx.h这个头文件名是可以在project的编译设置里指定的。编译器认为，所有在指令#include "stdafx.h"前的代码都是预编译的，它跳过#include "stdafx. h"指令，使用projectname.pch编译这条指令之后的所有代码。
因此，所有的CPP实现文件第一条语句都是：#include "stdafx.h"。
其实我学的pascal，所以对c++了解的少，如果你真的想学会他，还是自己找几本c++的书学一下，这样才能“使用”代码得心应手。

手机游戏怎么找源码 不懂让道

这个游戏的马源一般是找不到的，会制作的才可以！
你可以下载了游戏的apk，改后缀压缩在解压，在里面找找吧！
然后手机的手机游戏apk什么的，最好在应用宝里面下载
在手机上打开应用宝软件搜索你所需要游戏，找到下载就可以了。
也可以通过手机连接电脑端的应用宝软件来下载的，打开PC端的应用宝软件——手机应用。
可以通过搜索你所需要的游戏进行下载呢，都是很方便的。还望采纳

有手游源码怎么修改游戏配置

1、首先，先将Notepad++代码编辑器和FTP上传工具下载安装。2、其次，在百度搜索微信游戏源代码，找到游戏代码。3、最后，点击设置进行修改即可。

网上下的java手机游戏源码怎么用Eclipse在电脑上运行？

需要在eclipse中进行配置
　　工具：
　　eclipse
　　方法如下：
在eclipse中,鼠标放在一个android提供的类上,按下ctrl键,会打开一个新页面,提示找不到对应的类的class或者源文件,点击attach source...
之后点击external folder...选择下载好的source位置,确定后就可以了.
下载的游戏
已经是编译过的，没有源代码不能在ECLIPSE里面运行，想要运行的话楼主可以去下一个
手机顽童
用它打开就可以在电脑上运行。游戏你下的JAR文件是压缩包的样子，不要解压它，它本身
就是一个可执行文件
这东西比较麻烦，总之你这么做肯定不行，缺的东西太多了，要按照你这种方法来做，那手机游戏就没什么可以发展的了这么容易被破解，你说是吗？

游戏代码怎么找

问题一：怎么可以查看游戏源代码 如果不是开源的，是无法看到源代码的
只能从逆向工程反推，这个技术颇为艰深

问题二：怎么找一个游戏的代码 100分 能叠加的物品好找点，，不能叠加的很慢，
搞个游戏内存修改的东西，，改变物品数量，搜索到精确地址，，代码一般就离它不远了。具体没找过，，，楼主搞成功了分享下，

问题三：游戏软件怎么查看源代码？ 呵呵 ，源代码自然看不到了，比如java编写的游戏代码发布后都是.class的文件，你如果能成功找到这些文件的话，下载一个java的反编译器，把这个文件加载进去就可以看到源代码了！其他语言编写的代码，我还真不会弄了!

问题四：怎么查找手机游戏代码 物品代码只能用网上玩家查出来提供的。。。自己能随意改的只有内存数值，游戏里显而易见的金币啊属性啊之类的找到基本都能改，不过也有些加密的改不了没办法，当乐上有八门神器的修改教功，你可以去看看。

问题五：如何使用游戏代码 软件游戏都是封装好了再交付用户使用的，一般不会透露源代码。现在只有一些反编软件可以看到很低级的机器语言和汇编语言，想看高级语言的话应该是看不到的，你想啊，订么容易让你看到了，人家的版权利益怎么保障啊
希望采纳

问题六：一个游戏代码是怎么找的从哪入手的 什么游戏代码 具体说一下 什么从哪入手

问题七：游戏源码怎么找 怎么找游戏里某个物品的源代码？求大神稍微说一点，QQ邮箱也行啊~谢谢 像DNF 石头 50606 这属于源代码 崩山击20088 就是说

问题八：电脑里的游戏目录代码怎么找 一般的东西都封的了，得破解才能找到。而且不是一般人能破解的了的！~

问题九：我有C++一个游戏的源代码,但是要怎么运行?

问题十：如果我想弄一个游戏改怎么弄在哪里弄用什么代码 .运行CE->2.运行游戏(只能修改单机游戏)->3.打开游戏进程->4.首次搜索一个数值(建议搜索全部，因为一般单机游戏的血量可能是浮点数)->5.回游戏中让这个数值改变 ->6.回CE按数值增减的情况再次搜索->7.重复步骤5和6直到得到一个或很少的几个结果-。

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

这个地址也有，不过直接给你吧，这样比较好
先给你看看主要的类吧
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防破解的方法吧。
一般来说，当前在iOS 和安卓平台用的比较多的防破解方式有以下几种：
l字符串加密（XSE）：对源码中的字符串进行加密，从而避免敏感字符串泄露
这种方式的好处是比较简单、容易实施，而且对性能的损耗不大，但是防破解的能力一般。
l虚假控制流技术（BCF）：在原始代码块中随机插入垃圾指令（花指令）、在原始代码块前后随机插入新的代码块，制造虚假的程序控制流。
这种方法的破解难度就比第一种好很多了，当然会造成一定的性能损耗。
l控制流平坦化保护（FLA）：在保证不改变源代码功能的前提下，将源代码中的条件、循环（等控制语句转化为调度器统一调用，隐藏原始执行流程。
这种方法会对性能造成比较大的损耗，如果对于性能要求比较高的慎用这种方式。
还有一种破解难度非常高的技术叫做“虚机源码保护”技术，目前为顶象独有。该技术首先把待保护的核心代码编译成二进制文件，然后生成独特的执行环境和只能在该环境下执行的运行程序。运行时使用顶象独创的虚拟CPU直接运行加密的指令，它们完全不同于常见的x86或ARM指令，从而任何逆向工具均无法直接逆向破解。
当然，没有软件是绝对无法被破解的，通过这些方式，可以显著提升被破解的难度。