mapsettings.java

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

            (this.range != other.getRange()) ||
            (this.minWaterSpots != other.getMinWaterSpots()) ||
            (this.maxWaterSpots != other.getMaxWaterSpots()) ||
            (this.minWaterSize != other.getMinWaterSize()) ||
            (this.maxWaterSize != other.getMaxWaterSize()) ||
            (this.probDeep != other.getProbDeep()) ||
            (this.minForestSpots != other.getMinForestSpots()) ||
            (this.maxForestSpots != other.getMaxForestSpots()) ||
            (this.minForestSize != other.getMinForestSize()) ||
            (this.maxForestSize != other.getMaxForestSize()) ||
            (this.probHeavy != other.getProbHeavy()) ||
            (this.minRoughSpots != other.getMinRoughSpots()) ||
            (this.maxRoughSpots != other.getMaxRoughSpots()) ||
            (this.minRoughSize != other.getMinRoughSize()) ||
            (this.maxRoughSize != other.getMaxRoughSize()) ||
            (this.minSwampSpots != other.getMinSwampSpots()) ||
            (this.maxSwampSpots != other.getMaxSwampSpots()) ||
            (this.minSwampSize != other.getMinSwampSize()) ||
            (this.maxSwampSize != other.getMaxSwampSize()) ||
            (this.minPavementSpots != other.getMinPavementSpots()) ||
            (this.maxPavementSpots != other.getMaxPavementSpots()) ||
            (this.minPavementSize != other.getMinPavementSize()) ||
            (this.maxPavementSize != other.getMaxPavementSize()) ||
            (this.minRubbleSpots != other.getMinRubbleSpots()) ||
            (this.maxRubbleSpots != other.getMaxRubbleSpots()) ||
            (this.minRubbleSize != other.getMinRubbleSize()) ||
            (this.maxRubbleSize != other.getMaxRubbleSize()) ||
            (this.minFortifiedSpots != other.getMinFortifiedSpots()) ||
            (this.maxFortifiedSpots != other.getMaxFortifiedSpots()) ||
            (this.minFortifiedSize != other.getMinFortifiedSize()) ||
            (this.maxFortifiedSize != other.getMaxFortifiedSize()) ||
            (this.minIceSpots != other.getMinIceSpots()) ||
            (this.maxIceSpots != other.getMaxIceSpots()) ||
            (this.minIceSize != other.getMinIceSize()) ||
            (this.maxIceSize != other.getMaxIceSize()) ||
            (this.probRoad != other.getProbRoad()) ||
            (this.probInvert != other.getProbInvert()) ||
            (this.probRiver != other.getProbRiver()) ||
            (this.probCrater != other.getProbCrater()) ||
            (this.minRadius != other.getMinRadius()) ||
            (this.maxRadius != other.getMaxRadius()) ||
            (this.minCraters != other.getMinCraters()) ||
            (this.maxCraters != other.getMaxCraters()) ||
            (!this.theme.equals(other.getTheme())) ||
            (this.fxMod != other.getFxMod()) ||
            (this.cityBlocks != other.getCityBlocks()) ||
            (this.cityType != other.getCityType()) ||
            (this.cityMinCF != other.getCityMinCF()) ||
            (this.cityMaxCF != other.getCityMaxCF()) ||
            (this.cityMinFloors != other.getCityMinFloors()) ||
            (this.cityMaxFloors != other.getCityMaxFloors()) ||
            (this.cityDensity != other.getCityDensity()) ||
            (this.probFlood != other.getProbFlood()) ||
            (this.probForestFire != other.getProbForestFire()) ||
            (this.probFreeze != other.getProbFreeze()) ||
            (this.probDrought != other.getProbDrought()) ||
            (this.algorithmToUse != other.getAlgorithmToUse()) ||
            (this.mountainHeightMin != other.getMountainHeightMin()) ||
            (this.mountainHeightMax != other.getMountainHeightMax()) ||
            (this.mountainPeaks != other.getMountainPeaks()) ||
            (this.mountainStyle != other.getMountainStyle()) ||
            (this.mountainWidthMin != other.getMountainWidthMin()) ||
            (this.mountainWidthMax != other.getMountainWidthMax()) ||
            (this.boardBuildings != other.getBoardBuildings())) {
            return false;
        }
		return true;
    } /* equalMapGenParameters */

    /** clone! */
    public Object clone() {
        return new MapSettings(this);
    }

    public int getInvertNegativeTerrain() { return invertNegativeTerrain; }
    public int getHilliness() { return hilliness; }
    public int getCliffs() { return cliffs; }
    public int getRange() { return range; }
    public int getProbInvert() { return probInvert; }
    
    public int getMinWaterSpots() { return minWaterSpots; }
    public int getMaxWaterSpots() { return maxWaterSpots; }
    public int getMinWaterSize() { return minWaterSize; }
    public int getMaxWaterSize() { return maxWaterSize; }
    public int getProbDeep() { return probDeep; }
    
    public int getMinForestSpots() { return minForestSpots; }
    public int getMaxForestSpots() { return maxForestSpots; }
    public int getMinForestSize() { return minForestSize; }
    public int getMaxForestSize() { return maxForestSize; }
    public int getProbHeavy() { return probHeavy; }
    
    public int getMinRoughSpots() { return minRoughSpots; }
    public int getMaxRoughSpots() { return maxRoughSpots; }
    public int getMinRoughSize() { return minRoughSize; }
    public int getMaxRoughSize() { return maxRoughSize; }
    
    public int getMinSwampSpots() { return minSwampSpots; }
    public int getMaxSwampSpots() { return maxSwampSpots; }
    public int getMinSwampSize() { return minSwampSize; }
    public int getMaxSwampSize() { return maxSwampSize; }
    
    public int getMinPavementSpots() { return minPavementSpots; }
    public int getMaxPavementSpots() { return maxPavementSpots; }
    public int getMinPavementSize() { return minPavementSize; }
    public int getMaxPavementSize() { return maxPavementSize; }
    
    public int getMinRubbleSpots() { return minRubbleSpots; }
    public int getMaxRubbleSpots() { return maxRubbleSpots; }
    public int getMinRubbleSize() { return minRubbleSize; }
    public int getMaxRubbleSize() { return maxRubbleSize; }
    
    public int getMinFortifiedSpots() { return minFortifiedSpots; }
    public int getMaxFortifiedSpots() { return maxFortifiedSpots; }
    public int getMinFortifiedSize() { return minFortifiedSize; }
    public int getMaxFortifiedSize() { return maxFortifiedSize; }
    
    public int getMinIceSpots() { return minIceSpots; }
    public int getMaxIceSpots() { return maxIceSpots; }
    public int getMinIceSize() { return minIceSize; }
    public int getMaxIceSize() { return maxIceSize; }
    
    public int getProbRoad() { return probRoad; }
    
    public int getProbRiver() { return probRiver; }
    
    public int getProbCrater() { return probCrater; }
    public int getMinRadius() { return minRadius; }
    public int getMaxRadius() { return maxRadius; }
    public int getMinCraters() { return minCraters; }
    public int getMaxCraters() { return maxCraters; }
    public int getAlgorithmToUse() { return algorithmToUse; }
 
    public int getProbFlood() {return probFlood;}
    public int getProbForestFire() {return probForestFire;}
    public int getProbFreeze() {return probFreeze;}
    public int getProbDrought() {return probDrought;}
    public int getFxMod() {return fxMod;}
    public int getCityBlocks() {return cityBlocks;}
    public String getCityType() {return cityType;}
    public int getCityMinCF() {return cityMinCF;}
    public int getCityMaxCF() {return cityMaxCF;}
    public int getCityMinFloors() {return cityMinFloors;}
    public int getCityMaxFloors() {return cityMaxFloors;}
    public int getCityDensity() {return cityDensity;}
    public int getTownSize() {return townSize;}

    public int getMountainHeightMin() {return mountainHeightMin;}
    public int getMountainHeightMax() {return mountainHeightMax;}
    public int getMountainPeaks() {return mountainPeaks;}
    public int getMountainStyle() {return mountainStyle;}
    public int getMountainWidthMin() {return mountainWidthMin;}
    public int getMountainWidthMax() {return mountainWidthMax;}

    /** set the Parameters for the Map Generator 
    */
    public void setElevationParams(int hill, int newRange, int prob) {
        hilliness = hill;
        range = newRange;
        probInvert = prob;
    }
    
    /** set the Parameters for the Map Generator 
    */
    public void setWaterParams(int minSpots, int maxSpots,
                                int minSize, int maxSize, int prob) {
        minWaterSpots = minSpots;
        maxWaterSpots = maxSpots; 
        minWaterSize = minSize;
        maxWaterSize = maxSize;
        probDeep = prob;
    }
    
    /** set the Parameters for the Map Generator 
    */    
    public void setForestParams(int minSpots, int maxSpots,
                                int minSize, int maxSize, int prob) {
        minForestSpots = minSpots;
        maxForestSpots = maxSpots;
        minForestSize = minSize;
        maxForestSize = maxSize;
        probHeavy = prob;
    }
    
    /** set the Parameters for the Map Generator 
    */
    public void setRoughParams(int minSpots, int maxSpots,
                                int minSize, int maxSize) {
        minRoughSpots = minSpots;
        maxRoughSpots = maxSpots;
        minRoughSize = minSize;
        maxRoughSize = maxSize;
    }
    
    /** set the Parameters for the Map Generator 
     */
     public void setSwampParams(int minSpots, int maxSpots,
                                 int minSize, int maxSize) {
         minSwampSpots = minSpots;
         maxSwampSpots = maxSpots;
         minSwampSize = minSize;
         maxSwampSize = maxSize;
     }
    
    /** set the Parameters for the Map Generator 
     */
     public void setPavementParams(int minSpots, int maxSpots,
                                 int minSize, int maxSize) {
         minPavementSpots = minSpots;
         maxPavementSpots = maxSpots;
         minPavementSize = minSize;
         maxPavementSize = maxSize;
     }
    
     /** set the Parameters for the Map Generator 
      */
      public void setRubbleParams(int minSpots, int maxSpots,
                                  int minSize, int maxSize) {
          minRubbleSpots = minSpots;
          maxRubbleSpots = maxSpots;
          minRubbleSize = minSize;
          maxRubbleSize = maxSize;
      }
     
      /** set the Parameters for the Map Generator 
       */
       public void setFortifiedParams(int minSpots, int maxSpots,
                                   int minSize, int maxSize) {
           minFortifiedSpots = minSpots;
           maxFortifiedSpots = maxSpots;
           minFortifiedSize = minSize;
           maxFortifiedSize = maxSize;
       }
      
     /** set the Parameters for the Map Generator 
      */
      public void setIceParams(int minSpots, int maxSpots,
                                  int minSize, int maxSize) {
          minIceSpots = minSpots;
          maxIceSpots = maxSpots;
          minIceSize = minSize;
          maxIceSize = maxSize;
      }
     
    /** set the Parameters for the Map Generator 
    */
    public void setRiverParam(int prob) { probRiver = prob; }
    
    /** set the Parameters for the Map Generator 
    */
    public void setRoadParam(int prob) { probRoad = prob; }
    
    /** set the Parameters for the Map Generator 
     */
    public void setCliffParam(int prob) { cliffs = prob; }   
    
    /** set the Parameters for the Map Generator 
    */
    public void setCraterParam(int prob, int minCrat,
                                int maxCrat, int minRad, int maxRad) {

        probCrater = prob; 
        maxCraters = maxCrat;
        minCraters=minCrat;
        minRadius = minRad;
        maxRadius = maxRad;
    }
    
    /** set the Parameters for the Map Generator 
     */
    public void setInvertNegativeTerrain(int invert) { invertNegativeTerrain = invert; }
    
    
    /** 
     * set Map generator parameters
     */
    public void setSpecialFX(int modifier, int fire, int freeze, int flood, int drought) {
        fxMod = modifier;
        probForestFire = fire;
        probFreeze = freeze;
        probFlood = flood;
        probDrought = drought;
    }
    public void setAlgorithmToUse(int alg) {
        algorithmToUse = alg;
    }
    
    public void setCityParams( int cityBlocks,
            String cityType,
            int cityMinCF,
            int cityMaxCF,
            int cityMinFloors,
            int cityMaxFloors,
            int cityDensity,
            int townSize) {
        this.cityBlocks = cityBlocks;
        this.cityType = cityType;
        this.cityMinCF = cityMinCF;
        this.cityMaxCF = cityMaxCF;
        this.cityMinFloors = cityMinFloors;
        this.cityMaxFloors = cityMaxFloors;
        this.cityDensity = cityDensity;
        this.townSize = townSize;