android拼图代码（android 拼图）

今天给各位分享android拼图代码的知识，其中也会对android 拼图进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、android拼图游戏怎么实现记录最佳完成时间
• 2、android拼图游戏源码 不要选择难度,怎么默认设置3*3?
• 3、android滑动拼图验证码控件

android拼图游戏怎么实现记录最佳完成时间

第一次玩就把这个时间记录下来，之后每次玩都把这个时间取出来和游戏时间对比，如果本次游戏时间比之前存的那个时间短，就记录本次玩的时间就收最佳完成时间

android拼图游戏源码 不要选择难度,怎么默认设置3*3?

主界面开始之前，可以在该按钮选择附加选项，代表意义是：是否开始声音、是否继续上次最后玩的拼图、是否随机选择一幅拼图。

菜单，可分类管理：在列表右侧，可上下拖动排序；在列表左侧，可长按分类的更新、添加、删除操作，可选择媒体库(sdcard 里图片)玩拼图。

列表界面图片，可跳到拼图界面。

长按图片，可以下操作：

开始 + 完成赠言，那么在完成拼图后，会显示您为该图片设置的赠言，这个功能只要是为了，当您想找别人玩您指定的拼图，当别人完成时可以看到您设置的赠言，增加些乐趣。

开始 + 比赛，那么您就可以和别人一起来玩拼图比赛（两幅同样的图同样的玩法设置），赛事完成后，会统计你们的各自所走的步数和用时。

改变分类，可对该图分类改变操作。

删除，可删除该图。

拆散关卡类，可对是关卡类的图拆散操作。

菜单，可以下操作：

分类筛选，快速找到该分类拼图。

操作选择，必须先选择图片，然后可以将选择的图片改变分类、组成关卡类、删除操作。

排序操作，当排序后，可图片列表的图片排序：先一张图片，然后再另一张图片，那么这两张图片就会互换位置，从而达到排序效果。

拼图界面菜单，可玩法设置。左右滑动可对照完整拼图。

android滑动拼图验证码控件

package com.yolanda.code.library.widget;

import android.animation.ValueAnimator;

import android.content.Context;

import android.graphics.Bitmap;

import android.os.Handler;

import android.util.AttributeSet;

import android.view.View;

import android.view.ViewGroup;

import android.view.animation.AlphaAnimation;

import android.view.animation.Animation;

import android.view.animation.LinearInterpolator;

import android.view.animation.TranslateAnimation;

import android.widget.FrameLayout;

import android.widget.ImageView;

import android.widget.SeekBar;

import android.widget.TextView;

import com.yolanda.code.library.R;

import com.yolanda.code.library.view.DiyStyleTextView;

/**

* @author Created by Yolanda on 2018/10/31.

* @description 滑动拼图验证码

*/

public final class DragImageView extends FrameLayout implements SeekBar.OnSeekBarChangeListener {

    private final int showTipsTime = 1500;

    private final int animeTime = 333;

    private final int flashTime = 800;

    private ImageView ivCover;

    private ImageView ivBlock;

    private SeekBar sb;

    private TextView tvTips2;

    private DiyStyleTextView tvTips;

    private View vFlash, flContent;

    private Handler handler = new Handler();

    private Bitmap cover, block, completeCover;

    private boolean isNormal;

    public DragImageView(Context context) {

        super(context);

        init();

    }

    public DragImageView(Context context, AttributeSet attrs) {

        super(context, attrs);

        init();

    }

    public DragImageView(Context context, AttributeSet attrs, int defStyle) {

        super(context, attrs, defStyle);

        init();

    }

    private void init() {

        View.inflate(getContext(), R.layout.drag_view, this);

        flContent = findViewById(R.id.drag_fl_content);

        ivCover = findViewById(R.id.drag_iv_cover);

        ivBlock = findViewById(R.id.drag_iv_block);

        tvTips = findViewById(R.id.drag_tv_tips);

        tvTips2 = findViewById(R.id.drag_tv_tips2);

        vFlash = findViewById(R.id.drag_v_flash);

        tvTips.setColorRegex("拼图|成功|失败|正确|[\\d\\.%]+", 0xfff75151);

        sb = findViewById(R.id.drag_sb);

        sb.setMax(getContext().getResources().getDisplayMetrics().widthPixels);

        sb.setOnSeekBarChangeListener(this);

        reset();

    }

    /**

    * 设置资源

    *

    * @param cover        拼图

    * @param block        滑块

    * @param completeCover 完成的拼图

    * @param block_y      滑块Y值比例

    */

    public void setUp(Bitmap cover, Bitmap block, Bitmap completeCover, float block_y) {

        this.cover = cover;

        this.block = block;

        this.completeCover = completeCover;

        ivCover.setImageBitmap(completeCover);

        ivBlock.setImageBitmap(block);

        setLocation(1f * cover.getWidth() / cover.getHeight(), 1f * block.getHeight() / cover.getHeight(), block_y);

    }

    /**

    * 设置比例大小

    *

    * @param cover_wph  图片bili

    * @param block_size 滑块大小占高比

    * @param block_y    滑块位置占高比

    */

    private void setLocation(final float cover_wph, final float block_size, final float block_y) {

        post(new Runnable() {

            @Override

            public void run() {

                final int w = flContent.getMeasuredWidth();

                int h = (int) (w / cover_wph);

                ViewGroup.LayoutParams l = flContent.getLayoutParams();

                l.width = w;

                l.height = h;

                flContent.setLayoutParams(l);

                ViewGroup.MarginLayoutParams l2 = (MarginLayoutParams) ivBlock.getLayoutParams();

                l2.height = (int) (h * block_size);

                l2.width = l2.height * block.getWidth() / block.getHeight();

                l2.topMargin = (int) (h * block_y);

                ivBlock.setLayoutParams(l2);

            }

        });

    }

    public void ok() {

        ivCover.setImageBitmap(completeCover);

        blockHideAnime();

        int penset = (int) (99 - (timeUse 1 ? timeUse - 1 : 0) / 0.1f);

        if (penset 1) penset = 1;

        tvTips.setText(String.format("拼图成功: 耗时%.1f秒,打败了%d%%的用户!", timeUse, penset));

        tipsShowAnime(true);

        flashShowAnime();

        sb.setEnabled(false);

    }

    public void fail() {

        twinkleImage(ivBlock);

        tvTips.setText("拼图失败: 请重新拖曳滑块到正确的位置!");

        tipsShowAnime(true);

        handler.postDelayed(resetRun, showTipsTime);

        sb.setEnabled(false);

    }

    public void reset() {

        final int position = sb.getProgress();

        if (position != 0) {

            ValueAnimator animator = ValueAnimator.ofFloat(1f, 0);

            animator.setDuration(animeTime).start();

            animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

                @Override

                public void onAnimationUpdate(ValueAnimator animation) {

                    float f = (Float) animation.getAnimatedValue();

                    sb.setProgress((int) (position * f));

                }

            });

        }

        tipsShowAnime(false);

        tips2ShowAnime(true);

        sb.setEnabled(true);

        ivBlock.setVisibility(GONE);

        vFlash.setVisibility(GONE);

        ivCover.setImageBitmap(completeCover);

        isNormal = true;

    }

    //===================seekbar监听===================

    private long timeTemp;

    private float timeUse;

    @Override

    public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {

        int cw = ivCover.getMeasuredWidth();

        int bw = ivBlock.getMeasuredWidth();

        ViewGroup.MarginLayoutParams l = (MarginLayoutParams) ivBlock.getLayoutParams();

        l.leftMargin = (cw - bw) * progress / seekBar.getMax();

        ivBlock.setLayoutParams(l);

    }

    @Override

    public void onStartTrackingTouch(SeekBar seekBar) {

        ivBlock.setVisibility(VISIBLE);

        ivCover.setImageBitmap(cover);

        tips2ShowAnime(false);

        timeTemp = System.currentTimeMillis();

        isNormal = false;

    }

    @Override

    public void onStopTrackingTouch(SeekBar seekBar) {

        timeUse = (System.currentTimeMillis() - timeTemp) / 1000.f;

        if (dragListenner != null)

            dragListenner.onDrag(seekBar.getProgress() * 1f / seekBar.getMax());

    }

    //===================seekbar监听===================

    //闪烁滑块

    private void twinkleImage(final View view) {

        ValueAnimator animator = ValueAnimator.ofFloat(0, 1.0F);

        animator.setTarget(view);

        animator.setInterpolator(new LinearInterpolator());

        animator.setDuration(showTipsTime).start();

        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

            @Override

            public void onAnimationUpdate(ValueAnimator animation) {

                float f = (Float) animation.getAnimatedValue();

                int time = (int) (showTipsTime * f);

                if (time 125)

                    view.setVisibility(INVISIBLE);

                else if (time 250)

                    view.setVisibility(VISIBLE);

                else if (time 375)

                    view.setVisibility(INVISIBLE);

                else

                    view.setVisibility(VISIBLE);

            }

        });

    }

    //提示文本显示隐藏

    private void tipsShowAnime(boolean isShow) {

        if ((tvTips.getVisibility() == VISIBLE) == isShow)

            return;

        TranslateAnimation translateAnimation = new TranslateAnimation(

                Animation.RELATIVE_TO_SELF, 0f,

                Animation.RELATIVE_TO_SELF, 0f,

                Animation.RELATIVE_TO_SELF, isShow ? 1f : 0f,

                Animation.RELATIVE_TO_SELF, isShow ? 0f : 1f);

        translateAnimation.setDuration(animeTime);

        //translateAnimation.setInterpolator(new LinearInterpolator());

        tvTips.setAnimation(translateAnimation);

        tvTips.setVisibility(isShow ? VISIBLE : GONE);

    }

    //提示文本显示隐藏

    private void tips2ShowAnime(boolean isShow) {

        if ((tvTips2.getVisibility() == VISIBLE) == isShow)

            return;

        AlphaAnimation translateAnimation = new AlphaAnimation(isShow ? 0 : 1, isShow ? 1 : 0);

        translateAnimation.setDuration(animeTime);

        //translateAnimation.setInterpolator(new LinearInterpolator());

        tvTips2.setAnimation(translateAnimation);

        tvTips2.setVisibility(isShow ? VISIBLE : GONE);

    }

    //成功完成拼图滑块消失

    private void blockHideAnime() {

        AlphaAnimation translateAnimation = new AlphaAnimation(1, 0);

        translateAnimation.setDuration(animeTime);

        //translateAnimation.setInterpolator(new LinearInterpolator());

        ivBlock.setAnimation(translateAnimation);

        ivBlock.setVisibility(GONE);

    }

    //失败震动动画

    private void failAnime() {

    }

    //成功高亮动画

    private void flashShowAnime() {

        TranslateAnimation translateAnimation = new TranslateAnimation(

                Animation.RELATIVE_TO_SELF, 1f,

                Animation.RELATIVE_TO_SELF, -1f,

                Animation.RELATIVE_TO_SELF, 0f,

                Animation.RELATIVE_TO_SELF, 0f);

        translateAnimation.setDuration(flashTime);

        //translateAnimation.setInterpolator(new LinearInterpolator());

        vFlash.setAnimation(translateAnimation);

        vFlash.setVisibility(VISIBLE);

        translateAnimation.setAnimationListener(new Animation.AnimationListener() {

            @Override

            public void onAnimationStart(Animation animation) {

            }

            @Override

            public void onAnimationEnd(Animation animation) {

                vFlash.setVisibility(GONE);

            }

            @Override

            public void onAnimationRepeat(Animation animation) {

            }

        });

    }

    //失败延时重置控件

    private Runnable resetRun = new Runnable() {

        @Override

        public void run() {

            tipsShowAnime(false);

            tips2ShowAnime(true);

            sb.setEnabled(true);

            final int position = sb.getProgress();

            ValueAnimator animator = ValueAnimator.ofFloat(1f, 0);

            animator.setDuration(animeTime).start();

            animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

                @Override

                public void onAnimationUpdate(ValueAnimator animation) {

                    float f = (Float) animation.getAnimatedValue();

                    sb.setProgress((int) (position * f));

                }

            });

            isNormal = true;

        }

    };

    //监听

    private DragListenner dragListenner;

    public interface DragListenner {

        void onDrag(float position);

    }

    public void setDragListenner(DragListenner dragListenner) {

        this.dragListenner = dragListenner;

    }

}

android拼图代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于android 拼图、android拼图代码的信息别忘了在本站进行查找喔。