numTeamsMoving++;
}
}
// Now, generate the global order of all teams' turns.
TurnVectors team_order = TurnOrdered.generateTurnOrder(game.getTeamsVector(), game);
// See if there are any loaded units stranded on immobile transports.
Enumeration<Entity> strandedUnits = game.getSelectedEntities(new EntitySelector() {
public boolean accept(Entity entity) {
if (game.isEntityStranded(entity)) {
return true;
}
return false;
}
});
// Now, we collect everything into a single vector.
Vector<GameTurn> turns;
if (strandedUnits.hasMoreElements() && (game.getPhase() == IGame.Phase.PHASE_MOVEMENT)) {
// Add a game turn to unload stranded units, if this
// is the movement phase.
turns = new Vector<GameTurn>(team_order.getTotalTurns() + team_order.getEvenTurns() + 1);
turns.addElement(new GameTurn.UnloadStrandedTurn(strandedUnits));
} else {
// No stranded units.
turns = new Vector<GameTurn>(team_order.getTotalTurns() + team_order.getEvenTurns());
}
// Walk through the global order, assigning turns
// for individual players to the single vector.
// Keep track of how many turns we've added to the vector.
Team prevTeam = null;
int min = team_order.getMin();
for (int numTurn = 0; team_order.hasMoreElements(); numTurn++) {
Team team = (Team) team_order.nextElement();
TurnVectors withinTeamTurns = allTeamTurns.get(team);
int[] evenTracker = evenTrackers.get(team);
float teamEvenTurns = team.getEvenTurns();
// Calculate the number of "even" turns to add for this team.
int numEven = 0;
if (1 == numTeamsMoving) {
// The only team moving should move all "even" units.
numEven += teamEvenTurns;
} else if (prevTeam == null) {
// Increment the number of times we've checked for "leftovers".
evenTracker[0]++;
// The first team to move just adds the "baseline" turns.
numEven += teamEvenTurns / min;
} else if (!team.equals(prevTeam)) {
// Increment the number of times we've checked for "leftovers".
evenTracker[0]++;
// This wierd equation attempts to spread the "leftover"
// turns accross the turn's moves in a "fair" manner.
// It's based on the number of times we've checked for
// "leftovers" the number of "leftovers" we started with,
// the number of times we've added a turn for a "leftover",
// and the total number of times we're going to check.
numEven += Math.ceil(evenTracker[0] * (teamEvenTurns % min) / min - 0.5) - evenTracker[1];
// Update the number of turns actually added for "leftovers".
evenTracker[1] += numEven;
// Add the "baseline" number of turns.
numEven += teamEvenTurns / min;
}
// Record this team for the next move.
prevTeam = team;
if (withinTeamTurns.hasMoreSpaceStationElements()) {
Player player = (Player) withinTeamTurns.nextSpaceStationElement();
GameTurn turn = null;
turn = new GameTurn.EntityClassTurn(player.getId(), GameTurn.CLASS_SPACE_STATION);
turns.addElement(turn);
} else if (withinTeamTurns.hasMoreJumpshipElements()) {
Player player = (Player) withinTeamTurns.nextJumpshipElement();
GameTurn turn = null;
turn = new GameTurn.EntityClassTurn(player.getId(), GameTurn.CLASS_JUMPSHIP);
turns.addElement(turn);
} else if (withinTeamTurns.hasMoreWarshipElements()) {
Player player = (Player) withinTeamTurns.nextWarshipElement();
GameTurn turn = null;
turn = new GameTurn.EntityClassTurn(player.getId(), GameTurn.CLASS_WARSHIP);
turns.addElement(turn);
} else if (withinTeamTurns.hasMoreDropshipElements()) {
Player player = (Player) withinTeamTurns.nextDropshipElement();
GameTurn turn = null;
turn = new GameTurn.EntityClassTurn(player.getId(), GameTurn.CLASS_DROPSHIP);
turns.addElement(turn);
} else if (withinTeamTurns.hasMoreSmallCraftElements()) {
Player player = (Player) withinTeamTurns.nextSmallCraftElement();
GameTurn turn = null;
turn = new GameTurn.EntityClassTurn(player.getId(), GameTurn.CLASS_SMALL_CRAFT);
turns.addElement(turn);
}
// This may be a "placeholder" for a team without "normal" turns.
else if (withinTeamTurns.hasMoreElements()) {
// Not a placeholder... get the player who moves next.
Player player = (Player) withinTeamTurns.nextElement();
// If we've added all "normal" turns, allocate turns
// for the infantry and/or protomechs moving even.
GameTurn turn = null;
if (numTurn >= team_order.getTotalTurns()) {
turn = new GameTurn.EntityClassTurn(player.getId(), evenMask);
}
// If either Infantry or Protomechs move even, only allow
// the other classes to move during the "normal" turn.
else if (infMoveEven || protosMoveEven) {
turn = new GameTurn.EntityClassTurn(player.getId(), ~evenMask);
}
// Otherwise, let *anybody* move.
else {
turn = new GameTurn(player.getId());
}
turns.addElement(turn);
} // End team-has-"normal"-turns
// Add the calculated number of "even" turns.
// Allow the player at least one "normal" turn before the
// "even" turns to help with loading infantry in deployment.
while ((numEven > 0) && withinTeamTurns.hasMoreEvenElements()) {
Player evenPlayer = (Player) withinTeamTurns.nextEvenElement();
turns.addElement(new GameTurn.EntityClassTurn(evenPlayer.getId(), evenMask));
numEven--;
}
}