refactor(server): centralize room variable management and enhance logging

Moves room variable operations into the RoomManager to standardize state
access across protocols and adds comprehensive debug logging.

- Migrates global variable storage/deletion to RoomManager operations
- Adds debug logging to CL2, CL3/4, and Scratch packet handlers
- Implements JSON tags for BridgeClient to control field serialization
- Removes connection read deadlines and adds rate limit warnings
- Updates roomEvents to an unbuffered channel for synchronous processing
- Adds RoomOp stringer and centralized response logging helper

Author: MikeDev101

server/cl2.go

@@ -156,6 +156,8 @@ func (s *CL2) Handler(client *BridgeClient, p *CL2Packet) {
 		return
 	}
 
+	s.Logger.Debug().Any("packet", p).Any("client", client).Msg("Received CL2 packet")
+
 	if client.Conn != nil {
 		s.classicclientsmu.RLock()
 		active := s.ClassicClients[client]
@@ -258,9 +260,7 @@ func (s *CL2) Handler(client *BridgeClient, p *CL2Packet) {
 			}
 		case "1":
 			// Mode 1: Standard Global Variable Broadcast
-			if gv := s.GetRoomGlobalVars(DEFAULT_ROOM); gv != nil {
-				gv.Store(p.Var, p.Data)
-			}
+			s.SetRoomGlobalVar(client, DEFAULT_ROOM, p.Var, p.Data)
 			s.Broadcast(DEFAULT_ROOM, &Common_Packet{
 				Command: "gvar",
 				Name:    p.Var,

server/cl4or3.go

@@ -81,6 +81,8 @@ func (s CL4_or_CL3) Handler(client *BridgeClient, p *Common_Packet) {
 		return
 	}
 
+	s.Logger.Debug().Any("packet", p).Any("client", client).Msg("Received CL3/4 packet")
+
 	if client.Conn != nil {
 		s.classicclientsmu.RLock()
 		active := s.ClassicClients[client]
@@ -153,9 +155,7 @@ func (s CL4_or_CL3) Handler(client *BridgeClient, p *Common_Packet) {
 
 			// Store the variable dynamically across all protocols
 			if p.Command == "gvar" {
-				if gv := s.GetRoomGlobalVars(room); gv != nil {
-					gv.Store(p.Name, p.Value)
-				}
+				s.SetRoomGlobalVar(client, room, p.Name, p.Value)
 			}
 
 			s.Broadcast(room, &Common_Packet{

server/client.go

@@ -28,16 +28,10 @@ func (c *BridgeClient) Writer() {
 }
 
 func (c *BridgeClient) Reader() {
-	// 1. Set a hard limit of 64KB
+	// Set a hard limit of 64KB
 	c.Conn.SetReadLimit(64 * 1024)
-
-	// 2. Define a heartbeat/timeout interval
-	waitTimeout := 60 * time.Second
 reader:
 	for {
-		// 3. Refresh deadline; If no packets are received within 60 seconds the connection is aborted.
-		c.Conn.SetReadDeadline(time.Now().Add(waitTimeout))
-
 		if msg_type, packet, err := c.Conn.ReadMessage(); err != nil {
 			c.Server.Logger.Error().AnErr("error", err).Msg("Error reading from client")
 			c.exit <- true
@@ -68,6 +62,7 @@ reader:
 						c.exit <- true
 						break reader
 					} else {
+						c.Server.Logger.Warn().Msgf("%s ⚠️  Client exceeding rate limit...", c.GiveName())
 						// Silently drop new packets
 						continue
 					}

server/scratch.go

@@ -64,6 +64,8 @@ func (s Scratch_Handler) Handler(client *BridgeClient, p *ScratchPacket) {
 		return
 	}
 
+	s.Logger.Debug().Any("packet", p).Any("client", client).Msg("Received Scratch packet")
+
 	if client.Conn != nil {
 		s.classicclientsmu.RLock()
 		active := s.ClassicClients[client]
@@ -131,9 +133,7 @@ func (s Scratch_Handler) Handler(client *BridgeClient, p *ScratchPacket) {
 		}
 		projectRoom := client.Rooms[0]
 
-		if gv := s.GetRoomGlobalVars(projectRoom); gv != nil {
-			gv.Store(p.Name, p.Value)
-		}
+		s.SetRoomGlobalVar(client, projectRoom, p.Name, p.Value)
 
 		s.Broadcast(projectRoom, &ScratchPacket{
 			Method: p.Method,

server/server.go

@@ -52,6 +52,10 @@ func New(server_config *Config, duplex_config *duplex.Config) *Server {
 
 	self := "bridge@" + server_config.Designation
 
+	if server_config.Standalone_Mode {
+		self += "standalone"
+	}
+
 	// Create bridge manager
 	server := &Server{
 		Self:               self,
@@ -61,7 +65,7 @@ func New(server_config *Config, duplex_config *duplex.Config) *Server {
 		DeltaResolverCache: make(map[*duplex.Peer]HelloArgs),
 		Config:             server_config,
 		RoomsMap:           make(map[RoomKey]*Room),
-		roomEvents:         make(chan RoomEvent, 1024),
+		roomEvents:         make(chan RoomEvent),
 		snowflakeGen:       node,
 		App: fiber.New(fiber.Config{
 			JSONEncoder:   json.Marshal,
@@ -158,14 +162,21 @@ func (s *Server) Run() {
 	s.Done <- true
 }
 
+func (s *Server) make_response(a any, e RoomEvent) {
+	s.Logger.Debug().Any("response", a).Msg("🚪 replying")
+	e.Respond <- a
+}
+
 func (s *Server) RoomManager() {
 	for event := range s.roomEvents {
+		s.Logger.Debug().Str("opcode", event.Op.String()).Any("key", event.Key).Any("value", event.Value).Msg("🚪 processing")
+
 		switch event.Op {
 		case OpJoinRoom:
 			r, exists := s.RoomsMap[event.Room]
 			if !exists {
-				s.Logger.Info().Msgf("%s 🚪 Creating room %s", event.Client.GiveName(), event.Room)
-				r = &Room{Clients: make(Targets)}
+				s.Logger.Info().Any("client", event.Client).Any("room", event.Room).Msgf("🚪 creating")
+				r = &Room{Clients: make(Targets), GlobalVars: &sync.Map{}}
 				s.RoomsMap[event.Room] = r
 			}
 			r.Clients[event.Client] = true
@@ -174,7 +185,7 @@ func (s *Server) RoomManager() {
 				delete(r.Clients, event.Client)
 				if len(r.Clients) == 0 {
 					delete(s.RoomsMap, event.Room)
-					s.Logger.Info().Msgf("%s 🚪 Destroying vacant room %s", event.Client.GiveName(), event.Room)
+					s.Logger.Info().Any("client", event.Client).Any("room", event.Room).Msgf("🚪 destroying")
 				}
 			}
 		case OpGetClients:
@@ -185,7 +196,7 @@ func (s *Server) RoomManager() {
 					clients = append(clients, c)
 				}
 			}
-			event.Respond <- clients
+			s.make_response(clients, event)
 		case OpGetTargets:
 			var targets Targets
 			if r, exists := s.RoomsMap[event.Room]; exists {
@@ -194,12 +205,12 @@ func (s *Server) RoomManager() {
 					targets[c] = true
 				}
 			}
-			event.Respond <- targets
+			s.make_response(targets, event)
 		case OpDoesRoomExist:
 			_, exists := s.RoomsMap[event.Room]
-			event.Respond <- exists
+			s.make_response(exists, event)
 		case OpGetActiveRooms:
-			event.Respond <- len(s.RoomsMap)
+			s.make_response(len(s.RoomsMap), event)
 		case OpCanAllocateNRooms:
 			active_rooms := len(s.RoomsMap)
 			decrement := 0
@@ -208,20 +219,56 @@ func (s *Server) RoomManager() {
 					decrement = -1
 				}
 			}
-			event.Respond <- active_rooms+event.N+decrement <= int(s.Config.Maximum_Rooms)
-		case OpGetRoomForVars:
+			s.make_response(active_rooms+event.N+decrement <= int(s.Config.Maximum_Rooms), event)
+		case OpGetRoomVars:
 			if r, exists := s.RoomsMap[event.Room]; exists {
-				event.Respond <- &r.GlobalVars
+				s.make_response(r.GlobalVars, event)
 			} else {
-				event.Respond <- (*sync.Map)(nil)
+				s.make_response((*sync.Map)(nil), event)
+			}
+		case OpSetRoomVar:
+			if r, exists := s.RoomsMap[event.Room]; exists {
+
+				if _, ok := r.GlobalVars.Load(event.Key); !ok {
+					s.Logger.Info().Any("client", event.Client).Any("room", event.Room).Any("gvar", event.Key).Msgf("🚪 creating")
+				}
+
+				r.GlobalVars.Store(event.Key, event.Value)
+				s.make_response(true, event)
+			} else {
+				s.make_response(false, event)
+			}
+		case OpDeleteRoomVar:
+			if r, exists := s.RoomsMap[event.Room]; exists {
+
+				if _, ok := r.GlobalVars.Load(event.Key); !ok {
+					s.Logger.Info().Any("client", event.Client).Any("room", event.Room).Any("gvar", event.Key).Msgf("🚪 deleting")
+				}
+
+				r.GlobalVars.Delete(event.Key)
+				s.make_response(true, event)
+			} else {
+				s.make_response(false, event)
 			}
 		}
 	}
 }
 
+func (s *Server) DeleteRoomGlobalVar(room RoomKey, key any) bool {
+	resp := make(chan any, 1)
+	s.roomEvents <- RoomEvent{Op: OpDeleteRoomVar, Room: room, Key: key, Respond: resp}
+	return (<-resp).(bool)
+}
+
+func (s *Server) SetRoomGlobalVar(client *BridgeClient, room RoomKey, key any, value any) bool {
+	resp := make(chan any, 1)
+	s.roomEvents <- RoomEvent{Op: OpSetRoomVar, Client: client, Room: room, Key: key, Value: value, Respond: resp}
+	return (<-resp).(bool)
+}
+
 func (s *Server) GetRoomGlobalVars(room RoomKey) *sync.Map {
 	resp := make(chan any, 1)
-	s.roomEvents <- RoomEvent{Op: OpGetRoomForVars, Room: room, Respond: resp}
+	s.roomEvents <- RoomEvent{Op: OpGetRoomVars, Room: room, Respond: resp}
 	return (<-resp).(*sync.Map)
 }
 

server/types.go

@@ -45,7 +45,7 @@ var (
 
 type Room struct {
 	Clients    Targets
-	GlobalVars sync.Map // Protocol-agnostic global variable storage
+	GlobalVars *sync.Map // Protocol-agnostic global variable storage
 }
 
 type Targets map[*BridgeClient]bool
@@ -61,14 +61,45 @@ const (
 	OpDoesRoomExist
 	OpGetActiveRooms
 	OpCanAllocateNRooms
-	OpGetRoomForVars
+	OpGetRoomVars
+	OpSetRoomVar
+	OpDeleteRoomVar
 )
 
+func (r RoomOp) String() string {
+	switch r {
+	case OpJoinRoom:
+		return "join room"
+	case OpLeaveRoom:
+		return "leave room"
+	case OpGetClients:
+		return "get clients"
+	case OpGetTargets:
+		return "get targets"
+	case OpDoesRoomExist:
+		return "does room exist"
+	case OpGetActiveRooms:
+		return "get active rooms"
+	case OpCanAllocateNRooms:
+		return "can allocate n rooms"
+	case OpGetRoomVars:
+		return "get room vars"
+	case OpSetRoomVar:
+		return "set room var"
+	case OpDeleteRoomVar:
+		return "delete room var"
+	default:
+		return "unknown"
+	}
+}
+
 type RoomEvent struct {
 	Op      RoomOp
 	Client  *BridgeClient
 	Room    RoomKey
 	N       int
+	Key     any
+	Value   any
 	Respond chan any
 }
 
@@ -270,22 +301,22 @@ type RoomKey string
 type RoomKeys []RoomKey
 
 type BridgeClient struct {
-	Conn     *websocket.Conn
-	ID       string
-	Peer     *duplex.Peer
-	UUID     string
-	Username any
-	writer   chan []byte
-	exit     chan bool
-	Rooms    RoomKeys
-	room_mux sync.RWMutex
-	dialect  uint
-	Protocol Protocol
-	Server   *Server
+	Conn     *websocket.Conn `json:"-"`
+	ID       string          `json:"id"`
+	Peer     *duplex.Peer    `json:"-"`
+	UUID     string          `json:"uuid"`
+	Username any             `json:"username,omitempty"`
+	writer   chan []byte     `json:"-"`
+	exit     chan bool       `json:"-"`
+	Rooms    RoomKeys        `json:"rooms"`
+	room_mux sync.RWMutex    `json:"-"`
+	dialect  uint            `json:"-"`
+	Protocol Protocol        `json:"-"`
+	Server   *Server         `json:"-"`
 
 	// Rate limiting
-	last_msg_time time.Time
-	msg_count     int
+	last_msg_time time.Time `json:"-"`
+	msg_count     int       `json:"-"`
 }
 
 type Packet interface {