creare una classe partendo da una prototype

[ca-j]

Salve ragazzi, premetto che sto cominciando ora a imparare le classi. Normalmete richiamo i MC con delle funzioni prototipo, affinché eseguano delle azioni del tipo

MovieClip.prototype.muovescala = function (x,y,a,sx,sy,steps) {
	this.onEnterFrame=function () {
		this._rot=(Number(a)-this._rotation)/Number(steps);
		this._xstep=(Number(x)-this._x)/Number(steps);
	    this._ystep=(Number(y)-this._y)/Number(steps);
		this._xsca=(Number(sx)-this._xscale)/Number(steps);
	    this._ysca=(Number(sy)-this._yscale)/Number(steps);
	    this._steps=steps;
		if (this._steps) {
			this._rotation+=this._rot;
			this._x+=this._xstep;
			this._y+=this._ystep;
			this._xscale+=this._xsca;
			this._yscale+=this._ysca;
			this._steps--;
		}
		else {
			delete this._xstep;
			delete this._ystep;
			delete this._xsca;
			delete this._ysca;
			delete this._steps;
			this.onEnterFrame=function () {}
		}
	}
}

. Ora vorrei creare una classe Movimento che racchidesse le proprietá di questa proto e non saprei come fare. Mi date uno spunto?
Grazie

[negatyve]

Per un unico metodo una classe mi pare troppo, diventa una funzione (che può essere globale) con solo un paio di cambiamenti:

function muovescala(target, x,y,a,sx,sy,steps) {
	target.onEnterFrame=function () {
		this._rot=(Number(a)-this._rotation)/Number(steps);
		this._xstep=(Number(x)-this._x)/Number(steps);
	    this._ystep=(Number(y)-this._y)/Number(steps);
		this._xsca=(Number(sx)-this._xscale)/Number(steps);
	    this._ysca=(Number(sy)-this._yscale)/Number(steps);
	    this._steps=steps;
		if (this._steps) {
			this._rotation+=this._rot;
			this._x+=this._xstep;
			this._y+=this._ystep;
			this._xscale+=this._xsca;
			this._yscale+=this._ysca;
			this._steps--;
		}
		else {
			delete this._xstep;
			delete this._ystep;
			delete this._xsca;
			delete this._ysca;
			delete this._steps;
			delete this.onEnterFrame;
		}
	}
}
muovescala(mc, 300, 400, 45, 150, 92, 10)

Ad ogni modo:

Movimento = function(){}
Movimento.muovescala = function(target, x,y,a,sx,sy,steps) {
	target.onEnterFrame=function () {
		this._rot=(Number(a)-this._rotation)/Number(steps);
		this._xstep=(Number(x)-this._x)/Number(steps);
	    this._ystep=(Number(y)-this._y)/Number(steps);
		this._xsca=(Number(sx)-this._xscale)/Number(steps);
	    this._ysca=(Number(sy)-this._yscale)/Number(steps);
	    this._steps=steps;
		if (this._steps) {
			this._rotation+=this._rot;
			this._x+=this._xstep;
			this._y+=this._ystep;
			this._xscale+=this._xsca;
			this._yscale+=this._ysca;
			this._steps--;
		}
		else {
			delete this._xstep;
			delete this._ystep;
			delete this._xsca;
			delete this._ysca;
			delete this._steps;
			delete this.onEnterFrame;
		}
	}
}
Movimento.muovescala(mc, 300, 400, 45, 150, 92, 10)

[and80]

Originariamente inviato da negatyve
Per un unico metodo una classe mi pare troppo, diventa una funzione (che può essere globale) con solo un paio di cambiamenti:

la prototype però può dare più assegnazioni con il solo richiamo dal clip, mentre la funzione può essere richiamata come tale una per volta, sbaglio?

io sto utilizzando un altro metodo adesso, preso "in prestito" da andr3a, e devo dire che lo trovo molto flessibile e con meno dispendio di cpu, ad esempio il codice di ca-j diventa

var moveAndScale = new Object();
moveAndScale.onEnd = function(clip){
	if (this[clip._name] != undefined){
		clearInterval(this[clip._name]);
	}
}
moveAndScale.__process__ = function(clip, x, y, a, sx, sy, steps){
	this._rot=(Number(a)-this._rotation)/Number(steps);
	this._xstep=(Number(x)-this._x)/Number(steps);
	this._ystep=(Number(y)-this._y)/Number(steps);
	this._xsca=(Number(sx)-this._xscale)/Number(steps);
	this._ysca=(Number(sy)-this._yscale)/Number(steps);
	this._steps=steps;
	if (clip._steps) {
		clip._rotation+=clip._rot;
		clip._x+=clip._xstep;
		clip._y+=clip._ystep;
		clip._xscale+=clip._xsca;
		clip._yscale+=clip._ysca;
		clip._steps--;
	} else {
		delete this._xstep;
		delete this._ystep;
		delete this._xsca;
		delete this._ysca;
		delete this._steps;
		this.onEnd(clip)
	}	
}
moveAndScale.makeEvent = function(clip, x, y, a, sx, sy, steps){
	this[clip._name] = setInterval(this, "__process__", 20, clip, x, y, a, sx, sy, steps);	
}

//richiamo con:
moveAndScale.makeEvent(mc, 300, 400, 45, 150, 92, 10);

ho adattato in fretta e senza poter provare, quindi non me ne vogliate se ci sono degli errori

[negatyve]

Originariamente inviato da and80
la prototype però può dare più assegnazioni con il solo richiamo dal clip, mentre la funzione può essere richiamata come tale una per volta, sbaglio?

Guarda, non sono sicuro di aver capito esattamente cosa vuoi dire...

[and80]

Originariamente inviato da negatyve
Guarda, non sono sicuro di aver capito esattamente cosa vuoi dire...

mettiamo di avere diversi clip da "elaborare", ad esempio con un ciclo, con una proto potresti fare

for(i=0; i<10; i++){
_root["clip"+i].muovescala(300, 400, 45, 150, 92, 10)
}

o come ho scritto io

for(i=0; i<10; i++){
moveAndScale.makeEvent(_root["clip"+i], 300, 400, 45, 150, 92, 10);
}

mentre la funzione sembra "sovrastarsi" ogni volta che viene richiamata, spero di essermi spiegato meglio

[negatyve]

Non vedo perchè:

var counter = 0;
function createQuad()
{
	var mc = createEmptyMovieClip("mc" + counter, counter);
	mc.beginFill(0xFF0000, 100);
	mc.lineTo(20, 0);
	mc.lineTo(20, 20);
	mc.lineTo(0, 20);
	mc.lineTo(0, 0);
	mc.endFill();
	counter++;
	return mc;
}

function muovescala(target, x,y,a,sx,sy,steps) {
	target.onEnterFrame=function () {
		this._rot=(Number(a)-this._rotation)/Number(steps);
		this._xstep=(Number(x)-this._x)/Number(steps);
	    this._ystep=(Number(y)-this._y)/Number(steps);
		this._xsca=(Number(sx)-this._xscale)/Number(steps);
	    this._ysca=(Number(sy)-this._yscale)/Number(steps);
	    this._steps=steps;
		if (this._steps) {
			this._rotation+=this._rot;
			this._x+=this._xstep;
			this._y+=this._ystep;
			this._xscale+=this._xsca;
			this._yscale+=this._ysca;
			this._steps--;
		}
		else {
			delete this._xstep;
			delete this._ystep;
			delete this._xsca;
			delete this._ysca;
			delete this._steps;
			delete this.onEnterFrame;
		}
	}
}
for(var i = 0; i < 10; i++)
{
	var mc = createQuad();
	mc._x = random(400);
	mc._y = random(300);
}
for(var i = 0; i < 10; i++)
{
	muovescala(this["mc" + i], 300, 400, 45, 150, 92, 10)
}

[and80]

Originariamente inviato da negatyve
Non vedo perchè

ora non posso provarlo, comunque ogni volta che ho avuto a che fare con funzioni (ad esempio un preload multiplo) un secondo richiamo della funzione o una richiamo come quello che hai scritto tu, sovrastava il precedente, con il risultato ad esempio nel tuo script, che solo l'ultimo mc eseguiva l'azione di tempo ne è passato dall'ultima volta che ho provato 'sta cosa, ma questo era...

se mi confermi il contrario, non posso far altro che pensare a degli errori di fondo in quelle mie funzioni

grazie per il chiarimento

[negatyve]

Ti confermo il contrario, e ti do io dimostrazione dell'errore di cui parli:

var counter = 0;
function createQuad()
{
	var mc = createEmptyMovieClip("mc" + counter, counter);
	mc.beginFill(0xFF0000, 100);
	mc.lineTo(20, 0);
	mc.lineTo(20, 20);
	mc.lineTo(0, 20);
	mc.lineTo(0, 0);
	mc.endFill();
	counter++;
	return mc;
}
for(var i = 0; i < 10; i++)
{
	var mc = createQuad();
	mc._x = random(400);
	mc._y = random(300);
	mc.onRelease = function()
	{
		trace(i);
	}
}

Qualunque clip tu clicchi, traccia sempre 10 (cioè l'ultimo valore della i). Ma questo è un errore sull'utilizzo della variabile "i", non delle funzioni...

[ca-j]

Originariamente inviato da negatyve
Per un unico metodo una classe mi pare troppo, diventa una funzione (che può essere globale) con solo un paio di cambiamenti:

I metodi sono diversi. Oltre a 'muovescala' ho altri metodi, per quello volevo una classe, cosí colgo l'occasione per imparare ad usarle.

[negatyve]

Ottimo, allora usa o il secondo sistema che ti ho proposto, o quello proposto da and80 (poi al massimo dipende se stai programmando per as1 o 2).