particles.java

Critter_Crunch_J2ME 游戏源

               m_p2[id] = (dy>>FP_SHIFT);
            }
            for (p=0; p<TNT_DENSITY; ++p) {
               vx = getRandomFP(TNT_CHUNK_SPEED_FP);
               vy = getRandomFP(TNT_CHUNK_SPEED_FP);
               id = create(TYPE_CHUNK, layer, Engine.getRandom(TNT_CHUNK_LIFE_MIN,TNT_CHUNK_LIFE_MAX), x+vx, y+vy, vx, vy, 0, (0<<FP_SHIFT), TNT_CHUNK_RGB_1, TNT_CHUNK_RGB_2);
            }
            break;
            
            
            
         case TYPE_GEM_COLLECT:
            //#ifndef PARTICLES_LOW
            id = create(TYPE_RING, layer, RING_SMALL_LIFE, x, y, GEM_RING_SPEED_FP, GEM_RING_SPEED_FP, 0, 0, SPARKLE_RGB_1, SPARKLE_RGB_2);
            //#endif
            id = create(TYPE_CROSS, layer, CROSS_LIFE, x, y, 0,0,0,0,SPARKLE_RGB_1,SPARKLE_RGB_2);
            for (p=0; p<GEM_DENSITY; ++p) {
               vx = getRandomFP(GEM_SPEED_FP);
               vy = getRandomFP(GEM_SPEED_FP);
               id = create(TYPE_STAR, layer, SPARKLE_LIFE, x+2*vx, y+2*vy, vx, vy, 0, (1<<FP_SHIFT));
               m_age[id] -= (p>>2);
            }
            break;
            
         case TYPE_GEM_SHATTER:
            id = create(TYPE_RING, layer, RING_BIG_LIFE, x, y, RING_SPEED_FP, RING_SPEED_FP, 0, 0, SPARKLE_RGB_1, SPARKLE_RGB_2);
            for (p=0; p<GEM_DENSITY; ++p) {
               vx = getRandomFP(GOO_X_SPEED_FP>>1);
               vy = -Engine.getRandom(GOO_Y_SPEED_FP);
               id = create(TYPE_SHARD, layer, Engine.getRandom(GOO_LIFE_MIN,GOO_LIFE_MAX), x+vx, y+vy, vx, vy, 0, (1<<FP_SHIFT)>>1, getGemColor(sub_type), 0);
               m_age[id] -= (p>>2);
            }
            for (p=0; p<GEM_DENSITY; ++p) {
               vx = getRandomFP(GEM_SPEED_FP);
               vy = getRandomFP(GEM_SPEED_FP);
               id = create(TYPE_SPARKLE, layer, SPARKLE_LIFE, x+2*vx, y+2*vy, vx, vy, 0, (1<<FP_SHIFT));
               m_age[id] -= (p>>2);
            }
            break;
            
         case TYPE_GEM_SPARKLE:
            for (p=0; p<2; ++p) {
               id = create(TYPE_SPARKLE, layer, SPARKLE_LIFE, x+(getRandomFP(Critter.S_BOX[Entity.BOX_WIDTH]<<FP_SHIFT)>>1), y+(getRandomFP(Critter.S_BOX[Entity.BOX_HEIGHT]<<FP_SHIFT)>>1), 0, 0, 0, 0);
            }
            break;
            
            
         case TYPE_COMBO_TEXT:
            Engine.stringBufferClear();
            Engine.stringBufferAppend(Locale.COMBO);
            id = textEffect(TYPE_TEXT_SPIN, layer, x, y);
            break;
            
         case TYPE_FOOD_CHAIN_TEXT:
            Engine.stringBufferClear();
            //#ifndef PARTICLES_LOW
            Engine.stringBufferAppend(Locale.FOODCHAIN);
            //#else
//#             Engine.stringBufferAppend(Locale.CHAIN);
            //#endif
            id = textEffect(TYPE_TEXT_STRETCH, layer, x, y);
            break;
            
         case TYPE_POINTS_TEXT:
            Engine.stringBufferClear();
            Engine.stringBufferAppendInt(sub_type);
            id = textEffect(TYPE_TEXT_BOUNCE, layer, x, y);
            break;
            
         case TYPE_LOSE_POINTS_TEXT:
            Engine.stringBufferClear();
            Engine.stringBufferAppendInt(sub_type);
            id = textEffect(TYPE_TEXT_SHAKE, layer, x, y);
            break;
            
         case TYPE_TOXIC_POINTS_TEXT:
            Engine.stringBufferClear();
            Engine.stringBufferAppendInt(sub_type);
            id = textEffect(TYPE_TEXT_DROP, layer, x, y);
            break;
            
         case TYPE_COIN_TEXT:
            //y -= Engine.CUSTOM_FONT_BIG_NEWLINE_HEIGHT<<FP_SHIFT;
            
            Engine.stringBufferClear();
            Engine.stringBufferAppend(Locale.COIN);
            id = textEffect(TYPE_TEXT_GATHER, layer, x, y);
            
            //Engine.stringBufferClear();
            //Engine.stringBufferAppend(Locale.BONUS);
            //Engine.stringBufferAppend(Locale.EXCLAMATION);
            //id = textEffect(TYPE_TEXT_GATHER, layer, x, y + (Engine.CUSTOM_FONT_BIG_NEWLINE_HEIGHT<<FP_SHIFT));
            break;
            
         case TYPE_FALLING_LEAF:
            //#ifndef PARTICLES_LOW
            id = create(TYPE_LEAF, layer, LEAF_LIFE, x, y, 0, Engine.getRandom((1<<FP_SHIFT)>>1,(2<<FP_SHIFT)), Engine.getRandom((8<<FP_SHIFT)) - (4<<FP_SHIFT), 0, sub_type, 0);
            //#endif
            break;
            
         case TYPE_SPECIAL_GLOW:
         
            timer = Engine.s_engine.m_state_timer;
            size = Critter.S_BOX[Entity.BOX_WIDTH] - (Critter.S_BOX[Entity.BOX_WIDTH]>>1);
            //#ifndef PARTICLES_LOW
            if (timer%10==0)
               create(TYPE_CROSS, LAYER_FOREGROUND, CROSS_LIFE, x, y, 0,0,0,0,SPARKLE_RGB_1,SPARKLE_RGB_2);
            
            create(TYPE_STAR, LAYER_FOREGROUND, 4, x + size*Engine.sin(timer<<5), y + size*Engine.cos(timer<<5), 0,0,0,0);
            //#else
//#             if (timer%10==0)
//#                create(TYPE_CROSS, LAYER_FOREGROUND, CROSS_LIFE, x, y, 0,0,0,0,SPARKLE_RGB_1,SPARKLE_RGB_2);
//#             
//#             if (timer%2==0)
//#                create(TYPE_SPARKLE, LAYER_FOREGROUND, SPARKLE_LIFE, x + size*Engine.sin(timer<<5), y + size*Engine.cos(timer<<5), 0,0,0,0);
            //#endif
            break;
            
         case TYPE_TOXIC_BUBBLE:
            dx = getRandomFP((sub_type<<FP_SHIFT));
            dy = getRandomFP((sub_type<<FP_SHIFT));
            color0 = getCreatureColor(Critter.CREATURE_TOXIC, 0);
            color1 = getCreatureColor(Critter.CREATURE_TOXIC, 1);
            id = create(TYPE_BUBBLE, LAYER_FOREGROUND, TOXIC_BUBBLE_LIFE, x+dx, y+dy,
                  0, 0, 0, 0, color1, color0);
            break;
         
         case TYPE_TOXIC_HAZE:
            offset = 0;
            size = 0;
            color0 = getCreatureColor(Critter.CREATURE_TOXIC, 0);
            color1 = getCreatureColor(Critter.CREATURE_TOXIC, 1);
            //#ifndef PARTICLES_LOW
            if (sub_type==Critter.CREATURE_GREEN || sub_type==Critter.CREATURE_BLOCKER || sub_type==Critter.CREATURE_WILDCARD) size = 5;
            if (sub_type==Critter.CREATURE_RED || sub_type==Critter.CREATURE_ORANGE || sub_type==Critter.CREATURE_TOXIC) size = 6;
            if (sub_type==Critter.CREATURE_BLUE || sub_type==Critter.CREATURE_PURPLE || sub_type==Critter.CREATURE_TNT) size = 7;
            vx = getRandomFP((2<<FP_SHIFT));
            vy = getRandomFP((2<<FP_SHIFT));
            //#else
//#             if (sub_type==Critter.CREATURE_GREEN || sub_type==Critter.CREATURE_BLOCKER || sub_type==Critter.CREATURE_WILDCARD) size = 4;
//#             if (sub_type==Critter.CREATURE_RED || sub_type==Critter.CREATURE_ORANGE || sub_type==Critter.CREATURE_TOXIC) size = 4;
//#             if (sub_type==Critter.CREATURE_BLUE || sub_type==Critter.CREATURE_PURPLE || sub_type==Critter.CREATURE_TNT) size = 5;
//#             x += (1<<FP_SHIFT); y += (1<<FP_SHIFT);
//#             vx = getRandomFP((1<<FP_SHIFT));
//#             vy = getRandomFP((1<<FP_SHIFT));
            //#endif
            
            
            
            //#if DefaultConfiguration || Nokia_6600 || Nokia_6600_Unobfuscated || Nokia_3220 || Nokia_3220_Unobfuscated || Razr
            id = create(TYPE_TOXIC_UNIT, LAYER_FOREGROUND, 0, x, y, 0,0,0,0,sub_type,0);
            //#else
//#             //if (Engine.getRandom(6 + Level.s_specials)==0)
//#             if (((x>>FP_SHIFT)+(y>>FP_SHIFT) + Engine.s_engine.m_state_timer)%4==0)
//#                create(TYPE_TOXIC_BUBBLE, LAYER_FOREGROUND, x, y, size*2);
            //#endif
            
            break;
            
         case TYPE_ONION_BREATH:
            for (p=0; p<ONION_DENSITY; ++p) {
               vx = getRandomFP(PUFF_SPEED_FP);
               vy = -(Engine.getRandom(PUFF_SPEED_FP) + PUFF_SPEED_FP);
               id = create(TYPE_PUFF_UNIT, layer, Engine.getRandom(PUFF_LIFE_MIN,PUFF_LIFE_MAX), x+2*vx, y+2*vy, vx, vy, -vx>>2, PUFF_Y_FORCE_FP, ONION_PUFF_RGB_1, ONION_PUFF_RGB_2);
               //m_age[id] -= p/2;
               id = create(TYPE_GOO_SPIN, layer, Engine.getRandom(PUFF_LIFE_MIN,PUFF_LIFE_MAX), x+1*vx, y+1*vy, 2*vx, 2*vy, -vx>>2, PUFF_Y_FORCE_FP, ONION_PUFF_RGB_1, ONION_PUFF_RGB_2);
               //m_age[id] -= p/2;
            }
            break;
            
         case TYPE_FIRE_LEFT:
            vx = Engine.COORDS[Coords.MFLAME_1][Engine.WIDTH];
            id = create(EMITTER_FIRE_LEFT, layer, FIRE_UNIT_LIFE + ((x>>FP_SHIFT)-Engine.BOARD_MARGIN_LEFT)/vx, x, y, (-vx<<FP_SHIFT), 0, 0, 0);
            break;
         case TYPE_FIRE_RIGHT:
            vx = Engine.COORDS[Coords.MFLAME_1][Engine.WIDTH];
            id = create(EMITTER_FIRE_RIGHT, layer, FIRE_UNIT_LIFE + (Engine.SCREEN_WIDTH-Engine.BOARD_MARGIN_RIGHT-(x>>FP_SHIFT))/vx, x, y, (vx<<FP_SHIFT), 0, 0, 0);
            break;
            
            
         case TYPE_DEATH_PUFF:
            density = sub_type;
            //#if PARTICLES_LOW
//#             density = 1;
            //#endif
            for (p=0; p<density; ++p) {
               id = create(TYPE_DEATH_PUFF_UNIT, LAYER_MIDGROUND, Engine.getRandom(DEATH_PUFF_LIFE,DEATH_PUFF_LIFE*2), 
                  x+getRandomFP((DEATH_PUFF_MIN_SIZE*2)<<FP_SHIFT), y+getRandomFP(DEATH_PUFF_MAX_SIZE<<FP_SHIFT), 0,0,0,0, 
                  Engine.getRandom(DEATH_PUFF_MIN_SIZE, DEATH_PUFF_MAX_SIZE), Engine.getRandom(DEATH_PUFF_MIN_SIZE*2, DEATH_PUFF_MAX_SIZE*2));
               create(TYPE_DEATH_PUFF_UNIT_B, LAYER_FOREGROUND, m_life[id], 
                  m_fp_x[id], m_fp_y[id], 0,0,0,0, m_p1[id], m_p2[id]);
               create(TYPE_DEATH_PUFF_UNIT_C, LAYER_HUD, m_life[id], 
                  m_fp_x[id], m_fp_y[id], 0,0,0,0, m_p1[id], m_p2[id]);
            }
            
            if (m_clock%10==0) {
               vx = getRandomFP(STAR_SPEED_FP*2);
               vy = getRandomFP(STAR_SPEED_FP*2);
               id = create(TYPE_DEATH_CRITTER, LAYER_FOREGROUND, DEATH_CRITTER_LIFE, x+2*vx, y+2*vy, vx, vy, -vx>>2, -vy>>2, Engine.getRandom(0,3), 1);
            }
            
            if (Engine.getRandom(2)==0) {
               vx = getRandomFP(PUFF_SPEED_FP);
               vy = getRandomFP(PUFF_SPEED_FP);
               id = create(TYPE_GOO_SPIN, LAYER_HUD, Engine.getRandom(PUFF_LIFE_MIN,PUFF_LIFE_MAX), x+4*vx, y+2*vy, 2*vx, 2*vy, -vx>>2, PUFF_Y_FORCE_FP, DEATH_PUFF_RGB_2, DEATH_PUFF_RGB_3);
            }
               
            //#ifndef PARTICLES_LOW
            if (Engine.getRandom(2)==0) {
               vx = getRandomFP(STAR_SPEED_FP*2);
               vy = getRandomFP(STAR_SPEED_FP*2);
               id = create(TYPE_STAR, LAYER_FOREGROUND, Engine.getRandom(STAR_LIFE_MIN,STAR_LIFE_MAX), x+2*vx, y+2*vy, vx, vy, 0, (1<<FP_SHIFT)>>2);
            }
            //#endif
            break;
            
         case TYPE_VOMIT:
            //#if DefaultConfiguration || Nokia_6600 || Nokia_6600_Unobfuscated || Razr
            x += getRandomFP(VOMIT_SPREAD_FP);
            y += getRandomFP(VOMIT_SPREAD_FP);
            vx = -Engine.getRandom(4<<FP_SHIFT, 8<<FP_SHIFT);
            vy = -Engine.getRandom(4<<FP_SHIFT, 8<<FP_SHIFT);
            
            id = create(TYPE_GOO, layer, Engine.getRandom(GOO_LIFE_MIN,GOO_LIFE_MAX), x+vx, y+2*vy, vx, vy, 0,2<<FP_SHIFT, color1, color2);
            if (x%3==0) create(TYPE_BIT, layer, GOO_LIFE_MIN, x, y, getRandomFP(VOMIT_SPREAD_FP), getRandomFP(VOMIT_SPREAD_FP), 0, (1<<FP_SHIFT)>>1, color1, color2);
            //#endif
            break;
            
            
         default:
            id = create(type, layer, 10, x, y, 0, 0, 0, 0);
            break;
      }
      return id;
   }
   
   
   // process all particles
   public static final void process() {
      
      for (int i=0; i<MAX_PARTICLES; i++) {
         
         if (m_type[i] == TYPE_NONE) continue;
         if (m_age[i] < 0) { m_age[i]++; continue; }      // don't process particles that aren't born yet
         
         // remove particles once they're passed their lifespan
         if (m_age[i] >= m_life[i]) {
            remove(i);
            continue;
         }
         
         // remove particles that have gone too far off the screen
         if ((m_fp_x[i]>>FP_SHIFT) < -Engine.SCREEN_HALF_WIDTH  || (m_fp_x[i]>>FP_SHIFT) > Engine.SCREEN_WIDTH + Engine.SCREEN_HALF_WIDTH ||
             (m_fp_y[i]>>FP_SHIFT) < -Engine.SCREEN_HALF_HEIGHT || (m_fp_y[i]>>FP_SHIFT) > Engine.SCREEN_HEIGHT + Engine.SCREEN_HEIGHT ) {
            if (m_layer[i]!=LAYER_HUD) {
               remove(i);
               continue;
            }
         }
         
         
         
         
         // apply accelerations
         m_fp_vx[i] += m_fp_fx[i];
         m_fp_vy[i] += m_fp_fy[i];

         // apply velocities
         m_fp_x[i] += m_fp_vx[i];
         m_fp_y[i] += m_fp_vy[i];
         
         
         
         // process emitters
         if (m_type[i] >= EMITTER_TYPE) {
            switch (m_type[i]) {
               case EMITTER_FIRE_LEFT: