986 lines
22 KiB
Go
986 lines
22 KiB
Go
package util
|
||
|
||
import (
|
||
"backend/msg"
|
||
"bytes"
|
||
"crypto/aes"
|
||
"crypto/cipher"
|
||
crand "crypto/rand"
|
||
"encoding/base64"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"log"
|
||
"math/rand"
|
||
"net"
|
||
"os"
|
||
"path/filepath"
|
||
"reflect"
|
||
"regexp"
|
||
"slices"
|
||
"strconv"
|
||
"strings"
|
||
"text/template"
|
||
"time"
|
||
"unicode"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/gorilla/websocket"
|
||
"google.golang.org/protobuf/proto"
|
||
)
|
||
|
||
var MergeData = make(map[string]interface{})
|
||
var MergeEmitData = make(map[string]interface{})
|
||
var FrameData = make(map[string]interface{})
|
||
var CardData = make(map[string]interface{})
|
||
var CardCollectData = make(map[string]interface{})
|
||
var NetAssetData = make(map[string]interface{})
|
||
var ItemData = make(map[string]interface{})
|
||
|
||
func init() {
|
||
data, err := os.ReadFile("config/MergeData.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal MergeData.json: %v", err)
|
||
} else {
|
||
MergeData = m
|
||
}
|
||
}
|
||
data, err = os.ReadFile("config/MergeDataEmit.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal MergeEmitData.json: %v", err)
|
||
} else {
|
||
MergeEmitData = m
|
||
}
|
||
}
|
||
data, err = os.ReadFile("config/Avatar.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal FrameData.json: %v", err)
|
||
} else {
|
||
FrameData = m
|
||
}
|
||
}
|
||
data, err = os.ReadFile("config/CardDetail.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal CardData.json: %v", err)
|
||
} else {
|
||
CardData = m
|
||
}
|
||
}
|
||
|
||
data, err = os.ReadFile("config/CardCollect.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal CardCollectData.json: %v", err)
|
||
} else {
|
||
CardCollectData = m
|
||
}
|
||
}
|
||
data, err = os.ReadFile("config/NetAssetData.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal NetAssetData.json: %v", err)
|
||
} else {
|
||
NetAssetData = m
|
||
}
|
||
}
|
||
data, err = os.ReadFile("config/Item.json")
|
||
if err == nil {
|
||
var m map[string]interface{}
|
||
if err := json.Unmarshal(data, &m); err != nil {
|
||
log.Printf("failed to unmarshal ItemData.json: %v", err)
|
||
} else {
|
||
ItemData = m
|
||
}
|
||
}
|
||
}
|
||
|
||
func GetItemName(itemId int) string {
|
||
id := strconv.Itoa(itemId)
|
||
if v, ok := ItemData[id]; ok && v != nil {
|
||
entry, ok := v.(map[string]interface{})
|
||
if ok {
|
||
return String(entry["Name"])
|
||
}
|
||
}
|
||
return id
|
||
}
|
||
|
||
// 获取结构体名称
|
||
func GetStructName(v interface{}) string {
|
||
t := reflect.TypeOf(v)
|
||
if t.Kind() == reflect.Ptr {
|
||
t = t.Elem()
|
||
}
|
||
if t.Kind() == reflect.Struct {
|
||
return t.Name()
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func PackMsg(m proto.Message) []byte {
|
||
buf, _ := proto.Marshal(m)
|
||
Func := GetStructName(m)
|
||
req := &msg.AdminReq{
|
||
Func: Func,
|
||
Info: buf,
|
||
}
|
||
buf, _ = proto.Marshal(req)
|
||
return append([]byte{0, 2}, buf...)
|
||
}
|
||
|
||
func UnpackMsg(buf []byte, n int) (string, error) {
|
||
// 检查数据长度
|
||
if n < 2 {
|
||
return "", fmt.Errorf("message too short: got %d bytes, need at least 2", n)
|
||
}
|
||
res := &msg.AdminRes{}
|
||
err := proto.Unmarshal(buf[2:n], res)
|
||
if err != nil {
|
||
// 记录更详细的错误信息
|
||
log.Printf("UnpackMsg error: %v, data length: %d, hex: %x", err, n-2, buf[2:n])
|
||
return "", fmt.Errorf("proto unmarshal error: %v", err)
|
||
}
|
||
return res.Info, nil
|
||
}
|
||
|
||
func ParseUid(uid int) (int, int) {
|
||
AppId := uid / 100000000
|
||
ServerId := uid % 100000000 / 100000
|
||
return AppId, ServerId
|
||
}
|
||
|
||
func Int(a interface{}) int {
|
||
if a == nil {
|
||
return 0
|
||
}
|
||
switch v := a.(type) {
|
||
case int:
|
||
return v
|
||
case int32:
|
||
return int(v)
|
||
case int64:
|
||
return int(v)
|
||
case float64:
|
||
return int(v)
|
||
case string:
|
||
r, err := strconv.Atoi(v)
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return r
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func String(a interface{}) string {
|
||
if a == nil {
|
||
return ""
|
||
}
|
||
switch v := a.(type) {
|
||
case string:
|
||
return v
|
||
case int:
|
||
return strconv.Itoa(v)
|
||
case int32:
|
||
return strconv.Itoa(int(v))
|
||
case int64:
|
||
return strconv.FormatInt(v, 10)
|
||
case float64:
|
||
return strconv.FormatFloat(v, 'f', -1, 64)
|
||
case []byte:
|
||
return string(v)
|
||
default:
|
||
rv := reflect.ValueOf(a)
|
||
if !rv.IsValid() {
|
||
return ""
|
||
}
|
||
// unwrap pointer
|
||
if rv.Kind() == reflect.Ptr && !rv.IsNil() {
|
||
rv = rv.Elem()
|
||
}
|
||
kind := rv.Kind()
|
||
// if it's a struct/map/slice/array convert to JSON
|
||
if kind == reflect.Struct || kind == reflect.Map || kind == reflect.Slice || kind == reflect.Array {
|
||
b, err := json.Marshal(a)
|
||
if err == nil {
|
||
return string(b)
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
}
|
||
|
||
func InArray(Id int, s []int) bool {
|
||
for _, v := range s {
|
||
if v == Id {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func Now() int64 {
|
||
return time.Now().Unix()
|
||
}
|
||
|
||
func Year() int {
|
||
return time.Now().Year()
|
||
}
|
||
|
||
func NowFormat() string {
|
||
return time.Now().Format("2006-01-02 15:04:05")
|
||
}
|
||
|
||
func SendAdminMsg(ws *websocket.Conn, req proto.Message) (map[string]interface{}, error) {
|
||
reqBuf := PackMsg(req)
|
||
err := ws.WriteMessage(websocket.BinaryMessage, reqBuf)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to write to websocket: %v", err)
|
||
}
|
||
|
||
_, readbuf, err := ws.ReadMessage()
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to read from websocket: %v", err)
|
||
}
|
||
n := len(readbuf)
|
||
|
||
resBuf, err := UnpackMsg(readbuf, n)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to unpack message: %v", err)
|
||
}
|
||
|
||
r := make(map[string]interface{})
|
||
err = json.Unmarshal([]byte(resBuf), &r)
|
||
if err != nil {
|
||
log.Printf("Failed to unmarshal response: %v, %s", err, resBuf)
|
||
return nil, fmt.Errorf("failed to unmarshal response: %v, %s", err, resBuf)
|
||
}
|
||
return r, nil
|
||
}
|
||
|
||
func FloatDecimals(f float64, n int) float64 {
|
||
format := fmt.Sprintf("%%.%df", n)
|
||
r, _ := strconv.ParseFloat(fmt.Sprintf(format, f), 64)
|
||
return r
|
||
}
|
||
|
||
// 将两个参数转换成浮点数，如果无法转换则为0，实现两个浮点数的除法，除数为0的话，返回0
|
||
func FloatDiv(a, b interface{}, Decimal int) float64 {
|
||
af := toFloat64(a)
|
||
bf := toFloat64(b)
|
||
if bf == 0 {
|
||
return 0
|
||
}
|
||
result := af / bf
|
||
format := fmt.Sprintf("%%.%df", Decimal)
|
||
r, _ := strconv.ParseFloat(fmt.Sprintf(format, result), 64)
|
||
return r
|
||
}
|
||
|
||
func Decimal(f float64, n int) float64 {
|
||
format := fmt.Sprintf("%%.%df", n)
|
||
r, _ := strconv.ParseFloat(fmt.Sprintf(format, f), 64)
|
||
return r
|
||
}
|
||
|
||
// 辅助函数：将interface{}转换为float64
|
||
func toFloat64(v interface{}) float64 {
|
||
switch val := v.(type) {
|
||
case int:
|
||
return float64(val)
|
||
case int32:
|
||
return float64(val)
|
||
case int64:
|
||
return float64(val)
|
||
case float32:
|
||
return float64(val)
|
||
case float64:
|
||
return val
|
||
case string:
|
||
r, err := strconv.ParseFloat(val, 64)
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return r
|
||
default:
|
||
return 0
|
||
}
|
||
}
|
||
|
||
const (
|
||
SECRET_KEY = ")VQbB(vpy=U(wcp)"
|
||
)
|
||
|
||
// 加密字符串
|
||
func Encrypt(plainText string) (string, error) {
|
||
block, err := aes.NewCipher([]byte(SECRET_KEY))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
cipherText := make([]byte, aes.BlockSize+len(plainText))
|
||
iv := cipherText[:aes.BlockSize]
|
||
if _, err := io.ReadFull(crand.Reader, iv); err != nil {
|
||
return "", err
|
||
}
|
||
|
||
stream := cipher.NewCFBEncrypter(block, iv)
|
||
stream.XORKeyStream(cipherText[aes.BlockSize:], []byte(plainText))
|
||
|
||
return base64.URLEncoding.EncodeToString(cipherText), nil
|
||
}
|
||
|
||
// 解密字符串
|
||
func Decrypt(cipherText string) (string, error) {
|
||
cipherTextBytes, err := base64.URLEncoding.DecodeString(cipherText)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
block, err := aes.NewCipher([]byte(SECRET_KEY))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
|
||
if len(cipherTextBytes) < aes.BlockSize {
|
||
return "", fmt.Errorf("cipherText too short")
|
||
}
|
||
|
||
iv := cipherTextBytes[:aes.BlockSize]
|
||
cipherTextBytes = cipherTextBytes[aes.BlockSize:]
|
||
|
||
stream := cipher.NewCFBDecrypter(block, iv)
|
||
stream.XORKeyStream(cipherTextBytes, cipherTextBytes)
|
||
|
||
return string(cipherTextBytes), nil
|
||
}
|
||
|
||
func ParseTmpl(file string, data interface{}) string {
|
||
t, err := template.ParseFiles(file)
|
||
if err != nil {
|
||
log.Fatalf("failed to parse template file: %v", err)
|
||
}
|
||
var buf bytes.Buffer
|
||
err = t.Execute(&buf, data)
|
||
if err != nil {
|
||
log.Fatalf("failed to execute template: %v", err)
|
||
}
|
||
s := buf.String()
|
||
return s
|
||
}
|
||
|
||
// 将字符串转换成一行的字符串格式，并再进行一次转义输出
|
||
func ToTmplStr(input string) string {
|
||
// 转义换行符
|
||
escapedStr := strings.ReplaceAll(input, "\r", "")
|
||
escapedStr = strings.ReplaceAll(escapedStr, "\n", "\\n")
|
||
escapedStr = strings.ReplaceAll(escapedStr, "\"", "\\\"")
|
||
// 转义输出
|
||
// return template.HTMLEscapeString(escapedStr)
|
||
return escapedStr
|
||
}
|
||
|
||
func Ternary(condition bool, trueVal, falseVal interface{}) interface{} {
|
||
if condition {
|
||
return trueVal
|
||
}
|
||
return falseVal
|
||
}
|
||
|
||
func TimestampToDate(timestamp int64, Tz string) string {
|
||
loc, err := time.LoadLocation(Tz)
|
||
if err != nil {
|
||
log.Printf("failed to load location %s: %v", Tz, err)
|
||
loc = time.UTC // 默认使用UTC
|
||
}
|
||
t := time.Unix(timestamp, 0).In(loc)
|
||
return t.Format("2006-01-02")
|
||
}
|
||
func TimestampToDateTime(timestamp int64, Tz string) string {
|
||
loc, err := time.LoadLocation(Tz)
|
||
if err != nil {
|
||
log.Printf("failed to load location %s: %v", Tz, err)
|
||
loc = time.UTC // 默认使用UTC
|
||
}
|
||
t := time.Unix(timestamp, 0).In(loc)
|
||
return t.Format("2006-01-02 15:04:05")
|
||
}
|
||
|
||
func GenerateToken() string {
|
||
// 生成一个安全的随机token，适合网页登录
|
||
b := make([]byte, 32)
|
||
if _, err := crand.Read(b); err != nil {
|
||
return ""
|
||
}
|
||
return base64.URLEncoding.EncodeToString(b)
|
||
}
|
||
|
||
func GeneratedCode(Phone string) (string, error) {
|
||
Code := Rand6DigitNumber()
|
||
err := SmsCode(Phone, Code)
|
||
if err != nil {
|
||
return "", fmt.Errorf("failed to send SMS code: %v", err)
|
||
}
|
||
return Code, err
|
||
}
|
||
|
||
func Rand6DigitNumber() string {
|
||
n := rand.Intn(1000000)
|
||
return fmt.Sprintf("%06d", n)
|
||
}
|
||
|
||
func GetToken(c *gin.Context) string {
|
||
// 从请求头中获取Token
|
||
token := c.GetHeader("Authorization")
|
||
if len(token) > 7 && token[:7] == "Bearer " {
|
||
token = token[7:] // 去掉"Bearer "前缀
|
||
}
|
||
return token
|
||
}
|
||
|
||
const (
|
||
RoleSuper = "super"
|
||
RoleAdmin = "admin"
|
||
RoleUser = "user"
|
||
RoleWbTransfer = "wb_transfer"
|
||
RoleGuest = "guest"
|
||
)
|
||
|
||
func GetRole(code int) string {
|
||
switch code {
|
||
case 0:
|
||
return RoleSuper
|
||
case 1:
|
||
return RoleAdmin
|
||
case 2:
|
||
return RoleUser
|
||
case 99:
|
||
return RoleWbTransfer
|
||
default:
|
||
return RoleGuest
|
||
}
|
||
}
|
||
|
||
func ToJson(v interface{}) string {
|
||
data, err := json.Marshal(v)
|
||
if err != nil {
|
||
log.Printf("failed to marshal to JSON: %v", err)
|
||
return ""
|
||
}
|
||
return string(data)
|
||
}
|
||
|
||
func AddAdminLog(c *gin.Context, action string, params interface{}) {
|
||
admin := c.GetString("admin")
|
||
ip := c.ClientIP()
|
||
db := MPool.GetGameDB()
|
||
defer db.Close()
|
||
_, err := db.Exec("INSERT INTO admin_log (admin, action, params, ip, createTime) VALUES (?, ?, ?, ?, ?)",
|
||
admin, action, ToJson(params), ip, Now())
|
||
if err != nil {
|
||
fmt.Printf("failed to insert admin log: %v", err)
|
||
return
|
||
}
|
||
}
|
||
|
||
func ParseParam(s string) map[string]interface{} {
|
||
result := make(map[string]interface{})
|
||
if strings.TrimSpace(s) == "" {
|
||
return result
|
||
}
|
||
if err := json.Unmarshal([]byte(s), &result); err != nil {
|
||
return map[string]interface{}{}
|
||
}
|
||
return result
|
||
}
|
||
|
||
func CheckContainChess(ChessList []string, Emit []string) bool {
|
||
if len(Emit) == 0 {
|
||
return true
|
||
}
|
||
for _, c := range ChessList {
|
||
d, ok := MergeData[c]
|
||
if !ok {
|
||
continue
|
||
}
|
||
if d == nil {
|
||
continue
|
||
}
|
||
m, ok := d.(map[string]interface{})
|
||
if !ok {
|
||
continue
|
||
}
|
||
Color := m["Color"].(string)
|
||
Serise := getSeriseByColor(Color)
|
||
if InArrayStr(Serise, Emit) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func InArrayStr(s string, arr []string) bool {
|
||
return slices.Contains(arr, s)
|
||
}
|
||
|
||
func getSeriseByColor(Color string) string {
|
||
for k, v := range MergeEmitData {
|
||
d := v.(map[string]interface{})
|
||
colors, ok := d["Order_Type"].(string)
|
||
if !ok {
|
||
continue
|
||
}
|
||
colorList := strings.Split(colors, ",")
|
||
if InArrayStr(Color, colorList) {
|
||
return k
|
||
}
|
||
}
|
||
return Color
|
||
}
|
||
|
||
func Success(c *gin.Context, message string) {
|
||
c.JSON(200, gin.H{
|
||
"code": 0,
|
||
"message": message,
|
||
})
|
||
}
|
||
|
||
func LoginSuccess(c *gin.Context, message string, Port int, Host string, ServerId int) {
|
||
c.JSON(200, gin.H{
|
||
"code": 0,
|
||
"message": message,
|
||
"Port": Port,
|
||
"Host": Host,
|
||
"ServerId": ServerId,
|
||
})
|
||
}
|
||
|
||
func GetChessURL(ChessId string) string {
|
||
key := fmt.Sprintf("UI_MergeData_%s", ChessId)
|
||
return GetLanguageImageURL(key)
|
||
}
|
||
|
||
func GetLanguageImageURL(key string) string {
|
||
// 检查是否符合 UI_MergeData_<id> 格式
|
||
re := regexp.MustCompile(`^UI_MergeData_(\d+)$`)
|
||
m := re.FindStringSubmatch(key)
|
||
if len(m) == 2 {
|
||
id := m[1]
|
||
// 从 MergeData 中取出对应 id 的 Icon 字段
|
||
if v, ok := MergeData[id]; ok && v != nil {
|
||
if entry, ok2 := v.(map[string]interface{}); ok2 {
|
||
var iconStr string
|
||
if iv, ok3 := entry["Icon"]; ok3 && iv != nil {
|
||
switch t := iv.(type) {
|
||
case string:
|
||
iconStr = t
|
||
case float64:
|
||
iconStr = strconv.Itoa(int(t))
|
||
default:
|
||
iconStr = fmt.Sprintf("%v", t)
|
||
}
|
||
}
|
||
if iconStr != "" {
|
||
// baseDir := `D:\Github\AplusB_Pet_nation\Assets\GameMain\UI\UISprites\MergeObj`
|
||
baseDir := `/data/AplusB_Pet_nation/Assets/Art_SubModule/GameMain/UI/UISprites/MergeObj`
|
||
if fi, err := os.Stat(baseDir); err == nil && fi.IsDir() {
|
||
var found string
|
||
walkErr := filepath.Walk(baseDir, func(path string, info os.FileInfo, err error) error {
|
||
if err != nil {
|
||
return nil
|
||
}
|
||
if info.IsDir() {
|
||
return nil
|
||
}
|
||
// 忽略大小写匹配文件名包含 iconStr
|
||
if strings.Contains(strings.ToLower(info.Name()), strings.ToLower(iconStr)) {
|
||
found = path
|
||
return errors.New("found")
|
||
}
|
||
return nil
|
||
})
|
||
if found != "" {
|
||
// 截取从 "Assets" 开始的相对路径，统一为斜杠形式
|
||
lower := strings.ToLower(found)
|
||
idx := strings.Index(lower, "assets")
|
||
if idx >= 0 {
|
||
return filepath.ToSlash(found[idx:])
|
||
}
|
||
return filepath.ToSlash(found)
|
||
}
|
||
if walkErr != nil && walkErr.Error() == "found" && found != "" {
|
||
lower := strings.ToLower(found)
|
||
idx := strings.Index(lower, "assets")
|
||
if idx >= 0 {
|
||
return filepath.ToSlash(found[idx:])
|
||
}
|
||
return filepath.ToSlash(found)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 头像
|
||
reHead := regexp.MustCompile(`^Data_HeadName_(\d+)$`)
|
||
if m := reHead.FindStringSubmatch(key); len(m) == 2 {
|
||
id := Int(m[1])
|
||
return GetFaceURL(id)
|
||
}
|
||
// 头像框
|
||
reFrame := regexp.MustCompile(`^Data_HeadFrameName_(\d+)$`)
|
||
if m := reFrame.FindStringSubmatch(key); len(m) == 2 {
|
||
id := Int(m[1])
|
||
return GetFrameURL(id)
|
||
}
|
||
// Emoji
|
||
reEmoji := regexp.MustCompile(`^Data_EmojiName_(\d+)$`)
|
||
if m := reEmoji.FindStringSubmatch(key); len(m) == 2 {
|
||
return GetEmojiURL(Int(m[1]))
|
||
}
|
||
// 卡牌
|
||
reCard := regexp.MustCompile(`^UI_MainCardPanel_cardName_`)
|
||
if reCard.MatchString(key) {
|
||
parts := strings.Split(key, "_")
|
||
name := strings.TrimSpace(parts[len(parts)-1])
|
||
for _, v := range CardData {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
entry, ok := v.(map[string]interface{})
|
||
if !ok {
|
||
continue
|
||
}
|
||
if String(entry["Name"]) == name {
|
||
icon := String(entry["Icon"])
|
||
if icon != "" {
|
||
return fmt.Sprintf("UI/UISprites/%s.png", icon)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 卡牌收集
|
||
reCardCollect := regexp.MustCompile(`^UI_MainCardPanel_groupName_`)
|
||
if reCardCollect.MatchString(key) {
|
||
parts := strings.Split(key, "_")
|
||
name := strings.TrimSpace(parts[len(parts)-1])
|
||
for _, v := range CardCollectData {
|
||
if v == nil {
|
||
continue
|
||
}
|
||
entry, ok := v.(map[string]interface{})
|
||
if !ok {
|
||
continue
|
||
}
|
||
if String(entry["Name"]) == name {
|
||
return String(entry["ResourcesPath"])
|
||
}
|
||
}
|
||
}
|
||
//猫咪毛皮
|
||
reCat := regexp.MustCompile(`^UI_PetFurName_(\d+)$`)
|
||
if m := reCat.FindStringSubmatch(key); len(m) == 2 {
|
||
id := Int(m[1])
|
||
return fmt.Sprintf("UI/UISprites/Shop/Packed/Skin_pic_cat%d.png", id)
|
||
}
|
||
|
||
// 场景预览图
|
||
reScene := regexp.MustCompile(`^CS_ScenePanel_Scene(\d+)$`)
|
||
m = reScene.FindStringSubmatch(key)
|
||
if len(m) == 2 {
|
||
return fmt.Sprintf("UI/UISprites/Area/merge_pic_s%s.png", m[1])
|
||
}
|
||
//发射器插图
|
||
reNetAsset := regexp.MustCompile(`^UI_MainLvPanel_chapterTip_lv_(\d+)$`)
|
||
if reNetAsset.MatchString(key) {
|
||
if v, ok := NetAssetData[key]; ok && v != nil {
|
||
entry, ok := v.(map[string]interface{})
|
||
if !ok {
|
||
return ""
|
||
}
|
||
icon := String(entry["Picture"])
|
||
if icon != "" {
|
||
return fmt.Sprintf("UI/UISprites/%s.png", icon)
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func ParseNodeTags(tags string) []string {
|
||
if tags == "" {
|
||
return []string{}
|
||
}
|
||
return strings.Split(tags, ",")
|
||
}
|
||
|
||
func GetAppName(AppId int) string {
|
||
switch AppId {
|
||
case 0:
|
||
return "正式服"
|
||
case 1:
|
||
return "测试服"
|
||
case 2:
|
||
return "QA服"
|
||
default:
|
||
return "未知服"
|
||
}
|
||
}
|
||
|
||
func GetAppRegion(AppId int) string {
|
||
switch AppId {
|
||
case 0:
|
||
return "prod"
|
||
default:
|
||
return "test"
|
||
}
|
||
}
|
||
|
||
func GetEmojiURL(EmojiId int) string {
|
||
return _GetURL(EmojiId, 109)
|
||
}
|
||
|
||
func GetFaceURL(HeadId int) string {
|
||
return _GetURL(HeadId, 110)
|
||
}
|
||
|
||
func GetFrameURL(FrameId int) string {
|
||
return _GetURL(FrameId, 105)
|
||
}
|
||
|
||
func _GetURL(Id, Type int) string {
|
||
for _, v := range ItemData {
|
||
info, ok := v.(map[string]interface{})
|
||
if !ok {
|
||
continue
|
||
}
|
||
if Int(info["IType"]) == Type {
|
||
effect := String(info["Effect"])
|
||
effectList := strings.Split(effect, ",")
|
||
if Id == Int(effectList[0]) && len(effectList) > 0 {
|
||
return info["FullResourcePath"].(string)
|
||
}
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func GetCardURL(CardId string) string {
|
||
info, ok := CardData[CardId]
|
||
if ok && info != nil {
|
||
entry, ok := info.(map[string]interface{})
|
||
if ok {
|
||
return String(entry["ResourcesPath"])
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func GetCardCollectURL(name string) string {
|
||
for _, v := range CardCollectData {
|
||
info, ok := v.(map[string]interface{})
|
||
if !ok {
|
||
continue
|
||
}
|
||
if String(info["Name"]) == name {
|
||
return String(info["ResourcesPath"])
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func GetNetAssetURL(Key string) string {
|
||
info, ok := NetAssetData[Key]
|
||
if ok && info != nil {
|
||
entry, ok := info.(map[string]interface{})
|
||
if ok {
|
||
return String(entry["Picture"])
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func CountDisplayLen(s string) int {
|
||
total := 0
|
||
for _, r := range s {
|
||
if unicode.In(r, unicode.Han) {
|
||
total += 2
|
||
continue
|
||
}
|
||
total += 1
|
||
}
|
||
return total
|
||
}
|
||
|
||
func FormatJson(v string) string {
|
||
var data interface{}
|
||
err := json.Unmarshal([]byte(v), &data)
|
||
if err != nil {
|
||
log.Printf("failed to unmarshal JSON: %v", err)
|
||
return ""
|
||
}
|
||
jsonBytes, err := json.Marshal(data)
|
||
if err != nil {
|
||
log.Printf("failed to marshal JSON: %v", err)
|
||
return ""
|
||
}
|
||
return string(jsonBytes)
|
||
}
|
||
|
||
func GetAddressLatency(Host string, Port int) (int64, error) {
|
||
address := fmt.Sprintf("%s:%d", Host, Port)
|
||
timeout := 3 * time.Second
|
||
start := time.Now()
|
||
conn, err := net.DialTimeout("tcp", address, timeout)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
conn.Close()
|
||
latency := time.Since(start).Milliseconds()
|
||
return latency, nil
|
||
}
|
||
|
||
func Float(a interface{}) float64 {
|
||
if a == nil {
|
||
return 0
|
||
}
|
||
return toFloat64(a)
|
||
}
|
||
|
||
func parseMemoryTextToMB(value string) float64 {
|
||
s := strings.TrimSpace(strings.ToUpper(value))
|
||
if s == "" {
|
||
return 0
|
||
}
|
||
|
||
multiplier := 1.0
|
||
switch {
|
||
case strings.HasSuffix(s, "TB"):
|
||
multiplier = 1024 * 1024
|
||
s = strings.TrimSuffix(s, "TB")
|
||
case strings.HasSuffix(s, "GB"):
|
||
multiplier = 1024
|
||
s = strings.TrimSuffix(s, "GB")
|
||
case strings.HasSuffix(s, "MB"):
|
||
s = strings.TrimSuffix(s, "MB")
|
||
case strings.HasSuffix(s, "KB"):
|
||
multiplier = 1.0 / 1024
|
||
s = strings.TrimSuffix(s, "KB")
|
||
case strings.HasSuffix(s, "B"):
|
||
multiplier = 1.0 / (1024 * 1024)
|
||
s = strings.TrimSuffix(s, "B")
|
||
}
|
||
|
||
numberText := strings.TrimSpace(s)
|
||
if numberText == "" {
|
||
return 0
|
||
}
|
||
|
||
parsed, err := strconv.ParseFloat(numberText, 64)
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
if parsed < 0 {
|
||
return 0
|
||
}
|
||
return parsed * multiplier
|
||
}
|
||
|
||
func clampFloat(value, min, max float64) float64 {
|
||
if value < min {
|
||
return min
|
||
}
|
||
if value > max {
|
||
return max
|
||
}
|
||
return value
|
||
}
|
||
|
||
func GetServerWeight(resp *msg.ResServerInfo) int {
|
||
const (
|
||
memCapMB = 16384.0
|
||
playerSoftCap = 1500.0
|
||
goroutineSoftCap = 20000.0
|
||
gcSoftCap = 2000.0
|
||
warmupSeconds = 600.0
|
||
)
|
||
|
||
freeMemMB := float64(resp.FreeMem)
|
||
if freeMemMB < 0 {
|
||
freeMemMB = 0
|
||
}
|
||
|
||
usagePercent := clampFloat(float64(resp.UsageMem), 0, 100)
|
||
if usagePercent == 0 && resp.Sys > 0 {
|
||
allocMB := parseMemoryTextToMB(resp.Alloc)
|
||
sysMB := float64(resp.Sys) / 1024 / 1024
|
||
if sysMB > 0 && allocMB > 0 {
|
||
usagePercent = clampFloat(allocMB/sysMB*100, 0, 100)
|
||
}
|
||
}
|
||
|
||
memScore := clampFloat(freeMemMB/memCapMB*100, 0, 100)
|
||
memPressureScore := 100 - usagePercent
|
||
cpuScore := 100 - clampFloat(resp.CPU, 0, 100)
|
||
playerScore := 100 - clampFloat(float64(resp.PlayerNum)/playerSoftCap*100, 0, 100)
|
||
goroutineScore := 100 - clampFloat(float64(resp.NumGoroutine)/goroutineSoftCap*100, 0, 100)
|
||
gcScore := 100 - clampFloat(float64(resp.NumGC)/gcSoftCap*100, 0, 100)
|
||
|
||
warmupScore := 100.0
|
||
if resp.StartTime > 0 {
|
||
uptime := float64(Now() - int64(resp.StartTime))
|
||
if uptime < 0 {
|
||
uptime = 0
|
||
}
|
||
warmupScore = clampFloat(uptime/warmupSeconds*100, 0, 100)
|
||
}
|
||
|
||
allocRatioScore := 100.0
|
||
totalAllocMB := parseMemoryTextToMB(resp.TotalAlloc)
|
||
allocMB := parseMemoryTextToMB(resp.Alloc)
|
||
if totalAllocMB > 0 && allocMB >= 0 {
|
||
allocRatioScore = 100 - clampFloat(allocMB/totalAllocMB*100, 0, 100)
|
||
}
|
||
|
||
weight :=
|
||
memScore*0.22 +
|
||
memPressureScore*0.23 +
|
||
cpuScore*0.23 +
|
||
playerScore*0.18 +
|
||
goroutineScore*0.05 +
|
||
gcScore*0.03 +
|
||
warmupScore*0.03 +
|
||
allocRatioScore*0.02
|
||
|
||
return int(clampFloat(weight, 1, 100))
|
||
}
|
||
|
||
func LogStructured(level string, message string, fields map[string]any) {
|
||
payload := map[string]any{
|
||
"level": level,
|
||
"msg": message,
|
||
"time": time.Now().Format(time.RFC3339),
|
||
}
|
||
for key, value := range fields {
|
||
payload[key] = value
|
||
}
|
||
data, err := json.Marshal(payload)
|
||
if err != nil {
|
||
log.Printf("level=%s msg=%q marshal_error=%v", level, message, err)
|
||
return
|
||
}
|
||
log.Print(string(data))
|
||
}
|