public static bool CanUserAccess(this SharpStarClient client, string command, bool sendMsg = false)
{
if (client.IsAdmin())
{
return(true);
}
var cmds = SharpStarMain.Instance.PluginManager.CSPluginManager.Commands;
var cmd = cmds.SingleOrDefault(p => p.Item1 == command);
if (cmd == null || cmd.Item4)
{
return(false);
}
if (string.IsNullOrEmpty(cmd.Item3))
{
return(true);
}
bool hasPerm = client.Server.Player.HasPermission(cmd.Item3);
if (!hasPerm && sendMsg)
{
client.SendChatMessage("Server", "You do not have permission to use this command!");
}
return(hasPerm);
}
public void CallEvent(string evtName, IPacket packet, SharpStarClient client, params object[] args)
{
foreach (IPlugin plugin in _plugins)
{
plugin.CallEvent(evtName, packet, client, args);
}
}
public async Task CallEvent(IPacket packet, SharpStarClient client, bool isAfter = false)
{
foreach (ICSPlugin csPlugin in _csPlugins.Values.ToList())
{
await csPlugin.OnEventOccurred(packet, client, isAfter);
}
}
public async Task OnEventOccurred(IPacket packet, SharpStarClient client, bool isAfter = false)
{
KnownPacket kp = (KnownPacket)packet.PacketId;
if (!isAfter && !_registeredEvents.Contains(kp))
{
return;
}
if (isAfter && !_registeredAfterEvents.Contains(kp))
{
return;
}
try
{
foreach (List <CallablePacketEvent> evts in RegisteredPacketEventObjects.Values)
{
foreach (CallablePacketEvent evt in evts)
{
if (evt.PacketType == kp && evt.IsAfter == isAfter)
{
if (evt.IsAsync)
{
var toCall = evt.ToCall as Func <IPacket, SharpStarClient, Task>;
if (toCall != null)
{
await toCall(packet, client);
}
}
else
{
var toCall = evt.ToCall as Action <IPacket, SharpStarClient>;
if (toCall != null)
{
toCall(packet, client);
}
}
}
}
}
}
catch (Exception ex)
{
SharpStarLogger.DefaultLogger.Error("Plugin {0} has casued an error with packet event {1}!", Name, ((KnownPacket)packet.PacketId).ToString());
if (ex.InnerException != null)
{
SharpStarLogger.DefaultLogger.Error(ex.InnerException.ToString());
}
ex.LogError();
}
}
public async void SendPacket(SharpStarClient client, IPacket packet)
{
if (!Enabled)
{
return;
}
client.PacketQueue.Enqueue(packet);
await client.FlushPackets();
}
public override async Task Handle(ChatSentPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("chatSent", packet, client);
string message = packet.Message;
if (message.StartsWith("/"))
{
string[] ex = message.Substring(1).Split(' ');
string cmd = ex[0];
string[] args = ex.Skip(1).ToArray();
if (cmd.Equals("createacct", StringComparison.OrdinalIgnoreCase) && SharpStarMain.Instance.Config.ConfigFile.EnableAccounts)
{
if (client.Server.Player.UserAccount != null)
{
client.SendChatMessage("Server", "You are already logged into an account!");
}
else if (args.Length == 2)
{
string username = args[0];
string password = args[1];
if (SharpStarMain.Instance.Database.AddUser(username, password))
{
client.SendChatMessage("Server", "Account created! Please reconnect with your login details.");
}
else
{
client.SendChatMessage("Server", "Account already exists!");
}
}
else
{
client.SendChatMessage("Server", "Syntax: /createacct <username> <password>");
}
packet.Ignore = true;
}
else
{
if (!SharpStarMain.Instance.Config.ConfigFile.AllowedStarboundCommands.Any(p => p.Equals(cmd, StringComparison.OrdinalIgnoreCase)))
{
if (!await SharpStarMain.Instance.PluginManager.PassChatCommand(client, cmd, args).ConfigureAwait(false))
{
client.SendChatMessage("Server", "Unknown Command!");
}
packet.Ignore = true;
}
}
}
}
public override Task Handle(ConnectionResponsePacket packet, SharpStarClient client)
{
if (packet.IsReceive)
{
if (client.Server.Player == null)
{
packet.Success = false;
packet.RejectionReason = "An error has occurred!";
return(base.Handle(packet, client));
}
if (SharpStarMain.Instance.Server.Clients.Count > SharpStarMain.Instance.Config.ConfigFile.MaxPlayers)
{
packet.Success = false;
packet.RejectionReason = SharpStarMain.Instance.Config.ConfigFile.MaxPlayerRejectionReason;
client.Server.Player.JoinSuccessful = false;
}
if (client.Server.Player.UserAccount == null && SharpStarMain.Instance.Config.ConfigFile.RequireAccountLogin)
{
client.Server.Player.JoinSuccessful = false;
packet.Success = false;
packet.RejectionReason = SharpStarMain.Instance.Config.ConfigFile.RequireAccountLoginError;
}
else if (client.Server.Player.UserAccount != null)
{
SharpStarMain.Instance.Database.UpdateUserLastLogin(client.Server.Player.UserAccount.Username, DateTime.Now);
client.Server.Player.JoinSuccessful = true;
}
else if (client.Server.Player.Guest && !client.Server.Player.JoinSuccessful)
{
packet.Success = false;
packet.RejectionReason = SharpStarMain.Instance.Config.ConfigFile.GuestPasswordFailMessage;
}
else
{
client.Server.Player.JoinSuccessful = true;
}
if (packet.Success && client.Server.Player != null && !string.IsNullOrEmpty(client.Server.Player.Name) && client.Server.Player.JoinSuccessful)
{
SharpStarLogger.DefaultLogger.Info("Player {0} has successfully joined!", client.Server.Player.Name);
}
}
SharpStarMain.Instance.PluginManager.CallEvent("connectionResponse", packet, client);
return(base.Handle(packet, client));
}
public async void SendPacket(SharpStarClient client, IPacket packet)
{
if (!Enabled)
{
return;
}
if (client != null)
{
await client.SendPacket(packet);
}
}
public override Task Handle(EnvironmentUpdatePacket packet, SharpStarClient client)
{
var coords = WorldCoordinate.GetGlobalCoords(packet.Sky);
if (coords != null)
{
client.Server.Player.Coordinates = coords;
}
SharpStarMain.Instance.PluginManager.CallEvent("environmentUpdate", packet, client);
return(base.Handle(packet, client));
}
public async Task <bool> PassChatCommand(SharpStarClient client, string command, string[] args)
{
bool anyRegistered = await _csPluginManager.PassChatCommand(client, command, args).ConfigureAwait(false);
foreach (var plugin in _plugins)
{
if (plugin.PassChatCommand(command, client, args))
{
anyRegistered = true;
}
}
return(anyRegistered);
}
public async Task <bool> PassChatCommand(SharpStarClient client, string command, string[] args)
{
bool result = false;
foreach (ICSPlugin plugin in _csPlugins.Values)
{
if (await plugin.OnChatCommandReceived(client, command, args).ConfigureAwait(false))
{
result = true;
}
}
return(result);
}
public override async Task Handle(HandshakeChallengePacket packet, SharpStarClient client)
{
if (packet.IsReceive)
{
packet.Ignore = true;
if (client.Server.Player.UserAccount != null || !client.Server.Player.AttemptedLogin || client.Server.Player.Guest)
{
string hash = await Task.Run(() => SharpStarSecurity.GenerateHash("", "", packet.Salt, StarboundConstants.Rounds));
await client.Server.ServerClient.SendPacket(new HandshakeResponsePacket { PasswordHash = hash });
}
else if (client.Server.Player.AttemptedLogin)
{
await client.Server.ServerClient.SendPacket(new HandshakeResponsePacket { PasswordHash = packet.Salt });
}
}
//SharpStarMain.Instance.PluginManager.CallEvent("handshakeChallenge", packet, client);
}
public override Task Handle(EntityCreatePacket packet, SharpStarClient client)
{
/*
* foreach (var ent in packet.Entities)
* {
* if (ent.EntityType == EntityType.Player && ent is PlayerEntity)
* {
* PlayerEntity pent = (PlayerEntity)ent;
*
* if (pent.UUID == client.Server.Player.UUID)
* {
* client.Server.Player.EntityId = ent.EntityId;
* }
* }
* }
*/
SharpStarMain.Instance.PluginManager.CallEvent("entityCreate", packet, client);
return(base.Handle(packet, client));
}
public override Task Handle(HandshakeResponsePacket packet, SharpStarClient client)
{
if (packet.IsReceive)
{
packet.Ignore = true;
if (client.Server.Player.UserAccount != null && client.Server.Player.UserAccount.Hash != packet.PasswordHash)
{
client.Server.Player.UserAccount = null;
client.Server.Player.JoinSuccessful = false;
}
else if (client.Server.Player.Guest && SharpStarMain.Instance.Config.ConfigFile.GuestPasswordHash != packet.PasswordHash)
{
client.Server.Player.JoinSuccessful = false;
}
}
//SharpStarMain.Instance.PluginManager.CallEvent("handshakeResponse", packet, client);
return(base.Handle(packet, client));
}
public override Task Handle(WarpCommandPacket packet, SharpStarClient client)
{
if (packet.WarpType == WarpType.WarpHome)
{
client.Server.Player.PlayerShip = null;
client.Server.Player.OnOwnShip = true;
}
else if (packet.WarpType == WarpType.WarpOtherShip)
{
client.Server.Player.PlayerShip = packet.Player;
client.Server.Player.OnOwnShip = false;
}
else
{
client.Server.Player.OnOwnShip = false;
}
SharpStarMain.Instance.PluginManager.CallEvent("warpCommand", packet, client);
return(base.Handle(packet, client));
}
public override Task Handle(TileArrayUpdatePacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("tileArrayUpdate", packet, client);
return(base.Handle(packet, client));
}
public override Task Handle(StopCraftingInContainerPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("stopCraftingInContainerResult", packet, client);
return(base.Handle(packet, client));
}
public override Task HandleAfter(TileLiquidUpdatePacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterTileLiquidUpdateResult", packet, client);
return(base.HandleAfter(packet, client));
}
public virtual Task HandleAfter(T packet, SharpStarClient client)
{
return(Task.FromResult(false));
}
public override Task Handle(EntityInteractPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("entityInteractResult", packet, client);
return(base.Handle(packet, client));
}
public override Task HandleAfter(SpawnEntityPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterSpawnEntity", packet, client);
return(base.HandleAfter(packet, client));
}
public override Task HandleAfter(ItemApplyInContainerPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterItemApplyInContainerResult", packet, client);
return(base.HandleAfter(packet, client));
}
public override Task Handle(DamageRequestPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("damageRequestResult", packet, client);
return(base.Handle(packet, client));
}
/*
* public override async Task Handle(ClientConnectPacket packet, SharpStarClient client)
* {
*
* if (packet.IsReceive)
* {
* string uuid = BitConverter.ToString(packet.UUID, 0).Replace("-", String.Empty).ToLower();
*
* var clients = SharpStarMain.Instance.Server.Clients.Where(p => p.Player != null && p.Player.UUID == uuid);
* clients.ToList().ForEach(p =>
* {
* SharpStarLogger.DefaultLogger.Info("Duplicate UUID ({0}) detected. Killing old client!", uuid);
* p.PlayerClient.ForceDisconnect();
* p.ServerClient.ForceDisconnect();
* });
*
* client.Server.Player = new StarboundPlayer(packet.PlayerName.StripColors(), uuid)
* {
* NameWithColor = packet.PlayerName,
* Species = packet.Species,
* OnOwnShip = true
* };
*
* if (!string.IsNullOrEmpty(packet.Account.Trim()))
* {
* client.Server.Player.Guest = false;
* client.Server.Player.AttemptedLogin = true;
*
* SharpStarUser user = SharpStarMain.Instance.Database.GetUser(packet.Account.Trim());
*
* if (user == null)
* {
* await client.Server.PlayerClient.SendPacket(new HandshakeChallengePacket { Salt = "" });
*
* return;
* }
*
* packet.Account = "";
*
* client.Server.Player.UserAccount = user;
* client.Server.Player.JoinSuccessful = true;
*
* await client.Server.PlayerClient.SendPacket(new HandshakeChallengePacket { Salt = user.Salt });
* }
* else if (string.IsNullOrEmpty(packet.Account.Trim()) && !string.IsNullOrEmpty(SharpStarMain.Instance.Config.ConfigFile.GuestPassword))
* {
* client.Server.Player.AttemptedLogin = true;
* client.Server.Player.Guest = true;
*
* if (string.IsNullOrEmpty(SharpStarMain.Instance.Config.ConfigFile.GuestPasswordSalt) || string.IsNullOrEmpty(SharpStarMain.Instance.Config.ConfigFile.GuestPasswordHash))
* {
* string salt = SharpStarSecurity.GenerateSalt();
* string hash = SharpStarSecurity.GenerateHash("", SharpStarMain.Instance.Config.ConfigFile.GuestPassword, salt, StarboundConstants.Rounds);
*
* SharpStarMain.Instance.Config.ConfigFile.GuestPasswordSalt = salt;
* SharpStarMain.Instance.Config.ConfigFile.GuestPasswordHash = hash;
* SharpStarMain.Instance.Config.Save(SharpStarMain.ConfigFile);
* }
*
* client.Server.Player.JoinSuccessful = true;
*
* await client.Server.PlayerClient.SendPacket(new HandshakeChallengePacket { Salt = SharpStarMain.Instance.Config.ConfigFile.GuestPasswordSalt });
* }
* }
*
* SharpStarMain.Instance.PluginManager.CallEvent("clientConnected", packet, client);
* }
*/
public override Task Handle(ClientConnectPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("clientDisconnected", packet, client);
return(base.Handle(packet, client));
}
public static bool IsAdmin(this SharpStarClient client)
{
return(client.Server.Player.UserAccount != null && client.Server.Player.UserAccount.IsAdmin);
}
public override Task HandleAfter(WorldStopPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterWorldStop", packet, client);
return(base.HandleAfter(packet, client));
}
public override Task HandleAfter(ProtocolVersionPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterProtocolVersion", packet, client);
return(base.HandleAfter(packet, client));
}
public override Task HandleAfter(UpdateTileProtectionPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterUpdateTileProtectionResult", packet, client);
return(base.HandleAfter(packet, client));
}
public override Task HandleAfter(DamageNotificationPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("afterDamageNotification", packet, client);
return(base.HandleAfter(packet, client));
}
/*
* public override Task Handle(WorldStartPacket packet, SharpStarClient client)
* {
*
* Variant planet = packet.Planet;
* VariantDict planetDict = (VariantDict) planet.Value;
*
* if (planetDict.ContainsKey("celestialParameters"))
* {
* var celestParamsDict = (VariantDict) planetDict["celestialParameters"].Value;
*
* if (celestParamsDict != null)
* {
* var coordinateDict = (VariantDict) celestParamsDict["coordinate"].Value;
*
* if (coordinateDict != null)
* {
* var loc = (Variant[]) coordinateDict["location"].Value;
*
* var pCoords = new PlanetCoordinate
* {
* Sector = (string) coordinateDict["sector"].Value,
* X = (ulong) loc[0].Value,
* Y = (ulong) loc[1].Value,
* Z = (ulong) loc[2].Value,
* Planet = (ulong) coordinateDict["planet"].Value,
* Satellite = (ulong) coordinateDict["satellite"].Value
* };
*
* client.Server.Player.OnShip = false;
* }
* }
* else
* {
* client.Server.Player.OnShip = true;
* }
* }
*
* var coords = WorldCoordinate.GetGlobalCoords(packet.Sky);
*
* if (coords != null)
* {
* client.Server.Player.Coordinates = coords;
* }
*
* client.Server.Player.ClientId = packet.ClientId;
* client.Server.Player.SpawnX = packet.SpawnX;
* client.Server.Player.SpawnY = packet.SpawnY;
*
* SharpStarMain.Instance.PluginManager.CallEvent("worldStart", packet, client);
*
* return base.Handle(packet, client);
* }
*
* public override Task HandleAfter(WorldStartPacket packet, SharpStarClient client)
* {
* SharpStarMain.Instance.PluginManager.CallEvent("afterWorldStart", packet, client);
*
* return base.HandleAfter(packet, client);
* }
*/
public override Task Handle(WorldStartPacket packet, SharpStarClient client)
{
SharpStarMain.Instance.PluginManager.CallEvent("chatSendResult", packet, client);
return(base.Handle(packet, client));
}
