コード例 #1
0
ファイル: Flame.java プロジェクト: troy-work/Asteroidfield
  /**
   * @param x1 #start
   * @param y1 #start
   * @param x2 #end
   * @param y2 #end
   * @param numParticles #density
   */
  public void MakeFrontFire(int x1, int y1, int x2, int y2, int numParticles) {

    final Timeline fronttimeline = new Timeline();

    y2 = (int) (y2 - ((y2 - y1) * .8));
    for (int i = 0; i < numParticles; i++) {
      int size = CoreMath.rand(15, 20);
      int duration = (100 - size) * 10;
      int moveDistance = CoreMath.rand(1, 4 * size);
      double moveDirection = 180; // CoreMath.rand(0,5);
      int startX = x1 + i * (x2 - x1) / numParticles;
      int startY = y1 + i * (y2 - y1) / numParticles;
      int goalX = startX + (int) (moveDistance * Math.cos(moveDirection));
      int goalY = startY + (int) (moveDistance * Math.sin(moveDirection));

      CoreImage image = flame[CoreMath.rand(flame.length - 1)];
      Sprite sprite = new ImageSprite(image, startX, startY);
      sprite.setAnchor(.5, .5);

      sprite.setSize(size * 6, size * 2);
      sprite.alpha.set(50);
      scene.add(sprite);
      fronttimeline.animate(
          sprite.height, sprite.height.get(), sprite.width.get(), duration, Easing.REGULAR_OUT);
      fronttimeline.animateTo(sprite.x, goalX, duration, Easing.REGULAR_OUT);
      fronttimeline.animateTo(sprite.y, goalY, duration, Easing.REGULAR_OUT);
      fronttimeline.at(100).animateTo(sprite.alpha, 0, duration - 100, Easing.REGULAR_OUT);
      fronttimeline.add(new RemoveSpriteEvent(scene.getMainLayer(), sprite, duration));
    }

    scene.addTimeline(fronttimeline);
  }
コード例 #2
0
ファイル: Centipede.java プロジェクト: dgfitch/ld17
 public Centipede(Player p, Level l, int x, int y) {
   super(p, l, "enemy_centipede.png", x, y);
   speed = CoreMath.rand(0.8, 1.4) + (p.getLevelNumber() / 7);
   health = p.getLevelNumber() + CoreMath.rand(2.0, 5.0);
   points = (int) health;
   int size = CoreMath.rand(20, 30);
   setSize(size, size);
 }
コード例 #3
0
  public void load() {
    setCursor(Input.CURSOR_OFF);
    cursor = new ImageSprite("glow.png", 0, 0);
    cursor.setAnchor(0.5, 0.5);
    cursor.visible.set(false);

    // Create the mask
    maskLayer = new Group();
    maskLayer.add(new FilledSprite(gray(18)));
    maskLayer.add(cursor);
    maskLayer.setBlendMode(BlendMode.Multiply());
    maskLayer.createBackBuffer();

    // Create the background image
    Timeline t = new Timeline();
    Group imageLayer = new Group();
    imageLayer.add(new FilledSprite(rgb(0xba9b65)));
    int size = 80;
    int spacing = 16;
    for (int i = -spacing / 2; i < Stage.getWidth(); i += spacing + size) {
      for (int j = -spacing / 2; j < Stage.getHeight(); j += spacing + size) {
        int color1 = colors[CoreMath.rand(colors.length - 1)];
        int color2 = colors[CoreMath.rand(colors.length - 1)];
        FilledSprite sprite = new FilledSprite(i, j, size, size, color1);
        imageLayer.add(sprite);
        int delay1 = CoreMath.rand(20000);
        int delay2 = delay1 + CoreMath.rand(20000);
        t.set(sprite.fillColor, color2, delay1);
        t.set(sprite.fillColor, color1, delay2);
      }
    }
    t.loopForever();
    addTimeline(t);

    // Add the layers to the scene
    addLayer(imageLayer);
    addLayer(maskLayer);
  }
コード例 #4
0
ファイル: Flame.java プロジェクト: troy-work/Asteroidfield
  /**
   * @param x1 #start
   * @param y1 #start
   * @param x2 #end
   * @param y2 #end
   */
  public void MakeFire(int x1, int y1, int x2, int y2) {

    final Timeline backtimeline = new Timeline();

    for (int i = 0; i < 1; i++) {
      int size = CoreMath.rand(25, 50);
      int duration = (100 - size) * 10;
      if (duration < 0) {
        duration = 10;
      }
      int moveDistance = CoreMath.rand(70, 150 - size);
      double moveDirection = 180; // CoreMath.rand(0);

      int startX = x1 + i * (x2 - x1);
      int startY = y1 + i * (y2 - y1);
      int goalX = startX + (int) (moveDistance * Math.cos(moveDirection));
      int goalY = startY + (int) (moveDistance * Math.sin(moveDirection));

      CoreImage image = flame[CoreMath.rand(flame.length - 1)];
      Sprite sprite = new ImageSprite(image, startX, startY);
      sprite.setAnchor(.5, .5);

      sprite.setSize(size, size);
      scene.add(sprite);
      scene.getMainLayer().moveToBottom(sprite);
      scene.getMainLayer().moveUp(sprite);
      backtimeline.animateTo(sprite.x, goalX, duration, Easing.REGULAR_OUT);
      backtimeline.animateTo(sprite.y, goalY, duration, Easing.REGULAR_OUT);
      backtimeline.at(100).animateTo(sprite.alpha, 0, duration - 100, Easing.REGULAR_OUT);
      backtimeline.add(new RemoveSpriteEvent(scene.getMainLayer(), sprite, duration));
    }

    scene.addTimeline(backtimeline);

    MakeFrontFire(x1, y1, x2, y2, 1);
  }
コード例 #5
0
  void blend(
      int[] srcData,
      int srcScanSize,
      boolean srcOpaque,
      int edgeClamp,
      int srcX,
      int srcY,
      int srcWidth,
      int srcHeight,
      int u,
      int v,
      int du,
      int dv,
      boolean rotation,
      boolean renderBilinear,
      int renderAlpha,
      int[] destData,
      int destScanSize,
      int destOffset,
      int numPixels,
      int numRows) {
    if (renderAlpha <= 0) {
      return;
    }

    //
    // Pre-calc for bilinear scaling
    //

    int srcOffset = 0;
    int offsetTop = 0;
    int offsetBottom = 0;
    if (!rotation) {
      if (renderBilinear) {
        int imageY = v >> 16;
        if (srcOpaque) {
          if (imageY >= srcHeight - 1) {
            offsetTop = srcX + (srcY + srcHeight - 1) * srcScanSize;
            offsetBottom = offsetTop;
          } else if (imageY < 0) {
            offsetTop = srcX + srcY * srcScanSize;
            offsetBottom = offsetTop;
          } else if ((v & 0xffff) == 0) {
            offsetTop = srcX + (srcY + (v >> 16)) * srcScanSize;
            offsetBottom = offsetTop;
          } else {
            offsetTop = srcX + (srcY + (v >> 16)) * srcScanSize;
            offsetBottom = offsetTop + srcScanSize;
          }
        } else {
          if (imageY >= 0) {
            if (imageY < srcHeight - 1) {
              offsetTop = srcX + (srcY + (v >> 16)) * srcScanSize;
              offsetBottom = offsetTop + srcScanSize;
            } else if ((edgeClamp & CoreGraphics.EDGE_CLAMP_BOTTOM) != 0) {
              offsetTop = srcX + (srcY + srcHeight - 1) * srcScanSize;
              offsetBottom = offsetTop;
            } else if (v < (srcHeight << 16)) {
              offsetTop = srcX + (srcY + (v >> 16)) * srcScanSize;
              offsetBottom = -1;
            } else {
              offsetTop = -1;
              offsetBottom = -1;
            }
          } else if ((edgeClamp & CoreGraphics.EDGE_CLAMP_TOP) != 0) {
            offsetBottom = srcX + srcY * srcScanSize;
            offsetTop = offsetBottom;
          } else if (v > -(1 << 16)) {
            offsetBottom = srcX + srcY * srcScanSize;
            offsetTop = -1;
          } else {
            offsetTop = -1;
            offsetBottom = -1;
          }
        }
      } else {
        srcOffset = srcX;
        if ((u >> 16) >= srcWidth - 1) {
          srcOffset += srcWidth - 1;
        } else if (u > 0) {
          srcOffset += (u >> 16);
        }

        if ((v >> 16) >= srcHeight - 1) {
          srcOffset += (srcY + srcHeight - 1) * srcScanSize;
        } else if (v >= 0) {
          srcOffset += (srcY + (v >> 16)) * srcScanSize;
        }
      }
    }

    //
    // Opaque blending
    //

    if (renderAlpha == 255) {
      if (rotation) {
        // TODO: handle opaque images seperately?
        if (renderBilinear) {
          for (int i = 0; i < numPixels; i++) {
            int srcARGB =
                getPixelBilinearTranslucent(
                    srcData, srcScanSize, srcX, srcY, srcWidth, srcHeight, edgeClamp, u, v);
            int srcAlpha = srcARGB >>> 24;
            if (srcAlpha == 0xff) {
              blendOpaquePixel(destData, destOffset, srcARGB);
            } else if (BLEND_TRANSPARENT_PIXELS || srcAlpha != 0) {
              blendPixel(destData, destOffset, srcARGB);
            }
            destOffset++;
            u += du;
            v += dv;
          }
        } else {
          srcOffset = srcX + srcY * srcScanSize;
          for (int i = 0; i < numPixels; i++) {
            int x = CoreMath.clamp(u >> 16, 0, srcWidth - 1);
            int y = CoreMath.clamp(v >> 16, 0, srcHeight - 1);
            int srcARGB = srcData[srcOffset + x + y * srcScanSize];
            int srcAlpha = srcARGB >>> 24;
            if (srcAlpha == 0xff) {
              blendOpaquePixel(destData, destOffset, srcARGB);
            } else if (BLEND_TRANSPARENT_PIXELS || srcAlpha != 0) {
              blendPixel(destData, destOffset, srcARGB);
            }
            destOffset++;
            u += du;
            v += dv;
          }
        }
      } else if (renderBilinear) {
        if (srcOpaque) {
          for (int i = 0; i < numPixels; i++) {
            int srcARGB = getPixelBilinearOpaque(srcData, offsetTop, offsetBottom, u, v, srcWidth);
            blendOpaquePixel(destData, destOffset, srcARGB);
            destOffset++;
            u += du;
          }
        } else {
          for (int i = 0; i < numPixels; i++) {
            int srcARGB =
                getPixelBilinearTranslucent(
                    srcData, edgeClamp, offsetTop, offsetBottom, u, v, srcWidth);
            int srcAlpha = srcARGB >>> 24;
            if (srcAlpha == 0xff) {
              blendOpaquePixel(destData, destOffset, srcARGB);
            } else if (BLEND_TRANSPARENT_PIXELS || srcAlpha != 0) {
              blendPixel(destData, destOffset, srcARGB);
            }
            destOffset++;
            u += du;
          }
        }
      } else {
        for (int y = 0; y < numRows; y++) {
          if (du != (1 << 16)) {
            int offset = u & 0xffff;
            if (srcOpaque) {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + (offset >> 16)];
                blendOpaquePixel(destData, destOffset + i, srcARGB);
                offset += du;
              }
            } else {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + (offset >> 16)];
                int srcAlpha = srcARGB >>> 24;
                if (srcAlpha == 0xff) {
                  blendOpaquePixel(destData, destOffset + i, srcARGB);
                } else if (BLEND_TRANSPARENT_PIXELS || srcAlpha != 0) {
                  blendPixel(destData, destOffset + i, srcARGB);
                }
                offset += du;
              }
            }
          } else {
            if (srcOpaque) {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + i];
                blendOpaquePixel(destData, destOffset + i, srcARGB);
              }
            } else {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + i];
                int srcAlpha = srcARGB >>> 24;
                if (srcAlpha == 0xff) {
                  blendOpaquePixel(destData, destOffset + i, srcARGB);
                } else if (BLEND_TRANSPARENT_PIXELS || srcAlpha != 0) {
                  blendPixel(destData, destOffset + i, srcARGB);
                }
              }
            }
          }
          destOffset += destScanSize;
          srcOffset += srcScanSize;
        }
      }
    }

    //
    // Translucent blending
    //

    else {
      if (rotation) {
        // TODO: handle opaque images seperately?
        if (renderBilinear) {
          for (int i = 0; i < numPixels; i++) {
            int srcARGB =
                getPixelBilinearTranslucent(
                    srcData, srcScanSize, srcX, srcY, srcWidth, srcHeight, edgeClamp, u, v);
            if (BLEND_TRANSPARENT_PIXELS || srcARGB != 0) {
              blendPixel(destData, destOffset, srcARGB, renderAlpha);
            }
            destOffset++;
            u += du;
            v += dv;
          }
        } else {
          srcOffset = srcX + srcY * srcScanSize;
          for (int i = 0; i < numPixels; i++) {
            int x = CoreMath.clamp(u >> 16, 0, srcWidth - 1);
            int y = CoreMath.clamp(v >> 16, 0, srcHeight - 1);
            int srcARGB = srcData[srcOffset + x + y * srcScanSize];
            if (BLEND_TRANSPARENT_PIXELS || srcARGB != 0) {
              blendPixel(destData, destOffset, srcARGB, renderAlpha);
            }
            destOffset++;
            u += du;
            v += dv;
          }
        }
      } else if (renderBilinear) {
        if (srcOpaque) {
          for (int i = 0; i < numPixels; i++) {
            int srcARGB = getPixelBilinearOpaque(srcData, offsetTop, offsetBottom, u, v, srcWidth);
            blendOpaquePixel(destData, destOffset, srcARGB, renderAlpha);
            destOffset++;
            u += du;
          }
        } else {
          for (int i = 0; i < numPixels; i++) {
            int srcARGB =
                getPixelBilinearTranslucent(
                    srcData, edgeClamp, offsetTop, offsetBottom, u, v, srcWidth);
            if (BLEND_TRANSPARENT_PIXELS || srcARGB != 0) {
              blendPixel(destData, destOffset, srcARGB, renderAlpha);
            }
            destOffset++;
            u += du;
          }
        }
      } else {
        for (int y = 0; y < numRows; y++) {
          if (du != (1 << 16)) {
            int offset = u & 0xffff;
            if (srcOpaque) {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + (offset >> 16)];
                blendOpaquePixel(destData, destOffset + i, srcARGB, renderAlpha);
                offset += du;
              }
            } else {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + (offset >> 16)];
                if (BLEND_TRANSPARENT_PIXELS || srcARGB != 0) {
                  blendPixel(destData, destOffset + i, srcARGB, renderAlpha);
                }
                offset += du;
              }
            }
          } else {
            if (srcOpaque) {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + i];
                blendOpaquePixel(destData, destOffset + i, srcARGB, renderAlpha);
              }
            } else {
              for (int i = 0; i < numPixels; i++) {
                int srcARGB = srcData[srcOffset + i];
                if (BLEND_TRANSPARENT_PIXELS || srcARGB != 0) {
                  blendPixel(destData, destOffset + i, srcARGB, renderAlpha);
                }
              }
            }
          }
          destOffset += destScanSize;
          srcOffset += srcScanSize;
        }
      }
    }
  }