/// <summary>
/// Retrieves a ready-to-use instance of this shader.
/// </summary>
/// <remarks>
/// This instance is shared. As such, it is immutable.
/// Use <see cref="InstanceUnique"/> to get a mutable and unique shader instance.
/// </remarks>
public ShaderInstance Instance()
{
if (_cachedInstance == null)
{
_cacheInstance();
}
DebugTools.AssertNotNull(_cachedInstance);
return(_cachedInstance);
}
private void ContinueStartupAndLoop(DisplayMode mode)
{
if (!StartupContinue(mode))
{
Logger.Fatal("Failed to start game controller!");
return;
}
DebugTools.AssertNotNull(_mainLoop);
_mainLoop !.Run();
}
private Stream?VerifierExtraLoadHandler(string arg)
{
DebugTools.AssertNotNull(_loaderArgs);
if (_loaderArgs !.FileApi.TryOpen(arg, out var stream))
{
return(stream);
}
return(null);
}
/// <summary>
/// Implement to remove the reference you used to store the entity
/// </summary>
/// <param name="toremove"></param>
/// <param name="entMan"></param>
protected virtual void InternalRemove(EntityUid toremove, IEntityManager entMan)
{
DebugTools.Assert(!Deleted);
DebugTools.AssertNotNull(Manager);
DebugTools.AssertNotNull(toremove);
DebugTools.Assert(entMan.EntityExists(toremove));
entMan.EventBus.RaiseLocalEvent(Owner, new EntRemovedFromContainerMessage(toremove, this));
entMan.EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(toremove));
Manager.Dirty(entMan);
}
public override async void Refresh()
{
_memberList.DisposeAllChildren();
if (Instance.Object != null)
{
var first = true;
foreach (var group in ViewVariablesInstance.LocalPropertyList(Instance.Object,
Instance.ViewVariablesManager, _robustSerializer))
{
CreateMemberGroupHeader(
ref first,
TypeAbbreviation.Abbreviate(group.Key),
_memberList);
foreach (var control in group)
{
_memberList.AddChild(control);
}
}
}
else
{
DebugTools.AssertNotNull(Instance.Session);
var blob = await Instance.ViewVariablesManager.RequestData <ViewVariablesBlobMembers>(
Instance.Session !, new ViewVariablesRequestMembers());
var otherStyle = false;
var first = true;
foreach (var(groupName, groupMembers) in blob.MemberGroups)
{
CreateMemberGroupHeader(ref first, groupName, _memberList);
foreach (var propertyData in groupMembers)
{
var propertyEdit = new ViewVariablesPropertyControl(_vvm, _robustSerializer);
propertyEdit.SetStyle(otherStyle = !otherStyle);
var editor = propertyEdit.SetProperty(propertyData);
var selectorChain = new object[] { new ViewVariablesMemberSelector(propertyData.PropertyIndex) };
editor.WireNetworkSelector(Instance.Session !.SessionId, selectorChain);
editor.OnValueChanged += o =>
{
Instance.ViewVariablesManager.ModifyRemote(Instance.Session !,
selectorChain, o);
};
_memberList.AddChild(propertyEdit);
}
}
}
}
public bool InstallDroppedBodyPart(DroppedBodyPartComponent part, string slotName)
{
DebugTools.AssertNotNull(part);
if (!InstallBodyPart(part.ContainedBodyPart, slotName))
{
return(false);
}
part.Owner.Delete();
return(true);
}
/// <summary>
/// Implement to remove the reference you used to store the entity
/// </summary>
/// <param name="toremove"></param>
protected virtual void InternalRemove(IEntity toremove)
{
DebugTools.Assert(!Deleted);
DebugTools.AssertNotNull(Manager);
DebugTools.AssertNotNull(toremove);
DebugTools.Assert(toremove.IsValid());
Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new EntRemovedFromContainerMessage(toremove, this));
Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(toremove));
Manager.Owner.SendMessage(Manager, new ContainerContentsModifiedMessage(this, toremove, true));
Manager.Dirty();
}
public bool TryAddPart(string slot, DroppedBodyPartComponent part, bool force = false)
{
DebugTools.AssertNotNull(part);
if (!TryAddPart(slot, part.ContainedBodyPart, force))
{
return(false);
}
part.Owner.Delete();
return(true);
}
public bool Remove(Control item)
{
if (item?.Parent != Owner)
{
return(false);
}
DebugTools.AssertNotNull(Owner);
Owner.RemoveChild(item);
return(true);
}
private async Task _cacheTo(int index, bool netRefresh = false)
{
DebugTools.Assert(_networked || !netRefresh);
if (index < _cache.Count)
{
// This check is probably redundant, oh well.
return;
}
if (_networked)
{
await _networkSemaphore !.WaitAsync();
try
{
// I believe it may theoretically be possible to hit this, so...
if (index < _cache.Count)
{
return;
}
// Would it maybe be a good idea to send this in chunks?
// Too lazy to code that right now.
// Oh well..
var blob = await Instance.ViewVariablesManager.RequestData <ViewVariablesBlobEnumerable>(Instance.Session !,
new ViewVariablesRequestEnumerable(_cache.Count, index, netRefresh));
_cache.AddRange(blob.Objects);
if (_cache.Count < index)
{
_ended = true;
}
}
finally
{
_networkSemaphore.Release();
}
}
else
{
DebugTools.AssertNotNull(_enumerator);
while (_cache.Count < index)
{
if (!_enumerator !.MoveNext())
{
_ended = true;
break;
}
_cache.Add(_enumerator !.Current);
}
}
}
private void PlayerStatusChanged(object?sender, SessionStatusEventArgs args)
{
var session = args.Session;
switch (args.NewStatus)
{
case SessionStatus.Connecting:
// Cancel shutdown update timer in progress.
_updateShutdownCts?.Cancel();
break;
case SessionStatus.Connected:
{
// Always make sure the client has player data. Mind gets assigned on spawn.
if (session.Data.ContentDataUncast == null)
{
session.Data.ContentDataUncast = new PlayerData(session.UserId);
}
// Make the player actually join the game.
// timer time must be > tick length
Timer.Spawn(0, args.Session.JoinGame);
_chatManager.SendAdminAnnouncement(Loc.GetString("player-join-message", ("name", args.Session.Name)));
if (LobbyEnabled && _roundStartCountdownHasNotStartedYetDueToNoPlayers)
{
_roundStartCountdownHasNotStartedYetDueToNoPlayers = false;
_roundStartTime = _gameTiming.CurTime + LobbyDuration;
}
break;
}
case SessionStatus.InGame:
{
_prefsManager.OnClientConnected(session);
var data = session.ContentData();
DebugTools.AssertNotNull(data);
if (data !.Mind == null)
{
if (LobbyEnabled)
{
PlayerJoinLobby(session);
return;
}
SpawnWaitPrefs();
}
public (byte[] mapHash, byte[] package) GeneratePackage()
{
DebugTools.Assert(Locked);
DebugTools.AssertNotNull(_mappedStrings);
var memoryStream = new MemoryStream();
WriteStringPackage(_mappedStrings !, memoryStream, out var hash);
var package = memoryStream.ToArray();
return(hash, package);
}
private bool RemoveBodyPart(BodyPart part, [NotNullWhen(true)] out string slotName)
{
DebugTools.AssertNotNull(part);
slotName = _parts.FirstOrDefault(pair => pair.Value == part).Key;
if (slotName == null)
{
return(false);
}
return(RemoveBodyPart(slotName, false));
}
/// <summary>
/// Tries to find the container manager that this entity is inside (if any).
/// </summary>
/// <param name="entity">Entity that might be inside a container.</param>
/// <param name="manager">The container manager that this entity is inside of.</param>
/// <returns>If a container manager was found.</returns>
public static bool TryGetContainerMan(this IEntity entity, [NotNullWhen(true)] out IContainerManager?manager)
{
DebugTools.AssertNotNull(entity);
DebugTools.Assert(!entity.Deleted);
if (entity.Transform.Parent != null && TryGetManagerComp(entity.Transform.Parent.Owner, out manager) && manager.ContainsEntity(entity))
{
return(true);
}
manager = default;
return(false);
}
public void RemovePart(IBodyPart part, bool drop)
{
DebugTools.AssertNotNull(part);
var slotName = _parts.FirstOrDefault(x => x.Value == part).Key;
if (string.IsNullOrEmpty(slotName))
{
return;
}
RemovePart(slotName, drop);
}
public static void RandomOffset(this EntityUid entity, float minX, float maxX, float minY, float maxY)
{
DebugTools.AssertNotNull(entity);
DebugTools.Assert(minX <= maxX, $"Minimum X value ({minX}) must be smaller than or equal to the maximum X value ({maxX})");
DebugTools.Assert(minY <= maxY, $"Minimum Y value ({minY}) must be smaller than or equal to the maximum Y value ({maxY})");
var random = IoCManager.Resolve <IRobustRandom>();
var randomX = random.NextFloat() * (maxX - minX) + minX;
var randomY = random.NextFloat() * (maxY - minY) + minY;
var offset = new Vector2(randomX, randomY);
IoCManager.Resolve <IEntityManager>().GetComponent <TransformComponent>(entity).LocalPosition += offset;
}
/// <summary>
/// Tries to find the container that this entity is inside (if any).
/// </summary>
/// <param name="entity">Entity that might be inside a container.</param>
/// <param name="container">The container that this entity is inside of.</param>
/// <returns>If a container was found.</returns>
public static bool TryGetContainer(this IEntity entity, [NotNullWhen(true)] out IContainer?container)
{
DebugTools.AssertNotNull(entity);
DebugTools.Assert(!entity.Deleted);
if (TryGetContainerMan(entity, out var manager))
{
return(manager.TryGetContainer(entity, out container));
}
container = default;
return(false);
}
private bool RemoveBodyPart(string slotName, bool drop)
{
DebugTools.AssertNotNull(slotName);
if (!_parts.Remove(slotName, out var part))
{
return(false);
}
IEntity?dropped = null;
if (drop)
{
part.SpawnDropped(out dropped);
}
part.Body = null;
var args = new BodyPartRemovedEventArgs(part, slotName);
foreach (var component in Owner.GetAllComponents <IBodyPartRemoved>())
{
component.BodyPartRemoved(args);
}
if (part.RSIMap != null)
{
var message = new BodyPartRemovedMessage(part.RSIMap, dropped?.Uid);
SendNetworkMessage(message);
}
foreach (var mechanism in part.Mechanisms)
{
if (!Template.MechanismLayers.TryGetValue(mechanism.Id, out var mechanismMap))
{
continue;
}
if (!_reflectionManager.TryParseEnumReference(mechanismMap, out var mechanismEnum))
{
Logger.Warning($"Template {Template.Name} has an invalid RSI map key {mechanismMap} for mechanism {mechanism.Id}.");
continue;
}
var mechanismMessage = new MechanismSpriteRemovedMessage(mechanismEnum);
SendNetworkMessage(mechanismMessage);
}
return(true);
}
public int Compare(MsgEntity?x, MsgEntity?y)
{
DebugTools.AssertNotNull(x);
DebugTools.AssertNotNull(y);
var cmp = y !.SourceTick.CompareTo(x !.SourceTick);
if (cmp != 0)
{
return(cmp);
}
return(y.Sequence.CompareTo(x.Sequence));
}
private bool EnsureNetwork(BodyNetwork network)
{
DebugTools.AssertNotNull(network);
if (_networks.ContainsKey(network.GetType()))
{
return(false);
}
_networks.Add(network.GetType(), network);
network.OnAdd(Owner);
return(true);
}
public IEnumerable <GasMixture> GetAllMixtures(EntityUid gridUid, bool excite = false)
{
var ev = new GetAllMixturesMethodEvent(gridUid, excite);
RaiseLocalEvent(gridUid, ref ev);
if (!ev.Handled)
{
return(Enumerable.Empty <GasMixture>());
}
DebugTools.AssertNotNull(ev.Mixtures);
return(ev.Mixtures !);
}
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent <SleepAiMessage>(HandleAiSleep);
var processors = _reflectionManager.GetAllChildren <AiLogicProcessor>();
foreach (var processor in processors)
{
var att = (AiLogicProcessorAttribute)Attribute.GetCustomAttribute(processor, typeof(AiLogicProcessorAttribute)) !;
// Tests should pick this up
DebugTools.AssertNotNull(att);
_processorTypes.Add(att.SerializeName, processor);
}
}
public void PowerOff(EmitterComponent component)
{
if (!component.IsPowered)
{
return;
}
component.IsPowered = false;
// Must be set while emitter powered.
DebugTools.AssertNotNull(component.TimerCancel);
component.TimerCancel?.Cancel();
UpdateAppearance(component);
}
private void PowerOff()
{
if (!_isPowered)
{
return;
}
_isPowered = false;
// Must be set while emitter powered.
DebugTools.AssertNotNull(_timerCancel);
_timerCancel !.Cancel();
UpdateAppearance();
}
private static SandboxConfig LoadConfig()
{
using var stream = typeof(AssemblyTypeChecker).Assembly
.GetManifestResourceStream("Robust.Shared.ContentPack.Sandbox.yml") !;
DebugTools.AssertNotNull(stream);
var cfg = new Deserializer().Deserialize <SandboxConfig>(new StreamReader(stream, Encoding.UTF8));
foreach (var typeCfg in cfg.Types.Values.SelectMany(p => p.Values))
{
ParseTypeConfig(typeCfg);
}
return(cfg);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
var player = shell.Player as IPlayerSession;
if (player == null)
{
shell.WriteLine("shell-server-cannot");
return;
}
if (args.Length != 1)
{
shell.WriteLine(Loc.GetString("shell-wrong-arguments-number"));
return;
}
var entityManager = IoCManager.Resolve <IEntityManager>();
if (!int.TryParse(args[0], out var targetId))
{
shell.WriteLine(Loc.GetString("shell-argument-must-be-number"));
return;
}
var eUid = new EntityUid(targetId);
if (!eUid.IsValid() || !entityManager.EntityExists(eUid))
{
shell.WriteLine(Loc.GetString("shell-invalid-entity-id"));
return;
}
var target = entityManager.GetEntity(eUid);
if (!target.TryGetComponent(out MindComponent? mindComponent))
{
shell.WriteLine(Loc.GetString("shell-entity-is-not-mob"));
return;
}
var mind = player.ContentData()?.Mind;
DebugTools.AssertNotNull(mind);
mindComponent.Mind?.TransferTo(null);
mind !.TransferTo(target);
}
public void Execute(IConsoleShell shell, string argStr, string[] args)
{
var player = shell.Player as IPlayerSession;
if (player == null)
{
shell.WriteLine("Server cannot do this.");
return;
}
if (args.Length != 1)
{
shell.WriteLine(Loc.GetString("Wrong number of arguments."));
return;
}
var entityManager = IoCManager.Resolve <IEntityManager>();
if (!int.TryParse(args[0], out var targetId))
{
shell.WriteLine(Loc.GetString("Argument must be a number."));
return;
}
var eUid = new EntityUid(targetId);
if (!eUid.IsValid() || !entityManager.EntityExists(eUid))
{
shell.WriteLine(Loc.GetString("Invalid entity ID."));
return;
}
var target = entityManager.GetEntity(eUid);
if (!target.TryGetComponent(out MindComponent? mindComponent))
{
shell.WriteLine(Loc.GetString("Target entity is not a mob!"));
return;
}
var mind = player.ContentData()?.Mind;
DebugTools.AssertNotNull(mind);
mindComponent.Mind?.TransferTo(null);
mind !.TransferTo(target);
}
public static void RaisePredictiveEvent <T>(this IEntityManager entityManager, T msg)
where T : EntityEventArgs
{
var localPlayer = IoCManager.Resolve <IPlayerManager>().LocalPlayer;
DebugTools.AssertNotNull(localPlayer);
var sequence = IoCManager.Resolve <IClientGameStateManager>().SystemMessageDispatched(msg);
entityManager.EntityNetManager?.SendSystemNetworkMessage(msg, sequence);
var eventArgs = new EntitySessionEventArgs(localPlayer !.Session);
entityManager.EventBus.RaiseEvent(EventSource.Local, msg);
entityManager.EventBus.RaiseEvent(EventSource.Local, new EntitySessionMessage <T>(eventArgs, msg));
}
public static async Task<IAudioClient?> EnsureConnectAsync(this IVoiceChannel channel)
{
DebugTools.AssertNotNull(channel);
var user = await channel.Guild.GetCurrentUserAsync();
if (user.Guild.AudioClient == null ||
user.VoiceChannel != channel)
{
Logger.DebugS($"Connecting to channel {channel.Name}");
return await channel.ConnectAsync();
}
Logger.DebugS($"Using existing connection for channel {channel.Name}");
return user.Guild.AudioClient;
}
private void LoadRobustWebView(GameController.DisplayMode mode)
{
Logger.Debug("Loading Robust.Client.WebView");
var assembly = LoadRobustModuleAssembly("Robust.Client.WebView");
var attribute = assembly.GetCustomAttribute <WebViewManagerImplAttribute>() !;
DebugTools.AssertNotNull(attribute);
var managerType = attribute.ImplementationType;
_webViewHook = (IWebViewManagerHook)Activator.CreateInstance(managerType) !;
_webViewHook.Initialize(mode);
Logger.Debug("Done initializing Robust.Client.WebView");
}
