4月3日消息：百度多酷CEO孙祖德在《2013广州国际网络及数字互动游戏博览会》上表示：2013年是手机游戏的爆发元年，不管是平台商还是游戏开发商都应该抓住机遇，紧密合作，一起拥抱移动互联游戏大时代!
  
 
  

   　　在演讲中孙祖德称：“多酷游戏中心是百度移动娱乐平台战略级产品。在移动互联网时代，我们希望搭出一个好的平台来，把手机游戏这个生态圈建的更加健康，让每个产业链上的成员都能将各自的工作做到极致，共同创造更多更好的游戏产品，为手机玩家服务。为实现这一目标，百度投入大量的优势资源进行支持，包括百度搜索、百度助手、百度联盟、百度贴吧、阿拉丁、hao123手机等……并且2013年的支持力度会更大，相信这些资源及专业的运营团队、客服团队，可以给多酷游戏平台上的产品带来巨大的流量和付费用户。”
  
 
  

   　　在谈及和游戏商的合作计划时，他表示，有信心也有能力给合作伙伴带来更好的回报，并承诺今年将有近一个亿的预算用来支持与游戏研发商、渠道商的合作。在合作模式上不局限，希望能够实现多元化、战略级的合作，除了国内游戏，同时他还向国外优秀游戏开发商抛出橄榄枝。
  
 
  

   　　 
  
  
   
  
  
   

  
  
 
  

   　　百度多酷CEO孙祖德
  
  

   

  
 
  

   　　以下是百度多酷CEO孙祖德演讲实录：
  
 
  

   　　大家好，我今天的演讲主题是《2013如何拥抱移动游戏大时代》。主要是跟现场的各位业内朋友分享一下百度移动游戏平台—多酷游戏中心怎样迎合2013年这个手机游戏爆发的时代。
  
 
  

   　　今天的讲话大概分五个部分，第一部分先讲一下百度移动搜索的变化关键点，我们来看看近两年来，网民们都在关注什么?第二部分我讲一下多酷是什么?有哪些资源能为同行的一些合作伙伴服务和采用，第三部分是2013年百度多酷给合作CP提供的政策是什么?第四部分要提到一些战略合作伙伴和合作方式。
  
 
  

   　　先讲第一部分，由于手机业的发展，特别是android和IOS系统成熟后，百度移动搜索在最近两年时间里搜索量增长了11倍!这在以前是不敢想象的，与移动游戏相关的搜索占比也在一年内提升3倍，特别是单机类游戏和网游。如神庙逃亡这种下载类游戏在百度平台上早已过千万级的下载，众所周知，这款游戏是美国的一对夫妇研发的产品，那么我们也看到在地铁里、公交车上，很多人在玩，并且玩的特别high。单机游戏也具备很大的市场，像水果忍者、找你妹这类游戏下载量也是十分巨大的。在网游里面，像时空猎人这样的游戏是和百度进行战略合作的一款产品，表现也比较卓越，另外还有忘仙、世界OL等等。
  
 
  

   　　接下来让大家了解多酷是什么，多酷可以为CP做什么，是我今天演讲的重要目的。百度这个平台很大，但是百度在移动游戏方面所做的动作还是非常少的，这是我们比较欠缺的一个地方，当然我们2012年也是一直在修炼内功，目前单针对移动游戏我们的注册用户数超过两千万。
  
 
  

   　　多酷是百度重点打造的一个移动娱乐平台，既然是平台，那么产品肯定是多样化的，不仅仅有游戏，而游戏却是多酷的重中之重，其他还包括百度书城、百度音乐、百度社区。多酷成立于2011年12月5号，是一家独立运营的子公司，我们的目标是要打造中国最领先的移动娱乐平台。为什么要一家独立的公司在做?在这里可以跟大家分享一下，因为我们发现一款有影响力的产品往往在大公司里很难成长，特别是面对一个瞬息万变的市场环境，很难。为什么?大公司体系大，决策慢，没有创业公司的感觉，这个就是为什么我们要独立出来的一个原因。
  
 
  

   　　那么多酷究竟能为这个产业做些什么呢?
  
 
  

   　　我简单总结一下多酷游戏中心截止到2013年我们投入的一些资源。资源一：用手机登陆百度首页，多酷在下面会有小说、游戏、下载三个入口，大家知道百度首页的用户覆盖量每天是过亿的，我们可以在第一时间把平台上的游戏推向用户。资源二：我们实现了手机到手机快速无缝的对接，高效转换，长期培养玩家的消费下载行为。比如说，辛辛苦苦二十人的一个研发团队，好不容易研发出来一款游戏，想短时间内获得大量的用户，那是要要到处去做广告吗?那不行!为什么?广告只能带动品牌，并不能带来转化，而通过多酷游戏平台就不一样，用户看到游戏，只要点链接，就可以快速下载到手机上，这是我们提供的一个独家资源;资源三：今年三月初发布的百度助手，包括PC版本、APP版本都会给我们推荐位置 ，像我们现在推的时空猎人的下载量已超过百万的，捕鱼达人更是达到千万级。对于一些优秀产品，我们会在重要的位置进行推荐，这些重点位置每天会到达千万用户的面前。
  
 
  

   　　我们在深挖百度资源的同时也协调了百度旗下的资源，包括大家熟悉的hao123， 多酷在hao123首页有一个专门的频道叫“应用”，主要推荐业内一些主流游戏，其他还有Hao123游戏频道、频道内容底纹及排行支持等。这样可以让一款游戏快速的PUSH到网民面前。第三块我们协调的资源就是百度联盟资源，这一块我们合作的方式也比较多，其他还有百度输入法、百度地图等优势资源……总结一句话，多酷可以帮助大家将产品更快、跟广、更有效的推送到用户面前。
  
 
  

   　　2013年百度多酷给合作伙伴提供了四种合作模式：联运、首发、定制、独代。
  
 
  

   　　简单说一下，联运大家都知道，介入标准是SDK，多酷游戏中心也有一个标准SDK，能够保证产品快速上线推广;第二种合作模式就是首发，首发的话我们就会协调百度资源进行重点推广，如果大家觉得百度平台不错欢迎和我们进行合作首发;第三个合作模式定制，定制模式相对前两种合作会更为深度一些，除了百度资源，我们还会配备一些外部资源进行支持;第四种模式也是最深度的模式叫做独代，我们会给研发商定制专门的推广方案、对外购买资源、提供宣传支持等等。
  
 
  

   　　今年我们可以跟合作伙伴承诺的是大概有一个亿用来支持在研发上的合作，这样可以保证每个产业链上的成员都能将各自的工作做到极致，负责研发的成员专心把产品做好，而把运营交给多酷游戏中心这样的平台，做各自专业的事情会让我们取得更好的效果。
  
 
  

   　　2013年我们希望找一些战略级合作伙伴，如果你手里有很多款产品或者今年有很多研发计划，或者说在运营方面比较弱想找一个合作伙伴，那么，希望您在第一时间能够想到百度多酷游戏中心，今年多酷在整体的运营层次上，运营深度上都会跟大家进行一些互动，进行一些深层次的投入。
  
 
  

   　　另外我们发现在整个国际前100的游戏下载里面，真正走入国内的大概不超三十款，还有六七十款可能因为中国特殊的市场环境导致它们没有真正走进来，那么，在这里我也抛出橄榄枝，希望众多的海外游戏研发商在发行你们的产品时，能够想到百度多酷游戏中心。2013年百度多酷游戏中心希望和你一起携手共赢，谢谢!
  
 
 
 
转载于:https://blog.51cto.com/6748115/1173828

观前提示： 本文涉及的小成果特别多，即使你不需要写一个和我完全相同的游戏，也可以按照需要查看某些特定功能的实现过程，说不定能够给您的程序开发带来一点小小的启发！PS：结合源代码阅读此博客更加高效。
 
本博客的内容可看作上一篇多线程游戏实例分享的扩展，上一篇博客介绍过的内容（如何实现一个简单的小游戏）在本博客中不再赘述，如果有疑问可以回访那篇博客（点击此处跳转）或者私信博主。
 
游戏整体效果演示视频：
 


 
 
Javad多线程实例分享-雷火-稳定版演示视频


 
游戏规则简介

 

 
游戏整体框架
 
 
这里对String page使用了一个switch判断，用于判断现在玩家需要运行哪一个画面。当我们需要切换画面时（比如说从游戏界面切入到暂停界面）就可以通过使用语句更改page的值来实现界面的切换。每一个界面都有对应的方法体。
 
动图实现
 
在雷火游戏中用到了非常多的图片元素和动态图片元素，其中的绝大多数都是通过LoadingImage类加载出来的。当我们想要实现一个功能时，首先要明晰我们想要看到的具体效果，然后再制定方案。就拿这个例子来说，当我想在窗口中绘制一个动态图片时，只需要一行代码就能做到。
 
bufg.drawImage(loadingImg.getMotionGraph(此处输入图片地址),0,0,null);
 
我们需要实现的就是下面这一步：
 
 在上一篇博客中讲到，我们游戏中的线程是这样运行的：
 
 所以我们可以这样去实现想要的功能：程序最开始运行时，先将动图的每一帧加载到一个数组中，然后调用这个动图数组绘制图片时，根据目前的轮数（len）进行一个判断，判断一下现在应该要画的是动图的哪一帧图片，然后返回这个图片对象。
 
将动图的每一帧加载到一个数组中
 
//生成图片数组对象generateGraphList
	public Image[] ggList(int interval,String[] str){
	/*该方法传入一个图片地址数组str，返回一个图片对象数组
	其中整数interval指的是每两帧图片间隔的图片数，interval的值越大，动图运动的速度越慢
	*/
		//创建一个新的图片地址数组str，因为要留出存放间隔图片的位置
		String[] strs=new String[str.length+str.length*interval];
		//创建一个和strs相同长度的数组
		Image[] imgs=new Image[str.length+str.length*interval];
		String temp = null;
		//将str数组扩充到strs数组
		for(int i=0;i<str.length+str.length*interval;i++){
			if(i%(interval+1)==0){
				//当索引i为interval+1的整数倍时，插入str数组中对应的图片地址
				strs[i]=str[i/(interval+1)];
				temp=str[i/(interval+1)];
			}else{
				//插入间隔图片的地址（相当于复制了前面的图片）
				strs[i]=temp;
			}
		}
		for(int i=0;i<strs.length;i++){
		//根据strs数组中的图片地址往图片数组imgs中加载对应的图片
			ImageIcon imic=new ImageIcon(fileAddress+strs[i]);
			imgs[i]=imic.getImage();
		}
		
		/*这里的imgss指的是存放imgs数组的二维数组
		我们往HashMap hm_imgss中存放一对键值，这样我们使用动图数组时，
		只需要根据动图数组第一张图片的地址就可以获取这个动图数组在imgss中的索引
		*/
		hm_imgss.put(str[0], imgssCount);
		imgssCount++;
		
		return imgs;
	}
 

 当我们需要使用动图时，调用以下方法
 
//传入计数器len和图片数组键（这样程序才能知道你需要使用哪一张动图）
	public Image getMotionGraph(int len,String key){
		Image[]img=imgss.get(hm_imgss.get(key));
		//根据计数器判断现在需要返回哪一帧图片
		int count=len%img.length;
		Image image=img[count];
		return image;
	}
 
当我们在创建LoadingImage对象的时候就把需要用到的图片全部加载
 
public LoadingImage(){
		//加载图片组（多张图片/动图）
		imgss.add(ggList(10,new String[]{"图1.png","图2.png","图3.png","图4.png",……}));
		}
 
如果我需要画出上面这段代码表示的动图，使用的代码是
 
LoadingImage ldimg=new LoadingImage();
g.drawImage(loadingImg.getMotionGraph("图1.png"),0,0,null);
 
判断碰撞的更新
 
在上一个版本的飞机大战中，我们的子弹经常会穿过怪物，导致没有击中。这一次博主对判断碰撞进行了十分细致的优化，大大改善了碰撞判断的准确性。
 我们可以写出一个方法，当我们需要判断两个飞行物是否碰撞时，只需要将两个飞行物对象传入该方法，该方法就能返回一个是否碰撞的Boolean值。该方法对以下四种碰撞情况进行判断，当其中任何一种情况成立时，返回true，即两个飞行物已经碰撞。
 
 
private Boolean jgat(FlyObject f1,FlyObject f2){//传入两个飞行物对象
		int f1_x=0;
		int f1_y=0;
		f1_x=f1.location.x;
		f1_y=f1.location.y;

		int f2_x=0;
		int f2_y=0;
		f2_x=f2.location.x;
		f2_y=f2.location.y;
		
		int f1_w=hm.get(f1.imgName).x;
		int f1_h=hm.get(f1.imgName).y;
		int f2_w=hm.get(f2.imgName).x;
		int f2_h=hm.get(f2.imgName).y;
		
		Boolean attack=(f2_x-f1_x<f1_w&f1_x-f2_x<f2_w&f2_y-f1_y<f1_h&f1_y-f2_y<f2_h);
		return attack;
	}
 
判断碰撞更新后的效果：
 
 
HashMap的使用
 
另外，上面的代码还用到了HashMap（哈希表），HashMap的作用就是创建一个表格，这个表格可以让我们通过键(key)去找到对应的值(value)。
 比如说我知道一个同学的名字，我想要根据这个名字(键key)去查找到该同学的学号(值value)，这就是一个非常简单的类似HashMap的例子。
 HashMap有两个最常用的方法，一个是put(),另一个是get()，put顾名思义就是往HashMap中放入一对键值，get就是通过键去获取HashMap中对应的值。
 在上面这个例子中我们通过飞行物的名字imgName(key)去找到飞行物图片的宽和高(valule)。
 
private HashMap<String,Vector>hm=new HashMap<>();//创建HashMap对象，尖括号中存储的key和value可以是任何类

//当我们需要往HashMap中存入数据时
hm.put("我机.png", new Vector(100,100));//这里的key是飞行物图片名称，value是飞行物图片的宽高

//当我们需要通过飞行物图片的名字去获取图片的宽高时
int f1_w=hm.get(f1.imgName).x;
int f1_h=hm.get(f1.imgName).y;
 
开始界面
 
整个开始界面的图形元素有三类，一类是在画面中穿插而过的飞机；一类是雷火的图案，一类是画面中心的按任意键进入游戏。博主在这里将它们的实现方法分别讲述一下。
 
飞机飞过动画效果实现
 
在上一篇博客中我们讲到过如何生成敌机，这里的动画效果使用的原理也是类似的。
 首先我们需要创建一个列表来存放开场动画的飞机，并且准备两张图片。
 
//开场飞机
	public ArrayList<FlyObject>startfos=new ArrayList<>();
 
 
//生成开场飞机动画
		if(flag_start%10==0){
			for(int i=0;i<6;i++){
			//生成开场动画飞机
				Vector location=new Vector(i*400,-100);
				Vector speed=new Vector(-10,10);
				FlyObject fo=new FlyObject(location,speed,10,"开场敌机-左下.png");
				
				Vector location2=new Vector(-800+i*400,900);
				Vector speed2=new Vector(10,-10);
				FlyObject fo2=new FlyObject(location2,speed2,-100,"开场敌机-右上.png");
			//将开场动画飞机放入准备好的startfos列表中
				startfos.add(fo);
				startfos.add(fo2);
			}
		}
		
		//绘制开场画面飞机图片，飞机移动
		for(int i=0;i<startfos.size();i++){
			FlyObject fo=startfos.get(i);
			bufg.drawImage(loadingImg.getGraph(fo.imgName), fo.location.x, fo.location.y, null);
			fo.move();
		}
		
		//清理飞出画面之外的飞机
		if(startfos.size()>200){for(int i=0;i<startfos.size()-200;i++){startfos.remove(0);}}
 
雷火图案
 
在开场画面中，雷火字样图案从窗口最上端向下移动，一段时间后停止在窗口中心位置，这是我们想要实现的效果。
 在这里博主定义了一个flag_start，每执行完一轮画图操作这个flag_start就会加一（和len的作用相似），当这个整数小于26时，雷火字样图案的纵坐标每一轮都增加固定的值，从而达到向下以固定速度进行移动的效果。当这个整数大于等于26时，雷火字样图案在固定点进行绘制。
 
if(flag_start<26){
			bufg.drawImage(loadingImg.getMotionGraph(flag_start,"开始界面_按任意键进入游戏_1.png"),0,500-flag_start*20,null);
			bufg.drawImage(loadingImg.getGraph("开始界面_雷火.png"),0,-500+flag_start*20,null);
			bufg.drawImage(loadingImg.getMotionGraph(flag_start,"开始界面_雷火_动图1.png"),0,-500+flag_start*20,null);
			flag_start++;
		}else{
			bufg.drawImage(loadingImg.getMotionGraph(flag_start,"开始界面_按任意键进入游戏_1.png"),0,0,null);
			bufg.drawImage(loadingImg.getGraph("开始界面_雷火_动图底图.png"),0,0,null);
			bufg.drawImage(loadingImg.getMotionGraph(flag_start,"开始界面_雷火_动图1.png"),0,0,null);
			flag_start++;
			//绘出目前要按的键
			bufg.drawImage(loadingImg.getGraph(nowPress),nowPressx,nowPressy, null);
		}
 
按键效果
 
当鼠标置于“按任意键进入游戏”字样时，字体会出现发光效果。包括在后面很多的页面中，鼠标置于按键上时都会有发光效果。这里我们定义一个String类的对象nowPress，我们可以在鼠标监听器中设置当鼠标置于对应字样图案上方时，将nowPress的值更新为这个图案的名称；当鼠标移开时我们就将nowPress定义为""。这样就可以实现只在鼠标放置于对应图案上方时，图案才会有发光效果。
 
//鼠标监听器中的MouseMove函数
public void mouseMoved(MouseEvent e) {
			int x=e.getX();
			int y=e.getY();//判断按键
			if(x>150&x<1050&y>600&y<700){
				myThread.nowPress="开始界面_按任意键进入游戏_触碰.png";//一张发光的图片
				myThread.nowPressx=0;
				myThread.nowPressy=0;
			}else{//鼠标移开时
				myThread.nowPress="";
			}
}
 
游戏界面
 
技能实现
 
相较于上一版飞机大战，技能的使用是一个新增的功能。
 
 雷火游戏目前可以使用的技能有3个，S键是保护罩（使用后抵御一切攻击，消耗3技能点），D键是火球（火球会缓慢向右移动，并炸毁触及的所有敌机，消耗2技能点），F键是向我机周围发射多重环形高杀伤火力（消耗1技能点）。
 我们可以构造一个使用技能的方法，键盘监听器监听到按键事件时，调用此方法并传入按键代码完成技能的调用。
 
//使用技能
public void useSkill(int keyCode){//键盘监听器传入按键代码
	if(skillPoint>0){
		switch(keyCode){//keycode为70时是F键，83是S键，68是D键
		case 70:if(skill_F_wait==SKF){skill_F_wait=0;skillPoint--;skill_F+=5;}break;
		case 83:if(skill_S_wait==SKS&skillPoint>2){skill_S_wait=0;skillPoint-=3;skill_S+=300;}break;
		case 68:if(skill_D_wait==SKD&skillPoint>1){
		/*火球技能，我们可以将火球视作一种特殊的子弹，以下代码
		便是创建火球这个子弹并放入bults列表中*/
			skill_D_wait=0;
			skillPoint-=2;
			Vector location=new Vector(mps.get(mps.size()-5).location.x,mps.get(mps.size()-5).location.y-100);
			Vector speed=new Vector(5,0);
			bults.add(new FlyObject(location,speed,100,"技能D-火球.png"));
			}break;
		}
	}else if(keyCode==70|keyCode==83|keyCode==68){
	//当玩家使用技能按键，但技能点不足时窗体左下角出现“技能点不足”的提示
		Vector location=new Vector(30,730);
		explosions.add(new FlyObject(location,30,"技能点不足.png"));
	}
}
 
F技能
 
F技能向我机周围发射环状火力，想要实现这一点，我们只需要建立一个for循环，在循环中，每生成一次子弹就让子弹运动速度方向转换一个角度。
 
 
//F技能
if(len%5==0&mps.size()>5&skill_F>0){
	skill_F--;
	int direction=60;//子弹发射的方向数量，数量越大发射的子弹越多
	int speedx=20;//子弹速度
	for(int i=0;i<direction;i++){
		Vector location=new Vector((double)mps.get(mps.size()-5).location.x,(double)mps.get(mps.size()-5).location.y);
		Vector speed=new Vector(speedx*Math.cos(Math.PI*i*2/direction),speedx*Math.sin(Math.PI*i*2/direction));
		bults.add(new FlyObject(location,speed,3,"火球.png"));
	}
}
 
S技能
 
S技能是保护罩，保护罩的作用是躲避敌人的一切攻击。要做到这一点，我们可以创建一个整数skill_S（初始值定为0），当我们使用S技能时skill_S增加一个定值。然后在判断敌机和敌机子弹是否与我机碰撞之前，先判断一下skill_S的值是否大于0，如果是，则跳过碰撞的判断；如果为否，则正常进行碰撞判断。每经过一轮画图，skill_S的值就减1。
 此外，在S技能即将失效的时候，屏幕右下角会有一个闪烁警告图片显示。想要实现这个效果，我们可以每一轮对skill_S的值进行判断，当它等于某一个值的时候（不是小于等于而是等于，因为我们只需要放置一次图片），就在右下角放置一张动图。
 
 
技能冷却（绘制部分图片）
 
技能冷却的三种状态：
 
 我们需要用到三张图片，首先一张透明度为40%的图片打底，绘制在最底层。然后让一张透明度为100%的图片部分叠加其上，并随着时间不断填充整个图幅。当技能冷却完成时，绘制一张边缘发光的图片。
 
 这里我们遇到的一个问题是，如何显示一张图片的部分图像？博主在网络上寻找了很多裁剪图片的方法，但大多数要么很复杂，要么需要使用到第三方库，这里博主有一个非常简单易行的实现方法：
 
 首先我们创建一个比图片尺寸要小的BufferedImage对象，然后将这个图片绘制在这个BufferedImage上，但是纵坐标应该为负值，最终要使图片的底部和BufferedImage的底部对齐。这样显示在窗体上的就是BufferedImage和图片重叠的这一部分了。我们只需要按照一定规律对BufferedImage的尺寸和图片的纵坐标进行改变，就可以实现技能加载的效果。
 
//绘制透明图片
bufg.drawImage(loadingImg.getGraph("技能F2.png"),1100,800,null);
//F技能
if(skill_F_wait<SKF){
	//skill_F是等待的“时间”，SKF是技能完成加载需要的“时间”
	skill_F_wait++;
	//下面的代码实现的就是绘制部分图片
	int high_f=70*skill_F_wait/SKF+1;
	BufferedImage temp_bufimg=new BufferedImage(70,high_f,2);
	Graphics temp_g=temp_bufimg.getGraphics();
	temp_g.drawImage(loadingImg.getGraph("技能F1.png"),0,high_f-70,null);
	
	bufg.drawImage(temp_bufimg,1100,870-high_f,null);
}else{
	//技能加载完成
	skill_F_wait=SKF;
	//画一张发光的图
	bufg.drawImage(loadingImg.getGraph("技能F3.png"),1100,800,null);
}
 
奖励机
 
奖励机是每隔一段时间有概率刷出的，奖励机被击中后会随机掉落道具，被击毁后会掉落特殊道具。
 
我们需要实现以下三点：
 
奖励机被击中后掉落道具；
道具的随机运动路径；
击毁后随机掉落道具。
 
 
随机掉落道具
 
怎么设置随机掉落道具？我们可以获取一个大小在0-79的随机数，当这个随机数等于1时掉落某个道具，那么这个道具出现的概率就为1/80；如果我们想让某个道具掉落概率增加，就可以减小随机数的大小范围，或者给该道具多设置几个数字（比如说当随机数为0、1、2、3时掉落该道具，则其出现的概率就为原来的4倍）。
 
private void dropProp(FlyObject fo){
		if(fo.imgName.equals("奖励机_1.png")){
			Random ran=new Random();
			//获取一个0-79的随机数
			int pt=ran.nextInt(80);
			String propType=null;
			switch(pt){
			case 1:propType="火力蓝_奖励.png";break;
			case 2:propType="技能点_奖励.png";break;
			case 3:propType="技能点_奖励.png";break;
			case 4:propType="生命值_奖励.png";break;
			default:propType="金币.png";
			}
			//为掉落的道具设置随机速度
			int spd_x=ran.nextInt(20)-10;
			int spd_y=ran.nextInt(20)-10;
			Vector speed=new Vector(spd_x,spd_y);
			Vector location=new Vector(fo.location.x,fo.location.y);
			props.add(new FlyObject(location,speed,320,propType));
		}
	}
 
击中及击毁后掉落道具
 
在判断碰撞的方法中，加入以下代码，如果确定被子弹击中的飞行物为奖励机，则让奖励机扣除相应血量并调用dropProp函数随机掉落道具；如果奖励机血量小于0，说明奖励机被击毁，此时调用dropProp_bomb函数（和dropProp只有掉落道具的概率不同）。
 
if(enemy.imgName.equals("奖励机_1.png")){
	enemy.HP-=bullet.HP;
	if(len%3==1){
		dropProp(enemy);
	}
	if(enemys.get(i).HP<=0){
		explosion(enemy);
		for(int k=0;k<4;k++){
			dropProp_bomb(enemy);
		}
		moveAway(enemy);
	}
 
Boss模式
 
Boss技能
 
Boss一共有三个技能，在Boss使用技能前先获取一个随机数，这个随机数将决定Boss使用哪一个技能。
 
Random ran=new Random();
if(len_boss%600==0){
		bossSkill=ran.nextInt(3);//获取随机数
		bossSkillTime=450;
	}
 
Boss技能1:
 
boss技能1的原理与F技能的原理相似（发射一个子弹，转换一次角度），但boss技能1只向正前方固定角度范围发射子弹，且有一段固定长度的空缺。
 
 
 
//boss技能1
if(len_boss%20==0&bossSkill==0&bossSkillTime>0){
	int direction=100;//代表Boss发射一圈子弹的方向数
	int shootAngel=20;//代表direction中有多长一段是发射子弹的
	int speedx=10;//子弹速度
	int startPoint=ran.nextInt(15);//空缺开始的位置（随机）
	for(int i=direction/2-shootAngel/2;i<direction/2+shootAngel/2;i++){
		int flag_skip=i-direction/2+shootAngel/2;
		//跳过空缺的一段子弹
		if(!(flag_skip<startPoint+5&flag_skip>startPoint)){
			Vector location=new Vector((double)enemys.get(0).location.x+200,(double)enemys.get(0).location.y+150);
			Vector speed=new Vector((speedx*Math.cos(Math.PI*i*2/direction)),(speedx*Math.sin(Math.PI*i*2/direction)));
			enemys.add(new FlyObject(location,speed,3,"boss_子弹.png"));
		}
	}
}
 
Boss技能2:
 
Boss2技能的实现很巧妙，大家仔细对比技能1和技能2的代码就会发现，它们其实长得差不多！最大不同之处在于，技能1是子弹发射时跳过某一段子弹（造成某一段子弹空缺），而技能2正好就是只发射某一段子弹。相当于同一段代码实现了两个技能两种玩法哈哈哈！
 
 
//boss技能2
if(len_boss%2==0&bossSkill==1&bossSkillTime>0){
	if(len_boss%10==0){startPoint=ran.nextInt(35);}//每隔一段时间就切换一次发射子弹的角度段
	int direction=100;
	int shootAngel=40;
	int speedx=20;
	for(int i=direction/2-shootAngel/2;i<direction/2+shootAngel/2;i++){
		int flag_skip=i-direction/2+shootAngel/2;
		if(flag_skip<startPoint+5&flag_skip>startPoint){
			Vector location=new Vector((double)enemys.get(0).location.x+200,(double)enemys.get(0).location.y+150);
			Vector speed=new Vector((speedx*Math.cos(Math.PI*i*2/direction)),(speedx*Math.sin(Math.PI*i*2/direction)));
			enemys.add(new FlyObject(location,speed,3,"boss_子弹.png"));
		}
	}
}
 
Boss技能3:
 
 
Boss技能3实现的是交替使用两波数量和速度均有差别的子弹发射方式，仔细观察可以发现这两波子弹是没有对齐的，这样的玩法就是我们的飞机可以在这两波子弹交错的空隙中穿插而过。
 

 flag_switch的作用就是控制两种子弹发射方式交替进行。
 
//boss技能3
if(len_boss%30==0&bossSkill==2&bossSkillTime>0){
	flag_switch++;
	if(flag_switch%2==0){
		int direction=30;
		int shootAngel=30;
		int speedx=8;
		for(int i=direction/2-shootAngel/2;i<direction/2+shootAngel/2;i++){
			Vector location=new Vector((double)enemys.get(0).location.x+200,(double)enemys.get(0).location.y+150);
			Vector speed=new Vector((speedx*Math.cos(Math.PI*i*2/direction)),(speedx*Math.sin(Math.PI*i*2/direction)));
			enemys.add(new FlyObject(location,speed,3,"boss_子弹.png"));
		}
	}else if(flag_switch%2==1){
		int direction=30;
		int shootAngel=30;
		int speedx=7;
		for(int i=direction/2-shootAngel/2;i<direction/2+shootAngel/2;i++){
			Vector location=new Vector((double)enemys.get(0).location.x+200,(double)enemys.get(0).location.y+150);
			Vector speed=new Vector((speedx*Math.cos(Math.PI*i*2/direction+Math.PI/direction)),(speedx*Math.sin(Math.PI*i*2/direction+Math.PI/direction)));
			enemys.add(new FlyObject(location,speed,3,"boss_子弹.png"));
		}
	}

}
 
功能分区
 
Boss模式的功能分区玩法是博主自创的，规则是当我们的飞机停留在某一个区域时会有对应的效果加成。飞机停于回血区时会缓慢回血（并附有加血特效的显示）；停于战斗区时发射的子弹火力会增大；在道具区停留一段时间，飞机的技能点会增加；停于攻击区时会对Boss有雷电伤害加成；停于躲避区时飞机会自动获得保护罩，不受任何攻击。
 
 首先我们需要编写一个方法，来判断我们的飞机目前处于什么功能区域。功能区域划分的主要依据是与Boss中心的距离（除躲避区外其余功能区都是以Boss中心为圆心的圆环或圆）。当我们的飞机进入对应的区域时，变量areaName和areaName2就更改为对应的区域名称，方便进行下一步操作。
 
public void judgeFunctionArea(int x, int y) {
		int distance=(int)(Math.sqrt(Math.pow(x-1000,2)+Math.pow(y-450,2)));//距离Boss中心的距离
		
		//进入boss模式后开启判断
		if(len_boss>0){
			if(x>900&x<1200&!(distance<300)){
			//因为躲避区是矩形区域，所以判断方式有所不同
				areaName="躲避区-紫.png";
				areaName2="躲避区.png";
//				System.out.println("目前处于躲避区-紫");
			}else{
				if(distance<300){
					areaName="攻击区-红.png";
					areaName2="进击区.png";
//					System.out.println("目前处于攻击区-红");
				}else if(distance<600){
					areaName="道具区-黄.png";
					areaName2="技能区.png";
//					System.out.println("目前处于道具区-黄");
				}else if(distance<900){
					areaName="战斗区-蓝.png";
					areaName2="战斗区.png";
//					System.out.println("目前处于战斗区-蓝");
				}else if(distance<1200){
					areaName="回血区-绿.png";
					areaName2="回血区.png";
//					System.out.println("目前处于回血区-绿");
				}
			}
		}
 
功能分区效果实现
 
//绘制功能区
if(!areaName.equals("")){
	bufg.drawImage(loadingImg.getGraph(areaName),
			1000-hm.get(areaName).x/2,450-hm.get(areaName).y/2,null);
	bufg.drawImage(loadingImg.getGraph(areaName2),260,70,null);
	switch(areaName){
	case"回血区-绿.png":if(len_boss%5==0){newLife++;explosion(mps.get(mps.size()-5),0);}break;
	case"躲避区-紫.png":skill_S++;break;//处于躲避区就相当于使用了技能S
	case"道具区-黄.png":yellowAreaTime++;break;
	case"攻击区-红.png":
		//Boss模式下enemys的第一个元素为Boss
		enemys.get(0).HP-=5;
		//加入闪电特效
		if(len_boss%20==0){explosion(enemys.get(0),1);}
		if(len_boss%10==0){explosion(enemys.get(0),2);explosion(enemys.get(0),2);}
		break;
	case"战斗区-蓝.png":superPropTime=true;break;
	//我机发射子弹时会对superPropTime进行一个判断，当其为true时发射特殊子弹
	}
}

if(yellowAreaTime>100){
//计算在道具区的停留时间，yellowAreaTime每达到100就增加一个技能点
	yellowAreaTime-=100;
	skillPoint++;
}
 
回血区
 
 
战斗区
 
 
攻击区
 
 
躲避区
 
 
背景音乐（带调节音量效果）
 
背景音乐和爆炸音效的实现我使用了两个不同的类，分别是BackgroundMusic和PlayMusic。其中BackgroundMusic类继承了Runnable接口（也就是说播放背景音乐的时候也需要创建一个线程），这个类目前博主已经实现了暂停/播放、重新播放、音量调节、停止播放的功能，并且将这个类做成了一个单独的demo
 
背景音乐Demo（只能播放wav音频文件）
 
该Demo大概的实现原理是将wav音频文件的波形转化为一段一段的数组，然后逐段播放。处理文件的部分参考了CSDN某个博主的博客，因为当时没有收藏，所以没能找到参考的是哪一篇博客。如果这位博主看到了这里，希望能够联系我标记出处！
 RESTART：重新播放
 on_off：暂停/播放
 STOP：停止播放
 “+”“-”：调节音量
 
 Demo代码获取链接：提取码：q4im 
 
播放音乐
 
播放音乐的类(BackgroundMusic)继承了Runnable接口，所以想要播放音乐，应该先创建线程对象，然后启动线程实现音乐播放。我们可以把这一步放到BackgroundMusic的构造方法中，这样我们每次创建BackgroundMusic对象时就可以自动创建线程并播放音乐了。
 
public BackgroundMusic(String fileAddress){
		this.fileAddress=fileAddress;
		Thread micthc=new Thread(this);
		micthc.start();
		on_off();
	}
 
如果我们想在某一个地方播放音乐，只需要：
 
//游戏页面中播放的音乐
level_1_Music=new BackgroundMusic(fileAddress+"雷火BackgroundMusic.wav");
//括号中为音乐文件路径名称
 
暂停界面调节音量
 
 
private void page_pause(Graphics bufg) {
		//暂停界面背景
		bufg.drawImage(loadingImg.getGraph("背景_1.png"),0,0, null);
		//绘制按键
		bufg.drawImage(loadingImg.getGraph("暂停中.png"),0,100, null);
		bufg.drawImage(loadingImg.getGraph("音量关.png"),950,200, null); 
		bufg.drawImage(loadingImg.getGraph("+.png"),950,270, null); 
		bufg.drawImage(loadingImg.getGraph("-.png"),950,600, null); 
		bufg.drawImage(loadingImg.getGraph("空格或点击此处继续游戏.png"),0,100, null);
		bufg.drawImage(loadingImg.getGraph("重新开始.png"),0,50, null);
		
		//判断现在在放哪一个背景音乐
		BackgroundMusic bgm=new BackgroundMusic();
		if(len_boss==0){
			bgm=level_1_Music;
		}else{
			bgm=level_1_boss_Music;
		}
		
		//调节音量
		if(bgm.value>5){bgm.value=5;}else if(bgm.value<1){bgm.value=0.5;}
		//背景音乐暂停/继续
		if(bgm.flag_pause){bufg.drawImage(loadingImg.getGraph("音量开.png"),950,200, null);}
		//绘制音量大小
		for(int i=0;i<bgm.value;i++){
			bufg.drawImage(loadingImg.getGraph("音量.png"),950,540-i*50, null);
		}
		
		//绘出目前要按的键
		bufg.drawImage(loadingImg.getGraph(nowPress),nowPressx,nowPressy, null); 
	}
 
经验总结
 
经常使用的代码块可以编写成方法
 
将经常使用的代码块编写成方法，可以减少代码的重复，使代码更加简洁。比如在雷火这个小游戏中，判断碰撞（jgat函数）就经常被使用到，所以可以单独写成一个方法。
 
功能模块化处理
 
将功能模块化处理，可以方便程序的理解以及排查bug和增添功能。在雷火游戏中，每个页面（开始、暂停、游戏等）都是独立实现的，生成飞行物、绘制飞行物、判断碰撞、刷新分数等功能都独立编写了方法。特别是程序的体量比较大的时候，模块化处理能让我们的程序更加容易调试。
 
Debug模式的使用
 
debug模式主要作用是在用户指定的地方让代码停下来，然后逐步执行并发现问题。
 
 
打断点
 
双击编辑窗口靠左的区域（行数的左边），会出现一个蓝色的点。当我们以Debug模式启动程序时，运行到这一步会自动停下。
 
 
逐步执行
 
进入Debug模式后：
 
 
消化他人的代码
 
有时候我们想实现一个新的效果，比如旋转图片、播放音乐，我们可能会直接上百度或者CSDN搜索实现代码。如果我们只是把代码简单的插入到我们的程序中，那我们可能只是一个“调包侠”哈哈哈。如果你打算使用一段别人的代码，不妨仔细读一下，理解它的实现原理，理解作者的奇思妙想，寻找更多我们能运用到其他地方的知识。
 
最后
 
这个小游戏取名叫雷火，有我的一点情怀在里面。小时候还在按键机年代，我爸手机上有一个游戏就叫雷火，但是现在已经很难找到了，现在做了一个这样的游戏也算是实现了我小时候的梦想。那时候按键机游戏很多都是java开发的（开始画面会有经典的java的咖啡图标出现）当时还不知道这个图标的含义，现在，我正在用这种语言尝试着学会开发程序，这是一种很奇妙的感觉。
 
 游戏中使用到的绝大多数图片素材都是我用手绘板和PS软件绘制的，算是我的一个业余小爱好哈哈哈，所以大家不需要担心版权问题，可以放心使用。
 
 我的其他一些绘画作品
 
 最后的最后，感谢你能够看到这里！这篇博客花费了我非常大的心血，我已经记不清开发这个小游戏的那两个星期有多少次不自觉地熬到凌晨三四点，夜深人静，灵感却不断涌现，现在回想起来真是相当的充实。所以，我非常也希望能够帮助读到这篇博客的你，如果有小伙伴因为看了我的博客颇有收获，我也非常非常欢迎你来和我交流！
 
游戏的完整代码，放在这里！
 提取码：mk1n
 解压后可以直接运行的jar包，放在这里！（可以直接试玩）
 提取码：jagk

一．前言
 
某日，看见隔壁家的小朋友在玩一款网络爆款贪吃蛇游戏，感觉很好玩。自己刚好正在学习JAVA编程，也想实现一个类似功能的游戏Demo练手，在网上查看了不少源码案例，全都是很古老的方块式贪吃蛇游戏案例，没有想要的实现，因此自己动手实现一个JAVA版的贪吃蛇游戏。
 
我在这个Dome完成之后重写了这个游戏的Android版，并重新更名为《蛇王传说》。也欢迎大家下载试玩。游戏下载地址：蒲公英 - 用户登录
 
我的另一篇博客有Androd版本的游戏介绍：蛇王传说1.0Android版发布_hawkol的专栏-CSDN博客
 
二、实现效果
 
1.启动界面 蛇头会左右摆动，动态效果
 
 
2、游戏主界面   地图上有不同的食物，用键盘控制蛇在地图上行走，每吃掉一个食物，蛇会自动生长一节
 
 
三、按键功能说明  左右键蛇转向，上键蛇加速行走。
 
 
四、美工准备
 
因自己不会美工，很多图都是从网上找的，然后用photoshop抠图，按自己的设计思路，做成以下样式。做片做的比较丑，就不放原图了。
 
1、images 文件夹
 
 
2、foolds文件夹
 
 
3、snake文件夹
 
 
 
4、在s0,s1,s2,s3,s4文件夹分别放以下5张图，可以做成不同颜色和样式（也就是蛇的皮肤）
 
 
五、打开Eclipse新建HawkRetroSnaker 项目，目录文件结构如下图：
 
从目录结构可以看出，此游戏有5个JAVA类，分别是
 
Foods.java (食物），
 
Snake.java (蛇），
 
SnakePlayer.java (游戏主程），
 
Tools.java （工具类），
 
UIGameStart.java (启动时的Ui).
 
 
六、游戏代码：关键代码地方都有注释，我就不多啰嗦了，代码写的比较烂，只是为了实现功能，有很多地方可以优化，大家也可提出自己的见解。
 
1.Foods.java
 
package com.hawkonline.retorsnaker;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.imageio.ImageIO;

public class Foods {
	
	private int imgID;//食物图片D 以foodsX 
	private int drawX;// 图块显示中心的X位置
	private int drawY;// 图块显示中心的Y位置
	
	private int generateEnergy;//产生能量

	private  int offsetX;// 图块块显示的X位置偏移值-自动计算
	private  int offsetY;// 图块块显示的X位置偏移值-自动计算
	
	private BufferedImage imgFoods;//
	
	public Foods(int imgID, int drawX, int drawY, int generateEnergy) {
		super();

		this.imgID = imgID;
		this.drawX = drawX;
		this.drawY = drawY;
		this.generateEnergy = generateEnergy;
		
		//加载食物图片
		try {
			imgFoods= ImageIO.read(new FileInputStream("images\\foods\\foods"+imgID+".png"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		this.offsetX = imgFoods.getWidth()/2;
		this.offsetY = imgFoods.getHeight()/2;
	}
	
	//画食物
	public void drawFoods(Graphics cg,int x,int y ){
		cg.drawImage(imgFoods, drawX-offsetX+x, drawY-offsetY+y, null);
		cg.setColor(Color.WHITE);
		//参照线-------------------
		cg.fillRect(drawX-1+x, drawY-1+y, 2, 2);
	}

	public Foods() {
		super();
	}

	public int getImgID() {
		return imgID;
	}

	public void setImgID(int imgID) {
		this.imgID = imgID;
	}

	public int getDrawX() {
		return drawX;
	}

	public void setDrawX(int drawX) {
		this.drawX = drawX;
	}

	public int getDrawY() {
		return drawY;
	}

	public void setDrawY(int drawY) {
		this.drawY = drawY;
	}

	public int getGenerateEnergy() {
		return generateEnergy;
	}

	public void setGenerateEnergy(int generateEnergy) {
		this.generateEnergy = generateEnergy;
	}

	public int getOffsetX() {
		return offsetX;
	}

	public void setOffsetX(int offsetX) {
		this.offsetX = offsetX;
	}

	public int getOffsetY() {
		return offsetY;
	}

	public void setOffsetY(int offsetY) {
		this.offsetY = offsetY;
	}
}
 
2.Snake.java
 
package com.hawkonline.retorsnaker;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
import java.util.Random;

import javax.imageio.ImageIO;

public class Snake {
	private Random rand = new Random();
	private int to=0;//自动移动模式标记蛇移动的方向，1左，2右
	
	// 蛇图片相关显示属性
	private int step;// 步长
	private int offsetX;// 图块块显示的X位置偏移值-自动计算
	private int offsetY;// 图块块显示的X位置偏移值-自动计算
	private BufferedImage imgSnakeHead;// 蛇头图片
	private BufferedImage imgSnakeBody1;// 蛇身体奇数图片
	private BufferedImage imgSnakeBody2;// 蛇身体偶数图片
	private BufferedImage imgSnakeTait1;// 蛇尾巴图片
	private BufferedImage imgSnakeTait2;// 蛇尾巴图片
	private BufferedImage imgRotate;// 旋转后的图片

	// 蛇的属值
	private int energy;// 吃豆得到的能量
	private int snakeLength;// 蛇的长度--默认3节，根椐能量获得的多少自动生长

	// 蛇头
	private int snakeHeadX;// 蛇头X坐标
	private int snakeHeadY;// 蛇头Y坐标
	private int snakeHeadDirection;// 蛇头移动的方向
	private int snakeDisplayStyle;// 蛇显示风格
	private boolean snakeIsDeath;//蛇死亡标记   True-生存， false=死亡

	// 蛇身体
	private int[] bodyX;// 蛇身体X坐标
	private int[] bodyY;// 蛇身体Y坐标
	private int[] bodyDirection;// 蛇身体方向

	// 构造函数
	public Snake(int snakeHeadX, int snakeHeadY, int snakeHeadDirection, int snakeDisplayStyle) {
		super();
		this.snakeHeadX = snakeHeadX;
		this.snakeHeadY = snakeHeadY;
		this.snakeHeadDirection = snakeHeadDirection;
		this.snakeDisplayStyle = snakeDisplayStyle;
		this.snakeIsDeath = true;//蛇死亡标记   True-生存， false=死亡

		snakeLength =6;

		// 加载图片
		try {
			imgSnakeHead = ImageIO.read(new FileInputStream("images\\snake\\s" + snakeDisplayStyle + "\\head.png"));
			imgSnakeBody1 = ImageIO.read(new FileInputStream("images\\snake\\s" + snakeDisplayStyle + "\\body1.png"));
			imgSnakeBody2 = ImageIO.read(new FileInputStream("images\\snake\\s" + snakeDisplayStyle + "\\body2.png"));
			imgSnakeTait1 = ImageIO.read(new FileInputStream("images\\snake\\s" + snakeDisplayStyle + "\\tait1.png"));
			imgSnakeTait2 = ImageIO.read(new FileInputStream("images\\snake\\s" + snakeDisplayStyle + "\\tait2.png"));

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		this.offsetX =imgSnakeHead.getWidth()/2;
		this.offsetY =imgSnakeHead.getHeight()/2;
		this.step = 8;

		// 蛇身体-构造时为3节
		bodyX = new int[snakeLength];
		bodyY = new int[snakeLength];
		bodyDirection = new int[snakeLength];

		for (int i = 0; i < snakeLength; i++) {
			bodyX[i] = snakeHeadX - (i + 1) * step;
			bodyY[i] = snakeHeadY;
			bodyDirection[i] = 0;
		}

	}

	// 画蛇
	public void snakeShow(Graphics cg,int x,int y) {

		// 画蛇身体
		for (int i = snakeLength - 1; i >= 0; i--) {
			if (i == snakeLength - 1) {// 画蛇尾
				if ((i % 2 == 0)) {
					imgRotate = Tools.rotateImage(imgSnakeTait1, bodyDirection[i]);
				} else {
					imgRotate = Tools.rotateImage(imgSnakeTait2, bodyDirection[i]);
				}

			} else {
				// 画蛇身体
				if ((i % 2) == 0) {
					imgRotate = Tools.rotateImage(imgSnakeBody1, bodyDirection[i]);
				} else {
					imgRotate = Tools.rotateImage(imgSnakeBody2, bodyDirection[i]);
				}

			}
			cg.drawImage(imgRotate, bodyX[i] - offsetX+x, bodyY[i] - offsetY+y,null);
			// 参照线-------------------
			cg.setColor(Color.WHITE);
			cg.fillRect(bodyX[i] - 1+x, bodyY[i] - 1+y, 2, 2);
		}

		// 画蛇头
		imgRotate = Tools.rotateImage(imgSnakeHead, snakeHeadDirection);
		cg.drawImage(imgRotate, snakeHeadX - offsetX+x, snakeHeadY - offsetY+y,null);

		// 参照线-------------------
		cg.setColor(Color.WHITE);
		cg.fillRect(snakeHeadX - 1+x, snakeHeadY - 1+y, 2, 2);
		
		
		
		cg.setColor(Color.BLUE);
		int sX = (int) (snakeHeadX + 150 * Math.cos(snakeHeadDirection * 3.14 / 180));
		int sY = (int) (snakeHeadY + 150 * Math.sin(snakeHeadDirection * 3.14 / 180));
		cg.fillRect(sX - 1+x, sY - 1+y, 2, 2);
		
		sX = (int) (snakeHeadX + 100 * Math.cos((snakeHeadDirection+45) * 3.14 / 180));
		sY = (int) (snakeHeadY + 100 * Math.sin((snakeHeadDirection+45) * 3.14 / 180));
		cg.fillRect(sX - 1+x, sY - 1+y, 2, 2);
		sX = (int) (snakeHeadX + 100 * Math.cos((snakeHeadDirection-45) * 3.14 / 180));
		sY = (int) (snakeHeadY + 100 * Math.sin((snakeHeadDirection-45) * 3.14 / 180));
		cg.fillRect(sX - 1+x, sY - 1+y, 2, 2);
		// 参照线-------------------
		cg.setColor(Color.WHITE);
		cg.fillRect(snakeHeadX - 1+x, snakeHeadY - 1+y, 2, 2);
		
		

	}
	public void snakeAutoMove(){
		// 蛇智能移动方案3
		//蛇下一步的位置
		int sX = (int) (snakeHeadX + 150 * Math.cos(snakeHeadDirection * 3.14 / 180));
		int sY = (int) (snakeHeadY + 150 * Math.sin(snakeHeadDirection * 3.14 / 180));
		
		//蛇死亡了
		if(sX<=20||sX>=(Tools.MAP_X-20)||sY<=20||sY>=(Tools.MAP_Y-20)){
			boolean isL=false,isR=false;
			//看下左边45度会不会死
			sX = (int) (snakeHeadX + 100 * Math.cos((snakeHeadDirection+45) * 3.14 / 180));
			sY = (int) (snakeHeadY + 100 * Math.sin((snakeHeadDirection+45) * 3.14 / 180));
			if(sX<=20||sX>=(Tools.MAP_X-20)||sY<=20||sY>=(Tools.MAP_Y-20)){
				isL=true;
			}
			//看下左边45度会不会死
			sX = (int) (snakeHeadX + 100 * Math.cos((snakeHeadDirection-45) * 3.14 / 180));
			sY = (int) (snakeHeadY + 100 * Math.sin((snakeHeadDirection-45) * 3.14 / 180));
			if(sX<=20||sX>=(Tools.MAP_X-15)||sY<=20||sY>=(Tools.MAP_Y-15)){
				isR=true;
			}
			
			//左右死
			if((isL)&&(isL)){
				if(rand.nextInt(1)==1){
					snakeHeadDirection+=(rand.nextInt(5)+20);//增大旋转角度
					to=1;
				}else{
					snakeHeadDirection-=(rand.nextInt(5)+20);//增大旋转角度
					to=2;
				}
			}else if(isL){
				snakeHeadDirection-=(rand.nextInt(5)+5);//增大旋转角度
				to=2;
			}else{
				snakeHeadDirection+=(rand.nextInt(5)+5);//增大旋转角度
				to=1;
			}
		}else{
			if(rand.nextInt(rand.nextInt(20)+10)==1){
				to=rand.nextInt(3);
			}
			if (to==1) snakeHeadDirection+=(rand.nextInt(5)+2);
			if (to==2) snakeHeadDirection-=(rand.nextInt(5)+2);
		}
		snakeMove();


		
	}
	// 蛇移动-按照设置的方向前行
	public void snakeMove() {
		if (snakeIsDeath) {
			// 蛇的后一节的值继承前一节的值
			for (int i = snakeLength - 1; i > 0; i--) {
				bodyX[i] = bodyX[i - 1];
				bodyY[i] = bodyY[i - 1];
				bodyDirection[i] = bodyDirection[i - 1];
			}
			// 第一节的值继承蛇头的值
			bodyX[0] = snakeHeadX;
			bodyY[0] = snakeHeadY;
			bodyDirection[0] = snakeHeadDirection;

			snakeHeadX = (int) (snakeHeadX + step * Math.cos(snakeHeadDirection * 3.14 / 180));
			snakeHeadY = (int) (snakeHeadY + step * Math.sin(snakeHeadDirection * 3.14 / 180));
		}

	}

	// 蛇生长--数组自动扩容1节
	public void snakGrow() {

		snakeLength = snakeLength + 1;

		if (snakeLength > bodyX.length) {
			bodyX = Arrays.copyOf(bodyX, snakeLength);
			bodyY = Arrays.copyOf(bodyY, snakeLength);
			bodyDirection = Arrays.copyOf(bodyDirection, snakeLength);
		}

	}

	// 蛇死亡
	public void snakeDeath() {
		this.snakeIsDeath = false;//蛇死亡标记   True-生存， false=死亡
		// 随机数--产生蛇块断裂
		Random rand = new Random();
		for (int i = 0; i < snakeLength; i++) {
			bodyX[i] = bodyX[i] + rand.nextInt(step * 2) - rand.nextInt(step * 2);
			bodyY[i] = bodyY[i] + rand.nextInt(step * 2) - rand.nextInt(step * 2);
			bodyDirection[i] = bodyDirection[i] + rand.nextInt(360);
		}
		//snakeHeadX = snakeHeadX + rand.nextInt(step) - rand.nextInt(step);
		//snakeHeadY = snakeHeadY + rand.nextInt(step) - rand.nextInt(step);
		snakeHeadX = (int) (snakeHeadX + step * Math.cos(snakeHeadDirection * 3.14 / 180));
		snakeHeadY = (int) (snakeHeadY + step * Math.sin(snakeHeadDirection * 3.14 / 180));
	}


	// get---- set-----
	public int getSnakeHeadDirection() {
		return snakeHeadDirection;
	}

	public void setSnakeHeadDirection(int snakeHeadDirection) {
		this.snakeHeadDirection = snakeHeadDirection;
	}

	public int getSnakeHeadX() {
		return snakeHeadX;
	}

	public void setSnakeHeadX(int snakeHeadX) {
		this.snakeHeadX = snakeHeadX;
	}

	public int getSnakeHeadY() {
		return snakeHeadY;
	}

	public void setSnakeHeadY(int snakeHeadY) {
		this.snakeHeadY = snakeHeadY;
	}

	public boolean getSnakIsDeath() {
		return snakeIsDeath;
	}

	public boolean isSnakeIsDeath() {
		return snakeIsDeath;
	}

	public void setSnakeIsDeath(boolean snakeIsDeath) {
		this.snakeIsDeath = snakeIsDeath;
	}

	public int getEnergy() {
		return energy;
	}

	public void setEnergy(int energy) {
		this.energy = energy;
		
		if((energy-5)>=0){//每获取5点能量，蛇生长一节(12-5)>=0
			this.snakGrow();//蛇生长
			this.energy=this.energy-5;
		}
	}

	public int getSnakeLength() {
		return snakeLength;
	}

	public void setSnakeLength(int snakeLength) {
		this.snakeLength = snakeLength;
	}

	public int getSnakeDisplayStyle() {
		return snakeDisplayStyle;
	}

	public void setSnakeDisplayStyle(int snakeDisplayStyle) {
		this.snakeDisplayStyle = snakeDisplayStyle;
	}

}
 
 
3.SnakePlayer.java
 
package com.hawkonline.retorsnaker;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Font;
import java.awt.Graphics;

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;

public class SnakePlayer  extends JFrame implements Runnable, KeyListener{
	Random rand = new Random();
	private int runGame=0;
	
	//UI
	private UIGameStart uiGameStart=null;
	
	private int inputSleep=80;//线程执行间隔时长

	private int drawMapX,drawMapY;
	
	private static BufferedImage bfMap= new BufferedImage(Tools.MAP_X, Tools.MAP_Y, BufferedImage.TYPE_3BYTE_BGR); // 创建一张1920＊1080的地图源图
	
    private static BufferedImage bfGameMap = new BufferedImage(Tools.SCREEN_X, Tools.SCREEN_Y, BufferedImage.TYPE_3BYTE_BGR); // 创建一张1920＊1080的缓冲图片
    private static Graphics bfGameMapGraphics =bfGameMap.getGraphics();// 获取缓冲图片的画笔
    private BufferedImage imgDisplayInformation=null;
    private BufferedImage imeGameOver=null;
    
    private Foods []foods=null;//小圆点食物
    
    private Snake snake=null;//蛇
    //private Snake enemy=null;

	public SnakePlayer() {
		
		this.setTitle(Tools.GameName);
		// 设置框架的大小
		this.setSize(Tools.SCREEN_X, Tools.SCREEN_Y);
		 // 设置框架大小可以改变
		this.setResizable(false);
		//设置窗体居中显示
		this.setLocationRelativeTo(null);
      // 设置点击关闭按钮 关闭界面
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		//设置GUI的窗口图标
		ImageIcon snakeIcon = new ImageIcon("images\\snakeIcon.png");
		this.setIconImage(snakeIcon.getImage());
		// 允许显示游戏界面
		this.setVisible(true); 
		// 添加键盘监听器  
	    this.addKeyListener(this);
	    // 添加鼠标监听器 

        //鼠标样式
		this.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
	    //创建UI界面
	    uiGameStart=new UIGameStart();
	    
	    
	    loadGameResources();//加载游戏资源
	    bfMapDraw();//画背地图，以后不用多次画了
	    setFoods();
	    setSnake();
	    
	     Thread thread = new Thread(this); // 创建线程  
	     thread.start(); // 启动线程  
	}
	
	//加载游戏资源
	private void loadGameResources() {
	    try {
			imgDisplayInformation = ImageIO.read(new FileInputStream("images\\DisplayInformation.png"));
			imeGameOver = ImageIO.read(new FileInputStream("images\\GameOver.png"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	//设置蛇
	private void setSnake() {
		snake=new Snake(Tools.MAP_X/2, Tools.MAP_Y/2, 0,rand.nextInt(Tools.SNAKE_STYLE_SUM));
		
//		int sx=rand.nextInt(Tools.MAP_X-40)+20;
//		int sy=rand.nextInt(Tools.MAP_Y-40)+20;
//		int sd=rand.nextInt(360);
//		int ss=rand.nextInt(Tools.SNAKE_STYLE_SUM);
//
//		enemy=new Snake(sx, sy, sd, ss);
	}

	// 设置食物
	private void setFoods() {

		foods=new Foods[Tools.FOODS_SUM];
		for(int i=0;i<Tools.FOODS_SUM;i++){

				int imgID=rand.nextInt(Tools.FOODS_TYPE_SUM);
				int drawX=rand.nextInt(Tools.MAP_X-40)+20;
				int drawY=rand.nextInt(Tools.MAP_Y-40)+20;
				//-------------可设计从XML文件读入
				int generateEnergy;
				if (imgID<7){
					generateEnergy=1;
				}else {
					generateEnergy=5;
				}
				foods[i]=new Foods(imgID, drawX, drawY, generateEnergy);
		}

	}
	// 设置游戏地图
	private void bfMapDraw() {
		Graphics bfMapGraphics =bfMap.getGraphics();// 获取缓冲图片的画笔
		
		bfMapGraphics.setColor(Color.BLACK); // 设置map外框为黑色
		bfMapGraphics.fillRect(0, 0, Tools.MAP_X, Tools.MAP_Y);

		bfMapGraphics.setColor(new Color(90, 90, 90)); // 设置map墙为黑色
		bfMapGraphics.fillRect(10, 10, Tools.MAP_X - 20, Tools.MAP_Y - 20);

		bfMapGraphics.setColor(new Color(208, 208, 224)); // 设置map背景色
		bfMapGraphics.fillRect(20, 20, Tools.MAP_X - 40, Tools.MAP_Y - 40);
		// 画map格
		bfMapGraphics.setColor(new Color(241, 241, 240));
		for (int i = 20; i < Tools.MAP_Y; i += 20) {
			bfMapGraphics.drawLine(0 + 12, i, Tools.MAP_X -12, i);
		}

		for (int j = 20; j < Tools.MAP_X; j += 20) {
			bfMapGraphics.drawLine(j, 0 + 12, j, Tools.MAP_Y - 12);
		}
	}
	
	public void reDrawGame(){
		
		//得到画地图的偏移值
		drawMapX=-snake.getSnakeHeadX()+Tools.SCREEN_X/2;
		drawMapY=-snake.getSnakeHeadY()+Tools.SCREEN_Y/2;
		
		//画地图背景
		bfGameMapGraphics.setColor(Color.red);
		bfGameMapGraphics.fillRect(0, 0, Tools.SCREEN_X, Tools.SCREEN_Y);
		
		bfGameMapGraphics.drawImage(bfMap, drawMapX, drawMapY, null);//显示第一层背景地图
		
		for(int i=0;i<Tools.FOODS_SUM;i++){

			int distance = (int) Math.sqrt(Math.abs((foods[i].getDrawX() -  snake.getSnakeHeadX())*(foods[i].getDrawX() -  snake.getSnakeHeadX()))+Math.abs((foods[i].getDrawY() -  snake.getSnakeHeadY())*(foods[i].getDrawY() -  snake.getSnakeHeadY())));
			
			if (distance<25){//如果贪吃蛇离食物有20，测吃掉食物
				
				snake.setEnergy(snake.getEnergy()+foods[i].getGenerateEnergy());//能量加
				
				//产生新的食物

				foods[i].setDrawX(rand.nextInt(Tools.MAP_X-40)+20);
				foods[i].setDrawY(rand.nextInt(Tools.MAP_Y-40)+20);
			}
			foods[i].drawFoods(bfGameMapGraphics, drawMapX,drawMapY);

	}
		//===============================================
		if (snake.getSnakIsDeath()){//如果蛇在活着
			//snake.snakeMove();//蛇移动
			snake.snakeAutoMove();
			
			//判断蛇是否撞墙
			if(snake.getSnakeHeadX()<=20||snake.getSnakeHeadX()>=(Tools.MAP_X-20)||snake.getSnakeHeadY()<=20||snake.getSnakeHeadY()>=(Tools.MAP_Y-20)){
				snake.snakeDeath();//蛇死亡了
				runGame=2;//游戏结束
			}
		}

		snake.snakeShow(bfGameMapGraphics,drawMapX,drawMapY);

	}
	


	public void paint(Graphics gr) {
		switch (runGame){
		case 0:
			uiGameStart.drawUIGameStart(bfGameMapGraphics);
			gr.drawImage(bfGameMap,0,0, null); // 将缓冲map
			break;
		case 1:
			reDrawGame();
			//显示得分
			showDisplayInformation();
			gr.drawImage(bfGameMap,0,0, null); // 将缓冲map
			
            break;
		case 2:
			reDrawGame();

			showDisplayInformation();
			bfGameMapGraphics.drawImage(imeGameOver,250,100, null);
			
			gr.drawImage(bfGameMap,0,0, null); // 将缓冲map
			break;
			
		default:
			break;
			
		}

 }  


		//显示得分
		private void showDisplayInformation() {
			bfGameMapGraphics.drawImage(imgDisplayInformation,300,30, null); 
			bfGameMapGraphics.setColor(Color.RED);
			bfGameMapGraphics.setFont(new Font("arial",Font.BOLD, 30));
			bfGameMapGraphics.drawString(snake.getSnakeLength()+"", 460, 66);
			bfGameMapGraphics.drawString(snake.getEnergy()+"", 680, 66);
	}

		/** 
	     * 线程执行方法 
	     */  
	    public void run() {  
	        try {  
	            while (true) {  
	                this.repaint();  
	                Thread.sleep(inputSleep);  
	            }  
	        } catch (InterruptedException e) {  
	            e.printStackTrace();  
	        }  
	    }  
	  
	    /** 
	     * 按下时调用 
	     */  
	    public void keyPressed(KeyEvent e) {  
	    	
	        int keyCode = e.getKeyCode();
	        
	        //	游戏刚启动时，按任意键开始游戏        
	        if (runGame==0){
	    		runGame=1;
	    	}
	        
	        if (keyCode ==KeyEvent.VK_LEFT&&runGame==1) { // 左按键  
	        	snake.setSnakeHeadDirection(snake.getSnakeHeadDirection()-5);//蛇左转
	        }  
	        if (keyCode == KeyEvent.VK_RIGHT&&runGame==1) { // 右按键  
	        	snake.setSnakeHeadDirection(snake.getSnakeHeadDirection()+5);//蛇右转
	        }  
	       if(keyCode==KeyEvent.VK_UP&&runGame==1){//加速
	    	   inputSleep=20;
	       }
	       if(keyCode==KeyEvent.VK_L&&runGame==2){//复活

	    	   snake.setSnakeHeadX(Tools.MAP_X/2);
	    	   snake.setSnakeHeadY(Tools.MAP_Y/2);
	    	   runGame=1;
	    	   snake.setSnakeIsDeath(true);
	       }
	       if(keyCode==KeyEvent.VK_Y&&runGame==2){//重新开始
	    	   snake.setSnakeHeadX(Tools.MAP_X/2);
	    	   snake.setSnakeHeadY(Tools.MAP_Y/2);
	    	   snake.setSnakeLength(3);
	    	   snake.setEnergy(0);
	    	   runGame=1;
	    	   snake.setSnakeIsDeath(true);
	       }
	    }  
	  
	    /** 
	     * 释放按键时调用 
	     */  
	    public void keyReleased(KeyEvent e) {  
	    	 int keyCode = e.getKeyCode(); 
	    	 if(keyCode==KeyEvent.VK_UP){
		    	   inputSleep=80;
		       }
	    }  
	  
	    /** 
	     * 不解释 
	     */  
	    public void keyTyped(KeyEvent e) {  
	  
	    }  
	  
	    public static void main(String[] args) {  
	        new SnakePlayer();  
	    }

	}


 
4、Tools.java
 
package com.hawkonline.retorsnaker;

import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;

public class Tools {
	public static final int MAP_X = 1920;
	public static final int MAP_Y = 1080;
	public static final int SCREEN_X = 800;
	public static final int SCREEN_Y = 600;
	public static final String GameName = "美卡贪吃蛇1.0.0";

	public final static int FOODS_TYPE_SUM = 19;// 食物种类
	public final static int FOODS_SUM = 50;// 小圆食物总数
	public final static int SNAKE_STYLE_SUM = 6;// 蛇皮肤总数
	public final static int SNAKE__SUM=10;//蛇的数量
	
	/**
	 * 旋转图片为指定角度
	 * 
	 * @param bufferedimage
	 *            目标图像
	 * @param degree
	 *            旋转角度
	 * @return
	 */
	public final static BufferedImage rotateImage(final BufferedImage bufferedimage, final int degree) {
		int w = bufferedimage.getWidth();// 得到图片宽度。
		int h = bufferedimage.getHeight();// 得到图片高度。
		int type = bufferedimage.getColorModel().getTransparency();// 得到图片透明度。
		BufferedImage img;// 空的图片。
		Graphics2D graphics2d;// 空的画笔。
		(graphics2d = (img = new BufferedImage(w, h, type)).createGraphics())
				.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
		graphics2d.rotate(Math.toRadians(degree), w / 2, h / 2);// 旋转，degree是整型，度数，比如垂直90度。
		graphics2d.drawImage(bufferedimage, 0, 0, null);// 从bufferedimagecopy图片至img，0,0是img的坐标。
		graphics2d.dispose();
		return img;// 返回复制好的图片，原图片依然没有变，没有旋转，下次还可以使用。
	}

}
 
5、UIGameStart.java
 
package com.hawkonline.retorsnaker;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import javax.imageio.ImageIO;


public class UIGameStart {

	private BufferedImage gameStart=null;
    private BufferedImage snakeImage=null;
    private BufferedImage snakeTxt=null;
    private BufferedImage imgRotate;// 旋转后的图片
    private int retate=0;
    private boolean left=true;
    
    public UIGameStart() {
    	try {
    		gameStart = ImageIO.read(new FileInputStream("images\\gameStart.png"));
    		snakeImage = ImageIO.read(new FileInputStream("images\\snakeImage.png"));
    		snakeTxt = ImageIO.read(new FileInputStream("images\\snakeTxt.png"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
   
	}
    public void drawUIGameStart(Graphics cg){
    	cg.setColor(Color.BLACK);
    	cg.fillRect(0, 0, Tools.SCREEN_X, Tools.SCREEN_Y);
    	//画背景
    	cg.drawImage(gameStart,0, 0, Tools.SCREEN_X, Tools.SCREEN_Y,null);
    	
    	//蛇头动画参数
    	if (left){
    		retate+=2;
    		if (retate==20) left=false;
    		
    	}else{
    		retate-=2;
    		if (retate==-20) left=true;
    	}
    	
    	imgRotate = Tools.rotateImage(snakeImage, retate);
    	
    	//居中显示
    	cg.drawImage(imgRotate, (Tools.SCREEN_X-snakeImage.getWidth())/2, (Tools.SCREEN_Y-snakeImage.getHeight())/2, null);
    	cg.drawImage(snakeTxt, (Tools.SCREEN_X-snakeTxt.getWidth())/2, (Tools.SCREEN_Y-snakeTxt.getHeight())/2, null);
    	
    	cg.setColor(Color.RED);
    	cg.setFont(new Font("arial",Font.BOLD, 30));	
    }
}
 
直接运行。完工！！
 
snake.snakeAutoMove()是自动行走模式，实现了简单的AI智能,经测试蛇在地图上可以长时间不撞墙死掉。
 
如果改为snake.snakeMove()是手动操控模式。
 
 
 
 企业网站/微信小程序/app定制开发请添加微信:Hawkonline
 
 
 
 最新小程序案例
 
       
 

 
 
现在的游戏开发变得越来越复杂，需要制作各种炫丽的效果，还要制作各种基于 2D 或者 3D 的场景。为了节省游戏开发者的时间，让开发者集中精力在游戏的创新上，出现了许许多多的游戏引擎。而现在为了实现跨平台，HTML5 和 JavaScript 成功为了游戏开发者必备的利器，特别是移动端的开发者，必须要能很好的掌握 HTML5 和 JavaScript。
 
 
现在这么多的游戏引擎，各有各的优点和缺点，为了帮助开发者们找到属于自己的那款游戏开发引擎，我们综合了许多方面的考虑，选出来以下的 18 个超酷的 HTML5 和 JavaScript 游戏引擎库。大家欣赏完之后可以交流一下自己的经验和感受哦，Enjoy！
 
 
1)   Impactjs
 
 
Impact 是最好的 JavaScript 游戏引擎之一，允许开发者创建令人惊奇的游戏，开发者可以开发 HTML5 游戏，支持桌面环境和移动端，支持所有主流浏览器： FIrefox, Chrome,, Safari, Opera 和 IE 。
 
 
 
 
2)  Craftyjs
 
 
Craftjs 是另外一个完美的游戏引擎，提供一个开发杰出游戏的接口，并且跨浏览器兼容。
 
 
 
 
3)   Play Craft Labs
 
 
playcraft 引擎提供给开发者许多工具集，帮助开发各种类型的游戏，这些工具集非常强大，可以让开发者自由发挥自己的各种想法，并且可以很容易转换到其他的平台，比如 Facebook，旧版的网站，原生 Android 和 iOS 应用等等。
 
 
 
 
4)   Jawsjs
 
 
Jaws 是个 HTML5 驱动的 2D 游戏库，刚开发的时候只能用来制作 canvas，现在支持通过同样的 API 来制作普通基于 DOM 的 sprites。支持的浏览器：Chrome 9+, Firefox 3.6+, Safari 5+ & IE9。
 
 
 
 
5)   Enchantjs
 
 
Enchant.js 是个简单的 JavaScript 框架，可以使用 HTML5 和 JavaScript 来开发简单的游戏和应用。现在还是由 UEI 的 Akihabara 研究中心来开发和维护。在线演示
 
 
 
 
6)  Collie
 
 
Collie 是个 JavaScript 库，可以使用 HTML5 开发高优化的动画和游戏，Collie 可以在 PC 和手机端运行，使用 HTML5 Canva 和 DOM。
 
 
 
 
7)   Traffic Cone
 
 
Trafficcone 是 2D 和 2.5D（等距） 的 HTML5 游戏引擎，可以制作复杂的精灵动画和基于砖面的场景。
 
 
 
 
8)   HTML5 Quintus
 
 
Quintus 是 HTML5 JavaScript 游戏引擎，提供开发手机，桌面等等环境的更好的游戏开发接口。
 
 
 
 
9)   Flashjs
 
 
FlashJS 是非常杰出的图形和游戏开发引擎 API，这个库允许开发 HTML5 游戏和应用，类似于普通的 AS3 开发。支持浏览器：Chrome, Safari, Internet Explorer 和 Firefox。
 
 
 
 
10)  Game Queryjs
 
 
GameQuery 是个 jQuery 的 JavaScript 游戏引擎，可以结合 jQuery 插件来帮助开发 JavaScript 游戏。
 
 
 
 
11)  Melonjs
 
 
MelonJs 是个新兴的轻量级免费的，基于 2D 的游戏开发引擎。它有多个非常强大的特性：兼容所有浏览器( Chrome, Safari, Firefox, Opera, IE)，支持多个音频频道；tween 效果，效果转换等等。
 
 
 
 
12)  Turbulenz
 
 
Turbulenz ，这个开源 HTML5 游戏引擎，允许开发者创建 HTML5 SDK 的游戏，包括了开发者所需要的开发，运行项目，发布和部署的所有功能。
 
 
 
 
13)  Iso Genic Engine
 
 
Isogenic 游戏引擎是最先进的 HTML5 多玩家游戏引擎，拥有基于图像的架构艺术场景，容易使用的实时多玩家功能，支持所有主流浏览器和移动端设备。
 
 
 
 
14)   Akihabara
 
 
 
 
15)   Canvas Engine
 
 
CanvasEngine 提供所有简便的特性帮助开发者创建 HTML5 Canvas 游戏，提供一个简单的架构 API。
 
 
 
 
16)   Gogo Make Play
 
 
GMP 是非常快速而且免费开源的 JavaScript 游戏引擎，它简单而且容易使用。
 
 
 
 
17)   Squarepig
 
 
Squarepig 是一款 HTML5 游戏引擎。
 
 
 
 
18)   jGen
 
 
jGen 是开发者喜爱的一款 JavaScript 游戏引擎。
 
 
 
 
via  designzum.com
 
 
 
 
转载请注明：文章转载自：开源中国社区 [http://www.oschina.net]
 
 

 本文标题：18 款超酷的 HTML5 和 JavaScript 游戏引擎库
 
 本文地址：
 http://www.oschina.net/news/50897/best-html5-and-javascript-gamen-engine-libraries