maps

type Direction uint8

type ImageHelper struct {
	// contains filtered or unexported fields
}

type IntSlice []int

type Item byte

type Map struct {
	Torus                 // Defines the geometry of the map
	Players  int          // This is stored in the map file
	Grid     []Item       // The map data possibly run through the symmetry mapper
	TGrid    []Item       // The true map data - updated via ProcessTurn
	*SymData              // Symmetry data
	SID      int          // The integer id for symmetry so we can invalidate hill guesses etc.
	SMap     [][]Location // Symmetry map

	// internal cache data
	BorderDist []uint8       // border distance
	LocStep    [][5]Location // adjecent tile pointer
}

type MapSymData struct {
	Cycle            int
	Equivlen         int
	Gen              int
	Label            string
	Tiles            int
	Rows             int
	Cols             int
	Translate        Point
	RM1, RM2, MR, MC int
	Origin           Point
}

type Mask struct {
	Stride int // Cols
	Offsets
	// Locations added or removed for a step in each direction
	Union  Offsets     // Union is the one step out in any direction
	Add    []Offsets   // Points added for step in dir d
	Remove []Offsets   // Points removed for step in dir d
	MM     []*MoveMask // See FreedomKey for how to index into this
	MM2O   Offsets
}

type MoveMask struct {
	Offsets
	Add    Offsets // Points added on the step.
	NFree  int     // Degrees of freedom
	PStep  int     // Probability denom
	PTot   int     // Probability denom
	Stride int     // Cols used to generate loc offsets.
	MinPr  []int   // Pr numerator, matches Offsets order
	MaxPr  []int   // Pr numerator, matches Offsets order
}

type OffsetSlice []Point

type Offsets struct {
	R uint8 // Bounding Radius
	P []Point
	L []Location
	// contains filtered or unexported fields
}

type Path struct {
	// contains filtered or unexported fields
}

type SymData struct {
	*Map                         // The associated map for the Symmetry data.
	Offsets                      // The offsets cache
	MinBits uint8                // Ignore hashes with less than MinBits bits of different info
	NLen    [16]int              // Number of equiv group for a given N
	MinHash []SymHash            // Sym data for a given point.
	Hashes  []*[8]SymHash        // Map from the location to all rotations of the given location
	Tiles   map[SymHash]*SymTile // Map from minhash to location list.
	Fails   int
	Check   map[SymHash]bool // list of pending tiles to check.  possibly carried over from a previous turn.
}

type SymHash int64 // SymHash needs to be int64 if SYMN = 7, int32 otherwise.

type SymTile struct {
	Hash      SymHash    // the minhash
	Locs      []Location // encountered tiles with this minhash
	Bits      uint8      // bits of info Min(SYMN*SYMN - N*Water, N*Water)
	Self      uint8      // number of matching self rotations
	Ignore    bool       // Ignore this tile for symmetry stuff.
	Subtile   Torus      // The dimensions for the subtile == the map dim if none
	Gen       int        // the generator for the origin
	Origin    Point      // Origin for discovered symmetries
	RM1       int
	RM2       int
	MR        int
	MC        int
	Translate Point      // The offset for translation symmetry {0,0} for non translation
	EquivSet  []Location // the location list for the identified symmetry of this tile.
}