mirror of
https://github.com/CPunch/gopenfusion.git
synced 2024-11-14 12:00:05 +00:00
CPunch
1f66acfd25
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.
110 lines
2.4 KiB
Go
110 lines
2.4 KiB
Go
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.lock.Lock()
|
|
defer c.lock.Unlock()
|
|
|
|
c.entities[entity] = struct{}{}
|
|
}
|
|
|
|
func (c *Chunk) RemoveEntity(entity Entity) {
|
|
c.lock.Lock()
|
|
defer c.lock.Unlock()
|
|
|
|
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...)
|
|
}
|
|
|
|
// 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 {
|
|
entities[entity] = struct{}{}
|
|
}
|
|
c.lock.Unlock()
|
|
|
|
for entity := range entities {
|
|
if f(entity) {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *Chunk) SendPacketExclude(exclude Entity, typeID uint32, pkt ...interface{}) {
|
|
c.ForEachEntity(func(entity Entity) bool {
|
|
// only send to players, and exclude the player that sent the packet
|
|
if entity.GetKind() != ENTITY_KIND_PLAYER || entity == exclude {
|
|
return false
|
|
}
|
|
|
|
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()
|
|
}
|
|
|
|
return false
|
|
})
|
|
}
|
|
|
|
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
|
|
}
|