public bool Remove(QueryMatchID id)
        {
            int index;

            if (!MatchIdToIndex.TryGetValue(id, out index))
            {
                return(false);
            }

            MatchIdToIndex.Remove(id);

            QueryMatchIds[index] = QueryMatchID.NullQuery;
            // the query result can still be in use (by the onLoss event), so we don't pool/recycle it
            QueryResults[index] = null;

            Pools.DataIdHashSets.Recycle(UsedByMatch[index]);
            UsedByMatch[index] = null;

            Pools.RelationTraitCaches.Recycle(CachedTraits[index]);
            CachedTraits[index] = null;
            Pools.RelationRatings.Recycle(RelationRatings[index]);
            RelationRatings[index] = null;

            RelationIndexPairs[index]      = null;
            LocalRelationIndexPairs[index] = null;
            RatingConfigurations[index]    = default(GroupRatingConfiguration);
            SetQueryArgs[index]            = null;

            SearchData[index]?.Dispose();
            SearchData[index]   = null;
            SetMatchData[index] = default;

            TimeOuts[index]            = 0f;
            OrderWeights[index]        = 0f;
            Relations[index]           = null;
            ReAcquireOnLoss[index]     = false;
            Priorities[index]          = default;
            UpdateMatchInterval[index] = 0f;
            LastUpdateCheckTime[index] = 0f;

            AcquireHandlers[index] = null;
            UpdateHandlers[index]  = null;
            LossHandlers[index]    = null;
            TimeoutHandlers[index] = null;

            FreeIndex(index);
            if (UpdatingIndices.Contains(index))
            {
                UpdatingIndices.Remove(index);
            }

            if (AcquiringIndices.Contains(index))
            {
                AcquiringIndices.Remove(index);
            }

            m_Count--;
            return(true);
        }
Exemple #2
0
        public bool Remove(QueryMatchID id)
        {
            int index;

            if (!MatchIdToIndex.TryGetValue(id, out index))
            {
                return(false);
            }

            MatchIdToIndex.Remove(id);

            QueryMatchIds[index] = QueryMatchID.NullQuery;
            QueryArgs[index]     = null;
            // the query result can still be in use (by the onLoss event), so we don't pool/recycle it
            QueryResults[index] = null;

            Pools.TraitCaches.Recycle(CachedTraits[index]);
            CachedTraits[index] = null;
            Pools.ConditionRatings.Recycle(ConditionRatings[index]);
            ConditionRatings[index] = null;

            // these collection members are re-usable, but we null them out so it's clear what data is invalid
            Pools.DataIdHashSets.Recycle(ConditionMatchSets[index]);
            ConditionMatchSets[index] = null;
            Pools.Ratings.Recycle(ReducedConditionRatings[index]);
            ReducedConditionRatings[index] = null;

            Exclusivities[index]    = default(Exclusivity);
            BestMatchDataIds[index] = (int)ReservedDataIDs.Invalid;

            TimeOuts[index]            = 0f;
            Conditions[index]          = null;
            TraitRequirements[index]   = null;
            ReAcquireOnLoss[index]     = false;
            Priority[index]            = MarsEntityPriority.Normal;
            UpdateMatchInterval[index] = 0f;

            AcquireHandlers[index] = null;
            UpdateHandlers[index]  = null;
            LossHandlers[index]    = null;
            TimeoutHandlers[index] = null;

            FreeIndex(index);
            UpdatingIndices.Remove(index);
            AcquiringIndices.Remove(index);
            m_Count--;
            return(true);
        }
        public bool Remove(QueryMatchID id, int memberIndex)
        {
            if (!MatchIdToIndex.TryGetValue(id, out var indices))
            {
                return(false);
            }

            Assert.IsTrue(indices.Contains(memberIndex) && QueryMatchIds[memberIndex].Equals(id),
                          $"Unknown index: {memberIndex} or Id mismatch!: {id}");

            QueryMatchIds[memberIndex] = QueryMatchID.NullQuery;

            // the query result can still be in use (by the onLoss event), so we don't pool/recycle it
            QueryResults[memberIndex]     = null;
            ObjectReferences[memberIndex] = null;

            Pools.TraitCaches.Recycle(CachedTraits[memberIndex]);
            CachedTraits[memberIndex] = null;
            Pools.ConditionRatings.Recycle(ConditionRatings[memberIndex]);
            ConditionRatings[memberIndex] = null;

            // these collection members are re-usable, but we null them out so it's clear what data is invalid
            Pools.DataIdHashSets.Recycle(ConditionMatchSets[memberIndex]);
            ConditionMatchSets[memberIndex] = null;
            Pools.Ratings.Recycle(ReducedConditionRatings[memberIndex]);
            ReducedConditionRatings[memberIndex] = null;
            TraitRequirements[memberIndex]       = null;

            Exclusivities[memberIndex]    = default;
            BestMatchDataIds[memberIndex] = (int)ReservedDataIDs.Invalid;
            Conditions[memberIndex]       = null;
            Required[memberIndex]         = false;

            FreeIndex(memberIndex);
            UpdatingIndices.Remove(memberIndex);
            AcquiringIndices.Remove(memberIndex);
            m_Count--;
            indices.Remove(memberIndex);

            return(true);
        }