grid/autotile

const (
	Square      Layout = iota // a square grid: four edges and four diagonals
	HexRowsOdd                // hexagons in staggered rows, the odd rows shifted right
	HexRowsEven               // hexagons in staggered rows, the even rows shifted right
	HexColsOdd                // hexagons in staggered columns, the odd columns shifted down
	HexColsEven               // hexagons in staggered columns, the even columns shifted down
	// HexAxial holds hexagons in axial coordinates, where x runs east and
	// y runs south-east, so the offsets are the same for every cell. It
	// has the same six directions as the rows layouts.
	HexAxial
	IsoDiamond // a square grid projected as diamonds, with screen-relative directions
)

Dirs source

func (l Layout) Dirs() []int

Dirs lists the directions the layout has neighbours in, clockwise. A square or isometric layout lists all eight; a hexagonal one lists its six. The result is a fresh slice the caller may keep.

Hex source

func (l Layout) Hex() bool

Hex reports whether the layout is hexagonal, so a cell has six neighbours and no diagonals.

Neighbour source

func (l Layout) Neighbour(x, y, dir int) (int, int)

Neighbour returns the cell one step from (x, y) in a direction. A direction the layout has no neighbour in, such as north on a rows hexagon, returns the cell itself; Dirs lists the directions a layout uses.

String source

func (l Layout) String() string

String names the layout.

Apply source

func (m *Mapper) Apply(w, h int, terrain func(x, y int) int, set func(x, y, frame int))

Apply computes a frame for every cell and hands each to set, with -1 for cells the rules leave empty. terrain returns the id at a cell and is only called inside the map. Corner16 rules emit one extra row and column: x and y run to w and h inclusive. A nil Rules makes no calls.

Cell source

func (m *Mapper) Cell(x, y, w, h int, terrain func(x, y int) int, set func(x, y, frame int))

Cell recomputes the cells a change at (x, y) can affect: the cell and the neighbours the layout gives it, or the four surrounding corners for Corner16 rules. Call it after editing one cell instead of reapplying the map. To update after editing a block of cells, call Region instead, which computes each affected cell once.

Region source

func (m *Mapper) Region(x, y, rw, rh, w, h int, terrain func(x, y int) int, set func(x, y, frame int))

Region recomputes the cells a change anywhere in a rectangle can affect, and hands each to set once. To re-autotile after a brush stroke or a pasted block, call it with the rectangle of edited cells: rw by rh cells with its top-left cell at (x, y), on a w by h map. The frames it sets are the ones calling Cell for every cell of the rectangle would set, but a cell next to several edited cells is computed once instead of once per edited neighbour. Cells go to set in row-major order. Parts of the rectangle outside the map are allowed; a nil Rules or an empty rectangle makes no calls.

Blob47 source

func Blob47(terrain int, frames [47]int) *Rules

Blob47 builds rules that match all eight neighbours of cells with the given terrain id, reduced to the 47 distinct cases: a diagonal only matters when both edges beside it connect. frames is in canonical order, ascending by normalised mask; BlobIndex maps any raw mask to its place, and ExpandBlob emits tiles in this order.

Corner16 source

func Corner16(terrain int, frames [16]int) *Rules

Corner16 builds dual-grid rules for cells with the given terrain id. Each output tile sits on a corner between four cells, so Apply and Cell emit a grid one wider and one taller than the map; draw that tilemap offset up and left by half a tile. frames is indexed by a 4-bit mask of matching cells around the corner: north-west 1, north-east 2, south-west 4, south-east 8.

Edge16 source

func Edge16(terrain int, frames [16]int) *Rules

Edge16 builds rules that match the four edge neighbours of cells with the given terrain id. frames is indexed by a 4-bit mask of connected neighbours: north 1, east 2, south 4, west 8. Frame -1 leaves a case empty.

Edge64 source

func Edge64(terrain int, frames [64]int) *Rules

Edge64 builds rules that match the six neighbours of cells with the given terrain id on a hexagonal layout. frames is indexed by a 6-bit mask of connected neighbours, bit i being the i-th direction the layout uses, clockwise: for the rows layouts north-east, east, south-east, south-west, west and north-west, and for the columns layouts north, north-east, south-east, south, south-west and north-west. Frame -1 leaves a case empty.

Wang source

func Wang(t WangType, tiles []WangTile) *Rules

Wang builds rules from a Wang tile set. Cells hold terrain colours, zero for empty. For each cell the mapper works out the colour every relevant position should show, then places the tile matching the most positions; a complete set always matches exactly, an incomplete one falls back to the closest tile. Where two terrains meet at a corner or an edge, the higher colour wins, so higher colours overlap lower ones. A cell whose own and surrounding colours are all zero gets -1.

A hexagonal layout has six sides and no diagonals, so every type matches those six positions, in the direction slots the layout uses. t must be WangCorners, WangEdges or WangFull. The tiles slice is retained, not copied; edits affect later mapping. Use finite weights; nonpositive weights count as 1. An empty set maps every cell to -1.

A Mapper indexes the set by the colours each tile shows, so a cell that some tile matches at every position costs one lookup, however large the set. A cell no tile matches exactly scores every tile. Each call to Apply, Cell or Region first compares the set with the copy the index was built from and rebuilds the index if a tile changed, which costs time in proportion to the number of tiles.

Connect source

func (r *Rules) Connect(terrains ...int) *Rules

Connect makes neighbours of other terrains count as connected, so grass rules join up against road cells without drawing their tiles. It returns the rules for chaining.

Variant source

func (r *Rules) Variant(mask, frame int, weight float64) *Rules

Variant adds an alternative frame for one neighbourhood, chosen at random by cell position with the given weight; the frame passed to the constructor keeps weight 1. mask is the scheme's mask: 4 bits for Edge16 and Corner16, 6 bits for Edge64, the raw 8-bit mask for Blob47. A nonpositive weight counts as 1. An out-of-range mask is ignored. Wang rules take variants as extra tiles instead.

const (
	// WangCorners matches colours on the four diagonal positions; the
	// usual form for overlapping terrains.
	WangCorners WangType = iota
	// WangEdges matches colours on the four edge positions; the usual
	// form for paths and pipes.
	WangEdges
	// WangFull matches all eight positions.
	WangFull
)