spray.java

java的粒子算法,在j2me中可以用到,效果超级炫耀啊~~

import com.nokia.mid.ui.*;

public class Spray extends Particle
{
  private final int PARTICLE_STATE_DEAD = 0;
  private final int PARTICLE_STATE_NEW = -1;
  private final int PARTICLE_STATE_SPAWNED = -2;

  private final int MAX = 190;
  private final int LIFE_MAX = 10;
  private final int CREATE_MAX = 1;
  private final int EMIT_START = 0;//start create particle when lifeCount is
  private final int EMIT_END_NEW = 6;//stop create new particle when lifeCount is
  private final int EMIT_END_SPAWN = 40;//stop create spawn particle when lifeCount is

  private final int SPAWN_NUM = 3;

  private final int V_MAX = 25000;
  private final int V_MIN = 15000;
  private final int ACC_MAX = (70<<10)/100;//persent
  private final int DECAY = 1;
  private final int SIZE = 10;

  private final int GRAVITY_HIGH = 320;
  private final int GRAVITY_LOW = 280;

  private int display_until = EMIT_END_SPAWN + LIFE_MAX;

  public Spray()
  {
    super();

    max = MAX;
    create_max = CREATE_MAX;

    particle_color_seeds = new int[]{0x00999999, 0x00FFFFFF, 0x00FFFFFF};
    life_max = LIFE_MAX;
  }

  public void init() throws Exception
  {
    lifeCount = 0;
    particle = new int[max][9];

    for (int i=0; i<max; i++)
    {
      particle[i][PARTICLE_LIFE] = 0;//kill all particle first
    }

    particleAI();
  }

  public void particleAI()
  {
    //在这里面计算需要多大的屏幕缓冲
    int buffL = SCREENWIDTH;
    int buffT = SCREENHEIGHT;
    int buffR = 0;
    int buffB = 0;

    int create = create_max;
    for (int i=0; i<max; i++)
    {
      if (particle[i][PARTICLE_LIFE] == PARTICLE_STATE_DEAD)//死亡粒子
      {
        if (lifeCount>=EMIT_START && lifeCount<EMIT_END_NEW)
        {
          if (create>0)
          {
            //生成新粒子
            particle[i][PARTICLE_LIFE] = PARTICLE_STATE_NEW;
            create --;
          }
        }
      }
      else if (particle[i][PARTICLE_LIFE] == PARTICLE_STATE_NEW)
      {
        int rotate = -45;
        particle[i][PARTICLE_X] = startX << 10;
        particle[i][PARTICLE_Y] = startY << 10;
        int v = getRnd(0,100)<60?V_MAX:getRnd(V_MIN,V_MAX);
        particle[i][PARTICLE_VX] = (v * MathUtil.cos(rotate))>>10;
        particle[i][PARTICLE_VY] = (v * MathUtil.sin(rotate))>>10;
        particle[i][PARTICLE_XACC] = ACC_MAX;
        particle[i][PARTICLE_YACC] = particle[i][PARTICLE_XACC];//not for use
        particle[i][PARTICLE_LIFE] = life_max;
        particle[i][PARTICLE_DECAY] = DECAY;
        particle[i][PARTICLE_SIZE] = SIZE;
      }
      else if (particle[i][PARTICLE_LIFE] == PARTICLE_STATE_SPAWNED)
      {
      }
      else
      {
        particle[i][PARTICLE_X] += particle[i][PARTICLE_VX];
        particle[i][PARTICLE_Y] += particle[i][PARTICLE_VY];
        particle[i][PARTICLE_VX] = (particle[i][PARTICLE_VX] * particle[i][PARTICLE_XACC]) >> 10;
        particle[i][PARTICLE_VY] = (particle[i][PARTICLE_VY] * particle[i][PARTICLE_YACC]) >> 10;
        particle[i][PARTICLE_VY] += getRnd(0,100)<70 ? GRAVITY_LOW : GRAVITY_HIGH;
        particle[i][PARTICLE_LIFE] -= particle[i][PARTICLE_DECAY];
        if (particle[i][PARTICLE_LIFE]<=0)
        {
          particle[i][PARTICLE_LIFE] = PARTICLE_STATE_DEAD;

          //if (spawn==SPAWN_ON_DEATH)
            if (lifeCount>=EMIT_START && lifeCount<EMIT_END_SPAWN)
            {
              for (int j=0,count=0; j<particle.length && count<SPAWN_NUM; j++)
              {
                if (particle[j][PARTICLE_LIFE] == PARTICLE_STATE_DEAD)
                {
                  particle[j][PARTICLE_X] = particle[i][PARTICLE_X];
                  particle[j][PARTICLE_Y] = particle[i][PARTICLE_Y];
                  particle[j][PARTICLE_VX] = particle[i][PARTICLE_VX];
                  particle[j][PARTICLE_VY] = particle[i][PARTICLE_VY];
                  particle[j][PARTICLE_LIFE] = PARTICLE_STATE_SPAWNED;
                  particle[j][PARTICLE_SIZE] = particle[i][PARTICLE_SIZE]-particle[i][PARTICLE_DECAY];

                  int VX_add = Math.abs(particle[j][PARTICLE_VX]);
                  int VY_add = Math.abs(particle[j][PARTICLE_VY]);
                  particle[j][PARTICLE_VX] += getRnd(-VX_add,VX_add);
                  particle[j][PARTICLE_VY] += getRnd(-VY_add,VY_add);
                  particle[j][PARTICLE_XACC] = ACC_MAX;
                  particle[j][PARTICLE_YACC] = particle[i][PARTICLE_XACC];//not for use
                  particle[j][PARTICLE_LIFE] = life_max;
                  particle[j][PARTICLE_DECAY] = DECAY;

                  count++;
                }
              }
            }
        }
        //if (spawn==SPAWN_ON_TRAIL)
          if (lifeCount>=EMIT_START && lifeCount<EMIT_END_SPAWN && particle[i][PARTICLE_SIZE] == SIZE)
          {
            for (int j=0,count=0; j<particle.length && count<1; j++)
            {
              if (particle[j][PARTICLE_LIFE] == PARTICLE_STATE_DEAD)
              {
                particle[j][PARTICLE_X] = particle[i][PARTICLE_X]-getRnd(Math.min(particle[i][PARTICLE_VX],0),Math.max(particle[i][PARTICLE_VX],0));
                particle[j][PARTICLE_Y] = particle[i][PARTICLE_Y]-getRnd(Math.min(particle[i][PARTICLE_VY],0),Math.max(particle[i][PARTICLE_VY],0));
                particle[j][PARTICLE_VX] = particle[i][PARTICLE_VX]>>1;
                particle[j][PARTICLE_VY] = particle[i][PARTICLE_VY]>>1;
                particle[j][PARTICLE_LIFE] = PARTICLE_STATE_SPAWNED;
                particle[j][PARTICLE_SIZE] = particle[i][PARTICLE_SIZE]-(particle[i][PARTICLE_DECAY]<<1);

                particle[j][PARTICLE_XACC] = ACC_MAX;
                particle[j][PARTICLE_YACC] = particle[i][PARTICLE_XACC];//not for use
                particle[j][PARTICLE_LIFE] = life_max;
                particle[j][PARTICLE_DECAY] = DECAY;

                count++;
              }
            }
          }
      }

      //calculate screen buffer size:
      if (particle[i][PARTICLE_LIFE]>0)
      {
        int xoffset = particle[i][PARTICLE_X]>>10;
        int yoffset = particle[i][PARTICLE_Y]>>10;
        buffL = Math.min(buffL,xoffset-particle[i][PARTICLE_SIZE]/2);
        buffT = Math.min(buffT,yoffset-particle[i][PARTICLE_SIZE]/2);
        buffR = Math.max(buffR,xoffset+particle[i][PARTICLE_SIZE]/2);
        buffB = Math.max(buffB,yoffset+particle[i][PARTICLE_SIZE]/2);
      }
    }

    arrayX = buffL;
    arrayY = buffT;
    arrayW = buffR - buffL;
    arrayH = buffB - buffT;

    lifeCount ++;
  }

  public void draw(DirectGraphics dg, int offsetX, int offsetY)
  {
    if (arrayW>0 && arrayH>0)
    {
      imgArray = new int[arrayW*arrayH];

      //计算粒子颜色
      int color = particleColor(display_until-lifeCount,display_until-EMIT_START,particle_color_seeds);
      int alpha = particleAlpha(display_until-lifeCount,display_until-EMIT_START);
      for (int i=0; i<max; i++)
      {
        if (particle[i][PARTICLE_LIFE]>0)
        {
          int x = particle[i][PARTICLE_X] >> 10;
          int y = particle[i][PARTICLE_Y] >> 10;
          fillArcInArray(x-arrayX, y-arrayY, particle[i][PARTICLE_SIZE]/2, color, alpha, imgArray, arrayW, arrayH);
        }
      }
      blur_alpha(imgArray,arrayX,arrayY,arrayW,arrayH,dg);

      //drawPixels(int[] pixels, boolean transparency, int offset, int scanlength, int x, int y, int width, int height, int manipulation, int format)
      dg.drawPixels(imgArray,true,0,arrayW,arrayX+originX-offsetX,arrayY+originY-offsetY,arrayW,arrayH,0,DirectGraphics.TYPE_INT_8888_ARGB);
    }
  }

  protected static int particleAlpha(int life, int life_max)
  {
    int alpha_max = 255;//0~255
    return life * alpha_max / life_max;
  }
}