options.go

package minecraft

import "vimagination.zapto.org/minecraft/nbt"

// Option is a function used to set an option for a minecraft level struct.
type Option func(*Level)

// GetLevelName sets the given string to the name of the minecraft level.
func (l *Level) GetLevelName() string {
	return string(l.levelData.Get("LevelName").Data().(nbt.String))
}

// LevelName sets the name of the minecraft level.
func (l *Level) LevelName(name string) {
	l.setOption("LevelName", nbt.String(name))
}

// Default minecraft generators
const (
	DefaultGenerator    = "default"
	FlatGenerator       = "flat"
	LargeBiomeGenerator = "largeBiomes"
	AmplifiedGenerator  = "amplified"
	CustomGenerator     = "customized"
	DebugGenerator      = "debug_all_block_states"
)

// Generator sets the generator type.
func (l *Level) Generator(generator string) {
	l.setOption("generatorName", nbt.String(generator))
}

// GeneratorOptions sets the generator options for a flat or custom generator. The syntax is not checked.
func (l *Level) GeneratorOptions(options string) {
	l.setOption("generatorOptions", nbt.String(options))
}

// Seed sets the random seed for the level.
func (l *Level) Seed(seed int64) {
	l.setOption("RandomSeed", nbt.Long(seed))
}

// MapFeatures enables/disables map feature generation (villages, strongholds, mineshafts, etc.).
func (l *Level) MapFeatures(mf bool) {
	l.setOption("MapFeatures", boolToByte(mf))
}

// AllowCommands enables/disables the cheat commands.
func (l *Level) AllowCommands(a bool) {
	l.setOption("allowCommands", boolToByte(a))
}

// Hardcore enables/disables hardcore mode.
func (l *Level) Hardcore(h bool) {
	l.setOption("hardcore", boolToByte(h))
}

// Game Modes Settings.
const (
	Survival int32 = iota
	Creative
	Adventure
	Spectator
)

// GameMode sets the game mode type.
func (l *Level) GameMode(gm int32) {
	l.setOption("GameType", nbt.Int(gm))
}

// Difficulty Settings.
const (
	Peaceful int8 = iota
	Easy
	Normal
	Hard
)

// Difficulty sets the level difficulty.
func (l *Level) Difficulty(d int8) {
	l.setOption("Difficulty", nbt.Byte(d))
}

// DifficultyLocked locks the difficulty in game.
func (l *Level) DifficultyLocked(dl bool) {
	l.setOption("DifficultyLocked", boolToByte(dl))
}

// TicksExisted sets how many ticks have passed in game.
func (l *Level) TicksExisted(t int64) {
	l.setOption("Time", nbt.Long(t))
}

// Time-of-day convenience constants.
const (
	SunRise  = 0
	Noon     = 6000
	SunSet   = 12000
	MidNight = 18000
	Day      = 24000
)

// Time sets the in world time.
func (l *Level) Time(t int64) {
	l.setOption("DayTime", nbt.Long(t))
}

// GetSpawn sets the given x, y, z coordinates to the current spawn point.
func (l *Level) GetSpawn() (x int32, y int32, z int32) {
	xTag, yTag, zTag := l.levelData.Get("SpawnX"), l.levelData.Get("SpawnY"), l.levelData.Get("SpawnZ")
	x = int32(xTag.Data().(nbt.Int))
	y = int32(yTag.Data().(nbt.Int))
	z = int32(zTag.Data().(nbt.Int))

	return x, y, z
}

// Spawn sets the spawn point to the given coordinates..
func (l *Level) Spawn(x, y, z int32) {
	l.levelData.Set(nbt.NewTag("SpawnX", nbt.Int(x)))
	l.levelData.Set(nbt.NewTag("SpawnY", nbt.Int(y)))
	l.levelData.Set(nbt.NewTag("SpawnZ", nbt.Int(z)))

	l.changed = true
}

// BorderCenter sets the position of the center of the World Border.
func (l *Level) BorderCenter(x, z float64) {
	l.levelData.Set(nbt.NewTag("BorderCenterX", nbt.Double(x)))
	l.levelData.Set(nbt.NewTag("BorderCenterZ", nbt.Double(z)))

	l.changed = true
}

// BorderSize sets the width of the border.
func (l *Level) BorderSize(w float64) {
	l.setOption("BorderSize", nbt.Double(w))
}

// Raining sets the rain on or off.
func (l *Level) Raining(raining bool) {
	l.setOption("raining", boolToByte(raining))
}

// RainTime sets the time until the rain state changes.
func (l *Level) RainTime(time int32) {
	l.setOption("rainTime", nbt.Int(time))
}

// Thundering sets the lightning/thunder on or off.
func (l *Level) Thundering(thundering bool) {
	l.setOption("thundering", boolToByte(thundering))
}

// ThunderTime sets the tune until the thunder state changes.
func (l *Level) ThunderTime(time int32) {
	l.setOption("thunderTime", nbt.Int(time))
}

// CommandBlockOutput enables/disables chat echo for command blocks.
func (l *Level) CommandBlockOutput(d bool) {
	l.setGameRule("commandBlockOutput", d)
}

// DayLightCycle enables/disables the day/night cycle.
func (l *Level) DayLightCycle(d bool) {
	l.setGameRule("doDaylightCycle", d)
}

// FireTick enables/disables fire updates, such as spreading and extinguishing.
func (l *Level) FireTick(d bool) {
	l.setGameRule("doFireTick", d)
}

// MobLoot enables/disable mob loot drops.
func (l *Level) MobLoot(d bool) {
	l.setGameRule("doMobLoot", d)
}

// MobSpawning enables/disables mob spawning.
func (l *Level) MobSpawning(d bool) {
	l.setGameRule("doMobSpawning", d)
}

// TileDrops enables/disables the dropping of items upon block breakage.
func (l *Level) TileDrops(d bool) {
	l.setGameRule("doTileDrops", d)
}

// KeepInventory enables/disables the keeping of a players inventory upon death.
func (l *Level) KeepInventory(d bool) {
	l.setGameRule("keepInventory", d)
}

// LogAdminCommands enables/disables the logging of admin commands to the log.
func (l *Level) LogAdminCommands(d bool) {
	l.setGameRule("logAdminCommands", d)
}

// MobGriefing enables/disables the ability of mobs to destroy blocks.
func (l *Level) MobGriefing(d bool) {
	l.setGameRule("mobGriefing", d)
}

// HealthRegeneration enables/disables the regeneration of the players health
// when their hunger is high enough.
func (l *Level) HealthRegeneration(d bool) {
	l.setGameRule("naturalRegeneration", d)
}

// CommandFeedback enables/disables the echo for player commands in the chat.
func (l *Level) CommandFeedback(d bool) {
	l.setGameRule("sendCommandFeedback", d)
}

// DeathMessages enables/disables the logging of player deaths to the chat.
func (l *Level) DeathMessages(d bool) {
	l.setGameRule("showDeathMessages", d)
}

func (l *Level) setOption(name string, data nbt.Data) {
	l.levelData.Set(nbt.NewTag(name, data))

	l.changed = true
}

func (l *Level) setGameRule(name string, data bool) {
	var grc nbt.Compound

	gr := l.levelData.Get("GameRules")

	if gr.TagID() != 0 {
		grc = gr.Data().(nbt.Compound)
	}

	if grc.Type() == 0 {
		l.levelData.Set(nbt.NewTag("GameRules", grc))
	}

	var d nbt.String

	if data {
		d = nbt.String("True")
	} else {
		d = nbt.String("False")
	}

	grc.Set(nbt.NewTag(name, d))

	l.changed = true
}

func boolToByte(b bool) nbt.Byte {
	if b {
		return nbt.Byte(1)
	}

	return nbt.Byte(0)
}