Probleme beim Auslesen einer Liste

[SingSing]

Hallo liebe Mitglieder,
ich habe ein Programm geschrieben, welches Spielsteine verschiebt und die höchste Punktzahl ausgibt. Das Programm funktioniert, ist jedoch rekursiv geschrieben und hängt sich bei großen Feldern auf. Ich wollte das Programm nun iterative schreiben. Die einzelnen Elemente werden in die Liste eingefügt, aber er immer das Orginalelement auf und arbeitet damit. Aus diesem Grund läuft das Programm in einer Endlosschleife.
Wer kann mir da helfen?

public class Iterativmanagement {
	private List<KompositumNodeCenter> childComponents = new LinkedList<KompositumNodeCenter>();
	Iterator<KompositumNodeCenter> iteratorKomponent = childComponents.iterator();
	...

	public Iterativmanagement(int[] startfieldid, boolean win, boolean lose,
			boolean indifferent, int score, int columns, int lines) {
        ...
	}

	public void startoperation() {
		for (iteratorKomponent = childComponents.iterator(); iteratorKomponent.hasNext(); )
		{
			  createallFieldconfiguration(); 
	  		  komp = new  KompositumNodeCenter(columns, lines); 
	  		  iteratorKomponent = childComponents.iterator();
	  		  komp = iteratorKomponent.next(); 
			  win = komp.isWin(); 
			  lose = komp.isLose(); 
			  indifferent =komp.isIndifferent(); 
			  score = komp.getScore(); 
			  System.arraycopy(komp.getFieldid(), 0, this.fieldid, 0, komp.getFieldid().length);
		}
	}
	
// 	Erzeuge alle Kombinationen des Feldes
	private void createallFieldconfiguration() { 
		for (int i = 0; i < lines; i++) {
			for (int j = 1; j < columns; j++) {
				operation(i, j, true);}}
       ...
		}

// 	setze die Werte des aktuellen Knoten in das Objekt für die einzelnen Operationen 
	private void setNodeOperationValue() {
        ...
	}
	
	// entscheidet, ob elemet weitere elemente erzeugt oder gewinnt, verliert usw
	private void operation(int numberof, int step, boolean movelineorcolumn) {
		setNodeOperationValue();
		if(!nodeoperation.justemptyfields(movelineorcolumn, numberof))
		{
			nodeoperation.editfieldid(movelineorcolumn, numberof, step);

				if (nodeoperation.checkwin() || nodeoperation.checklose()||nodeoperation.checkindifferent()) 
					...do something, if you won, lose or indifferent...
		} else {	
			nodeoperation.score(this.score);
			SaveClass.setScore(nodeoperation.getScore());
			if (SaveClass.berechneScore(SaveClass.maxPoint(fieldid), nodeoperation.getScore())) {
				createnewNode();
				}}}}

	// Erzeuge neues Element und füge es an die Liste
	private void createnewNode() { // mache Knoten und füge ihn zur Liste
		KompositumNodeCenter kn = new KompositumNodeCenter(columns, lines);
		kn.setIndifferent(nodeoperation.checkindifferent());
		kn.setLose(nodeoperation.checklose());
		kn.setScore(nodeoperation.getScore());
		kn.setWin(nodeoperation.checkwin());
		System.arraycopy(nodeoperation.getfieldid(), 0, copyfieldid, 0, nodeoperation.getfieldid().length);
		kn.setFieldid(copyfieldid);
		add(kn);
	}

        ...
	public void add() {
        ...
}

 

[SlaterB]

dein Programm ist nicht vollständig, man kann es nicht testen,

allzu genau benennst du den Fehler nicht, z.B. könntest du untersuchen wieviele Elemente in der Liste sind, ob es mehr werden, ob du ein Element wirklich herausnimmst (im Code nicht zu sehen)
oder immer dasselbe erste

im Programm fehlen Kommentare, willst du denn gar nicht konzentriert helfen? bedenke dass das für Antworten wichtig ist..

was ist
> for (iteratorKomponent = childComponents.iterator(); iteratorKomponent.hasNext(); )
die Hauptschleife?

wieso steht
> createallFieldconfiguration();
darin, was genaum macht das, reicht das nicht einmal am Anfang?

> komp = new KompositumNodeCenter(columns, lines);
> iteratorKomponent = childComponents.iterator();
> komp = iteratorKomponent.next();

wofür wird das erste komp neu erzeugt, wenn gleich danach wieder überschrieben?

Iterator lasse wohl lieber komplett weg,
mache eine Schleife while(true) oder while(not empty)
und hole einfach das erste Element mit get(0) wenn eine Liste,
sonst durchaus mit Iterator, aber nur in einer Zeile, nicht als Attribut merken

ach ja, und removen

 

[SingSing]

dein Programm ist nicht vollständig, man kann es nicht testen
im Programm fehlen Kommentare, willst du denn gar nicht konzentriert helfen?

Das Programm ist schon relativ groß, aber ich werde es mit Kommentaren versehen und nachreichen.

allzu genau benennst du den Fehler nicht, z.B. könntest du untersuchen wieviele Elemente in der Liste sind, ob es mehr werden, ob du ein Element wirklich herausnimmst oder immer dasselbe erste

.size() habe ich getest, aber nicht ob ich immer das erste Element verwende. Sehr gute Idee!

for (iteratorKomponent = childComponents.iterator(); iteratorKomponent.hasNext(); )

Ja, ist die Hauptschleife.

createallFieldconfiguration();

In dieser Methode werden alle Kombinationen des Spieldfeldes abgefragt.

komp = new KompositumNodeCenter(columns, lines);
iteratorKomponent = childComponents.iterator();
komp = iteratorKomponent.next();

Ok! Erzeugung des Objektes scheint unnötig. Iterator() muss immer nach der Implementierung durch add erfolgen. iterator.next soll eigentlich die Werte des Elements laden. Mit diesen soll man anschließend weiterarbeiten.

Iterator lasse wohl lieber komplett weg, mache eine Schleife while(true) oder while(not empty)

Werde ich mal ausprobieren. Danke für den Tipp!

sonst durchaus mit Iterator, aber nur in einer Zeile, nicht als Attribut merken

Dies Anmerkung verstehe ich leider nicht.

removen

Meinst du damit den Befehl remove? All Gegenteil von add?

Vielen Dank! Deine Anmerkungen haben mir jetzt schon sehr geholfen. Werde das Programm das nächste Mal komplett posten, einschließlich der Kommentare.
LG SingSing

 

[SlaterB]

> Dies Anmerkung verstehe ich leider nicht.

bei einem set kann man nur über Iterator an ein Element

> Meinst du damit den Befehl remove? All Gegenteil von add?

ohne remove wird die Collection nicht leerer, wenn du es einmal durchläufst ginge es vielleicht dennoch,
bei bei ständig neuen Iterator immer wieder von vorne..

> In dieser Methode werden alle Kombinationen des Spieldfeldes abgefragt.

das hat für mich keine sonderliche Aufklärung,
entscheidend ist, ob ganz viele Felder in die Collection kommen?
wenn ja und immer dieselben, dann sollte das wohl nicht ständig wiederholt werden?

 

[SingSing]

Moin SlaterB und alle anderen,

hat etwas länger gedauert. Das Programm funktioniert, aber es läuft nur für 6x6 Felder. Ich benötige jedoch 8x9. Muss jetzt das Programm optimieren. Vielleicht hat irgendjemand eine Idee. Jetzt erstmal das vollständige Prog. Meiner Meinung muss die Optimierung in der Iterativmanagement geschehen, da hier die Elemente der Liste erzeugt werden.

public class Initmain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int columns = 6;
		int lines = 6;
		
		// Orginalfeld
		int [] fieldid =  {	2, 0, 0, 1, 2,0,
				0, 21,0, 0, 0,0, 
				0, 0, 0, 0, 3,0, 
				0, 19,0, 0, 0,0, 
				0, 0, 0, 20,0,0,
				0, 0, 0, 0,0,	0
				};
	
		// Instance des Objektes
		Iterativmanagement itm = new Iterativmanagement(fieldid, false, false, false, 0,columns, lines) ;
		// starte das Programm
		itm.startoperation();
		// Ergebnisausgabe
		System.out.println("Ende der main"+SaveClass.getScore());	}}

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class Iterativmanagement {
	private List<KompositumNodeCenter> childComponents = new LinkedList<KompositumNodeCenter>();
	Iterator<KompositumNodeCenter> iteratorKomponent = childComponents.iterator();
	private int columns;			// Spalten des Spielfeldes
	private int lines;				// Zeilen des Spielfeldes
	private int score;				// Punktestand
	private int[] fieldid;			// speichert die id der Steine
	protected int[] copyfieldid;
	private NodeOperation nodeoperation;	// beinhaltet die Logik z.B. Verschiebung der 
	private KompositumNodeCenter komp;
	private int glob = 0;

	public Iterativmanagement(int[] startfieldid, boolean win, boolean lose,
			boolean indifferent, int score, int columns, int lines) {
		fieldid = new int[columns * lines];
		copyfieldid = new int[columns * lines];
		this.fieldid = startfieldid;
		this.score = score;
		this.columns = columns;
		this.lines = lines;
		nodeoperation = new NodeOperation(columns, lines);
		setNodeOperationValue();  	// setzt die Ausgangswerte 
		createnewNode();			// erzeugt das erste Element der Liste	}

	// startet die Hauptschleife
	public void startoperation() {
		for (iteratorKomponent = childComponents.iterator(); iteratorKomponent.hasNext(); )
		{
			System.out.println("win" +childComponents.size() );
			createallFieldconfiguration(); 
			// nach dem Zufügen weiterer Elemente muss die der Iterator neu zugewiesen werden
			iteratorKomponent = childComponents.iterator();
			// Anwahl des Elementes 0
			komp = iteratorKomponent.next(); 
			// Löschen des angewählten Elementes, da bereits bearbeitet
			iteratorKomponent.remove();
			// wiederanwahl des ersten Elementes
			komp = iteratorKomponent.next(); 
			// zuweisung des derzeitigen Punktestandes
			score = komp.getScore(); 
			// kopieren des gespeicherten Arrays
			System.arraycopy(komp.getFieldid(), 0, this.fieldid, 0, komp.getFieldid().length);	}}
	
// 	geht alle Kombinationen des Feldes durch
	private void createallFieldconfiguration() { 
		// für Spalten
		for (int i = 0; i < lines; i++) {
			for (int j = 1; j < columns; j++) {
				operation(i, j, true);}}

		// für Zeilen
		for (int i = 0; i < columns; i++) { // verschiebung der Felder in der Spalte
			for (int j = 1; j < lines; j++) {
				operation(i, j, false);	}}}

// 	setze die Werte des aktuellen Knoten in das Objekt für die Operationen
	private void setNodeOperationValue() {
		nodeoperation.setColumns(columns);
		nodeoperation.setLines(lines);
		nodeoperation.setNofieldid(fieldid);
		nodeoperation.setScore(score);
		nodeoperation.setDeadownstone(0);
		nodeoperation.setDeadenemystone(0);}
	
	// entscheidet, ob elemet weitere elemente erzeugt oder gewinnt, verliert usw
	private void operation(int numberof, int step, boolean movelineorcolumn) {
		setNodeOperationValue();	// setzt die Ausgangswerte
		if(!nodeoperation.justemptyfields(movelineorcolumn, numberof)){
		// bearbeite Feld
		nodeoperation.editfieldid(movelineorcolumn, numberof, step);
		// wenn das Spiel gewonnen, verloren oder unentschieden ist, sonst erstelle weiteres Element
				if (nodeoperation.checkwin() || nodeoperation.checklose()||nodeoperation.checkindifferent()) 
					{
					// setzt in der nodeoperation die Punkte des derzeitigen Spielfeldes
					nodeoperation.score(this.score);
					// wenn das Feld gewonnen hat, dann setze den Spielstand, sonst 0
					if(nodeoperation.checkwin())
						{
						SaveClass.setScore(nodeoperation.getScore());
						}
		} else {	
			nodeoperation.score(this.score);
			SaveClass.setScore(nodeoperation.getScore());
			// wenn man mit dem field noch gewinnen kann, dann erstelle ein weiteres Element
			if (SaveClass.berechneScore(SaveClass.maxPoint(fieldid), nodeoperation.getScore())) {
				createnewNode();
				}}}}

	// Erzeuge neues Element und füge es an die Liste
	private void createnewNode() { // mache Knoten und füge ihn zur Liste
		KompositumNodeCenter kn = new KompositumNodeCenter(columns, lines);
		kn.setScore(nodeoperation.getScore());
		System.arraycopy(nodeoperation.getfieldid(), 0, copyfieldid, 0, nodeoperation.getfieldid().length);
		kn.setFieldid(copyfieldid);
		add(kn);	}
	
	// Überschreiben der Defaulimplementierung
	public void add(KompositumNodeCenter pComp) {
		childComponents.add(pComp);}

	// Überschreibend er Methode entfernen
	public void remove(KompositumNodeCenter pComp) {
		childComponents.remove(pComp);	}

	public KompositumNodeCenter getChild(int pIndex) {
		return childComponents.get(pIndex);
	}}

// Objektelement
public class KompositumNodeCenter {

	private int columns;
	private int lines;
	private int score;
	private int [] kncfieldid;
	
	public KompositumNodeCenter(int columns, int lines){
		this.columns = columns;
		this.lines = lines;
		kncfieldid = new int[columns*lines];}

	public int getScore() {
		return score;}

	public void setScore(int score) {
		this.score = score;}

	public int[] getFieldid() {
		return kncfieldid;}

	public void setFieldid(int [] fieldid) {
		System.arraycopy(fieldid, 0, kncfieldid, 0, fieldid.length);}}

/**
 * contain all operations to change the fieldid and check the win and loses
 */
public class NodeOperation {

	private int lines;
	private int columns;
	private int[] nofieldid;
	private boolean[][] killmatrix = new boolean[36][36];
	protected int deadenemystone = 0;
	protected int deadownstone = 0;
	protected int score = 0;
	private boolean winner;

	public NodeOperation(int columns, int lines){
		this.columns = columns; 
		this.lines = lines;
		nofieldid = new int[columns * lines];
		setKillMatrix();	
	}
	
	public void setDeadenemystone(int deadenemystone) {
		this.deadenemystone = deadenemystone;
	}

	public void setDeadownstone(int deadownstone) {
		this.deadownstone = deadownstone;
	}

	public NodeOperation(int columns, int lines, int[] fieldid) {
		System.arraycopy(fieldid, 0, this.nofieldid, 0, fieldid.length);
		this.lines = lines;
		this.columns = columns;
		setKillMatrix();
		nofieldid = new int[columns * lines];
	}

	public void setScore(int score) {
		this.score = score;
	}

	public int getScore() {
		return score;
	}

	protected int[] getNofieldid() {
		return nofieldid;
	}

	protected void setNofieldid(int[] fieldid) {
		System.arraycopy(fieldid, 0, this.nofieldid, 0, fieldid.length);
	}

	protected int getLines() {
		return lines;
	}

	protected void setLines(int lines) {
		this.lines = lines;
	}

	protected int getColumns() {
		return columns;
	}

	protected void setColumns(int columns) {
		this.columns = columns;
	}

	protected void editfieldid(boolean lineorcolumn, int numberof, int step) {
		updateEndPosition(lineorcolumn, numberof, step);
		destroyStoneCenter(lineorcolumn, numberof);
	}

	protected int[] getfieldid() {
		return nofieldid;
	}

	public void score(int currentscore) {
		score = currentscore - 5 + deadenemystone * 25 - deadownstone * 50;
	}

	/**
	 * check the field for winner
	 */
	protected boolean checkwin() {
		winner = true;
		for (int i = 0; i < nofieldid.length; i++) {
			if (nofieldid[i] < 19 && nofieldid[i] > 0) {
				winner = false;
				i = nofieldid.length;
			}
		}
		return winner;
	}

	protected boolean justemptyfields(boolean lineorcolumn, int numberof) {
		boolean justempty = true;
		if (lineorcolumn) {
			for (int i = (columns * numberof); i < (columns * numberof)
					+ columns; i++) {
			if (nofieldid[i] > 0) {
					justempty = false;
					i = 100;
				}
			}
		} else {
			for (int i = numberof; i <= numberof + (columns * (lines - 1)); i = i
					+ columns) {
				if (nofieldid[i] > 0) {
					justempty = false;
					i = 100;
				}
			}
		}
		return justempty;
	}

	// prüft auf verlieren
	protected boolean checklose() {
		boolean lose = true;
		for (int i = 0; i < nofieldid.length; i++) {
			if ((nofieldid[i] > 18)) {
				lose = false;
				i = nofieldid.length;
			}
		}
		return lose;
	}

	// prüft auf unentschieden
	protected boolean checkindifferent() {
		boolean indifferent = false;
		for (int i = 0; i < nofieldid.length; i++) {
			if (nofieldid[i] > 0 && nofieldid[i] < 19) {

				for (int j = 0; j < nofieldid.length; j++) {
					if (killmatrix[nofieldid[i]][nofieldid[j]]) {
						j = nofieldid.length;
						indifferent = false;
					} else {
						indifferent = true;
						if(j==(nofieldid.length-1)){
							j = nofieldid.length;
							i = nofieldid.length;
						}
					}
				}
			}
		}	
		return indifferent;
	}

	// if true, dann zerstöre den Stein 
	protected boolean isitadeadStone(int firststoneid, int secondstoneid) {
		/*
		 * firststoneid is the line at the array, secondstoneid is the column
		 */

		if (killmatrix[firststoneid][secondstoneid]) {
			if (firststoneid < secondstoneid) {
				++deadenemystone;
			} else {
				++deadownstone;
			}
		}
		return killmatrix[firststoneid][secondstoneid];
	}

	// welcher Stein zerstört, welchen Stein
	protected void setKillMatrix() {

		for (int i = 0; i < 36; i++) {
			for (int j = 0; j < 36; j++) {
				killmatrix[i][j] = false;
			}
		}

		killmatrix [1][20]= true;
		killmatrix [1][24]= true;
		killmatrix [1][27]= true;
		killmatrix [2][21]= true;
		killmatrix [2][26]= true;
		killmatrix [2][27]= true;
		killmatrix [3][19]= true;
		killmatrix [3][24]= true;
		killmatrix [3][25]= true;
		
		killmatrix [6][20]= true;
		killmatrix [6][26]= true;
		killmatrix [6][27]= true;
		killmatrix [7][19]= true;
		killmatrix [7][20]= true;
		killmatrix [7][24]= true;
		
		killmatrix [19][2]= true;
		killmatrix [20][3]= true;
		killmatrix [21][1]= true;
	}

	// setzt die Steine entsprechend der Bewegungsrichtung und Bewegungsweite
	protected void updateEndPosition(boolean movelineorcolumn, int numberof,
			int step) {
		int[] tempidsave = new int[columns * lines];
		for (int i = 0; i < nofieldid.length; i++) {
			tempidsave[i] = nofieldid[i];
		}

		if (movelineorcolumn) {
			int tempstart = columns;
			for (int j = (tempstart * numberof); j < (tempstart * numberof)
					+ tempstart; j++) {
				if ((step + j) < (tempstart * numberof) + tempstart) {
					nofieldid[j + step] = tempidsave[j];
				} else {
					nofieldid[j + step - tempstart] = tempidsave[j];
				}
			}
		} else {
			int tempstart = columns;
			for (int j = numberof; j <= numberof + (columns * (lines - 1)); j = j
					+ tempstart) {
				if (((step * tempstart) + j) <= (numberof + (lines - 1)
						* columns)) {
					nofieldid[j + (step * tempstart)] = tempidsave[j];
				} else {
					nofieldid[j + (step * tempstart) - (lines * columns)] = tempidsave[j];
				}
			}
		}
	}

	// koordiniert die einzelnen Fälle der Zerstörung
	protected void destroyStoneCenter(boolean movelineorcolumn, int numberof) {
		if (movelineorcolumn) {
			if (numberof == 0) {
				destroyStoneinmovingLine(movelineorcolumn, numberof);
				destroyStonesintheneighbourhood(movelineorcolumn,
						(numberof + 1), (-columns));
				destroyStonesintheneighbourhood(movelineorcolumn, (numberof),
						columns);
			} else {
				if (numberof == (lines - 1)) {
					destroyStoneinmovingLine(movelineorcolumn, numberof);
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof - 1), columns);
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof), (-columns));
				} else {
					destroyStoneinmovingLine(movelineorcolumn, numberof);
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof + 1), (-columns));
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof - 1), (columns));
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof), (-columns));
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof), (columns));
				}
			}
		} else {
			if (numberof == 0) {
				destroyStoneinmovingLine(movelineorcolumn, numberof);
				destroyStonesintheneighbourhood(movelineorcolumn,
						(numberof + 1), (-1));
				destroyStonesintheneighbourhood(movelineorcolumn, (numberof), 1);
			} else {

				if (numberof == (columns - 1)) {
					destroyStoneinmovingLine(movelineorcolumn, numberof);
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof - 1), 1);
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof), (-1));
				} else {
					destroyStoneinmovingLine(movelineorcolumn, numberof);
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof + 1), (-1));
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof - 1), (1));
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof), (-1));
					destroyStonesintheneighbourhood(movelineorcolumn,
							(numberof), 1);
				}
			}
		}
	}
	
	// regelt die Zerstörung der Steine in der bewegten Linie bzw Spalte
	protected void destroyStoneinmovingLine(boolean movelineorcolumn,
			int numberof) {
		int tempstart;
		int schleifenstart;
		int schleifenende;
		int schleifenschritt;
		int objectwahl;
		int firststone;
		int laststone;

		if (movelineorcolumn) {
			tempstart = columns;
			schleifenstart = (tempstart * numberof);
			schleifenende = (tempstart * numberof) + tempstart;
			schleifenschritt = (tempstart * numberof) + 1;
			objectwahl = 1;
			firststone = schleifenstart;
			laststone = schleifenende - 1;
		} else {
			tempstart = columns;
			schleifenstart = numberof;
			schleifenende = (columns * (lines - 1)) + numberof;
			// schleifenschritt = (tempstart * clickedline) + 1;
			schleifenschritt = schleifenstart + tempstart;
			objectwahl = tempstart;
			firststone = schleifenstart;
			laststone = schleifenende - 1;
		}
		//
		// Log.i("TAG", "laststone" + laststone);
		for (int j = schleifenstart; j < schleifenende; j = schleifenschritt) {
			if (movelineorcolumn) {
				schleifenschritt = j + 1;
			} else {
				schleifenschritt = j + tempstart;
			}
			if (j == firststone) {

				if (isitadeadStone(nofieldid[j], nofieldid[j + objectwahl])) {
					doifitisadeadStone(j);
				}
			} else {
				if (j == laststone) {
					if (isitadeadStone(nofieldid[j], nofieldid[j - objectwahl])) {
						doifitisadeadStone(j);
					}} else {
					if (isitadeadStone(nofieldid[j], nofieldid[j + objectwahl])
							|| isitadeadStone(nofieldid[j], nofieldid[j
									- objectwahl])) {
						doifitisadeadStone(j);}}}}}

	protected void doifitisadeadStone(int j) {
		nofieldid[j] = 0;	}
	
	
	// regelt die Zerstörung der Steine neben der bewegten Linie
	protected void destroyStonesintheneighbourhood(boolean movelineorcolumn,
			int currentline, int neighbourobject) {

		int tempstart;
		int schleifenstart;
		int schleifenende;
		int schleifenschritt;
		int firststone;
		int laststone;

		if (movelineorcolumn) {
			tempstart = columns;
			schleifenstart = (tempstart * currentline);
			schleifenende = (tempstart * currentline) + tempstart;
			schleifenschritt = (tempstart * currentline) + 1;
			firststone = schleifenstart;
			laststone = schleifenende - 1;

		} else {
			tempstart = columns;
			schleifenstart = currentline;
			schleifenende = (columns * (lines - 1)) + currentline + 1;
			schleifenschritt = schleifenstart + tempstart;
			firststone = schleifenstart;
			laststone = schleifenende - 1;
		}

		for (int j = schleifenstart; j < schleifenende; j = schleifenschritt) {
			if (movelineorcolumn) {
				schleifenschritt = j + 1;
			} else {
				schleifenschritt = j + tempstart;
			}
			if (j == firststone) {
				if (isitadeadStone(nofieldid[j], nofieldid[j + neighbourobject])) {
					doifitisadeadStone(j);
				}
			} else {
				if (j == laststone) {

					if (isitadeadStone(nofieldid[j], nofieldid[j
							+ neighbourobject])) {
						doifitisadeadStone(j);
					}
				} else {

					if (isitadeadStone(nofieldid[j], nofieldid[j
							+ neighbourobject])) {
						doifitisadeadStone(j);
					}}}}}}

public class SaveClass {
	
	static int score = 0;

	/*
	 * set the new score, if higher
	 */
	public static void setScore(int currentscore) {
		if(score <= currentscore){
			SaveClass.score = currentscore;
		}
	}
	
	public static int getScore() {
		return score;
	}

	/*
	 * 
	 */
	public static boolean berechneScore(int currentscore, int ownscore){
		return (score < (currentscore+ownscore)) ? true : false;
	}
	
	/*
	 * count the enemy stones and is it possible to win
	 */
	public static int maxPoint(int [] fieldid){
		int stonenumber = 0;
		// all ids between 0 and 19 are enemys
		for(int i = 0; i<fieldid.length; i++){
			if(fieldid[i] <= 18 && fieldid[i] > 0){
				stonenumber++;
			}
		}
		return stonenumber * 25 - 5;}}

 

[SlaterB]

600 Zeilen Code mal eben..

ich werde mir das nicht alles anschauen und du hast nach wie vor mit keinem Wort erwähnt, was das Programm macht,
bei 540.000 Durchläufen der Hauptschleife habe ich vorerst abgebrochen,
dann wie vorher geschrieben die Methode createallFieldconfiguration(); VOR die Schleife gesetzt,
schon waren es nur noch 39 Durchläufe in Zeit quasi 0,

aber ob das nun hilfreich ist oder das Programm einfach nichts mehr berechnet, kann ich nicht beurteilen

 

[SingSing]

Das Programm soll die höchste mögliche Punktzahl errechnen, welche man durch das verschieben der Felder erreichen kann. Die Felder werden spalten- und lienienweise verschoben. Aus diesem Grund soll das Programm alle Kombinationsmöglichkeiten der Felder ermitteln. Kombinationen ohne Gewinnchance werden aussortiert.

Die Verschiebung der createallFieldconfiguration bewirkt, dass lediglich alle Kombinationen des ersten Feldes erzeugt werden. Es führt dadurch nicht zum eigentlichen Ergebnis.

Du kannst auch ein kleineres Feld benutzen.

		int columns = 3;
		int lines = 3;
		
		// Orginalfeld
		int [] fieldid = 
				{	2, 0,   2,
					0, 21, 0,	
					0, 0,   0,
				};

 

[SlaterB]

also ich fürchte mir ist das zu hoch ohne weitere Erklärungen,
wenn du genaue Regeln und Beispielabläufe notierst, kann ich vielleicht dazu was nachprüfen,
aber sicher ist das nicht, erwarte nicht zu viel

erkannt habe ich schon, dass 0en ziemlich wenig bewirken, erweitere ich dein 3x3-Array auf 6x6 nur mit 0en,
dann gibts auch dort nur wenige Durchläufe,

ändere ich in deinem 6x6 die eine 20 unten auf 0, gibts aber eine Exception,
ein fachfremder kann da nicht durchsehen

 

[SingSing]

Ok, werde ich morgen bzw. übermorgen nachliefern. Ich danke dir trotzdem.