server.java

MegaMek is a networked Java clone of BattleTech, a turn-based sci-fi boardgame for 2+ players. Fight

            entity.rolledForEngineExplosion = false;
            entity.dodging = false;

            // reset done to false

            if ( phase == IGame.PHASE_DEPLOYMENT ) {
                entity.setDone(!entity.shouldDeploy(game.getRoundCount()));
            } else {
                entity.setDone(false);
            }

            // reset spotlights
            entity.setIlluminated(false);
            entity.setUsedSearchlight(false);
        }
    }

    /**
     * Called at the beginning of certain phases to make
     * every player not ready.
     */
    private void resetPlayersDone() {
        for (Enumeration i = game.getPlayers(); i.hasMoreElements();) {
            final Player player = (Player)i.nextElement();
            player.setDone(false);
        }
    }

    /**
     * Called at the beginning of certain phases to make
     * every active player not ready.
     */
    private void resetActivePlayersDone() {
        for (Enumeration i = game.getPlayers(); i.hasMoreElements();) {
            final Player player = (Player)i.nextElement();

            player.setDone(game.getEntitiesOwnedBy(player) <= 0);

        }
        transmitAllPlayerDones();
    }

    /**
     * Writes the victory report
     */
    private void prepareVictoryReport() {
        Report r;

        addReport(new Report(7000, Report.PUBLIC));

        //Declare the victor
        r = new Report(1210);
        r.type = Report.PUBLIC;
        if (game.getVictoryTeam() == Player.TEAM_NONE) {
            Player player = getPlayer( game.getVictoryPlayerId() );
            if ( null == player ) {
                r.messageId = 7005;
            } else {
                r.messageId = 7010;
                r.add(player.getName());
            }
        } else {
            //Team victory
            r.messageId = 7015;
            r.add(game.getVictoryTeam());
        }
        addReport(r);
        
        //Show player BVs
        Enumeration players = game.getPlayers();
        while ( players.hasMoreElements() ) {
            Player player = (Player) players.nextElement();
            r = new Report();
            r.type = Report.PUBLIC;
            r.messageId = 7016;
            r.add(player.getName());
            r.add(player.getBV());
            r.add(player.getInitialBV());
            addReport(r);
        }

        //List the survivors
        Enumeration survivors = game.getEntities();
        if ( survivors.hasMoreElements() ) {
            addReport(new Report(7020, Report.PUBLIC));
            while ( survivors.hasMoreElements() ) {
                Entity entity = (Entity) survivors.nextElement();

                if ( !entity.isDeployed() )
                  continue;

                addReport( entity.victoryReport());
            }
        }
        //List units that never deployed
        Enumeration undeployed = game.getEntities();
        if ( undeployed.hasMoreElements() ) {
            boolean wroteHeader = false;

            while ( undeployed.hasMoreElements() ) {
                Entity entity = (Entity) undeployed.nextElement();

                if ( entity.isDeployed() )
                  continue;

                if ( !wroteHeader ) {
                  addReport(new Report(7075, Report.PUBLIC));
                  wroteHeader = true;
                }

                addReport( entity.victoryReport());
            }
        }
        //List units that retreated
        Enumeration retreat = game.getRetreatedEntities();
        if ( retreat.hasMoreElements() ) {
            addReport(new Report(7080, Report.PUBLIC));
            while ( retreat.hasMoreElements() ) {
                Entity entity = (Entity) retreat.nextElement();
                addReport( entity.victoryReport());
            }
        }
        //List destroyed units
        Enumeration graveyard = game.getGraveyardEntities();
        if ( graveyard.hasMoreElements() ) {
            addReport(new Report(7085, Report.PUBLIC));
            while ( graveyard.hasMoreElements() ) {
                Entity entity = (Entity) graveyard.nextElement();
                addReport( entity.victoryReport());
            }
        }
        //List devastated units (not salvagable)
        Enumeration devastated = game.getDevastatedEntities();
        if ( devastated.hasMoreElements() ) {
            addReport(new Report(7090, Report.PUBLIC));

            while ( devastated.hasMoreElements() ) {
                Entity entity = (Entity) devastated.nextElement();
                addReport( entity.victoryReport());
            }
        }
        //Let player know about entitystatus.txt file
        addReport(new Report(7095, Report.PUBLIC));
    }

    /**
     * Generates a detailed report for campaign use
     */
    private String getDetailedVictoryReport() {
        StringBuffer sb = new StringBuffer();

        Vector vAllUnits = new Vector();
        for (Enumeration i = game.getEntities(); i.hasMoreElements();) {
            vAllUnits.addElement(i.nextElement());
        }

        for ( Enumeration i = game.getRetreatedEntities();
              i.hasMoreElements(); ) {
            vAllUnits.addElement(i.nextElement());
        }

        for ( Enumeration i = game.getGraveyardEntities();
              i.hasMoreElements(); ) {
            vAllUnits.addElement(i.nextElement());
        }

        for (Enumeration i = game.getPlayers(); i.hasMoreElements();) {

            // Record the player.
            Player p = (Player)i.nextElement();
            sb.append("++++++++++ " )
                .append( p.getName() )
                .append( " ++++++++++");
            sb.append( CommonConstants.NL );

            // Record the player's alive, retreated, or salvageable units.
            for (int x = 0; x < vAllUnits.size(); x++) {
                Entity e = (Entity)vAllUnits.elementAt(x);
                if (e.getOwner() == p) {
                    sb.append(UnitStatusFormatter.format(e));
                }
            }

            // Record the player's devastated units.
            Enumeration devastated = game.getDevastatedEntities();
            if ( devastated.hasMoreElements() ) {
                sb.append("=============================================================");
                sb.append( CommonConstants.NL );
                sb.append("The following utterly destroyed units are not available for salvage:");
                sb.append( CommonConstants.NL );
                while ( devastated.hasMoreElements() ) {
                    Entity e = (Entity) devastated.nextElement();
                    if (e.getOwner() == p) {
                        sb.append( e.getShortName() )
                            .append( ", Pilot: " )
                            .append( e.getCrew().getName() )
                            .append( " (" )
                            .append( e.getCrew().getGunnery() )
                            .append( '/' )
                            .append( e.getCrew().getPiloting() )
                            .append( ')' );
                        sb.append( CommonConstants.NL );
                    }
                } // Handle the next unsalvageable unit for the player
                sb.append("=============================================================");
                sb.append( CommonConstants.NL );
            }

        } // Handle the next player

        return sb.toString();
    }

    /**
     * Forces victory for the specified player, or his/her team at the end of
     * the round.
     */
    public void forceVictory(Player victor) {
        game.setForceVictory(true);
        if (victor.getTeam() == Player.TEAM_NONE) {
            game.setVictoryPlayerId(victor.getId());
            game.setVictoryTeam(Player.TEAM_NONE);
        } else {
            game.setVictoryPlayerId(Player.PLAYER_NONE);
            game.setVictoryTeam(victor.getTeam());
        }

        Vector players = game.getPlayersVector();
        for (int i = 0; i < players.size(); i++) {
            Player player = (Player) players.elementAt(i);
            player.setAdmitsDefeat(false);
        }
    }

    /** Cancels the force victory */
    public void cancelVictory() {
        game.setForceVictory(false);
        game.setVictoryPlayerId(Player.PLAYER_NONE);
        game.setVictoryTeam(Player.TEAM_NONE);
    }

    /**
     * Called when a player declares that he is "done."  Checks to see if all
     * players are done, and if so, moves on to the next phase.
     */
    private void checkReady() {
        // check if all active players are done
        for (Enumeration i = game.getPlayers(); i.hasMoreElements();) {
            final Player player = (Player)i.nextElement();
            if (!player.isGhost() && !player.isObserver() && !player.isDone()) {
                return;
            }
        }

        // Tactical Genius pilot special ability (lvl 3)
        if (game.getNoOfInitiativeRerollRequests() > 0) {
            resetActivePlayersDone();
            game.rollInitAndResolveTies();

            determineTurnOrder(IGame.PHASE_INITIATIVE);
            clearReports();
            writeInitiativeReport(true);
            sendReport(true);
            return;  // don't end the phase yet, players need to see new report
        }

        // need at least one entity in the game for the lounge phase to end
        if (!game.phaseHasTurns(game.getPhase()) &&
                (game.getPhase() != IGame.PHASE_LOUNGE || game.getNoOfEntities() > 0)) {
            endCurrentPhase();
        }
    }

    /**
     * Called when the current player has done his current turn and the turn
     * counter needs to be advanced.
     * Also enforces the "protos_move_multi" and the "protos_move_multi"
     * option.  If the player has just moved infantry/protos with a "normal"
     * turn, adds up to Game.INF_AND_PROTOS_MOVE_MULTI - 1 more
     * infantry/proto-specific turns after the current turn.
     */
    private void endCurrentTurn(Entity entityUsed) {

        // Enforce "inf_move_multi" and "protos_move_multi" options.
        // The "isNormalTurn" flag is checking to see if any non-Infantry
        // or non-Protomech units can move during the current turn.
        boolean turnsChanged = false;
        GameTurn turn = game.getTurn();
        final int playerId = null == entityUsed ?
            Player.PLAYER_NONE : entityUsed.getOwnerId();
        boolean infMoved = entityUsed instanceof Infantry;
        boolean infMoveMulti =
            game.getOptions().booleanOption("inf_move_multi")
            && (game.getPhase() == IGame.PHASE_MOVEMENT
                || game.getPhase() == IGame.PHASE_INITIATIVE);
        boolean protosMoved = entityUsed instanceof Protomech;
        boolean protosMoveMulti =
            game.getOptions().booleanOption("protos_move_multi");

        // If infantry or protos move multi see if any
        // other unit types can move in the current turn.
        int multiMask = 0;
        if ( infMoveMulti ) {
            multiMask += GameTurn.CLASS_INFANTRY;
        }
        if ( protosMoveMulti ) {
            multiMask += GameTurn.CLASS_PROTOMECH;
        }

        // If a proto declared fire and protos don't move
        // multi, ignore whether infantry move or not.
        else if ( protosMoved && game.getPhase() == IGame.PHASE_FIRING ) {
            multiMask = 0;
        }

        // Is this a general move turn?
        boolean isGeneralMoveTurn =
                !(turn instanceof GameTurn.SpecificEntityTurn) && !(turn instanceof GameTurn.UnitNumberTurn) && !(turn instanceof GameTurn.UnloadStrandedTurn) && (!(turn instanceof GameTurn.EntityClassTurn) || turn instanceof GameTurn.EntityClassTurn && ((GameTurn.EntityClassTurn) turn).isValidClass(~multiMask));

        // Unless overridden by the "protos_move_multi" option, all Protomechs
        // in a unit declare fire, and they don't mix with infantry.
        if ( protosMoved && !protosMoveMulti && isGeneralMoveTurn &&
             game.getPhase() == IGame.PHASE_FIRING ) {

            // What's the unit number and ID of the entity used?
            final char movingUnit = entityUsed.getUnitNumber();
            final int movingId = entityUsed.getId();

            // How many other Protomechs are in the unit that can fire?
            int protoTurns = game.getSelectedEntityCount
                ( new EntitySelector() {
                        private final int ownerId = playerId;
                        private final int entityId = movingId;
                        private final char unitNum = movingUnit;
                        public boolean accept( Entity entity ) {
                            if ( entity instanceof Protomech &&
                                 entity.isSelectableThisTurn() &&
                                 ownerId == entity.getOwnerId() &&
                                 entityId != entity.getId() &&
                                 unitNum == entity.getUnitNumber() )
                                return true;
                            return false;
                        }
                    } );

            // Add the correct number of turns for the Protomech unit number.
            for (int i = 0; i < protoTurns; i++) {
                GameTurn newTurn = new GameTurn.UnitNumberTurn
                    ( playerId, movingUnit );
                game.insertNextTurn(newTurn);
                turnsChanged = true;
            }
        }

        // Otherwise, we may need to add turns for the "*_move_multi" options.
        else if ( ( infMoved && infMoveMulti ||