0

我四处寻找帮助，但找不到任何答案。目前，当我想在表面视图中为球设置动画时，我调用了一个方法：

  1. 将surfaceview中的动画变量设置为扩展AnimationModule（扩展AnimationSet）的自定义类，该类在每次绘制时更改球的属性

  2. 然后在每次绘制时调用它，直到 AnimationModule 达到其 maxCount，此时它调用其继承的 AnimationListener.onAnimationEnd

  3. surfaceview 接收到这个回调，然后将动画变量声明为 null，这样它就不会再在每次绘制时调用它了

目前这工作还不错，但感觉非常糟糕和笨拙 - 我真的很想使用其他人使用的久经考验的方法，因为我对动画非常陌生。

另一个问题是我必须使用扩展 view.animation 的动画，所以 ScaleAnimation、TranslateAnimation 等。这对于在屏幕上移动球来说很好，但是当我遇到更复杂的事情时，比如用它的透视动画canvas.polyToPoly 我必须为这种情况创建一个扩展 view.animation 的新类，或者不使用它。

动画模块类：

public abstract class AnimationModule extends AnimationSet{

protected AnimationListener listener;
protected CreatureView attacker;
protected CreatureView defender;
protected BattleCanvas canvas;
protected long increment=0;
protected long individualIncrement=0;
protected float interpolation=0;
private boolean finished=false;
private ArrayList<Animation> animations = new ArrayList<Animation>();
private int currentAnimation=0;
private long totalTime=0;

public interface OnAnimationFinishedListener{
    public void OnAnimationFinished();
}

public AnimationModule(boolean shareInterpolator){
    super(shareInterpolator);
    init();
}

public void setCanvas(BattleCanvas canvas){
    this.canvas=canvas;
}

public void setCreatures(CreatureView attacker, CreatureView defender){
    this.attacker=attacker;
    this.defender=defender;
    Log.i("anim","attacker :"+String.valueOf(attacker.getCreature().getBaseName()));
}

public AnimationModule(boolean shareInterpolator, AnimationController controller){
    super(shareInterpolator);

}

private void init(){

    setFillAfter(true);

}
public boolean isFinished(){
    return finished;
}

@Override
public void addAnimation(Animation a){
    Log.i("Animation","adding animation");
    animations.add(a);
    computeDuration();
    //super.addAnimation(a);
    finished=false;
}

@Override
public void setAnimationListener(AnimationListener a){
    super.setAnimationListener(a);
    this.listener=a;
}

@Override
public boolean getTransformation(long increment, Transformation transform){
    //super.getTransformation(increment, transform);
    if(animations.size()>currentAnimation)
    animations.get(currentAnimation).getTransformation(individualIncrement, transform);
    return true;
}

public void draw(){


}

public void update(){
    if(animations.size()>0){
    Log.i("Animation",String.valueOf(individualIncrement));
    Log.i("Animation",String.valueOf((animations.get(currentAnimation).getRepeatCount()+1)));
    Log.i("Animation",String.valueOf(animations.get(currentAnimation).getDuration()));
    if(individualIncrement>animations.get(currentAnimation).getDuration()*(animations.get(currentAnimation).getRepeatCount()+1)){
        if(animations.size()>currentAnimation+1){
            currentAnimation++;
            individualIncrement=0;
        }else{
            finished();
            return;
        }
    }
    Log.i("module","on animation "+String.valueOf(currentAnimation));

    increment();
    if(increment>=getDuration()){
        finished();

    }
    }
}



protected long computeDuration(){
    long duration=0;
    Iterator<Animation> iterator = animations.iterator();
    while (iterator.hasNext()) {
        Animation a = iterator.next();
        duration=duration+a.computeDurationHint();
    }
    totalTime=duration;
    setDuration(duration);
    Log.i("Animation","duration set to "+String.valueOf(duration));
    return duration;
}

private void finished(){
    finished=true;
    if(listener!=null)
    listener.onAnimationEnd(this);
}

private void increment(){
    increment++;
    individualIncrement++;
    if(getDuration()!=0){
    float far = increment/getDuration();
    interpolation=far;      
    }
    else
        interpolation=0;
}

}

扩展 AnimationModule 的示例动画：

class BiteAnimation extends AnimationModule{


    private float fromSy;
    private float fromSx;
    private ColorAnimation flash;

    public BiteAnimation(boolean shareInterpolator){
        super(shareInterpolator);



    }


    @Override
    public void setCanvas(BattleCanvas canvas){
        super.setCanvas(canvas);

    fromSy=defender.getSy();

        fromSx=defender.getSx();

        ScaleAnimation scale = new ScaleAnimation(fromSx,fromSx,fromSy,fromSy/2, defender.size/2, defender.size/2);

        scale.setDuration(50);
        scale.setRepeatMode(2);
        scale.setRepeatCount(1);

        addAnimation(scale);

         flash = new ColorAnimation(defender.getAdd(), Color.WHITE, ColorAnimation.TYPE_ADD, defender);
         flash.setDuration(50);
         flash.setRepeatMode(2);
         flash.setRepeatCount(1);

    }

    @Override
    public void update() {
        super.update();
         Transformation t = new Transformation();

         Log.i("Animation","increment: "+String.valueOf(individualIncrement));
                    getTransformation(individualIncrement, t);
                    defender.getMatrix().postConcat(t.getMatrix());

               flash.getTransformation(individualIncrement, null);


    }

}

如您所见，自定义 animationModule 只是将其转换应用于它正在转换的画布的对象（在本例中为防御者）。然后在表面视图上绘制防御者时使用此画布。

就像我说的，这感觉真的很糟糕，我可以在如何实现对象动画方面提供一些帮助。

4

0 回答 0