Adding modding folder with a hacked build.

2026-09-26 08:53:08 +02:00
parent cdb960dc71
commit c91080aba7
755 changed files with 50424 additions and 0 deletions
@@ -0,0 +1,119 @@
+package level
+
+// WallHeights describes the height delta, in HeightUnits, one would take to
+// cross to the other tile. A value of 0 means equal floor, a negative value a fall down.
+// A value of 0x20 (= maximum of height units) means a solid wall.
+//
+// For each cardinal direction, facing to the specified direction,
+// the first entry is the left side, the second the center, and the third the right side.
+type WallHeights struct {
+	North [3]float32
+	East  [3]float32
+	South [3]float32
+	West  [3]float32
+}
+
+// Reset sets all the heights to zero.
+func (heights *WallHeights) Reset() {
+	*heights = WallHeights{}
+}
+
+// WallHeightsMap is rectangular table of wall heights, typically mirroring a tile map.
+type WallHeightsMap [][]WallHeights
+
+// NewWallHeightsMap returns a new, initialized map.
+func NewWallHeightsMap(width, height int) WallHeightsMap {
+	m := make([][]WallHeights, height)
+	for y := 0; y < height; y++ {
+		m[y] = make([]WallHeights, width)
+		for x := 0; x < width; x++ {
+			m[y][x].Reset()
+		}
+	}
+	return m
+}
+
+// Tile returns a pointer to the tile within the map for given position.
+func (m WallHeightsMap) Tile(pos TilePosition) *WallHeights {
+	return &m[pos.Y][pos.X]
+}
+
+// CalculateFrom updates all the wall heights according to the specified map.
+func (m *WallHeightsMap) CalculateFrom(tileMap interface {
+	Tile(pos TilePosition) *TileMapEntry
+}) {
+	posAt := func(x, y int) TilePosition {
+		return TilePosition{X: byte(x), Y: byte(y)}
+	}
+	for y, row := range *m {
+		for x := 0; x < len(row); x++ {
+			tile := tileMap.Tile(posAt(x, y))
+			if tile == nil {
+				continue
+			}
+			heights := &row[x]
+			heights.North = calculateWallHeight(tile, DirNorth, tileMap.Tile(posAt(x, y+1)), DirSouth)
+			heights.East = calculateWallHeight(tile, DirEast, tileMap.Tile(posAt(x+1, y)), DirWest)
+			heights.South = calculateWallHeight(tile, DirSouth, tileMap.Tile(posAt(x, y-1)), DirNorth)
+			heights.West = calculateWallHeight(tile, DirWest, tileMap.Tile(posAt(x-1, y)), DirEast)
+		}
+	}
+}
+
+func calculateWallHeight(entry *TileMapEntry, entrySide Direction, other *TileMapEntry, otherSide Direction) [3]float32 {
+	var result [3]float32
+	baseHeights := func(tile *TileMapEntry, side Direction) (floor TileHeightUnit, slope TileHeightUnit, ceiling TileHeightUnit) {
+		floor = TileHeightUnitMax
+		slope = TileHeightUnitMin
+		ceiling = TileHeightUnitMax
+		if (tile != nil) && ((tile.Type.Info().SolidSides & side.AsMask()) == 0) {
+			floor = tile.Floor.AbsoluteHeight()
+			slope = tile.SlopeHeight
+			ceiling = tile.Ceiling.AbsoluteHeight()
+		}
+		return
+	}
+
+	otherFloorHeight, otherSlopeHeight, otherCeilingHeight := baseHeights(other, otherSide)
+	var otherFloorFactors SlopeFactors
+	var otherCeilingFactors SlopeFactors
+	if other != nil {
+		otherSlopeControl := other.Flags.SlopeControl()
+		otherFloorFactors = otherSlopeControl.FloorSlopeFactors(other.Type)
+		otherCeilingFactors = otherSlopeControl.CeilingSlopeFactors(other.Type)
+	}
+
+	entryFloorHeight, entrySlopeHeight, entryCeilingHeight := baseHeights(entry, entrySide)
+	entrySlopeControl := entry.Flags.SlopeControl()
+	entryFloorFactors := entrySlopeControl.FloorSlopeFactors(entry.Type)
+	entryCeilingFactors := entrySlopeControl.CeilingSlopeFactors(entry.Type)
+
+	sideHeights := func(side Direction, sideOffset int, factors SlopeFactors, slopeHeight TileHeightUnit, absoluteHeight TileHeightUnit) [3]float32 {
+		return [3]float32{
+			factors[side.Offset(-sideOffset)]*float32(slopeHeight) + float32(absoluteHeight),
+			factors[side.Offset(0)]*float32(slopeHeight) + float32(absoluteHeight),
+			factors[side.Offset(+sideOffset)]*float32(slopeHeight) + float32(absoluteHeight),
+		}
+	}
+	entryFloorSideHeights := sideHeights(entrySide, 1, entryFloorFactors, entrySlopeHeight, entryFloorHeight)
+	entryCeilingSideHeights := sideHeights(entrySide, 1, entryCeilingFactors.Negated(), entrySlopeHeight, entryCeilingHeight)
+	otherFloorSideHeights := sideHeights(otherSide, -1, otherFloorFactors, otherSlopeHeight, otherFloorHeight)
+	otherCeilingSideHeights := sideHeights(otherSide, -1, otherCeilingFactors.Negated(), otherSlopeHeight, otherCeilingHeight)
+
+	for i := 0; i < 3; i++ {
+		switch {
+		case (otherFloorSideHeights[i] == entryFloorSideHeights[i]) && (entryFloorSideHeights[i] == float32(TileHeightUnitMax)):
+			// shortcut for solid-to-solid - no "wall" to see here
+			result[i] = 0
+		case (otherFloorSideHeights[i] >= otherCeilingSideHeights[i]) || // other ceiling side seals off at its floor
+			(otherCeilingSideHeights[i] <= entryFloorSideHeights[i]) || // other ceiling side seals off at this floor
+			(otherFloorSideHeights[i] >= entryCeilingSideHeights[i]) || // other floor side seals off at this ceiling
+			(entryFloorSideHeights[i] >= entryCeilingSideHeights[i]): // own ceiling side seals off at floor
+			result[i] = float32(TileHeightUnitMax)
+		default:
+			result[i] = otherFloorSideHeights[i] - entryFloorSideHeights[i]
+		}
+	}
+
+	return result
+}