Queuing System...

Hey so i've been trying to figure out how to make a queuing system but i cant find a way...If anyone knows how please let me know.

 

Much specific question.. so much detail contained to help us help you easier... not.

You want a queue?

Code:

 Deque deck = new ArrayDeque();

deck.pop() will take off the last element inserted.
deck.push(anObject) will push that object onto the "top" of the queue.

Deque is a special kind of queue that allows inserting/removing from both ends, so it nether FIFO (first in first out) or LIFO (last in first out), but both. (more information here)

As for a "queuing system".. if that doesn't already answer your question, can you elaborate?

 

Code:java

//Setting an ArrayList that will serve as a queue
List<String> queue = new ArrayList<String>();
 
//Adding new people in the queue
queue.add(player.getName());
 
//Removing people from the queue
queue.remove(player.getName());
 
//Getting the people on the queue
queue.get(0);
queue.get(1);
queue.get(2);
...
 
//If the person is in the queue
if(queue.contains(player.getName())){
 
}

 

Create a list with what you need to work, for example, I'll make a queue for setting the blocks to Dirt

Code:java

LinkedArrayList<Block> queue = new LinkedArrayList();

Ok, now that I have the queue, i'll keep setting all blocks to dirt with a limit per run. (using a SyncRepeatingTask)

Code:java

private void run() { // all this inside a repeating task, so it'll loop everytime, if you set timesperRun outside of this, it wont loop, it'll stop after a few repeats
int timesPerRun = 100;
if(queue.size() < timesPerRun) { // if the queue size is lower than the runs that we'll do
timesPerRun = queue.size(); // make it more efficient by just making what we need
}
 
while(timesPerRun > 0) { // i'm NOT sure, but I think you can do '&& queue.size() > 0' here
Iterable<Block> iterable = queue.iterable();
if(iterable.hasPrevious()) { // I'll use previous so older values are always removed
Block block = iterable.previous();
block.setType(Material.DIRT);
queue.remove(block);
}
}
}

I THINK thats how you create a queue... I'm not sure lol - I made this queue to run a task with a limitation on each run because you'll need depending on whats the queue for. But you can make queues with a ordered list (list that doesn't lose its order)

 

rfsantos1996 iBieel Darq sorry guys i should have been more specific. I meant that i want to make a system that when a player enables it, the system searches for someone else that enabled it too so they can have a match together

 

You should use Darq or iBieel, mine is more useful for tasks that require queueing because its a heavy performance...

 

Code:java

import java.util.HashMap;
 
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
 
 
public class PlayerQueueSystem {
 
private JavaPlugin plugin;
private int queueSize;
public PlayerQueueSystem(JavaPlugin plugin, int queueSize){
  this.plugin = plugin;
  this.queueSize = queueSize;
}
 
private final HashMap<String,Integer> player_index = new HashMap<String,Integer>();
private String[] player_queue = new String[queueSize];
 
/**
  *
  * @return    Next available spot in the queue.
  */
private int getNextSpot(){
  int freeIndex = 0;
  int i;
  for(i = 0; i <= queueSize; i++){
  if(player_queue[i] == "" | player_queue[i] == null){
    freeIndex = i;
    continue; // breakpoint
  }
  }
 
  return freeIndex;
}
/**
  *
  * @return    True if there is a spot in the queue, false if there is no space in the queue.
  */
private boolean hasNextSpot(){
  if(getNextSpot() > queueSize) return false;
  else return true;
}
 
/**
  * Adds a player (by name) to the queue and flags them for selection.
  * @param p    Player to add to the queue
  *
  * @return    If the player was added to the queue, return true else return false.
  */
public boolean queue_add(String pName){
  if(hasNextSpot()){
  int nextSpot = getNextSpot();
  player_queue[nextSpot] = pName;
  player_index.put(pName, nextSpot);
  return true;
  }
  else return false;
}
 
/**
  * Removes a player (by name) from the queue and unflags them for selection.
  * @param p    Player to remove from the queue
  *
  * @return    If the player was removed from the queue, return true else return false.
  */
public boolean queue_rem(String pName){
  if(hasNextSpot()){
  player_queue[player_index.get(pName)] = "";
  player_index.put(pName, -1);
  return true;
  }
  else return false;
}
 
/**
  * This has to be called in an onPlayerJoin() or other similar method; creates the defaults for the player
  * @param p
  */
public void queue_default(Player p){
  player_index.put(p.getName(), -1); // -1 value prevents selection
}
 
/**
  * This is called when you want to select some people from the queue
  * @return    Array of player names that have been selected from the queue
  */
public String[] queue_select(int amountToSelect){
  String[] selected = new String[amountToSelect];
 
  int i;
  int index = 0;
  for(i = 0; i <= queueSize; i++){
  if(index > amountToSelect) continue;
 
  if(player_queue[i] != null && player_queue[i] != ""){
    // Player is in the queue
    if(player_index.get(player_queue[i]) > 0){ // Check if they are flagged for selection
    // Add them to the selected players
    selected[index] = player_queue[index];
 
    // Remove them from the queue
    queue_rem(player_queue[i]);
 
    // Increment up the selection index
    index++;
    }
  }
  }
 
  return selected; // Returns a string array of the selected players so that the plugin can do something with them
}
}
[/i][/i][/i][/i][/i][/i]

This should work for your needs, bud. Good luck!