仿球场直播球员跑动控件布局、

最新推荐文章于 2024-08-10 10:05:04 发布
最新推荐文章于 2024-08-10 10:05:04 发布
阅读量163 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26361871/article/details/79563210
版权 
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.animation.DecelerateInterpolator;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.TextView;

import com.bumptech.glide.Glide;
import com.up72.football.R;
import com.up72.football.model.Data2DPlayerModel;
import com.up72.football.utils.Constants;
import com.up72.football.utils.Utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jp.wasabeef.glide.transformations.CropCircleTransformation;


/**
 * 2D直播控件
 * Created by CZF on 2017/05/12.
 */
public class Live2DView extends FrameLayout {
    private OnItemClickListener onItemClickListener;
    private double fieldY = 0;//球场宽 y
    private double fieldX = 0;//球场高 x
    private boolean isSpeedKing;
    private boolean isAllHide = true;
    private boolean hideName;//是否隐藏名称

    private double proportionx = 0;

    private double proportiony = 0;

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

    public Live2DView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public Live2DView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    public void setFieldXY(double fieldX, double fieldY) {
        this.fieldY = fieldY;
        this.fieldX = fieldX;
    }

    // 球场直接的比例
    public void setProportion(double proportionx, double proportiony) {
        this.proportionx = proportionx;
        this.proportiony = proportiony;

    }

    public void setOnItemClickListener(OnItemClickListener onItemClickListener) {
        this.onItemClickListener = onItemClickListener;
    }

    private void init() {
        views.clear();
    }

    /**
     * 是否处于都不显示状态
     */
    public void setAllHide(boolean isAllHide) {
        this.isAllHide = isAllHide;
    }

    public boolean isSpeedKing() {
        return this.isSpeedKing;
    }

    /**
     * 切换显示奔跑王和速度王
     */
    public void setSpeedKing(boolean isSpeedKing) {
        this.isSpeedKing = isSpeedKing;
    }

    private List<View> existView = new ArrayList<>();
    private List<View> noExistView = new ArrayList<>();

    private List<View> views = new ArrayList<>();

    private Map<View, AnimatorSet> maps = new HashMap<>();

    @TargetApi(Build.VERSION_CODES.KITKAT)
    public void pauseAnim(boolean isDown) {
        for (View view : maps.keySet()) {
            if (isDown) {
                maps.get(view).cancel();
                view.clearAnimation();
            } else {
                maps.get(view).pause();
            }
        }
    }

    @TargetApi(Build.VERSION_CODES.KITKAT)
    public void resumeAnim(boolean isDown) {
        for (View view : maps.keySet()) {
            if (isDown) {
                maps.get(view).start();
            } else {
                maps.get(view).resume();
            }
        }
    }


    public void clearAllView() {
        maps.clear();
        existView.clear();
        noExistView.clear();
        views.clear();
        removeAllViews();
    }

    public void clearViewByNonExistence(List<Data2DPlayerModel> list) {
        existView.clear();
        noExistView.clear();
        // TODO: 2017/5/15 找出 集合中所有在场的 View
        for (int i = 0; i < list.size(); i++) {
            for (int j = 0; j < views.size(); j++) {
                Data2DPlayerModel tagModel = (Data2DPlayerModel) views.get(j).getTag();
                if (tagModel.getPlayerId() == list.get(i).getPlayerId()) {
                    existView.add(views.get(j));
                }
            }
        }
         TODO: 2017/5/15 用在场的 View 找出所有不在场的
        for (int i = 0; i < views.size(); i++) {
            boolean isExist = false;
            for (int j = 0; j < existView.size(); j++) {
                if (existView.get(j) == views.get(i)) {
                    isExist = true;
                    break;
                }
            }
            if (!isExist) {
                android.util.Log.e("chenzefeng", "不存在的~~~");
                noExistView.add(views.get(i));
            }
        }
        for (int i = 0; i < noExistView.size(); i++) {
            android.util.Log.e("chenzefeng", "有一个换下");
            noExistView.get(i).clearAnimation();
            removeView(noExistView.get(i));
            views.remove(noExistView.get(i));
        }
    }

    /**
     * 添加2d直播数据
     *  youwenti
     * @param model
     */
    public void addPoint(final Data2DPlayerModel model) {
        final int width = getMeasuredWidth();
        final int height = getMeasuredHeight();
        final int viewWidth = Utils.dip2px(getContext(), 60);
        final int viewHeight = Utils.dip2px(getContext(), 114);
        final int textHeight = Utils.dip2px(getContext(), 14);

        boolean isExist = false;


        for (int i = 0; i < views.size(); i++) {
            Data2DPlayerModel tagModel = (Data2DPlayerModel) views.get(i).getTag();
            if (tagModel.getPlayerId() == model.getPlayerId()) {
                isExist = true;
                bindingData(views.get(i), model);

//                int xEnd = (int) ((model.getPoints().get(2).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
//                int yEnd = (int) ((model.getPoints().get(2).x / fieldX * 100.0) * height / 100 - viewHeight);
//
//                AnimatorSet animatorSet = new AnimatorSet();//组合动画
//                ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(i), "translationX", views.get(i).getX(), xEnd);
//                ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(i), "translationY", views.get(i).getY(), yEnd + textHeight);
//                animatorSet.setDuration(2800);
//                animatorSet.setInterpolator(new DecelerateInterpolator());
//                animatorSet.play(translationX).with(translationY);//两个动画同时开始
//                animatorSet.start();


                // TODO: 2017/5/16 应该可以支持回放暂停动画继续动画
                final long duration = 6000;//总动画时间

                if (maps.get(views.get(i)) != null) {
                    maps.get(views.get(i)).cancel();
                }
                views.get(i).clearAnimation();

                AnimatorSet animatorSet = new AnimatorSet();
                AnimatorSet.Builder builder = null;
                for (int j = 0; j < model.getPoints().size(); j++) {
                    int xBegin;
                    int yBegin;
                    int xEnd;
                    int yEnd;
                    if (j == 0) {
                        xBegin = (int) views.get(i).getX();
                        yBegin = (int) views.get(i).getY();
//                        xEnd = (int) ((model.getPoints().get(j).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
//                        yEnd = (int) ((model.getPoints().get(j).x / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                        //  最新的球场计算公式 proportionx proportiony 第一个
                        if (proportiony >= fieldY) {
                            double y = model.getPoints().get(j).x - proportionx;
                            double x = proportiony - model.getPoints().get(j).y;
                            if (Math.abs(y)>fieldX){
                                y=fieldX;
                            }
                            if (y<0){
                                y=1;
                            }

                            if (y>fieldY){
                                y =fieldY;
                            }
//                            xBegin = (int) ((y / fieldX * 100.0) * width / 100 - viewWidth / 2);
//                            yBegin = (int) ((x / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                            xEnd = (int) ((y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                            yEnd = (int) ((x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);

//                            Log.i("info", "addPoint---xBegin非正常1111===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

//                            Log.i("info", "addPoint---xBegin非正常1111===================x"+ x + "y===" + y);

                            Log.i("info", "addPoint---xBegin非正常1111===================X的结束"+xEnd+"Y的结束"+yEnd+"xxxxxx"+ x + "y===" + y);
                        } else {
                            xEnd = (int) Math.abs(((model.getPoints().get(j).y - proportiony) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                            yEnd = (int) Math.abs(((model.getPoints().get(j).x - proportionx) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                            Log.i("info", "addPoint---xBegin正常11111===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);
                            int xx=(int) (model.getPoints().get(j).y - proportiony);
                            int yy=(int)(model.getPoints().get(j).x - proportionx);
                            Log.i("info", "addPoint---正常11111===XXXX"+xx+"YYYY"+yy);
                        }


                    }
                    else {
//                        xBegin = (int) ((model.getPoints().get(j - 1).y / fieldX * 100.0) * width / 100 - viewWidth / 2);
//                        yBegin = (int) ((model.getPoints().get(j - 1).x / fieldY * 100.0) * height / 100 - viewHeight + textHeight);
//
//                        xEnd = (int) ((model.getPoints().get(j).y / fieldX * 100.0) * width / 100 - viewWidth / 2);
//                        yEnd = (int) ((model.getPoints().get(j).x / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                        //  第二个地方换算公式

                        if (proportiony >= fieldY) {
                            double y = model.getPoints().get(j).x - proportionx;
                            double x = proportiony - model.getPoints().get(j).y;

                            if (Math.abs(y)>fieldX){
                                y=fieldX;
                            }
                            if (y<0){
                                y =1;
                            }

                            if (y>fieldY){
                                y =fieldY;
                            }
                            // proportiony -model.getPoints().get(j - 1).y
                            double y2 = model.getPoints().get(j - 1).x - proportionx;
                            double x2 = proportiony - model.getPoints().get(j - 1).y;

                            if (Math.abs(y2)>fieldX){
                                y2=fieldX;
                            }
                            if (y2<0){
                                y2 =1;
                            }

                            if (y2>fieldY){
                                y2 =fieldY;
                            }

                            xBegin = (int) ((y2 / fieldY * 100.0) * width / 100 - viewWidth / 2);
                            yBegin = (int) ((x2 / fieldX * 100.0) * height / 100 - viewHeight + textHeight);

                            xEnd = (int) ((y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                            yEnd = (int) ((x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);

//                            Log.i("info", "addPoint---xBegin非正常222222===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

                            Log.i("info", "addPoint---xBegin非正常222222===================X的开始"+xBegin+"Y的开始"+yBegin);

                            Log.i("yyyyyyyy"+(j - 1),y2+"");
                            Log.i("xxxxxxxx"+(j - 1),x2+"" );
                            Log.i("info", "addPoint---xBegin非正常222222===================x"+(j - 1)+"----->" + x + "y===" + y);
                        } else {
                            xBegin = (int) (((model.getPoints().get(j - 1).y - proportiony) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                            yBegin = (int) (((model.getPoints().get(j - 1).x - proportionx) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                            xEnd = (int) (((model.getPoints().get(j).y - proportiony) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                            yEnd = (int) (((model.getPoints().get(j).x - proportionx) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                            Log.i("info", "addPoint---xBegin正常22222===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

                            int xx=(int) (model.getPoints().get(j).y - proportiony);
                            int yy=(int)(model.getPoints().get(j).x - proportionx);
                            Log.i("info", "addPoint---正常2222===XXXX"+xx+"YYYY"+yy);
                        }
                    }
                    try {
                        ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(i), "translationX", xBegin, xEnd);
                        ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(i), "translationY", yBegin, yEnd);
                        translationX.setStartDelay(j * (duration / model.getPoints().size()));
                        translationY.setStartDelay(j * (duration / model.getPoints().size()));
                        if (builder == null) {
                            builder = animatorSet.play(translationX).with(translationY);//两个动画同时开始
                        } else {
                            builder.with(translationX).with(translationY);
                        }
                    } catch (Exception e) {
                    }
                }
                animatorSet.setDuration(duration / model.getPoints().size());
                animatorSet.setInterpolator(new DecelerateInterpolator());
                maps.put(views.get(i), animatorSet);
                maps.get(views.get(i)).start();


//                final long duration = 3000;//总动画时间
//                for (int j = 0; j < model.getPoints().size(); j++) {
//                    final int finalJ = j;
//                    final int finalI = i;
//                    new Handler().postDelayed(new Runnable() {
//                        @Override
//                        public void run() {
//                            int xEnd = (int) ((model.getPoints().get(finalJ).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
//                            int yEnd = (int) ((model.getPoints().get(finalJ).x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);
//                            try {
//                                AnimatorSet animatorSet = new AnimatorSet();//组合动画
//                                ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(finalI), "translationX", views.get(finalI).getX(), xEnd);
//                                ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(finalI), "translationY", views.get(finalI).getY(), yEnd);
//                                animatorSet.setDuration(duration / model.getPoints().size());
//                                animatorSet.setInterpolator(new DecelerateInterpolator());
//                                animatorSet.play(translationX).with(translationY);//两个动画同时开始
//                                animatorSet.start();
//                            } catch (Exception e) {
//
//                            }
//                        }
//                    }, j * (duration / model.getPoints().size()));
//                }
                break;
            }
        }
        if (!isExist) {
            View view = LayoutInflater.from(getContext()).inflate(R.layout.item_live2d, this, false);
            view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
            bindingData(view, model);
            views.add(view);
            addView(view);

            if (model.getPoints() != null && model.getPoints().size() > 0) {
//                int xBegin = (int) ((model.getPoints().get(0).y / fieldX * 100.0) * width / 100 - viewWidth / 2);
//                int yBegin = (int) ((model.getPoints().get(0).x / fieldY * 100.0) * height / 100 - viewHeight + textHeight);
//                int xEnd = (int) ((model.getPoints().get(model.getPoints().size() - 1).y / fieldX * 100.0) * width / 100 - viewWidth / 2);
//                int yEnd = (int) ((model.getPoints().get(model.getPoints().size() - 1).x / fieldY * 100.0) * height / 100 - viewHeight + textHeight);


                //  第三个地方换算公式
                if (proportiony >= fieldY) {
                    double y = model.getPoints().get(0).x - proportionx;
                    double x = proportiony - model.getPoints().get(0).y;

                    int xBegin = (int) ((Math.abs(x) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                    int yBegin = (int) ((Math.abs(y) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);
                    int xEnd = (int) (Math.abs((proportiony - model.getPoints().get(model.getPoints().size() - 1).y) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                    int yEnd = (int) ((Math.abs(model.getPoints().get(model.getPoints().size() - 1).x - proportionx) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);

                    Log.i("info", "addPoint---xBegin非正常333333333===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

                    AnimatorSet animatorSet = new AnimatorSet();//组合动画
                    ObjectAnimator translationX = ObjectAnimator.ofFloat(view, "translationX", xBegin, xEnd);
                    ObjectAnimator translationY = ObjectAnimator.ofFloat(view, "translationY", yBegin, yEnd);
                    animatorSet.setDuration(3000);
                    animatorSet.setInterpolator(new DecelerateInterpolator());
                    animatorSet.play(translationX).with(translationY);//两个动画同时开始
                    animatorSet.start();

                } else {
                    int xBegin = (int) (((model.getPoints().get(0).y - proportiony) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                    int yBegin = (int) (((model.getPoints().get(0).x - proportionx) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);
                    int xEnd = (int) (((model.getPoints().get(model.getPoints().size() - 1).y - proportiony) / fieldX * 100.0) * width / 100 - viewWidth / 2);
                    int yEnd = (int) (((model.getPoints().get(model.getPoints().size() - 1).x - proportionx) / fieldY * 100.0) * height / 100 - viewHeight + textHeight);
                    Log.i("info", " addPoint----xBegin正常333333333===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);
                    AnimatorSet animatorSet = new AnimatorSet();//组合动画
                    ObjectAnimator translationX = ObjectAnimator.ofFloat(view, "translationX", xBegin, xEnd);
                    ObjectAnimator translationY = ObjectAnimator.ofFloat(view, "translationY", yBegin, yEnd);
                    animatorSet.setDuration(3000);
                    animatorSet.setInterpolator(new DecelerateInterpolator());
                    animatorSet.play(translationX).with(translationY);//两个动画同时开始
                    animatorSet.start();
                }
//                maps.put(view, animatorSet);
//                maps.get(view).start();
            }
        }
    }


    /**
     * 添加2d直播数据
     * 测试大2D 直播界面
     *
     * @param model
     */
    public void addnewPoint(final Data2DPlayerModel model) {
        final int width = getMeasuredWidth();
        final int height = getMeasuredHeight();
        final int viewWidth = Utils.dip2px(getContext(), 60);
        final int viewHeight = Utils.dip2px(getContext(), 114);
        final int textHeight = Utils.dip2px(getContext(), 14);

        boolean isExist = false;


        for (int i = 0; i < views.size(); i++) {
            Data2DPlayerModel tagModel = (Data2DPlayerModel) views.get(i).getTag();
            if (tagModel.getPlayerId() == model.getPlayerId()) {
                isExist = true;
                bindingData(views.get(i), model);

                // TODO: 2017/5/16 应该可以支持回放暂停动画继续动画
                final long duration = 3000;//总动画时间

                if (maps.get(views.get(i)) != null) {
                    maps.get(views.get(i)).cancel();
                }
                views.get(i).clearAnimation();

                AnimatorSet animatorSet = new AnimatorSet();
                AnimatorSet.Builder builder = null;
                for (int j = 0; j < model.getPoints().size(); j++) {
                    int xBegin;
                    int yBegin;
                    int xEnd;
                    int yEnd;
                    if (j == 0) {
                        xBegin = (int) views.get(i).getX();
                        yBegin = (int) views.get(i).getY();
                        xEnd = (int) ((model.getPoints().get(j).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                        yEnd = (int) ((model.getPoints().get(j).x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);
                    } else {
                        xBegin = (int) ((model.getPoints().get(j - 1).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                        yBegin = (int) ((model.getPoints().get(j - 1).x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);
                        xEnd = (int) ((model.getPoints().get(j).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                        yEnd = (int) ((model.getPoints().get(j).x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);
                    }
                    try {
                        ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(i), "translationX", xBegin, xEnd);
                        ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(i), "translationY", yBegin, yEnd);
                        translationX.setStartDelay(j * (duration / model.getPoints().size()));
                        translationY.setStartDelay(j * (duration / model.getPoints().size()));
                        if (builder == null) {
                            builder = animatorSet.play(translationX).with(translationY);//两个动画同时开始
                        } else {
                            builder.with(translationX).with(translationY);
                        }
                    } catch (Exception e) {
                    }
                }
                animatorSet.setDuration(duration / model.getPoints().size());
                animatorSet.setInterpolator(new DecelerateInterpolator());
                maps.put(views.get(i), animatorSet);
                maps.get(views.get(i)).start();
                break;
            }
        }
        if (!isExist) {
            View view = LayoutInflater.from(getContext()).inflate(R.layout.item_live2d, this, false);
            view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
            bindingData(view, model);
            views.add(view);
            addView(view);

            if (model.getPoints() != null && model.getPoints().size() > 0) {
                int xBegin = (int) ((model.getPoints().get(0).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                int yBegin = (int) ((model.getPoints().get(0).x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);
                int xEnd = (int) ((model.getPoints().get(model.getPoints().size() - 1).y / fieldY * 100.0) * width / 100 - viewWidth / 2);
                int yEnd = (int) ((model.getPoints().get(model.getPoints().size() - 1).x / fieldX * 100.0) * height / 100 - viewHeight + textHeight);
                AnimatorSet animatorSet = new AnimatorSet();//组合动画
                ObjectAnimator translationX = ObjectAnimator.ofFloat(view, "translationX", xBegin, xEnd);
                ObjectAnimator translationY = ObjectAnimator.ofFloat(view, "translationY", yBegin, yEnd);
                animatorSet.setDuration(3000);
                animatorSet.setInterpolator(new DecelerateInterpolator());
                animatorSet.play(translationX).with(translationY);//两个动画同时开始
                animatorSet.start();
            }
        }
    }



    private void bindingData(View view, Data2DPlayerModel model) {
        FrameLayout layBack = (FrameLayout) view.findViewById(R.id.layBack);
        ImageView ivAvatar = (ImageView) view.findViewById(R.id.ivAvatar);
        TextView tvName = (TextView) view.findViewById(R.id.tvName);
        TextView tvKing = (TextView) view.findViewById(R.id.tvKing);
        tvKing.setVisibility(INVISIBLE);
        tvKing.setBackgroundResource(0);
        if (model.isHomeTeam()) {
            layBack.setBackgroundResource(R.drawable.ic_bubble_blue);
            if (!isAllHide) {
                if (!model.getRunKing().equals("") && !isSpeedKing) {
                    tvKing.setText(model.getRunKing() + "km");
                    tvKing.setBackgroundResource(R.drawable.ic_live2d_run);
                    tvKing.setVisibility(VISIBLE);
                    layBack.setBackgroundResource(R.drawable.ic_bubble_blue_king);
                } else if (!model.getSpeedKing().equals("") && isSpeedKing) {
                    tvKing.setText(model.getSpeedKing() + "m/s");
                    tvKing.setBackgroundResource(R.drawable.ic_live2d_speed);
                    tvKing.setVisibility(VISIBLE);
                    layBack.setBackgroundResource(R.drawable.ic_bubble_blue_king);
                }
            }
            if (model.isChangeUp()) {
                layBack.setBackgroundResource(R.drawable.ic_bubble_blue_up);
            }
        } else {
            layBack.setBackgroundResource(R.drawable.ic_bubble_red);
            if (!isAllHide) {
                if (!model.getRunKing().equals("") && !isSpeedKing) {
                    tvKing.setText(model.getRunKing() + "km");
                    tvKing.setBackgroundResource(R.drawable.ic_live2d_run);
                    tvKing.setVisibility(VISIBLE);
                    layBack.setBackgroundResource(R.drawable.ic_bubble_red_king);
                } else if (!model.getSpeedKing().equals("") && isSpeedKing) {
                    tvKing.setText(model.getSpeedKing() + "m/s");
                    tvKing.setBackgroundResource(R.drawable.ic_live2d_speed);
                    tvKing.setVisibility(VISIBLE);
                    layBack.setBackgroundResource(R.drawable.ic_bubble_red_king);
                }
            }
            if (model.isChangeUp()) {
                layBack.setBackgroundResource(R.drawable.ic_bubble_red_up);
            }
        }
        Glide.with(getContext()).load(Constants.RequestUrl.baseImageUrl + model.getPlayerImg()).
                placeholder(R.drawable.ic_default_user).
                error(R.drawable.ic_default_user).
                bitmapTransform(new CropCircleTransformation(getContext())).
                dontAnimate().into(ivAvatar);
        tvName.setText(model.getPlayerName());
        tvName.setVisibility(hideName ? INVISIBLE : VISIBLE);
        view.setTag(model);
        view.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                if (onItemClickListener != null && v.getTag() instanceof Data2DPlayerModel) {
                    onItemClickListener.onItemClick((Data2DPlayerModel) v.getTag());
                }
            }
        });

    }

    /**
     * 添加迷你2d直播数据
     *
     * @param model
     */
    public void addMini2DPoint(final Data2DPlayerModel model) {
        final int width = getMeasuredWidth();
        final int height = getMeasuredHeight();
        final int viewWidth = Utils.dip2px(getContext(), 32);
        final int viewHeight = Utils.dip2px(getContext(), 32);

        boolean isExist = false;
        for (int i = 0; i < views.size(); i++) {
            Data2DPlayerModel tagModel = (Data2DPlayerModel) views.get(i).getTag();
            if (tagModel.getPlayerId() == model.getPlayerId()) {
                isExist = true;
                bindingMinData((TextView) views.get(i), model);

//                int xEnd = (int) ((Math.round(model.getPoints().get(2).x / fieldX * 100.0)) * width / 100 - viewWidth / 2);
//                int yEnd = (int) (height - (Math.round(model.getPoints().get(2).y / fieldY * 100.0)) * height / 100 - viewHeight / 2);
//
//                AnimatorSet animatorSet = new AnimatorSet();//组合动画
//                ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(i), "translationX", views.get(i).getX(), xEnd);
//                ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(i), "translationY", views.get(i).getY(), yEnd);
//                animatorSet.setDuration(2500);
//                animatorSet.setInterpolator(new DecelerateInterpolator());
//                animatorSet.play(translationX).with(translationY);//两个动画同时开始
//                animatorSet.start();


//                final long duration = 3000;//总动画时间
//                for (int j = 0; j < model.getPoints().size(); j++) {
//                    final int finalJ = j;
//                    final int finalI = i;
//                    new Handler().postDelayed(new Runnable() {
//                        @Override
//                        public void run() {
//                            int xEnd = (int) ((Math.round(model.getPoints().get(finalJ).x / fieldX * 100.0)) * width / 100 - viewWidth / 2);
//                            int yEnd = (int) (height - (Math.round(model.getPoints().get(finalJ).y / fieldY * 100.0)) * height / 100 - viewHeight / 2);
//
//                            AnimatorSet animatorSet = new AnimatorSet();//组合动画
//                            ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(finalI), "translationX", views.get(finalI).getX(), xEnd);
//                            ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(finalI), "translationY", views.get(finalI).getY(), yEnd);
//                            animatorSet.setDuration(duration / model.getPoints().size());
//                            animatorSet.setInterpolator(new DecelerateInterpolator());
//                            animatorSet.play(translationX).with(translationY);//两个动画同时开始
//                            animatorSet.start();
//                        }
//                    }, j * (duration / model.getPoints().size()));
//                }


                // TODO: 2017/5/16 应该可以支持回放暂停动画继续动画
                final long duration = 3000;//总动画时间

                if (maps.get(views.get(i)) != null) {
                    maps.get(views.get(i)).cancel();
                }
                views.get(i).clearAnimation();

                AnimatorSet animatorSet = new AnimatorSet();
                AnimatorSet.Builder builder = null;
                // 当前球员的坐标
                for (int j = 0; j < model.getPoints().size(); j++) {
                    int xBegin = 0;
                    int yBegin = 0;
                    int xEnd = 0;
                    int yEnd = 0;
                    if (j == 0) {
                        xBegin = (int) views.get(i).getX();
                        yBegin = (int) views.get(i).getY();
                        if (proportiony >= fieldY) { // 第一种

                            double y = model.getPoints().get(j).x - proportionx;
                            double x = proportiony - model.getPoints().get(j).y;
                            if (Math.abs(y)>fieldY){
                                y=fieldY;
                            }
                            if (y<0){
                                y=1;
                            }

                            xEnd = (int) ((Math.round(x / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                            yEnd = (int) (height - (Math.round(y / fieldY * 100.0)) * height / 100 - viewHeight / 2);

                            Log.i("info", "addMini2DPoint---xBegin非正常11111===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

                            Log.i("info", "addMini2DPoint---x非正常11111===================x" + x + "y===" + y);
                        } else {

                            xEnd = (int) ((Math.round((model.getPoints().get(j).x - proportionx) / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                            yEnd = (int) (height - (Math.round((model.getPoints().get(j).y - proportiony) / fieldY * 100.0)) * height / 100 - viewHeight / 2);
                            Log.i("info", "addMini2DPoint---xBegin正常11111===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

                            int xx=(int) (model.getPoints().get(j).y - proportiony);
                            int yy=(int)(model.getPoints().get(j).x - proportionx);
                            Log.i("info", "addMini2DPoint---正常11111===XXXX"+xx+"YYYY"+yy);
                        }
                    } else {
                        if (proportiony >= fieldY) {

                            double y = model.getPoints().get(j).x - proportionx;
                            double x = proportiony - model.getPoints().get(j).y;

                            if (Math.abs(y)>fieldY){
                                y=fieldY;
                            }
                            if (y<0){
                                y=1;
                            }


                            double y2 = model.getPoints().get(j - 1).x - proportionx;
                            double x2 = proportiony - model.getPoints().get(j - 1).y;

                            if (Math.abs(y2)>fieldX){
                                y2=fieldX;
                            }
                            if (y2<0){
                                y2 =1;
                            }


                            xBegin = (int) ((Math.round(x2/ fieldX * 100.0)) * width / 100 - viewWidth / 2);
                            yBegin = (int) (height - (Math.round(y2 / fieldY * 100.0)) * height / 100 - viewHeight / 2);
                            xEnd = (int) ((Math.round(x / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                            yEnd = (int) (height - (Math.round(y / fieldY * 100.0)) * height / 100 - viewHeight / 2);

                            Log.i("info", "addMini2DPoint---xBegin非正常22222===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);

                            Log.i("info", "addMini2DPoint---x非正常222222===================x" + x + "y===" + y);
                        } else {
                            xBegin = (int) ((Math.round(Math.abs(model.getPoints().get(j - 1).x - proportionx) / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                            yBegin = (int) Math.abs(height - (Math.round((model.getPoints().get(j - 1).y - proportiony) / fieldY * 100.0)) * height / 100 - viewHeight / 2);
                            xEnd = (int) ((Math.round(Math.abs(model.getPoints().get(j).x - proportionx) / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                            yEnd = (int) (height - (Math.round((model.getPoints().get(j).y - proportiony) / fieldY * 100.0)) * height / 100 - viewHeight / 2);
                            Log.i("info", "addMini2DPoint---xBegin正常22222===" + xBegin + "yBegin===" + yBegin + "xEnd===" + xEnd + "yEnd===" + yEnd);
                        }
                    }
                    try {
                        ObjectAnimator translationX = ObjectAnimator.ofFloat(views.get(i), "translationX", xBegin, xEnd);

                        ObjectAnimator translationY = ObjectAnimator.ofFloat(views.get(i), "translationY", yBegin, yEnd);
                        translationX.setStartDelay(j * (duration / model.getPoints().size()));
                        translationY.setStartDelay(j * (duration / model.getPoints().size()));
                        if (builder == null) {
                            builder = animatorSet.play(translationX).with(translationY);//两个动画同时开始
                        } else {
                            builder.with(translationX).with(translationY);
                        }
                    } catch (Exception e) {
                    }
                }
                animatorSet.setDuration(duration / model.getPoints().size());
                animatorSet.setInterpolator(new DecelerateInterpolator());
                maps.put(views.get(i), animatorSet);
                maps.get(views.get(i)).start();
                break;
            }
        }
        if (!isExist) {
            TextView tvPlayerNum = (TextView) LayoutInflater.from(getContext()).inflate(R.layout.item_mini_live2d, this, false);
            bindingMinData(tvPlayerNum, model);
            views.add(tvPlayerNum);
            addView(tvPlayerNum);

            if (model.getPoints() != null && model.getPoints().size() > 0) {

                if (proportiony >= fieldY) {
                    double y = model.getPoints().get(0).x - proportionx;
                    double x = proportiony - model.getPoints().get(0).y;
                    Log.i("info","非正常-====xx"+x+"y====="+y);

                    int xBegin = (int) (Math.round((x / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                    int yBegin = (int) (height - (Math.round(y / fieldY * 100.0)) * height / 100 - viewHeight / 2);
                    int xEnd = (int) ((Math.round(Math.abs(proportiony - model.getPoints().get(2).y) / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                    int yEnd = (int) (height - (Math.round(Math.abs(model.getPoints().get(2).x - proportionx) / fieldY * 100.0)) * height / 100 - viewHeight / 2);

                    AnimatorSet animatorSet = new AnimatorSet();//组合动画
                    ObjectAnimator translationX = ObjectAnimator.ofFloat(tvPlayerNum, "translationX", xBegin, xEnd);
                    ObjectAnimator translationY = ObjectAnimator.ofFloat(tvPlayerNum, "translationY", yBegin, yEnd);
                    animatorSet.setDuration(3000);
                    animatorSet.setInterpolator(new DecelerateInterpolator());
                    animatorSet.play(translationX).with(translationY);//两个动画同时开始
                    animatorSet.start();
                } else {
                    int xBegin = (int) (Math.round((Math.abs(model.getPoints().get(0).x - proportionx) / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                    int yBegin = (int) (height - (Math.round(Math.abs(model.getPoints().get(0).y - proportiony) / fieldY * 100.0)) * height / 100 - viewHeight / 2);
                    int xEnd = (int) ((Math.round(Math.abs(model.getPoints().get(2).x - proportionx) / fieldX * 100.0)) * width / 100 - viewWidth / 2);
                    int yEnd = (int) (height - (Math.round(Math.abs(model.getPoints().get(2).y - proportiony) / fieldY * 100.0)) * height / 100 - viewHeight / 2);

                    Log.i("info","正常-====xx"+Math.abs(model.getPoints().get(0).x - proportionx)+"y====="+Math.abs(model.getPoints().get(0).y - proportiony));

                    AnimatorSet animatorSet = new AnimatorSet();//组合动画
                    ObjectAnimator translationX = ObjectAnimator.ofFloat(tvPlayerNum, "translationX", xBegin, xEnd);
                    ObjectAnimator translationY = ObjectAnimator.ofFloat(tvPlayerNum, "translationY", yBegin, yEnd);
                    animatorSet.setDuration(3000);
                    animatorSet.setInterpolator(new DecelerateInterpolator());
                    animatorSet.play(translationX).with(translationY);//两个动画同时开始
                    animatorSet.start();

                }

            }
        }
    }

    private void bindingMinData(TextView tvPlayerNum, Data2DPlayerModel model) {
        if (model.isHomeTeam()) {
            tvPlayerNum.setBackgroundResource(R.drawable.ic_match2_mini_2d_blue);
        } else {
            tvPlayerNum.setBackgroundResource(R.drawable.ic_match2_mini_2d_red);
        }
        if (model.getTeamNum() < 10) {
            tvPlayerNum.setText(String.valueOf(model.getTeamNum()));
        } else {
            tvPlayerNum.setText(String.valueOf(model.getTeamNum()));
        }
        tvPlayerNum.setTag(model);
        tvPlayerNum.setLayerType(View.LAYER_TYPE_HARDWARE, null);
    }

    public void setHideName(boolean hideName) {
        this.hideName = hideName;
        for (int i = 0; i < getChildCount(); i++) {
            View view = getChildAt(i);
            TextView tvName = (TextView) view.findViewById(R.id.tvName);
            tvName.setVisibility(hideName ? INVISIBLE : VISIBLE);
        }
    }

    public interface OnItemClickListener {
        void onItemClick(Data2DPlayerModel model);
    }
}
hrd930219
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
上海羽毛球场预定app_羽毛球预约管家
weixin_32722209的博客
12-30 9143
喜欢运动，喜欢玩羽毛球的用户们可以使用羽毛球预约管家了，这是一个拥有多个地区羽毛球场地资源的软件，大家可以使用它进行预订，而且这里的资源都是非常有名的，安全的地区，让你在这里玩游戏不会有顾虑还可以增加自己的社交圈。羽毛球预约管家介绍羽毛球预约管家app是一款可以让的洒家在线预约羽毛球馆的手机平台，大家可以根据自己的位置来查询周边的球馆，所有的详细信息都会在第一时间为你显示，支支持大家在线上预定，线...
计算机网络教学仿真平台,网络三维虚拟校园仿真平台构建
weixin_39828193的博客
07-16 1292
1. 引言随着高校的不断发展，其原有基础设施建设和教学管理、生活管理等综合方面已经面临着严峻的挑战。以广西师范学院为例，旧校区地下管线、道路、体育场都面临翻新与扩建的问题，新校区教学楼、停车场、图书馆、宿舍楼等建筑都面临着选址的合理性与可持续发展的问题，这些校内基础设施的建设依据都与地理信息空间数据紧密关联，然而以往的地理信息空间数据存在数据量庞大、时间周期长、管理系统效率低等问题，这些问题都给校...
亚冠之旅-浦和红钻球场篇
bisal的专栏
05-28 600
这是杂货铺的第476篇文章上周恰逢北京国安客战挑战日本浦和红钻的亚冠联赛，有幸作为远征军，现场观赛助威，和以往到不同国家看球经历的区别，就是这次，我有自己绝对支持的主队，...
美国oracle球场,【Dubnation翻译】甲骨文球馆的恢弘“绝唱”
weixin_29596423的博客
04-04 804
47个赛季的跌宕起伏在周四的一场令人心绪难平的比赛中画上了句号。这是一场NBA总决赛，对于甲骨文这个具有传奇意义的球馆来说，没有比这更好的剧本了——作为勇士队主场已经将近50年的甲骨文球馆，迎来了勇士队在总决赛中“赢球或者回家”的G6。重大的伤病，令人情绪激动的复出等等……勇士队跌跌撞撞，将2019年NBA总决赛G6带回了自己的主场。经历种种艰辛之后，勇士球迷终于得以见证甲骨文球馆的最后一场比赛。...
爬取NBA球员数据
weixin_64426947的博客
02-04 852
此次爬虫实验使我可以更好运用网页开发者模式来分析目标网站的结构和数据格式，通过使用Python中的爬虫库，我成功地从网页上提取了NBA球员的相关数据，但在爬虫过程中，我也遇到了网站的反爬虫机制，为了规避这些机制我学到了一些应对策略，如设置合适的请求头、使用代理IP等，以确保稳定的数据爬取，此次实验我用到了代理IP成功找到网站中想要爬取的数据。
流体力学仿真揭秘“任意球”的奥妙
仿真APP博客
08-10 1025
足球比赛中，当你听解说员说到“香蕉球”、“落叶球”、“电梯球”时，你能说出他们的区别吗？更关键的是，怎样才能踢出这些匪夷所思的球呢？今天就带你一起来认识一下这三种经典任意球，并结合流体力学理论和仿真软件Simdroid来探究一下踢出这些球的关键因素。
风生水起的VR直播丨VR直播市场何时迎来爆发期？
酷雷曼vr全景
01-06 927
自VR直播横空出世便引人瞩目，尤其在2020年火速升温。在各种会议、赛事中都能看到它的身影。能够赢得各大会议、体育赛事、综艺节目等青睐，除了VR直播本身的优势以外，这主要得益于5G商用落地以及后疫情时代的加持与助推。那么在这股助推力之下，VR直播真的能够一发向上，迎来爆发期吗？接下来将结合视频、直播、VR直播等行业趋势分析一下VR直播未来的发展态势。 身临其境 “视”与争锋 对于视频行业来讲，VR直播绝对是一项颠覆性的视觉展现技术。传统直播由于视角固定，观众只能被动接收内容。相比之下，由于VR直播的720
重磅|如何利用NBA球员推文预测其球场表现？
weixin_34050519的博客
05-02 904
本文已获论文原作者授权，转载请后台留言申请 原文作者： Yang Yu （余旸）- Rochester Institute of Technology （罗切斯特理工大学） Chenyan Xu （许辰燕）- Stockton University （斯托克顿大学） Chun-Keung Hoi - Rochester Institute of ...
THU羽毛球场预约脚本
Plutonjr的博客
08-25 957
这里需要手动选择是哪个体育场，如选择气膜馆，接下来脚本按按钮的顺序是，先点击类型（乒乓球/羽毛球），再点击日期，再点击时间和场地号，最后点击提交。如果想要自行改变预约的运动场类型、时间段、场地，需要手动查询网页中对应的XPATH并粘贴到代码中。例如如果将场地类型改为紫荆网球场，则在网页中右击紫荆网球场对应的位置，点击“检查”，在弹出的网页源码中高亮的部分右击，选择copy–copy full Xpath，粘贴到。
对足球轨迹进行计算机仿真,基于数据挖掘的足球最优射门角度分析
weixin_42514394的博客
07-18 1049
刘溢鑫摘 要： 为了提高足球射门的准确度，提出数据挖掘的足球最优射门角度分析算法。采用粒子群算法把球场规划为一个虚拟的网格环境，对足球射门路径点实时标定和叠加特性进行分析，根据球场环境中的信息素，粒子群算法实现进球概率优化求解，以路径适应度函数为优化目标函数进行射门角度特征数据挖掘，求得路径适应度函数的最优解即为最优射门角度的解向量。仿真结果表明，该算法可以在复杂程度不同的球场环境中规划出一条最优...
创意手球场设计矢量素材
07-25
本资源“创意手球场设计矢量素材”提供了一套专用于手球场设计的专业素材，旨在帮助设计师们高效、创新地完成手球场的设计工作。下面将详细探讨手球场设计、运动场的场地设计以及矢量素材在设计中的应用。 首先，手...
高尔夫球场管理系统》.docx
12-08
《高尔夫球场管理系统》是一款基于SQL Server设计的数据库应用，旨在高效管理高尔夫球场的各项运营事务。这个系统涵盖了管理员信息管理、会员信息管理和场地信息管理三大核心功能，满足了高尔夫球场日常运营的需求。...
馆客多球场管理会员系统
05-19
专业的智慧场馆经营方案，适用于大中型体育场馆、篮羽足网球馆、游泳馆等运动健身机构！ 手机管理：可通过微信一键登录小程序，获取场馆实时状态、订单收入、营收详情、商品库存、会员信息等。...
高尔夫球场管理系统
08-10
总的来说，VB作为经典的编程语言，其丰富的控件库和强大的数据库支持，使得开发高尔夫球场管理系统变得可行且高效。通过合理的设计和编程，这些模块可以协同工作，形成一个完整、流畅的管理系统，极大地提升高尔夫...
高尔夫球场俱乐部响应式网站模板
01-23
【高尔夫球场俱乐部响应式网站模板】是一个专为高尔夫球场和俱乐部设计的网页模板，它具有高度适应各种设备的能力，能够确保在台式机、平板电脑和手机等不同屏幕尺寸上提供一致且良好的用户体验。响应式设计是现代...
源代码-创意互动网站导航（ASP静态版） v1.0.zip
最新发布
08-24
源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip 源代码-创意互动网站导航（ASP静态版） v1.0.zip
java源码资源很不错的Java计算器java源码资源很不错的Java计算器
08-24
java源码资源很不错的Java计算器java源码资源很不错的Java计算器提取方式是百度网盘分享地址
源代码-补单系统 v1.0.zip
08-24
源代码-补单系统 v1.0.zip
java源码资源网络蚂蚁Java版java源码资源网络蚂蚁Java版
08-24
java源码资源网络蚂蚁Java版java源码资源网络蚂蚁Java版提取方式是百度网盘分享地址
2D仿真足球比赛：场地规则与球员控制
参与RoboCup 2D技术培训的人员会了解到基本的2D开发技术，包括规则理解和球场布局管理。例如，剧场管理员需要考虑演员和剧组的出场顺序以及与直播和录播的相关安排。此外，培训还可能涵盖如何通过Monitor来实时监控...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值