feat: 白色主题UI + 签到接口修复 + 物理/地形Bug修复 + WPF启动器重构

2026-08-09 21:32:55 +08:00
parent f70b061d1a
commit abd4548dff
20 changed files with 3559 additions and 449 deletions
@@ -0,0 +1,324 @@
+package auth
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
+)
+
+// User 用户数据
+type User struct {
+	ID              string           `json:"id"`
+	Username        string           `json:"username"`
+	PasswordHash    string           `json:"-"` // 不返回给客户端
+	CreatedAt       int64            `json:"created_at"`
+	Level           int              `json:"level"`
+	Exp             int              `json:"exp"`
+	Diamonds        int              `json:"diamonds"`
+	RedstoneCoins   int64            `json:"redstone_coins"`
+	GoldCoins       int              `json:"gold_coins"`
+	LastLoginDate   string           `json:"last_login_date"`
+	Inventory       map[string]int   `json:"inventory"`        // itemId → count
+	EquippedItem    string           `json:"equipped_item"`    // 当前装备的道具ID
+	SpeedBoostUntil int64            `json:"speed_boost_until"` // 速度加成到期时间(unix)
+	PurchaseHistory []PurchaseRecord `json:"purchase_history"` // 最近50条购买记录
+}
+
+// PurchaseRecord 购买记录
+type PurchaseRecord struct {
+	ItemID    string `json:"item_id"`
+	ItemName  string `json:"item_name"`
+	Currency  string `json:"currency"`
+	Amount    int64  `json:"amount"`
+	Timestamp int64  `json:"timestamp"`
+}
+
+// UserStore 内存用户存储 (后续可替换为 PostgreSQL)
+type UserStore struct {
+	mu    sync.RWMutex
+	users map[string]*User // key = username (lowercase)
+}
+
+func NewUserStore() *UserStore {
+	return &UserStore{users: make(map[string]*User)}
+}
+
+func (s *UserStore) Create(username, password string) (*User, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if _, exists := s.users[username]; exists {
+		return nil, errors.New("用户名已存在")
+	}
+
+	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return nil, fmt.Errorf("密码加密失败: %w", err)
+	}
+
+	now := time.Now()
+	user := &User{
+		ID:              fmt.Sprintf("u_%d", now.UnixNano()),
+		Username:        username,
+		PasswordHash:    string(hash),
+		CreatedAt:       now.Unix(),
+		Level:           1,
+		Exp:             0,
+		Diamonds:        20,
+		RedstoneCoins:   3000,
+		GoldCoins:       1,
+		LastLoginDate:   "", // 留空：注册当天可正常签到领奖
+		Inventory:       make(map[string]int),
+		PurchaseHistory: []PurchaseRecord{},
+	}
+	s.users[username] = user
+	return user, nil
+}
+
+func (s *UserStore) GetByUsername(username string) (*User, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	u, ok := s.users[username]
+	return u, ok
+}
+
+func (s *UserStore) GetByID(id string) (*User, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	for _, u := range s.users {
+		if u.ID == id {
+			return u, true
+		}
+	}
+	return nil, false
+}
+
+func (s *UserStore) VerifyPassword(username, password string) (*User, error) {
+	user, ok := s.GetByUsername(username)
+	if !ok {
+		return nil, errors.New("用户不存在")
+	}
+	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)); err != nil {
+		return nil, errors.New("密码错误")
+	}
+	return user, nil
+}
+
+// DailyLogin 每日登录奖励。返回奖励详情和是否已领取。
+func (s *UserStore) DailyLogin(userID string) (map[string]interface{}, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	var user *User
+	for _, u := range s.users {
+		if u.ID == userID {
+			user = u
+			break
+		}
+	}
+	if user == nil {
+		return nil, errors.New("用户不存在")
+	}
+
+	today := time.Now().Format("2006-01-02")
+	if user.LastLoginDate == today {
+		return map[string]interface{}{
+			"claimed": true,
+			"message": "今日已领取",
+		}, nil
+	}
+
+	// 发放奖励
+	const rewardDiamonds = 20
+	const rewardRedstoneCoins = 3000
+	const rewardGoldCoins = 1
+
+	user.Diamonds += rewardDiamonds
+	user.RedstoneCoins += rewardRedstoneCoins
+	user.GoldCoins += rewardGoldCoins
+	user.LastLoginDate = today
+
+	return map[string]interface{}{
+		"claimed":      false,
+		"message":      "领取成功",
+		"diamonds":     rewardDiamonds,
+		"redstone":     rewardRedstoneCoins,
+		"gold":         rewardGoldCoins,
+		"total_diamonds":     user.Diamonds,
+		"total_redstone":     user.RedstoneCoins,
+		"total_gold":         user.GoldCoins,
+	}, nil
+}
+
+// SpendCurrency 消费货币，返回成功或余额不足错误
+func (s *UserStore) SpendCurrency(userID, currency string, amount int64) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	var user *User
+	for _, u := range s.users {
+		if u.ID == userID {
+			user = u
+			break
+		}
+	}
+	if user == nil {
+		return errors.New("用户不存在")
+	}
+
+	switch currency {
+	case "diamonds":
+		if user.Diamonds < int(amount) {
+			return fmt.Errorf("钻石不足，当前: %d，需要: %d", user.Diamonds, amount)
+		}
+		user.Diamonds -= int(amount)
+	case "redstone_coins":
+		if user.RedstoneCoins < amount {
+			return fmt.Errorf("红石币不足，当前: %d，需要: %d", user.RedstoneCoins, amount)
+		}
+		user.RedstoneCoins -= amount
+	case "gold_coins":
+		if user.GoldCoins < int(amount) {
+			return fmt.Errorf("金币不足，当前: %d，需要: %d", user.GoldCoins, amount)
+		}
+		user.GoldCoins -= int(amount)
+	default:
+		return fmt.Errorf("未知货币类型: %s", currency)
+	}
+	return nil
+}
+
+// BuyItem 购买商品 (货币扣款 + 库存追踪 + 交易记录)
+func (s *UserStore) BuyItem(userID, itemID, itemName, currency string, amount int64, quantity int) (map[string]interface{}, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	var user *User
+	for _, u := range s.users { if u.ID == userID { user = u; break } }
+	if user == nil { return nil, errors.New("用户不存在") }
+	switch currency {
+	case "diamonds": if user.Diamonds < int(amount) { return nil, fmt.Errorf("钻石不足") }; user.Diamonds -= int(amount)
+	case "redstone_coins": if user.RedstoneCoins < amount { return nil, fmt.Errorf("红石币不足") }; user.RedstoneCoins -= amount
+	case "gold_coins": if user.GoldCoins < int(amount) { return nil, fmt.Errorf("金币不足") }; user.GoldCoins -= int(amount)
+	default: return nil, fmt.Errorf("未知货币")
+	}
+	if user.Inventory == nil { user.Inventory = make(map[string]int) }
+	user.Inventory[itemID] += quantity
+	if itemID == "speed_boost" { user.SpeedBoostUntil = time.Now().Unix() + 3600 }
+	rec := PurchaseRecord{ItemID: itemID, ItemName: itemName, Currency: currency, Amount: amount, Timestamp: time.Now().Unix()}
+	user.PurchaseHistory = append([]PurchaseRecord{rec}, user.PurchaseHistory...)
+	if len(user.PurchaseHistory) > 50 { user.PurchaseHistory = user.PurchaseHistory[:50] }
+	return map[string]interface{}{"message": "购买成功", "item_id": itemID, "quantity": quantity, "user": userToMap(user)}, nil
+}
+
+// UseItem 使用道具
+func (s *UserStore) UseItem(userID, itemID string) (map[string]interface{}, error) {
+	s.mu.Lock(); defer s.mu.Unlock()
+	var user *User
+	for _, u := range s.users { if u.ID == userID { user = u; break } }
+	if user == nil { return nil, errors.New("用户不存在") }
+	if user.Inventory == nil || user.Inventory[itemID] <= 0 { return nil, errors.New("道具数量不足") }
+	user.Inventory[itemID]--
+	msg := "使用成功"
+	switch itemID {
+	case "speed_boost":
+		user.SpeedBoostUntil = time.Now().Unix() + 3600
+		user.EquippedItem = itemID
+		msg = "速度加成已激活(1小时)"
+	case "exp_boost":
+		user.Exp += 500
+		if user.Exp >= user.Level*1000 {
+			user.Level++
+			user.Exp -= (user.Level - 1) * 1000
+			msg = fmt.Sprintf("升级! Lv.%d", user.Level)
+		} else {
+			msg = "获得500经验值"
+		}
+	case "diamond_pack":
+		user.Diamonds += 10
+		msg = "获得10钻石"
+	case "gold_pack":
+		user.GoldCoins += 5
+		msg = "获得5金币"
+	case "rs_pack":
+		user.RedstoneCoins += 10000
+		msg = "获得10000红石币"
+	}
+	return map[string]interface{}{"message": msg, "user": userToMap(user)}, nil
+}
+
+// userToMap 将 User 转换为返回给客户端的 map
+func userToMap(u *User) map[string]interface{} {
+	inv := u.Inventory
+	if inv == nil { inv = make(map[string]int) }
+	hist := u.PurchaseHistory
+	if hist == nil { hist = []PurchaseRecord{} }
+	return map[string]interface{}{
+		"id":               u.ID,
+		"username":         u.Username,
+		"level":            u.Level,
+		"exp":              u.Exp,
+		"diamonds":         u.Diamonds,
+		"redstone_coins":   u.RedstoneCoins,
+		"gold_coins":       u.GoldCoins,
+		"last_login_date":  u.LastLoginDate,
+		"created_at":       u.CreatedAt,
+		"inventory":        inv,
+		"equipped_item":    u.EquippedItem,
+		"speed_boost_until": u.SpeedBoostUntil,
+		"purchase_history": hist,
+	}
+}
+
+// ==================== JWT ====================
+
+type JWTManager struct {
+	secretKey []byte
+	expires   time.Duration
+}
+
+func NewJWTManager(secret string) *JWTManager {
+	return &JWTManager{
+		secretKey: []byte(secret),
+		expires:   24 * time.Hour,
+	}
+}
+
+type Claims struct {
+	UserID   string `json:"uid"`
+	Username string `json:"username"`
+	jwt.RegisteredClaims
+}
+
+func (m *JWTManager) Generate(user *User) (string, error) {
+	claims := &Claims{
+		UserID:   user.ID,
+		Username: user.Username,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(m.expires)),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString(m.secretKey)
+}
+
+func (m *JWTManager) Verify(tokenStr string) (*Claims, error) {
+	token, err := jwt.ParseWithClaims(tokenStr, &Claims{}, func(t *jwt.Token) (interface{}, error) {
+		if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
+		}
+		return m.secretKey, nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	claims, ok := token.Claims.(*Claims)
+	if !ok || !token.Valid {
+		return nil, errors.New("invalid token")
+	}
+	return claims, nil
+}
@@ -0,0 +1,225 @@
+package auth
+
+import (
+	"net/http"
+	"strings"
+
+	"mrcc/pkg/response"
+
+	"github.com/gin-gonic/gin"
+)
+
+type Handler struct {
+	store *UserStore
+	jwt   *JWTManager
+}
+
+func NewHandler(store *UserStore, jwtMgr *JWTManager) *Handler {
+	return &Handler{store: store, jwt: jwtMgr}
+}
+
+// RegisterAuthRoutes 注册认证路由 (/api/auth)
+func (h *Handler) RegisterAuthRoutes(r *gin.RouterGroup) {
+	r.POST("/register", h.Register)
+	r.POST("/login", h.Login)
+	r.GET("/me", h.AuthMiddleware(), h.Me)
+}
+
+// RegisterEconomyRoutes 注册经济路由 (/api)
+func (h *Handler) RegisterEconomyRoutes(r *gin.RouterGroup) {
+	r.POST("/daily-reward", h.AuthMiddleware(), h.DailyReward)
+	r.POST("/spend", h.AuthMiddleware(), h.Spend)
+	r.POST("/buy", h.AuthMiddleware(), h.Buy)
+	r.POST("/use-item", h.AuthMiddleware(), h.UseItem)
+}
+
+// RegisterRoutes 注册全部路由（兼容旧调用）
+func (h *Handler) RegisterRoutes(r *gin.RouterGroup) {
+	h.RegisterAuthRoutes(r)
+	h.RegisterEconomyRoutes(r)
+}
+
+type registerReq struct {
+	Username string `json:"username" binding:"required,min=3,max=20"`
+	Password string `json:"password" binding:"required,min=6,max=50"`
+}
+
+// Register 用户注册
+func (h *Handler) Register(c *gin.Context) {
+	var req registerReq
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, http.StatusBadRequest, "参数无效: "+err.Error())
+		return
+	}
+
+	user, err := h.store.Create(req.Username, req.Password)
+	if err != nil {
+		response.Error(c, http.StatusConflict, err.Error())
+		return
+	}
+
+	token, err := h.jwt.Generate(user)
+	if err != nil {
+		response.Error(c, http.StatusInternalServerError, "生成令牌失败")
+		return
+	}
+
+	response.OK(c, gin.H{
+		"token": token,
+		"user":  userToMap(user),
+	})
+}
+
+// Login 用户登录
+func (h *Handler) Login(c *gin.Context) {
+	var req registerReq
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, http.StatusBadRequest, "参数无效: "+err.Error())
+		return
+	}
+
+	user, err := h.store.VerifyPassword(req.Username, req.Password)
+	if err != nil {
+		response.Error(c, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	token, err := h.jwt.Generate(user)
+	if err != nil {
+		response.Error(c, http.StatusInternalServerError, "生成令牌失败")
+		return
+	}
+
+	response.OK(c, gin.H{
+		"token": token,
+		"user":  userToMap(user),
+	})
+}
+
+// Me 获取当前用户完整信息
+func (h *Handler) Me(c *gin.Context) {
+	claims, exists := c.Get("claims")
+	if !exists {
+		response.Error(c, http.StatusUnauthorized, "未认证")
+		return
+	}
+	cl := claims.(*Claims)
+	user, ok := h.store.GetByID(cl.UserID)
+	if !ok {
+		response.Error(c, http.StatusNotFound, "用户不存在")
+		return
+	}
+	response.OK(c, userToMap(user))
+}
+
+// DailyReward 每日登录奖励
+func (h *Handler) DailyReward(c *gin.Context) {
+	claims, exists := c.Get("claims")
+	if !exists {
+		response.Error(c, http.StatusUnauthorized, "未认证")
+		return
+	}
+	cl := claims.(*Claims)
+
+	result, err := h.store.DailyLogin(cl.UserID)
+	if err != nil {
+		response.Error(c, http.StatusInternalServerError, err.Error())
+		return
+	}
+
+	response.OK(c, result)
+}
+
+type spendReq struct {
+	Currency string `json:"currency" binding:"required"`
+	Amount   int64  `json:"amount" binding:"required,min=1"`
+}
+
+// Spend 消费货币
+func (h *Handler) Spend(c *gin.Context) {
+	claims, exists := c.Get("claims")
+	if !exists {
+		response.Error(c, http.StatusUnauthorized, "未认证")
+		return
+	}
+	cl := claims.(*Claims)
+
+	var req spendReq
+	if err := c.ShouldBindJSON(&req); err != nil {
+		response.Error(c, http.StatusBadRequest, "参数无效: "+err.Error())
+		return
+	}
+
+	if err := h.store.SpendCurrency(cl.UserID, req.Currency, req.Amount); err != nil {
+		response.Error(c, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	// 返回最新余额
+	user, _ := h.store.GetByID(cl.UserID)
+	response.OK(c, gin.H{
+		"message":  "消费成功",
+		"currency": req.Currency,
+		"amount":   req.Amount,
+		"user":     userToMap(user),
+	})
+}
+
+type buyReq struct {
+	ItemID   string `json:"item_id" binding:"required"`
+	ItemName string `json:"item_name" binding:"required"`
+	Currency string `json:"currency" binding:"required"`
+	Amount   int64  `json:"amount" binding:"required,min=1"`
+	Quantity int    `json:"quantity"`
+}
+
+// Buy 购买商品 (含库存追踪)
+func (h *Handler) Buy(c *gin.Context) {
+	claims, _ := c.Get("claims"); cl := claims.(*Claims)
+	var req buyReq
+	if err := c.ShouldBindJSON(&req); err != nil { response.Error(c, http.StatusBadRequest, err.Error()); return }
+	if req.Quantity <= 0 { req.Quantity = 1 }
+	result, err := h.store.BuyItem(cl.UserID, req.ItemID, req.ItemName, req.Currency, req.Amount, req.Quantity)
+	if err != nil { response.Error(c, http.StatusBadRequest, err.Error()); return }
+	response.OK(c, result)
+}
+
+type useReq struct {
+	ItemID string `json:"item_id" binding:"required"`
+}
+
+// UseItem 使用道具
+func (h *Handler) UseItem(c *gin.Context) {
+	claims, _ := c.Get("claims"); cl := claims.(*Claims)
+	var req useReq
+	if err := c.ShouldBindJSON(&req); err != nil { response.Error(c, http.StatusBadRequest, err.Error()); return }
+	result, err := h.store.UseItem(cl.UserID, req.ItemID)
+	if err != nil { response.Error(c, http.StatusBadRequest, err.Error()); return }
+	response.OK(c, result)
+}
+
+// AuthMiddleware JWT 认证中间件
+func (h *Handler) AuthMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		auth := c.GetHeader("Authorization")
+		if auth == "" {
+			response.Error(c, http.StatusUnauthorized, "缺少认证令牌")
+			c.Abort()
+			return
+		}
+		parts := strings.SplitN(auth, " ", 2)
+		if len(parts) != 2 || parts[0] != "Bearer" {
+			response.Error(c, http.StatusUnauthorized, "认证格式错误")
+			c.Abort()
+			return
+		}
+		claims, err := h.jwt.Verify(parts[1])
+		if err != nil {
+			response.Error(c, http.StatusUnauthorized, "令牌无效或已过期")
+			c.Abort()
+			return
+		}
+		c.Set("claims", claims)
+		c.Next()
+	}
+}