棒打疯猫^^

欢迎来到程序小院

棒打疯猫

玩法：点击鼠标左键举起棒子打猫，等猫落下之后打，打飞猫遇到炸弹会弹飞更远距离，
遇到大便会停止前进游戏结束，看你能够打飞多远距离，快去打猫吧^^。

开始游戏https://www.ormcc.com/play/gameStart/232

html

css

canvas{
  position:absolute;	
  left:0;	
  top:0;	
  width:640;	
  height:960;	 	
  -ms-interpolation-mode:nearest-neighbor;	 	
  -webkit-transform:scale3d(1,1,1);	
  z-index:1;
}

js

var c, d, e, a = this,
  b = b || {};
 for (b.WEBGL_RENDERER = 0, b.CANVAS_RENDERER = 1, b.VERSION = "v1.6.1", b.blendModes = {
   NORMAL: 0,
   ADD: 1,
   MULTIPLY: 2,
   SCREEN: 3,
   OVERLAY: 4,
   DARKEN: 5,
   LIGHTEN: 6,
   COLOR_DODGE: 7,
   COLOR_BURN: 8,
   HARD_LIGHT: 9,
   SOFT_LIGHT: 10,
   DIFFERENCE: 11,
   EXCLUSION: 12,
   HUE: 13,
   SATURATION: 14,
   COLOR: 15,
   LUMINOSITY: 16
  }, b.scaleModes = {
   DEFAULT: 0,
   LINEAR: 0,
   NEAREST: 1
  }, b._UID = 0, "undefined" != typeof Float32Array ? (b.Float32Array = Float32Array,
    b.Uint16Array = Uint16Array) : (b.Float32Array = Array, b.Uint16Array = Array), 
    b.INTERACTION_FREQUENCY = 30, b.AUTO_PREVENT_DEFAULT = !0, b.RAD_TO_DEG = 180 
    / Math.PI, b.DEG_TO_RAD = Math.PI / 180, b.dontSayHello = !1, b.sayHello = 
    function(a) {
   if (!b.dontSayHello) {
    if (navigator.userAgent.toLowerCase().indexOf("chrome") > -1) {
     var c = ["%c %c %c Pixi.js " + b.VERSION + " - " + a + "  %c " + " %c " + 
          " http://www.pixijs.com/  %c %c ♥%c♥%c♥ ", "background: #ff66a5", 
          "background: #ff66a5", "color: #ff66a5; background: #030307;", 
          "background: #ff66a5", "background: #ffc3dc", "background: #ff66a5", 
          "color: #ff2424; background: #fff", "color: #ff2424; background: #fff",
          "color: #ff2424; background: #fff"];
     console.log.apply(console, c)
    } else window["console"] && console.log("Pixi.js " + b.VERSION + " - 
        http://www.pixijs.com/");
    b.dontSayHello = !0
   }
  }, b.Point = function(a, b) {
   this.x = a || 0, this.y = b || 0
  }, b.Point.prototype.clone = function() {
   return new b.Point(this.x, this.y)
  }, b.Point.prototype.set = function(a, b) {
   this.x = a || 0, this.y = b || (0 !== b ? this.x : 0)
  }, b.Point.prototype.constructor = b.Point, b.Rectangle = function(a, b, c, d) {
   this.x = a || 0, this.y = b || 0, this.width = c || 0, this.height = d || 0
  }, b.Rectangle.prototype.clone = function() {
   return new b.Rectangle(this.x, this.y, this.width, this.height)
  }, b.Rectangle.prototype.contains = function(a, b) {
   var c, d;
   return this.width <= 0 || this.height <= 0 ? !1 : (c = this.x, a >= c && a <= 
      c + this.width && (d = this.y, b >= d && b <= d + this.height) ? !0 : !1)
  }, b.Rectangle.prototype.constructor = b.Rectangle, b.EmptyRectangle = 
    new b.Rectangle(0, 0, 0, 0), b.Polygon = function(a) {
   var c, d, e;
   if (a instanceof Array || (a = Array.prototype.slice.call(arguments)), 
      "number" == typeof a[0]) {
    for (c = [], d = 0, e = a.length; e > d; d += 2) 
        c.push(new b.Point(a[d], a[d + 1]));
    a = c
   }
   this.points = a
  }, b.Polygon.prototype.clone = function() {
   var c, a = [];
   for (c = 0; c < this.points.length; c++) a.push(this.points[c].clone());
   return new b.Polygon(a)
  }, b.Polygon.prototype.contains = function(a, b) {
   var d, e, f, g, h, i, j, c = !1;
   for (d = 0, e = this.points.length - 1; d < this.points.length; e = d++) 
      f = this.points[d].x, g = this.points[d].y, h = this.points[e].x, 
      i = this.points[e].y, j = g > b != i > b && (h - f) * (b - g) / 
      (i - g) + f > a, j && (c = !c);
   return c
  }, b.Polygon.prototype.constructor = b.Polygon, b.Circle = function(a, b, c) {
   this.x = a || 0, this.y = b || 0, this.radius = c || 0
  }, b.Circle.prototype.clone = function() {
   return new b.Circle(this.x, this.y, this.radius)
  }, b.Circle.prototype.contains = function(a, b) {
   if (this.radius <= 0) return !1;
   var c = this.x - a,
    d = this.y - b,
    e = this.radius * this.radius;
   return c *= c, d *= d, e >= c + d
  }, b.Circle.prototype.getBounds = function() {
   return new b.Rectangle(this.x - this.radius, this.y - this.radius, 
      this.width, this.height)
  }, b.Circle.prototype.constructor = b.Circle, b.Ellipse = function(a, b, c, d) {
   this.x = a || 0, this.y = b || 0, this.width = c || 0, this.height = d || 0
  }, b.Ellipse.prototype.clone = function() {
   return new b.Ellipse(this.x, this.y, this.width, this.height)
  }, b.Ellipse.prototype.contains = function(a, b) {
   if (this.width <= 0 || this.height <= 0) return !1;
   var c = (a - this.x) / this.width,
    d = (b - this.y) / this.height;
   return c *= c, d *= d, 1 >= c + d
  }, b.Ellipse.prototype.getBounds = function() {
   return new b.Rectangle(this.x - this.width, this.y - this.height, this.width,
      this.height)
  }, b.Ellipse.prototype.constructor = b.Ellipse, b.Matrix = function() {
   this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.tx = 0, this.ty = 0
  }, b.Matrix.prototype.fromArray = function(a) {
   this.a = a[0], this.b = a[1], this.c = a[3], this.d = a[4], this.tx = a[2], 
      this.ty = a[5]
  }, b.Matrix.prototype.toArray = function(a) {
   this.array || (this.array = new Float32Array(9));
   var b = this.array;
   return a ? (b[0] = this.a, b[1] = this.c, b[2] = 0, b[3] = this.b, b[4] = 
      this.d, b[5] = 0, b[6] = this.tx, b[7] = this.ty, b[8] = 1) : (b[0] = 
      this.a, b[1] = this.b, b[2] = this.tx, b[3] = this.c, b[4] = this.d, b[5] = 
      this.ty, b[6] = 0, b[7] = 0, b[8] = 1), b
  }, b.identityMatrix = new b.Matrix, b.determineMatrixArrayType = function() {
   return "undefined" != typeof Float32Array ? Float32Array : Array
  }, b.Matrix2 = b.determineMatrixArrayType(), b.DisplayObject = function() {
   this.position = new b.Point, this.scale = new b.Point(1, 1), this.pivot = 
      new b.Point(0, 0), this.rotation = 0, this.alpha = 1, this.visible = !0, 
      this.hitArea = null, this.buttonMode = !1, this.renderable = !1, this.parent = null, 
      this.stage = null, this.worldAlpha = 1, this._interactive = !1, this.defaultCursor = 
      "pointer", this.worldTransform = new b.Matrix, this.color = [], this.dynamic = 
      !0, this._sr = 0, this._cr = 1, this.filterArea = null, this._bounds = 
      new b.Rectangle(0, 0, 1, 1), this._currentBounds = null, this._mask = 
      null, this._cacheAsBitmap = !1, this._cacheIsDirty = !1
  }, b.DisplayObject.prototype.constructor = b.DisplayObject, 
    b.DisplayObject.prototype.setInteractive = function(a) {
   this.interactive = a
  }, Object.defineProperty(b.DisplayObject.prototype, "interactive", {
   get: function() {
    return this._interactive
   },
   set: function(a) {
    this._interactive = a, this.stage && (this.stage.dirty = !0)
   }
  }), Object.defineProperty(b.DisplayObject.prototype, "worldVisible", {
   get: function() {
    var a = this;
    do {
     if (!a.visible) return !1;
     a = a.parent
    } while (a);
    return !0
   }
  }), Object.defineProperty(b.DisplayObject.prototype, "mask", {
   get: function() {
    return this._mask
   },
   set: function(a) {
    this._mask && (this._mask.isMask = !1), this._mask = a, this._mask && 
        (this._mask.isMask = !0)
   }
  }), Object.defineProperty(b.DisplayObject.prototype, "filters", {
   get: function() {
    return this._filters
   },
   set: function(a) {
    var b, c, d, e;
    if (a) {
     for (b = [], c = 0; c < a.length; c++)
      for (d = a[c].passes, e = 0; e < d.length; e++) b.push(d[e]);
     this._filterBlock = {
      target: this,
      filterPasses: b
     }
    }
    this._filters = a
   }
  }), Object.defineProperty(b.DisplayObject.prototype, "cacheAsBitmap", {
   get: function() {
    return this._cacheAsBitmap
   },
   set: function(a) {
    this._cacheAsBitmap !== a && (a ? this._generateCachedSprite() : 
        this._destroyCachedSprite(), this._cacheAsBitmap = a)
   }
  }), b.DisplayObject.prototype.updateTransform = function() {
   var a, b, c, d, e, f, g, h, i, j, k, l, m, n;
   this.rotation !== this.rotationCache && (this.rotationCache = this.rotation, 
      this._sr = Math.sin(this.rotation), this._cr = Math.cos(this.rotation)), 
      a = this.parent.worldTransform, b = this.worldTransform, c = this.pivot.x, 
      d = this.pivot.y, e = this._cr * this.scale.x, f = -this._sr * this.scale.y, 
      g = this._sr * this.scale.x, h = this._cr * this.scale.y, 
      i = this.position.x - e * c - d * f, j = this.position.y - h * d - c * g, 
      k = a.a, l = a.b, m = a.c, n = a.d, b.a = k * e + l * g, b.b = k * f + l * h, 
      b.tx = k * i + l * j + a.tx, b.c = m * e + n * g, b.d = m * f + n * h, 
      b.ty = m * i + n * j + a.ty, this.worldAlpha = this.alpha * 
      this.parent.worldAlpha
  }, b.DisplayObject.prototype.getBounds = function(a) {
   return a = a, b.EmptyRectangle
  }, b.DisplayObject.prototype.getLocalBounds = function() {
   return this.getBounds(b.identityMatrix)
  }, b.DisplayObject.prototype.setStageReference = function(a) {
   this.stage = a, this._interactive && (this.stage.dirty = !0)
  }, b.DisplayObject.prototype.generateTexture = function(a) {
   var c = this.getLocalBounds(),
    d = new b.RenderTexture(0 | c.width, 0 | c.height, a);
   return d.render(this, new b.Point(-c.x, -c.y)), d
  }, b.DisplayObject.prototype.updateCache = function() {
   this._generateCachedSprite()
  }, b.DisplayObject.prototype._renderCachedSprite = function(a) {
   this._cachedSprite.worldAlpha = this.worldAlpha, a.gl ? 
      b.Sprite.prototype._renderWebGL.call(this._cachedSprite, a) : 
      b.Sprite.prototype._renderCanvas.call(this._cachedSprite, a)
  }, b.DisplayObject.prototype._generateCachedSprite = function() {
   var a, c, d;
   this._cacheAsBitmap = !1, a = this.getLocalBounds(), this._cachedSprite ? 
      this._cachedSprite.texture.resize(0 | a.width, 0 | a.height) : 
      (c = new b.RenderTexture(0 | a.width, 0 | a.height), this._cachedSprite = 
      new b.Sprite(c), this._cachedSprite.worldTransform = this.worldTransform), 
      d = this._filters, this._filters = null, this._cachedSprite.filters = d, 
      this._cachedSprite.texture.render(this, new b.Point(-a.x, -a.y)), 
      this._cachedSprite.anchor.x = -(a.x / a.width), 
      this._cachedSprite.anchor.y = -(a.y / a.height), this._filters = d, 
      this._cacheAsBitmap = !0
  }, b.DisplayObject.prototype._destroyCachedSprite = function() {
   this._cachedSprite && (this._cachedSprite.texture.destroy(!0), 
      this._cachedSprite = null)
  }, b.DisplayObject.prototype._renderWebGL = function(a) {
   a = a
  }, b.DisplayObject.prototype._renderCanvas = function(a) {
   a = a
  }, Object.defineProperty(b.DisplayObject.prototype, "x", {
   get: function() {
    return this.position.x
   },
   set: function(a) {
    this.position.x = a
   }
  }), Object.defineProperty(b.DisplayObject.prototype, "y", {
   get: function() {
    return this.position.y
   },
   set: function(a) {
    this.position.y = a
   }
  }), b.DisplayObjectContainer = function() {
   b.DisplayObject.call(this), this.children = []
  }, b.DisplayObjectContainer.prototype = Object.create(b.DisplayObject.prototype), 
    b.DisplayObjectContainer.prototype.constructor = b.DisplayObjectContainer, 
    Object.defineProperty(b.DisplayObjectContainer.prototype, "width", {
   get: function() {
    return this.scale.x * this.getLocalBounds().width
   },
   set: function(a) {
    var b = this.getLocalBounds().width;
    this.scale.x = 0 !== b ? a / (b / this.scale.x) : 1, this._width = a
   }
  }), Object.defineProperty(b.DisplayObjectContainer.prototype, "height", {
   get: function() {
    return this.scale.y * this.getLocalBounds().height
   },
   set: function(a) {
    var b = this.getLocalBounds().height;
    this.scale.y = 0 !== b ? a / (b / this.scale.y) : 1, this._height = a
   }
  }), b.DisplayObjectContainer.prototype.addChild = function(a) {
   return this.addChildAt(a, this.children.length)
  }, b.DisplayObjectContainer.prototype.addChildAt = function(a, b) {
   if (b >= 0 && b <= this.children.length) return a.parent && 
      a.parent.removeChild(a), a.parent = this, this.children.splice(b, 0, a), 
      this.stage && a.setStageReference(this.stage), a;
   throw new Error(a + " The index " + b + " supplied is out of bounds " + 
      this.children.length)
  }, b.DisplayObjectContainer.prototype.swapChildren = function(a, b) {
   var c, d;
   if (a !== b) {
    if (c = this.children.indexOf(a), d = this.children.indexOf(b), 0 > c || 0 > d) 
        throw new Error("swapChildren: Both the supplied DisplayObjects must be a 
        child of the caller.");
    this.children[c] = b, this.children[d] = a
   }
  }, b.DisplayObjectContainer.prototype.getChildAt = function(a) {
   if (a >= 0 && a < this.children.length) return this.children[a];
   throw new Error("Supplied index does not exist in the child list, or the 
      supplied DisplayObject must be a child of the caller")
  }, b.DisplayObjectContainer.prototype.removeChild = function(a) {
   return this.removeChildAt(this.children.indexOf(a))
  }, b.DisplayObjectContainer.prototype.removeChildAt = function(a) {
   var b = this.getChildAt(a);
   return this.stage && b.removeStageReference(), b.parent = void 0, 
      this.children.splice(a, 1), b
  }, b.DisplayObjectContainer.prototype.removeChildren = function(a, b) {
   var f, g, h, c = a || 0,
    d = "number" == typeof b ? b : this.children.length,
    e = d - c;
   if (e > 0 && d >= e) {
    for (f = this.children.splice(c, e), g = 0; g < f.length; g++) h = f[g], 
        this.stage && h.removeStageReference(), h.parent = void 0;
    return f
   }
   throw new Error("Range Error, numeric values are outside the acceptable range")
  }, b.DisplayObjectContainer.prototype.updateTransform = function() {
   if (this.visible && (b.DisplayObject.prototype.updateTransform.call(this), 
      !this._cacheAsBitmap))
    for (var a = 0, c = this.children.length; c > a; a++) 
        this.children[a].updateTransform()
  }, b.DisplayObjectContainer.prototype.getBounds = function(a) {
   var c, d, e, f, g, h, i, j, k, l, m, n, o;
   if (0 === this.children.length) return b.EmptyRectangle;
   for (a && (c = this.worldTransform, this.worldTransform = a, 
      this.updateTransform(), this.worldTransform = c), d = 1 / 0, e = 1 / 0, f = -1 / 0,
      g = -1 / 0, k = !1, l = 0, m = this.children.length; m > l; l++) n = 
      this.children[l], n.visible && (k = !0, h = this.children[l].getBounds(a), 
      d = d < h.x ? d : h.x, e = e < h.y ? e : h.y, i = h.width + h.x, j = 
      h.height + h.y, f = f > i ? f : i, g = g > j ? g : j);
   return k ? (o = this._bounds, o.x = d, o.y = e, o.width = f - d, 
      o.height = g - e, o) : b.EmptyRectangle
  }, b.DisplayObjectContainer.prototype.getLocalBounds = function() {
   var c, d, e, a = this.worldTransform;
   for (this.worldTransform = b.identityMatrix, c = 0, d = this.children.length; 
      d > c; c++) this.children[c].updateTransform();
   return e = this.getBounds(), this.worldTransform = a, e
  }, b.DisplayObjectContainer.prototype.setStageReference = function(a) {
   var b, c, d;
   for (this.stage = a, this._interactive && (this.stage.dirty = !0), b = 0, 
      c = this.children.length; c > b; b++) d = this.children[b], 
      d.setStageReference(a)
  }, b.DisplayObjectContainer.prototype.removeStageReference = function() {
   var a, b, c;
   for (a = 0, b = this.children.length; b > a; a++) c = this.children[a], 
      c.removeStageReference();
   this._interactive && (this.stage.dirty = !0), this.stage = null
  }, b.DisplayObjectContainer.prototype._renderWebGL = function(a) {
   if (this.visible && !(this.alpha <= 0)) {
    if (this._cacheAsBitmap) return this._renderCachedSprite(a), void 0;
    var b, c;
    if (this._mask || this._filters) {
     for (this._filters && (a.spriteBatch.flush(), 
          a.filterManager.pushFilter(this._filterBlock)), 
          this._mask && (a.spriteBatch.stop(), a.maskManager.pushMask(this.mask, a), 
          a.spriteBatch.start()), b = 0, c = this.children.length; 
          c > b; b++) this.children[b]._renderWebGL(a);
     a.spriteBatch.stop(), this._mask && a.maskManager.popMask(this._mask, a), 
          this._filters && a.filterManager.popFilter(), a.spriteBatch.start()
    } else
     for (b = 0, c = this.children.length; c > b; b++) 
          this.children[b]._renderWebGL(a)
   }
  }, b.DisplayObjectContainer.prototype._renderCanvas = function(a) {
   var b, c, d;
   if (this.visible !== !1 && 0 !== this.alpha) {
    if (this._cacheAsBitmap) return this._renderCachedSprite(a), void 0;
    for (this._mask && a.maskManager.pushMask(this._mask, a.context), b = 0, 
        c = this.children.length; c > b; b++) d = this.children[b], d._renderCanvas(a);
    this._mask && a.maskManager.popMask(a.context)
   }
  }, b.Sprite = function(a) {
   b.DisplayObjectContainer.call(this), this.anchor = new b.Point, this.texture = 
      a, this._width = 0, this._height = 0, this.tint = 16777215, this.blendMode =
      b.blendModes.NORMAL, 
      a.baseTexture.hasLoaded ? this.onTextureUpdate() : (this.onTextureUpdateBind = 
      this.onTextureUpdate.bind(this), this.texture.addEventListener("update",
      this.onTextureUpdateBind)), 
      this.renderable = !0
  }, b.Sprite.prototype = Object.create(b.DisplayObjectContainer.prototype), 
    b.Sprite.prototype.constructor = b.Sprite, Object.defineProperty(b.Sprite.prototype,
    "width", {
   get: function() {
    return this.scale.x * this.texture.frame.width
   },
   set: function(a) {
    this.scale.x = a / this.texture.frame.width, this._width = a
   }
  }), Object.defineProperty(b.Sprite.prototype, "height", {
   get: function() {
    return this.scale.y * this.texture.frame.height
   },
   set: function(a) {
    this.scale.y = a / this.texture.frame.height, this._height = a
   }
  }), b.Sprite.prototype.setTexture = function(a) {
   this.texture = a, this.cachedTint = 16777215
  }, b.Sprite.prototype.onTextureUpdate = function() {
   this._width && (this.scale.x = this._width / this.texture.frame.width), 
      this._height && (this.scale.y = this._height / this.texture.frame.height)
  }

源码

需要源码请关注添加好友哦^ ^

转载：欢迎来到本站，转载请注明文章出处https://ormcc.com/