doodle/pkg/collision/collide_level.go

package collision

import (
	"sync"

	"git.kirsle.net/SketchyMaze/doodle/pkg/balance"
	"git.kirsle.net/SketchyMaze/doodle/pkg/level"
	"git.kirsle.net/go/render"
)

// Collide describes how a collision occurred.
type Collide struct {
	Top         bool
	TopPoint    render.Point
	TopPixel    *level.Swatch
	Left        bool
	LeftPoint   render.Point
	LeftPixel   *level.Swatch
	Right       bool
	RightPoint  render.Point
	RightPixel  *level.Swatch
	Bottom      bool
	BottomPoint render.Point
	BottomPixel *level.Swatch
	MoveTo      render.Point

	// Swatch attributes affecting the collision at this time.
	InFire     string // the name of the swatch, Fire = general ouchy color.
	InWater    bool
	IsSlippery bool
}

// Reset a Collide struct flipping all the bools off, but keeping MoveTo.
func (c *Collide) Reset() {
	c.Top = false
	c.Left = false
	c.Right = false
	c.Bottom = false
	c.InWater = false
}

// Side of the collision box (top, bottom, left, right)
type Side uint8

// Options for the Side type.
const (
	Top Side = iota
	Bottom
	Left
	Right
)

/*
CollidesWithGrid checks if a Doodad collides with level geometry.

The `target` is the point the actor wants to move to on this tick.

This function handles translation for doodads having an offset hitbox which doesn't begin
at the 0,0 coordinate on the X,Y axis.

For example:

  - The caller of this function cares about where on screen to display the actor's sprite at
    (the X,Y position of the top left corner of their sprite).
  - The target point is where the actor is moving on this tick, which is also relative to their
    current world coordinate (top corner of their sprite), NOT their hitbox coordinate.

The original collision detection code worked well when the actor's hitbox began at 0,0 as it
matched their world position. But when the hitbox is offset from the corner, collision detection
glitches abounded.

This function will compute the physical hitbox of the doodad regarding the level geometry
(simulating a simple doodad whose hitbox is a full 0,0,W,H) and translate the offset to and
from.
*/
func CollidesWithGrid(d Actor, grid *level.Chunker, target render.Point) (*Collide, bool) {
	var (
		actor     = NewActorOffset(d)
		offset    = actor.Offset()
		newTarget = render.Point{
			X: target.X + offset.X,
			Y: target.Y + offset.Y,
		}
	)

	collide, ok := BoxCollidesWithGrid(actor, grid, newTarget)

	// Undo the offset for the MoveTo target.
	collide.MoveTo.X -= offset.X
	collide.MoveTo.Y -= offset.Y

	return collide, ok
}

/*
BoxCollidesWithGrid handles the core logic for level collision checks.
*/
func BoxCollidesWithGrid(d Actor, grid *level.Chunker, target render.Point) (*Collide, bool) {
	var (
		P      = d.Position()
		S      = d.Size()
		hitbox = d.Hitbox()

		result = &Collide{
			MoveTo: P,
		}
		ceiling   bool // Has hit a ceiling?
		capHeight int  // Stop vertical movement thru a ceiling
		capLeft   int  // Stop movement thru a wall
		capRight  int
		capFloor  int  // Stop movement thru the floor
		hitLeft   bool // Has hit an obstacle on the left
		hitRight  bool // or right
		hitFloor  bool
	)

	// Adjust the actor's bounding rect by its stated Hitbox from its script.
	// e.g.: Boy's Canvas size is 56x56 but he is a narrower character with a
	// hitbox width smaller than its Canvas size.
	S = SizePlusHitbox(GetBoundingRect(d), hitbox)
	actorHeight := P.Y + S.H

	// Test if we are ALREADY colliding with level geometry and try and wiggle
	// free. ScanBoundingBox scans level pixels along the four edges of the
	// actor's hitbox in world space.
	if ok := result.ScanBoundingBox(GetBoundingRectHitbox(d, hitbox), grid); ok {
		// We've already collided! Try to wiggle free.
		if result.Bottom {
			if !d.Grounded() {
				d.SetGrounded(true)
			}
		} else {
			d.SetGrounded(false)
		}
		if result.Top {
			ceiling = true
			P.Y++
		}
		if result.Left && !result.LeftPixel.SemiSolid {
			P.X++
		}
		if result.Right && !result.RightPixel.SemiSolid {
			P.X--
		}
	}

	// If grounded, cap our Y position.
	if d.Grounded() {
		if !result.Bottom {
			// We've fallen off a ledge.
			d.SetGrounded(false)
		} else if target.Y < P.Y {
			// We're moving upward.
			d.SetGrounded(false)
		} else {
			// Cap our downward motion to our current position,
			// fighting the force of gravity.
			target.Y = P.Y
		}
	}

	// Cap our horizontal movement if we're touching walls.
	if (result.Left && target.X < P.X) || (result.Right && target.X > P.X) {
		// Handle walking up slopes, if the step is short enough.
		var slopeHeight int
		if result.Left {
			slopeHeight = result.LeftPoint.Y
		} else if result.Right {
			slopeHeight = result.RightPoint.Y
		}

		if offset, ok := CanStepUp(actorHeight, slopeHeight, target.X > P.X); ok {
			target.Add(offset)
		} else {
			// Not a slope.. may be a solid wall. If the wall is a SemiSolid though,
			// do not cap our direction just yet.
			if !(result.Left && result.LeftPixel.SemiSolid) && !(result.Right && result.RightPixel.SemiSolid) {
				target.X = P.X
			}
		}
	}

	// Cap our vertical movement if we're touching ceilings.
	if ceiling {
		// The existing box intersects a ceiling, this will almost never
		// happen because gravity will always pull you away at the last frame.
		// But if we do somehow get here, may as well cap it where it's at.
		capHeight = P.Y
	}

	// Trace a line from where we are to where we wanna go.
	result.Reset()
	result.MoveTo = P
	for point := range render.IterLine(P, target) {
		// Before we compute their next move, if we're already capping their
		// height make sure the new point stays capped too. This prevents them
		// clipping thru a ceiling if they were also holding right/left too.
		if capHeight != 0 && point.Y < capHeight {
			point.Y = capHeight
		}
		if capLeft != 0 && point.X < capLeft {
			// TODO: this along with a "+ 1" hack prevents clipping thru the
			// left wall sometimes, but breaks walking up leftward slopes.
			point.X = capLeft
		}
		if capRight != 0 && point.X > capRight {
			// This if check fixes the climbing-walls-on-the-right bug.
			point.X = capRight
		}

		if has := result.ScanBoundingBox(render.Rect{
			X: point.X,
			Y: point.Y,
			W: S.W,
			H: S.H,
		}, grid); has {
			if result.Bottom {
				if !hitFloor {
					hitFloor = true
					capFloor = result.BottomPoint.Y - S.H
				}
				d.SetGrounded(true)
			}

			if result.Top && !ceiling {
				// This is a newly discovered ceiling.
				ceiling = true
				capHeight = result.TopPoint.Y + 1
				// TODO: the "+ 1" helps prevent clip thru ceiling, probably.
				// Similar to the "+ 1" on the left side, below.
			}

			// TODO: this block of code is interesting. For SemiSolid slopes, the character
			// walks up the slopes FAST (full speed) which is nice; would like to do this
			// for regular solid slopes too. But if this block of code is dummied out for
			// solid walls, the player is able to clip thru thin walls (couple px thick); the
			// capLeft/capRight behavior is good at stopping the player here.

			// See if they have hit a solid wall on their left or right edge. If the wall
			// is short enough to step up, allow them to pass through.
			if result.Left && !hitLeft && !result.LeftPixel.SemiSolid {
				if _, ok := CanStepUp(actorHeight, result.LeftPoint.Y, false); !ok {
					hitLeft = true
					capLeft = result.LeftPoint.X
				}
			}
			if result.Right && !hitRight && !result.RightPixel.SemiSolid {
				if _, ok := CanStepUp(actorHeight, result.RightPoint.Y, false); !ok {
					hitRight = true
					capRight = result.RightPoint.X - S.W
				}
			}
		}

		// So far so good, keep following the MoveTo to
		// the last good point before a collision.
		result.MoveTo = point
	}

	// If they hit the roof, cap them to the roof.
	if ceiling && result.MoveTo.Y < capHeight {
		result.Top = true
		result.MoveTo.Y = capHeight
	}
	if hitFloor && result.MoveTo.Y > capFloor {
		result.Bottom = true
		result.MoveTo.Y = capFloor
	}
	if hitLeft && !result.LeftPixel.SemiSolid {
		result.Left = true
		result.MoveTo.X = capLeft
	}
	if hitRight && !result.RightPixel.SemiSolid {
		result.Right = true
		result.MoveTo.X = capRight
	}

	return result, result.IsColliding()
}

/*
CanStepUp checks whether the actor is moving left or right onto a gentle slope which
they can step on top of instead of being blocked by the solid wall.

* actorHeight is the actor's Y position + their hitbox height.
* slopeHeight is the Y position of the left or right edge of the level they collide with.
* moveRight is true if moving right, false if moving left.

If the actor can step up the slope, the return value is the Point of how to offset their
X,Y position to move up the slope and the boolean is whether they can step up.
*/
func CanStepUp(actorHeight, slopeHeight int, moveRight bool) (render.Point, bool) {
	var (
		height = actorHeight - slopeHeight
		target render.Point
	)

	if height <= balance.SlopeMaxHeight {
		target.Y -= height
		if moveRight {
			target.X++
		} else {
			target.X--
		}

		return target, true
	}

	return target, false
}

// IsColliding returns whether any sort of collision has occurred.
func (c *Collide) IsColliding() bool {
	return c.Top || c.Bottom || (c.Left && !c.LeftPixel.SemiSolid) || (c.Right && !c.RightPixel.SemiSolid) ||
		c.InFire != "" || c.InWater
}

// ScanBoundingBox scans all of the pixels in a bounding box on the grid and
// returns if any of them intersect with level geometry.
func (c *Collide) ScanBoundingBox(box render.Rect, grid *level.Chunker) bool {
	col := GetCollisionBox(box)

	// Check all four edges of the box in parallel on different CPU cores.
	type jobSide struct {
		p1   render.Point // p2 is perpendicular to p1 along a straight edge
		p2   render.Point // of the collision box.
		side Side
	}
	jobs := []jobSide{ // We'll scan each side of the bounding box in parallel
		{col.Top[0], col.Top[1], Top},
		{col.Bottom[0], col.Bottom[1], Bottom},
		{col.Left[0], col.Left[1], Left},
		{col.Right[0], col.Right[1], Right},
	}

	var wg sync.WaitGroup
	for _, job := range jobs {
		wg.Add(1)
		job := job
		go func() {
			defer wg.Done()
			c.ScanGridLine(job.p1, job.p2, grid, job.side)
		}()
	}

	wg.Wait()
	return c.IsColliding()
}

// ScanGridLine scans all of the pixels between p1 and p2 on the grid and tests
// for any pixels to be set, implying a collision between level geometry and the
// bounding boxes of the doodad.
func (c *Collide) ScanGridLine(p1, p2 render.Point, grid *level.Chunker, side Side) {
	// If scanning the top or bottom line, offset the X coordinate by 1 pixel.
	// This is because the 4 corners of the bounding box share their corner
	// pixel with each side, so the Left and Right edges will check the
	// left- and right-most point.
	if side == Top || side == Bottom {
		p1.X++
		p2.X--
	}

	for point := range render.IterLine(p1, p2) {
		if swatch, err := grid.Get(point); err == nil {
			// We're intersecting a pixel! If it's a solid one we'll return it
			// in our result. If non-solid, we'll collect attributes from it
			// and return them in the final result for gameplay behavior.
			if swatch.Fire {
				c.InFire = swatch.Name
			}
			if swatch.Water {
				c.InWater = true
			}

			// Slippery floor?
			if side == Bottom && swatch.Slippery {
				c.IsSlippery = true
			}

			// Non-solid swatches don't collide so don't pay them attention.
			if !swatch.Solid && !swatch.SemiSolid {
				continue
			}

			// A semisolid only has collision on the bottom (and a little on the
			// sides, for slope walking only)
			if swatch.SemiSolid && side == Top {
				continue
			}

			switch side {
			case Top:
				c.Top = true
				c.TopPoint = point
				c.TopPixel = swatch
			case Bottom:
				c.Bottom = true
				c.BottomPoint = point
				c.BottomPixel = swatch
			case Left:
				c.Left = true
				c.LeftPoint = point
				c.LeftPixel = swatch
			case Right:
				c.Right = true
				c.RightPoint = point
				c.RightPixel = swatch
			}
		}
	}
}