/// <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"); }