igame.java

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

     */
    public abstract boolean checkForMagneticClamp();
    
    /** Adds the specified action to the actions list for this phase. */
    public abstract void addAction(EntityAction ea);
    
    public abstract void addArtilleryAttack(ArtilleryAttackAction aaa);
    
    public abstract void removeArtilleryAttack(ArtilleryAttackAction aaa);
    
    public abstract Vector getArtilleryVector();
    
    public abstract Enumeration getArtilleryAttacks();
    
    public abstract int getArtillerySize();
    
    public abstract void setArtilleryVector(Vector v);
    
    /** 
     * Returns an Enumeration of actions scheduled for this phase. 
     */
    public abstract Enumeration getActions();
    
    /**
     * Resets the actions list.
     */
    public abstract void resetActions();
    
    /**
     * Removes all actions by the specified entity
     */
    public abstract void removeActionsFor(int entityId);

    /**
     * Remove a specified action
     * @param o The action to remove.
     */
    public abstract void removeAction(Object o);
    
    public abstract int actionsSize();
    
    /** 
     * Returns the actions vector.  Do not use to modify the actions;
     * I will be angry. >:[  Used for sending all actions to the client.
     */
    public abstract Vector getActionsVector();
    
    public abstract void addInitiativeRerollRequest(Team t);

    public abstract void rollInitAndResolveTies();
    
    public abstract int getNoOfInitiativeRerollRequests();
    
    /**
     * Adds a pending displacement attack to the list for this phase.
     */
    public abstract void addCharge(AttackAction ea);
    
    /**
     * Returns an Enumeration of displacement attacks scheduled for the end
     * of the physical phase.
     */
    public abstract Enumeration getCharges();
    
    /**
     * Resets the pending charges list.
     */
    public abstract void resetCharges();
    
    /**
     * Returns the charges vector.  Do not modify. >:[ Used for sending all
     * charges to the client.
     */
    public abstract Vector getChargesVector();
    
    /**
     * Adds a pending lay minefield action to the list for this phase.
     */
    public void addLayMinefieldAction(LayMinefieldAction lma);

    /**
     * Returns an Enumeration of LayMinefieldActions
     */
    public Enumeration getLayMinefieldActions();

    /** Resets the pending LayMinefieldActions list. */
    public void resetLayMinefieldActions();

    /** Returns the LayMinefieldActions vector. 
     *  Do not modify. >:[ Used for sending these actions to the client.
     */
    public Vector getLayMinefieldActionsVector();
    
    /**
     * Adds a pending PSR to the list for this phase.
     */
    public abstract void addPSR(PilotingRollData psr);
    
    /**
     * Returns an Enumeration of pending PSRs.
     */
    public abstract Enumeration getPSRs();
    
    /**
     * Adds a pending extreme Gravity PSR to the list for this phase.
     */
    public abstract void addExtremeGravityPSR(PilotingRollData psr);
    
    /**
     * Returns an Enumeration of pending extreme GravityPSRs.
     */
    public abstract Enumeration getExtremeGravityPSRs();
    
    /**
     * Resets the PSR list for a given entity.
     */
    public abstract void resetPSRs(Entity entity);
    
    /**
     * Resets the extreme Gravity PSR list.
     */
    public abstract void resetExtremeGravityPSRs();
    
    /**
     * Resets the extreme Gravity PSR list for a given entity.
     */
    public abstract void resetExtremeGravityPSRs(Entity entity);
    
    /**
     * Resets the PSR list.
     */
    public abstract void resetPSRs();
    
    /** 
     * Getter for property roundCount.
     * @return Value of property roundCount.
     */
    public abstract int getRoundCount();
    
    public abstract void setRoundCount(int roundCount);
    
    /**
     * Increments the round counter
     */
    public abstract void incrementRoundCount();
    
    /**
     * Getter for property forceVictory.
     * @return Value of property forceVictory.
     */
    public abstract boolean isForceVictory();
    
    /**
     * Setter for property forceVictory.
     * @param forceVictory New value of property forceVictory.
     */
    public abstract void setForceVictory(boolean forceVictory);
    
    /**
     * Adds the given reports vector to the GameReport collection.
     * @param v Vector of reports
     */
    public abstract void addReports(Vector v);

    /**
     * Returns a vector of reports for the given round.
     * @param r Round number
     */
    public abstract Vector getReports(int r);

    /**
     * Returns a vector of all the reports.
     */
    public abstract Vector getAllReports();

    /**
     * Used to populate previous game reports, e.g. after a client connects
     *  to an existing game.
     */
    public void setAllReports(Vector v);

    /**
     * Clears out all the current reports, paving the way for a new game.
     */
    public void clearAllReports();

    public abstract void end(int winner, int winnerTeam);

    /**
     * Getter for property victoryPlayerId.
     * @return Value of property victoryPlayerId.
     */
    public abstract int getVictoryPlayerId();
    
    /**
     * Setter for property victoryPlayerId.
     * @param victoryPlayerId New value of property victoryPlayerId.
     */
    public abstract void setVictoryPlayerId(int victoryPlayerId);
    
    /**
     * Getter for property victoryTeam.
     * @return Value of property victoryTeam.
     */
    public abstract int getVictoryTeam();
    
    /**
     * Setter for property victoryTeam.
     * @param victoryTeam New value of property victoryTeam.
     */
    public abstract void setVictoryTeam(int victoryTeam);
    
    /**
     * Returns true if the specified player is either the victor, or is on the
     * winning team.  Best to call during PHASE_VICTORY.
     */
    public abstract boolean isPlayerVictor(Player player);
    
    /**
     * Shortcut to isPlayerVictor(Player player)
     */
    public abstract boolean isPlayerVictor(int playerId);
    
    /**
     * Get all <code>Entity</code>s that pass the given selection criteria.
     *
     * @param   selector the <code>EntitySelector</code> that implements
     *          test that an entity must pass to be included.
     *          This value may be <code>null</code> (in which case all
     *          entities in the game will be returned).
     * @return  an <code>Enumeration</code> of all entities that the
     *          selector accepts.  This value will not be <code>null</code>
     *          but it may be empty.
     */
    public abstract Enumeration getSelectedEntities(EntitySelector selector);
    
    /**
     * Count all <code>Entity</code>s that pass the given selection criteria.
     *
     * @param   selector the <code>EntitySelector</code> that implements
     *          test that an entity must pass to be included.
     *          This value may be <code>null</code> (in which case the
     *          count of all entities in the game will be returned).
     * @return  the <code>int</code> count of all entities that the
     *          selector accepts.  This value will not be <code>null</code>
     *          but it may be empty.
     */
    public abstract int getSelectedEntityCount(EntitySelector selector);
    
    /**
     * Get all out-of-game <code>Entity</code>s that pass the given selection
     * criteria.
     *
     * @param   selector the <code>EntitySelector</code> that implements
     *          test that an entity must pass to be included.
     *          This value may be <code>null</code> (in which case all
     *          entities in the game will be returned).
     * @return  an <code>Enumeration</code> of all entities that the
     *          selector accepts.  This value will not be <code>null</code>
     *          but it may be empty.
     */
    public abstract Enumeration getSelectedOutOfGameEntities(EntitySelector selector);
    
    /**
     * Count all out-of-game<code>Entity</code>s that pass the given selection
     * criteria.
     *
     * @param   selector the <code>EntitySelector</code> that implements
     *          test that an entity must pass to be included.
     *          This value may be <code>null</code> (in which case the
     *          count of all out-of-game entities will be returned).
     * @return  the <code>int</code> count of all entities that the
     *          selector accepts.  This value will not be <code>null</code>
     *          but it may be empty.
     */
    public abstract int getSelectedOutOfGameEntityCount(EntitySelector selector);
    
    /**
     * Returns true if the player has any valid units this turn that
     * are not infantry, not protomechs, or not either of those.  This
     * method is utitilized by the "A players Infantry moves after
     * that players other units", and "A players Protomechs move after
     * that players other units" options.
     */
    public abstract boolean checkForValidNonInfantryAndOrProtomechs(int playerId);
    
    /**
     * Get Entities that have have a iNarc Nemesis pod attached and are situated
     * between two Coords
     *  
     * @param attacker The attacking <code>Entity</code>.
     * @param target The <code>Coords</code> of the original target.
     * @return a <code>Enumeration</code> of entities that have nemesis pods
     *         attached and are located between attacker and target and are
     *         friendly with the attacker.
     */
    public abstract Enumeration getNemesisTargets(Entity attacker, Coords target);

    /**
     * Returns the previous entity from the master list of entities.  Will
     * wrap around to the end of the list if necessary.
     *
     * @param current The <code>Entity</code> whose list position you wish
     * to start from.
     * @return  The previous <code>Entity</code> in the list.
     */
    public abstract Entity getPreviousEntityFromList (Entity current);

    /**
     * Returns the next entity from the master list of entities.  Will
     * wrap around to the begining of the list if necessary.
     *
     * @param current The <code>Entity</code> whose list position you wish
     * to start from.
     * @return  The next <code>Entity</code> in the list.
     */
    public abstract Entity getNextEntityFromList (Entity current);

    /**
     * Returns this turn's tag information
     */
    public abstract Vector getTagInfo();

    /**
     * add the results of one tag attack
     */
    public abstract void addTagInfo(TagInfo info);

    /**
     * modify tag information
     */
    public abstract void updateTagInfo(TagInfo info, int index);

    /**
     * clears the "shots" attribute of all TagInfos
     * where attacker is on same team as ae
     * and target is on same mapsheet as tc
     */
    public abstract void clearTagInfoShots(Entity ae, Coords tc);

    /**
     * Reset tag information
     */
    public abstract void resetTagInfo();

    /** 
     * Get a list of flares
     */
    public abstract Vector getFlares();

    /**
     * Set the list of flares
     */
    public abstract void setFlares(Vector flares);

    /**
     * Add a new flare
     */
    public abstract void addFlare(Flare flare);

    /**
     * returns true if the hex is illuminated by a flare
     */
    public abstract boolean isPositionIlluminated(Coords c);

    /**
     * Age the flare list and remove any which have burnt out
     * Artillery flares drift with wind.
     * (called at end of turn)
     */
    public abstract Vector ageFlares();

    public abstract boolean gameTimerIsExpired();
}