LanesMapGenerator (squidlib-util 3.0.6 API)

java.lang.Object
- squidpony.squidgrid.mapping.LanesMapGenerator

All Implemented Interfaces:

IDungeonGenerator
```
public class LanesMapGenerator
extends java.lang.Object
implements IDungeonGenerator
```
Generate dungeons with between 1 and 3 primary "lanes" going from the upper left "base" to the bottom right "base" (and vice versa, since this is symmetrical). Also fills the area not covered by lanes with "jungle" (random, but symmetrical, room or cave connections). Dungeons are produced by MixedGenerator, like those SerpentMapGenerator makes, but include the wide lanes going from corner to corner. You can call different methods like putCaveCarvers(), putBoxRoomCarvers(), putWalledRoundRoomCarvers(), etc. to affect the "jungle", which defaults to caves unless one or more of the putXXXCarvers methods was called. The lanes are always 5 floor cells wide, measured 8-way. This supports the getEnvironment() method, which can be used in conjunction with RoomFinder to find where separate room, corridor, and cave areas have been placed.
A preview can be seen here https://gist.github.com/tommyettinger/4f57cff23eead11b17bf , with dungeons created with one, two, and three lanes, and only using box-shaped rooms for "jungle." Currently, the two-lane dungeon seems to be ideal for maps that aren't incredibly large; the samples are 80x80, but larger maps may have better jungle layout with three lanes than those three-lane maps can manage on smaller sizes. Another potential advantage of the two-lane approach is that it can be used to generate a "ring" of wide paths around a central "core" of jungle, which wasn't originally intended as a use of this generator but could be very useful for games that, for instance, want guards patrolling an obvious ring, while the player, monsters, and/or other prisoners start in the jungle. Created by Tommy Ettinger on 10/24/2015.

Field Summary

Fields
Modifier and Type Field and Description

protected int[] columns

protected int lanes

protected SymmetryDungeonGenerator mix

protected IRNG random

protected int[] rows

Fields
Modifier and Type	Field and Description
`protected int[]`	`columns`
`protected int`	`lanes`
`protected SymmetryDungeonGenerator`	`mix`
`protected IRNG`	`random`
`protected int[]`	`rows`

Constructor Summary

Constructors
Constructor and Description
`LanesMapGenerator(int width, int height, IRNG rng, int lanes)` This prepares a map generator that will generate a map with the given width and height, using the given RNG.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`char[][]`	`generate()` This generates a new map by stretching a 16x16 grid of potential rooms to fit the width and height passed to the constructor, randomly expanding columns and rows before contracting the whole to fit perfectly.
`char[][]`	`getDungeon()` Gets the most recently-produced dungeon as a 2D char array, usually produced by calling `IDungeonGenerator.generate()` or some similar method present in a specific implementation.
`int[][]`	`getEnvironment()` Gets a 2D array of int constants, each representing a type of environment corresponding to a static field of MixedGenerator.
`void`	`putBoxRoomCarvers(int count)` Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a box shape at the start and end, and a small room at the corner if there is one.
`void`	`putCaveCarvers(int count)` Changes the number of "carvers" that will create caves from one room to the next.
`void`	`putRoundRoomCarvers(int count)` Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a circle shape at the start and end, and a small circular room at the corner if there is one.
`void`	`putWalledBoxRoomCarvers(int count)` Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a box shape at the start and end, and a small room at the corner if there is one.
`void`	`putWalledRoundRoomCarvers(int count)` Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a circle shape at the start and end, and a small circular room at the corner if there is one.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - mix
```
protected SymmetryDungeonGenerator mix
```
  - columns
```
protected int[] columns
```
  - rows
```
protected int[] rows
```
  - random
```
protected IRNG random
```
  - lanes
```
protected int lanes
```
- Constructor Detail
  - LanesMapGenerator
```
public LanesMapGenerator(int width,
                         int height,
                         IRNG rng,
                         int lanes)
```
    This prepares a map generator that will generate a map with the given width and height, using the given RNG. The dungeon will have the specified number of wide lanes going from upper left to lower right, possibly taking a longer path to approach the other corners. You call the different carver-adding methods to affect what the non-lane portion of the dungeon will look like, putCaveCarvers(), putBoxRoomCarvers(), and putRoundRoomCarvers(), defaulting to only caves if none are called. You call generate() after adding carvers, which returns a char[][] for a map.
    
    Parameters:
    
    width - the width of the final map in cells
    
    height - the height of the final map in cells
    
    rng - an RNG object to use for random choices; this make a lot of random choices.
    
    lanes - between 1 and 3; the number of wide paths to generate going from upper left to lower right.
    
    See Also:
    
    MixedGenerator
- Method Detail
  - putCaveCarvers
```
public void putCaveCarvers(int count)
```
    Changes the number of "carvers" that will create caves from one room to the next. If count is 0 or less, no caves will be made. If count is at least 1, caves are possible, and higher numbers relative to the other carvers make caves more likely. Carvers are shuffled when used, then repeat if exhausted during generation. Since typically about 30-40 rooms are carved, large totals for carver count aren't really needed; aiming for a total of 10 between the count of putCaveCarvers(), putBoxRoomCarvers(), and putRoundRoomCarvers() is reasonable.
    
    Parameters:
    
    count - the number of carvers making caves between rooms; only matters in relation to other carvers
    
    See Also:
    
    MixedGenerator
  - putBoxRoomCarvers
```
public void putBoxRoomCarvers(int count)
```
    Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a box shape at the start and end, and a small room at the corner if there is one. If count is 0 or less, no box-shaped rooms will be made. If count is at least 1, box-shaped rooms are possible, and higher numbers relative to the other carvers make box-shaped rooms more likely. Carvers are shuffled when used, then repeat if exhausted during generation. Since typically about 30-40 rooms are carved, large totals for carver count aren't really needed; aiming for a total of 10 between the count of putCaveCarvers(), putBoxRoomCarvers(), and putRoundRoomCarvers() is reasonable.
    
    Parameters:
    
    count - the number of carvers making box-shaped rooms and corridors between them; only matters in relation to other carvers
    
    See Also:
    
    MixedGenerator
  - putWalledBoxRoomCarvers
```
public void putWalledBoxRoomCarvers(int count)
```
    Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a box shape at the start and end, and a small room at the corner if there is one. This also ensures walls will be placed around the room, only allowing corridors and small cave openings to pass. If count is 0 or less, no box-shaped rooms will be made. If count is at least 1, box-shaped rooms are possible, and higher numbers relative to the other carvers make box-shaped rooms more likely. Carvers are shuffled when used, then repeat if exhausted during generation. Since typically about 30-40 rooms are carved, large totals for carver count aren't really needed; aiming for a total of 10 between the count of putCaveCarvers(), putBoxRoomCarvers(), and putRoundRoomCarvers() is reasonable.
    
    Parameters:
    
    count - the number of carvers making box-shaped rooms and corridors between them; only matters in relation to other carvers
    
    See Also:
    
    MixedGenerator
  - putRoundRoomCarvers
```
public void putRoundRoomCarvers(int count)
```
    Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a circle shape at the start and end, and a small circular room at the corner if there is one. If count is 0 or less, no circular rooms will be made. If count is at least 1, circular rooms are possible, and higher numbers relative to the other carvers make circular rooms more likely. Carvers are shuffled when used, then repeat if exhausted during generation. Since typically about 30-40 rooms are carved, large totals for carver count aren't really needed; aiming for a total of 10 between the count of putCaveCarvers(), putBoxRoomCarvers(), and putRoundRoomCarvers() is reasonable.
    
    Parameters:
    
    count - the number of carvers making circular rooms and corridors between them; only matters in relation to other carvers
    
    See Also:
    
    MixedGenerator
  - putWalledRoundRoomCarvers
```
public void putWalledRoundRoomCarvers(int count)
```
    Changes the number of "carvers" that will create right-angle corridors from one room to the next, create rooms with a random size in a circle shape at the start and end, and a small circular room at the corner if there is one. This also ensures walls will be placed around the room, only allowing corridors and small cave openings to pass. If count is 0 or less, no circular rooms will be made. If count is at least 1, circular rooms are possible, and higher numbers relative to the other carvers make circular rooms more likely. Carvers are shuffled when used, then repeat if exhausted during generation. Since typically about 30-40 rooms are carved, large totals for carver count aren't really needed; aiming for a total of 10 between the count of putCaveCarvers(), putBoxRoomCarvers(), and putRoundRoomCarvers() is reasonable.
    
    Parameters:
    
    count - the number of carvers making circular rooms and corridors between them; only matters in relation to other carvers
    
    See Also:
    
    MixedGenerator
  - generate
```
public char[][] generate()
```
    This generates a new map by stretching a 16x16 grid of potential rooms to fit the width and height passed to the constructor, randomly expanding columns and rows before contracting the whole to fit perfectly. This uses the Moore Curve, a space-filling curve that loops around on itself, to guarantee that the rooms will always have a long path through the dungeon that, if followed completely, will take you back to your starting room. Some small branches are possible, and large rooms may merge with other rooms nearby. This uses MixedGenerator.
    
    Specified by:
    
    generate in interface IDungeonGenerator
    
    Returns:
    
    a char[][] where '#' is a wall and '.' is a floor or corridor; x first y second
    
    See Also:
    
    MixedGenerator
  - getEnvironment
```
public int[][] getEnvironment()
```
    Gets a 2D array of int constants, each representing a type of environment corresponding to a static field of MixedGenerator. This array will have the same size as the last char 2D array prduced by generate(), and the value of this method if called before generate() is undefined, but probably will be a 2D array of all 0 (UNTOUCHED).
    - MixedGenerator.UNTOUCHED, equal to 0, is used for any cells that aren't near a floor.
    - MixedGenerator.ROOM_FLOOR, equal to 1, is used for floor cells inside wide room areas.
    - MixedGenerator.ROOM_WALL, equal to 2, is used for wall cells around wide room areas.
    - MixedGenerator.CAVE_FLOOR, equal to 3, is used for floor cells inside rough cave areas.
    - MixedGenerator.CAVE_WALL, equal to 4, is used for wall cells around rough cave areas.
    - MixedGenerator.CORRIDOR_FLOOR, equal to 5, is used for floor cells inside narrow corridor areas.
    - MixedGenerator.CORRIDOR_WALL, equal to 6, is used for wall cells around narrow corridor areas.
    Returns:
    
    a 2D int array where each element is an environment type constant in MixedGenerator
  - getDungeon
```
public char[][] getDungeon()
```
    Description copied from interface: IDungeonGenerator
    
    Gets the most recently-produced dungeon as a 2D char array, usually produced by calling IDungeonGenerator.generate() or some similar method present in a specific implementation. This normally passes a direct reference and not a copy, so you can normally modify the returned array to propagate changes back into this IDungeonGenerator.
    
    Specified by:
    
    getDungeon in interface IDungeonGenerator
    
    Returns:
    
    the most recently-produced dungeon/map as a 2D char array

Class LanesMapGenerator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

mix

columns

rows

random

lanes

Constructor Detail

LanesMapGenerator

Method Detail

putCaveCarvers

putBoxRoomCarvers

putWalledBoxRoomCarvers

putRoundRoomCarvers

putWalledRoundRoomCarvers

generate

getEnvironment

getDungeon