Android实现烟花效果

HolderSurfaceView.java
package com.lyc;
import android.graphics.PixelFormat;
import android.view.SurfaceView;
public class HolderSurfaceView {
    private HolderSurfaceView() {

}
private SurfaceView mSurfaceView;
private static HolderSurfaceView mHolderSurfaceView = null;

public static HolderSurfaceView getInstance() {
    if (mHolderSurfaceView == null)
        mHolderSurfaceView = new HolderSurfaceView();
    return mHolderSurfaceView;
}



public void setSurfaceView(SurfaceView view) {
    mSurfaceView = view;
    mSurfaceView.setZOrderOnTop(true);
    mSurfaceView.getHolder().setFormat(PixelFormat.TRANSLUCENT);
}

public SurfaceView getSurfaceView() {
    return mSurfaceView;
}
 
}
DrawTopBase.java
package com.lyc;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceHolder.Callback;
import android.view.SurfaceView;
import android.view.View;
import android.view.View.OnTouchListener;
public class DrawTopBase implements Runnable, Callback ,OnTouchListener{
protected DrawStatus mStatus = DrawStatus.NoWork;
    protected SurfaceView mSurfaceView;
    protected SurfaceHolder mSurfaceHolder;
    protected Context mContext;
    protected Rect mSurfaceRect = new Rect(0, 0, 0, 0); //前两个参数是左上角的坐标，后两个参数是右下角的坐标（不是宽度和高度）

public DrawTopBase() {
    setSurfaceView(HolderSurfaceView.getInstance().getSurfaceView());
}

public void setSurfaceView(SurfaceView view) {
    mSurfaceView = view;
    mContext = mSurfaceView.getContext();
    mSurfaceHolder = mSurfaceView.getHolder();
    mSurfaceHolder.addCallback(this);
 
//        mSurfaceRect.set(new Rect(0, 0, mSurfaceView.getWidth(), mSurfaceView.getHeight()));
        mSurfaceRect.set(new Rect(100, 100, 250, 250));
        set();
    }

public void set() {
    setRect(mSurfaceRect);
}

protected Thread mThread = null;


public void begin() {

    if (mThread == null) {
        mThread = new Thread(this);
        mThread.start();

    }
}

public void end() {
    mStatus = DrawStatus.Ending;
}


protected void doWork(Canvas canvas) {

}


protected void endWork() {

}

protected Paint mPaint = new Paint();


protected void clear(Canvas canvas) {
    mPaint.setXfermode(new PorterDuffXfermode(Mode.CLEAR));
    canvas.drawPaint(mPaint);
    mPaint.setXfermode(new PorterDuffXfermode(Mode.SRC));
}

protected void clear() {
    synchronized (mSurfaceHolder) {
        Canvas canvas = this.mSurfaceHolder.lockCanvas();
        try {
            clear(canvas);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (canvas != null)
                mSurfaceHolder.unlockCanvasAndPost(canvas);
        }
    }
}

protected void doChange() {
    change();
}


protected void change() {

}

 
//    protected Rect mRect = new Rect(0, 0, 0, 0);
    protected Rect mRect = new Rect(50, 50, 250, 250);

public void setRect(Rect r) {
    mRect.set(r);
}

public Rect getRect() {
    return mRect;
}




protected enum DrawStatus {
    NoWork, Drawing, Ending, Destroyed
};

protected long mBegintime;

public void run() {
    mStatus = DrawStatus.Drawing;
    //获取当前时间
    starttime = System.currentTimeMillis();
    mBegintime = System.currentTimeMillis();
    // 建立两次缓存
    clear();
    clear();
    while (mStatus == DrawStatus.Drawing) {
        synchronized (mSurfaceHolder) {
            Canvas canvas = this.mSurfaceHolder.lockCanvas(getRect());
            try {
                if (canvas != null) {
                    clear(canvas);
                    doWork(canvas);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (canvas != null)
                    mSurfaceHolder.unlockCanvasAndPost(canvas);
            }
            doChange();               
        }
        calculatePerframe();
    }
    if (mStatus != DrawStatus.Destroyed)
        clear();
    mThread = null;
    endWork();
}


protected long starttime;
// 每帧时间 60帧附近 第一次计算前使用 毫秒
private float perframe = 6;   //6=16

private int count = 0;

// 每隔多长时间测试一次帧时间
private int mRefreshSpeed = 30; //30=12

// 设定要求多长时间每帧 24帧每秒
private float mFPS = 1000 / 4;
private float sleep = mFPS;

// 设置刷新频率
public void setFPS(int fps) {
    mFPS = 1000 / fps;
}


protected void calculatePerframe() {
    count++;
    if (count == mRefreshSpeed) // 由于每帧计算会降低游戏效率。20到50差不多
    {
        long timepass = System.currentTimeMillis();
        long time = timepass - starttime;
        perframe = time / mRefreshSpeed;// 每帧时间
        sleep = perframe > mFPS ? mFPS - (perframe - mFPS) / mRefreshSpeed : mFPS;
        starttime = timepass;
        count = 0;
    }
    try {

        Thread.sleep((long) (sleep));
 
//         Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        new Thread(){
//          public void run(){
//           try {
//

//      sleep(2000);
//     } catch (Exception e) {
//      // TODO: handle exception
//      e.printStackTrace();
//     }finally{
////      finish();
//     }
//          }
//         }.start();

}

public void surfaceChanged(SurfaceHolder holder, int format, int width,
        int height) {
    mSurfaceRect.set(new Rect(0, 0, width, height));
 
//        mSurfaceRect.set(new Rect(0, 0, 200, 500));
        set();
    }

public void surfaceCreated(SurfaceHolder holder) {

}

public void surfaceDestroyed(SurfaceHolder holder) {
    mStatus = DrawStatus.Destroyed;
}

public boolean onTouch(View v, MotionEvent event) {
    // TODO Auto-generated method stub
    return false;
}
 
}
package com.lyc;
import java.util.Random;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.View;
public class DrawYH extends DrawTopBase {
private int m_nAppX;
     private int m_nAppY;
     private int m_centerX;
     private int m_centerY;
     private int m_mouseX;
     private int m_mouseY;
     private int m_sleepTime;
     private boolean isError;
     private boolean m_isPaintFinished;
     boolean isRunning;
     boolean isInitialized;
     Thread runner;
     int pix0[];
     Bitmap offImage;
     // Image dbImg;
     int pixls;
     int pixls2;
     Random rand;
     int bits;
     double bit_px[];
     double bit_py[];
     double bit_vx[];
     double bit_vy[];
     int bit_sx[];
     int bit_sy[];
     int bit_l[];
     int bit_f[];
     int bit_p[];
     int bit_c[];
     int bit_max = 100;
//     int bit_sound = 2;
     int ru;
     int rv;
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // TODO Auto-generated method stub
        super.surfaceCreated(holder);
        this.begin();
//        stopBGMedia();
//        bgMedia = new GameSoundMedia(mContext);
//        bgMedia.playInMediaPlayer(R.raw.bg, null);
    }
//    private void stopBGMedia() {
//        if (bgMedia != null) {
//            try {
//                bgMedia.stopAll();

//                bgMedia = null;
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//        }
//    }

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
 
//        stopBGMedia();
        super.surfaceDestroyed(holder);
    }

@Override
public void set() {
    super.set();
    if (this.getRect().width() > 10 && this.getRect().height() > 10)
        init();
}



 
Draw.java       //重要类

public Draw() {     //画烟花
    super();
    m_mouseX = 0;
    m_mouseY = 0;
    m_sleepTime = 5;   //5
    isError = false;
    isInitialized = false;
    rand = new Random();
    bits = 10000;           //控制烟花数量
    bit_px = new double[bits];
    bit_py = new double[bits];
    bit_vx = new double[bits];
    bit_vy = new double[bits];
    bit_sx = new int[bits];
    bit_sy = new int[bits];
    bit_l = new int[bits];
    bit_f = new int[bits];
    bit_p = new int[bits];
    bit_c = new int[bits];
    ru = 50;
    rv = 50;
    // init();
}

Canvas mCanvas;
private Rect drawRect = new Rect(0, 0, 0, 0);

public void init() {


    m_nAppX = this.getRect().width() / 2;
    m_nAppY = this.getRect().height() / 2;
    drawRect = new Rect(0, 0, m_nAppX, m_nAppY);
    m_centerX = m_nAppX / 2;
    m_centerY = m_nAppY / 2;
    m_mouseX = m_centerX;
    m_mouseY = m_centerY;
    // resize(m_nAppX, m_nAppY);
    pixls = m_nAppX * m_nAppY;
    pixls2 = pixls - m_nAppX * 3;
    pix0 = new int[pixls];
    offImage = Bitmap.createBitmap(m_nAppX, m_nAppY,
            Bitmap.Config.ARGB_8888);
    mCanvas = new Canvas();
    mCanvas.setBitmap(offImage);
    for (int i = 0; i < pixls; i++)
        pix0[i] = 0xff000000;

    for (int j = 0; j < bits; j++)
        bit_f[j] = 0;

    isInitialized = true;
}

@Override
protected void doWork(Canvas canvas) {
    // TODO Auto-generated method stub
    super.doWork(canvas);
    if (offImage != null)
        canvas.drawBitmap(offImage, drawRect, this.getRect(), mPaint);

}

@Override
protected void change() {
    super.change();
    if (isInitialized) {
        for (int j = 0; j < pixls2; j++) {     //pixls=pixls2
            int k = pix0[j];
            int l = pix0[j + 1];
            int i1 = pix0[j + m_nAppX];
            int j1 = pix0[j + m_nAppX + 1];
            int i = (k & 0xff0000) >> 16;
            int k1 = ((((l & 0xff0000) >> 16) - i) * ru >> 8) + i;
            i = (k & 0xff00) >> 8;
            int l1 = ((((l & 0xff00) >> 8) - i) * ru >> 8) + i;
            i = k & 0xff;
            int i2 = (((l & 0xff) - i) * ru >> 8) + i;
            i = (i1 & 0xff0000) >> 16;
            int j2 = ((((j1 & 0xff0000) >> 16) - i) * ru >> 8) + i;
            i = (i1 & 0xff00) >> 8;
            int k2 = ((((j1 & 0xff00) >> 8) - i) * ru >> 8) + i;
            i = i1 & 0xff;
            int l2 = (((j1 & 0xff) - i) * ru >> 8) + i;
            int i3 = ((j2 - k1) * rv >> 8) + k1;
            int j3 = ((k2 - l1) * rv >> 8) + l1;
            int k3 = ((l2 - i2) * rv >> 8) + i2;
            pix0[j] = i3 << 16 | j3 << 8 | k3 | 0x77000000;
            // if(pix0[j]==0x77000000)pix0[j]=0x55000000;
        }

        rend();

        mCanvas.drawBitmap(pix0, 0, m_nAppX, 0, 0, m_nAppX, m_nAppY, true,mPaint);
    }
}

public void dot() {
    dot(rand.nextInt(m_nAppX), rand.nextInt(m_nAppY));
}

public void dot(int x, int y) {
    m_mouseX = x;
    m_mouseY = y;
    int k = (int) (rand.nextDouble() * 256D);
    int l = (int) (rand.nextDouble() * 256D);
    int i1 = (int) (rand.nextDouble() * 256D);
    int j1 = k << 16 | l << 8 | i1 | 0xff000000;
    int k1 = 0;
    for (int l1 = 0; l1 < bits; l1++) {
        if (bit_f[l1] != 0)
            continue;
        bit_px[l1] = m_mouseX;
        bit_py[l1] = m_mouseY;
        double d = rand.nextDouble() * 6.2800000000000002D;
        double d1 = rand.nextDouble();
        bit_vx[l1] = Math.sin(d) * d1;
        bit_vy[l1] = Math.cos(d) * d1;
        bit_l[l1] = (int) (rand.nextDouble() * 100D) + 100;
        bit_p[l1] = (int) (rand.nextDouble() * 3D);
        bit_c[l1] = j1;
        bit_sx[l1] = m_mouseX;
        bit_sy[l1] = m_nAppY - 5;
        bit_f[l1] = 2;
        if (++k1 == bit_max)
            break;
    }
}

void rend() {
    boolean flag = false;
    boolean flag1 = false;
    boolean flag2 = false;
    for (int k = 0; k < bits; k++)
        switch (bit_f[k]) {

        case 1: // '\001'
            bit_vy[k] += rand.nextDouble() / 50D;
            bit_px[k] += bit_vx[k];
            bit_py[k] += bit_vy[k];
            bit_l[k]--;
            if (bit_l[k] == 0 || bit_px[k] < 0.0D || bit_py[k] < 0.0D
                    || bit_px[k] > (double) m_nAppX
                    || bit_py[k] > (double) (m_nAppY - 3)) {
                bit_c[k] = 0xff000000;
                bit_f[k] = 0;
            } else if (bit_p[k] == 0) {
                if ((int) (rand.nextDouble() * 2D) == 0)
                    bit_set((int) bit_px[k], (int) bit_py[k], -1);
            } else {
                bit_set((int) bit_px[k], (int) bit_py[k], bit_c[k]);
            }
            break;

        case 2: // '\002'
            bit_sy[k] -= 5;
            if ((double) bit_sy[k] <= bit_py[k]) {
                bit_f[k] = 1;
                flag2 = true;
            }
            if ((int) (rand.nextDouble() * 20D) == 0) {
                int i = (int) (rand.nextDouble() * 2D);
                int j = (int) (rand.nextDouble() * 5D);
                bit_set(bit_sx[k] + i, bit_sy[k] + j, -1);
            }
            break;
        default:
            break;

        }

 
//        if (flag2 && bit_sound > 0)
            // sm.playInMediaPlayer(R.raw.firework, null);
//            soundPool.play(id_sound1, 0);
    }

void bit_set(int i, int j, int k) {
    int l = i + j * m_nAppX;
     pix0[l] = k;
}

protected void calculatePerframe() {
      try {
        Thread.sleep(m_sleepTime);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}



@Override
public boolean onTouch(View v, MotionEvent event) {
    // return super.onTouch(v, event);
    int x = (int) event.getX();
    int y = (int) event.getY();
    x = x / 2;
    y = y / 2;
    if (x > m_nAppX)
        x = m_nAppX;
    if (y > m_nAppY)
        y = m_nAppY;
    if (x < 0)
        x = 0;
    if (y < 0)
        y = 0;
    switch (event.getAction()) {
 
//        case MotionEvent.ACTION_DOWN:
//
//            break;
//        case MotionEvent.ACTION_UP:
//            this.dot(x, y);
//            if (this.bit_sound > 1)
                // sm.playInMediaPlayer(R.raw.syu, null);
//                soundPool.play(id_sound2, 0);
//         break;
        case MotionEvent.ACTION_MOVE:
         this.dot(x,y);
            break;
        }
        m_mouseX = x;
        m_mouseY = y;
        return true;
    }
}
package com.lyc;
import android.app.Activity;
import android.os.Bundle;
import android.view.SurfaceView;
public class MainActivity extends Activity {
public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
//          setContentView(R.layout.main);
         SurfaceView v = new SurfaceView(this);
//         bt1 = (Button) findViewById(R.id.bt1);
         HolderSurfaceView.getInstance().setSurfaceView(v);
//         v.setBackgroundResource(R.drawable.mov005);
         this.setContentView(v);
         final DrawYH yh=new DrawYH();

         v.setOnTouchListener(yh);
         yh.begin();
}
}</pre>