moved 'core' to 'internal'

internal/entity/chunk.go

@@ -0,0 +1,86 @@
+package entity
+
+import (
+	"log"
+	"sync"
+)
+
+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) {
+	c.Entities[entity] = struct{}{}
+}
+
+func (c *Chunk) RemoveEntity(entity Entity) {
+	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.SendPacketExclude(nil, typeID, pkt...)
+}
+
+func (c *Chunk) SendPacketExclude(exclude Entity, typeID uint32, pkt ...interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	for entity := range c.Entities {
+		// only send to players, and exclude the player that sent the packet
+		if entity.GetKind() != ENTITY_KIND_PLAYER || entity == exclude {
+			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 {
+			log.Printf("Error sending packet to peer %p: %v", peer, err)
+			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},
+	}
+}
+
+// https://stackoverflow.com/a/45428032 lol
+func ChunkSliceDifference(a, b []*Chunk) []*Chunk {
+	m := make(map[*Chunk]struct{})
+	for _, item := range b {
+		m[item] = struct{}{}
+	}
+
+	var diff []*Chunk
+	for _, item := range a {
+		if _, ok := m[item]; !ok {
+			diff = append(diff, item)
+		}
+	}
+
+	return diff
+}

internal/entity/chunkposition.go

@@ -0,0 +1,15 @@
+package entity
+
+import "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),
+	}
+}

internal/entity/entity.go

@@ -0,0 +1,25 @@
+package entity
+
+import "github.com/CPunch/gopenfusion/internal/protocol"
+
+type EntityKind int
+
+const (
+	ENTITY_KIND_PLAYER EntityKind = iota
+	ENTITY_KIND_NPC
+)
+
+type Entity interface {
+	GetKind() EntityKind
+
+	GetChunk() ChunkPosition
+	GetPosition() (x int, y int, z int)
+	GetAngle() int
+
+	SetChunk(chunk ChunkPosition)
+	SetPosition(x, y, z int)
+	SetAngle(angle int)
+
+	DisappearFromViewOf(peer *protocol.CNPeer)
+	EnterIntoViewOf(peer *protocol.CNPeer)
+}

internal/entity/npc.go

@@ -0,0 +1,87 @@
+package entity
+
+import (
+	"sync/atomic"
+
+	"github.com/CPunch/gopenfusion/internal/protocol"
+)
+
+type NPC struct {
+	ID      int
+	X       int `json:"iX"`
+	Y       int `json:"iY"`
+	Z       int `json:"iZ"`
+	Angle   int `json:"iAngle"`
+	NPCType int `json:"iNPCType"`
+	Chunk   ChunkPosition
+}
+
+var nextNPCID = &atomic.Int32{}
+
+func NewNPC(X, Y, Z, Angle int, npcType int) *NPC {
+	return &NPC{
+		ID:      int(nextNPCID.Add(1)),
+		X:       X,
+		Y:       Y,
+		Z:       Z,
+		Angle:   Angle,
+		NPCType: npcType,
+		Chunk:   MakeChunkPosition(X, Y),
+	}
+}
+
+// ==================== Entity interface ====================
+
+func (npc *NPC) GetKind() EntityKind {
+	return ENTITY_KIND_NPC
+}
+
+func (npc *NPC) GetChunk() ChunkPosition {
+	return npc.Chunk
+}
+
+func (npc *NPC) GetPosition() (x int, y int, z int) {
+	return npc.X, npc.Y, npc.Z
+}
+
+func (npc *NPC) GetAngle() int {
+	return npc.Angle
+}
+
+func (npc *NPC) SetChunk(chunk ChunkPosition) {
+	npc.Chunk = chunk
+}
+
+func (npc *NPC) SetPosition(x, y, z int) {
+	npc.X = x
+	npc.Y = y
+	npc.Z = z
+}
+
+func (npc *NPC) SetAngle(angle int) {
+	npc.Angle = angle
+}
+
+func (npc *NPC) DisappearFromViewOf(peer *protocol.CNPeer) {
+	peer.Send(protocol.P_FE2CL_NPC_EXIT, protocol.SP_FE2CL_NPC_EXIT{
+		INPC_ID: int32(npc.ID),
+	})
+}
+
+func (npc *NPC) EnterIntoViewOf(peer *protocol.CNPeer) {
+	peer.Send(protocol.P_FE2CL_NPC_NEW, protocol.SP_FE2CL_NPC_NEW{
+		NPCAppearanceData: npc.GetAppearanceData(),
+	})
+}
+
+func (npc *NPC) GetAppearanceData() protocol.SNPCAppearanceData {
+	return protocol.SNPCAppearanceData{
+		INPC_ID:  int32(npc.ID),
+		INPCType: int32(npc.NPCType),
+		IHP:      100,
+		IX:       int32(npc.X),
+		IY:       int32(npc.Y),
+		IZ:       int32(npc.Z),
+		IAngle:   int32(npc.Angle),
+	}
+}

internal/entity/player.go

@@ -0,0 +1,127 @@
+package entity
+
+import (
+	"github.com/CPunch/gopenfusion/config"
+	"github.com/CPunch/gopenfusion/internal/protocol"
+)
+
+type Player struct {
+	Peer               *protocol.CNPeer
+	Chunk              ChunkPosition
+	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
+}
+
+// ==================== Entity interface ====================
+
+func (plr *Player) GetKind() EntityKind {
+	return ENTITY_KIND_PLAYER
+}
+
+func (plr *Player) GetChunk() ChunkPosition {
+	return plr.Chunk
+}
+
+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) SetChunk(chunk ChunkPosition) {
+	plr.Chunk = chunk
+}
+
+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) DisappearFromViewOf(peer *protocol.CNPeer) {
+	peer.Send(protocol.P_FE2CL_PC_EXIT, protocol.SP_FE2CL_PC_EXIT{
+		IID: int32(plr.PlayerID),
+	})
+}
+
+func (plr *Player) EnterIntoViewOf(peer *protocol.CNPeer) {
+	peer.Send(protocol.P_FE2CL_PC_NEW, protocol.SP_FE2CL_PC_NEW{
+		PCAppearanceData: plr.GetAppearanceData(),
+	})
+}
+
+func (plr *Player) ToPCLoadData2CL() protocol.SPCLoadData2CL {
+	return protocol.SPCLoadData2CL{
+		IUserLevel:         int16(plr.AccountLevel),
+		PCStyle:            plr.PCStyle,
+		PCStyle2:           plr.PCStyle2,
+		IMentor:            int16(plr.Mentor),
+		IMentorCount:       1,
+		IHP:                int32(plr.HP),
+		IBatteryW:          int32(plr.BatteryW),
+		IBatteryN:          int32(plr.BatteryN),
+		ICandy:             int32(plr.Taros),
+		IFusionMatter:      int32(plr.FusionMatter),
+		ISpecialState:      0,
+		IMapNum:            0,
+		IX:                 int32(plr.X),
+		IY:                 int32(plr.Y),
+		IZ:                 int32(plr.Z),
+		IAngle:             int32(plr.Angle),
+		AEquip:             plr.Equip,
+		AInven:             plr.Inven,
+		ANanoSlots:         [3]int16{int16(plr.EquippedNanos[0]), int16(plr.EquippedNanos[1]), int16(plr.EquippedNanos[2])},
+		IActiveNanoSlotNum: int16(plr.ActiveNanoSlotNum),
+		IWarpLocationFlag:  int32(plr.WarpLocationFlag),
+		IBuddyWarpTime:     60,
+		IFatigue:           50,
+	}
+}
+
+func (plr *Player) GetAppearanceData() protocol.SPCAppearanceData {
+	return protocol.SPCAppearanceData{
+		IID:       int32(plr.PlayerID),
+		IHP:       int32(plr.HP),
+		ILv:       int16(plr.Level),
+		IX:        int32(plr.X),
+		IY:        int32(plr.Y),
+		IZ:        int32(plr.Z),
+		IAngle:    int32(plr.Angle),
+		PCStyle:   plr.PCStyle,
+		IPCState:  plr.IPCState,
+		ItemEquip: plr.Equip,
+		Nano:      plr.Nanos[plr.ActiveNanoSlotNum],
+	}
+}