made it clearer when session object and server object was being used by renaming s to session and server. Split out ravi,broadcast and discord into sys_*

server/channelserver/handlers_register.go

@@ -132,8 +132,8 @@ func (s *Session) notifyRavi() {
 	}
 }
 
-func (s *Server) getRaviSemaphore() *Semaphore {
-	for _, semaphore := range s.semaphore {
+func (server *Server) getRaviSemaphore() *Semaphore {
+	for _, semaphore := range server.semaphore {
 		if strings.HasPrefix(semaphore.name, "hs_l0") && strings.HasSuffix(semaphore.name, "3") {
 			return semaphore
 		}

server/channelserver/sys_broadcast.go

@@ -0,0 +1,83 @@
+package channelserver
+
+import (
+	"erupe-ce/network/binpacket"
+	"erupe-ce/network/mhfpacket"
+	"erupe-ce/utils/byteframe"
+	ps "erupe-ce/utils/pascalstring"
+
+	"go.uber.org/zap"
+)
+
+// BroadcastMHF queues a MHFPacket to be sent to all sessions.
+func (server *Server) BroadcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session) {
+	// Broadcast the data.
+	server.Lock()
+	defer server.Unlock()
+	for _, session := range server.sessions {
+		if session == ignoredSession {
+			continue
+		}
+		session.QueueSendMHF(pkt)
+	}
+}
+
+func (server *Server) WorldcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session, ignoredChannel *Server) {
+	for _, c := range server.Channels {
+		if c == ignoredChannel {
+			continue
+		}
+		c.BroadcastMHF(pkt, ignoredSession)
+	}
+}
+
+// BroadcastChatMessage broadcasts a simple chat message to all the sessions.
+func (server *Server) BroadcastChatMessage(message string) {
+	bf := byteframe.NewByteFrame()
+	bf.SetLE()
+	msgBinChat := &binpacket.MsgBinChat{
+		Unk0:       0,
+		Type:       5,
+		Flags:      0x80,
+		Message:    message,
+		SenderName: server.name,
+	}
+	msgBinChat.Build(bf)
+
+	server.BroadcastMHF(&mhfpacket.MsgSysCastedBinary{
+		MessageType:    BinaryMessageTypeChat,
+		RawDataPayload: bf.Data(),
+	}, nil)
+}
+
+func (server *Server) BroadcastRaviente(ip uint32, port uint16, stage []byte, _type uint8) {
+	bf := byteframe.NewByteFrame()
+	bf.SetLE()
+	bf.WriteUint16(0)    // Unk
+	bf.WriteUint16(0x43) // Data len
+	bf.WriteUint16(3)    // Unk len
+	var text string
+	switch _type {
+	case 2:
+		text = server.i18n.raviente.berserk
+	case 3:
+		text = server.i18n.raviente.extreme
+	case 4:
+		text = server.i18n.raviente.extremeLimited
+	case 5:
+		text = server.i18n.raviente.berserkSmall
+	default:
+		server.logger.Error("Unk raviente type", zap.Uint8("_type", _type))
+	}
+	ps.Uint16(bf, text, true)
+	bf.WriteBytes([]byte{0x5F, 0x53, 0x00})
+	bf.WriteUint32(ip)   // IP address
+	bf.WriteUint16(port) // Port
+	bf.WriteUint16(0)    // Unk
+	bf.WriteBytes(stage)
+	server.WorldcastMHF(&mhfpacket.MsgSysCastedBinary{
+		BroadcastType:  BroadcastTypeServer,
+		MessageType:    BinaryMessageTypeChat,
+		RawDataPayload: bf.Data(),
+	}, nil, server)
+}

server/channelserver/sys_channel_server.go

@@ -3,17 +3,12 @@ package channelserver
 import (
 	"fmt"
 	"net"
-	"strings"
 	"sync"
 	"time"
 
 	_config "erupe-ce/config"
-	"erupe-ce/network/binpacket"
-	"erupe-ce/network/mhfpacket"
 	"erupe-ce/server/discordbot"
-	"erupe-ce/utils/byteframe"
 	"erupe-ce/utils/gametime"
-	ps "erupe-ce/utils/pascalstring"
 
 	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
@@ -80,74 +75,22 @@ type Server struct {
 	questCacheTime map[int]time.Time
 }
 
-type Raviente struct {
-	sync.Mutex
-	id       uint16
-	register []uint32
-	state    []uint32
-	support  []uint32
-}
-
-func (s *Server) resetRaviente() {
-	for _, semaphore := range s.semaphore {
-		if strings.HasPrefix(semaphore.name, "hs_l0") {
-			return
-		}
-	}
-	s.logger.Debug("All Raviente Semaphores empty, resetting")
-	s.raviente.id = s.raviente.id + 1
-	s.raviente.register = make([]uint32, 30)
-	s.raviente.state = make([]uint32, 30)
-	s.raviente.support = make([]uint32, 30)
-}
-
-func (s *Server) GetRaviMultiplier() float64 {
-	raviSema := s.getRaviSemaphore()
-	if raviSema != nil {
-		var minPlayers int
-		if s.raviente.register[9] > 8 {
-			minPlayers = 24
-		} else {
-			minPlayers = 4
-		}
-		if len(raviSema.clients) > minPlayers {
-			return 1
-		}
-		return float64(minPlayers / len(raviSema.clients))
-	}
-	return 0
-}
-
-func (s *Server) UpdateRavi(semaID uint32, index uint8, value uint32, update bool) (uint32, uint32) {
-	var prev uint32
-	var dest *[]uint32
-	switch semaID {
-	case 0x40000:
-		switch index {
-		case 17, 28: // Ignore res and poison
-			break
-		default:
-			value = uint32(float64(value) * s.GetRaviMultiplier())
-		}
-		dest = &s.raviente.state
-	case 0x50000:
-		dest = &s.raviente.support
-	case 0x60000:
-		dest = &s.raviente.register
-	default:
-		return 0, 0
-	}
-	if update {
-		(*dest)[index] += value
-	} else {
-		(*dest)[index] = value
-	}
-	return prev, (*dest)[index]
-}
-
 // NewServer creates a new Server type.
 func NewServer(config *Config) *Server {
-	s := &Server{
+	stageNames := []string{
+		"sl1Ns200p0a0u0", // Mezeporta
+		"sl1Ns211p0a0u0", // Rasta bar
+		"sl1Ns260p0a0u0", // Pallone Carvan
+		"sl1Ns262p0a0u0", // Pallone Guest House 1st Floor
+		"sl1Ns263p0a0u0", // Pallone Guest House 2nd Floor
+		"sl2Ns379p0a0u0", // Diva fountain
+		"sl1Ns462p0a0u0", // MezFes
+	}
+	stages := make(map[string]*Stage)
+	for _, name := range stageNames {
+		stages[name] = NewStage(name)
+	}
+	server := &Server{
 		ID:              config.ID,
 		logger:          config.Logger,
 		db:              config.DB,
@@ -156,7 +99,7 @@ func NewServer(config *Config) *Server {
 		deleteConns:     make(chan net.Conn),
 		sessions:        make(map[net.Conn]*Session),
 		objectIDs:       make(map[*Session]uint16),
-		stages:          make(map[string]*Stage),
+		stages:          stages,
 		userBinaryParts: make(map[userBinaryPartID][]byte),
 		semaphore:       make(map[string]*Semaphore),
 		semaphoreIndex:  7,
@@ -172,203 +115,94 @@ func NewServer(config *Config) *Server {
 		questCacheTime: make(map[int]time.Time),
 	}
 
-	// Mezeporta
-	s.stages["sl1Ns200p0a0u0"] = NewStage("sl1Ns200p0a0u0")
+	server.i18n = getLangStrings(server)
 
-	// Rasta bar stage
-	s.stages["sl1Ns211p0a0u0"] = NewStage("sl1Ns211p0a0u0")
-
-	// Pallone Carvan
-	s.stages["sl1Ns260p0a0u0"] = NewStage("sl1Ns260p0a0u0")
-
-	// Pallone Guest House 1st Floor
-	s.stages["sl1Ns262p0a0u0"] = NewStage("sl1Ns262p0a0u0")
-
-	// Pallone Guest House 2nd Floor
-	s.stages["sl1Ns263p0a0u0"] = NewStage("sl1Ns263p0a0u0")
-
-	// Diva fountain / prayer fountain.
-	s.stages["sl2Ns379p0a0u0"] = NewStage("sl2Ns379p0a0u0")
-
-	// MezFes
-	s.stages["sl1Ns462p0a0u0"] = NewStage("sl1Ns462p0a0u0")
-
-	s.i18n = getLangStrings(s)
-
-	return s
+	return server
 }
 
 // Start starts the server in a new goroutine.
-func (s *Server) Start() error {
-	l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.Port))
+func (server *Server) Start() error {
+	l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.Port))
 	if err != nil {
 		return err
 	}
-	s.listener = l
+	server.listener = l
 
-	go s.acceptClients()
-	go s.manageSessions()
+	go server.acceptClients()
+	go server.manageSessions()
 
 	// Start the discord bot for chat integration.
-	if s.erupeConfig.Discord.Enabled && s.discordBot != nil {
-		s.discordBot.Session.AddHandler(s.onDiscordMessage)
-		s.discordBot.Session.AddHandler(s.onInteraction)
+	if server.erupeConfig.Discord.Enabled && server.discordBot != nil {
+		server.discordBot.Session.AddHandler(server.onDiscordMessage)
+		server.discordBot.Session.AddHandler(server.onInteraction)
 	}
 
 	return nil
 }
 
 // Shutdown tries to shut down the server gracefully.
-func (s *Server) Shutdown() {
-	s.Lock()
-	s.isShuttingDown = true
-	s.Unlock()
+func (server *Server) Shutdown() {
+	server.Lock()
+	server.isShuttingDown = true
+	server.Unlock()
 
-	s.listener.Close()
+	server.listener.Close()
 
-	close(s.acceptConns)
+	close(server.acceptConns)
 }
 
-func (s *Server) acceptClients() {
+func (server *Server) acceptClients() {
 	for {
-		conn, err := s.listener.Accept()
+		conn, err := server.listener.Accept()
 		if err != nil {
-			s.Lock()
-			shutdown := s.isShuttingDown
-			s.Unlock()
+			server.Lock()
+			shutdown := server.isShuttingDown
+			server.Unlock()
 
 			if shutdown {
 				break
 			} else {
-				s.logger.Warn("Error accepting client", zap.Error(err))
+				server.logger.Warn("Error accepting client", zap.Error(err))
 				continue
 			}
 		}
-		s.acceptConns <- conn
+		server.acceptConns <- conn
 	}
 }
 
-func (s *Server) manageSessions() {
+func (server *Server) manageSessions() {
 	for {
 		select {
-		case newConn := <-s.acceptConns:
+		case newConn := <-server.acceptConns:
 			// Gracefully handle acceptConns channel closing.
 			if newConn == nil {
-				s.Lock()
-				shutdown := s.isShuttingDown
-				s.Unlock()
+				server.Lock()
+				shutdown := server.isShuttingDown
+				server.Unlock()
 
 				if shutdown {
 					return
 				}
 			}
 
-			session := NewSession(s, newConn)
+			session := NewSession(server, newConn)
 
-			s.Lock()
-			s.sessions[newConn] = session
-			s.Unlock()
+			server.Lock()
+			server.sessions[newConn] = session
+			server.Unlock()
 
 			session.Start()
 
-		case delConn := <-s.deleteConns:
-			s.Lock()
-			delete(s.sessions, delConn)
-			s.Unlock()
+		case delConn := <-server.deleteConns:
+			server.Lock()
+			delete(server.sessions, delConn)
+			server.Unlock()
 		}
 	}
 }
 
-// BroadcastMHF queues a MHFPacket to be sent to all sessions.
-func (s *Server) BroadcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session) {
-	// Broadcast the data.
-	s.Lock()
-	defer s.Unlock()
-	for _, session := range s.sessions {
-		if session == ignoredSession {
-			continue
-		}
-		session.QueueSendMHF(pkt)
-	}
-}
-
-func (s *Server) WorldcastMHF(pkt mhfpacket.MHFPacket, ignoredSession *Session, ignoredChannel *Server) {
-	for _, c := range s.Channels {
-		if c == ignoredChannel {
-			continue
-		}
-		c.BroadcastMHF(pkt, ignoredSession)
-	}
-}
-
-// BroadcastChatMessage broadcasts a simple chat message to all the sessions.
-func (s *Server) BroadcastChatMessage(message string) {
-	bf := byteframe.NewByteFrame()
-	bf.SetLE()
-	msgBinChat := &binpacket.MsgBinChat{
-		Unk0:       0,
-		Type:       5,
-		Flags:      0x80,
-		Message:    message,
-		SenderName: s.name,
-	}
-	msgBinChat.Build(bf)
-
-	s.BroadcastMHF(&mhfpacket.MsgSysCastedBinary{
-		MessageType:    BinaryMessageTypeChat,
-		RawDataPayload: bf.Data(),
-	}, nil)
-}
-
-func (s *Server) BroadcastRaviente(ip uint32, port uint16, stage []byte, _type uint8) {
-	bf := byteframe.NewByteFrame()
-	bf.SetLE()
-	bf.WriteUint16(0)    // Unk
-	bf.WriteUint16(0x43) // Data len
-	bf.WriteUint16(3)    // Unk len
-	var text string
-	switch _type {
-	case 2:
-		text = s.i18n.raviente.berserk
-	case 3:
-		text = s.i18n.raviente.extreme
-	case 4:
-		text = s.i18n.raviente.extremeLimited
-	case 5:
-		text = s.i18n.raviente.berserkSmall
-	default:
-		s.logger.Error("Unk raviente type", zap.Uint8("_type", _type))
-	}
-	ps.Uint16(bf, text, true)
-	bf.WriteBytes([]byte{0x5F, 0x53, 0x00})
-	bf.WriteUint32(ip)   // IP address
-	bf.WriteUint16(port) // Port
-	bf.WriteUint16(0)    // Unk
-	bf.WriteBytes(stage)
-	s.WorldcastMHF(&mhfpacket.MsgSysCastedBinary{
-		BroadcastType:  BroadcastTypeServer,
-		MessageType:    BinaryMessageTypeChat,
-		RawDataPayload: bf.Data(),
-	}, nil, s)
-}
-
-func (s *Server) DiscordChannelSend(charName string, content string) {
-	if s.erupeConfig.Discord.Enabled && s.discordBot != nil {
-		message := fmt.Sprintf("**%s**: %s", charName, content)
-		s.discordBot.RealtimeChannelSend(message)
-	}
-}
-
-func (s *Server) DiscordScreenShotSend(charName string, title string, description string, articleToken string) {
-	if s.erupeConfig.Discord.Enabled && s.discordBot != nil {
-		imageUrl := fmt.Sprintf("%s:%d/api/ss/bbs/%s", s.erupeConfig.Screenshots.Host, s.erupeConfig.Screenshots.Port, articleToken)
-		message := fmt.Sprintf("**%s**: %s - %s %s", charName, title, description, imageUrl)
-		s.discordBot.RealtimeChannelSend(message)
-	}
-}
-
-func (s *Server) FindSessionByCharID(charID uint32) *Session {
-	for _, c := range s.Channels {
+func (server *Server) FindSessionByCharID(charID uint32) *Session {
+	for _, c := range server.Channels {
 		for _, session := range c.sessions {
 			if session.charID == charID {
 				return session
@@ -378,15 +212,15 @@ func (s *Server) FindSessionByCharID(charID uint32) *Session {
 	return nil
 }
 
-func (s *Server) DisconnectUser(uid uint32) {
+func (server *Server) DisconnectUser(uid uint32) {
 	var cid uint32
 	var cids []uint32
-	rows, _ := s.db.Query(`SELECT id FROM characters WHERE user_id=$1`, uid)
+	rows, _ := server.db.Query(`SELECT id FROM characters WHERE user_id=$1`, uid)
 	for rows.Next() {
 		rows.Scan(&cid)
 		cids = append(cids, cid)
 	}
-	for _, c := range s.Channels {
+	for _, c := range server.Channels {
 		for _, session := range c.sessions {
 			for _, cid := range cids {
 				if session.charID == cid {
@@ -398,10 +232,10 @@ func (s *Server) DisconnectUser(uid uint32) {
 	}
 }
 
-func (s *Server) FindObjectByChar(charID uint32) *Object {
-	s.stagesLock.RLock()
-	defer s.stagesLock.RUnlock()
-	for _, stage := range s.stages {
+func (server *Server) FindObjectByChar(charID uint32) *Object {
+	server.stagesLock.RLock()
+	defer server.stagesLock.RUnlock()
+	for _, stage := range server.stages {
 		stage.RLock()
 		for objId := range stage.objects {
 			obj := stage.objects[objId]
@@ -416,8 +250,8 @@ func (s *Server) FindObjectByChar(charID uint32) *Object {
 	return nil
 }
 
-func (s *Server) HasSemaphore(ses *Session) bool {
-	for _, semaphore := range s.semaphore {
+func (server *Server) HasSemaphore(ses *Session) bool {
+	for _, semaphore := range server.semaphore {
 		if semaphore.host == ses {
 			return true
 		}
@@ -425,7 +259,7 @@ func (s *Server) HasSemaphore(ses *Session) bool {
 	return false
 }
 
-func (s *Server) Season() uint8 {
-	sid := int64(((s.ID & 0xFF00) - 4096) / 256)
+func (server *Server) Season() uint8 {
+	sid := int64(((server.ID & 0xFF00) - 4096) / 256)
 	return uint8(((gametime.TimeAdjusted().Unix() / 86400) + sid) % 3)
 }

server/channelserver/sys_discord.go

@@ -2,11 +2,12 @@ package channelserver
 
 import (
 	"fmt"
-	"github.com/bwmarrin/discordgo"
-	"golang.org/x/crypto/bcrypt"
 	"sort"
 	"strings"
 	"unicode"
+
+	"github.com/bwmarrin/discordgo"
+	"golang.org/x/crypto/bcrypt"
 )
 
 type Player struct {
@@ -14,11 +15,11 @@ type Player struct {
 	QuestID  int
 }
 
-func getPlayerSlice(s *Server) []Player {
+func getPlayerSlice(server *Server) []Player {
 	var p []Player
 	var questIndex int
 
-	for _, channel := range s.Channels {
+	for _, channel := range server.Channels {
 		for _, stage := range channel.stages {
 			if len(stage.clients) == 0 {
 				continue
@@ -39,7 +40,7 @@ func getPlayerSlice(s *Server) []Player {
 	return p
 }
 
-func getCharacterList(s *Server) string {
+func getCharacterList(server *Server) string {
 	questEmojis := []string{
 		":person_in_lotus_position:",
 		":white_circle:",
@@ -53,7 +54,7 @@ func getCharacterList(s *Server) string {
 		":black_circle:",
 	}
 
-	playerSlice := getPlayerSlice(s)
+	playerSlice := getPlayerSlice(server)
 
 	sort.SliceStable(playerSlice, func(i, j int) bool {
 		return playerSlice[i].QuestID < playerSlice[j].QuestID
@@ -68,11 +69,11 @@ func getCharacterList(s *Server) string {
 }
 
 // onInteraction handles slash commands
-func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCreate) {
+func (server *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCreate) {
 	switch i.Interaction.ApplicationCommandData().Name {
 	case "link":
 		var temp string
-		err := s.db.QueryRow(`UPDATE users SET discord_id = $1 WHERE discord_token = $2 RETURNING discord_id`, i.Member.User.ID, i.ApplicationCommandData().Options[0].StringValue()).Scan(&temp)
+		err := server.db.QueryRow(`UPDATE users SET discord_id = $1 WHERE discord_token = $2 RETURNING discord_id`, i.Member.User.ID, i.ApplicationCommandData().Options[0].StringValue()).Scan(&temp)
 		if err == nil {
 			ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,
@@ -92,7 +93,7 @@ func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCr
 		}
 	case "password":
 		password, _ := bcrypt.GenerateFromPassword([]byte(i.ApplicationCommandData().Options[0].StringValue()), 10)
-		_, err := s.db.Exec(`UPDATE users SET password = $1 WHERE discord_id = $2`, password, i.Member.User.ID)
+		_, err := server.db.Exec(`UPDATE users SET password = $1 WHERE discord_id = $2`, password, i.Member.User.ID)
 		if err == nil {
 			ds.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,
@@ -114,9 +115,9 @@ func (s *Server) onInteraction(ds *discordgo.Session, i *discordgo.InteractionCr
 }
 
 // onDiscordMessage handles receiving messages from discord and forwarding them ingame.
-func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCreate) {
+func (server *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCreate) {
 	// Ignore messages from bots, or messages that are not in the correct channel.
-	if m.Author.Bot || m.ChannelID != s.erupeConfig.Discord.RelayChannel.RelayChannelID {
+	if m.Author.Bot || m.ChannelID != server.erupeConfig.Discord.RelayChannel.RelayChannelID {
 		return
 	}
 
@@ -129,8 +130,8 @@ func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCre
 	for i := 0; i < 8-len(m.Author.Username); i++ {
 		paddedName += " "
 	}
-	message := s.discordBot.NormalizeDiscordMessage(fmt.Sprintf("[D] %s > %s", paddedName, m.Content))
-	if len(message) > s.erupeConfig.Discord.RelayChannel.MaxMessageLength {
+	message := server.discordBot.NormalizeDiscordMessage(fmt.Sprintf("[D] %s > %s", paddedName, m.Content))
+	if len(message) > server.erupeConfig.Discord.RelayChannel.MaxMessageLength {
 		return
 	}
 
@@ -144,6 +145,20 @@ func (s *Server) onDiscordMessage(ds *discordgo.Session, m *discordgo.MessageCre
 		messages = append(messages, message[i:end])
 	}
 	for i := range messages {
-		s.BroadcastChatMessage(messages[i])
+		server.BroadcastChatMessage(messages[i])
+	}
+}
+func (server *Server) DiscordChannelSend(charName string, content string) {
+	if server.erupeConfig.Discord.Enabled && server.discordBot != nil {
+		message := fmt.Sprintf("**%s**: %s", charName, content)
+		server.discordBot.RealtimeChannelSend(message)
+	}
+}
+
+func (server *Server) DiscordScreenShotSend(charName string, title string, description string, articleToken string) {
+	if server.erupeConfig.Discord.Enabled && server.discordBot != nil {
+		imageUrl := fmt.Sprintf("%s:%d/api/ss/bbs/%s", server.erupeConfig.Screenshots.Host, server.erupeConfig.Screenshots.Port, articleToken)
+		message := fmt.Sprintf("**%s**: %s - %s %s", charName, title, description, imageUrl)
+		server.discordBot.RealtimeChannelSend(message)
 	}
 }

server/channelserver/sys_language.go

@@ -101,9 +101,9 @@ type i18n struct {
 	}
 }
 
-func getLangStrings(s *Server) i18n {
+func getLangStrings(server *Server) i18n {
 	var i i18n
-	switch s.erupeConfig.Language {
+	switch server.erupeConfig.Language {
 	case "jp":
 		i.language = "日本語"
 		i.cafe.reset = "%d/%dにリセット"

server/channelserver/sys_ravi.go

@@ -0,0 +1,71 @@
+package channelserver
+
+import (
+	"strings"
+	"sync"
+)
+
+type Raviente struct {
+	sync.Mutex
+	id       uint16
+	register []uint32
+	state    []uint32
+	support  []uint32
+}
+
+func (server *Server) resetRaviente() {
+	for _, semaphore := range server.semaphore {
+		if strings.HasPrefix(semaphore.name, "hs_l0") {
+			return
+		}
+	}
+	server.logger.Debug("All Raviente Semaphores empty, resetting")
+	server.raviente.id = server.raviente.id + 1
+	server.raviente.register = make([]uint32, 30)
+	server.raviente.state = make([]uint32, 30)
+	server.raviente.support = make([]uint32, 30)
+}
+
+func (server *Server) GetRaviMultiplier() float64 {
+	raviSema := server.getRaviSemaphore()
+	if raviSema != nil {
+		var minPlayers int
+		if server.raviente.register[9] > 8 {
+			minPlayers = 24
+		} else {
+			minPlayers = 4
+		}
+		if len(raviSema.clients) > minPlayers {
+			return 1
+		}
+		return float64(minPlayers / len(raviSema.clients))
+	}
+	return 0
+}
+
+func (server *Server) UpdateRavi(semaID uint32, index uint8, value uint32, update bool) (uint32, uint32) {
+	var prev uint32
+	var dest *[]uint32
+	switch semaID {
+	case 0x40000:
+		switch index {
+		case 17, 28: // Ignore res and poison
+			break
+		default:
+			value = uint32(float64(value) * server.GetRaviMultiplier())
+		}
+		dest = &server.raviente.state
+	case 0x50000:
+		dest = &server.raviente.support
+	case 0x60000:
+		dest = &server.raviente.register
+	default:
+		return 0, 0
+	}
+	if update {
+		(*dest)[index] += value
+	} else {
+		(*dest)[index] = value
+	}
+	return prev, (*dest)[index]
+}

server/entranceserver/entrance_server.go

@@ -8,8 +8,9 @@ import (
 	"strings"
 	"sync"
 
-	"erupe-ce/config"
+	_config "erupe-ce/config"
 	"erupe-ce/network"
+
 	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
@@ -33,50 +34,50 @@ type Config struct {
 
 // NewServer creates a new Server type.
 func NewServer(config *Config) *Server {
-	s := &Server{
+	server := &Server{
 		logger:      config.Logger,
 		erupeConfig: config.ErupeConfig,
 		db:          config.DB,
 	}
-	return s
+	return server
 }
 
 // Start starts the server in a new goroutine.
-func (s *Server) Start() error {
+func (server *Server) Start() error {
 
-	l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.erupeConfig.Entrance.Port))
+	l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.erupeConfig.Entrance.Port))
 	if err != nil {
 		return err
 	}
 
-	s.listener = l
+	server.listener = l
 
-	go s.acceptClients()
+	go server.acceptClients()
 
 	return nil
 }
 
 // Shutdown exits the server gracefully.
-func (s *Server) Shutdown() {
-	s.logger.Debug("Shutting down...")
+func (server *Server) Shutdown() {
+	server.logger.Debug("Shutting down...")
 
-	s.Lock()
-	s.isShuttingDown = true
-	s.Unlock()
+	server.Lock()
+	server.isShuttingDown = true
+	server.Unlock()
 
 	// This will cause the acceptor goroutine to error and exit gracefully.
-	s.listener.Close()
+	server.listener.Close()
 }
 
 // acceptClients handles accepting new clients in a loop.
-func (s *Server) acceptClients() {
+func (server *Server) acceptClients() {
 	for {
-		conn, err := s.listener.Accept()
+		conn, err := server.listener.Accept()
 		if err != nil {
 			// Check if we are shutting down and exit gracefully if so.
-			s.Lock()
-			shutdown := s.isShuttingDown
-			s.Unlock()
+			server.Lock()
+			shutdown := server.isShuttingDown
+			server.Unlock()
 
 			if shutdown {
 				break
@@ -86,20 +87,20 @@ func (s *Server) acceptClients() {
 		}
 
 		// Start a new goroutine for the connection so that we don't block other incoming connections.
-		go s.handleEntranceServerConnection(conn)
+		go server.handleEntranceServerConnection(conn)
 	}
 }
 
-func (s *Server) handleEntranceServerConnection(conn net.Conn) {
+func (server *Server) handleEntranceServerConnection(conn net.Conn) {
 	defer conn.Close()
 	// Client initalizes the connection with a one-time buffer of 8 NULL bytes.
 	nullInit := make([]byte, 8)
 	n, err := io.ReadFull(conn, nullInit)
 	if err != nil {
-		s.logger.Warn("Failed to read 8 NULL init", zap.Error(err))
+		server.logger.Warn("Failed to read 8 NULL init", zap.Error(err))
 		return
 	} else if n != len(nullInit) {
-		s.logger.Warn("io.ReadFull couldn't read the full 8 byte init.")
+		server.logger.Warn("io.ReadFull couldn't read the full 8 byte init.")
 		return
 	}
 
@@ -107,11 +108,11 @@ func (s *Server) handleEntranceServerConnection(conn net.Conn) {
 	cc := network.NewCryptConn(conn)
 	pkt, err := cc.ReadPacket()
 	if err != nil {
-		s.logger.Warn("Error reading packet", zap.Error(err))
+		server.logger.Warn("Error reading packet", zap.Error(err))
 		return
 	}
 
-	if s.erupeConfig.DebugOptions.LogInboundMessages {
+	if server.erupeConfig.DebugOptions.LogInboundMessages {
 		fmt.Printf("[Client] -> [Server]\nData [%d bytes]:\n%s\n", len(pkt), hex.Dump(pkt))
 	}
 
@@ -119,9 +120,9 @@ func (s *Server) handleEntranceServerConnection(conn net.Conn) {
 	if strings.Split(conn.RemoteAddr().String(), ":")[0] == "127.0.0.1" {
 		local = true
 	}
-	data := makeSv2Resp(s.erupeConfig, s, local)
+	data := makeSv2Resp(server.erupeConfig, server, local)
 	if len(pkt) > 5 {
-		data = append(data, makeUsrResp(pkt, s)...)
+		data = append(data, makeUsrResp(pkt, server)...)
 	}
 	cc.SendPacket(data)
 	// Close because we only need to send the response once.

server/entranceserver/make_resp.go

@@ -12,7 +12,7 @@ import (
 	"net"
 )
 
-func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte {
+func encodeServerInfo(config *_config.Config, server *Server, local bool) []byte {
 	serverInfos := config.Entrance.Entries
 	bf := byteframe.NewByteFrame()
 
@@ -42,22 +42,22 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte {
 		bf.WriteUint16(uint16(len(si.Channels)))
 		bf.WriteUint8(si.Type)
 		bf.WriteUint8(uint8(((gametime.TimeAdjusted().Unix() / 86400) + int64(serverIdx)) % 3))
-		if s.erupeConfig.ClientID >= _config.G1 {
+		if server.erupeConfig.ClientID >= _config.G1 {
 			bf.WriteUint8(si.Recommended)
 		}
 
 		fullName := append(append(stringsupport.UTF8ToSJIS(si.Name), []byte{0x00}...), stringsupport.UTF8ToSJIS(si.Description)...)
-		if s.erupeConfig.ClientID >= _config.G1 && s.erupeConfig.ClientID <= _config.G5 {
+		if server.erupeConfig.ClientID >= _config.G1 && server.erupeConfig.ClientID <= _config.G5 {
 			bf.WriteUint8(uint8(len(fullName)))
 			bf.WriteBytes(fullName)
 		} else {
-			if s.erupeConfig.ClientID >= _config.G51 {
+			if server.erupeConfig.ClientID >= _config.G51 {
 				bf.WriteUint8(0) // Ignored
 			}
 			bf.WriteBytes(stringsupport.PaddedString(string(fullName), 65, false))
 		}
 
-		if s.erupeConfig.ClientID >= _config.GG {
+		if server.erupeConfig.ClientID >= _config.GG {
 			bf.WriteUint32(si.AllowedClientFlags)
 		}
 
@@ -71,7 +71,7 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte {
 			bf.WriteUint16(uint16(channelIdx | 16))
 			bf.WriteUint16(ci.MaxPlayers)
 			var currentPlayers uint16
-			s.db.QueryRow("SELECT current_players FROM servers WHERE server_id=$1", sid).Scan(&currentPlayers)
+			server.db.QueryRow("SELECT current_players FROM servers WHERE server_id=$1", sid).Scan(&currentPlayers)
 			bf.WriteUint16(currentPlayers)
 			bf.WriteUint16(0)
 			bf.WriteUint16(0)
@@ -86,7 +86,7 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte {
 		}
 	}
 	bf.WriteUint32(uint32(gametime.TimeAdjusted().Unix()))
-	bf.WriteUint32(uint32(s.erupeConfig.GameplayOptions.ClanMemberLimits[len(s.erupeConfig.GameplayOptions.ClanMemberLimits)-1][1]))
+	bf.WriteUint32(uint32(server.erupeConfig.GameplayOptions.ClanMemberLimits[len(server.erupeConfig.GameplayOptions.ClanMemberLimits)-1][1]))
 	return bf.Data()
 }
 
@@ -108,7 +108,7 @@ func makeHeader(data []byte, respType string, entryCount uint16, key byte) []byt
 	return bf.Data()
 }
 
-func makeSv2Resp(config *_config.Config, s *Server, local bool) []byte {
+func makeSv2Resp(config *_config.Config, server *Server, local bool) []byte {
 	serverInfos := config.Entrance.Entries
 	// Decrease by the number of MezFes Worlds
 	var mf int
@@ -128,9 +128,9 @@ func makeSv2Resp(config *_config.Config, s *Server, local bool) []byte {
 			}
 		}
 	}
-	rawServerData := encodeServerInfo(config, s, local)
+	rawServerData := encodeServerInfo(config, server, local)
 
-	if s.erupeConfig.DebugOptions.LogOutboundMessages {
+	if server.erupeConfig.DebugOptions.LogOutboundMessages {
 		fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(rawServerData), hex.Dump(rawServerData))
 	}
 
@@ -144,7 +144,7 @@ func makeSv2Resp(config *_config.Config, s *Server, local bool) []byte {
 	return bf.Data()
 }
 
-func makeUsrResp(pkt []byte, s *Server) []byte {
+func makeUsrResp(pkt []byte, server *Server) []byte {
 	bf := byteframe.NewByteFrameFromBytes(pkt)
 	_ = bf.ReadUint32() // ALL+
 	_ = bf.ReadUint8()  // 0x00
@@ -153,7 +153,7 @@ func makeUsrResp(pkt []byte, s *Server) []byte {
 	for i := 0; i < int(userEntries); i++ {
 		cid := bf.ReadUint32()
 		var sid uint16
-		err := s.db.QueryRow("SELECT(SELECT server_id FROM sign_sessions WHERE char_id=$1) AS _", cid).Scan(&sid)
+		err := server.db.QueryRow("SELECT(SELECT server_id FROM sign_sessions WHERE char_id=$1) AS _", cid).Scan(&sid)
 		if err != nil {
 			resp.WriteUint16(0)
 		} else {
@@ -162,7 +162,7 @@ func makeUsrResp(pkt []byte, s *Server) []byte {
 		resp.WriteUint16(0)
 	}
 
-	if s.erupeConfig.DebugOptions.LogOutboundMessages {
+	if server.erupeConfig.DebugOptions.LogOutboundMessages {
 		fmt.Printf("[Server] -> [Client]\nData [%d bytes]:\n%s\n", len(resp.Data()), hex.Dump(resp.Data()))
 	}
 

server/signserver/dbutils.go

@@ -12,9 +12,9 @@ import (
 	"golang.org/x/crypto/bcrypt"
 )
 
-func (s *Server) newUserChara(uid uint32) error {
+func (server *Server) newUserChara(uid uint32) error {
 	var numNewChars int
-	err := s.db.QueryRow("SELECT COUNT(*) FROM characters WHERE user_id = $1 AND is_new_character = true", uid).Scan(&numNewChars)
+	err := server.db.QueryRow("SELECT COUNT(*) FROM characters WHERE user_id = $1 AND is_new_character = true", uid).Scan(&numNewChars)
 	if err != nil {
 		return err
 	}
@@ -24,7 +24,7 @@ func (s *Server) newUserChara(uid uint32) error {
 		return err
 	}
 
-	_, err = s.db.Exec(`
+	_, err = server.db.Exec(`
 		INSERT INTO characters (
 			user_id, is_female, is_new_character, name, unk_desc_string,
 			hr, gr, weapon_type, last_login)
@@ -39,9 +39,9 @@ func (s *Server) newUserChara(uid uint32) error {
 	return nil
 }
 
-func (s *Server) registerDBAccount(username string, password string) (uint32, error) {
+func (server *Server) registerDBAccount(username string, password string) (uint32, error) {
 	var uid uint32
-	s.logger.Info("Creating user", zap.String("User", username))
+	server.logger.Info("Creating user", zap.String("User", username))
 
 	// Create salted hash of user password
 	passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
@@ -49,7 +49,7 @@ func (s *Server) registerDBAccount(username string, password string) (uint32, er
 		return 0, err
 	}
 
-	err = s.db.QueryRow("INSERT INTO users (username, password, return_expires) VALUES ($1, $2, $3) RETURNING id", username, string(passwordHash), time.Now().Add(time.Hour*24*30)).Scan(&uid)
+	err = server.db.QueryRow("INSERT INTO users (username, password, return_expires) VALUES ($1, $2, $3) RETURNING id", username, string(passwordHash), time.Now().Add(time.Hour*24*30)).Scan(&uid)
 	if err != nil {
 		return 0, err
 	}
@@ -69,42 +69,42 @@ type character struct {
 	LastLogin      uint32 `db:"last_login"`
 }
 
-func (s *Server) getCharactersForUser(uid uint32) ([]character, error) {
+func (server *Server) getCharactersForUser(uid uint32) ([]character, error) {
 	characters := make([]character, 0)
-	err := s.db.Select(&characters, "SELECT id, is_female, is_new_character, name, unk_desc_string, hr, gr, weapon_type, last_login FROM characters WHERE user_id = $1 AND deleted = false ORDER BY id", uid)
+	err := server.db.Select(&characters, "SELECT id, is_female, is_new_character, name, unk_desc_string, hr, gr, weapon_type, last_login FROM characters WHERE user_id = $1 AND deleted = false ORDER BY id", uid)
 	if err != nil {
 		return nil, err
 	}
 	return characters, nil
 }
 
-func (s *Server) getReturnExpiry(uid uint32) time.Time {
+func (server *Server) getReturnExpiry(uid uint32) time.Time {
 	var returnExpiry, lastLogin time.Time
-	s.db.Get(&lastLogin, "SELECT COALESCE(last_login, now()) FROM users WHERE id=$1", uid)
+	server.db.Get(&lastLogin, "SELECT COALESCE(last_login, now()) FROM users WHERE id=$1", uid)
 	if time.Now().Add((time.Hour * 24) * -90).After(lastLogin) {
 		returnExpiry = time.Now().Add(time.Hour * 24 * 30)
-		s.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid)
+		server.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid)
 	} else {
-		err := s.db.Get(&returnExpiry, "SELECT return_expires FROM users WHERE id=$1", uid)
+		err := server.db.Get(&returnExpiry, "SELECT return_expires FROM users WHERE id=$1", uid)
 		if err != nil {
 			returnExpiry = time.Now()
-			s.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid)
+			server.db.Exec("UPDATE users SET return_expires=$1 WHERE id=$2", returnExpiry, uid)
 		}
 	}
-	s.db.Exec("UPDATE users SET last_login=$1 WHERE id=$2", time.Now(), uid)
+	server.db.Exec("UPDATE users SET last_login=$1 WHERE id=$2", time.Now(), uid)
 	return returnExpiry
 }
 
-func (s *Server) getLastCID(uid uint32) uint32 {
+func (server *Server) getLastCID(uid uint32) uint32 {
 	var lastPlayed uint32
-	_ = s.db.QueryRow("SELECT last_character FROM users WHERE id=$1", uid).Scan(&lastPlayed)
+	_ = server.db.QueryRow("SELECT last_character FROM users WHERE id=$1", uid).Scan(&lastPlayed)
 	return lastPlayed
 }
 
-func (s *Server) getUserRights(uid uint32) uint32 {
+func (server *Server) getUserRights(uid uint32) uint32 {
 	var rights uint32
 	if uid != 0 {
-		_ = s.db.QueryRow("SELECT rights FROM users WHERE id=$1", uid).Scan(&rights)
+		_ = server.db.QueryRow("SELECT rights FROM users WHERE id=$1", uid).Scan(&rights)
 		_, rights = mhfcourse.GetCourseStruct(rights)
 	}
 	return rights
@@ -116,11 +116,11 @@ type members struct {
 	Name string `db:"name"`
 }
 
-func (s *Server) getFriendsForCharacters(chars []character) []members {
+func (server *Server) getFriendsForCharacters(chars []character) []members {
 	friends := make([]members, 0)
 	for _, char := range chars {
 		friendsCSV := ""
-		err := s.db.QueryRow("SELECT friends FROM characters WHERE id=$1", char.ID).Scan(&friendsCSV)
+		err := server.db.QueryRow("SELECT friends FROM characters WHERE id=$1", char.ID).Scan(&friendsCSV)
 		friendsSlice := strings.Split(friendsCSV, ",")
 		friendQuery := "SELECT id, name FROM characters WHERE id="
 		for i := 0; i < len(friendsSlice); i++ {
@@ -130,7 +130,7 @@ func (s *Server) getFriendsForCharacters(chars []character) []members {
 			}
 		}
 		charFriends := make([]members, 0)
-		err = s.db.Select(&charFriends, friendQuery)
+		err = server.db.Select(&charFriends, friendQuery)
 		if err != nil {
 			continue
 		}
@@ -142,19 +142,19 @@ func (s *Server) getFriendsForCharacters(chars []character) []members {
 	return friends
 }
 
-func (s *Server) getGuildmatesForCharacters(chars []character) []members {
+func (server *Server) getGuildmatesForCharacters(chars []character) []members {
 	guildmates := make([]members, 0)
 	for _, char := range chars {
 		var inGuild int
-		_ = s.db.QueryRow("SELECT count(*) FROM guild_characters WHERE character_id=$1", char.ID).Scan(&inGuild)
+		_ = server.db.QueryRow("SELECT count(*) FROM guild_characters WHERE character_id=$1", char.ID).Scan(&inGuild)
 		if inGuild > 0 {
 			var guildID int
-			err := s.db.QueryRow("SELECT guild_id FROM guild_characters WHERE character_id=$1", char.ID).Scan(&guildID)
+			err := server.db.QueryRow("SELECT guild_id FROM guild_characters WHERE character_id=$1", char.ID).Scan(&guildID)
 			if err != nil {
 				continue
 			}
 			charGuildmates := make([]members, 0)
-			err = s.db.Select(&charGuildmates, "SELECT character_id AS id, c.name FROM guild_characters gc JOIN characters c ON c.id = gc.character_id WHERE guild_id=$1 AND character_id!=$2", guildID, char.ID)
+			err = server.db.Select(&charGuildmates, "SELECT character_id AS id, c.name FROM guild_characters gc JOIN characters c ON c.id = gc.character_id WHERE guild_id=$1 AND character_id!=$2", guildID, char.ID)
 			if err != nil {
 				continue
 			}
@@ -167,16 +167,16 @@ func (s *Server) getGuildmatesForCharacters(chars []character) []members {
 	return guildmates
 }
 
-func (s *Server) deleteCharacter(cid int, token string, tokenID uint32) error {
-	if !s.validateToken(token, tokenID) {
+func (server *Server) deleteCharacter(cid int, token string, tokenID uint32) error {
+	if !server.validateToken(token, tokenID) {
 		return errors.New("invalid token")
 	}
 	var isNew bool
-	err := s.db.QueryRow("SELECT is_new_character FROM characters WHERE id = $1", cid).Scan(&isNew)
+	err := server.db.QueryRow("SELECT is_new_character FROM characters WHERE id = $1", cid).Scan(&isNew)
 	if isNew {
-		_, err = s.db.Exec("DELETE FROM characters WHERE id = $1", cid)
+		_, err = server.db.Exec("DELETE FROM characters WHERE id = $1", cid)
 	} else {
-		_, err = s.db.Exec("UPDATE characters SET deleted = true WHERE id = $1", cid)
+		_, err = server.db.Exec("UPDATE characters SET deleted = true WHERE id = $1", cid)
 	}
 	if err != nil {
 		return err
@@ -185,9 +185,9 @@ func (s *Server) deleteCharacter(cid int, token string, tokenID uint32) error {
 }
 
 // Unused
-func (s *Server) checkToken(uid uint32) (bool, error) {
+func (server *Server) checkToken(uid uint32) (bool, error) {
 	var exists int
-	err := s.db.QueryRow("SELECT count(*) FROM sign_sessions WHERE user_id = $1", uid).Scan(&exists)
+	err := server.db.QueryRow("SELECT count(*) FROM sign_sessions WHERE user_id = $1", uid).Scan(&exists)
 	if err != nil {
 		return false, err
 	}
@@ -197,42 +197,42 @@ func (s *Server) checkToken(uid uint32) (bool, error) {
 	return false, nil
 }
 
-func (s *Server) registerUidToken(uid uint32) (uint32, string, error) {
+func (server *Server) registerUidToken(uid uint32) (uint32, string, error) {
 	_token := token.Generate(16)
 	var tid uint32
-	err := s.db.QueryRow(`INSERT INTO sign_sessions (user_id, token) VALUES ($1, $2) RETURNING id`, uid, _token).Scan(&tid)
+	err := server.db.QueryRow(`INSERT INTO sign_sessions (user_id, token) VALUES ($1, $2) RETURNING id`, uid, _token).Scan(&tid)
 	return tid, _token, err
 }
 
-func (s *Server) registerPsnToken(psn string) (uint32, string, error) {
+func (server *Server) registerPsnToken(psn string) (uint32, string, error) {
 	_token := token.Generate(16)
 	var tid uint32
-	err := s.db.QueryRow(`INSERT INTO sign_sessions (psn_id, token) VALUES ($1, $2) RETURNING id`, psn, _token).Scan(&tid)
+	err := server.db.QueryRow(`INSERT INTO sign_sessions (psn_id, token) VALUES ($1, $2) RETURNING id`, psn, _token).Scan(&tid)
 	return tid, _token, err
 }
 
-func (s *Server) validateToken(token string, tokenID uint32) bool {
+func (server *Server) validateToken(token string, tokenID uint32) bool {
 	query := `SELECT count(*) FROM sign_sessions WHERE token = $1`
 	if tokenID > 0 {
 		query += ` AND id = $2`
 	}
 	var exists int
-	err := s.db.QueryRow(query, token, tokenID).Scan(&exists)
+	err := server.db.QueryRow(query, token, tokenID).Scan(&exists)
 	if err != nil || exists == 0 {
 		return false
 	}
 	return true
 }
 
-func (s *Server) validateLogin(user string, pass string) (uint32, RespID) {
+func (server *Server) validateLogin(user string, pass string) (uint32, RespID) {
 	var uid uint32
 	var passDB string
-	err := s.db.QueryRow(`SELECT id, password FROM users WHERE username = $1`, user).Scan(&uid, &passDB)
+	err := server.db.QueryRow(`SELECT id, password FROM users WHERE username = $1`, user).Scan(&uid, &passDB)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
-			s.logger.Info("User not found", zap.String("User", user))
-			if s.erupeConfig.AutoCreateAccount {
-				uid, err = s.registerDBAccount(user, pass)
+			server.logger.Info("User not found", zap.String("User", user))
+			if server.erupeConfig.AutoCreateAccount {
+				uid, err = server.registerDBAccount(user, pass)
 				if err == nil {
 					return uid, SIGN_SUCCESS
 				} else {
@@ -245,11 +245,11 @@ func (s *Server) validateLogin(user string, pass string) (uint32, RespID) {
 	} else {
 		if bcrypt.CompareHashAndPassword([]byte(passDB), []byte(pass)) == nil {
 			var bans int
-			err = s.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires IS NULL`, uid).Scan(&bans)
+			err = server.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires IS NULL`, uid).Scan(&bans)
 			if err == nil && bans > 0 {
 				return uid, SIGN_EELIMINATE
 			}
-			err = s.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires > now()`, uid).Scan(&bans)
+			err = server.db.QueryRow(`SELECT count(*) FROM bans WHERE user_id=$1 AND expires > now()`, uid).Scan(&bans)
 			if err == nil && bans > 0 {
 				return uid, SIGN_ESUSPEND
 			}

server/signserver/sign_server.go

@@ -6,8 +6,9 @@ import (
 	"net"
 	"sync"
 
-	"erupe-ce/config"
+	_config "erupe-ce/config"
 	"erupe-ce/network"
+
 	"github.com/jmoiron/sqlx"
 	"go.uber.org/zap"
 )
@@ -41,38 +42,38 @@ func NewServer(config *Config) *Server {
 }
 
 // Start starts the server in a new goroutine.
-func (s *Server) Start() error {
-	l, err := net.Listen("tcp", fmt.Sprintf(":%d", s.erupeConfig.Sign.Port))
+func (server *Server) Start() error {
+	l, err := net.Listen("tcp", fmt.Sprintf(":%d", server.erupeConfig.Sign.Port))
 	if err != nil {
 		return err
 	}
-	s.listener = l
+	server.listener = l
 
-	go s.acceptClients()
+	go server.acceptClients()
 
 	return nil
 }
 
 // Shutdown exits the server gracefully.
-func (s *Server) Shutdown() {
-	s.logger.Debug("Shutting down...")
+func (server *Server) Shutdown() {
+	server.logger.Debug("Shutting down...")
 
-	s.Lock()
-	s.isShuttingDown = true
-	s.Unlock()
+	server.Lock()
+	server.isShuttingDown = true
+	server.Unlock()
 
 	// This will cause the acceptor goroutine to error and exit gracefully.
-	s.listener.Close()
+	server.listener.Close()
 }
 
-func (s *Server) acceptClients() {
+func (server *Server) acceptClients() {
 	for {
-		conn, err := s.listener.Accept()
+		conn, err := server.listener.Accept()
 		if err != nil {
 			// Check if we are shutting down and exit gracefully if so.
-			s.Lock()
-			shutdown := s.isShuttingDown
-			s.Unlock()
+			server.Lock()
+			shutdown := server.isShuttingDown
+			server.Unlock()
 
 			if shutdown {
 				break
@@ -81,26 +82,26 @@ func (s *Server) acceptClients() {
 			}
 		}
 
-		go s.handleConnection(conn)
+		go server.handleConnection(conn)
 	}
 }
 
-func (s *Server) handleConnection(conn net.Conn) {
-	s.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String()))
+func (server *Server) handleConnection(conn net.Conn) {
+	server.logger.Debug("New connection", zap.String("RemoteAddr", conn.RemoteAddr().String()))
 	defer conn.Close()
 
 	// Client initalizes the connection with a one-time buffer of 8 NULL bytes.
 	nullInit := make([]byte, 8)
 	_, err := io.ReadFull(conn, nullInit)
 	if err != nil {
-		s.logger.Error("Error initializing connection", zap.Error(err))
+		server.logger.Error("Error initializing connection", zap.Error(err))
 		return
 	}
 
 	// Create a new session.
 	session := &Session{
-		logger:    s.logger,
-		server:    s,
+		logger:    server.logger,
+		server:    server,
 		rawConn:   conn,
 		cryptConn: network.NewCryptConn(conn),
 	}