格式化代码

common/region/region.go

@@ -1,11 +1,11 @@
 package region
 
 import (
-	"hk4e/pkg/random"
 	"os"
 
 	"hk4e/pkg/endec"
 	"hk4e/pkg/logger"
+	"hk4e/pkg/random"
 	"hk4e/protocol/proto"
 )
 
@@ -14,20 +14,20 @@ func LoadRsaKey() (signRsaKey []byte, encRsaKeyMap map[string][]byte, pwdRsaKey
 	encRsaKeyMap = make(map[string][]byte)
 	signRsaKey, err = os.ReadFile("key/region_sign_key.pem")
 	if err != nil {
-		logger.LOG.Error("open region_sign_key.pem error: %v", err)
+		logger.Error("open region_sign_key.pem error: %v", err)
 		return nil, nil, nil
 	}
 	encKeyIdList := []string{"2", "3", "4", "5"}
 	for _, v := range encKeyIdList {
 		encRsaKeyMap[v], err = os.ReadFile("key/region_enc_key_" + v + ".pem")
 		if err != nil {
-			logger.LOG.Error("open region_enc_key_"+v+".pem error: %v", err)
+			logger.Error("open region_enc_key_"+v+".pem error: %v", err)
 			return nil, nil, nil
 		}
 	}
 	pwdRsaKey, err = os.ReadFile("key/account_password_key.pem")
 	if err != nil {
-		logger.LOG.Error("open account_password_key.pem error: %v", err)
+		logger.Error("open account_password_key.pem error: %v", err)
 		return nil, nil, nil
 	}
 	return signRsaKey, encRsaKeyMap, pwdRsaKey

common/region/region_test.go

@@ -3,9 +3,11 @@ package region
 import (
 	"encoding/base64"
 	"fmt"
-	pb "google.golang.org/protobuf/proto"
-	"hk4e/protocol/proto"
 	"testing"
+
+	"hk4e/protocol/proto"
+
+	pb "google.golang.org/protobuf/proto"
 )
 
 func TestRegion(t *testing.T) {

dispatch/app/app.go

@@ -18,7 +18,7 @@ func Run(ctx context.Context, configFile string) error {
 	config.InitConfig(configFile)
 
 	logger.InitLogger("dispatch")
-	logger.LOG.Info("dispatch start")
+	logger.Warn("dispatch start")
 
 	db := dao.NewDao()
 	defer db.CloseDao()
@@ -32,10 +32,10 @@ func Run(ctx context.Context, configFile string) error {
 		case <-ctx.Done():
 			return nil
 		case s := <-c:
-			logger.LOG.Info("get a signal %s", s.String())
+			logger.Warn("get a signal %s", s.String())
 			switch s {
 			case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
-				logger.LOG.Info("dispatch exit")
+				logger.Warn("dispatch exit")
 
 				time.Sleep(time.Second)
 				return nil

dispatch/controller/controller.go

@@ -2,7 +2,6 @@ package controller
 
 import (
 	"encoding/base64"
-	"hk4e/pkg/random"
 	"net/http"
 	"strconv"
 
@@ -10,6 +9,7 @@ import (
 	"hk4e/common/region"
 	"hk4e/dispatch/dao"
 	"hk4e/pkg/logger"
+	"hk4e/pkg/random"
 
 	"github.com/gin-gonic/gin"
 	pb "google.golang.org/protobuf/proto"
@@ -35,13 +35,13 @@ func NewController(dao *dao.Dao) (r *Controller) {
 	r.signRsaKey, r.encRsaKeyMap, r.pwdRsaKey = region.LoadRsaKey()
 	regionCurrModify, err := pb.Marshal(regionCurr)
 	if err != nil {
-		logger.LOG.Error("Marshal QueryCurrRegionHttpRsp error")
+		logger.Error("Marshal QueryCurrRegionHttpRsp error")
 		return nil
 	}
 	r.regionCurrBase64 = base64.StdEncoding.EncodeToString(regionCurrModify)
 	regionListModify, err := pb.Marshal(regionList)
 	if err != nil {
-		logger.LOG.Error("Marshal QueryRegionListHttpRsp error")
+		logger.Error("Marshal QueryRegionListHttpRsp error")
 		return nil
 	}
 	r.regionListBase64 = base64.StdEncoding.EncodeToString(regionListModify)
@@ -75,7 +75,7 @@ func (c *Controller) registerRouter() {
 	{
 		// 404
 		engine.NoRoute(func(context *gin.Context) {
-			logger.LOG.Info("no route find, fallback to fuck mhy, url: %v", context.Request.RequestURI)
+			logger.Info("no route find, fallback to fuck mhy, url: %v", context.Request.RequestURI)
 			context.Header("Content-type", "text/html; charset=UTF-8")
 			context.Status(http.StatusNotFound)
 			_, _ = context.Writer.WriteString("FUCK MHY")
@@ -148,6 +148,6 @@ func (c *Controller) registerRouter() {
 	addr := ":" + strconv.Itoa(int(port))
 	err := engine.Run(addr)
 	if err != nil {
-		logger.LOG.Error("gin run error: %v", err)
+		logger.Error("gin run error: %v", err)
 	}
 }

dispatch/controller/dispatch_controller.go

@@ -19,7 +19,7 @@ import (
 func (c *Controller) query_security_file(context *gin.Context) {
 	file, err := os.ReadFile("static/security_file")
 	if err != nil {
-		logger.LOG.Error("open security_file error")
+		logger.Error("open security_file error")
 		return
 	}
 	context.Header("Content-type", "text/html; charset=UTF-8")
@@ -39,7 +39,7 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 	}
 	reg, err := regexp.Compile("[0-9]+")
 	if err != nil {
-		logger.LOG.Error("compile regexp error: %v", err)
+		logger.Error("compile regexp error: %v", err)
 		return
 	}
 	versionSlice := reg.FindAllString(versionName, -1)
@@ -47,7 +47,7 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 	for index := 0; index < len(versionSlice); index++ {
 		v, err := strconv.Atoi(versionSlice[index])
 		if err != nil {
-			logger.LOG.Error("parse client version error: %v", err)
+			logger.Error("parse client version error: %v", err)
 			return
 		}
 		for i := 0; i < len(versionSlice)-1-index; i++ {
@@ -60,7 +60,7 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 		version /= 10
 	}
 	if version >= 275 {
-		logger.LOG.Debug("do hk4e 2.8 rsa logic")
+		logger.Debug("do hk4e 2.8 rsa logic")
 		if context.Query("dispatchSeed") == "" {
 			rsp := &api.QueryCurRegionRspJson{
 				Content: response,
@@ -72,12 +72,12 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 		keyId := context.Query("key_id")
 		encPubPrivKey, exist := c.encRsaKeyMap[keyId]
 		if !exist {
-			logger.LOG.Error("can not found key id: %v", keyId)
+			logger.Error("can not found key id: %v", keyId)
 			return
 		}
 		regionInfo, err := base64.StdEncoding.DecodeString(response)
 		if err != nil {
-			logger.LOG.Error("decode region info error: %v", err)
+			logger.Error("decode region info error: %v", err)
 			return
 		}
 		chunkSize := 256 - 11
@@ -90,47 +90,47 @@ func (c *Controller) query_cur_region(context *gin.Context) {
 			chunk := regionInfo[from:to]
 			pubKey, err := endec.RsaParsePubKeyByPrivKey(encPubPrivKey)
 			if err != nil {
-				logger.LOG.Error("parse rsa pub key error: %v", err)
+				logger.Error("parse rsa pub key error: %v", err)
 				return
 			}
 			privKey, err := endec.RsaParsePrivKey(encPubPrivKey)
 			if err != nil {
-				logger.LOG.Error("parse rsa priv key error: %v", err)
+				logger.Error("parse rsa priv key error: %v", err)
 				return
 			}
 			encrypt, err := endec.RsaEncrypt(chunk, pubKey)
 			if err != nil {
-				logger.LOG.Error("rsa enc error: %v", err)
+				logger.Error("rsa enc error: %v", err)
 				return
 			}
 			decrypt, err := endec.RsaDecrypt(encrypt, privKey)
 			if err != nil {
-				logger.LOG.Error("rsa dec error: %v", err)
+				logger.Error("rsa dec error: %v", err)
 				return
 			}
 			if bytes.Compare(decrypt, chunk) != 0 {
-				logger.LOG.Error("rsa dec test fail")
+				logger.Error("rsa dec test fail")
 				return
 			}
 			encryptedRegionInfo = append(encryptedRegionInfo, encrypt...)
 		}
 		signPrivkey, err := endec.RsaParsePrivKey(c.signRsaKey)
 		if err != nil {
-			logger.LOG.Error("parse rsa priv key error: %v", err)
+			logger.Error("parse rsa priv key error: %v", err)
 			return
 		}
 		signData, err := endec.RsaSign(regionInfo, signPrivkey)
 		if err != nil {
-			logger.LOG.Error("rsa sign error: %v", err)
+			logger.Error("rsa sign error: %v", err)
 			return
 		}
 		ok, err := endec.RsaVerify(regionInfo, signData, &signPrivkey.PublicKey)
 		if err != nil {
-			logger.LOG.Error("rsa verify error: %v", err)
+			logger.Error("rsa verify error: %v", err)
 			return
 		}
 		if !ok {
-			logger.LOG.Error("rsa verify test fail")
+			logger.Error("rsa verify test fail")
 			return
 		}
 		rsp := &api.QueryCurRegionRspJson{

dispatch/controller/fixed_controller.go

@@ -195,7 +195,7 @@ func (c *Controller) webp(context *gin.Context) {
 	context.Header("Content-type", "image/webp")
 	file, err := os.ReadFile("static/a330cf996.webp")
 	if err != nil {
-		logger.LOG.Error("open a330cf996.webp error")
+		logger.Error("open a330cf996.webp error")
 		return
 	}
 	_, _ = context.Writer.Write(file)
@@ -206,7 +206,7 @@ func (c *Controller) bgWebp(context *gin.Context) {
 	context.Header("Content-type", "image/webp")
 	file, err := os.ReadFile("static/86f9db021.webp")
 	if err != nil {
-		logger.LOG.Error("open 86f9db021.webp error")
+		logger.Error("open 86f9db021.webp error")
 		return
 	}
 	_, _ = context.Writer.Write(file)
@@ -217,7 +217,7 @@ func (c *Controller) slicePng(context *gin.Context) {
 	context.Header("Content-type", "image/png")
 	file, err := os.ReadFile("static/86f9db021.png")
 	if err != nil {
-		logger.LOG.Error("open 86f9db021.png error")
+		logger.Error("open 86f9db021.png error")
 		return
 	}
 	_, _ = context.Writer.Write(file)
@@ -228,7 +228,7 @@ func (c *Controller) sprite2xPng(context *gin.Context) {
 	context.Header("Content-type", "image/png")
 	file, err := os.ReadFile("static/sprite2x.1.2.6.png")
 	if err != nil {
-		logger.LOG.Error("open sprite2x.1.2.6.png error")
+		logger.Error("open sprite2x.1.2.6.png error")
 		return
 	}
 	_, _ = context.Writer.Write(file)

dispatch/controller/gate_controller.go

@@ -1,10 +1,12 @@
 package controller
 
 import (
-	"github.com/gin-gonic/gin"
-	"hk4e/pkg/logger"
 	"net/http"
 	"strconv"
+
+	"hk4e/pkg/logger"
+
+	"github.com/gin-gonic/gin"
 )
 
 type TokenVerifyReq struct {
@@ -25,7 +27,7 @@ func (c *Controller) gateTokenVerify(context *gin.Context) {
 	if err != nil {
 		return
 	}
-	logger.LOG.Debug("gate token verify, req: %v", tokenVerifyReq)
+	logger.Debug("gate token verify, req: %v", tokenVerifyReq)
 	accountId, err := strconv.ParseUint(tokenVerifyReq.AccountId, 10, 64)
 	if err != nil {
 		return

dispatch/controller/login_controller.go

@@ -3,13 +3,13 @@ package controller
 import (
 	"encoding/base64"
 	"encoding/json"
-	"hk4e/dispatch/model"
 	"net/http"
 	"regexp"
 	"strconv"
 	"strings"
 
 	"hk4e/dispatch/api"
+	"hk4e/dispatch/model"
 	"hk4e/pkg/endec"
 	"hk4e/pkg/logger"
 	"hk4e/pkg/random"
@@ -21,28 +21,28 @@ func (c *Controller) apiLogin(context *gin.Context) {
 	requestData := new(api.LoginAccountRequestJson)
 	err := context.ShouldBindJSON(requestData)
 	if err != nil {
-		logger.LOG.Error("parse LoginAccountRequestJson error: %v", err)
+		logger.Error("parse LoginAccountRequestJson error: %v", err)
 		return
 	}
 
 	encPwdData, err := base64.StdEncoding.DecodeString(requestData.Password)
 	if err != nil {
-		logger.LOG.Error("decode password enc data error: %v", err)
+		logger.Error("decode password enc data error: %v", err)
 		return
 	}
 	pwdPrivKey, err := endec.RsaParsePrivKey(c.pwdRsaKey)
 	if err != nil {
-		logger.LOG.Error("parse rsa key error: %v", err)
+		logger.Error("parse rsa key error: %v", err)
 		return
 	}
 	pwdDecData, err := endec.RsaDecrypt(encPwdData, pwdPrivKey)
 	useAtAtMode := false
 	if err != nil {
-		logger.LOG.Debug("rsa dec error: %v", err)
+		logger.Debug("rsa dec error: %v", err)
-		logger.LOG.Debug("password rsa dec fail, fallback to @@ mode")
+		logger.Debug("password rsa dec fail, fallback to @@ mode")
 		useAtAtMode = true
 	} else {
-		logger.LOG.Debug("password dec: %v", string(pwdDecData))
+		logger.Debug("password dec: %v", string(pwdDecData))
 		useAtAtMode = false
 	}
 
@@ -94,7 +94,7 @@ func (c *Controller) apiLogin(context *gin.Context) {
 	// TODO SDK账号登陆
 	account, err := c.dao.QueryAccountByField("username", username)
 	if err != nil {
-		logger.LOG.Error("query account from db error: %v", err)
+		logger.Error("query account from db error: %v", err)
 		return
 	}
 	if account == nil {
@@ -158,17 +158,17 @@ func (c *Controller) apiVerify(context *gin.Context) {
 	requestData := new(api.LoginTokenRequest)
 	err := context.ShouldBindJSON(requestData)
 	if err != nil {
-		logger.LOG.Error("parse LoginTokenRequest error: %v", err)
+		logger.Error("parse LoginTokenRequest error: %v", err)
 		return
 	}
 	uid, err := strconv.ParseInt(requestData.Uid, 10, 64)
 	if err != nil {
-		logger.LOG.Error("parse uid error: %v", err)
+		logger.Error("parse uid error: %v", err)
 		return
 	}
 	account, err := c.dao.QueryAccountByField("accountID", uid)
 	if err != nil {
-		logger.LOG.Error("query account from db error: %v", err)
+		logger.Error("query account from db error: %v", err)
 		return
 	}
 	responseData := api.NewLoginResult()
@@ -189,23 +189,23 @@ func (c *Controller) v2Login(context *gin.Context) {
 	requestData := new(api.ComboTokenReq)
 	err := context.ShouldBindJSON(requestData)
 	if err != nil {
-		logger.LOG.Error("parse ComboTokenReq error: %v", err)
+		logger.Error("parse ComboTokenReq error: %v", err)
 		return
 	}
 	data := requestData.Data
 	if len(data) == 0 {
-		logger.LOG.Error("requestData.Data len == 0")
+		logger.Error("requestData.Data len == 0")
 		return
 	}
 	loginData := new(api.LoginTokenData)
 	err = json.Unmarshal([]byte(data), loginData)
 	if err != nil {
-		logger.LOG.Error("Unmarshal LoginTokenData error: %v", err)
+		logger.Error("Unmarshal LoginTokenData error: %v", err)
 		return
 	}
 	uid, err := strconv.ParseInt(loginData.Uid, 10, 64)
 	if err != nil {
-		logger.LOG.Error("ParseInt uid error: %v", err)
+		logger.Error("ParseInt uid error: %v", err)
 		return
 	}
 	responseData := api.NewComboTokenRes()

dispatch/dao/account_dao.go

@@ -2,8 +2,8 @@ package dao
 
 import (
 	"context"
-	"hk4e/dispatch/model"
 
+	"hk4e/dispatch/model"
 	"hk4e/pkg/logger"
 
 	"github.com/pkg/errors"
@@ -96,7 +96,7 @@ func (d *Dao) InsertAccount(account *model.Account) (primitive.ObjectID, error)
 	} else {
 		_id, ok := id.InsertedID.(primitive.ObjectID)
 		if !ok {
-			logger.LOG.Error("get insert id error")
+			logger.Error("get insert id error")
 			return primitive.ObjectID{}, nil
 		}
 		return _id, nil

dispatch/dao/dao.go

@@ -20,7 +20,7 @@ func NewDao() (r *Dao) {
 	clientOptions := options.Client().ApplyURI(config.CONF.Database.Url)
 	client, err := mongo.Connect(context.TODO(), clientOptions)
 	if err != nil {
-		logger.LOG.Error("mongo connect error: %v", err)
+		logger.Error("mongo connect error: %v", err)
 		return nil
 	}
 	r.client = client
@@ -31,6 +31,6 @@ func NewDao() (r *Dao) {
 func (d *Dao) CloseDao() {
 	err := d.client.Disconnect(context.TODO())
 	if err != nil {
-		logger.LOG.Error("mongo close error: %v", err)
+		logger.Error("mongo close error: %v", err)
 	}
 }

gate/app/app.go

@@ -19,7 +19,7 @@ func Run(ctx context.Context, configFile string) error {
 	config.InitConfig(configFile)
 
 	logger.InitLogger("gate")
-	logger.LOG.Info("gate start")
+	logger.Warn("gate start")
 
 	netMsgInput := make(chan *cmd.NetMsg, 10000)
 	netMsgOutput := make(chan *cmd.NetMsg, 10000)
@@ -45,10 +45,10 @@ func Run(ctx context.Context, configFile string) error {
 		case <-ctx.Done():
 			return nil
 		case s := <-c:
-			logger.LOG.Info("get a signal %s", s.String())
+			logger.Warn("get a signal %s", s.String())
 			switch s {
 			case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
-				logger.LOG.Info("gate exit")
+				logger.Warn("gate exit")
 				time.Sleep(time.Second)
 				return nil
 			case syscall.SIGHUP:

gate/kcp/crypt.go

@@ -9,7 +9,6 @@ import (
 
 	xor "github.com/templexxx/xorsimd"
 	"github.com/tjfoc/gmsm/sm4"
-
 	"golang.org/x/crypto/blowfish"
 	"golang.org/x/crypto/cast5"
 	"golang.org/x/crypto/pbkdf2"

gate/kcp/readloop.go

@@ -3,6 +3,7 @@ package kcp
 import (
 	"bytes"
 	"encoding/binary"
+
 	"github.com/pkg/errors"
 )
 

gate/kcp/readloop_linux.go

@@ -6,11 +6,12 @@ package kcp
 import (
 	"bytes"
 	"encoding/binary"
+	"net"
+	"os"
+
 	"github.com/pkg/errors"
 	"golang.org/x/net/ipv4"
 	"golang.org/x/net/ipv6"
-	"net"
-	"os"
 )
 
 // the read loop for a client session

gate/kcp/tx_linux.go

@@ -4,13 +4,13 @@
 package kcp
 
 import (
-	"golang.org/x/net/ipv6"
 	"net"
 	"os"
 	"sync/atomic"
 
 	"github.com/pkg/errors"
 	"golang.org/x/net/ipv4"
+	"golang.org/x/net/ipv6"
 )
 
 func (l *Listener) SendEnetNotifyToClient(enet *Enet) {

gate/mq/mq.go

@@ -22,14 +22,14 @@ func NewMessageQueue(netMsgInput chan *cmd.NetMsg, netMsgOutput chan *cmd.NetMsg
 	r = new(MessageQueue)
 	conn, err := nats.Connect(config.CONF.MQ.NatsUrl)
 	if err != nil {
-		logger.LOG.Error("connect nats error: %v", err)
+		logger.Error("connect nats error: %v", err)
 		return nil
 	}
 	r.natsConn = conn
 	r.natsMsgChan = make(chan *nats.Msg, 10000)
 	_, err = r.natsConn.ChanSubscribe("GATE_CMD_HK4E", r.natsMsgChan)
 	if err != nil {
-		logger.LOG.Error("nats subscribe error: %v", err)
+		logger.Error("nats subscribe error: %v", err)
 		return nil
 	}
 	r.netMsgInput = netMsgInput
@@ -54,7 +54,7 @@ func (m *MessageQueue) startRecvHandler() {
 		netMsg := new(cmd.NetMsg)
 		err := msgpack.Unmarshal(natsMsg.Data, netMsg)
 		if err != nil {
-			logger.LOG.Error("parse bin to net msg error: %v", err)
+			logger.Error("parse bin to net msg error: %v", err)
 			continue
 		}
 		if netMsg.EventId == cmd.NormalMsg {
@@ -62,7 +62,7 @@ func (m *MessageQueue) startRecvHandler() {
 			payloadMessage := m.cmdProtoMap.GetProtoObjByCmdId(netMsg.CmdId)
 			err = pb.Unmarshal(netMsg.PayloadMessageData, payloadMessage)
 			if err != nil {
-				logger.LOG.Error("parse bin to payload msg error: %v", err)
+				logger.Error("parse bin to payload msg error: %v", err)
 				continue
 			}
 			netMsg.PayloadMessage = payloadMessage
@@ -77,21 +77,21 @@ func (m *MessageQueue) startSendHandler() {
 		// protobuf PayloadMessage
 		payloadMessageData, err := pb.Marshal(netMsg.PayloadMessage)
 		if err != nil {
-			logger.LOG.Error("parse payload msg to bin error: %v", err)
+			logger.Error("parse payload msg to bin error: %v", err)
 			continue
 		}
 		netMsg.PayloadMessageData = payloadMessageData
 		// msgpack NetMsg
 		netMsgData, err := msgpack.Marshal(netMsg)
 		if err != nil {
-			logger.LOG.Error("parse net msg to bin error: %v", err)
+			logger.Error("parse net msg to bin error: %v", err)
 			continue
 		}
 		natsMsg := nats.NewMsg("GS_CMD_HK4E")
 		natsMsg.Data = netMsgData
 		err = m.natsConn.PublishMsg(natsMsg)
 		if err != nil {
-			logger.LOG.Error("nats publish msg error: %v", err)
+			logger.Error("nats publish msg error: %v", err)
 			continue
 		}
 	}

gate/net/forward.go

@@ -5,6 +5,11 @@ import (
 	"encoding/base64"
 	"encoding/binary"
 	"fmt"
+	"math/rand"
+	"strconv"
+	"strings"
+	"time"
+
 	"hk4e/dispatch/controller"
 	"hk4e/gate/kcp"
 	"hk4e/pkg/endec"
@@ -13,10 +18,6 @@ import (
 	"hk4e/pkg/random"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
-	"math/rand"
-	"strconv"
-	"strings"
-	"time"
 )
 
 const (
@@ -32,7 +33,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 	headMeta := session.headMeta
 	connState := session.connState
 	if protoMsg.HeadMessage == nil {
-		logger.LOG.Error("recv null head msg: %v", protoMsg)
+		logger.Error("recv null head msg: %v", protoMsg)
 	}
 	headMeta.seq = protoMsg.HeadMessage.ClientSequenceId
 	// gate本地处理的请求
@@ -77,7 +78,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 		netMsg.EventId = cmd.UserLoginNotify
 		netMsg.ClientSeq = headMeta.seq
 		k.netMsgInput <- netMsg
-		logger.LOG.Info("send to gs user login ok, ConvId: %v, UserId: %v", protoMsg.ConvId, netMsg.UserId)
+		logger.Info("send to gs user login ok, ConvId: %v, UserId: %v", protoMsg.ConvId, netMsg.UserId)
 	case cmd.SetPlayerBornDataReq:
 		// 玩家注册请求
 		if connState != ConnAlive {
@@ -106,7 +107,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 			return
 		}
 		pingReq := protoMsg.PayloadMessage.(*proto.PingReq)
-		logger.LOG.Debug("user ping req, data: %v", pingReq.String())
+		logger.Debug("user ping req, data: %v", pingReq.String())
 		// 返回数据到客户端
 		// TODO 记录客户端最后一次ping时间做超时下线处理
 		pingRsp := new(proto.PingRsp)
@@ -124,7 +125,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 		netMsg.ClientTime = pingReq.ClientTime
 		k.netMsgInput <- netMsg
 		// RTT
-		logger.LOG.Debug("convId: %v, RTO: %v, SRTT: %v, RTTVar: %v", protoMsg.ConvId, session.conn.GetRTO(), session.conn.GetSRTT(), session.conn.GetSRTTVar())
+		logger.Debug("convId: %v, RTO: %v, SRTT: %v, RTTVar: %v", protoMsg.ConvId, session.conn.GetRTO(), session.conn.GetSRTT(), session.conn.GetSRTTVar())
 		// 客户端往返时延通知
 		rtt := session.conn.GetSRTT()
 		// 通知GS玩家客户端往返时延
@@ -151,7 +152,7 @@ func (k *KcpConnectManager) recvMsgHandle(protoMsg *ProtoMsg, session *Session)
 
 // 从GS接收消息
 func (k *KcpConnectManager) sendMsgHandle() {
-	logger.LOG.Debug("send msg handle start")
+	logger.Debug("send msg handle start")
 	kcpRawSendChanMap := make(map[uint64]chan *ProtoMsg)
 	userIdConvMap := make(map[uint32]uint64)
 	sendToClientFn := func(protoMsg *ProtoMsg) {
@@ -161,10 +162,10 @@ func (k *KcpConnectManager) sendMsgHandle() {
 			select {
 			case kcpRawSendChan <- protoMsg:
 			default:
-				logger.LOG.Error("kcpRawSendChan is full, convId: %v", protoMsg.ConvId)
+				logger.Error("kcpRawSendChan is full, convId: %v", protoMsg.ConvId)
 			}
 		} else {
-			logger.LOG.Error("kcpRawSendChan is nil, convId: %v", protoMsg.ConvId)
+			logger.Error("kcpRawSendChan is nil, convId: %v", protoMsg.ConvId)
 		}
 	}
 	for {
@@ -181,7 +182,7 @@ func (k *KcpConnectManager) sendMsgHandle() {
 		case netMsg := <-k.netMsgOutput:
 			convId, exist := userIdConvMap[netMsg.UserId]
 			if !exist {
-				logger.LOG.Error("can not find convId by userId")
+				logger.Error("can not find convId by userId")
 				continue
 			}
 			if netMsg.EventId == cmd.NormalMsg {
@@ -192,7 +193,7 @@ func (k *KcpConnectManager) sendMsgHandle() {
 				protoMsg.PayloadMessage = netMsg.PayloadMessage
 				sendToClientFn(protoMsg)
 			} else {
-				logger.LOG.Error("recv unknown event from game server, event id: %v", netMsg.EventId)
+				logger.Error("recv unknown event from game server, event id: %v", netMsg.EventId)
 			}
 		}
 	}
@@ -213,11 +214,11 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 		AccountToken: req.AccountToken,
 	}, "")
 	if err != nil {
-		logger.LOG.Error("verify token error: %v", err)
+		logger.Error("verify token error: %v", err)
 		return nil
 	}
 	if !tokenVerifyRsp.Valid {
-		logger.LOG.Error("token error")
+		logger.Error("token error")
 		return nil
 	}
 	// comboToken验证成功
@@ -273,38 +274,38 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 	split := strings.Split(addr, ":")
 	rsp.ClientIpStr = split[0]
 	if req.GetKeyId() != 0 {
-		logger.LOG.Debug("do hk4e 2.8 rsa logic")
+		logger.Debug("do hk4e 2.8 rsa logic")
 		keyId := strconv.Itoa(int(req.GetKeyId()))
 		encPubPrivKey, exist := k.encRsaKeyMap[keyId]
 		if !exist {
-			logger.LOG.Error("can not found key id: %v", keyId)
+			logger.Error("can not found key id: %v", keyId)
 			return
 		}
 		pubKey, err := endec.RsaParsePubKeyByPrivKey(encPubPrivKey)
 		if err != nil {
-			logger.LOG.Error("parse rsa pub key error: %v", err)
+			logger.Error("parse rsa pub key error: %v", err)
 			return nil
 		}
 		signPrivkey, err := endec.RsaParsePrivKey(k.signRsaKey)
 		if err != nil {
-			logger.LOG.Error("parse rsa priv key error: %v", err)
+			logger.Error("parse rsa priv key error: %v", err)
 			return nil
 		}
 		clientSeedBase64 := req.GetClientRandKey()
 		clientSeedEnc, err := base64.StdEncoding.DecodeString(clientSeedBase64)
 		if err != nil {
-			logger.LOG.Error("parse client seed base64 error: %v", err)
+			logger.Error("parse client seed base64 error: %v", err)
 			return nil
 		}
 		clientSeed, err := endec.RsaDecrypt(clientSeedEnc, signPrivkey)
 		if err != nil {
-			logger.LOG.Error("rsa dec error: %v", err)
+			logger.Error("rsa dec error: %v", err)
 			return rsp
 		}
 		clientSeedUint64 := uint64(0)
 		err = binary.Read(bytes.NewReader(clientSeed), binary.BigEndian, &clientSeedUint64)
 		if err != nil {
-			logger.LOG.Error("parse client seed to uint64 error: %v", err)
+			logger.Error("parse client seed to uint64 error: %v", err)
 			return rsp
 		}
 		timeRand := random.GetTimeRand()
@@ -315,18 +316,18 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 		seedBuf := new(bytes.Buffer)
 		err = binary.Write(seedBuf, binary.BigEndian, seedUint64)
 		if err != nil {
-			logger.LOG.Error("conv seed uint64 to bytes error: %v", err)
+			logger.Error("conv seed uint64 to bytes error: %v", err)
 			return rsp
 		}
 		seed := seedBuf.Bytes()
 		seedEnc, err := endec.RsaEncrypt(seed, pubKey)
 		if err != nil {
-			logger.LOG.Error("rsa enc error: %v", err)
+			logger.Error("rsa enc error: %v", err)
 			return rsp
 		}
 		seedSign, err := endec.RsaSign(seed, signPrivkey)
 		if err != nil {
-			logger.LOG.Error("rsa sign error: %v", err)
+			logger.Error("rsa sign error: %v", err)
 			return rsp
 		}
 		rsp.KeyId = req.KeyId
@@ -337,7 +338,7 @@ func (k *KcpConnectManager) getPlayerToken(req *proto.GetPlayerTokenReq, session
 }
 
 func (k *KcpConnectManager) playerLogin(req *proto.PlayerLoginReq, session *Session) (rsp *proto.PlayerLoginRsp) {
-	logger.LOG.Debug("player login, info: %v", req.String())
+	logger.Debug("player login, info: %v", req.String())
 	// TODO 验证token
 	session.connState = ConnAlive
 	// 返回响应

gate/net/kcp_connect_manager.go

@@ -3,19 +3,19 @@ package net
 import (
 	"bytes"
 	"encoding/binary"
-	"hk4e/common/region"
-	"hk4e/dispatch/controller"
-	"hk4e/pkg/httpclient"
-	"hk4e/protocol/cmd"
-	"hk4e/protocol/proto"
 	"strconv"
 	"sync"
 	"time"
 
 	"hk4e/common/config"
+	"hk4e/common/region"
+	"hk4e/dispatch/controller"
 	"hk4e/gate/kcp"
+	"hk4e/pkg/httpclient"
 	"hk4e/pkg/logger"
 	"hk4e/pkg/random"
+	"hk4e/protocol/cmd"
+	"hk4e/protocol/proto"
 )
 
 type KcpConnectManager struct {
@@ -63,15 +63,15 @@ func (k *KcpConnectManager) Start() {
 	// key
 	dispatchEc2bSeedRsp, err := httpclient.Get[controller.DispatchEc2bSeedRsp]("http://127.0.0.1:8080/dispatch/ec2b/seed", "")
 	if err != nil {
-		logger.LOG.Error("get dispatch ec2b seed error: %v", err)
+		logger.Error("get dispatch ec2b seed error: %v", err)
 		return
 	}
 	dispatchEc2bSeed, err := strconv.ParseUint(dispatchEc2bSeedRsp.Seed, 10, 64)
 	if err != nil {
-		logger.LOG.Error("parse dispatch ec2b seed error: %v", err)
+		logger.Error("parse dispatch ec2b seed error: %v", err)
 		return
 	}
-	logger.LOG.Debug("get dispatch ec2b seed: %v", dispatchEc2bSeed)
+	logger.Debug("get dispatch ec2b seed: %v", dispatchEc2bSeed)
 	gateDispatchEc2b := random.NewEc2b()
 	gateDispatchEc2b.SetSeed(dispatchEc2bSeed)
 	k.dispatchKey = gateDispatchEc2b.XorKey()
@@ -79,7 +79,7 @@ func (k *KcpConnectManager) Start() {
 	port := strconv.Itoa(int(config.CONF.Hk4e.KcpPort))
 	listener, err := kcp.ListenWithOptions(config.CONF.Hk4e.KcpAddr+":"+port, nil, 0, 0)
 	if err != nil {
-		logger.LOG.Error("listen kcp err: %v", err)
+		logger.Error("listen kcp err: %v", err)
 		return
 	}
 	go k.enetHandle(listener)
@@ -89,11 +89,11 @@ func (k *KcpConnectManager) Start() {
 }
 
 func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
-	logger.LOG.Debug("accept handle start")
+	logger.Debug("accept handle start")
 	for {
 		conn, err := listener.AcceptKCP()
 		if err != nil {
-			logger.LOG.Error("accept kcp err: %v", err)
+			logger.Error("accept kcp err: %v", err)
 			return
 		}
 		if k.openState == false {
@@ -103,7 +103,7 @@ func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
 		conn.SetACKNoDelay(true)
 		conn.SetWriteDelay(false)
 		convId := conn.GetConv()
-		logger.LOG.Debug("client connect, convId: %v", convId)
+		logger.Debug("client connect, convId: %v", convId)
 		kcpRawSendChan := make(chan *ProtoMsg, 1000)
 		session := &Session{
 			conn:      conn,
@@ -129,12 +129,12 @@ func (k *KcpConnectManager) acceptHandle(listener *kcp.Listener) {
 }
 
 func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
-	logger.LOG.Debug("enet handle start")
+	logger.Debug("enet handle start")
 	// conv短时间内唯一生成
 	convGenMap := make(map[uint64]int64)
 	for {
 		enetNotify := <-listener.EnetNotify
-		logger.LOG.Info("[Enet Notify], addr: %v, conv: %v, conn: %v, enet: %v", enetNotify.Addr, enetNotify.ConvId, enetNotify.ConnType, enetNotify.EnetType)
+		logger.Info("[Enet Notify], addr: %v, conv: %v, conn: %v, enet: %v", enetNotify.Addr, enetNotify.ConvId, enetNotify.ConnType, enetNotify.EnetType)
 		switch enetNotify.ConnType {
 		case kcp.ConnEnetSyn:
 			if enetNotify.EnetType == kcp.EnetClientConnectKey {
@@ -156,7 +156,7 @@ func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
 					}
 				}
 				k.sessionMapLock.RUnlock()
-				logger.LOG.Info("clean dead conv list: %v", delConvList)
+				logger.Info("clean dead conv list: %v", delConvList)
 				// 生成没用过的conv
 				var conv uint64
 				for {
@@ -182,7 +182,7 @@ func (k *KcpConnectManager) enetHandle(listener *kcp.Listener) {
 		case kcp.ConnEnetFin:
 			session := k.GetSessionByConvId(enetNotify.ConvId)
 			if session == nil {
-				logger.LOG.Error("session not exist, convId: %v", enetNotify.ConvId)
+				logger.Error("session not exist, convId: %v", enetNotify.ConvId)
 				continue
 			}
 			session.conn.SendEnetNotify(&kcp.Enet{
@@ -218,7 +218,7 @@ type Session struct {
 }
 
 func (k *KcpConnectManager) recvHandle(session *Session) {
-	logger.LOG.Debug("recv handle start")
+	logger.Debug("recv handle start")
 	// 接收
 	conn := session.conn
 	convId := conn.GetConv()
@@ -229,7 +229,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
 		_ = conn.SetReadDeadline(time.Now().Add(time.Second * 15))
 		recvLen, err := conn.Read(recvBuf)
 		if err != nil {
-			logger.LOG.Error("exit recv loop, conn read err: %v, convId: %v", err, convId)
+			logger.Error("exit recv loop, conn read err: %v, convId: %v", err, convId)
 			k.closeKcpConn(session, kcp.EnetServerKick)
 			break
 		}
@@ -246,7 +246,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
 		now := time.Now().UnixNano()
 		if now-pktFreqLimitTimer > int64(time.Second) {
 			if pktFreqLimitCounter > 100 {
-				logger.LOG.Error("exit recv loop, client packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
+				logger.Error("exit recv loop, client packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
 				k.closeKcpConn(session, kcp.EnetPacketFreqTooHigh)
 				break
 			} else {
@@ -267,7 +267,7 @@ func (k *KcpConnectManager) recvHandle(session *Session) {
 }
 
 func (k *KcpConnectManager) sendHandle(session *Session) {
-	logger.LOG.Debug("send handle start")
+	logger.Debug("send handle start")
 	// 发送
 	conn := session.conn
 	convId := conn.GetConv()
@@ -276,20 +276,20 @@ func (k *KcpConnectManager) sendHandle(session *Session) {
 	for {
 		protoMsg, ok := <-session.kcpRawSendChan
 		if !ok {
-			logger.LOG.Error("exit send loop, send chan close, convId: %v", convId)
+			logger.Error("exit send loop, send chan close, convId: %v", convId)
 			k.closeKcpConn(session, kcp.EnetServerKick)
 			break
 		}
 		kcpMsg := k.protoEncode(protoMsg)
 		if kcpMsg == nil {
-			logger.LOG.Error("decode kcp msg is nil, convId: %v", convId)
+			logger.Error("decode kcp msg is nil, convId: %v", convId)
 			continue
 		}
 		bin := k.encodePayloadToBin(kcpMsg, session.xorKey)
 		_ = conn.SetWriteDeadline(time.Now().Add(time.Second * 5))
 		_, err := conn.Write(bin)
 		if err != nil {
-			logger.LOG.Error("exit send loop, conn write err: %v, convId: %v", err, convId)
+			logger.Error("exit send loop, conn write err: %v, convId: %v", err, convId)
 			k.closeKcpConn(session, kcp.EnetServerKick)
 			break
 		}
@@ -298,7 +298,7 @@ func (k *KcpConnectManager) sendHandle(session *Session) {
 		now := time.Now().UnixNano()
 		if now-pktFreqLimitTimer > int64(time.Second) {
 			if pktFreqLimitCounter > 100 {
-				logger.LOG.Error("exit send loop, server packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
+				logger.Error("exit send loop, server packet send freq too high, convId: %v, pps: %v", convId, pktFreqLimitCounter)
 				k.closeKcpConn(session, kcp.EnetPacketFreqTooHigh)
 				break
 			} else {
@@ -336,7 +336,7 @@ func (k *KcpConnectManager) closeKcpConn(session *Session, enetType uint32) {
 	netMsg.UserId = session.userId
 	netMsg.EventId = cmd.UserOfflineNotify
 	k.netMsgInput <- netMsg
-	logger.LOG.Info("send to gs user offline, ConvId: %v, UserId: %v", convId, netMsg.UserId)
+	logger.Info("send to gs user offline, ConvId: %v, UserId: %v", convId, netMsg.UserId)
 	k.destroySessionChan <- session
 }
 

gate/net/kcp_endecode.go

@@ -42,12 +42,12 @@ func (k *KcpConnectManager) decodeBinToPayload(data []byte, convId uint64, kcpMs
 func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[]*KcpMsg) {
 	// 长度太短
 	if len(data) < 12 {
-		logger.LOG.Debug("packet len less 12 byte")
+		logger.Debug("packet len less 12 byte")
 		return
 	}
 	// 头部幻数错误
 	if data[0] != 0x45 || data[1] != 0x67 {
-		logger.LOG.Error("packet head magic 0x4567 error")
+		logger.Error("packet head magic 0x4567 error")
 		return
 	}
 	// 协议号
@@ -58,7 +58,7 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	var cmdId int64
 	err := binary.Read(cmdIdBuffer, binary.BigEndian, &cmdId)
 	if err != nil {
-		logger.LOG.Error("packet cmd id parse fail: %v", err)
+		logger.Error("packet cmd id parse fail: %v", err)
 		return
 	}
 	// 头部长度
@@ -69,7 +69,7 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	var headLen int64
 	err = binary.Read(headLenBuffer, binary.BigEndian, &headLen)
 	if err != nil {
-		logger.LOG.Error("packet head len parse fail: %v", err)
+		logger.Error("packet head len parse fail: %v", err)
 		return
 	}
 	// proto长度
@@ -82,17 +82,17 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
 	var protoLen int64
 	err = binary.Read(protoLenBuffer, binary.BigEndian, &protoLen)
 	if err != nil {
-		logger.LOG.Error("packet proto len parse fail: %v", err)
+		logger.Error("packet proto len parse fail: %v", err)
 		return
 	}
 	// 检查最小长度
 	if len(data) < int(headLen+protoLen)+12 {
-		logger.LOG.Error("packet len error")
+		logger.Error("packet len error")
 		return
 	}
 	// 尾部幻数错误
 	if data[headLen+protoLen+10] != 0x89 || data[headLen+protoLen+11] != 0xAB {
-		logger.LOG.Error("packet tail magic 0x89AB error")
+		logger.Error("packet tail magic 0x89AB error")
 		return
 	}
 	// 判断是否有不止一个包
@@ -136,7 +136,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
 	cmdIdBuffer := bytes.NewBuffer([]byte{})
 	err := binary.Write(cmdIdBuffer, binary.BigEndian, kcpMsg.CmdId)
 	if err != nil {
-		logger.LOG.Error("cmd id encode err: %v", err)
+		logger.Error("cmd id encode err: %v", err)
 		return nil
 	}
 	bin[2] = (cmdIdBuffer.Bytes())[0]
@@ -145,7 +145,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
 	headLenBuffer := bytes.NewBuffer([]byte{})
 	err = binary.Write(headLenBuffer, binary.BigEndian, uint16(len(kcpMsg.HeadData)))
 	if err != nil {
-		logger.LOG.Error("head len encode err: %v", err)
+		logger.Error("head len encode err: %v", err)
 		return nil
 	}
 	bin[4] = (headLenBuffer.Bytes())[0]
@@ -154,7 +154,7 @@ func (k *KcpConnectManager) encodePayloadToBin(kcpMsg *KcpMsg, xorKey []byte) (b
 	protoLenBuffer := bytes.NewBuffer([]byte{})
 	err = binary.Write(protoLenBuffer, binary.BigEndian, uint32(len(kcpMsg.ProtoData)))
 	if err != nil {
-		logger.LOG.Error("proto len encode err: %v", err)
+		logger.Error("proto len encode err: %v", err)
 		return nil
 	}
 	bin[6] = (protoLenBuffer.Bytes())[0]

gate/net/kcp_event.go

@@ -1,9 +1,10 @@
 package net
 
 import (
+	"reflect"
+
 	"hk4e/gate/kcp"
 	"hk4e/pkg/logger"
-	"reflect"
 )
 
 const (
@@ -30,22 +31,22 @@ func (k *KcpConnectManager) GetKcpEventOutputChan() chan *KcpEvent {
 }
 
 func (k *KcpConnectManager) eventHandle() {
-	logger.LOG.Debug("event handle start")
+	logger.Debug("event handle start")
 	// 事件处理
 	for {
 		event := <-k.kcpEventInput
-		logger.LOG.Info("kcp manager recv event, ConvId: %v, EventId: %v, EventMessage Type: %v", event.ConvId, event.EventId, reflect.TypeOf(event.EventMessage))
+		logger.Info("kcp manager recv event, ConvId: %v, EventId: %v, EventMessage Type: %v", event.ConvId, event.EventId, reflect.TypeOf(event.EventMessage))
 		switch event.EventId {
 		case KcpConnForceClose:
 			// 强制关闭某个连接
 			session := k.GetSessionByConvId(event.ConvId)
 			if session == nil {
-				logger.LOG.Error("session not exist, convId: %v", event.ConvId)
+				logger.Error("session not exist, convId: %v", event.ConvId)
 				continue
 			}
 			reason, ok := event.EventMessage.(uint32)
 			if !ok {
-				logger.LOG.Error("event KcpConnForceClose msg type error")
+				logger.Error("event KcpConnForceClose msg type error")
 				continue
 			}
 			session.conn.SendEnetNotify(&kcp.Enet{
@@ -53,16 +54,16 @@ func (k *KcpConnectManager) eventHandle() {
 				EnetType: reason,
 			})
 			_ = session.conn.Close()
-			logger.LOG.Info("conn has been force close, convId: %v", event.ConvId)
+			logger.Info("conn has been force close, convId: %v", event.ConvId)
 		case KcpAllConnForceClose:
 			// 强制关闭所有连接
 			k.closeAllKcpConn()
-			logger.LOG.Info("all conn has been force close")
+			logger.Info("all conn has been force close")
 		case KcpGateOpenState:
 			// 改变网关开放状态
 			openState, ok := event.EventMessage.(bool)
 			if !ok {
-				logger.LOG.Error("event KcpGateOpenState msg type error")
+				logger.Error("event KcpGateOpenState msg type error")
 				continue
 			}
 			k.openState = openState

gate/net/proto_endecode.go

@@ -30,7 +30,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 		headMsg := new(proto.PacketHead)
 		err := pb.Unmarshal(kcpMsg.HeadData, headMsg)
 		if err != nil {
-			logger.LOG.Error("unmarshal head data err: %v", err)
+			logger.Error("unmarshal head data err: %v", err)
 			return protoMsgList
 		}
 		protoMsg.HeadMessage = headMsg
@@ -41,7 +41,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 	protoMessageList := make([]*ProtoMessage, 0)
 	k.protoDecodePayloadLoop(kcpMsg.CmdId, kcpMsg.ProtoData, &protoMessageList)
 	if len(protoMessageList) == 0 {
-		logger.LOG.Error("decode proto object is nil")
+		logger.Error("decode proto object is nil")
 		return protoMsgList
 	}
 	if kcpMsg.CmdId == cmd.UnionCmdNotify {
@@ -58,7 +58,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 			if msg.PayloadMessage != nil {
 				cmdName = string(msg.PayloadMessage.ProtoReflect().Descriptor().FullName())
 			}
-			logger.LOG.Debug("[RECV UNION CMD], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", msg.CmdId, cmdName, msg.ConvId, msg.HeadMessage)
+			logger.Debug("[RECV UNION CMD], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", msg.CmdId, cmdName, msg.ConvId, msg.HeadMessage)
 		}
 	} else {
 		protoMsg.PayloadMessage = protoMessageList[0].message
@@ -67,7 +67,7 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 		if protoMsg.PayloadMessage != nil {
 			cmdName = string(protoMsg.PayloadMessage.ProtoReflect().Descriptor().FullName())
 		}
-		logger.LOG.Debug("[RECV], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
+		logger.Debug("[RECV], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
 	}
 	return protoMsgList
 }
@@ -75,14 +75,14 @@ func (k *KcpConnectManager) protoDecode(kcpMsg *KcpMsg) (protoMsgList []*ProtoMs
 func (k *KcpConnectManager) protoDecodePayloadLoop(cmdId uint16, protoData []byte, protoMessageList *[]*ProtoMessage) {
 	protoObj := k.decodePayloadToProto(cmdId, protoData)
 	if protoObj == nil {
-		logger.LOG.Error("decode proto object is nil")
+		logger.Error("decode proto object is nil")
 		return
 	}
 	if cmdId == cmd.UnionCmdNotify {
 		// 处理聚合消息
 		unionCmdNotify, ok := protoObj.(*proto.UnionCmdNotify)
 		if !ok {
-			logger.LOG.Error("parse union cmd error")
+			logger.Error("parse union cmd error")
 			return
 		}
 		for _, unionCmd := range unionCmdNotify.GetCmdList() {
@@ -100,7 +100,7 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 	if protoMsg.PayloadMessage != nil {
 		cmdName = string(protoMsg.PayloadMessage.ProtoReflect().Descriptor().FullName())
 	}
-	logger.LOG.Debug("[SEND], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
+	logger.Debug("[SEND], cmdId: %v, cmdName: %v, convId: %v, headMsg: %v", protoMsg.CmdId, cmdName, protoMsg.ConvId, protoMsg.HeadMessage)
 	kcpMsg = new(KcpMsg)
 	kcpMsg.ConvId = protoMsg.ConvId
 	kcpMsg.CmdId = protoMsg.CmdId
@@ -108,7 +108,7 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 	if protoMsg.HeadMessage != nil {
 		headData, err := pb.Marshal(protoMsg.HeadMessage)
 		if err != nil {
-			logger.LOG.Error("marshal head data err: %v", err)
+			logger.Error("marshal head data err: %v", err)
 			return nil
 		}
 		kcpMsg.HeadData = headData
@@ -119,11 +119,11 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 	if protoMsg.PayloadMessage != nil {
 		cmdId, protoData := k.encodeProtoToPayload(protoMsg.PayloadMessage)
 		if cmdId == 0 || protoData == nil {
-			logger.LOG.Error("encode proto data is nil")
+			logger.Error("encode proto data is nil")
 			return nil
 		}
 		if cmdId != 65535 && cmdId != protoMsg.CmdId {
-			logger.LOG.Error("cmd id is not match with proto obj, src cmd id: %v, found cmd id: %v", protoMsg.CmdId, cmdId)
+			logger.Error("cmd id is not match with proto obj, src cmd id: %v, found cmd id: %v", protoMsg.CmdId, cmdId)
 			return nil
 		}
 		kcpMsg.ProtoData = protoData
@@ -136,12 +136,12 @@ func (k *KcpConnectManager) protoEncode(protoMsg *ProtoMsg) (kcpMsg *KcpMsg) {
 func (k *KcpConnectManager) decodePayloadToProto(cmdId uint16, protoData []byte) (protoObj pb.Message) {
 	protoObj = k.cmdProtoMap.GetProtoObjByCmdId(cmdId)
 	if protoObj == nil {
-		logger.LOG.Error("get new proto object is nil")
+		logger.Error("get new proto object is nil")
 		return nil
 	}
 	err := pb.Unmarshal(protoData, protoObj)
 	if err != nil {
-		logger.LOG.Error("unmarshal proto data err: %v", err)
+		logger.Error("unmarshal proto data err: %v", err)
 		return nil
 	}
 	return protoObj
@@ -152,7 +152,7 @@ func (k *KcpConnectManager) encodeProtoToPayload(protoObj pb.Message) (cmdId uin
 	var err error = nil
 	protoData, err = pb.Marshal(protoObj)
 	if err != nil {
-		logger.LOG.Error("marshal proto object err: %v", err)
+		logger.Error("marshal proto object err: %v", err)
 		return 0, nil
 	}
 	return cmdId, protoData

gdconf/avatar_data.go

@@ -2,11 +2,13 @@ package gdconf
 
 import (
 	"fmt"
-	"github.com/hjson/hjson-go/v4"
+	"os"
-	"github.com/jszwec/csvutil"
+
 	"hk4e/pkg/endec"
 	"hk4e/pkg/logger"
-	"os"
+
+	"github.com/hjson/hjson-go/v4"
+	"github.com/jszwec/csvutil"
 )
 
 // 角色配置表
@@ -58,7 +60,7 @@ func (g *GameDataConfig) loadAvatarData() {
 			panic(info)
 		}
 		if len(configAvatar.Abilities) == 0 {
-			logger.LOG.Info("can not find any ability of avatar, AvatarId: %v", avatarData.AvatarId)
+			logger.Info("can not find any ability of avatar, AvatarId: %v", avatarData.AvatarId)
 		}
 		for _, configAvatarAbility := range configAvatar.Abilities {
 			abilityHashCode := endec.Hk4eAbilityHashCode(configAvatarAbility.AbilityName)
@@ -67,5 +69,5 @@ func (g *GameDataConfig) loadAvatarData() {
 		// list -> map
 		g.AvatarDataMap[avatarData.AvatarId] = avatarData
 	}
-	logger.LOG.Info("AvatarData count: %v", len(g.AvatarDataMap))
+	logger.Info("AvatarData count: %v", len(g.AvatarDataMap))
 }

gdconf/avatar_skill_data.go

@@ -2,8 +2,10 @@ package gdconf
 
 import (
 	"fmt"
-	"github.com/jszwec/csvutil"
+
 	"hk4e/pkg/logger"
+
+	"github.com/jszwec/csvutil"
 )
 
 // 角色技能配置表
@@ -29,5 +31,5 @@ func (g *GameDataConfig) loadAvatarSkillData() {
 		// list -> map
 		g.AvatarSkillDataMap[avatarSkillData.AvatarSkillId] = avatarSkillData
 	}
-	logger.LOG.Info("AvatarSkillData count: %v", len(g.AvatarSkillDataMap))
+	logger.Info("AvatarSkillData count: %v", len(g.AvatarSkillDataMap))
 }

gdconf/avatar_skill_depot_data.go

@@ -2,8 +2,10 @@ package gdconf
 
 import (
 	"fmt"
-	"github.com/jszwec/csvutil"
+
 	"hk4e/pkg/logger"
+
+	"github.com/jszwec/csvutil"
 )
 
 // 角色技能库配置表
@@ -94,5 +96,5 @@ func (g *GameDataConfig) loadAvatarSkillDepotData() {
 		// list -> map
 		g.AvatarSkillDepotDataMap[avatarSkillDepotData.AvatarSkillDepotId] = avatarSkillDepotData
 	}
-	logger.LOG.Info("AvatarSkillDepotData count: %v", len(g.AvatarSkillDepotDataMap))
+	logger.Info("AvatarSkillDepotData count: %v", len(g.AvatarSkillDepotDataMap))
 }

gdconf/check_json_valid_test.go

@@ -1,19 +1,21 @@
 package gdconf
 
 import (
-	"github.com/hjson/hjson-go/v4"
-	"hk4e/common/config"
-	"hk4e/pkg/logger"
 	"os"
 	"strings"
 	"testing"
 	"time"
+
+	"hk4e/common/config"
+	"hk4e/pkg/logger"
+
+	"github.com/hjson/hjson-go/v4"
 )
 
 func CheckJsonLoop(path string, errorJsonFileList *[]string, totalJsonFileCount *int) {
 	fileList, err := os.ReadDir(path)
 	if err != nil {
-		logger.LOG.Error("open dir error: %v", err)
+		logger.Error("open dir error: %v", err)
 		return
 	}
 	for _, file := range fileList {
@@ -26,7 +28,7 @@ func CheckJsonLoop(path string, errorJsonFileList *[]string, totalJsonFileCount
 		}
 		fileData, err := os.ReadFile(path + "/" + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		var obj any
@@ -45,8 +47,8 @@ func TestCheckJsonValid(t *testing.T) {
 	totalJsonFileCount := 0
 	CheckJsonLoop("./game_data_config/json", &errorJsonFileList, &totalJsonFileCount)
 	for _, v := range errorJsonFileList {
-		logger.LOG.Info("%v", v)
+		logger.Info("%v", v)
 	}
-	logger.LOG.Info("err json file count: %v, total count: %v", len(errorJsonFileList), totalJsonFileCount)
+	logger.Info("err json file count: %v, total count: %v", len(errorJsonFileList), totalJsonFileCount)
 	time.Sleep(time.Second)
 }

gdconf/drop_group_data.go

@@ -1,8 +1,9 @@
 package gdconf
 
 import (
-	"github.com/jszwec/csvutil"
 	"hk4e/pkg/logger"
+
+	"github.com/jszwec/csvutil"
 )
 
 type Drop struct {
@@ -26,7 +27,7 @@ func (g *GameDataConfig) loadDropGroupData() {
 		var dropList []*Drop
 		err := csvutil.Unmarshal(data, &dropList)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			return
 		}
 		for _, drop := range dropList {
@@ -42,5 +43,5 @@ func (g *GameDataConfig) loadDropGroupData() {
 			dropGroupData.DropConfig = append(dropGroupData.DropConfig, drop)
 		}
 	}
-	logger.LOG.Info("load %v DropGroupData", len(g.DropGroupDataMap))
+	logger.Info("load %v DropGroupData", len(g.DropGroupDataMap))
 }

gdconf/game_data_config.go

@@ -2,9 +2,10 @@ package gdconf
 
 import (
 	"fmt"
-	"hk4e/common/config"
 	"os"
 	"strings"
+
+	"hk4e/common/config"
 )
 
 // 游戏数据配置表

gdconf/game_data_config_test.go

@@ -1,17 +1,18 @@
 package gdconf
 
 import (
-	"hk4e/common/config"
-	"hk4e/pkg/logger"
 	"testing"
 	"time"
+
+	"hk4e/common/config"
+	"hk4e/pkg/logger"
 )
 
 func TestInitGameDataConfig(t *testing.T) {
 	config.InitConfig("./application.toml")
 	logger.InitLogger("test")
-	logger.LOG.Info("start load conf")
+	logger.Info("start load conf")
 	InitGameDataConfig()
-	logger.LOG.Info("load conf finish, conf: %v", CONF)
+	logger.Info("load conf finish, conf: %v", CONF)
 	time.Sleep(time.Second)
 }

gm/app/app.go

@@ -19,11 +19,11 @@ func Run(ctx context.Context, configFile string) error {
 	config.InitConfig(configFile)
 
 	logger.InitLogger("gm")
-	logger.LOG.Info("gm start")
+	logger.Warn("gm start")
 
 	conn, err := nats.Connect(config.CONF.MQ.NatsUrl)
 	if err != nil {
-		logger.LOG.Error("connect nats error: %v", err)
+		logger.Error("connect nats error: %v", err)
 		return err
 	}
 	defer conn.Close()
@@ -41,10 +41,10 @@ func Run(ctx context.Context, configFile string) error {
 		case <-ctx.Done():
 			return nil
 		case s := <-c:
-			logger.LOG.Info("get a signal %s", s.String())
+			logger.Warn("get a signal %s", s.String())
 			switch s {
 			case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
-				logger.LOG.Info("gm exit")
+				logger.Warn("gm exit")
 				time.Sleep(time.Second)
 				return nil
 			case syscall.SIGHUP:

gm/controller/controller.go

@@ -51,6 +51,6 @@ func (c *Controller) registerRouter() {
 	addr := ":" + strconv.Itoa(int(port))
 	err := engine.Run(addr)
 	if err != nil {
-		logger.LOG.Error("gin run error: %v", err)
+		logger.Error("gin run error: %v", err)
 	}
 }

gm/controller/gm_controller.go

@@ -29,5 +29,5 @@ func (c *Controller) gmCmd(context *gin.Context) {
 		return
 	}
 	context.JSON(http.StatusOK, rep)
-	logger.LOG.Info("%v", gmCmdReq)
+	logger.Info("%v", gmCmdReq)
 }

gs/app/app.go

@@ -2,7 +2,6 @@ package app
 
 import (
 	"context"
-	"hk4e/gdconf"
 	_ "net/http/pprof"
 	"os"
 	"os/signal"
@@ -10,6 +9,7 @@ import (
 	"time"
 
 	"hk4e/common/config"
+	"hk4e/gdconf"
 	gdc "hk4e/gs/config"
 	"hk4e/gs/constant"
 	"hk4e/gs/dao"
@@ -26,7 +26,7 @@ func Run(ctx context.Context, configFile string) error {
 	config.InitConfig(configFile)
 
 	logger.InitLogger("gs")
-	logger.LOG.Info("gs start")
+	logger.Warn("gs start")
 
 	constant.InitConstant()
 
@@ -35,7 +35,7 @@ func Run(ctx context.Context, configFile string) error {
 
 	conn, err := nats.Connect(config.CONF.MQ.NatsUrl)
 	if err != nil {
-		logger.LOG.Error("connect nats error: %v", err)
+		logger.Error("connect nats error: %v", err)
 		return err
 	}
 	defer conn.Close()
@@ -71,10 +71,10 @@ func Run(ctx context.Context, configFile string) error {
 		case <-ctx.Done():
 			return nil
 		case s := <-c:
-			logger.LOG.Info("get a signal %s", s.String())
+			logger.Warn("get a signal %s", s.String())
 			switch s {
 			case syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT:
-				logger.LOG.Info("gs exit")
+				logger.Warn("gs exit")
 				time.Sleep(time.Second)
 				return nil
 			case syscall.SIGHUP:

gs/config/ability_embryos.go

@@ -26,7 +26,7 @@ func (g *GameDataConfig) loadAbilityEmbryos() {
 	dirPath := g.binPrefix + "Avatar"
 	fileList, err := os.ReadDir(dirPath)
 	if err != nil {
-		logger.LOG.Error("open dir error: %v", err)
+		logger.Error("open dir error: %v", err)
 		return
 	}
 	embryoList := make([]*AbilityEmbryoEntry, 0)
@@ -38,19 +38,19 @@ func (g *GameDataConfig) loadAbilityEmbryos() {
 		startIndex := strings.Index(fileName, "ConfigAvatar_")
 		endIndex := strings.Index(fileName, ".json")
 		if startIndex == -1 || endIndex == -1 || startIndex+13 > endIndex {
-			logger.LOG.Error("file name format error: %v", fileName)
+			logger.Error("file name format error: %v", fileName)
 			continue
 		}
 		avatarName := fileName[startIndex+13 : endIndex]
 		fileData, err := os.ReadFile(dirPath + "/" + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		avatarConfig := new(AvatarConfig)
 		err = json.Unmarshal(fileData, avatarConfig)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		if len(avatarConfig.Abilities) == 0 {
@@ -64,11 +64,11 @@ func (g *GameDataConfig) loadAbilityEmbryos() {
 		embryoList = append(embryoList, abilityEmbryoEntry)
 	}
 	if len(embryoList) == 0 {
-		logger.LOG.Error("no embryo load")
+		logger.Error("no embryo load")
 	}
 	g.AbilityEmbryos = make(map[string]*AbilityEmbryoEntry)
 	for _, v := range embryoList {
 		g.AbilityEmbryos[v.Name] = v
 	}
-	logger.LOG.Info("load %v AbilityEmbryos", len(g.AbilityEmbryos))
+	logger.Info("load %v AbilityEmbryos", len(g.AbilityEmbryos))
 }

gs/config/avatar_data.go

@@ -48,31 +48,31 @@ func (g *GameDataConfig) loadAvatarData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			avatarData := new(AvatarData)
 			err = json.Unmarshal(i, avatarData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.AvatarDataMap[avatarData.Id] = avatarData
 		}
 	}
-	logger.LOG.Info("load %v AvatarData", len(g.AvatarDataMap))
+	logger.Info("load %v AvatarData", len(g.AvatarDataMap))
 	for _, v := range g.AvatarDataMap {
 		split := strings.Split(v.IconName, "_")
 		if len(split) > 0 {

gs/config/avatar_skill_data.go

@@ -35,31 +35,31 @@ func (g *GameDataConfig) loadAvatarSkillData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			avatarSkillData := new(AvatarSkillData)
 			err = json.Unmarshal(i, avatarSkillData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.AvatarSkillDataMap[avatarSkillData.Id] = avatarSkillData
 		}
 	}
-	logger.LOG.Info("load %v AvatarSkillData", len(g.AvatarSkillDataMap))
+	logger.Info("load %v AvatarSkillData", len(g.AvatarSkillDataMap))
 	for _, v := range g.AvatarSkillDataMap {
 		v.CostElemTypeX = constant.ElementTypeConst.STRING_MAP[v.CostElemType]
 	}

gs/config/avatar_skill_depot_data.go

@@ -39,31 +39,31 @@ func (g *GameDataConfig) loadAvatarSkillDepotData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			avatarSkillDepotData := new(AvatarSkillDepotData)
 			err = json.Unmarshal(i, avatarSkillDepotData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.AvatarSkillDepotDataMap[avatarSkillDepotData.Id] = avatarSkillDepotData
 		}
 	}
-	logger.LOG.Info("load %v AvatarSkillDepotData", len(g.AvatarSkillDepotDataMap))
+	logger.Info("load %v AvatarSkillDepotData", len(g.AvatarSkillDepotDataMap))
 	for _, v := range g.AvatarSkillDepotDataMap {
 		// set energy skill data
 		v.EnergySkillData = g.AvatarSkillDataMap[v.EnergySkill]

gs/config/fetter_data.go

@@ -18,31 +18,31 @@ func (g *GameDataConfig) loadFetterData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			fetterData := new(FetterData)
 			err = json.Unmarshal(i, fetterData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.FetterDataMap[fetterData.FetterId] = fetterData
 		}
 	}
-	logger.LOG.Info("load %v FetterData", len(g.FetterDataMap))
+	logger.Info("load %v FetterData", len(g.FetterDataMap))
 	g.AvatarFetterDataMap = make(map[int32][]int32)
 	for _, v := range g.FetterDataMap {
 		avatarFetterIdList, exist := g.AvatarFetterDataMap[v.AvatarId]

gs/config/gadget_data.go

@@ -30,31 +30,31 @@ func (g *GameDataConfig) loadGadgetData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			gadgetData := new(GadgetData)
 			err = json.Unmarshal(i, gadgetData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.GadgetDataMap[gadgetData.Id] = gadgetData
 		}
 	}
-	logger.LOG.Info("load %v GadgetData", len(g.GadgetDataMap))
+	logger.Info("load %v GadgetData", len(g.GadgetDataMap))
 	for _, v := range g.GadgetDataMap {
 		v.TypeX = constant.EntityTypeConst.STRING_MAP[v.Type]
 	}

gs/config/game_data_config.go

@@ -76,19 +76,19 @@ func (g *GameDataConfig) loadAll() {
 	resourcePath := g.getResourcePathPrefix()
 	dirInfo, err := os.Stat(resourcePath)
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data config dir error: %v", err)
+		logger.Error("open game data config dir error: %v", err)
 		return
 	}
 	g.binPrefix = resourcePath + "/BinOutput"
 	g.excelBinPrefix = resourcePath + "/ExcelBinOutput"
 	dirInfo, err = os.Stat(g.binPrefix)
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data bin output config dir error: %v", err)
+		logger.Error("open game data bin output config dir error: %v", err)
 		return
 	}
 	dirInfo, err = os.Stat(g.excelBinPrefix)
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data excel bin output config dir error: %v", err)
+		logger.Error("open game data excel bin output config dir error: %v", err)
 		return
 	}
 	g.binPrefix += "/"
@@ -100,17 +100,17 @@ func (g *GameDataConfig) ReadWorldTerrain() []byte {
 	resourcePath := g.getResourcePathPrefix()
 	dirInfo, err := os.Stat(resourcePath)
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data config dir error: %v", err)
+		logger.Error("open game data config dir error: %v", err)
 		return nil
 	}
 	dirInfo, err = os.Stat(resourcePath + "/WorldStatic")
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data world static dir error: %v", err)
+		logger.Error("open game data world static dir error: %v", err)
 		return nil
 	}
 	data, err := os.ReadFile(resourcePath + "/WorldStatic/world_terrain.bin")
 	if err != nil {
-		logger.LOG.Error("read world terrain file error: %v", err)
+		logger.Error("read world terrain file error: %v", err)
 		return nil
 	}
 	return data
@@ -120,17 +120,17 @@ func (g *GameDataConfig) WriteWorldTerrain(data []byte) {
 	resourcePath := g.getResourcePathPrefix()
 	dirInfo, err := os.Stat(resourcePath)
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data config dir error: %v", err)
+		logger.Error("open game data config dir error: %v", err)
 		return
 	}
 	dirInfo, err = os.Stat(resourcePath + "/WorldStatic")
 	if err != nil || !dirInfo.IsDir() {
-		logger.LOG.Error("open game data world static dir error: %v", err)
+		logger.Error("open game data world static dir error: %v", err)
 		return
 	}
 	err = os.WriteFile(resourcePath+"/WorldStatic/world_terrain.bin", data, 0644)
 	if err != nil {
-		logger.LOG.Error("write world terrain file error: %v", err)
+		logger.Error("write world terrain file error: %v", err)
 		return
 	}
 }

gs/config/game_depot.go

@@ -16,15 +16,15 @@ func (g *GameDataConfig) loadGameDepot() {
 	playerElementsFilePath := g.binPrefix + "AbilityGroup/AbilityGroup_Other_PlayerElementAbility.json"
 	playerElementsFile, err := os.ReadFile(playerElementsFilePath)
 	if err != nil {
-		logger.LOG.Error("open file error: %v", err)
+		logger.Error("open file error: %v", err)
 		return
 	}
 	playerAbilities := make(map[string]*AvatarConfig)
 	err = json.Unmarshal(playerElementsFile, &playerAbilities)
 	if err != nil {
-		logger.LOG.Error("parse file error: %v", err)
+		logger.Error("parse file error: %v", err)
 		return
 	}
 	g.GameDepot.PlayerAbilities = playerAbilities
-	logger.LOG.Info("load %v PlayerAbilities", len(g.GameDepot.PlayerAbilities))
+	logger.Info("load %v PlayerAbilities", len(g.GameDepot.PlayerAbilities))
 }

gs/config/gather_data.go

@@ -23,29 +23,29 @@ func (g *GameDataConfig) loadGatherData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			gatherData := new(GatherData)
 			err = json.Unmarshal(i, gatherData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.GatherDataMap[gatherData.Id] = gatherData
 		}
 	}
-	logger.LOG.Info("load %v GatherData", len(g.GatherDataMap))
+	logger.Info("load %v GatherData", len(g.GatherDataMap))
 }

gs/config/item_data.go

@@ -89,31 +89,31 @@ func (g *GameDataConfig) loadItemData() {
 	for _, fileName := range fileNameList {
 		fileData, err := os.ReadFile(g.excelBinPrefix + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		list := make([]map[string]any, 0)
 		err = json.Unmarshal(fileData, &list)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		for _, v := range list {
 			i, err := json.Marshal(v)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			itemData := new(ItemData)
 			err = json.Unmarshal(i, itemData)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			g.ItemDataMap[itemData.Id] = itemData
 		}
 	}
-	logger.LOG.Info("load %v ItemData", len(g.ItemDataMap))
+	logger.Info("load %v ItemData", len(g.ItemDataMap))
 
 	for _, itemData := range g.ItemDataMap {
 		itemData.ItemEnumType = constant.ItemTypeConst.STRING_MAP[itemData.ItemType]

gs/config/open_config_entries.go

@@ -57,7 +57,7 @@ func (g *GameDataConfig) loadOpenConfig() {
 		dirPath := g.binPrefix + v
 		fileList, err := os.ReadDir(dirPath)
 		if err != nil {
-			logger.LOG.Error("open dir error: %v", err)
+			logger.Error("open dir error: %v", err)
 			return
 		}
 		for _, file := range fileList {
@@ -68,12 +68,12 @@ func (g *GameDataConfig) loadOpenConfig() {
 			config := make(map[string][]*OpenConfigData)
 			fileData, err := os.ReadFile(dirPath + "/" + fileName)
 			if err != nil {
-				logger.LOG.Error("open file error: %v", err)
+				logger.Error("open file error: %v", err)
 				continue
 			}
 			err = json.Unmarshal(fileData, &config)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			for kk, vv := range config {
@@ -83,11 +83,11 @@ func (g *GameDataConfig) loadOpenConfig() {
 		}
 	}
 	if len(list) == 0 {
-		logger.LOG.Error("no open config entries load")
+		logger.Error("no open config entries load")
 	}
 	g.OpenConfigEntries = make(map[string]*OpenConfigEntry)
 	for _, v := range list {
 		g.OpenConfigEntries[v.Name] = v
 	}
-	logger.LOG.Info("load %v OpenConfig", len(g.OpenConfigEntries))
+	logger.Info("load %v OpenConfig", len(g.OpenConfigEntries))
 }

gs/config/scene_points.go

@@ -39,7 +39,7 @@ func (g *GameDataConfig) loadScenePoints() {
 	dirPath := g.binPrefix + "Scene/Point"
 	fileList, err := os.ReadDir(dirPath)
 	if err != nil {
-		logger.LOG.Error("open dir error: %v", err)
+		logger.Error("open dir error: %v", err)
 		return
 	}
 	for _, file := range fileList {
@@ -50,19 +50,19 @@ func (g *GameDataConfig) loadScenePoints() {
 		startIndex := strings.Index(fileName, "scene")
 		endIndex := strings.Index(fileName, "_point.json")
 		if startIndex == -1 || endIndex == -1 || startIndex+5 > endIndex {
-			logger.LOG.Error("file name format error: %v", fileName)
+			logger.Error("file name format error: %v", fileName)
 			continue
 		}
 		sceneId := fileName[startIndex+5 : endIndex]
 		fileData, err := os.ReadFile(dirPath + "/" + fileName)
 		if err != nil {
-			logger.LOG.Error("open file error: %v", err)
+			logger.Error("open file error: %v", err)
 			continue
 		}
 		scenePointConfig := new(ScenePointConfig)
 		err = json.Unmarshal(fileData, scenePointConfig)
 		if err != nil {
-			logger.LOG.Error("parse file error: %v", err)
+			logger.Error("parse file error: %v", err)
 			continue
 		}
 		if len(scenePointConfig.Points) == 0 {
@@ -71,7 +71,7 @@ func (g *GameDataConfig) loadScenePoints() {
 		for k, v := range scenePointConfig.Points {
 			sceneIdInt32, err := strconv.ParseInt(k, 10, 32)
 			if err != nil {
-				logger.LOG.Error("parse file error: %v", err)
+				logger.Error("parse file error: %v", err)
 				continue
 			}
 			v.Id = int32(sceneIdInt32)
@@ -82,5 +82,5 @@ func (g *GameDataConfig) loadScenePoints() {
 			g.ScenePointEntries[scenePointEntry.Name] = scenePointEntry
 		}
 	}
-	logger.LOG.Info("load %v ScenePointEntries", len(g.ScenePointEntries))
+	logger.Info("load %v ScenePointEntries", len(g.ScenePointEntries))
 }

gs/dao/dao.go

@@ -20,7 +20,7 @@ func NewDao() (r *Dao, err error) {
 	clientOptions := options.Client().ApplyURI(config.CONF.Database.Url)
 	client, err := mongo.Connect(context.TODO(), clientOptions)
 	if err != nil {
-		logger.LOG.Error("mongo connect error: %v", err)
+		logger.Error("mongo connect error: %v", err)
 		return nil, err
 	}
 	r.client = client
@@ -31,6 +31,6 @@ func NewDao() (r *Dao, err error) {
 func (d *Dao) CloseDao() {
 	err := d.client.Disconnect(context.TODO())
 	if err != nil {
-		logger.LOG.Error("mongo close error: %v", err)
+		logger.Error("mongo close error: %v", err)
 	}
 }

gs/dao/player_dao.go

@@ -2,9 +2,11 @@ package dao
 
 import (
 	"context"
+
+	"hk4e/gs/model"
+
 	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
-	"hk4e/gs/model"
 )
 
 func (d *Dao) InsertPlayer(player *model.Player) error {

gs/game/aoi/aoi.go

@@ -34,7 +34,7 @@ func NewAoiManager(minX, maxX, numX, minY, maxY, numY, minZ, maxZ, numZ int16) (
 	r.maxZ = maxZ
 	r.numZ = numZ
 	r.gridMap = make(map[uint32]*Grid)
-	logger.LOG.Info("start init aoi area grid, num: %v", uint32(numX)*uint32(numY)*uint32(numZ))
+	logger.Info("start init aoi area grid, num: %v", uint32(numX)*uint32(numY)*uint32(numZ))
 	// 初始化aoi区域中所有的格子
 	for x := int16(0); x < numX; x++ {
 		for y := int16(0); y < numY; y++ {
@@ -55,7 +55,7 @@ func NewAoiManager(minX, maxX, numX, minY, maxY, numY, minZ, maxZ, numZ int16) (
 			}
 		}
 	}
-	logger.LOG.Info("init aoi area grid finish")
+	logger.Info("init aoi area grid finish")
 	return r
 }
 
@@ -175,7 +175,7 @@ func (a *AoiManager) GetEntityIdListByPos(x, y, z float32) (entityIdList []uint3
 	for _, v := range gridList {
 		tmp := v.GetEntityIdList()
 		entityIdList = append(entityIdList, tmp...)
-		//logger.LOG.Debug("Grid: gid: %d, tmp len: %v", v.gid, len(tmp))
+		// logger.Debug("Grid: gid: %d, tmp len: %v", v.gid, len(tmp))
 	}
 	return entityIdList
 }

gs/game/aoi/aoi_test.go

@@ -16,16 +16,16 @@ func TestAoiManagerGetSurrGridListByGid(t *testing.T) {
 		-150, 150, 3,
 		-150, 150, 3,
 	)
-	logger.LOG.Debug("aoiManager: %s", aoiManager.DebugString())
+	logger.Debug("aoiManager: %s", aoiManager.DebugString())
 	for k := range aoiManager.gridMap {
 		// 得到当前格子周边的九宫格
 		gridList := aoiManager.GetSurrGridListByGid(k)
 		// 得到九宫格所有的id
-		logger.LOG.Debug("gid: %d gridList len: %d", k, len(gridList))
+		logger.Debug("gid: %d gridList len: %d", k, len(gridList))
 		gidList := make([]uint32, 0, len(gridList))
 		for _, grid := range gridList {
 			gidList = append(gidList, grid.gid)
 		}
-		logger.LOG.Debug("Grid: gid: %d, surr grid gid list: %v", k, gidList)
+		logger.Debug("Grid: gid: %d, surr grid gid list: %v", k, gidList)
 	}
 }

gs/game/aoi/grid.go

@@ -44,7 +44,7 @@ func (g *Grid) RemoveEntityId(entityId uint32) {
 	if exist {
 		delete(g.entityIdMap, entityId)
 	} else {
-		logger.LOG.Error("remove entity id but it not exist, entityId: %v", entityId)
+		logger.Error("remove entity id but it not exist, entityId: %v", entityId)
 	}
 }
 

gs/game/command_controller.go

@@ -1,9 +1,10 @@
 package game
 
 import (
-	"hk4e/gs/model"
 	"strconv"
 	"strings"
+
+	"hk4e/gs/model"
 )
 
 // HelpCommand 帮助命令

gs/game/command_gm.go

@@ -9,7 +9,7 @@ import (
 func (c *CommandManager) GMTeleportPlayer(userId, sceneId uint32, posX, posY, posZ float64) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	GAME_MANAGER.TeleportPlayer(player, sceneId, &model.Vector{
@@ -42,7 +42,7 @@ func (c *CommandManager) GMAddUserWeapon(userId, itemId, itemCount uint32) {
 func (c *CommandManager) GMAddUserAvatar(userId, avatarId uint32) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	// 添加角色

gs/game/command_manager.go

@@ -86,7 +86,7 @@ func (c *CommandManager) RegisterRouter(cmdPerm CommandPerm, cmdFunc CommandFunc
 		s = strings.ToLower(s)
 		// 如果命令已注册则报错 后者覆盖前者
 		if c.HasCommand(s) {
-			logger.LOG.Error("register command repeat, name: %v", s)
+			logger.Error("register command repeat, name: %v", s)
 		}
 		// 记录命令
 		c.commandFuncRouter[s] = cmdFunc
@@ -112,7 +112,7 @@ func (c *CommandManager) InputCommand(executor any, text string) {
 	// 确保消息文本为 / 开头
 	// 如果不为这个开头那接下来就毫无意义
 	if strings.HasPrefix(text, "/") {
-		logger.LOG.Debug("command input, uid: %v, text: %v", c.GetExecutorId(executor), text)
+		logger.Debug("command input, uid: %v, text: %v", c.GetExecutorId(executor), text)
 
 		// 输入的命令将在其他协程中处理
 		c.commandTextInput <- &CommandMessage{Executor: executor, Text: text}
@@ -123,7 +123,7 @@ func (c *CommandManager) InputCommand(executor any, text string) {
 // 主协程接收到命令消息后执行
 func (c *CommandManager) HandleCommand(cmd *CommandMessage) {
 	executor := cmd.Executor
-	logger.LOG.Debug("command handle, uid: %v, text: %v", c.GetExecutorId(executor), cmd.Text)
+	logger.Debug("command handle, uid: %v, text: %v", c.GetExecutorId(executor), cmd.Text)
 
 	// 将开头的 / 去掉 并 分割出命令的每个参数
 	// 不区分命令的大小写 统一转为小写
@@ -150,7 +150,7 @@ func (c *CommandManager) HandleCommand(cmd *CommandMessage) {
 
 		// 分割出来的参数只有一个那肯定不是键值对
 		if len(cmdArg) < 2 {
-			logger.LOG.Debug("command arg error, uid: %v, name: %v, arg: %v, text: %v", c.GetExecutorId(executor), cmd.Name, cmdSplit, cmd.Text)
+			logger.Debug("command arg error, uid: %v, name: %v, arg: %v, text: %v", c.GetExecutorId(executor), cmd.Name, cmdSplit, cmd.Text)
 			c.SendMessage(executor, "格式错误，用法: /[命令名] -[参数名] [参数]。")
 			return
 		}
@@ -186,13 +186,13 @@ func (c *CommandManager) GetFriendList(friendList map[uint32]bool) map[uint32]bo
 // ExecCommand 执行命令
 func (c *CommandManager) ExecCommand(cmd *CommandMessage) {
 	executor := cmd.Executor
-	logger.LOG.Debug("command exec, uid: %v, name: %v, args: %v", c.GetExecutorId(executor), cmd.Name, cmd.Args)
+	logger.Debug("command exec, uid: %v, name: %v, args: %v", c.GetExecutorId(executor), cmd.Name, cmd.Args)
 
 	// 判断命令是否注册
 	cmdFunc, ok := c.commandFuncRouter[cmd.Name]
 	if !ok {
 		// 玩家可能会执行一些没有的命令仅做调试输出
-		logger.LOG.Debug("exec command not exist, uid: %v, name: %v", c.GetExecutorId(executor), cmd.Name)
+		logger.Debug("exec command not exist, uid: %v, name: %v", c.GetExecutorId(executor), cmd.Name)
 		c.SendMessage(executor, "命令不存在，输入 /help 查看帮助。")
 		return
 	}
@@ -200,21 +200,21 @@ func (c *CommandManager) ExecCommand(cmd *CommandMessage) {
 	cmdPerm, ok := c.commandPermMap[cmd.Name]
 	if !ok {
 		// 一般命令权限都会注册 没注册则报error错误
-		logger.LOG.Error("command exec permission not exist, name: %v", cmd.Name)
+		logger.Error("command exec permission not exist, name: %v", cmd.Name)
 		return
 	}
 
 	// 判断玩家的权限是否符合要求
 	player, ok := executor.(*model.Player)
 	if ok && player.IsGM < uint8(cmdPerm) {
-		logger.LOG.Debug("exec command permission denied, uid: %v, isGM: %v", player.PlayerID, player.IsGM)
+		logger.Debug("exec command permission denied, uid: %v, isGM: %v", player.PlayerID, player.IsGM)
 		c.SendMessage(player, "权限不足，该命令需要%v级权限。\n你目前的权限等级：%v", cmdPerm, player.IsGM)
 		return
 	}
 
-	logger.LOG.Debug("command start, uid: %v, name: %v, args: %v", c.GetExecutorId(executor), cmd.Name, cmd.Args)
+	logger.Debug("command start, uid: %v, name: %v, args: %v", c.GetExecutorId(executor), cmd.Name, cmd.Args)
 	cmdFunc(cmd) // 执行命令
-	logger.LOG.Debug("command done, uid: %v, name: %v, args: %v", c.GetExecutorId(executor), cmd.Name, cmd.Args)
+	logger.Debug("command done, uid: %v, name: %v, args: %v", c.GetExecutorId(executor), cmd.Name, cmd.Args)
 }
 
 // SendMessage 发送消息
@@ -230,7 +230,7 @@ func (c *CommandManager) SendMessage(executor any, msg string, param ...any) {
 		// str := executor.(string)
 	default:
 		// 无效的类型报错
-		logger.LOG.Error("command executor type error, type: %T", executor)
+		logger.Error("command executor type error, type: %T", executor)
 	}
 }
 

gs/game/game_manager.go

@@ -1,7 +1,8 @@
 package game
 
 import (
-	pb "google.golang.org/protobuf/proto"
+	"time"
+
 	"hk4e/gs/dao"
 	"hk4e/gs/model"
 	"hk4e/pkg/alg"
@@ -9,7 +10,8 @@ import (
 	"hk4e/pkg/reflection"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
-	"time"
+
+	pb "google.golang.org/protobuf/proto"
 )
 
 var GAME_MANAGER *GameManager = nil
@@ -88,7 +90,7 @@ func (g *GameManager) SendMsg(cmdId uint16, userId uint32, clientSeq uint32, pay
 	// 在这里直接序列化成二进制数据 防止发送的消息内包含各种游戏数据指针 而造成并发读写的问题
 	payloadMessageData, err := pb.Marshal(payloadMsg)
 	if err != nil {
-		logger.LOG.Error("parse payload msg to bin error: %v", err)
+		logger.Error("parse payload msg to bin error: %v", err)
 		return
 	}
 	netMsg.PayloadMessageData = payloadMessageData
@@ -112,7 +114,7 @@ func (g *GameManager) CommonRetError(cmdId uint16, player *model.Player, rsp pb.
 	if !ok {
 		return
 	}
-	logger.LOG.Debug("send common error: %v", rsp)
+	logger.Debug("send common error: %v", rsp)
 	g.SendMsg(cmdId, player.PlayerID, player.ClientSeq, rsp)
 }
 

gs/game/local_event_manager.go

@@ -1,10 +1,11 @@
 package game
 
 import (
+	"time"
+
 	"hk4e/gs/model"
 	"hk4e/pkg/logger"
 	"hk4e/pkg/object"
-	"time"
 )
 
 // 本地事件队列管理器
@@ -57,7 +58,7 @@ func (l *LocalEventManager) LocalEventHandle(localEvent *LocalEvent) {
 				playerCopy := new(model.Player)
 				err := object.FastDeepCopy(playerCopy, player)
 				if err != nil {
-					logger.LOG.Error("deep copy player error: %v", err)
+					logger.Error("deep copy player error: %v", err)
 					continue
 				}
 				insertPlayerList = append(insertPlayerList, playerCopy)
@@ -66,7 +67,7 @@ func (l *LocalEventManager) LocalEventHandle(localEvent *LocalEvent) {
 				playerCopy := new(model.Player)
 				err := object.FastDeepCopy(playerCopy, player)
 				if err != nil {
-					logger.LOG.Error("deep copy player error: %v", err)
+					logger.Error("deep copy player error: %v", err)
 					continue
 				}
 				updatePlayerList = append(updatePlayerList, playerCopy)
@@ -75,7 +76,7 @@ func (l *LocalEventManager) LocalEventHandle(localEvent *LocalEvent) {
 				playerCopy := new(model.Player)
 				err := object.FastDeepCopy(playerCopy, player)
 				if err != nil {
-					logger.LOG.Error("deep copy player error: %v", err)
+					logger.Error("deep copy player error: %v", err)
 					continue
 				}
 				updatePlayerList = append(updatePlayerList, playerCopy)
@@ -87,6 +88,6 @@ func (l *LocalEventManager) LocalEventHandle(localEvent *LocalEvent) {
 		}
 		endTime := time.Now().UnixNano()
 		costTime := endTime - startTime
-		logger.LOG.Info("run save user copy cost time: %v ns", costTime)
+		logger.Info("run save user copy cost time: %v ns", costTime)
 	}
 }

gs/game/route_manager.go

@@ -30,12 +30,12 @@ func (r *RouteManager) registerRouter(cmdId uint16, handlerFunc HandlerFunc) {
 func (r *RouteManager) doRoute(cmdId uint16, userId uint32, clientSeq uint32, payloadMsg pb.Message) {
 	handlerFunc, ok := r.handlerFuncRouteMap[cmdId]
 	if !ok {
-		logger.LOG.Error("no route for msg, cmdId: %v", cmdId)
+		logger.Error("no route for msg, cmdId: %v", cmdId)
 		return
 	}
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		// 临时为了调试便捷搞的重连 生产环境请务必去除 不然新用户会一直重连不能进入
 		// GAME_MANAGER.ReconnectPlayer(userId)
 		return

gs/game/tick_manager.go

@@ -21,7 +21,7 @@ type TickManager struct {
 func NewTickManager() (r *TickManager) {
 	r = new(TickManager)
 	r.ticker = time.NewTicker(time.Millisecond * 100)
-	logger.LOG.Info("game server tick start at: %v", time.Now().UnixMilli())
+	logger.Info("game server tick start at: %v", time.Now().UnixMilli())
 	return r
 }
 
@@ -59,15 +59,15 @@ func (t *TickManager) OnGameServerTick() {
 }
 
 func (t *TickManager) onTickWeek(now int64) {
-	logger.LOG.Info("on tick week, time: %v", now)
+	logger.Info("on tick week, time: %v", now)
 }
 
 func (t *TickManager) onTickDay(now int64) {
-	logger.LOG.Info("on tick day, time: %v", now)
+	logger.Info("on tick day, time: %v", now)
 }
 
 func (t *TickManager) onTickHour(now int64) {
-	logger.LOG.Info("on tick hour, time: %v", now)
+	logger.Info("on tick hour, time: %v", now)
 }
 
 func (t *TickManager) onTick10Minute(now int64) {
@@ -91,7 +91,7 @@ func (t *TickManager) onTickMinute(now int64) {
 			for itemId := range allItemDataConfig {
 				itemDataConfig, ok := allItemDataConfig[itemId]
 				if !ok {
-					logger.LOG.Error("config is nil, itemId: %v", itemId)
+					logger.Error("config is nil, itemId: %v", itemId)
 					return
 				}
 				// TODO 3.0.0REL版本中 发送某些无效家具 可能会导致客户端背包家具界面卡死

gs/game/user_avatar.go

@@ -31,20 +31,20 @@ func (g *GameManager) GetAllAvatarDataConfig() map[int32]*gdc.AvatarData {
 func (g *GameManager) AddUserAvatar(userId uint32, avatarId uint32) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	player.AddAvatar(avatarId)
 	avatar := player.AvatarMap[avatarId]
 	if avatar == nil {
-		logger.LOG.Error("avatar is nil, avatarId", avatarId)
+		logger.Error("avatar is nil, avatarId", avatarId)
 		return
 	}
 
 	// 添加初始武器
 	avatarDataConfig, ok := gdc.CONF.AvatarDataMap[int32(avatarId)]
 	if !ok {
-		logger.LOG.Error("config is nil, itemId: %v", avatarId)
+		logger.Error("config is nil, itemId: %v", avatarId)
 		return
 	}
 	weaponId := g.AddUserWeapon(player.PlayerID, uint32(avatarDataConfig.InitialWeapon))
@@ -62,7 +62,7 @@ func (g *GameManager) AddUserAvatar(userId uint32, avatarId uint32) {
 }
 
 func (g *GameManager) WearEquipReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user wear equip, uid: %v", player.PlayerID)
+	logger.Debug("user wear equip, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.WearEquipReq)
 	avatarGuid := req.AvatarGuid
 	equipGuid := req.EquipGuid
@@ -80,7 +80,7 @@ func (g *GameManager) WearEquipReq(player *model.Player, payloadMsg pb.Message)
 func (g *GameManager) WearUserAvatarEquip(userId uint32, avatarId uint32, weaponId uint64) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	avatar := player.AvatarMap[avatarId]
@@ -127,7 +127,7 @@ func (g *GameManager) WearUserAvatarEquip(userId uint32, avatarId uint32, weapon
 }
 
 func (g *GameManager) AvatarChangeCostumeReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change avatar costume, uid: %v", player.PlayerID)
+	logger.Debug("user change avatar costume, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.AvatarChangeCostumeReq)
 	avatarGuid := req.AvatarGuid
 	costumeId := req.CostumeId
@@ -165,7 +165,7 @@ func (g *GameManager) AvatarChangeCostumeReq(player *model.Player, payloadMsg pb
 }
 
 func (g *GameManager) AvatarWearFlycloakReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change avatar fly cloak, uid: %v", player.PlayerID)
+	logger.Debug("user change avatar fly cloak, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.AvatarWearFlycloakReq)
 	avatarGuid := req.AvatarGuid
 	flycloakId := req.FlycloakId
@@ -236,7 +236,7 @@ func (g *GameManager) PacketAvatarEquipTakeOffNotify(avatar *model.Avatar, weapo
 func (g *GameManager) UpdateUserAvatarFightProp(userId uint32, avatarId uint32) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	avatar := player.AvatarMap[avatarId]

gs/game/user_chat.go

@@ -12,7 +12,7 @@ import (
 )
 
 func (g *GameManager) PullRecentChatReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user pull recent chat, uid: %v", player.PlayerID)
+	logger.Debug("user pull recent chat, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PullRecentChatReq)
 	// 经研究发现 原神现网环境 客户端仅拉取最新的5条未读聊天消息 所以人太多的话小姐姐不回你消息是有原因的
 	// 因此 阿米你这样做真的合适吗 不过现在代码到了我手上我想怎么写就怎么写 我才不会重蹈覆辙
@@ -52,7 +52,7 @@ func (g *GameManager) PullRecentChatReq(player *model.Player, payloadMsg pb.Mess
 }
 
 func (g *GameManager) PullPrivateChatReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user pull private chat, uid: %v", player.PlayerID)
+	logger.Debug("user pull private chat, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PullPrivateChatReq)
 	targetUid := req.TargetUid
 	pullNum := req.PullNum
@@ -132,7 +132,7 @@ func (g *GameManager) SendPrivateChat(player, targetPlayer *model.Player, conten
 }
 
 func (g *GameManager) PrivateChatReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user send private chat, uid: %v", player.PlayerID)
+	logger.Debug("user send private chat, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PrivateChatReq)
 	targetUid := req.TargetUid
 	content := req.Content
@@ -171,7 +171,7 @@ func (g *GameManager) PrivateChatReq(player *model.Player, payloadMsg pb.Message
 }
 
 func (g *GameManager) ReadPrivateChatReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user read private chat, uid: %v", player.PlayerID)
+	logger.Debug("user read private chat, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ReadPrivateChatReq)
 	targetUid := req.TargetUid
 
@@ -189,7 +189,7 @@ func (g *GameManager) ReadPrivateChatReq(player *model.Player, payloadMsg pb.Mes
 }
 
 func (g *GameManager) PlayerChatReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user multiplayer chat, uid: %v", player.PlayerID)
+	logger.Debug("user multiplayer chat, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PlayerChatReq)
 	channelId := req.ChannelId
 	chatInfo := req.ChatInfo

gs/game/user_common_handler.go

@@ -12,7 +12,7 @@ import (
 )
 
 func (g *GameManager) PlayerSetPauseReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user pause, uid: %v", player.PlayerID)
+	logger.Debug("user pause, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PlayerSetPauseReq)
 	isPaused := req.IsPaused
 	player.Pause = isPaused
@@ -21,7 +21,7 @@ func (g *GameManager) PlayerSetPauseReq(player *model.Player, payloadMsg pb.Mess
 }
 
 func (g *GameManager) TowerAllDataReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get tower all data, uid: %v", player.PlayerID)
+	logger.Debug("user get tower all data, uid: %v", player.PlayerID)
 
 	towerAllDataRsp := &proto.TowerAllDataRsp{
 		TowerScheduleId:        29,
@@ -40,7 +40,7 @@ func (g *GameManager) TowerAllDataReq(player *model.Player, payloadMsg pb.Messag
 }
 
 func (g *GameManager) EntityAiSyncNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user entity ai sync, uid: %v", player.PlayerID)
+	logger.Debug("user entity ai sync, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EntityAiSyncNotify)
 
 	entityAiSyncNotify := &proto.EntityAiSyncNotify{
@@ -59,20 +59,20 @@ func (g *GameManager) EntityAiSyncNotify(player *model.Player, payloadMsg pb.Mes
 func (g *GameManager) ClientTimeNotify(userId uint32, clientTime uint32) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
-	logger.LOG.Debug("client time notify, uid: %v, time: %v", userId, clientTime)
+	logger.Debug("client time notify, uid: %v, time: %v", userId, clientTime)
 	player.ClientTime = clientTime
 }
 
 func (g *GameManager) ClientRttNotify(userId uint32, clientRtt uint32) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
-	logger.LOG.Debug("client rtt notify, uid: %v, rtt: %v", userId, clientRtt)
+	logger.Debug("client rtt notify, uid: %v, rtt: %v", userId, clientRtt)
 	player.ClientRTT = clientRtt
 }
 
@@ -102,14 +102,14 @@ func (g *GameManager) ServerAnnounceRevokeNotify(announceId uint32) {
 }
 
 func (g *GameManager) ToTheMoonEnterSceneReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user ttm enter scene, uid: %v", player.PlayerID)
+	logger.Debug("user ttm enter scene, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ToTheMoonEnterSceneReq)
 	_ = req
 	g.SendMsg(cmd.ToTheMoonEnterSceneRsp, player.PlayerID, player.ClientSeq, new(proto.ToTheMoonEnterSceneRsp))
 }
 
 func (g *GameManager) SetEntityClientDataNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user set entity client data, uid: %v", player.PlayerID)
+	logger.Debug("user set entity client data, uid: %v", player.PlayerID)
 	ntf := payloadMsg.(*proto.SetEntityClientDataNotify)
 	g.SendMsg(cmd.SetEntityClientDataNotify, player.PlayerID, player.ClientSeq, ntf)
 }

gs/game/user_fight_sync.go

@@ -54,7 +54,7 @@ func DoForward[IET model.InvokeEntryType](player *model.Player, req pb.Message,
 }
 
 func (g *GameManager) UnionCmdNotify(player *model.Player, payloadMsg pb.Message) {
-	//logger.LOG.Debug("user send union cmd, uid: %v", player.PlayerID)
+	// logger.Debug("user send union cmd, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.UnionCmdNotify)
 	_ = req
 	if player.SceneLoadState != model.SceneEnterDone {
@@ -67,7 +67,7 @@ func (g *GameManager) UnionCmdNotify(player *model.Player, payloadMsg pb.Message
 }
 
 func (g *GameManager) MassiveEntityElementOpBatchNotify(player *model.Player, payloadMsg pb.Message) {
-	//logger.LOG.Debug("user meeo sync, uid: %v", player.PlayerID)
+	// logger.Debug("user meeo sync, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.MassiveEntityElementOpBatchNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
@@ -84,7 +84,7 @@ func (g *GameManager) MassiveEntityElementOpBatchNotify(player *model.Player, pa
 }
 
 func (g *GameManager) CombatInvocationsNotify(player *model.Player, payloadMsg pb.Message) {
-	//logger.LOG.Debug("user combat invocations, uid: %v", player.PlayerID)
+	// logger.Debug("user combat invocations, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.CombatInvocationsNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
@@ -99,7 +99,7 @@ func (g *GameManager) CombatInvocationsNotify(player *model.Player, payloadMsg p
 			entityMoveInfo := new(proto.EntityMoveInfo)
 			err := pb.Unmarshal(entry.CombatData, entityMoveInfo)
 			if err != nil {
-				logger.LOG.Error("parse EntityMoveInfo error: %v", err)
+				logger.Error("parse EntityMoveInfo error: %v", err)
 				continue
 			}
 			motionInfo := entityMoveInfo.MotionInfo
@@ -144,9 +144,9 @@ func (g *GameManager) CombatInvocationsNotify(player *model.Player, payloadMsg p
 			evtAnimatorStateChangedInfo := new(proto.EvtAnimatorStateChangedInfo)
 			err := pb.Unmarshal(entry.CombatData, evtAnimatorStateChangedInfo)
 			if err != nil {
-				logger.LOG.Error("parse EvtAnimatorStateChangedInfo error: %v", err)
+				logger.Error("parse EvtAnimatorStateChangedInfo error: %v", err)
 			}
-			logger.LOG.Debug("EvtAnimatorStateChangedInfo: %v", entry, player.PlayerID)
+			logger.Debug("EvtAnimatorStateChangedInfo: %v", entry, player.PlayerID)
 			player.CombatInvokeHandler.AddEntry(entry.ForwardType, entry)
 		default:
 			player.CombatInvokeHandler.AddEntry(entry.ForwardType, entry)
@@ -155,14 +155,14 @@ func (g *GameManager) CombatInvocationsNotify(player *model.Player, payloadMsg p
 }
 
 func (g *GameManager) AbilityInvocationsNotify(player *model.Player, payloadMsg pb.Message) {
-	//logger.LOG.Debug("user ability invocations, uid: %v", player.PlayerID)
+	// logger.Debug("user ability invocations, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.AbilityInvocationsNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
 
 	for _, entry := range req.Invokes {
-		//logger.LOG.Debug("AbilityInvocationsNotify: %v", entry, player.PlayerID)
+		// logger.Debug("AbilityInvocationsNotify: %v", entry, player.PlayerID)
 
 		// switch entry.ArgumentType {
 		// case proto.AbilityInvokeArgument_ABILITY_INVOKE_ARGUMENT_META_MODIFIER_CHANGE:
@@ -171,17 +171,17 @@ func (g *GameManager) AbilityInvocationsNotify(player *model.Player, payloadMsg
 		//	if worldAvatar != nil {
 		//		for _, ability := range worldAvatar.abilityList {
 		//			if ability.InstancedAbilityId == entry.Head.InstancedAbilityId {
-		//				logger.LOG.Error("A: %v", ability)
+		//				logger.Error("A: %v", ability)
 		//			}
 		//		}
 		//		for _, modifier := range worldAvatar.modifierList {
 		//			if modifier.InstancedAbilityId == entry.Head.InstancedAbilityId {
-		//				logger.LOG.Error("B: %v", modifier)
+		//				logger.Error("B: %v", modifier)
 		//			}
 		//		}
 		//		for _, modifier := range worldAvatar.modifierList {
 		//			if modifier.InstancedModifierId == entry.Head.InstancedModifierId {
-		//				logger.LOG.Error("C: %v", modifier)
+		//				logger.Error("C: %v", modifier)
 		//			}
 		//		}
 		//	}
@@ -195,28 +195,28 @@ func (g *GameManager) AbilityInvocationsNotify(player *model.Player, payloadMsg
 }
 
 func (g *GameManager) ClientAbilityInitFinishNotify(player *model.Player, payloadMsg pb.Message) {
-	//logger.LOG.Debug("user client ability init finish, uid: %v", player.PlayerID)
+	// logger.Debug("user client ability init finish, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ClientAbilityInitFinishNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
 	invokeHandler := model.NewInvokeHandler[proto.AbilityInvokeEntry]()
 	for _, entry := range req.Invokes {
-		logger.LOG.Debug("ClientAbilityInitFinishNotify: %v", entry, player.PlayerID)
+		logger.Debug("ClientAbilityInitFinishNotify: %v", entry, player.PlayerID)
 		invokeHandler.AddEntry(entry.ForwardType, entry)
 	}
 	DoForward[proto.AbilityInvokeEntry](player, &proto.ClientAbilityInitFinishNotify{}, []string{"EntityId"}, "Invokes", invokeHandler)
 }
 
 func (g *GameManager) ClientAbilityChangeNotify(player *model.Player, payloadMsg pb.Message) {
-	//logger.LOG.Debug("user client ability change, uid: %v", player.PlayerID)
+	// logger.Debug("user client ability change, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ClientAbilityChangeNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
 	invokeHandler := model.NewInvokeHandler[proto.AbilityInvokeEntry]()
 	for _, entry := range req.Invokes {
-		logger.LOG.Debug("ClientAbilityChangeNotify: %v", entry, player.PlayerID)
+		logger.Debug("ClientAbilityChangeNotify: %v", entry, player.PlayerID)
 
 		invokeHandler.AddEntry(entry.ForwardType, entry)
 	}
@@ -232,7 +232,7 @@ func (g *GameManager) ClientAbilityChangeNotify(player *model.Player, payloadMsg
 			abilityMetaAddAbility := new(proto.AbilityMetaAddAbility)
 			err := pb.Unmarshal(abilityInvokeEntry.AbilityData, abilityMetaAddAbility)
 			if err != nil {
-				logger.LOG.Error("%v", err)
+				logger.Error("%v", err)
 				continue
 			}
 			worldAvatar := world.GetWorldAvatarByEntityId(abilityInvokeEntry.EntityId)
@@ -244,7 +244,7 @@ func (g *GameManager) ClientAbilityChangeNotify(player *model.Player, payloadMsg
 			abilityMetaModifierChange := new(proto.AbilityMetaModifierChange)
 			err := pb.Unmarshal(abilityInvokeEntry.AbilityData, abilityMetaModifierChange)
 			if err != nil {
-				logger.LOG.Error("%v", err)
+				logger.Error("%v", err)
 				continue
 			}
 			abilityAppliedModifier := &proto.AbilityAppliedModifier{
@@ -273,68 +273,68 @@ func (g *GameManager) ClientAbilityChangeNotify(player *model.Player, payloadMsg
 }
 
 func (g *GameManager) EvtDoSkillSuccNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user event do skill success, uid: %v", player.PlayerID)
+	logger.Debug("user event do skill success, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtDoSkillSuccNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtDoSkillSuccNotify: %v", req)
+	logger.Debug("EvtDoSkillSuccNotify: %v", req)
 
 	// 处理技能开始的耐力消耗
 	g.SkillStartStamina(player, req.CasterId, req.SkillId)
 }
 
 func (g *GameManager) EvtAvatarEnterFocusNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user avatar enter focus, uid: %v", player.PlayerID)
+	logger.Debug("user avatar enter focus, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtAvatarEnterFocusNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtAvatarEnterFocusNotify: %v", req)
+	logger.Debug("EvtAvatarEnterFocusNotify: %v", req)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	g.SendToWorldA(world, cmd.EvtAvatarEnterFocusNotify, player.ClientSeq, req)
 }
 
 func (g *GameManager) EvtAvatarUpdateFocusNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user avatar update focus, uid: %v", player.PlayerID)
+	logger.Debug("user avatar update focus, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtAvatarUpdateFocusNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtAvatarUpdateFocusNotify: %v", req)
+	logger.Debug("EvtAvatarUpdateFocusNotify: %v", req)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	g.SendToWorldA(world, cmd.EvtAvatarUpdateFocusNotify, player.ClientSeq, req)
 }
 
 func (g *GameManager) EvtAvatarExitFocusNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user avatar exit focus, uid: %v", player.PlayerID)
+	logger.Debug("user avatar exit focus, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtAvatarExitFocusNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtAvatarExitFocusNotify: %v", req)
+	logger.Debug("EvtAvatarExitFocusNotify: %v", req)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	g.SendToWorldA(world, cmd.EvtAvatarExitFocusNotify, player.ClientSeq, req)
 }
 
 func (g *GameManager) EvtEntityRenderersChangedNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user entity render change, uid: %v", player.PlayerID)
+	logger.Debug("user entity render change, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtEntityRenderersChangedNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtEntityRenderersChangedNotify: %v", req)
+	logger.Debug("EvtEntityRenderersChangedNotify: %v", req)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	g.SendToWorldA(world, cmd.EvtEntityRenderersChangedNotify, player.ClientSeq, req)
 }
 
 func (g *GameManager) EvtCreateGadgetNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user create gadget, uid: %v", player.PlayerID)
+	logger.Debug("user create gadget, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtCreateGadgetNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtCreateGadgetNotify: %v", req)
+	logger.Debug("EvtCreateGadgetNotify: %v", req)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	scene := world.GetSceneById(player.SceneId)
 	scene.ClientCreateEntityGadget(&model.Vector{
@@ -350,12 +350,12 @@ func (g *GameManager) EvtCreateGadgetNotify(player *model.Player, payloadMsg pb.
 }
 
 func (g *GameManager) EvtDestroyGadgetNotify(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user destroy gadget, uid: %v", player.PlayerID)
+	logger.Debug("user destroy gadget, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EvtDestroyGadgetNotify)
 	if player.SceneLoadState != model.SceneEnterDone {
 		return
 	}
-	logger.LOG.Debug("EvtDestroyGadgetNotify: %v", req)
+	logger.Debug("EvtDestroyGadgetNotify: %v", req)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	scene := world.GetSceneById(player.SceneId)
 	scene.DestroyEntity(req.EntityId)

gs/game/user_gacha.go

@@ -1,10 +1,10 @@
 package game
 
 import (
-	"hk4e/gdconf"
 	"time"
 
 	"hk4e/common/config"
+	"hk4e/gdconf"
 	"hk4e/gs/model"
 	"hk4e/pkg/logger"
 	"hk4e/pkg/random"
@@ -22,7 +22,7 @@ type UserInfo struct {
 
 // 获取卡池信息
 func (g *GameManager) GetGachaInfoReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get gacha info, uid: %v", player.PlayerID)
+	logger.Debug("user get gacha info, uid: %v", player.PlayerID)
 	serverAddr := config.CONF.Hk4e.GachaHistoryServer
 	userInfo := &UserInfo{
 		UserId: player.PlayerID,
@@ -35,7 +35,7 @@ func (g *GameManager) GetGachaInfoReq(player *model.Player, payloadMsg pb.Messag
 	token := jwt.NewWithClaims(jwt.SigningMethodHS512, userInfo)
 	jwtStr, err := token.SignedString([]byte("flswld"))
 	if err != nil {
-		logger.LOG.Error("generate jwt error: %v", err)
+		logger.Error("generate jwt error: %v", err)
 		jwtStr = "default.jwt.token"
 	}
 
@@ -195,7 +195,7 @@ func (g *GameManager) GetGachaInfoReq(player *model.Player, payloadMsg pb.Messag
 }
 
 func (g *GameManager) DoGachaReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user do gacha, uid: %v", player.PlayerID)
+	logger.Debug("user do gacha, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.DoGachaReq)
 	gachaScheduleId := req.GachaScheduleId
 	gachaTimes := req.GachaTimes
@@ -319,7 +319,7 @@ func (g *GameManager) DoGachaReq(player *model.Player, payloadMsg pb.Message) {
 		doGachaRsp.GachaItemList = append(doGachaRsp.GachaItemList, gachaItem)
 	}
 
-	logger.LOG.Debug("doGachaRsp: %v", doGachaRsp.String())
+	logger.Debug("doGachaRsp: %v", doGachaRsp.String())
 	g.SendMsg(cmd.DoGachaRsp, player.PlayerID, player.ClientSeq, doGachaRsp)
 }
 
@@ -380,21 +380,21 @@ const (
 func (g *GameManager) doGachaOnce(userId uint32, gachaType uint32, mustGetUpEnable bool, weaponFix bool) (bool, uint32) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return false, 0
 	}
 
 	// 找到卡池对应的掉落组
 	dropGroupDataConfig := gdconf.CONF.DropGroupDataMap[int32(gachaType)]
 	if dropGroupDataConfig == nil {
-		logger.LOG.Error("drop group not found, drop id: %v", gachaType)
+		logger.Error("drop group not found, drop id: %v", gachaType)
 		return false, 0
 	}
 
 	// 获取用户的卡池保底信息
 	gachaPoolInfo := player.DropInfo.GachaPoolInfo[gachaType]
 	if gachaPoolInfo == nil {
-		logger.LOG.Error("user gacha pool info not found, gacha type: %v", gachaType)
+		logger.Error("user gacha pool info not found, gacha type: %v", gachaType)
 		return false, 0
 	}
 
@@ -448,7 +448,7 @@ func (g *GameManager) doGachaOnce(userId uint32, gachaType uint32, mustGetUpEnab
 			} else if drop.Result == blueDropId {
 				fixDrop.Weight = drop.Weight - addOrangeWeight - addPurpleWeight
 			} else {
-				logger.LOG.Error("invalid drop group id, does not match any case of orange/purple/blue, result group id: %v", drop.Result)
+				logger.Error("invalid drop group id, does not match any case of orange/purple/blue, result group id: %v", drop.Result)
 				fixDrop.Weight = drop.Weight
 			}
 			fixDropGroupDataConfig.DropConfig = append(fixDropGroupDataConfig.DropConfig, fixDrop)
@@ -473,20 +473,20 @@ func (g *GameManager) doGachaOnce(userId uint32, gachaType uint32, mustGetUpEnab
 		allAvatarDataConfig := g.GetAllAvatarDataConfig()
 		avatarDataConfig := allAvatarDataConfig[int32(avatarId)]
 		if avatarDataConfig == nil {
-			logger.LOG.Error("avatar data config not found, avatar id: %v", avatarId)
+			logger.Error("avatar data config not found, avatar id: %v", avatarId)
 			return false, 0
 		}
 		if avatarDataConfig.QualityType == "QUALITY_ORANGE" {
 			itemColor = Orange
-			logger.LOG.Debug("[orange avatar], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
+			logger.Debug("[orange avatar], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
 			if gachaPoolInfo.OrangeTimes > 90 {
-				logger.LOG.Error("[abnormal orange avatar], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
+				logger.Error("[abnormal orange avatar], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
 			}
 		} else if avatarDataConfig.QualityType == "QUALITY_PURPLE" {
 			itemColor = Purple
-			logger.LOG.Debug("[purple avatar], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
+			logger.Debug("[purple avatar], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
 			if gachaPoolInfo.PurpleTimes > 10 {
-				logger.LOG.Error("[abnormal purple avatar], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
+				logger.Error("[abnormal purple avatar], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
 			}
 		} else {
 			itemColor = Blue
@@ -497,20 +497,20 @@ func (g *GameManager) doGachaOnce(userId uint32, gachaType uint32, mustGetUpEnab
 		allWeaponDataConfig := g.GetAllWeaponDataConfig()
 		weaponDataConfig := allWeaponDataConfig[int32(gachaItemId)]
 		if weaponDataConfig == nil {
-			logger.LOG.Error("weapon item data config not found, item id: %v", gachaItemId)
+			logger.Error("weapon item data config not found, item id: %v", gachaItemId)
 			return false, 0
 		}
 		if weaponDataConfig.RankLevel == 5 {
 			itemColor = Orange
-			logger.LOG.Debug("[orange weapon], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
+			logger.Debug("[orange weapon], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
 			if gachaPoolInfo.OrangeTimes > 90 {
-				logger.LOG.Error("[abnormal orange weapon], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
+				logger.Error("[abnormal orange weapon], times: %v, gachaItemId: %v", gachaPoolInfo.OrangeTimes, gachaItemId)
 			}
 		} else if weaponDataConfig.RankLevel == 4 {
 			itemColor = Purple
-			logger.LOG.Debug("[purple weapon], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
+			logger.Debug("[purple weapon], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
 			if gachaPoolInfo.PurpleTimes > 10 {
-				logger.LOG.Error("[abnormal purple weapon], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
+				logger.Error("[abnormal purple weapon], times: %v, gachaItemId: %v", gachaPoolInfo.PurpleTimes, gachaItemId)
 			}
 		} else {
 			itemColor = Blue
@@ -526,10 +526,10 @@ func (g *GameManager) doGachaOnce(userId uint32, gachaType uint32, mustGetUpEnab
 			upOrangeDropId := int32(gachaType*100 + 12)
 			// 替换本次结果为5星大保底
 			if gachaPoolInfo.MustGetUpOrange {
-				logger.LOG.Debug("trigger must get up orange, uid: %v", userId)
+				logger.Debug("trigger must get up orange, uid: %v", userId)
 				upOrangeDropGroupDataConfig := gdconf.CONF.DropGroupDataMap[upOrangeDropId]
 				if upOrangeDropGroupDataConfig == nil {
-					logger.LOG.Error("drop group not found, drop id: %v", upOrangeDropId)
+					logger.Error("drop group not found, drop id: %v", upOrangeDropId)
 					return false, 0
 				}
 				upOrangeOk, upOrangeDrop := g.doFullRandDrop(upOrangeDropGroupDataConfig)
@@ -553,10 +553,10 @@ func (g *GameManager) doGachaOnce(userId uint32, gachaType uint32, mustGetUpEnab
 			upPurpleDropId := int32(gachaType*100 + 22)
 			// 替换本次结果为4星大保底
 			if gachaPoolInfo.MustGetUpPurple {
-				logger.LOG.Debug("trigger must get up purple, uid: %v", userId)
+				logger.Debug("trigger must get up purple, uid: %v", userId)
 				upPurpleDropGroupDataConfig := gdconf.CONF.DropGroupDataMap[upPurpleDropId]
 				if upPurpleDropGroupDataConfig == nil {
-					logger.LOG.Error("drop group not found, drop id: %v", upPurpleDropId)
+					logger.Error("drop group not found, drop id: %v", upPurpleDropId)
 					return false, 0
 				}
 				upPurpleOk, upPurpleDrop := g.doFullRandDrop(upPurpleDropGroupDataConfig)
@@ -582,7 +582,7 @@ func (g *GameManager) doFullRandDrop(dropGroupDataConfig *gdconf.DropGroupData)
 	for {
 		drop := g.doRandDropOnce(dropGroupDataConfig)
 		if drop == nil {
-			logger.LOG.Error("weight error, drop group config: %v", dropGroupDataConfig)
+			logger.Error("weight error, drop group config: %v", dropGroupDataConfig)
 			return false, nil
 		}
 		if drop.IsEnd {
@@ -592,7 +592,7 @@ func (g *GameManager) doFullRandDrop(dropGroupDataConfig *gdconf.DropGroupData)
 		// 进行下一步掉落流程
 		dropGroupDataConfig = gdconf.CONF.DropGroupDataMap[drop.Result]
 		if dropGroupDataConfig == nil {
-			logger.LOG.Error("drop config tab exist error, invalid drop id: %v", drop.Result)
+			logger.Error("drop config tab exist error, invalid drop id: %v", drop.Result)
 			return false, nil
 		}
 	}

gs/game/user_item.go

@@ -51,7 +51,7 @@ func (g *GameManager) GetAllItemDataConfig() map[int32]*gdc.ItemData {
 func (g *GameManager) AddUserItem(userId uint32, itemList []*UserItem, isHint bool, hintReason uint16) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	for _, userItem := range itemList {
@@ -118,7 +118,7 @@ func (g *GameManager) AddUserItem(userId uint32, itemList []*UserItem, isHint bo
 func (g *GameManager) CostUserItem(userId uint32, itemList []*UserItem) {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	for _, userItem := range itemList {

gs/game/user_login.go

@@ -1,7 +1,6 @@
 package game
 
 import (
-	pb "google.golang.org/protobuf/proto"
 	"time"
 
 	gdc "hk4e/gs/config"
@@ -11,10 +10,12 @@ import (
 	"hk4e/pkg/reflection"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
+
+	pb "google.golang.org/protobuf/proto"
 )
 
 func (g *GameManager) OnLogin(userId uint32, clientSeq uint32) {
-	logger.LOG.Info("user login, uid: %v", userId)
+	logger.Info("user login, uid: %v", userId)
 	player, asyncWait := USER_MANAGER.OnlineUser(userId, clientSeq)
 	if !asyncWait {
 		g.OnLoginOk(userId, player, clientSeq)
@@ -59,9 +60,9 @@ func (g *GameManager) OnLoginOk(userId uint32, player *model.Player, clientSeq u
 }
 
 func (g *GameManager) OnReg(userId uint32, clientSeq uint32, payloadMsg pb.Message) {
-	logger.LOG.Debug("user reg, uid: %v", userId)
+	logger.Debug("user reg, uid: %v", userId)
 	req := payloadMsg.(*proto.SetPlayerBornDataReq)
-	logger.LOG.Debug("avatar id: %v, nickname: %v", req.AvatarId, req.NickName)
+	logger.Debug("avatar id: %v, nickname: %v", req.AvatarId, req.NickName)
 
 	exist, asyncWait := USER_MANAGER.CheckUserExistOnReg(userId, req, clientSeq)
 	if !asyncWait {
@@ -71,20 +72,20 @@ func (g *GameManager) OnReg(userId uint32, clientSeq uint32, payloadMsg pb.Messa
 
 func (g *GameManager) OnRegOk(exist bool, req *proto.SetPlayerBornDataReq, userId uint32, clientSeq uint32) {
 	if exist {
-		logger.LOG.Error("recv reg req, but user is already exist, userId: %v", userId)
+		logger.Error("recv reg req, but user is already exist, userId: %v", userId)
 		return
 	}
 
 	nickName := req.NickName
 	mainCharAvatarId := req.GetAvatarId()
 	if mainCharAvatarId != 10000005 && mainCharAvatarId != 10000007 {
-		logger.LOG.Error("invalid main char avatar id: %v", mainCharAvatarId)
+		logger.Error("invalid main char avatar id: %v", mainCharAvatarId)
 		return
 	}
 
 	player := g.CreatePlayer(userId, nickName, mainCharAvatarId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return
 	}
 	USER_MANAGER.AddUser(player)
@@ -94,10 +95,10 @@ func (g *GameManager) OnRegOk(exist bool, req *proto.SetPlayerBornDataReq, userI
 }
 
 func (g *GameManager) OnUserOffline(userId uint32) {
-	logger.LOG.Info("user offline, uid: %v", userId)
+	logger.Info("user offline, uid: %v", userId)
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, userId: %v", userId)
+		logger.Error("player is nil, userId: %v", userId)
 		return
 	}
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
@@ -164,7 +165,7 @@ func (g *GameManager) PacketPlayerStoreNotify(player *model.Player) *proto.Playe
 		}
 		itemData, ok := itemDataMapConfig[int32(weapon.ItemId)]
 		if !ok {
-			logger.LOG.Error("config is nil, itemId: %v", weapon.ItemId)
+			logger.Error("config is nil, itemId: %v", weapon.ItemId)
 			return nil
 		}
 		if itemData.ItemEnumType != constant.ItemTypeConst.ITEM_WEAPON {
@@ -364,7 +365,7 @@ func (g *GameManager) CreatePlayer(userId uint32, nickName string, mainCharAvata
 	// 添加初始武器
 	avatarDataConfig, ok := gdc.CONF.AvatarDataMap[int32(mainCharAvatarId)]
 	if !ok {
-		logger.LOG.Error("config is nil, mainCharAvatarId: %v", mainCharAvatarId)
+		logger.Error("config is nil, mainCharAvatarId: %v", mainCharAvatarId)
 		return nil
 	}
 	weaponId := uint64(g.snowflake.GenId())

gs/game/user_manager.go

@@ -111,7 +111,7 @@ func (u *UserManager) LoadTempOfflineUserSync(userId uint32) *model.Player {
 func (u *UserManager) loadUserFromDb(userId uint32) *model.Player {
 	player, err := u.dao.QueryPlayerByID(userId)
 	if err != nil {
-		logger.LOG.Error("query player error: %v", err)
+		logger.Error("query player error: %v", err)
 		return nil
 	}
 	return player
@@ -150,7 +150,7 @@ func (u *UserManager) OnlineUser(userId uint32, clientSeq uint32) (*model.Player
 			if player != nil {
 				u.ChangeUserDbState(player, model.DbNormal)
 			} else {
-				logger.LOG.Error("can not find user from db, uid: %v", userId)
+				logger.Error("can not find user from db, uid: %v", userId)
 			}
 			LOCAL_EVENT_MANAGER.localEventChan <- &LocalEvent{
 				EventId: LoadLoginUserFromDbFinish,
@@ -178,22 +178,22 @@ func (u *UserManager) ChangeUserDbState(player *model.Player, state int) {
 		} else if state == model.DbNormal {
 			player.DbState = model.DbNormal
 		} else {
-			logger.LOG.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
+			logger.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
 		}
 	case model.DbInsert:
-		logger.LOG.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
+		logger.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
 		break
 	case model.DbDelete:
 		if state == model.DbNormal {
 			player.DbState = model.DbNormal
 		} else {
-			logger.LOG.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
+			logger.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
 		}
 	case model.DbNormal:
 		if state == model.DbDelete {
 			player.DbState = model.DbDelete
 		} else {
-			logger.LOG.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
+			logger.Error("player db state change not allow, before: %v, after: %v", player.DbState, state)
 		}
 	}
 }
@@ -221,13 +221,13 @@ func (u *UserManager) StartAutoSaveUser() {
 func (u *UserManager) SaveUser(saveUserData *SaveUserData) {
 	err := u.dao.InsertPlayerList(saveUserData.insertPlayerList)
 	if err != nil {
-		logger.LOG.Error("insert player list error: %v", err)
+		logger.Error("insert player list error: %v", err)
 		return
 	}
 	err = u.dao.UpdatePlayerList(saveUserData.updatePlayerList)
 	if err != nil {
-		logger.LOG.Error("update player list error: %v", err)
+		logger.Error("update player list error: %v", err)
 		return
 	}
-	logger.LOG.Info("save user finish, insert user count: %v, update user count: %v", len(saveUserData.insertPlayerList), len(saveUserData.updatePlayerList))
+	logger.Info("save user finish, insert user count: %v, update user count: %v", len(saveUserData.insertPlayerList), len(saveUserData.updatePlayerList))
 }

gs/game/user_map.go

@@ -14,7 +14,7 @@ import (
 )
 
 func (g *GameManager) SceneTransToPointReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get scene trans to point, uid: %v", player.PlayerID)
+	logger.Debug("user get scene trans to point, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SceneTransToPointReq)
 
 	transPointId := strconv.Itoa(int(req.SceneId)) + "_" + strconv.Itoa(int(req.PointId))
@@ -43,15 +43,15 @@ func (g *GameManager) SceneTransToPointReq(player *model.Player, payloadMsg pb.M
 }
 
 func (g *GameManager) MarkMapReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user mark map, uid: %v", player.PlayerID)
+	logger.Debug("user mark map, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.MarkMapReq)
 	operation := req.Op
 	if operation == proto.MarkMapReq_OPERATION_ADD {
-		logger.LOG.Debug("user mark type: %v", req.Mark.PointType)
+		logger.Debug("user mark type: %v", req.Mark.PointType)
 		if req.Mark.PointType == proto.MapMarkPointType_MAP_MARK_POINT_TYPE_NPC {
 			posYInt, err := strconv.ParseInt(req.Mark.Name, 10, 64)
 			if err != nil {
-				logger.LOG.Error("parse pos y error: %v", err)
+				logger.Error("parse pos y error: %v", err)
 				posYInt = 300
 			}
 			// 传送玩家
@@ -99,10 +99,10 @@ func (g *GameManager) TeleportPlayer(player *model.Player, sceneId uint32, pos *
 
 	var enterType proto.EnterType
 	if jumpScene {
-		logger.LOG.Debug("player jump scene, scene: %v, pos: %v", player.SceneId, player.Pos)
+		logger.Debug("player jump scene, scene: %v, pos: %v", player.SceneId, player.Pos)
 		enterType = proto.EnterType_ENTER_TYPE_JUMP
 	} else {
-		logger.LOG.Debug("player goto scene, scene: %v, pos: %v", player.SceneId, player.Pos)
+		logger.Debug("player goto scene, scene: %v, pos: %v", player.SceneId, player.Pos)
 		enterType = proto.EnterType_ENTER_TYPE_GOTO
 	}
 	playerEnterSceneNotify := g.PacketPlayerEnterSceneNotifyTp(player, enterType, uint32(constant.EnterReasonConst.TransPoint), oldSceneId, oldPos)
@@ -110,12 +110,12 @@ func (g *GameManager) TeleportPlayer(player *model.Player, sceneId uint32, pos *
 }
 
 func (g *GameManager) PathfindingEnterSceneReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user pathfinding enter scene, uid: %v", player.PlayerID)
+	logger.Debug("user pathfinding enter scene, uid: %v", player.PlayerID)
 	g.SendMsg(cmd.PathfindingEnterSceneRsp, player.PlayerID, player.ClientSeq, new(proto.PathfindingEnterSceneRsp))
 }
 
 func (g *GameManager) QueryPathReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user query path, uid: %v", player.PlayerID)
+	logger.Debug("user query path, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.QueryPathReq)
 
 	queryPathRsp := &proto.QueryPathRsp{
@@ -127,7 +127,7 @@ func (g *GameManager) QueryPathReq(player *model.Player, payloadMsg pb.Message)
 }
 
 func (g *GameManager) GetScenePointReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get scene point, uid: %v", player.PlayerID)
+	logger.Debug("user get scene point, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.GetScenePointReq)
 
 	if req.SceneId != 3 {
@@ -150,7 +150,7 @@ func (g *GameManager) GetScenePointReq(player *model.Player, payloadMsg pb.Messa
 }
 
 func (g *GameManager) GetSceneAreaReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get scene area, uid: %v", player.PlayerID)
+	logger.Debug("user get scene area, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.GetSceneAreaReq)
 
 	if req.SceneId != 3 {

gs/game/user_multiplayer.go

@@ -1,12 +1,12 @@
 package game
 
 import (
-	"hk4e/pkg/object"
 	"time"
 
 	"hk4e/gs/constant"
 	"hk4e/gs/model"
 	"hk4e/pkg/logger"
+	"hk4e/pkg/object"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
 
@@ -14,7 +14,7 @@ import (
 )
 
 func (g *GameManager) PlayerApplyEnterMpReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user apply enter world, uid: %v", player.PlayerID)
+	logger.Debug("user apply enter world, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PlayerApplyEnterMpReq)
 	targetUid := req.TargetUid
 
@@ -36,7 +36,7 @@ func (g *GameManager) PlayerApplyEnterMpReq(player *model.Player, payloadMsg pb.
 }
 
 func (g *GameManager) PlayerApplyEnterMpResultReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user deal world enter apply, uid: %v", player.PlayerID)
+	logger.Debug("user deal world enter apply, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.PlayerApplyEnterMpResultReq)
 	applyUid := req.ApplyUid
 	isAgreed := req.IsAgreed
@@ -51,7 +51,7 @@ func (g *GameManager) PlayerApplyEnterMpResultReq(player *model.Player, payloadM
 }
 
 func (g *GameManager) PlayerGetForceQuitBanInfoReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get world exit ban info, uid: %v", player.PlayerID)
+	logger.Debug("user get world exit ban info, uid: %v", player.PlayerID)
 	ok := true
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	for _, worldPlayer := range world.playerMap {
@@ -68,7 +68,7 @@ func (g *GameManager) PlayerGetForceQuitBanInfoReq(player *model.Player, payload
 }
 
 func (g *GameManager) BackMyWorldReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user back world, uid: %v", player.PlayerID)
+	logger.Debug("user back world, uid: %v", player.PlayerID)
 	// 其他玩家
 	ok := g.UserLeaveWorld(player)
 
@@ -80,7 +80,7 @@ func (g *GameManager) BackMyWorldReq(player *model.Player, payloadMsg pb.Message
 }
 
 func (g *GameManager) ChangeWorldToSingleModeReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change world to single, uid: %v", player.PlayerID)
+	logger.Debug("user change world to single, uid: %v", player.PlayerID)
 	// 房主
 	ok := g.UserLeaveWorld(player)
 
@@ -92,7 +92,7 @@ func (g *GameManager) ChangeWorldToSingleModeReq(player *model.Player, payloadMs
 }
 
 func (g *GameManager) SceneKickPlayerReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user kick player, uid: %v", player.PlayerID)
+	logger.Debug("user kick player, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SceneKickPlayerReq)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	if player.PlayerID != world.owner.PlayerID {
@@ -122,7 +122,7 @@ func (g *GameManager) SceneKickPlayerReq(player *model.Player, payloadMsg pb.Mes
 }
 
 func (g *GameManager) JoinPlayerSceneReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user join player scene, uid: %v", player.PlayerID)
+	logger.Debug("user join player scene, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.JoinPlayerSceneReq)
 	hostPlayer := USER_MANAGER.GetOnlineUser(req.TargetUid)
 	hostWorld := WORLD_MANAGER.GetWorldByID(hostPlayer.WorldId)

gs/game/user_scene.go

@@ -17,7 +17,7 @@ import (
 )
 
 func (g *GameManager) EnterSceneReadyReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user enter scene ready, uid: %v", player.PlayerID)
+	logger.Debug("user enter scene ready, uid: %v", player.PlayerID)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 
 	enterScenePeerNotify := &proto.EnterScenePeerNotify{
@@ -35,7 +35,7 @@ func (g *GameManager) EnterSceneReadyReq(player *model.Player, payloadMsg pb.Mes
 }
 
 func (g *GameManager) SceneInitFinishReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user scene init finish, uid: %v", player.PlayerID)
+	logger.Debug("user scene init finish, uid: %v", player.PlayerID)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	scene := world.GetSceneById(player.SceneId)
 
@@ -220,7 +220,7 @@ func (g *GameManager) SceneInitFinishReq(player *model.Player, payloadMsg pb.Mes
 }
 
 func (g *GameManager) EnterSceneDoneReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user enter scene done, uid: %v", player.PlayerID)
+	logger.Debug("user enter scene done, uid: %v", player.PlayerID)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 
 	if world.multiplayer && world.IsPlayerFirstEnter(player) {
@@ -281,7 +281,7 @@ func (g *GameManager) EnterSceneDoneReq(player *model.Player, payloadMsg pb.Mess
 }
 
 func (g *GameManager) PostEnterSceneReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user post enter scene, uid: %v", player.PlayerID)
+	logger.Debug("user post enter scene, uid: %v", player.PlayerID)
 
 	postEnterSceneRsp := &proto.PostEnterSceneRsp{
 		EnterSceneToken: player.EnterSceneToken,
@@ -290,7 +290,7 @@ func (g *GameManager) PostEnterSceneReq(player *model.Player, payloadMsg pb.Mess
 }
 
 func (g *GameManager) EnterWorldAreaReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user enter world area, uid: %v", player.PlayerID)
+	logger.Debug("user enter world area, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.EnterWorldAreaReq)
 
 	enterWorldAreaRsp := &proto.EnterWorldAreaRsp{
@@ -301,7 +301,7 @@ func (g *GameManager) EnterWorldAreaReq(player *model.Player, payloadMsg pb.Mess
 }
 
 func (g *GameManager) ChangeGameTimeReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change game time, uid: %v", player.PlayerID)
+	logger.Debug("user change game time, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ChangeGameTimeReq)
 	gameTime := req.GameTime
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
@@ -394,7 +394,7 @@ func (g *GameManager) AddSceneEntityNotifyToPlayer(player *model.Player, visionT
 		EntityList: entityList,
 	}
 	g.SendMsg(cmd.SceneEntityAppearNotify, player.PlayerID, player.ClientSeq, sceneEntityAppearNotify)
-	logger.LOG.Debug("SceneEntityAppearNotify, uid: %v, type: %v, len: %v",
+	logger.Debug("SceneEntityAppearNotify, uid: %v, type: %v, len: %v",
 		player.PlayerID, sceneEntityAppearNotify.AppearType, len(sceneEntityAppearNotify.EntityList))
 }
 
@@ -408,7 +408,7 @@ func (g *GameManager) AddSceneEntityNotifyBroadcast(player *model.Player, scene
 			continue
 		}
 		g.SendMsg(cmd.SceneEntityAppearNotify, scenePlayer.PlayerID, scenePlayer.ClientSeq, sceneEntityAppearNotify)
-		logger.LOG.Debug("SceneEntityAppearNotify, uid: %v, type: %v, len: %v",
+		logger.Debug("SceneEntityAppearNotify, uid: %v, type: %v, len: %v",
 			scenePlayer.PlayerID, sceneEntityAppearNotify.AppearType, len(sceneEntityAppearNotify.EntityList))
 	}
 }
@@ -419,7 +419,7 @@ func (g *GameManager) RemoveSceneEntityNotifyToPlayer(player *model.Player, visi
 		DisappearType: visionType,
 	}
 	g.SendMsg(cmd.SceneEntityDisappearNotify, player.PlayerID, player.ClientSeq, sceneEntityDisappearNotify)
-	logger.LOG.Debug("SceneEntityDisappearNotify, uid: %v, type: %v, len: %v",
+	logger.Debug("SceneEntityDisappearNotify, uid: %v, type: %v, len: %v",
 		player.PlayerID, sceneEntityDisappearNotify.DisappearType, len(sceneEntityDisappearNotify.EntityList))
 }
 
@@ -430,7 +430,7 @@ func (g *GameManager) RemoveSceneEntityNotifyBroadcast(scene *Scene, visionType
 	}
 	for _, scenePlayer := range scene.playerMap {
 		g.SendMsg(cmd.SceneEntityDisappearNotify, scenePlayer.PlayerID, scenePlayer.ClientSeq, sceneEntityDisappearNotify)
-		logger.LOG.Debug("SceneEntityDisappearNotify, uid: %v, type: %v, len: %v",
+		logger.Debug("SceneEntityDisappearNotify, uid: %v, type: %v, len: %v",
 			scenePlayer.PlayerID, sceneEntityDisappearNotify.DisappearType, len(sceneEntityDisappearNotify.EntityList))
 	}
 }
@@ -442,7 +442,7 @@ func (g *GameManager) AddSceneEntityNotify(player *model.Player, visionType prot
 	for _, entityId := range entityIdList {
 		entity, ok := scene.entityMap[entityId]
 		if !ok {
-			// logger.LOG.Error("get entity is nil, entityId: %v", entityId)
+			// logger.Error("get entity is nil, entityId: %v", entityId)
 			continue
 		}
 		switch entity.entityType {
@@ -452,7 +452,7 @@ func (g *GameManager) AddSceneEntityNotify(player *model.Player, visionType prot
 			}
 			scenePlayer := USER_MANAGER.GetOnlineUser(entity.avatarEntity.uid)
 			if scenePlayer == nil {
-				logger.LOG.Error("get scene player is nil, world id: %v, scene id: %v", world.id, scene.id)
+				logger.Error("get scene player is nil, world id: %v, scene id: %v", world.id, scene.id)
 				continue
 			}
 			if entity.avatarEntity.avatarId != world.GetPlayerActiveAvatarId(scenePlayer) {
@@ -756,7 +756,7 @@ func (g *GameManager) PacketSceneGadgetInfoVehicle(gadgetVehicleEntity *GadgetVe
 func (g *GameManager) PacketSceneGadgetInfoGather(gadgetGatherEntity *GadgetGatherEntity) *proto.SceneGadgetInfo {
 	gather, ok := gdc.CONF.GatherDataMap[int32(gadgetGatherEntity.gatherId)]
 	if !ok {
-		logger.LOG.Error("gather data error, gatherId: %v", gadgetGatherEntity.gatherId)
+		logger.Error("gather data error, gatherId: %v", gadgetGatherEntity.gatherId)
 		return new(proto.SceneGadgetInfo)
 	}
 	sceneGadgetInfo := &proto.SceneGadgetInfo{

gs/game/user_shop.go

@@ -13,7 +13,7 @@ import (
 )
 
 func (g *GameManager) GetShopmallDataReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get shop mall, uid: %v", player.PlayerID)
+	logger.Debug("user get shop mall, uid: %v", player.PlayerID)
 
 	getShopmallDataRsp := &proto.GetShopmallDataRsp{
 		ShopTypeList: []uint32{900, 1052, 902, 1001, 903},
@@ -22,7 +22,7 @@ func (g *GameManager) GetShopmallDataReq(player *model.Player, payloadMsg pb.Mes
 }
 
 func (g *GameManager) GetShopReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get shop, uid: %v", player.PlayerID)
+	logger.Debug("user get shop, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.GetShopReq)
 	shopType := req.ShopType
 
@@ -70,7 +70,7 @@ func (g *GameManager) GetShopReq(player *model.Player, payloadMsg pb.Message) {
 }
 
 func (g *GameManager) BuyGoodsReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user buy goods, uid: %v", player.PlayerID)
+	logger.Debug("user buy goods, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.BuyGoodsReq)
 	buyItemId := req.Goods.GoodsItem.ItemId
 	buyItemCount := req.BuyCount
@@ -103,7 +103,7 @@ func (g *GameManager) BuyGoodsReq(player *model.Player, payloadMsg pb.Message) {
 }
 
 func (g *GameManager) McoinExchangeHcoinReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user mcoin exchange hcoin, uid: %v", player.PlayerID)
+	logger.Debug("user mcoin exchange hcoin, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.McoinExchangeHcoinReq)
 	if req.Hcoin != req.McoinCost {
 		return

gs/game/user_social.go

@@ -16,7 +16,7 @@ import (
 )
 
 func (g *GameManager) GetPlayerSocialDetailReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get player social detail, uid: %v", player.PlayerID)
+	logger.Debug("user get player social detail, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.GetPlayerSocialDetailReq)
 	targetUid := req.Uid
 
@@ -47,7 +47,7 @@ func (g *GameManager) GetPlayerSocialDetailReq(player *model.Player, payloadMsg
 }
 
 func (g *GameManager) SetPlayerBirthdayReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user set birthday, uid: %v", player.PlayerID)
+	logger.Debug("user set birthday, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SetPlayerBirthdayReq)
 	if player.Birthday[0] != 0 || player.Birthday[1] != 0 {
 		g.CommonRetError(cmd.SetPlayerBirthdayRsp, player, &proto.SetPlayerBirthdayRsp{})
@@ -64,7 +64,7 @@ func (g *GameManager) SetPlayerBirthdayReq(player *model.Player, payloadMsg pb.M
 }
 
 func (g *GameManager) SetNameCardReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change name card, uid: %v", player.PlayerID)
+	logger.Debug("user change name card, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SetNameCardReq)
 	nameCardId := req.NameCardId
 	exist := false
@@ -74,7 +74,7 @@ func (g *GameManager) SetNameCardReq(player *model.Player, payloadMsg pb.Message
 		}
 	}
 	if !exist {
-		logger.LOG.Error("name card not exist, uid: %v", player.PlayerID)
+		logger.Error("name card not exist, uid: %v", player.PlayerID)
 		return
 	}
 	player.NameCard = nameCardId
@@ -86,7 +86,7 @@ func (g *GameManager) SetNameCardReq(player *model.Player, payloadMsg pb.Message
 }
 
 func (g *GameManager) SetPlayerSignatureReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change signature, uid: %v", player.PlayerID)
+	logger.Debug("user change signature, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SetPlayerSignatureReq)
 	signature := req.Signature
 
@@ -103,7 +103,7 @@ func (g *GameManager) SetPlayerSignatureReq(player *model.Player, payloadMsg pb.
 }
 
 func (g *GameManager) SetPlayerNameReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change nickname, uid: %v", player.PlayerID)
+	logger.Debug("user change nickname, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SetPlayerNameReq)
 	nickName := req.NickName
 
@@ -124,12 +124,12 @@ func (g *GameManager) SetPlayerNameReq(player *model.Player, payloadMsg pb.Messa
 }
 
 func (g *GameManager) SetPlayerHeadImageReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change head image, uid: %v", player.PlayerID)
+	logger.Debug("user change head image, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SetPlayerHeadImageReq)
 	avatarId := req.AvatarId
 	_, exist := player.AvatarMap[avatarId]
 	if !exist {
-		logger.LOG.Error("the head img of the avatar not exist, uid: %v", player.PlayerID)
+		logger.Error("the head img of the avatar not exist, uid: %v", player.PlayerID)
 		return
 	}
 	player.HeadImage = avatarId
@@ -141,7 +141,7 @@ func (g *GameManager) SetPlayerHeadImageReq(player *model.Player, payloadMsg pb.
 }
 
 func (g *GameManager) GetAllUnlockNameCardReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get all unlock name card, uid: %v", player.PlayerID)
+	logger.Debug("user get all unlock name card, uid: %v", player.PlayerID)
 
 	getAllUnlockNameCardRsp := &proto.GetAllUnlockNameCardRsp{
 		NameCardList: player.NameCardList,
@@ -150,7 +150,7 @@ func (g *GameManager) GetAllUnlockNameCardReq(player *model.Player, payloadMsg p
 }
 
 func (g *GameManager) GetPlayerFriendListReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get friend list, uid: %v", player.PlayerID)
+	logger.Debug("user get friend list, uid: %v", player.PlayerID)
 	getPlayerFriendListRsp := &proto.GetPlayerFriendListRsp{
 		FriendList: make([]*proto.FriendBrief, 0),
 	}
@@ -169,7 +169,7 @@ func (g *GameManager) GetPlayerFriendListReq(player *model.Player, payloadMsg pb
 		}
 		friendPlayer := USER_MANAGER.LoadTempOfflineUserSync(uid)
 		if friendPlayer == nil {
-			logger.LOG.Error("target player is nil, uid: %v", player.PlayerID)
+			logger.Error("target player is nil, uid: %v", player.PlayerID)
 			continue
 		}
 		friendBrief := &proto.FriendBrief{
@@ -193,7 +193,7 @@ func (g *GameManager) GetPlayerFriendListReq(player *model.Player, payloadMsg pb
 }
 
 func (g *GameManager) GetPlayerAskFriendListReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get friend apply list, uid: %v", player.PlayerID)
+	logger.Debug("user get friend apply list, uid: %v", player.PlayerID)
 
 	getPlayerAskFriendListRsp := &proto.GetPlayerAskFriendListRsp{
 		AskFriendList: make([]*proto.FriendBrief, 0),
@@ -209,7 +209,7 @@ func (g *GameManager) GetPlayerAskFriendListReq(player *model.Player, payloadMsg
 		}
 		friendPlayer := USER_MANAGER.LoadTempOfflineUserSync(uid)
 		if friendPlayer == nil {
-			logger.LOG.Error("target player is nil, uid: %v", player.PlayerID)
+			logger.Error("target player is nil, uid: %v", player.PlayerID)
 			continue
 		}
 		friendBrief := &proto.FriendBrief{
@@ -233,7 +233,7 @@ func (g *GameManager) GetPlayerAskFriendListReq(player *model.Player, payloadMsg
 }
 
 func (g *GameManager) AskAddFriendReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user apply add friend, uid: %v", player.PlayerID)
+	logger.Debug("user apply add friend, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.AskAddFriendReq)
 	targetUid := req.TargetUid
 
@@ -241,13 +241,13 @@ func (g *GameManager) AskAddFriendReq(player *model.Player, payloadMsg pb.Messag
 	targetPlayerOnline := USER_MANAGER.GetUserOnlineState(targetUid)
 	targetPlayer := USER_MANAGER.LoadTempOfflineUserSync(targetUid)
 	if targetPlayer == nil {
-		logger.LOG.Error("apply add friend target player is nil, uid: %v", player.PlayerID)
+		logger.Error("apply add friend target player is nil, uid: %v", player.PlayerID)
 		return
 	}
 	_, applyExist := targetPlayer.FriendApplyList[player.PlayerID]
 	_, friendExist := targetPlayer.FriendList[player.PlayerID]
 	if applyExist || friendExist {
-		logger.LOG.Error("friend or apply already exist, uid: %v", player.PlayerID)
+		logger.Error("friend or apply already exist, uid: %v", player.PlayerID)
 		return
 	}
 	targetPlayer.FriendApplyList[player.PlayerID] = true
@@ -285,14 +285,14 @@ func (g *GameManager) AddFriend(player *model.Player, targetUid uint32) {
 	// TODO 同步阻塞待优化
 	targetPlayer := USER_MANAGER.LoadTempOfflineUserSync(targetUid)
 	if targetPlayer == nil {
-		logger.LOG.Error("agree friend apply target player is nil, uid: %v", player.PlayerID)
+		logger.Error("agree friend apply target player is nil, uid: %v", player.PlayerID)
 		return
 	}
 	targetPlayer.FriendList[player.PlayerID] = true
 }
 
 func (g *GameManager) DealAddFriendReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user deal friend apply, uid: %v", player.PlayerID)
+	logger.Debug("user deal friend apply, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.DealAddFriendReq)
 	targetUid := req.TargetUid
 	result := req.DealAddFriendResult
@@ -310,7 +310,7 @@ func (g *GameManager) DealAddFriendReq(player *model.Player, payloadMsg pb.Messa
 }
 
 func (g *GameManager) GetOnlinePlayerListReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user get online player list, uid: %v", player.PlayerID)
+	logger.Debug("user get online player list, uid: %v", player.PlayerID)
 
 	count := 0
 	onlinePlayerList := make([]*model.Player, 0)

gs/game/user_stamina.go

@@ -1,7 +1,8 @@
 package game
 
 import (
-	pb "google.golang.org/protobuf/proto"
+	"time"
+
 	"hk4e/gdconf"
 	"hk4e/gs/constant"
 	"hk4e/gs/model"
@@ -9,7 +10,8 @@ import (
 	"hk4e/pkg/logger"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
-	"time"
+
+	pb "google.golang.org/protobuf/proto"
 )
 
 // HandleAbilityStamina 处理来自ability的耐力消耗
@@ -20,7 +22,7 @@ func (g *GameManager) HandleAbilityStamina(player *model.Player, entry *proto.Ab
 		costStamina := new(proto.AbilityMixinCostStamina)
 		err := pb.Unmarshal(entry.AbilityData, costStamina)
 		if err != nil {
-			logger.LOG.Error("unmarshal ability data err: %v", err)
+			logger.Error("unmarshal ability data err: %v", err)
 			return
 		}
 		// 处理持续耐力消耗
@@ -37,7 +39,7 @@ func (g *GameManager) HandleAbilityStamina(player *model.Player, entry *proto.Ab
 		abilityNameHashCode := uint32(0)
 		for _, ability := range worldAvatar.abilityList {
 			if ability.InstancedAbilityId == entry.Head.InstancedAbilityId {
-				//logger.LOG.Error("%v", ability)
+				// logger.Error("%v", ability)
 				abilityNameHashCode = ability.AbilityName.GetHash()
 			}
 		}
@@ -84,7 +86,7 @@ func (g *GameManager) SceneAvatarStaminaStepReq(player *model.Player, payloadMsg
 		} else if req.Rot.X > 270 && req.Rot.X < 360 {
 			angleRevise = int32(req.Rot.X - 360.0)
 		} else {
-			logger.LOG.Error("invalid rot x angle: %v, uid: %v", req.Rot.X, player.PlayerID)
+			logger.Error("invalid rot x angle: %v, uid: %v", req.Rot.X, player.PlayerID)
 			g.CommonRetError(cmd.SceneAvatarStaminaStepRsp, player, &proto.SceneAvatarStaminaStepRsp{})
 			return
 		}
@@ -99,7 +101,7 @@ func (g *GameManager) SceneAvatarStaminaStepReq(player *model.Player, payloadMsg
 			// 倒三角 非常消耗体力
 			costRevise = -(angleRevise * 2) + 10
 		}
-		logger.LOG.Debug("stamina climbing, rotX: %v, costRevise: %v, cost: %v", req.Rot.X, costRevise, constant.StaminaCostConst.CLIMBING_BASE-costRevise)
+		logger.Debug("stamina climbing, rotX: %v, costRevise: %v, cost: %v", req.Rot.X, costRevise, constant.StaminaCostConst.CLIMBING_BASE-costRevise)
 		g.UpdatePlayerStamina(player, constant.StaminaCostConst.CLIMBING_BASE-costRevise)
 	case proto.MotionState_MOTION_STATE_SWIM_MOVE:
 		// 缓慢游泳
@@ -120,7 +122,7 @@ func (g *GameManager) ImmediateStamina(player *model.Player, motionState proto.M
 		return
 	}
 	staminaInfo := player.StaminaInfo
-	//logger.LOG.Debug("stamina handle, uid: %v, motionState: %v", player.PlayerID, motionState)
+	// logger.Debug("stamina handle, uid: %v, motionState: %v", player.PlayerID, motionState)
 
 	// 设置用于持续消耗或恢复耐力的值
 	staminaInfo.SetStaminaCost(motionState)
@@ -158,7 +160,7 @@ func (g *GameManager) SkillSustainStamina(player *model.Player, isSwim bool) {
 	// 读取技能配置表
 	avatarSkillConfig, ok := gdconf.CONF.AvatarSkillDataMap[int32(skillId)]
 	if !ok {
-		logger.LOG.Error("avatarSkillConfig error, skillId: %v", skillId)
+		logger.Error("avatarSkillConfig error, skillId: %v", skillId)
 		return
 	}
 	// 获取释放技能者的角色Id
@@ -171,7 +173,7 @@ func (g *GameManager) SkillSustainStamina(player *model.Player, isSwim bool) {
 	// 获取现行角色的配置表
 	avatarDataConfig, ok := gdconf.CONF.AvatarDataMap[int32(worldAvatar.avatarId)]
 	if !ok {
-		logger.LOG.Error("avatarDataConfig error, avatarId: %v", worldAvatar.avatarId)
+		logger.Error("avatarDataConfig error, avatarId: %v", worldAvatar.avatarId)
 		return
 	}
 
@@ -192,7 +194,7 @@ func (g *GameManager) SkillSustainStamina(player *model.Player, isSwim bool) {
 	pastTime := time.Now().UnixMilli() - staminaInfo.LastSkillTime
 	// 根据配置以及距离上次的时间计算消耗的耐力
 	costStamina = int32(float64(pastTime) / 1000 * float64(costStamina))
-	logger.LOG.Debug("stamina skill sustain, skillId: %v, cost: %v, isSwim: %v", skillId, costStamina, isSwim)
+	logger.Debug("stamina skill sustain, skillId: %v, cost: %v, isSwim: %v", skillId, costStamina, isSwim)
 
 	// 根据配置以及距离上次的时间计算消耗的耐力
 	g.UpdatePlayerStamina(player, costStamina)
@@ -206,7 +208,7 @@ func (g *GameManager) ChargedAttackStamina(player *model.Player, worldAvatar *Wo
 	// 获取现行角色的配置表
 	avatarDataConfig, ok := gdconf.CONF.AvatarDataMap[int32(worldAvatar.avatarId)]
 	if !ok {
-		logger.LOG.Error("avatarDataConfig error, avatarId: %v", worldAvatar.avatarId)
+		logger.Error("avatarDataConfig error, avatarId: %v", worldAvatar.avatarId)
 		return
 	}
 
@@ -231,7 +233,7 @@ func (g *GameManager) ChargedAttackStamina(player *model.Player, worldAvatar *Wo
 	} else {
 		costStamina = -(skillData.CostStamina * 100)
 	}
-	logger.LOG.Debug("charged attack stamina, skillId: %v, cost: %v", skillData.AvatarSkillId, costStamina)
+	logger.Debug("charged attack stamina, skillId: %v, cost: %v", skillData.AvatarSkillId, costStamina)
 
 	// 根据配置消耗耐力
 	g.UpdatePlayerStamina(player, costStamina)
@@ -250,13 +252,13 @@ func (g *GameManager) SkillStartStamina(player *model.Player, casterId uint32, s
 		pastTime := time.Now().UnixMilli() - staminaInfo.LastSkillStartTime
 		// 上次触发的技能相同则每400ms触发一次消耗
 		if staminaInfo.LastSkillId != skillId || pastTime > 400 {
-			logger.LOG.Debug("skill start stamina, skillId: %v, cost: %v", skillId, costStamina)
+			logger.Debug("skill start stamina, skillId: %v, cost: %v", skillId, costStamina)
 			// 根据配置消耗耐力
 			g.UpdatePlayerStamina(player, costStamina)
 			staminaInfo.LastSkillStartTime = time.Now().UnixMilli()
 		}
 	} else {
-		//logger.LOG.Debug("skill start cost error, cost: %v", costStamina)
+		// logger.Debug("skill start cost error, cost: %v", costStamina)
 	}
 
 	// 记录最后释放的技能
@@ -338,13 +340,13 @@ func (g *GameManager) UpdateVehicleStamina(player *model.Player, vehicleEntity *
 	if staminaCost > 0 {
 		// 耐力延迟2s(10 ticks)恢复 动作状态为加速将立刻恢复耐力
 		if staminaInfo.VehicleRestoreDelay < 10 && staminaInfo.State != proto.MotionState_MOTION_STATE_SKIFF_POWERED_DASH {
-			//logger.LOG.Debug("stamina delay add, restoreDelay: %v", staminaInfo.RestoreDelay)
+			// logger.Debug("stamina delay add, restoreDelay: %v", staminaInfo.RestoreDelay)
 			staminaInfo.VehicleRestoreDelay++
 			return // 不恢复耐力
 		}
 	} else {
 		// 消耗耐力重新计算恢复需要延迟的tick
-		//logger.LOG.Debug("stamina delay reset, restoreDelay: %v", player.StaminaInfo.VehicleRestoreDelay)
+		// logger.Debug("stamina delay reset, restoreDelay: %v", player.StaminaInfo.VehicleRestoreDelay)
 		staminaInfo.VehicleRestoreDelay = 0
 	}
 
@@ -384,13 +386,13 @@ func (g *GameManager) UpdatePlayerStamina(player *model.Player, staminaCost int3
 	if staminaCost > 0 {
 		// 耐力延迟2s(10 ticks)恢复 动作状态为加速将立刻恢复耐力
 		if staminaInfo.PlayerRestoreDelay < 10 && staminaInfo.State != proto.MotionState_MOTION_STATE_POWERED_FLY {
-			//logger.LOG.Debug("stamina delay add, restoreDelay: %v", staminaInfo.RestoreDelay)
+			// logger.Debug("stamina delay add, restoreDelay: %v", staminaInfo.RestoreDelay)
 			staminaInfo.PlayerRestoreDelay++
 			return // 不恢复耐力
 		}
 	} else {
 		// 消耗耐力重新计算恢复需要延迟的tick
-		//logger.LOG.Debug("stamina delay reset, restoreDelay: %v", player.StaminaInfo.RestoreDelay)
+		// logger.Debug("stamina delay reset, restoreDelay: %v", player.StaminaInfo.RestoreDelay)
 		staminaInfo.PlayerRestoreDelay = 0
 	}
 
@@ -415,7 +417,7 @@ func (g *GameManager) UpdatePlayerStamina(player *model.Player, staminaCost int3
 func (g *GameManager) SetVehicleStamina(player *model.Player, vehicleEntity *Entity, stamina float32) {
 	// 设置载具的耐力
 	vehicleEntity.gadgetEntity.gadgetVehicleEntity.curStamina = stamina
-	//logger.LOG.Debug("vehicle stamina set, stamina: %v", stamina)
+	// logger.Debug("vehicle stamina set, stamina: %v", stamina)
 
 	// PacketVehicleStaminaNotify
 	vehicleStaminaNotify := new(proto.VehicleStaminaNotify)
@@ -429,7 +431,7 @@ func (g *GameManager) SetPlayerStamina(player *model.Player, stamina uint32) {
 	// 设置玩家的耐力
 	prop := constant.PlayerPropertyConst.PROP_CUR_PERSIST_STAMINA
 	player.PropertiesMap[prop] = stamina
-	//logger.LOG.Debug("player stamina set, stamina: %v", stamina)
+	// logger.Debug("player stamina set, stamina: %v", stamina)
 
 	// PacketPlayerPropNotify
 	playerPropNotify := new(proto.PlayerPropNotify)

gs/game/user_team.go

@@ -13,7 +13,7 @@ import (
 )
 
 func (g *GameManager) ChangeAvatarReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change avatar, uid: %v", player.PlayerID)
+	logger.Debug("user change avatar, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ChangeAvatarReq)
 	targetAvatarGuid := req.Guid
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
@@ -21,12 +21,12 @@ func (g *GameManager) ChangeAvatarReq(player *model.Player, payloadMsg pb.Messag
 	targetAvatarId := player.GetAvatarIdByGuid(targetAvatarGuid)
 	oldAvatarId := world.GetPlayerActiveAvatarId(player)
 	if targetAvatarId == oldAvatarId {
-		logger.LOG.Error("can not change to the same avatar, uid: %v, oldAvatarId: %v, targetAvatarId: %v", player.PlayerID, oldAvatarId, targetAvatarId)
+		logger.Error("can not change to the same avatar, uid: %v, oldAvatarId: %v, targetAvatarId: %v", player.PlayerID, oldAvatarId, targetAvatarId)
 		return
 	}
 	newAvatarIndex := world.GetPlayerAvatarIndexByAvatarId(player, targetAvatarId)
 	if newAvatarIndex == -1 {
-		logger.LOG.Error("can not find the target avatar in team, uid: %v, targetAvatarId: %v", player.PlayerID, targetAvatarId)
+		logger.Error("can not find the target avatar in team, uid: %v, targetAvatarId: %v", player.PlayerID, targetAvatarId)
 		return
 	}
 	if !world.multiplayer {
@@ -36,7 +36,7 @@ func (g *GameManager) ChangeAvatarReq(player *model.Player, payloadMsg pb.Messag
 	oldAvatarEntityId := world.GetPlayerWorldAvatarEntityId(player, oldAvatarId)
 	oldAvatarEntity := scene.GetEntity(oldAvatarEntityId)
 	if oldAvatarEntity == nil {
-		logger.LOG.Error("can not find old avatar entity, entity id: %v", oldAvatarEntityId)
+		logger.Error("can not find old avatar entity, entity id: %v", oldAvatarEntityId)
 		return
 	}
 	oldAvatarEntity.moveState = uint16(proto.MotionState_MOTION_STATE_STANDBY)
@@ -67,7 +67,7 @@ func (g *GameManager) ChangeAvatarReq(player *model.Player, payloadMsg pb.Messag
 }
 
 func (g *GameManager) SetUpAvatarTeamReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change team avatar, uid: %v", player.PlayerID)
+	logger.Debug("user change team avatar, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.SetUpAvatarTeamReq)
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
 	if world.multiplayer {
@@ -135,7 +135,7 @@ func (g *GameManager) SetUpAvatarTeamReq(player *model.Player, payloadMsg pb.Mes
 }
 
 func (g *GameManager) ChooseCurAvatarTeamReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user switch team, uid: %v", player.PlayerID)
+	logger.Debug("user switch team, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ChooseCurAvatarTeamReq)
 	teamId := req.TeamId
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)
@@ -165,7 +165,7 @@ func (g *GameManager) ChooseCurAvatarTeamReq(player *model.Player, payloadMsg pb
 }
 
 func (g *GameManager) ChangeMpTeamAvatarReq(player *model.Player, payloadMsg pb.Message) {
-	logger.LOG.Debug("user change mp team avatar, uid: %v", player.PlayerID)
+	logger.Debug("user change mp team avatar, uid: %v", player.PlayerID)
 	req := payloadMsg.(*proto.ChangeMpTeamAvatarReq)
 	avatarGuidList := req.AvatarGuidList
 	world := WORLD_MANAGER.GetWorldByID(player.WorldId)

gs/game/user_vehicle.go

@@ -1,12 +1,14 @@
 package game
 
 import (
-	pb "google.golang.org/protobuf/proto"
+	"time"
+
 	"hk4e/gs/model"
 	"hk4e/pkg/logger"
 	"hk4e/protocol/cmd"
 	"hk4e/protocol/proto"
-	"time"
+
+	pb "google.golang.org/protobuf/proto"
 )
 
 // CreateVehicleReq 创建载具
@@ -37,7 +39,7 @@ func (g *GameManager) CreateVehicleReq(player *model.Player, payloadMsg pb.Messa
 	rot := &model.Vector{X: float64(req.Rot.X), Y: float64(req.Rot.Y), Z: float64(req.Rot.Z)}
 	entityId := scene.CreateEntityGadgetVehicle(player.PlayerID, pos, rot, req.VehicleId)
 	if entityId == 0 {
-		logger.LOG.Error("vehicle entityId is 0, uid: %v", player.PlayerID)
+		logger.Error("vehicle entityId is 0, uid: %v", player.PlayerID)
 		g.CommonRetError(cmd.VehicleInteractRsp, player, &proto.VehicleInteractRsp{})
 		return
 	}
@@ -147,7 +149,7 @@ func (g *GameManager) EnterVehicle(player *model.Player, entity *Entity, avatarG
 func (g *GameManager) ExitVehicle(player *model.Player, entity *Entity, avatarGuid uint64) {
 	// 玩家是否进入载具
 	if !g.IsPlayerInVehicle(player, entity.gadgetEntity.gadgetVehicleEntity) {
-		logger.LOG.Error("vehicle not has player, uid: %v", player.PlayerID)
+		logger.Error("vehicle not has player, uid: %v", player.PlayerID)
 		g.CommonRetError(cmd.VehicleInteractRsp, player, &proto.VehicleInteractRsp{}, proto.Retcode_RET_NOT_IN_VEHICLE)
 		return
 	}
@@ -185,13 +187,13 @@ func (g *GameManager) VehicleInteractReq(player *model.Player, payloadMsg pb.Mes
 	// 获取载具实体
 	entity := g.GetSceneVehicleEntity(scene, req.EntityId)
 	if entity == nil {
-		logger.LOG.Error("vehicle entity is nil, entityId: %v", req.EntityId)
+		logger.Error("vehicle entity is nil, entityId: %v", req.EntityId)
 		g.CommonRetError(cmd.VehicleInteractRsp, player, &proto.VehicleInteractRsp{}, proto.Retcode_RET_ENTITY_NOT_EXIST)
 		return
 	}
 	// 判断实体类型是否为载具
 	if entity.entityType != uint32(proto.ProtEntityType_PROT_ENTITY_TYPE_GADGET) || entity.gadgetEntity.gadgetType != GADGET_TYPE_VEHICLE {
-		logger.LOG.Error("vehicle entity error, entityType: %v", entity.entityType)
+		logger.Error("vehicle entity error, entityType: %v", entity.entityType)
 		g.CommonRetError(cmd.VehicleInteractRsp, player, &proto.VehicleInteractRsp{}, proto.Retcode_RET_GADGET_NOT_VEHICLE)
 		return
 	}

gs/game/user_weapon.go

@@ -40,14 +40,14 @@ func (g *GameManager) GetAllWeaponDataConfig() map[int32]*gdc.ItemData {
 func (g *GameManager) AddUserWeapon(userId uint32, itemId uint32) uint64 {
 	player := USER_MANAGER.GetOnlineUser(userId)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", userId)
+		logger.Error("player is nil, uid: %v", userId)
 		return 0
 	}
 	weaponId := uint64(g.snowflake.GenId())
 	player.AddWeapon(itemId, weaponId)
 	weapon := player.GetWeapon(weaponId)
 	if weapon == nil {
-		logger.LOG.Error("weapon is nil, itemId: %v, weaponId: %v", itemId, weaponId)
+		logger.Error("weapon is nil, itemId: %v, weaponId: %v", itemId, weaponId)
 		return 0
 	}
 

gs/game/world_manager.go

@@ -1,7 +1,6 @@
 package game
 
 import (
-	"hk4e/pkg/logger"
 	"math"
 	"time"
 
@@ -9,6 +8,7 @@ import (
 	"hk4e/gs/game/aoi"
 	"hk4e/gs/model"
 	"hk4e/pkg/alg"
+	"hk4e/pkg/logger"
 	"hk4e/protocol/proto"
 )
 
@@ -728,7 +728,7 @@ func (s *Scene) CreateEntityGadget(pos *model.Vector, gatherId uint32) uint32 {
 func (s *Scene) CreateEntityGadgetVehicle(uid uint32, pos, rot *model.Vector, vehicleId uint32) uint32 {
 	player := USER_MANAGER.GetOnlineUser(uid)
 	if player == nil {
-		logger.LOG.Error("player is nil, uid: %v", uid)
+		logger.Error("player is nil, uid: %v", uid)
 		return 0
 	}
 	entityId := s.world.GetNextWorldEntityId(constant.EntityIdTypeConst.GADGET)

gs/game/world_static.go

@@ -59,7 +59,7 @@ func (w *WorldStatic) InitTerrain() bool {
 	decoder := gob.NewDecoder(bytes.NewReader(data))
 	err := decoder.Decode(&w.terrain)
 	if err != nil {
-		logger.LOG.Error("unmarshal world terrain data error: %v", err)
+		logger.Error("unmarshal world terrain data error: %v", err)
 		return false
 	}
 	return true
@@ -70,7 +70,7 @@ func (w *WorldStatic) SaveTerrain() bool {
 	encoder := gob.NewEncoder(&buffer)
 	err := encoder.Encode(w.terrain)
 	if err != nil {
-		logger.LOG.Error("marshal world terrain data error: %v", err)
+		logger.Error("marshal world terrain data error: %v", err)
 		return false
 	}
 	gdc.CONF.WriteWorldTerrain(buffer.Bytes())
@@ -140,10 +140,10 @@ func (w *WorldStatic) Pathfinding() {
 	)
 	pathVectorList := bfs.Pathfinding()
 	if pathVectorList == nil {
-		logger.LOG.Error("could not find path")
+		logger.Error("could not find path")
 		return
 	}
-	logger.LOG.Debug("find path success, path: %v", pathVectorList)
+	logger.Debug("find path success, path: %v", pathVectorList)
 	w.pathVectorList = w.ConvPFPVLToWSPVL(pathVectorList)
 }
 

gs/model/avatar.go

@@ -49,7 +49,7 @@ func (p *Player) InitAllAvatar() {
 func (p *Player) InitAvatar(avatar *Avatar) {
 	avatarDataConfig, ok := gdc.CONF.AvatarDataMap[int32(avatar.AvatarId)]
 	if !ok {
-		logger.LOG.Error("avatarDataConfig error, avatarId: %v", avatar.AvatarId)
+		logger.Error("avatarDataConfig error, avatarId: %v", avatar.AvatarId)
 		return
 	}
 	// 角色战斗属性
@@ -91,7 +91,7 @@ func (p *Player) GetAvatarIdByGuid(guid uint64) uint32 {
 func (p *Player) AddAvatar(avatarId uint32) {
 	avatarDataConfig, ok := gdc.CONF.AvatarDataMap[int32(avatarId)]
 	if !ok {
-		logger.LOG.Error("avatarDataConfig error, avatarId: %v", avatarId)
+		logger.Error("avatarDataConfig error, avatarId: %v", avatarId)
 		return
 	}
 	skillDepotId := int32(0)
@@ -105,7 +105,7 @@ func (p *Player) AddAvatar(avatarId uint32) {
 	}
 	avatarSkillDepotDataConfig, ok := gdc.CONF.AvatarSkillDepotDataMap[skillDepotId]
 	if !ok {
-		logger.LOG.Error("avatarSkillDepotDataConfig error, skillDepotId: %v", skillDepotId)
+		logger.Error("avatarSkillDepotDataConfig error, skillDepotId: %v", skillDepotId)
 		return
 	}
 	avatar := &Avatar{

gs/model/invoke_handler.go

@@ -43,9 +43,9 @@ func (i *InvokeHandler[T]) AddEntry(forward proto.ForwardType, entry *T) {
 		i.EntryListForwardHost = append(i.EntryListForwardHost, entry)
 	case proto.ForwardType_FORWARD_TYPE_ONLY_SERVER:
 		i.EntryListForwardServer = append(i.EntryListForwardServer, entry)
-		//logger.LOG.Error("forward server entry: %v", entry)
+		// logger.Error("forward server entry: %v", entry)
 	default:
-		logger.LOG.Error("forward type: %v, entry: %v", forward, entry)
+		logger.Error("forward type: %v, entry: %v", forward, entry)
 	}
 }
 

gs/model/player.go

@@ -1,8 +1,9 @@
 package model
 
 import (
-	"go.mongodb.org/mongo-driver/bson/primitive"
 	"hk4e/protocol/proto"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
 const (

gs/model/weapon.go

@@ -66,7 +66,7 @@ func (p *Player) AddWeapon(itemId uint32, weaponId uint64) {
 	}
 	itemDataConfig, ok := gdc.CONF.ItemDataMap[int32(itemId)]
 	if !ok {
-		logger.LOG.Error("config is nil, itemId: %v", itemId)
+		logger.Error("config is nil, itemId: %v", itemId)
 		return
 	}
 	if itemDataConfig.SkillAffix != nil {

gs/mq/mq.go

@@ -23,7 +23,7 @@ func NewMessageQueue(conn *nats.Conn, netMsgInput chan *cmd.NetMsg, netMsgOutput
 	r.natsMsgChan = make(chan *nats.Msg, 10000)
 	_, err := r.natsConn.ChanSubscribe("GS_CMD_HK4E", r.natsMsgChan)
 	if err != nil {
-		logger.LOG.Error("nats subscribe error: %v", err)
+		logger.Error("nats subscribe error: %v", err)
 		return nil
 	}
 	r.netMsgInput = netMsgInput
@@ -48,7 +48,7 @@ func (m *MessageQueue) startRecvHandler() {
 		netMsg := new(cmd.NetMsg)
 		err := msgpack.Unmarshal(natsMsg.Data, netMsg)
 		if err != nil {
-			logger.LOG.Error("parse bin to net msg error: %v", err)
+			logger.Error("parse bin to net msg error: %v", err)
 			continue
 		}
 		if netMsg.EventId == cmd.NormalMsg || netMsg.EventId == cmd.UserRegNotify {
@@ -56,7 +56,7 @@ func (m *MessageQueue) startRecvHandler() {
 			payloadMessage := m.cmdProtoMap.GetProtoObjByCmdId(netMsg.CmdId)
 			err = pb.Unmarshal(netMsg.PayloadMessageData, payloadMessage)
 			if err != nil {
-				logger.LOG.Error("parse bin to payload msg error: %v", err)
+				logger.Error("parse bin to payload msg error: %v", err)
 				continue
 			}
 			netMsg.PayloadMessage = payloadMessage
@@ -72,14 +72,14 @@ func (m *MessageQueue) startSendHandler() {
 		// msgpack NetMsg
 		netMsgData, err := msgpack.Marshal(netMsg)
 		if err != nil {
-			logger.LOG.Error("parse net msg to bin error: %v", err)
+			logger.Error("parse net msg to bin error: %v", err)
 			continue
 		}
 		natsMsg := nats.NewMsg("GATE_CMD_HK4E")
 		natsMsg.Data = netMsgData
 		err = m.natsConn.PublishMsg(natsMsg)
 		if err != nil {
-			logger.LOG.Error("nats publish msg error: %v", err)
+			logger.Error("nats publish msg error: %v", err)
 			continue
 		}
 	}

pkg/email/email_test.go

@@ -1,13 +1,10 @@
 package email
 
 import (
-	"fmt"
-	"strings"
-	"testing"
-
 	"bufio"
 	"bytes"
 	"crypto/rand"
+	"fmt"
 	"io"
 	"mime"
 	"mime/multipart"
@@ -15,6 +12,8 @@ import (
 	"net/mail"
 	"net/smtp"
 	"net/textproto"
+	"strings"
+	"testing"
 )
 
 func prepareEmail() *Email {

pkg/logger/logger.go

@@ -3,7 +3,6 @@ package logger
 import (
 	"bytes"
 	"fmt"
-	"hk4e/common/config"
 	"log"
 	"os"
 	"path"
@@ -11,13 +10,15 @@ import (
 	"strconv"
 	"strings"
 	"time"
+
+	"hk4e/common/config"
 )
 
 const (
 	DEBUG = iota
 	INFO
+	WARN
 	ERROR
-	UNKNOWN
 )
 
 const (
@@ -66,8 +67,8 @@ func InitLogger(appName string) {
 	log.SetFlags(0)
 	LOG = new(Logger)
 	LOG.AppName = appName
-	LOG.Level = getLevelInt(config.CONF.Logger.Level)
+	LOG.Level = LOG.getLevelInt(config.CONF.Logger.Level)
-	LOG.Mode = getModeInt(config.CONF.Logger.Mode)
+	LOG.Mode = LOG.getModeInt(config.CONF.Logger.Mode)
 	LOG.Track = config.CONF.Logger.Track
 	LOG.MaxSize = config.CONF.Logger.MaxSize
 	LOG.LogInfoChan = make(chan *LogInfo, 1000)
@@ -85,6 +86,8 @@ func (l *Logger) doLog() {
 			logHeader += BLUE + "[" + l.getLevelStr(logInfo.Level) + "]" + RESET + " "
 		} else if logInfo.Level == INFO {
 			logHeader += GREEN + "[" + l.getLevelStr(logInfo.Level) + "]" + RESET + " "
+		} else if logInfo.Level == WARN {
+			logHeader += YELLOW + "[" + l.getLevelStr(logInfo.Level) + "]" + RESET + " "
 		} else if logInfo.Level == ERROR {
 			logHeader += RED + "[" + l.getLevelStr(logInfo.Level) + "]" + RESET + " "
 		}
@@ -107,15 +110,15 @@ func (l *Logger) doLog() {
 		if l.Mode == CONSOLE {
 			log.Print(logStr)
 		} else if l.Mode == FILE {
-			l.WriteLogFile(logStr)
+			l.writeLogFile(logStr)
 		} else if l.Mode == BOTH {
 			log.Print(logStr)
-			l.WriteLogFile(logStr)
+			l.writeLogFile(logStr)
 		}
 	}
 }
 
-func (l *Logger) WriteLogFile(logStr string) {
+func (l *Logger) writeLogFile(logStr string) {
 	for _, v := range ALL_COLOR {
 		logStr = strings.ReplaceAll(logStr, v, "")
 	}
@@ -159,77 +162,94 @@ func (l *Logger) WriteLogFile(logStr string) {
 	}
 }
 
-func (l *Logger) Debug(msg string, param ...any) {
+func Debug(msg string, param ...any) {
-	if l.Level > DEBUG {
+	if LOG.Level > DEBUG {
 		return
 	}
 	logInfo := new(LogInfo)
 	logInfo.Level = DEBUG
 	logInfo.Msg = msg
 	logInfo.Param = param
-	if l.Track {
+	if LOG.Track {
-		logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
+		logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
-		logInfo.GoroutineId = l.getGoroutineId()
+		logInfo.GoroutineId = LOG.getGoroutineId()
 	}
-	l.LogInfoChan <- logInfo
+	LOG.LogInfoChan <- logInfo
 }
 
-func (l *Logger) Info(msg string, param ...any) {
+func Info(msg string, param ...any) {
-	if l.Level > INFO {
+	if LOG.Level > INFO {
 		return
 	}
 	logInfo := new(LogInfo)
 	logInfo.Level = INFO
 	logInfo.Msg = msg
 	logInfo.Param = param
-	if l.Track {
+	if LOG.Track {
-		logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
+		logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
-		logInfo.GoroutineId = l.getGoroutineId()
+		logInfo.GoroutineId = LOG.getGoroutineId()
 	}
-	l.LogInfoChan <- logInfo
+	LOG.LogInfoChan <- logInfo
 }
 
-func (l *Logger) Error(msg string, param ...any) {
+func Warn(msg string, param ...any) {
-	if l.Level > ERROR {
+	if LOG.Level > WARN {
+		return
+	}
+	logInfo := new(LogInfo)
+	logInfo.Level = WARN
+	logInfo.Msg = msg
+	logInfo.Param = param
+	if LOG.Track {
+		logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
+		logInfo.GoroutineId = LOG.getGoroutineId()
+	}
+	LOG.LogInfoChan <- logInfo
+}
+
+func Error(msg string, param ...any) {
+	if LOG.Level > ERROR {
 		return
 	}
 	logInfo := new(LogInfo)
 	logInfo.Level = ERROR
 	logInfo.Msg = msg
 	logInfo.Param = param
-	if l.Track {
+	if LOG.Track {
-		logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
+		logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
-		logInfo.GoroutineId = l.getGoroutineId()
+		logInfo.GoroutineId = LOG.getGoroutineId()
 	}
-	l.LogInfoChan <- logInfo
+	LOG.LogInfoChan <- logInfo
 }
 
-func (l *Logger) ErrorStack(msg string, param ...any) {
+func ErrorStack(msg string, param ...any) {
-	if l.Level > ERROR {
+	if LOG.Level > ERROR {
 		return
 	}
 	logInfo := new(LogInfo)
 	logInfo.Level = ERROR
 	logInfo.Msg = msg
 	logInfo.Param = param
-	if l.Track {
+	if LOG.Track {
-		logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
+		logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
-		logInfo.GoroutineId = l.getGoroutineId()
+		logInfo.GoroutineId = LOG.getGoroutineId()
-		logInfo.Stack = l.Stack()
+		logInfo.Stack = Stack()
 	}
-	l.LogInfoChan <- logInfo
+	LOG.LogInfoChan <- logInfo
 }
 
-func getLevelInt(level string) (ret int) {
+func (l *Logger) getLevelInt(level string) (ret int) {
 	switch level {
 	case "DEBUG":
 		ret = DEBUG
 	case "INFO":
 		ret = INFO
+	case "WARN":
+		ret = WARN
 	case "ERROR":
 		ret = ERROR
 	default:
-		ret = UNKNOWN
+		ret = DEBUG
 	}
 	return ret
 }
@@ -240,13 +260,17 @@ func (l *Logger) getLevelStr(level int) (ret string) {
 		ret = "DEBUG"
 	case INFO:
 		ret = "INFO"
+	case WARN:
+		ret = "WARN"
 	case ERROR:
 		ret = "ERROR"
+	default:
+		ret = "DEBUG"
 	}
 	return ret
 }
 
-func getModeInt(mode string) (ret int) {
+func (l *Logger) getModeInt(mode string) (ret int) {
 	switch mode {
 	case "CONSOLE":
 		ret = CONSOLE
@@ -254,8 +278,10 @@ func getModeInt(mode string) (ret int) {
 		ret = FILE
 	case "BOTH":
 		ret = BOTH
-	default:
+	case "NEITHER":
 		ret = NEITHER
+	default:
+		ret = CONSOLE
 	}
 	return ret
 }
@@ -286,7 +312,7 @@ func (l *Logger) getLineFunc() (fileName string, line int, funcName string) {
 	return fileName, line, funcName
 }
 
-func (l *Logger) Stack() string {
+func Stack() string {
 	buf := make([]byte, 1024)
 	for {
 		n := runtime.Stack(buf, false)
@@ -297,7 +323,7 @@ func (l *Logger) Stack() string {
 	}
 }
 
-func (l *Logger) StackAll() string {
+func StackAll() string {
 	buf := make([]byte, 1024*16)
 	for {
 		n := runtime.Stack(buf, true)

pkg/object/object.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/gob"
 	"fmt"
+
 	"github.com/vmihailenco/msgpack/v5"
 )
 

pkg/statsviz_serve/statsviz_serve.go

@@ -12,12 +12,12 @@ func Serve(addr string) error {
 	// 性能检测
 	err := statsviz.RegisterDefault()
 	if err != nil {
-		logger.LOG.Error("statsviz init error: %v", err)
+		logger.Error("statsviz init error: %v", err)
 		return err
 	}
 	err = http.ListenAndServe(addr, nil)
 	if err != nil {
-		logger.LOG.Error("perf debug http start error: %v", err)
+		logger.Error("perf debug http start error: %v", err)
 		return err
 	}
 	return nil

protocol/cmd/cmd_id_proto_obj_map.go

@@ -259,7 +259,7 @@ func (c *CmdProtoMap) registerAllMessage() {
 func (c *CmdProtoMap) registerMessage(cmdId uint16, protoObj pb.Message) {
 	_, exist := c.cmdDeDupMap[cmdId]
 	if exist {
-		logger.LOG.Error("reg dup msg, cmd id: %v", cmdId)
+		logger.Error("reg dup msg, cmd id: %v", cmdId)
 		return
 	} else {
 		c.cmdDeDupMap[cmdId] = true
@@ -273,7 +273,7 @@ func (c *CmdProtoMap) registerMessage(cmdId uint16, protoObj pb.Message) {
 func (c *CmdProtoMap) GetProtoObjByCmdId(cmdId uint16) (protoObj pb.Message) {
 	protoObjTypePointer, ok := c.cmdIdProtoObjMap[cmdId]
 	if !ok {
-		logger.LOG.Error("unknown cmd id: %v", cmdId)
+		logger.Error("unknown cmd id: %v", cmdId)
 		protoObj = nil
 		return protoObj
 	}
@@ -286,7 +286,7 @@ func (c *CmdProtoMap) GetCmdIdByProtoObj(protoObj pb.Message) (cmdId uint16) {
 	var ok = false
 	cmdId, ok = c.protoObjCmdIdMap[reflect.TypeOf(protoObj)]
 	if !ok {
-		logger.LOG.Error("unknown proto object: %v", protoObj)
+		logger.Error("unknown proto object: %v", protoObj)
 		cmdId = 0
 	}
 	return cmdId