Quellcode für Proben

Ich biete hier jetzt nicht den gesamten Quellcode des Applets an, da er zum Einen recht lang ist und zum Anderen recht verwirrend, insbesondere für Nicht-Java-Kundige. (Zudem ist die Formatierung in HTML recht zeitaufwendig). Daher biete ich hier stattdessen nur die für die Berechnung relevanten Zeilen an, dafür ergänzt durch einige Kommentare. Ich denke das ist sinnvoller, als euch mit haufenweise schwer verständlichen Code zuzudröhnen. (ich hoff nur, ich hab auch keinen Fehler gemacht)

public class Formular
{
// Deklaration der Variablen
private final int MAXPLUS = 7777; // maximal denkbare Plus
private int[ ] eigenschaft = new int[3]; // Die 3 Eigenschaften für die Probe
private int[ ] eigenschaftOrdnung = new int[3]; // fü:r Ordnung der Eigenschaften nach Größe
// Diese Arrays enthalten später die maximale Plus, die noch gelungen wäre
private int[ ][ ][ ] probe1 = new int[20][20][20]; // Offizielle Regeln
private int[ ][ ][ ] probe2 = new int[20][20][20]; // Regelvorschlag von Norman Mauder
private int[ ][ ][ ] probe3 = new int[20][20][20]; // Regelvorschlag von Andreas Wielenberg
private double[ ] prop1,prop2,prop3; // Diese Array enthalten später die Wahrscheinlichtkeiten
private int talentwert; // Der Talentwert
private int minProbe,maxProbe; // minimale und maximale Plus
private int step; // step = ±1, brauch ich, falls die Grenzen falsch rum eingegeben werden

// Konstruktor, führt auch alle Methoden aus
public Formular(int[ ] eigenschaft,int minProbe,int maxProbe,int talentwert)
{
for (int i=0;i<eigenschaft.length;i++)
this.eigenschaft[i] = eigenschaft[i];
setzEigenschaftOrdnung();
if (minProbe<=maxProbe)
step=1;
else
step=-1;
this.minProbe = Math.min(minProbe,maxProbe);
this.maxProbe = Math.max(minProbe,maxProbe);
this.talentwert = talentwert;
maxPlus();
prop1 = setzProp(probe1);
prop2 = setzProp(probe2);
prop3 = setzProp(probe3);
}

// Berechnet maximal mögliche Plus (Erspart mir, dreimal eine Dreifachschleife zu machen)
private void maxPlus()
{
for (int i=0;i<probe1.length;i++)
{
for (int j=0;j<probe1.length;j++)
{
for (int k=0;k<probe1.length;k++)
{
probe1[i][j][k] = berechnemaxPlus1(i+1,j+1,k+1);
probe2[i][j][k] = berechnemaxPlus2(i+1,j+1,k+1);
probe3[i][j][k] = berechnemaxPlus3(i+1,j+1,k+1);
}
}
}
}

// Ordnet die Eigenschaften nach der Größe (eigenschaftOrdnung[0] enthält den Index des größten Eigenschaftwertes)
private void setzEigenschaftOrdnung()
{
int i=0;
for (int j=0;j<3;j++)
{
if (eigenschaft[j]>eigenschaft[i])
i=j;
}
eigenschaftOrdnung[0]=i;
if (eigenschaft[(++i)%3]<eigenschaft[(++i)%3])
{
eigenschaftOrdnung[1] = i%3;
i = (i+2)%3;
eigenschaftOrdnung[2] = i;
}
else
{
i = (i+2)%3;
eigenschaftOrdnung[1] = i;
eigenschaftOrdnung[2] = (++i)%3;
}
}

// Berechnet die maximale Plus, die nach den offiziellen Regeln gelungen wäre
private int berechnemaxPlus1 (int i,int j,int k)
{
if ((i==1 && j==1) || (i==1 && k==1) || (j==1 && k==1))
return MAXPLUS;
if ((i==20 && j==20) || (i==20 && k==20) || (j==20 && k==20))
return -MAXPLUS;
int betraegeSumme = Math.abs(eigenschaft[0]-i) + Math.abs(eigenschaft[1]-j) + Math.abs(eigenschaft[2]-k);
int summe = eigenschaft[0] - i + eigenschaft[1] - j + eigenschaft[2] - k;
if (betraegeSumme == summe)
return summe + talentwert;
else
return talentwert + (summe-betraegeSumme)/2;
}

// Berechnet die maximae Plus nach dem Regelvorschlag von Norman Mauder
private int berechnemaxPlus2 (int i,int j,int k)
{
if ((i==1 && j==1) || (i==1 && k==1) || (j==1 && k==1))
return MAXPLUS;
if ((i==20 && j==20) || (i==20 && k==20) || (j==20 && k==20))
return -MAXPLUS;
if (eigenschaft[0]<i || eigenschaft[1]<j || eigenschaft[2]<k)
return talentwert - Math.max(i-eigenschaft[0],0) - Math.max(j-eigenschaft[1],0) - Math.max(k-eigenschaft[2],0);
else
{
int[ ] plus = new int[3];
plus[0] = eigenschaft[0]-i;
plus[1] = eigenschaft[1]-j;
plus[2] = eigenschaft[2]-k;
if (i==1)
plus[0] = MAXPLUS;
if (j==1)
plus[1] = MAXPLUS;
if (k==1)
plus[2] = MAXPLUS;
return talentwert + Math.min(Math.min(plus[0],plus[1]),plus[2]);
}
}

// Berechnet die maximale plus nach dem Regelvorschlag von Andreas Wielenberg
private int berechnemaxPlus3(int i,int j,int k)
{
if ((i==1 && j==1) || (i==1 && k==1) || (j==1 && k==1))
return MAXPLUS;
if ((i==20 && j==20) || (i==20 && k==20) || (j==20 && k==20))
return -MAXPLUS;
if ( eigenschaft[0]<i || eigenschaft[1]<j || eigenschaft[2]<k)
return talentwert - Math.max(i-eigenschaft[0],0) - Math.max(j-eigenschaft[1],0) - Math.max(k-eigenschaft[2],0);
else
{
int[ ] plus = new int[3];
plus[0] = eigenschaft[0]-i;
plus[1] = eigenschaft[1]-j;
plus[2] = eigenschaft[2]-k;
if (i==1)
plus[0] = MAXPLUS;
if (j==1)
plus[1] = MAXPLUS;
if (k==1)
plus[2] = MAXPLUS;
int rueckgabe = talentwert + 3*Math.min(Math.min(plus[0],plus[1]),plus[2]);
if (plus[eigenschaftOrdnung[0]]>Math.min(plus[eigenschaftOrdnung[1]],plus[eigenschaftOrdnung[2]]))
{
rueckgabe++;
if (plus[eigenschaftOrdnung[1]]>plus[eigenschaftOrdnung[2]])
rueckgabe++;
}
return rueckgabe;
}
}

// Diese Methode set nur das Array der maximalen Plus in ein Array der Gelingwahrscheinlichkeiten um
private double[ ] setzProp(int[ ][ ][ ] probe)
{
double[ ] prop = new double[Math.abs(minProbe-maxProbe)+1];
for (int p=0;p<prop.length;p++)
prop[p] = 0;
for (int i=0;i {
for (int j=0;j<probe.length;j++)
{
for (int k=0;k<probe.length;k++)
{
for (int p=Math.min(prop.length-1,probe[i][j][k]-minProbe);p>=0;p--)
prop[p]++;
}
}
}
for (int p=0;p<prop.length;p++)
prop[p] /= 8000;
return prop;
}

}

Falls ihr genug von diesem Quelltext habt, könnt ihr diese Betriebsanleitung auch wieder zurücklegen und die Wundermaschine noch genauer unter die Lupe nehmen.

Quelltext zu Proben