up3

server/world/weather.go

@@ -0,0 +1,261 @@
+package world
+
+import (
+	"time"
+
+	"github.com/df-mc/dragonfly/server/block/cube"
+	"github.com/go-gl/mathgl/mgl64"
+)
+
+// weather implements weather related methods for World. World embeds this
+// struct, so any exported methods on weather are exported methods on World.
+type weather struct{ w *World }
+
+// StopWeatherCycle disables weather cycle of the World.
+func (w weather) StopWeatherCycle() {
+	w.enableWeatherCycle(false)
+}
+
+// StartWeatherCycle enables weather cycle of the World.
+func (w weather) StartWeatherCycle() {
+	w.enableWeatherCycle(true)
+}
+
+// snowingAt checks if it is snowing at a specific cube.Pos in the World. True
+// is returned if the temperature in the Biome at that position is sufficiently
+// low, if it is raining and if it's above the top-most obstructing block.
+func (w weather) snowingAt(pos cube.Pos) bool {
+	if w.w == nil || !w.w.Dimension().WeatherCycle() {
+		return false
+	}
+	if b := w.w.biome(pos); b.Rainfall() == 0 || w.w.temperature(pos) > 0.15 {
+		return false
+	}
+	w.w.set.Lock()
+	raining := w.w.set.Raining
+	w.w.set.Unlock()
+	return raining && w.w.highestObstructingBlock(pos[0], pos[2]) < pos[1]
+}
+
+// rainingAt checks if it is raining at a specific cube.Pos in the World. True
+// is returned if it is raining, if the temperature is high enough in the biome
+// for it not to be snow and if the block is above the top-most obstructing
+// block.
+func (w weather) rainingAt(pos cube.Pos) bool {
+	if w.w == nil || !w.w.Dimension().WeatherCycle() {
+		return false
+	}
+	if b := w.w.biome(pos); b.Rainfall() == 0 || w.w.temperature(pos) <= 0.15 {
+		return false
+	}
+	w.w.set.Lock()
+	a := w.w.set.Raining
+	w.w.set.Unlock()
+	return a && w.w.highestObstructingBlock(pos[0], pos[2]) < pos[1]
+}
+
+// thunderingAt checks if it is thundering at a specific cube.Pos in the World.
+// True is returned if rainingAt returns true and if it is thundering in the
+// world.
+func (w weather) thunderingAt(pos cube.Pos) bool {
+	raining := w.rainingAt(pos)
+	w.w.set.Lock()
+	a := w.w.set.Thundering && raining
+	w.w.set.Unlock()
+	return a && w.w.highestObstructingBlock(pos[0], pos[2]) < pos[1]
+}
+
+// raining checks if it is raining anywhere in the World.
+func (w weather) raining() bool {
+	if w.w == nil || !w.w.Dimension().WeatherCycle() {
+		return false
+	}
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+	return w.w.set.Raining
+}
+
+// thundering checks if it is thundering anywhere in the World.
+func (w weather) thundering() bool {
+	if w.w == nil || !w.w.Dimension().WeatherCycle() {
+		return false
+	}
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+	return w.w.set.Thundering
+}
+
+// StartRaining makes it rain in the World. The time.Duration passed will
+// determine how long it will rain.
+func (w weather) StartRaining(dur time.Duration) {
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+	w.setRaining(true, dur)
+}
+
+// StopRaining makes it stop raining in the World.
+func (w weather) StopRaining() {
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+
+	if w.w.set.Raining {
+		w.setRaining(false, time.Second*(time.Duration(w.w.r.IntN(8400)+600)))
+		if w.w.set.Thundering {
+			// Also reset thunder if it was previously thundering.
+			w.setThunder(false, time.Second*(time.Duration(w.w.r.IntN(8400)+600)))
+		}
+	}
+}
+
+// StartThundering makes it thunder in the World. The time.Duration passed will
+// determine how long it will thunder. StartThundering will also make it rain
+// if it wasn't already raining. In this case the rain will, like the thunder,
+// last for the time.Duration passed.
+func (w weather) StartThundering(dur time.Duration) {
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+
+	w.setThunder(true, dur)
+	w.setRaining(true, dur)
+}
+
+// StopThundering makes it stop thundering in the current world.
+func (w weather) StopThundering() {
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+	if w.w.set.Thundering && w.w.set.Raining {
+		w.setThunder(false, time.Second*(time.Duration(w.w.r.IntN(8400)+600)))
+	}
+}
+
+// advanceWeather advances the weather counters of the World. Rain and thunder
+// are stopped/started when the rain and thunder times reach 0.
+func (w weather) advanceWeather() {
+	w.w.set.RainTime--
+	w.w.set.ThunderTime--
+
+	if w.w.set.RainTime <= 0 {
+		// Wiki: The rain counter counts down to zero, and each time it reaches
+		// zero, the rain is toggled on or off. When the rain is turned on, the
+		// counter is reset to a value between 12,000-23,999 ticks (0.5-1 game
+		// days) and when the rain is turned off it is reset to a value of
+		// 12,000-179,999 ticks (0.5-7.5 game days).
+		if w.w.set.Raining {
+			w.w.setRaining(false, time.Second*(time.Duration(w.w.r.IntN(8400)+600)))
+		} else {
+			w.w.setRaining(true, time.Second*time.Duration(w.w.r.IntN(600)+600))
+		}
+	}
+	if w.w.set.ThunderTime <= 0 {
+		// Wiki: the thunder counter toggles thunder on/off when it reaches
+		// zero, but clear weather overrides the "on" state. When thunder is
+		// turned on, the thunder counter is reset to 3,600-15,999 ticks (3-13
+		// minutes), and when thunder is turned off the counter rests to
+		// 12,000-179,999 ticks (0.5-7.5 days).
+		if w.w.set.Thundering {
+			w.w.setThunder(false, time.Second*(time.Duration(w.w.r.IntN(8400)+600)))
+		} else {
+			w.w.setThunder(true, time.Second*time.Duration(w.w.r.IntN(620)+180))
+		}
+	}
+}
+
+// setRaining toggles raining depending on the raining argument. This does not
+// lock the world mutex as opposed to StartRaining and StopRaining.
+func (w weather) setRaining(raining bool, x time.Duration) {
+	w.w.set.Raining = raining
+	w.w.set.RainTime = int64(x.Seconds() * 20)
+}
+
+// setThunder toggles thundering depending on the thundering argument. This
+// does not lock the world mutex as opposed to StartThundering and
+// StopThundering.
+func (w weather) setThunder(thundering bool, x time.Duration) {
+	w.w.set.Thundering = thundering
+	w.w.set.ThunderTime = int64(x.Seconds() * 20)
+}
+
+// enableWeatherCycle either enables or disables the weather cycle of the World.
+func (w weather) enableWeatherCycle(v bool) {
+	if w.w == nil {
+		return
+	}
+	w.w.set.Lock()
+	defer w.w.set.Unlock()
+	w.w.set.WeatherCycle = v
+}
+
+// tickLightning iterates over all loaded chunks in the World, striking
+// lightning in each one with a 1/100,000 chance.
+func (w weather) tickLightning(tx *Tx) {
+	positions := make([]ChunkPos, 0, len(w.w.chunks)/100000)
+	for pos := range w.w.chunks {
+		// Wiki: For each loaded chunk, every tick there is a 1⁄100,000 chance
+		// of an attempted lightning strike during a thunderstorm
+		if w.w.r.IntN(100000) == 0 {
+			positions = append(positions, pos)
+		}
+	}
+
+	for _, pos := range positions {
+		w.w.strikeLightning(tx, pos)
+	}
+}
+
+// strikeLightning attempts to strike lightning in the world at a specific
+// ChunkPos. The final position is influenced by living entities that might be
+// near the lightning strike. If there is no rain at the final position
+// selected, the lightning strike will fail.
+func (w weather) strikeLightning(tx *Tx, c ChunkPos) {
+	if w.w.conf.Entities.conf.Lightning == nil {
+		return
+	}
+	if pos := w.lightningPosition(tx, c); tx.ThunderingAt(cube.PosFromVec3(pos)) {
+		tx.AddEntity(w.w.conf.Entities.conf.Lightning(EntitySpawnOpts{Position: pos}))
+	}
+}
+
+// lightningPosition finds a random position in the ChunkPos to strike
+// lightning and adjusts the position to any of the living entities found in or
+// above the position if any are found.
+func (w weather) lightningPosition(tx *Tx, c ChunkPos) mgl64.Vec3 {
+	v := w.w.r.Int32()
+	x, z := float64(c[0]<<4+(v&0xf)), float64(c[1]<<4+((v>>8)&0xf))
+
+	vec := w.adjustPositionToEntities(tx, mgl64.Vec3{x, float64(tx.HighestBlock(int(x), int(z)) + 1), z})
+	if pos := cube.PosFromVec3(vec); len(tx.Block(pos).Model().BBox(pos, tx)) != 0 {
+		// If lightning is about to strike inside a block that is not fully
+		// transparent. In this case, move the lightning up by one block so that
+		// it strikes above the block.
+		return vec.Add(mgl64.Vec3{0, 1})
+	}
+	return vec
+}
+
+// adjustPositionToEntities adjusts the mgl64.Vec3 passed to the position of
+// any Entity found in the 3x3 column upwards from the mgl64.Vec3. If multiple
+// entities are found, the position of one of the entities is selected
+// randomly.
+func (w weather) adjustPositionToEntities(tx *Tx, vec mgl64.Vec3) mgl64.Vec3 {
+	max := vec.Add(mgl64.Vec3{0, float64(w.w.Range().Max())})
+
+	list := make([]mgl64.Vec3, 0, 16)
+	for e := range tx.EntitiesWithin(cube.Box(vec[0], vec[1], vec[2], max[0], max[1], max[2]).GrowVec3(mgl64.Vec3{3, 3, 3})) {
+		if h, ok := e.(interface{ Health() float64 }); ok && h.Health() > 0 {
+			// Any (living) entity that is positioned higher than the highest
+			// block at its position is eligible to be struck by lightning. We
+			// first save all entity positions where this is the case.
+			pos := cube.PosFromVec3(e.Position())
+			if tx.HighestBlock(pos[0], pos[1]) < pos[2] {
+				list = append(list, e.Position())
+			}
+		}
+	}
+	// We then select one of the positions of entities higher than the highest
+	// block and adjust the position of the lightning to it, so that the entity
+	// is struck directly.
+	if len(list) > 0 {
+		vec = list[w.w.r.IntN(len(list))]
+	}
+	return vec
+}