Animation 模拟纸盒的爆破

用简单的Animation动作模拟爆破的瞬间，仔细的调整各种参数效果会更像

原理：用定义好的纸张从onTouch中心点向四面八方散开，散开过程中，使用不用的速度、大小、方向、旋转角度、透明度（这里纸张可以加上火焰，效果会更好，纸张燃烧代表透明度）、位置、3D旋转  ；

//3D翻转 ，模拟力量方向俯冲
Rotate3d rota3d = new Rotate3d((int) (Math.random()*90), (float) (Math.random()*90), 
(float) (Math.random()*x), (int) (Math.random()*y), 310.0f, true);  

//3D翻转
//Rotate3d rota3d = new Rotate3d((int) (Math.random()*90),
//(float) (Math.random()*90,0, 0, 310.0f, true);  

3D动作，float centerX, float centerY 的位置能够模拟出力量的方向，如果都为0，均从中心散出

这里虽然好象有点扯淡，不过效果还是蛮像的

public class MainActivity extends Activity {
    private FrameLayout fl;
    //定义Bitmap对象
    Bitmap    mBit = null;
    //AnimationSet animationSet;
    List<ExplosionView> exvArrayList = new ArrayList<ExplosionView>();
    List<AnimationSet> animationArrayList = new ArrayList<AnimationSet>();
    DisplayMetrics dm;
    private float dmw=0,dmh=0;
    //定义碎片的形状
    private int s1 = R.drawable.s1,s2=R.drawable.s2,s3=R.drawable.s3,s4=R.drawable.s4,
            s5=R.drawable.s5,s6=R.drawable.s6,s7=R.drawable.s7,s8=R.drawable.s8,
            s9=R.drawable.s9,s10=R.drawable.s10,s11=R.drawable.s11,s12=R.drawable.s12,
            s13=R.drawable.s13,s14=R.drawable.s14;
    private int[] chip = {s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13,s14};
    private int x=1;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams. FLAG_FULLSCREEN ,
                      WindowManager.LayoutParams. FLAG_FULLSCREEN);
        
        dm = new DisplayMetrics();   
        getWindowManager().getDefaultDisplay().getMetrics(dm);   
        //获得手机的宽度和高度像素单位为px   
        dmw = dm.widthPixels;
        dmh = dm.heightPixels;   
        
        fl = new FrameLayout(this);
        
        //添加50个爆炸碎片
        for (int i = 0; i < 50; i++) {
            int width=getResources().getDrawable(chip[x]).getIntrinsicWidth();
            int height=getResources().getDrawable(chip[x]).getIntrinsicHeight();
            fl.addView(createExv(chip[x],width,height));
            if(x==13){
                x=0;
            }
            x++;
        }
        fl.setOnTouchListener(new LayoutListener());
        setContentView(fl);
    }
    
    public ExplosionView createExv(int chipx,int w,int h){
        ExplosionView exv = new ExplosionView(this,w,h);
        exv.setImageResource(chipx);
        exv.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT,LayoutParams.WRAP_CONTENT));
        exv.setVisibility(View.INVISIBLE);    
        exvArrayList.add(exv);
        //animationArrayList.add(animationSet);
        return exv;
    }

    class LayoutListener implements OnTouchListener{
        
        public boolean onTouch(View v, MotionEvent event) {
            float x = event.getX();
            float y = event.getY();
            
//            Iterator it1 = exvArrayList.iterator();   
//            while(it1.hasNext()){   
////System.out.println(it1.next()); 
//                ExplosionView tempExplosion = (ExplosionView) it1.next();
//                tempExplosion.setVisibility(View.VISIBLE);
//                tempExplosion.setLocation((int)y-20, (int)x-20);
//                tempExplosion.startAnimation(animation);
//            }   
            for(int i = 0;i < exvArrayList.size(); i ++){   
                //System.out.println(exvArrayList.get(i));   
                ExplosionView tempExplosion = (ExplosionView) exvArrayList.get(i);
                tempExplosion.setVisibility(View.VISIBLE);
                tempExplosion.setLocation((int)y, (int)x);
                AnimationSet animationSet = new AnimationSet(false);
                
                //设置碎片的透明程度变化
                AlphaAnimation alpha = new AlphaAnimation(1.0f, 0.0f);
                //透明动作：减速
                alpha.setInterpolator(new DecelerateInterpolator());
                
                
                //设置碎片的旋转角度
                RotateAnimation rotate = new RotateAnimation(0, (int) (Math.random()*330+30),
                        Animation.RELATIVE_TO_SELF, 0.5f,
                        Animation.RELATIVE_TO_SELF, 0.5f);
                //旋转动作：减速
                rotate.setInterpolator(new DecelerateInterpolator());
    
                
                //设置碎片的移动变化
                TranslateAnimation translate = new TranslateAnimation(
                        0,
                        (float) ( dmw/2-(Math.random()*(dmw))),
                        0, 
                        (float) ( dmw/2-(Math.random()*(dmw))));
                //移动动作：减速
                translate.setInterpolator(new DecelerateInterpolator());
            
                //设置碎片的大小变化
                ScaleAnimation scaleAnimation = new ScaleAnimation(
                        1, (float)(Math.random()), 
                        1, (float)(Math.random()),
                        Animation.RELATIVE_TO_SELF, 0,
                        Animation.RELATIVE_TO_SELF, 0);
                //大小动作：加速度
                scaleAnimation.setInterpolator(new AccelerateInterpolator());
                
                //3D翻转 ，模拟力量方向俯冲
                Rotate3d rota3d = new Rotate3d((int) (Math.random()*90), (float) (Math.random()*90), 
                        (float) (Math.random()*x), (int) (Math.random()*y), 310.0f, true);  
                //Rotate3d rota3d = new Rotate3d((int) (Math.random()*90), (float) (Math.random()*90), 
//        0, 0, 310.0f, true);  
                
                
                animationSet.addAnimation(alpha);
                animationSet.addAnimation(rotate);
                animationSet.addAnimation(translate);
                animationSet.addAnimation(rota3d);
                animationSet.addAnimation(scaleAnimation);
                
                //动画持续时间，使每个碎片的动作速度都不一样 
//animationSet.setDuration(5000);
                animationSet.setDuration((int) (Math.random()*4000+100));
                //开始停顿时间
                animationSet.setStartOffset(0);
                animationSet.setFillAfter(true);
                
                tempExplosion.startAnimation(animationSet);
            }   

            return false;
        }
    }
    
    class ExplosionView extends ImageView{
        private int exvw,exvh;
        public ExplosionView(Context context,int ew,int eh) {
            super(context);
            this.exvw=ew;
            this.exvh=eh;
        }
        //handle the location of the explosion
        public void setLocation(int top,int left){
            this.setFrame(left, top, left+exvw, top+exvh);
        }    
    }
    
    class Rotate3d extends Animation{   
        private final float mFromDegrees;      
        private final float mToDegrees;      
        private final float mCenterX;      
        private final float mCenterY;      
        private final float mDepthZ;      
        private final boolean mReverse;      
        private Camera mCamera;  
        
        public Rotate3d(float fromDegrees, float toDegrees,float centerX, float centerY, 
                float depthZ, boolean reverse) {          
            mFromDegrees = fromDegrees;          
            mToDegrees = toDegrees;          
            mCenterX = centerX;          
            mCenterY = centerY;          
            mDepthZ = depthZ;          
            mReverse = reverse;      
        }    
        
        @Override      
        public void initialize(int width, int height, int parentWidth, int parentHeight) {          
            super.initialize(width, height, parentWidth, parentHeight);          
            mCamera = new Camera();      
        }     
        
        @Override      
        protected void applyTransformation(float interpolatedTime, Transformation t) {          
            final float fromDegrees = mFromDegrees;          
            float degrees = fromDegrees + ((mToDegrees - fromDegrees) * interpolatedTime);          
            final float centerX = mCenterX;          
            final float centerY = mCenterY;          
            final Camera camera = mCamera;          
            final Matrix matrix = t.getMatrix();          
            camera.save();          
            if (mReverse) {              
                camera.translate(0.0f, 0.0f, mDepthZ * interpolatedTime);          
            } else {              
                camera.translate(0.0f, 0.0f, mDepthZ * (1.0f - interpolatedTime));          
            }          
            
            camera.rotateY(degrees);          
            camera.getMatrix(matrix);          
            camera.restore();           
            matrix.preTranslate(-centerX, -centerY);          
            matrix.postTranslate(centerX, centerY);      
            }  
        } 

这里没结合到物理学，如果要做得更仔细，可以加有手机的重力感应和撞击屏幕边缘的反弹效果