mirrors2/hk4e
1
0
Fork 0
mirror of https://github.com/FlourishingWorld/hk4e.git synced 2026-02-04 12:52:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

格式化代码

Browse Source
This commit is contained in:
huangxiaolei
2022-12-19 13:40:04 +08:00
parent f773ba8df7
commit 58b2df2bc6
92 changed files with 682 additions and 626 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/dispatch/main.go
View File

@@ -16,7 +16,7 @@ var (
func main() {
flag.Parse()
//go statsviz_serve.Serve("0.0.0.0:2345")
// go statsviz_serve.Serve("0.0.0.0:2345")
err := app.Run(context.TODO(), *config)
if err != nil {
fmt.Println(err)

8
common/region/region.go
View File

@@ -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

6
common/region/region_test.go
View File

@@ -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) {

6
dispatch/app/app.go
View File

@@ -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

10
dispatch/controller/controller.go
View File

@@ -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)
}
}

30
dispatch/controller/dispatch_controller.go
View File

@@ -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{

8
dispatch/controller/fixed_controller.go
View File

@@ -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)

8
dispatch/controller/gate_controller.go
View File

@@ -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

30
dispatch/controller/login_controller.go
View File

@@ -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.LOG.Debug("password rsa dec fail, fallback to @@ mode")
logger.Debug("rsa dec error: %v", err)
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()

4
dispatch/dao/account_dao.go
View File

@@ -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

4
dispatch/dao/dao.go
View File

@@ -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)
}
}

20
dispatch/service/service.go
View File

@@ -23,15 +23,15 @@ func (f *Service) UserPasswordChange(uid uint32) bool {
if account == nil {
return false
}
//convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
//if !exist {
// convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
// if !exist {
// return true
//}
//f.kcpEventInput <- &net.KcpEvent{
// }
// f.kcpEventInput <- &net.KcpEvent{
// ConvId: convId,
// EventId: net.KcpConnForceClose,
// EventMessage: uint32(kcp.EnetAccountPasswordChange),
//}
// }
return true
}
@@ -57,15 +57,15 @@ func (f *Service) ForbidUser(info *ForbidUserInfo) bool {
if account == nil {
return false
}
//convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
//if !exist {
// convId, exist := f.getConvIdByUserId(uint32(account.PlayerID))
// if !exist {
// return true
//}
//f.kcpEventInput <- &net.KcpEvent{
// }
// f.kcpEventInput <- &net.KcpEvent{
// ConvId: convId,
// EventId: net.KcpConnForceClose,
// EventMessage: uint32(kcp.EnetServerKillClient),
//}
// }
return true
}

6
gate/app/app.go
View File

@@ -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:

1
gate/kcp/crypt.go
View File

@@ -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"

2
gate/kcp/entropy.go
View File

@@ -36,7 +36,7 @@ type nonceAES128 struct {
}
func (n *nonceAES128) Init() {
var key [16]byte //aes-128
var key [16]byte // aes-128
io.ReadFull(rand.Reader, key[:])
io.ReadFull(rand.Reader, n.seed[:])
block, _ := aes.NewCipher(key[:])

2
gate/kcp/fec.go
View File

@@ -112,7 +112,7 @@ func (dec *fecDecoder) decode(in fecPacket) (recovered [][]byte) {
dec.codec = codec
dec.decodeCache = make([][]byte, dec.shardSize)
dec.flagCache = make([]bool, dec.shardSize)
//log.Println("autotune to :", dec.dataShards, dec.parityShards)
// log.Println("autotune to :", dec.dataShards, dec.parityShards)
}
}
}

5
gate/kcp/readloop.go
View File

@@ -3,6 +3,7 @@ package kcp
import (
"bytes"
"encoding/binary"
"github.com/pkg/errors"
)
@@ -17,8 +18,8 @@ func (s *UDPSession) defaultReadLoop() {
if src == "" { // set source address
src = addr.String()
} else if addr.String() != src {
//atomic.AddUint64(&DefaultSnmp.InErrs, 1)
//continue
// atomic.AddUint64(&DefaultSnmp.InErrs, 1)
// continue
s.remote = addr
src = addr.String()
}

9
gate/kcp/readloop_linux.go
View File

@@ -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
@@ -37,8 +38,8 @@ func (s *UDPSession) readLoop() {
if src == "" { // set source address if nil
src = msg.Addr.String()
} else if msg.Addr.String() != src {
//atomic.AddUint64(&DefaultSnmp.InErrs, 1)
//continue
// atomic.AddUint64(&DefaultSnmp.InErrs, 1)
// continue
s.remote = msg.Addr
src = msg.Addr.String()
}

4
gate/kcp/sess.go
View File

@@ -291,7 +291,7 @@ func (s *UDPSession) WriteBuffers(v [][]byte) (n int, err error) {
for _, b := range v {
n += len(b)
// 原神KCP是消息模式 上层不要对消息进行分割 并且保证消息长度小于256*mss
//for {
// for {
// if len(b) <= int(s.kcp.mss) {
// s.kcp.Send(b)
// break
@@ -299,7 +299,7 @@ func (s *UDPSession) WriteBuffers(v [][]byte) (n int, err error) {
// s.kcp.Send(b[:s.kcp.mss])
// b = b[s.kcp.mss:]
// }
//}
// }
s.kcp.Send(b)
}

40
gate/kcp/sess_test.go
View File

@@ -29,10 +29,10 @@ func init() {
}
func dialEcho(port int) (*UDPSession, error) {
//block, _ := NewNoneBlockCrypt(pass)
//block, _ := NewSimpleXORBlockCrypt(pass)
//block, _ := NewTEABlockCrypt(pass[:16])
//block, _ := NewAESBlockCrypt(pass)
// block, _ := NewNoneBlockCrypt(pass)
// block, _ := NewSimpleXORBlockCrypt(pass)
// block, _ := NewTEABlockCrypt(pass[:16])
// block, _ := NewAESBlockCrypt(pass)
block, _ := NewSalsa20BlockCrypt(pass)
sess, err := DialWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 3)
if err != nil {
@@ -75,10 +75,10 @@ func dialSink(port int) (*UDPSession, error) {
}
func dialTinyBufferEcho(port int) (*UDPSession, error) {
//block, _ := NewNoneBlockCrypt(pass)
//block, _ := NewSimpleXORBlockCrypt(pass)
//block, _ := NewTEABlockCrypt(pass[:16])
//block, _ := NewAESBlockCrypt(pass)
// block, _ := NewNoneBlockCrypt(pass)
// block, _ := NewSimpleXORBlockCrypt(pass)
// block, _ := NewTEABlockCrypt(pass[:16])
// block, _ := NewAESBlockCrypt(pass)
block, _ := NewSalsa20BlockCrypt(pass)
sess, err := DialWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 3)
if err != nil {
@@ -89,18 +89,18 @@ func dialTinyBufferEcho(port int) (*UDPSession, error) {
// ////////////////////////
func listenEcho(port int) (net.Listener, error) {
//block, _ := NewNoneBlockCrypt(pass)
//block, _ := NewSimpleXORBlockCrypt(pass)
//block, _ := NewTEABlockCrypt(pass[:16])
//block, _ := NewAESBlockCrypt(pass)
// block, _ := NewNoneBlockCrypt(pass)
// block, _ := NewSimpleXORBlockCrypt(pass)
// block, _ := NewTEABlockCrypt(pass[:16])
// block, _ := NewAESBlockCrypt(pass)
block, _ := NewSalsa20BlockCrypt(pass)
return ListenWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 0)
}
func listenTinyBufferEcho(port int) (net.Listener, error) {
//block, _ := NewNoneBlockCrypt(pass)
//block, _ := NewSimpleXORBlockCrypt(pass)
//block, _ := NewTEABlockCrypt(pass[:16])
//block, _ := NewAESBlockCrypt(pass)
// block, _ := NewNoneBlockCrypt(pass)
// block, _ := NewSimpleXORBlockCrypt(pass)
// block, _ := NewTEABlockCrypt(pass[:16])
// block, _ := NewAESBlockCrypt(pass)
block, _ := NewSalsa20BlockCrypt(pass)
return ListenWithOptions(fmt.Sprintf("127.0.0.1:%v", port), block, 10, 3)
}
@@ -178,7 +178,7 @@ func tinyBufferEchoServer(port int) net.Listener {
return l
}
///////////////////////////
// /////////////////////////
func handleEcho(conn *UDPSession) {
conn.SetStreamMode(true)
@@ -229,7 +229,7 @@ func handleTinyBufferEcho(conn *UDPSession) {
}
}
///////////////////////////
// /////////////////////////
func TestTimeout(t *testing.T) {
port := int(atomic.AddUint32(&baseport, 1))
@@ -242,7 +242,7 @@ func TestTimeout(t *testing.T) {
}
buf := make([]byte, 10)
//timeout
// timeout
cli.SetDeadline(time.Now().Add(time.Second))
<-time.After(2 * time.Second)
n, err := cli.Read(buf)
@@ -554,7 +554,7 @@ func TestListenerClose(t *testing.T) {
}
l.Close()
//fakeaddr, _ := net.ResolveUDPAddr("udp6", "127.0.0.1:1111")
// fakeaddr, _ := net.ResolveUDPAddr("udp6", "127.0.0.1:1111")
fakeConvId := uint64(0)
if l.closeSession(fakeConvId) {
t.Fail()

2
gate/kcp/tx_linux.go
View File

@@ -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) {

14
gate/mq/mq.go
View File

@@ -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
}
}

53
gate/net/forward.go
View File

@@ -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
// 返回响应

50
gate/net/kcp_connect_manager.go
View File

@@ -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
}

28
gate/net/kcp_endecode.go
View File

@@ -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
}
// 判断是否有不止一个包
@@ -108,10 +108,10 @@ func (k *KcpConnectManager) decodeLoop(data []byte, convId uint64, kcpMsgList *[
kcpMsg := new(KcpMsg)
kcpMsg.ConvId = convId
kcpMsg.CmdId = uint16(cmdId)
//kcpMsg.HeadData = make([]byte, len(headData))
//copy(kcpMsg.HeadData, headData)
//kcpMsg.ProtoData = make([]byte, len(protoData))
//copy(kcpMsg.ProtoData, protoData)
// kcpMsg.HeadData = make([]byte, len(headData))
// copy(kcpMsg.HeadData, headData)
// kcpMsg.ProtoData = make([]byte, len(protoData))
// copy(kcpMsg.ProtoData, protoData)
kcpMsg.HeadData = headData
kcpMsg.ProtoData = protoData
*kcpMsgList = append(*kcpMsgList, kcpMsg)
@@ -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]

17
gate/net/kcp_event.go
View File

@@ -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

26
gate/net/proto_endecode.go
View File

@@ -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

12
gdconf/avatar_data.go
View File

@@ -2,11 +2,13 @@ package gdconf
import (
"fmt"
"github.com/hjson/hjson-go/v4"
"github.com/jszwec/csvutil"
"os"
"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))
}

6
gdconf/avatar_skill_data.go
View File

@@ -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))
}

6
gdconf/avatar_skill_depot_data.go
View File

@@ -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))
}

16
gdconf/check_json_valid_test.go
View File

@@ -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)
}

7
gdconf/drop_group_data.go
View File

@@ -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))
}

3
gdconf/game_data_config.go
View File

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

9
gdconf/game_data_config_test.go
View File

@@ -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)
}

8
gm/app/app.go
View File

@@ -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:

2
gm/controller/controller.go
View File

@@ -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)
}
}

2
gm/controller/gm_controller.go
View File

@@ -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)
}

10
gs/app/app.go
View File

@@ -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:

12
gs/config/ability_embryos.go
View File

@@ -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))
}

10
gs/config/avatar_data.go
View File

@@ -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 {

10
gs/config/avatar_skill_data.go
View File

@@ -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]
}

10
gs/config/avatar_skill_depot_data.go
View File

@@ -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]

10
gs/config/fetter_data.go
View File

@@ -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]

10
gs/config/gadget_data.go
View File

@@ -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]
}

18
gs/config/game_data_config.go
View File

@@ -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
}
}

6
gs/config/game_depot.go
View File

@@ -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))
}

10
gs/config/gather_data.go
View File

@@ -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))
}

10
gs/config/item_data.go
View File

@@ -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]

10
gs/config/open_config_entries.go
View File

@@ -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))
}

12
gs/config/scene_points.go
View File

@@ -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))
}

4
gs/dao/dao.go
View File

@@ -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)
}
}

4
gs/dao/player_dao.go
View File

@@ -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 {

6
gs/game/aoi/aoi.go
View File

@@ -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
}

6
gs/game/aoi/aoi_test.go
View File

@@ -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)
}
}

2
gs/game/aoi/grid.go
View File

@@ -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)
}
}

3
gs/game/command_controller.go
View File

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

6
gs/game/command_gm.go
View File

@@ -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,13 +42,13 @@ 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
}
// 添加角色
GAME_MANAGER.AddUserAvatar(userId, avatarId)
// TODO 设置角色 等以后做到角色升级之类的再说
//avatar := player.AvatarMap[avatarId]
// avatar := player.AvatarMap[avatarId]
}
// GMAddUserAllItem 给予玩家所有物品

24
gs/game/command_manager.go
View File

@@ -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 发送消息
@@ -227,10 +227,10 @@ func (c *CommandManager) SendMessage(executor any, msg string, param ...any) {
GAME_MANAGER.SendPrivateChat(c.system, player, fmt.Sprintf(msg, param...))
case string:
// GM接口等
//str := executor.(string)
// str := executor.(string)
default:
// 无效的类型报错
logger.LOG.Error("command executor type error, type: %T", executor)
logger.Error("command executor type error, type: %T", executor)
}
}

12
gs/game/game_manager.go
View File

@@ -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
@@ -72,7 +74,7 @@ func (g *GameManager) Stop() {
EventId: RunUserCopyAndSave,
}
time.Sleep(time.Second * 3)
//g.worldManager.worldStatic.SaveTerrain()
// g.worldManager.worldStatic.SaveTerrain()
}
// SendMsg 发送消息给客户端
@@ -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)
}

11
gs/game/local_event_manager.go
View File

@@ -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)
}
}

4
gs/game/route_manager.go
View File

@@ -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

12
gs/game/tick_manager.go
View File

@@ -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) {
@@ -81,7 +81,7 @@ func (t *TickManager) onTick10Minute(now int64) {
}
func (t *TickManager) onTickMinute(now int64) {
//GAME_MANAGER.ServerAnnounceNotify(100, "test123")
// GAME_MANAGER.ServerAnnounceNotify(100, "test123")
for _, world := range WORLD_MANAGER.worldMap {
for _, player := range world.playerMap {
// 随机物品
@@ -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版本中 发送某些无效家具 可能会导致客户端背包家具界面卡死

20
gs/game/user_avatar.go
View File

@@ -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]
@@ -249,9 +249,9 @@ func (g *GameManager) UpdateUserAvatarFightProp(userId uint32, avatarId uint32)
func (g *GameManager) PacketAvatarInfo(avatar *model.Avatar) *proto.AvatarInfo {
isFocus := false
//if avatar.AvatarId == 10000005 || avatar.AvatarId == 10000007 {
// if avatar.AvatarId == 10000005 || avatar.AvatarId == 10000007 {
// isFocus = true
//}
// }
pbAvatar := &proto.AvatarInfo{
IsFocus: isFocus,
AvatarId: avatar.AvatarId,

10
gs/game/user_chat.go
View File

@@ -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

18
gs/game/user_common_handler.go
View File

@@ -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)
}

70
gs/game/user_fight_sync.go
View File

@@ -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,38 +155,38 @@ 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:
// switch entry.ArgumentType {
// case proto.AbilityInvokeArgument_ABILITY_INVOKE_ARGUMENT_META_MODIFIER_CHANGE:
// world := WORLD_MANAGER.GetWorldByID(player.WorldId)
// worldAvatar := world.GetWorldAvatarByEntityId(entry.EntityId)
// 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)
// }
// }
// }
//case proto.AbilityInvokeArgument_ABILITY_INVOKE_ARGUMENT_NONE:
//}
// case proto.AbilityInvokeArgument_ABILITY_INVOKE_ARGUMENT_NONE:
// }
// 处理耐力消耗
g.HandleAbilityStamina(player, entry)
@@ -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)

50
gs/game/user_gacha.go
View File

@@ -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
}
}

4
gs/game/user_item.go
View File

@@ -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 {

31
gs/game/user_login.go
View File

@@ -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)
@@ -31,7 +32,7 @@ func (g *GameManager) OnLoginOk(userId uint32, player *model.Player, clientSeq u
// 初始化
player.InitAll()
//player.TeamConfig.UpdateTeam()
// player.TeamConfig.UpdateTeam()
// 创建世界
world := WORLD_MANAGER.CreateWorld(player)
world.AddPlayer(player, player.SceneId)
@@ -40,8 +41,8 @@ func (g *GameManager) OnLoginOk(userId uint32, player *model.Player, clientSeq u
player.CombatInvokeHandler = model.NewInvokeHandler[proto.CombatInvokeEntry]()
player.AbilityInvokeHandler = model.NewInvokeHandler[proto.AbilityInvokeEntry]()
//// TODO 薄荷标记
//if world.IsBigWorld() {
// // TODO 薄荷标记
// if world.IsBigWorld() {
// bigWorld := world.GetSceneById(3)
// for pos := range g.worldManager.worldStatic.terrain {
// bigWorld.CreateEntityGadget(&model.Vector{
@@ -50,7 +51,7 @@ func (g *GameManager) OnLoginOk(userId uint32, player *model.Player, clientSeq u
// Z: float64(pos.Z),
// }, 3003009)
// }
//}
// }
g.LoginNotify(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())

18
gs/game/user_manager.go
View File

@@ -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))
}

20
gs/game/user_map.go
View File

@@ -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 {

18
gs/game/user_multiplayer.go
View File

@@ -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)
@@ -140,7 +140,7 @@ func (g *GameManager) JoinPlayerSceneReq(player *model.Player, payloadMsg pb.Mes
g.SendMsg(cmd.LeaveWorldNotify, player.PlayerID, player.ClientSeq, new(proto.LeaveWorldNotify))
//g.LoginNotify(player.PlayerID, player, 0)
// g.LoginNotify(player.PlayerID, player, 0)
if hostPlayer.SceneLoadState == model.SceneEnterDone {
delete(hostWorld.waitEnterPlayerMap, player.PlayerID)

36
gs/game/user_scene.go
View File

@@ -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) {
@@ -240,7 +240,7 @@ func (g *GameManager) EnterSceneDoneReq(player *model.Player, payloadMsg pb.Mess
g.AddSceneEntityNotify(player, visionType, []uint32{world.GetPlayerWorldAvatarEntityId(player, activeAvatarId)}, true, false)
// 通过aoi获取场景中在自己周围格子里的全部实体id
//entityIdList := world.aoiManager.GetEntityIdListByPos(float32(player.Pos.X), float32(player.Pos.Y), float32(player.Pos.Z))
// entityIdList := world.aoiManager.GetEntityIdListByPos(float32(player.Pos.X), float32(player.Pos.Y), float32(player.Pos.Z))
entityIdList := world.GetSceneById(player.SceneId).GetEntityIdList()
if world.IsPlayerFirstEnter(player) {
visionType = proto.VisionType_VISION_TYPE_MEET
@@ -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) {
@@ -719,9 +719,9 @@ func (g *GameManager) PacketSceneAvatarInfo(scene *Scene, player *model.Player,
BornTime: uint32(player.AvatarMap[avatarId].BornTime),
TeamResonanceList: make([]uint32, 0),
}
//for id := range player.TeamConfig.TeamResonances {
// for id := range player.TeamConfig.TeamResonances {
// sceneAvatarInfo.TeamResonanceList = append(sceneAvatarInfo.TeamResonanceList, uint32(id))
//}
// }
return sceneAvatarInfo
}
@@ -756,13 +756,13 @@ 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{
GadgetId: uint32(gather.GadgetId),
//GroupId: 133003011,
//ConfigId: 11001,
// GroupId: 133003011,
// ConfigId: 11001,
GadgetState: 0,
IsEnableInteract: false,
AuthorityPeerId: 1,

8
gs/game/user_shop.go
View File

@@ -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

38
gs/game/user_social.go
View File

@@ -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)

42
gs/game/user_stamina.go
View File

@@ -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)

24
gs/game/user_team.go
View File

@@ -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 {
@@ -111,7 +111,7 @@ func (g *GameManager) SetUpAvatarTeamReq(player *model.Player, payloadMsg pb.Mes
g.SendMsg(cmd.AvatarTeamUpdateNotify, player.PlayerID, player.ClientSeq, avatarTeamUpdateNotify)
if selfTeam {
//player.TeamConfig.UpdateTeam()
// player.TeamConfig.UpdateTeam()
world.SetPlayerLocalTeam(player, avatarIdList)
world.UpdateMultiplayerTeam()
world.InitPlayerWorldAvatar(player)
@@ -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)
@@ -149,7 +149,7 @@ func (g *GameManager) ChooseCurAvatarTeamReq(player *model.Player, payloadMsg pb
}
player.TeamConfig.CurrTeamIndex = uint8(teamId) - 1
player.TeamConfig.CurrAvatarIndex = 0
//player.TeamConfig.UpdateTeam()
// player.TeamConfig.UpdateTeam()
world.SetPlayerAvatarIndex(player, 0)
world.SetPlayerLocalTeam(player, team.GetAvatarIdList())
world.UpdateMultiplayerTeam()
@@ -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)
@@ -265,8 +265,8 @@ func (g *GameManager) PacketSceneTeamUpdateNotify(world *World) *proto.SceneTeam
}
acb.AbilityEmbryoList = append(acb.AbilityEmbryoList, emb)
}
//// add team resonances
//for id := range worldPlayer.TeamConfig.TeamResonancesConfig {
// // add team resonances
// for id := range worldPlayer.TeamConfig.TeamResonancesConfig {
// embryoId++
// emb := &proto.AbilityEmbryo{
// AbilityId: uint32(embryoId),
@@ -274,7 +274,7 @@ func (g *GameManager) PacketSceneTeamUpdateNotify(world *World) *proto.SceneTeam
// AbilityOverrideNameHash: uint32(constant.GameConstantConst.DEFAULT_ABILITY_NAME),
// }
// acb.AbilityEmbryoList = append(acb.AbilityEmbryoList, emb)
//}
// }
// add skill depot abilities
skillDepot := gdc.CONF.AvatarSkillDepotDataMap[int32(worldPlayerAvatar.SkillDepotId)]
if skillDepot != nil && len(skillDepot.Abilities) != 0 {

18
gs/game/user_vehicle.go
View File

@@ -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
}
@@ -89,9 +91,9 @@ func (g *GameManager) DestroyVehicleEntity(player *model.Player, scene *Scene, v
}
// 目前原神仅有一种载具 多载具时可能跟载具耐力回复冲突 到时候再改
// 确保载具Id为将要创建的 (每种载具允许存在1个)
//if entity.gadgetEntity.gadgetVehicleEntity.vehicleId != vehicleId {
// if entity.gadgetEntity.gadgetVehicleEntity.vehicleId != vehicleId {
// return
//}
// }
// 该载具是否为此玩家的
if entity.gadgetEntity.gadgetVehicleEntity.owner != player {
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
}

4
gs/game/user_weapon.go
View File

@@ -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
}

8
gs/game/world_manager.go
View File

@@ -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"
)
@@ -27,8 +27,8 @@ func NewWorldManager(snowflake *alg.SnowflakeWorker) (r *WorldManager) {
r.snowflake = snowflake
r.worldStatic = NewWorldStatic()
r.worldStatic.InitTerrain()
//r.worldStatic.Pathfinding()
//r.worldStatic.ConvPathVectorListToAiMoveVectorList()
// r.worldStatic.Pathfinding()
// r.worldStatic.ConvPathVectorListToAiMoveVectorList()
return r
}
@@ -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)

8
gs/game/world_static.go
View File

@@ -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)
}

6
gs/model/avatar.go
View File

@@ -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{

4
gs/model/invoke_handler.go
View File

@@ -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)
}
}

3
gs/model/player.go
View File

@@ -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 (

2
gs/model/weapon.go
View File

@@ -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 {

10
gs/mq/mq.go
View File

@@ -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
}
}

2
gs/service/gm.go
View File

@@ -15,7 +15,7 @@ type GMService struct {
}
func (s *GMService) Cmd(ctx context.Context, req *api.CmdRequest) (*api.CmdReply, error) {
//TODO implement me
// TODO implement me
fmt.Println("Cmd", req.FuncName, req.Param)
return &api.CmdReply{
Message: "TODO",

11
pkg/email/email_test.go
View File

@@ -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 {
@@ -90,7 +89,7 @@ func TestEmailWithHTMLAttachments(t *testing.T) {
}
// Print the bytes for ocular validation and make sure no errors.
//fmt.Println(string(b))
// fmt.Println(string(b))
// TODO: Verify the attachments.
s := &trimReader{rd: bytes.NewBuffer(b)}
@@ -156,7 +155,7 @@ func TestEmailWithHTMLAttachmentsHTMLOnly(t *testing.T) {
}
// Print the bytes for ocular validation and make sure no errors.
//fmt.Println(string(b))
// fmt.Println(string(b))
// TODO: Verify the attachments.
s := &trimReader{rd: bytes.NewBuffer(b)}

102
pkg/logger/logger.go
View File

@@ -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.Mode = getModeInt(config.CONF.Logger.Mode)
LOG.Level = LOG.getLevelInt(config.CONF.Logger.Level)
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) {
if l.Level > DEBUG {
func Debug(msg string, param ...any) {
if LOG.Level > DEBUG {
return
}
logInfo := new(LogInfo)
logInfo.Level = DEBUG
logInfo.Msg = msg
logInfo.Param = param
if l.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
logInfo.GoroutineId = l.getGoroutineId()
if LOG.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
logInfo.GoroutineId = LOG.getGoroutineId()
}
l.LogInfoChan <- logInfo
LOG.LogInfoChan <- logInfo
}
func (l *Logger) Info(msg string, param ...any) {
if l.Level > INFO {
func Info(msg string, param ...any) {
if LOG.Level > INFO {
return
}
logInfo := new(LogInfo)
logInfo.Level = INFO
logInfo.Msg = msg
logInfo.Param = param
if l.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
logInfo.GoroutineId = l.getGoroutineId()
if LOG.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
logInfo.GoroutineId = LOG.getGoroutineId()
}
l.LogInfoChan <- logInfo
LOG.LogInfoChan <- logInfo
}
func (l *Logger) Error(msg string, param ...any) {
if l.Level > ERROR {
func Warn(msg string, param ...any) {
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 {
logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
logInfo.GoroutineId = l.getGoroutineId()
if LOG.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
logInfo.GoroutineId = LOG.getGoroutineId()
}
l.LogInfoChan <- logInfo
LOG.LogInfoChan <- logInfo
}
func (l *Logger) ErrorStack(msg string, param ...any) {
if l.Level > ERROR {
func ErrorStack(msg string, param ...any) {
if LOG.Level > ERROR {
return
}
logInfo := new(LogInfo)
logInfo.Level = ERROR
logInfo.Msg = msg
logInfo.Param = param
if l.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = l.getLineFunc()
logInfo.GoroutineId = l.getGoroutineId()
logInfo.Stack = l.Stack()
if LOG.Track {
logInfo.FileName, logInfo.Line, logInfo.FuncName = LOG.getLineFunc()
logInfo.GoroutineId = LOG.getGoroutineId()
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)

1
pkg/object/object.go
View File

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

4
pkg/statsviz_serve/statsviz_serve.go
View File

@@ -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

20
protocol/cmd/cmd_id_proto_obj_map.go
View File

@@ -244,13 +244,13 @@ func (c *CmdProtoMap) registerAllMessage() {
c.registerMessage(ServerAnnounceNotify, &proto.ServerAnnounceNotify{}) // 服务器公告通知
c.registerMessage(ServerAnnounceRevokeNotify, &proto.ServerAnnounceRevokeNotify{}) // 服务器公告撤销通知
//// TODO
//c.registerMessage(EvtAiSyncSkillCdNotify, &proto.EvtAiSyncSkillCdNotify{})
//c.registerMessage(EvtAiSyncCombatThreatInfoNotify, &proto.EvtAiSyncCombatThreatInfoNotify{})
//c.registerMessage(EntityConfigHashNotify, &proto.EntityConfigHashNotify{})
//c.registerMessage(MonsterAIConfigHashNotify, &proto.MonsterAIConfigHashNotify{})
//c.registerMessage(GetRegionSearchReq, &proto.GetRegionSearchReq{})
//c.registerMessage(ObstacleModifyNotify, &proto.ObstacleModifyNotify{})
// // TODO
// c.registerMessage(EvtAiSyncSkillCdNotify, &proto.EvtAiSyncSkillCdNotify{})
// c.registerMessage(EvtAiSyncCombatThreatInfoNotify, &proto.EvtAiSyncCombatThreatInfoNotify{})
// c.registerMessage(EntityConfigHashNotify, &proto.EntityConfigHashNotify{})
// c.registerMessage(MonsterAIConfigHashNotify, &proto.MonsterAIConfigHashNotify{})
// c.registerMessage(GetRegionSearchReq, &proto.GetRegionSearchReq{})
// c.registerMessage(ObstacleModifyNotify, &proto.ObstacleModifyNotify{})
// 空消息
c.registerMessage(65535, &proto.NullMsg{})
@@ -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