335 lines
6.2 KiB
Go
335 lines
6.2 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/json"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"regexp"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
"unicode"
|
|
|
|
mcrcon "github.com/Kelwing/mc-rcon"
|
|
)
|
|
|
|
func dialRCON(addr, password string) (*mcrcon.MCConn, error) {
|
|
conn := new(mcrcon.MCConn)
|
|
|
|
if err := conn.Open(addr, password); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := conn.Authenticate(); err != nil {
|
|
conn.Close()
|
|
return nil, err
|
|
}
|
|
|
|
return conn, nil
|
|
}
|
|
|
|
func NewMinecraft(addr, password string) (*Minecraft, error) {
|
|
conn, err := dialRCON(addr, password)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Minecraft{RCON: conn, addr: addr, password: password}, nil
|
|
}
|
|
|
|
const (
|
|
maxNickLen = 32
|
|
maxMsgLen = 256
|
|
)
|
|
|
|
func sanitize(s string, max int) string {
|
|
s = strings.ToValidUTF8(s, "")
|
|
var b strings.Builder
|
|
n := 0
|
|
for _, r := range s {
|
|
if r == '\n' || r == '\r' || r == '\t' {
|
|
r = ' '
|
|
}
|
|
if r == '\u00a7' || unicode.IsControl(r) || unicode.Is(unicode.Cf, r) {
|
|
continue
|
|
}
|
|
if n >= max {
|
|
b.WriteString("…")
|
|
break
|
|
}
|
|
b.WriteRune(r)
|
|
n++
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
func (mc *Minecraft) SendMessage(nick, msg string) error {
|
|
components := []map[string]any{
|
|
{"text": "", "color": "dark_gray"},
|
|
{"text": sanitize(nick, maxNickLen), "color": "aqua", "bold": true},
|
|
{"text": ": ", "color": "gray"},
|
|
{"text": sanitize(msg, maxMsgLen), "color": "white"},
|
|
}
|
|
j, err := json.Marshal(components)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = mc.SendCommand("tellraw @a " + string(j))
|
|
|
|
return err
|
|
}
|
|
|
|
var playerNameRE = regexp.MustCompile(`^[A-Za-z0-9_]{1,16}$`)
|
|
|
|
var onlineRE = regexp.MustCompile(`players online: ?(.*)$`)
|
|
|
|
type PlayerSet struct {
|
|
mu sync.Mutex
|
|
m map[string]struct{}
|
|
}
|
|
|
|
func NewPlayerSet() *PlayerSet { return &PlayerSet{m: map[string]struct{}{}} }
|
|
|
|
func (p *PlayerSet) Add(n string) { p.mu.Lock(); p.m[n] = struct{}{}; p.mu.Unlock() }
|
|
func (p *PlayerSet) Remove(n string) { p.mu.Lock(); delete(p.m, n); p.mu.Unlock() }
|
|
func (p *PlayerSet) Has(n string) bool {
|
|
p.mu.Lock()
|
|
defer p.mu.Unlock()
|
|
_, ok := p.m[n]
|
|
return ok
|
|
}
|
|
|
|
func (p *PlayerSet) Seed(listOutput string) {
|
|
m := onlineRE.FindStringSubmatch(listOutput)
|
|
if m == nil {
|
|
return
|
|
}
|
|
for _, n := range strings.Split(m[1], ",") {
|
|
if n = strings.TrimSpace(n); playerNameRE.MatchString(n) {
|
|
p.Add(n)
|
|
}
|
|
}
|
|
}
|
|
|
|
func ParseLogLine(line string) (*MCEvent, bool) {
|
|
now := time.Now()
|
|
|
|
if m := chatRE.FindStringSubmatch(line); m != nil {
|
|
return &MCEvent{
|
|
Type: ChatEvent,
|
|
Player: m[1],
|
|
Message: m[2],
|
|
RawLine: line,
|
|
Time: now,
|
|
}, true
|
|
}
|
|
|
|
if m := joinRE.FindStringSubmatch(line); m != nil {
|
|
return &MCEvent{
|
|
Type: JoinEvent,
|
|
Player: m[1],
|
|
RawLine: line,
|
|
Time: now,
|
|
}, true
|
|
}
|
|
|
|
if m := leaveRE.FindStringSubmatch(line); m != nil {
|
|
return &MCEvent{
|
|
Type: LeaveEvent,
|
|
Player: m[1],
|
|
RawLine: line,
|
|
Time: now,
|
|
}, true
|
|
}
|
|
|
|
if m := advancementRE.FindStringSubmatch(line); m != nil {
|
|
return &MCEvent{
|
|
Type: AdvancementEvent,
|
|
Player: m[1],
|
|
Message: m[2],
|
|
RawLine: line,
|
|
Time: now,
|
|
}, true
|
|
}
|
|
if m := pauseRE.FindStringSubmatch(line); m != nil {
|
|
return &MCEvent{
|
|
Type: PauseEvent,
|
|
Message: m[1],
|
|
RawLine: line,
|
|
Time: now,
|
|
}, true
|
|
}
|
|
|
|
if m := deathRE.FindStringSubmatch(line); m != nil {
|
|
msg := m[1]
|
|
|
|
deaths := []string{
|
|
" was slain by ",
|
|
" was shot by ",
|
|
" was blown up",
|
|
" was doomed to ",
|
|
" drowned",
|
|
" died",
|
|
" blew up",
|
|
" burned to death",
|
|
" fell from",
|
|
" hit the ground too hard",
|
|
" was killed by ",
|
|
}
|
|
|
|
for _, d := range deaths {
|
|
if strings.Contains(msg, d) {
|
|
|
|
player := strings.Fields(msg)[0]
|
|
if !playerNameRE.MatchString(player) {
|
|
return nil, false
|
|
}
|
|
|
|
return &MCEvent{
|
|
Type: DeathEvent,
|
|
Player: player,
|
|
Message: msg,
|
|
RawLine: line,
|
|
Time: now,
|
|
}, true
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil, false
|
|
}
|
|
|
|
const maxLogLine = 64 << 10
|
|
|
|
func WatchLog(path string, events chan<- *MCEvent) error {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { f.Close() }()
|
|
|
|
info, err := f.Stat()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err = f.Seek(0, io.SeekEnd); err != nil {
|
|
return err
|
|
}
|
|
|
|
var (
|
|
reader = bufio.NewReaderSize(f, 32<<10)
|
|
pending []byte
|
|
overflow bool
|
|
offset = info.Size()
|
|
)
|
|
|
|
for {
|
|
chunk, err := reader.ReadSlice('\n')
|
|
offset += int64(len(chunk))
|
|
|
|
if !overflow {
|
|
pending = append(pending, chunk...)
|
|
if len(pending) > maxLogLine {
|
|
pending, overflow = nil, true
|
|
}
|
|
}
|
|
|
|
if err == bufio.ErrBufferFull {
|
|
continue
|
|
}
|
|
|
|
if err == nil {
|
|
if !overflow {
|
|
line := strings.TrimSpace(string(pending))
|
|
if event, ok := ParseLogLine(line); ok {
|
|
events <- event
|
|
}
|
|
}
|
|
pending, overflow = pending[:0], false
|
|
continue
|
|
}
|
|
|
|
if err != io.EOF {
|
|
return err
|
|
}
|
|
|
|
if cur, statErr := os.Stat(path); statErr == nil {
|
|
if !os.SameFile(info, cur) || cur.Size() < offset {
|
|
log.Printf("%s rotated or truncated, reopening", path)
|
|
|
|
nf, openErr := os.Open(path)
|
|
if openErr != nil {
|
|
return openErr
|
|
}
|
|
f.Close()
|
|
f = nf
|
|
info, err = f.Stat()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reader.Reset(f)
|
|
pending, overflow, offset = nil, false, 0
|
|
}
|
|
}
|
|
|
|
time.Sleep(250 * time.Millisecond)
|
|
}
|
|
}
|
|
func (b *Bridge) RunMCEvents() {
|
|
for ev := range b.Events {
|
|
|
|
switch ev.Type {
|
|
|
|
case ChatEvent:
|
|
b.Players.Add(ev.Player)
|
|
if b.Usepmp {
|
|
b.SendMessageWithpmp(b.RoomID, ev.Player, sanitize(ev.Message, 1024))
|
|
} else {
|
|
b._SendMatrix(
|
|
"%s: %s",
|
|
sanitize(ev.Player, 64),
|
|
sanitize(ev.Message, 1024),
|
|
)
|
|
}
|
|
//b.SendMatrix(sanitize(ev.Player, 64), "%s", sanitize(ev.Message, 1024))
|
|
case JoinEvent:
|
|
b.Players.Add(ev.Player)
|
|
b._SendMatrix(
|
|
"%s joined the game :3",
|
|
ev.Player,
|
|
)
|
|
|
|
case LeaveEvent:
|
|
b.Players.Remove(ev.Player)
|
|
b._SendMatrix(
|
|
"%s left the game :<",
|
|
ev.Player,
|
|
)
|
|
|
|
case DeathEvent:
|
|
if !b.Players.Has(ev.Player) {
|
|
continue
|
|
}
|
|
b._SendMatrix(
|
|
"%s",
|
|
sanitize(ev.Message, 512),
|
|
)
|
|
|
|
case AdvancementEvent:
|
|
b._SendMatrix(
|
|
"%s has made the advancement [%s] :3",
|
|
ev.Player,
|
|
sanitize(ev.Message, 128),
|
|
)
|
|
|
|
case PauseEvent:
|
|
b._SendMatrix(
|
|
"Server paused after %s seconds of inactivity :3",
|
|
ev.Message,
|
|
)
|
|
}
|
|
}
|
|
}
|