internal/db/players.go

@@ -4,41 +4,11 @@ import (
 	"database/sql"
 
 	"github.com/CPunch/gopenfusion/config"
+	"github.com/CPunch/gopenfusion/internal/entity"
 	"github.com/CPunch/gopenfusion/internal/protocol"
 	"github.com/blockloop/scan"
 )
 
-type Player struct {
-	PlayerID           int
-	AccountID          int
-	AccountLevel       int
-	Slot               int
-	PCStyle            protocol.SPCStyle
-	PCStyle2           protocol.SPCStyle2
-	EquippedNanos      [3]int
-	Nanos              [config.NANO_COUNT]protocol.SNano
-	Equip              [config.AEQUIP_COUNT]protocol.SItemBase
-	Inven              [config.AINVEN_COUNT]protocol.SItemBase
-	Bank               [config.ABANK_COUNT]protocol.SItemBase
-	SkywayLocationFlag []byte
-	FirstUseFlag       []byte
-	Quests             []byte
-	HP                 int
-	Level              int
-	Taros              int
-	FusionMatter       int
-	Mentor             int
-	X, Y, Z            int
-	Angle              int
-	BatteryN           int
-	BatteryW           int
-	WarpLocationFlag   int
-	ActiveNanoSlotNum  int
-	Fatigue            int
-	CurrentMissionID   int
-	IPCState           int8
-}
-
 // returns PlayerID, error
 func (db *DBHandler) NewPlayer(AccountID int, FirstName, LastName string, slot int) (int, error) {
 	nameCheck := 1 // for now, we approve all names
@@ -151,8 +121,8 @@ const (
 	INNER JOIN Accounts as acc ON p.AccountID = acc.AccountID `
 )
 
-func (db *DBHandler) readPlayer(rows *sql.Rows) (*Player, error) {
+func (db *DBHandler) readPlayer(rows *sql.Rows) (*entity.Player, error) {
-	plr := Player{ActiveNanoSlotNum: 0}
+	plr := entity.Player{ActiveNanoSlotNum: 0}
 
 	if err := rows.Scan(
 		&plr.PlayerID, &plr.AccountID, &plr.Slot, &plr.PCStyle.SzFirstName, &plr.PCStyle.SzLastName,
@@ -192,13 +162,13 @@ func (db *DBHandler) readPlayer(rows *sql.Rows) (*Player, error) {
 	return &plr, nil
 }
 
-func (db *DBHandler) GetPlayer(PlayerID int) (*Player, error) {
+func (db *DBHandler) GetPlayer(PlayerID int) (*entity.Player, error) {
 	rows, err := db.Query(QUERY_PLAYERS+"WHERE p.PlayerID = $1", PlayerID)
 	if err != nil {
 		return nil, err
 	}
 
-	var plr *Player
+	var plr *entity.Player
 	for rows.Next() {
 		plr, err = db.readPlayer(rows)
 		if err != nil {
@@ -209,13 +179,13 @@ func (db *DBHandler) GetPlayer(PlayerID int) (*Player, error) {
 	return plr, nil
 }
 
-func (db *DBHandler) GetPlayers(AccountID int) ([]Player, error) {
+func (db *DBHandler) GetPlayers(AccountID int) ([]entity.Player, error) {
 	rows, err := db.Query(QUERY_PLAYERS+"WHERE p.AccountID = $1", AccountID)
 	if err != nil {
 		return nil, err
 	}
 
-	var plrs []Player
+	var plrs []entity.Player
 	for rows.Next() {
 		plr, err := db.readPlayer(rows)
 		if err != nil {

internal/entity/chunk.go

@@ -38,17 +38,11 @@ func (c *Chunk) SendPacket(typeID uint32, pkt ...interface{}) {
 }
 
 // calls f for each entity in this chunk, if f returns true, stop iterating
-// f can safely add/remove entities from the chunk
 func (c *Chunk) ForEachEntity(f func(entity Entity) bool) {
-	// copy entities to avoid locking for the entire iteration
-	entities := make(map[Entity]struct{})
 	c.lock.Lock()
-	for entity := range c.entities {
+	defer c.lock.Unlock()
-		entities[entity] = struct{}{}
-	}
-	c.lock.Unlock()
 
-	for entity := range entities {
+	for entity := range c.entities {
 		if f(entity) {
 			break
 		}

internal/entity/player.go

@@ -1,22 +1,41 @@
 package entity
 
 import (
-	"github.com/CPunch/gopenfusion/internal/db"
+	"github.com/CPunch/gopenfusion/config"
 	"github.com/CPunch/gopenfusion/internal/protocol"
 )
 
 type Player struct {
-	db.Player
 	Peer               *protocol.CNPeer
 	Chunk              ChunkPosition
-}
+	PlayerID           int
-
+	AccountID          int
-func NewPlayer(peer *protocol.CNPeer, player *db.Player) *Player {
+	AccountLevel       int
-	return &Player{
+	Slot               int
-		Player: *player,
+	PCStyle            protocol.SPCStyle
-		Peer:   peer,
+	PCStyle2           protocol.SPCStyle2
-		Chunk:  MakeChunkPosition(player.X, player.Y),
+	EquippedNanos      [3]int
-	}
+	Nanos              [config.NANO_COUNT]protocol.SNano
+	Equip              [config.AEQUIP_COUNT]protocol.SItemBase
+	Inven              [config.AINVEN_COUNT]protocol.SItemBase
+	Bank               [config.ABANK_COUNT]protocol.SItemBase
+	SkywayLocationFlag []byte
+	FirstUseFlag       []byte
+	Quests             []byte
+	HP                 int
+	Level              int
+	Taros              int
+	FusionMatter       int
+	Mentor             int
+	X, Y, Z            int
+	Angle              int
+	BatteryN           int
+	BatteryW           int
+	WarpLocationFlag   int
+	ActiveNanoSlotNum  int
+	Fatigue            int
+	CurrentMissionID   int
+	IPCState           int8
 }
 
 // ==================== Entity interface ====================

internal/protocol/cnpeer.go

@@ -6,8 +6,9 @@ import (
 	"io"
 	"log"
 	"net"
-	"sync/atomic"
 	"time"
+
+	"github.com/CPunch/gopenfusion/internal/protocol/pool"
 )
 
 const (
@@ -19,14 +20,13 @@ const (
 type CNPeer struct {
 	conn      net.Conn
 	eRecv     chan *Event
-	whichKey int
+	SzID      string
-	alive    *atomic.Bool
-
-	// May not be set while Send() or Handler() are concurrently running.
 	E_key     []byte
-
-	// May not be set while Send() or Handler() are concurrently running.
 	FE_key    []byte
+	AccountID int
+	PlayerID  int32
+	whichKey  int
+	alive     bool
 }
 
 func GetTime() uint64 {
@@ -34,23 +34,22 @@ func GetTime() uint64 {
 }
 
 func NewCNPeer(eRecv chan *Event, conn net.Conn) *CNPeer {
-	p := &CNPeer{
+	return &CNPeer{
 		conn:      conn,
 		eRecv:     eRecv,
-		whichKey: USE_E,
+		SzID:      "",
-		alive:    &atomic.Bool{},
-
 		E_key:     []byte(DEFAULT_KEY),
 		FE_key:    nil,
+		AccountID: -1,
+		whichKey:  USE_E,
+		alive:     true,
 	}
-
-	return p
 }
 
 func (peer *CNPeer) Send(typeID uint32, data ...interface{}) error {
 	// grab buffer from pool
-	buf := GetBuffer()
+	buf := pool.Get()
-	defer PutBuffer(buf)
+	defer pool.Put(buf)
 
 	// allocate space for packet size
 	buf.Write(make([]byte, 4))
@@ -74,14 +73,12 @@ func (peer *CNPeer) Send(typeID uint32, data ...interface{}) error {
 	binary.LittleEndian.PutUint32(buf.Bytes()[:4], uint32(buf.Len()-4))
 
 	// encrypt body
-	var key []byte
 	switch peer.whichKey {
 	case USE_E:
-		key = peer.E_key
+		EncryptData(buf.Bytes()[4:], peer.E_key)
 	case USE_FE:
-		key = peer.FE_key
+		EncryptData(buf.Bytes()[4:], peer.FE_key)
 	}
-	EncryptData(buf.Bytes()[4:], key)
 
 	// send full packet
 	log.Printf("Sending %#v, sizeof: %d, buffer: %v", data, buf.Len(), buf.Bytes())
@@ -97,11 +94,11 @@ func (peer *CNPeer) SetActiveKey(whichKey int) {
 
 func (peer *CNPeer) Kill() {
 	log.Printf("Killing peer %p", peer)
-
+	if !peer.alive {
-	if !peer.alive.CompareAndSwap(true, false) {
 		return
 	}
 
+	peer.alive = false
 	peer.conn.Close()
 	peer.eRecv <- &Event{Type: EVENT_CLIENT_DISCONNECT, Peer: peer}
 }
@@ -110,7 +107,6 @@ func (peer *CNPeer) Kill() {
 func (peer *CNPeer) Handler() {
 	defer peer.Kill()
 
-	peer.alive.Store(true)
 	for {
 		// read packet size, the goroutine spends most of it's time parked here
 		var sz uint32
@@ -127,7 +123,7 @@ func (peer *CNPeer) Handler() {
 
 		// grab buffer && read packet body
 		if err := func() error {
-			buf := GetBuffer()
+			buf := pool.Get()
 			if _, err := buf.ReadFrom(io.LimitReader(peer.conn, int64(sz))); err != nil {
 				return fmt.Errorf("failed to read packet body! %v", err)
 			}

internal/protocol/pool/pool.go

@@ -1,4 +1,4 @@
-package protocol
+package pool
 
 import (
 	"bytes"
@@ -9,13 +9,11 @@ var allocator = &sync.Pool{
 	New: func() any { return new(bytes.Buffer) },
 }
 
-// grabs a *bytes.Buffer from the pool
+func Get() *bytes.Buffer {
-func GetBuffer() *bytes.Buffer {
 	return allocator.Get().(*bytes.Buffer)
 }
 
-// returns a *bytes.Buffer to the pool
+func Put(buf *bytes.Buffer) {
-func PutBuffer(buf *bytes.Buffer) {
 	buf.Reset()
 	allocator.Put(buf)
 }

internal/service/service.go

@@ -1,138 +0,0 @@
-package service
-
-import (
-	"fmt"
-	"log"
-	"net"
-	"sync"
-
-	"github.com/CPunch/gopenfusion/config"
-	"github.com/CPunch/gopenfusion/internal/protocol"
-)
-
-type PacketHandler func(peer *protocol.CNPeer, uData interface{}, pkt protocol.Packet) error
-
-func StubbedPacket(_ *protocol.CNPeer, _ interface{}, _ protocol.Packet) error {
-	return nil
-}
-
-type Service struct {
-	listener       net.Listener
-	port           int
-	Name           string
-	eRecv          chan *protocol.Event
-	packetHandlers map[uint32]PacketHandler
-	peers          *sync.Map
-
-	// OnDisconnect is called when a peer disconnects from the service.
-	// uData is the stored value of the key/value pair in the peer map.
-	// It may not be set while the service is running. (eg. srvc.Start() has been called)
-	OnDisconnect func(peer *protocol.CNPeer, uData interface{})
-
-	// OnConnect is called when a peer connects to the service.
-	// return value is used as the value in the peer map.
-	// It may not be set while the service is running. (eg. srvc.Start() has been called)
-	OnConnect func(peer *protocol.CNPeer) (uData interface{})
-}
-
-func NewService(name string, port int) (*Service, error) {
-	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
-	if err != nil {
-		return nil, err
-	}
-
-	service := &Service{
-		listener:       listener,
-		port:           port,
-		Name:           name,
-		eRecv:          make(chan *protocol.Event),
-		packetHandlers: make(map[uint32]PacketHandler),
-		peers:          &sync.Map{},
-	}
-
-	return service, nil
-}
-
-// may not be called while the service is running (eg. srvc.Start() has been called)
-func (service *Service) AddPacketHandler(pktID uint32, handler PacketHandler) {
-	service.packetHandlers[pktID] = handler
-}
-
-func (service *Service) Start() {
-	log.Printf("%s service hosted on %s:%d\n", service.Name, config.GetAnnounceIP(), service.port)
-
-	go service.handleEvents()
-	for {
-		conn, err := service.listener.Accept()
-		if err != nil {
-			log.Println("Connection error: ", err)
-			return
-		}
-
-		peer := protocol.NewCNPeer(service.eRecv, conn)
-		service.connect(peer)
-	}
-}
-
-func (service *Service) handleEvents() {
-	for event := range service.eRecv {
-		switch event.Type {
-		case protocol.EVENT_CLIENT_DISCONNECT:
-			service.disconnect(event.Peer)
-		case protocol.EVENT_CLIENT_PACKET:
-			if err := service.handlePacket(event.Peer, event.PktID, protocol.NewPacket(event.Pkt)); err != nil {
-				log.Printf("Error handling packet: %v", err)
-				event.Peer.Kill()
-			}
-
-			// the packet buffer is given to us by the event, so we'll need to make sure to return it to the pool
-			protocol.PutBuffer(event.Pkt)
-		}
-	}
-}
-
-func (service *Service) handlePacket(peer *protocol.CNPeer, typeID uint32, pkt protocol.Packet) error {
-	uData, _ := service.peers.Load(peer)
-	if hndlr, ok := service.packetHandlers[typeID]; ok {
-		if err := hndlr(peer, uData, pkt); err != nil {
-			return err
-		}
-	} else {
-		log.Printf("[WARN] unknown packet ID: %x\n", typeID)
-	}
-
-	return nil
-}
-
-func (service *Service) disconnect(peer *protocol.CNPeer) {
-	if service.OnDisconnect != nil {
-		uData, _ := service.peers.Load(peer)
-		service.OnDisconnect(peer, uData)
-	}
-
-	log.Printf("Peer %p disconnected from %s\n", peer, service.Name)
-	service.peers.Delete(peer)
-}
-
-func (service *Service) connect(peer *protocol.CNPeer) {
-	// default uData to nil, but if the service has an OnConnect
-	// handler, use the result from that
-	uData := interface{}(nil)
-	if service.OnConnect != nil {
-		uData = service.OnConnect(peer)
-	}
-
-	log.Printf("New peer %p connected to %s\n", peer, service.Name)
-	service.peers.Store(peer, uData)
-	go peer.Handler()
-}
-
-func (service *Service) SetPeerData(peer *protocol.CNPeer, uData interface{}) {
-	service.peers.Store(peer, uData)
-}
-
-func (service *Service) RangePeers(f func(peer *protocol.CNPeer, uData interface{}) bool) {
-	service.peers.Range(func(key, value any) bool {
-		return f(key.(*protocol.CNPeer), value)
-	})
-}

login/login.go

@@ -25,6 +25,8 @@ const (
 )
 
 func (server *LoginServer) AcceptLogin(peer *protocol.CNPeer, SzID string, IClientVerC int32, ISlotNum int8, data []protocol.SP_LS2CL_REP_CHAR_INFO) error {
+	peer.SzID = SzID
+
 	resp := protocol.SP_LS2CL_REP_LOGIN_SUCC{
 		SzID:          SzID,
 		ICharCount:    int8(len(data)),
@@ -60,7 +62,7 @@ func (server *LoginServer) AcceptLogin(peer *protocol.CNPeer, SzID string, IClie
 	return nil
 }
 
-func (server *LoginServer) Login(peer *protocol.CNPeer, _account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) Login(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var loginPkt protocol.SP_CL2LS_REQ_LOGIN
 	pkt.Decode(&loginPkt)
 
@@ -72,9 +74,9 @@ func (server *LoginServer) Login(peer *protocol.CNPeer, _account interface{}, pk
 	}
 
 	// client is resending a login packet??
-	if _account != nil {
+	if peer.AccountID != -1 {
 		SendError(LOGIN_ERROR)
-		return fmt.Errorf("out of order P_CL2LS_REQ_LOGIN: %v", _account)
+		return fmt.Errorf("out of order P_CL2LS_REQ_LOGIN")
 	}
 
 	// attempt login
@@ -97,7 +99,7 @@ func (server *LoginServer) Login(peer *protocol.CNPeer, _account interface{}, pk
 	}
 
 	// grab player data
-	server.service.SetPeerData(peer, account)
+	peer.AccountID = account.AccountID
 	plrs, err := server.dbHndlr.GetPlayers(account.AccountID)
 	if err != nil {
 		SendError(LOGIN_DATABASE_ERROR)
@@ -136,7 +138,7 @@ func (server *LoginServer) Login(peer *protocol.CNPeer, _account interface{}, pk
 	return server.AcceptLogin(peer, loginPkt.SzID, loginPkt.IClientVerC, 1, charInfo[:len(plrs)])
 }
 
-func (server *LoginServer) CheckCharacterName(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) CheckCharacterName(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHECK_CHAR_NAME
 	pkt.Decode(&charPkt)
 
@@ -147,17 +149,17 @@ func (server *LoginServer) CheckCharacterName(peer *protocol.CNPeer, account int
 	})
 }
 
-func (server *LoginServer) SaveCharacterName(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) SaveCharacterName(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_NAME
 	pkt.Decode(&charPkt)
 
-	if account == nil {
+	if peer.AccountID == -1 {
 		peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{})
 		return fmt.Errorf("out of order P_LS2CL_REP_SAVE_CHAR_NAME_FAIL")
 	}
 
 	// TODO: sanity check SzFirstName && SzLastName
-	PlayerID, err := server.dbHndlr.NewPlayer(account.(*db.Account).AccountID, charPkt.SzFirstName, charPkt.SzLastName, int(charPkt.ISlotNum))
+	PlayerID, err := server.dbHndlr.NewPlayer(peer.AccountID, charPkt.SzFirstName, charPkt.SzLastName, int(charPkt.ISlotNum))
 	if err != nil {
 		peer.Send(protocol.P_LS2CL_REP_SAVE_CHAR_NAME_FAIL, protocol.SP_LS2CL_REP_SAVE_CHAR_NAME_FAIL{})
 		return err
@@ -209,20 +211,16 @@ func SendFail(peer *protocol.CNPeer) error {
 	return nil
 }
 
-func (server *LoginServer) CharacterCreate(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) CharacterCreate(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHAR_CREATE
 	pkt.Decode(&charPkt)
 
-	if account == nil {
-		return SendFail(peer)
-	}
-
 	if !validateCharacterCreation(&charPkt) {
 		log.Printf("Invalid character creation packet: %+v", charPkt)
 		return SendFail(peer)
 	}
 
-	if err := server.dbHndlr.FinishPlayer(&charPkt, account.(*db.Account).AccountID); err != nil {
+	if err := server.dbHndlr.FinishPlayer(&charPkt, peer.AccountID); err != nil {
 		log.Printf("Error finishing player: %v", err)
 		return SendFail(peer)
 	}
@@ -241,15 +239,11 @@ func (server *LoginServer) CharacterCreate(peer *protocol.CNPeer, account interf
 	})
 }
 
-func (server *LoginServer) CharacterDelete(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) CharacterDelete(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_CHAR_DELETE
 	pkt.Decode(&charPkt)
 
-	if account == nil {
+	slot, err := server.dbHndlr.DeletePlayer(int(charPkt.IPC_UID), peer.AccountID)
-		return SendFail(peer)
-	}
-
-	slot, err := server.dbHndlr.DeletePlayer(int(charPkt.IPC_UID), account.(*db.Account).AccountID)
 	if err != nil {
 		return SendFail(peer)
 	}
@@ -259,14 +253,10 @@ func (server *LoginServer) CharacterDelete(peer *protocol.CNPeer, account interf
 	})
 }
 
-func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var selection protocol.SP_CL2LS_REQ_CHAR_SELECT
 	pkt.Decode(&selection)
 
-	if account == nil {
-		return SendFail(peer)
-	}
-
 	shards := server.redisHndlr.GetShards()
 	if len(shards) == 0 {
 		SendFail(peer)
@@ -288,10 +278,9 @@ func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, account interface{
 		log.Printf("Error getting player: %v", err)
 		return SendFail(peer)
 	}
-	accountID := account.(*db.Account).AccountID
 
-	if plr.AccountID != accountID {
+	if plr.AccountID != peer.AccountID {
-		log.Printf("HACK: player %d tried to join shard as player %d", accountID, plr.AccountID)
+		log.Printf("HACK: player %d tried to join shard as player %d", peer.AccountID, plr.AccountID)
 		return SendFail(peer)
 	}
 
@@ -299,7 +288,7 @@ func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, account interface{
 	server.redisHndlr.QueueLogin(key, redis.LoginMetadata{
 		FEKey:     peer.FE_key,
 		PlayerID:  int32(selection.IPC_UID),
-		AccountID: accountID,
+		AccountID: peer.AccountID,
 	})
 
 	// craft response
@@ -314,15 +303,11 @@ func (server *LoginServer) ShardSelect(peer *protocol.CNPeer, account interface{
 	return peer.Send(protocol.P_LS2CL_REP_SHARD_SELECT_SUCC, resp)
 }
 
-func (server *LoginServer) FinishTutorial(peer *protocol.CNPeer, account interface{}, pkt protocol.Packet) error {
+func (server *LoginServer) FinishTutorial(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var charPkt protocol.SP_CL2LS_REQ_SAVE_CHAR_TUTOR
 	pkt.Decode(&charPkt)
 
-	if account == nil {
+	if err := server.dbHndlr.FinishTutorial(int(charPkt.IPC_UID), peer.AccountID); err != nil {
-		return SendFail(peer)
-	}
-
-	if err := server.dbHndlr.FinishTutorial(int(charPkt.IPC_UID), account.(*db.Account).AccountID); err != nil {
 		return SendFail(peer)
 	}
 

login/loginserver.go

@@ -1,52 +1,126 @@
 package login
 
 import (
+	"fmt"
+	"log"
+	"net"
+	"sync"
+
+	"github.com/CPunch/gopenfusion/config"
 	"github.com/CPunch/gopenfusion/internal/db"
 	"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
+
+func stubbedPacket(_ *protocol.CNPeer, _ protocol.Packet) error { /* stubbed */ return nil }
+
 type LoginServer struct {
-	service    *service.Service
+	listener       net.Listener
+	port           int
 	dbHndlr        *db.DBHandler
 	redisHndlr     *redis.RedisHandler
+	eRecv          chan *protocol.Event
+	peers          map[*protocol.CNPeer]bool
+	packetHandlers map[uint32]PacketHandler
+	peerLock       sync.Mutex
 }
 
 func NewLoginServer(dbHndlr *db.DBHandler, redisHndlr *redis.RedisHandler, port int) (*LoginServer, error) {
-	srvc, err := service.NewService("LOGIN", port)
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
 	if err != nil {
 		return nil, err
 	}
 
 	server := &LoginServer{
-		service:    srvc,
+		listener:   listener,
+		port:       port,
 		dbHndlr:    dbHndlr,
 		redisHndlr: redisHndlr,
+		peers:      make(map[*protocol.CNPeer]bool),
+		eRecv:      make(chan *protocol.Event),
 	}
 
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_LOGIN, server.Login)
+	server.packetHandlers = map[uint32]PacketHandler{
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHECK_CHAR_NAME, server.CheckCharacterName)
+		protocol.P_CL2LS_REQ_LOGIN:             server.Login,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SAVE_CHAR_NAME, server.SaveCharacterName)
+		protocol.P_CL2LS_REQ_CHECK_CHAR_NAME:   server.CheckCharacterName,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHAR_CREATE, server.CharacterCreate)
+		protocol.P_CL2LS_REQ_SAVE_CHAR_NAME:    server.SaveCharacterName,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHAR_SELECT, server.ShardSelect)
+		protocol.P_CL2LS_REQ_CHAR_CREATE:       server.CharacterCreate,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHAR_DELETE, server.CharacterDelete)
+		protocol.P_CL2LS_REQ_CHAR_SELECT:       server.ShardSelect,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SHARD_SELECT, service.StubbedPacket)
+		protocol.P_CL2LS_REQ_CHAR_DELETE:       server.CharacterDelete,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SHARD_LIST_INFO, service.StubbedPacket)
+		protocol.P_CL2LS_REQ_SHARD_SELECT:      stubbedPacket,
-	srvc.AddPacketHandler(protocol.P_CL2LS_CHECK_NAME_LIST, service.StubbedPacket)
+		protocol.P_CL2LS_REQ_SHARD_LIST_INFO:   stubbedPacket,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SAVE_CHAR_TUTOR, server.FinishTutorial)
+		protocol.P_CL2LS_CHECK_NAME_LIST:       stubbedPacket,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_PC_EXIT_DUPLICATE, service.StubbedPacket)
+		protocol.P_CL2LS_REQ_SAVE_CHAR_TUTOR:   server.FinishTutorial,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REP_LIVE_CHECK, service.StubbedPacket)
+		protocol.P_CL2LS_REQ_PC_EXIT_DUPLICATE: stubbedPacket,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_CHANGE_CHAR_NAME, service.StubbedPacket)
+		protocol.P_CL2LS_REP_LIVE_CHECK:        stubbedPacket,
-	srvc.AddPacketHandler(protocol.P_CL2LS_REQ_SERVER_SELECT, service.StubbedPacket)
+		protocol.P_CL2LS_REQ_CHANGE_CHAR_NAME:  stubbedPacket,
-
+		protocol.P_CL2LS_REQ_SERVER_SELECT:     stubbedPacket,
-	srvc.OnConnect = func(peer *protocol.CNPeer) interface{} {
-		return nil
 	}
 
 	return server, nil
 }
 
 func (server *LoginServer) Start() {
-	server.service.Start()
+	log.Printf("Login 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 *LoginServer) 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 {
+				log.Printf("Error handling packet: %v", err)
+				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 *LoginServer) 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)
+	}
+
+	return nil
+}
+
+func (server *LoginServer) disconnect(peer *protocol.CNPeer) {
+	server.peerLock.Lock()
+	defer server.peerLock.Unlock()
+
+	log.Printf("Peer %p disconnected from LOGIN\n", peer)
+	delete(server.peers, peer)
+}
+
+func (server *LoginServer) connect(peer *protocol.CNPeer) {
+	server.peerLock.Lock()
+	defer server.peerLock.Unlock()
+
+	log.Printf("New peer %p connected to LOGIN\n", peer)
+	server.peers[peer] = true
 }

shard/chat.go

@@ -1,20 +1,16 @@
 package shard
 
-import (
+import "github.com/CPunch/gopenfusion/internal/protocol"
-	"fmt"
 
-	"github.com/CPunch/gopenfusion/internal/entity"
+func (server *ShardServer) freeChat(peer *protocol.CNPeer, pkt protocol.Packet) error {
-	"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)
 
-	if _plr == nil {
+	// sanity check
-		return fmt.Errorf("freeChat: _plr is nil")
+	plr, err := server.getPlayer(peer)
+	if err != nil {
+		return err
 	}
-	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{
@@ -24,14 +20,15 @@ func (server *ShardServer) freeChat(peer *protocol.CNPeer, _plr interface{}, pkt
 	})
 }
 
-func (server *ShardServer) menuChat(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
+func (server *ShardServer) menuChat(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var chat protocol.SP_CL2FE_REQ_SEND_MENUCHAT_MESSAGE
 	pkt.Decode(&chat)
 
-	if _plr == nil {
+	// sanity check
-		return fmt.Errorf("menuChat: _plr is nil")
+	plr, err := server.getPlayer(peer)
+	if err != nil {
+		return err
 	}
-	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{
@@ -41,14 +38,15 @@ func (server *ShardServer) menuChat(peer *protocol.CNPeer, _plr interface{}, pkt
 	})
 }
 
-func (server *ShardServer) emoteChat(peer *protocol.CNPeer, _plr interface{}, pkt protocol.Packet) error {
+func (server *ShardServer) emoteChat(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var chat protocol.SP_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT
 	pkt.Decode(&chat)
 
-	if _plr == nil {
+	// sanity check
-		return fmt.Errorf("emoteChat: _plr is nil")
+	plr, err := server.getPlayer(peer)
+	if err != nil {
+		return err
 	}
-	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,29 +10,27 @@ import (
 )
 
 func (server *ShardServer) attachPlayer(peer *protocol.CNPeer, meta redis.LoginMetadata) (*entity.Player, error) {
-	dbPlr, err := server.dbHndlr.GetPlayer(int(meta.PlayerID))
+	// 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))
 	if err != nil {
 		return nil, err
 	}
-	plr := entity.NewPlayer(peer, dbPlr)
+	plr.Peer = peer
 
-	// once we create the player, it's memory address is owned by the
+	server.setPlayer(peer, plr)
-	// 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, _plr interface{}, pkt protocol.Packet) error {
+func (server *ShardServer) RequestEnter(peer *protocol.CNPeer, 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 :(
@@ -54,35 +52,29 @@ func (server *ShardServer) RequestEnter(peer *protocol.CNPeer, _plr interface{},
 	// 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, _plr interface{}, pkt protocol.Packet) error {
+func (server *ShardServer) LoadingComplete(peer *protocol.CNPeer, pkt protocol.Packet) error {
 	var loadComplete protocol.SP_CL2FE_REQ_PC_LOADING_COMPLETE
 	pkt.Decode(&loadComplete)
 
-	// was the peer attached to a player?
+	plr, err := server.getPlayer(peer)
-	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
 	}
 
-	// we send the chunk updates (PC_NEW, NPC_NEW, etc.) after the enter packet
+	return peer.Send(protocol.P_FE2CL_REP_PC_LOADING_COMPLETE_SUCC, protocol.SP_FE2CL_REP_PC_LOADING_COMPLETE_SUCC{IPC_ID: int32(plr.PlayerID)})
-	chunkPos := entity.MakeChunkPosition(plr.X, plr.Y)
-	viewableChunks := server.getViewableChunks(chunkPos)
-	plr.SetChunkPos(chunkPos)
-	server.addEntityToChunks(plr, viewableChunks)
-	return nil
 }

shard/movement.go

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

shard/shardserver.go

@@ -1,47 +1,60 @@
 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 {
-	service    *service.Service
+	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
 }
 
 func NewShardServer(dbHndlr *db.DBHandler, redisHndlr *redis.RedisHandler, port int) (*ShardServer, error) {
-	srvc, err := service.NewService("SHARD", port)
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
 	if err != nil {
 		return nil, err
 	}
 
 	server := &ShardServer{
-		service:    srvc,
+		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),
 	}
 
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_ENTER, server.RequestEnter)
+	server.packetHandlers = map[uint32]PacketHandler{
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_LOADING_COMPLETE, server.LoadingComplete)
+		protocol.P_CL2FE_REQ_PC_ENTER:              server.RequestEnter,
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_MOVE, server.playerMove)
+		protocol.P_CL2FE_REQ_PC_LOADING_COMPLETE:   server.LoadingComplete,
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_STOP, server.playerStop)
+		protocol.P_CL2FE_REQ_PC_MOVE:               server.playerMove,
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_JUMP, server.playerJump)
+		protocol.P_CL2FE_REQ_PC_STOP:               server.playerStop,
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_SEND_FREECHAT_MESSAGE, server.freeChat)
+		protocol.P_CL2FE_REQ_PC_JUMP:               server.playerJump,
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE, server.menuChat)
+		protocol.P_CL2FE_REQ_SEND_FREECHAT_MESSAGE: server.freeChat,
-	srvc.AddPacketHandler(protocol.P_CL2FE_REQ_PC_AVATAR_EMOTES_CHAT, server.emoteChat)
+		protocol.P_CL2FE_REQ_SEND_MENUCHAT_MESSAGE: server.menuChat,
-
+		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(),
@@ -51,18 +64,97 @@ func NewShardServer(dbHndlr *db.DBHandler, redisHndlr *redis.RedisHandler, port
 	return server, nil
 }
 
-func (server *ShardServer) Start() {
+func (server *ShardServer) handleEvents() {
-	server.LoadNPCs()
+	for event := range server.eRecv {
-	server.service.Start()
+		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()
+			}
 
-func (server *ShardServer) onDisconnect(peer *protocol.CNPeer, _plr interface{}) {
+			// the packet is given to us by the event, so we'll need to make sure to return it to the pool
-	// remove from chunks
+			pool.Put(event.Pkt)
-	if _plr != nil {
+		}
-		server.removeEntity(_plr.(*entity.Player))
 	}
 }
 
-func (server *ShardServer) onConnect(peer *protocol.CNPeer) interface{} {
+func (server *ShardServer) Start() {
+	server.LoadNPCs()
+
+	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) 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)
+	}
+
 	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
+		}
+	}
+}