Add input gesture: swipe

Author: JiepengTan

event.go

@@ -94,6 +94,7 @@ func (p *eventSink) call(wait bool, data any, doSth func(*eventSink)) {
 type eventSinkMgr struct {
 	allWhenStart           *eventSink
 	allWhenKeyPressed      *eventSink
+	allWhenSwipe           *eventSink
 	allWhenIReceive        *eventSink
 	allWhenBackdropChanged *eventSink
 	allWhenCloned          *eventSink
@@ -110,6 +111,7 @@ type eventSinkMgr struct {
 func (p *eventSinkMgr) reset() {
 	p.allWhenStart = nil
 	p.allWhenKeyPressed = nil
+	p.allWhenSwipe = nil
 	p.allWhenIReceive = nil
 	p.allWhenBackdropChanged = nil
 	p.allWhenCloned = nil
@@ -126,6 +128,7 @@ func (p *eventSinkMgr) reset() {
 func (p *eventSinkMgr) doDeleteClone(this any) {
 	p.allWhenStart = p.allWhenStart.doDeleteClone(this)
 	p.allWhenKeyPressed = p.allWhenKeyPressed.doDeleteClone(this)
+	p.allWhenSwipe = p.allWhenSwipe.doDeleteClone(this)
 	p.allWhenIReceive = p.allWhenIReceive.doDeleteClone(this)
 	p.allWhenBackdropChanged = p.allWhenBackdropChanged.doDeleteClone(this)
 	p.allWhenCloned = p.allWhenCloned.doDeleteClone(this)
@@ -162,6 +165,14 @@ func (p *eventSinkMgr) doWhenKeyPressed(key Key) {
 	})
 }
 
+func (p *eventSinkMgr) doWhenSwipe(direction Direction, this threadObj) {
+	p.allWhenSwipe.asyncCall(false, direction, func(ev *eventSink) {
+		if ev.pthis == this {
+			ev.sink.(func(Direction))(direction)
+		}
+	})
+}
+
 func (p *eventSinkMgr) doWhenClick(this threadObj) {
 	p.allWhenClick.asyncCall(false, this, func(ev *eventSink) {
 		if debugEvent {
@@ -243,6 +254,7 @@ type IEventSinks interface {
 	OnMsg__0(onMsg func(msg string, data any))
 	OnMsg__1(msg string, onMsg func())
 	OnStart(onStart func())
+	OnSwipe__0(direction Direction, onSwipe func())
 	OnTimer(time float64, onTimer func())
 	Stop(kind StopKind)
 }
@@ -276,6 +288,11 @@ func (p *eventSinks) doDeleteClone() {
 	p.eventSinkMgr.doDeleteClone(p.pthis)
 }
 
+// doWhenSwipe triggers swipe events for this specific object
+func (p *eventSinks) doWhenSwipe(direction Direction, target threadObj) {
+	p.eventSinkMgr.doWhenSwipe(direction, target)
+}
+
 // -------------------------------------------------------------------------------------
 
 func (p *eventSinks) OnStart(onStart func()) {
@@ -339,6 +356,22 @@ func (p *eventSinks) OnKey__0(key Key, onKey func()) {
 	}
 }
 
+func (p *eventSinks) OnSwipe__0(direction Direction, onSwipe func()) {
+	p.allWhenSwipe = &eventSink{
+		prev:  p.allWhenSwipe,
+		pthis: p.pthis,
+		sink: func(Direction) {
+			if debugEvent {
+				log.Println("==> onSwipe", direction, nameOf(p.pthis))
+			}
+			onSwipe()
+		},
+		cond: func(data any) bool {
+			return data.(Direction) == direction
+		},
+	}
+}
+
 func (p *eventSinks) OnKey__1(keys []Key, onKey func(Key)) {
 	p.allWhenKeyPressed = &eventSink{
 		prev:  p.allWhenKeyPressed,

game.go

@@ -734,17 +734,20 @@ type clicker interface {
 	Visible() bool
 }
 
-func (p *Game) doWhenLeftButtonDown(ev *eventLeftButtonDown) {
-	// add a global click cooldown
-	if !p.inputs.canTriggerClickEvent(inputGlobalClickTimerId) {
-		return
-	}
+func (p *Game) doWhenLeftButtonUp(ev *eventLeftButtonUp) {
+	point := ev.Pos
+	p.inputs.checkTracking(point)
+}
 
+func (p *Game) doWhenLeftButtonDown(ev *eventLeftButtonDown) {
 	point := ev.Pos
+
+	// Detect target sprite for both swipe and click events
 	tempItems := p.getTempShapes()
 	count := len(tempItems)
 
 	var target clicker = nil
+	var targetSprite *SpriteImpl = nil
 	for i := 0; i < count; i++ {
 		item := tempItems[count-i-1]
 		if o, ok := item.(clicker); ok {
@@ -753,12 +756,24 @@ func (p *Game) doWhenLeftButtonDown(ev *eventLeftButtonDown) {
 				isClicked := spriteMgr.CheckCollisionWithPoint(syncSprite.GetId(), point, true)
 				if isClicked {
 					target = o
+					// Try to get the SpriteImpl from the clicker
+					if sprite, ok := o.(*SpriteImpl); ok {
+						targetSprite = sprite
+					}
 					break
 				}
 			}
 		}
 	}
 
+	// Start swipe tracking with detected target sprite (can be nil for stage swipes)
+	p.inputs.startTracking(point, targetSprite)
+
+	// add a global click cooldown
+	if !p.inputs.canTriggerClickEvent(inputGlobalClickTimerId) {
+		return
+	}
+
 	if target != nil {
 		syncSprite := target.getProxy()
 		if p.inputs.canTriggerClickEvent(syncSprite.GetId()) {
@@ -771,11 +786,21 @@ func (p *Game) doWhenLeftButtonDown(ev *eventLeftButtonDown) {
 	}
 }
 
+func (p *Game) doWhenMouseMove(ev *eventMouseMove) {
+	// Update current mouse position
+	p.mousePos = ev.Pos
+	// If swipe tracking is active, record the movement
+	p.inputs.onMouseMove(ev.Pos)
+}
+
 func (p *Game) handleEvent(event event) {
 	switch ev := event.(type) {
-
+	case *eventLeftButtonUp:
+		p.doWhenLeftButtonUp(ev)
 	case *eventLeftButtonDown:
 		p.doWhenLeftButtonDown(ev)
+	case *eventMouseMove:
+		p.doWhenMouseMove(ev)
 	case *eventKeyDown:
 		p.sinkMgr.doWhenKeyPressed(ev.Key)
 	case *eventStart:
@@ -821,8 +846,12 @@ func (p *Game) logicLoop(me coroutine.Thread) int {
 
 func (p *Game) inputEventLoop(me coroutine.Thread) int {
 	lastLbtnPressed := false
+	lastMousePos := mathf.Vec2{}       // Track last mouse position
+	const mouseMovementThreshold = 1.0 // Minimum movement to trigger event (pixels)
 	keyEvents := make([]engine.KeyEvent, 0)
+
 	for {
+		// Check mouse button state
 		curLbtnPressed := inputMgr.GetMouseState(MOUSE_BUTTON_LEFT)
 		if curLbtnPressed != lastLbtnPressed {
 			if lastLbtnPressed {
@@ -833,6 +862,21 @@ func (p *Game) inputEventLoop(me coroutine.Thread) int {
 		}
 		lastLbtnPressed = curLbtnPressed
 
+		// Check mouse movement
+		// Note: We need to get the actual current mouse position from the engine
+		// For now, we'll use the stored mousePos which should be updated elsewhere
+		curMousePos := inputMgr.GetMousePos()
+		mathfMousePos := mathf.Vec2{X: float64(curMousePos.X), Y: float64(curMousePos.Y)}
+
+		// Check if mouse moved significantly
+		dx := mathfMousePos.X - lastMousePos.X
+		dy := mathfMousePos.Y - lastMousePos.Y
+		if math.Abs(dx) > mouseMovementThreshold || math.Abs(dy) > mouseMovementThreshold {
+			p.inputs.onMouseMove(mathfMousePos)
+			lastMousePos = mathfMousePos
+		}
+
+		// Handle keyboard events
 		keyEvents = engine.GetKeyEvents(keyEvents)
 		for _, ev := range keyEvents {
 			if ev.IsPressed {