canvas实现粒子碰撞消失动画效果代码-html代码-BFW代码库

代码语言：html

所属分类：动画

代码描述：canvas实现粒子碰撞消失动画效果代码

下面为部分代码预览，完整代码请点击下载或在bfwstudio webide中打开

<!DOCTYPE html>
<html lang="en" >

<head>
  <meta charset="UTF-8">
  

  
  
<style>
body {
  font-family: Arial, Helvetica, "Liberation Sans", FreeSans, sans-serif;
  background-color: #000;
  margin: 0;
  padding: 0;
  border-width: 0;
  overflow: hidden;
  cursor: pointer;
}
</style>


</head>

<body>

  
      <script >
"use strict";

window.addEventListener("load", function () {
  let canv, ctx; // canvas and context
  let maxx, maxy; // canvas dimensions

  const NUM_ATOMS = 500; // base to calculate number of atoms. Actual number may differ
  const DIAMETER_RATIO = 0.6; // ratio particle diameter / distance between particle centers
  const REL_PHOTON_SPEED = 10; // speed in aDist / second
  const EMISSIVITY = 1.5; // average number of photons emitted during disintegration
  const PHOTON_TRAIL = 3; // in aDist;
  const DISAPPEAR_TIME = 1000; // average time for atom disappearance

  let aDist, aRadius; // actual distance between atoms centers, actual radius
  let pRadius; // radius of emited particle

  let pSpeed; // actual REL_PART_SPEED converted in pix / ms
  let pTrail; // actual PHOTON_TRAIL converted in pixels
  let tTrail;
  let numExploding;

  let nbx, nby;
  let offsX, offsY;
  let crystal, photons;

  // for animation
  let messages;

  // shortcuts for Math.
  const mrandom = Math.random;
  const mfloor = Math.floor;
  const mround = Math.round;
  const mceil = Math.ceil;
  const mabs = Math.abs;
  const mmin = Math.min;
  const mmax = Math.max;

  const mPI = Math.PI;
  const mPIS2 = Math.PI / 2;
  const mPIS3 = Math.PI / 3;
  const m2PI = Math.PI * 2;
  const m2PIS3 = Math.PI * 2 / 3;
  const msin = Math.sin;
  const mcos = Math.cos;
  const matan2 = Math.atan2;

  const mhypot = Math.hypot;
  const msqrt = Math.sqrt;

  //------------------------------------------------------------------------

  function alea(mini, maxi) {
    // random number in given range
    if (typeof maxi == "undefined") return mini * mrandom(); // range 0..mini
    return mini + mrandom() * (maxi - mini); // range mini..maxi
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  function intAlea(mini, maxi) {
    // random integer in given range (mini..maxi - 1 or 0..mini - 1)
    //
    if (typeof maxi == "undefined") return mfloor(mini * mrandom()); // range 0..mini - 1
    return mini + mfloor(mrandom() * (maxi - mini)); // range mini .. maxi - 1
  }
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  function distance(p0, p1) {
    return mhypot(p1.x - p0.x, p1.y - p0.y);
  } // distance

  //------------------------------------------------------------------------
  class Photon {
    constructor(atom, t) {
      this.atom = atom;
      this.c = atom.c; // initial position
      this.p = Object.assign({}, atom.c); // current position
      this.pkx = atom.kx; // previous kx and ky
      this.pky = atom.ky;
      this.tInit = t;
      const angle = alea(m2PI);
      this.sin = msin(angle) * pSpeed;
      this.cos = mcos(angle) * pSpeed;
      this.animState = 0;
      this.color = `hsl(${atom.hue} 100% 50%)`;
      this.trailingColor = `hsl(${atom.hue} 60% 30%)`;
    } // constructor

    animate(t) {
      const dt = t - this.tInit;
      switch (this.animState) {
        case 0:
          this.p.x = this.c.x + this.cos * dt;
          this.p.y = this.c.y + this.sin * dt;
          let kx = mround((this.p.x - offsX) / aDist);
          let ky = mround((this.p.y - offsY) / aDist);
          if (kx == this.atom.kx && ky == this.atom.ky) return; // no suicide !

          let currDist;
          while (mabs(this.pkx - kx) + mabs(this.pky - ky) > 1) {
            // check all atoms between previous and present positions (may be far !)
            /* try to move 1 cell in X and Y directions, and keep closest */
            let d1, d2;
            let currC = crystal[this.pky][this.pkx];
            if (currDist === undefined) currDist = this.distancePerp(currC.c);

            if (currDist < pRadius + aRadius && currC.animState == 0) {
              // hit !
              this.hitPosition = this.projection(currC.c);
              currC.disintegrate(t);
              this.animState = 15; // hit detected during too long step
              return;
            }
            // choose next
            let nkx = this.cos > 0 ? this.pkx + 1 : this.pkx - 1;
            if (nkx < 0 || nkx >= nbx) d1 = 1e99;else
            d1 = this.distancePerp(crystal[this.pky][nkx].c);
            let nky = this.sin > 0 ? this.pky + 1 : this.pky - 1;
            if (nky < 0 || nky >= nby) d2 = 1e99;else
            d2 = this.distancePerp(crystal[nky][this.pkx].c);
            if (d1 < d2) {
              // move in x
              currDist = d1;
              this.pkx = nkx;
            } else {
              currDist = d2;
              this.pky = nky;
            }
            if (currDist > 1e98) {
              this.animState = 10; // exceeded screen limits
              return;
            }
          } // while

          if (kx < 0 || kx >= nbx || ky < 0 || ky >= nby) {
            this.animState = 10; // exceeded screen limits
            return;
          }

          this.pkx = kx;
          this.pky = ky; // record for next step

          if (crystal[ky][kx].animState == 0) {
            if (
            distance(this.p, crystal[ky][kx].c) < aRadius + pRadius ||
            dt * pSpeed > this.distProjection(crystal[ky][kx].c))
            {
              this.hitPosition = this.p; // not always accurate, but who cares ?
              crystal[ky][kx].disintegrate(t);
              this.animState = 15;
              return;
            }
          }
          break;

        case 10:
          photons.splice(photons.indexOf(this), 1); // remove from list
          break;

        case 15:
          // play come animation
          this.animState = 10; // done
          break;}
      // switch (animState)
   .........完整代码请登录后点击上方下载按钮下载查看