/// <summary> /// Only checks if any of the Picked requirements are matched (used for checking id card(s)). Much simpler and a bit different than HasRequiredItems. /// </summary> public virtual bool HasAccess(Character character) { if (character.IsBot && item.IgnoreByAI(character)) { return(false); } if (!item.IsInteractable(character)) { return(false); } if (requiredItems.None()) { return(true); } if (character.Inventory != null) { foreach (Item item in character.Inventory.AllItems) { if (requiredItems.Any(ri => ri.Value.Any(r => r.Type == RelatedItem.RelationType.Picked && r.MatchesItem(item)))) { return(true); } } } return(false); }
public static Path FindLargestCommon(this IEnumerable <Path> paths) { Dictionary <Path, Path[]> ancestors = paths.ToDictionary(p => p, p => new[] { p }.Concat(p.GetAncestors()).ToArray()); if (ancestors.None()) { return(null); } if (ancestors.Count == 1) { return(ancestors.Single().Key); } int maxIndex = ancestors.Min(kvp => kvp.Value.Length); Path largestCommonAncestor = null; for (int i = 1; i <= maxIndex; i++) { Path[] testAncestors = ancestors.Select(kvp => kvp.Value[kvp.Value.Length - i]).ToArray(); Path[] distinctAncestors = testAncestors.Distinct().Take(2).ToArray(); if (distinctAncestors.Length == 1) { largestCommonAncestor = distinctAncestors.Single(); } else { return(largestCommonAncestor); } } return(largestCommonAncestor); }
private void RemoveCore(PointerCaptureTarget target, PointerCaptureKind kinds) { global::System.Diagnostics.Debug.Assert( kinds != PointerCaptureKind.None, "The capture kind must be set to release pointer captures."); if (this.Log().IsEnabled(LogLevel.Information)) { this.Log().Info($"{target.Element.GetDebugName()}: Releasing ({kinds}) capture of pointer {Pointer}"); } // If we remove an explicit capture, we update the _localExplicitCaptures of the target element if (kinds.HasFlag(PointerCaptureKind.Explicit) && target.Kind.HasFlag(PointerCaptureKind.Explicit)) { target.Element._localExplicitCaptures.Remove(Pointer); } target.Kind &= ~kinds; // The element is no longer listening for events, remove it. if (target.Kind == PointerCaptureKind.None) { _targets.Remove(target.Element); } IsImplicitOnly = _targets.None(t => t.Value.Kind.HasFlag(PointerCaptureKind.Explicit)); // Validate / update the state of this capture EnsureEffectiveCaptureState(); }
public ExpressionInfo FindIn(Expression expression) { Visit(expression); if (_nestedAccessesByPath.None() && _multiInvocations.NoneOrNull()) { return(EmptyExpressionInfo); } var nestedAccessChecks = GetNestedAccessChecks(); var multiInvocations = _multiInvocations?.Any() == true ? _multiInvocations.OrderBy(inv => inv.ToString()).ToArray() : Enumerable <Expression> .EmptyArray; return(new ExpressionInfo(nestedAccessChecks, multiInvocations)); }
/// <summary> /// Only checks if any of the Picked requirements are matched (used for checking id card(s)). Much simpler and a bit different than HasRequiredItems. /// </summary> public bool HasAccess(Character character) { if (character.Inventory == null) { return(false); } if (requiredItems.None()) { return(true); } foreach (Item item in character.Inventory.Items) { if (requiredItems.Any(ri => ri.Value.Any(r => r.Type == RelatedItem.RelationType.Picked && r.MatchesItem(item)))) { return(true); } } return(false); }
public void Should_Be_False_Given_Existing_Keys() { var dictionary = new Dictionary <int, string>() { [0] = "0", [1] = "1" }; bool result = dictionary.None(0, 1); Assert.False(result); }
public void Should_Be_True_Given_A_Non_Existing_Key() { var dictionary = new Dictionary <int, string>() { [0] = "0", [1] = "1" }; bool result = dictionary.None(2); Assert.True(result); }
public static TExpression Replace <TExpression>( this TExpression expression, Dictionary <Expression, Expression> replacementsByTarget) where TExpression : Expression { if (replacementsByTarget.None()) { return(expression); } var replacer = new ExpressionReplacer(replacementsByTarget); var replaced = replacer.ReplaceIn(expression); return((TExpression)replaced); }
public IList <DerivedTypePair> GetDerivedTypePairsFor(IQualifiedMemberContext context) { LookForDerivedTypePairs(context); if (_typePairsByTargetType.None()) { return(Enumerable <DerivedTypePair> .EmptyArray); } if (_typePairsByTargetType.TryGetValue(context.TargetType, out var typePairs)) { return(typePairs.FilterToArray(context, (ctx, tp) => tp.AppliesTo(ctx))); } return(Enumerable <DerivedTypePair> .EmptyArray); }
protected override IReadOnlyDictionary<string, object> GetEntries() { Dictionary<string, object> driverNames = new Dictionary<string, object>(); foreach (var driverName in AsioOut.GetDriverNames()) { //the return dictionary holds the names of the entries as key with an optional "tag" //here the tag is null but you can provide any object that you want to associate with the entry driverNames[driverName] = null; } if (driverNames.None()) driverNames["No ASIO!? -> get yours from http://www.asio4all.org/"] = null; return driverNames; }
public IList <DerivedTypePair> GetDerivedTypePairsFor( IBasicMapperData mapperData, MapperContext mapperContext) { LookForDerivedTypePairs(mapperData, mapperContext); if (_typePairsByTargetType.None()) { return(Enumerable <DerivedTypePair> .EmptyArray); } if (_typePairsByTargetType.TryGetValue(mapperData.TargetType, out var typePairs)) { return(typePairs.Filter(tp => tp.AppliesTo(mapperData)).ToArray()); } return(Enumerable <DerivedTypePair> .EmptyArray); }
public override void Update(AIObjectiveManager objectiveManager, float deltaTime) { base.Update(objectiveManager, deltaTime); if (IgnoreListClearInterval > 0) { if (ignoreListTimer > IgnoreListClearInterval) { Reset(); } else { ignoreListTimer += deltaTime; } } if (targetUpdateTimer >= TargetUpdateInterval) { targetUpdateTimer = 0; UpdateTargets(); } else { targetUpdateTimer += deltaTime; } // Sync objectives, subobjectives and targets foreach (var objective in objectives) { var target = objective.Key; if (!objective.Value.CanBeCompleted) { ignoreList.Add(target); targetUpdateTimer = TargetUpdateInterval; } if (!targets.Contains(target)) { subObjectives.Remove(objective.Value); } } SyncRemovedObjectives(objectives, GetList()); if (objectives.None() && targets.Any()) { CreateObjectives(); } }
public static TExpression Replace <TExpression>( this TExpression expression, Dictionary <Expression, Expression> replacementsByTarget) where TExpression : Expression { if ((expression == null) || replacementsByTarget.None()) { return(expression); } var replacer = replacementsByTarget.HasOne() ? new ExpressionReplacer( replacementsByTarget.Keys.First(), replacementsByTarget.Values.First(), replacementsByTarget.Comparer) : new ExpressionReplacer(replacementsByTarget); return(replacer.Replace <TExpression>(expression)); }
// Returns null if the report is empty protected static string GenerateReport( Alert alert, string htmlTemplate, IEnumerable <DataModelIssue> issues, IEnumerable <string> inputFiles, ExpressionUntriaged untriagedExpression) { IEnumerable <DataModelIssue> matchingIssues = alert.Query.Evaluate(issues); var untriagedFlagsMap = new Dictionary <DataModelIssue, ExpressionUntriaged.Flags>(); foreach (DataModelIssue issue in matchingIssues) { ExpressionUntriaged.Flags flags = untriagedExpression.GetUntriagedFlags(issue); if (flags != 0) { untriagedFlagsMap[issue] = flags; } } if (untriagedFlagsMap.None()) { Console.WriteLine(" No untriaged issues, skipping."); Console.WriteLine(); return(null); } string text = htmlTemplate; text = text.Replace("%UNTRIAGED_ISSUES_START%", ""); text = text.Replace("%UNTRIAGED_ISSUES_END%", ""); text = text.Replace("%UNTRIAGED_ISSUES_LINKED_COUNTS%", AlertReport.GetLinkedCount("is:issue is:open", untriagedFlagsMap.Keys)); IEnumerable <IssueEntry> untriagedIssueEntries = untriagedFlagsMap.Keys.Select(issue => new IssueEntry(issue)); text = text.Replace("%UNTRIAGED_ISSUES_TABLE%", FormatIssueTable(untriagedFlagsMap)); text = text.Replace("%INPUT_FILES_LIST%", FormatInputFilesList(inputFiles)); return(text); }
public Expression[] FindIn(Expression expression, bool targetCanBeNull) { Expression[] memberAccesses; lock (_syncLock) { _includeTargetNullChecking = targetCanBeNull; Visit(expression); memberAccesses = _memberAccessesByPath.None() ? _noMemberAccesses : _memberAccessesByPath.Values.Reverse().ToArray(); _stringMemberAccessSubjects.Clear(); _nullCheckSubjects.Clear(); _memberAccessesByPath.Clear(); } return(memberAccesses); }
protected override void Act(float deltaTime) { SyncRemovedObjectives(extinguishObjectives, Hull.hullList); if (character.Submarine == null) { return; } foreach (Hull hull in Hull.hullList) { if (hull.FireSources.None()) { continue; } if (hull.Submarine == null) { continue; } if (hull.Submarine.TeamID != character.TeamID) { continue; } // If the character is inside, only take connected hulls into account. if (character.Submarine != null && !character.Submarine.IsEntityFoundOnThisSub(hull, true)) { continue; } if (!extinguishObjectives.TryGetValue(hull, out AIObjectiveExtinguishFire objective)) { objective = new AIObjectiveExtinguishFire(character, hull); extinguishObjectives.Add(hull, objective); AddSubObjective(objective); } } if (extinguishObjectives.None()) { character?.Speak(TextManager.Get("DialogNoFire"), null, 3.0f, "nofire", 30.0f); } }
private static void AddUnmappedTargetMembersInfo( Dictionary <QualifiedMember, IDataSourceSet> unmappedMembers, StringBuilder failureMessage, IMemberMapperData rootData) { if (unmappedMembers.None()) { return; } failureMessage .AppendLine(" Unmapped target members - fix by ignoring or configuring a custom source member or data source:") .AppendLine(); foreach (var unmappedMember in unmappedMembers) { var targetMemberPath = unmappedMember.Key.GetFriendlyTargetPath(rootData); failureMessage.Append(" - ").AppendLine(targetMemberPath); } failureMessage.AppendLine(); }
/// <summary> /// Lists the modules. /// </summary> /// <param name="user">The user.</param> /// <param name="channel">The channel.</param> /// <param name="messageType">Type of the message.</param> /// <param name="messageFormat">The message format.</param> /// <param name="message">The message.</param> /// <param name="arguments">The arguments.</param> private void ListModules(User user, string channel, MessageType messageType, MessageFormat messageFormat, string message, Dictionary<string, string> arguments) { var targets = new[] { user.Nick }; if (arguments.None()) { this.SendCommandUsageExamples(this, targets, messageType, messageFormat); } foreach (var key in arguments.Keys) { AccessLevel level; if (Enum.TryParse(key, ignoreCase: true, result: out level)) { foreach (var module in this.IrcClient.Modules.Where(m => m.Commands.Any(c => c.LevelRequired <= level && c.LevelRequired <= user.AccessLevel))) { var moduleInfoResponse = new Response("{0}: {1}".FormatWith(module.Name, module.Description), targets, MessageFormat.Notice, messageType); this.SendResponse(moduleInfoResponse); } } } if (arguments.ContainsKey("list")) { #region Send all Module descriptions foreach (var module in this.IrcClient.Modules.Where(m => m.Commands.Any(c => c.LevelRequired <= user.AccessLevel))) { var moduleInfoResponse = new Response("{0}: {1}".FormatWith(module.Name, module.Description), targets, MessageFormat.Notice, messageType); this.SendResponse(moduleInfoResponse); } #endregion this.GetMoreInformation(messageType, targets); } if (arguments.ContainsKey("examples")) { // For each module where the module has a command that is accessible by this user foreach (var module in this.IrcClient.Modules.Where(m => m.Commands.Any(c => c.LevelRequired <= user.AccessLevel))) { #region Module Description var response = new Response("{0}: {1}".FormatWith(module.Name, module.Description), targets, MessageFormat.Notice, messageType); this.SendResponse(response); #endregion #region Usage Examples response.Message = "Usage Examples: "; this.SendResponse(response); this.SendCommandUsageExamples(module, targets, messageType, MessageFormat.Notice); #endregion } } }
private static void Place(IEnumerable <Submarine> subs) { if (GameMain.NetworkMember != null && GameMain.NetworkMember.IsClient) { DebugConsole.ThrowError("Clients are not allowed to use AutoItemPlacer.\n" + Environment.StackTrace.CleanupStackTrace()); return; } int itemCountApprox = MapEntityPrefab.List.Count() / 3; var containers = new List <ItemContainer>(70 + 30 * subs.Count()); var prefabsWithContainer = new List <ItemPrefab>(itemCountApprox / 3); var prefabsWithoutContainer = new List <ItemPrefab>(itemCountApprox); var removals = new List <ItemPrefab>(); foreach (Item item in Item.ItemList) { if (!subs.Contains(item.Submarine)) { continue; } if (item.GetRootInventoryOwner() is Character) { continue; } containers.AddRange(item.GetComponents <ItemContainer>()); } containers.Shuffle(Rand.RandSync.Server); foreach (MapEntityPrefab prefab in MapEntityPrefab.List) { if (!(prefab is ItemPrefab ip)) { continue; } if (ip.ConfigElement.Elements().Any(e => string.Equals(e.Name.ToString(), typeof(ItemContainer).Name.ToString(), StringComparison.OrdinalIgnoreCase))) { prefabsWithContainer.Add(ip); } else { prefabsWithoutContainer.Add(ip); } } spawnedItems.Clear(); var validContainers = new Dictionary <ItemContainer, PreferredContainer>(); prefabsWithContainer.Shuffle(Rand.RandSync.Server); // Spawn items that have an ItemContainer component first so we can fill them up with items if needed (oxygen tanks inside the spawned diving masks, etc) for (int i = 0; i < prefabsWithContainer.Count; i++) { var itemPrefab = prefabsWithContainer[i]; if (itemPrefab == null) { continue; } if (SpawnItems(itemPrefab)) { removals.Add(itemPrefab); } } // Remove containers that we successfully spawned items into so that they are not counted in in the second pass. removals.ForEach(i => prefabsWithContainer.Remove(i)); // Another pass for items with containers because also they can spawn inside other items (like smg magazine) prefabsWithContainer.ForEach(i => SpawnItems(i)); // Spawn items that don't have containers last prefabsWithoutContainer.Shuffle(Rand.RandSync.Server); prefabsWithoutContainer.ForEach(i => SpawnItems(i)); if (OutputDebugInfo) { var subNames = subs.Select(s => s.Info.Name).ToList(); DebugConsole.NewMessage($"Automatically placed items in { string.Join(", ", subNames) }:"); foreach (string itemName in spawnedItems.Select(it => it.Name).Distinct()) { DebugConsole.NewMessage(" - " + itemName + " x" + spawnedItems.Count(it => it.Name == itemName)); } } if (GameMain.GameSession?.Level != null && GameMain.GameSession.Level.Type == LevelData.LevelType.Outpost && GameMain.GameSession.StartLocation?.TakenItems != null) { foreach (Location.TakenItem takenItem in GameMain.GameSession.StartLocation.TakenItems) { var matchingItem = spawnedItems.Find(it => takenItem.Matches(it)); if (matchingItem == null) { continue; } var containedItems = spawnedItems.FindAll(it => it.ParentInventory?.Owner == matchingItem); matchingItem.Remove(); spawnedItems.Remove(matchingItem); foreach (Item containedItem in containedItems) { containedItem.Remove(); spawnedItems.Remove(containedItem); } } } #if SERVER foreach (Item spawnedItem in spawnedItems) { Entity.Spawner.CreateNetworkEvent(spawnedItem, remove: false); } #endif bool SpawnItems(ItemPrefab itemPrefab) { if (itemPrefab == null) { string errorMsg = "Error in AutoItemPlacer.SpawnItems - itemPrefab was null.\n" + Environment.StackTrace.CleanupStackTrace(); DebugConsole.ThrowError(errorMsg); GameAnalyticsManager.AddErrorEventOnce("AutoItemPlacer.SpawnItems:ItemNull", GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg); return(false); } bool success = false; foreach (PreferredContainer preferredContainer in itemPrefab.PreferredContainers) { if (preferredContainer.SpawnProbability <= 0.0f || preferredContainer.MaxAmount <= 0) { continue; } validContainers = GetValidContainers(preferredContainer, containers, validContainers, primary: true); if (validContainers.None()) { validContainers = GetValidContainers(preferredContainer, containers, validContainers, primary: false); } foreach (var validContainer in validContainers) { if (SpawnItem(itemPrefab, containers, validContainer)) { success = true; } } } return(success); } }
// Returns null if the report is empty protected static string GenerateReport( Alert alert, string htmlTemplate, IEnumerable <DataModelIssue> issues, IEnumerable <DataModelIssue> comments) { // Create a Dictionary mapping issues to comments for that issue Dictionary <int, List <DataModelIssue> > issueComments = new Dictionary <int, List <DataModelIssue> >(); Dictionary <int, DataModelIssue> issuesMap = new Dictionary <int, DataModelIssue>(); IEnumerable <DataModelIssue> matchingIssues = alert.Query.Evaluate(issues); if (matchingIssues.None()) { Console.WriteLine(" No changes to the query, skipping."); Console.WriteLine(); return(null); } foreach (DataModelIssue issue in matchingIssues) { issueComments.Add(issue.Number, new List <DataModelIssue>()); issuesMap.Add(issue.Number, issue); } foreach (DataModelIssue comment in comments) { int startIndex = comment.HtmlUrl.IndexOf("/issues/") + 8; if (startIndex < 8) { startIndex = comment.HtmlUrl.IndexOf("/pull/") + 6; } int endIndex = comment.HtmlUrl.IndexOf("#"); string issueString = comment.HtmlUrl.Substring(startIndex, endIndex - startIndex); int issueID = int.Parse(issueString); if (issueComments.ContainsKey(issueID)) { issueComments[issueID].Add(comment); } } // Filter our issues to ones that haven't had an owner response after our grace waiting period Dictionary <DataModelIssue, TimeSpan?> needsResponse = new Dictionary <DataModelIssue, TimeSpan?>(); foreach (KeyValuePair <int, List <DataModelIssue> > pair in issueComments) { TimeSpan?lastComment; // First check if there are no comments and the issue was opened past the threshold. if (pair.Value.Count == 0 && ((lastComment = (DateTime.Now - issuesMap[pair.Key].CreatedAt)) > _acceptableResponseDelay)) { needsResponse.Add(issuesMap[pair.Key], lastComment); } // Next check if the last issue occurred past the threshold else if (pair.Value.Count > 0 && ((lastComment = (DateTime.Now - pair.Value.Max((issue) => issue.CreatedAt))) > _acceptableResponseDelay)) { needsResponse.Add(issuesMap[pair.Key], lastComment); } } if (needsResponse.None()) { Console.WriteLine(" No changes to the query, skipping."); Console.WriteLine(); return(null); } string text = htmlTemplate; text = text.Replace("%NEEDSMSRESPONSE_ACCEPTABLE_RESPONSE_DELAY%", _acceptableResponseDelay.Days.ToString()); text = text.Replace("%NEEDSMSRESPONSE_ISSUES_START%", ""); text = text.Replace("%NEEDSMSRESPONSE_ISSUES_END%", ""); text = text.Replace("%NEEDSMSRESPONSE_ISSUES_LINKED_COUNTS%", AlertReport.GetLinkedCount("is:issue is:open", needsResponse.Keys)); text = text.Replace("%NEEDSMSRESPONSE_ISSUES_COUNT%", needsResponse.Count().ToString()); text = text.Replace("%NEEDSMSRESPONSE_ISSUES_TABLE%", FormatIssueTable(needsResponse.OrderByDescending((pair) => pair.Value.Value.Days))); return(text); }
private static string BuildParameterList(Dictionary<string, ObjectOutput> properties) { return properties.None() ? "no properties " : properties .Select(kv => "{0} [{1}]".FormatWith(kv.Key, GetTypeName(kv.Value.GetTypedValue()))) .Join(", "); }