noname/extension/coin/extension.js

import { lib, game, ui, get, ai, _status } from "../../noname.js";
game.import("play", function () {
	return {
		name: "coin",
		init: function () {
			if (
				lib.config.mode != "chess" ||
				get.config("chess_mode") != "leader"
			) {
				_status.coin = 0;
			}
		},
		arenaReady: function () {
			if (_status.video || _status.connectMode) 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 && !game.online) {
							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 / game.documentZoom;
							mouse.y = e.pageY / game.documentZoom;
						});
						ui.window.addEventListener("touchmove", function (e) {
							mouse.x = e.touches[0].clientX / game.documentZoom;
							mouse.y = e.touches[0].clientY / game.documentZoom;
						});

						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 /
											game.documentZoom -
										canvas.offsetLeft;
									my =
										e.touches[0].clientY /
											game.documentZoom -
										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 / game.documentZoom -
										canvas.offsetLeft;
									my =
										e.pageY / game.documentZoom -
										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>金币可用于购买烟花等游戏特效（点击右上角的金币按钮）" +
				"<li>修改金币：<br>game.changCoin" +
				"<li>默认下雪：<br>game.haveFun.alwaysSnow",
		},
	};
});