哪个网站有。所有所有游戏的源代码
您好，现在很多网站都可以查询到游戏的源代码。
例如17171、u9、766都是可以进行相关查询的。
源代码（也称源程序）是指未编译的按照一定的程序设计语言规范书写的文本文件，是一系列人类可读的计算机语言指令。
在现代程序语言中，源代码可以是以书籍或者磁带的形式出现，但最为常用的格式是文本文件，这种典型格式的目的是为了编译出计算机程序。
网络游戏的源代码是什么
网络游戏源代码就是游戏的基础，在外行人眼里是无数行的英文和数字，其实就是一组程序。
作用当然是开发游戏啦。
手上拥有了源代码就可以制作游戏，当然如果你啥都不改，那功能就和原来的游戏没什么两样。
现在网上你可以搜索一下网络游戏的源代码还是非常多的，但是大多数都是不完整的，也就是说你即便得到了也无法用。
另外只要这款游戏是国产的，你如果一模一样也不行，因为违反版权。
所以就算你拿到了源代码，你也要有完整的美术资源，需要让程序贴图替换上去，达到视觉上不一样的效果。世界背景和故事都要换，所有这些的成本当然不是一般的高。
好吧，即便你搞那接下来你还要运营吧，运营的成本就更高了。
谁能给我一个手机游戏的源代码啊
这个地址也有，不过直接给你吧，这样比较好
先给你看看主要的类吧
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
看不明白的可以随时来问我哦，还可以当时传给你撒