Gamelogic.Grids Namespace

Place holder class.

This class provides static methods that ensure all the code is generated by to AOT compiler for iOS. The easiest way to use it is to copy the appropriate methods to one of your classes, modify the __CellType type, and call the methods.

Compiler hints for our examples. Since 1.8

This class is suitable to use as base class for most maps. AbstractMap implements the IMap interface almost completely; you only have to implement to methods that correspond to the two calculations: converting from world to grid coordinates, and converting from grid to world coordinates.

The base class for all shape operators.A shape operator provides a mechanism to construct grids in a certain shape.Shape operators are used with the shape info classes.

The base class of shape info classes

A spliced grid represents a simple grid where all cells has been sliced in an equal numbers of cells. This class implements the common features of tri and rhomb grids. It is the most probable class to use to define your own grid.

This is the base class of all ShapeInfo classes for spliced grids.

This is the base class for grids that are not spliced; in other words, grids that have identical cells, with identical orientation, and in which grid points behave as (integer) vectors.

This class provides extensions that implement obsolete methods.

This class provide generic functions for common grid operations, such as finding a shortest path or connected shapes.

A map that changes over time.

A map that maps points of a LineGrid in an archimedean spiral.

A tile that is represented by a simple 3D object (such as a cube), typically an object with a single mesh and material.

A CiaroGrid is a grid where all the cells are pentagons (so each cell has five neighbors). See http://en.wikipedia.org/wiki/Cairo_pentagonal_tiling.

Maps between world points and CiaroPoints. This example shows how to implement a map for a grid with arbitrary polygons, using PolygonMap.

Class for making CairoGrids in different shapes. Copyright Gamelogic. Author Herman Tulleken Since version 1.0 See also AbstractOp

Provides the implementation for AbstractSplicedShapeInfo to be used with CairoGrid.

Class for building a Cairo grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

This is an inspectable presentation of a grid coloring, using three parameters as explained here: http://gamelogic.co.za/2013/12/18/what-are-grid-colorings/ The three values represent two corners of a parallelogram (x0, 0) and(xq, y1) that describe the patch to repeat for the coloring.

A maps that combines two maps through function composition.

Inherit from this class to implement custom grid shapes. This class should return a grid.To have the grid builder used this grid, you should set the Shape to Custom in the editor, and attached this script to the same game object as the grid builder.

Base class for 3D grid builders using a custom map.

Inherit from this class to implement custom map for an grid builder. This class should return a map. To have the grid builder used this map, you should set the Map to Custom in the editor, and attach this script to the same game object as the grid builder.

Represents a diamond grid. At its simplest, diamond grids are square grids that are rotated 45 degrees. By using suitable dimensions in the map, DiamondGrids can be used to implement isometric grids.

Wraps points horizontally. Since version 1.7

Maps between grid points and world points.

Builder for building diamond mesh grid.

Map for diamond mesh grids.

Documentation in Op.cs

Wraps points both horizontally and vertically. Since version 1.7

Provides the implementation for AbstractShapeInfo to be used with DiamondGrid.

Class for building a diamond grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Wraps points vertically. Since version 1.7

A map that can be used with a PointyHexGrid to get a brick-wall pattern (rotated by 90 degrees). The cells are rectangular.

Map for flat brick mesh grids.

A grid for flat hexagons, that is, hexagons with two horizontal edges.

Since version 1.7

Wraps points horizontally. Since version 1.7

The default Map to be used with a FlatHexGrid.

Builder for building flat hex mesh grid.

Map for flat hex mesh grids.

Documentation in Op.cs

Wraps points both horizontally and vertically. Since version 1.7

Provides the implementation for AbstractShapeInfo to be used with FlatHexGrid.

Class for building a flat hex grid in the Unity editor. This builder can also make flat brick grids. This component should (generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Wraps points vertically. Since version 1.7

A rhombille grid in the flat orientation, that is, there are rhombusses with horizontal edges.

The default map to be used with FlatRhombGrid.

Documentation in Op.cs

Provides the implementation for AbstractSplicedShapeInfo to be used with FlatRhombGrid.

Class for building a flat rhomb grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

A grid of triangles in the flat orientation. All triangles have one horizontal edge.

A wrapper that wraps tri points over a hexagon, similar to the way hex points are wrapped in this example: http://www.redblobgames.com/grids/hexagons/ Since version 1.7

The default map between world coordinates and FlatTri coordinates.

Documentation in Op.cs

Provides the implementation for AbstractSplicedShapeInfo to be used with FlatTriGrid.

Class for building a flat tri grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Provides methods for drawing Gizmos in for grids in the Unity editor.

Extend from this class to hook in your own grid initialisation code. This is also a useful place for other logic that interacts with the grid(typically, your game logic). It has properties to access the grid and map. You cannot use this to customize the shape or map of the grid (instead, use CustomGridBuilder and CustomMapBuilder).

Base class for grid builders.

Provides utility functions for grid builders. Renamed from GridBuilderUtil to GridBuilderUtils(1.8.1)

Defines extension methods for the IGrid interface. This is implemented as an extension so that implementers need not extend from a common base class, but provide it to their clients.

Extensions for IEnumerable.

Map that maps a grid to an image; useful for texturing a grid with a single image, or point an image with a grid.

This class provides extensions that implement obsolete methods. These methods will be removed in a future version of this library.

This class provides is a mutable class that can be used to construct partial vector points. It is provided for use in Unity's inspector.

This class provides is a mutable class that can be used to construct VectorPoints. It is provided for use in Unity's inspector.

A layered grid is a 3D grid made out of layers of 2D grids with the same point type. Each layer can have a different shape. Layered grids are accessed through LayeredPoints. Note that neighbors are not implemented for this grid.If you need to use neighbor relationships, you need to extend this class and configure neighbors. See also [A new look at layered grids: setting up neighbors](http://gamelogic.co.za/2014/05/24/a-new-look-at-layered-grids-setting-up-neighbors/).

Represents a one dimensional grid; essentially an array that can work with maps. LinePoints are automatically convertible to integers.

The default map for a LineGrid, that maps points in a straight horizontal line.

Class for making LineGrids in different shapes. AbstractOpTShapeInfo

Provides the implementation for AbstractShapeInfo to be used with LineGrid.

Class for building a line grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Extensions for IMap3D.

The default maps for putting a grid in 3D space in the XY-plane.

The default maps for putting a grid in 3D space in the XZ-plane.

These functions are defined as extensions so that IMap can remain pure (that is, not access Time.time). These methods are implemented as extension methods so that they do not become part of the "pure" interface of IMap. (Time.time is a "non-pure", very Unity-specific feature).

Extensions for IMap.

Contains methods for integer arithmetic that works consistently for both positive and negative integers.

A cell that can be used in mesh grids. It contains information about the texture to use, and can be extended to contain other cell information.

Attach this component to Mesh Grid Builders to change the grid's behaviour.

Base class for tile grid builders where grid is rendered as a single mesh.

Contains various mesh maps used by builders.

A cell represented by a mesh, such as used by the polar grids.

Provides methods for making specialised meshes that can be used with grids.

Represents a composite grid, where each cell contains a grid. Big points access the "big" cells(which contain grids). Small points access the cells of the grids in the big cells. The grid can also be accessed with "normal" points.For example: suppose the grid is a 3x3 grid, where each cell is a 2x2 grid. Then the "normal" point[7, 2] corresponds to "big" point[3, 1] and "small" point[1, 1].

Use this class in constructors of HashSets and Dictionaries that take point types(such as PointyHexPoint) as keys.

An implementation of IList for grid points that is safe to use with the AOT compiler.

A one-way map map that maps a sequence of LinePoints to an arbitrary list of world points.

Class for building a point list grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

An implementation of a stack for grid points that is safe to use with the AOT compiler.

A map that can be used with a PointyHexGrid to get a brick-wall pattern. The cells are rectangular.

Map for pointy brick mesh grids.

A grid for pointy hexagons, that is, hexagons with two vertical edges.

Since version 1.7

This wrapper wraps pointy hex points horizontally.

Wraps points horizontally. Since version 1.7

The default Map to be used with a PointyHexGrid.

Builder for building flat hex mesh grid.

Map for pointy hex mesh grids.

Documentation in Op.cs

Wraps points both horizontally and vertically. Since version 1.7

Provides the implementation for AbstractShapeInfo to be used with PointyHexGrid.

Class for building a pointy hex grid in the Unity editor. This builder can also make pointy brick grids. This component should (generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Wraps points vertically. Since version 1.7

A rhombille grid in the pointy orientation, that is, there are rhombusses with vertical edges.

The default maps that works with PointyRhombGrids.

Documentation in Op.cs

Provides the implementation for AbstractSplicedShapeInfo to be used with PointyRhombGrid.

Class for building a pointy rhomb grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

A grid of triangles in the pointy orientation. All triangles have one vertical edge.

A wrapper that wraps tri points over a hexagon, similar to the way hex points are wrapped in this example: http://www.redblobgames.com/grids/hexagons/ Since version 1.7

The default map between world coordinates and PointyTri coordinates.

Documentation in Op.cs

Provides the implementation for AbstractSplicedShapeInfo to be used with PointyTriGrid.

Class for building a pointy tri grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Used to generate Poisson disk sample points.

Class for holding properties for generating a Poisson disk sample set.

This map can be used with a horizontally wrapped FlatHexGrid. For now, alignment does not work as with the other maps.

Class for building a polar flat brick grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

A class for storing properties to setup a polar grid.

This map can be used with a horizontally wrapped PointyHexGrid. For now, alignment does not work as with the other maps.

Class for building a polar pointy brick grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

This map can be used with a horizontally wrapped RectGrid. For now, alignment does not work as with the other maps.

Class for building a polar rect grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Base class for polar tile grid builders.

A map that can be used for general spliced grids made from polygons. To use this map: - Find a rectangular tessellation for your grid. - This rectangle will consist out of several polygons, each which represents a (partial) cell of your grid. - One of these polygons should correspond to the splice point (0, 0, 0). - Find the center of this polygon relative to the rectangle in normalized coordinates, that is, so that the entire rectangle corresponds to (0, 0) -> (1, 1). - Label the polygons 0, 1, 2, ... etc. - Find the vertices of each polygon in normalized coordinates. - Now calculate the spliced vector point offsets for each polygon, relative to the (0, 0, 0) polygon, in normalized coordinates.

Represents a rectangular grid.

Wraps points horizontally. Since version 1.7

Maps between RectPoints grid points and Vector2 world points.

Builder for building flat hex mesh grid.

Map for rect mesh grids.

Documentation in Op.cs

Wraps points both horizontally and vertically. Since version 1.7

Provides the implementation for AbstractShapeInfo to be used with RectGrid.

Class for building a rectangular grid in the Unity editor. This component should(generally) not be accessed directly.Instead, add your own component that inherits from GridBebaviour, and access the grid and map through there.

Wraps points vertically. Since version 1.7

Class used for keeping the proeprties of a rectangle.

Class that represents a grid shape.

Methods in an Op (sublcasses of AbstractOp) marked with this attribute are automatically added as static methods to the appropriate grid class for convenience.

This class handles how the cells of a grid is represented in memeory. This class is used by shape info classes.

A simple map that can be used for Layered Grids.

A SplicedGrid is a grid formed from another grid, where each cell is "spliced" in a certain number of cells. For example, a triangular grid can be implemented as a diamond grid where each diamond cell is spliced into two triangles.

A one-way map that can be used to make maps for arbitrary spliced grids, where each point is mapped to the base point location, plus an offset, where each index has a different offset. For example, if the spliced grid is a diamond grid, with each cell spliced into a top and bottom triangle, then the two offsets will be above and below the origin (for example, (0, 1) and(0, -1)).

A tile cell that uses a Unity sprite to render.

Similar to a sprite cell, but with custom UV coordinates. This type of cell is useful when placing a single texture across multiple cells.

A TileCell is a cell that is represented by a single Unity object. They can be anything, including Sprites, Models, or compound objects, as long as they can be instantiated, and each corresponds to exactly one cell in a grid.They are used with TileGrid builders.

Base class for tile grid builders where all the tiles are the same.

This component represents a cell that can be used with Unity's GUI system, using an Image compoenent to render the cell. It expects an Image component in the hierarchy (on the same game object or a child). To use it with grid builders: Make a new cell prefab with this component Add the grid builder to the canvas or to some child of the canvas Set the cell prefab proeprty oof the grid builder to the new prefab. Grids ships with a few example prefabs that uses UIImageCells; check them out to see how they work.

This is the same as UIImageCell, except that it supports a text component as well. This class is also suitable to use with Unity's Buttons (since they are rendered with Image and Text components). In addition to the Image component that is expected down the hierarchy, this component also expects a Text component down the hierarchy (on this object or a child).

This component represents a cell that can be used with Unity's GUI system, using a Text component to render the cell. It expects a Text component in the hierarchy (on the same game object or a child). To use it with grid builders: Make a new cell prefab with this component Add the grid builder to the canvas or to some child of the canvas Set the cell prefab property oof the grid builder to the new prefab. Grids ships with a few example prefabs that uses UITextCells; check them out to see how they work.

Similar to a sprite cell, but with custom UV coordinates. This type of cell is useful when placing a single texture across multiple cells.

Extension methods for Vector2.

Provides extension methods for transforming Vector2 instances.

A map that uses a Voronoi diagram to map points.

A WindowedMap maps grid points relative to a window (a rectangle in world space) and provides methods that makes alignment with respect to this window simple.

This class provides extensions that implement obsolete methods. These methods will be removed in a future version of this library.

A general implementation of Wrapped grids, that use arbitrary internal grids and point wrappers. A "true point" of a wrapped grid is a point that stays the same after the wrapping. - Contains returns true only for true points. - GetAllNeighbors return true points (that is, the neighbors are already wrapped) - the index operator takes all points, and wrap them before access - Iterators iterate over true points

This class is used for accessing 2D arrays. It is mainly used as a convenient wrapper for returning results of coordinate calculations.

A coordinate for a cell in a CiaroGrid. The base point is a pointy hex point, and indices run from 0 to 3.

Class that represents a points of a DiamondGrid.

A point of a hexagonal grid, where the hexagons have two horizontal edges.

A struct that represents a point of a FlatRhombGrid.

A struct that represents a point of a FlatTriGrid.

A rectangle where coordinates are non-negative integers (that is, the corners are ArrayPoints). This class is useful for implementing storage operations for shapes.

A point that represent cells in a LayeredGrid.

Represents 1D grid points. These are auto-convertible to integers, making it possible to write, for example, `grid[6]` instead of `grid[new LinePoint(6)]`.

Struct for representing a pair of integers.

Represents coordinates of the faces in a regular hexagonal lattice.The hexagons have the Pointy orientation.

A struct that represents a point of a PointyRhombPoint.

A struct that represents a point of a PointyTriGrid.

The point to be used with rectangular grids.

A point that can be use that access a generic SplicedGrid. It has two components, a base point (which is another grid point), and a splice index. Note that for these points to be truly immutable, the base point on which they are based must also be immutable.

A VectorPoint behaves like a vector, except that it's coordinates are integers.

A common interface for all cells. This class does not specify any methods, but is used to identify cells so they can be handled in a special way by the editor.

Represents a cell whose color can be set.

A point type implements this interface if that point type can be the edge grid of TPoint. For example, FlatRhombPoints are the points of the edge grid for FlatHexPoints, and hence FlatRombPoint implements "IEdge<FlatHexPoint>." (This class replaces IEdgeAnchor).

A grid where cells have an even number of neighbors. In an even grid each neighbor has an opposite neighbor.

Classes that can be edited in the inspector using a custum editor should implement this interface to allow the editor to update the presentation when necessary.

A grid interface that is not generic in the cell type. This is useful if you do not care about the cell type, and for implementing casting of grid contents.

The base class of all types of grids. Grids are similar to 2D arrays.Elements in the grid are called _cells_.Grids support random access to cells through grid points(IGridPoint), using square bracket syntax. Cell cell = squareGrid[squarePoint]; Most grids support enumeration of points, making it possible to use[LINQ](http://msdn.microsoft.com/en-us/library/bb397926.aspx) on grids as well. foreach(var point in grid) doSomethingWithCell(grid[point]); var pointsThatSatsifyPointPredicate = grid.Where(pointPredicate); General algorithms are provided in Algorithms. If you want to implement your own grid, you can implement th is interface to have your grid work with many grid algorithms.

A common interface implemented by all grid builders to allow identification by type.

Non generic interface for grid points.

Represents a "point" that is used to access a cell in a Grid. For built-in 2D grids, these points are often 2D integer vectors, or spliced vectors, and hence they implement additional interfaces such as IVectorPoint, ISplicedPoint, andISplicedVectorPoint.These points supports arithmetic, [colorings](http://gamelogic.co.za/2013/12/18/what-are-grid-colorings/), and some other geometric operations. In general, points do not "know" their neighbors.Use the grid methods IGrid<TCell, TPoint>.GetNeighbors and IGrid<TCell, TPoint>.GetAllNeighbors to make queries about a point's neighbors. GridPoint base classes must be immutable for many of the algorithms to work correctly.In particular, GridPoints are used as keys in dictionaries and sets. It is also a good idea to overload the `==` and `!=` operators.

A grid space is an object that can determine whether a point is inside it our not. Unlike grids, it does not contain data, and therefore there is no data at points.

A one-way map that converts grid points to worls points. One-way maps are useful for maps that can automatically invert the map, such as VoronoiMap.

An IMap maps 2D world coordinates to Grid coordinates and vice versa. Most of the methods of this class are meant to be chained to the constructor.The last command in the chain is suaully a conversion to IMap3D, which converts the 2D coordinates to 3D for use in the game engine. The order of chained calls sometimes make a difference. The standard order is this: - set grid point transforms - set cell anchoring - set world transforms (such as translate, rotate) - do layout (using WithWindow) - convert to 3D Transformations only apply to the world points returned and processed by the map, the grid contents is not transformed. For example, applying scale to the map, will not scale the cells physically, in the sense that if the grid contains GameObjects, cells will remain the same size. The cells will be logically bigger, so they will appear further apart from each other. Built-in 2D grids generally have associated built-in maps.See the [Grid Index](http://gamelogic.co.za/grids/quick-start-tutorial/grid-index/) for the list. You can also provide your own maps, either as implementations of IMap, or IMap3D.

An IMap maps 3D world coordinates to Grid coordinates and vice versa. Many grids provide 2D maps, which can be converted to standard 3D maps using commands such as To3DXY. You can also provide your own maps, either as implementations of IMap, or IMap3D.

Interface for maps for mesh grids.

Provides a function for wrapping points that is used by wrapped grids. Since many such functions require lookup tables, it's more suitable to provide it as a class than providing it as a delagate.

An interface for polar maps that make it easier to build meshes for them.

Interface for grid shapes.

All Shape Info classes should implement this interface. This provides basic transformations and set operations to combine shape info instances.

Interface for working with compound points. Spliced points are used for periodic grids where not all faces are identical(see AbstractSplicedGrid). Every spliced grid can be seen as a uniform regular grid, where each cell has been divided.Therefore, a spliced point consists of a coordinate on the base grid, and an index denoting the particular cell.

A partial vector point is a point that can be translated by "adding" a vector point. Partial vectors can be seen as a pair, one of which is a vector(of type TVectorPoint). All the operations actually operate on the vector of this pair. Partial vector points are used in SplicedGrids, where the second of the pair is an index that denotes the sub-cell.For example, for a tri point, the vector is a hex point, and the index denotes whether the point refers to the up or down triangle.

Indicates that a grid supports an edge grid.

Used to indicated that grids of this point type can support edge grids. Replaces ISupportsEdgeGrid that is now applied to grids, not Interface

Indicates that a grid supports an vertex grid.

Used to indicate hat grids of this point type can support vertex grids. Replaces ISupportsVertexGrid that is now aplied to grids and not points.

An interface that all tile grid builder implement. This gives common hooks that are used by the grid editors.

IVectorGrids are build on (spliced) vector points. They are regular and uniform.

A VectorPoint is a point that is also an algebraic vector.

This point type is the type of vertex anchor point of the type parmater. The vertex anchor is the point from which all the vertices are calculated. For example, if TriPoint implements ISupportsVertexGrid<HexPoint>, then HexPoint will implement IVertex<TriPoint>. (This class replaces IVertexAnchor).

An enumeration of the two basic types of 2D planes (in 3D space) used in the library.