tilepix

package module
v0.4.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 9, 2023 License: MIT Imports: 20 Imported by: 4

README

Build Status Go Report Card GitHub GoDoc

TilePixLogo TilePix

TilePix is a complementary library, designed to be used with the Pixel library (see below for more details on Pixel). TilePix was born out of Ludum Dare; having found that a vast amount of very limited time during the Ludum Dare weekends was used planing out map layouts, and defining collision or activation areas. TilePix should make those activities a trivially short amount of time.

Pixel

This library is a complement to the Pixel 2D games library, and is largely inspired by it. A huge thanks to faiface for one, giving us access to such a fantastic library; and two, providing the inspiration for this library! Further thanks to duysqubix and collaborators for continuing the effort with Pixel2.

TilePix would not have been possible without the great amount of care and effort that has been put into Pixel.

Pixel is subject to the MIT licence.

Stability

TilePix is a work-in-progress project; as such, expect bugs and missing features. If you notice a bug or a feature you feel is missing, please consider contributing - simply (and correctly) raising issues is just as valuable as writing code!

Example

Here is a very basic example of using the library. It is advisable to view the excellent Pixel tutorials before trying to understand this package, as TilePix is very Pixel centric.

package main

import (
	"image/color"

	// We must use blank imports for any image formats in the tileset image sources.
	// You will get an error if a blank import is not made; TilePix does not import
	// specific image formats, that is the responsibility of the calling code.
	_ "image/png"

	"github.com/bcvery1/tilepix"

	pixel "github.com/duysqubix/pixel2"
	"github.com/duysqubix/pixel2/pixelgl"
)

func run() {
	cfg := pixelgl.WindowConfig{
		Title: "TilePix",
		Bounds: pixel.R(0, 0, 640, 320),
		VSync: true,
	}

	win, err := pixelgl.NewWindow(cfg)
	if err != nil {
		panic(err)
	}

	// Load and initialise the map.
	m, err := tilepix.ReadFile("myMap.tmx")
	if err != nil {
		panic(err)
	}

	for !win.Closed() {
		win.Clear(color.White)

		// Draw all layers to the window.
		if err := m.DrawAll(win, color.White, pixel.IM); err != nil {
			panic(err)
		}

		win.Update()
	}
}

func main() {
	pixelgl.Run(run)
}

Further examples can be found in the examples directory.

Contributing

Thanks for considering contributing to TilePix; for details on how you can contribute, please consult the contribution guide.

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrUnknownEncoding       = errors.New("tmx: invalid encoding scheme")
	ErrUnknownCompression    = errors.New("tmx: invalid compression method")
	ErrInvalidDecodedDataLen = errors.New("tmx: invalid decoded data length")
	ErrInvalidGID            = errors.New("tmx: invalid GID")
	ErrInvalidObjectType     = errors.New("tmx: the object type requested does not match this object")
	ErrInvalidPointsField    = errors.New("tmx: invalid points string")
	ErrInfiniteMap           = errors.New("tmx: infinite maps are not currently supported")
)

Errors which are returned from various places in the package.

View Source 
var (
	// NilTile is a tile with no tile set.  Will be skipped over when drawing.
	NilTile = &DecodedTile{Nil: true}
)

Functions

This section is empty.

Types

type Data 

type Data struct {
	Encoding    string `xml:"encoding,attr"`
	Compression string `xml:"compression,attr"`
	RawData     []byte `xml:",innerxml"`
	// DataTiles is only used when layer encoding is XML.
	DataTiles []*DataTile `xml:"tile"`
}

Data is a TMX file structure holding data.

func (*Data) String added in v0.2.0 

func (d *Data) String() string

type DataTile 

type DataTile struct {
	GID GID `xml:"gid,attr"`
}

DataTile is a tile from a data object.

type DecodedTile 

type DecodedTile struct {
	ID             ID
	Tileset        *Tileset
	HorizontalFlip bool
	VerticalFlip   bool
	DiagonalFlip   bool
	Nil            bool
	// contains filtered or unexported fields
}

DecodedTile is a convenience struct, which stores the decoded data from a Tile.

func (*DecodedTile) Draw added in v0.2.0 

func (t *DecodedTile) Draw(ind, columns, numRows int, ts *Tileset, target pixel.Target, offset pixel.Vec)

Draw will draw the tile to the target provided. This will calculate the sprite from the provided tileset and set the DecodedTiles' internal `sprite` property; this is so it is only calculated the first time.

func (*DecodedTile) IsNil 

func (t *DecodedTile) IsNil() bool

IsNil returns whether this tile is nil. If so, it means there is nothing set for the tile, and should be skipped in drawing.

func (DecodedTile) Position added in v0.4.0 

func (t DecodedTile) Position(ind int, ts *Tileset) pixel.Vec

Position returns the relative game position.

func (*DecodedTile) String added in v0.2.0 

func (t *DecodedTile) String() string

type GID 

type GID uint32

GID is a global tile ID. Tiles can use GID or ID.

type ID 

type ID uint32

ID is a tile ID. Tiles can use GID or ID.

type Image 

type Image struct {
	Source string `xml:"source,attr"`
	Trans  string `xml:"trans,attr"`
	Width  int    `xml:"width,attr"`
	Height int    `xml:"height,attr"`
	// contains filtered or unexported fields
}

Image is a TMX file structure which referencing an image file, with associated properies.

func (*Image) String added in v0.2.0 

func (i *Image) String() string

type ImageLayer added in v0.2.0 

type ImageLayer struct {
	Locked  bool    `xml:"locked,attr"`
	Name    string  `xml:"name,attr"`
	OffSetX float64 `xml:"offsetx,attr"`
	OffSetY float64 `xml:"offsety,attr"`
	Opacity float64 `xml:"opacity,attr"`
	Image   *Image  `xml:"image"`
	// contains filtered or unexported fields
}

ImageLayer is a TMX file structure which references an image layer, with associated properties.

func (*ImageLayer) Draw added in v0.2.0 

func (im *ImageLayer) Draw(target pixel.Target, mat pixel.Matrix) error

Draw will draw the image layer to the target provided, shifted with the provided matrix.

func (*ImageLayer) String added in v0.2.0 

func (im *ImageLayer) String() string

type Map 

type Map struct {
	Version     string `xml:"title,attr"`
	Orientation string `xml:"orientation,attr"`
	// Width is the number of tiles - not the width in pixels
	Width int `xml:"width,attr"`
	// Height is the number of tiles - not the height in pixels
	Height          int            `xml:"height,attr"`
	TileWidth       int            `xml:"tilewidth,attr"`
	TileHeight      int            `xml:"tileheight,attr"`
	Properties      []*Property    `xml:"properties>property"`
	Tilesets        []*Tileset     `xml:"tileset"`
	TileLayers      []*TileLayer   `xml:"layer"`
	ObjectGroups    []*ObjectGroup `xml:"objectgroup"`
	Infinite        bool           `xml:"infinite,attr"`
	ImageLayers     []*ImageLayer  `xml:"imagelayer"`
	BackgroundColor string         `xml:"backgroundcolor,attr"`
	// contains filtered or unexported fields
}

Map is a TMX file structure representing the map as a whole.

func Read 

func Read(r io.Reader, dir string, openFileFunc func(name string) (http.File, error)) (*Map, error)

Read will read, decode and initialise a Tiled Map from a data reader. openFileFunc is used to retrieve tilesets and can be nil, in which case os.Open is used.

func ReadFile 

func ReadFile(filePath string) (*Map, error)

ReadFile will read, decode and initialise a Tiled Map from a file path.

func (*Map) Bounds added in v0.3.0 

func (m *Map) Bounds() pixel.Rect

Bounds will return a pixel rectangle representing the width-height in pixels.

func (*Map) Centre added in v0.3.0 

func (m *Map) Centre() pixel.Vec

Centre will return a pixel vector reprensenting the center of the bounds.

func (*Map) DrawAll 

func (m *Map) DrawAll(target pixel.Target, clearColour color.Color, mat pixel.Matrix) error

DrawAll will draw all tile layers and image layers to the target. Tile layers are first draw to their own `pixel.Batch`s for efficiency. All layers are drawn to a `pixel.Canvas` before being drawn to the target.

- target - The target to draw layers to. - clearColour - The colour to clear the maps' canvas before drawing. - mat - The matrix to draw the canvas to the target with.

func (*Map) GenerateTileObjectLayer added in v0.4.0 

func (m *Map) GenerateTileObjectLayer() error

GenerateTileObjectLayer will create an object layer which contains all objects as defined by individual tiles.

func (*Map) GetImageLayerByName added in v0.2.0 

func (m *Map) GetImageLayerByName(name string) *ImageLayer

GetImageLayerByName returns a Map's ImageLayer by its name

func (*Map) GetObjectByName added in v0.3.0 

func (m *Map) GetObjectByName(name string) []*Object

GetObjectByName returns the Maps' Objects by their name

func (*Map) GetObjectLayerByName added in v0.2.0 

func (m *Map) GetObjectLayerByName(name string) *ObjectGroup

GetObjectLayerByName returns a Map's ObjectGroup by its name

func (*Map) GetTileLayerByName added in v0.3.0 

func (m *Map) GetTileLayerByName(name string) *TileLayer

GetTileLayerByName returns a Map's TileLayer by its name

func (*Map) String added in v0.2.0 

func (m *Map) String() string

type Object 

type Object struct {
	Name       string      `xml:"name,attr"`
	Type       string      `xml:"type,attr"`
	X          float64     `xml:"x,attr"`
	Y          float64     `xml:"y,attr"`
	Width      float64     `xml:"width,attr"`
	Height     float64     `xml:"height,attr"`
	GID        ID          `xml:"gid,attr"`
	ID         ID          `xml:"id,attr"`
	Visible    bool        `xml:"visible,attr"`
	Polygon    *Polygon    `xml:"polygon"`
	PolyLine   *PolyLine   `xml:"polyline"`
	Properties []*Property `xml:"properties>property"`
	Ellipse    *struct{}   `xml:"ellipse"`
	Point      *struct{}   `xml:"point"`
	// contains filtered or unexported fields
}

Object is a TMX file struture holding a specific Tiled object.

func (*Object) GetEllipse added in v0.2.0 

func (o *Object) GetEllipse() (pixel.Circle, error)

GetEllipse will return a pixel.Circle representation of this object relative to the map (the co-ordinates will match those as drawn in Tiled). If the object type is not `EllipseObj` this function will return `pixel.C(pixel.ZV, 0)` and an error.

Because there is no pixel geometry code for irregular ellipses, this function will average the width and height of the ellipse object from the TMX file, and return a regular circle about the centre of the ellipse.

func (*Object) GetPoint added in v0.2.0 

func (o *Object) GetPoint() (pixel.Vec, error)

GetPoint will return a pixel.Vec representation of this object relative to the map (the co-ordinates will match those as drawn in Tiled). If the object type is not `PointObj` this function will return `pixel.ZV` and an error.

func (*Object) GetPolyLine added in v0.3.0 

func (o *Object) GetPolyLine() ([]pixel.Vec, error)

GetPolyLine will return a pixel.Vec slice representation of this object relative to the map (the co-ordinates will match those as drawn in Tiled). If the object type is not `PolylineObj` this function will return `nil` and an error.

func (*Object) GetPolygon added in v0.3.0 

func (o *Object) GetPolygon() ([]pixel.Vec, error)

GetPolygon will return a pixel.Vec slice representation of this object relative to the map (the co-ordinates will match those as drawn in Tiled). If the object type is not `PolygonObj` this function will return `nil` and an error.

func (*Object) GetRect added in v0.2.0 

func (o *Object) GetRect() (pixel.Rect, error)

GetRect will return a pixel.Rect representation of this object relative to the map (the co-ordinates will match those as drawn in Tiled). If the object type is not `RectangleObj` this function will return `pixel.R(0, 0, 0, 0)` and an error.

func (*Object) GetTile added in v0.3.0 

func (o *Object) GetTile() (*DecodedTile, error)

GetTile will return the object decoded into a DecodedTile struct. If this object is not a DecodedTile, this function will return `nil` and an error.

func (*Object) GetType added in v0.2.0 

func (o *Object) GetType() ObjectType

GetType will return the ObjectType constant type of this object.

func (*Object) String added in v0.2.0 

func (o *Object) String() string

type ObjectGroup 

type ObjectGroup struct {
	Name       string      `xml:"name,attr"`
	Color      string      `xml:"color,attr"`
	OffSetX    float64     `xml:"offsetx,attr"`
	OffSetY    float64     `xml:"offsety,attr"`
	Opacity    float32     `xml:"opacity,attr"`
	Visible    bool        `xml:"visible,attr"`
	Properties []*Property `xml:"properties>property"`
	Objects    []*Object   `xml:"object"`
	// contains filtered or unexported fields
}

ObjectGroup is a TMX file structure holding a Tiled ObjectGroup.

func (*ObjectGroup) GetObjectByName added in v0.3.0 

func (og *ObjectGroup) GetObjectByName(name string) []*Object

GetObjectByName returns the ObjectGroups' Objects by their name

func (*ObjectGroup) String added in v0.2.0 

func (og *ObjectGroup) String() string

type ObjectType added in v0.2.0 

type ObjectType int

ObjectType is used to represent the types an object can be. 

const (
	EllipseObj ObjectType = iota
	PolygonObj
	PolylineObj
	RectangleObj
	PointObj
	TileObj
)

These are the currently supported object types.

func (ObjectType) String added in v0.2.0 

func (o ObjectType) String() string

type Point 

type Point struct {
	X int
	Y int
	// contains filtered or unexported fields
}

Point is a TMX file structure holding a Tiled Point object.

func (*Point) String added in v0.2.0 

func (p *Point) String() string

func (*Point) V 

func (p *Point) V() pixel.Vec

V converts the Tiled Point to a Pixel Vector.

type PolyLine 

type PolyLine struct {
	Points string `xml:"points,attr"`
	// contains filtered or unexported fields
}

PolyLine is a TMX file structure representing a Tiled Polyline.

func (*PolyLine) Decode 

func (p *PolyLine) Decode() ([]*Point, error)

Decode will return a slice of points which make up this polyline.

func (*PolyLine) String added in v0.2.0 

func (p *PolyLine) String() string

type Polygon 

type Polygon struct {
	Points string `xml:"points,attr"`
	// contains filtered or unexported fields
}

Polygon is a TMX file structure representing a Tiled Polygon.

func (*Polygon) Decode 

func (p *Polygon) Decode() ([]*Point, error)

Decode will return a slice of points which make up this polygon.

func (*Polygon) String added in v0.2.0 

func (p *Polygon) String() string

type Property 

type Property struct {
	Name  string `xml:"name,attr"`
	Value string `xml:"value,attr"`
	// contains filtered or unexported fields
}

Property is a TMX file structure which holds a Tiled property.

func (*Property) String added in v0.2.0 

func (p *Property) String() string

type Tile 

type Tile struct {
	ID    ID     `xml:"id,attr"`
	Image *Image `xml:"image"`
	// ObjectGroup is set if objects have been added to individual sprites in Tiled.
	ObjectGroup *ObjectGroup `xml:"objectgroup,omitempty"`
	// contains filtered or unexported fields
}

Tile is a TMX file structure which holds a Tiled tile.

func (*Tile) String added in v0.2.0 

func (t *Tile) String() string

type TileLayer added in v0.3.0 

type TileLayer struct {
	Name       string      `xml:"name,attr"`
	Opacity    float32     `xml:"opacity,attr"`
	OffSetX    float64     `xml:"offsetx,attr"`
	OffSetY    float64     `xml:"offsety,attr"`
	Visible    bool        `xml:"visible,attr"`
	Properties []*Property `xml:"properties>property"`
	Data       Data        `xml:"data"`
	// DecodedTiles is the attribute you should use instead of `Data`.
	// Tile entry at (x,y) is obtained using l.DecodedTiles[y*map.Width+x].
	DecodedTiles []*DecodedTile
	// Tileset is only set when the layer uses a single tileset and NilLayer is false.
	Tileset *Tileset
	// Empty should be set when all entries of the layer are NilTile.
	Empty bool
	// contains filtered or unexported fields
}

TileLayer is a TMX file structure which can hold any type of Tiled layer.

func (*TileLayer) Batch added in v0.3.0 

func (l *TileLayer) Batch() (*pixel.Batch, error)

Batch returns the batch with the picture data from the tileset associated with this layer.

func (*TileLayer) Draw added in v0.3.0 

func (l *TileLayer) Draw(target pixel.Target) error

Draw will use the TileLayers' batch to draw all tiles within the TileLayer to the target.

func (*TileLayer) SetDirty added in v0.3.0 

func (l *TileLayer) SetDirty(newVal bool)

SetDirty will update the TileLayers' `dirty` property. If true, this will cause the TileLayers' batch be cleared and re-drawn next time `TileLayer.Draw` is called.

func (*TileLayer) SetStatic added in v0.3.0 

func (l *TileLayer) SetStatic(newVal bool)

SetStatic will update the TileLayers' `static` property. If false, this will set the dirty property to true each time after `TileLayer.Draw` is called, so that the layer is drawn everytime.

func (*TileLayer) String added in v0.3.0 

func (l *TileLayer) String() string

type Tileset 

type Tileset struct {
	FirstGID   GID         `xml:"firstgid,attr"`
	Source     string      `xml:"source,attr"`
	Name       string      `xml:"name,attr"`
	TileWidth  int         `xml:"tilewidth,attr"`
	TileHeight int         `xml:"tileheight,attr"`
	Spacing    int         `xml:"spacing,attr"`
	Margin     int         `xml:"margin,attr"`
	Properties []*Property `xml:"properties>property"`
	Image      *Image      `xml:"image"`
	Tiles      []*Tile     `xml:"tile"`
	Tilecount  int         `xml:"tilecount,attr"`
	Columns    int         `xml:"columns,attr"`
	// contains filtered or unexported fields
}

Tileset is a TMX file structure which represents a Tiled Tileset

func (Tileset) GenerateTileObjectLayer added in v0.4.0 

func (ts Tileset) GenerateTileObjectLayer(tileLayers []*TileLayer) ObjectGroup

GenerateTileObjectLayer will create a new ObjectGroup for the mapping of Objects to individual tiles.

func (*Tileset) String added in v0.2.0 

func (ts *Tileset) String() string

func (Tileset) TileObjects added in v0.4.0 

func (ts Tileset) TileObjects() map[ID]*ObjectGroup

TileObjects will return all ObjectGroups contained in Tiles.

Source Files

View all Source files

Directories

Path Synopsis
examples
basics
wiki

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.