if (protosMoveEven) {
evenMask += GameTurn.CLASS_PROTOMECH;
}
// Reset all of the Players' turn category counts
for (Enumeration<Player> loop = game.getPlayers(); loop.hasMoreElements();) {
final Player player = loop.nextElement();
player.resetEvenTurns();
player.resetMultiTurns();
player.resetOtherTurns();
player.resetSpaceStationTurns();
player.resetJumpshipTurns();
player.resetWarshipTurns();
player.resetDropshipTurns();
player.resetSmallCraftTurns();
// Add turns for protomechs weapons declaration.
if (protosMoveByPoint) {
// How many Protomechs does the player have?
Enumeration<Entity> playerProtos = game.getSelectedEntities(new EntitySelector() {
private final int ownerId = player.getId();
public boolean accept(Entity entity) {
if ((entity instanceof Protomech) && (ownerId == entity.getOwnerId()) && entity.isSelectableThisTurn()) {
return true;
}
return false;
}
});
HashSet<Integer> points = new HashSet<Integer>();
int numPlayerProtos = 0;
for (; playerProtos.hasMoreElements();) {
Entity proto = playerProtos.nextElement();
numPlayerProtos++;
points.add(new Integer(proto.getUnitNumber()));
}
int numProtoUnits = (int) Math.ceil(numPlayerProtos / 5.0);
if (!protosMoveEven) {
numProtoUnits = points.size();
}
for (int unit = 0; unit < numProtoUnits; unit++) {
if (protosMoveEven) {
player.incrementEvenTurns();
} else {
player.incrementOtherTurns();
}
}
} // End handle-proto-firing-turns
} // Handle the next player
// Go through all entities, and update the turn categories of the
// entity's player. The teams get their totals from their players.
// N.B. protomechs declare weapons fire based on their point.
for (Enumeration<Entity> loop = game.getEntities(); loop.hasMoreElements();) {
final Entity entity = loop.nextElement();
if (entity.isSelectableThisTurn()) {
final Player player = entity.getOwner();
if ((entity instanceof Infantry)) {
if (infMoveEven) {
player.incrementEvenTurns();
} else if (infMoveMulti) {
player.incrementMultiTurns();
} else {
player.incrementOtherTurns();
}
} else if (entity instanceof Protomech) {
if (!protosMoveByPoint) {
if (protosMoveEven) {
player.incrementEvenTurns();
} else if (protosMoveMulti) {
player.incrementMultiTurns();
} else {
player.incrementOtherTurns();
}
}
} else if ((entity instanceof Tank) && tankMoveByLance) {
player.incrementMultiTurns();
} else if ((entity instanceof SpaceStation) && (game.getPhase() == IGame.Phase.PHASE_MOVEMENT)) {
player.incrementSpaceStationTurns();
} else if ((entity instanceof Warship) && (game.getPhase() == IGame.Phase.PHASE_MOVEMENT)) {
player.incrementWarshipTurns();
} else if ((entity instanceof Jumpship) && (game.getPhase() == IGame.Phase.PHASE_MOVEMENT)) {
player.incrementJumpshipTurns();
} else if ((entity instanceof Dropship) && (game.getPhase() == IGame.Phase.PHASE_MOVEMENT)) {
player.incrementDropshipTurns();
} else if ((entity instanceof SmallCraft) && (game.getPhase() == IGame.Phase.PHASE_MOVEMENT)) {
player.incrementSmallCraftTurns();
} else {
player.incrementOtherTurns();
}
}
}
// Generate the turn order for the Players *within*
// each Team. Map the teams to their turn orders.
// Count the number of teams moving this turn.
int nTeams = game.getNoOfTeams();
Hashtable<Team, TurnVectors> allTeamTurns = new Hashtable<Team, TurnVectors>(nTeams);
Hashtable<Team, int[]> evenTrackers = new Hashtable<Team, int[]>(nTeams);
int numTeamsMoving = 0;
for (Enumeration<Team> loop = game.getTeams(); loop.hasMoreElements();) {
final Team team = loop.nextElement();
allTeamTurns.put(team, team.determineTeamOrder(game));
// Track both the number of times we've checked the team for
// "leftover" turns, and the number of "leftover" turns placed.
int[] evenTracker = new int[2];
evenTracker[0] = 0;
evenTracker[1] = 0;
evenTrackers.put(team, evenTracker);
// Count this team if it has any "normal" moves.
if (team.getNormalTurns(game) > 0) {
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--;
}
}
// set fields in game