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, ) } } }