Package megamek.common

Examples of megamek.common.IHex


                int distance = c.distance(centre);
                int elev = (100 * height * (width - distance)) / width;
                elev = (elev / 100)
                        + (Compute.randomInt(100) < (elev % 100) ? 1 : 0);

                IHex hex = board.getHex(c);

                if (elev >= height - 2) {
                    switch (capStyle) {
                        case MapSettings.MOUNTAIN_SNOWCAPPED:
                            hex.setTheme("snow");
                            break;
                        case MapSettings.MOUNTAIN_VOLCANO_ACTIVE:
                        case MapSettings.MOUNTAIN_VOLCANO_DORMANT:
                            hex.setTheme("lunar");
                            break;
                        case MapSettings.MOUNTAIN_LAKE:
                            int lake = (width / 4);
                            int depth = ((lake - distance) + 1);
                            if (depth < 1) { // eliminates depth 0 water
                                depth = 1;
                            }
                            hex.addTerrain(tf.createTerrain(Terrains.WATER,
                                    (depth)));
                            elev -= (Math.abs(lake - elev) - 1);
                            break;
                    }
                }
                if (elev == height) {
                    // for volcanoes, invert the peak
                    switch (capStyle) {
                        case MapSettings.MOUNTAIN_VOLCANO_ACTIVE:
                            hex.removeAllTerrains();
                            hex.addTerrain(tf.createTerrain(Terrains.MAGMA, 2));
                            elev -= 2;
                            break;
                        case MapSettings.MOUNTAIN_VOLCANO_DORMANT:
                            hex.removeAllTerrains();
                            hex.addTerrain(tf.createTerrain(Terrains.MAGMA, 1));
                            elev -= 2;
                            break;
                        case MapSettings.MOUNTAIN_VOLCANO_EXTINCT:
                            hex.setTheme("lunar");
                            elev -= 2;
                            break;
                    }
                }

                if (hex.getElevation() < elev)
                    hex.setElevation(elev);
            }
        }

    }
View Full Code Here


        }

        // Walk through the current data array and build a new one.
        int newX;
        int newY;
        IHex tempHex;
        ITerrain terr;
        for (int oldX = 0; oldX < stopX; oldX++) {
            // Calculate the new X position of the flipped hex.
            if (horiz) {
                newX = width - oldX - 1;
            } else {
                newX = oldX;
            }
            for (int oldY = 0; oldY < stopY; oldY++) {
                // Calculate the new Y position of the flipped hex.
                if (vert) {
                    newY = height - oldY - 1;
                } else {
                    newY = oldY;
                }

                // Swap the old hex for the new hex.
                tempHex = board.getHex(oldX, oldY);
                board.setHex(oldX, oldY, board.getHex(newX, newY));
                board.setHex(newX, newY, tempHex);

                IHex newHex = board.getHex(newX, newY);
                IHex oldHex = board.getHex(oldX, oldY);

                // Update the road exits in the swapped hexes.
                terr = newHex.getTerrain(Terrains.ROAD);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }
                terr = oldHex.getTerrain(Terrains.ROAD);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }

                // Update the building exits in the swapped hexes.
                terr = newHex.getTerrain(Terrains.BUILDING);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }
                terr = oldHex.getTerrain(Terrains.BUILDING);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }

                // Update the fuel tank exits in the swapped hexes.
                terr = newHex.getTerrain(Terrains.FUEL_TANK);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }
                terr = oldHex.getTerrain(Terrains.FUEL_TANK);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }

                // Update the bridge exits in the swapped hexes.
                terr = newHex.getTerrain(Terrains.BRIDGE);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }
                terr = oldHex.getTerrain(Terrains.BRIDGE);
                if (null != terr) {
                    terr.flipExits(horiz, vert);
                }
            }
        }
View Full Code Here

        ITerrainFactory tf = Terrains.getTerrainFactory();
        ArrayList<IHex> hexes = new ArrayList<IHex>();
        int level = 0;
        for (Iterator<Coords> i = building.getCoords(); i.hasNext();) {
            Coords c = i.next();
            IHex hex = board.getHex(c);
            // work out exits...
            int exits = 0;
            for (int dir = 0; dir < 6; dir++) {
                if (building.containsCoords(c.translated(dir))) {
                    exits |= (1 << dir);
                }
            }

            // remove everything
            hex.removeAllTerrains();
            hex.addTerrain(tf.createTerrain(Terrains.PAVEMENT, 1));
            hex.addTerrain(tf.createTerrain(Terrains.BUILDING, type, true,
                    exits));
            hex.addTerrain(tf.createTerrain(Terrains.BLDG_CF, cf));
            hex.addTerrain(tf.createTerrain(Terrains.BLDG_ELEV, height));
            // hex.addTerrain(tf.createTerrain(Terrains.BLDG_BASEMENT,
            // building.getBasement()));
            hexes.add(hex);
            level += hex.getElevation();
        }
        // set everything to the same level
        for (int j = 0; j < hexes.size(); j++) {
            hexes.get(j).setElevation(level / hexes.size());
        }
View Full Code Here

                .randomInt(board.getHeight()));
        int count = minHexes;
        if ((maxHexes - minHexes) > 0) {
            count += Compute.randomInt(maxHexes - minHexes);
        }
        IHex field;

        HashSet<IHex> alreadyUsed = new HashSet<IHex>();
        HashSet<IHex> unUsed = new HashSet<IHex>();
        field = board.getHex(p.x, p.y);
        if (!field.containsTerrain(terrainType)) {
            unUsed.add(field);
        } else {
            findAllUnused(board, terrainType, alreadyUsed, unUsed, field,
                    reverseHex);
        }
        ITerrainFactory f = Terrains.getTerrainFactory();
        for (int i = 0; i < count; i++) {
            if (unUsed.isEmpty()) {
                return;
            }
            int which = Compute.randomInt(unUsed.size());
            Iterator<IHex> iter = unUsed.iterator();
            for (int n = 0; n < (which - 1); n++)
                iter.next();
            field = iter.next();
            if (exclusive) {
                field.removeAllTerrains();
            }
            int tempInt = (Compute.randomInt(100) < probMore) ? 2 : 1;
            ITerrain tempTerrain = f.createTerrain(terrainType, tempInt);
            field.addTerrain(tempTerrain);
            unUsed.remove(field);
            findAllUnused(board, terrainType, alreadyUsed, unUsed, field,
                    reverseHex);
        }

        if (terrainType == Terrains.WATER) {
            /*
             * if next to an Water Hex is an lower lvl lower the hex. First we
             * search for lowest Hex next to the lake
             */
            int min = Integer.MAX_VALUE;
            Iterator<IHex> iter = unUsed.iterator();
            while (iter.hasNext()) {
                field = iter.next();
                if (field.getElevation() < min) {
                    min = field.getElevation();
                }
            }
            iter = alreadyUsed.iterator();
            while (iter.hasNext()) {
                field = iter.next();
                field.setElevation(min);
            }

        }
    }
View Full Code Here

     * @param searchFrom The Hex where to start
     */
    private static void findAllUnused(IBoard board, int terrainType,
            HashSet<IHex> alreadyUsed, HashSet<IHex> unUsed, IHex searchFrom,
            HashMap<IHex, Point> reverseHex) {
        IHex field;
        HashSet<IHex> notYetUsed = new HashSet<IHex>();

        notYetUsed.add(searchFrom);
        do {
            Iterator<IHex> iter = notYetUsed.iterator();
            field = iter.next();
            if (field == null) {
                continue;
            }
            for (int dir = 0; dir < 6; dir++) {
                Point loc = reverseHex.get(field);
                IHex newHex = board.getHexInDir(loc.x, loc.y, dir);
                if ((newHex != null) && (!alreadyUsed.contains(newHex))
                        && (!notYetUsed.contains(newHex))
                        && (!unUsed.contains(newHex))) {
                    ((newHex.containsTerrain(terrainType)) ? notYetUsed
                            : unUsed).add(newHex);
                }
            }
            notYetUsed.remove(field);
            alreadyUsed.add(field);
View Full Code Here

            /* now recalculate every hex */
            for (int h = 0; h < height; h++) {
                for (int w = 0; w < width; w++) {
                    int distance = (int) distance(center, new Point(w, h));
                    if (distance < radius) {
                        IHex field = board.getHex(w, h);
                        field.setElevation(// field.getElevation() +
                                cratHeight[distance]);
                    }
                }
            }
        }
View Full Code Here

     * river goes from one border to another. Nor Params, no results.
     */
    public static void addRiver(IBoard board, HashMap<IHex, Point> reverseHex) {
        int minElevation = Integer.MAX_VALUE;
        HashSet<IHex> riverHexes = new HashSet<IHex>();
        IHex field;
        Point p = null;
        int direction = 0;
        int nextLeft = 0;
        int nextRight = 0;

        int width = board.getWidth();
        int height = board.getHeight();

        /* if map is smaller than 5x5 no real space for an river */
        if ((width < 5) || (height < 5)) {
            return;
        }
        /* First select start and the direction */
        switch (Compute.randomInt(4)) {
            case 0:
                p = new Point(0, Compute.randomInt(5) - 2 + height / 2);
                direction = Compute.randomInt(2) + 1;
                nextLeft = direction - 1;
                nextRight = direction + 1;
                break;
            case 1:
                p = new Point(width - 1, Compute.randomInt(5) - 2 + height / 2);
                direction = Compute.randomInt(2) + 4;
                nextLeft = direction - 1;
                nextRight = (direction + 1) % 6;
                break;
            case 2:
            case 3:
                p = new Point(Compute.randomInt(5) - 2 + width / 2, 0);
                direction = 2;
                nextRight = 3;
                nextLeft = 4;
                break;
        } // switch
        /* place the river */
        field = board.getHex(p.x, p.y);
        ITerrainFactory f = Terrains.getTerrainFactory();
        do {
            /* first the hex itself */
            field.removeAllTerrains();
            field.addTerrain(f.createTerrain(Terrains.WATER, 1));
            riverHexes.add(field);
            p = reverseHex.get(field);
            /* then maybe the left and right neighbours */
            riverHexes.addAll(extendRiverToSide(board, p, Compute.randomInt(3),
                    nextLeft, reverseHex));
            riverHexes.addAll(extendRiverToSide(board, p, Compute.randomInt(3),
                    nextRight, reverseHex));
            switch (Compute.randomInt(4)) {
                case 0:
                    field = board.getHexInDir(p.x, p.y, (direction + 5) % 6);
                    break;
                case 1:
                    field = board.getHexInDir(p.x, p.y, (direction + 1) % 6);
                    break;
                default:
                    field = board.getHexInDir(p.x, p.y, direction);
                    break;
            }

        } while (field != null);

        /* search the elevation for the river */
        HashSet<IHex> tmpRiverHexes = new HashSet<IHex>(riverHexes);
        while (!tmpRiverHexes.isEmpty()) {
            Iterator<IHex> iter = tmpRiverHexes.iterator();
            field = iter.next();
            if (field.getElevation() < minElevation) {
                minElevation = field.getElevation();
            }
            tmpRiverHexes.remove(field);
            Point thisHex = reverseHex.get(field);
            /* and now the six neighbours */
            for (int i = 0; i < 6; i++) {
                field = board.getHexInDir(thisHex.x, thisHex.y, i);
                if ((field != null) && (field.getElevation() < minElevation)) {
                    minElevation = field.getElevation();
                }
                tmpRiverHexes.remove(field);
            }
        }

        /* now adjust the elevation to same height */
        Iterator<IHex> iter = riverHexes.iterator();
        while (iter.hasNext()) {
            field = iter.next();
            field.setElevation(minElevation);
        }

        return;
    }
View Full Code Here

     */
    private static HashSet<IHex> extendRiverToSide(IBoard board, Point hexloc,
            int width, int direction, HashMap<IHex, Point> reverseHex) {
        Point current = new Point(hexloc);
        HashSet<IHex> result = new HashSet<IHex>();
        IHex hex;

        hex = board.getHexInDir(current.x, current.y, direction);
        while ((hex != null) && (width-- > 0)) {
            hex.removeAllTerrains();
            hex.addTerrain(Terrains.getTerrainFactory().createTerrain(
                    Terrains.WATER, 1));
            result.add(hex);
            current = reverseHex.get(hex);
            hex = board.getHexInDir(current.x, current.y, direction);
        }
View Full Code Here

     * Flood negative hex levels Shoreline / salt marshes effect Works best with
     * more elevation
     */
    protected static void postProcessFlood(IHex[] hexSet, int modifier) {
        int n;
        IHex field;
        ITerrainFactory f = Terrains.getTerrainFactory();
        for (n = 0; n < hexSet.length; n++) {
            field = hexSet[n];
            int elev = field.getElevation() - modifier;
            if (elev == 0 && !(field.containsTerrain(Terrains.WATER))
                    && !(field.containsTerrain(Terrains.PAVEMENT))) {
                field.addTerrain(f.createTerrain(Terrains.SWAMP, 1));
            } else if (elev < 0) {
                if (elev < -4)
                    elev = -4;
                field.removeAllTerrains();
                field.addTerrain(f.createTerrain(Terrains.WATER, -elev));
                field.setElevation(modifier);
            }
        }
    }
View Full Code Here

    /**
     * Converts water hexes to ice hexes. Works best with snow&ice theme.
     */
    protected static void postProcessDeepFreeze(IHex[] hexSet, int modifier) {
        int n;
        IHex field;
        ITerrainFactory f = Terrains.getTerrainFactory();
        for (n = 0; n < hexSet.length; n++) {
            field = hexSet[n];
            if (field.containsTerrain(Terrains.WATER)) {
                int level = field.terrainLevel(Terrains.WATER);
                if (modifier != 0) {
                    level -= modifier;
                    field.removeTerrain(Terrains.WATER);
                    if (level > 0) {
                        field.addTerrain(f.createTerrain(Terrains.WATER,
                                        level));
                    }
                }
                field.addTerrain(f.createTerrain(Terrains.ICE, 1));
            } else if (field.containsTerrain(Terrains.SWAMP)) {
                field.removeTerrain(Terrains.SWAMP);
                if (field.terrainsPresent() == 0) {
                    if (Compute.randomInt(100) < 30) {
                        // if no other terrains present, 30% chance to change to
                        // rough
                        field.addTerrain(f.createTerrain(Terrains.ROUGH, 1));
                    } else {
                        field.addTerrain(f.createTerrain(Terrains.ICE, 1));
                    }
                }
            }
        }
    }
View Full Code Here

TOP

Related Classes of megamek.common.IHex

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.