SketchyMaze/doodle
SketchyMaze/doodle
1
0
Fork 0
Code Issues 41 Pull Requests 1 Releases Wiki Activity

Compare commits

base: SketchyMaze:actor-collision
Branches Tags
SketchyMaze:master
SketchyMaze:actor-collision
SketchyMaze:zoom-hell
SketchyMaze:loading-screen
SketchyMaze:modals
SketchyMaze:physics
SketchyMaze:stash-ui-rework
SketchyMaze:bitmap-cache
SketchyMaze:chunks
..
compare: SketchyMaze:master
Branches Tags
SketchyMaze:actor-collision
SketchyMaze:master
SketchyMaze:zoom-hell
SketchyMaze:loading-screen
SketchyMaze:modals
SketchyMaze:physics
SketchyMaze:stash-ui-rework
SketchyMaze:bitmap-cache
SketchyMaze:chunks

No commits in common. "actor-collision" and "master" have entirely different histories.
actor-coll ... master

6 changed files with 76 additions and 192 deletions
Show Stats Expand all files Collapse all files

3
pkg/balance/numbers.go
View File

@ -57,9 +57,6 @@ var (
CoyoteFrames uint64 = 4 // Coyote time, frames after we walk off a cliff but can still jump late CoyoteFrames uint64 = 4 // Coyote time, frames after we walk off a cliff but can still jump late
SlopeMaxHeight = 8 // max pixel height for player to walk up a slope SlopeMaxHeight = 8 // max pixel height for player to walk up a slope
// Collision detection threshold to consider an actor "on top" of a doodad's solid hitbox.
OnTopThreshold = 4
// Number of game ticks to insist the canvas follows the player at the start // Number of game ticks to insist the canvas follows the player at the start
// of a level - to overcome Anvils settling into their starting positions so // of a level - to overcome Anvils settling into their starting positions so
// they don't steal the camera focus straight away. // they don't steal the camera focus straight away.

4
pkg/collision/bounding_rect.go
View File

@ -24,9 +24,7 @@ func GetBoundingRect(a Actor) render.Rect {
// account their self-declared collision hitbox. // account their self-declared collision hitbox.
// //
// The rect returned has the X,Y coordinate set to the actor's position, plus // The rect returned has the X,Y coordinate set to the actor's position, plus
// the X,Y of their hitbox, if any. For example, their sprite size could be 64x32 // the X,Y of their hitbox, if any.
// and their hitbox is the lower 0,32,32,32 half. This function would return the
// world coordinate of where their bounding box begins.
// //
// The W,H of the rect is the W,H of their declared hitbox. // The W,H of the rect is the W,H of their declared hitbox.
// //

2
pkg/collision/collide_level.go
View File

@ -117,7 +117,7 @@ func BoxCollidesWithGrid(d Actor, grid *level.Chunker, target render.Point) (*Co
// Adjust the actor's bounding rect by its stated Hitbox from its script. // 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 // e.g.: Boy's Canvas size is 56x56 but he is a narrower character with a
// hitbox width smaller than its Canvas size. // hitbox width smaller than its Canvas size.
S = GetBoundingRectHitbox(d, hitbox) S = SizePlusHitbox(GetBoundingRect(d), hitbox)
actorHeight := P.Y + S.H actorHeight := P.Y + S.H
// Test if we are ALREADY colliding with level geometry and try and wiggle // Test if we are ALREADY colliding with level geometry and try and wiggle

7
pkg/fps.go
View File

@ -158,12 +158,13 @@ func (d *Doodle) DrawCollisionBox(canvas *uix.Canvas, actor *uix.Actor) {
} }
var ( var (
rect = collision.GetBoundingRect(actor) rect = collision.GetBoundingRect(actor)
box = collision.GetCollisionBox(rect) box = collision.GetCollisionBox(rect)
hitbox = actor.Hitbox()
) )
// Adjust the actor's bounding rect by its stated Hitbox from its script. // Adjust the actor's bounding rect by its stated Hitbox from its script.
rect = collision.GetBoundingRectHitbox(actor, actor.Hitbox()) rect = collision.SizePlusHitbox(rect, hitbox)
box = collision.GetCollisionBox(rect) box = collision.GetCollisionBox(rect)

250
pkg/uix/actor_collision.go
View File

@ -31,7 +31,6 @@ func (w *Canvas) loopActorCollision() error {
// collision later, store each actor's original position before the move. // collision later, store each actor's original position before the move.
boxes = make([]render.Rect, len(w.actors)) boxes = make([]render.Rect, len(w.actors))
originalPositions = map[string]render.Point{} originalPositions = map[string]render.Point{}
originalHitboxes = map[string]render.Rect{} // original world hitboxes
) )
// Loop over all the actors in parallel, processing their movement and // Loop over all the actors in parallel, processing their movement and
@ -49,10 +48,8 @@ func (w *Canvas) loopActorCollision() error {
func(i int, a *Actor) { func(i int, a *Actor) {
// defer wg.Done() // defer wg.Done()
originalPositions[a.ID()] = a.Position() originalPositions[a.ID()] = a.Position()
originalHitboxes[a.ID()] = collision.GetBoundingRectHitbox(a, a.Hitbox())
// Advance any animations for this actor. // Advance any animations for this actor.
// TODO: wallclock time here, should be set by FPS for consistency.
if a.activeAnimation != nil && a.activeAnimation.nextFrameAt.Before(now) { if a.activeAnimation != nil && a.activeAnimation.nextFrameAt.Before(now) {
if done := a.TickAnimation(a.activeAnimation); done { if done := a.TickAnimation(a.activeAnimation); done {
// Animation has finished, get the callback function. // Animation has finished, get the callback function.
@ -133,42 +130,31 @@ func (w *Canvas) loopActorCollision() error {
w.loopContainActorsInsideLevel(a) w.loopContainActorsInsideLevel(a)
// Store this actor's bounding box after they've moved. // Store this actor's bounding box after they've moved.
boxes[i] = collision.GetBoundingRect(a) boxes[i] = collision.SizePlusHitbox(collision.GetBoundingRect(a), a.Hitbox())
}(i, a) }(i, a)
// wg.Wait() // wg.Wait()
} }
// log.Warn("== BEGIN BetweenBoxes") var collidingActors = map[*Actor]*Actor{}
// Check pairs of all our Actor boxes for overlap and running their OnCollide
// scripts for mobile actors.
var collidingActors = ActorCollisionMap{}
for tuple := range collision.BetweenBoxes(boxes) { for tuple := range collision.BetweenBoxes(boxes) {
a, b := w.actors[tuple.A], w.actors[tuple.B]
// Give the A, B tuple of boxes names: their order doesn't matter.
// Example: stable could be the Button and mover is the Player walking onto it.
// Or: stable could be the Player and mover is a Key that they walked onto.
stable, mover := w.actors[tuple.A], w.actors[tuple.B]
// If neither actor is mobile, don't run collision handlers. // If neither actor is mobile, don't run collision handlers.
if !(stable.IsMobile() || mover.IsMobile()) { if !(a.IsMobile() || b.IsMobile()) {
continue continue
} }
collidingActors.Set(stable, mover) collidingActors[a] = b
log.Error("between boxes: %+v A=<%s> B=<%s>", tuple, stable.ID(), mover.ID()) // log.Error("between boxes: %+v <%s> <%s>", tuple, a.ID(), b.ID())
// Call the OnCollide handler for A informing them of B's intersection. // Call the OnCollide handler for A informing them of B's intersection.
if w.scripting != nil { if w.scripting != nil {
var ( var (
rect = collision.GetBoundingRectHitbox(mover, mover.Hitbox()) rect = collision.SizePlusHitbox(collision.GetBoundingRect(b), b.Hitbox())
// lastGoodBox = rect
lastGoodBox = render.Rect{ lastGoodBox = render.Rect{
// Level Positions of the doodad is based on the top left X: originalPositions[b.ID()].X,
// of its graphical sprite, not its (possibly offset) hitbox. Y: originalPositions[b.ID()].Y,
X: originalPositions[mover.ID()].X,
Y: originalPositions[mover.ID()].Y,
W: boxes[tuple.B].W, W: boxes[tuple.B].W,
H: boxes[tuple.B].H, H: boxes[tuple.B].H,
} }
@ -185,7 +171,7 @@ func (w *Canvas) loopActorCollision() error {
// use it for collision-check purposes but DON'T physically move // use it for collision-check purposes but DON'T physically move
// the character by it (moving the character may clip them thru // the character by it (moving the character may clip them thru
// other solid hitboxes like the upside-down trapdoor) // other solid hitboxes like the upside-down trapdoor)
// var onTopY int var onTopY int
// Firstly we want to make sure B isn't able to clip through A's // Firstly we want to make sure B isn't able to clip through A's
// solid hitbox if A protests the movement. Trace a vector from // solid hitbox if A protests the movement. Trace a vector from
@ -194,40 +180,27 @@ func (w *Canvas) loopActorCollision() error {
// only return false if it protests the movement, but not trigger // only return false if it protests the movement, but not trigger
// any actions (such as emit messages to linked doodads) until // any actions (such as emit messages to linked doodads) until
// Settled=true. // Settled=true.
if origHitbox, ok := originalHitboxes[mover.ID()]; ok { if origPoint, ok := originalPositions[b.ID()]; ok {
// Trace a vector back from the actor's current position
var (
// Special case for when a mobile actor lands ON TOP OF a solid
// actor. We want to stop their Y movement downwards, but allow
// horizontal movement on the X axis.
// Touching the solid actor from the side is already fine.
onTop bool
onBottom bool // they hit the bottom instead
// onSide bool // they hit a side, maybe allow Y movement
// If we lock their movement coordinate.
lockX *int
lockY *int
)
// If their original hitbox is offset from their sprite corner,
// gather the offset now.
var (
origPosition = originalPositions[mover.ID()]
hitboxPadding = render.Point{
X: render.AbsInt(origHitbox.X - origPosition.X),
Y: render.AbsInt(origHitbox.Y - origPosition.Y),
}
)
// Trace a vector back from the mover's current position
// to where they originated from. If A protests B's position at // to where they originated from. If A protests B's position at
// ANY time, we ?mark didProtest=true? and continue backscanning // ANY time, we mark didProtest=true and continue backscanning
// B's movement. The next time A does NOT protest, that is to be // B's movement. The next time A does NOT protest, that is to be
// B's new position. // B's new position.
// Special case for when a mobile actor lands ON TOP OF a solid
// actor. We want to stop their Y movement downwards, but allow
// horizontal movement on the X axis.
// Touching the solid actor from the side is already fine.
var onTop = false
var (
lockX int
lockY int
)
for point := range render.IterLine( for point := range render.IterLine(
origHitbox.Point(), origPoint,
mover.Position(), // TODO: verify non 0,0 hitbox doodads work b.Position(),
) { ) {
point := point point := point
test := render.Rect{ test := render.Rect{
@ -238,92 +211,49 @@ func (w *Canvas) loopActorCollision() error {
} }
if info, err := collision.CompareBoxes(boxes[tuple.A], test); err == nil { if info, err := collision.CompareBoxes(boxes[tuple.A], test); err == nil {
// A and B have their drawings overlapping on the page. Get each
// of their declared hitboxes (if smaller) to see if their hitboxes
// intersect as well.
var (
stableHitbox = collision.GetBoundingRectHitbox(stable, stable.Hitbox())
moverHitbox = collision.GetBoundingRectHitbox(mover, mover.Hitbox())
)
// B is overlapping A's box, call its OnCollide handler // B is overlapping A's box, call its OnCollide handler
// with Settled=false and see if it protests the overlap. // with Settled=false and see if it protests the overlap.
err := w.scripting.To(stable.ID()).Events.RunCollide(&CollideEvent{ err := w.scripting.To(a.ID()).Events.RunCollide(&CollideEvent{
Actor: mover, Actor: b,
Overlap: info.Overlap, Overlap: info.Overlap,
InHitbox: stableHitbox.Intersects(moverHitbox), InHitbox: info.Overlap.Intersects(a.Hitbox()),
Settled: false, Settled: false,
}) })
// log.Warn("ActorCollision: CompareBoxes info was %+v", info)
// Did A protest? // Did A protest?
if err == scripting.ErrReturnFalse { if err == scripting.ErrReturnFalse {
// Are they on top? // Are they on top?
var ( aHitbox := collision.SizePlusHitbox(collision.GetBoundingRect(a), a.Hitbox())
stableTop = stableHitbox.Y if render.AbsInt(test.Y+test.H-aHitbox.Y) == 0 {
stableBottom = stableHitbox.Y + stableHitbox.H // log.Error("ActorCollision: onTop=true at Y=%s", test.Y)
moverTop = test.Y
moverBottom = test.Y + test.H // bottom of falling actor
)
// Is the colliding actor on top? (e.g. mover=player character)
if render.AbsInt(moverBottom-stableTop) < balance.OnTopThreshold {
onTop = true onTop = true
// onTopY = stableHitbox.Y onTopY = test.Y
}
// Or are they hitting from below?
if render.AbsInt(stableBottom-moverTop) < balance.OnTopThreshold {
onBottom = true
}
if onTop || onBottom {
log.Error("onTop=%+v onBottom=%+v", onTop, onBottom)
} }
// What direction were we moving? // What direction were we moving?
if test.Y != lastGoodBox.Y { if test.Y != lastGoodBox.Y {
if lockY == 0 {
// If we are hitting the top or bottom, lock our Y coordinate here. lockY = lastGoodBox.Y
if onTop || onBottom { }
if onTop {
// First Y coordinate before the protested collision. // log.Error("ActorCollision: setGrounded(true)", test.Y)
if lockY == nil { b.SetGrounded(true)
lockY = new(int)
*lockY = lastGoodBox.Y
if onBottom {
*lockY -= hitboxPadding.Y
}
}
// If on top, set the mover to Grounded here.
if onTop {
mover.SetGrounded(true)
}
} }
} }
if test.X != lastGoodBox.X { if test.X != lastGoodBox.X {
if lockX == nil && !(onTop || onBottom) { if !onTop {
lockX = new(int) lockX = lastGoodBox.X
*lockX = lastGoodBox.X
} }
} }
// Move them back to the last good box. // Move them back to the last good box.
lastGoodBox = render.Rect{ lastGoodBox = test
X: test.X, // - hitboxPadding.X, // note: this is in World Coordinates if lockX != 0 {
Y: test.Y, // - hitboxPadding.Y, lastGoodBox.X = lockX
W: test.W,
H: test.H,
}
if lockX != nil {
lastGoodBox.X = *lockX - hitboxPadding.X
} }
} else { } else {
if err != nil { if err != nil {
log.Error("RunCollide on %s (%s) errored: %s", stable.ID(), stable.Actor.Filename, err) log.Error("RunCollide on %s (%s) errored: %s", a.ID(), a.Actor.Filename, err)
} }
// Move them back to the last good box. // Move them back to the last good box.
lastGoodBox = test lastGoodBox = test
@ -335,107 +265,65 @@ func (w *Canvas) loopActorCollision() error {
} }
// Did we lock their X or Y coordinate from moving further? // Did we lock their X or Y coordinate from moving further?
if lockY != nil { if lockY != 0 {
lastGoodBox.Y = *lockY lastGoodBox.Y = lockY
} }
if lockX != nil { if lockX != 0 {
lastGoodBox.X = *lockX lastGoodBox.X = lockX
} }
if !mover.noclip { if !b.noclip {
log.Error("Move B to: %s", lastGoodBox.Point()) b.MoveTo(lastGoodBox.Point())
// The stationary doodad should move the moving one only.
mover.MoveTo(lastGoodBox.Point())
} }
} else { } else {
log.Error( log.Error(
"ERROR: Actors %s and %s overlap and the script returned false,"+ "ERROR: Actors %s and %s overlap and the script returned false,"+
"but I didn't store %s original position earlier??", "but I didn't store %s original position earlier??",
stable.Doodad().Title, mover.Doodad().Title, mover.Doodad().Title, a.Doodad().Title, b.Doodad().Title, b.Doodad().Title,
) )
} }
// TODO: onTopY != nil if onTopY != 0 && lastGoodBox.Y-onTopY <= 1 {
// if onTopY != 0 && lastGoodBox.Y-onTopY <= 1 { lastGoodBox.Y = onTopY
// lastGoodBox.Y = onTopY }
// }
// Movement has been settled. Check if B's point is still invading // Movement has been settled. Check if B's point is still invading
// A's box and call its OnCollide handler one last time in // A's box and call its OnCollide handler one last time in
// Settled=true mode so it can run its actions. // Settled=true mode so it can run its actions.
if info, err := collision.CompareBoxes(boxes[tuple.A], lastGoodBox); err == nil { if info, err := collision.CompareBoxes(boxes[tuple.A], lastGoodBox); err == nil {
if err := w.scripting.To(stable.ID()).Events.RunCollide(&CollideEvent{ if err := w.scripting.To(a.ID()).Events.RunCollide(&CollideEvent{
Actor: mover, Actor: b,
Overlap: info.Overlap, Overlap: info.Overlap,
InHitbox: info.Overlap.Intersects(stable.Hitbox()), InHitbox: info.Overlap.Intersects(a.Hitbox()),
Settled: true, Settled: true,
}); err != nil && err != scripting.ErrReturnFalse { }); err != nil && err != scripting.ErrReturnFalse {
log.Error("VM(%s).RunCollide: %s", stable.ID(), err.Error()) log.Error("VM(%s).RunCollide: %s", a.ID(), err.Error())
} }
// If the (player) is pressing the Use key, call the colliding // If the (player) is pressing the Use key, call the colliding
// actor's OnUse event. // actor's OnUse event.
if mover.flagUsing { if b.flagUsing {
if err := w.scripting.To(stable.ID()).Events.RunUse(&UseEvent{ if err := w.scripting.To(a.ID()).Events.RunUse(&UseEvent{
Actor: mover, Actor: b,
}); err != nil { }); err != nil {
log.Error("VM(%s).RunUse: %s", stable.ID(), err.Error()) log.Error("VM(%s).RunUse: %s", a.ID(), err.Error())
} }
} }
} }
} }
} }
log.Warn("-- END BetweenBoxes")
// Check for lacks of collisions since last frame. // Check for lacks of collisions since last frame.
// Note: w.collidingActors is "last frame's" map of colliding actor boxes. for sourceActor, targetActor := range w.collidingActors {
w.collidingActors.Iter(func(stable, mover *Actor) { if _, ok := collidingActors[sourceActor]; !ok {
w.scripting.To(sourceActor.ID()).Events.RunLeave(&CollideEvent{
// Are these not colliding this frame? Actor: targetActor,
// TODO: does this work with three-way actor collisions?
if !collidingActors.Exists(stable, mover) {
w.scripting.To(stable.ID()).Events.RunLeave(&CollideEvent{
Actor: mover,
Settled: true, Settled: true,
}) })
} }
}) }
// Store this frame's colliding actors for next frame. // Store this frame's colliding actors for next frame.
w.collidingActors = collidingActors w.collidingActors = collidingActors
return nil return nil
} }
// ActorCollisionMap keeps a cache of collision box overlaps between
// an Actor and one or more other Actors.
type ActorCollisionMap map[*Actor]map[*Actor]interface{}
// Set a collision to the other actor.
func (m ActorCollisionMap) Set(stable, mover *Actor) {
if m[stable] == nil {
m[stable] = map[*Actor]interface{}{}
}
m[stable][mover] = nil
}
// Exists checks if the actor is colliding with the other.
func (m ActorCollisionMap) Exists(stable, mover *Actor) bool {
if m[stable] == nil {
return false
}
_, ok := m[stable][mover]
return ok
}
// Iter the collision data.
func (m ActorCollisionMap) Iter(fn func(stable, mover *Actor)) {
for stable, moverMap := range m {
for mover := range moverMap {
fn(stable, mover)
}
}
}

2
pkg/uix/canvas.go
View File

@ -90,7 +90,7 @@ type Canvas struct {
actors []*Actor // if this canvas CONTAINS actors (i.e., is a level) actors []*Actor // if this canvas CONTAINS actors (i.e., is a level)
// Collision memory for the actors. // Collision memory for the actors.
collidingActors ActorCollisionMap // mapping their IDs to each other collidingActors map[*Actor]*Actor // mapping their IDs to each other
// Doodad scripting engine supervisor. // Doodad scripting engine supervisor.
// NOTE: initialized and managed by the play_scene. // NOTE: initialized and managed by the play_scene.