holy refactor

started out as me making a service abstraction..

- db.Player exists again, and entity.Player uses it as an embedded struct
- chunk.ForEachEntity() lets you add/remove entities during iteration now
- removed account related fields from CNPeer
- protocol/pool has been merged with protocol.
use protocol.GetBuffer() and protocol.PutBuffer().
- new protocol/internal/service!
service.Service is an abstraction layer to handle multiple CNPeer*
connections and allows you to associate each with an interface{} uData.
In the future it might also handle a task queue for jobs that
modify/interact with the player's uData, called from service.handleEvents()
- PacketHandler callback type has a new param! uData is passed as well now
- much of loginserver/shardserver is now handled by the shared service
abstraction
- SHARD: NPC_ENTER packets are now sent on player loading complete
rather than on enter.

shard/chat.go

@@ -1,16 +1,20 @@
 package shard
 
-import "github.com/CPunch/gopenfusion/internal/protocol"
+import (
+	"fmt"
 
-func (server *ShardServer) freeChat(peer *protocol.CNPeer, pkt protocol.Packet) error {
+	"github.com/CPunch/gopenfusion/internal/entity"
+	"github.com/CPunch/gopenfusion/internal/protocol"
+)
+
+func (server *ShardServer) freeChat(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var chat protocol.SP_CL2FE_REQ_SEND_FREECHAT_MESSAGE
 	pkt.Decode(&chat)
 
-	// sanity check
-	plr, err := server.getPlayer(peer)
-	if err != nil {
-		return err
+	if _plr == nil {
+		return fmt.Errorf("freeChat: _plr is nil")
 	}
+	plr := _plr.(*entity.Player)
 
 	// spread message
 	return server.sendAllPacket(plr, protocol.P_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC, protocol.SP_FE2CL_REP_SEND_FREECHAT_MESSAGE_SUCC{
@@ -20,15 +24,14 @@ func (server *ShardServer) freeChat(peer *protocol.CNPeer, pkt protocol.Packet)
 	})
 }
 
-func (server *ShardServer) menuChat(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) menuChat(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var chat protocol.SP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE
 	pkt.Decode(&chat)
 
-	// sanity check
-	plr, err := server.getPlayer(peer)
-	if err != nil {
-		return err
+	if _plr == nil {
+		return fmt.Errorf("menuChat: _plr is nil")
 	}
+	plr := _plr.(*entity.Player)
 
 	// spread message
 	return server.sendAllPacket(plr, protocol.P_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC, protocol.SP_FE2CL_REP_SEND_MENUCHAT_MESSAGE_SUCC{
@@ -38,15 +41,14 @@ func (server *ShardServer) menuChat(peer *protocol.CNPeer, pkt protocol.Packet)
 	})
 }
 
-func (server *ShardServer) emoteChat(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) emoteChat(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var chat protocol.SP_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT
 	pkt.Decode(&chat)
 
-	// sanity check
-	plr, err := server.getPlayer(peer)
-	if err != nil {
-		return err
+	if _plr == nil {
+		return fmt.Errorf("emoteChat: _plr is nil")
 	}
+	plr := _plr.(*entity.Player)
 
 	// spread message
 	return server.sendAllPacket(plr, protocol.P_FE2CL_REP_PC_AVATAR_EMOTES_CHAT, protocol.SP_FE2CL_REP_PC_AVATAR_EMOTES_CHAT{

shard/join.go

@@ -10,27 +10,29 @@ import (
 )
 
 func (server *ShardServer) attachPlayer(peer *protocol.CNPeer, meta redis.LoginMetadata) (*entity.Player, error) {
-	// resending a shard enter packet?
-	old, _ := server.getPlayer(peer)
-	if old != nil {
-		return nil, fmt.Errorf("resent enter packet")
-	}
-
-	// attach player
-	plr, err := server.dbHndlr.GetPlayer(int(meta.PlayerID))
+	dbPlr, err := server.dbHndlr.GetPlayer(int(meta.PlayerID))
 	if err != nil {
 		return nil, err
 	}
-	plr.Peer = peer
+	plr := entity.NewPlayer(peer, dbPlr)
 
-	server.setPlayer(peer, plr)
+	// 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.
+	server.service.SetPeerData(peer, plr)
 	return plr, nil
 }
 
-func (server *ShardServer) RequestEnter(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) RequestEnter(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var enter protocol.SP_CL2FE_REQ_PC_ENTER
 	pkt.Decode(&enter)
 
+	// resending a shard enter packet?
+	if _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 :(
@@ -52,29 +54,35 @@ func (server *ShardServer) RequestEnter(peer *protocol.CNPeer, pkt protocol.Pack
 	// setup peer
 	peer.E_key = protocol.CreateNewKey(resp.UiSvrTime, uint64(resp.IID+1), uint64(resp.PCLoadData2CL.IFusionMatter+1))
 	peer.FE_key = loginData.FEKey
-	peer.PlayerID = loginData.PlayerID
-	peer.AccountID = loginData.AccountID
 	peer.SetActiveKey(protocol.USE_FE)
 
 	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
 	}
 
-	// we send the chunk updates (PC_NEW, NPC_NEW, etc.) after the enter packet
-	server.updatePlayerPosition(plr, int(plr.X), int(plr.Y), int(plr.Z), int(plr.Angle))
 	return nil
 }
 
-func (server *ShardServer) LoadingComplete(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) LoadingComplete(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var loadComplete protocol.SP_CL2FE_REQ_PC_LOADING_COMPLETE
 	pkt.Decode(&loadComplete)
 
-	plr, err := server.getPlayer(peer)
+	// was the peer attached to a player?
+	if _plr == nil {
+		return fmt.Errorf("loadingComplete: plr is nil")
+	}
+	plr := _plr.(*entity.Player)
+
+	err := peer.Send(protocol.P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, protocol.SP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC{IPC_ID: int32(plr.PlayerID)})
 	if err != nil {
 		return err
 	}
 
-	return peer.Send(protocol.P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, protocol.SP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC{IPC_ID: int32(plr.PlayerID)})
+	// 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.addEntityToChunks(plr, viewableChunks)
+	return nil
 }

shard/movement.go

@@ -1,6 +1,8 @@
 package shard
 
 import (
+	"fmt"
+
 	"github.com/CPunch/gopenfusion/internal/entity"
 	"github.com/CPunch/gopenfusion/internal/protocol"
 )
@@ -13,15 +15,14 @@ func (server *ShardServer) updatePlayerPosition(plr *entity.Player, X, Y, Z, Ang
 	server.updateEntityChunk(plr, plr.GetChunkPos(), entity.MakeChunkPosition(X, Y))
 }
 
-func (server *ShardServer) playerMove(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) playerMove(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var move protocol.SP_CL2FE_REQ_PC_MOVE
 	pkt.Decode(&move)
 
-	// sanity check
-	plr, err := server.getPlayer(peer)
-	if err != nil {
-		return err
+	if _plr == nil {
+		return fmt.Errorf("playerMove: _plr is nil")
 	}
+	plr := _plr.(*entity.Player)
 
 	// update chunking
 	server.updatePlayerPosition(plr, int(move.IX), int(move.IY), int(move.IZ), int(move.IAngle))
@@ -42,15 +43,14 @@ func (server *ShardServer) playerMove(peer *protocol.CNPeer, pkt protocol.Packet
 	})
 }
 
-func (server *ShardServer) playerStop(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) playerStop(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var stop protocol.SP_CL2FE_REQ_PC_STOP
 	pkt.Decode(&stop)
 
-	// sanity check
-	plr, err := server.getPlayer(peer)
-	if err != nil {
-		return err
+	if _plr == nil {
+		return fmt.Errorf("playerStop: _plr is nil")
 	}
+	plr := _plr.(*entity.Player)
 
 	// update chunking
 	server.updatePlayerPosition(plr, int(stop.IX), int(stop.IY), int(stop.IZ), plr.Angle)
@@ -65,15 +65,14 @@ func (server *ShardServer) playerStop(peer *protocol.CNPeer, pkt protocol.Packet
 	})
 }
 
-func (server *ShardServer) playerJump(peer *protocol.CNPeer, pkt protocol.Packet) error {
+func (server *ShardServer) playerJump(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
 	var jump protocol.SP_CL2FE_REQ_PC_JUMP
 	pkt.Decode(&jump)
 
-	// sanity check
-	plr, err := server.getPlayer(peer)
-	if err != nil {
-		return err
+	if _plr == nil {
+		return fmt.Errorf("playerJump: _plr is nil")
 	}
+	plr := _plr.(*entity.Player)
 
 	// update chunking
 	server.updatePlayerPosition(plr, int(jump.IX), int(jump.IY), int(jump.IZ), plr.Angle)

shard/shardserver.go

@@ -1,60 +1,47 @@
 package shard
 
 import (
-	"fmt"
-	"log"
-	"net"
-	"sync"
-
 	"github.com/CPunch/gopenfusion/config"
 	"github.com/CPunch/gopenfusion/internal/db"
 	"github.com/CPunch/gopenfusion/internal/entity"
 	"github.com/CPunch/gopenfusion/internal/protocol"
-	"github.com/CPunch/gopenfusion/internal/protocol/pool"
 	"github.com/CPunch/gopenfusion/internal/redis"
+	"github.com/CPunch/gopenfusion/internal/service"
 )
 
 type PacketHandler func(peer *protocol.CNPeer, pkt protocol.Packet) error
 
 type ShardServer struct {
-	listener       net.Listener
-	port           int
-	dbHndlr        *db.DBHandler
-	redisHndlr     *redis.RedisHandler
-	eRecv          chan *protocol.Event
-	packetHandlers map[uint32]PacketHandler
-	peers          map[*protocol.CNPeer]*entity.Player
-	chunks         map[entity.ChunkPosition]*entity.Chunk
-	peerLock       sync.Mutex
+	service    *service.Service
+	dbHndlr    *db.DBHandler
+	redisHndlr *redis.RedisHandler
+	chunks     map[entity.ChunkPosition]*entity.Chunk
 }
 
 func NewShardServer(dbHndlr *db.DBHandler, redisHndlr *redis.RedisHandler, port int) (*ShardServer, error) {
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
+	srvc, err := service.NewService("SHARD", port)
 	if err != nil {
 		return nil, err
 	}
 
 	server := &ShardServer{
-		listener:       listener,
-		port:           port,
-		dbHndlr:        dbHndlr,
-		redisHndlr:     redisHndlr,
-		packetHandlers: make(map[uint32]PacketHandler),
-		peers:          make(map[*protocol.CNPeer]*entity.Player),
-		chunks:         make(map[entity.ChunkPosition]*entity.Chunk),
-		eRecv:          make(chan *protocol.Event),
+		service:    srvc,
+		dbHndlr:    dbHndlr,
+		redisHndlr: redisHndlr,
+		chunks:     make(map[entity.ChunkPosition]*entity.Chunk),
 	}
 
-	server.packetHandlers = map[uint32]PacketHandler{
-		protocol.P_CL2FE_REQ_PC_ENTER:              server.RequestEnter,
-		protocol.P_CL2FE_REQ_PC_LOADING_COMPLETE:   server.LoadingComplete,
-		protocol.P_CL2FE_REQ_PC_MOVE:               server.playerMove,
-		protocol.P_CL2FE_REQ_PC_STOP:               server.playerStop,
-		protocol.P_CL2FE_REQ_PC_JUMP:               server.playerJump,
-		protocol.P_CL2FE_REQ_SEND_FREECHAT_MESSAGE: server.freeChat,
-		protocol.P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE: server.menuChat,
-		protocol.P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT: server.emoteChat,
-	}
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_ENTER, server.RequestEnter)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_LOADING_COMPLETE, server.LoadingComplete)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_MOVE, server.playerMove)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_STOP, server.playerStop)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_JUMP, server.playerJump)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_SEND_FREECHAT_MESSAGE, server.freeChat)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE, server.menuChat)
+	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT, server.emoteChat)
+
+	srvc.OnConnect = server.onConnect
+	srvc.OnDisconnect = server.onDisconnect
 
 	redisHndlr.RegisterShard(redis.ShardMetadata{
 		IP:   config.GetAnnounceIP(),
@@ -64,97 +51,18 @@ func NewShardServer(dbHndlr *db.DBHandler, redisHndlr *redis.RedisHandler, port
 	return server, nil
 }
 
-func (server *ShardServer) handleEvents() {
-	for event := range server.eRecv {
-		switch event.Type {
-		case protocol.EVENT_CLIENT_DISCONNECT:
-			server.disconnect(event.Peer)
-		case protocol.EVENT_CLIENT_PACKET:
-			if err := server.handlePacket(event.Peer, event.PktID, protocol.NewPacket(event.Pkt)); err != nil {
-				event.Peer.Kill()
-			}
-
-			// the packet is given to us by the event, so we'll need to make sure to return it to the pool
-			pool.Put(event.Pkt)
-		}
-	}
-}
-
 func (server *ShardServer) Start() {
 	server.LoadNPCs()
+	server.service.Start()
+}
 
-	log.Printf("Shard service hosted on %s:%d\n", config.GetAnnounceIP(), server.port)
-	go server.handleEvents()
-	for {
-		conn, err := server.listener.Accept()
-		if err != nil {
-			log.Println("Connection error: ", err)
-			return
-		}
-
-		client := protocol.NewCNPeer(server.eRecv, conn)
-		server.connect(client)
-		go client.Handler()
+func (server *ShardServer) onDisconnect(peer *protocol.CNPeer, _plr interface{}) {
+	// remove from chunks
+	if _plr != nil {
+		server.removeEntity(_plr.(*entity.Player))
 	}
 }
 
-func (server *ShardServer) GetPort() int {
-	return server.port
-}
-
-func (server *ShardServer) handlePacket(peer *protocol.CNPeer, typeID uint32, pkt protocol.Packet) error {
-	if hndlr, ok := server.packetHandlers[typeID]; ok {
-		if err := hndlr(peer, pkt); err != nil {
-			return err
-		}
-	} else {
-		log.Printf("[WARN] unknown packet ID: %x\n", typeID)
-	}
-
+func (server *ShardServer) onConnect(peer *protocol.CNPeer) interface{} {
 	return nil
 }
-
-func (server *ShardServer) disconnect(peer *protocol.CNPeer) {
-	server.peerLock.Lock()
-	defer server.peerLock.Unlock()
-
-	// remove from chunk(s)
-	plr, ok := server.peers[peer]
-	if ok {
-		log.Printf("Player %d (AccountID %d) disconnected\n", plr.PlayerID, plr.AccountID)
-		server.removeEntity(plr)
-	}
-
-	log.Printf("Peer %p disconnected from SHARD\n", peer)
-	delete(server.peers, peer)
-}
-
-func (server *ShardServer) connect(peer *protocol.CNPeer) {
-	server.peerLock.Lock()
-	defer server.peerLock.Unlock()
-
-	log.Printf("New peer %p connected to SHARD\n", peer)
-	server.peers[peer] = nil
-}
-
-func (server *ShardServer) getPlayer(peer *protocol.CNPeer) (*entity.Player, error) {
-	plr, ok := server.peers[peer]
-	if !ok {
-		return nil, fmt.Errorf("player not found")
-	}
-
-	return plr, nil
-}
-
-func (server *ShardServer) setPlayer(peer *protocol.CNPeer, plr *entity.Player) {
-	server.peers[peer] = plr
-}
-
-// If f returns false the iteration is stopped.
-func (server *ShardServer) rangePeers(f func(peer *protocol.CNPeer, plr *entity.Player) bool) {
-	for peer, plr := range server.peers {
-		if f(peer, plr) {
-			return
-		}
-	}
-}