wie steigere ich die Performance

[Fralle]

Ich bin gerade dabei eine Art Spiel für eine Firma zu entwickeln.

hier

findet ihr einen abgespeckten Dummy eines Teils davon.
Die Walze wird durch gewisse Ereignisse in Bewegung gesetzt und dreht sich dann wieder zurück.

Dies hier ist der betreffende Code:
("allfields" sind je die drei Felder in einer Höhe)

PHP-Code:

// Initvars -- felder nur in gerader Anzahl!!
felder = 14;
buyfeld = felder/2;
salefeld = felder/2+1;
// Walzendurchmesser
walze = 220;
// Verteilungsdeltawinkel auf der Walze (vorher 360/felder/2)
deltagrad = 12;
// Walze zurückdrehen, so daß die Mitt wirklich in der Mitte ist;
yversatz = ymitte=-(felder/2)*deltagrad-deltagrad/2;
// Walze soll bewegt werden
walzenmove = true;
// Walzen Ausgleich
createEmptyMovieClip("walzenausgleich", 250);
walzenausgleich.onEnterFrame = function() {
    if (walzenmove) {
        dreheWalze();
    }
    Ausgleich();
};
// Drehe Walze
function dreheWalze() {
    for (i=1; i<=felder; i++) {
        mc = "allfields"+i;
        this[mc].t = yversatz;
        // setzt beta auf [-240...+240]
        this[mc].beta = Math.round(Math.sin(DegToRad(deltagrad*this[mc].num+this[mc].t))*walze);
        // setzt gamma auf [0...100]
        this[mc].gamma = Math.round(Math.cos(DegToRad(deltagrad*this[mc].num+this[mc].t))*100);
        // setzt tiefe auf [100...200]
        this[mc].tiefe = Math.round(Math.cos(DegToRad(deltagrad*this[mc].num+this[mc].t))*100+100);
        // setzt _y auf die Sinuskurve, abhängig der Numme
        this[mc]._y = this[mc].beta;
        // Alpha steckt im gotoAndStop, auf den jeweiligen Frames sitzt eine "gealphate" Instanz des MC's
        if (this[mc].num == buyfeld or this[mc].num == salefeld) {
            this[mc].gotoAndStop(1);
        } else if (this[mc].num<buyfeld) {
            this[mc].gotoAndStop(salefeld-this[mc].num);
        } else if (this[mc].num>buyfeld) {
            this[mc].gotoAndStop(this[mc].num-buyfeld);
        }
        // setzt  _xscale auf die Cosinuskurve
        this[mc]._xscale = Math.round(this[mc].gamma/4+75);
        // Dies sorgt dafür, daß _yscale zum Randbereich hin immer flacher wird
        this[mc]._yscale = Math.abs(Math.round(this[mc].gamma));
        // setzt die Tiefe so, daß der richtige vorne ist
        this[mc].swapDepths(this[mc].tiefe);
    }
}
function Ausgleich() {
    //
    if (yversatz<ymitte) {
        walzenmove = true;
        schritt = digitHalfNum((ymitte-yversatz)/30);
        yversatz += schritt;
    } else if (yversatz>ymitte) {
        walzenmove = true;
        schritt = digitHalfNum((yversatz-ymitte)/30);
        yversatz -= schritt;
    } else if (yversatz == ymitte) {
        walzenmove = false;
    }
}
// Rad in Deg
function DegToRad(angle) {
    var radian = angle*Math.PI/180;
    return radian;
}
//gerundet auf 1 Nachkommastelle in 0.5-Schritten
function digitHalfNum(z) {
    return Math.ceil(z*2)/2;
} 


mein Problem ist nun, daß immer wenn die Walze bewegt wird, knickt die Framerate gehörig ein. Es sind noch andere Elemente im Spiel, die u.a. auch mit OEF-Funktionen belegt sind. Teilweise habe ich diese in dem Beispiel rausgenommen, aber die fps (oben rechts angezeigt, darunter die durchschnittliche Framerate) gehen trotzdem immer runter sobald "walzenmove" == true ist.

Ich würde mich freuen, wenn ihr euch das Beispiel angucken würdet und mir sagen könntet, wie ich einen ähnlichen Effekt CPU-schonender programmieren könnte...

p.s.ie Framerate ist auf 24 fps eingestellt

[Janoscharlipp]

z.B. in der Schleife nicht immer this[mc] schreiben, sondern einmal am Anfang var ref = this[mc] schreiben, dann kannst du immer ref als MovieClip nehmen.
dann erstmal das hier zwischenspeichern:
angle = DegToRad(deltagrad*this[mc].num+this[mc].t)

Fuer die Positionsberechnung kønntest du auch Matrizen nehmen, aber das wære vielleicht etwas uebertrieben.

[artjom]

walzenausgleich.onEnterFrame = function() { 
    if (walzenmove) { 
        dreheWalze(); 
    } 
    Ausgleich(); 
};

das aufrufen von funktionen: dreheWalze() und Ausgleich() kostet schon einiges an zeit/performance. schieb' also alles was diese funktionen an code haben in die onEnterFrame.

gruß

[Fralle]

Zitat von Janoscharlipp

z.B. in der Schleife nicht immer this[mc] schreiben, sondern einmal am Anfang var ref = this[mc] schreiben, dann kannst du immer ref als MovieClip nehmen.
dann erstmal das hier zwischenspeichern:
angle = DegToRad(deltagrad*this[mc].num+this[mc].t)

Fuer die Positionsberechnung kønntest du auch Matrizen nehmen, aber das wære vielleicht etwas uebertrieben.

diese beiden Änderungen habe ich vorgenommen, das mit der deltagrad()-Funktion war ja klar. (Da waren vorher noch andere Parameter drin) Ich habe sie durch eine Variable ersetzt.
aber was genau bringt es, this.[mc] zu ersetzen?

Die Funktion sieht jetzt so aus:

PHP-Code:

function dreheWalze() {
    for (i=1; i<=felder; i++) {
        var mc = this["allfields"+i];
        mc.t = DegToRad(deltagrad*mc.num+yversatz);
        // setzt beta auf [-240...+240]
        mc.beta = Math.round(Math.sin(mc.t)*walze);
        // setzt gamma auf [0...100]
        mc.gamma = Math.round(Math.cos(mc.t)*100);
        // setzt tiefe auf [100...200]
        mc.tiefe = Math.round(Math.cos(mc.t)*100)+100;
        // setzt _y auf die Sinuskurve, abhängig der Nummer
        mc._y = mc.beta;
        // Alpha abhängig vom Frame
        if (mc.num == buyfeld or mc.num == salefeld) {
            mc.gotoAndStop(1);
        } else if (mc.num<buyfeld) {
            mc.gotoAndStop(salefeld-mc.num);
        } else if (mc.num>buyfeld) {
            mc.gotoAndStop(mc.num-buyfeld);
        }
        // setzt _xscale auf die Cosinuskurve, abhängig
        mc._xscale = Math.round(mc.gamma/4+75);
        // Dies sorgt dafür, daß _yscale zum Randbereich hin immer flacher wird
        mc._yscale = Math.abs(mc.gamma);
        // setzt die Tiefe so, daß der richtige vorne ist
        mc.swapDepths(mc.tiefe);
    }
} 


[Fralle]

Zitat von artjom

das aufrufen von funktionen: dreheWalze() und Ausgleich() kostet schon einiges an zeit/performance. schieb' also alles was diese funktionen an code haben in die onEnterFrame.

gruß

das heißt, jedes Aufrufen einer Funktion kostet mehr Performance als den Code der Funktion direkt an die Stelle des Aufrufs zu schreiben?!

Also müßten alle Funktionen, die sowieso nur einmalig aufgerufen werden, immer dorthin geschoben werden, wo sie gebraucht werden?

wie verhält es sich eigentlich mit Variablen die über _parent oder _parent._parent etc. angesprochen werden?
Raubt das auch schon Zeit?

Bei mir ist es meistens so, daß der AS-Code sich (aus Gründen der Bequemlichkeit) gerne und oft verschachtelt.

[artjom]

Zitat von Fralle

das heißt, jedes Aufrufen einer Funktion kostet mehr Performance als den Code der Funktion direkt an die Stelle des Aufrufs zu schreiben?!

richtig, guggst de:
OOP sucks!
beispiel:

function test(){
x = x + 2;
}

t = getTimer();
for(i=0; i<1000; i++){
test();
}
trace(getTimer() - t);

t = getTimer();
for(i=0; i<1000; i++){
x = x + 2;
}
trace(getTimer() - t);

output
107
47

gruß

[Fralle]

okay, da sind ja schon 50% drin!

in dem Thread hab' ich gelesen, daß auch jeder Punkt was frisst.
Also möglichst keine _root.'s oder _parent.'s und so verwenden...
da muss ich aber mal ganz schön durch den Code durcharbeiten und 'ne Menge ändern...

[Fralle]

Wie sieht's eigentlich mit Funktionen, die gar nicht aufgerufen werden oder //Kommentaren aus?

Ist ja für's PRG überflüssiger Code.
Dürfte doch eigentlich nicht stören, oder etwa doch?!

Wie verhält es sich mit der Grafik?

-siehe Anhang-
beides ist je ein MC, braucht es mehr Performance den farbigen zu bewegen?

[Fralle]

anhang

[Fralle]

nochmal zu den Funktionen oben:

(var felder = 14)
Das ganze bewegt sich erst, wenn die var "yversatz" geändert wird (was bei gewissen Ereignissen der Fall ist)
Das habe ich jetzt mal geändert.

vorher:
yversatz += 10
nacher:
//yversatz +=10

Alles läuft wie vorher, nur wird die Walze nicht mehr bewegt.
vorher hatte das ganze bei mir eine durchschnittliche fps von ~13
und jetzt ohne Bewegung ~17

hm...wat nu?

[Fralle]

schade, daß keiner mehr antwortet...

brauche immer noch Hilfe!


hier nochmal ein Update des Walzen-Codes:

PHP-Code:

// Initvars -- felder nur in gerader Anzahl!!
felder = 12;
buyfeld = felder/2;
salefeld = felder/2+1;
// Walzendurchmesser
walze = 220;
// Verteilungsdeltawinkel auf der Walze (vorher 360/felder/2)
deltagrad = 12;
// Walze zurückdrehen, so daß die Mitt wirklich in der Mitte ist;
yversatz = ymitte=-(felder/2)*deltagrad-deltagrad/2;
// Walzen Ausgleich
createEmptyMovieClip("walzenausgleich", 250);
walzenausgleich.onEnterFrame = function() {
    if (yversatz<(ymitte-14)) {
        walzenmove = true;
        yversatz += 1;
    } else if (yversatz<ymitte) {
        walzenmove = true;
        yversatz += 0.5;
    } else if (yversatz>(ymitte+14)) {
        walzenmove = true;
        yversatz -= 1;
    } else if (yversatz>ymitte) {
        walzenmove = true;
        yversatz -= 0.5;
    } else if (yversatz == ymitte) {
        walzenmove = false;
    }
    //
    if (walzenmove) {
        for (var i = 1; i<=felder; i++) {
            var mc = _parent.dax["allfields"+i];
            var t = DegToRad(deltagrad*i+yversatz);
            // setzt _y auf [-240...+240]
            mc._y = Math.round(Math.sin(t)*walze);
            // setzt gamma auf [0...100]
            var gamma = Math.round(Math.cos(t)*100);
            // setzt _xscale auf die Cosinuskurve, abhängig
            mc._xscale = Math.round(gamma/4+75);
            // Dies sorgt dafür, daß _yscale zum Randbereich hin immer flacher wird
            mc._yscale = Math.abs(gamma);
            // setzt die Tiefe so, daß der richtige vorne ist
            mc.swapDepths(gamma+100);
            if (i == buyfeld or i == salefeld) {
                mc._xscale = 100;
                mc._yscale = 100;
            }
        }
    }
};
// Rad in Deg
function DegToRad(angle) {
    var radian = angle*Math.PI/180;
    return radian;
} 


ich habe bisherige Verbesserungsvorschläge einfließen lassen, dies hat jedoch noch nicht zu einer merklichen Performancesteigerung geführt.

nochmal kurz zur Erläuterung:
durch zwei andere Ereignisse wird yversatz += 10; bzw. yversatz -= 10; ausgeführt, wodurch die Walzenbewegung ausgelöst wird.
("allfields"+i sind immer 3 nebeneinanderliegende Felder)
Wer hat noch Ideen, wie man das ganze vereinfachen und somit schneller machen kann?!