✔ Praktischere Lösung um mehrere unabhängige Bewegungen auszuführen?

[nijes]

Leider ist der Titel des Themas etwas lang, aber mir ist kein kürzerer/aussagekräfiter Titel in den Sinn gekommen.

Da es bei mir oft vorkommt, dass verschiedene onEnterFrame Aktionen simultan in einem MovieClip ablaufen, kommt es dabei oft zu einem sehr verwirrenden Baum an MovieClips, daher würde ich gerne einmal wissen, ob es möglich ist, dafür eine etwas schönere Variante zu verwenden.

Hier einmal ein Beispiel von zwei verschiedenen Funktionen, welche gleichzeitig aufgerufen werden, um die Thematik zu verdeutlichen:

var target:MovieClip = this.attachMovie("circle_mc", "circle_mc", 0)

target.createEmptyMovieClip("scaling", 0);
target.createEmptyMovieClip("slide", 1);

target.scaling.onEnterFrame = function():Void
{
     this._parent._xscale += (150 - this._parent._xscale) /  5
}

target.slide.onEnterFrame = function():Void
{
     this._parent._x += (250 - this._parent._x) / 5
}

(Dies ist nur ein Beispiel. daher die kurzen onEnterFrame Aktionen. Und mir ist bewusst, das man in diesem Fall, beides in eine onEnterFrame Funktion ausführen könnte.)

Der Grund, wieso sich die Bewegungen in verschiedenen onEnterFrame Funktionen befinden ist, dass es durchaus vorkommt, dass sie zu absolut unterschiedlichen Zeitpunkten aufgerufen werden und auch alleine arbeiten können, ohne dabei anderes zu berechnen.

Mein "Problem" ist, dass diese Art und Weise leider jegliche ästhetik des Codes nimmt, da es bei anhäufung von solchen Aktionen sehr unübersichtlich wird, und es eine Menge unnötiger leerer Clips gibt, die eigentlich nur dazu dienen, um eine onEnterFrame Aktion aufzurufen.

Ich habe schon eine Klasse geschrieben, welches die Steuerung und Bewegungen übernimmt, was auch sehr einfach zu Handhaben ist, aber trotzdem gibt es immernoch diese Masse an unnötigen MovieClips.

Ich hoffe ich konnte die Problematik etwas verdeutlichen. Danke für jeden Denkanstoß!

 

[Tobias Menzel]

Hi,

für jede Art der Animation einen neuen "Hilfssclip" zu erstellen, ist meiner Meinung nach in der Tat die sinnvollste Vorgehensweise.

Deine Klasse (bzw. Deine Prototypen) kann allerdings dafür sorgen, dass diese Clips automatisch erstellt und auch wieder entfernt werden:

class Ani {
  private var _tgt:MovieClip;

  public function Ani(t:MovieClip) {
    this._tgt = t;
  }

  public function slide(dx:Number, dy:Number, d:Number):Void {
    this._tgt["Ani_helper_slide"].removeMovieClip();
    var helper:MovieClip = this._tgt.createEmptyMovieClip("Ani_helper_slide", this._tgt.getNextHighestDepth());
    helper.onEnterFrame = function() {
      this._parent._x += (dx - this._parent._x) / d;
      this._parent._y += (dy - this._parent._y) / d;
      if (Math.abs(dx - this._parent._x) < 1 && Math.abs(dy - this._parent._y) < 1) {
        this._parent._x = dx;
        this._parent._y = dy;
        this.removeMovieClip();
      }
    }
  }

  public function fade(da:Number, d:Number):Void {
    this._tgt["Ani_helper_fade"].removeMovieClip();
    var helper:MovieClip = this._tgt.createEmptyMovieClip("Ani_helper_fade", this._tgt.getNextHighestDepth());
    helper.onEnterFrame = function() {
      this._parent._alpha += (da - this._parent._alpha) / d;
      if (Math.abs(da - this._parent._alpha) < 1 ) {
        this._parent._alpha = da;
        this.removeMovieClip();
      }
    }
  }
}

Aufruf z.B.:

var ani = new Ani(meinMC);

ani.slide(320, 240, 5);

ani.fade(30, 8);

Gruß
.

 

[nijes]

Ja, meine Klasse ist bereits so aufgebaut, das sie bei aufrufen einer Funktion einen einzelnen MovieClip dafür erstell und ihn danach wieder entfernt, dachte nur, dass es dafür eventuell eine schönere Vorgehensweiße gibt.

Trotzdem vielen Dank für die schnelle ausführliche Hilfe!

 

[Tobias Menzel]

Hi,

alternativ könntest Du eine onEnterFrame-Methode auf dem Zielclip erstellen, in der ein Animationshandler aufgerufen wird, der die verschiedenen Bewegungen durchführt:

class Ani {
	private var _tgt:MovieClip;
	private var _aniFramer:MovieClip;
	private var _events:Array = new Array();

	public function Ani(t:MovieClip) {
		this._tgt = t;
		this._aniFramer = t.createEmptyMovieClip("_aniFramer_" + new Date().toString(), t.getNextHighestDepth());
		var that:Ani = this;
		this._aniFramer.onEnterFrame = function() {
			that.handleEvents();
		}
	}
	
	private function handleEvents():Void {
		for (var i in _events) {
			_tgt[_events[i]._propName] += (_events[i]._destVal - _tgt[_events[i]._propName]) / _events[i]._speed;
			if (Math.abs(_tgt[_events[i]._propName] - _events[i]._destVal) < 1) {
				_tgt[_events[i]._propName] = _events[i]._destVal;
				var _cb:Function = _events[i]._callback;
				var _pn:String = _events[i]._propName;
				_cb(_pn, stopAni(_events[i]._propName));
			}
		}
	}
	
	public function startAni(propName:String, destVal:Number, speed:Number, callback:Function):Void {
		var overwrite:Boolean = false;
		for (var i in _events) {
			var obj:Object = _events[i];
			if (obj._propName == propName) {
				obj._destVal = destVal;
				obj._speed = speed;
				obj._callback = callback;
				overwrite = true;
			}
		}
		if (!overwrite) {
			_events.push({_propName:propName, _destVal:destVal, _speed:speed, _callback:callback});
			trace(_events[_events.length - 1]._destVal);
		}
	}
	
	public function stopAni(propName:String):Number {
		for (var i=0; i<_events.length; i++) {
			var obj:Object = _events[i];
			if (obj._propName == propName) {
				_events.splice(i, 1);
				break;
			}
		}
		return _tgt[propName];
	}
}

Aufruf z.B.:

import Ani;

var a = new Ani(mc);

a.startAni("_alpha", 50, 10, onFinished);

a.startAni("_x", 400, 20, onFinished);

function onFinished(propName, v) {
	trace("fertig: " + propName + ", " + v);
}

Bei dieser Methode läuft eine einzige onEnterFrame-Methode die gesamte Zeit - Animationen können zur Laufzeit hinzugefügt bzw. entfernt werden. Ist eine Animation abgelaufen, wird eine Callback-Funktion ausgeführt, der der jeweilige Eigenschaftsname und der Endwert der Transformation übergeben wird.

Gruß
.

 

[nijes]

Nocheimal vielen Danke für die Mühe.

Für dieses Projekt bietet sich diese Art der Eventverwaltung leider nicht richtig an, da einige Funktionen sehr individuell ausgeführt werden, aber ich bin mir sicher, dass ich auf diese Vorgehensweiße später nocheinmal zurückgreifen werde!