public async Task HelpAsync(ObsidianContext Context)
{
StringBuilder help = new StringBuilder();
await Context.Player.SendMessageAsync(new ChatMessage()
{
Bold = true, Underline = true, Text = $"***Command Listing***"
});
foreach (var cmd in Context.Commands.GetAllCommands().Where(x => x.Parent == null))
{
// only list commands the user may execute.
var success = true;
foreach (var check in cmd.ExecutionChecks)
{
if (!await check.RunChecksAsync(Context))
{
// at least one check failed
success = false;
}
}
if (success)
{
help.Append($"{ChatColor.DarkGreen}{cmd.Name}{ChatColor.Reset}: {cmd.Description}\n");
}
}
await Context.Player.SendMessageAsync(help.ToString());
}
public async Task RequestOpAsync(ObsidianContext Context, string code = null)
{
if (!Context.Server.Config.AllowOperatorRequests)
{
await Context.Player.SendMessageAsync("§cOperator requests are disabled on this server.");
return;
}
if (Context.Server.Operators.ProcessRequest(Context.Player, code))
{
await Context.Player.SendMessageAsync("Your request has been accepted");
return;
}
if (Context.Server.Operators.CreateRequest(Context.Player))
{
await Context.Player.SendMessageAsync("A request has been to the server console");
}
else
{
await Context.Player.SendMessageAsync("§cYou have already sent a request");
}
}
public async Task TeleportAsync(ObsidianContext Context, [Remaining] Position location)
{
var player = (Player)Context.Player;
await player.SendMessageAsync($"ight homie tryna tp you (and sip dicks) {location.X} {location.Y} {location.Z}");
await player.TeleportAsync(location);
}
public async Task BreakpointAsync(ObsidianContext Context)
{
await Context.Server.BroadcastAsync("You might get kicked due to timeout, a breakpoint will hit in 3 seconds!");
await Task.Delay(3000);
Debugger.Break();
}
public async Task ForceChunkReloadAsync(ObsidianContext Context)
{
var player = (Player)Context.Player;
var server = (Server)Context.Server;
var c = player.client;
var world = server.World;
await world.UpdateChunksForClientAsync(c, true);
}
public async Task StopAsync(ObsidianContext Context)
{
var server = (Server)Context.Server;
await server.BroadcastAsync($"Server stopped by {ChatColor.Red}{Context.Player.Username}{ChatColor.Reset}.");
await Task.Run(() =>
{
server.StopServer();
});
}
public async Task RevokePermission(ObsidianContext ctx, string permission)
{
if (await ctx.Player.RevokePermission(permission))
{
await ctx.Player.SendMessageAsync($"Sucessfully revoked {ChatColor.BrightGreen}{permission}{ChatColor.Reset}.");
}
else
{
await ctx.Player.SendMessageAsync($"Failed revoking {ChatColor.Red}{permission}{ChatColor.Reset}.");
}
}
public async Task CheckPermission(ObsidianContext ctx, string permission)
{
if (await ctx.Player.HasPermission(permission))
{
await ctx.Player.SendMessageAsync($"You have {ChatColor.BrightGreen}{permission}{ChatColor.Reset}.");
}
else
{
await ctx.Player.SendMessageAsync($"You don't have {ChatColor.Red}{permission}{ChatColor.Reset}.");
}
}
public async Task ForceChunkReloadAsync(ObsidianContext Context)
{
var c = Context.Client;
var world = Context.Server.World;
int dist = c.ClientSettings?.ViewDistance ?? 1;
(int oldChunkX, int oldChunkZ) = c.Player.LastLocation.ToChunkCoord();
(int chunkX, int chunkZ) = c.Player.Location.ToChunkCoord();
await world.ResendBaseChunksAsync(dist, oldChunkX, oldChunkZ, chunkX, chunkZ, c);
}
public async Task UnclaimOpAsync(ObsidianContext Context, Player player)
{
var onlinePlayers = Context.Server.OnlinePlayers;
if (!onlinePlayers.ContainsKey(player.Uuid) || !onlinePlayers.Any(x => x.Value.Username == player.Username))
{
return;
}
Context.Server.Operators.RemoveOperator(player);
await Context.Player.SendMessageAsync($"Made {player} no longer a server operator");
}
public override async Task <bool> RunChecksAsync(ObsidianContext ctx)
{
if (this.op && ctx.Player.IsOperator)
{
return(true);
}
if (this.permission != "")
{
return(await ctx.Player.HasPermission(permission.ToLower()));
}
return(false);
}
public async Task GiveOpAsync(ObsidianContext Context, IPlayer player)
{
var server = (Server)Context.Server;
var onlinePlayers = server.OnlinePlayers;
if (!onlinePlayers.ContainsKey(player.Uuid) || !onlinePlayers.Any(x => x.Value.Username == player.Username))
{
return;
}
server.Operators.AddOperator((Player)player);
await Context.Player.SendMessageAsync($"Made {player} a server operator");
}
public async Task PluginsAsync(ObsidianContext Context)
{
var srv = (Server)Context.Server;
var player = (Player)Context.Player;
var pluginCount = srv.PluginManager.Plugins.Count;
var message = new ChatMessage
{
Text = $"{ChatColor.Reset}List of plugins ({ChatColor.Gold}{pluginCount}{ChatColor.Reset}): ",
};
var messages = new List <ChatMessage>();
for (int i = 0; i < pluginCount; i++)
{
var pluginContainer = srv.PluginManager.Plugins[i];
var info = pluginContainer.Info;
var plugin = new ChatMessage();
var colorByState = pluginContainer.Loaded || pluginContainer.IsReady ? ChatColor.DarkGreen : ChatColor.DarkRed;
plugin.Text = colorByState + pluginContainer.Info.Name;
plugin.HoverEvent = new TextComponent {
Action = ETextAction.ShowText, Value = $"{colorByState}{info.Name}{ChatColor.Reset}\nVersion: {colorByState}{info.Version}{ChatColor.Reset}\nAuthor(s): {colorByState}{info.Authors}{ChatColor.Reset}"
};
if (pluginContainer.Info.ProjectUrl != null)
{
plugin.ClickEvent = new TextComponent {
Action = ETextAction.OpenUrl, Value = pluginContainer.Info.ProjectUrl.AbsoluteUri
}
}
;
messages.Add(plugin);
messages.Add(new ChatMessage
{
Text = $"{ChatColor.Reset}{(i + 1 < srv.PluginManager.Plugins.Count ? ", " : "")}"
});
}
if (messages.Count > 0)
{
message.AddExtra(messages);
}
await player.SendMessageAsync(message);
}
public async Task GamemodeAsync(ObsidianContext Context, [Remaining] string args_)
{
var chatMessage = ChatMessage.Simple("");
var args = args_.Contains(" ") ? args_.Split(" ").ToList() : new List <string> {
args_
};
if (args.Count == 1)
{
if (args[0].ToLower() == "creative" || args[0].ToLower() == "survival" || args[0].ToLower() == "spectator" || args[0].ToLower() == "adventure")
{
try
{
var gamemode = (Gamemode)Enum.Parse(typeof(Gamemode), args[0], true);
if (Context.Player.Gamemode != gamemode)
{
await Context.Player.SetGamemodeAsync(gamemode);
chatMessage = ChatMessage.Simple($"{ChatColor.Reset}Your game mode set to {ChatColor.Red}{gamemode}{ChatColor.Reset}.");
}
else
{
await Context.Player.SetGamemodeAsync(gamemode);
chatMessage = ChatMessage.Simple($"{ChatColor.Reset}Your current game mode is {ChatColor.Red}{gamemode}{ChatColor.Reset}.");
}
}
catch (Exception)
{
chatMessage = SendCommandUsage("/gamemode <survival/creative/adventure/spectator>");
}
}
}
else
{
chatMessage = SendCommandUsage("/gamemode <survival/creative/adventure/spectator>");
}
var player = (Player)Context.Player;
await player.SendMessageAsync(chatMessage);
}
public async Task TPSAsync(ObsidianContext ctx)
{
ChatColor color;
if (ctx.Server.TPS > 15)
{
color = ChatColor.BrightGreen;
}
else if (ctx.Server.TPS > 10)
{
color = ChatColor.Yellow;
}
else
{
color = ChatColor.Red;
}
var message = new ChatMessage
{
Text = $"{ChatColor.Gold}Current server TPS: {color}{ctx.Server.TPS}",
};
await ctx.Player.SendMessageAsync(message);
}
public Task AnnounceAsync(ObsidianContext Context, [Remaining] string text) => Context.Server.BroadcastAsync(text, 2);
public async Task ObsidianAsync(ObsidianContext Context)
{
await Context.Player.SendMessageAsync("§dWelcome to Obsidian Test Build. §l§4<3", 2);
}
public Task DeclareCommandsTestAsync(ObsidianContext Context) => ((Player)Context.Player).client.SendDeclareCommandsAsync();
public async Task HelpAsync(ObsidianContext Context, [Remaining] string cmd)
{
// TODO subcommand help
await Context.Player.SendMessageAsync("Overload test");
}
public async Task GamemodeAsync(ObsidianContext Context)
{
var chatMessage = SendCommandUsage("/gamemode <survival/creative/adventure/spectator>");
var player = (Player)Context.Player;
await player.SendMessageAsync(chatMessage);
}
public Task DeclareCommandsTestAsync(ObsidianContext Context) => Context.Client.SendDeclareCommandsAsync();
public async Task HelpAsync(ObsidianContext Context, int page)
{
var player = (Player)Context.Player;
var allcommands = Context.Commands.GetAllCommands();
var availablecommands = new List <Command>();
// filter available commands
foreach (var cmd in allcommands)
{
var success = true;
// check commands
// only list commands the user may execute.
foreach (var check in cmd.ExecutionChecks)
{
if (!await check.RunChecksAsync(Context))
{
success = false;
}
}
if (success)
{
availablecommands.Add(cmd);
}
}
int commandcount = availablecommands.Count();
var remainder = commandcount % CommandsPerPage;
int pagecount = (commandcount - remainder) / CommandsPerPage; // all commands / page commands - remainder
if (remainder > 0)
{
pagecount++; // if remainder, extra page
}
if (page < 1 || page > pagecount)
{
await player.SendMessageAsync(ChatMessage.Simple($"{ChatColor.Red}Invalid help page."));
return;
}
var cmdsection = availablecommands.Skip((page - 1) * CommandsPerPage).Take(CommandsPerPage);
var commands = ChatMessage.Simple("\n");
var header = new ChatMessage()
{
Underline = true,
Text = $"List of available commands ({page}/{pagecount}):"
};
commands.AddExtra(header);
foreach (var cmd in cmdsection.Where(x => x.Parent == null))
{
var commandName = new ChatMessage
{
Text = $"\n{ChatColor.Gold}{(cmd.Usage == "" ? $"/{cmd.Name}" : cmd.Usage)}",
ClickEvent = new TextComponent
{
Action = ETextAction.SuggestCommand,
Value = $"{(cmd.Usage == "" ? $"/{cmd.Name}" : cmd.Usage.Contains(" ") ? $"{cmd.Usage.Split(" ")[0]} " : cmd.Usage)}"
},
HoverEvent = new TextComponent
{
Action = ETextAction.ShowText,
Value = $"Click to suggest the command"
}
};
commands.AddExtra(commandName);
var commandInfo = new ChatMessage
{
Text = $"{ChatColor.Gray}:{ChatColor.Reset} {cmd.Description}"
};
commands.AddExtra(commandInfo);
}
await player.SendMessageAsync(commands);
}
public async Task SubCommandAsync(ObsidianContext ctx)
{
await ctx.Player.SendMessageAsync("group subcommand", 1);
}
public Task EchoAsync(ObsidianContext Context, [Remaining] string text) => Context.Server.BroadcastAsync(text);
public async Task TestAsync(ObsidianContext Context, string test1, string test2, string test3)
{
await Context.Player.SendMessageAsync($"{test1} + {test2} + {test3}");
}
public async Task ForceSkinAsync(ObsidianContext Context)
{
await Context.Client.SendPlayerInfoAsync();
await Context.Player.SendMessageAsync(ChatMessage.Simple("done"));
}
public async Task ExecuteAsync(ObsidianContext ctx)
{
await ctx.Player.SendMessageAsync("group command", 1);
}
public Task LeaveAsync(ObsidianContext Context) => Context.Player.KickAsync("Is this what you wanted?");
public async Task SubCommandAsync(ObsidianContext ctx, int test)
{
await ctx.Player.SendMessageAsync($"group subcommand overload {test}", 1);
}
public Task UptimeAsync(ObsidianContext Context)
=> Context.Player.SendMessageAsync($"Uptime: {DateTimeOffset.Now.Subtract(Context.Server.StartTime)}");
