Abbrechen einer verzögerten Aufgabe, wenn eine andere Aufgabe erstellt wird

Question

Ich habe derzeit eine verzögerte Aufgabe, die ausgeführt wird, wenn ich auf eine Schaltfläche klicke. Durch Klicken auf die Schaltfläche wird ein Boolean auf true umgeschaltet und nach 7 Sekunden wird die verzögerte Aufgabe wieder auf false gesetzt.

Wenn jedoch eine Person mehrmals auf die Schaltfläche klickt, wird der Boolesche Wert ein- und ausgeschaltet, ein- und ausgeschaltet usw., da sich die verzögerten Aufgaben häufen. Gibt es eine Möglichkeit, die verzögerte Aufgabe einfach zu verlängern, wenn die Schaltfläche mehrmals angeklickt wird, anstatt dass sich alle verzögerten Aufgaben aufeinander stapeln?

Nehmen wir an, dass die verzögerte Aufgabe 7 Sekunden warten würde, bevor der Boolesche Wert von true zu false gewechselt wird, sobald die Schaltfläche geklickt wird. Wie würde ich den Code ändern, wenn die Taste erneut gedrückt wird, während die verzögerte Aufgabe nicht ausgeführt wurde, löscht sie die vorherige und führt einfach die nächste verzögerte Aufgabe aus (ich benutze dies für einen Server, also kann die vorherige Aufgabe nicht abgebrochen werden bedeuten, dass es die eigentliche verzögerte Aufgabe war, aber eine andere Aufgabe)?

@EventHandler 
public void damage (EntityDamageEvent event) { 
    Entity victim = event.getEntity(); 
    if (event instanceof EntityDamageByEntityEvent) { 
     EntityDamageByEntityEvent edbeEvent = (EntityDamageByEntityEvent) event; 
     if(edbeEvent.getDamager() instanceof Player && victim instanceof Player) { 
      EntityDamageByEntityEvent edbeEvent1 = (EntityDamageByEntityEvent) event; 
      Entity attacker = edbeEvent1.getDamager(); 
      //Checks if both players are humans and not NPCS. 
      final Player player = (Player) victim; 
      final Player player2 = (Player) attacker; 
      //Saving the players as the variable Player. 
      Damagelist.add(player); 

      Damagelist.add(player2); 
      //Adds both players to the hashmap to be used by other classes. 
      isDamaged = true; 
      //Toggles the boolean to true. 
      int delay = plugin.getConfig().getInt("StunDuration") * 20; 
      //The above line gets the delay time from the config.yml file. 
      plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { 
       public void run() {   

        Damagelist.remove(player); 
        Damagelist.remove(player2); 
        //After an x amount of time, removes players from hashmap. 
        isDamaged = false; 
        playeradd = true; 
        //Toggles the booleans around. 
       } 
      }, delay); 
     } 
    } 
} 

Answer 1

Um sicherzustellen, dass das Ereignis nicht die Folgezeit für das gleiche Schadensereignis nicht laufen Sie isDamaged Variable verwenden können, um zu validieren, wenn der Code ausgeführt werden soll.

Da Sie isDamaged auf true gesetzt, nachdem das Ereignis Validieren Sie einfach einen Scheck gegen diesen Wert vornehmen müssen so hoch wie möglich in dem Fall und wenn es wahr ist, dann wieder nur das gesamte Verfahren aus, die eine weitere geplant aufhören würde Aufgabe wird erstellt.

Wenn du den Spielerschaden auch stoppen möchtest, kannst du auch das gesamte Ereignis abbrechen, bevor du zu anderen Plugins zurückkehrst, die während der Cooldown-Zeit keinen Schaden verursachen dürfen.

// End event, add setCancelled(true), and exit method if the isDamaged modifier is set to true 
if (isDamaged) { 
    event.setCancelled(true); 
    return; 
} 

Hier ist der Code modifiziert, um ein Beispiel für die Verwendung zu zeigen.

@EventHandler 
public void damage (EntityDamageEvent event) { 
    // Get the victim of the damage event. 
    Entity victim = event.getEntity(); 

    // End event, add setCancelled(true), and exit method if the isDamaged modifier is set to true 
    if (isDamaged) { 
     event.setCancelled(true); 
     return; 
    } 

    if (event instanceof EntityDamageByEntityEvent) { 
     // Get the attacker of the event. 
     EntityDamageByEntityEvent edbeEvent = (EntityDamageByEntityEvent) event; 
     Entity attacker = edbeEvent.getDamager(); 

     // Continue only if both players are humans and not NPCS. 
     if(edbeEvent.getDamager() instanceof Player && victim instanceof Player) { 

      // Saving the players as the variable Player. 
      final Player player = (Player) victim; 
      final Player player2 = (Player) attacker; 

      // Add both players to the hashmap to be used by other classes. 
      Damagelist.add(player); 
      Damagelist.add(player2); 

      // Toggle to true. 
      isDamaged = true; 

      // Get delay time from the config.yml file. 
      int delay = plugin.getConfig().getInt("StunDuration") * 20; 

      // Setup delayed task to end cooldown set under StunDuration. 
      plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { 
       // Define task to be run by scheduler. 
       public void run() {   
        // After amount of time set by StunDuration, remove players from hashmap. 
        Damagelist.remove(player); 
        Damagelist.remove(player2); 

        // Toggle back to false; 
        isDamaged = false; 
        playeradd = true; 
       } 
      }, delay); 
     } 
    } 
} 

Answer 2

Dies wäre viel einfacher, wenn Sie Ihren eigenen Thread verwenden würden. verlängern Einfach Thread und diese Klasse verwenden zu tun:

Thread.sleep(timeinmilliseconds); 

Auf diese Weise wird Scheduler-Programmierung viel einfacher, einfache Linie, wo die Zeit wartete kann einer Variablen geändert werden, wenn Sie es verändern wollen in dein Code.