Bukkit Programmieren Plugin "warten" lassen

[Origenes]

Hey leute,
ich wollte eine Chest Programmieren, wo die Items von der Seite "reinfliegen".
Ich wollte es folgend machen:

	public static void moveItem(Material material, String name, int von, int bis, Inventory inv) {
		ItemStack test = new ItemStack(material);
		ItemMeta meta = test.getItemMeta();
		meta.setDisplayName(name);
		test.setItemMeta(meta);
		while(durchzählen(von, bis) <= bis){
			Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
				@Override
				public void run() {
					Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
						@Override
						public void run() {
							inv.setItem(durchzählen(von, bis), new ItemStack(Material.AIR));
						}					
					}, 10);
					inv.setItem(durchzählen(von, bis), test);			
				}
			}, 10);
		}
	}
	
	public static int durchzählen(int von, int bis){
		for(von = 0; von <= bis; von++){
			return von;
		}
		return von;
	}

Jedoch erstellt es mir da ja so viele Scheduler, dass sogar mein Localhost Server abschmiert^^ weiß jemand eine Methode um einen Scheduler Warten zu lassen, oder eine andere Methode.

Danke

[lordsill]

liegt vllt an deiner guten endlos-schleife.

Betrachten wir erstmal deine durchzählen Methode.

public static int durchzählen(int von, int bis) {
	for(von = 0; von <= bis; von++){
		return von;
	}
	return von;
}

Kurz gesagt:
Du übergibst 2 Variablen. Danach wird die 1. Variable (von) direkt auf 0 gesetzt (durch die for-schleife) und wird dann durch das "return von;" in der for-Schleife direkt zurückgegeben. Damit ist die Methode abgeschlossen und macht nichts weiteres. Also entspricht deine Methode an sich nichts anderes als:

public static int durchzählen(int von, int bis) {
  return 0;
}

So, jetzt betrachten wir nochmal deine while-schleife. Die Bedingung ist:

durchzählen(von, bis) <= bis

Also solange aktuell 0 <= bis ist, wird die Schleife ausgeführt. Ich gehe mal davon aus, dass "bis" keine negative Zahl ist, somit ist diese Bedingung immer erfüllt => Endlos-Schleife

Im End-Effekt ist die durchzählen Methode aktuell der Hauptgrund, warum dir alles um die Ohren fliegt.

Also mögliche Lösung:

public static int durchzählen(int von, int bis) {
  if(von <= bis) {
    return von+1;
  }
  return von;
}

Dazu solltest du nicht vergessen, dass von dann um 1 Wert kleiner sein sollte, als sonst. (Willst du also mit der Zahl 3 anfangen, sollte der Methode als Variable von den Wert 2 übergeben werden (diese gibt dann 3 beim 1. durchlauf zurück))

Und oben dann halt noch:

von--; //Ist das selbe wie: von = von-1;
while((von = durchzählen(von, bis)) <= bis) {
}

und innerhalb der while-Schleife verwendest du dann statt "durchzählen(von, bis)" dann nur noch die variable "von". Danach kommen dann halt noch paar Logikfehler dazu, die du aber mit for-Schleifen beheben kannst.
Denn:
inv.setItem(durchzählen(von, bis), ItemStack); bewirkte nicht, dass alle Slots von von-bis auf ItemStack gesetzt werden, sondern nur 1 Slot wird gesetzt (der Wert, der von durchzählen zurückgegeben wurde (also 0)).

[ComputerBaer]

Ich würde das ganze anders angehen und nein, du bekommst von mir keine Komplettlösung in Code Form.

Du machst es aktuell so, dass du für jedes Item eine ganze Reihe Tasks anlegst. Ich weiß nicht in welchem Bereich sich "von" und "bis" bewegen, aber ich sage jetzt einfach mal das es 20 Tasks pro Item sind, die parallel ausgeführt werden. Dann hast du mit Sicherheit deutlich mehr als ein Item und schon bist du ganz schnell bei Zahlen die kein Programmierer erreichen will.

Ich würde es so machen, dass ich alle Items an einem Ort sammel, z.B. eine Liste, und dann mit genau einem Task alle Items bearbeite. Da gehören dann nürlich ein paar mehr Informationen zu einem Item, aber das ist ja kein Problem. Jedes mal wenn der Task ausgeführt wird, gehst du alle Items durch und schaust welche du jetzt bewegen musst.

Edit:
Außerdem wäre es gut, wenn du auf deutsche Umlaute verzichtest. Mach aus durchzählen lieber durchzaehlen, dann bist du definitiv auf der sicheren Seite. Die Inhaltlichen Probleme hat lordsill schon gut bearbeitet.

[Origenes]

Originally Posted by ComputerBaer

Ich würde das ganze anders angehen und nein, du bekommst von mir keine Komplettlösung in Code Form.

Du machst es aktuell so, dass du für jedes Item eine ganze Reihe Tasks anlegst. Ich weiß nicht in welchem Bereich sich "von" und "bis" bewegen, aber ich sage jetzt einfach mal das es 20 Tasks pro Item sind, die parallel ausgeführt werden. Dann hast du mit Sicherheit deutlich mehr als ein Item und schon bist du ganz schnell bei Zahlen die kein Programmierer erreichen will.

Ich würde es so machen, dass ich alle Items an einem Ort sammel, z.B. eine Liste, und dann mit genau einem Task alle Items bearbeite. Da gehören dann nürlich ein paar mehr Informationen zu einem Item, aber das ist ja kein Problem. Jedes mal wenn der Task ausgeführt wird, gehst du alle Items durch und schaust welche du jetzt bewegen musst.

Edit:
Außerdem wäre es gut, wenn du auf deutsche Umlaute verzichtest. Mach aus durchzählen lieber durchzaehlen, dann bist du definitiv auf der sicheren Seite. Die Inhaltlichen Probleme hat lordsill schon gut bearbeitet.

Nur mein Problem ist ja, wenn ich die Items umsetzen muss ich das ja mit einem Integer machen, der pro durchgang um 1 erhöht wird. Jedoch kann ich ja pro durchgang das nicht um 1 hochzählen, da der Integer Final sein muss und ich ihn so nicht verändern kann^^ Sonst hätte ich das garnicht mit der Methode gemacht

[ComputerBaer]

Originally Posted by Origenes

Nur mein Problem ist ja, wenn ich die Items umsetzen muss ich das ja mit einem Integer machen, der pro durchgang um 1 erhöht wird. Jedoch kann ich ja pro durchgang das nicht um 1 hochzählen, da der Integer Final sein muss und ich ihn so nicht verändern kann^^ Sonst hätte ich das garnicht mit der Methode gemacht

Also um ehrlich zu sein, verstehe ich nicht was du mir damit sagen willst.

Bei meiner Lösung funktioniert das alles ohne Probleme, bei deiner funktioniert es überhaupt nicht.