var breakpoints = new Array();
var breakpoints1 = new Array();
var breakpoints2 = new Array();
while (breakpoints1.length > 0) { breakpoints.pop(); }
while (breakpoints2.length > 0) { breakpoints.pop(); }
while (breakpoints.length > 0) { breakpoints.pop(); }
[color=gold]arrays löschen[/color]
var temp3 = 0;
if ((fertigkeiten[document.myform.skill.value][2] == 1) && (document.myform.zweitwaffe.value > 0))
[color=gold]ausführen bei standartangriff bei verwendung von zwei waffen[/color]
{
for (i=100+SIAS-WSMprimär; i <= 175; i++)
{
frames = waffengattung[waffen[document.myform.waffe.value][2]][document.myform.char.value][0];
[color=gold]in abhängigkeit von waffe und char benötigte frames auslesen[/color]
ergebnis = berechneFPA(frames,i,0);
[color=gold]frames in angriffsdauer umrechnen[/color]
frames = waffengattung[waffen[document.myform.waffe.value][2]][document.myform.char.value][1];
[color=gold]frames der dazugehörigen A2 animation ermitteln[/color]
ergebnis2 = berechneFPA(frames,i,0);
[color=gold]angriffsdauer errechnen[/color]
ergebnis = (ergebnis + ergebnis2)/2;
[color=gold]mittelwertbildung beider angriffe da abwechselnd eingesetzt[/color]
if (temp3 != ergebnis)
{
breakpoints1.push([Math.ceil(120*(i-100-SIAS+WSMprimär)/(120-(i-100-SIAS+WSMprimär)))-IASprimär,ergebnis]);
temp3 = ergebnis;
}
[color=gold]bei änderung der angriffsdauer mit steigendem i die zahl der ticks und das benötigtes IAS als array im array breakpoints1 speichern[/color]
if ((breakpoints1.length > 0) && (breakpoints1[0][0] < 0) && (ergebnis > (berechneFPA(waffengattung[waffen[document.myform.waffe.value][2]][document.myform.char.value][0],175,0) + berechneFPA(waffengattung[waffen[document.myform.waffe.value][2]][document.myform.char.value][1],175,0))/2)) { breakpoints1.pop(); }
if ((breakpoints1.length > 0) && (breakpoints1[0][0] < 0) && (ergebnis == (berechneFPA(waffengattung[waffen[document.myform.waffe.value][2]][document.myform.char.value][0],175,0) + berechneFPA(waffengattung[waffen[document.myform.waffe.value][2]][document.myform.char.value][1],175,0))/2)) { breakpoints1[0][0] = 0; }
[color=gold]wenn ermittelter IAS-wert negativ, eintrag löschen. sollte es der letzte eintrag sein (weil die geschwindigkeit gleich der maximalgeschwindigkeit ist) und der IAS-wert ist negativ, so wird er auf 0 gesetzt[/color]
}
while (breakpoints2.length > 0) { breakpoints2.pop(); }
temp3 = 0;
[color=gold]temp3 für zweite hälte des angriffes wieder auf 0 setzen[/color]
for (i=100+SIAS-WSMsekundär; i <= 175; i++)
{
ergebnis = berechneFPA(12,i,0);
if (temp3 != ergebnis)
{
breakpoints2.push([Math.ceil(120*(i-100-SIAS+WSMsekundär)/(120-(i-100-SIAS+WSMsekundär)))-IASsekundär,ergebnis]);
temp3 = ergebnis;
}
[color=gold]berechne breakpoints für zweite hälte des angriffes, diesmal fixe anzahl an frames[/color]
if ((breakpoints2.length > 0) && (breakpoints2[0][0] < 0) && (ergebnis > berechneFPA(12,175,0))) { breakpoints2.pop(); }
if ((breakpoints2.length > 0) && (breakpoints2[0][0] < 0) && (ergebnis == berechneFPA(12,175,0))) { breakpoints2[0][0] = 0; }
}
[color=gold]arrays mit negativem IAS-wert erneut löschen[/color]
[color=gold](bis hierhin arbeitet das programm noch, in gewisser hinsicht zumindest.
die arrays werden gelöscht, richtig mit den errechneten breakpoints beschrieben
und jene breakpoints mit einem IAS-wert unter null werden gelöscht.
allerdings funktioniert es bloß einmalig. wenn ich die funktion nochmals aufrufen
will, erhalte ich die fehlermeldung "ein skript auf dieser seite
ist momenten beschäftigt oder es antwortet nicht mehr. sie können das skript
jetzt stoppen oder fortsetzen, um zu sehen, ob das skript fertig wird.)[/color]
for (i=0; i <= Math.max(breakpoints1[breakpoints1.length-1][0],breakpoints2[breakpoints2.length-1][0]); i++)
[color=gold]anzahl der schleifendurchläufe entspricht dem größten IAS-wert aus breakpoints1 bzw breakpoints2. hier scheint kein fehler zu stecken, da ich den langen ausdruck auch gegen eine zahl eintauschen kann und die funktion trotzdem nicht arbeitet.[/color]
{
if (breakpoints1[0][0] == i)
{
breakpoints.push(breakpoints1[0]);
breakpoints1.shift();
}
[color=gold]wenn erster IAS-wert in breakpoints1 gleich i ist, kopiere den ersten eintrag von breakpoints1 in breakpoints und lösche ersten eintrag in breakpoints1[/color]
if (breakpoints2[0][0] == i)
{
breakpoints.push(breakpoints2[0]);
breakpoints2.shift();
}
[color=gold]wenn erster IAS-wert in breakpoints2 gleich i ist, kopiere den ersten eintrag von breakpoints2 in breakpoints und lösche ersten eintrag in breakpoints2[/color]
[color=gold](da array.shift() immer das erste element eines arrays löscht
und alle nachfolgenden eine stelle vorrücken, muss ich in beiden fällen
bloß immer das erste element abfragen und löschen.)[/color]
if (breakpoints[breakpoints.length-1][0] == breakpoints[breakpoints.length-2][0])
{
breakpoints[breakpoints.length-2].value = [i,(breakpoints[breakpoints.length-2][1] + breakpoints[breakpoints.length-1][1])/2]
breakpoints.pop();
}
[color=gold]sollten zu einem IAS-wert (i) beide hälften des angriffes einen breakpoint haben,
dann stehen beide bereits in breakpoints drinnen. daher vergleiche ich die IAS-werte
des letzten (length-1) und vorletzen (length-2) eintrages. stimmen sie überein,
ändere ich den wert der angriffsdauer des vorletzen eintrages auf den mittelwert
der angriffsdauern der letzten beiden einträge und lösche im anschluss
mit breakpoints.pop() den letzten, nun unbenötigten eintrag aus breakpoints.[/color]
}
}
Und was heißt hier mit Kanonen auf Spatzen schießen? Ich halte hier eher das ganze Objektgedudel bei so einer einfachen Aufgabenstellung für Overdrive, wo es ein einzelner, sauber formulierter Query besser und schneller erledigt und die Datenpflege dann auch um einiges einfacher wird.
und will nicht, dass dies dann vieleicht überlesen wird.