gopenfusion/shard/join.go

94 lines
2.7 KiB
Go
Raw Normal View History

2023-03-27 22:02:13 +00:00
package shard
import (
"fmt"
"log"
2023-12-01 23:11:41 +00:00
"github.com/CPunch/gopenfusion/cnet"
"github.com/CPunch/gopenfusion/cnet/protocol"
2023-08-23 23:16:24 +00:00
"github.com/CPunch/gopenfusion/internal/redis"
2023-12-01 22:56:55 +00:00
"github.com/CPunch/gopenfusion/shard/entity"
"github.com/CPunch/gopenfusion/util"
)
2023-12-02 01:15:00 +00:00
func (server *ShardServer) attachPlayer(peer *cnet.Peer, meta redis.LoginMetadata) (*entity.Player, error) {
dbPlr, err := server.dbHndlr.GetPlayer(int(meta.PlayerID))
2023-06-25 06:51:21 +00:00
if err != nil {
return nil, err
}
plr := entity.NewPlayer(peer, dbPlr)
2023-06-25 06:51:21 +00:00
// once we create the player, it's memory address is owned by the
// server.Start() goroutine. the only functions allowed to access
// it are the packet handlers as no other goroutines will be
// concurrently accessing it.
peer.SetUserData(plr)
2023-06-25 08:33:17 +00:00
return plr, nil
2023-06-25 06:51:21 +00:00
}
2023-12-02 01:15:00 +00:00
func (server *ShardServer) RequestEnter(peer *cnet.Peer, pkt protocol.Packet) error {
var enter protocol.SP_CL2FE_REQ_PC_ENTER
pkt.Decode(&enter)
// resending a shard enter packet?
_plr, ok := peer.UserData().(*entity.Player)
if ok && _plr != nil {
return fmt.Errorf("resent enter packet")
}
loginData, err := server.redisHndlr.GetLogin(enter.IEnterSerialKey)
if err != nil {
// the error codes for P_FE2CL_REP_PC_ENTER_FAIL aren't referenced in the client :(
peer.Send(protocol.P_FE2CL_REP_PC_ENTER_FAIL, protocol.SP_FE2CL_REP_PC_ENTER_FAIL{})
return err
}
2023-06-25 06:51:21 +00:00
plr, err := server.attachPlayer(peer, loginData)
if err != nil {
return err
}
2023-06-25 06:51:21 +00:00
resp := &protocol.SP_FE2CL_REP_PC_ENTER_SUCC{
IID: int32(plr.PlayerID),
PCLoadData2CL: plr.ToPCLoadData2CL(),
UiSvrTime: util.GetTime(),
2023-06-25 06:51:21 +00:00
}
2023-06-25 03:36:04 +00:00
// setup peer
2023-06-25 06:51:21 +00:00
peer.E_key = protocol.CreateNewKey(resp.UiSvrTime, uint64(resp.IID+1), uint64(resp.PCLoadData2CL.IFusionMatter+1))
peer.FE_key = loginData.FEKey
2023-12-01 23:11:41 +00:00
peer.SetActiveKey(cnet.USE_FE)
2023-06-25 03:36:04 +00:00
2023-06-22 23:12:31 +00:00
log.Printf("Player %d (AccountID %d) entered\n", resp.IID, loginData.AccountID)
if err := peer.Send(protocol.P_FE2CL_REP_PC_ENTER_SUCC, resp); err != nil {
return err
}
return nil
}
2023-12-02 01:15:00 +00:00
func (server *ShardServer) LoadingComplete(peer *cnet.Peer, pkt protocol.Packet) error {
var loadComplete protocol.SP_CL2FE_REQ_PC_LOADING_COMPLETE
pkt.Decode(&loadComplete)
// was the peer attached to a player?
plr, ok := peer.UserData().(*entity.Player)
if !ok || plr == nil {
return fmt.Errorf("loadingComplete: plr is nil")
}
err := peer.Send(protocol.P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, protocol.SP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC{IPC_ID: int32(plr.PlayerID)})
2023-06-25 03:36:04 +00:00
if err != nil {
return err
}
// we send the chunk updates (PC_NEW, NPC_NEW, etc.) after the enter packet
chunkPos := entity.MakeChunkPosition(plr.X, plr.Y)
viewableChunks := server.getViewableChunks(chunkPos)
plr.SetChunkPos(chunkPos)
server.getChunk(chunkPos).AddEntity(plr)
server.addEntityToChunks(plr, viewableChunks)
return nil
}