Fix: Applies proper bounce physics by reflecting the direction

joeykchen · joeykchen · commit ec74ee724a03 · 2026-01-05T19:04:49.000+08:00
diff --git a/internal/enginewrap/sync.gen.go b/internal/enginewrap/sync.gen.go
@@ -534,6 +534,13 @@ func (pself *physicMgrImpl) CheckTouchedCameraBoundary(obj gdx.Object, board_typ
 	})
 	return _ret1
 }
+func (pself *physicMgrImpl) CheckNearestTouchedCameraBoundary(obj gdx.Object) int64 {
+	var _ret1 int64
+	callInMainThread(func() {
+		_ret1 = gdx.PhysicMgr.CheckNearestTouchedCameraBoundary(obj)
+	})
+	return _ret1
+}
 func (pself *physicMgrImpl) SetCollisionSystemType(is_collision_by_alpha bool) {
 	callInMainThread(func() {
 		gdx.PhysicMgr.SetCollisionSystemType(is_collision_by_alpha)
diff --git a/internal/enginewrap/sync_pure.gen.go b/internal/enginewrap/sync_pure.gen.go
@@ -291,6 +291,10 @@ func (pself *physicMgrImpl) CheckTouchedCameraBoundary(obj gdx.Object, board_typ
 	var _ret1 bool
 	return _ret1
 }
+func (pself *physicMgrImpl) CheckNearestTouchedCameraBoundary(obj gdx.Object) int64 {
+	var _ret1 int64
+	return _ret1
+}
 func (pself *physicMgrImpl) SetCollisionSystemType(is_collision_by_alpha bool) {}
 func (pself *physicMgrImpl) SetGlobalGravity(gravity float64)                  {}
 func (pself *physicMgrImpl) GetGlobalGravity() float64 {
diff --git a/pkg/gdspx/internal/ffi/ffi.gen.go b/pkg/gdspx/internal/ffi/ffi.gen.go
diff --git a/pkg/gdspx/internal/ffi/ffi_wrapper.gen.go b/pkg/gdspx/internal/ffi/ffi_wrapper.gen.go
@@ -153,6 +153,7 @@ type GDExtensionSpxPhysicRaycast C.GDExtensionSpxPhysicRaycast
 type GDExtensionSpxPhysicCheckCollision C.GDExtensionSpxPhysicCheckCollision
 type GDExtensionSpxPhysicCheckTouchedCameraBoundaries C.GDExtensionSpxPhysicCheckTouchedCameraBoundaries
 type GDExtensionSpxPhysicCheckTouchedCameraBoundary C.GDExtensionSpxPhysicCheckTouchedCameraBoundary
+type GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary C.GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary
 type GDExtensionSpxPhysicSetCollisionSystemType C.GDExtensionSpxPhysicSetCollisionSystemType
 type GDExtensionSpxPhysicSetGlobalGravity C.GDExtensionSpxPhysicSetGlobalGravity
 type GDExtensionSpxPhysicGetGlobalGravity C.GDExtensionSpxPhysicGetGlobalGravity
@@ -1046,6 +1047,16 @@ func CallPhysicCheckTouchedCameraBoundary(
 
 	return (GdBool)(ret_val)
 }
+func CallPhysicCheckNearestTouchedCameraBoundary(
+	obj GdObj,
+) GdInt {
+	arg0 := (C.GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary)(api.SpxPhysicCheckNearestTouchedCameraBoundary)
+	arg1GdObj := (C.GdObj)(obj)
+	var ret_val C.GdInt
+	C.cgo_callfn_GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary(arg0, arg1GdObj, &ret_val)
+
+	return (GdInt)(ret_val)
+}
 func CallPhysicSetCollisionSystemType(
 	is_collision_by_alpha GdBool,
 ) {
diff --git a/pkg/gdspx/internal/ffi/ffi_wrapper.gen.h b/pkg/gdspx/internal/ffi/ffi_wrapper.gen.h
@@ -216,6 +216,9 @@ void cgo_callfn_GDExtensionSpxPhysicCheckTouchedCameraBoundaries(const GDExtensi
 void cgo_callfn_GDExtensionSpxPhysicCheckTouchedCameraBoundary(const GDExtensionSpxPhysicCheckTouchedCameraBoundary fn, GdObj obj, GdInt board_type, GdBool* ret_val) {
 	fn(obj, board_type,ret_val);
 }
+void cgo_callfn_GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary(const GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary fn, GdObj obj, GdInt* ret_val) {
+	fn(obj,ret_val);
+}
 void cgo_callfn_GDExtensionSpxPhysicSetCollisionSystemType(const GDExtensionSpxPhysicSetCollisionSystemType fn, GdBool is_collision_by_alpha) {
 	fn(is_collision_by_alpha);
 }
diff --git a/pkg/gdspx/internal/ffi/gdextension_spx_ext.h b/pkg/gdspx/internal/ffi/gdextension_spx_ext.h
@@ -292,6 +292,7 @@ typedef void (*GDExtensionSpxPhysicRaycast)(GdVec2 from, GdVec2 to, GdInt collis
 typedef void (*GDExtensionSpxPhysicCheckCollision)(GdVec2 from, GdVec2 to, GdInt collision_mask, GdBool collide_with_areas, GdBool collide_with_bodies, GdBool *ret_value);
 typedef void (*GDExtensionSpxPhysicCheckTouchedCameraBoundaries)(GdObj obj, GdInt *ret_value);
 typedef void (*GDExtensionSpxPhysicCheckTouchedCameraBoundary)(GdObj obj, GdInt board_type, GdBool *ret_value);
+typedef void (*GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary)(GdObj obj, GdInt *ret_value);
 typedef void (*GDExtensionSpxPhysicSetCollisionSystemType)(GdBool is_collision_by_alpha);
 typedef void (*GDExtensionSpxPhysicSetGlobalGravity)(GdFloat gravity);
 typedef void (*GDExtensionSpxPhysicGetGlobalGravity)(GdFloat *ret_value);
diff --git a/pkg/gdspx/internal/webffi/ffi.gen.go b/pkg/gdspx/internal/webffi/ffi.gen.go
diff --git a/pkg/gdspx/internal/wrap/manager_wrapper.gen.go b/pkg/gdspx/internal/wrap/manager_wrapper.gen.go
@@ -485,6 +485,11 @@ func (pself *physicMgr) CheckTouchedCameraBoundary(obj Object, board_type int64)
 	retValue := CallPhysicCheckTouchedCameraBoundary(arg0, arg1)
 	return ToBool(retValue)
 }
+func (pself *physicMgr) CheckNearestTouchedCameraBoundary(obj Object) int64 {
+	arg0 := ToGdObj(obj)
+	retValue := CallPhysicCheckNearestTouchedCameraBoundary(arg0)
+	return ToInt64(retValue)
+}
 func (pself *physicMgr) SetCollisionSystemType(is_collision_by_alpha bool) {
 	arg0 := ToGdBool(is_collision_by_alpha)
 	CallPhysicSetCollisionSystemType(arg0)
diff --git a/pkg/gdspx/internal/wrap/manager_wrapper_web.gen.go b/pkg/gdspx/internal/wrap/manager_wrapper_web.gen.go
@@ -462,6 +462,11 @@ func (pself *physicMgr) CheckTouchedCameraBoundary(obj Object, board_type int64)
 	_retValue := API.SpxPhysicCheckTouchedCameraBoundary.Invoke(arg0, arg1)
 	return JsToGdBool(_retValue)
 }
+func (pself *physicMgr) CheckNearestTouchedCameraBoundary(obj Object) int64 {
+	arg0 := JsFromGdObj(obj)
+	_retValue := API.SpxPhysicCheckNearestTouchedCameraBoundary.Invoke(arg0)
+	return JsToGdInt(_retValue)
+}
 func (pself *physicMgr) SetCollisionSystemType(is_collision_by_alpha bool) {
 	arg0 := JsFromGdBool(is_collision_by_alpha)
 	API.SpxPhysicSetCollisionSystemType.Invoke(arg0)
diff --git a/pkg/gdspx/pkg/engine/interface.gen.go b/pkg/gdspx/pkg/engine/interface.gen.go
@@ -121,6 +121,7 @@ type IPhysicMgr interface {
 	CheckCollision(from Vec2, to Vec2, collision_mask int64, collide_with_areas bool, collide_with_bodies bool) bool
 	CheckTouchedCameraBoundaries(obj Object) int64
 	CheckTouchedCameraBoundary(obj Object, board_type int64) bool
+	CheckNearestTouchedCameraBoundary(obj Object) int64
 	SetCollisionSystemType(is_collision_by_alpha bool)
 	SetGlobalGravity(gravity float64)
 	GetGlobalGravity() float64
diff --git a/sprite_impl.go b/sprite_impl.go
@@ -803,19 +803,32 @@ func (p *SpriteImpl) BounceOffEdge() {
 	if debugInstr {
 		spxlog.Debug("BounceOffEdge: %s", p.name)
 	}
-	dir := p.Heading()
-	where := checkTouchingDirection(dir)
-	touching := p.checkTouchingScreen(where)
-	if touching == 0 {
+
+	nearestEdge := p.checkNearestTouchedBoundary()
+
+	if nearestEdge == 0 {
 		return
 	}
-	if (touching & (touchingScreenLeft | touchingScreenRight)) != 0 {
-		dir = -dir
-	} else {
-		dir = 180 - dir
+
+	// prevents sprites from getting stuck at boundaries
+	const minBounceComponent = 0.2
+	radians := toRadian(90 - p.direction)
+	dx := math.Cos(radians)
+	dy := -math.Sin(radians)
+
+	switch nearestEdge {
+	case touchingScreenLeft:
+		dx = math.Max(minBounceComponent, math.Abs(dx))
+	case touchingScreenTop:
+		dy = math.Max(minBounceComponent, math.Abs(dy))
+	case touchingScreenRight:
+		dx = -math.Max(minBounceComponent, math.Abs(dx))
+	case touchingScreenBottom:
+		dy = -math.Max(minBounceComponent, math.Abs(dy))
 	}
 
-	p.direction = normalizeDirection(dir)
+	newDirection := math.Atan2(dy, dx)*180/math.Pi + 90
+	p.direction = normalizeDirection(newDirection)
 }
 
 // ============================================================================
diff --git a/sprite_util.go b/sprite_util.go
@@ -132,6 +132,14 @@ func (p *SpriteImpl) checkTouchingScreen(where int) (touching int) {
 	return touching & where
 }
 
+// checkNearestTouchedBoundary returns the nearest screen boundary that the sprite is touching.
+func (p *SpriteImpl) checkNearestTouchedBoundary() int {
+	if p.syncSprite == nil {
+		return 0
+	}
+	return (int)(physicMgr.CheckNearestTouchedCameraBoundary(p.syncSprite.GetId()))
+}
+
 // checkTouchingDirection determines which screen edges to check based on direction
 func checkTouchingDirection(dir float64) int {
 	if dir > 0 {

Original file line number	Diff line number	Diff line change
`@@ -216,6 +216,9 @@ void cgo_callfn_GDExtensionSpxPhysicCheckTouchedCameraBoundaries(const GDExtensi`
`216`	`216`	`void cgo_callfn_GDExtensionSpxPhysicCheckTouchedCameraBoundary(const GDExtensionSpxPhysicCheckTouchedCameraBoundary fn, GdObj obj, GdInt board_type, GdBool* ret_val) {`
`217`	`217`	`fn(obj, board_type,ret_val);`
`218`	`218`	`}`
	`219`	`+void cgo_callfn_GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary(const GDExtensionSpxPhysicCheckNearestTouchedCameraBoundary fn, GdObj obj, GdInt* ret_val) {`
	`220`	`+ fn(obj,ret_val);`
	`221`	`+}`
`219`	`222`	`void cgo_callfn_GDExtensionSpxPhysicSetCollisionSystemType(const GDExtensionSpxPhysicSetCollisionSystemType fn, GdBool is_collision_by_alpha) {`
`220`	`223`	`fn(is_collision_by_alpha);`
`221`	`224`	`}`