This repository has been archived on 2026-11-20. You can view files and clone it, but you cannot make any changes to its state, such as pushing and creating new issues, pull requests or comments.
Matrixmc/minecraft.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,
)
}
}
}