i18n proposal

server/channelserver/handlers_cafe.go

@@ -94,7 +94,7 @@ func handleMsgMhfGetCafeDuration(s *Session, p mhfpacket.MHFPacket) {
 	}
 	bf.WriteUint32(cafeTime) // Total cafe time
 	bf.WriteUint16(0)
-	ps.Uint16(bf, fmt.Sprintf(s.server.dict["cafeReset"], int(cafeReset.Month()), cafeReset.Day()), true)
+	ps.Uint16(bf, fmt.Sprintf(s.server.i18n.cafe.reset, int(cafeReset.Month()), cafeReset.Day()), true)
 
 	doAckBufSucceed(s, pkt.AckHandle, bf.Data())
 }

server/channelserver/handlers_cast_binary.go

@@ -59,7 +59,7 @@ func init() {
 }
 
 func sendDisabledCommandMessage(s *Session, cmd _config.Command) {
-	sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandDisabled"], cmd.Name))
+	sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.disabled, cmd.Name))
 }
 
 func sendServerChatMessage(s *Session, message string) {
@@ -95,20 +95,20 @@ func parseChatCommand(s *Session, command string) {
 				if exists == 0 {
 					_, err := s.server.db.Exec(`UPDATE users u SET psn_id=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, args[1], s.charID)
 					if err == nil {
-						sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandPSNSuccess"], args[1]))
+						sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.psn.success, args[1]))
 					}
 				} else {
-					sendServerChatMessage(s, s.server.dict["commandPSNExists"])
+					sendServerChatMessage(s, s.server.i18n.commands.psn.exists)
 				}
 			} else {
-				sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandPSNError"], commands["PSN"].Prefix))
+				sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.psn.error, commands["PSN"].Prefix))
 			}
 		} else {
 			sendDisabledCommandMessage(s, commands["PSN"])
 		}
 	case commands["Reload"].Prefix:
 		if commands["Reload"].Enabled {
-			sendServerChatMessage(s, s.server.dict["commandReload"])
+			sendServerChatMessage(s, s.server.i18n.commands.reload)
 			var temp mhfpacket.MHFPacket
 			deleteNotif := byteframe.NewByteFrame()
 			for _, object := range s.stage.objects {
@@ -170,19 +170,19 @@ func parseChatCommand(s *Session, command string) {
 	case commands["KeyQuest"].Prefix:
 		if commands["KeyQuest"].Enabled {
 			if s.server.erupeConfig.RealClientMode < _config.G10 {
-				sendServerChatMessage(s, s.server.dict["commandKqfVersion"])
+				sendServerChatMessage(s, s.server.i18n.commands.kqf.version)
 			} else {
 				if len(args) > 1 {
 					if args[1] == "get" {
-						sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandKqfGet"], s.kqf))
+						sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.kqf.get, 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"])
+							sendServerChatMessage(s, s.server.i18n.commands.kqf.set.success)
 						} else {
-							sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandKqfSetError"], commands["KeyQuest"].Prefix))
+							sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.kqf.set.error, commands["KeyQuest"].Prefix))
 						}
 					}
 				}
@@ -196,12 +196,12 @@ func parseChatCommand(s *Session, command string) {
 				v, _ := strconv.Atoi(args[1])
 				_, err := s.server.db.Exec("UPDATE users u SET rights=$1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)", v, s.charID)
 				if err == nil {
-					sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandRightsSuccess"], v))
+					sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.rights.success, v))
 				} else {
-					sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandRightsError"], commands["Rights"].Prefix))
+					sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.rights.error, commands["Rights"].Prefix))
 				}
 			} else {
-				sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandRightsError"], commands["Rights"].Prefix))
+				sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.rights.error, commands["Rights"].Prefix))
 			}
 		} else {
 			sendDisabledCommandMessage(s, commands["Rights"])
@@ -225,11 +225,11 @@ func parseChatCommand(s *Session, command string) {
 									})
 									if ei != -1 {
 										delta = uint32(-1 * math.Pow(2, float64(course.ID)))
-										sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandCourseDisabled"], course.Aliases()[0]))
+										sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.course.disabled, course.Aliases()[0]))
 									}
 								} else {
 									delta = uint32(math.Pow(2, float64(course.ID)))
-									sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandCourseEnabled"], course.Aliases()[0]))
+									sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.course.enabled, course.Aliases()[0]))
 								}
 								err := s.server.db.QueryRow("SELECT rights FROM users u INNER JOIN characters c ON u.id = c.user_id WHERE c.id = $1", s.charID).Scan(&rightsInt)
 								if err == nil {
@@ -237,14 +237,14 @@ func parseChatCommand(s *Session, command string) {
 								}
 								updateRights(s)
 							} else {
-								sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandCourseLocked"], course.Aliases()[0]))
+								sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.course.locked, course.Aliases()[0]))
 							}
 							return
 						}
 					}
 				}
 			} else {
-				sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandCourseError"], commands["Course"].Prefix))
+				sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.course.error, commands["Course"].Prefix))
 			}
 		} else {
 			sendDisabledCommandMessage(s, commands["Course"])
@@ -257,45 +257,45 @@ func parseChatCommand(s *Session, command string) {
 					case "start":
 						if s.server.raviente.register[1] == 0 {
 							s.server.raviente.register[1] = s.server.raviente.register[3]
-							sendServerChatMessage(s, s.server.dict["commandRaviStartSuccess"])
+							sendServerChatMessage(s, s.server.i18n.commands.ravi.start.success)
 							s.notifyRavi()
 						} else {
-							sendServerChatMessage(s, s.server.dict["commandRaviStartError"])
+							sendServerChatMessage(s, s.server.i18n.commands.ravi.start.error)
 						}
 					case "cm", "check", "checkmultiplier", "multiplier":
-						sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandRaviMultiplier"], s.server.GetRaviMultiplier()))
+						sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.ravi.multiplier, s.server.GetRaviMultiplier()))
 					case "sr", "sendres", "resurrection", "ss", "sendsed", "rs", "reqsed":
 						if s.server.erupeConfig.RealClientMode == _config.ZZ {
 							switch args[1] {
 							case "sr", "sendres", "resurrection":
 								if s.server.raviente.state[28] > 0 {
-									sendServerChatMessage(s, s.server.dict["commandRaviResSuccess"])
+									sendServerChatMessage(s, s.server.i18n.commands.ravi.res.success)
 									s.server.raviente.state[28] = 0
 								} else {
-									sendServerChatMessage(s, s.server.dict["commandRaviResError"])
+									sendServerChatMessage(s, s.server.i18n.commands.ravi.res.error)
 								}
 							case "ss", "sendsed":
-								sendServerChatMessage(s, s.server.dict["commandRaviSedSuccess"])
+								sendServerChatMessage(s, s.server.i18n.commands.ravi.sed.success)
 								// Total BerRavi HP
 								HP := s.server.raviente.state[0] + s.server.raviente.state[1] + s.server.raviente.state[2] + s.server.raviente.state[3] + s.server.raviente.state[4]
 								s.server.raviente.support[1] = HP
 							case "rs", "reqsed":
-								sendServerChatMessage(s, s.server.dict["commandRaviRequest"])
+								sendServerChatMessage(s, s.server.i18n.commands.ravi.request)
 								// Total BerRavi HP
 								HP := s.server.raviente.state[0] + s.server.raviente.state[1] + s.server.raviente.state[2] + s.server.raviente.state[3] + s.server.raviente.state[4]
 								s.server.raviente.support[1] = HP + 1
 							}
 						} else {
-							sendServerChatMessage(s, s.server.dict["commandRaviVersion"])
+							sendServerChatMessage(s, s.server.i18n.commands.ravi.version)
 						}
 					default:
-						sendServerChatMessage(s, s.server.dict["commandRaviError"])
+						sendServerChatMessage(s, s.server.i18n.commands.ravi.error)
 					}
 				} else {
-					sendServerChatMessage(s, s.server.dict["commandRaviNoPlayers"])
+					sendServerChatMessage(s, s.server.i18n.commands.ravi.noPlayers)
 				}
 			} else {
-				sendServerChatMessage(s, s.server.dict["commandRaviError"])
+				sendServerChatMessage(s, s.server.i18n.commands.ravi.error)
 			}
 		} else {
 			sendDisabledCommandMessage(s, commands["Raviente"])
@@ -316,9 +316,9 @@ func parseChatCommand(s *Session, command string) {
 					MessageType:    BinaryMessageTypeState,
 					RawDataPayload: payloadBytes,
 				})
-				sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandTeleportSuccess"], x, y))
+				sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.teleport.success, x, y))
 			} else {
-				sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandTeleportError"], commands["Teleport"].Prefix))
+				sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.teleport.error, commands["Teleport"].Prefix))
 			}
 		} else {
 			sendDisabledCommandMessage(s, commands["Teleport"])
@@ -333,7 +333,7 @@ func parseChatCommand(s *Session, command string) {
 				_token = fmt.Sprintf("%x-%x", randToken[:2], randToken[2:])
 				s.server.db.Exec(`UPDATE users u SET discord_token = $1 WHERE u.id=(SELECT c.user_id FROM characters c WHERE c.id=$2)`, _token, s.charID)
 			}
-			sendServerChatMessage(s, fmt.Sprintf(s.server.dict["commandDiscordSuccess"], _token))
+			sendServerChatMessage(s, fmt.Sprintf(s.server.i18n.commands.discord.success, _token))
 		} else {
 			sendDisabledCommandMessage(s, commands["Discord"])
 		}

server/channelserver/handlers_guild_scout.go

@@ -60,9 +60,9 @@ func handleMsgMhfPostGuildScout(s *Session, p mhfpacket.MHFPacket) {
 	mail := &Mail{
 		SenderID:    s.charID,
 		RecipientID: pkt.CharID,
-		Subject:     s.server.dict["guildInviteName"],
+		Subject:     s.server.i18n.guild.invite.title,
 		Body: fmt.Sprintf(
-			s.server.dict["guildInvite"],
+			s.server.i18n.guild.invite.body,
 			guildInfo.Name,
 		),
 		IsGuildInvite: true,
@@ -146,30 +146,30 @@ func handleMsgMhfAnswerGuildScout(s *Session, p mhfpacket.MHFPacket) {
 		err = guild.AcceptApplication(s, s.charID)
 		mail = append(mail, Mail{
 			RecipientID:     s.charID,
-			Subject:         s.server.dict["guildInviteSuccessName"],
+			Subject:         s.server.i18n.guild.invite.success.title,
-			Body:            fmt.Sprintf(s.server.dict["guildInviteSuccess"], guild.Name),
+			Body:            fmt.Sprintf(s.server.i18n.guild.invite.success.body, guild.Name),
 			IsSystemMessage: true,
 		})
 		mail = append(mail, Mail{
 			SenderID:        s.charID,
 			RecipientID:     pkt.LeaderID,
-			Subject:         s.server.dict["guildInviteAcceptedName"],
+			Subject:         s.server.i18n.guild.invite.accepted.title,
-			Body:            fmt.Sprintf(s.server.dict["guildInviteAccepted"], guild.Name),
+			Body:            fmt.Sprintf(s.server.i18n.guild.invite.accepted.body, guild.Name),
 			IsSystemMessage: true,
 		})
 	} else {
 		err = guild.RejectApplication(s, s.charID)
 		mail = append(mail, Mail{
 			RecipientID:     s.charID,
-			Subject:         s.server.dict["guildInviteRejectName"],
+			Subject:         s.server.i18n.guild.invite.rejected.title,
-			Body:            fmt.Sprintf(s.server.dict["guildInviteReject"], guild.Name),
+			Body:            fmt.Sprintf(s.server.i18n.guild.invite.rejected.body, guild.Name),
 			IsSystemMessage: true,
 		})
 		mail = append(mail, Mail{
 			SenderID:        s.charID,
 			RecipientID:     pkt.LeaderID,
-			Subject:         s.server.dict["guildInviteDeclined"],
+			Subject:         s.server.i18n.guild.invite.declined.title,
-			Body:            fmt.Sprintf(s.server.dict["guildInviteDeclined"], guild.Name),
+			Body:            fmt.Sprintf(s.server.i18n.guild.invite.declined.body, guild.Name),
 			IsSystemMessage: true,
 		})
 	}

server/channelserver/sys_channel_server.go

@@ -57,7 +57,7 @@ type Server struct {
 	stages     map[string]*Stage
 
 	// Used to map different languages
-	dict map[string]string
+	i18n i18n
 
 	// UserBinary
 	userBinaryPartsLock sync.RWMutex
@@ -192,7 +192,7 @@ func NewServer(config *Config) *Server {
 	// MezFes
 	s.stages["sl1Ns462p0a0u0"] = NewStage("sl1Ns462p0a0u0")
 
-	s.dict = getLangStrings(s)
+	s.i18n = getLangStrings(s)
 
 	return s
 }
@@ -337,13 +337,13 @@ func (s *Server) BroadcastRaviente(ip uint32, port uint16, stage []byte, _type u
 	var text string
 	switch _type {
 	case 2:
-		text = s.dict["ravienteBerserk"]
+		text = s.i18n.raviente.berserk
 	case 3:
-		text = s.dict["ravienteExtreme"]
+		text = s.i18n.raviente.extreme
 	case 4:
-		text = s.dict["ravienteExtremeLimited"]
+		text = s.i18n.raviente.extremeLimited
 	case 5:
-		text = s.dict["ravienteBerserkSmall"]
+		text = s.i18n.raviente.berserkSmall
 	default:
 		s.logger.Error("Unk raviente type", zap.Uint8("_type", _type))
 	}

server/channelserver/sys_language.go

@@ -1,118 +1,206 @@
 package channelserver
 
-func getLangStrings(s *Server) map[string]string {
+type i18n struct {
-	strings := make(map[string]string)
+	language string
+	cafe     struct {
+		reset string
+	}
+	commands struct {
+		disabled string
+		reload   string
+		kqf      struct {
+			get string
+			set struct {
+				error   string
+				success string
+			}
+			version string
+		}
+		rights struct {
+			error   string
+			success string
+		}
+		course struct {
+			error    string
+			disabled string
+			enabled  string
+			locked   string
+		}
+		teleport struct {
+			error   string
+			success string
+		}
+		psn struct {
+			error   string
+			success string
+			exists  string
+		}
+		discord struct {
+			success string
+		}
+		ravi struct {
+			noCommand string
+			start     struct {
+				success string
+				error   string
+			}
+			multiplier string
+			res        struct {
+				success string
+				error   string
+			}
+			sed struct {
+				success string
+			}
+			request   string
+			error     string
+			noPlayers string
+			version   string
+		}
+	}
+	raviente struct {
+		berserk        string
+		extreme        string
+		extremeLimited string
+		berserkSmall   string
+	}
+	guild struct {
+		invite struct {
+			title   string
+			body    string
+			success struct {
+				title string
+				body  string
+			}
+			accepted struct {
+				title string
+				body  string
+			}
+			rejected struct {
+				title string
+				body  string
+			}
+			declined struct {
+				title string
+				body  string
+			}
+		}
+	}
+}
+
+func getLangStrings(s *Server) i18n {
+	var i i18n
 	switch s.erupeConfig.Language {
 	case "jp":
-		strings["language"] = "日本語"
+		i.language = "日本語"
-		strings["cafeReset"] = "%d/%dにリセット"
+		i.cafe.reset = "%d/%dにリセット"
 
-		strings["commandDisabled"] = "%sのコマンドは無効です"
+		i.commands.disabled = "%sのコマンドは無効です"
-		strings["commandReload"] = "リロードします"
+		i.commands.reload = "リロードします"
-		strings["commandKqfGet"] = "現在のキークエストフラグ：%x"
+		i.commands.kqf.get = "現在のキークエストフラグ：%x"
-		strings["commandKqfSetError"] = "キークエコマンドエラー　例：%s set xxxxxxxxxxxxxxxx"
+		i.commands.kqf.set.error = "キークエコマンドエラー　例：%s set xxxxxxxxxxxxxxxx"
-		strings["commandKqfSetSuccess"] = "キークエストのフラグが更新されました。ワールド／ランドを移動してください"
+		i.commands.kqf.set.success = "キークエストのフラグが更新されました。ワールド／ランドを移動してください"
-		strings["commandKqfVersion"] = "This command is disabled prior to MHFG10"
+		i.commands.kqf.version = "This command is disabled prior to MHFG10"
-		strings["commandRightsError"] = "コース更新コマンドエラー　例：%s x"
+		i.commands.rights.error = "コース更新コマンドエラー　例：%s x"
-		strings["commandRightsSuccess"] = "コース情報を更新しました：%d"
+		i.commands.rights.success = "コース情報を更新しました：%d"
-		strings["commandCourseError"] = "コース確認コマンドエラー　例：%s <name>"
+		i.commands.course.error = "コース確認コマンドエラー　例：%s <name>"
-		strings["commandCourseDisabled"] = "%sコースは無効です"
+		i.commands.course.disabled = "%sコースは無効です"
-		strings["commandCourseEnabled"] = "%sコースは有効です"
+		i.commands.course.enabled = "%sコースは有効です"
-		strings["commandCourseLocked"] = "%sコースはロックされています"
+		i.commands.course.locked = "%sコースはロックされています"
-		strings["commandTeleportError"] = "テレポートコマンドエラー　構文：%s x y"
+		i.commands.teleport.error = "テレポートコマンドエラー　構文：%s x y"
-		strings["commandTeleportSuccess"] = "%d %dにテレポート"
+		i.commands.teleport.success = "%d %dにテレポート"
-		strings["commandPSNError"] = "PSN連携コマンドエラー　例：%s <psn id>"
+		i.commands.psn.error = "PSN連携コマンドエラー　例：%s <psn id>"
-		strings["commandPSNSuccess"] = "PSN「%s」が連携されています"
+		i.commands.psn.success = "PSN「%s」が連携されています"
-		strings["commandPSNExists"] = "PSNは既存のユーザに接続されています"
+		i.commands.psn.exists = "PSNは既存のユーザに接続されています"
 
-		strings["commandDiscordSuccess"] = "あなたのDiscordトークン：%s"
+		i.commands.discord.success = "あなたのDiscordトークン：%s"
 
-		strings["commandRaviNoCommand"] = "ラヴィコマンドが指定されていません"
+		i.commands.ravi.noCommand = "ラヴィコマンドが指定されていません"
-		strings["commandRaviStartSuccess"] = "大討伐を開始します"
+		i.commands.ravi.start.success = "大討伐を開始します"
-		strings["commandRaviStartError"] = "大討伐は既に開催されています"
+		i.commands.ravi.start.error = "大討伐は既に開催されています"
-		strings["commandRaviMultiplier"] = "ラヴィダメージ倍率：ｘ%.2f"
+		i.commands.ravi.multiplier = "ラヴィダメージ倍率：ｘ%.2f"
-		strings["commandRaviResSuccess"] = "復活支援を実行します"
+		i.commands.ravi.res.success = "復活支援を実行します"
-		strings["commandRaviResError"] = "復活支援は実行されませんでした"
+		i.commands.ravi.res.error = "復活支援は実行されませんでした"
-		strings["commandRaviSedSuccess"] = "鎮静支援を実行します"
+		i.commands.ravi.sed.success = "鎮静支援を実行します"
-		strings["commandRaviRequest"] = "鎮静支援を要請します"
+		i.commands.ravi.request = "鎮静支援を要請します"
-		strings["commandRaviError"] = "ラヴィコマンドが認識されません"
+		i.commands.ravi.error = "ラヴィコマンドが認識されません"
-		strings["commandRaviNoPlayers"] = "誰も大討伐に参加していません"
+		i.commands.ravi.noPlayers = "誰も大討伐に参加していません"
-		strings["commandRaviVersion"] = "This command is disabled outside of MHFZZ"
+		i.commands.ravi.version = "This command is disabled outside of MHFZZ"
 
-		strings["ravienteBerserk"] = "<大討伐：猛狂期>が開催されました！"
+		i.raviente.berserk = "<大討伐：猛狂期>が開催されました！"
-		strings["ravienteExtreme"] = "<大討伐：猛狂期【極】>が開催されました！"
+		i.raviente.extreme = "<大討伐：猛狂期【極】>が開催されました！"
-		strings["ravienteExtremeLimited"] = "<大討伐：猛狂期【極】(制限付)>が開催されました！"
+		i.raviente.extremeLimited = "<大討伐：猛狂期【極】(制限付)>が開催されました！"
-		strings["ravienteBerserkSmall"] = "<大討伐：猛狂期(小数)>が開催されました！"
+		i.raviente.berserkSmall = "<大討伐：猛狂期(小数)>が開催されました！"
 
-		strings["guildInviteName"] = "猟団勧誘のご案内"
+		i.guild.invite.title = "猟団勧誘のご案内"
-		strings["guildInvite"] = "猟団「%s」からの勧誘通知です。\n「勧誘に返答」より、返答を行ってください。"
+		i.guild.invite.body = "猟団「%s」からの勧誘通知です。\n「勧誘に返答」より、返答を行ってください。"
 
-		strings["guildInviteSuccessName"] = "成功"
+		i.guild.invite.success.title = "成功"
-		strings["guildInviteSuccess"] = "あなたは「%s」に参加できました。"
+		i.guild.invite.success.body = "あなたは「%s」に参加できました。"
 
-		strings["guildInviteAcceptedName"] = "承諾されました"
+		i.guild.invite.accepted.title = "承諾されました"
-		strings["guildInviteAccepted"] = "招待した狩人が「%s」への招待を承諾しました。"
+		i.guild.invite.accepted.body = "招待した狩人が「%s」への招待を承諾しました。"
 
-		strings["guildInviteRejectName"] = "却下しました"
+		i.guild.invite.rejected.title = "却下しました"
-		strings["guildInviteReject"] = "あなたは「%s」への参加を却下しました。"
+		i.guild.invite.rejected.body = "あなたは「%s」への参加を却下しました。"
 
-		strings["guildInviteDeclinedName"] = "辞退しました"
+		i.guild.invite.declined.title = "辞退しました"
-		strings["guildInviteDeclined"] = "招待した狩人が「%s」への招待を辞退しました。"
+		i.guild.invite.declined.body = "招待した狩人が「%s」への招待を辞退しました。"
 	default:
-		strings["language"] = "English"
+		i.language = "English"
-		strings["cafeReset"] = "Resets on %d/%d"
+		i.cafe.reset = "Resets on %d/%d"
 
-		strings["commandDisabled"] = "%s command is disabled"
+		i.commands.disabled = "%s command is disabled"
-		strings["commandReload"] = "Reloading players..."
+		i.commands.reload = "Reloading players..."
-		strings["commandKqfGet"] = "KQF: %x"
+		i.commands.kqf.get = "KQF: %x"
-		strings["commandKqfSetError"] = "Error in command. Format: %s set xxxxxxxxxxxxxxxx"
+		i.commands.kqf.set.error = "Error in command. Format: %s set xxxxxxxxxxxxxxxx"
-		strings["commandKqfSetSuccess"] = "KQF set, please switch Land/World"
+		i.commands.kqf.set.success = "KQF set, please switch Land/World"
-		strings["commandKqfVersion"] = "This command is disabled prior to MHFG10"
+		i.commands.kqf.version = "This command is disabled prior to MHFG10"
-		strings["commandRightsError"] = "Error in command. Format: %s x"
+		i.commands.rights.error = "Error in command. Format: %s x"
-		strings["commandRightsSuccess"] = "Set rights integer: %d"
+		i.commands.rights.success = "Set rights integer: %d"
-		strings["commandCourseError"] = "Error in command. Format: %s <name>"
+		i.commands.course.error = "Error in command. Format: %s <name>"
-		strings["commandCourseDisabled"] = "%s Course disabled"
+		i.commands.course.disabled = "%s Course disabled"
-		strings["commandCourseEnabled"] = "%s Course enabled"
+		i.commands.course.enabled = "%s Course enabled"
-		strings["commandCourseLocked"] = "%s Course is locked"
+		i.commands.course.locked = "%s Course is locked"
-		strings["commandTeleportError"] = "Error in command. Format: %s x y"
+		i.commands.teleport.error = "Error in command. Format: %s x y"
-		strings["commandTeleportSuccess"] = "Teleporting to %d %d"
+		i.commands.teleport.success = "Teleporting to %d %d"
-		strings["commandPSNError"] = "Error in command. Format: %s <psn id>"
+		i.commands.psn.error = "Error in command. Format: %s <psn id>"
-		strings["commandPSNSuccess"] = "Connected PSN ID: %s"
+		i.commands.psn.success = "Connected PSN ID: %s"
-		strings["commandPSNExists"] = "PSN ID is connected to another account!"
+		i.commands.psn.exists = "PSN ID is connected to another account!"
 
-		strings["commandDiscordSuccess"] = "Your Discord token: %s"
+		i.commands.discord.success = "Your Discord token: %s"
 
-		strings["commandRaviNoCommand"] = "No Raviente command specified!"
+		i.commands.ravi.noCommand = "No Raviente command specified!"
-		strings["commandRaviStartSuccess"] = "The Great Slaying will begin in a moment"
+		i.commands.ravi.start.success = "The Great Slaying will begin in a moment"
-		strings["commandRaviStartError"] = "The Great Slaying has already begun!"
+		i.commands.ravi.start.error = "The Great Slaying has already begun!"
-		strings["commandRaviMultiplier"] = "Raviente multiplier is currently %.2fx"
+		i.commands.ravi.multiplier = "Raviente multiplier is currently %.2fx"
-		strings["commandRaviResSuccess"] = "Sending resurrection support!"
+		i.commands.ravi.res.success = "Sending resurrection support!"
-		strings["commandRaviResError"] = "Resurrection support has not been requested!"
+		i.commands.ravi.res.error = "Resurrection support has not been requested!"
-		strings["commandRaviSedSuccess"] = "Sending sedation support if requested!"
+		i.commands.ravi.sed.success = "Sending sedation support if requested!"
-		strings["commandRaviRequest"] = "Requesting sedation support!"
+		i.commands.ravi.request = "Requesting sedation support!"
-		strings["commandRaviError"] = "Raviente command not recognised!"
+		i.commands.ravi.error = "Raviente command not recognised!"
-		strings["commandRaviNoPlayers"] = "No one has joined the Great Slaying!"
+		i.commands.ravi.noPlayers = "No one has joined the Great Slaying!"
-		strings["commandRaviVersion"] = "This command is disabled outside of MHFZZ"
+		i.commands.ravi.version = "This command is disabled outside of MHFZZ"
 
-		strings["ravienteBerserk"] = "<Great Slaying: Berserk> is being held!"
+		i.raviente.berserk = "<Great Slaying: Berserk> is being held!"
-		strings["ravienteExtreme"] = "<Great Slaying: Extreme> is being held!"
+		i.raviente.extreme = "<Great Slaying: Extreme> is being held!"
-		strings["ravienteExtremeLimited"] = "<Great Slaying: Extreme (Limited)> is being held!"
+		i.raviente.extremeLimited = "<Great Slaying: Extreme (Limited)> is being held!"
-		strings["ravienteBerserkSmall"] = "<Great Slaying: Berserk (Small)> is being held!"
+		i.raviente.berserkSmall = "<Great Slaying: Berserk (Small)> is being held!"
 
-		strings["guildInviteName"] = "Invitation!"
+		i.guild.invite.title = "Invitation!"
-		strings["guildInvite"] = "You have been invited to join\n「%s」\nDo you want to accept?"
+		i.guild.invite.body = "You have been invited to join\n「%s」\nDo you want to accept?"
 
-		strings["guildInviteSuccessName"] = "Success!"
+		i.guild.invite.success.title = "Success!"
-		strings["guildInviteSuccess"] = "You have successfully joined\n「%s」."
+		i.guild.invite.success.body = "You have successfully joined\n「%s」."
 
-		strings["guildInviteAcceptedName"] = "Accepted"
+		i.guild.invite.accepted.title = "Accepted"
-		strings["guildInviteAccepted"] = "The recipient accepted your invitation to join\n「%s」."
+		i.guild.invite.accepted.body = "The recipient accepted your invitation to join\n「%s」."
 
-		strings["guildInviteRejectName"] = "Rejected"
+		i.guild.invite.rejected.title = "Rejected"
-		strings["guildInviteReject"] = "You rejected the invitation to join\n「%s」."
+		i.guild.invite.rejected.body = "You rejected the invitation to join\n「%s」."
 
-		strings["guildInviteDeclinedName"] = "Declined"
+		i.guild.invite.declined.title = "Declined"
-		strings["guildInviteDeclined"] = "The recipient declined your invitation to join\n「%s」."
+		i.guild.invite.declined.body = "The recipient declined your invitation to join\n「%s」."
 	}
-	return strings
+	return i
 }