10de5d21ad
Create chat/ package with Message type, Room (NATS pub/sub + buffer), DB persistence helpers, and a unified templ component parameterized by Config (CSS prefix, post URL, color function, key propagation). Both c4game and snakegame now use chat.Room for message management and chatcomponents.Chat for rendering, eliminating the duplicated ChatMessage types, chat templ components, chatAutoScroll scripts, color functions, and inline buffer management.
93 lines
2.4 KiB
Go
93 lines
2.4 KiB
Go
// Package chat provides a reusable chat room backed by NATS pub/sub
|
|
// with optional database persistence.
|
|
package chat
|
|
|
|
import (
|
|
"encoding/json"
|
|
"sync"
|
|
|
|
"github.com/nats-io/nats.go"
|
|
"github.com/rs/zerolog/log"
|
|
)
|
|
|
|
// Message is the wire format for chat messages over NATS.
|
|
type Message struct {
|
|
Nickname string `json:"nickname"`
|
|
Slot int `json:"slot"` // player slot/color index
|
|
Message string `json:"message"`
|
|
Time int64 `json:"time"` // unix millis, zero for ephemeral messages
|
|
}
|
|
|
|
const maxMessages = 50
|
|
|
|
// Room manages an in-memory message buffer and NATS pub/sub for a single
|
|
// chat room (typically one per game).
|
|
type Room struct {
|
|
subject string
|
|
nc *nats.Conn
|
|
messages []Message
|
|
mu sync.Mutex
|
|
}
|
|
|
|
// NewRoom creates a chat room that publishes and subscribes on the given
|
|
// NATS subject (e.g. "chat.abc123").
|
|
func NewRoom(nc *nats.Conn, subject string, initial []Message) *Room {
|
|
return &Room{
|
|
subject: subject,
|
|
nc: nc,
|
|
messages: initial,
|
|
}
|
|
}
|
|
|
|
// Send publishes a message to the room's NATS subject.
|
|
func (r *Room) Send(msg Message) {
|
|
data, err := json.Marshal(msg)
|
|
if err != nil {
|
|
log.Error().Err(err).Str("subject", r.subject).Msg("failed to marshal chat message")
|
|
return
|
|
}
|
|
if err := r.nc.Publish(r.subject, data); err != nil {
|
|
log.Error().Err(err).Str("subject", r.subject).Msg("failed to publish chat message")
|
|
}
|
|
}
|
|
|
|
// Receive processes an incoming NATS message, appending it to the buffer.
|
|
// Returns the new message and a snapshot of all messages.
|
|
func (r *Room) Receive(data []byte) (Message, []Message) {
|
|
var msg Message
|
|
if err := json.Unmarshal(data, &msg); err != nil {
|
|
return msg, nil
|
|
}
|
|
|
|
r.mu.Lock()
|
|
r.messages = append(r.messages, msg)
|
|
if len(r.messages) > maxMessages {
|
|
r.messages = r.messages[len(r.messages)-maxMessages:]
|
|
}
|
|
snapshot := make([]Message, len(r.messages))
|
|
copy(snapshot, r.messages)
|
|
r.mu.Unlock()
|
|
|
|
return msg, snapshot
|
|
}
|
|
|
|
// Messages returns a snapshot of the current message buffer.
|
|
func (r *Room) Messages() []Message {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
snapshot := make([]Message, len(r.messages))
|
|
copy(snapshot, r.messages)
|
|
return snapshot
|
|
}
|
|
|
|
// Subscribe creates a NATS channel subscription for the room's subject.
|
|
// Caller is responsible for unsubscribing.
|
|
func (r *Room) Subscribe() (chan *nats.Msg, *nats.Subscription, error) {
|
|
ch := make(chan *nats.Msg, 64)
|
|
sub, err := r.nc.ChanSubscribe(r.subject, ch)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return ch, sub, nil
|
|
}
|