block

type AABBer interface {
	// AABB returns all the axis aligned bounding boxes of the block.
	AABB(pos world.BlockPos, w *world.World) []physics.AABB
}

type Activatable interface {
	// Activate activates the block at a specific block position. The face clicked is passed, as well as the
	// world in which the block was activated and the viewer that activated it.
	Activate(pos world.BlockPos, clickedFace world.Face, w *world.World, u item.User)
}

type Air struct{}

type Andesite polishable

type Beacon struct{}

type Bedrock struct {
	// InfiniteBurning specifies if the bedrock block is set aflame and will burn forever. This is the case
	// for bedrock found under end crystals on top of the end pillars.
	InfiniteBurning bool
}

type BreakInfo struct {
	// Hardness is the hardness of the block, which influences the speed with which the block may be mined.
	Hardness float64
	// Harvestable is a function called to check if the block is harvestable using the tool passed. If the
	// item used to break the block is not a tool, a tool.None is passed.
	Harvestable func(t tool.Tool) bool
	// Effective is a function called to check if the block can be mined more effectively with the tool passed
	// than with an empty hand.
	Effective func(t tool.Tool) bool
	// Drops is a function called to get the drops of the block if it is broken using the tool passed. If the
	// item used to break the block is not a tool, a tool.None is passed.
	Drops func(t tool.Tool) []item.Stack
}

type Breakable interface {
	// BreakInfo returns information of the block related to the breaking of it.
	BreakInfo() BreakInfo
}

type Carpet struct {
	Colour colour.Colour
}

type Chest struct {
	// Facing is the direction that the chest is facing.
	Facing world.Direction
	// CustomName is the custom name of the chest. This name is displayed when the chest is opened, and may
	// include colour codes.
	CustomName string
	// contains filtered or unexported fields
}

type Cobblestone struct {
	// Mossy specifies if the cobblestone is mossy. This variant of cobblestone is typically found in
	// dungeons or in small clusters in the giant tree taiga biome.
	Mossy bool
}

type Concrete struct {
	// Colour is the colour of the concrete block.
	Colour colour.Colour
}

type Container interface {
	AddViewer(v ContainerViewer, w *world.World, pos world.BlockPos)
	RemoveViewer(v ContainerViewer, w *world.World, pos world.BlockPos)
	Inventory() *inventory.Inventory
}

type ContainerOpener interface {
	// OpenBlockContainer opens a block container at the position passed.
	OpenBlockContainer(pos world.BlockPos)
}

type ContainerViewer interface {
	// ViewSlotChange views a change of a single slot in the inventory, in which the item was changed to the
	// new item passed.
	ViewSlotChange(slot int, newItem item.Stack)
}

type DiamondBlock struct{}

type Diorite polishable

type Dirt struct {
	// Coarse specifies if the dirt should be off the coarse dirt variant. Grass blocks won't spread on
	// the block if set to true.
	Coarse bool
}

type EmeraldBlock struct{}

type FromStringer interface {
	FromString(s string) (interface{}, error)
}

type Glass struct{}

type GlazedTerracotta struct {
	// Colour specifies the colour of the block.
	Colour colour.Colour
	// Facing specifies the face of the block.
	Facing world.Direction
}

type GoldBlock struct{}

type Granite polishable

type Grass struct {
	// Path specifies if the grass was made into a path or not. If true, the block will have only 15/16th of
	// the height of a full block.
	Path bool
}

type IronBlock struct{}

type Lava struct {
	// Still makes the lava not spread whenever it is updated. Still lava cannot be acquired in the game
	// without world editing.
	Still bool
	// Depth is the depth of the water. This is a number from 1-8, where 8 is a source block and 1 is the
	// smallest possible lava block.
	Depth int
	// Falling specifies if the lava is falling. Falling lava will always appear as a source block, but its
	// behaviour differs when it starts spreading.
	Falling bool
}

type Leaves struct {
	// Wood is the type of wood of the leaves. This field must have one of the values found in the material
	// package.
	Wood wood.Wood
	// Persistent specifies if the leaves are persistent, meaning they will not decay as a result of no wood
	// being nearby.
	Persistent bool
	// contains filtered or unexported fields
}

type Light struct {
	// Level is the light level that the light block produces. It is a number from 0-15, where 15 is the
	// brightest and 0 is no light at all.
	Level int
}

type LightDiffuser interface {
	// LightDiffusionLevel returns the amount of light levels that is subtracted when light passes through
	// this block. Some locks, such as leaves, have this behaviour. A diffusion level of 15 means that all
	// light will be completely blocked when light passes through the block.
	LightDiffusionLevel() uint8
}

type LightEmitter interface {
	// LightEmissionLevel returns the light emission level of the block, a number from 0-15 where 15 is the
	// brightest and 0 means it doesn't emit light at all.
	LightEmissionLevel() uint8
}

type LiquidRemovable interface {
	HasLiquidDrops() bool
}

type Log struct {
	// Wood is the type of wood of the log. This field must have one of the values found in the material
	// package.
	Wood wood.Wood
	// Stripped specifies if the log is stripped or not.
	Stripped bool
	// Axis is the axis which the log block faces.
	Axis world.Axis
}

type Obsidian struct{}

type Placer interface {
	item.User
	PlaceBlock(pos world.BlockPos, b world.Block, ctx *item.UseContext)
}

type Planks struct {
	// Wood is the type of wood of the planks. This field must have one of the values found in the material
	// package.
	Wood wood.Wood
}

type Replaceable interface {
	// ReplaceableBy returns a bool which indicates if the block is replaceable by another block.
	ReplaceableBy(b world.Block) bool
}

type Sponge struct {
	// Wet specifies whether the dry or the wet variant of the block is used.
	Wet bool
}

type StainedTerracotta struct {
	// Colour specifies the colour of the block.
	Colour colour.Colour
}

type Stone struct{}

type Terracotta struct{}

type Water struct {
	// Still makes the water appear as if it is not flowing.
	Still bool
	// Depth is the depth of the water. This is a number from 1-8, where 8 is a source block and 1 is the
	// smallest possible water block.
	Depth int
	// Falling specifies if the water is falling. Falling water will always appear as a source block, but its
	// behaviour differs when it starts spreading.
	Falling bool
}

type WoodSlab struct {
	// Wood is the type of wood of the slabs. This field must have one of the values found in the material
	// package.
	Wood wood.Wood
	// UpsideDown specifies if the slabs are upside down.
	UpsideDown bool
	// Double specifies if the slab is a double slab. These double slabs can be made by placing another slab
	// on an existing slab.
	Double bool
}

type WoodStairs struct {
	// Wood is the type of wood of the stairs. This field must have one of the values found in the material
	// package.
	Wood wood.Wood
	// UpsideDown specifies if the stairs are upside down. If set to true, the full side is at the top part
	// of the block.
	UpsideDown bool
	// Facing is the direction that the full side of the stairs is facing.
	Facing world.Direction
}

type Wool struct {
	Colour colour.Colour
}