public static bool Matches(this ILookupGroup lookupGroup, IEntity entity)
        {
            if (lookupGroup.ExcludedComponents.Length == 0)
            {
                return(ContainsAllRequiredComponents(lookupGroup, entity));
            }

            return(ContainsAllRequiredComponents(lookupGroup, entity) && !ContainsAnyExcludedComponents(lookupGroup, entity));
        }
        public static bool ContainsAny(this ILookupGroup group, params int[] components)
        {
            var requiredContains = group.ContainsAnyRequiredComponents(components);

            if (requiredContains)
            {
                return(true);
            }

            return(group.ContainsAnyExcludedComponents(components));
        }
        public static bool ContainsAllRequiredComponents(this ILookupGroup group, params int[] componentTypeIds)
        {
            for (var i = group.RequiredComponents.Length - 1; i >= 0; i--)
            {
                if (!componentTypeIds.Contains(group.RequiredComponents[i]))
                {
                    return(false);
                }
            }

            return(true);
        }
Esempio n. 4
0
        public IEnumerable <IEntity> GetEntitiesFor(ILookupGroup lookupGroup, string collectionName = null)
        {
            if (lookupGroup.RequiredComponents.Length == 0 && lookupGroup.ExcludedComponents.Length == 0)
            {
                return(new IEntity[0]);
            }

            if (collectionName != null)
            {
                return(_collections[collectionName].MatchingGroup(lookupGroup));
            }

            return(Collections.GetAllEntities().MatchingGroup(lookupGroup));
        }
Esempio n. 5
0
        public static bool ContainsAllRequiredComponents(this ILookupGroup group, params int[] componentTypeIds)
        {
            for (var index = group.RequiredComponents.Length - 1; index >= 0; index--)
            {
                if (componentTypeIds.Contains(@group.RequiredComponents[index]))
                {
                    continue;
                }

                return(false);
            }

            return(true);
        }
Esempio n. 6
0
        public static bool ContainsAnyRequiredComponents(this ILookupGroup group, params int[] componentTypes)
        {
            for (var index = @group.RequiredComponents.Length - 1; index >= 0; index--)
            {
                for (var j = componentTypes.Length - 1; j >= 0; j--)
                {
                    if (group.RequiredComponents[index] == componentTypes[j])
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
Esempio n. 7
0
 public static IEnumerable <IEntity> MatchingGroup(this IEnumerable <IEntity> entities, ILookupGroup group) =>
 entities.Where(group.Matches);
Esempio n. 8
0
 public static bool ContainsAnyExcludedComponents(this ILookupGroup group, IEntity entity) =>
 entity.HasAnyComponents(group.ExcludedComponents);
Esempio n. 9
0
 public static bool ContainsAnyExcludedComponents(this ILookupGroup group, params int[] componentTypes) =>
 group.ExcludedComponents.Any(componentTypes.Contains);
Esempio n. 10
0
 public static bool ContainsAllRequiredComponents(this ILookupGroup group, IEntity entity) =>
 entity.HasAllComponents(group.RequiredComponents);
 public static bool ContainsAnyRequiredComponents(this ILookupGroup group, IEntity entity)
 {
     return(entity.HasAnyComponents(group.RequiredComponents));
 }
Esempio n. 12
0
 public ObservableGroupToken(ILookupGroup lookupGroup, string collectionName)
 {
     LookupGroup    = lookupGroup;
     CollectionName = collectionName;
 }