Merge branch 'main' into clean_beep

# Conflicts:
#	internal/routes/wait.go

internal/routes/play.go

@@ -19,11 +19,14 @@ func switchPoint(ctx context.Context, point int) leaf.HandlerFunc {
 	switch point {
 	case 2: // 镇水塔点位
 		return play.OnlyVideo
-	case 4:
-		// 4号点位(发卡机)
-		return play.PushCard(ctx)
 	case 5:
-		// 5号点位(等待插卡)
+		// 登龙云台(激光秀)
+		return play.LaserShow
+	case 10:
+		// 10号点位(发卡机)
+		return play.PushCard(ctx)
+	case 11:
+		// 11号点位(等待插卡)
 		return play.WaitCard(ctx)
 	default:
 		return play.Default

internal/routes/play/laser.go

@@ -0,0 +1,45 @@
+package play
+
+import (
+	"game-driver/config/game"
+	"game-driver/internal/middleware"
+	"game-driver/internal/schema"
+	"game-driver/leaf"
+	"game-driver/pkg/oscx"
+	"go.uber.org/zap"
+	"time"
+)
+
+func LaserShow(c *leaf.Context) {
+	cfg := (game.C).(game.LaserConfig)
+
+	payload := leaf.Value[*schema.PlayModal](c, middleware.PayloadJSONKey)
+
+	if data, ok := payload.Game["osc"].(string); ok {
+		zap.S().Infoln("开始播放激光秀:", data)
+
+		o := oscx.New(cfg.Host, cfg.Port)
+		err := o.EnableLaserOutput()
+		if err != nil {
+			zap.S().Warnln("激光打开异常:", err)
+			return
+		} else {
+			defer zap.S().Infoln("激光秀播放结束:", data)
+			defer o.DisableLaserOutput()
+
+			err = o.StartCue(data)
+			if err != nil {
+				zap.S().Warnln("播放激光节目异常:", err)
+				return
+			}
+		}
+	}
+	if w, ok := payload.Game["wait"]; ok {
+		if v, ok := w.(float64); ok {
+			select {
+			case <-c.Done():
+			case <-time.After(time.Duration(v) * time.Second):
+			}
+		}
+	}
+}

internal/routes/play/only_video.go

@@ -16,11 +16,11 @@ func OnlyVideo(c *leaf.Context) {
 	defer utils.BlankClose()
 
 	if url, ok := payload.Game["video"]; ok {
-		local, err := utils.LinkVideo(url.(string))
+		path, local, err := utils.LinkVideo(url.(string))
 		if err != nil {
 			zap.S().Errorln("视频文件获取异常: ", err)
 			return
 		}
-		_ = video.Play(c, local)
+		_ = video.Play(c, path, local)
 	}
 }

internal/routes/play/push_card.go

@@ -28,14 +28,14 @@ type ResponseBody struct {
 }
 
 func PushCard(ctx context.Context) leaf.HandlerFunc {
-	g := (game.G).(game.ConfigPush)
+	g := (game.C).(game.ConfigPush)
 
 	readers := make([]card_reader.Reader, len(g.PushGroups))
 	devices := make([]*card_pusher.Device, len(g.PushGroups))
 	for i, group := range g.PushGroups {
 		// 解析配置
 		gv, _ := json.Marshal(group)
-		zap.S().Info("关卡配置:", string(gv))
+		zap.S().Infof("关卡配置[%v]: %s", i, string(gv))
 
 		// 开始连接读卡器
 		if group.Read != "" {
@@ -63,7 +63,7 @@ func PushCard(ctx context.Context) leaf.HandlerFunc {
 			zap.S().Panicln("初始化发卡器失败: ", err)
 		}
 
-		// 保存读卡器和发卡器
+		// 保存发卡器
 		devices[i] = device
 	}
 	go func() {

internal/routes/play/wait_card.go

@@ -18,7 +18,7 @@ import (
 )
 
 func WaitCard(ctx context.Context) leaf.HandlerFunc {
-	g := (game.G).(game.ConfigWait)
+	g := (game.C).(game.ConfigWait)
 
 	reader, err := card_reader.NewReader(g.Addr)
 	if err != nil {

internal/routes/standby.go

@@ -0,0 +1,101 @@
+package routes
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"game-driver/internal/middleware"
+	"game-driver/internal/routes/standby"
+	"game-driver/internal/routes/standby_ctrl"
+	"game-driver/internal/schema"
+	"game-driver/leaf"
+	"github.com/go-pkgz/cronrange"
+	"go.uber.org/zap"
+	"sync"
+)
+
+// StandbyAction 待机任务，支持音乐、TTS、继电器、视频、网页、投影仪、大型激光秀 ctrl
+func StandbyAction(ctrl *common.CtrlWait, device *common.Device) leaf.HandlerFunc {
+	ps := common.NewPauseSub(ctrl)
+
+	return func(c *leaf.Context) {
+		payload := leaf.Value[*schema.WaitModel](c, middleware.PayloadJSONKey)
+
+		// 设定默认时间规则,ctrl
+		if payload.Cron == "" {
+			payload.Cron = "* * * *"
+		}
+
+		rules, err := cronrange.Parse(payload.Cron)
+		if err != nil {
+			zap.S().Errorln("解析时间规则异常: ", err)
+			return
+		}
+
+		// 等待组
+		var waitGroup sync.WaitGroup
+		defer waitGroup.Wait()
+
+		// 开启暂停监听
+		waitGroup.Add(1)
+		go func() {
+			defer waitGroup.Done()
+			ps.Run(c)
+		}()
+
+		// 处理每个待机控制
+		handleItem := func(title string, item schema.WaitItemModel, f func(c context.Context) error) {
+			waitGroup.Add(1)
+			go func() {
+				defer waitGroup.Done()
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Duration(item.Duration, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Device(device, item.Lock, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Interval(item.Interval, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Pause(ps, item.Pause, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Cron(rules, item.Cron, f)
+				if f == nil {
+					return
+				}
+				e := f(c)
+				if e != nil {
+					zap.S().Errorf("%s异常: %s\n", title, e)
+				}
+			}()
+		}
+
+		for _, item := range payload.Items {
+			switch item.Type {
+			case schema.WaitAudio:
+				handleItem("音乐待机控制", item, standby.Audio(item))
+			case schema.WaitTTS:
+				handleItem("TTS待机控制", item, standby.TTS(item))
+			case schema.WaitRelay:
+				handleItem("继电器待机控制", item, standby.Relay(item))
+			case schema.WaitVideo:
+				handleItem("视频待机控制", item, standby.Video(item))
+			case schema.WaitWeb:
+				handleItem("网页待机控制", item, standby.Web(item))
+			case schema.WaitPJLink:
+				handleItem("投影仪待机控制", item, standby.PJLink(item))
+			case schema.WaitLaserShow:
+				handleItem("大型激光秀控制", item, standby.LaserShow(item))
+			default:
+				zap.S().Infof("不支持的类型: %d\n", item.Type)
+			}
+		}
+	}
+}

internal/routes/standby/audio.go

@@ -0,0 +1,40 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/audio"
+	"game-driver/pkg/utils"
+	"github.com/gopxl/beep/v2/speaker"
+	"go.uber.org/zap"
+)
+
+func Audio(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		data, err := utils.LinkAudio(item.Data)
+		if err != nil {
+			return fmt.Errorf("音频数据获取异常: %w", err)
+		}
+		if data == nil {
+			return fmt.Errorf("音频数据获取为空")
+		}
+
+		zap.S().Infoln("播放待机音乐")
+		defer zap.S().Infoln("结束待机音乐")
+
+		ctrl, closer, e := audio.PlayBgmMP3(data)
+		defer closer()
+		if e != nil {
+			return fmt.Errorf("播放待机音乐异常: %w", e)
+		}
+
+		<-c.Done()
+
+		speaker.Lock()
+		ctrl.Streamer = nil
+		speaker.Unlock()
+
+		return nil
+	}
+}

internal/routes/standby/laser.go

@@ -0,0 +1,35 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/config/game"
+	"game-driver/internal/schema"
+	"game-driver/pkg/oscx"
+	"go.uber.org/zap"
+)
+
+func LaserShow(item schema.WaitItemModel) func(c context.Context) error {
+	cfg := (game.C).(game.LaserConfig)
+
+	return func(c context.Context) error {
+		zap.S().Infoln("开始播放大型激光秀")
+
+		o := oscx.New(cfg.Host, cfg.Port)
+		err := o.EnableLaserOutput()
+		if err != nil {
+			return fmt.Errorf("激光打开异常: %w", err)
+		} else {
+			defer zap.S().Infoln("大型激光秀播放结束:", item.Data)
+			defer o.DisableLaserOutput()
+
+			err = o.StartCue(item.Data)
+			if err != nil {
+				return fmt.Errorf("播放大型激光节目异常: %w", err)
+			}
+		}
+
+		<-c.Done()
+		return nil
+	}
+}

internal/routes/standby/pjlink.go

@@ -0,0 +1,49 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/config/wait"
+	"game-driver/internal/schema"
+	"game-driver/pkg/pjlink"
+	"go.uber.org/zap"
+	"time"
+)
+
+func PJLink(_ schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		cfg := (wait.C).(wait.PJLink)
+		pjc := pjlink.NewClient(cfg.Ip, cfg.Port, cfg.Password, cfg.Id)
+
+		zap.S().Infoln("打开待机投影仪")
+		resp, err := pjc.PowerOnSync()
+		if err != nil {
+			return fmt.Errorf("打开投影仪异常: %w", err)
+		}
+		zap.S().Infoln("打开投影仪结果：", resp)
+
+		run := true
+		for run {
+			select {
+			case <-c.Done():
+				zap.S().Infoln("关闭待机投影仪")
+				resp, err = pjc.PowerOffSync()
+				if err != nil {
+					return fmt.Errorf("关闭投影仪异常: %w", err)
+				}
+				zap.S().Infoln("关闭投影仪结果：", resp)
+				run = false
+				break
+			case <-time.After(time.Minute * 30):
+				zap.S().Infoln("轮询待机投影仪")
+				resp, err = pjc.PowerOnSync()
+				if err != nil {
+					return fmt.Errorf("轮询投影仪异常: %w", err)
+				}
+				zap.S().Infoln("轮询投影仪结果：", resp)
+			}
+		}
+
+		return nil
+	}
+}

internal/routes/standby/relay.go

@@ -0,0 +1,28 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/relay"
+	"go.uber.org/zap"
+)
+
+func Relay(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		r, err := relay.New(item.Data)
+		if err != nil {
+			return fmt.Errorf("继电器初始化异常: %w", err)
+		}
+		defer r.Close()
+
+		zap.S().Infoln("待机继电器供电")
+		defer zap.S().Infoln("待机继电器断电")
+
+		_ = r.On(0)
+		<-c.Done()
+		_ = r.Off(0)
+
+		return nil
+	}
+}

internal/routes/standby/tts.go

@@ -0,0 +1,26 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/audio"
+	"game-driver/pkg/tts"
+	"go.uber.org/zap"
+)
+
+func TTS(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		reader, err := tts.DefaultTTS.Get(item.Data)
+		if err != nil {
+			return fmt.Errorf("语音合成异常: %w", err)
+		}
+
+		zap.S().Infoln("播放待机 TTS 语音")
+		defer zap.S().Infoln("结束待机 TTS 语音")
+
+		audio.PlayWav(c, reader)
+
+		return nil
+	}
+}

internal/routes/standby/video.go

@@ -0,0 +1,31 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/utils"
+	"game-driver/pkg/video"
+	"go.uber.org/zap"
+)
+
+func Video(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		path, local, err := utils.LinkVideo(item.Data)
+		if err != nil {
+			return fmt.Errorf("视频文件获取异常: %w", err)
+		}
+
+		zap.S().Infoln("播放待机视频")
+		defer zap.S().Infoln("结束待机视频")
+
+		utils.BlankOpen()
+		defer utils.BlankClose()
+
+		err = video.Play(c, path, local)
+		if err != nil {
+			return fmt.Errorf("视频播放异常: %w", err)
+		}
+		return nil
+	}
+}

internal/routes/standby/web.go

@@ -0,0 +1,22 @@
+package standby
+
+import (
+	"context"
+	"game-driver/internal/schema"
+	"game-driver/pkg/browser"
+	"game-driver/pkg/utils"
+	"go.uber.org/zap"
+)
+
+func Web(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		zap.S().Infoln("打开待机网页")
+
+		// 控制背光
+		utils.BlankOpen()
+		defer utils.BlankClose()
+
+		browser.OpenApp(c, item.Data)
+		return nil
+	}
+}

internal/routes/standby_ctrl/cron.go

@@ -0,0 +1,94 @@
+package standby_ctrl
+
+import (
+	"context"
+	"github.com/go-pkgz/cronrange"
+	"go.uber.org/zap"
+	"sync"
+	"time"
+)
+
+// Cron 时间控制器
+func Cron(rootRules []cronrange.Rule, cron string, play func(c context.Context) error) func(c context.Context) error {
+	// 设定默认时间规则
+	if cron == "" {
+		cron = "* * * *"
+	}
+
+	rules, err := cronrange.Parse(cron)
+	if err != nil {
+		zap.S().Errorln("解析时间规则异常: ", err)
+		return nil
+	}
+
+	return func(c context.Context) error {
+		a := make(chan bool)
+		defer close(a)
+
+		zap.S().Infoln("待机时间控制器")
+		defer zap.S().Infoln("待机时间控制器结束")
+
+		// 等待组
+		var waitGroup sync.WaitGroup
+		defer waitGroup.Wait()
+
+		ticker := time.NewTicker(time.Second)
+		defer ticker.Stop()
+
+		waitGroup.Add(1)
+		go func() {
+			defer waitGroup.Done()
+			for {
+				select {
+				case <-c.Done():
+					return
+				case <-ticker.C:
+					if cronrange.Match(rules, time.Now()) && cronrange.Match(rootRules, time.Now()) {
+						a <- true
+					} else {
+						a <- false
+					}
+				}
+			}
+		}()
+
+		var cancel context.CancelFunc
+		var m sync.Mutex
+		for {
+			select {
+			case <-c.Done():
+				if cancel != nil {
+					cancel()
+					cancel = nil
+				}
+				return nil
+			case r := <-a:
+				if r {
+					if ok := m.TryLock(); ok {
+						ctx, cc := context.WithCancel(context.TODO())
+						cancel = cc
+						waitGroup.Add(1)
+						go func() {
+							defer waitGroup.Done()
+							defer m.Unlock()
+							defer func() { cancel = nil }()
+
+							err := play(ctx)
+							if err != nil {
+								zap.S().Errorln("执行动作异常: ", err)
+								select {
+								case <-ctx.Done():
+									return
+								case <-time.After(time.Minute):
+								}
+							}
+						}()
+					}
+				} else if cancel != nil {
+					cancel()
+					cancel = nil
+				}
+			}
+		}
+	}
+}

internal/routes/standby_ctrl/device.go

@@ -0,0 +1,22 @@
+package standby_ctrl
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"go.uber.org/zap"
+)
+
+// Device 设备锁定控制器
+func Device(d *common.Device, lock bool, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		if lock {
+			zap.S().Infoln("待机任务锁定设备")
+			defer zap.S().Infoln("待机任务解锁设备")
+
+			d.Lock()
+			defer d.Unlock()
+		}
+
+		return play(c)
+	}
+}

internal/routes/standby_ctrl/duration.go

@@ -0,0 +1,23 @@
+package standby_ctrl
+
+import (
+	"context"
+	"go.uber.org/zap"
+	"time"
+)
+
+// Duration 持续时长控制器
+func Duration(duration int64, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		zap.S().Infoln("待机持续时长控制器: ", duration)
+		defer zap.S().Infoln("待机持续时长控制器结束: ", duration)
+
+		if duration > 0 {
+			ctx, cancel := context.WithTimeout(c, time.Duration(duration)*time.Second)
+			defer cancel()
+			c = ctx
+		}
+
+		return play(c)
+	}
+}

internal/routes/standby_ctrl/interval.go

@@ -0,0 +1,35 @@
+package standby_ctrl
+
+import (
+	"context"
+	"go.uber.org/zap"
+	"time"
+)
+
+// Interval 循环间隔控制器
+func Interval(interval int64, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		zap.S().Infoln("待机间隔控制器: ", interval)
+		defer zap.S().Infoln("待机间隔控制器结束: ", interval)
+
+		for {
+			err := play(c)
+			if err != nil {
+				zap.S().Errorln("执行后续操作异常: ", err)
+			}
+			if interval > 0 {
+				select {
+				case <-c.Done():
+					return nil
+				case <-time.After(time.Duration(interval) * time.Second):
+				}
+			} else {
+				select {
+				case <-c.Done():
+					return nil
+				default:
+				}
+			}
+		}
+	}
+}

internal/routes/standby_ctrl/pause.go

@@ -0,0 +1,64 @@
+package standby_ctrl
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"go.uber.org/zap"
+	"sync"
+)
+
+// Pause 暂停控制器
+func Pause(ps *common.PauseSub, isPause bool, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		var cancel context.CancelFunc
+		run := true
+
+		if isPause {
+			zap.S().Infoln("待机暂停控制器")
+			defer zap.S().Infoln("待机暂停控制器结束")
+
+			p := ps.GetNew()
+			defer ps.Close(p)
+
+			// 等待组
+			var wait sync.WaitGroup
+			defer wait.Wait()
+
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				for {
+					select {
+					case <-c.Done():
+						return
+					case v := <-p:
+						if v == 1 {
+							zap.S().Infoln("待机控制器 Pause 触发")
+							run = false
+							cancel()
+						} else {
+							zap.S().Infoln("待机控制器 Resume 触发")
+							run = true
+						}
+					}
+				}
+			}()
+		}
+
+		for {
+			select {
+			case <-c.Done():
+				return nil
+			default:
+				if run {
+					nc, cc := context.WithCancel(c)
+					cancel = cc
+					err := play(nc)
+					if err != nil {
+						zap.S().Infoln("执行后续操作异常: ", err)
+					}
+				}
+			}
+		}
+	}
+}