Merge remote-tracking branch 'origin/main' into feature/warehouse-v2

# Conflicts: # server/channelserver/handlers.go
2026-03-31 04:52:35 +02:00 · 2023-12-13 11:38:05 +11:00
parent a9f280a2ef 6686d59146
commit 7e34862e25
143 changed files with 3551 additions and 3183 deletions
--- a/server/channelserver/handlers.go
+++ b/server/channelserver/handlers.go
--- a/server/channelserver/handlers_cafe.go
+++ b/server/channelserver/handlers_cafe.go
@@ -220,7 +220,7 @@ func addPointNetcafe(s *Session, p int) error {
 func handleMsgMhfStartBoostTime(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfStartBoostTime)
 	bf := byteframe.NewByteFrame()
-	boostLimit := TimeAdjusted().Add(time.Duration(s.server.erupeConfig.GameplayOptions.BoostTimeDuration) * time.Minute)
+	boostLimit := TimeAdjusted().Add(time.Duration(s.server.erupeConfig.GameplayOptions.BoostTimeDuration) * time.Second)
 	if s.server.erupeConfig.GameplayOptions.DisableBoostTime {
 		bf.WriteUint32(0)
 		doAckBufSucceed(s, pkt.AckHandle, bf.Data())
--- a/server/channelserver/handlers_cast_binary.go
+++ b/server/channelserver/handlers_cast_binary.go
@@ -6,6 +6,7 @@ import (
 	"erupe-ce/common/mhfcourse"
 	"erupe-ce/common/token"
 	"erupe-ce/config"
+	"erupe-ce/network"
 	"erupe-ce/network/binpacket"
 	"erupe-ce/network/mhfpacket"
 	"fmt"
@@ -74,7 +75,7 @@ func sendServerChatMessage(s *Session, message string) {
 	msgBinChat.Build(bf)

 	castedBin := &mhfpacket.MsgSysCastedBinary{
-		CharID:         s.charID,
+		CharID:         0,
 		MessageType:    BinaryMessageTypeChat,
 		RawDataPayload: bf.Data(),
 	}
@@ -83,7 +84,7 @@ func sendServerChatMessage(s *Session, message string) {
 }

 func parseChatCommand(s *Session, command string) {
-	args := strings.Split(command[1:], " ")
+	args := strings.Split(command[len(s.server.erupeConfig.CommandPrefix):], " ")
 	switch args[0] {
 	case commands["PSN"].Prefix:
 		if commands["PSN"].Enabled {
@@ -125,7 +126,7 @@ func parseChatCommand(s *Session, command string) {
 				deleteNotif.WriteUint16(uint16(temp.Opcode()))
 				temp.Build(deleteNotif, s.clientContext)
 			}
-			deleteNotif.WriteUint16(0x0010)
+			deleteNotif.WriteUint16(uint16(network.MSG_SYS_END))
 			s.QueueSend(deleteNotif.Data())
 			time.Sleep(500 * time.Millisecond)
 			reloadNotif := byteframe.NewByteFrame()
@@ -160,24 +161,28 @@ func parseChatCommand(s *Session, command string) {
 				reloadNotif.WriteUint16(uint16(temp.Opcode()))
 				temp.Build(reloadNotif, s.clientContext)
 			}
-			reloadNotif.WriteUint16(0x0010)
+			reloadNotif.WriteUint16(uint16(network.MSG_SYS_END))
 			s.QueueSend(reloadNotif.Data())
 		} else {
 			sendDisabledCommandMessage(s, commands["Reload"])
 		}
 	case commands["KeyQuest"].Prefix:
 		if commands["KeyQuest"].Enabled {
-			if len(args) > 1 {
-				if args[1] == "get" {
-					sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandKqfGet"], s.kqf))
-				} else if args[1] == "set" {
-					if len(args) > 2 && len(args[2]) == 16 {
-						hexd, _ := hex.DecodeString(args[2])
-						s.kqf = hexd
-						s.kqfOverride = true
-						sendServerChatMessage(s, s.server.dict["commandKqfSetSuccess"])
-					} else {
-						sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandKqfSetError"], commands["KeyQuest"].Prefix))
+			if s.server.erupeConfig.RealClientMode < _config.G10 {
+				sendServerChatMessage(s, s.server.dict["commandKqfVersion"])
+			} else {
+				if len(args) > 1 {
+					if args[1] == "get" {
+						sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandKqfGet"], s.kqf))
+					} else if args[1] == "set" {
+						if len(args) > 2 && len(args[2]) == 16 {
+							hexd, _ := hex.DecodeString(args[2])
+							s.kqf = hexd
+							s.kqfOverride = true
+							sendServerChatMessage(s, s.server.dict["commandKqfSetSuccess"])
+						} else {
+							sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandKqfSetError"], commands["KeyQuest"].Prefix))
+						}
 					}
 				}
 			}
@@ -297,8 +302,8 @@ func parseChatCommand(s *Session, command string) {
 	case commands["Teleport"].Prefix:
 		if commands["Teleport"].Enabled {
 			if len(args) > 2 {
-				x, _ := strconv.Atoi(args[1])
-				y, _ := strconv.Atoi(args[2])
+				x, _ := strconv.ParseInt(args[1], 10, 16)
+				y, _ := strconv.ParseInt(args[2], 10, 16)
 				payload := byteframe.NewByteFrame()
 				payload.SetLE()
 				payload.WriteUint8(2)        // SetState type(position == 2)
@@ -317,6 +322,16 @@ func parseChatCommand(s *Session, command string) {
 		} else {
 			sendDisabledCommandMessage(s, commands["Teleport"])
 		}
+	case commands["Help"].Prefix:
+		if commands["Help"].Enabled {
+			for _, command := range commands {
+				if command.Enabled {
+					sendServerChatMessage(s, fmt.Sprintf("%s%s: %s", s.server.erupeConfig.CommandPrefix, command.Prefix, command.Description))
+				}
+			}
+		} else {
+			sendDisabledCommandMessage(s, commands["Help"])
+		}
 	}
 }

@@ -390,7 +405,7 @@ func handleMsgSysCastBinary(s *Session, p mhfpacket.MHFPacket) {
 			bf.SetLE()
 			chatMessage := &binpacket.MsgBinChat{}
 			chatMessage.Parse(bf)
-			if strings.HasPrefix(chatMessage.Message, "!") {
+			if strings.HasPrefix(chatMessage.Message, s.server.erupeConfig.CommandPrefix) {
 				parseChatCommand(s, chatMessage.Message)
 				return
 			}
--- a/server/channelserver/handlers_character.go
+++ b/server/channelserver/handlers_character.go
@@ -19,7 +19,7 @@ const (
 	pRP                   // +2
 	pHouseTier            // +5
 	pHouseData            // +195
-	pBookshelfData        // +5576
+	pBookshelfData        // +lBookshelfData
 	pGalleryData          // +1748
 	pToreData             // +240
 	pGardenData           // +68
@@ -28,6 +28,7 @@ const (
 	pHRP                  // +2
 	pGRP                  // +4
 	pKQF                  // +8
+	lBookshelfData
 )

 type CharacterSaveData struct {
@@ -55,7 +56,7 @@ type CharacterSaveData struct {
 }

 func getPointers() map[SavePointer]int {
-	pointers := map[SavePointer]int{pGender: 81}
+	pointers := map[SavePointer]int{pGender: 81, lBookshelfData: 5576}
 	switch _config.ErupeConfig.RealClientMode {
 	case _config.ZZ:
 		pointers[pWeaponID] = 128522
@@ -70,7 +71,9 @@ func getPointers() map[SavePointer]int {
 		pointers[pGardenData] = 142424
 		pointers[pRP] = 142614
 		pointers[pKQF] = 146720
-	case _config.Z2, _config.Z1, _config.G101, _config.G10:
+	case _config.Z2, _config.Z1, _config.G101, _config.G10, _config.G91, _config.G9, _config.G81, _config.G8,
+		_config.G7, _config.G61, _config.G6, _config.G52, _config.G51, _config.G5, _config.GG, _config.G32, _config.G31,
+		_config.G3, _config.G2, _config.G1:
 		pointers[pWeaponID] = 92522
 		pointers[pWeaponType] = 92789
 		pointers[pHouseTier] = 93900
@@ -83,6 +86,22 @@ func getPointers() map[SavePointer]int {
 		pointers[pGardenData] = 106424
 		pointers[pRP] = 106614
 		pointers[pKQF] = 110720
+	case _config.F5, _config.F4:
+		pointers[pWeaponID] = 60522
+		pointers[pWeaponType] = 60789
+		pointers[pHouseTier] = 61900
+		pointers[pToreData] = 62228
+		pointers[pHRP] = 62550
+		pointers[pHouseData] = 62561
+		pointers[pBookshelfData] = 57118 // This pointer only half works
+		pointers[pGalleryData] = 72064
+		pointers[pGardenData] = 74424
+		pointers[pRP] = 74614
+	}
+	if _config.ErupeConfig.RealClientMode == _config.G5 {
+		pointers[lBookshelfData] = 5548
+	} else if _config.ErupeConfig.RealClientMode <= _config.GG {
+		pointers[lBookshelfData] = 4520
 	}
 	return pointers
 }
@@ -176,8 +195,10 @@ func (save *CharacterSaveData) Decompress() error {
 func (save *CharacterSaveData) updateSaveDataWithStruct() {
 	rpBytes := make([]byte, 2)
 	binary.LittleEndian.PutUint16(rpBytes, save.RP)
-	if _config.ErupeConfig.RealClientMode >= _config.G10 {
+	if _config.ErupeConfig.RealClientMode >= _config.F4 {
 		copy(save.decompSave[save.Pointers[pRP]:save.Pointers[pRP]+2], rpBytes)
+	}
+	if _config.ErupeConfig.RealClientMode >= _config.G10 {
 		copy(save.decompSave[save.Pointers[pKQF]:save.Pointers[pKQF]+8], save.KQF)
 	}
 }
@@ -191,21 +212,25 @@ func (save *CharacterSaveData) updateStructWithSaveData() {
 		save.Gender = false
 	}
 	if !save.IsNewCharacter {
-		if _config.ErupeConfig.RealClientMode >= _config.G10 {
+		if _config.ErupeConfig.RealClientMode >= _config.F4 {
 			save.RP = binary.LittleEndian.Uint16(save.decompSave[save.Pointers[pRP] : save.Pointers[pRP]+2])
 			save.HouseTier = save.decompSave[save.Pointers[pHouseTier] : save.Pointers[pHouseTier]+5]
 			save.HouseData = save.decompSave[save.Pointers[pHouseData] : save.Pointers[pHouseData]+195]
-			save.BookshelfData = save.decompSave[save.Pointers[pBookshelfData] : save.Pointers[pBookshelfData]+5576]
+			save.BookshelfData = save.decompSave[save.Pointers[pBookshelfData] : save.Pointers[pBookshelfData]+save.Pointers[lBookshelfData]]
 			save.GalleryData = save.decompSave[save.Pointers[pGalleryData] : save.Pointers[pGalleryData]+1748]
 			save.ToreData = save.decompSave[save.Pointers[pToreData] : save.Pointers[pToreData]+240]
 			save.GardenData = save.decompSave[save.Pointers[pGardenData] : save.Pointers[pGardenData]+68]
 			save.WeaponType = save.decompSave[save.Pointers[pWeaponType]]
 			save.WeaponID = binary.LittleEndian.Uint16(save.decompSave[save.Pointers[pWeaponID] : save.Pointers[pWeaponID]+2])
 			save.HRP = binary.LittleEndian.Uint16(save.decompSave[save.Pointers[pHRP] : save.Pointers[pHRP]+2])
-			if save.HRP == uint16(999) {
-				save.GR = grpToGR(binary.LittleEndian.Uint32(save.decompSave[save.Pointers[pGRP] : save.Pointers[pGRP]+4]))
+			if _config.ErupeConfig.RealClientMode >= _config.G1 {
+				if save.HRP == uint16(999) {
+					save.GR = grpToGR(int(binary.LittleEndian.Uint32(save.decompSave[save.Pointers[pGRP] : save.Pointers[pGRP]+4])))
+				}
+			}
+			if _config.ErupeConfig.RealClientMode >= _config.G10 {
+				save.KQF = save.decompSave[save.Pointers[pKQF] : save.Pointers[pKQF]+8]
 			}
-			save.KQF = save.decompSave[save.Pointers[pKQF] : save.Pointers[pKQF]+8]
 		}
 	}
 	return
--- a/server/channelserver/handlers_clients.go
+++ b/server/channelserver/handlers_clients.go
@@ -29,6 +29,9 @@ func handleMsgSysEnumerateClient(s *Session, p mhfpacket.MHFPacket) {
 		for _, cid := range stage.clients {
 			clients = append(clients, cid)
 		}
+		for cid := range stage.reservedClientSlots {
+			clients = append(clients, cid)
+		}
 	case 1: // Not ready
 		for cid, ready := range stage.reservedClientSlots {
 			if !ready {
@@ -60,20 +63,19 @@ func handleMsgMhfListMember(s *Session, p mhfpacket.MHFPacket) {
 	resp := byteframe.NewByteFrame()
 	resp.WriteUint32(0) // Blacklist count
 	err := s.server.db.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.charID).Scan(&csv)
-	if err != nil {
-		panic(err)
-	}
-	cids := stringsupport.CSVElems(csv)
-	for _, cid := range cids {
-		var name string
-		err = s.server.db.QueryRow("SELECT name FROM characters WHERE id=$1", cid).Scan(&name)
-		if err != nil {
-			continue
+	if err == nil {
+		cids := stringsupport.CSVElems(csv)
+		for _, cid := range cids {
+			var name string
+			err = s.server.db.QueryRow("SELECT name FROM characters WHERE id=$1", cid).Scan(&name)
+			if err != nil {
+				continue
+			}
+			count++
+			resp.WriteUint32(uint32(cid))
+			resp.WriteUint32(16)
+			resp.WriteBytes(stringsupport.PaddedString(name, 16, true))
 		}
-		count++
-		resp.WriteUint32(uint32(cid))
-		resp.WriteUint32(16)
-		resp.WriteBytes(stringsupport.PaddedString(name, 16, true))
 	}
 	resp.Seek(0, 0)
 	resp.WriteUint32(count)
@@ -83,28 +85,28 @@ func handleMsgMhfListMember(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgMhfOprMember(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOprMember)
 	var csv string
-	if pkt.Blacklist {
-		err := s.server.db.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.charID).Scan(&csv)
-		if err != nil {
-			panic(err)
+	for _, cid := range pkt.CharIDs {
+		if pkt.Blacklist {
+			err := s.server.db.QueryRow("SELECT blocked FROM characters WHERE id=$1", s.charID).Scan(&csv)
+			if err == nil {
+				if pkt.Operation {
+					csv = stringsupport.CSVRemove(csv, int(cid))
+				} else {
+					csv = stringsupport.CSVAdd(csv, int(cid))
+				}
+				s.server.db.Exec("UPDATE characters SET blocked=$1 WHERE id=$2", csv, s.charID)
+			}
+		} else { // Friendlist
+			err := s.server.db.QueryRow("SELECT friends FROM characters WHERE id=$1", s.charID).Scan(&csv)
+			if err == nil {
+				if pkt.Operation {
+					csv = stringsupport.CSVRemove(csv, int(cid))
+				} else {
+					csv = stringsupport.CSVAdd(csv, int(cid))
+				}
+				s.server.db.Exec("UPDATE characters SET friends=$1 WHERE id=$2", csv, s.charID)
+			}
 		}
-		if pkt.Operation {
-			csv = stringsupport.CSVRemove(csv, int(pkt.CharID))
-		} else {
-			csv = stringsupport.CSVAdd(csv, int(pkt.CharID))
-		}
-		s.server.db.Exec("UPDATE characters SET blocked=$1 WHERE id=$2", csv, s.charID)
-	} else { // Friendlist
-		err := s.server.db.QueryRow("SELECT friends FROM characters WHERE id=$1", s.charID).Scan(&csv)
-		if err != nil {
-			panic(err)
-		}
-		if pkt.Operation {
-			csv = stringsupport.CSVRemove(csv, int(pkt.CharID))
-		} else {
-			csv = stringsupport.CSVAdd(csv, int(pkt.CharID))
-		}
-		s.server.db.Exec("UPDATE characters SET friends=$1 WHERE id=$2", csv, s.charID)
 	}
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }
--- a/server/channelserver/handlers_data.go
+++ b/server/channelserver/handlers_data.go
@@ -2,6 +2,7 @@ package channelserver

 import (
 	"erupe-ce/common/stringsupport"
+	_config "erupe-ce/config"
 	"fmt"
 	"io"
 	"os"
@@ -44,6 +45,9 @@ func handleMsgMhfSavedata(s *Session, p mhfpacket.MHFPacket) {
 			doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 			return
 		}
+		if s.server.erupeConfig.DevModeOptions.SaveDumps.RawEnabled {
+			dumpSaveData(s, saveData, "raw-savedata")
+		}
 		s.logger.Info("Updating save with blob")
 		characterSaveData.decompSave = saveData
 	}
@@ -54,7 +58,7 @@ func handleMsgMhfSavedata(s *Session, p mhfpacket.MHFPacket) {
 		s.Name = characterSaveData.Name
 	}

-	if characterSaveData.Name == s.Name {
+	if characterSaveData.Name == s.Name || _config.ErupeConfig.RealClientMode <= _config.S10 {
 		characterSaveData.Save(s)
 		s.logger.Info("Wrote recompressed savedata back to DB.")
 	} else {
@@ -72,162 +76,39 @@ func handleMsgMhfSavedata(s *Session, p mhfpacket.MHFPacket) {
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

-func grpToGR(n uint32) uint16 {
-	var gr uint16
-	gr = 1
-	switch grp := int(n); {
-	case grp < 208750: // Up to 50
-		i := 0
-		for {
-			grp -= 500
-			if grp <= 500 {
-				if grp < 0 {
-					i--
+func grpToGR(n int) uint16 {
+	var gr int
+	a := []int{208750, 593400, 993400, 1400900, 2315900, 3340900, 4505900, 5850900, 7415900, 9230900, 11345900, 100000000}
+	b := []int{7850, 8000, 8150, 9150, 10250, 11650, 13450, 15650, 18150, 21150, 23950}
+	c := []int{51, 100, 150, 200, 300, 400, 500, 600, 700, 800, 900}
+
+	for i := 0; i < len(a); i++ {
+		if n < a[i] {
+			if i == 0 {
+				for {
+					n -= 500
+					if n <= 500 {
+						if n < 0 {
+							i--
+						}
+						break
+					} else {
+						i++
+						for j := 0; j < i; j++ {
+							n -= 150
+						}
+					}
 				}
-				break
+				gr = i + 2
 			} else {
-				i++
-				for j := 0; j < i; j++ {
-					grp -= 150
-				}
+				n -= a[i-1]
+				gr = c[i-1]
+				gr += n / b[i-1]
 			}
+			break
 		}
-		gr = uint16(i + 2)
-		break
-	case grp < 593400: // 51-99
-		grp -= 208750
-		i := 51
-		for {
-			if grp < 7850 {
-				break
-			}
-			i++
-			grp -= 7850
-		}
-		gr = uint16(i)
-		break
-	case grp < 993400: // 100-149
-		grp -= 593400
-		i := 100
-		for {
-			if grp < 8000 {
-				break
-			}
-			i++
-			grp -= 8000
-		}
-		gr = uint16(i)
-		break
-	case grp < 1400900: // 150-199
-		grp -= 993400
-		i := 150
-		for {
-			if grp < 8150 {
-				break
-			}
-			i++
-			grp -= 8150
-		}
-		gr = uint16(i)
-		break
-	case grp < 2315900: // 200-299
-		grp -= 1400900
-		i := 200
-		for {
-			if grp < 9150 {
-				break
-			}
-			i++
-			grp -= 9150
-		}
-		gr = uint16(i)
-		break
-	case grp < 3340900: // 300-399
-		grp -= 2315900
-		i := 300
-		for {
-			if grp < 10250 {
-				break
-			}
-			i++
-			grp -= 10250
-		}
-		gr = uint16(i)
-		break
-	case grp < 4505900: // 400-499
-		grp -= 3340900
-		i := 400
-		for {
-			if grp < 11650 {
-				break
-			}
-			i++
-			grp -= 11650
-		}
-		gr = uint16(i)
-		break
-	case grp < 5850900: // 500-599
-		grp -= 4505900
-		i := 500
-		for {
-			if grp < 13450 {
-				break
-			}
-			i++
-			grp -= 13450
-		}
-		gr = uint16(i)
-		break
-	case grp < 7415900: // 600-699
-		grp -= 5850900
-		i := 600
-		for {
-			if grp < 15650 {
-				break
-			}
-			i++
-			grp -= 15650
-		}
-		gr = uint16(i)
-		break
-	case grp < 9230900: // 700-799
-		grp -= 7415900
-		i := 700
-		for {
-			if grp < 18150 {
-				break
-			}
-			i++
-			grp -= 18150
-		}
-		gr = uint16(i)
-		break
-	case grp < 11345900: // 800-899
-		grp -= 9230900
-		i := 800
-		for {
-			if grp < 21150 {
-				break
-			}
-			i++
-			grp -= 21150
-		}
-		gr = uint16(i)
-		break
-	default: // 900+
-		grp -= 11345900
-		i := 900
-		for {
-			if grp < 23950 {
-				break
-			}
-			i++
-			grp -= 23950
-		}
-		gr = uint16(i)
-		break
 	}
-	return gr
+	return uint16(gr)
 }

 func dumpSaveData(s *Session, data []byte, suffix string) {
@@ -301,7 +182,7 @@ func handleMsgMhfLoadScenarioData(s *Session, p mhfpacket.MHFPacket) {
 	var scenarioData []byte
 	bf := byteframe.NewByteFrame()
 	err := s.server.db.QueryRow("SELECT scenariodata FROM characters WHERE id = $1", s.charID).Scan(&scenarioData)
-	if err != nil {
+	if err != nil || len(scenarioData) < 10 {
 		s.logger.Error("Failed to load scenariodata", zap.Error(err))
 		bf.WriteBytes(make([]byte, 10))
 	} else {
--- a/server/channelserver/handlers_distitem.go
+++ b/server/channelserver/handlers_distitem.go
@@ -3,144 +3,183 @@ package channelserver
 import (
 	"erupe-ce/common/byteframe"
 	ps "erupe-ce/common/pascalstring"
+	_config "erupe-ce/config"
 	"erupe-ce/network/mhfpacket"
+	"time"

 	"go.uber.org/zap"
 )

-type ItemDist struct {
-	ID              uint32 `db:"id"`
-	Deadline        uint32 `db:"deadline"`
-	TimesAcceptable uint16 `db:"times_acceptable"`
-	TimesAccepted   uint16 `db:"times_accepted"`
-	MinHR           uint16 `db:"min_hr"`
-	MaxHR           uint16 `db:"max_hr"`
-	MinSR           uint16 `db:"min_sr"`
-	MaxSR           uint16 `db:"max_sr"`
-	MinGR           uint16 `db:"min_gr"`
-	MaxGR           uint16 `db:"max_gr"`
-	EventName       string `db:"event_name"`
-	Description     string `db:"description"`
-	Data            []byte `db:"data"`
+type Distribution struct {
+	ID              uint32    `db:"id"`
+	Deadline        time.Time `db:"deadline"`
+	TimesAcceptable uint16    `db:"times_acceptable"`
+	TimesAccepted   uint16    `db:"times_accepted"`
+	MinHR           int16     `db:"min_hr"`
+	MaxHR           int16     `db:"max_hr"`
+	MinSR           int16     `db:"min_sr"`
+	MaxSR           int16     `db:"max_sr"`
+	MinGR           int16     `db:"min_gr"`
+	MaxGR           int16     `db:"max_gr"`
+	EventName       string    `db:"event_name"`
+	Description     string    `db:"description"`
+	Data            []byte    `db:"data"`
 }

 func handleMsgMhfEnumerateDistItem(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateDistItem)
+
+	var itemDists []Distribution
 	bf := byteframe.NewByteFrame()
-	distCount := 0
-	dists, err := s.server.db.Queryx(`
+	rows, err := s.server.db.Queryx(`
 		SELECT d.id, event_name, description, times_acceptable,
-		min_hr, max_hr, min_sr, max_sr, min_gr, max_gr,
+		COALESCE(min_hr, -1) AS min_hr, COALESCE(max_hr, -1) AS max_hr,
+		COALESCE(min_sr, -1) AS min_sr, COALESCE(max_sr, -1) AS max_sr,
+		COALESCE(min_gr, -1) AS min_gr, COALESCE(max_gr, -1) AS max_gr,
 		(
-    	SELECT count(*)
-    	FROM distributions_accepted da
-    	WHERE d.id = da.distribution_id
-    	AND da.character_id = $1
+    		SELECT count(*) FROM distributions_accepted da
+    		WHERE d.id = da.distribution_id AND da.character_id = $1
 		) AS times_accepted,
-		CASE
-			WHEN (EXTRACT(epoch FROM deadline)::int) IS NULL THEN 0
-			ELSE (EXTRACT(epoch FROM deadline)::int)
-		END deadline
+		COALESCE(deadline, TO_TIMESTAMP(0)) AS deadline
 		FROM distribution d
-		WHERE character_id = $1 AND type = $2 OR character_id IS NULL AND type = $2 ORDER BY id DESC;
-	`, s.charID, pkt.Unk0)
-	if err != nil {
-		s.logger.Error("Error getting distribution data from db", zap.Error(err))
-		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 4))
-	} else {
-		for dists.Next() {
-			distCount++
-			distData := &ItemDist{}
-			err = dists.StructScan(&distData)
+		WHERE character_id = $1 AND type = $2 OR character_id IS NULL AND type = $2 ORDER BY id DESC
+	`, s.charID, pkt.DistType)
+
+	if err == nil {
+		var itemDist Distribution
+		for rows.Next() {
+			err = rows.StructScan(&itemDist)
 			if err != nil {
-				s.logger.Error("Error parsing item distribution data", zap.Error(err))
+				continue
 			}
-			bf.WriteUint32(distData.ID)
-			bf.WriteUint32(distData.Deadline)
-			bf.WriteUint32(0) // Unk
-			bf.WriteUint16(distData.TimesAcceptable)
-			bf.WriteUint16(distData.TimesAccepted)
-			bf.WriteUint16(0) // Unk
-			bf.WriteUint16(distData.MinHR)
-			bf.WriteUint16(distData.MaxHR)
-			bf.WriteUint16(distData.MinSR)
-			bf.WriteUint16(distData.MaxSR)
-			bf.WriteUint16(distData.MinGR)
-			bf.WriteUint16(distData.MaxGR)
-			bf.WriteUint32(0) // Unk
-			bf.WriteUint32(0) // Unk
-			ps.Uint16(bf, distData.EventName, true)
-			bf.WriteBytes(make([]byte, 391))
+			itemDists = append(itemDists, itemDist)
 		}
-		resp := byteframe.NewByteFrame()
-		resp.WriteUint16(uint16(distCount))
-		resp.WriteBytes(bf.Data())
-		resp.WriteUint8(0)
-		doAckBufSucceed(s, pkt.AckHandle, resp.Data())
 	}
+
+	bf.WriteUint16(uint16(len(itemDists)))
+	for _, dist := range itemDists {
+		bf.WriteUint32(dist.ID)
+		bf.WriteUint32(uint32(dist.Deadline.Unix()))
+		bf.WriteUint32(0) // Unk
+		bf.WriteUint16(dist.TimesAcceptable)
+		bf.WriteUint16(dist.TimesAccepted)
+		if _config.ErupeConfig.RealClientMode >= _config.G9 {
+			bf.WriteUint16(0) // Unk
+		}
+		bf.WriteInt16(dist.MinHR)
+		bf.WriteInt16(dist.MaxHR)
+		bf.WriteInt16(dist.MinSR)
+		bf.WriteInt16(dist.MaxSR)
+		bf.WriteInt16(dist.MinGR)
+		bf.WriteInt16(dist.MaxGR)
+		if _config.ErupeConfig.RealClientMode >= _config.G7 {
+			bf.WriteUint8(0) // Unk
+		}
+		if _config.ErupeConfig.RealClientMode >= _config.G6 {
+			bf.WriteUint16(0) // Unk
+		}
+		if _config.ErupeConfig.RealClientMode >= _config.G8 {
+			bf.WriteUint8(0) // Unk
+		}
+		if _config.ErupeConfig.RealClientMode >= _config.G7 {
+			bf.WriteUint16(0) // Unk
+			bf.WriteUint16(0) // Unk
+		}
+		if _config.ErupeConfig.RealClientMode >= _config.G10 {
+			bf.WriteUint8(0) // Unk
+		}
+		ps.Uint8(bf, dist.EventName, true)
+		k := 6
+		if _config.ErupeConfig.RealClientMode >= _config.G8 {
+			k = 13
+		}
+		for i := 0; i < 6; i++ {
+			for j := 0; j < k; j++ {
+				bf.WriteUint8(0)
+				bf.WriteUint32(0)
+			}
+		}
+		if _config.ErupeConfig.RealClientMode >= _config.Z2 {
+			i := uint8(0)
+			bf.WriteUint8(i)
+			if i <= 10 {
+				for j := uint8(0); j < i; j++ {
+					bf.WriteUint32(0)
+					bf.WriteUint32(0)
+					bf.WriteUint32(0)
+				}
+			}
+		}
+	}
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
+}
+
+type DistributionItem struct {
+	ItemType uint8  `db:"item_type"`
+	ID       uint32 `db:"id"`
+	ItemID   uint32 `db:"item_id"`
+	Quantity uint32 `db:"quantity"`
+}
+
+func getDistributionItems(s *Session, i uint32) []DistributionItem {
+	var distItems []DistributionItem
+	rows, err := s.server.db.Queryx(`SELECT id, item_type, COALESCE(item_id, 0) AS item_id, COALESCE(quantity, 0) AS quantity FROM distribution_items WHERE distribution_id=$1`, i)
+	if err == nil {
+		var distItem DistributionItem
+		for rows.Next() {
+			err = rows.StructScan(&distItem)
+			if err != nil {
+				continue
+			}
+			distItems = append(distItems, distItem)
+		}
+	}
+	return distItems
 }

 func handleMsgMhfApplyDistItem(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfApplyDistItem)
-
-	if pkt.DistributionID == 0 {
-		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 6))
-	} else {
-		row := s.server.db.QueryRowx("SELECT data FROM distribution WHERE id = $1", pkt.DistributionID)
-		dist := &ItemDist{}
-		err := row.StructScan(dist)
-		if err != nil {
-			s.logger.Error("Error parsing item distribution data", zap.Error(err))
-			doAckBufSucceed(s, pkt.AckHandle, make([]byte, 6))
-			return
-		}
-
-		if len(dist.Data) >= 2 {
-			distData := byteframe.NewByteFrameFromBytes(dist.Data)
-			distItems := int(distData.ReadUint16())
-			for i := 0; i < distItems; i++ {
-				if len(dist.Data) >= 2+(i*13) {
-					itemType := distData.ReadUint8()
-					_ = distData.ReadBytes(6)
-					quantity := int(distData.ReadUint16())
-					_ = distData.ReadBytes(4)
-					switch itemType {
-					case 17:
-						_ = addPointNetcafe(s, quantity)
-					case 19:
-						s.server.db.Exec("UPDATE users u SET gacha_premium=gacha_premium+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", quantity, s.charID)
-					case 20:
-						s.server.db.Exec("UPDATE users u SET gacha_trial=gacha_trial+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", quantity, s.charID)
-					case 21:
-						s.server.db.Exec("UPDATE users u SET frontier_points=frontier_points+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", quantity, s.charID)
-					case 23:
-						saveData, err := GetCharacterSaveData(s, s.charID)
-						if err == nil {
-							saveData.RP += uint16(quantity)
-							saveData.Save(s)
-						}
-					}
-				}
-			}
-		}
-
-		bf := byteframe.NewByteFrame()
-		bf.WriteUint32(pkt.DistributionID)
-		bf.WriteBytes(dist.Data)
-		doAckBufSucceed(s, pkt.AckHandle, bf.Data())
-
-		_, err = s.server.db.Exec(`
-			INSERT INTO public.distributions_accepted
-			VALUES ($1, $2)
-		`, pkt.DistributionID, s.charID)
-		if err != nil {
-			s.logger.Error("Error updating accepted dist count", zap.Error(err))
+	bf := byteframe.NewByteFrame()
+	bf.WriteUint32(pkt.DistributionID)
+	distItems := getDistributionItems(s, pkt.DistributionID)
+	bf.WriteUint16(uint16(len(distItems)))
+	for _, item := range distItems {
+		bf.WriteUint8(item.ItemType)
+		bf.WriteUint32(item.ItemID)
+		bf.WriteUint32(item.Quantity)
+		if _config.ErupeConfig.RealClientMode >= _config.G8 {
+			bf.WriteUint32(item.ID)
 		}
 	}
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

 func handleMsgMhfAcquireDistItem(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireDistItem)
+	if pkt.DistributionID > 0 {
+		_, err := s.server.db.Exec(`INSERT INTO public.distributions_accepted VALUES ($1, $2)`, pkt.DistributionID, s.charID)
+		if err == nil {
+			distItems := getDistributionItems(s, pkt.DistributionID)
+			for _, item := range distItems {
+				switch item.ItemType {
+				case 17:
+					_ = addPointNetcafe(s, int(item.Quantity))
+				case 19:
+					s.server.db.Exec("UPDATE users u SET gacha_premium=gacha_premium+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.charID)
+				case 20:
+					s.server.db.Exec("UPDATE users u SET gacha_trial=gacha_trial+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.charID)
+				case 21:
+					s.server.db.Exec("UPDATE users u SET frontier_points=frontier_points+$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", item.Quantity, s.charID)
+				case 23:
+					saveData, err := GetCharacterSaveData(s, s.charID)
+					if err == nil {
+						saveData.RP += uint16(item.Quantity)
+						saveData.Save(s)
+					}
+				}
+			}
+		}
+	}
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

--- a/server/channelserver/handlers_diva.go
+++ b/server/channelserver/handlers_diva.go
@@ -72,10 +72,10 @@ func handleMsgMhfGetUdSchedule(s *Session, p mhfpacket.MHFPacket) {
 	var timestamps []uint32
 	if s.server.erupeConfig.DevMode && s.server.erupeConfig.DevModeOptions.DivaEvent >= 0 {
 		if s.server.erupeConfig.DevModeOptions.DivaEvent == 0 {
-			if s.server.erupeConfig.RealClientMode <= _config.Z1 {
-				doAckBufSucceed(s, pkt.AckHandle, make([]byte, 32))
-			} else {
+			if s.server.erupeConfig.RealClientMode >= _config.Z2 {
 				doAckBufSucceed(s, pkt.AckHandle, make([]byte, 36))
+			} else {
+				doAckBufSucceed(s, pkt.AckHandle, make([]byte, 32))
 			}
 			return
 		}
@@ -84,7 +84,7 @@ func handleMsgMhfGetUdSchedule(s *Session, p mhfpacket.MHFPacket) {
 		timestamps = generateDivaTimestamps(s, start, false)
 	}

-	if s.server.erupeConfig.RealClientMode <= _config.Z1 {
+	if s.server.erupeConfig.RealClientMode >= _config.Z2 {
 		bf.WriteUint32(id)
 	}
 	for i := range timestamps {
--- a/server/channelserver/handlers_event.go
+++ b/server/channelserver/handlers_event.go
@@ -199,15 +199,11 @@ func handleMsgMhfUseKeepLoginBoost(s *Session, p mhfpacket.MHFPacket) {
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint8(0)
 	switch pkt.BoostWeekUsed {
-	case 1:
-		fallthrough
-	case 3:
+	case 1, 3:
 		expiration = TimeAdjusted().Add(120 * time.Minute)
 	case 4:
 		expiration = TimeAdjusted().Add(180 * time.Minute)
-	case 2:
-		fallthrough
-	case 5:
+	case 2, 5:
 		expiration = TimeAdjusted().Add(240 * time.Minute)
 	}
 	bf.WriteUint32(uint32(expiration.Unix()))
--- a/server/channelserver/handlers_festa.go
+++ b/server/channelserver/handlers_festa.go
@@ -96,7 +96,7 @@ func cleanupFesta(s *Session) {
 	s.server.db.Exec("DELETE FROM events WHERE event_type='festa'")
 	s.server.db.Exec("DELETE FROM festa_registrations")
 	s.server.db.Exec("DELETE FROM festa_prizes_accepted")
-	s.server.db.Exec("UPDATE guild_characters SET souls=0")
+	s.server.db.Exec("UPDATE guild_characters SET souls=0, trial_vote=NULL")
 }

 func generateFestaTimestamps(s *Session, start uint32, debug bool) []uint32 {
@@ -141,13 +141,13 @@ func generateFestaTimestamps(s *Session, start uint32, debug bool) []uint32 {
 }

 type FestaTrial struct {
-	ID        uint32 `db:"id"`
-	Objective uint16 `db:"objective"`
-	GoalID    uint32 `db:"goal_id"`
-	TimesReq  uint16 `db:"times_req"`
-	Locale    uint16 `db:"locale_req"`
-	Reward    uint16 `db:"reward"`
-	Monopoly  uint16
+	ID        uint32         `db:"id"`
+	Objective uint16         `db:"objective"`
+	GoalID    uint32         `db:"goal_id"`
+	TimesReq  uint16         `db:"times_req"`
+	Locale    uint16         `db:"locale_req"`
+	Reward    uint16         `db:"reward"`
+	Monopoly  FestivalColour `db:"monopoly"`
 	Unk       uint16
 }

@@ -205,7 +205,19 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {

 	var trials []FestaTrial
 	var trial FestaTrial
-	rows, _ = s.server.db.Queryx("SELECT * FROM festa_trials")
+	rows, _ = s.server.db.Queryx(`SELECT ft.*,
+		COALESCE(CASE
+			WHEN COUNT(gc.id) FILTER (WHERE fr.team = 'blue' AND gc.trial_vote = ft.id) >
+				 COUNT(gc.id) FILTER (WHERE fr.team = 'red' AND gc.trial_vote = ft.id)
+			THEN CAST('blue' AS public.festival_colour)
+			WHEN COUNT(gc.id) FILTER (WHERE fr.team = 'red' AND gc.trial_vote = ft.id) >
+				 COUNT(gc.id) FILTER (WHERE fr.team = 'blue' AND gc.trial_vote = ft.id)
+			THEN CAST('red' AS public.festival_colour)
+		END, CAST('none' AS public.festival_colour)) AS monopoly
+		FROM public.festa_trials ft
+		LEFT JOIN public.guild_characters gc ON ft.id = gc.trial_vote
+		LEFT JOIN public.festa_registrations fr ON gc.guild_id = fr.guild_id
+		GROUP BY ft.id`)
 	for rows.Next() {
 		err := rows.StructScan(&trial)
 		if err != nil {
@@ -221,12 +233,12 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 		bf.WriteUint16(trial.TimesReq)
 		bf.WriteUint16(trial.Locale)
 		bf.WriteUint16(trial.Reward)
-		trial.Monopoly = 0xFFFF // NYI
-		bf.WriteUint16(trial.Monopoly)
+		bf.WriteInt16(int16(FestivalColourCodes[trial.Monopoly]))
 		bf.WriteUint16(trial.Unk)
 	}

 	// The Winner and Loser Armor IDs are missing
+	// Item 7011 may not exist in older versions, remove to prevent crashes
 	rewards := []FestaReward{
 		{1, 0, 7, 350, 1520, 0, 0, 0},
 		{1, 0, 7, 1000, 7011, 0, 0, 1},
@@ -254,6 +266,7 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 		{5, 0, 13, 0, 0, 0, 0, 0},
 		//{5, 0, 1, 0, 0, 0, 0, 0},
 	}
+
 	bf.WriteUint16(uint16(len(rewards)))
 	for _, reward := range rewards {
 		bf.WriteUint8(reward.Unk0)
@@ -261,11 +274,13 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 		bf.WriteUint16(reward.ItemType)
 		bf.WriteUint16(reward.Quantity)
 		bf.WriteUint16(reward.ItemID)
-		bf.WriteUint16(reward.Unk5)
-		bf.WriteUint16(reward.Unk6)
-		bf.WriteUint8(reward.Unk7)
+		// Not confirmed to be G1 but exists in G3
+		if _config.ErupeConfig.RealClientMode >= _config.G1 {
+			bf.WriteUint16(reward.Unk5)
+			bf.WriteUint16(reward.Unk6)
+			bf.WriteUint8(reward.Unk7)
+		}
 	}
-
 	if _config.ErupeConfig.RealClientMode <= _config.G61 {
 		if s.server.erupeConfig.GameplayOptions.MaximumFP > 0xFFFF {
 			s.server.erupeConfig.GameplayOptions.MaximumFP = 0xFFFF
@@ -294,17 +309,17 @@ func handleMsgMhfInfoFesta(s *Session, p mhfpacket.MHFPacket) {
 		ps.Uint8(bf, "", true) // Guild Name
 	}

-	// Unknown values
-	bf.WriteUint32(1)
-	bf.WriteUint32(5000)
-	bf.WriteUint32(2000)
-	bf.WriteUint32(1000)
-	bf.WriteUint32(100)
-	bf.WriteUint16(300)
-	bf.WriteUint16(200)
-	bf.WriteUint16(150)
-	bf.WriteUint16(100)
-	bf.WriteUint16(50)
+	// Final bonus rates
+	bf.WriteUint32(1)    // 5000-Infinity?
+	bf.WriteUint32(5000) // 5000+ souls
+	bf.WriteUint32(2000) // 2000-4999 souls
+	bf.WriteUint32(1000) // 1000-1999 souls
+	bf.WriteUint32(100)  // 100-999 souls
+	bf.WriteUint16(300)  // 300% bonus
+	bf.WriteUint16(200)  // 200% bonus
+	bf.WriteUint16(150)  // 150% bonus
+	bf.WriteUint16(100)  // Normal rate
+	bf.WriteUint16(50)   // 50% penalty

 	ps.Uint16(bf, "", false)
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
@@ -391,6 +406,7 @@ func handleMsgMhfEnumerateFestaMember(s *Session, p mhfpacket.MHFPacket) {

 func handleMsgMhfVoteFesta(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfVoteFesta)
+	s.server.db.Exec(`UPDATE guild_characters SET trial_vote=$1 WHERE character_id=$2`, pkt.TrialID, s.charID)
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

--- a/server/channelserver/handlers_guild.go
+++ b/server/channelserver/handlers_guild.go
@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"database/sql/driver"
 	"encoding/binary"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	_config "erupe-ce/config"
@@ -26,14 +25,14 @@ type FestivalColour string

 const (
 	FestivalColourNone FestivalColour = "none"
-	FestivalColourRed  FestivalColour = "red"
 	FestivalColourBlue FestivalColour = "blue"
+	FestivalColourRed  FestivalColour = "red"
 )

-var FestivalColourCodes = map[FestivalColour]uint8{
-	FestivalColourBlue: 0x00,
-	FestivalColourRed:  0x01,
-	FestivalColourNone: 0xFF,
+var FestivalColourCodes = map[FestivalColour]int8{
+	FestivalColourNone: -1,
+	FestivalColourBlue: 0,
+	FestivalColourRed:  1,
 }

 type GuildApplicationType string
@@ -968,7 +967,7 @@ func handleMsgMhfInfoGuild(s *Session, p mhfpacket.MHFPacket) {
 		bf.WriteUint8(uint8(len(guildLeaderName)))
 		bf.WriteBytes(guildName)
 		bf.WriteBytes(guildComment)
-		bf.WriteUint8(FestivalColourCodes[guild.FestivalColour])
+		bf.WriteInt8(FestivalColourCodes[guild.FestivalColour])
 		bf.WriteUint32(guild.RankRP)
 		bf.WriteBytes(guildLeaderName)
 		bf.WriteUint32(0)   // Unk
@@ -990,20 +989,21 @@ func handleMsgMhfInfoGuild(s *Session, p mhfpacket.MHFPacket) {
 		}
 		bf.WriteUint32(guild.PugiOutfits)

-		if guild.Rank() >= 3 {
-			bf.WriteUint8(40)
-		} else if guild.Rank() >= 7 {
-			bf.WriteUint8(50)
-		} else if guild.Rank() >= 10 {
-			bf.WriteUint8(60)
-		} else {
-			bf.WriteUint8(30)
+		limit := s.server.erupeConfig.GameplayOptions.ClanMemberLimits[0][1]
+		for _, j := range s.server.erupeConfig.GameplayOptions.ClanMemberLimits {
+			if guild.Rank() >= uint16(j[0]) {
+				limit = j[1]
+			}
 		}
+		if limit > 100 {
+			limit = 100
+		}
+		bf.WriteUint8(limit)

 		bf.WriteUint32(55000)
 		bf.WriteUint32(0)
 		bf.WriteUint16(0) // Changing Room RP
-		bf.WriteUint16(0)
+		bf.WriteUint16(0) // Ignored

 		if guild.AllianceID > 0 {
 			alliance, err := GetAllianceData(s, guild.AllianceID)
@@ -1013,7 +1013,7 @@ func handleMsgMhfInfoGuild(s *Session, p mhfpacket.MHFPacket) {
 				bf.WriteUint32(alliance.ID)
 				bf.WriteUint32(uint32(alliance.CreatedAt.Unix()))
 				bf.WriteUint16(alliance.TotalMembers)
-				bf.WriteUint8(0)
+				bf.WriteUint8(0) // Ignored
 				bf.WriteUint8(0)
 				ps.Uint16(bf, alliance.Name, true)
 				if alliance.SubGuild1ID > 0 {
@@ -1148,7 +1148,6 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 	var alliances []*GuildAlliance
 	var rows *sqlx.Rows
 	var err error
-	bf := byteframe.NewByteFrameFromBytes(pkt.Data1)

 	if pkt.Type <= 8 {
 		var tempGuilds []*Guild
@@ -1165,20 +1164,20 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 		switch pkt.Type {
 		case mhfpacket.ENUMERATE_GUILD_TYPE_GUILD_NAME:
 			for _, guild := range tempGuilds {
-				if strings.Contains(guild.Name, pkt.Data2) {
+				if strings.Contains(guild.Name, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
 					guilds = append(guilds, guild)
 				}
 			}
 		case mhfpacket.ENUMERATE_GUILD_TYPE_LEADER_NAME:
 			for _, guild := range tempGuilds {
-				if strings.Contains(guild.LeaderName, pkt.Data2) {
+				if strings.Contains(guild.LeaderName, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
 					guilds = append(guilds, guild)
 				}
 			}
 		case mhfpacket.ENUMERATE_GUILD_TYPE_LEADER_ID:
-			ID := bf.ReadUint32()
+			CID := pkt.Data1.ReadUint32()
 			for _, guild := range tempGuilds {
-				if guild.LeaderCharID == ID {
+				if guild.LeaderCharID == CID {
 					guilds = append(guilds, guild)
 				}
 			}
@@ -1216,15 +1215,15 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 			}
 			guilds = tempGuilds
 		case mhfpacket.ENUMERATE_GUILD_TYPE_MOTTO:
-			mainMotto := uint8(bf.ReadUint16())
-			subMotto := uint8(bf.ReadUint16())
+			mainMotto := uint8(pkt.Data1.ReadUint16())
+			subMotto := uint8(pkt.Data1.ReadUint16())
 			for _, guild := range tempGuilds {
 				if guild.MainMotto == mainMotto && guild.SubMotto == subMotto {
 					guilds = append(guilds, guild)
 				}
 			}
 		case mhfpacket.ENUMERATE_GUILD_TYPE_RECRUITING:
-			recruitingMotto := uint8(bf.ReadUint16())
+			recruitingMotto := uint8(pkt.Data1.ReadUint16())
 			for _, guild := range tempGuilds {
 				if guild.MainMotto == recruitingMotto {
 					guilds = append(guilds, guild)
@@ -1245,20 +1244,20 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 		switch pkt.Type {
 		case mhfpacket.ENUMERATE_ALLIANCE_TYPE_ALLIANCE_NAME:
 			for _, alliance := range tempAlliances {
-				if strings.Contains(alliance.Name, pkt.Data2) {
+				if strings.Contains(alliance.Name, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
 					alliances = append(alliances, alliance)
 				}
 			}
 		case mhfpacket.ENUMERATE_ALLIANCE_TYPE_LEADER_NAME:
 			for _, alliance := range tempAlliances {
-				if strings.Contains(alliance.ParentGuild.LeaderName, pkt.Data2) {
+				if strings.Contains(alliance.ParentGuild.LeaderName, stringsupport.SJISToUTF8(pkt.Data2.ReadNullTerminatedBytes())) {
 					alliances = append(alliances, alliance)
 				}
 			}
 		case mhfpacket.ENUMERATE_ALLIANCE_TYPE_LEADER_ID:
-			ID := bf.ReadUint32()
+			CID := pkt.Data1.ReadUint32()
 			for _, alliance := range tempAlliances {
-				if alliance.ParentGuild.LeaderCharID == ID {
+				if alliance.ParentGuild.LeaderCharID == CID {
 					alliances = append(alliances, alliance)
 				}
 			}
@@ -1292,7 +1291,7 @@ func handleMsgMhfEnumerateGuild(s *Session, p mhfpacket.MHFPacket) {
 		return
 	}

-	bf = byteframe.NewByteFrame()
+	bf := byteframe.NewByteFrame()

 	if pkt.Type > 8 {
 		hasNextPage := false
@@ -1437,7 +1436,7 @@ func handleMsgMhfEnumerateGuildMember(s *Session, p mhfpacket.MHFPacket) {
 	for _, member := range guildMembers {
 		bf.WriteUint32(member.CharID)
 		bf.WriteUint16(member.HRP)
-		if s.server.erupeConfig.RealClientMode > _config.G7 {
+		if s.server.erupeConfig.RealClientMode >= _config.G10 {
 			bf.WriteUint16(member.GR)
 		}
 		if s.server.erupeConfig.RealClientMode < _config.ZZ {
@@ -1559,7 +1558,7 @@ func handleMsgMhfEnumerateGuildItem(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuildItem)
 	var boxContents []byte
 	bf := byteframe.NewByteFrame()
-	err := s.server.db.QueryRow("SELECT item_box FROM guilds WHERE id = $1", int(pkt.GuildId)).Scan(&boxContents)
+	err := s.server.db.QueryRow("SELECT item_box FROM guilds WHERE id = $1", pkt.GuildID).Scan(&boxContents)
 	if err != nil {
 		s.logger.Error("Failed to get guild item box contents from db", zap.Error(err))
 		bf.WriteBytes(make([]byte, 4))
@@ -1593,7 +1592,7 @@ func handleMsgMhfUpdateGuildItem(s *Session, p mhfpacket.MHFPacket) {
 	// Get item cache from DB
 	var boxContents []byte
 	var oldItems []Item
-	err := s.server.db.QueryRow("SELECT item_box FROM guilds WHERE id = $1", int(pkt.GuildId)).Scan(&boxContents)
+	err := s.server.db.QueryRow("SELECT item_box FROM guilds WHERE id = $1", pkt.GuildID).Scan(&boxContents)
 	if err != nil {
 		s.logger.Error("Failed to get guild item box contents from db", zap.Error(err))
 		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
@@ -1610,16 +1609,16 @@ func handleMsgMhfUpdateGuildItem(s *Session, p mhfpacket.MHFPacket) {
 	// Update item stacks
 	newItems := make([]Item, len(oldItems))
 	copy(newItems, oldItems)
-	for i := 0; i < int(pkt.Amount); i++ {
+	for i := 0; i < len(pkt.Items); i++ {
 		for j := 0; j <= len(oldItems); j++ {
 			if j == len(oldItems) {
 				var newItem Item
-				newItem.ItemId = pkt.Items[i].ItemId
+				newItem.ItemId = pkt.Items[i].ItemID
 				newItem.Amount = pkt.Items[i].Amount
 				newItems = append(newItems, newItem)
 				break
 			}
-			if pkt.Items[i].ItemId == oldItems[j].ItemId {
+			if pkt.Items[i].ItemID == oldItems[j].ItemId {
 				newItems[j].Amount = pkt.Items[i].Amount
 				break
 			}
@@ -1643,7 +1642,7 @@ func handleMsgMhfUpdateGuildItem(s *Session, p mhfpacket.MHFPacket) {
 	}

 	// Upload new item cache
-	_, err = s.server.db.Exec("UPDATE guilds SET item_box = $1 WHERE id = $2", bf.Data(), int(pkt.GuildId))
+	_, err = s.server.db.Exec("UPDATE guilds SET item_box = $1 WHERE id = $2", bf.Data(), pkt.GuildID)
 	if err != nil {
 		s.logger.Error("Failed to update guild item box contents in db", zap.Error(err))
 	}
@@ -1678,7 +1677,7 @@ func handleMsgMhfUpdateGuildIcon(s *Session, p mhfpacket.MHFPacket) {

 	icon := &GuildIcon{}

-	icon.Parts = make([]GuildIconPart, pkt.PartCount)
+	icon.Parts = make([]GuildIconPart, len(pkt.IconParts))

 	for i, p := range pkt.IconParts {
 		icon.Parts[i] = GuildIconPart{
@@ -1723,16 +1722,51 @@ func handleMsgMhfReadGuildcard(s *Session, p mhfpacket.MHFPacket) {
 	doAckBufSucceed(s, pkt.AckHandle, resp.Data())
 }

+type GuildMission struct {
+	ID          uint32
+	Unk         uint32
+	Type        uint16
+	Goal        uint16
+	Quantity    uint16
+	SkipTickets uint16
+	GR          bool
+	RewardType  uint16
+	RewardLevel uint16
+}
+
 func handleMsgMhfGetGuildMissionList(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildMissionList)
-
-	decoded, err := hex.DecodeString("000694610000023E000112990023000100000200015DDD232100069462000002F30000005F000C000200000300025DDD232100069463000002EA0000005F0006000100000100015DDD23210006946400000245000000530010000200000400025DDD232100069465000002B60001129B0019000100000200015DDD232100069466000003DC0000001B0010000100000600015DDD232100069467000002DA000112A00019000100000400015DDD232100069468000002A800010DEF0032000200000200025DDD2321000694690000045500000022003C000200000600025DDD23210006946A00000080000122D90046000200000300025DDD23210006946B000001960000003B000A000100000100015DDD23210006946C0000049200000046005A000300000600035DDD23210006946D000000A4000000260018000200000600025DDD23210006946E0000017A00010DE40096000300000100035DDD23210006946F000001BE0000005E0014000200000400025DDD2355000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
-
-	if err != nil {
-		panic(err)
+	bf := byteframe.NewByteFrame()
+	missions := []GuildMission{
+		{431201, 574, 1, 4761, 35, 1, false, 2, 1},
+		{431202, 755, 0, 95, 12, 2, false, 3, 2},
+		{431203, 746, 0, 95, 6, 1, false, 1, 1},
+		{431204, 581, 0, 83, 16, 2, false, 4, 2},
+		{431205, 694, 1, 4763, 25, 1, false, 2, 1},
+		{431206, 988, 0, 27, 16, 1, false, 6, 1},
+		{431207, 730, 1, 4768, 25, 1, false, 4, 1},
+		{431208, 680, 1, 3567, 50, 2, false, 2, 2},
+		{431209, 1109, 0, 34, 60, 2, false, 6, 2},
+		{431210, 128, 1, 8921, 70, 2, false, 3, 2},
+		{431211, 406, 0, 59, 10, 1, false, 1, 1},
+		{431212, 1170, 0, 70, 90, 3, false, 6, 3},
+		{431213, 164, 0, 38, 24, 2, false, 6, 2},
+		{431214, 378, 1, 3556, 150, 3, false, 1, 3},
+		{431215, 446, 0, 94, 20, 2, false, 4, 2},
 	}
-
-	doAckBufSucceed(s, pkt.AckHandle, decoded)
+	for _, mission := range missions {
+		bf.WriteUint32(mission.ID)
+		bf.WriteUint32(mission.Unk)
+		bf.WriteUint16(mission.Type)
+		bf.WriteUint16(mission.Goal)
+		bf.WriteUint16(mission.Quantity)
+		bf.WriteUint16(mission.SkipTickets)
+		bf.WriteBool(mission.GR)
+		bf.WriteUint16(mission.RewardType)
+		bf.WriteUint16(mission.RewardLevel)
+		bf.WriteUint32(uint32(TimeAdjusted().Unix()))
+	}
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

 func handleMsgMhfGetGuildMissionRecord(s *Session, p mhfpacket.MHFPacket) {
@@ -1798,18 +1832,18 @@ func handleMsgMhfLoadGuildCooking(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgMhfRegistGuildCooking(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegistGuildCooking)
 	guild, _ := GetGuildInfoByCharacterId(s, s.charID)
-	currentTime := TimeAdjusted().Add(time.Duration(s.server.erupeConfig.GameplayOptions.GuildMealDuration-60) * time.Minute)
+	startTime := TimeAdjusted().Add(time.Duration(s.server.erupeConfig.GameplayOptions.ClanMealDuration-3600) * time.Second)
 	if pkt.OverwriteID != 0 {
-		s.server.db.Exec("UPDATE guild_meals SET meal_id = $1, level = $2, created_at = $3 WHERE id = $4", pkt.MealID, pkt.Success, currentTime, pkt.OverwriteID)
+		s.server.db.Exec("UPDATE guild_meals SET meal_id = $1, level = $2, created_at = $3 WHERE id = $4", pkt.MealID, pkt.Success, startTime, pkt.OverwriteID)
 	} else {
-		s.server.db.QueryRow("INSERT INTO guild_meals (guild_id, meal_id, level, created_at) VALUES ($1, $2, $3, $4) RETURNING id", guild.ID, pkt.MealID, pkt.Success, currentTime).Scan(&pkt.OverwriteID)
+		s.server.db.QueryRow("INSERT INTO guild_meals (guild_id, meal_id, level, created_at) VALUES ($1, $2, $3, $4) RETURNING id", guild.ID, pkt.MealID, pkt.Success, startTime).Scan(&pkt.OverwriteID)
 	}
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(1)
 	bf.WriteUint32(pkt.OverwriteID)
 	bf.WriteUint32(uint32(pkt.MealID))
 	bf.WriteUint32(uint32(pkt.Success))
-	bf.WriteUint32(uint32(currentTime.Unix()))
+	bf.WriteUint32(uint32(startTime.Unix()))
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

@@ -1817,14 +1851,14 @@ func handleMsgMhfGetGuildWeeklyBonusMaster(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildWeeklyBonusMaster)

 	// Values taken from brand new guild capture
-	doAckBufSucceed(s, pkt.AckHandle, make([]byte, 0x28))
+	doAckBufSucceed(s, pkt.AckHandle, make([]byte, 40))
 }
 func handleMsgMhfGetGuildWeeklyBonusActiveCount(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildWeeklyBonusActiveCount)
 	bf := byteframe.NewByteFrame()
-	bf.WriteUint8(0x3C) // Active count
-	bf.WriteUint8(0x3C) // Current active count
-	bf.WriteUint8(0x00) // New active count
+	bf.WriteUint8(60) // Active count
+	bf.WriteUint8(60) // Current active count
+	bf.WriteUint8(0)  // New active count
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

@@ -1832,18 +1866,54 @@ func handleMsgMhfGuildHuntdata(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGuildHuntdata)
 	bf := byteframe.NewByteFrame()
 	switch pkt.Operation {
-	case 0: // Unk
-		doAckBufSucceed(s, pkt.AckHandle, []byte{})
-	case 1: // Get Huntdata
+	case 0: // Acquire
+		s.server.db.Exec(`UPDATE guild_characters SET box_claimed=$1 WHERE character_id=$2`, TimeAdjusted(), s.charID)
+	case 1: // Enumerate
 		bf.WriteUint8(0) // Entries
-		/* Entry format
-		uint32 UnkID
-		uint32 MonID
-		*/
-		doAckBufSucceed(s, pkt.AckHandle, bf.Data())
-	case 2: // Unk, controls glow
-		doAckBufSucceed(s, pkt.AckHandle, []byte{0x00, 0x00})
+		rows, err := s.server.db.Query(`SELECT kl.id, kl.monster FROM kill_logs kl
+			INNER JOIN guild_characters gc ON kl.character_id = gc.character_id
+			WHERE gc.guild_id=$1
+			AND kl.timestamp >= (SELECT box_claimed FROM guild_characters WHERE character_id=$2)
+		`, pkt.GuildID, s.charID)
+		if err == nil {
+			var count uint8
+			var huntID, monID uint32
+			for rows.Next() {
+				err = rows.Scan(&huntID, &monID)
+				if err != nil {
+					continue
+				}
+				count++
+				if count > 255 {
+					count = 255
+					rows.Close()
+					break
+				}
+				bf.WriteUint32(huntID)
+				bf.WriteUint32(monID)
+			}
+			bf.Seek(0, 0)
+			bf.WriteUint8(count)
+		}
+	case 2: // Check
+		guild, err := GetGuildInfoByCharacterId(s, s.charID)
+		if err == nil {
+			var count uint8
+			err = s.server.db.QueryRow(`SELECT COUNT(*) FROM kill_logs kl
+				INNER JOIN guild_characters gc ON kl.character_id = gc.character_id
+				WHERE gc.guild_id=$1
+				AND kl.timestamp >= (SELECT box_claimed FROM guild_characters WHERE character_id=$2)
+			`, guild.ID, s.charID).Scan(&count)
+			if err == nil && count > 0 {
+				bf.WriteBool(true)
+			} else {
+				bf.WriteBool(false)
+			}
+		} else {
+			bf.WriteBool(false)
+		}
 	}
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

 type MessageBoardPost struct {
--- a/server/channelserver/handlers_guild_alliance.go
+++ b/server/channelserver/handlers_guild_alliance.go
@@ -162,8 +162,7 @@ func handleMsgMhfOperateJoint(s *Session, p mhfpacket.MHFPacket) {
 		}
 	case mhfpacket.OPERATE_JOINT_KICK:
 		if alliance.ParentGuild.LeaderCharID == s.charID {
-			_ = pkt.UnkData.ReadUint8()
-			kickedGuildID := pkt.UnkData.ReadUint32()
+			kickedGuildID := pkt.Data1.ReadUint32()
 			if kickedGuildID == alliance.SubGuild1ID && alliance.SubGuild2ID > 0 {
 				s.server.db.Exec(`UPDATE guild_alliances SET sub1_id = sub2_id, sub2_id = NULL WHERE id = $1`, alliance.ID)
 			} else if kickedGuildID == alliance.SubGuild1ID && alliance.SubGuild2ID == 0 {
--- a/server/channelserver/handlers_guild_tresure.go
+++ b/server/channelserver/handlers_guild_tresure.go
@@ -4,72 +4,79 @@ import (
 	"erupe-ce/common/byteframe"
 	"erupe-ce/common/stringsupport"
 	"erupe-ce/network/mhfpacket"
+	"time"
 )

 type TreasureHunt struct {
-	HuntID      uint32 `db:"id"`
-	HostID      uint32 `db:"host_id"`
-	Destination uint32 `db:"destination"`
-	Level       uint32 `db:"level"`
-	Return      uint32 `db:"return"`
-	Acquired    bool   `db:"acquired"`
-	Claimed     bool   `db:"claimed"`
-	Hunters     string `db:"hunters"`
-	Treasure    string `db:"treasure"`
-	HuntData    []byte `db:"hunt_data"`
+	HuntID      uint32    `db:"id"`
+	HostID      uint32    `db:"host_id"`
+	Destination uint32    `db:"destination"`
+	Level       uint32    `db:"level"`
+	Start       time.Time `db:"start"`
+	Acquired    bool      `db:"acquired"`
+	Collected   bool      `db:"collected"`
+	HuntData    []byte    `db:"hunt_data"`
+	Hunters     uint32    `db:"hunters"`
+	Claimed     bool      `db:"claimed"`
 }

 func handleMsgMhfEnumerateGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateGuildTresure)
 	guild, err := GetGuildInfoByCharacterId(s, s.charID)
-	if err != nil {
-		panic(err)
+	if err != nil || guild == nil {
+		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 4))
+		return
+	}
+	var hunts []TreasureHunt
+	var hunt TreasureHunt
+
+	switch pkt.MaxHunts {
+	case 1:
+		err = s.server.db.QueryRowx(`SELECT id, host_id, destination, level, start, hunt_data FROM guild_hunts WHERE host_id=$1 AND acquired=FALSE`, s.charID).StructScan(&hunt)
+		if err == nil {
+			hunts = append(hunts, hunt)
+		}
+	case 30:
+		rows, err := s.server.db.Queryx(`SELECT gh.id, gh.host_id, gh.destination, gh.level, gh.start, gh.collected, gh.hunt_data,
+			(SELECT COUNT(*) FROM guild_characters gc WHERE gc.treasure_hunt = gh.id AND gc.character_id <> $1) AS hunters,
+			CASE
+				WHEN ghc.character_id IS NOT NULL THEN true
+				ELSE false
+			END AS claimed
+			FROM guild_hunts gh
+			LEFT JOIN guild_hunts_claimed ghc ON gh.id = ghc.hunt_id AND ghc.character_id = $1
+			WHERE gh.guild_id=$2 AND gh.level=2 AND gh.acquired=TRUE
+		`, s.charID, guild.ID)
+		if err != nil {
+			rows.Close()
+			doAckBufSucceed(s, pkt.AckHandle, make([]byte, 4))
+			return
+		} else {
+			for rows.Next() {
+				err = rows.StructScan(&hunt)
+				if err == nil && hunt.Start.Add(time.Second*time.Duration(s.server.erupeConfig.GameplayOptions.TreasureHuntExpiry)).After(TimeAdjusted()) {
+					hunts = append(hunts, hunt)
+				}
+			}
+		}
+		if len(hunts) > 30 {
+			hunts = hunts[:30]
+		}
 	}
 	bf := byteframe.NewByteFrame()
-	hunts := 0
-	rows, _ := s.server.db.Queryx("SELECT id, host_id, destination, level, return, acquired, claimed, hunters, treasure, hunt_data FROM guild_hunts WHERE guild_id=$1 AND $2 < return+604800", guild.ID, TimeAdjusted().Unix())
-	for rows.Next() {
-		hunt := &TreasureHunt{}
-		err = rows.StructScan(&hunt)
-		// Remove self from other hunter count
-		hunt.Hunters = stringsupport.CSVRemove(hunt.Hunters, int(s.charID))
-		if err != nil {
-			panic(err)
-		}
-		if pkt.MaxHunts == 1 {
-			if hunt.HostID != s.charID || hunt.Acquired {
-				continue
-			}
-			hunts++
-			bf.WriteUint32(hunt.HuntID)
-			bf.WriteUint32(hunt.Destination)
-			bf.WriteUint32(hunt.Level)
-			bf.WriteUint32(uint32(stringsupport.CSVLength(hunt.Hunters)))
-			bf.WriteUint32(hunt.Return)
-			bf.WriteBool(false)
-			bf.WriteBool(false)
-			bf.WriteBytes(hunt.HuntData)
-			break
-		} else if pkt.MaxHunts == 30 && hunt.Acquired && hunt.Level == 2 {
-			if hunts == 30 {
-				break
-			}
-			hunts++
-			bf.WriteUint32(hunt.HuntID)
-			bf.WriteUint32(hunt.Destination)
-			bf.WriteUint32(hunt.Level)
-			bf.WriteUint32(uint32(stringsupport.CSVLength(hunt.Hunters)))
-			bf.WriteUint32(hunt.Return)
-			bf.WriteBool(hunt.Claimed)
-			bf.WriteBool(stringsupport.CSVContains(hunt.Treasure, int(s.charID)))
-			bf.WriteBytes(hunt.HuntData)
-		}
+	bf.WriteUint16(uint16(len(hunts)))
+	bf.WriteUint16(uint16(len(hunts)))
+	for _, h := range hunts {
+		bf.WriteUint32(h.HuntID)
+		bf.WriteUint32(h.Destination)
+		bf.WriteUint32(h.Level)
+		bf.WriteUint32(h.Hunters)
+		bf.WriteUint32(uint32(h.Start.Unix()))
+		bf.WriteBool(h.Collected)
+		bf.WriteBool(h.Claimed)
+		bf.WriteBytes(h.HuntData)
 	}
-	resp := byteframe.NewByteFrame()
-	resp.WriteUint16(uint16(hunts))
-	resp.WriteUint16(uint16(hunts))
-	resp.WriteBytes(bf.Data())
-	doAckBufSucceed(s, pkt.AckHandle, resp.Data())
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

 func handleMsgMhfRegistGuildTresure(s *Session, p mhfpacket.MHFPacket) {
@@ -77,8 +84,9 @@ func handleMsgMhfRegistGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 	bf := byteframe.NewByteFrameFromBytes(pkt.Data)
 	huntData := byteframe.NewByteFrame()
 	guild, err := GetGuildInfoByCharacterId(s, s.charID)
-	if err != nil {
-		panic(err)
+	if err != nil || guild == nil {
+		doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
+		return
 	}
 	guildCats := getGuildAirouList(s)
 	destination := bf.ReadUint32()
@@ -92,87 +100,55 @@ func handleMsgMhfRegistGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 		if catID > 0 {
 			catsUsed = stringsupport.CSVAdd(catsUsed, int(catID))
 			for _, cat := range guildCats {
-				if cat.CatID == catID {
-					huntData.WriteBytes(cat.CatName)
+				if cat.ID == catID {
+					huntData.WriteBytes(cat.Name)
 					break
 				}
 			}
 			huntData.WriteBytes(bf.ReadBytes(9))
 		}
 	}
-	_, err = s.server.db.Exec("INSERT INTO guild_hunts (guild_id, host_id, destination, level, return, hunt_data, cats_used) VALUES ($1, $2, $3, $4, $5, $6, $7)",
-		guild.ID, s.charID, destination, level, TimeAdjusted().Unix(), huntData.Data(), catsUsed)
-	if err != nil {
-		panic(err)
-	}
+	s.server.db.Exec(`INSERT INTO guild_hunts (guild_id, host_id, destination, level, hunt_data, cats_used) VALUES ($1, $2, $3, $4, $5, $6)
+		`, guild.ID, s.charID, destination, level, huntData.Data(), catsUsed)
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

 func handleMsgMhfAcquireGuildTresure(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireGuildTresure)
-	_, err := s.server.db.Exec("UPDATE guild_hunts SET acquired=true WHERE id=$1", pkt.HuntID)
-	if err != nil {
-		panic(err)
-	}
+	s.server.db.Exec(`UPDATE guild_hunts SET acquired=true WHERE id=$1`, pkt.HuntID)
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

-func treasureHuntUnregister(s *Session) {
-	guild, err := GetGuildInfoByCharacterId(s, s.charID)
-	if err != nil || guild == nil {
-		return
-	}
-	var huntID int
-	var hunters string
-	rows, err := s.server.db.Queryx("SELECT id, hunters FROM guild_hunts WHERE guild_id=$1", guild.ID)
-	if err != nil {
-		return
-	}
-	for rows.Next() {
-		rows.Scan(&huntID, &hunters)
-		hunters = stringsupport.CSVRemove(hunters, int(s.charID))
-		s.server.db.Exec("UPDATE guild_hunts SET hunters=$1 WHERE id=$2", hunters, huntID)
-	}
-}
-
 func handleMsgMhfOperateGuildTresureReport(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfOperateGuildTresureReport)
-	var csv string
-	if pkt.State == 0 { // Report registration
-		// Unregister from all other hunts
-		treasureHuntUnregister(s)
-		if pkt.HuntID != 0 {
-			// Register to selected hunt
-			err := s.server.db.QueryRow("SELECT hunters FROM guild_hunts WHERE id=$1", pkt.HuntID).Scan(&csv)
-			if err != nil {
-				panic(err)
-			}
-			csv = stringsupport.CSVAdd(csv, int(s.charID))
-			_, err = s.server.db.Exec("UPDATE guild_hunts SET hunters=$1 WHERE id=$2", csv, pkt.HuntID)
-			if err != nil {
-				panic(err)
-			}
-		}
-	} else if pkt.State == 1 { // Collected by hunter
-		s.server.db.Exec("UPDATE guild_hunts SET hunters='', claimed=true WHERE id=$1", pkt.HuntID)
-	} else if pkt.State == 2 { // Claim treasure
-		err := s.server.db.QueryRow("SELECT treasure FROM guild_hunts WHERE id=$1", pkt.HuntID).Scan(&csv)
-		if err != nil {
-			panic(err)
-		}
-		csv = stringsupport.CSVAdd(csv, int(s.charID))
-		_, err = s.server.db.Exec("UPDATE guild_hunts SET treasure=$1 WHERE id=$2", csv, pkt.HuntID)
-		if err != nil {
-			panic(err)
-		}
+	switch pkt.State {
+	case 0: // Report registration
+		s.server.db.Exec(`UPDATE guild_characters SET treasure_hunt=$1 WHERE character_id=$2`, pkt.HuntID, s.charID)
+	case 1: // Collected by hunter
+		s.server.db.Exec(`UPDATE guild_hunts SET collected=true WHERE id=$1`, pkt.HuntID)
+		s.server.db.Exec(`UPDATE guild_characters SET treasure_hunt=NULL WHERE treasure_hunt=$1`, pkt.HuntID)
+	case 2: // Claim treasure
+		s.server.db.Exec(`INSERT INTO guild_hunts_claimed VALUES ($1, $2)`, pkt.HuntID, s.charID)
 	}
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

+type TreasureSouvenir struct {
+	Destination uint32
+	Quantity    uint32
+}
+
 func handleMsgMhfGetGuildTresureSouvenir(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetGuildTresureSouvenir)
-
-	doAckBufSucceed(s, pkt.AckHandle, make([]byte, 6))
+	bf := byteframe.NewByteFrame()
+	bf.WriteUint32(0)
+	souvenirs := []TreasureSouvenir{}
+	bf.WriteUint16(uint16(len(souvenirs)))
+	for _, souvenir := range souvenirs {
+		bf.WriteUint32(souvenir.Destination)
+		bf.WriteUint32(souvenir.Quantity)
+	}
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

 func handleMsgMhfAcquireGuildTresureSouvenir(s *Session, p mhfpacket.MHFPacket) {
--- a/server/channelserver/handlers_house.go
+++ b/server/channelserver/handlers_house.go
@@ -121,7 +121,9 @@ func handleMsgMhfEnumerateHouse(s *Session, p mhfpacket.MHFPacket) {
 			bf.WriteUint8(0)
 		}
 		bf.WriteUint16(house.HRP)
-		bf.WriteUint16(house.GR)
+		if _config.ErupeConfig.RealClientMode >= _config.G10 {
+			bf.WriteUint16(house.GR)
+		}
 		ps.Uint8(bf, house.Name, true)
 	}
 	bf.Seek(0, 0)
@@ -215,10 +217,12 @@ func handleMsgMhfLoadHouse(s *Session, p mhfpacket.MHFPacket) {
 		bf.WriteBytes(houseFurniture)
 	case 10: // Garden
 		bf.WriteBytes(garden)
-		c, d := getGookData(s, pkt.CharID)
-		bf.WriteUint16(c)
+		goocoos := getGoocooData(s, pkt.CharID)
+		bf.WriteUint16(uint16(len(goocoos)))
 		bf.WriteUint16(0)
-		bf.WriteBytes(d)
+		for _, goocoo := range goocoos {
+			bf.WriteBytes(goocoo)
+		}
 	}
 	if len(bf.Data()) == 0 {
 		doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
@@ -240,8 +244,8 @@ func handleMsgMhfGetMyhouseInfo(s *Session, p mhfpacket.MHFPacket) {

 func handleMsgMhfUpdateMyhouseInfo(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfUpdateMyhouseInfo)
-	s.server.db.Exec("UPDATE user_binary SET mission=$1 WHERE id=$2", pkt.Unk0, s.charID)
-	doAckSimpleSucceed(s, pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
+	s.server.db.Exec("UPDATE user_binary SET mission=$1 WHERE id=$2", pkt.Data, s.charID)
+	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

 func handleMsgMhfLoadDecoMyset(s *Session, p mhfpacket.MHFPacket) {
@@ -252,71 +256,65 @@ func handleMsgMhfLoadDecoMyset(s *Session, p mhfpacket.MHFPacket) {
 		s.logger.Error("Failed to load decomyset", zap.Error(err))
 	}
 	if len(data) == 0 {
+		data = []byte{0x01, 0x00}
 		if s.server.erupeConfig.RealClientMode < _config.G10 {
 			data = []byte{0x00, 0x00}
 		}
-		data = []byte{0x01, 0x00}
 	}
 	doAckBufSucceed(s, pkt.AckHandle, data)
 }

 func handleMsgMhfSaveDecoMyset(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfSaveDecoMyset)
-	// https://gist.github.com/Andoryuuta/9c524da7285e4b5ca7e52e0fc1ca1daf
-	var loadData []byte
-	bf := byteframe.NewByteFrameFromBytes(pkt.RawDataPayload[1:]) // skip first unk byte
-	err := s.server.db.QueryRow("SELECT decomyset FROM characters WHERE id = $1", s.charID).Scan(&loadData)
+	var temp []byte
+	err := s.server.db.QueryRow("SELECT decomyset FROM characters WHERE id = $1", s.charID).Scan(&temp)
 	if err != nil {
 		s.logger.Error("Failed to load decomyset", zap.Error(err))
-	} else {
-		numSets := bf.ReadUint8() // sets being written
-		// empty save
-		if len(loadData) == 0 {
-			loadData = []byte{0x01, 0x00}
-		}
-
-		savedSets := loadData[1] // existing saved sets
-		// no sets, new slice with just first 2 bytes for appends later
-		if savedSets == 0 {
-			loadData = []byte{0x01, 0x00}
-		}
-		for i := 0; i < int(numSets); i++ {
-			writeSet := bf.ReadUint16()
-			dataChunk := bf.ReadBytes(76)
-			setBytes := append([]byte{uint8(writeSet >> 8), uint8(writeSet & 0xff)}, dataChunk...)
-			for x := 0; true; x++ {
-				if x == int(savedSets) {
-					// appending set
-					if loadData[len(loadData)-1] == 0x10 {
-						// sanity check for if there was a messy manual import
-						loadData = append(loadData[:len(loadData)-2], setBytes...)
-					} else {
-						loadData = append(loadData, setBytes...)
-					}
-					savedSets++
-					break
-				}
-				currentSet := loadData[3+(x*78)]
-				if int(currentSet) == int(writeSet) {
-					// replacing a set
-					loadData = append(loadData[:2+(x*78)], append(setBytes, loadData[2+((x+1)*78):]...)...)
-					break
-				} else if int(currentSet) > int(writeSet) {
-					// inserting before current set
-					loadData = append(loadData[:2+((x)*78)], append(setBytes, loadData[2+((x)*78):]...)...)
-					savedSets++
-					break
-				}
-			}
-			loadData[1] = savedSets // update set count
-		}
-		dumpSaveData(s, loadData, "decomyset")
-		_, err := s.server.db.Exec("UPDATE characters SET decomyset=$1 WHERE id=$2", loadData, s.charID)
-		if err != nil {
-			s.logger.Error("Failed to save decomyset", zap.Error(err))
-		}
+		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
+		return
 	}
-	doAckSimpleSucceed(s, pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
+
+	// Version handling
+	bf := byteframe.NewByteFrame()
+	var size uint
+	if s.server.erupeConfig.RealClientMode >= _config.G10 {
+		size = 76
+		bf.WriteUint8(1)
+	} else {
+		size = 68
+		bf.WriteUint8(0)
+	}
+
+	// Handle nil data
+	if len(temp) == 0 {
+		temp = append(bf.Data(), uint8(0))
+	}
+
+	// Build a map of set data
+	sets := make(map[uint16][]byte)
+	oldSets := byteframe.NewByteFrameFromBytes(temp[2:])
+	for i := uint8(0); i < temp[1]; i++ {
+		index := oldSets.ReadUint16()
+		sets[index] = oldSets.ReadBytes(size)
+	}
+
+	// Overwrite existing sets
+	newSets := byteframe.NewByteFrameFromBytes(pkt.RawDataPayload[2:])
+	for i := uint8(0); i < pkt.RawDataPayload[1]; i++ {
+		index := newSets.ReadUint16()
+		sets[index] = newSets.ReadBytes(size)
+	}
+
+	// Serialise the set data
+	bf.WriteUint8(uint8(len(sets)))
+	for u, b := range sets {
+		bf.WriteUint16(u)
+		bf.WriteBytes(b)
+	}
+
+	dumpSaveData(s, bf.Data(), "decomyset")
+	s.server.db.Exec("UPDATE characters SET decomyset=$1 WHERE id=$2", bf.Data(), s.charID)
+	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

 type Title struct {
@@ -355,12 +353,14 @@ func handleMsgMhfEnumerateTitle(s *Session, p mhfpacket.MHFPacket) {

 func handleMsgMhfAcquireTitle(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfAcquireTitle)
-	var exists int
-	err := s.server.db.QueryRow("SELECT count(*) FROM titles WHERE id=$1 AND char_id=$2", pkt.TitleID, s.charID).Scan(&exists)
-	if err != nil || exists == 0 {
-		s.server.db.Exec("INSERT INTO titles VALUES ($1, $2, now(), now())", pkt.TitleID, s.charID)
-	} else {
-		s.server.db.Exec("UPDATE titles SET updated_at=now()")
+	for _, title := range pkt.TitleIDs {
+		var exists int
+		err := s.server.db.QueryRow(`SELECT count(*) FROM titles WHERE id=$1 AND char_id=$2`, title, s.charID).Scan(&exists)
+		if err != nil || exists == 0 {
+			s.server.db.Exec(`INSERT INTO titles VALUES ($1, $2, now(), now())`, title, s.charID)
+		} else {
+			s.server.db.Exec(`UPDATE titles SET updated_at=now() WHERE id=$1 AND char_id=$2`, title, s.charID)
+		}
 	}
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }
--- a/server/channelserver/handlers_mail.go
+++ b/server/channelserver/handlers_mail.go
@@ -79,57 +79,6 @@ func (m *Mail) MarkRead(s *Session) error {
 	return nil
 }

-func (m *Mail) MarkDeleted(s *Session) error {
-	_, err := s.server.db.Exec(`
-		UPDATE mail SET deleted = true WHERE id = $1
-	`, m.ID)
-
-	if err != nil {
-		s.logger.Error(
-			"failed to mark mail as deleted",
-			zap.Error(err),
-			zap.Int("mailID", m.ID),
-		)
-		return err
-	}
-
-	return nil
-}
-
-func (m *Mail) MarkAcquired(s *Session) error {
-	_, err := s.server.db.Exec(`
-		UPDATE mail SET attached_item_received = true WHERE id = $1
-	`, m.ID)
-
-	if err != nil {
-		s.logger.Error(
-			"failed to mark mail item as claimed",
-			zap.Error(err),
-			zap.Int("mailID", m.ID),
-		)
-		return err
-	}
-
-	return nil
-}
-
-func (m *Mail) MarkLocked(s *Session, locked bool) error {
-	_, err := s.server.db.Exec(`
-		UPDATE mail SET locked = $1 WHERE id = $2
-	`, locked, m.ID)
-
-	if err != nil {
-		s.logger.Error(
-			"failed to mark mail as locked",
-			zap.Error(err),
-			zap.Int("mailID", m.ID),
-		)
-		return err
-	}
-
-	return nil
-}
-
 func GetMailListForCharacter(s *Session, charID uint32) ([]Mail, error) {
 	rows, err := s.server.db.Queryx(`
 		SELECT
@@ -256,26 +205,21 @@ func handleMsgMhfReadMail(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfReadMail)

 	mailId := s.mailList[pkt.AccIndex]
-
 	if mailId == 0 {
-		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
-		panic("attempting to read mail that doesn't exist in session map")
+		doAckBufSucceed(s, pkt.AckHandle, []byte{0})
+		return
 	}

 	mail, err := GetMailByID(s, mailId)
-
 	if err != nil {
-		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
-		panic(err)
+		doAckBufSucceed(s, pkt.AckHandle, []byte{0})
+		return
 	}

-	_ = mail.MarkRead(s)
-
+	s.server.db.Exec(`UPDATE mail SET read = true WHERE id = $1`, mail.ID)
 	bf := byteframe.NewByteFrame()
-
 	body := stringsupport.UTF8ToSJIS(mail.Body)
 	bf.WriteNullTerminatedBytes(body)
-
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

@@ -283,10 +227,9 @@ func handleMsgMhfListMail(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfListMail)

 	mail, err := GetMailListForCharacter(s, s.charID)
-
 	if err != nil {
-		doAckBufFail(s, pkt.AckHandle, make([]byte, 4))
-		panic(err)
+		doAckBufSucceed(s, pkt.AckHandle, []byte{0})
+		return
 	}

 	if s.mailList == nil {
@@ -354,24 +297,20 @@ func handleMsgMhfOprtMail(s *Session, p mhfpacket.MHFPacket) {

 	mail, err := GetMailByID(s, s.mailList[pkt.AccIndex])
 	if err != nil {
-		panic(err)
+		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
+		return
 	}

 	switch pkt.Operation {
-	case mhfpacket.OPERATE_MAIL_DELETE:
-		err = mail.MarkDeleted(s)
-	case mhfpacket.OPERATE_MAIL_LOCK:
-		err = mail.MarkLocked(s, true)
-	case mhfpacket.OPERATE_MAIL_UNLOCK:
-		err = mail.MarkLocked(s, false)
-	case mhfpacket.OPERATE_MAIL_ACQUIRE_ITEM:
-		err = mail.MarkAcquired(s)
+	case mhfpacket.OperateMailDelete:
+		s.server.db.Exec(`UPDATE mail SET deleted = true WHERE id = $1`, mail.ID)
+	case mhfpacket.OperateMailLock:
+		s.server.db.Exec(`UPDATE mail SET locked = TRUE WHERE id = $1`, mail.ID)
+	case mhfpacket.OperateMailUnlock:
+		s.server.db.Exec(`UPDATE mail SET locked = FALSE WHERE id = $1`, mail.ID)
+	case mhfpacket.OperateMailAcquireItem:
+		s.server.db.Exec(`UPDATE mail SET attached_item_received = TRUE WHERE id = $1`, mail.ID)
 	}
-
-	if err != nil {
-		panic(err)
-	}
-
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

--- a/server/channelserver/handlers_mercenary.go
+++ b/server/channelserver/handlers_mercenary.go
@@ -9,8 +9,6 @@ import (
 	"erupe-ce/server/channelserver/compression/nullcomp"
 	"go.uber.org/zap"
 	"io"
-	"os"
-	"path/filepath"
 	"time"
 )

@@ -299,18 +297,12 @@ func handleMsgMhfSaveOtomoAirou(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgMhfEnumerateAiroulist(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfEnumerateAiroulist)
 	resp := byteframe.NewByteFrame()
-	if _, err := os.Stat(filepath.Join(s.server.erupeConfig.BinPath, "airoulist.bin")); err == nil {
-		data, _ := os.ReadFile(filepath.Join(s.server.erupeConfig.BinPath, "airoulist.bin"))
-		resp.WriteBytes(data)
-		doAckBufSucceed(s, pkt.AckHandle, resp.Data())
-		return
-	}
 	airouList := getGuildAirouList(s)
 	resp.WriteUint16(uint16(len(airouList)))
 	resp.WriteUint16(uint16(len(airouList)))
 	for _, cat := range airouList {
-		resp.WriteUint32(cat.CatID)
-		resp.WriteBytes(cat.CatName)
+		resp.WriteUint32(cat.ID)
+		resp.WriteBytes(cat.Name)
 		resp.WriteUint32(cat.Experience)
 		resp.WriteUint8(cat.Personality)
 		resp.WriteUint8(cat.Class)
@@ -321,11 +313,10 @@ func handleMsgMhfEnumerateAiroulist(s *Session, p mhfpacket.MHFPacket) {
 	doAckBufSucceed(s, pkt.AckHandle, resp.Data())
 }

-// CatDefinition holds values needed to populate the guild cat list
-type CatDefinition struct {
-	CatID       uint32
-	CatName     []byte
-	CurrentTask uint8
+type Airou struct {
+	ID          uint32
+	Name        []byte
+	Task        uint8
 	Personality uint8
 	Class       uint8
 	Experience  uint32
@@ -333,46 +324,39 @@ type CatDefinition struct {
 	WeaponID    uint16
 }

-func getGuildAirouList(s *Session) []CatDefinition {
-	var guild *Guild
-	var err error
-	var guildCats []CatDefinition
-
-	// returning 0 cats on any guild issues
-	// can probably optimise all of the guild queries pretty heavily
-	guild, err = GetGuildInfoByCharacterId(s, s.charID)
+func getGuildAirouList(s *Session) []Airou {
+	var guildCats []Airou
+	bannedCats := make(map[uint32]int)
+	guild, err := GetGuildInfoByCharacterId(s, s.charID)
 	if err != nil {
 		return guildCats
 	}
-
-	// Get cats used recently
-	// Retail reset at midday, 12 hours is a midpoint
-	tempBanDuration := 43200 - (1800) // Minus hunt time
-	bannedCats := make(map[uint32]int)
-	var csvTemp string
-	rows, err := s.server.db.Query(`SELECT cats_used
-	FROM guild_hunts gh
-	INNER JOIN characters c
-	ON gh.host_id = c.id
-	WHERE c.id=$1 AND gh.return+$2>$3`, s.charID, tempBanDuration, TimeAdjusted().Unix())
+	rows, err := s.server.db.Query(`SELECT cats_used FROM guild_hunts gh
+		INNER JOIN characters c ON gh.host_id = c.id WHERE c.id=$1
+	`, s.charID)
 	if err != nil {
 		s.logger.Warn("Failed to get recently used airous", zap.Error(err))
+		return guildCats
 	}
+
+	var csvTemp string
+	var startTemp time.Time
 	for rows.Next() {
-		rows.Scan(&csvTemp)
-		for i, j := range stringsupport.CSVElems(csvTemp) {
-			bannedCats[uint32(j)] = i
+		err = rows.Scan(&csvTemp, &startTemp)
+		if err != nil {
+			continue
+		}
+		if startTemp.Add(time.Second * time.Duration(s.server.erupeConfig.GameplayOptions.TreasureHuntPartnyaCooldown)).Before(TimeAdjusted()) {
+			for i, j := range stringsupport.CSVElems(csvTemp) {
+				bannedCats[uint32(j)] = i
+			}
 		}
 	}

-	// ellie's GetGuildMembers didn't seem to pull leader?
-	rows, err = s.server.db.Query(`SELECT c.otomoairou
-	FROM characters c
-	INNER JOIN guild_characters gc
-	ON gc.character_id = c.id
+	rows, err = s.server.db.Query(`SELECT c.otomoairou FROM characters c
+	INNER JOIN guild_characters gc ON gc.character_id = c.id
 	WHERE gc.guild_id = $1 AND c.otomoairou IS NOT NULL
-	ORDER BY c.id ASC
-	LIMIT 60;`, guild.ID)
+	ORDER BY c.id LIMIT 60`, guild.ID)
 	if err != nil {
 		s.logger.Warn("Selecting otomoairou based on guild failed", zap.Error(err))
 		return guildCats
@@ -381,11 +365,7 @@ func getGuildAirouList(s *Session) []CatDefinition {
 	for rows.Next() {
 		var data []byte
 		err = rows.Scan(&data)
-		if err != nil {
-			s.logger.Warn("select failure", zap.Error(err))
-			continue
-		} else if len(data) == 0 {
-			// non extant cats that aren't null in DB
+		if err != nil || len(data) == 0 {
 			continue
 		}
 		// first byte has cat existence in general, can skip if 0
@@ -396,10 +376,10 @@ func getGuildAirouList(s *Session) []CatDefinition {
 				continue
 			}
 			bf := byteframe.NewByteFrameFromBytes(decomp)
-			cats := GetCatDetails(bf)
+			cats := GetAirouDetails(bf)
 			for _, cat := range cats {
-				_, exists := bannedCats[cat.CatID]
-				if cat.CurrentTask == 4 && !exists {
+				_, exists := bannedCats[cat.ID]
+				if cat.Task == 4 && !exists {
 					guildCats = append(guildCats, cat)
 				}
 			}
@@ -408,20 +388,20 @@ func getGuildAirouList(s *Session) []CatDefinition {
 	return guildCats
 }

-func GetCatDetails(bf *byteframe.ByteFrame) []CatDefinition {
+func GetAirouDetails(bf *byteframe.ByteFrame) []Airou {
 	catCount := bf.ReadUint8()
-	cats := make([]CatDefinition, catCount)
+	cats := make([]Airou, catCount)
 	for x := 0; x < int(catCount); x++ {
-		var catDef CatDefinition
+		var catDef Airou
 		// cat sometimes has additional bytes for whatever reason, gift items? timestamp?
 		// until actual variance is known we can just seek to end based on start
 		catDefLen := bf.ReadUint32()
 		catStart, _ := bf.Seek(0, io.SeekCurrent)

-		catDef.CatID = bf.ReadUint32()
-		bf.Seek(1, io.SeekCurrent)        // unknown value, probably a bool
-		catDef.CatName = bf.ReadBytes(18) // always 18 len, reads first null terminated string out of section and discards rest
-		catDef.CurrentTask = bf.ReadUint8()
+		catDef.ID = bf.ReadUint32()
+		bf.Seek(1, io.SeekCurrent)     // unknown value, probably a bool
+		catDef.Name = bf.ReadBytes(18) // always 18 len, reads first null terminated string out of section and discards rest
+		catDef.Task = bf.ReadUint8()
 		bf.Seek(16, io.SeekCurrent) // appearance data and what is seemingly null bytes
 		catDef.Personality = bf.ReadUint8()
 		catDef.Class = bf.ReadUint8()
--- a/server/channelserver/handlers_plate.go
+++ b/server/channelserver/handlers_plate.go
@@ -42,7 +42,7 @@ func handleMsgMhfSavePlateData(s *Session, p mhfpacket.MHFPacket) {
 			}
 		} else {
 			// create empty save if absent
-			data = make([]byte, 0x1AF20)
+			data = make([]byte, 140000)
 		}

 		// Perform diff and compress it to write back to db
@@ -110,7 +110,7 @@ func handleMsgMhfSavePlateBox(s *Session, p mhfpacket.MHFPacket) {
 			}
 		} else {
 			// create empty save if absent
-			data = make([]byte, 0x820)
+			data = make([]byte, 4800)
 		}

 		// Perform diff and compress it to write back to db
@@ -147,7 +147,7 @@ func handleMsgMhfLoadPlateMyset(s *Session, p mhfpacket.MHFPacket) {
 	err := s.server.db.QueryRow("SELECT platemyset FROM characters WHERE id = $1", s.charID).Scan(&data)
 	if len(data) == 0 {
 		s.logger.Error("Failed to load platemyset", zap.Error(err))
-		data = make([]byte, 0x780)
+		data = make([]byte, 1920)
 	}
 	doAckBufSucceed(s, pkt.AckHandle, data)
 }
--- a/server/channelserver/handlers_quest.go
+++ b/server/channelserver/handlers_quest.go
@@ -62,25 +62,30 @@ func handleMsgSysGetFile(s *Session, p mhfpacket.MHFPacket) {
 	}
 }

-func questSuffix(s *Session) string {
-	// Determine the letter to append for day / night
-	var timeSet string
-	if TimeGameAbsolute() > 2880 {
-		timeSet = "d"
-	} else {
-		timeSet = "n"
-	}
-	return fmt.Sprintf("%s%d", timeSet, s.server.Season())
-}
-
 func seasonConversion(s *Session, questFile string) string {
-	filename := fmt.Sprintf("%s%s", questFile[:5], questSuffix(s))
+	filename := fmt.Sprintf("%s%d", questFile[:6], s.server.Season())

-	// Return original file if file doesn't exist
-	if _, err := os.Stat(filename); err == nil {
+	// Return the seasonal file
+	if _, err := os.Stat(filepath.Join(s.server.erupeConfig.BinPath, fmt.Sprintf("quests/%s.bin", filename))); err == nil {
 		return filename
 	} else {
-		return questFile
+		// Attempt to return the requested quest file if the seasonal file doesn't exist
+		if _, err = os.Stat(filepath.Join(s.server.erupeConfig.BinPath, fmt.Sprintf("quests/%s.bin", questFile))); err == nil {
+			return questFile
+		}
+
+		// If the code reaches this point, it's most likely a custom quest with no seasonal variations in the files.
+		// Since event quests when seasonal pick day or night and the client requests either one, we need to differentiate between the two to prevent issues.
+		var _time string
+
+		if TimeGameAbsolute() > 2880 {
+			_time = "d"
+		} else {
+			_time = "n"
+		}
+
+		// Request a d0 or n0 file depending on the time of day. The time of day matters and issues will occur if it's different to the one it requests.
+		return fmt.Sprintf("%s%s%d", questFile[:5], _time, 0)
 	}
 }

@@ -103,6 +108,11 @@ func handleMsgMhfSaveFavoriteQuest(s *Session, p mhfpacket.MHFPacket) {
 }

 func loadQuestFile(s *Session, questId int) []byte {
+	data, exists := s.server.questCacheData[questId]
+	if exists && s.server.questCacheTime[questId].Add(time.Duration(s.server.erupeConfig.QuestCacheExpiry)*time.Second).After(time.Now()) {
+		return data
+	}
+
 	file, err := os.ReadFile(filepath.Join(s.server.erupeConfig.BinPath, fmt.Sprintf("quests/%05dd0.bin", questId)))
 	if err != nil {
 		return nil
@@ -139,14 +149,17 @@ func loadQuestFile(s *Session, questId int) []byte {
 	}
 	questBody.WriteBytes(newStrings.Data())

+	s.server.questCacheData[questId] = questBody.Data()
+	s.server.questCacheTime[questId] = time.Now()
 	return questBody.Data()
 }

 func makeEventQuest(s *Session, rows *sql.Rows) ([]byte, error) {
 	var id, mark uint32
-	var questId int
+	var questId, activeDuration, inactiveDuration, flags int
 	var maxPlayers, questType uint8
-	rows.Scan(&id, &maxPlayers, &questType, &questId, &mark)
+	var startTime time.Time
+	rows.Scan(&id, &maxPlayers, &questType, &questId, &mark, &flags, &startTime, &activeDuration, &inactiveDuration)

 	data := loadQuestFile(s, questId)
 	if data == nil {
@@ -155,8 +168,8 @@ func makeEventQuest(s *Session, rows *sql.Rows) ([]byte, error) {

 	bf := byteframe.NewByteFrame()
 	bf.WriteUint32(id)
-	bf.WriteUint32(0)
-	bf.WriteUint8(0) // Indexer
+	bf.WriteUint32(0) // Unk
+	bf.WriteUint8(0)  // Unk
 	switch questType {
 	case 16:
 		bf.WriteUint8(s.server.erupeConfig.GameplayOptions.RegularRavienteMaxPlayers)
@@ -177,15 +190,43 @@ func makeEventQuest(s *Session, rows *sql.Rows) ([]byte, error) {
 	} else {
 		bf.WriteBool(true)
 	}
-	bf.WriteUint16(0)
+	bf.WriteUint16(0) // Unk
 	if _config.ErupeConfig.RealClientMode >= _config.G1 {
 		bf.WriteUint32(mark)
 	}
-	bf.WriteUint16(0)
+	bf.WriteUint16(0) // Unk
 	bf.WriteUint16(uint16(len(data)))
 	bf.WriteBytes(data)
-	ps.Uint8(bf, "", true) // What is this string for?

+	// Time Flag Replacement
+	// Bitset Structure: b8 UNK, b7 Required Objective, b6 UNK, b5 Night, b4 Day, b3 Cold, b2 Warm, b1 Spring
+	// if the byte is set to 0 the game choses the quest file corresponding to whatever season the game is on
+	bf.Seek(25, 0)
+	flagByte := bf.ReadUint8()
+	bf.Seek(25, 0)
+	if s.server.erupeConfig.GameplayOptions.SeasonOverride {
+		bf.WriteUint8(flagByte & 0b11100000)
+	} else {
+		// Allow for seasons to be specified in database, otherwise use the one in the file.
+		if flags < 0 {
+			bf.WriteUint8(flagByte)
+		} else {
+			bf.WriteUint8(uint8(flags))
+		}
+	}
+
+	// Bitset Structure Quest Variant 1: b8 UL Fixed, b7 UNK, b6 UNK, b5 UNK, b4 G Rank, b3 HC to UL, b2 Fix HC, b1 Hiden
+	// Bitset Structure Quest Variant 2: b8 Road, b7 High Conquest, b6 Fixed Difficulty, b5 No Active Feature, b4 Timer, b3 No Cuff, b2 No Halk Pots, b1 Low Conquest
+	// Bitset Structure Quest Variant 3: b8 No Sigils, b7 UNK, b6 Interception, b5 Zenith, b4 No GP Skills, b3 No Simple Mode?, b2 GSR to GR, b1 No Reward Skills
+
+	bf.Seek(175, 0)
+	questVariant3 := bf.ReadUint8()
+	questVariant3 &= 0b11011111 // disable Interception flag
+	bf.Seek(175, 0)
+	bf.WriteUint8(questVariant3)
+
+	bf.Seek(0, 2)
+	ps.Uint8(bf, "", true) // Debug/Notes string for quest
 	return bf.Data(), nil
 }

@@ -195,23 +236,59 @@ func handleMsgMhfEnumerateQuest(s *Session, p mhfpacket.MHFPacket) {
 	bf := byteframe.NewByteFrame()
 	bf.WriteUint16(0)

-	rows, _ := s.server.db.Query("SELECT id, COALESCE(max_players, 4) AS max_players, quest_type, quest_id, COALESCE(mark, 0) AS mark FROM event_quests ORDER BY quest_id")
-	for rows.Next() {
-		data, err := makeEventQuest(s, rows)
-		if err != nil {
-			continue
-		} else {
-			if len(data) > 896 || len(data) < 352 {
+	rows, err := s.server.db.Query("SELECT id, COALESCE(max_players, 4) AS max_players, quest_type, quest_id, COALESCE(mark, 0) AS mark, COALESCE(flags, -1), start_time, COALESCE(active_days, 0) AS active_days, COALESCE(inactive_days, 0) AS inactive_days FROM event_quests ORDER BY quest_id")
+	if err == nil {
+		currentTime := time.Now()
+		tx, _ := s.server.db.Begin()
+
+		for rows.Next() {
+			var id, mark uint32
+			var questId, flags, activeDays, inactiveDays int
+			var maxPlayers, questType uint8
+			var startTime time.Time
+
+			err = rows.Scan(&id, &maxPlayers, &questType, &questId, &mark, &flags, &startTime, &activeDays, &inactiveDays)
+			if err != nil {
+				continue
+			}
+
+			// Use the Event Cycling system
+			if activeDays > 0 {
+				cycleLength := (time.Duration(activeDays) + time.Duration(inactiveDays)) * 24 * time.Hour
+
+				// Count the number of full cycles elapsed since the last rotation.
+				extraCycles := int(currentTime.Sub(startTime) / cycleLength)
+
+				if extraCycles > 0 {
+					// Calculate the rotation time based on start time, active duration, and inactive duration.
+					rotationTime := startTime.Add(time.Duration(activeDays+inactiveDays) * 24 * time.Hour * time.Duration(extraCycles))
+					if currentTime.After(rotationTime) {
+						// Normalize rotationTime to 12PM JST to align with the in-game events update notification.
+						newRotationTime := time.Date(rotationTime.Year(), rotationTime.Month(), rotationTime.Day(), 12, 0, 0, 0, TimeAdjusted().Location())
+
+						_, err = tx.Exec("UPDATE event_quests SET start_time = $1 WHERE id = $2", newRotationTime, id)
+						if err != nil {
+							tx.Rollback() // Rollback if an error occurs
+							break
+						}
+						startTime = newRotationTime // Set the new start time so the quest can be used/removed immediately.
+					}
+				}
+
+				// Check if the quest is currently active
+				if currentTime.Before(startTime) || currentTime.After(startTime.Add(time.Duration(activeDays)*24*time.Hour)) {
+					break
+				}
+			}
+
+			data, err := makeEventQuest(s, rows)
+			if err != nil {
 				continue
 			} else {
-				totalCount++
-				if _config.ErupeConfig.RealClientMode == _config.F5 {
-					if totalCount > pkt.Offset && len(bf.Data()) < 21550 {
-						returnedCount++
-						bf.WriteBytes(data)
-						continue
-					}
+				if len(data) > 896 || len(data) < 352 {
+					continue
 				} else {
+					totalCount++
 					if totalCount > pkt.Offset && len(bf.Data()) < 60000 {
 						returnedCount++
 						bf.WriteBytes(data)
@@ -220,6 +297,9 @@ func handleMsgMhfEnumerateQuest(s *Session, p mhfpacket.MHFPacket) {
 				}
 			}
 		}
+
+		rows.Close()
+		tx.Commit()
 	}

 	type tuneValue struct {
@@ -565,7 +645,7 @@ func handleMsgMhfEnumerateQuest(s *Session, p mhfpacket.MHFPacket) {

 	tuneValues = append(tuneValues, tuneValue{1020, uint16(s.server.erupeConfig.GameplayOptions.GCPMultiplier * 100)})

-	tuneValues = append(tuneValues, tuneValue{1029, s.server.erupeConfig.GameplayOptions.GUrgentRate})
+	tuneValues = append(tuneValues, tuneValue{1029, uint16(s.server.erupeConfig.GameplayOptions.GUrgentRate * 100)})

 	if s.server.erupeConfig.GameplayOptions.DisableHunterNavi {
 		tuneValues = append(tuneValues, tuneValue{1037, 1})
--- a/server/channelserver/handlers_register.go
+++ b/server/channelserver/handlers_register.go
@@ -10,7 +10,7 @@ func handleMsgMhfRegisterEvent(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfRegisterEvent)
 	bf := byteframe.NewByteFrame()
 	// Some kind of check if there's already a session
-	if pkt.Unk3 > 0 && s.server.getRaviSemaphore() == nil {
+	if pkt.Unk1 && s.server.getRaviSemaphore() == nil {
 		doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 		return
 	}
--- a/server/channelserver/handlers_shop_gacha.go
+++ b/server/channelserver/handlers_shop_gacha.go
@@ -10,13 +10,13 @@ import (

 type ShopItem struct {
 	ID           uint32 `db:"id"`
-	ItemID       uint16 `db:"item_id"`
+	ItemID       uint32 `db:"item_id"`
 	Cost         uint32 `db:"cost"`
 	Quantity     uint16 `db:"quantity"`
 	MinHR        uint16 `db:"min_hr"`
 	MinSR        uint16 `db:"min_sr"`
 	MinGR        uint16 `db:"min_gr"`
-	StoreLevel   uint16 `db:"store_level"`
+	StoreLevel   uint8  `db:"store_level"`
 	MaxQuantity  uint16 `db:"max_quantity"`
 	UsedQuantity uint16 `db:"used_quantity"`
 	RoadFloors   uint16 `db:"road_floors"`
@@ -61,19 +61,30 @@ func writeShopItems(bf *byteframe.ByteFrame, items []ShopItem) {
 	bf.WriteUint16(uint16(len(items)))
 	bf.WriteUint16(uint16(len(items)))
 	for _, item := range items {
-		bf.WriteUint32(item.ID)
-		bf.WriteUint16(0)
-		bf.WriteUint16(item.ItemID)
+		if _config.ErupeConfig.RealClientMode >= _config.Z2 {
+			bf.WriteUint32(item.ID)
+		}
+		bf.WriteUint32(item.ItemID)
 		bf.WriteUint32(item.Cost)
 		bf.WriteUint16(item.Quantity)
 		bf.WriteUint16(item.MinHR)
 		bf.WriteUint16(item.MinSR)
-		bf.WriteUint16(item.MinGR)
-		bf.WriteUint16(item.StoreLevel)
-		bf.WriteUint16(item.MaxQuantity)
-		bf.WriteUint16(item.UsedQuantity)
-		bf.WriteUint16(item.RoadFloors)
-		bf.WriteUint16(item.RoadFatalis)
+		if _config.ErupeConfig.RealClientMode >= _config.Z2 {
+			bf.WriteUint16(item.MinGR)
+		}
+		bf.WriteUint8(0) // Unk
+		bf.WriteUint8(item.StoreLevel)
+		if _config.ErupeConfig.RealClientMode >= _config.Z2 {
+			bf.WriteUint16(item.MaxQuantity)
+			bf.WriteUint16(item.UsedQuantity)
+		}
+		if _config.ErupeConfig.RealClientMode == _config.Z1 {
+			bf.WriteUint8(uint8(item.RoadFloors))
+			bf.WriteUint8(uint8(item.RoadFatalis))
+		} else if _config.ErupeConfig.RealClientMode >= _config.Z2 {
+			bf.WriteUint16(item.RoadFloors)
+			bf.WriteUint16(item.RoadFatalis)
+		}
 	}
 }

@@ -116,103 +127,113 @@ func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
 			return
 		}

-		var count uint16
-		shopEntries, err := s.server.db.Queryx("SELECT id, min_gr, min_hr, name, url_banner, url_feature, url_thumbnail, wide, recommended, gacha_type, hidden FROM gacha_shop")
+		rows, err := s.server.db.Queryx("SELECT id, min_gr, min_hr, name, url_banner, url_feature, url_thumbnail, wide, recommended, gacha_type, hidden FROM gacha_shop")
 		if err != nil {
 			doAckBufSucceed(s, pkt.AckHandle, make([]byte, 4))
 			return
 		}
-		resp := byteframe.NewByteFrame()
-		resp.WriteUint32(0)
+		bf := byteframe.NewByteFrame()
 		var gacha Gacha
-		for shopEntries.Next() {
-			err = shopEntries.StructScan(&gacha)
-			if err != nil {
-				continue
+		var gachas []Gacha
+		for rows.Next() {
+			err = rows.StructScan(&gacha)
+			if err == nil {
+				gachas = append(gachas, gacha)
 			}
-			resp.WriteUint32(gacha.ID)
-			resp.WriteBytes(make([]byte, 16)) // Rank restriction
-			resp.WriteUint32(gacha.MinGR)
-			resp.WriteUint32(gacha.MinHR)
-			resp.WriteUint32(0) // only 0 in known packet
-			ps.Uint8(resp, gacha.Name, true)
-			ps.Uint8(resp, gacha.URLBanner, false)
-			ps.Uint8(resp, gacha.URLFeature, false)
-			resp.WriteBool(gacha.Wide)
-			ps.Uint8(resp, gacha.URLThumbnail, false)
-			resp.WriteUint8(0) // Unk
-			if gacha.Recommended {
-				resp.WriteUint8(2)
-			} else {
-				resp.WriteUint8(0)
-			}
-			resp.WriteUint8(gacha.GachaType)
-			resp.WriteBool(gacha.Hidden)
-			count++
 		}
-		resp.Seek(0, 0)
-		resp.WriteUint16(count)
-		resp.WriteUint16(count)
-		doAckBufSucceed(s, pkt.AckHandle, resp.Data())
+		bf.WriteUint16(uint16(len(gachas)))
+		bf.WriteUint16(uint16(len(gachas)))
+		for _, g := range gachas {
+			bf.WriteUint32(g.ID)
+			bf.WriteUint32(0) // Unknown rank restrictions
+			bf.WriteUint32(0)
+			bf.WriteUint32(0)
+			bf.WriteUint32(0)
+			bf.WriteUint32(g.MinGR)
+			bf.WriteUint32(g.MinHR)
+			bf.WriteUint32(0) // only 0 in known packet
+			ps.Uint8(bf, g.Name, true)
+			ps.Uint8(bf, g.URLBanner, false)
+			ps.Uint8(bf, g.URLFeature, false)
+			if _config.ErupeConfig.RealClientMode >= _config.G10 {
+				bf.WriteBool(g.Wide)
+				ps.Uint8(bf, g.URLThumbnail, false)
+			}
+			if g.Recommended {
+				bf.WriteUint16(2)
+			} else {
+				bf.WriteUint16(0)
+			}
+			bf.WriteUint8(g.GachaType)
+			if _config.ErupeConfig.RealClientMode >= _config.G10 {
+				bf.WriteBool(g.Hidden)
+			}
+		}
+		doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 	case 2: // Actual gacha
 		bf := byteframe.NewByteFrame()
 		bf.WriteUint32(pkt.ShopID)
 		var gachaType int
 		s.server.db.QueryRow(`SELECT gacha_type FROM gacha_shop WHERE id = $1`, pkt.ShopID).Scan(&gachaType)
-		entries, err := s.server.db.Queryx(`SELECT entry_type, id, item_type, item_number, item_quantity, weight, rarity, rolls, daily_limit, frontier_points, name FROM gacha_entries WHERE gacha_id = $1 ORDER BY weight DESC`, pkt.ShopID)
+		rows, err := s.server.db.Queryx(`SELECT entry_type, id, item_type, item_number, item_quantity, weight, rarity, rolls, daily_limit, frontier_points, COALESCE(name, '') AS name FROM gacha_entries WHERE gacha_id = $1 ORDER BY weight DESC`, pkt.ShopID)
 		if err != nil {
 			doAckBufSucceed(s, pkt.AckHandle, make([]byte, 4))
 			return
 		}
 		var divisor float64
 		s.server.db.QueryRow(`SELECT COALESCE(SUM(weight) / 100000.0, 0) AS chance FROM gacha_entries WHERE gacha_id = $1`, pkt.ShopID).Scan(&divisor)
-		var entryCount uint16
-		bf.WriteUint16(0)
-		gachaEntry := GachaEntry{}
-		gachaItem := GachaItem{}
-		for entries.Next() {
-			entryCount++
-			entries.StructScan(&gachaEntry)
-			bf.WriteUint8(gachaEntry.EntryType)
-			bf.WriteUint32(gachaEntry.ID)
-			bf.WriteUint8(gachaEntry.ItemType)
-			bf.WriteUint32(gachaEntry.ItemNumber)
-			bf.WriteUint16(gachaEntry.ItemQuantity)
+
+		var entry GachaEntry
+		var entries []GachaEntry
+		var item GachaItem
+		for rows.Next() {
+			err = rows.StructScan(&entry)
+			if err == nil {
+				entries = append(entries, entry)
+			}
+		}
+		bf.WriteUint16(uint16(len(entries)))
+		for _, ge := range entries {
+			var items []GachaItem
+			bf.WriteUint8(ge.EntryType)
+			bf.WriteUint32(ge.ID)
+			bf.WriteUint8(ge.ItemType)
+			bf.WriteUint32(ge.ItemNumber)
+			bf.WriteUint16(ge.ItemQuantity)
 			if gachaType >= 4 { // If box
 				bf.WriteUint16(1)
 			} else {
-				bf.WriteUint16(uint16(gachaEntry.Weight / divisor))
+				bf.WriteUint16(uint16(ge.Weight / divisor))
 			}
-			bf.WriteUint8(gachaEntry.Rarity)
-			bf.WriteUint8(gachaEntry.Rolls)
+			bf.WriteUint8(ge.Rarity)
+			bf.WriteUint8(ge.Rolls)

-			var itemCount uint8
-			temp := byteframe.NewByteFrame()
-			items, err := s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id=$1`, gachaEntry.ID)
+			rows, err = s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id=$1`, ge.ID)
 			if err != nil {
 				bf.WriteUint8(0)
 			} else {
-				for items.Next() {
-					itemCount++
-					items.StructScan(&gachaItem)
-					temp.WriteUint16(uint16(gachaItem.ItemType))
-					temp.WriteUint16(gachaItem.ItemID)
-					temp.WriteUint16(gachaItem.Quantity)
+				for rows.Next() {
+					err = rows.StructScan(&item)
+					if err == nil {
+						items = append(items, item)
+					}
 				}
-				bf.WriteUint8(itemCount)
+				bf.WriteUint8(uint8(len(items)))
 			}

-			bf.WriteUint16(gachaEntry.FrontierPoints)
-			bf.WriteUint8(gachaEntry.DailyLimit)
-			if gachaEntry.EntryType < 10 {
-				ps.Uint8(bf, gachaEntry.Name, true)
+			bf.WriteUint16(ge.FrontierPoints)
+			bf.WriteUint8(ge.DailyLimit)
+			if ge.EntryType < 10 {
+				ps.Uint8(bf, ge.Name, true)
 			} else {
 				bf.WriteUint8(0)
 			}
-			bf.WriteBytes(temp.Data())
+			for _, gi := range items {
+				bf.WriteUint16(uint16(gi.ItemType))
+				bf.WriteUint16(gi.ItemID)
+				bf.WriteUint16(gi.Quantity)
+			}
 		}
-		bf.Seek(4, 0)
-		bf.WriteUint16(entryCount)
 		doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 	case 3: // Hunting Festival Exchange
 		fallthrough
@@ -231,6 +252,9 @@ func handleMsgMhfEnumerateShop(s *Session, p mhfpacket.MHFPacket) {
 	case 10: // Item shop, 0-8
 		bf := byteframe.NewByteFrame()
 		items := getShopItems(s, pkt.ShopType, pkt.ShopID)
+		if len(items) > int(pkt.Limit) {
+			items = items[:pkt.Limit]
+		}
 		writeShopItems(bf, items)
 		doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 	}
@@ -424,7 +448,7 @@ func handleMsgMhfReceiveGachaItem(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgMhfPlayNormalGacha(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayNormalGacha)
 	bf := byteframe.NewByteFrame()
-	var gachaEntries []GachaEntry
+	var entries []GachaEntry
 	var entry GachaEntry
 	var rewards []GachaItem
 	var reward GachaItem
@@ -433,31 +457,40 @@ func handleMsgMhfPlayNormalGacha(s *Session, p mhfpacket.MHFPacket) {
 		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	temp := byteframe.NewByteFrame()
-	entries, err := s.server.db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
+
+	rows, err := s.server.db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
 	if err != nil {
 		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	for entries.Next() {
-		entries.StructScan(&entry)
-		gachaEntries = append(gachaEntries, entry)
-	}
-	rewardEntries, err := getRandomEntries(gachaEntries, rolls, false)
-	for i := range rewardEntries {
-		items, err := s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+	for rows.Next() {
+		err = rows.StructScan(&entry)
 		if err != nil {
 			continue
 		}
-		for items.Next() {
-			items.StructScan(&reward)
+		entries = append(entries, entry)
+	}
+
+	rewardEntries, err := getRandomEntries(entries, rolls, false)
+	temp := byteframe.NewByteFrame()
+	for i := range rewardEntries {
+		rows, err = s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+		if err != nil {
+			continue
+		}
+		for rows.Next() {
+			err = rows.StructScan(&reward)
+			if err != nil {
+				continue
+			}
 			rewards = append(rewards, reward)
 			temp.WriteUint8(reward.ItemType)
 			temp.WriteUint16(reward.ItemID)
 			temp.WriteUint16(reward.Quantity)
-			temp.WriteUint8(entry.Rarity)
+			temp.WriteUint8(rewardEntries[i].Rarity)
 		}
 	}
+
 	bf.WriteUint8(uint8(len(rewards)))
 	bf.WriteBytes(temp.Data())
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
@@ -467,7 +500,7 @@ func handleMsgMhfPlayNormalGacha(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgMhfPlayStepupGacha(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayStepupGacha)
 	bf := byteframe.NewByteFrame()
-	var gachaEntries []GachaEntry
+	var entries []GachaEntry
 	var entry GachaEntry
 	var rewards []GachaItem
 	var reward GachaItem
@@ -479,40 +512,49 @@ func handleMsgMhfPlayStepupGacha(s *Session, p mhfpacket.MHFPacket) {
 	s.server.db.Exec("UPDATE users u SET frontier_points=frontier_points+(SELECT frontier_points FROM gacha_entries WHERE gacha_id = $1 AND entry_type = $2) WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$3)", pkt.GachaID, pkt.RollType, s.charID)
 	s.server.db.Exec(`DELETE FROM gacha_stepup WHERE gacha_id = $1 AND character_id = $2`, pkt.GachaID, s.charID)
 	s.server.db.Exec(`INSERT INTO gacha_stepup (gacha_id, step, character_id) VALUES ($1, $2, $3)`, pkt.GachaID, pkt.RollType+1, s.charID)
-	temp := byteframe.NewByteFrame()
-	guaranteedItems := getGuaranteedItems(s, pkt.GachaID, pkt.RollType)
-	for _, item := range guaranteedItems {
-		temp.WriteUint8(item.ItemType)
-		temp.WriteUint16(item.ItemID)
-		temp.WriteUint16(item.Quantity)
-		temp.WriteUint8(0)
-	}
-	entries, err := s.server.db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
+
+	rows, err := s.server.db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
 	if err != nil {
 		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	for entries.Next() {
-		entries.StructScan(&entry)
-		gachaEntries = append(gachaEntries, entry)
-	}
-	rewardEntries, err := getRandomEntries(gachaEntries, rolls, false)
-	for i := range rewardEntries {
-		items, err := s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+	for rows.Next() {
+		err = rows.StructScan(&entry)
 		if err != nil {
 			continue
 		}
-		for items.Next() {
-			items.StructScan(&reward)
+		entries = append(entries, entry)
+	}
+
+	guaranteedItems := getGuaranteedItems(s, pkt.GachaID, pkt.RollType)
+	rewardEntries, err := getRandomEntries(entries, rolls, false)
+	temp := byteframe.NewByteFrame()
+	for i := range rewardEntries {
+		rows, err = s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
+		if err != nil {
+			continue
+		}
+		for rows.Next() {
+			err = rows.StructScan(&reward)
+			if err != nil {
+				continue
+			}
 			rewards = append(rewards, reward)
 			temp.WriteUint8(reward.ItemType)
 			temp.WriteUint16(reward.ItemID)
 			temp.WriteUint16(reward.Quantity)
-			temp.WriteUint8(entry.Rarity)
+			temp.WriteUint8(rewardEntries[i].Rarity)
 		}
 	}
+
 	bf.WriteUint8(uint8(len(rewards) + len(guaranteedItems)))
 	bf.WriteUint8(uint8(len(rewards)))
+	for _, item := range guaranteedItems {
+		bf.WriteUint8(item.ItemType)
+		bf.WriteUint16(item.ItemID)
+		bf.WriteUint16(item.Quantity)
+		bf.WriteUint8(0)
+	}
 	bf.WriteBytes(temp.Data())
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 	addGachaItem(s, rewards)
@@ -561,7 +603,7 @@ func handleMsgMhfGetBoxGachaInfo(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfPlayBoxGacha)
 	bf := byteframe.NewByteFrame()
-	var gachaEntries []GachaEntry
+	var entries []GachaEntry
 	var entry GachaEntry
 	var rewards []GachaItem
 	var reward GachaItem
@@ -570,17 +612,18 @@ func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
 		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	temp := byteframe.NewByteFrame()
-	entries, err := s.server.db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
+	rows, err := s.server.db.Queryx(`SELECT id, weight, rarity FROM gacha_entries WHERE gacha_id = $1 AND entry_type = 100 ORDER BY weight DESC`, pkt.GachaID)
 	if err != nil {
 		doAckBufSucceed(s, pkt.AckHandle, make([]byte, 1))
 		return
 	}
-	for entries.Next() {
-		entries.StructScan(&entry)
-		gachaEntries = append(gachaEntries, entry)
+	for rows.Next() {
+		err = rows.StructScan(&entry)
+		if err == nil {
+			entries = append(entries, entry)
+		}
 	}
-	rewardEntries, err := getRandomEntries(gachaEntries, rolls, true)
+	rewardEntries, err := getRandomEntries(entries, rolls, true)
 	for i := range rewardEntries {
 		items, err := s.server.db.Queryx(`SELECT item_type, item_id, quantity FROM gacha_items WHERE entry_id = $1`, rewardEntries[i].ID)
 		if err != nil {
@@ -588,16 +631,19 @@ func handleMsgMhfPlayBoxGacha(s *Session, p mhfpacket.MHFPacket) {
 		}
 		s.server.db.Exec(`INSERT INTO gacha_box (gacha_id, entry_id, character_id) VALUES ($1, $2, $3)`, pkt.GachaID, rewardEntries[i].ID, s.charID)
 		for items.Next() {
-			items.StructScan(&reward)
-			rewards = append(rewards, reward)
-			temp.WriteUint8(reward.ItemType)
-			temp.WriteUint16(reward.ItemID)
-			temp.WriteUint16(reward.Quantity)
-			temp.WriteUint8(0)
+			err = items.StructScan(&reward)
+			if err == nil {
+				rewards = append(rewards, reward)
+			}
 		}
 	}
 	bf.WriteUint8(uint8(len(rewards)))
-	bf.WriteBytes(temp.Data())
+	for _, r := range rewards {
+		bf.WriteUint8(r.ItemType)
+		bf.WriteUint16(r.ItemID)
+		bf.WriteUint16(r.Quantity)
+		bf.WriteUint8(0)
+	}
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 	addGachaItem(s, rewards)
 }
@@ -632,59 +678,59 @@ func handleMsgMhfExchangeItem2Fpoint(s *Session, p mhfpacket.MHFPacket) {
 	doAckSimpleSucceed(s, pkt.AckHandle, bf.Data())
 }

+type FPointExchange struct {
+	ID       uint32 `db:"id"`
+	ItemType uint8  `db:"item_type"`
+	ItemID   uint16 `db:"item_id"`
+	Quantity uint16 `db:"quantity"`
+	FPoints  uint16 `db:"fpoints"`
+	Buyable  bool   `db:"buyable"`
+}
+
 func handleMsgMhfGetFpointExchangeList(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgMhfGetFpointExchangeList)
-	resp := byteframe.NewByteFrame()
-	resp.WriteUint32(0)
-	var buyables, sellables uint16
-	var id uint32
-	var itemType uint8
-	var itemID, quantity, fPoints uint16

-	buyRows, err := s.server.db.Query("SELECT id,item_type,item_id,quantity,fpoints FROM fpoint_items WHERE trade_type=0")
+	bf := byteframe.NewByteFrame()
+	var exchange FPointExchange
+	var exchanges []FPointExchange
+	var buyables uint16
+	rows, err := s.server.db.Queryx(`SELECT id, item_type, item_id, quantity, fpoints, buyable FROM fpoint_items ORDER BY buyable DESC`)
 	if err == nil {
-		for buyRows.Next() {
-			err = buyRows.Scan(&id, &itemType, &itemID, &quantity, &fPoints)
+		for rows.Next() {
+			err = rows.StructScan(&exchange)
 			if err != nil {
 				continue
 			}
-			resp.WriteUint32(id)
-			resp.WriteUint16(0)
-			resp.WriteUint16(0)
-			resp.WriteUint16(0)
-			resp.WriteUint8(itemType)
-			resp.WriteUint16(itemID)
-			resp.WriteUint16(quantity)
-			resp.WriteUint16(fPoints)
-			buyables++
-		}
-	}
-
-	sellRows, err := s.server.db.Query("SELECT id,item_type,item_id,quantity,fpoints FROM fpoint_items WHERE trade_type=1")
-	if err == nil {
-		for sellRows.Next() {
-			err = sellRows.Scan(&id, &itemType, &itemID, &quantity, &fPoints)
-			if err != nil {
-				continue
+			if exchange.Buyable {
+				buyables++
 			}
-			resp.WriteUint32(id)
-			resp.WriteUint16(0)
-			resp.WriteUint16(0)
-			resp.WriteUint16(0)
-			resp.WriteUint8(itemType)
-			resp.WriteUint16(itemID)
-			resp.WriteUint16(quantity)
-			resp.WriteUint16(fPoints)
-			sellables++
+			exchanges = append(exchanges, exchange)
 		}
 	}
-	resp.Seek(0, 0)
-	resp.WriteUint16(buyables)
-	resp.WriteUint16(sellables)
+	if _config.ErupeConfig.RealClientMode <= _config.Z2 {
+		bf.WriteUint8(uint8(len(exchanges)))
+		bf.WriteUint8(uint8(buyables))
+	} else {
+		bf.WriteUint16(uint16(len(exchanges)))
+		bf.WriteUint16(buyables)
+	}
+	for _, e := range exchanges {
+		bf.WriteUint32(e.ID)
+		bf.WriteUint16(0)
+		bf.WriteUint16(0)
+		bf.WriteUint16(0)
+		bf.WriteUint8(e.ItemType)
+		bf.WriteUint16(e.ItemID)
+		bf.WriteUint16(e.Quantity)
+		bf.WriteUint16(e.FPoints)
+	}

-	doAckBufSucceed(s, pkt.AckHandle, resp.Data())
+	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

 func handleMsgMhfPlayFreeGacha(s *Session, p mhfpacket.MHFPacket) {
-	// not sure this is used anywhere, free gachas use the MSG_MHF_PLAY_NORMAL_GACHA method in captures
+	pkt := p.(*mhfpacket.MsgMhfPlayFreeGacha)
+	bf := byteframe.NewByteFrame()
+	bf.WriteUint32(1)
+	doAckSimpleSucceed(s, pkt.AckHandle, bf.Data())
 }
--- a/server/channelserver/handlers_stage.go
+++ b/server/channelserver/handlers_stage.go
@@ -55,7 +55,6 @@ func doStageTransfer(s *Session, ackHandle uint32, stageID string) {

 	// Save our new stage ID and pointer to the new stage itself.
 	s.Lock()
-	s.stageID = stageID
 	s.stage = s.server.stages[stageID]
 	s.Unlock()

@@ -153,17 +152,14 @@ func handleMsgSysEnterStage(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysEnterStage)

 	// Push our current stage ID to the movement stack before entering another one.
-	if s.stageID == "" {
-		s.stageMoveStack.Set(pkt.StageID)
-	} else {
+	if s.stage != nil {
 		s.stage.Lock()
 		s.stage.reservedClientSlots[s.charID] = false
 		s.stage.Unlock()
-		s.stageMoveStack.Push(s.stageID)
+		s.stageMoveStack.Push(s.stage.id)
 		s.stageMoveStack.Lock()
 	}

-	s.QueueSendMHF(&mhfpacket.MsgSysCleanupObject{})
 	if s.reservationStage != nil {
 		s.reservationStage = nil
 	}
@@ -177,8 +173,8 @@ func handleMsgSysBackStage(s *Session, p mhfpacket.MHFPacket) {
 	// Transfer back to the saved stage ID before the previous move or enter.
 	s.stageMoveStack.Unlock()
 	backStage, err := s.stageMoveStack.Pop()
-	if err != nil {
-		panic(err)
+	if backStage == "" || err != nil {
+		backStage = "sl1Ns200p0a0u0"
 	}

 	if _, exists := s.stage.reservedClientSlots[s.charID]; exists {
@@ -195,7 +191,7 @@ func handleMsgSysBackStage(s *Session, p mhfpacket.MHFPacket) {
 func handleMsgSysMoveStage(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysMoveStage)

-	// Set a new move stack from the given stage ID if unlocked
+	// Set a new move stack from the given stage ID
 	if !s.stageMoveStack.Locked {
 		s.stageMoveStack.Set(pkt.StageID)
 	}
@@ -207,9 +203,12 @@ func handleMsgSysLeaveStage(s *Session, p mhfpacket.MHFPacket) {}

 func handleMsgSysLockStage(s *Session, p mhfpacket.MHFPacket) {
 	pkt := p.(*mhfpacket.MsgSysLockStage)
-	// TODO(Andoryuuta): What does this packet _actually_ do?
-	// I think this is supposed to mark a stage as no longer able to accept client reservations
-	doAckSimpleSucceed(s, pkt.AckHandle, []byte{0x00, 0x00, 0x00, 0x00})
+	if stage, exists := s.server.stages[pkt.StageID]; exists {
+		stage.Lock()
+		stage.locked = true
+		stage.Unlock()
+	}
+	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }

 func handleMsgSysUnlockStage(s *Session, p mhfpacket.MHFPacket) {
@@ -219,7 +218,9 @@ func handleMsgSysUnlockStage(s *Session, p mhfpacket.MHFPacket) {

 		for charID := range s.reservationStage.reservedClientSlots {
 			session := s.server.FindSessionByCharID(charID)
-			session.QueueSendMHF(&mhfpacket.MsgSysStageDestruct{})
+			if session != nil {
+				session.QueueSendMHF(&mhfpacket.MsgSysStageDestruct{})
+			}
 		}

 		delete(s.server.stages, s.reservationStage.id)
@@ -242,6 +243,10 @@ func handleMsgSysReserveStage(s *Session, p mhfpacket.MHFPacket) {
 			}
 			doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 		} else if uint16(len(stage.reservedClientSlots)) < stage.maxPlayers {
+			if stage.locked {
+				doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
+				return
+			}
 			if len(stage.password) > 0 {
 				if stage.password != s.stagePass {
 					doAckSimpleFail(s, pkt.AckHandle, make([]byte, 4))
@@ -367,39 +372,43 @@ func handleMsgSysEnumerateStage(s *Session, p mhfpacket.MHFPacket) {
 	defer s.server.stagesLock.RUnlock()

 	// Build the response
-	resp := byteframe.NewByteFrame()
 	bf := byteframe.NewByteFrame()
-	var joinable int
+	var joinable uint16
+	bf.WriteUint16(0)
 	for sid, stage := range s.server.stages {
 		stage.RLock()
-		defer stage.RUnlock()

 		if len(stage.reservedClientSlots) == 0 && len(stage.clients) == 0 {
+			stage.RUnlock()
 			continue
 		}
-
 		if !strings.Contains(stage.id, pkt.StagePrefix) {
+			stage.RUnlock()
 			continue
 		}
-
 		joinable++

-		resp.WriteUint16(uint16(len(stage.reservedClientSlots))) // Reserved players.
-		resp.WriteUint16(0)                                      // Unk
-		resp.WriteUint8(0)                                       // Unk
-		resp.WriteBool(len(stage.clients) > 0)                   // Has departed.
-		resp.WriteUint16(stage.maxPlayers)                       // Max players.
-		if len(stage.password) > 0 {
-			// This byte has also been seen as 1
-			// The quest is also recognised as locked when this is 2
-			resp.WriteUint8(3)
+		bf.WriteUint16(uint16(len(stage.reservedClientSlots)))
+		bf.WriteUint16(uint16(len(stage.clients)))
+		if strings.HasPrefix(stage.id, "sl2Ls") {
+			bf.WriteUint16(uint16(len(stage.clients) + len(stage.reservedClientSlots)))
 		} else {
-			resp.WriteUint8(0)
+			bf.WriteUint16(uint16(len(stage.clients)))
 		}
-		ps.Uint8(resp, sid, false)
+		bf.WriteUint16(stage.maxPlayers)
+		var flags uint8
+		if stage.locked {
+			flags |= 1
+		}
+		if len(stage.password) > 0 {
+			flags |= 2
+		}
+		bf.WriteUint8(flags)
+		ps.Uint8(bf, sid, false)
+		stage.RUnlock()
 	}
-	bf.WriteUint16(uint16(joinable))
-	bf.WriteBytes(resp.Data())
+	bf.Seek(0, 0)
+	bf.WriteUint16(joinable)

 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }
--- a/server/channelserver/handlers_tower.go
+++ b/server/channelserver/handlers_tower.go
@@ -126,8 +126,9 @@ func handleMsgMhfPostTowerInfo(s *Session, p mhfpacket.MHFPacket) {
 		skills := "0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0"
 		s.server.db.QueryRow(`SELECT skills FROM tower WHERE char_id=$1`, s.charID).Scan(&skills)
 		s.server.db.Exec(`UPDATE tower SET skills=$1, tsp=tsp-$2 WHERE char_id=$3`, stringsupport.CSVSetIndex(skills, int(pkt.Skill), stringsupport.CSVGetIndex(skills, int(pkt.Skill))+1), pkt.Cost, s.charID)
-	case 7:
-		s.server.db.Exec(`UPDATE tower SET tr=$1, trp=trp+$2, block1=block1+$3 WHERE char_id=$4`, pkt.TR, pkt.TRP, pkt.Block1, s.charID)
+	case 1, 7:
+		// This might give too much TSP? No idea what the rate is supposed to be
+		s.server.db.Exec(`UPDATE tower SET tr=$1, trp=COALESCE(trp, 0)+$2, tsp=COALESCE(tsp, 0)+$3, block1=COALESCE(block1, 0)+$4 WHERE char_id=$5`, pkt.TR, pkt.TRP, pkt.Cost, pkt.Block1, s.charID)
 	}
 	doAckSimpleSucceed(s, pkt.AckHandle, make([]byte, 4))
 }
--- a/server/channelserver/sys_channel_server.go
+++ b/server/channelserver/sys_channel_server.go
@@ -5,10 +5,11 @@ import (
 	"net"
 	"strings"
 	"sync"
+	"time"

 	"erupe-ce/common/byteframe"
 	ps "erupe-ce/common/pascalstring"
-	"erupe-ce/config"
+	_config "erupe-ce/config"
 	"erupe-ce/network/binpacket"
 	"erupe-ce/network/mhfpacket"
 	"erupe-ce/server/discordbot"
@@ -73,6 +74,9 @@ type Server struct {
 	name string

 	raviente *Raviente
+
+	questCacheData map[int][]byte
+	questCacheTime map[int]time.Time
 }

 type Raviente struct {
@@ -115,6 +119,7 @@ func (s *Server) GetRaviMultiplier() float64 {

 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 {
@@ -123,28 +128,20 @@ func (s *Server) UpdateRavi(semaID uint32, index uint8, value uint32, update boo
 		default:
 			value = uint32(float64(value) * s.GetRaviMultiplier())
 		}
-		prev = s.raviente.state[index]
-		if prev != 0 && !update {
-			return prev, prev
-		}
-		s.raviente.state[index] += value
-		return prev, s.raviente.state[index]
+		dest = &s.raviente.state
 	case 0x50000:
-		prev = s.raviente.support[index]
-		if prev != 0 && !update {
-			return prev, prev
-		}
-		s.raviente.support[index] += value
-		return prev, s.raviente.support[index]
+		dest = &s.raviente.support
 	case 0x60000:
-		prev = s.raviente.register[index]
-		if prev != 0 && !update {
-			return prev, prev
-		}
-		s.raviente.register[index] += value
-		return prev, s.raviente.register[index]
+		dest = &s.raviente.register
+	default:
+		return 0, 0
 	}
-	return 0, 0
+	if update {
+		(*dest)[index] += value
+	} else {
+		(*dest)[index] = value
+	}
+	return prev, (*dest)[index]
 }

 // NewServer creates a new Server type.
@@ -170,6 +167,8 @@ func NewServer(config *Config) *Server {
 			state:    make([]uint32, 30),
 			support:  make([]uint32, 30),
 		},
+		questCacheData: make(map[int][]byte),
+		questCacheTime: make(map[int]time.Time),
 	}

 	// Mezeporta
@@ -323,7 +322,6 @@ func (s *Server) BroadcastChatMessage(message string) {
 	msgBinChat.Build(bf)

 	s.BroadcastMHF(&mhfpacket.MsgSysCastedBinary{
-		CharID:         0xFFFFFFFF,
 		MessageType:    BinaryMessageTypeChat,
 		RawDataPayload: bf.Data(),
 	}, nil)
@@ -355,7 +353,6 @@ func (s *Server) BroadcastRaviente(ip uint32, port uint16, stage []byte, _type u
 	bf.WriteUint16(0)    // Unk
 	bf.WriteBytes(stage)
 	s.WorldcastMHF(&mhfpacket.MsgSysCastedBinary{
-		CharID:         0x00000000,
 		BroadcastType:  BroadcastTypeServer,
 		MessageType:    BinaryMessageTypeChat,
 		RawDataPayload: bf.Data(),
--- a/server/channelserver/sys_language.go
+++ b/server/channelserver/sys_language.go
@@ -12,6 +12,7 @@ func getLangStrings(s *Server) map[string]string {
 		strings["commandKqfGet"] = "現在のキークエストフラグ：%x"
 		strings["commandKqfSetError"] = "キークエコマンドエラー　例：%s set xxxxxxxxxxxxxxxx"
 		strings["commandKqfSetSuccess"] = "キークエストのフラグが更新されました。ワールド／ランドを移動してください"
+		strings["commandKqfVersion"] = "This command is disabled prior to MHFG10"
 		strings["commandRightsError"] = "コース更新コマンドエラー　例：%s x"
 		strings["commandRightsSuccess"] = "コース情報を更新しました：%d"
 		strings["commandCourseError"] = "コース確認コマンドエラー　例：%s <name>"
@@ -64,6 +65,7 @@ func getLangStrings(s *Server) map[string]string {
 		strings["commandKqfGet"] = "KQF: %x"
 		strings["commandKqfSetError"] = "Error in command. Format: %s set xxxxxxxxxxxxxxxx"
 		strings["commandKqfSetSuccess"] = "KQF set, please switch Land/World"
+		strings["commandKqfVersion"] = "This command is disabled prior to MHFG10"
 		strings["commandRightsError"] = "Error in command. Format: %s x"
 		strings["commandRightsSuccess"] = "Set rights integer: %d"
 		strings["commandCourseError"] = "Error in command. Format: %s <name>"
--- a/server/channelserver/sys_session.go
+++ b/server/channelserver/sys_session.go
@@ -36,7 +36,6 @@ type Session struct {

 	objectIndex      uint16
 	userEnteredStage bool // If the user has entered a stage before
-	stageID          string
 	stage            *Stage
 	reservationStage *Stage // Required for the stateful MsgSysUnreserveStage packet.
 	stagePass        string // Temporary storage
@@ -62,8 +61,9 @@ type Session struct {
 	mailList []int

 	// For Debuging
-	Name   string
-	closed bool
+	Name     string
+	closed   bool
+	ackStart map[uint32]time.Time
 }

 // NewSession creates a new Session type.
@@ -78,6 +78,7 @@ func NewSession(server *Server, conn net.Conn) *Session {
 		lastPacket:     time.Now(),
 		sessionStart:   TimeAdjusted().Unix(),
 		stageMoveStack: stringstack.New(),
+		ackStart:       make(map[uint32]time.Time),
 	}
 	s.SetObjectID()
 	return s
@@ -192,6 +193,10 @@ func (s *Session) handlePacketGroup(pktGroup []byte) {
 	s.lastPacket = time.Now()
 	bf := byteframe.NewByteFrameFromBytes(pktGroup)
 	opcodeUint16 := bf.ReadUint16()
+	if len(bf.Data()) >= 6 {
+		s.ackStart[bf.ReadUint32()] = time.Now()
+		bf.Seek(2, io.SeekStart)
+	}
 	opcode := network.PacketID(opcodeUint16)

 	// This shouldn't be needed, but it's better to recover and let the connection die than to panic the server.
@@ -254,7 +259,7 @@ func (s *Session) logMessage(opcode uint16, data []byte, sender string, recipien

 	if sender == "Server" && !s.server.erupeConfig.DevModeOptions.LogOutboundMessages {
 		return
-	} else if !s.server.erupeConfig.DevModeOptions.LogInboundMessages {
+	} else if sender != "Server" && !s.server.erupeConfig.DevModeOptions.LogInboundMessages {
 		return
 	}

@@ -262,12 +267,24 @@ func (s *Session) logMessage(opcode uint16, data []byte, sender string, recipien
 	if ignored(opcodePID) {
 		return
 	}
-	fmt.Printf("[%s] -> [%s]\n", sender, recipient)
-	fmt.Printf("Opcode: %s\n", opcodePID)
-	if len(data) <= s.server.erupeConfig.DevModeOptions.MaxHexdumpLength {
-		fmt.Printf("Data [%d bytes]:\n%s\n", len(data), hex.Dump(data))
+	var ackHandle uint32
+	if len(data) >= 6 {
+		ackHandle = binary.BigEndian.Uint32(data[2:6])
+	}
+	if t, ok := s.ackStart[ackHandle]; ok {
+		fmt.Printf("[%s] -> [%s] (%fs)\n", sender, recipient, float64(time.Now().UnixNano()-t.UnixNano())/1000000000)
 	} else {
-		fmt.Printf("Data [%d bytes]:\n(Too long!)\n\n", len(data))
+		fmt.Printf("[%s] -> [%s]\n", sender, recipient)
+	}
+	fmt.Printf("Opcode: %s\n", opcodePID)
+	if s.server.erupeConfig.DevModeOptions.LogMessageData {
+		if len(data) <= s.server.erupeConfig.DevModeOptions.MaxHexdumpLength {
+			fmt.Printf("Data [%d bytes]:\n%s\n", len(data), hex.Dump(data))
+		} else {
+			fmt.Printf("Data [%d bytes]: (Too long!)\n\n", len(data))
+		}
+	} else {
+		fmt.Printf("\n")
 	}
 }

--- a/server/channelserver/sys_stage.go
+++ b/server/channelserver/sys_stage.go
@@ -47,6 +47,7 @@ type Stage struct {
 	host       *Session
 	maxPlayers uint16
 	password   string
+	locked     bool
 }

 // NewStage creates a new stage with intialized values.
--- a/server/channelserver/sys_time.go
+++ b/server/channelserver/sys_time.go
@@ -16,8 +16,11 @@ func TimeMidnight() time.Time {

 func TimeWeekStart() time.Time {
 	midnight := TimeMidnight()
-	offset := (int(midnight.Weekday()) - 1) * -24
-	return midnight.Add(time.Hour * time.Duration(offset))
+	offset := int(midnight.Weekday()) - int(time.Monday)
+	if offset < 0 {
+		offset += 7
+	}
+	return midnight.Add(-time.Duration(offset) * 24 * time.Hour)
 }

 func TimeWeekNext() time.Time {
--- a/server/entranceserver/make_resp.go
+++ b/server/entranceserver/make_resp.go
@@ -69,7 +69,11 @@ func encodeServerInfo(config *_config.Config, s *Server, local bool) []byte {

 		for channelIdx, ci := range si.Channels {
 			sid = (4096 + serverIdx*256) + (16 + channelIdx)
-			bf.WriteUint16(ci.Port)
+			if _config.ErupeConfig.DevMode && _config.ErupeConfig.ProxyPort != 0 {
+				bf.WriteUint16(_config.ErupeConfig.ProxyPort)
+			} else {
+				bf.WriteUint16(ci.Port)
+			}
 			bf.WriteUint16(16 + uint16(channelIdx))
 			bf.WriteUint16(ci.MaxPlayers)
 			var currentPlayers uint16
--- a/server/signserver/dsgn_resp.go
+++ b/server/signserver/dsgn_resp.go
@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"go.uber.org/zap"
 	"strings"
+	"time"
 )

 func (s *Session) makeSignResponse(uid uint32) []byte {
@@ -154,35 +155,30 @@ func (s *Session) makeSignResponse(uid uint32) []byte {
 	bf.WriteUint32(uint32(s.server.getReturnExpiry(uid).Unix()))
 	bf.WriteUint32(0)

-	mezfes := s.server.erupeConfig.DevModeOptions.MezFesEvent
-	alt := s.server.erupeConfig.DevModeOptions.MezFesAlt
-	if mezfes {
-		// We can just use the start timestamp as the event ID
-		bf.WriteUint32(uint32(channelserver.TimeWeekStart().Unix()))
-		// Start time
-		bf.WriteUint32(uint32(channelserver.TimeWeekStart().Unix()))
-		// End time
-		bf.WriteUint32(uint32(channelserver.TimeWeekNext().Unix()))
-		bf.WriteUint8(2) // Unk
-		bf.WriteUint32(s.server.erupeConfig.GameplayOptions.MezfesSoloTickets)
-		bf.WriteUint32(s.server.erupeConfig.GameplayOptions.MezfesGroupTickets)
-		bf.WriteUint8(8)  // Stalls open
-		bf.WriteUint8(10) // Stall Map
-		bf.WriteUint8(3)  // Pachinko
-		bf.WriteUint8(6)  // Nyanrendo
-		bf.WriteUint8(9)  // Point stall
-		if alt {
-			bf.WriteUint8(2) // Tokotoko Partnya
-		} else {
-			bf.WriteUint8(4) // Volpakkun Together
-		}
-		bf.WriteUint8(8) // Dokkan Battle Cats
-		bf.WriteUint8(5) // Goocoo Scoop
-		bf.WriteUint8(7) // Honey Panic
-	} else {
-		bf.WriteUint32(0)
-		bf.WriteUint32(0)
-		bf.WriteUint32(0)
+	tickets := []uint32{
+		s.server.erupeConfig.GameplayOptions.MezfesSoloTickets,
+		s.server.erupeConfig.GameplayOptions.MezfesGroupTickets,
+	}
+	stalls := []uint8{
+		10, 3, 6, 9, 4, 8, 5, 7,
+	}
+	if s.server.erupeConfig.GameplayOptions.MezFesSwitchMinigame {
+		stalls[4] = 2
+	}
+
+	// We can just use the start timestamp as the event ID
+	bf.WriteUint32(uint32(channelserver.TimeWeekStart().Unix()))
+	// Start time
+	bf.WriteUint32(uint32(channelserver.TimeWeekNext().Add(-time.Duration(s.server.erupeConfig.GameplayOptions.MezFesDuration) * time.Second).Unix()))
+	// End time
+	bf.WriteUint32(uint32(channelserver.TimeWeekNext().Unix()))
+	bf.WriteUint8(uint8(len(tickets)))
+	for i := range tickets {
+		bf.WriteUint32(tickets[i])
+	}
+	bf.WriteUint8(uint8(len(stalls)))
+	for i := range stalls {
+		bf.WriteUint8(stalls[i])
 	}
 	return bf.Data()
 }
--- a/server/signv2server/dbutils.go
+++ b/server/signv2server/dbutils.go
@@ -10,36 +10,40 @@ import (
 	"golang.org/x/crypto/bcrypt"
 )

-func (s *Server) createNewUser(ctx context.Context, username string, password string) (int, error) {
+func (s *Server) createNewUser(ctx context.Context, username string, password string) (uint32, uint32, error) {
 	// Create salted hash of user password
 	passwordHash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
 	if err != nil {
-		return 0, err
+		return 0, 0, err
 	}

-	var id int
+	var (
+		id     uint32
+		rights uint32
+	)
 	err = s.db.QueryRowContext(
 		ctx, `
 		INSERT INTO users (username, password, return_expires)
 		VALUES ($1, $2, $3)
-		RETURNING id
+		RETURNING id, rights
 		`,
 		username, string(passwordHash), time.Now().Add(time.Hour*24*30),
-	).Scan(&id)
-	return id, err
+	).Scan(&id, &rights)
+	return id, rights, err
 }

-func (s *Server) createLoginToken(ctx context.Context, uid int) (string, error) {
+func (s *Server) createLoginToken(ctx context.Context, uid uint32) (uint32, string, error) {
 	loginToken := token.Generate(16)
-	_, err := s.db.ExecContext(ctx, "INSERT INTO sign_sessions (user_id, token) VALUES ($1, $2)", uid, loginToken)
+	var tid uint32
+	err := s.db.QueryRowContext(ctx, "INSERT INTO sign_sessions (user_id, token) VALUES ($1, $2) RETURNING id", uid, loginToken).Scan(&tid)
 	if err != nil {
-		return "", err
+		return 0, "", err
 	}
-	return loginToken, nil
+	return tid, loginToken, nil
 }

-func (s *Server) userIDFromToken(ctx context.Context, token string) (int, error) {
-	var userID int
+func (s *Server) userIDFromToken(ctx context.Context, token string) (uint32, error) {
+	var userID uint32
 	err := s.db.QueryRowContext(ctx, "SELECT user_id FROM sign_sessions WHERE token = $1", token).Scan(&userID)
 	if err == sql.ErrNoRows {
 		return 0, fmt.Errorf("invalid login token")
@@ -49,65 +53,47 @@ func (s *Server) userIDFromToken(ctx context.Context, token string) (int, error)
 	return userID, nil
 }

-func (s *Server) createCharacter(ctx context.Context, userID int) (int, error) {
-	var charID int
-	err := s.db.QueryRowContext(ctx,
-		"SELECT id FROM characters WHERE is_new_character = true AND user_id = $1",
+func (s *Server) createCharacter(ctx context.Context, userID uint32) (Character, error) {
+	var character Character
+	err := s.db.GetContext(ctx, &character,
+		"SELECT id, name, is_female, weapon_type, hrp, gr, last_login FROM characters WHERE is_new_character = true AND user_id = $1 LIMIT 1",
 		userID,
-	).Scan(&charID)
+	)
 	if err == sql.ErrNoRows {
-		err = s.db.QueryRowContext(ctx, `
+		var count int
+		s.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM characters WHERE user_id = $1", userID).Scan(&count)
+		if count >= 16 {
+			return character, fmt.Errorf("cannot have more than 16 characters")
+		}
+		err = s.db.GetContext(ctx, &character, `
 			INSERT INTO characters (
 				user_id, is_female, is_new_character, name, unk_desc_string,
 				hrp, gr, weapon_type, last_login
 			)
 			VALUES ($1, false, true, '', '', 0, 0, 0, $2)
-			RETURNING id`,
+			RETURNING id, name, is_female, weapon_type, hrp, gr, last_login`,
 			userID, uint32(time.Now().Unix()),
-		).Scan(&charID)
+		)
 	}
-	return charID, err
+	return character, err
 }

-func (s *Server) deleteCharacter(ctx context.Context, userID int, charID int) error {
-	tx, err := s.db.BeginTx(ctx, nil)
+func (s *Server) deleteCharacter(ctx context.Context, userID uint32, charID uint32) error {
+	var isNew bool
+	err := s.db.QueryRow("SELECT is_new_character FROM characters WHERE id = $1", charID).Scan(&isNew)
 	if err != nil {
 		return err
 	}
-	defer tx.Rollback()
-
-	_, err = tx.ExecContext(
-		ctx, `
-		DELETE FROM login_boost_state
-		WHERE char_id = $1`,
-		charID,
-	)
-	if err != nil {
-		return err
+	if isNew {
+		_, err = s.db.Exec("DELETE FROM characters WHERE id = $1", charID)
+	} else {
+		_, err = s.db.Exec("UPDATE characters SET deleted = true WHERE id = $1", charID)
 	}
-	_, err = tx.ExecContext(
-		ctx, `
-		DELETE FROM guild_characters
-		WHERE character_id = $1`,
-		charID,
-	)
-	if err != nil {
-		return err
-	}
-	_, err = tx.ExecContext(
-		ctx, `
-		DELETE FROM characters
-		WHERE user_id = $1 AND id = $2`,
-		userID, charID,
-	)
-	if err != nil {
-		return err
-	}
-	return tx.Commit()
+	return err
 }

-func (s *Server) getCharactersForUser(ctx context.Context, uid int) ([]Character, error) {
-	characters := make([]Character, 0)
+func (s *Server) getCharactersForUser(ctx context.Context, uid uint32) ([]Character, error) {
+	var characters []Character
 	err := s.db.SelectContext(
 		ctx, &characters, `
 		SELECT id, name, is_female, weapon_type, hrp, gr, last_login
@@ -120,3 +106,30 @@ func (s *Server) getCharactersForUser(ctx context.Context, uid int) ([]Character
 	}
 	return characters, nil
 }
+
+func (s *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)
+	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)
+	} else {
+		err := s.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)
+		}
+	}
+	s.db.Exec("UPDATE users SET last_login=$1 WHERE id=$2", time.Now(), uid)
+	return returnExpiry
+}
+
+func (s *Server) exportSave(ctx context.Context, uid uint32, cid uint32) (map[string]interface{}, error) {
+	row := s.db.QueryRowxContext(ctx, "SELECT * FROM characters WHERE id=$1 AND user_id=$2", cid, uid)
+	result := make(map[string]interface{})
+	err := row.MapScan(result)
+	if err != nil {
+		return nil, err
+	}
+	return result, nil
+}
--- a/server/signv2server/endpoints.go
+++ b/server/signv2server/endpoints.go
@@ -4,7 +4,10 @@ import (
 	"database/sql"
 	"encoding/json"
 	"errors"
+	_config "erupe-ce/config"
+	"erupe-ce/server/channelserver"
 	"net/http"
+	"strings"
 	"time"

 	"github.com/lib/pq"
@@ -12,52 +15,99 @@ import (
 	"golang.org/x/crypto/bcrypt"
 )

-type LauncherMessage struct {
-	Message string `json:"message"`
-	Date    int64  `json:"date"`
-	Link    string `json:"link"`
+const (
+	NotificationDefault = iota
+	NotificationNew
+)
+
+type LauncherResponse struct {
+	Banners  []_config.SignV2Banner  `json:"banners"`
+	Messages []_config.SignV2Message `json:"messages"`
+	Links    []_config.SignV2Link    `json:"links"`
+}
+
+type User struct {
+	TokenID uint32 `json:"tokenId"`
+	Token   string `json:"token"`
+	Rights  uint32 `json:"rights"`
 }

 type Character struct {
-	ID        int    `json:"id"`
+	ID        uint32 `json:"id"`
 	Name      string `json:"name"`
 	IsFemale  bool   `json:"isFemale" db:"is_female"`
-	Weapon    int    `json:"weapon" db:"weapon_type"`
-	HR        int    `json:"hr" db:"hrp"`
-	GR        int    `json:"gr"`
-	LastLogin int64  `json:"lastLogin" db:"last_login"`
+	Weapon    uint32 `json:"weapon" db:"weapon_type"`
+	HR        uint32 `json:"hr" db:"hrp"`
+	GR        uint32 `json:"gr"`
+	LastLogin int32  `json:"lastLogin" db:"last_login"`
+}
+
+type MezFes struct {
+	ID           uint32   `json:"id"`
+	Start        uint32   `json:"start"`
+	End          uint32   `json:"end"`
+	SoloTickets  uint32   `json:"soloTickets"`
+	GroupTickets uint32   `json:"groupTickets"`
+	Stalls       []uint32 `json:"stalls"`
+}
+
+type AuthData struct {
+	CurrentTS     uint32      `json:"currentTs"`
+	ExpiryTS      uint32      `json:"expiryTs"`
+	EntranceCount uint32      `json:"entranceCount"`
+	Notices       []string    `json:"notices"`
+	User          User        `json:"user"`
+	Characters    []Character `json:"characters"`
+	MezFes        *MezFes     `json:"mezFes"`
+	PatchServer   string      `json:"patchServer"`
+}
+
+type ExportData struct {
+	Character map[string]interface{} `json:"character"`
+}
+
+func (s *Server) newAuthData(userID uint32, userRights uint32, userTokenID uint32, userToken string, characters []Character) AuthData {
+	resp := AuthData{
+		CurrentTS:     uint32(channelserver.TimeAdjusted().Unix()),
+		ExpiryTS:      uint32(s.getReturnExpiry(userID).Unix()),
+		EntranceCount: 1,
+		User: User{
+			Rights:  userRights,
+			TokenID: userTokenID,
+			Token:   userToken,
+		},
+		Characters:  characters,
+		PatchServer: s.erupeConfig.SignV2.PatchServer,
+		Notices:     []string{},
+	}
+	if s.erupeConfig.DevModeOptions.MaxLauncherHR {
+		for i := range resp.Characters {
+			resp.Characters[i].HR = 7
+		}
+	}
+	stalls := []uint32{10, 3, 6, 9, 4, 8, 5, 7}
+	if s.erupeConfig.GameplayOptions.MezFesSwitchMinigame {
+		stalls[4] = 2
+	}
+	resp.MezFes = &MezFes{
+		ID:           uint32(channelserver.TimeWeekStart().Unix()),
+		Start:        uint32(channelserver.TimeWeekStart().Add(-time.Duration(s.erupeConfig.GameplayOptions.MezFesDuration) * time.Second).Unix()),
+		End:          uint32(channelserver.TimeWeekNext().Unix()),
+		SoloTickets:  s.erupeConfig.GameplayOptions.MezfesSoloTickets,
+		GroupTickets: s.erupeConfig.GameplayOptions.MezfesGroupTickets,
+		Stalls:       stalls,
+	}
+	if !s.erupeConfig.HideLoginNotice {
+		resp.Notices = append(resp.Notices, strings.Join(s.erupeConfig.LoginNotices[:], "<PAGE>"))
+	}
+	return resp
 }

 func (s *Server) Launcher(w http.ResponseWriter, r *http.Request) {
-	var respData struct {
-		Important []LauncherMessage `json:"important"`
-		Normal    []LauncherMessage `json:"normal"`
-	}
-	respData.Important = []LauncherMessage{
-		{
-			Message: "Server Update 9 Released!",
-			Date:    time.Date(2022, 8, 2, 0, 0, 0, 0, time.UTC).Unix(),
-			Link:    "https://discord.com/channels/368424389416583169/929509970624532511/1003985850255818762",
-		},
-		{
-			Message: "Eng 2.0 & Ravi Patch Released!",
-			Date:    time.Date(2022, 5, 3, 0, 0, 0, 0, time.UTC).Unix(),
-			Link:    "https://discord.com/channels/368424389416583169/929509970624532511/969305400795078656",
-		},
-		{
-			Message: "Launcher Patch V1.0 Released!",
-			Date:    time.Date(2022, 4, 24, 0, 0, 0, 0, time.UTC).Unix(),
-			Link:    "https://discord.com/channels/368424389416583169/929509970624532511/969286397301248050",
-		},
-	}
-	respData.Normal = []LauncherMessage{
-		{
-			Message: "Join the community Discord for updates!",
-			Date:    time.Date(2022, 4, 24, 0, 0, 0, 0, time.UTC).Unix(),
-			Link:    "https://discord.gg/CFnzbhQ",
-		},
-	}
-	w.WriteHeader(200)
+	var respData LauncherResponse
+	respData.Banners = s.erupeConfig.SignV2.Banners
+	respData.Messages = s.erupeConfig.SignV2.Messages
+	respData.Links = s.erupeConfig.SignV2.Links
 	w.Header().Add("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(respData)
 }
@@ -71,17 +121,17 @@ func (s *Server) Login(w http.ResponseWriter, r *http.Request) {
 	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
 		s.logger.Error("JSON decode error", zap.Error(err))
 		w.WriteHeader(400)
-		w.Write([]byte("Invalid data received"))
 		return
 	}
 	var (
-		userID   int
-		password string
+		userID     uint32
+		userRights uint32
+		password   string
 	)
-	err := s.db.QueryRow("SELECT id, password FROM users WHERE username = $1", reqData.Username).Scan(&userID, &password)
+	err := s.db.QueryRow("SELECT id, password, rights FROM users WHERE username = $1", reqData.Username).Scan(&userID, &password, &userRights)
 	if err == sql.ErrNoRows {
 		w.WriteHeader(400)
-		w.Write([]byte("Username does not exist"))
+		w.Write([]byte("username-error"))
 		return
 	} else if err != nil {
 		s.logger.Warn("SQL query error", zap.Error(err))
@@ -90,27 +140,26 @@ func (s *Server) Login(w http.ResponseWriter, r *http.Request) {
 	}
 	if bcrypt.CompareHashAndPassword([]byte(password), []byte(reqData.Password)) != nil {
 		w.WriteHeader(400)
-		w.Write([]byte("Your password is incorrect"))
+		w.Write([]byte("password-error"))
 		return
 	}

-	var respData struct {
-		Token      string      `json:"token"`
-		Characters []Character `json:"characters"`
-	}
-	respData.Token, err = s.createLoginToken(ctx, userID)
+	userTokenID, userToken, err := s.createLoginToken(ctx, userID)
 	if err != nil {
 		s.logger.Warn("Error registering login token", zap.Error(err))
 		w.WriteHeader(500)
 		return
 	}
-	respData.Characters, err = s.getCharactersForUser(ctx, userID)
+	characters, err := s.getCharactersForUser(ctx, userID)
 	if err != nil {
 		s.logger.Warn("Error getting characters from DB", zap.Error(err))
 		w.WriteHeader(500)
 		return
 	}
-	w.WriteHeader(200)
+	if characters == nil {
+		characters = []Character{}
+	}
+	respData := s.newAuthData(userID, userRights, userTokenID, userToken, characters)
 	w.Header().Add("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(respData)
 }
@@ -124,16 +173,19 @@ func (s *Server) Register(w http.ResponseWriter, r *http.Request) {
 	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
 		s.logger.Error("JSON decode error", zap.Error(err))
 		w.WriteHeader(400)
-		w.Write([]byte("Invalid data received"))
+		return
+	}
+	if reqData.Username == "" || reqData.Password == "" {
+		w.WriteHeader(400)
 		return
 	}
 	s.logger.Info("Creating account", zap.String("username", reqData.Username))
-	userID, err := s.createNewUser(ctx, reqData.Username, reqData.Password)
+	userID, userRights, err := s.createNewUser(ctx, reqData.Username, reqData.Password)
 	if err != nil {
 		var pqErr *pq.Error
 		if errors.As(err, &pqErr) && pqErr.Constraint == "users_username_key" {
 			w.WriteHeader(400)
-			w.Write([]byte("User already exists"))
+			w.Write([]byte("username-exists-error"))
 			return
 		}
 		s.logger.Error("Error checking user", zap.Error(err), zap.String("username", reqData.Username))
@@ -141,15 +193,14 @@ func (s *Server) Register(w http.ResponseWriter, r *http.Request) {
 		return
 	}

-	var respData struct {
-		Token string `json:"token"`
-	}
-	respData.Token, err = s.createLoginToken(ctx, userID)
+	userTokenID, userToken, err := s.createLoginToken(ctx, userID)
 	if err != nil {
 		s.logger.Error("Error registering login token", zap.Error(err))
 		w.WriteHeader(500)
 		return
 	}
+	respData := s.newAuthData(userID, userRights, userTokenID, userToken, []Character{})
+	w.Header().Add("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(respData)
 }

@@ -161,37 +212,36 @@ func (s *Server) CreateCharacter(w http.ResponseWriter, r *http.Request) {
 	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
 		s.logger.Error("JSON decode error", zap.Error(err))
 		w.WriteHeader(400)
-		w.Write([]byte("Invalid data received"))
 		return
 	}

-	var respData struct {
-		CharID int `json:"id"`
-	}
 	userID, err := s.userIDFromToken(ctx, reqData.Token)
 	if err != nil {
 		w.WriteHeader(401)
 		return
 	}
-	respData.CharID, err = s.createCharacter(ctx, userID)
+	character, err := s.createCharacter(ctx, userID)
 	if err != nil {
 		s.logger.Error("Failed to create character", zap.Error(err), zap.String("token", reqData.Token))
 		w.WriteHeader(500)
 		return
 	}
-	json.NewEncoder(w).Encode(respData)
+	if s.erupeConfig.DevModeOptions.MaxLauncherHR {
+		character.HR = 7
+	}
+	w.Header().Add("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(character)
 }

 func (s *Server) DeleteCharacter(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	var reqData struct {
 		Token  string `json:"token"`
-		CharID int    `json:"id"`
+		CharID uint32 `json:"charId"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
 		s.logger.Error("JSON decode error", zap.Error(err))
 		w.WriteHeader(400)
-		w.Write([]byte("Invalid data received"))
 		return
 	}
 	userID, err := s.userIDFromToken(ctx, reqData.Token)
@@ -200,9 +250,39 @@ func (s *Server) DeleteCharacter(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if err := s.deleteCharacter(ctx, userID, reqData.CharID); err != nil {
-		s.logger.Error("Failed to delete character", zap.Error(err), zap.String("token", reqData.Token), zap.Int("charID", reqData.CharID))
+		s.logger.Error("Failed to delete character", zap.Error(err), zap.String("token", reqData.Token), zap.Uint32("charID", reqData.CharID))
 		w.WriteHeader(500)
 		return
 	}
+	w.Header().Add("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(struct{}{})
 }
+
+func (s *Server) ExportSave(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	var reqData struct {
+		Token  string `json:"token"`
+		CharID uint32 `json:"charId"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&reqData); err != nil {
+		s.logger.Error("JSON decode error", zap.Error(err))
+		w.WriteHeader(400)
+		return
+	}
+	userID, err := s.userIDFromToken(ctx, reqData.Token)
+	if err != nil {
+		w.WriteHeader(401)
+		return
+	}
+	character, err := s.exportSave(ctx, userID, reqData.CharID)
+	if err != nil {
+		s.logger.Error("Failed to export save", zap.Error(err), zap.String("token", reqData.Token), zap.Uint32("charID", reqData.CharID))
+		w.WriteHeader(500)
+		return
+	}
+	save := ExportData{
+		Character: character,
+	}
+	w.Header().Add("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(save)
+}
--- a/server/signv2server/signv2_server.go
+++ b/server/signv2server/signv2_server.go
@@ -51,6 +51,7 @@ func (s *Server) Start() error {
 	r.HandleFunc("/register", s.Register)
 	r.HandleFunc("/character/create", s.CreateCharacter)
 	r.HandleFunc("/character/delete", s.DeleteCharacter)
+	r.HandleFunc("/character/export", s.ExportSave)
 	handler := handlers.CORS(handlers.AllowedHeaders([]string{"Content-Type"}))(r)
 	s.httpServer.Handler = handlers.LoggingHandler(os.Stdout, handler)
 	s.httpServer.Addr = fmt.Sprintf(":%d", s.erupeConfig.SignV2.Port)