world

type ArrowSpawnConfig struct {
	Damage float64

	Owner Entity

	Critical bool

	DisablePickup bool

	ObtainArrowOnPickup bool

	PunchLevel int

	PiercingLevel int

	Tip any
}

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

type Biome interface {
	Temperature() float64

	Rainfall() float64

	Depth() float64

	Scale() float64

	WaterColour() color.RGBA

	Tags() []string

	String() string

	EncodeBiome() int
}

type Block interface {
	EncodeBlock() (string, map[string]any)

	Hash() (uint64, uint64)

	Model() BlockModel
}

type BlockAction interface {
	BlockAction()
}

type BlockModel interface {
	BBox(pos cube.Pos, s BlockSource) []cube.BBox

	FaceSolid(pos cube.Pos, face cube.Face, s BlockSource) bool
}

type BlockRegistry interface {
	chunk.BlockRegistry

	BlockByRuntimeID(rid uint32) (Block, bool)

	BlockByRuntimeIDOrAir(rid uint32) Block

	BlockRuntimeID(block Block) (rid uint32)

	RegisterBlock(block Block)

	RegisterBlockState(blockState BlockState)

	CustomBlocks() map[string]CustomBlock

	BlockByName(name string, properties map[string]any) (Block, bool)

	Blocks() []Block

	Air() Block

	Finalize()

	BitSize() int

	BlockHash(b Block) uint64

	RuntimeIDToHash(runtimeID uint32) (hash uint32, ok bool)
}

type BlockSource interface {
	Block(cube.Pos) Block
}

type BlockState struct {
	Name       string         `nbt:"name"`
	Properties map[string]any `nbt:"states"`
	Version    int32          `nbt:"version"`
}

type ChunkPos [2]int32

type Column struct {
	*chunk.Chunk
	Entities      []*EntityHandle
	BlockEntities map[cube.Pos]Block
	// contains filtered or unexported fields
}

type Config struct {
	Log *slog.Logger

	Dim Dimension

	PortalDestination func(dim Dimension) *World

	Provider Provider

	Generator Generator

	ReadOnly bool

	SaveInterval time.Duration

	ChunkUnloadInterval time.Duration

	ChunkLoadWorkers int

	RandomTickSpeed int

	RandSource rand.Source

	Entities EntityRegistry

	Blocks BlockRegistry

	Synchronous bool
}

type Context struct {
	*Tx
	// contains filtered or unexported fields
}

type CustomBlock interface {
	Block
	Properties() customblock.Properties
}

type CustomBlockBuildable interface {
	CustomBlock

	Name() string

	Geometry() []byte

	Textures() map[string]image.Image
}

type CustomItem interface {
	Item

	Name() string

	Texture() image.Image

	Category() category.Category
}

type DamageSource interface {
	ReducedByArmour() bool

	ReducedByResistance() bool

	Fire() bool

	IgnoreTotem() bool
}

type Difficulty interface {
	FoodRegenerates() bool

	StarvationHealthLimit() float64

	FireSpreadIncrease() int
}

type Dimension interface {
	Range() cube.Range
	WaterEvaporates() bool
	LavaSpreadDuration() time.Duration
	WeatherCycle() bool
	TimeCycle() bool
}

type Entity interface {
	io.Closer

	H() *EntityHandle

	Position() mgl64.Vec3

	Rotation() cube.Rotation
}

type EntityAction interface {
	EntityAction()
}

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

type EntityConfig interface {
	Apply(data *EntityData)
}

type EntityData struct {
	Pos, Vel          mgl64.Vec3
	Rot               cube.Rotation
	Name              string
	AlwaysShowNameTag bool
	FireDuration      time.Duration
	Age               time.Duration

	Data any
}

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

type EntityRef[T Entity] struct {
	// contains filtered or unexported fields
}

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

type EntityRegistryConfig struct {
	Item               func(opts EntitySpawnOpts, it any) *EntityHandle
	FallingBlock       func(opts EntitySpawnOpts, bl Block) *EntityHandle
	TNT                func(opts EntitySpawnOpts, fuse time.Duration) *EntityHandle
	BottleOfEnchanting func(opts EntitySpawnOpts, owner Entity) *EntityHandle
	Arrow              func(opts EntitySpawnOpts, conf ArrowSpawnConfig) *EntityHandle
	Egg                func(opts EntitySpawnOpts, owner Entity) *EntityHandle
	EnderPearl         func(opts EntitySpawnOpts, owner Entity) *EntityHandle
	Firework           func(opts EntitySpawnOpts, firework Item, owner Entity, sidewaysVelocityMultiplier, upwardsAcceleration float64, attached bool) *EntityHandle
	LingeringPotion    func(opts EntitySpawnOpts, t any, owner Entity) *EntityHandle
	Snowball           func(opts EntitySpawnOpts, owner Entity) *EntityHandle
	SplashPotion       func(opts EntitySpawnOpts, t any, owner Entity) *EntityHandle
	Lightning          func(opts EntitySpawnOpts) *EntityHandle
}

type EntitySpawnOpts struct {
	Position mgl64.Vec3

	Rotation cube.Rotation

	Velocity mgl64.Vec3

	ID uuid.UUID

	NameTag string
}

type EntityType interface {
	Open(tx *Tx, handle *EntityHandle, data *EntityData) Entity

	EncodeEntity() string

	BBox(e Entity) cube.BBox

	DecodeNBT(m map[string]any, data *EntityData)

	EncodeNBT(data *EntityData) map[string]any
}

type GameMode interface {
	AllowsEditing() bool

	AllowsTakingDamage() bool

	CreativeInventory() bool

	HasCollision() bool

	AllowsFlying() bool

	AllowsInteraction() bool

	Visible() bool

	InstantPortalTravel() bool
}

type Generator interface {
	GenerateChunk(pos ChunkPos, chunk *chunk.Chunk)

	DefaultSpawn(dim Dimension) cube.Pos
}

type Handler interface {
	HandleLiquidFlow(ctx *Context, from, into cube.Pos, liquid Liquid, replaced Block)

	HandleLiquidDecay(ctx *Context, pos cube.Pos, before, after Liquid)

	HandleLiquidHarden(ctx *Context, hardenedPos cube.Pos, liquidHardened, otherLiquid, newBlock Block)

	HandleSound(ctx *Context, s Sound, pos mgl64.Vec3)

	HandleFireSpread(ctx *Context, from, to cube.Pos)

	HandleBlockBurn(ctx *Context, pos cube.Pos)

	HandleCropTrample(ctx *Context, pos cube.Pos)

	HandleLeavesDecay(ctx *Context, pos cube.Pos)

	HandleEntitySpawn(tx *Tx, e Entity)

	HandleEntityDespawn(tx *Tx, e Entity)

	HandleExplosion(ctx *Context, position mgl64.Vec3, entities *[]Entity, blocks *[]cube.Pos, itemDropChance *float64, spawnFire *bool)

	HandleRedstoneUpdate(ctx *Context, update RedstoneUpdate)

	HandleClose(tx *Tx)
}

type HealingSource interface {
	HealingSource()
}

type Item interface {
	EncodeItem() (name string, meta int16)
}

type Liquid interface {
	Block

	LiquidDepth() int

	SpreadDecay() int

	WithDepth(depth int, falling bool) Liquid

	LiquidFalling() bool

	BlastResistance() float64

	LiquidType() string

	Harden(pos cube.Pos, tx *Tx, flownIntoBy *cube.Pos) bool

	LiquidRemoveBlock(pos cube.Pos, tx *Tx, removed Block)
}

type LiquidDisplacer interface {
	CanDisplace(b Liquid) bool

	SideClosed(pos, side cube.Pos, tx *Tx) bool
}

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

type NBTer interface {
	DecodeNBT(data map[string]any) any

	EncodeNBT() map[string]any
}

type NeighbourUpdateTicker interface {
	NeighbourUpdateTick(pos, changedNeighbour cube.Pos, tx *Tx)
}

type NopGenerator struct{}

type NopHandler struct{}

type NopProvider struct {
	Set *Settings
}

type NopViewer struct{}

type PanicError struct {
	Value any

	Stack []byte
}

type Particle interface {
	Spawn(w *World, pos mgl64.Vec3)
}

type Provider interface {
	io.Closer

	Settings() *Settings

	SaveSettings(*Settings)

	LoadPlayerSpawnPosition(uuid uuid.UUID) (pos cube.Pos, exists bool, err error)

	SavePlayerSpawnPosition(uuid uuid.UUID, pos cube.Pos) error

	LoadColumn(pos ChunkPos, dim Dimension) (*chunk.Column, error)

	StoreColumn(pos ChunkPos, dim Dimension, col *chunk.Column) error
}

type RandomTicker interface {
	RandomTick(pos cube.Pos, tx *Tx, r *rand.Rand)
}

type RedstoneNonConductive interface {
	RedstoneNonConductive()
}

type RedstonePowerAction interface {
	RedstonePowerAction(pos cube.Pos, tx *Tx, oldPower, newPower int)
}

type RedstonePowerConsumer interface {
	RedstonePowerUpdate(pos cube.Pos, tx *Tx, power int) (after Block, changed bool)
}

type RedstonePowerContextAction interface {
	RedstonePowerActionUpdate(pos cube.Pos, tx *Tx, update RedstoneUpdate)
}

type RedstonePowerPostUpdater interface {
	RedstonePowerPostUpdate(pos cube.Pos, tx *Tx, before, after Block, oldPower, newPower int)
}

type RedstonePowerRelayer interface {
	RedstoneSignalLoss(pos cube.Pos, tx *Tx) int
}

type RedstonePowerRelayerNeighbourer interface {
	RedstoneRelayerNeighbours(pos cube.Pos, tx *Tx) []cube.Pos
}

type RedstonePowerSource interface {
	RedstonePower(pos cube.Pos, tx *Tx, face cube.Face) int
}

type RedstoneStrongPowerSource interface {
	RedstoneStrongPower(pos cube.Pos, tx *Tx, face cube.Face) int
}

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

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

type RedstoneUpdate struct {
	Pos cube.Pos

	ChangedNeighbour cube.Pos

	HasChangedNeighbour bool

	ChangedRedstoneRelevant bool

	Source cube.Pos

	HasSource bool

	Before Block

	After Block

	OldPower int

	NewPower int

	CurrentTick int64

	Cause RedstoneUpdateCause
}

type RedstoneUpdateCause uint8

type RedstoneWeakBlockPowerer interface {
	RedstoneWeaklyPowersBlocks() bool
}

type ScheduledTicker interface {
	ScheduledTick(pos cube.Pos, tx *Tx, r *rand.Rand)
}

type SetOpts struct {
	DisableBlockUpdates bool

	DisableLiquidDisplacement bool

	DisableRedstoneUpdates bool
}

type Settings struct {
	sync.Mutex

	Name string

	Spawn cube.Pos

	Time int64

	TimeCycle bool

	RainTime int64

	Raining bool

	ThunderTime int64

	Thundering bool

	WeatherCycle bool

	RequiredSleepTicks int64

	CurrentTick int64

	DefaultGameMode GameMode

	Difficulty Difficulty

	TickRange int32
	// contains filtered or unexported fields
}

type Sleeper interface {
	Entity

	Name() string
	UUID() uuid.UUID

	Messaget(t chat.Translation, a ...any)
	SendSleepingIndicator(sleeping, max int)

	Sleep(pos cube.Pos)
	Sleeping() (cube.Pos, bool)
	Wake()
}

type Sound interface {
	Play(w *World, pos mgl64.Vec3)
}

type SpawnEggHandler func(tx *Tx, pos cube.Pos) bool

type Structure interface {
	Dimensions() [3]int

	At(x, y, z int, blockAt func(x, y, z int) Block) (Block, Liquid)
}

type SubChunkPos [3]int32

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

type TickerBlock interface {
	NBTer
	Tick(currentTick int64, pos cube.Pos, tx *Tx)
}

type TickerEntity interface {
	Entity

	Tick(tx *Tx, current int64)
}

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

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

type ViewLayerUpdater interface {
	ViewLayerEntityChanged(entity Entity)
}

type Viewer interface {
	ViewEntity(e Entity)

	HideEntity(e Entity)

	ViewEntityGameMode(e Entity)

	ViewEntityMovement(e Entity, pos mgl64.Vec3, rot cube.Rotation, onGround bool)

	ViewEntityDisplacement(e Entity, pos mgl64.Vec3, rot cube.Rotation, onGround bool)

	ViewEntityVelocity(e Entity, vel mgl64.Vec3)

	ViewEntityTeleport(e Entity, pos mgl64.Vec3)

	ViewFurnaceUpdate(prevCookTime, cookTime, prevRemainingFuelTime, remainingFuelTime, prevMaxFuelTime, maxFuelTime time.Duration)

	ViewBrewingUpdate(prevBrewTime, brewTime time.Duration, prevFuelAmount, fuelAmount, prevFuelTotal, fuelTotal int32)

	ViewChunk(pos ChunkPos, dim Dimension, blockEntities map[cube.Pos]Block, c *chunk.Chunk)

	ViewTime(t int)

	ViewTimeCycle(doDayLightCycle bool)

	ViewEntityItems(e Entity)

	ViewEntityArmour(e Entity)

	ViewEntityAction(e Entity, a EntityAction)

	ViewEntityState(e Entity)

	ViewEntityAnimation(e Entity, a EntityAnimation)

	ViewParticle(pos mgl64.Vec3, p Particle)

	ViewSound(pos mgl64.Vec3, s Sound)

	ViewBlockUpdate(pos cube.Pos, b Block, layer int)

	ViewBlockAction(pos cube.Pos, a BlockAction)

	ViewEmote(e Entity, emote uuid.UUID)

	ViewSkin(e Entity)

	ViewWorldSpawn(pos cube.Pos)

	ViewWeather(raining, thunder bool)

	ViewEntityWake(e Entity)
}

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

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