server.java

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

                protosMoved && protosMoveMulti ) &&
                  isGeneralMoveTurn ) {
            int remaining = 0;

            // Calculate the number of EntityClassTurns need to be added.
            if ( infMoveMulti ) {
                remaining += game.getInfantryLeft(playerId);
            }
            if ( protosMoveMulti ) {
                remaining += game.getProtomechsLeft(playerId);
            }
            int moreInfAndProtoTurns =
                Math.min(game.getOptions().intOption("inf_proto_move_multi") - 1, remaining);

            // Add the correct number of turns for the right unit classes.
            for (int i = 0; i < moreInfAndProtoTurns; i++) {
                GameTurn newTurn =
                    new GameTurn.EntityClassTurn( playerId, multiMask );
                game.insertNextTurn(newTurn);
                turnsChanged = true;
            }
        }
        // brief everybody on the turn update, if they changed
        if (turnsChanged) {
            send(createTurnVectorPacket());
        }

        // move along
        changeToNextTurn();
    }

    /**
     * Changes the current phase, does some bookkeeping and
     * then tells the players.
     * @param phase the <code>int</code> id of the phase to change to
     */
    private void changePhase(int phase) {
        game.setLastPhase(game.getPhase());
        game.setPhase(phase);

        // prepare for the phase
        prepareForPhase(phase);

        if (isPhasePlayable(phase)) {
            // tell the players about the new phase
            send(new Packet(Packet.COMMAND_PHASE_CHANGE, new Integer(phase)));

            // post phase change stuff
            executePhase(phase);
        } else {
            endCurrentPhase();
        }
    }

    /**
     * Prepares for, presumably, the next phase.  This typically involves
     * resetting the states of entities in the game and making sure the client
     * has the information it needs for the new phase.
     * @param phase the <code>int</code> id of the phase to prepare for
     */
    private void prepareForPhase(int phase) {
        switch (phase) {
            case IGame.PHASE_LOUNGE :
                clearReports();
                mapSettings.setBoardsAvailableVector
                    ( scanForBoards(mapSettings.getBoardWidth(),
                                    mapSettings.getBoardHeight()) );
                mapSettings.setNullBoards(DEFAULT_BOARD);
                send(createMapSettingsPacket());
                break;
            case IGame.PHASE_INITIATIVE :
                // remove the last traces of last round
                game.resetActions();
                game.resetTagInfo();
                clearReports();
                resetEntityRound();
                resetEntityPhase(phase);
                checkForObservers();
                // roll 'em
                resetActivePlayersDone();
                rollInitiative();

                if ( !game.shouldDeployThisRound() )
                    incrementAndSendGameRound();

                //setIneligible(phase);
                determineTurnOrder(phase);
                writeInitiativeReport(false);
                System.out.println("Round " + game.getRoundCount() + " memory usage: " + MegaMek.getMemoryUsed());
                break;
            case IGame.PHASE_DEPLOY_MINEFIELDS :
                checkForObservers();
                resetActivePlayersDone();
                setIneligible(phase);

                Enumeration e = game.getPlayers();
                Vector turns = new Vector();
                while (e.hasMoreElements()) {
                    Player p = (Player) e.nextElement();
                    if (p.hasMinefields()) {
                        GameTurn gt = new GameTurn(p.getId());
                        turns.addElement(gt);
                    }
                }
                game.setTurnVector(turns);
                game.resetTurnIndex();

                // send turns to all players
                send(createTurnVectorPacket());
                break;
            case IGame.PHASE_SET_ARTYAUTOHITHEXES :
                // place off board entities actually off-board
                Enumeration i = game.getEntities();
                while (i.hasMoreElements()) {
                    Entity en = (Entity) i.nextElement();
                    en.deployOffBoard();
                }
                checkForObservers();
                resetActivePlayersDone();
                setIneligible(phase);

                i = game.getPlayers();
                Vector turn = new Vector();

                // Walk through the players of the game, and add
                // a turn for all players with artillery weapons.
                while (i.hasMoreElements()) {

                    // Get the next player.
                    final Player p = (Player) i.nextElement();

                    // Does the player have any artillery-equipped units?
                    EntitySelector playerArtySelector = new EntitySelector() {
                            private Player owner = p;
                            public boolean accept (Entity entity) {
                                if ( owner.equals( entity.getOwner() ) &&
                                     entity.isEligibleForTargetingPhase() )
                                    return true;
                                return false;
                            }
                        };
                    if ( game.getSelectedEntities( playerArtySelector )
                         .hasMoreElements() ) {

                        // Yes, the player has arty-equipped units.
                        GameTurn gt = new GameTurn(p.getId());
                        turn.addElement(gt);
                    }
                }
                game.setTurnVector(turn);
                game.resetTurnIndex();

                // send turns to all players
                send(createTurnVectorPacket());
                break;
            case IGame.PHASE_MOVEMENT :
            case IGame.PHASE_DEPLOYMENT :
            case IGame.PHASE_FIRING :
            case IGame.PHASE_PHYSICAL :
            case IGame.PHASE_TARGETING:
            case IGame.PHASE_OFFBOARD:
                resetEntityPhase(phase);
                checkForObservers();
                setIneligible(phase);
                determineTurnOrder(phase);
                resetActivePlayersDone();
                //send(createEntitiesPacket());
                entityAllUpdate();
                clearReports();
                doTryUnstuck();
                break;
            case IGame.PHASE_END :
                resetEntityPhase(phase);
                clearReports();
                resolveHeat();
                //write End Phase header
                addReport(new Report(5005, Report.PUBLIC));
                checkForSuffocation();
                if (game.getOptions().booleanOption("vacuum")) {
                    checkForVacuumDeath();
                }
                for(Enumeration<DynamicTerrainProcessor> tps=terrainProcessors.elements();tps.hasMoreElements();) {
                    DynamicTerrainProcessor tp = tps.nextElement();
                    tp.DoEndPhaseChanges(vPhaseReport);
                }
                addReport( game.ageFlares());
                send(createFlarePacket());
                resolveExtremeTempInfantryDeath();
                resolveAmmoDumps();
                resolveCrewDamage();
                resolveCrewWakeUp();
                resolveMechWarriorPickUp();
                resolveVeeINarcPodRemoval();
                resolveFortify();
                checkForObservers();
                entityAllUpdate();
                break;
            case IGame.PHASE_INITIATIVE_REPORT :
                autoSave();
            case IGame.PHASE_MOVEMENT_REPORT :
            case IGame.PHASE_OFFBOARD_REPORT :
            case IGame.PHASE_FIRING_REPORT :
            case IGame.PHASE_PHYSICAL_REPORT :
            case IGame.PHASE_END_REPORT :
                resetActivePlayersDone();
                sendReport();
                if (game.getOptions().booleanOption("paranoid_autosave")) autoSave();
                break;
            case IGame.PHASE_VICTORY :
                resetPlayersDone();
                clearReports();
                prepareVictoryReport();
                game.addReports(vPhaseReport);
                send(createFullEntitiesPacket());
                send(createReportPacket(null));
                send(createEndOfGamePacket());
                break;
        }
    }

    /**
     * Should we play this phase or skip it?
     */
    private boolean isPhasePlayable(int phase) {
        switch (phase) {
            case IGame.PHASE_INITIATIVE :
            case IGame.PHASE_END :
                return false;
            case IGame.PHASE_SET_ARTYAUTOHITHEXES :
            case IGame.PHASE_DEPLOY_MINEFIELDS :
            case IGame.PHASE_DEPLOYMENT :
            case IGame.PHASE_MOVEMENT :
            case IGame.PHASE_FIRING :
            case IGame.PHASE_PHYSICAL :
            case IGame.PHASE_TARGETING:
                return game.hasMoreTurns();
            case IGame.PHASE_OFFBOARD :
                return isOffboardPlayable();
            default :
                return true;
        }
    }
    
    /** Skip offboard phase, if there is no 
     *  homing / semiguided ammo in play
     */
    private boolean isOffboardPlayable() {
        if(!game.hasMoreTurns())
            return false;
        for(Enumeration e = game.getEntities(); e.hasMoreElements();) {
            Entity entity = (Entity)e.nextElement();
            for(Mounted m : entity.getAmmo()) {
                AmmoType atype = (AmmoType)m.getType();
                if(atype.getAmmoType() == AmmoType.T_LRM && atype.getMunitionType() == AmmoType.M_SEMIGUIDED) {
                    return true;
                }
                if((atype.getAmmoType() == AmmoType.T_ARROW_IV
                        || atype.getAmmoType() == AmmoType.T_LONG_TOM
                        || atype.getAmmoType() == AmmoType.T_SNIPER)
                        && atype.getMunitionType() == AmmoType.M_HOMING) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Do anything we seed to start the new phase, such as give a turn to
     * the first player to play.
     */
    private void executePhase(int phase) {
        switch (phase) {
            case IGame.PHASE_EXCHANGE :
                resetPlayersDone();
                calculatePlayerBVs();
                // Build teams vector
                game.setupTeams();
                applyBoardSettings();
                game.setupRoundDeployment();
                game.determineWind();
                // If we add transporters for any Magnetic Clamp
                // equiped squads, then update the clients' entities.
                if ( game.checkForMagneticClamp() ) {
                    entityAllUpdate();
                }
                // transmit the board to everybody
                send(createBoardPacket());
                break;
            case IGame.PHASE_MOVEMENT :
                //write Movement Phase header to report
                addReport(new Report(2000, Report.PUBLIC));
            case IGame.PHASE_SET_ARTYAUTOHITHEXES :
            case IGame.PHASE_DEPLOY_MINEFIELDS :
            case IGame.PHASE_DEPLOYMENT :
            case IGame.PHASE_FIRING :
            case IGame.PHASE_PHYSICAL :
            case IGame.PHASE_TARGETING :
            case IGame.PHASE_OFFBOARD :
                changeToNextTurn();
                if (game.getOptions().booleanOption("paranoid_autosave")) autoSave();
                break;
        }
    }
    
    /**
     * Calculates all players initial BV, should only
     * be called at start of game
     */
    public void calculatePlayerBVs() {
        for ( Enumeration players = game.getPlayers(); players.hasMoreElements(); )
            ((Player) players.nextElement()).setInitialBV();
    }

    /**
     * Ends this phase and moves on to the next.
     */
    private void endCurrentPhase() {
        switch (game.getPhase()) {
            case IGame.PHASE_LOUNGE :
                changePhase(IGame.PHASE_EXCHANGE);
                break;
            case IGame.PHASE_EXCHANGE :
                changePhase(IGame.PHASE_SET_ARTYAUTOHITHEXES);
                break;
            case IGame.PHASE_STARTING_SCENARIO :
                changePhase(IGame.PHASE_SET_ARTYAUTOHITHEXES);
                break;
            case IGame.PHASE_SET_ARTYAUTOHITHEXES :
                Enumeration e = game.getPlayers();
                boolean mines = false;
                while (e.hasMoreElements()) {
                    Player p = (Player) e.nextElement();
                    if (p.hasMinefields()) {
                         mines = true;
                    }
                }
                if (mines) {
                    changePhase(IGame.PHASE_DEPLOY_MINEFIELDS);
                } else {
                    changePhase(IGame.PHASE_INITIATIVE);
                }
                break;
            case IGame.PHASE_DEPLOY_MINEFIELDS :
                changePhase(IGame.PHASE_INITIATIVE);
                break;
            case IGame.PHASE_DEPLOYMENT :
                game.clearDeploymentThisRound();
                game.checkForCompleteDeployment();
                Enumeration pls = game.getPlayers();
                while (pls.hasMoreElements()) {
                    Player p