add timer

Author: hai.lin

event.go

@@ -91,6 +91,7 @@ func (p *eventSink) call(wait bool, data interface{}, doSth func(*eventSink)) {
 
 type eventSinkMgr struct {
 	allWhenStart           *eventSink
+	allWhenTimer           *eventSink
 	allWhenKeyPressed      *eventSink
 	allWhenIReceive        *eventSink
 	allWhenBackdropChanged *eventSink
@@ -102,10 +103,12 @@ type eventSinkMgr struct {
 	allWhenMoving          *eventSink
 	allWhenTurning         *eventSink
 	calledStart            bool
+	calledTimer            bool
 }
 
 func (p *eventSinkMgr) reset() {
 	p.allWhenStart = nil
+	p.allWhenTimer = nil
 	p.allWhenKeyPressed = nil
 	p.allWhenIReceive = nil
 	p.allWhenBackdropChanged = nil
@@ -121,6 +124,7 @@ func (p *eventSinkMgr) reset() {
 
 func (p *eventSinkMgr) doDeleteClone(this interface{}) {
 	p.allWhenStart = p.allWhenStart.doDeleteClone(this)
+	p.allWhenTimer = p.allWhenTimer.doDeleteClone(this)
 	p.allWhenKeyPressed = p.allWhenKeyPressed.doDeleteClone(this)
 	p.allWhenIReceive = p.allWhenIReceive.doDeleteClone(this)
 	p.allWhenBackdropChanged = p.allWhenBackdropChanged.doDeleteClone(this)
@@ -145,6 +149,17 @@ func (p *eventSinkMgr) doWhenStart() {
 	}
 }
 
+func (p *eventSinkMgr) doWhenTimer(time float64) {
+	if !p.calledTimer {
+		p.allWhenTimer.asyncCall(false, time, func(ev *eventSink) {
+			if ev.cond != nil && ev.cond(time) {
+				ev.sink.(func(float64))(time)
+				p.calledTimer = true
+			}
+		})
+	}
+}
+
 func (p *eventSinkMgr) doWhenKeyPressed(key Key) {
 	p.allWhenKeyPressed.asyncCall(false, key, func(ev *eventSink) {
 		ev.sink.(func(Key))(key)
@@ -232,6 +247,7 @@ type IEventSinks interface {
 	OnMsg__0(onMsg func(msg string, data interface{}))
 	OnMsg__1(msg string, onMsg func())
 	OnStart(onStart func())
+	OnTimer(time float64, onTimer func())
 	Stop(kind StopKind)
 }
 
@@ -274,6 +290,22 @@ func (p *eventSinks) OnStart(onStart func()) {
 	}
 }
 
+func (p *eventSinks) OnTimer(time float64, onTimer func()) {
+	p.allWhenTimer = &eventSink{
+		prev:  p.allWhenTimer,
+		pthis: p.pthis,
+		sink: func(float64) {
+			if debugEvent {
+				log.Println("==> OnTimer", time, nameOf(p.pthis))
+			}
+			onTimer()
+		},
+		cond: func(data interface{}) bool {
+			return data.(float64) >= time
+		},
+	}
+}
+
 func (p *eventSinks) OnClick(onClick func()) {
 	pthis := p.pthis
 	p.allWhenClick = &eventSink{

game.go

@@ -578,6 +578,8 @@ func (p *Game) addSpecialShape(g reflect.Value, v specsp, inits []Sprite) []Spri
 			sm.game = p
 			p.addShape(sm)
 		}
+	case "timer":
+		p.addShape(newTimer(v))
 	case "measure":
 		p.addShape(newMeasure(v))
 	case "sprites":
@@ -717,6 +719,8 @@ func (p *Game) handleEvent(event event) {
 		p.sinkMgr.doWhenKeyPressed(ev.Key)
 	case *eventStart:
 		p.sinkMgr.doWhenStart()
+	case *eventTimer:
+		p.sinkMgr.doWhenTimer(ev.time)
 	}
 }
 
@@ -738,6 +742,8 @@ func (p *Game) eventLoop(me coroutine.Thread) int {
 }
 func (p *Game) logicLoop(me coroutine.Thread) int {
 	for {
+		gtime.Tick(gtime.DeltaTime())
+
 		tempItems := p.getTempShapes()
 		for _, item := range tempItems {
 			if result, ok := item.(interface{ onUpdate(float64) }); ok {
@@ -1197,11 +1203,16 @@ func (p *Game) Wait(secs float64) {
 }
 
 func (p *Game) Timer() float64 {
-	panic("todo")
+	return gtime.Timer()
 }
 
 func (p *Game) ResetTimer() {
-	panic("todo")
+	gtime.ResetTimer()
+}
+
+func (p *Game) OnTimerGreaterThan(secs float64, call func()) {
+	engine.Wait(secs)
+	gco.WaitMainThread(call)
 }
 
 // -----------------------------------------------------------------------------

gdspx.go

@@ -85,6 +85,7 @@ func (p *Game) syncUpdateLogic() error {
 	p.startFlag.Do(func() {
 		p.fireEvent(&eventStart{})
 	})
+	p.fireEvent(&eventTimer{time: p.Timer()})
 
 	return nil
 }

input.go

@@ -246,6 +246,10 @@ type event interface{}
 
 type eventStart struct{}
 
+type eventTimer struct {
+	time float64
+}
+
 type eventKeyDown struct {
 	Key Key
 }

internal/time/timer.go

@@ -0,0 +1,17 @@
+package time
+
+var (
+	gameTimer float64
+)
+
+func Tick(deltaTime float64) {
+	gameTimer += deltaTime
+}
+
+func Timer() float64 {
+	return gameTimer
+}
+
+func ResetTimer() {
+	gameTimer = 0
+}

internal/ui/ui_timer.go

@@ -0,0 +1,31 @@
+package ui
+
+import (
+	"github.com/goplus/spx/internal/engine"
+	"github.com/realdream-ai/mathf"
+)
+
+type UiTimer struct {
+	UiNode
+	bg    *UiNode
+	label *UiNode
+}
+
+func NewUiTimer() *UiTimer {
+	panel := engine.NewUiNode[UiTimer]()
+	return panel
+}
+
+// !!Warning: this method was called in main thread
+func (pself *UiTimer) OnStart() {
+	pself.bg = SyncBindUI[UiNode](pself.GetId(), "BG")
+	pself.label = SyncBindUI[UiNode](pself.GetId(), "BG/Label")
+}
+
+func (pself *UiTimer) UpdatePos(pos mathf.Vec2) {
+	uiMgr.SetGlobalPosition(pself.bg.GetId(), pos)
+}
+
+func (pself *UiTimer) UpdateText(value string) {
+	uiMgr.SetText(pself.label.GetId(), value)
+}

monitor.go

@@ -20,9 +20,11 @@ import (
 	"fmt"
 	"log"
 	"reflect"
+	"strconv"
 	"strings"
 	"syscall"
 
+	gtime "github.com/goplus/spx/internal/time"
 	"github.com/goplus/spx/internal/tools"
 	"github.com/goplus/spx/internal/ui"
 	"github.com/realdream-ai/mathf"
@@ -124,7 +126,8 @@ func getValueRef(target reflect.Value, name string, from int) reflect.Value {
 }
 
 const (
-	getVarPrefix = "getVar:"
+	getVarPrefix   = "getVar:"
+	getTimerPrefix = "getProp:"
 )
 
 func buildMonitorEval(g reflect.Value, t, val string) func() string {
@@ -142,6 +145,10 @@ func buildMonitorEval(g reflect.Value, t, val string) func() string {
 			}
 		}
 		log.Println("[WARN] Monitor: var not found -", name, target)
+	case strings.HasPrefix(val, getTimerPrefix):
+		return func() string {
+			return strconv.FormatFloat(gtime.Timer(), 'f', 3, 64)
+		}
 	default:
 		log.Println("[WARN] Monitor: unknown command -", val)
 	}

timer.go

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2021 The GoPlus Authors (goplus.org). All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package spx
+
+import (
+	"strconv"
+
+	gtime "github.com/goplus/spx/internal/time"
+	"github.com/goplus/spx/internal/ui"
+	"github.com/realdream-ai/mathf"
+)
+
+type timer struct {
+	visible bool
+	pos     mathf.Vec2
+	panel   *ui.UiTimer
+}
+
+func newTimer(v specsp) *timer {
+	visible := v["visible"].(bool)
+	pos := mathf.NewVec2(v["x"].(float64), v["y"].(float64))
+	panel := ui.NewUiTimer()
+	timerObj := &timer{
+		visible: visible,
+		pos:     pos,
+		panel:   panel,
+	}
+	panel.UpdatePos(pos)
+	return timerObj
+}
+
+func (pself *timer) onUpdate(delta float64) {
+	// pself.panel.SetVisible(pself.visible)
+	if !pself.visible {
+		return
+	}
+
+	pself.panel.UpdateText(strconv.FormatFloat(gtime.Timer(), 'f', 3, 64))
+}
+
+func (pself *timer) Visible() bool {
+	return pself.visible
+}
+func (pself *timer) Show() {
+	pself.visible = true
+}
+func (pself *timer) Hide() {
+	pself.visible = false
+}
+func (pself *timer) Xpos() float64 {
+	return pself.pos.X
+}
+func (pself *timer) Ypos() float64 {
+	return pself.pos.Y
+}
+func (pself *timer) SetXpos(x float64) {
+	pself.pos.X = x
+}
+func (pself *timer) SetYpos(y float64) {
+	pself.pos.Y = y
+}
+func (pself *timer) SetXYpos(x float64, y float64) {
+	pself.pos = mathf.NewVec2(x, y)
+}
+func (pself *timer) ChangeXpos(dx float64) {
+	pself.pos.X += dx
+}
+func (pself *timer) ChangeYpos(dy float64) {
+	pself.pos.Y += dy
+}
+func (pself *timer) ChangeXYpos(dx float64, dy float64) {
+	pself.pos = pself.pos.Add(mathf.NewVec2(dx, dy))
+}