noname/play/coin.js

'use strict';
play.coin={
	init:function(){
		if(lib.config.mode!='chess'||get.config('chess_mode')!='leader'){
			_status.coin=0;
		}
	},
	arenaReady:function(){
        if(_status.video) return;
		if(lib.config.mode!='chess'||get.config('chess_mode')!='leader'){
			var str;
			if(lib.config.coin_display_playpackconfig=='text'){
				str='<span>'+lib.config.coin+'</span><span>金</span>'
			}
			else{
				str='<span style="position:absolute">㉤</span><span style="margin-left:18px;font-family:xinwei;line-height:10px">'+lib.config.coin+'</span>';
			}
			if(lib.config.coin_canvas_playpackconfig){
				ui.window.classList.add('canvas_top');
			}
			ui.coin=ui.create.system(str,null,true);
			if(lib.config.snowFall){
				game.haveFun.list.snow.bought=true;
				setTimeout(function(){
					game.haveFun.snow();
				},500);
			}
			lib.setPopped(ui.coin,function(){
				var uiintro=ui.create.dialog('hidden');
				uiintro.classList.add('coin_menu')
				uiintro.add('商店');
				uiintro.listen(function(e){
					e.stopPropagation();
				});
				var clickBuy=function(){
					if(this.innerHTML=='停止'){
						game.haveFun[this.name+'Stop']();
					}
					else if(this.innerHTML=='开始'){
						game.haveFun[this.name]();
					}
					else if(this.innerHTML.indexOf('金')!=-1){
						if(lib.config.coin>=this.content.cost){
							this.content.bought=true;
							game.changeCoin(-this.content.cost);
							game.haveFun[this.name]();
							if(this.content.onbuy){
								this.content.onbuy.call(this);
							}
						}
						else{
							return;
						}
					}
					ui.click.window();
				};
				for(var i in game.haveFun.list){
					var item=game.haveFun.list[i];
					uiintro.add('<div class="coin_buy">'+item.name+'<div class="menubutton">'+item.cost+'金</span></div></div>');
					var buy=uiintro.content.lastChild.lastChild.lastChild;
					if(lib.config.coin<item.cost&&!item.bought){
						buy.classList.add('disabled');
					}
					if(item.bought){
						if(item.running){
							buy.innerHTML='停止';
							if(item.control){
								var node=item.control();
								if(node){
									buy.parentNode.appendChild(node,buy);
								}
							}
						}
						else{
							buy.innerHTML='开始';
						}
					}
					buy.name=i;
					buy.content=item;
					buy.listen(clickBuy);
				}

				if(!game.phaseNumber){
					uiintro.add('下注');
					uiintro.add('<div class="coin_buy">本局获胜<div class="menubutton">20金</span></div></div>');
					var bet=uiintro.content.lastChild.lastChild.lastChild;
					bet.listen(function(){
						if(_status.betWin) return;
						_status.betWin=true;
						game.changeCoin(-20);
						this.innerHTML='已下注';
					});
					if(_status.betWin){
						bet.innerHTML='已下注';
					}
				}
				else if(_status.betWin){
					uiintro.add('下注');
					uiintro.add('<div class="coin_buy">本局获胜<div class="menubutton">已下注</span></div></div>');
				}

				uiintro.classList.add('noleave');

				return uiintro;
			},220,400);
		}
    },
	game:{
		changeCoin:function(num){
			if(typeof num=='number'&&ui.coin){
				game.saveConfig('coin',lib.config.coin+num);
				var str;
				if(lib.config.coin_display_playpackconfig=='text'){
					str='<span>'+lib.config.coin+'</span><span>金</span>'
				}
				else{
					str='<span style="position:absolute">㉤</span><span style="margin-left:18px;font-family:xinwei;line-height:10px">'+lib.config.coin+'</span>';
				}
				ui.coin.innerHTML=str;
			}
		},
		haveFun:{
			list:{
				firework:{
					name:'烟花',
					cost:50,
				},
				snow:{
					name:'下雪',
					cost:20,
					size:'large',
					control:function(){
						var size=ui.create.div('.menubutton');
						if(game.haveFun.list.snow.size=='small'){
							size.innerHTML='大雪';
						}
						else{
							size.innerHTML='小雪';
						}
						size.listen(game.haveFun.snowSize);
						return size;
					}
				},
				star:{
					name:'星云',
					cost:10
				},
				blink:{
					name:'闪烁',
					cost:10
				}
			},
			alwaysSnow:function(){
				game.saveConfig('snowFall',!lib.config.snowFall);
				game.reload();
			},
			blink:function(){
				if(game.haveFun.list.blink.running) return;
				game.haveFun.list.blink.running=true;
				if(game.haveFun.blinkLoop){
					game.haveFun.blinkLoop();
				}
				else{
					var canvas = document.createElement("canvas");
					ui.window.appendChild(canvas);
					canvas.classList.add('fun');
					canvas.style.zIndex=20;
					var ctx = canvas.getContext("2d");

					//Make the canvas occupy the full page
					var W = ui.window.offsetWidth, H = ui.window.offsetHeight;
					canvas.width = W;
					canvas.height = H;
					lib.onresize.push(function(){
						var W = ui.window.offsetWidth, H = ui.window.offsetHeight;
						canvas.width = W;
						canvas.height = H;
					});

					var particles = [];
					var mouse = {};

					//Lets create some particles now
					var particle_count = 25;


					//finally some mouse tracking
					ui.window.addEventListener('mousemove', function(e)
					{
						//since the canvas = full page the position of the mouse
						//relative to the document will suffice
						mouse.x = e.pageX;
						mouse.y = e.pageY;
					});
					ui.window.addEventListener('touchmove',function(e){
						mouse.x = e.touches[0].clientX;
						mouse.y = e.touches[0].clientY;
					});

					var particle=function()
					{
						//speed, life, location, life, colors
						//speed.x range = -2.5 to 2.5
						//speed.y range = -15 to -5 to make it move upwards
						//lets change the Y speed to make it look like a flame
						this.speed = {x: -2.5+Math.random()*5, y: -5+Math.random()*10};
						this.speed.x/=4;
						this.speed.y/=4;
						//location = mouse coordinates
						//Now the flame follows the mouse coordinates
						if(mouse.x && mouse.y)
						{
							this.location = {x: mouse.x, y: mouse.y};
						}
						else
						{
							this.location = {x: W/2, y: H/2};
						}
						//radius range = 10-30
						this.radius = 10+Math.random()*20;
						//life range = 20-30
						this.radius/=4;
						this.life = 20+Math.random()*10;
						this.life*=4;
						this.remaining_life = this.life;
						//colors
						this.r = Math.round(Math.random()*255);
						this.g = Math.round(Math.random()*255);
						this.b = Math.round(Math.random()*255);
					}
					for(var i = 0; i < particle_count; i++)
					{
						particles.push(new particle());
					}

					var draw=function()
					{
						if(!game.haveFun.list.blink.running){
							canvas.width=W;
							canvas.height=H;
							return;
						}
						ctx.clearRect(0, 0, W, H);
						//Painting the canvas black
						//Time for lighting magic
						//particles are painted with "lighter"
						//In the next frame the background is painted normally without blending to the
						//previous frame
						ctx.globalCompositeOperation = "lighter";

						for(var i = 0; i < particles.length; i++)
						{
							var p = particles[i];
							ctx.beginPath();
							//changing opacity according to the life.
							//opacity goes to 0 at the end of life of a particle
							p.opacity = Math.round(p.remaining_life/p.life*100)/100
							//a gradient instead of white fill
							var gradient = ctx.createRadialGradient(p.location.x, p.location.y, 0, p.location.x, p.location.y, p.radius);
							gradient.addColorStop(0, "rgba("+p.r+", "+p.g+", "+p.b+", "+p.opacity+")");
							gradient.addColorStop(0.5, "rgba("+p.r+", "+p.g+", "+p.b+", "+p.opacity+")");
							gradient.addColorStop(1, "rgba("+p.r+", "+p.g+", "+p.b+", 0)");
							ctx.fillStyle = gradient;
							ctx.arc(p.location.x, p.location.y, p.radius, Math.PI*2, false);
							ctx.fill();

							//lets move the particles
							p.remaining_life--;
							p.radius-=0.2;
							p.location.x += p.speed.x;
							p.location.y += p.speed.y;

							//regenerate particles
							if(p.remaining_life < 0 || p.radius < 0)
							{
								//a brand new particle replacing the dead one
								particles[i] = new particle();
							}
						}
						requestAnimationFrame(draw);
					}

					draw();
					game.haveFun.blinkLoop=draw;
					game.haveFun.blinkStop=function(){
						game.haveFun.list.blink.running=false;
					}
				}
			},
			star:function(){
				if(game.haveFun.list.star.running) return;
				game.haveFun.list.star.running=true;
				if(game.haveFun.starLoop){
					game.haveFun.starLoop();
				}
				else{
					//******************************************************
					// Yet Another Particle Engine
					var cos = Math.cos,
					    sin = Math.sin,
					    sqrt = Math.sqrt,
					    abs = Math.abs,
					    atan2 = Math.atan2,
					    log = Math.log,
					    random = Math.random,
					    PI = Math.PI,
					    sqr = function(v){return v*v;},
					    particles = [],
					    drawScale = 1,
					    emitters = [],
					    forces  = [],
					    collidedMass = 0,
					    maxParticles = 100,
					    emissionRate = 1,
						minParticleSize = 2;

					//-------------------------------------------------------
					// Vectors, and not the kind you put stuff in
					var Vector=function(x, y, z) {
					  this.x = x || 0;
					  this.y = y || 0;
					  this.z = z || 0;
					}
					Vector.prototype = {
					  add : function(vector) {
					    this.x += vector.x;
					    this.y += vector.y;
					    this.z += vector.z;
					    return this;
					  },
					  subtract : function(vector) {
					    this.x -= vector.x;
					    this.y -= vector.y;
					    this.z -= vector.z;
					    return this;
					  },
					  multiply : function(another) {
					    this.x /= another.x;
					    this.y /= another.y;
					    this.z /= another.z;
					    return this;
					  },
					  divide : function(another) {
					    this.x /= another.x;
					    this.y /= another.y;
					    this.z /= another.z;
					    return this;
					  },
					  scale : function(factor) {
					    this.x *= factor;
					    this.y *= factor;
					    this.z *= factor;
					    return this;
					  },
					  magnitude : function () {
					    return sqrt(sqr(this.x + this.y));
					  },
					  distance : function (another) {
					    return abs(sqrt(sqr(this.x - another.x) + sqr(this.y - another.y)));
					  },
					  angle : function (angle, magnitude) {
					    if(angle && magnitude)
					      return Vector.fromAngle(angle, magnitude);
					    return atan2(this.y, this.x);
					  },
					  clone : function() {
					    return new Vector(this.x, this.y, this.z);
					  },
					  equals : function(another) {
					    return this.x === another.x&&
							this.y === another.y&&
							this.z === another.z;
					  },
					  random : function(r) {
					    this.x += (random() * r * 2) - r;
					    this.y += (random() * r * 2) - r;
					    return this;
					  }
					};
					Vector.fromAngle = function (angle, magnitude) {
					  return new Vector(
					    magnitude * cos(angle),
					    magnitude * sin(angle),
					    magnitude * sin(angle));
					};

					//******************************************************
					// A thing with mass, position, and velocity - like your mom
					var Particle=function(pt, vc, ac, mass) {
					  this.pos = pt || new Vector(0, 0);
					  this.vc = vc || new Vector(0, 0);
					  this.ac = ac || new Vector(0, 0);
					  this.mass = mass || 1;
					  this.alive = true;
					}
					Particle.prototype.move = function () {
					  this.vc.add(this.ac);
					  this.pos.add(this.vc);
					};
					Particle.prototype.reactToForces = function (fields) {
					  var totalAccelerationX = 0;
					  var totalAccelerationY = 0;

					  for (var i = 0; i < fields.length; i++) {
					    var field = fields[i];
					    var vectorX = field.pos.x - this.pos.x;
					    var vectorY = field.pos.y - this.pos.y;
					    var distance = this.pos.distance(field.pos);
					    if(distance < 1) field.grow(this);
					    if(distance < 100) this.doubleSize = true;
					    var force = G(this.forceBetween(field, distance));
					    totalAccelerationX += vectorX * force;
					    totalAccelerationY += vectorY * force;
					  }
					  this.ac = new Vector(totalAccelerationX, totalAccelerationY);

					  totalAccelerationX = 0;
					  totalAccelerationY = 0;
					  for (var i = 0; i < particles.length; i++) {
					    var field = particles[i];
					    if(field === this || !field.alive) continue;
					    var vectorX = field.pos.x - this.pos.x;
					    var vectorY = field.pos.y - this.pos.y;
					    var distance = this.pos.distance(field.pos);
					    if(distance < 1) {
					      if(this.mass >= field.mass) {
					        var massRatio = this.mass / field.mass;
					        if(particles.length <= maxParticles && this.mass>40) {
					          this.alive = false;
					          this.nova = true;
					          collidedMass += this.mass;
					        } else this.grow(field);
					      } else this.alive = false;
					    }
					    if(this.alive) {
					      var force = G(this.forceBetween(field, distance));
					      totalAccelerationX += vectorX * G(force);
					      totalAccelerationY += vectorY * G(force);
					    }
					  }

					  var travelDist = this.pos.distance(this.lastPos ? this.lastPos : this.pos);
					  this.velocity = travelDist - (this.lastDistance ? this.lastDistance : travelDist);
					  this.lastDistance = travelDist;
					  this.lastPos = this.pos.clone();

					  this.ac.add(new Vector(totalAccelerationX, totalAccelerationY));
					  this.lastPos = this.pos.clone();
					  // if(this.mass > 20) {
					  //   var chance = 1 / (this.mass - 20);
					  //   if(Math.random()>chance) {
					  //     this.supernova = true;
					  //     this.supernovaDur = 10;
					  //     this.alive = false;
					  //     if(particles.length <= maxParticles) collidedMass += this.mass;
					  //     delete this.size;
					  //   }
					  // }
					};
					Particle.prototype.grow = function (another) {
					  this.mass += another.mass;
					  this.nova = true;
					  another.alive = false;
					  delete this.size;
					};
					Particle.prototype.breakApart = function(minMass, maxParts) {
					  if(!minMass) minMass = 1;
					  if(!maxParts) maxParts = 2;
					  var remainingMass = this.mass;
					  var num = 0;
					  while(remainingMass > 0) {
					    var np = new Particle(this.pos.clone().random(this.mass), new Vector(0,0));
					    np.mass = 1 + Math.random() * (remainingMass - 1);
					    if(num>=maxParts-1) np.mass = remainingMass;
					    np.mass = np.mass < minMass ? minMass : np.mass;
					    remainingMass -= np.mass;
					    num++;
					  }
					  this.nova = true;
					  delete this.size;
					  this.alive = false;
					};
					Particle.prototype.forceBetween = function(another, distance) {
					  var distance = distance? distance : this.pos.distance(another.pos);
					  return (this.mass * another.mass) / sqr(distance);
					};

					//******************************************************
					//This certainly doesn't *sub*mit to particles, that's for sure
					var ParticleEmitter=function(pos, vc, ang) {
					  // to do config options for emitter - random, static, show emitter, emitter color, etc
					  this.pos = pos;
					  this.vc = vc;
					  this.ang = ang || 0.09;
					  this.color = "#999";
					}
					ParticleEmitter.prototype.emit = function() {
					  var angle = this.vc.angle() +
					      this.ang - (Math.random() * this.ang * 2);
					  var magnitude = this.vc.magnitude();
					  var position = this.pos.clone();
					        position.add(
					        new Vector(
					          ~~((Math.random() * 100) - 50) * drawScale,
					          ~~((Math.random() * 100) - 50) * drawScale
					        ));
					  var velocity = Vector.fromAngle(angle, magnitude);
					  return new Particle(position,velocity);
					};

					//******************************************************
					// Use it, Luke
					// to do collapse functionality into particle
					var Force=function(pos, m) {
					  this.pos = pos;
					  this.mass = m || 100;
					}
					Force.prototype.grow = function (another) {
					  this.mass += another.mass;
					  this.burp = true;
					  another.alive = false;
					};



					var G=function(data) {
					  return 0.00674 * data;
					}

					//******************************************************
					var canvas = document.createElement('canvas');
					canvas.classList.add('fun');
					ui.window.appendChild(canvas);
					var ctx = canvas.getContext('2d');
					canvas.width = ui.window.offsetWidth;
					canvas.height = ui.window.offsetHeight;
					var canvasWidth = canvas.width;
					var canvasHeight = canvas.height;
					lib.onresize.push(function() {
						canvas.width = ui.window.offsetWidth;
						canvas.height = ui.window.offsetHeight;
						canvasWidth = canvas.width;
						canvasHeight = canvas.height;
					});

					var renderToCanvas = function (width, height, renderFunction) {
					    var buffer = document.createElement('canvas');
					    buffer.width = width;
					    buffer.height = height;
					    renderFunction(buffer.getContext('2d'));
					    return buffer;
					};

					maxParticles = 500;
					emissionRate = 1;
					drawScale = 1.3;
					minParticleSize = 2;
					emitters = [
					  //br
					  new ParticleEmitter(
					    new Vector(
					      canvasWidth / 2 * drawScale + 400,
					      canvasHeight / 2 * drawScale
					      ),
					    Vector.fromAngle(2, 5),
					    1
					  ),
					  //   // bl
					  //   new ParticleEmitter(
					  //   new Vector(
					  //     canvasWidth / 2 * drawScale - 400,
					  //     canvasHeight / 2 * drawScale + 400
					  //     ),
					  //   Vector.fromAngle(1.5, 1),
					  //   1
					  // ),
					    // tl
					  new ParticleEmitter(
					    new Vector(
					      canvasWidth / 2 * drawScale - 400,
					      canvasHeight / 2 * drawScale
					      ),
					    Vector.fromAngle(5, 5),
					    1
					  ),
					  //   // tr
					  //   new ParticleEmitter(
					  //   new Vector(
					  //     canvasWidth / 2 * drawScale + 400,
					  //     canvasHeight / 2 * drawScale - 400
					  //     ),
					  //   Vector.fromAngle(4.5, 1),
					  //   1
					  // )
					];
					forces  = [
					  new Force(
					    new Vector((canvasWidth / 2 * drawScale) ,
					               (canvasHeight / 2 * drawScale)), 1800)
					];

					var loop=function() {
						if(!game.haveFun.list.star.running){
							canvas.width=ui.window.offsetWidth;
							canvas.height=ui.window.offsetHeight;
							return;
						}
						clear();
						update();
						draw();
						queue();
					}
					game.haveFun.starLoop=loop;
					game.haveFun.starStop=function(){
						game.haveFun.list.star.running=false;
					};


					var clear=function() {
					  ctx.clearRect(0, 0, canvas.width, canvas.height);
					}

					var ctr = 0;
					var c = [
					  'rgba(255,255,255,',
					  'rgba(0,150,255,',
					  'rgba(255,255,128,',
					  'rgba(255,255,255,'
					];
					var rndc=function() {
					  return c[~~(Math.random() * c.length-1)];
					}
					var c2 = 'rgba(255,64,32,';
					var addNewParticles=function() {
					  var _emit = function() {
					    var ret = 0;
					    for (var i = 0; i < emitters.length; i++) {
					      for (var j = 0; j < emissionRate; j++) {
					        var p = emitters[i].emit();
					        p.color = ( ctr % 10 === 0 )?
							  ( Math.random() * 5 <= 1 ? c2 : rndc() )
					          : rndc();
					        p.mass = ~~(Math.random() * 5);
					        particles.push(p);
					        ret += p.mass;
					        ctr++;
					      }
					    }
					    return ret;
					  };
					  if(collidedMass !== 0) {
					    while(collidedMass !== 0) {
					      collidedMass -= _emit();
					      collidedMass = collidedMass<0 ? 0 :collidedMass;
					    }
					  }
					  if (particles.length > maxParticles)
					    return;
					  _emit();
					}

					var CLIPOFFSCREEN = 1,
					    BUFFEROFFSCREEN = 2,
					    LOOPSCREEN = 3;

					var isPositionAliveAndAdjust=function(particle,check) {
					  return true;
					//   var pos = particle.pos;
					//   if(!check) check = BUFFEROFFSCREEN;
					//   if(check === CLIPOFFSCREEN) {
					//     return !(!particle.alive ||
					//              pos.x < 0 ||
					//              (pos.x / drawScale) > boundsX ||
					//              pos.y < 0 ||
					//              (pos.y / drawScale) > boundsY);
					//   } else if(check === BUFFEROFFSCREEN) {
					//     return !(!particle.alive ||
					//              pos.x < -boundsX * drawScale ||
					//              pos.x > 2 * boundsX * drawScale ||
					//              pos.y < -boundsY * drawScale ||
					//              pos.y > 2 * boundsY * drawScale);
					//   } else if(check === LOOPSCREEN) {
					//     if (pos.x < 0) pos.x = boundsX * drawScale;
					//     if ((pos.x / drawScale) > boundsX) pos.x = 0;
					//     if (pos.y < 0) pos.y = boundsY * drawScale;
					//     if ((pos.y / drawScale) > boundsY) pos.y = 0;
					//     return true;
					//   }
					}

					var plotParticles=function(boundsX, boundsY) {
					  var currentParticles = [];
					  for (var i = 0; i < particles.length; i++) {
					    var particle = particles[i];
					    particle.reactToForces(forces);
					    if(!isPositionAliveAndAdjust(particle))
					      continue;
					    particle.move();
					    currentParticles.push(particle);
					  }
					}

					var offscreenCache = {};
					var renderParticle=function(p) {
					    var position = p.pos;
					    if(!p.size) p.size = Math.floor(p.mass / 100);


					    if(!p.opacity) p.opacity = 0.05;
					    if(p.velocity > 0) {
					      if(p.opacity<=0.18)
					        p.opacity += 0.04;
					    }
					      if(p.opacity>0.08)
					        p.opacity -= 0.02;

					    var actualSize = p.size / drawScale;
					    actualSize = actualSize < minParticleSize ? minParticleSize : actualSize;
					    if(p.mass>8) actualSize *= 2;
					    if(p.nova) {
					      actualSize *= 4;
					      p.nova = false;
					    }
					    if(p.doubleSize) {
					      p.doubleSize = false;
					      actualSize *= 2;
					    }
					    // if(p.supernova) {
					    //   actualSize *= 6;
					    //   opacity = 0.15;
					    //   p.supernovaDur = p.supernovaDur - 1;
					    //   if(p.supernovaDur === 0)
					    //     p.supernova = false;
					    // }
					    var cacheKey = actualSize + '_' + p.opacity + '_' + p.color;
					    var cacheValue = offscreenCache[cacheKey];
					    if(!cacheValue) {
					      cacheValue = renderToCanvas(actualSize * 32, actualSize * 32, function(ofsContext) {
					        var opacity = p.opacity;
					        var fills = [
					          {size:actualSize/2,  opacity:1},
					          {size:actualSize,  opacity:opacity},
					          {size:actualSize * 2, opacity:opacity / 2},
					          {size:actualSize * 4, opacity:opacity / 3},
					          {size:actualSize * 8, opacity:opacity / 5},
					          {size:actualSize * 16, opacity:opacity / 16}
					        ];
					        ofsContext.beginPath();
					        for(var f in fills) {
					          f = fills[f];
					          ofsContext.fillStyle = p.color + f.opacity + ')';
					          ofsContext.arc(
					            actualSize * 16,
					            actualSize * 16,
					            f.size , 0, Math.PI*2, true);
					          ofsContext.fill();
					        }
					        ofsContext.closePath();
					      });
					      offscreenCache[cacheKey] = cacheValue;
					    }
					      var posX = p.pos.x / drawScale;
					    var posY = p.pos.y / drawScale;
					    ctx.drawImage(cacheValue, posX, posY);
					}

					var fills = [
					  {size:15,opacity:1  },
					  {size:25,opacity:0.3},
					  {size:50,opacity:0.1} ];

					var renderScene=function(ofsContext) {
					  for (var i = 0; i < forces.length; i++) {
					    var p = forces[i];
					    var position = p.pos;
					    var opacity = 1;

					    ofsContext.beginPath();
					    for(var f in fills) {
					      f = fills[f];
					      var o = p.burp === true ? 1 : f.opacity;
					      p.burp = false;
					      // ofsContext.fillStyle = 'rgba(255,255,255,' + o + ')';
					      // ofsContext.arc(position.x / drawScale,
					      //   position.y / drawScale,
					      //   f.size / drawScale, 0, Math.PI*2, true);
					      // ofsContext.fill();
					    }
					    ofsContext.closePath();
					  }

					  for (var i = 0; i < particles.length; i++) {
					    var p = particles[i];
					    renderParticle(p);
					  }
					}

					var draw=function() {
					  renderScene(ctx);
					}

					var update=function() {
					  addNewParticles();
					  plotParticles(canvas.width, canvas.height);
					}

					var queue=function() {
					  window.requestAnimationFrame(loop);
					}

					loop();

				}
			},
			snow:function(){
				game.haveFun.list.snow.running=true;
				if(game.haveFun.snowStart){
					game.haveFun.snowStart();
				}
				else{
					/*
					* 自由下雪 snowFall
					* author：xuanfeng
					* time: 2014-01-11
					*/
					// 控制下雪
					var canvas;
					var snowFall=function(snow) {
						// 可配置属性
						snow = snow || {};
						this.maxFlake = snow.maxFlake || 200;	//最多片数
						this.flakeSize = snow.flakeSize || 10;	//雪花形状
						this.fallSpeed = snow.fallSpeed || 2;	//坠落速度
						this.status = 0;	//0-初始化、1-开始下雪、2-停止下雪、3-暂停下雪、4-继续下雪
					}

					// 兼容写法
					var requestAnimationFrame = window.requestAnimationFrame ||
											window.mozRequestAnimationFrame ||
											window.webkitRequestAnimationFrame ||
											window.msRequestAnimationFrame ||
											window.oRequestAnimationFrame ||
											function(callback) { setTimeout(callback, 1000 / 60); };
					var cancelAnimationFrame = window.cancelAnimationFrame ||
											window.mozCancelAnimationFrame ||
											window.webkitCancelAnimationFrame ||
											window.msCancelAnimationFrame ||
											window.oCancelAnimationFrame;

					// 开始下雪
					snowFall.prototype.start = function(){
						if(this.status == 1 || this.status == 4){
							// 已经在下雪则不作处理
							return false;
						}
						this.status = 1;

						// 创建画布
						snowCanvas.apply(this);
						// 创建雪花形状
						createFlakes.apply(this);
						// 画雪
						drawSnow.apply(this)
					}

					// 停止下雪
					snowFall.prototype.stop = function(){
						if(this.status == 2 || this.status == 0 || !this.canvas){
							return false;
						}
						// 停止动画循环
						this.pause();
						this.status = 2;
						// 删除画布
						this.canvas.parentNode.removeChild(this.canvas);
						this.canvas = null;
					}

					// 暂停下雪
					snowFall.prototype.pause = function(){
						if(this.status == 3){
							return false;
						}
						this.status = 3;
						cancelAnimationFrame(this.loop)
					};
					// 继续下雪
					snowFall.prototype.resume = function(){
						if(this.status == 3 && this.canvas){
							this.status = 4;
							// 动画的计时控制
							var that=this;
							this.loop = requestAnimationFrame(function() {
								drawSnow.apply(that)
							});
						}
					};

					// 创建画布
					var snowCanvas=function() {
						// 添加Dom结点
						var snowcanvas = document.createElement("canvas");
						snowcanvas.classList.add('fun');
						snowcanvas.id = "snowfall";
						ui.window.appendChild(snowcanvas);
						canvas=snowcanvas;
						this.canvas = snowcanvas;
						this.ctx = snowcanvas.getContext("2d");
						// 窗口大小改变的处理
						lib.onresize.push(function() {
							snowcanvas.width = ui.window.offsetWidth;
							snowcanvas.height = ui.window.offsetHeight
						});
						snowcanvas.width = ui.window.offsetWidth;
						snowcanvas.height = ui.window.offsetHeight;
					}

					// 雪运动对象
					var flakeMove=function(canvasWidth, canvasHeight, flakeSize, fallSpeed) {
						this.x = Math.floor(Math.random() * canvasWidth); 	//x坐标
						this.y = Math.floor(Math.random() * canvasHeight);	//y坐标
						this.size = Math.random() * flakeSize + 2;			//形状
						this.maxSize = flakeSize;							 //最大形状
						this.speed = Math.random() * 1 + fallSpeed;		      //坠落速度
						this.fallSpeed = fallSpeed;						  //坠落速度
						this.velY = this.speed;							  //Y方向速度
						this.velX = 0;									    //X方向速度
						this.stepSize = Math.random() / 30;				    //步长
						this.step = 0 									    //步数
					}

					flakeMove.prototype.update = function() {
						var x = this.x,
						    y = this.y;

						// 左右摆动(余弦)
						this.velX *= 0.98;
						if (this.velY <= this.speed) {
							this.velY = this.speed
						}
						this.velX += Math.cos(this.step += 0.05) * this.stepSize;

						this.y += this.velY;
						this.x += this.velX;
						// 飞出边界的处理
						if (this.x >= canvas.width || this.x <= 0 || this.y >= canvas.height || this.y <= 0) {
							this.reset(canvas.width, canvas.height)
						}
					};

					// 飞出边界-放置最顶端继续坠落
					flakeMove.prototype.reset = function(width, height) {
						this.x = Math.floor(Math.random() * width);
						this.y = 0;
						this.size = Math.random() * snow.flakeSize + 2;
						this.speed = Math.random() * 1 + snow.fallSpeed;
						this.velY = this.speed;
						this.velX = 0;
					};

					// 渲染雪花-随机形状
					flakeMove.prototype.render = function(ctx) {
						var snowFlake = ctx.createRadialGradient(this.x, this.y, 0, this.x, this.y, this.size);
						snowFlake.addColorStop(0, "rgba(255, 255, 255, 0.9)");
						snowFlake.addColorStop(0.5, "rgba(255, 255, 255, 0.5)");
						snowFlake.addColorStop(1, "rgba(255, 255, 255, 0)");
						ctx.save();
						ctx.fillStyle = snowFlake;
						ctx.beginPath();
						ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
						ctx.fill();
						ctx.restore();
					};

					// 创建雪花-定义形状
					var createFlakes=function() {
						var maxFlake = this.maxFlake,
							flakes = this.flakes = [],
							canvas = this.canvas;
						for (var i = 0; i < 200; i++) {
							flakes.push(new flakeMove(canvas.width, canvas.height, this.flakeSize, this.fallSpeed))
						}
					}

					// 画雪
					var drawSnow=function() {
						var maxFlake = this.maxFlake,
							flakes = this.flakes;
						var ctx = this.ctx, canvas = this.canvas, that = this;
						// 清空雪花
						ctx.clearRect(0, 0, canvas.width, canvas.height);
						for (var e = 0; e < maxFlake; e++) {
							flakes[e].update();
							flakes[e].render(ctx);
						}
						// 一帧一帧的画
						this.loop = requestAnimationFrame(function() {
							drawSnow.apply(that);
						});
					}

					// 调用及控制方法
					var snow = new snowFall();
					game.haveFun.snowStart=function(){
						snow.start();
					}
					game.haveFun.snowStop=function(){
						game.haveFun.list.snow.running=false;
						snow.stop();
					}
					game.haveFun.snowSize=function(){
						if(game.haveFun.list.snow.size=='large'){
							game.haveFun.list.snow.size='small';
							snow.maxFlake=80;
							snow.flakeSize=3;
							snow.fallSpeed=1;
							if(this&&this.innerHTML){
								this.innerHTML='大雪';
							}
							game.saveConfig('coinSnowSize',true);
						}
						else{
							game.haveFun.list.snow.size='large';
							snow.maxFlake=200;
							snow.flakeSize=10;
							snow.fallSpeed=2;
							if(this&&this.innerHTML){
								this.innerHTML='小雪';
							}
							game.saveConfig('coinSnowSize',false);
						}
					}
					if(lib.config.coinSnowSize){
						game.haveFun.snowSize();
					}
					snow.start();
				}
			},
			firework:function(){
				if(game.haveFun.list.firework.running) return;
				game.haveFun.list.firework.running=true;
				if(game.haveFun.fireworkLoop){
					game.haveFun.fireworkLoop();
				}
				else{
					// when animating on canvas, it is best to use requestAnimationFrame instead of setTimeout or setInterval
					// not supported in all browsers though and sometimes needs a prefix, so we need a shim
					var requestAnimFrame = ( function() {
						return window.requestAnimationFrame ||
									window.webkitRequestAnimationFrame ||
									window.mozRequestAnimationFrame ||
									function( callback ) {
										window.setTimeout( callback, 1000 / 60 );
									};
					})();

					// now we will setup our basic variables for the demo
					var canvas = document.createElement( 'canvas' ),
							ctx = canvas.getContext( '2d' ),
							// full screen dimensions
							cw = ui.window.offsetWidth,
							ch = ui.window.offsetHeight,
							// firework collection
							fireworks = [],
							// particle collection
							particles = [],
							// starting hue
							hue = 120,
							// when launching fireworks with a click, too many get launched at once without a limiter, one launch per 5 loop ticks
							limiterTotal = 5,
							limiterTick = 0,
							// this will time the auto launches of fireworks, one launch per 80 loop ticks
							timerTotal = 80,
							timerTick = 0,
							mousedown = false,
							// mouse x coordinate,
							mx,
							// mouse y coordinate
							my;

					// set canvas dimensions
					canvas.width = cw;
					canvas.height = ch;
					ui.window.appendChild(canvas);
					canvas.classList.add('fun');
					lib.onresize.push(function(){
						cw=ui.window.offsetWidth;
						ch=ui.window.offsetHeight;
						canvas.width = cw;
						canvas.height = ch;
					});

					// now we are going to setup our function placeholders for the entire demo

					// get a random number within a range
					var random=function( min, max ) {
						return Math.random() * ( max - min ) + min;
					}

					// calculate the distance between two points
					var calculateDistance=function( p1x, p1y, p2x, p2y ) {
						var xDistance = p1x - p2x,
								yDistance = p1y - p2y;
						return Math.sqrt( Math.pow( xDistance, 2 ) + Math.pow( yDistance, 2 ) );
					}

					// create firework
					var Firework=function( sx, sy, tx, ty ) {
						// actual coordinates
						this.x = sx;
						this.y = sy;
						// starting coordinates
						this.sx = sx;
						this.sy = sy;
						// target coordinates
						this.tx = tx;
						this.ty = ty;
						// distance from starting point to target
						this.distanceToTarget = calculateDistance( sx, sy, tx, ty );
						this.distanceTraveled = 0;
						// track the past coordinates of each firework to create a trail effect, increase the coordinate count to create more prominent trails
						this.coordinates = [];
						this.coordinateCount = 3;
						// populate initial coordinate collection with the current coordinates
						while( this.coordinateCount-- ) {
							this.coordinates.push( [ this.x, this.y ] );
						}
						this.angle = Math.atan2( ty - sy, tx - sx );
						this.speed = 2;
						this.acceleration = 1.05;
						this.brightness = random( 50, 70 );
						// circle target indicator radius
						this.targetRadius = 1;
					}

					// update firework
					Firework.prototype.update = function( index ) {
						// remove last item in coordinates array
						this.coordinates.pop();
						// add current coordinates to the start of the array
						this.coordinates.unshift( [ this.x, this.y ] );

						// cycle the circle target indicator radius
						if( this.targetRadius < 8 ) {
							this.targetRadius += 0.3;
						} else {
							this.targetRadius = 1;
						}

						// speed up the firework
						this.speed *= this.acceleration;

						// get the current velocities based on angle and speed
						var vx = Math.cos( this.angle ) * this.speed,
								vy = Math.sin( this.angle ) * this.speed;
						// how far will the firework have traveled with velocities applied?
						this.distanceTraveled = calculateDistance( this.sx, this.sy, this.x + vx, this.y + vy );

						// if the distance traveled, including velocities, is greater than the initial distance to the target, then the target has been reached
						if( this.distanceTraveled >= this.distanceToTarget ) {
							createParticles( this.tx, this.ty );
							// remove the firework, use the index passed into the update function to determine which to remove
							fireworks.splice( index, 1 );
						} else {
							// target not reached, keep traveling
							this.x += vx;
							this.y += vy;
						}
					}

					// draw firework
					Firework.prototype.draw = function() {
						ctx.beginPath();
						// move to the last tracked coordinate in the set, then draw a line to the current x and y
						ctx.moveTo( this.coordinates[ this.coordinates.length - 1][ 0 ], this.coordinates[ this.coordinates.length - 1][ 1 ] );
						ctx.lineTo( this.x, this.y );
						ctx.strokeStyle = 'hsl(' + hue + ', 100%, ' + this.brightness + '%)';
						ctx.stroke();

						ctx.beginPath();
						// draw the target for this firework with a pulsing circle
						ctx.arc( this.tx, this.ty, this.targetRadius, 0, Math.PI * 2 );
						ctx.stroke();
					}

					// create particle
					var Particle=function( x, y ) {
						this.x = x;
						this.y = y;
						// track the past coordinates of each particle to create a trail effect, increase the coordinate count to create more prominent trails
						this.coordinates = [];
						this.coordinateCount = 5;
						while( this.coordinateCount-- ) {
							this.coordinates.push( [ this.x, this.y ] );
						}
						// set a random angle in all possible directions, in radians
						this.angle = random( 0, Math.PI * 2 );
						this.speed = random( 1, 10 );
						// friction will slow the particle down
						this.friction = 0.95;
						// gravity will be applied and pull the particle down
						this.gravity = 1;
						// set the hue to a random number +-20 of the overall hue variable
						this.hue = random( hue - 20, hue + 20 );
						this.brightness = random( 50, 80 );
						this.alpha = 1;
						// set how fast the particle fades out
						this.decay = random( 0.015, 0.03 );
					}

					// update particle
					Particle.prototype.update = function( index ) {
						// remove last item in coordinates array
						this.coordinates.pop();
						// add current coordinates to the start of the array
						this.coordinates.unshift( [ this.x, this.y ] );
						// slow down the particle
						this.speed *= this.friction;
						// apply velocity
						this.x += Math.cos( this.angle ) * this.speed;
						this.y += Math.sin( this.angle ) * this.speed + this.gravity;
						// fade out the particle
						this.alpha -= this.decay;

						// remove the particle once the alpha is low enough, based on the passed in index
						if( this.alpha <= this.decay ) {
							particles.splice( index, 1 );
						}
					}

					// draw particle
					Particle.prototype.draw = function() {
						ctx. beginPath();
						// move to the last tracked coordinates in the set, then draw a line to the current x and y
						ctx.moveTo( this.coordinates[ this.coordinates.length - 1 ][ 0 ], this.coordinates[ this.coordinates.length - 1 ][ 1 ] );
						ctx.lineTo( this.x, this.y );
						ctx.strokeStyle = 'hsla(' + this.hue + ', 100%, ' + this.brightness + '%, ' + this.alpha + ')';
						ctx.stroke();
					}

					// create particle group/explosion
					var createParticles=function( x, y ) {
						// increase the particle count for a bigger explosion, beware of the canvas performance hit with the increased particles though
						var particleCount = 30;
						while( particleCount-- ) {
							particles.push( new Particle( x, y ) );
						}
					}

					// main demo loop
					var loop=function() {
						// if(lib.config.coin_free_playpackconfig&&!_status.imchoosing){
						// 	canvas.style.display='none';
						// }
						// else{
						// 	canvas.style.display='';
						// }
						// this function will run endlessly with requestAnimationFrame
						if(!game.haveFun.list.firework.running){
							canvas.width=cw;
							canvas.height=ch;
							return;
						}
						else{
							requestAnimFrame( loop );
						}

						// increase the hue to get different colored fireworks over time
						hue += 0.5;

						// normally, clearRect() would be used to clear the canvas
						// we want to create a trailing effect though
						// setting the composite operation to destination-out will allow us to clear the canvas at a specific opacity, rather than wiping it entirely
						ctx.globalCompositeOperation = 'destination-out';
						// decrease the alpha property to create more prominent trails
						ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
						ctx.fillRect( 0, 0, cw, ch );
						// change the composite operation back to our main mode
						// lighter creates bright highlight points as the fireworks and particles overlap each other
						ctx.globalCompositeOperation = 'lighter';

						// loop over each firework, draw it, update it
						var i = fireworks.length;
						while( i-- ) {
							fireworks[ i ].draw();
							fireworks[ i ].update( i );
						}

						// loop over each particle, draw it, update it
						var i = particles.length;
						while( i-- ) {
							particles[ i ].draw();
							particles[ i ].update( i );
						}

						// launch fireworks automatically to random coordinates, when the mouse isn't down
						if( timerTick >= timerTotal ) {
							if( !mousedown ) {
								// start the firework at the bottom middle of the screen, then set the random target coordinates, the random y coordinates will be set within the range of the top half of the screen
								fireworks.push( new Firework( cw / 2, ch, random( 0, cw ), random( 0, ch / 2 ) ) );
								timerTick = 0;
							}
						} else {
							timerTick++;
						}

						// limit the rate at which fireworks get launched when mouse is down
						if( limiterTick >= limiterTotal ) {
							if( mousedown ) {
								// start the firework at the bottom middle of the screen, then set the current mouse coordinates as the target
								fireworks.push( new Firework( cw / 2, ch, mx, my ) );
								limiterTick = 0;
							}
						} else {
							limiterTick++;
						}
					}


					if(lib.config.touchscreen){
						ui.window.addEventListener( 'touchmove', function( e ) {
							mx = e.touches[0].clientX - canvas.offsetLeft;
							my = e.touches[0].clientY - canvas.offsetTop;
						});
						ui.window.addEventListener( 'touchstart', function( e ) {
							mousedown = true;
						});
						ui.window.addEventListener( 'touchend', function( e ) {
							mousedown = false;
						});
					}
					else{
						// mouse event bindings
						// update the mouse coordinates on mousemove
						ui.window.addEventListener( 'mousemove', function( e ) {
							mx = e.pageX - canvas.offsetLeft;
							my = e.pageY - canvas.offsetTop;
						});

						// toggle mousedown state and prevent canvas from being selected
						ui.window.addEventListener( 'mousedown', function( e ) {
							e.preventDefault();
							mousedown = true;
						});

						ui.window.addEventListener( 'mouseup', function( e ) {
							e.preventDefault();
							mousedown = false;
						});
					}

					// once the window loads, we are ready for some fireworks!
					game.haveFun.fireworkLoop=loop;
					game.haveFun.fireworkStop=function(){
						game.haveFun.list.firework.running=false;
					},
					loop();
				}
			}
		}
	},
	help:{
		'富甲天下':'<ul><li>每完成一次对局，可获得一定数量的金币'+
		'<li>战斗胜利可额外获得20金币，每杀死一个敌人可获得10金币（托管无效）'+
		'<li>使用的武将越强，获得的金币数越少'+
		'<li>执行以下操作时，将扣除金币：<ul><li>作弊：20金币<li>换将卡：3金币<li>'+
		'自由选将：10金币<li>手气卡：3金币<li>换人：10金币</ul>'+
		'<li>金币可用于购买烟花等游戏特效（点击右上角的金币按钮）'
	}
}