自定义view超萌小炸弹

最新推荐文章于 2023-06-27 06:45:00 发布
最新推荐文章于 2023-06-27 06:45:00 发布
阅读量316 收藏 1
点赞数

BombView：

package com.example.a08_bomb;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Camera;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.DashPathEffect;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.PathMeasure;
import android.graphics.Point;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.RectF;
import android.os.Build;
import android.support.annotation.Nullable;
import android.support.annotation.RequiresApi;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.View;
import android.view.animation.DecelerateInterpolator;

/**
 * Created by yujie on 2017/12/6.
 */

public class BombView extends View {
    private Paint mPaint;
    private Path mPath, mHeadLinePath ,mHeadPath ,mBodyLightPath;
    private int bombColor = Color.parseColor("#88B0E8");
    private int bombLineColor = Color.parseColor("#181D82");
    private int bombShadowColor = Color.parseColor("#77609ee6");
    private int lightColor = Color.WHITE;
    private int bombLineWidth;
    //炸弹身体半径 高光半径
    private int bodyRadius, highLightRadius;
    //用于处理线条的分割点
    private DashPathEffect groundDashPathEffect,bodyDashPathEffect,highLightPathEffect,mHeadEffect;
    private RectF mRectF;
    private PathMeasure mPathMeasure=new PathMeasure();
    private float[] mPathPosition=new float[2];
    //动画控制相关
    private float faceLROffset , faceMaxLROffset;
    private float faceTBOffset =0, faceMaxTBOffset;
    private float bombLRRotate =15, bombMaxLRRotate =15 ,bombTBRotate=0, bombMaxTBRotate =5;
    private float eyeRadius,eyeMaxRadius,eyeMinRadius;
    private float headLinePercent=1,headLineLightRate=0;
    private float maxBlastCircleRadius, currentBlastCircleRadius,blastCircleRadiusPercent;
    //用于计算mouth第二阶段变化
    private float mouthMaxWidthOffset, mouthMaxHeightOffset, mouthWidthOffset=0, mouthHeightOffset =0,mouthOffsetPercent=0;
    //用于计算mouth第一阶段变化
    private float mouthFSMaxWidthOffset,mouthFSMaxHeightOffset,mouthFSWidthOffset=0,mouthFSHeightOffset=0;
    //炸弹的中心点
    private int bombCenterX,bombCenterY;
    //用于控制旋转
    private Camera mCamera=new Camera();
    private Matrix mMatrix=new Matrix();


    public BombView(Context context) {
        super(context);
        init();
    }

    public BombView(Context context, @Nullable AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BombView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    public BombView(Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
        init();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int width=getMeasuredWidth();
        int height=getMeasuredHeight();
        int minLength= (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,100,getContext().getResources().getDisplayMetrics());
        minLength=Math.max(Math.min(width,height),minLength);
        setMeasuredDimension(minLength,minLength);
    }

    private void init() {
        mPaint=new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setDither(true);
        mPaint.setStrokeCap(Paint.Cap.ROUND);
        mPaint.setStrokeJoin(Paint.Join.ROUND);
        mPath=new Path();
        mRectF=new RectF();
        mHeadLinePath =new Path();
        mHeadPath =new Path();
        mBodyLightPath =new Path();
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        bombLineWidth =getMeasuredWidth()/35;
        mPaint.setStrokeWidth(bombLineWidth);
        float[] groundEffectFloat=new float[]{bombLineWidth/4,bombLineWidth/2+bombLineWidth,bombLineWidth*2,bombLineWidth/3*2+bombLineWidth,getMeasuredWidth(),0};
        groundDashPathEffect=new DashPathEffect(groundEffectFloat,0);
        bodyRadius= (int) (getMeasuredHeight()/3.4f);
        float[] bodyEffectFloat=new float[]{getRadianLength(56,bodyRadius)
                ,getRadianLength(4,bodyRadius)+bombLineWidth
                ,getRadianLength(2.5f,bodyRadius)
                ,getRadianLength(4,bodyRadius)+bombLineWidth
                ,getRadianLength(220,bodyRadius)
                ,getRadianLength(12,bodyRadius)+bombLineWidth
                ,getRadianLength(90,bodyRadius)
                ,0};
        bodyDashPathEffect=new DashPathEffect(bodyEffectFloat,0);

        highLightRadius =bodyRadius/3*2;
        float[] highLightFloat=new float[]{0,getRadianLength(95, highLightRadius)
                ,getRadianLength(0.5f, highLightRadius)
                ,getRadianLength(5, highLightRadius)+bombLineWidth
                ,getRadianLength(12, highLightRadius)
                ,getRadianLength(5, highLightRadius)+bombLineWidth
                ,getRadianLength(24, highLightRadius)
                ,getRadianLength(270, highLightRadius)};
        highLightPathEffect=new DashPathEffect(highLightFloat,0);

        float padding= (float) (2*bombLineWidth*Math.PI/2/72);
        mHeadEffect=new DashPathEffect(new float[]{padding*2,padding},0);

        faceMaxLROffset =bodyRadius/3;
        faceLROffset =-faceMaxLROffset;
        eyeRadius=eyeMaxRadius=bombLineWidth/2;
        eyeMinRadius=eyeMaxRadius/6;

        faceMaxTBOffset=bodyRadius/3;
        maxBlastCircleRadius = getMeasuredWidth()*(2);

        mouthMaxWidthOffset =bodyRadius/5-bodyRadius/5/10;
        mouthMaxHeightOffset =bodyRadius/5/2;

        mouthFSMaxWidthOffset= mouthMaxWidthOffset/3;
        mouthFSMaxHeightOffset = mouthMaxHeightOffset/2;

        bombCenterX=getMeasuredWidth()/2;
        bombCenterY=getMeasuredHeight()-bombLineWidth-bodyRadius;

        setHeadLinePath();
        setHeadPath();
        setBodyLightPath();
    }

    private void setBodyLightPath() {
        //160度坐标计算
        mBodyLightPath.reset();
        Point point=getPointInCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth,160);
        mBodyLightPath.moveTo(point.x-bodyRadius,point.y);
        mBodyLightPath.lineTo(point.x,point.y);
        Point pointControl=getPointInCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth+bombLineWidth*2.2f,210);
        point=getPointInCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth,260);
        mBodyLightPath.quadTo(pointControl.x,pointControl.y,point.x,point.y);
        mBodyLightPath.lineTo(point.x-bodyRadius,point.y);
        mBodyLightPath.close();
    }

    private void setHeadPath() {
        mHeadPath.reset();
        mHeadPath.moveTo(bombCenterX-bodyRadius/5,getMeasuredHeight()/2);
        mHeadPath.lineTo(bombCenterX+bodyRadius/5,getMeasuredHeight()/2);
        mHeadPath.lineTo(bombCenterX+bodyRadius/5,bombCenterY-bodyRadius-bodyRadius/4);
        mHeadPath.lineTo(bombCenterX,bombCenterY-bodyRadius-bodyRadius/4-bodyRadius/4/4);
        mHeadPath.lineTo(bombCenterX-bodyRadius/5,bombCenterY-bodyRadius-bodyRadius/4);
        mHeadPath.close();
    }

    private void setHeadLinePath() {
        float beginY=bombCenterY-bodyRadius-bodyRadius/4-bodyRadius/4/4;
        mHeadLinePath.reset();
        mHeadLinePath.moveTo(bombCenterX,beginY);
        float controlY=beginY-bodyRadius/2.2f;
        float bottomPointY=bombCenterY-bodyRadius;//转折点高度
        mHeadLinePath.quadTo(bombCenterX+bodyRadius/2/5,controlY,bombCenterX+bodyRadius/2,controlY);
        mHeadLinePath.cubicTo(bombCenterX+bodyRadius/2+bodyRadius/2/5*4,controlY
                ,bombCenterX+bodyRadius/2*2f-bodyRadius/16,bottomPointY-bodyRadius/6
                ,bombCenterX+bodyRadius/2*2f,bottomPointY);
        mHeadLinePath.quadTo(bombCenterX+bodyRadius/2*2f+bodyRadius/16,bottomPointY+bodyRadius/6
                ,bombCenterX+bodyRadius/2*2f+bodyRadius/7,bottomPointY+bodyRadius/4);
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        drawHead(canvas);//头部小房子
        drawGround(canvas);//地板
        drawBody(canvas);//身体
        drawBodyBorder(canvas);//身体边框
        drawFace(canvas);//脸
        drawFaceShadow(canvas);//脸阴影
        drawHeadLine(canvas);//头部的炸弹线
        drawBlast(canvas);//爆炸
    }

    private void drawFaceShadow(Canvas canvas) {
        //两个圆相交产生阴影
        int save=canvas.saveLayer(0,0,getMeasuredWidth(),getMeasuredHeight(),null,Canvas.ALL_SAVE_FLAG);
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(bombShadowColor);
        canvas.drawCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth/2,mPaint);
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
        canvas.translate(-bodyRadius/5,-bodyRadius/5);
        mPaint.setColor(bombColor);
        canvas.drawCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth/2,mPaint);
        canvas.restoreToCount(save);
        mPaint.setXfermode(null);
    }

    private void drawFace(Canvas canvas) {
        canvas.save();
        mCamera.save();
        mCamera.rotate(bombTBRotate,0,-bombLRRotate/3);
        mMatrix.reset();
        mCamera.getMatrix(mMatrix);
        mCamera.restore();
        mMatrix.preTranslate(-bombCenterX,-(bombCenterY));
        mMatrix.postTranslate(bombCenterX,bombCenterY);
        mMatrix.postTranslate(faceLROffset,faceTBOffset);
        canvas.concat(mMatrix);
        //眼睛 椭圆控制
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(bombLineColor);
        float eyeY=bombCenterY+bodyRadius/5;
        float eyeWidth=Math.max(eyeMaxRadius,eyeRadius);
        mRectF.set(bombCenterX-bodyRadius/3.5f-eyeWidth,eyeY-eyeRadius
                ,bombCenterX-bodyRadius/3.5f+eyeWidth,eyeY+eyeRadius);
        canvas.drawOval(mRectF,mPaint);
        mRectF.set(bombCenterX+bodyRadius/3.5f-eyeWidth,eyeY-eyeRadius
                ,bombCenterX+bodyRadius/3.5f+eyeWidth,eyeY+eyeRadius);
        canvas.drawOval(mRectF,mPaint);
        //画嘴巴 路径
        float mouthY=eyeY+bombLineWidth- mouthHeightOffset;//嘴巴起始高度
        float mouthMaxY=mouthY+bodyRadius/7+ mouthHeightOffset - mouthFSHeightOffset;//嘴巴最底部
        float mouthHalfDistance=bodyRadius/5-mouthWidthOffset*0.5f + mouthFSWidthOffset;//嘴巴顶部的拐角的一半宽度
        float mouthTopHalfDistance=(mouthHalfDistance-bodyRadius/5/10)-mouthWidthOffset; //嘴巴顶部的一半宽度
        float mouthHorDistanceHalf=(mouthMaxY-mouthY)/(6-4*mouthOffsetPercent);//嘴角控制点的距离嘴角点的竖直距离
        if (mouthTopHalfDistance<bodyRadius/5/10){//让过渡更加自然
            mouthTopHalfDistance=0;
        }
        mPath.reset();
        mPath.moveTo(bombCenterX-mouthTopHalfDistance,mouthY);
        mPath.lineTo(bombCenterX+mouthTopHalfDistance,mouthY);

        mPath.quadTo(bombCenterX+mouthHalfDistance,mouthY,
                bombCenterX+mouthHalfDistance,mouthY+mouthHorDistanceHalf);
        mPath.cubicTo(bombCenterX+mouthHalfDistance,mouthY+mouthHorDistanceHalf*2,
                bombCenterX+(mouthHalfDistance-bodyRadius/5/4)*(1-mouthOffsetPercent),mouthMaxY,
                bombCenterX,mouthMaxY);

        mPath.cubicTo(bombCenterX-(mouthHalfDistance-bodyRadius/5/4)*(1-mouthOffsetPercent),mouthMaxY,
                bombCenterX-mouthHalfDistance,mouthY+mouthHorDistanceHalf*2,
                bombCenterX-mouthHalfDistance,mouthY+mouthHorDistanceHalf);
        mPath.quadTo(bombCenterX-mouthHalfDistance,mouthY,bombCenterX-mouthTopHalfDistance,mouthY);
        mPath.close();
        canvas.drawPath(mPath,mPaint);
        //画舌头 圆和嘴巴的缩放相交
        int save=canvas.saveLayer(0,0,getMeasuredWidth(),getMeasuredHeight(),null,Canvas.ALL_SAVE_FLAG);
        canvas.drawPath(mPath,mPaint);
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        mPaint.setColor(Color.parseColor("#f34671"));
        canvas.drawCircle(bombCenterX,mouthY+(mouthMaxY-mouthY)/8+bodyRadius/(5-1.4f*mouthOffsetPercent),bodyRadius/5,mPaint);
        mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
        canvas.scale(0.8f,0.8f,bombCenterX,(mouthMaxY+mouthY)/2);
        canvas.drawPath(mPath,mPaint);
        canvas.restoreToCount(save);
        mPaint.setXfermode(null);
        //酒窝
        mPaint.setColor(Color.parseColor("#5689cc"));
        canvas.drawCircle(bombCenterX-bodyRadius/3.5f-bombLineWidth,(mouthMaxY+mouthY)/2,bombLineWidth/3,mPaint);
        canvas.drawCircle(bombCenterX+bodyRadius/3.5f+bombLineWidth,(mouthMaxY+mouthY)/2,bombLineWidth/3,mPaint);
        mPaint.setPathEffect(null);
        canvas.restore();
    }

    private void drawBlast(Canvas canvas) {
        if (blastCircleRadiusPercent==0){
            return;
        }
        float circleY=bombCenterY-bodyRadius-bodyRadius/4-bodyRadius/4/4;
        int save = canvas.saveLayer(0,0,getMeasuredWidth(),getMeasuredHeight(),null,Canvas.ALL_SAVE_FLAG);
        float distance = maxBlastCircleRadius/12;
        //画圆
        mPaint.setColor(lightColor);
        canvas.drawCircle(bombCenterX,circleY, currentBlastCircleRadius,mPaint);
        mPaint.setColor(bombColor);
        canvas.drawCircle(bombCenterX,circleY, currentBlastCircleRadius -distance,mPaint);
        mPaint.setColor(bombLineColor);
        canvas.drawCircle(bombCenterX,circleY, currentBlastCircleRadius -distance*2,mPaint);
        mPaint.setColor(lightColor);
        canvas.drawCircle(bombCenterX,circleY, currentBlastCircleRadius -distance*3,mPaint);
        //掏空
        if (blastCircleRadiusPercent >0.65) {
            mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT));
            canvas.drawCircle(bombCenterX, circleY, currentBlastCircleRadius - maxBlastCircleRadius * 0.65f, mPaint);
            mPaint.setXfermode(null);
        }
        canvas.restoreToCount(save);
    }

    private void drawHeadLine(Canvas canvas) {
        canvas.save();
        mCamera.save();
        mCamera.rotate(bombTBRotate,0,-bombLRRotate);
        mMatrix.reset();
        mCamera.getMatrix(mMatrix);
        mCamera.restore();
        mMatrix.preTranslate(-bombCenterX,-bombCenterY);
        mMatrix.postTranslate(bombCenterX,bombCenterY);
        canvas.concat(mMatrix);
        mPaint.setColor(bombLineColor);
        mPaint.setStyle(Paint.Style.STROKE);
        mPathMeasure.setPath(mHeadLinePath,false);
        mPath.reset();
        mPathMeasure.getSegment(0,mPathMeasure.getLength()*headLinePercent,mPath,true);
        canvas.drawPath(mPath,mPaint);
        //火光
        mPathMeasure.setPath(mPath,false);
        float length=mPathMeasure.getLength();
        mPathMeasure.getPosTan(length,mPathPosition,null);
        mPaint.setColor(Color.parseColor("#fbb42d"));
        mPaint.setStyle(Paint.Style.FILL);
        canvas.drawCircle(mPathPosition[0],mPathPosition[1],Math.max(bombLineWidth/1.3f*headLineLightRate,bombLineWidth/2*1.2f),mPaint);
        mPaint.setColor(Color.parseColor("#f34671"));
        mPath.reset();
        mPath.addCircle(mPathPosition[0],mPathPosition[1],bombLineWidth/2.5f*headLineLightRate, Path.Direction.CCW);
        mPaint.setPathEffect(mHeadEffect);
        canvas.drawPath(mPath,mPaint);
        mPaint.setPathEffect(null);
        mPaint.setColor(Color.WHITE);
        canvas.drawCircle(mPathPosition[0],mPathPosition[1], bombLineWidth /6.5f * headLineLightRate,mPaint);
        canvas.restore();
    }

    private void drawHead(Canvas canvas) {
        canvas.save();
        mCamera.save();
        mCamera.rotate(bombTBRotate,0,-bombLRRotate);
        mMatrix.reset();
        mCamera.getMatrix(mMatrix);
        mCamera.restore();
        mMatrix.preTranslate(-bombCenterX,-(bombCenterY));
        mMatrix.postTranslate(bombCenterX,(bombCenterY));
        canvas.concat(mMatrix);

        mPaint.setStrokeWidth(bombLineWidth*0.8f);
        //内部
        mPaint.setColor(bombColor);
        mPaint.setStyle(Paint.Style.FILL);
        canvas.drawPath(mHeadPath,mPaint);
        //边框
        mPaint.setColor(bombLineColor);
        mPaint.setStyle(Paint.Style.STROKE);
        canvas.drawPath(mHeadPath,mPaint);
        mPaint.setStrokeWidth(bombLineWidth);
        canvas.restore();
    }

    private void drawBody(Canvas canvas) {
        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(bombColor);
        canvas.drawCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth/2,mPaint);
        //左上角光点
        mPaint.setPathEffect(highLightPathEffect);
        mPaint.setColor(lightColor);
        mPaint.setStyle(Paint.Style.STROKE);
        mPath.reset();
        mPath.addCircle(bombCenterX,bombCenterY, highLightRadius, Path.Direction.CCW);
        canvas.drawPath(mPath,mPaint);
        //左上角的光边
        mPaint.setPathEffect(null);
        mRectF.set(bombCenterX-bodyRadius+bombLineWidth/2,bombCenterY-bodyRadius+bombLineWidth/2
                ,bombCenterX+bodyRadius-bombLineWidth/2,getMeasuredHeight()-bombLineWidth-bombLineWidth/2);
        canvas.drawArc(mRectF,160,100,false,mPaint);
        //拼接光边
        mPath.reset();
        mPath.addCircle(bombCenterX,bombCenterY,bodyRadius-bombLineWidth/2, Path.Direction.CCW);
        canvas.save();
        canvas.clipPath(mPath);//裁剪圆内

        mPaint.setStyle(Paint.Style.FILL);
        mPaint.setColor(lightColor);
        canvas.drawPath(mBodyLightPath,mPaint);
        canvas.restore();
    }


    private Point getPointInCircle(int circleX,int circleY,float radius,float angle){
        Point mPoint=new Point();
        mPoint.set((int)(circleX + radius * Math.cos(Math.toRadians(angle))),
                (int)(circleY+radius*Math.sin(Math.toRadians(angle))));
        return mPoint;
    }

    private void drawBodyBorder(Canvas canvas) {
        canvas.save();
        canvas.rotate(bombLRRotate,bombCenterX,bombCenterY);
        mPaint.setPathEffect(bodyDashPathEffect);
        mPaint.setColor(bombLineColor);
        mPaint.setStyle(Paint.Style.STROKE);
        mPath.reset();
        mPath.addCircle(bombCenterX,bombCenterY,bodyRadius, Path.Direction.CW);
        canvas.drawPath(mPath,mPaint);
        canvas.restore();
    }

    private void drawGround(Canvas canvas) {
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setColor(bombLineColor);
        mPaint.setPathEffect(groundDashPathEffect);
        mPath.reset();
        mPath.moveTo(bombLineWidth/2,getMeasuredHeight()-bombLineWidth/2);
        mPath.lineTo(getMeasuredWidth()-bombLineWidth/2,getMeasuredHeight()-bombLineWidth/2);
        canvas.drawPath(mPath,mPaint);
    }

    private AnimatorSet set=new AnimatorSet();
    public void startAnim(){
        stopAnim();
        ValueAnimator faceTBAnim=getFaceTopBottomAnim();
        ValueAnimator faceLRAnim=getFaceLeftRightAnim();
        AnimatorSet faceChangeAnim=getFaceChangeAnim();
        set.play(getBlastAnim()).after(faceChangeAnim);
        set.play(faceChangeAnim).after(faceTBAnim);
        set.play(faceTBAnim).after(faceLRAnim);
        set.play(faceLRAnim).with(getHeadLineAnim());
        set.start();
    }

    public void stopAnim(){
        set.cancel();
        initData();
        invalidate();
    }

    private void initData() {
        faceTBOffset=0;
        bombTBRotate=0;
        bombLRRotate=15;
        faceLROffset=-faceMaxLROffset;
        currentBlastCircleRadius =0;
        blastCircleRadiusPercent=0;
        eyeRadius=eyeMaxRadius;
        headLinePercent=1;
        mouthWidthOffset=0;
        mouthHeightOffset =0;
        mouthOffsetPercent=0;
        mouthFSWidthOffset=0;
        mouthFSHeightOffset=0;
        headLineLightRate=0;
    }

    private int getFaceChangeAnimTime(){
        return 450;
    }

    private AnimatorSet getFaceChangeAnim(){
        AnimatorSet animatorSet=new AnimatorSet();
        //眼睛
        ValueAnimator valueAnimator= ValueAnimator.ofFloat(1,0,1.4f)
                .setDuration(getFaceChangeAnimTime());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                eyeRadius=eyeMaxRadius*(float) animation.getAnimatedValue();
                if (eyeRadius<eyeMinRadius){
                    eyeRadius=eyeMinRadius;
                }
            }
        });

        ValueAnimator mouthAnimator=ValueAnimator.ofFloat(0,1,0,1)
                .setDuration(getFaceChangeAnimTime());
        mouthAnimator.setInterpolator(new DecelerateInterpolator());
        mouthAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float value= (float) animation.getAnimatedValue();
                if (animation.getAnimatedFraction()>0.75){//第一阶段还是第二阶段
                    mouthWidthOffset=mouthMaxWidthOffset*value;
                    mouthHeightOffset = mouthMaxHeightOffset *value;
                    mouthOffsetPercent=animation.getAnimatedFraction();
                }else{
                    mouthFSWidthOffset=mouthFSMaxWidthOffset*value;
                    mouthFSHeightOffset=mouthFSMaxHeightOffset*value;
                }
                invalidate();
            }
        });
        animatorSet.play(valueAnimator).with(mouthAnimator);
        return animatorSet;
    }

    private int getFaceTopBottomAnimTime(){
        return 300;
    }
    private int getFaceTopBottomAnimDelayTime(){
        return 200;
    }

    private ValueAnimator getFaceTopBottomAnim(){
        ValueAnimator objectAnimator= ValueAnimator.ofFloat(0,1)
                .setDuration(getFaceTopBottomAnimTime());
        objectAnimator.setStartDelay(getFaceTopBottomAnimDelayTime());
        objectAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float value= (float) animation.getAnimatedValue();
                faceTBOffset= -faceMaxTBOffset*value;
                bombTBRotate= bombMaxTBRotate*value;
                invalidate();
            }
        });
        return objectAnimator;
    }

    private int getFaceLeftRightAnimTime(){
        return 1400;
    }
    private ValueAnimator getFaceLeftRightAnim(){
        ValueAnimator valueAnimator= ValueAnimator.ofFloat(-1,0,1,0)
                .setDuration(getFaceLeftRightAnimTime());
        valueAnimator.setInterpolator(new DecelerateInterpolator());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float value= (float) animation.getAnimatedValue();
                faceLROffset = faceMaxLROffset *value;
                bombLRRotate = -bombMaxLRRotate *value;
                if (Math.abs(value)<0.3&&animation.getAnimatedFraction()<0.6){
                    eyeRadius=Math.max(eyeMaxRadius*Math.abs(value),eyeMinRadius);
                }else{
                    eyeRadius=eyeMaxRadius;
                }
                invalidate();
            }
        });
        return valueAnimator;
    }

    private int getHeadLineAnimTime(){
        return getFaceLeftRightAnimTime()+getFaceTopBottomAnimTime()+getFaceTopBottomAnimDelayTime()+getFaceChangeAnimTime()+500;
    }
    private AnimatorSet getHeadLineAnim(){
        AnimatorSet animatorSet=new AnimatorSet();
        ValueAnimator valueAnimator= ValueAnimator.ofFloat(1f,0f)
                .setDuration(getHeadLineAnimTime());
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                headLinePercent= (float) animation.getAnimatedValue();
                invalidate();
            }
        });
        ValueAnimator valueAnimatorLight=ValueAnimator.ofFloat(0f,1.3f,0f)
                .setDuration(getHeadLineAnimTime()/5);
        valueAnimatorLight.setRepeatCount(5);
        valueAnimatorLight.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                headLineLightRate= (float) animation.getAnimatedValue();
            }
        });
        animatorSet.play(valueAnimator).with(valueAnimatorLight);
        return animatorSet;
    }

    private ValueAnimator getBlastAnim(){
        ValueAnimator valueAnimator= ValueAnimator.ofFloat(0,maxBlastCircleRadius)
                .setDuration(500);
        valueAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                if (animation.getAnimatedFraction()>0.7f){
                    initData();
                }
                currentBlastCircleRadius = (float) animation.getAnimatedValue();
                blastCircleRadiusPercent=animation.getAnimatedFraction();
                invalidate();
            }
        });
        valueAnimator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                super.onAnimationEnd(animation);
                initData();
                invalidate();
            }
        });
        return valueAnimator;
    }

    private float getRadianLength(float angle,float radius){
        return (float) (angle*Math.PI*radius/180f);
    }
}
布局中使用：
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.a08_bomb.MainActivity">

    <com.example.a08_bomb.BombView
        android:id="@+id/bomb_view"
        android:layout_centerInParent="true"
        android:layout_width="300dp"
        android:layout_height="300dp" />

</RelativeLayout>

代码：
package com.example.a08_bomb;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        final BombView bombView = findViewById(R.id.bomb_view);
        bombView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                bombView.startAnim();
            }
        });
    }
}

rookieForAndroid
关注
android 自定义View实现粒子爆炸效果
安卓兼职framework和app工程师的博客
08-26 934
今天看到一个粒子爆炸动画效果感觉特别的漂亮，仔细研究了下实现了下 也是用ValueAnimator动画实现 先看效果图： 接下来讲解下自定义动画 GrainView.java import android.animation.ValueAnimator; import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.
android view超出屏幕_自定义View超出屏幕大小，如何滑屏
weixin_39842475的博客
12-19 2434
自定义View超出屏幕大小，在自定义View里面重写了onTouchEvent方法，请问，如何在caseMotionEvent.ACTION_MOVE:中操作？我看网上说结合scrollTo和scrollBy方法，但也没说具体怎么结合，它们之间是如何调用了？下面是我的代码：activity：public class AndroidTest03 extends Activity {@Override...
感受一波Android自定义view实现超萌动感小炸弹
huahaiyi的博客
06-27 163
老规矩，咱们先来看看效果图！再来看android的实现效果。下面我们和自定义view实现超萌动感天气小太阳一样，开始解析动画！（没看过天气小太阳的朋友可以先去看天气小太阳，有些天气小太阳讲过的套路将不再讲，同时需要掌握path、camera、贝塞尔曲线等，不然部分代码可能会引起不适）。我们先把静态view绘制出来，然后再实现动画，Let’s go。
ios-点击按钮爆炸效果.zip
07-11
点击按钮爆炸效果
一行代码实现任意View的粒子爆炸效果
start_mao的博客
12-12 432
使用方法很简单，只需要一行代码。 BombViewUtil.bomb(view,null);//该view需要展现粒子爆炸效果时调用 比如对于常见的ImageView、Button、TextView调用上面的方法，效果如下。 分析实现： 1、首先要明白爆炸的不是真正的TextView或者Button，而是他们对应的快照。通过下面这个方法就可以获得某个View对应的Bitmap。 targe...
Android高手进阶之自定义View，自定义属性（带进度的圆形进度条）源码
08-25
在Android开发中，自定义View是一项重要的技能，它允许开发者根据特定需求创建独特且功能丰富的UI组件。本篇文章将深入探讨如何实现一个自定义的、带有进度指示的圆形进度条，以此来提升用户界面的交互体验。我们...
Android 自定义View (四) 视频音量调控
04-26
在Android开发中，自定义View是一项重要的技能，它允许开发者根据特定需求创建独特且功能丰富的用户界面。本教程将深入探讨如何实现一个自定义的音量调控View，以提供更直观、更个性化的音量控制体验。我们参考的...
android 自定义view 高度,自定义View之宽高的设置，全网最详解
weixin_29513805的博客
05-25 4229
今天给大家带来的是自定义View，然后如何设置他的宽高，经常用自定义view的程序猿肯定都知道我们在给自定义view设置wrap_content或者match_parent，view都会占满全屏，就想如下以下是方法，不提供自定义view的布局了，很简单，就是绘一个蓝色的圆第一种方式(布局修改)第一种方法也是最简单的方法，我们直接给自定义view限制一个宽高xmlns:app="http://sch...
Android自定义View贪吃蛇-超简单、好理解
07-12
Android自定义View贪吃蛇-超简单、好理解
android炸弹爆炸游戏
12-04
android炸弹爆炸游戏，帧动画，补间动画效果都有，还加了音乐效果，还在完善中
Android炸弹人游戏源码.rar
10-27
Android炸弹人游戏源码.rar
Android开发实例简化版--炸弹超人源代码
03-16
该小型程序利用简单的代码组合逻辑，非常适合刚入门的、急需通过实战练习的Android学习者学习，不容错过哦！
Android 游戏开发之爆炸效果
huazaichang的专栏
09-05 452
在做Android游戏MagicBubble开发的时候，在连通两个Bubbles的时候，Bubble会以水泡爆破的情形消失。为了实现这一效果，我查找了不少资料，希望能找到一些标准的实现方面，花了不少时间，发觉Android关于游戏开发的资料实在太少了，更不用说标准做法了，没办法，只能按照自己的思路来实现这一效果。     我的思路是这样的（仅供参考，希望有更好做法的朋友跟我们共享一下）：在Fra
Android Canvas进阶之自定义View实现粒子爆炸效果
zb987570437的博客
09-07 616
话不多少，先上效果图，觉得简单的请轻喷。 老婆爆炸。。。哦不，是图片爆炸后是多个粒子移动，因此每个粒子都是一个对象，首先定义粒子对象，粒子是圆形的，首先是粒子的颜色，，然后是粒子的圆心坐标和粒子半径，这就已经能够确定一个粒子，然后爆炸后粒子需要有速度和加速度，上码 public class Ball { public int color; //图片像素点颜色值 publi...
android 烟花动画效果图,Android烟花效果（SurfaceView实现）
weixin_42342010的博客
05-25 730
/** * 直播页面点赞特效，采用SurfaceView绘制 * 与普通控件使用方法类似，点赞是只需要调用startBomb()即可 */public class BombView extends SurfaceView implements SurfaceHolder.Callback {private static final int MAX_BUBBLE_COUNT = 90;private...
Android实现图片点击爆炸效果
adolph_lu的博客
09-19 941
实现效果： 需要注意的点： ValueAnimator ValueAnimator，是针对值的，也就是说ValueAnimator不会对控件进行任何操作，而是控制值的变化，然后我们监听这个值的变化过程，从而来控制控件的变化。什么意思呢？例如我们使用属性动画来控制TextView的位移，我们在初始化ValueAnimator时，会设置一个初始值和结束的值，假如我用这两个值来控制Tex...
AnimationDrawable逐帧动画--爆炸效果
03-04 1489
1基于STM32的智能气象站项目.docx
最新发布
10-30
1基于STM32的智能气象站项目
Android自定义View：手指拖动小兔子教程
本文主要介绍了如何在Android平台上通过自定义View来实现一个小兔子跟随用户手指移动的效果。首先，我们需要创建一个新的项目，并在其中添加一个新的模块。接着，将所需的背景图像和兔子图片放入项目的mipmap目录中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值