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]
+}