god forgive me for this commit

core/db/players.go

@@ -4,7 +4,7 @@ import (
 	"database/sql"
 
 	"github.com/CPunch/gopenfusion/config"
-	"github.com/CPunch/gopenfusion/core"
+	"github.com/CPunch/gopenfusion/core/entity"
 	"github.com/CPunch/gopenfusion/core/protocol"
 	"github.com/blockloop/scan"
 )
@@ -121,8 +121,8 @@ const (
 	INNER JOIN Accounts as acc ON p.AccountID = acc.AccountID `
 )
 
-func (db *DBHandler) readPlayer(rows *sql.Rows) (*core.Player, error) {
-	plr := core.Player{ActiveNanoSlotNum: -1}
+func (db *DBHandler) readPlayer(rows *sql.Rows) (*entity.Player, error) {
+	plr := entity.Player{ActiveNanoSlotNum: -1}
 
 	if err := rows.Scan(
 		&plr.PlayerID, &plr.AccountID, &plr.Slot, &plr.PCStyle.SzFirstName, &plr.PCStyle.SzLastName,
@@ -162,13 +162,13 @@ func (db *DBHandler) readPlayer(rows *sql.Rows) (*core.Player, error) {
 	return &plr, nil
 }
 
-func (db *DBHandler) GetPlayer(PlayerID int) (*core.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 *core.Player
+	var plr *entity.Player
 	for rows.Next() {
 		plr, err = db.readPlayer(rows)
 		if err != nil {
@@ -179,13 +179,13 @@ func (db *DBHandler) GetPlayer(PlayerID int) (*core.Player, error) {
 	return plr, nil
 }
 
-func (db *DBHandler) GetPlayers(AccountID int) ([]core.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 []core.Player
+	var plrs []entity.Player
 	for rows.Next() {
 		plr, err := db.readPlayer(rows)
 		if err != nil {

core/entity/chunk.go

@@ -0,0 +1,79 @@
+package entity
+
+import (
+	"log"
+	"sync"
+
+	"github.com/CPunch/gopenfusion/config"
+)
+
+type ChunkPosition struct {
+	X int
+	Y int
+}
+
+func makeChunkPosition(x, y int) ChunkPosition {
+	return ChunkPosition{
+		X: x / (config.VIEW_DISTANCE / 3),
+		Y: y / (config.VIEW_DISTANCE / 3),
+	}
+}
+
+type Chunk struct {
+	Position ChunkPosition
+	entities map[Entity]struct{}
+	lock     sync.Mutex
+}
+
+func NewChunk(position ChunkPosition) *Chunk {
+	return &Chunk{
+		Position: position,
+		entities: make(map[Entity]struct{}),
+	}
+}
+
+func (c *Chunk) AddEntity(entity Entity) {
+	entity.SetChunk(c)
+	c.entities[entity] = struct{}{}
+}
+
+func (c *Chunk) RemoveEntity(entity Entity) {
+	entity.SetChunk(nil)
+	delete(c.entities, entity)
+}
+
+// send packet to all peers in this chunk and kill each peer if error
+func (c *Chunk) SendPacket(typeID uint32, pkt ...interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	for entity := range c.entities {
+		if entity.GetKind() != ENTITY_KIND_PLAYER {
+			continue
+		}
+
+		plr, ok := entity.(*Player)
+		if !ok {
+			log.Panic("Chunk.SendPacket: entity kind was player, but is not a *Player")
+		}
+		peer := plr.Peer
+
+		if err := peer.Send(typeID, pkt...); err != nil {
+			peer.Kill()
+		}
+	}
+}
+
+func (c *Chunk) GetAdjacentPositions() []ChunkPosition {
+	return []ChunkPosition{
+		{c.Position.X - 1, c.Position.Y - 1},
+		{c.Position.X - 1, c.Position.Y},
+		{c.Position.X - 1, c.Position.Y + 1},
+		{c.Position.X, c.Position.Y - 1},
+		{c.Position.X, c.Position.Y},
+		{c.Position.X, c.Position.Y + 1},
+		{c.Position.X + 1, c.Position.Y - 1},
+		{c.Position.X + 1, c.Position.Y},
+		{c.Position.X + 1, c.Position.Y + 1},
+	}
+}

core/entity/entity.go

@@ -0,0 +1,20 @@
+package entity
+
+type EntityKind int
+
+const (
+	ENTITY_KIND_PLAYER EntityKind = iota
+	ENTITY_KIND_NPC
+)
+
+type Entity interface {
+	GetKind() EntityKind
+
+	GetChunk() *Chunk
+	GetPosition() (x int, y int, z int)
+	GetAngle() int
+
+	SetChunk(chunk *Chunk)
+	SetPosition(x, y, z int)
+	SetAngle(angle int)
+}

core/entity/player.go

@@ -1,4 +1,4 @@
-package core
+package entity
 
 import (
 	"github.com/CPunch/gopenfusion/config"
@@ -6,6 +6,8 @@ import (
 )
 
 type Player struct {
+	Peer               *protocol.CNPeer
+	CurrentChunk       *Chunk
 	PlayerID           int
 	AccountID          int
 	AccountLevel       int
@@ -35,6 +37,38 @@ type Player struct {
 	CurrentMissionID   int
 }
 
+// ==================== Entity interface ====================
+
+func (plr *Player) GetKind() EntityKind {
+	return ENTITY_KIND_PLAYER
+}
+
+func (plr *Player) GetChunk() *Chunk {
+	return plr.CurrentChunk
+}
+
+func (plr *Player) GetPosition() (x int, y int, z int) {
+	return plr.X, plr.Y, plr.Z
+}
+
+func (plr *Player) GetAngle() int {
+	return plr.Angle
+}
+
+func (plr *Player) SetPosition(x, y, z int) {
+	plr.X = x
+	plr.Y = y
+	plr.Z = z
+}
+
+func (plr *Player) SetAngle(angle int) {
+	plr.Angle = angle
+}
+
+func (plr *Player) SetChunk(chunk *Chunk) {
+	plr.CurrentChunk = chunk
+}
+
 func (plr *Player) ToPCLoadData2CL() protocol.SPCLoadData2CL {
 	return protocol.SPCLoadData2CL{
 		IUserLevel:         int16(plr.AccountLevel),

core/protocol/cnpeer.go

@@ -15,15 +15,10 @@ const (
 	USE_FE
 )
 
-type PeerHandler interface {
-	HandlePacket(peer *CNPeer, typeID uint32, pkt Packet) error
-	Disconnect(peer *CNPeer)
-}
-
 // CNPeer is a simple wrapper for net.Conn connections to send/recv packets over the Fusionfall packet protocol.
 type CNPeer struct {
 	conn      net.Conn
-	handler   PeerHandler
+	eRecv     chan *Event
 	SzID      string
 	E_key     []byte
 	FE_key    []byte
@@ -33,10 +28,10 @@ type CNPeer struct {
 	alive     bool
 }
 
-func NewCNPeer(handler PeerHandler, conn net.Conn) *CNPeer {
+func NewCNPeer(eRecv chan *Event, conn net.Conn) *CNPeer {
 	return &CNPeer{
 		conn:      conn,
-		handler:   handler,
+		eRecv:     eRecv,
 		SzID:      "",
 		E_key:     []byte(DEFAULT_KEY),
 		FE_key:    nil,
@@ -93,13 +88,14 @@ func (peer *CNPeer) SetActiveKey(whichKey int) {
 }
 
 func (peer *CNPeer) Kill() {
+	log.Printf("Killing peer %p", peer)
 	if !peer.alive {
 		return
 	}
 
 	peer.alive = false
 	peer.conn.Close()
-	peer.handler.Disconnect(peer)
+	peer.eRecv <- &Event{Type: EVENT_CLIENT_DISCONNECT, Peer: peer}
 }
 
 // meant to be invoked as a goroutine
@@ -123,7 +119,6 @@ func (peer *CNPeer) Handler() {
 		// grab buffer && read packet body
 		if err := func() error {
 			buf := pool.Get()
-			defer pool.Put(buf)
 			if _, err := buf.ReadFrom(io.LimitReader(peer.conn, int64(sz))); err != nil {
 				return fmt.Errorf("failed to read packet body! %v", err)
 			}
@@ -132,18 +127,15 @@ func (peer *CNPeer) Handler() {
 			DecryptData(buf.Bytes(), peer.E_key)
 			pkt := NewPacket(buf)
 
-			// create packet && read typeID
-			var typeID uint32
-			if err := pkt.Decode(&typeID); err != nil {
+			// create packet && read pktID
+			var pktID uint32
+			if err := pkt.Decode(&pktID); err != nil {
 				return fmt.Errorf("failed to read packet type! %v", err)
 			}
 
 			// dispatch packet
-			log.Printf("Got packet ID: %x, with a sizeof: %d\n", typeID, sz)
-			if err := peer.handler.HandlePacket(peer, typeID, pkt); err != nil {
-				return err
-			}
-
+			log.Printf("Got packet ID: %x, with a sizeof: %d\n", pktID, sz)
+			peer.eRecv <- &Event{Type: EVENT_CLIENT_PACKET, Peer: peer, Pkt: buf, PktID: pktID}
 			return nil
 		}(); err != nil {
 			log.Printf("[FATAL] %v", err)

core/protocol/event.go

@@ -0,0 +1,15 @@
+package protocol
+
+import "bytes"
+
+const (
+	EVENT_CLIENT_DISCONNECT = iota
+	EVENT_CLIENT_PACKET
+)
+
+type Event struct {
+	Type  int
+	Peer  *CNPeer
+	Pkt   *bytes.Buffer
+	PktID uint32
+}