import (
"errors"
- "github.com/anon55555/mt"
"github.com/dragonfireclient/hydra-dragonfire/convert"
+ "github.com/dragonfireclient/mt"
"github.com/yuin/gopher-lua"
"net"
"sync"
}
type Client struct {
- mu sync.Mutex
address string
state clientState
conn mt.Peer
+ muConn sync.Mutex
queue chan Event
components map[string]Component
+ muComp sync.Mutex
table *lua.LTable
userdata *lua.LUserData
}
}
func (client *Client) closeConn() {
- client.mu.Lock()
- defer client.mu.Unlock()
+ client.muConn.Lock()
+ defer client.muConn.Unlock()
if client.state == csConnected {
client.conn.Close()
pkt, err := client.conn.Recv()
if err == nil {
- client.mu.Lock()
- for _, component := range client.components {
- component.process(&pkt)
+ client.muComp.Lock()
+ for _, comp := range client.components {
+ comp.process(&pkt)
}
- client.mu.Unlock()
+ client.muComp.Unlock()
} else if errors.Is(err, net.ErrClosed) {
client.queue <- EventDisconnect{client: client}
return
}
}()
- client.mu.Lock()
- for _, component := range client.components {
- component.connect()
+ client.muComp.Lock()
+ for _, comp := range client.components {
+ comp.connect()
}
- client.mu.Unlock()
+ client.muComp.Unlock()
return 0
}
client := getClient(l)
n := l.GetTop()
- client.mu.Lock()
- defer client.mu.Unlock()
+ client.muComp.Lock()
+ defer client.muComp.Unlock()
for i := 2; i <= n; i++ {
- compname := l.CheckString(i)
+ name := l.CheckString(i)
- if component, exists := client.components[compname]; !exists {
- switch compname {
+ if comp, exists := client.components[name]; !exists {
+ switch name {
case "auth":
- component = &Auth{}
+ comp = &CompAuth{}
case "map":
- component = &Map{}
+ comp = &CompMap{}
case "pkts":
- component = &Pkts{}
+ comp = &CompPkts{}
default:
- panic("invalid component: " + compname)
+ panic("invalid component: " + name)
}
- client.components[compname] = component
- component.create(client, l)
+ client.components[name] = comp
+ comp.create(client, l)
}
}
func l_client_send(l *lua.LState) int {
client := getClient(l)
+ client.muConn.Lock()
+ defer client.muConn.Unlock()
+
if client.state != csConnected {
panic("not connected")
}
cmd := convert.ReadCmd(l)
doAck := l.ToBool(4)
- client.mu.Lock()
- defer client.mu.Unlock()
-
if client.state == csConnected {
ack, err := client.conn.SendCmd(cmd)
if err != nil && !errors.Is(err, net.ErrClosed) {