629 lines
17 KiB
Go
629 lines
17 KiB
Go
package commands
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// RegisterConsoleCommands registers all console-level commands
|
|
func RegisterConsoleCommands(cm *CommandManager) error {
|
|
commands := []*Command{
|
|
// Player management commands
|
|
{
|
|
Name: "console_ban",
|
|
Type: CommandTypeConsole,
|
|
Description: "Bans a player account",
|
|
Usage: "console_ban <player> [duration] [reason]",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleBan,
|
|
},
|
|
{
|
|
Name: "console_unban",
|
|
Type: CommandTypeConsole,
|
|
Description: "Unbans a player account",
|
|
Usage: "console_unban <player>",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleUnban,
|
|
},
|
|
{
|
|
Name: "console_kick",
|
|
Type: CommandTypeConsole,
|
|
Description: "Kicks a player from the server",
|
|
Usage: "console_kick <player> [reason]",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleKick,
|
|
},
|
|
|
|
// Communication commands
|
|
{
|
|
Name: "console_announce",
|
|
Type: CommandTypeConsole,
|
|
Description: "Announces a message to all players",
|
|
Usage: "console_announce <message>",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleAnnounce,
|
|
},
|
|
{
|
|
Name: "console_broadcast",
|
|
Type: CommandTypeConsole,
|
|
Description: "Broadcasts a message to all players",
|
|
Usage: "console_broadcast <message>",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleBroadcast,
|
|
},
|
|
{
|
|
Name: "channel",
|
|
Type: CommandTypeConsole,
|
|
Description: "Sends message to specific channel",
|
|
Usage: "channel <channel_id> <message>",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleChannel,
|
|
},
|
|
{
|
|
Name: "console_tell",
|
|
Type: CommandTypeConsole,
|
|
Description: "Sends private message to a player",
|
|
Usage: "console_tell <player> <message>",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleTell,
|
|
},
|
|
|
|
// Information commands
|
|
{
|
|
Name: "console_guild",
|
|
Type: CommandTypeConsole,
|
|
Description: "Guild management commands",
|
|
Usage: "console_guild <list|info|delete> [options]",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleGuild,
|
|
},
|
|
{
|
|
Name: "player",
|
|
Type: CommandTypeConsole,
|
|
Description: "Player information and management",
|
|
Usage: "player <list|info|modify> [options]",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsolePlayer,
|
|
},
|
|
{
|
|
Name: "setadmin",
|
|
Type: CommandTypeConsole,
|
|
Description: "Sets admin level for a player",
|
|
Usage: "setadmin <player> <admin_level>",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleSetAdmin,
|
|
},
|
|
{
|
|
Name: "world",
|
|
Type: CommandTypeConsole,
|
|
Description: "World server information",
|
|
Usage: "world",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleWorld,
|
|
},
|
|
{
|
|
Name: "console_zone",
|
|
Type: CommandTypeConsole,
|
|
Description: "Zone information and management",
|
|
Usage: "console_zone <list|info|shutdown> [options]",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleZone,
|
|
},
|
|
{
|
|
Name: "console_who",
|
|
Type: CommandTypeConsole,
|
|
Description: "Lists players online",
|
|
Usage: "console_who [pattern]",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleWho,
|
|
},
|
|
|
|
// MOTD commands
|
|
{
|
|
Name: "getmotd",
|
|
Type: CommandTypeConsole,
|
|
Description: "Gets the current MOTD",
|
|
Usage: "getmotd",
|
|
RequiredLevel: AdminLevelGM,
|
|
Handler: HandleConsoleGetMOTD,
|
|
},
|
|
{
|
|
Name: "setmotd",
|
|
Type: CommandTypeConsole,
|
|
Description: "Sets the MOTD",
|
|
Usage: "setmotd <message>",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleSetMOTD,
|
|
},
|
|
|
|
// Server management commands
|
|
{
|
|
Name: "console_reload",
|
|
Type: CommandTypeConsole,
|
|
Description: "Reloads server data",
|
|
Usage: "console_reload <spells|quests|zones|items|rules|all>",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleReload,
|
|
},
|
|
{
|
|
Name: "console_shutdown",
|
|
Type: CommandTypeConsole,
|
|
Description: "Shuts down the server",
|
|
Usage: "console_shutdown [time_minutes] [reason]",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleShutdown,
|
|
},
|
|
{
|
|
Name: "console_cancelshutdown",
|
|
Type: CommandTypeConsole,
|
|
Description: "Cancels a scheduled shutdown",
|
|
Usage: "console_cancelshutdown",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleCancelShutdown,
|
|
},
|
|
{
|
|
Name: "exit",
|
|
Type: CommandTypeConsole,
|
|
Description: "Exits the server immediately",
|
|
Usage: "exit",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleExit,
|
|
},
|
|
{
|
|
Name: "rules",
|
|
Type: CommandTypeConsole,
|
|
Description: "Rules management commands",
|
|
Usage: "rules <list|get|set> [options]",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleRules,
|
|
},
|
|
|
|
// Testing commands
|
|
{
|
|
Name: "console_test",
|
|
Type: CommandTypeConsole,
|
|
Description: "Testing command for development",
|
|
Usage: "console_test [parameters]",
|
|
RequiredLevel: AdminLevelAdmin,
|
|
Handler: HandleConsoleTest,
|
|
},
|
|
}
|
|
|
|
for _, cmd := range commands {
|
|
if err := cm.Register(cmd); err != nil {
|
|
return fmt.Errorf("failed to register console command %s: %w", cmd.Name, err)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleBan handles the console ban command
|
|
func HandleConsoleBan(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: ban <player> [duration] [reason]")
|
|
return nil
|
|
}
|
|
|
|
playerName := ctx.Arguments[0]
|
|
duration := "permanent"
|
|
reason := "Banned by administrator"
|
|
|
|
if ctx.ArgumentCount() > 1 {
|
|
duration = ctx.Arguments[1]
|
|
}
|
|
if ctx.ArgumentCount() > 2 {
|
|
reason = ctx.GetRemainingArguments(2)
|
|
}
|
|
|
|
// TODO: Implement actual ban functionality
|
|
ctx.AddStatusMessage(fmt.Sprintf("Banned player '%s' for %s with reason: %s",
|
|
playerName, duration, reason))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleUnban handles the console unban command
|
|
func HandleConsoleUnban(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, 1); err != nil {
|
|
ctx.AddErrorMessage("Usage: unban <player>")
|
|
return nil
|
|
}
|
|
|
|
playerName := ctx.Arguments[0]
|
|
|
|
// TODO: Implement actual unban functionality
|
|
ctx.AddStatusMessage(fmt.Sprintf("Unbanned player '%s'", playerName))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleKick handles the console kick command
|
|
func HandleConsoleKick(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: kick <player> [reason]")
|
|
return nil
|
|
}
|
|
|
|
playerName := ctx.Arguments[0]
|
|
reason := "Kicked by administrator"
|
|
if ctx.ArgumentCount() > 1 {
|
|
reason = ctx.GetRemainingArguments(1)
|
|
}
|
|
|
|
// TODO: Implement actual kick functionality
|
|
ctx.AddStatusMessage(fmt.Sprintf("Kicked player '%s' with reason: %s", playerName, reason))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleAnnounce handles the console announce command
|
|
func HandleConsoleAnnounce(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: announce <message>")
|
|
return nil
|
|
}
|
|
|
|
message := ctx.RawArguments
|
|
|
|
// TODO: Implement server announcement
|
|
ctx.AddMessage(ChannelBroadcast, ColorRed, fmt.Sprintf("[ANNOUNCEMENT] %s", message))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleBroadcast handles the console broadcast command
|
|
func HandleConsoleBroadcast(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: broadcast <message>")
|
|
return nil
|
|
}
|
|
|
|
message := ctx.RawArguments
|
|
|
|
// TODO: Implement server-wide broadcast
|
|
ctx.AddMessage(ChannelBroadcast, ColorYellow, fmt.Sprintf("[BROADCAST] %s", message))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleChannel handles the console channel command
|
|
func HandleConsoleChannel(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(2, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: channel <channel_id> <message>")
|
|
return nil
|
|
}
|
|
|
|
channelID := ctx.GetArgumentInt(0, 0)
|
|
message := ctx.GetRemainingArguments(1)
|
|
|
|
if channelID < 0 {
|
|
ctx.AddErrorMessage("Invalid channel ID")
|
|
return nil
|
|
}
|
|
|
|
// TODO: Implement channel message sending
|
|
ctx.AddMessage(channelID, ColorWhite, message)
|
|
ctx.AddStatusMessage(fmt.Sprintf("Sent message to channel %d: %s", channelID, message))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleTell handles the console tell command
|
|
func HandleConsoleTell(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(2, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: tell <player> <message>")
|
|
return nil
|
|
}
|
|
|
|
targetName := ctx.Arguments[0]
|
|
message := ctx.GetRemainingArguments(1)
|
|
|
|
// TODO: Implement tell system
|
|
ctx.AddStatusMessage(fmt.Sprintf("Told %s: %s", targetName, message))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleGuild handles the console guild command
|
|
func HandleConsoleGuild(ctx *CommandContext) error {
|
|
if ctx.ArgumentCount() == 0 {
|
|
ctx.AddErrorMessage("Usage: guild <list|info|delete> [options]")
|
|
return nil
|
|
}
|
|
|
|
subCommand := strings.ToLower(ctx.Arguments[0])
|
|
|
|
switch subCommand {
|
|
case "list":
|
|
// TODO: List all guilds
|
|
ctx.AddStatusMessage("Guild listing (not yet implemented)")
|
|
|
|
case "info":
|
|
if ctx.ArgumentCount() < 2 {
|
|
ctx.AddErrorMessage("Usage: guild info <guild_name>")
|
|
return nil
|
|
}
|
|
guildName := ctx.Arguments[1]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Guild info for '%s' (not yet implemented)", guildName))
|
|
|
|
case "delete":
|
|
if ctx.ArgumentCount() < 2 {
|
|
ctx.AddErrorMessage("Usage: guild delete <guild_name>")
|
|
return nil
|
|
}
|
|
guildName := ctx.Arguments[1]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Deleted guild '%s' (not yet implemented)", guildName))
|
|
|
|
default:
|
|
ctx.AddErrorMessage("Usage: guild <list|info|delete> [options]")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsolePlayer handles the console player command
|
|
func HandleConsolePlayer(ctx *CommandContext) error {
|
|
if ctx.ArgumentCount() == 0 {
|
|
ctx.AddErrorMessage("Usage: player <list|info|modify> [options]")
|
|
return nil
|
|
}
|
|
|
|
subCommand := strings.ToLower(ctx.Arguments[0])
|
|
|
|
switch subCommand {
|
|
case "list":
|
|
// TODO: List all players
|
|
ctx.AddStatusMessage("Player listing (not yet implemented)")
|
|
|
|
case "info":
|
|
if ctx.ArgumentCount() < 2 {
|
|
ctx.AddErrorMessage("Usage: player info <player_name>")
|
|
return nil
|
|
}
|
|
playerName := ctx.Arguments[1]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Player info for '%s' (not yet implemented)", playerName))
|
|
|
|
case "modify":
|
|
if ctx.ArgumentCount() < 4 {
|
|
ctx.AddErrorMessage("Usage: player modify <player_name> <attribute> <value>")
|
|
return nil
|
|
}
|
|
playerName := ctx.Arguments[1]
|
|
attribute := ctx.Arguments[2]
|
|
value := ctx.Arguments[3]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Modified %s's %s to %s (not yet implemented)",
|
|
playerName, attribute, value))
|
|
|
|
default:
|
|
ctx.AddErrorMessage("Usage: player <list|info|modify> [options]")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleSetAdmin handles the console setadmin command
|
|
func HandleConsoleSetAdmin(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(2, 2); err != nil {
|
|
ctx.AddErrorMessage("Usage: setadmin <player> <admin_level>")
|
|
return nil
|
|
}
|
|
|
|
playerName := ctx.Arguments[0]
|
|
adminLevel := ctx.GetArgumentInt(1, 0)
|
|
|
|
if adminLevel < 0 || adminLevel > 300 {
|
|
ctx.AddErrorMessage("Admin level must be between 0 and 300")
|
|
return nil
|
|
}
|
|
|
|
// TODO: Implement admin level setting
|
|
ctx.AddStatusMessage(fmt.Sprintf("Set %s's admin level to %d", playerName, adminLevel))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleWorld handles the console world command
|
|
func HandleConsoleWorld(ctx *CommandContext) error {
|
|
// TODO: Show world server statistics
|
|
ctx.AddStatusMessage("World Server Status:")
|
|
ctx.AddStatusMessage(" Uptime: 1 hour 23 minutes (not yet implemented)")
|
|
ctx.AddStatusMessage(" Players Online: 5 (not yet implemented)")
|
|
ctx.AddStatusMessage(" Zones Active: 12 (not yet implemented)")
|
|
ctx.AddStatusMessage(" Memory Usage: 256MB (not yet implemented)")
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleZone handles the console zone command
|
|
func HandleConsoleZone(ctx *CommandContext) error {
|
|
if ctx.ArgumentCount() == 0 {
|
|
ctx.AddErrorMessage("Usage: zone <list|info|shutdown> [options]")
|
|
return nil
|
|
}
|
|
|
|
subCommand := strings.ToLower(ctx.Arguments[0])
|
|
|
|
switch subCommand {
|
|
case "list":
|
|
// TODO: List all zones
|
|
ctx.AddStatusMessage("Zone listing (not yet implemented)")
|
|
|
|
case "info":
|
|
if ctx.ArgumentCount() < 2 {
|
|
ctx.AddErrorMessage("Usage: zone info <zone_name>")
|
|
return nil
|
|
}
|
|
zoneName := ctx.Arguments[1]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Zone info for '%s' (not yet implemented)", zoneName))
|
|
|
|
case "shutdown":
|
|
if ctx.ArgumentCount() < 2 {
|
|
ctx.AddErrorMessage("Usage: zone shutdown <zone_name>")
|
|
return nil
|
|
}
|
|
zoneName := ctx.Arguments[1]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Shutting down zone '%s' (not yet implemented)", zoneName))
|
|
|
|
default:
|
|
ctx.AddErrorMessage("Usage: zone <list|info|shutdown> [options]")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleWho handles the console who command
|
|
func HandleConsoleWho(ctx *CommandContext) error {
|
|
pattern := ""
|
|
if ctx.ArgumentCount() > 0 {
|
|
pattern = ctx.Arguments[0]
|
|
}
|
|
|
|
// TODO: Implement player listing
|
|
if pattern != "" {
|
|
ctx.AddStatusMessage(fmt.Sprintf("Players matching '%s':", pattern))
|
|
} else {
|
|
ctx.AddStatusMessage("Players online:")
|
|
}
|
|
ctx.AddStatusMessage(" TestPlayer (Zone: Qeynos, Level: 10)")
|
|
ctx.AddStatusMessage("Total: 1 player online")
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleGetMOTD handles the console getmotd command
|
|
func HandleConsoleGetMOTD(ctx *CommandContext) error {
|
|
// TODO: Get actual MOTD from database
|
|
ctx.AddStatusMessage("Current MOTD:")
|
|
ctx.AddStatusMessage(" Welcome to EQ2Go Server!")
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleSetMOTD handles the console setmotd command
|
|
func HandleConsoleSetMOTD(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, -1); err != nil {
|
|
ctx.AddErrorMessage("Usage: setmotd <message>")
|
|
return nil
|
|
}
|
|
|
|
message := ctx.RawArguments
|
|
|
|
// TODO: Set MOTD in database
|
|
ctx.AddStatusMessage(fmt.Sprintf("MOTD set to: %s", message))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleReload handles the console reload command
|
|
func HandleConsoleReload(ctx *CommandContext) error {
|
|
if err := ctx.ValidateArgumentCount(1, 1); err != nil {
|
|
ctx.AddErrorMessage("Usage: reload <spells|quests|zones|items|rules|all>")
|
|
return nil
|
|
}
|
|
|
|
reloadType := strings.ToLower(ctx.Arguments[0])
|
|
|
|
switch reloadType {
|
|
case "spells":
|
|
ctx.AddStatusMessage("Reloaded spells")
|
|
case "quests":
|
|
ctx.AddStatusMessage("Reloaded quests")
|
|
case "zones":
|
|
ctx.AddStatusMessage("Reloaded zones")
|
|
case "items":
|
|
ctx.AddStatusMessage("Reloaded items")
|
|
case "rules":
|
|
ctx.AddStatusMessage("Reloaded rules")
|
|
case "all":
|
|
ctx.AddStatusMessage("Reloaded all server data")
|
|
default:
|
|
ctx.AddErrorMessage("Usage: reload <spells|quests|zones|items|rules|all>")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleShutdown handles the console shutdown command
|
|
func HandleConsoleShutdown(ctx *CommandContext) error {
|
|
minutes := 5 // Default 5 minutes
|
|
reason := "Server maintenance"
|
|
|
|
if ctx.ArgumentCount() > 0 {
|
|
minutes = ctx.GetArgumentInt(0, 5)
|
|
}
|
|
if ctx.ArgumentCount() > 1 {
|
|
reason = ctx.GetRemainingArguments(1)
|
|
}
|
|
|
|
// TODO: Implement server shutdown
|
|
ctx.AddStatusMessage(fmt.Sprintf("Server shutdown scheduled in %d minutes. Reason: %s",
|
|
minutes, reason))
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleCancelShutdown handles the console cancelshutdown command
|
|
func HandleConsoleCancelShutdown(ctx *CommandContext) error {
|
|
// TODO: Implement shutdown cancellation
|
|
ctx.AddStatusMessage("Server shutdown cancelled")
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleExit handles the console exit command
|
|
func HandleConsoleExit(ctx *CommandContext) error {
|
|
// TODO: Implement immediate server exit
|
|
ctx.AddStatusMessage("Exiting server immediately...")
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleRules handles the console rules command
|
|
func HandleConsoleRules(ctx *CommandContext) error {
|
|
if ctx.ArgumentCount() == 0 {
|
|
ctx.AddErrorMessage("Usage: rules <list|get|set> [options]")
|
|
return nil
|
|
}
|
|
|
|
subCommand := strings.ToLower(ctx.Arguments[0])
|
|
|
|
switch subCommand {
|
|
case "list":
|
|
// TODO: List all rules
|
|
ctx.AddStatusMessage("Server rules listing (not yet implemented)")
|
|
|
|
case "get":
|
|
if ctx.ArgumentCount() < 2 {
|
|
ctx.AddErrorMessage("Usage: rules get <rule_name>")
|
|
return nil
|
|
}
|
|
ruleName := ctx.Arguments[1]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Rule '%s' value (not yet implemented)", ruleName))
|
|
|
|
case "set":
|
|
if ctx.ArgumentCount() < 3 {
|
|
ctx.AddErrorMessage("Usage: rules set <rule_name> <value>")
|
|
return nil
|
|
}
|
|
ruleName := ctx.Arguments[1]
|
|
value := ctx.Arguments[2]
|
|
ctx.AddStatusMessage(fmt.Sprintf("Set rule '%s' to '%s' (not yet implemented)",
|
|
ruleName, value))
|
|
|
|
default:
|
|
ctx.AddErrorMessage("Usage: rules <list|get|set> [options]")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// HandleConsoleTest handles the console test command
|
|
func HandleConsoleTest(ctx *CommandContext) error {
|
|
ctx.AddStatusMessage("Console test command executed successfully")
|
|
|
|
if ctx.ArgumentCount() > 0 {
|
|
ctx.AddStatusMessage(fmt.Sprintf("Arguments: %s", ctx.RawArguments))
|
|
}
|
|
|
|
// TODO: Add actual test functionality for development
|
|
return nil
|
|
} |