Solved [Error] Selecting random teams

So i've been developing this new minigame for a server, but it won't select the teams. I really don't know what is wrong and there are no erros in the cmd prompt or in game for anyone to see or notice. Everything (from what I can see) is set up correctly and works like a charm. But what doesn't work is the team selector.

This is the GameHandler class and here is the startGame and initialiseTeams coding.

Code:java

/**
* Start the game
*/
public void startGame() {
initialiseTeams();
 
for(Player p : instance.ph.getPlayers()) {
if(!IMC.containsPlayer(p) && !MILITIA.containsPlayer(p)) {
if(IMC.getSize() > MILITIA.getSize()) {
MILITIA.addPlayer(p);
} else {
if(MILITIA.getSize() > IMC.getSize()) {
IMC.addPlayer(p);
}
}
}
}
 
instance.setState(GameState.IN_GAME);
}
 
/**
* Adds players to the specified teams
*/
private void initialiseTeams() {
 
for(Player p : instance.ph.getPlayers()) {
if(IMC.containsPlayer(p)) {
p.teleport(this.getSpawnIMC());
p.sendMessage(ChatColor.BLUE + "You're on the IMC team.");
if(!this.titanTimer.containsKey(p.getName()))
this.titanTimer.put(p.getName(), this.defaultTitanTimer);
}
else if(MILITIA.containsPlayer(p)) {
p.teleport(this.getSpawnMilitia());
p.sendMessage(ChatColor.RED + "You're on the MILITIA team.");
if(!this.titanTimer.containsKey(p.getName()))
this.titanTimer.put(p.getName(), this.defaultTitanTimer);
}
else {
p.sendMessage(ChatColor.RED + "An error occured whilst trying to teleport you to the spawn locations. You're not on a team.");
}
}
 
}

It's not teleporting the players which means it cannot select teams... Can someone help?

(The entire GameHandler class)

Code:java

package project.titan.java.handlers;
 
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.logging.Level;
 
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.entity.IronGolem;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.scheduler.BukkitRunnable;
 
import project.titan.java.MainComponent;
import project.titan.java.Titanfall;
import project.titan.java.events.BeaconPlaceEvent;
import project.titan.java.handlers.titans.Titan;
import project.titan.java.handlers.titans.TitanManager;
import project.titan.java.util.GameState;
import project.titan.java.util.Messages;
import project.titan.java.util.ServerState;
 
public class GameHandler extends BukkitRunnable implements Listener {
 
//Uninitialised variables
private Titanfall instance;
private boolean cancelled;
 
public TeamHandler IMC;
public TeamHandler MILITIA;
 
private int maximumScore;
 
private int defaultCount;
private int currentCount;
 
private int intermission;
 
private MapHandler currentMap;
 
private TitanManager titanManager;
private int defaultTitanTimer;
private HashMap<String, Integer> titanTimer;
 
private int maximumTitans;
 
private Material beaconMaterial;
 
/**
* Create a GameHandler class to handle
* @param instance
*/
public GameHandler(Titanfall instance) {
this.titanTimer = new HashMap<String, Integer>();
 
this.instance = instance;
this.cancelled = false;
 
this.defaultCount = MainComponent.getInstance().getConfig().getInt("timer.game");
this.currentCount = this.defaultCount;
 
this.maximumScore = MainComponent.getInstance().getConfig().getInt("maximum-score");
 
this.beaconMaterial = Material.BEACON;
 
startIntermission();
}
 
/**
* Initialises all the required variables in order for the plugin to function
*/
private void loadPrerequisites() {
this.intermission = MainComponent.getInstance().getConfig().getInt("timer.intermission");
this.maximumTitans = MainComponent.getInstance().getConfig().getInt("maximum-titans");
this.defaultTitanTimer = MainComponent.getInstance().getConfig().getInt("timer.titan-wait");
 
titanTimer.clear();
 
IMC = new TeamHandler("IMC", ChatColor.BLUE, false);
MILITIA = new TeamHandler("Militia", ChatColor.RED, false);
 
titanManager = new TitanManager();
 
currentMap = getRandomMap();
if(currentMap == null) {
this.setCancelled(true);
MainComponent.getInstance().setState(ServerState.EDIT_MODE);
} else {
MainComponent.getInstance().setState(ServerState.GAME_MODE);
}
}
 
/**
* Get a random map from the List
* @return a random map
*/
public MapHandler getRandomMap() {
if(instance.maps != null && !instance.maps.isEmpty()) {
List<MapHandler> m = instance.maps;
Collections.shuffle(m);
return m.get(0);
} else {
return null;
}
}
 
/**
* Start the intermission
*/
public void startIntermission() {
loadPrerequisites();
 
for(Player p : instance.ph.getPlayers()) {
if(this.getLobbySpawnLocation() != null)
p.teleport(this.getLobbySpawnLocation());
}
 
instance.setState(GameState.INTERMISSION);
}
 
/**
* Start the game
*/
public void startGame() {
initialiseTeams();
 
for(Player p : instance.ph.getPlayers()) {
if(!IMC.containsPlayer(p) && !MILITIA.containsPlayer(p)) {
if(IMC.getSize() > MILITIA.getSize()) {
MILITIA.addPlayer(p);
} else {
if(MILITIA.getSize() > IMC.getSize()) {
IMC.addPlayer(p);
}
}
}
}
 
instance.setState(GameState.IN_GAME);
}
 
/**
* Ends the game, and resets everything to default.
*/
public void endGame() {
//Announce winner...
 
this.startIntermission();
this.currentCount = defaultCount;
}
 
/**
* Adds players to the specified teams
*/
private void initialiseTeams() {
for(Player p : instance.ph.getPlayers()) {
if(IMC.containsPlayer(p)) {
p.teleport(this.getSpawnIMC());
p.sendMessage(ChatColor.BLUE + "You're on the IMC team.");
if(!this.titanTimer.containsKey(p.getName()))
this.titanTimer.put(p.getName(), this.defaultTitanTimer);
}
else if(MILITIA.containsPlayer(p)) {
p.teleport(this.getSpawnMilitia());
p.sendMessage(ChatColor.RED + "You're on the MILITIA team.");
if(!this.titanTimer.containsKey(p.getName()))
this.titanTimer.put(p.getName(), this.defaultTitanTimer);
}
else {
p.sendMessage(ChatColor.RED + "An error occured whilst trying to teleport you to the spawn locations. You're not on a team.");
}
}
 
}
 
/**
* Get the main lobby spawn location
* @return Location object
*/
public Location getLobbySpawnLocation() {
double x, y, z;
float yaw, pitch;
World world;
 
if(Bukkit.getServer().getWorld(MainComponent.getInstance().getConfig().getString("LOBBY.spawn.world")) != null) {
x = MainComponent.getInstance().getConfig().getDouble("LOBBY.spawn.x");
y = MainComponent.getInstance().getConfig().getDouble("LOBBY.spawn.y");
z = MainComponent.getInstance().getConfig().getDouble("LOBBY.spawn.z");
yaw = MainComponent.getInstance().getConfig().getInt("LOBBY.spawn.yaw");
pitch = MainComponent.getInstance().getConfig().getInt("LOBBY.spawn.pitch");
world = Bukkit.getServer().getWorld(MainComponent.getInstance().getConfig().getString("LOBBY.spawn.world"));
 
return new Location(world, x, y, z, yaw, pitch);
} else {
Bukkit.getServer().getLogger().log(Level.SEVERE, "A lobby world doesn't exist! Please create one!");
return null;
}
}
 
/**
* Get the spawn location for the IMC team
*/
public Location getSpawnDefault() {
double x, y, z;
float yaw, pitch;
 
x = currentMap.getConfigurationFile().getConfig().getDouble("DEFAULT.spawn.x");
y = currentMap.getConfigurationFile().getConfig().getDouble("DEFAULT.spawn.y");
z = currentMap.getConfigurationFile().getConfig().getDouble("DEFAULT.spawn.z");
yaw = currentMap.getConfigurationFile().getConfig().getInt("DEFAULT.spawn.yaw");
pitch = currentMap.getConfigurationFile().getConfig().getInt("DEFAULT.spawn.pitch");
 
return new Location(currentMap.getWorld(), x, y, z, yaw, pitch);
}
 
/**
* Get the spawn location for the IMC team
*/
public Location getSpawnIMC() {
double x, y, z;
float yaw, pitch;
 
x = currentMap.getConfigurationFile().getConfig().getDouble("IMC.spawn.x");
y = currentMap.getConfigurationFile().getConfig().getDouble("IMC.spawn.y");
z = currentMap.getConfigurationFile().getConfig().getDouble("IMC.spawn.z");
yaw = currentMap.getConfigurationFile().getConfig().getInt("IMC.spawn.yaw");
pitch = currentMap.getConfigurationFile().getConfig().getInt("IMC.spawn.pitch");
 
return new Location(currentMap.getWorld(), x, y, z, yaw, pitch);
}
 
/**
* Get the spawn location for the MILITIA team
*/
public Location getSpawnMilitia() {
double x, y, z;
float yaw, pitch;
 
x = currentMap.getConfigurationFile().getConfig().getDouble("MILITIA.spawn.x");
y = currentMap.getConfigurationFile().getConfig().getDouble("MILITIA.spawn.y");
z = currentMap.getConfigurationFile().getConfig().getDouble("MILITIA.spawn.z");
yaw = currentMap.getConfigurationFile().getConfig().getInt("MILITIA.spawn.yaw");
pitch = currentMap.getConfigurationFile().getConfig().getInt("MILITIA.spawn.pitch");
 
return new Location(currentMap.getWorld(), x, y, z, yaw, pitch);
}
 
/**
* Set the cancelled boolean of the timer
* @param cancelled as boolean object
*/
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
 
/**
* Check to see if the timer is cancelled or not
* @return boolean object
*/
public boolean isCancelled() {
return cancelled;
}
 
//Temporary int array
private int[] seconds = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 30, 60, 120, 300, 600, 1200, 1800, 3600 };
 
/**
* The runnable method is triggered every ( 1 second / 20 server ticks )
*/
public void run() {
//If the timer isn't cancelled.
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
if(this.instance.getState() == GameState.INTERMISSION) {
if(this.intermission > -1) {
for(int n : seconds) {
if(intermission == n) {
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.intermissionTimer.replace("%%TIME%%", Integer.toString(intermission)));
}
}
}
this.intermission--;
} else {
int minimumRequirement = MainComponent.getInstance().getConfig().getInt("minimum-requirement");
if(instance.ph.getSize() < minimumRequirement) {
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.notEnoughPlayers.replace("%%AMOUNT%%", Integer.toString(minimumRequirement)));
p.sendMessage(ChatColor.YELLOW + "Restarting the intermission...");
}
this.intermission = MainComponent.getInstance().getConfig().getInt("timer.intermission");
} else {
this.startGame();
this.currentCount = defaultCount;
}
}
} else if(this.instance.getState() == GameState.IN_GAME) {
 
if(this.currentCount >= -1) {
for(int n : seconds) {
if(currentCount == n)
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.gameTimer.replace("%%TIME%%", Integer.toString(currentCount)));
}
}
 
titanLoopHandler();
 
if(this.MILITIA.getScore() >= this.maximumScore && this.IMC.getScore() >= this.maximumScore) {
endGame();
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.draw);
}
} else if(this.MILITIA.getScore() >= this.maximumScore) {
endGame();
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.militiaWon);
}
} else if(this.IMC.getScore() >= this.maximumScore) {
endGame();
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.imcWon);
}
}
this.currentCount--;
} else {
if(this.IMC.getScore() == MILITIA.getScore()) {
for(Player p : instance.ph.getPlayers()) {
p.sendMessage(Messages.draw);
}
}
endGame();
}
}
}
}
 
//Events
 
/**
* What happens when a Player respawns...
* @param event PlayerRespawnEvent object
*/
@EventHandler
public void onRespawn(PlayerRespawnEvent event) {
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
if(IMC.containsPlayer(event.getPlayer())) {
event.setRespawnLocation(this.getSpawnIMC());
}
else if(MILITIA.containsPlayer(event.getPlayer())) {
event.setRespawnLocation(this.getSpawnMilitia());
}
else {
event.getPlayer().sendMessage(ChatColor.RED + "An error occured whilst trying to teleport you to the spawn locations. You're not on a team.");
}
}
}
 
/**
* What happens once a player has died
* @param event PlayerDeathEvent object
*/
@EventHandler
public void onDeath(PlayerDeathEvent event) {
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
if(event.getEntity() instanceof Player) {
if(IMC.containsPlayer((Player) event.getEntity())) {
MILITIA.addScore(1);
}
else if(MILITIA.containsPlayer((Player) event.getEntity())) {
IMC.addScore(1);
}
}
}
}
 
/**
* What happens once a player takes damage
* @param event EntityDamageEvent object
*/
@EventHandler
public void onDamage(EntityDamageEvent event) {
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
if(event.getEntity() instanceof Player) {
if(event.getCause() == DamageCause.FALL) {
event.setCancelled(true);
}
}
}
}
 
/**
* What happens when a player breaks a block
* @param event BlockPlaceEvent object
*/
@EventHandler
public void onBreak(BlockBreakEvent event) {
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
this.setCancelled(true);
}
}
 
/**
* What happens when a player interacts with a block.
* @param event PlayerInteractEvent object
*/
@EventHandler
public void onInteract(PlayerInteractEvent event) {
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
this.setCancelled(true);
}
}
 
 
 
 
 
 
 
 
//The code which handles Titans
 
 
 
 
 
 
 
/**
* This is a loop which goes along with the default loop
*/
private void titanLoopHandler() {
//loop through each person and lower his timer...
for(Entry<String, Integer> entry : this.titanTimer.entrySet()) {
if(!(this.titanManager.getTitans().size() >= maximumTitans)) {
if(entry.getValue() >= 0) {
this.titanTimer.remove(entry);
 
int i = entry.getValue();
this.titanTimer.put(entry.getKey(), i--);
} else {
if(Bukkit.getServer().getPlayer(entry.getKey()) != null) {
boolean hasTitan = false;
for(Titan t : this.titanManager.getTitans()) {
if(t.getOwner().getName().equalsIgnoreCase(entry.getKey())) {
hasTitan = true;
}
}
if(!hasTitan) {
giveBeacon(Bukkit.getServer().getPlayer(entry.getKey()));
}
} else {
 
}
}
}
}
}
 
/**
* Give a player a beacon
* @param player Player object
*/
public void giveBeacon(Player player) {
player.getInventory().addItem(new ItemStack(beaconMaterial, 1));
}
 
/**
* What happens when a player places a block
* @param event BlockPlaceEvent object
*/
@EventHandler
public void onPlace(BlockPlaceEvent event) {
if(!this.isCancelled() && MainComponent.getInstance().getState() == ServerState.GAME_MODE) {
if(event.getBlock().getType() == beaconMaterial) {
if(!(this.titanManager.getTitans().size() >= maximumTitans)) {
event.getPlayer().getInventory().remove(beaconMaterial);
 
BeaconPlaceEvent ev = new BeaconPlaceEvent(event.getBlock().getLocation(), event.getPlayer());
MainComponent.getInstance().getServer().getPluginManager().callEvent(ev);
} else {
event.getPlayer().sendMessage(ChatColor.RED + "You cannot place a beacon at this time.");
event.getPlayer().sendMessage(ChatColor.RED + "Maximum number of titans are in play.");
}
}
event.setCancelled(true);
}
}
 
/**
* When a beacon is placed
* @param event BeaconPlaceEvent object
*/
@EventHandler
public void onBeacon(BeaconPlaceEvent event) {
ChatColor color = ChatColor.GREEN;
if(this.IMC.containsPlayer(event.getPlayer())) {
color = ChatColor.BLUE;
} else if(this.MILITIA.containsPlayer(event.getPlayer())) {
color = ChatColor.RED;
}
Titan titan = new Titan(event.getLocation().add(0, 50, 0), event.getPlayer(), color);
 
boolean hasTitan = false;
for(Titan t : this.titanManager.getTitans()) {
if(t.getOwner().getName().equalsIgnoreCase(event.getPlayer().getName())) {
hasTitan = true;
}
}
if(!hasTitan) {
this.titanManager.addTitan(titan);
} else {
event.getPlayer().sendMessage(ChatColor.RED + "You already have a Titan");
}
 
}
 
/**
* When an entity takes damage
* @param event EntityDamageEvent object
*/
@EventHandler
public void onEntityDamage(EntityDamageEvent event) {
if(event.getEntity() instanceof IronGolem) {
event.setCancelled(true);
}
}
 
/**
* When an entity takes damage caused by another entity
* @param event EntityDamageByEntityEvent object
*/
@EventHandler
public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
if(event.getEntity() instanceof IronGolem) {
for(Titan t : this.titanManager.getTitans()) {
if(t.getGolem() == event.getEntity()) {
if(event.getDamager() instanceof Player) {
if(event.getCause() == DamageCause.CONTACT) {
if(((Player) event.getDamager()).getName().equalsIgnoreCase(t.getOwner().getName())) {
//Set mounted!
}
}
}
}
}
event.setCancelled(true);
}
}
 
}
 

In case it's needed, here's my config.yml

Code:

minimum-requirement: 1
maximum-score: 100
maximum-titans: 3
timer:
  game: 60
  intermission: 20
  titan-wait: 15
lobby:
  spawn: {}
LOBBY:
  spawn:
    x: -630.1068948934618
    y: 5.0
    z: -630.000623558105
    yaw: 132.06277
    pitch: 18.455997
    world: hub1

And here's my maps.yml

Code:

maps:
arena1:
world: hub1

Any help would be appreciated. -Thanks XD

 

Maybe use randoms ?

 

I'll give it a shot.

Plugers11 Update: I didn't use Random to select teams. I got my code working but it selects teams but puts every player on the IMC team. Is it because it's trying to add every player to a team at the same time?

Code:java

public void startGame() {
 
    for(Player p : Bukkit.getServer().getOnlinePlayers()) {   
        if(!IMC.containsPlayer(p) && !MILITIA.containsPlayer(p)) {
            if(IMC.getSize() > MILITIA.getSize()) {
                MILITIA.addPlayer(p);
            } else {
            if(!(IMC.getSize() > MILITIA.getSize())) {
            IMC.addPlayer(p);
            }
            }
        }
    }       
       instance.setState(GameState.IN_GAME);
    }
private void initialiseTeams() {
 
        for(Player p : Bukkit.getServer().getOnlinePlayers()) {    
 
        if(IMC.containsPlayer(p)) {
            p.teleport(this.getSpawnIMC());
            p.sendMessage(ChatColor.BLUE + "You're on the IMC team.");
            if(!this.titanTimer.containsKey(p.getName()))
                this.titanTimer.put(p.getName(), this.defaultTitanTimer);
        }
        else if(MILITIA.containsPlayer(p)) {
            p.teleport(this.getSpawnMilitia());
            p.sendMessage(ChatColor.RED + "You're on the MILITIA team.");
            if(!this.titanTimer.containsKey(p.getName()))
                this.titanTimer.put(p.getName(), this.defaultTitanTimer);
        }
        else {
            p.sendMessage(ChatColor.RED + "An error occured whilst trying to teleport you to the spawn locations. You're not on a team.");
        }
    }
 
    }
 
 

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Case and switch.

 

How do they work? (Just give me a basic type of code, it doesn't have to have anything to do with mine) Just to help me out a ltitle.

 

I don't know how to use them for random, but I can if you need a player to join the team with less players

 

That'll be great to equal out teams, Spoon Feed me a little ?? XD

le bump because no one's helping me out. Like a rebel

Not at all.

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

Xyplo Instead of just posting countless threads on here and distracting from others why don't you look around and see if people have asked the same question before?

 

Because this was created a while ago and it's event stated as 'solved'... XD