minecraft - level.go

  package minecraft
  
  import (
  	"math/rand"
  	"time"
  
  	"vimagination.zapto.org/boolmap"
  	"vimagination.zapto.org/minecraft/nbt"
  )
  
  var levelRequired = map[string]nbt.TagID{
  	"LevelName": nbt.TagString,
  	"SpawnX":    nbt.TagInt,
  	"SpawnY":    nbt.TagInt,
  	"SpawnZ":    nbt.TagInt,
  }
  
  // Level is the base type for minecraft data, all data for a minecraft level is
  // either store in, or accessed from, this type.
  type Level struct {
  	path      Path
  	chunks    map[uint64]*chunk
  	levelData nbt.Compound
  	changed   bool
  }
  
  // NewLevel creates/Loads a minecraft level from the given path.
  func NewLevel(location Path) (*Level, error) {
  	var (
  		levelDat nbt.Tag
  		data     nbt.Compound
  		changed  bool
  	)
  
  	levelDat, err := location.ReadLevelDat()
  	if err != nil {
  		return nil, err
  	} else if levelDat.TagID() == 0 {
  		levelDat = nbt.NewTag("", nbt.Compound{
  			nbt.NewTag("Data", nbt.Compound{
  				nbt.NewTag("version", nbt.Int(19133)),
  				nbt.NewTag("initialized", nbt.Byte(0)),
  				nbt.NewTag("LevelName", nbt.String("")),
  				nbt.NewTag("generatorName", nbt.String(DefaultGenerator)),
  				nbt.NewTag("generatorVersion", nbt.Int(0)),
  				nbt.NewTag("generatorOptions", nbt.String("0")),
  				nbt.NewTag("RandomSeed", nbt.Long(rand.New(rand.NewSource(time.Now().Unix())).Int63())),
  				nbt.NewTag("MapFeatures", nbt.Byte(1)),
  				nbt.NewTag("LastPlayed", nbt.Long(time.Now().Unix()*1000)),
  				nbt.NewTag("SizeOnDisk", nbt.Long(0)),
  				nbt.NewTag("allowCommands", nbt.Byte(0)),
  				nbt.NewTag("hardcore", nbt.Byte(0)),
  				nbt.NewTag("GameType", nbt.Int(Survival)),
  				nbt.NewTag("Time", nbt.Long(0)),
  				nbt.NewTag("DayTime", nbt.Long(0)),
  				nbt.NewTag("SpawnX", nbt.Int(0)),
  				nbt.NewTag("SpawnY", nbt.Int(0)),
  				nbt.NewTag("SpawnZ", nbt.Int(0)),
  				nbt.NewTag("BorderCenterX", nbt.Double(0)),
  				nbt.NewTag("BorderCenterZ", nbt.Double(0)),
  				nbt.NewTag("BorderSize", nbt.Double(60000000)),
  				nbt.NewTag("BorderSafeZone", nbt.Double(5)),
  				nbt.NewTag("BorderWarningTime", nbt.Double(15)),
  				nbt.NewTag("BorderSizeLerpTarget", nbt.Double(60000000)),
  				nbt.NewTag("BorderSizeLerpTime", nbt.Long(0)),
  				nbt.NewTag("BorderDamagePerBlock", nbt.Double(0.2)),
  				nbt.NewTag("raining", nbt.Byte(0)),
  				nbt.NewTag("rainTime", nbt.Int(0)),
  				nbt.NewTag("thundering", nbt.Byte(0)),
  				nbt.NewTag("thunderTime", nbt.Int(0)),
  				nbt.NewTag("clearWeatherTime", nbt.Int(0)),
  				nbt.NewTag("GameRules", nbt.Compound{
  					nbt.NewTag("commandBlockOutput", nbt.String("True")),
  					nbt.NewTag("doDaylightCycle", nbt.String("True")),
  					nbt.NewTag("doFireTick", nbt.String("True")),
  					nbt.NewTag("doMobLoot", nbt.String("True")),
  					nbt.NewTag("doMobSpawning", nbt.String("True")),
  					nbt.NewTag("doTileDrops", nbt.String("True")),
  					nbt.NewTag("keepInventory", nbt.String("False")),
  					nbt.NewTag("logAdminCommands", nbt.String("True")),
  					nbt.NewTag("mobGriefing", nbt.String("True")),
  					nbt.NewTag("naturalRegeneration", nbt.String("True")),
  					nbt.NewTag("randomTickSpeed", nbt.String("3")),
  					nbt.NewTag("sendCommandFeedback", nbt.String("True")),
  					nbt.NewTag("showDeathMessages", nbt.String("True")),
  				}),
  			}),
  		})
  
  		changed = true
  	}
  
  	if levelDat.TagID() != nbt.TagCompound {
  		return nil, WrongTypeError{"[BASE]", nbt.TagCompound, levelDat.TagID()}
  	} else if d := levelDat.Data().(nbt.Compound).Get("Data"); d.TagID() != 0 {
  		if d.TagID() == nbt.TagCompound {
  			data = d.Data().(nbt.Compound)
  		} else {
  			return nil, WrongTypeError{"Data", nbt.TagCompound, d.TagID()}
  		}
  	} else {
  		return nil, MissingTagError{"Data"}
  	}
  
  	for name, tagType := range levelRequired {
  		if x := data.Get(name); x.TagID() == 0 {
  			return nil, MissingTagError{name}
  		} else if x.TagID() != tagType {
  			return nil, WrongTypeError{name, tagType, x.TagID()}
  		}
  	}
  
  	return &Level{
  		location,
  		make(map[uint64]*chunk),
  		levelDat.Data().(nbt.Compound).Get("Data").Data().(nbt.Compound),
  		changed,
  	}, nil
  }
  
  // GetBlock gets the block at coordinates x, y, z.
  func (l *Level) GetBlock(x, y, z int32) (Block, error) {
  	if y < 0 {
  		return Block{}, nil
  	}
  
  	c, err := l.getChunk(x, z, false)
  	if err != nil {
  		return Block{}, err
  	} else if c == nil {
  		return Block{}, nil
  	}
  
  	return c.GetBlock(x, y, z), nil
  }
  
  // SetBlock sets the block at coordinates x, y, z. Also processes any lighting updates if applicable.
  func (l *Level) SetBlock(x, y, z int32, block Block) error {
  	if y < 0 {
  		y = 0
  	}
  
  	var (
  		c   *chunk
  		err error
  	)
  
  	for mx := x - 1; mx <= x+1; mx++ {
  		for mz := z - 1; mz <= z+1; mz++ {
  			if c, err = l.getChunk(mx, mz, true); err != nil {
  				return err
  			}
  
  			for my := y + 16; my >= 0; my -= 16 {
  				if c.createSection(my) {
  					break
  				}
  			}
  		}
  	}
  
  	c, _ = l.getChunk(x, z, false)
  	opacity := c.GetOpacity(x, y, z)
  
  	c.SetBlock(x, y, z, block)
  
  	if block.Opacity() != opacity {
  		if err = l.genLighting(x, y, z, true, block.Opacity() > opacity, 0); err != nil {
  			return err
  		}
  	}
  
  	if bl := c.GetBlockLight(x, y, z); block.Light() != bl || block.Opacity() != opacity {
  		if err = l.genLighting(x, y, z, false, block.Light() < bl, block.Light()); err != nil {
  			return err
  		}
  	}
  
  	return nil
  }
  
  type lightCoords struct {
  	x, y, z    int32
  	lightLevel uint8
  }
  
  func (l *Level) genLighting(x, y, z int32, skyLight, darker bool, source uint8) error {
  	var (
  		getLight func(*chunk, int32, int32, int32) uint8
  		setLight func(*chunk, int32, int32, int32, uint8)
  	)
  
  	if skyLight {
  		getLight = (*chunk).GetSkyLight
  		setLight = (*chunk).SetSkyLight
  	} else {
  		getLight = (*chunk).GetBlockLight
  		setLight = (*chunk).SetBlockLight
  	}
  
  	c, err := l.getChunk(x, z, false)
  	if err != nil {
  		return err
  	} else if c == nil {
  		return nil
  	}
  
  	list := make([]*lightCoords, 1)
  	list[0] = &lightCoords{x, y, z, getLight(c, x, y, z)}
  	changed := boolmap.NewMap()
  
  	changed.SetBool((uint64(y)<<10)|(uint64(z&31)<<5)|uint64(x&31), true)
  
  	if darker { // reset lighting on all blocks affected by the changed one (only applies if darker)
  		setLight(c, x, y, z, 0)
  
  		for i := 0; i < len(list); i++ {
  			for _, s := range surroundingBlocks(list[i].x, list[i].y, list[i].z) {
  				mx, my, mz := s[0], s[1], s[2]
  				pos := (uint64(my) << 10) | (uint64(mz&31) << 5) | uint64(mx&31)
  
  				if changed.GetBool(pos) {
  					continue
  				}
  
  				if c, err = l.getChunk(mx, mz, false); err != nil {
  					return err
  				} else if c == nil {
  					continue
  				} else if ys := my >> 4; my < 16 && c.sections[ys] == nil {
  					changed.SetBool(pos, true)
  
  					continue
  				}
  
  				shouldBe := list[i].lightLevel
  				opacity := c.GetOpacity(mx, my, mz)
  
  				if opacity > shouldBe {
  					shouldBe = 0
  				} else {
  					shouldBe -= opacity
  				}
  
  				if thisLight := getLight(c, mx, my, mz); thisLight == shouldBe && shouldBe != 0 || (skyLight && thisLight == 15 && my < c.GetHeight(mx, mz)) {
  					list = append(list, &lightCoords{mx, my, mz, thisLight})
  
  					changed.SetBool(pos, true)
  
  					if thisLight > 0 {
  						setLight(c, mx, my, mz, 0)
  					}
  				}
  			}
  		}
  	} // end lighting reset
  
  	if source > 0 { // If this is the source of light
  		c, _ = l.getChunk(x, z, false)
  		list = list[1:]
  
  		c.SetBlockLight(x, y, z, source)
  
  		for _, s := range surroundingBlocks(x, y, z) {
  			mx, my, mz := s[0], s[1], s[2]
  			pos := (uint64(my) << 10) | (uint64(mz&31) << 5) | uint64(mx&31)
  
  			if changed.GetBool(pos) {
  				continue
  			}
  
  			if c, err = l.getChunk(mx, mz, false); err != nil {
  				return err
  			} else if c == nil {
  				continue
  			} else if ys := my >> 4; my < 16 && c.sections[ys] == nil {
  				changed.SetBool(pos, true)
  
  				continue
  			}
  
  			if thisLight := getLight(c, mx, my, mz); thisLight < source {
  				list = append(list, &lightCoords{mx, my, mz, thisLight})
  
  				changed.SetBool(pos, true)
  			}
  		}
  	}
  
  	for ; len(list) > 0; list = list[1:] {
  		mx, my, mz := list[0].x, list[0].y, list[0].z
  		newLight := uint8(0)
  		c, _ = l.getChunk(mx, mz, false)
  
  		changed.SetBool((uint64(my)<<10)|(uint64(mz&31)<<5)|uint64(mx&31), false)
  
  		if skyLight && my >= c.GetHeight(mx, mz) { // Determine correct light level...
  			newLight = 15
  		} else if opacity := c.GetOpacity(mx, my, mz); opacity == 15 {
  			newLight = 0
  		} else {
  			var d *chunk
  
  			for _, s := range surroundingBlocks(mx, my, mz) {
  				nx, ny, nz := s[0], s[1], s[2]
  
  				if d, err = l.getChunk(nx, nz, false); err != nil {
  					return err
  				} else if d == nil {
  					continue
  				}
  
  				curr := getLight(d, nx, ny, nz)
  				if curr < opacity {
  					continue
  				}
  
  				curr -= opacity
  				if curr > newLight {
  					newLight = curr
  				}
  			}
  		} // ...end determining light level
  
  		setLight(c, mx, my, mz, newLight)
  
  		if newLight > list[0].lightLevel || (darker && newLight == list[0].lightLevel) {
  			for _, s := range surroundingBlocks(mx, my, mz) {
  				mx, my, mz = s[0], s[1], s[2]
  				pos := (uint64(my) << 10) | (uint64(mz&31) << 5) | uint64(mx&31)
  
  				if changed.GetBool(pos) {
  					continue
  				}
  
  				if c, err = l.getChunk(mx, mz, false); err != nil {
  					return err
  				} else if c == nil {
  					continue
  				} else if ys := my >> 4; ys < 16 && c.sections[ys] == nil {
  					changed.SetBool(pos, true)
  
  					continue
  				}
  
  				if thisLight := getLight(c, mx, my, mz); thisLight < newLight {
  					list = append(list, &lightCoords{mx, my, mz, thisLight})
  
  					changed.SetBool(pos, true)
  				}
  			}
  		}
  	}
  
  	return nil
  }
  
  // GetBiome returns the biome for the column x, z.
  func (l *Level) GetBiome(x, z int32) (Biome, error) {
  	c, err := l.getChunk(x, z, false)
  	if err != nil {
  		return AutoBiome, err
  	} else if c == nil {
  		return Plains, nil
  	}
  
  	return c.GetBiome(x, z), nil
  }
  
  // SetBiome sets the biome for the column x, z.
  func (l *Level) SetBiome(x, z int32, biome Biome) error {
  	c, err := l.getChunk(x, z, true)
  	if err != nil {
  		return err
  	}
  
  	c.SetBiome(x, z, biome)
  
  	return nil
  }
  
  // GetHeight returns the y coordinate for the highest non-transparent block at column x, z.
  func (l *Level) GetHeight(x, z int32) (int32, error) {
  	c, err := l.getChunk(x, z, false)
  	if err != nil || c == nil {
  		return 0, err
  	}
  
  	return c.GetHeight(x, z), nil
  }
  
  func (l *Level) getChunk(x, z int32, create bool) (*chunk, error) {
  	x >>= 4
  	z >>= 4
  	pos := uint64(z)<<32 | uint64(uint32(x))
  
  	if l.chunks[pos] == nil {
  		chunkData, err := l.path.GetChunk(x, z)
  		if err != nil {
  			return nil, err
  		}
  
  		if chunkData.TagID() != 0 {
  			chunk, err := newChunk(x, z, chunkData)
  			if err != nil {
  				return nil, err
  			}
  
  			l.chunks[pos] = chunk
  		} else if create {
  			l.chunks[pos], _ = newChunk(x, z, nbt.Tag{})
  		}
  	}
  
  	return l.chunks[pos], nil
  }
  
  // Save saves all open chunks, but does not close them.
  func (l *Level) Save() error {
  	if l.changed {
  		if err := l.path.WriteLevelDat(nbt.NewTag("", nbt.Compound{nbt.NewTag("Data", l.levelData)})); err != nil {
  			return err
  		}
  
  		l.changed = false
  	}
  
  	toSave := make([]nbt.Tag, 0, len(l.chunks))
  
  	for _, c := range l.chunks {
  		toSave = append(toSave, c.GetNBT())
  	}
  
  	if len(toSave) > 0 {
  		return l.path.SetChunk(toSave...) // check multi-error
  	}
  
  	return nil
  }
  
  // Close closes all open chunks, but does not save them.
  func (l *Level) Close() {
  	l.changed = false
  	l.chunks = make(map[uint64]*chunk)
  }
  
  func surroundingBlocks(x, y, z int32) [][3]int32 {
  	sB := [6][3]int32{
  		{x, y - 1, z},
  		{x - 1, y, z},
  		{x + 1, y, z},
  		{x, y, z - 1},
  		{x, y, z + 1},
  		{x, y + 1, z},
  	}
  
  	if y == 0 {
  		return sB[1:]
  	}
  
  	if y == 255 {
  		return sB[:5]
  	}
  
  	return sB[:]
  }