int Add(QueryMatchID matchId,
IMRObject objectRef,
Exclusivity exclusivity,
int bestMatchDataId,
bool isRequired,
CachedTraitCollection traitCache,
ProxyConditions condition,
ProxyTraitRequirements requirements,
ConditionRatingsData rating,
HashSet <int> matchSet,
Dictionary <int, float> flatRatings,
QueryResult result)
{
var index = GetInsertionIndex();
QueryMatchIds[index] = matchId;
ObjectReferences[index] = objectRef;
Exclusivities[index] = exclusivity;
Required[index] = isRequired;
BestMatchDataIds[index] = bestMatchDataId;
CachedTraits[index] = traitCache;
Conditions[index] = condition;
TraitRequirements[index] = requirements;
RelationMemberships[index] = null;
ConditionRatings[index] = rating;
ReducedConditionRatings[index] = flatRatings;
ConditionMatchSets[index] = matchSet;
QueryResults[index] = result;
m_Count++;
ValidIndices.Add(index);
return(index);
}
internal bool DataPassesAllConditions(ProxyConditions conditions, int dataId)
{
if (conditions.TryGetType(out ISemanticTagCondition[] semanticTagConditions))
{
GetTraitProvider(out MARSTraitDataProvider <bool> tagTraitProvider);
foreach (var condition in semanticTagConditions)
{
if (!tagTraitProvider.TryGetTraitValue(dataId, condition.traitName, out var traitValue))
{
if (condition.matchRule == SemanticTagMatchRule.Match)
{
return(false);
}
continue;
}
if (condition.PassesCondition(ref traitValue) && condition.matchRule == SemanticTagMatchRule.Match)
{
continue;
}
return(false);
}
}
return(DataPassesAllConditionsInternal(conditions, dataId));
}
public void ConditionRatingsData_ConstructsCorrectSizeArray_ForConditionCount()
{
AddOneOfEachConditionType(m_GameObject);
m_GameObject.AddTestFloatCondition();
m_GameObject.AddTestFloatCondition();
m_GameObject.AddComponent <TestConditions.Pose>();
var ratings = new ConditionRatingsData(ProxyConditions.FromGenericIMRObject(m_ConditionsRoot));
Assert.AreEqual(10, ratings.totalConditionCount);
Assert.AreEqual(3, ratings[typeof(float)].Count);
Assert.AreEqual(2, ratings[typeof(Pose)].Count);
Assert.AreEqual(1, ratings[typeof(bool)].Count);
Assert.AreEqual(1, ratings[typeof(Vector2)].Count);
Assert.AreEqual(1, ratings[typeof(Vector3)].Count);
Assert.AreEqual(1, ratings[typeof(int)].Count);
Assert.AreEqual(1, ratings[typeof(string)].Count);
ratings[typeof(int)].AssertCollectionsCreated();
ratings[typeof(float)].AssertCollectionsCreated();
ratings[typeof(bool)].AssertCollectionsCreated();
ratings[typeof(Vector2)].AssertCollectionsCreated();
ratings[typeof(Vector3)].AssertCollectionsCreated();
ratings[typeof(string)].AssertCollectionsCreated();
ratings[typeof(Pose)].AssertCollectionsCreated();
}
/// <summary>
/// See if the value for a given data ID still meets a set of Conditions
/// </summary>
/// <param name="dataID">The id of the data value to check</param>
/// <param name="conditions">The conditions to evaluate against</param>
/// <param name="result">The Query result to fill out with updated values</param>
/// <returns>True if the query data still matches, false otherwise</returns>
public bool TryUpdateQueryMatchData(int dataID, ProxyConditions conditions, ProxyTraitRequirements requirements, QueryResult result)
{
if (requirements != null)
{
if (!TryFillTraitRequirementsUpdate(dataID, requirements, result))
{
return(false);
}
}
GetTraitProvider(out MARSTraitDataProvider <Pose> poseTraitProvider);
GetTraitProvider(out MARSTraitDataProvider <bool> tagTraitProvider);
if (conditions.TryGetType(out ICondition <Pose>[] poseConditions))
{
foreach (var condition in poseConditions)
{
if (!poseTraitProvider.TryGetTraitValue(dataID, condition.traitName, out var traitValue))
{
return(false);
}
if (condition.PassesCondition(ref traitValue))
{
result.SetTrait(condition.traitName, this.ApplyOffsetToPose(traitValue));
}
else
{
return(false);
}
}
}
if (conditions.TryGetType(out ISemanticTagCondition[] semanticTagConditions))
{
foreach (var condition in semanticTagConditions)
{
if (!tagTraitProvider.TryGetTraitValue(dataID, condition.traitName, out var traitValue))
{
if (condition.matchRule == SemanticTagMatchRule.Match)
{
return(false);
}
continue; // an excluding match update made by lack of tag
}
if (condition.PassesCondition(ref traitValue) && condition.matchRule == SemanticTagMatchRule.Match)
{
result.SetTrait(condition.traitName, traitValue);
}
else
{
return(false);
}
}
}
// Update all condition types that we don't special-case in generated code
return(UpdateQueryMatchInternal(dataID, conditions, requirements, result));
}
internal static TryBestMatchArguments GetMatchArgs(this GameObject go,
Exclusivity exclusivity = Exclusivity.ReadOnly)
{
var conditionsRoot = go.GetComponent <TestMRObject>();
var conditions = ProxyConditions.FromGenericIMRObject(conditionsRoot);
return(new TryBestMatchArguments(conditions, exclusivity));
}
void SetupObject(GameObject go)
{
var rwo = go.AddComponent <Proxy>();
m_Conditions = ProxyConditions.FromGenericIMRObject(rwo);
m_ConditionRatings = new ConditionRatingsData(m_Conditions);
m_TraitCache = new CachedTraitCollection(m_Conditions);
m_Db.FindTraitCollections(m_Conditions, m_TraitCache);
}
internal static QueryArgs GetQueryArgs(this GameObject go, Exclusivity exclusivity = Exclusivity.ReadOnly)
{
return(new QueryArgs
{
conditions = ProxyConditions.FromGameObject <Proxy>(go),
exclusivity = exclusivity,
commonQueryData = new CommonQueryData()
});
}
static Relations MakeBaseSet(out SetQueryResult result, Dictionary <IMRObject, ChildMatchInfo> childrenExpectedMatchInfo)
{
var gameObject = new GameObject("Set");
gameObject.AddComponent <ProxyGroup>();
k_ToDestroy.Add(gameObject);
// Make child MR objects and give them ordinary relations
var children = new Dictionary <IMRObject, SetChildArgs>();
for (var i = 0; i < k_RelationCount + 1; ++i)
{
var childGameObject = new GameObject("Child" + i);
k_ToDestroy.Add(childGameObject);
childGameObject.transform.SetParent(gameObject.transform);
var conditionsRoot = childGameObject.AddComponent <TestMRObject>();
var expectedMatchInfo = new ChildMatchInfo();
childrenExpectedMatchInfo[conditionsRoot] = expectedMatchInfo;
var hasTraitCondition = childGameObject.AddComponent <SemanticTagCondition>();
hasTraitCondition.SetTraitName(k_CommonTrait);
expectedMatchInfo.semanticTagTraits.Add(k_CommonTrait, true);
var conditions = ProxyConditions.FromGenericIMRObject(conditionsRoot);
var childArgs = new SetChildArgs(conditions);
children[conditionsRoot] = childArgs;
}
// Make relations and store the expected trait values that will match them
var childrenList = new List <IMRObject>(children.Keys);
for (var i = 0; i < k_RelationCount; ++i)
{
var child1 = childrenList[i];
var child2 = childrenList[i + 1];
var floatRelation = gameObject.AddComponent <FloatRelation>();
floatRelation.Initialize(child1, child2, k_FloatTrait1, k_FloatTrait2);
childrenExpectedMatchInfo[child1].floatTraits[floatRelation.child1TraitName] = i;
childrenExpectedMatchInfo[child2].floatTraits[floatRelation.child2TraitName] = i + 1f;
var vector2Relation = gameObject.AddComponent <Vector2Relation>();
vector2Relation.Initialize(child1, child2, k_Vector2Trait1, k_Vector2Trait2);
childrenExpectedMatchInfo[child1].vector2Traits[vector2Relation.child1TraitName] = new Vector2(i, 0f);
childrenExpectedMatchInfo[child2].vector2Traits[vector2Relation.child2TraitName] = new Vector2(i + 1f, 0f);
}
result = new SetQueryResult(QueryMatchID.Generate(), childrenList);
var relations = new Relations(gameObject, children);
s_SetArgs = new SetQueryArgs {
relations = relations
};
return(relations);
}
internal bool FindTraitCollections(ProxyConditions conditions, CachedTraitCollection cache)
{
if (cache.fulfilled)
{
return(true);
}
cache.fulfilled = FindTraitsInternal(conditions, cache);
return(cache.fulfilled);
}
public ConditionRatingsData Initialize(ProxyConditions conditions)
{
m_SemanticTagListIndex = -1;
AllRatings.Clear();
MatchRuleIndexes.Clear();
TypeToIndex.Clear();
FromConditions(conditions);
m_ReductionPower = 1f / m_Count;
return(this);
}
ProxyConditions SetupExclusiveSemanticTagTest(int count)
{
var go = new GameObject("tag matching test");
var conditionsRoot = go.AddComponent <TestMRObject>();
AddSemanticTagCondition(go, TraitNames.Plane);
AddSemanticTagCondition(go, k_ExcludedTrait, SemanticTagMatchRule.Exclude);
AddSemanticTagToRange(0, TraitNames.Plane, true, count);
var conditions = ProxyConditions.FromGenericIMRObject(conditionsRoot);
Object.DestroyImmediate(go);
return(conditions);
}
internal static ConditionRatingsData Setup()
{
var go = new GameObject();
go.AddComponent <Proxy>();
go.AddTestFloatCondition();
go.AddComponent <TestConditions.Pose>();
var conditions = ProxyConditions.FromGameObject <Proxy>(go);
var ratings = new ConditionRatingsData(conditions);
ratings[typeof(float)][0] = floatRatings;
ratings[typeof(Pose)][0] = poseRatings;
return(ratings);
}
bool DataPassesAllConditionsInternal(ProxyConditions conditions, int dataId)
{
if (conditions.TryGetType(out ICondition <System.Int32>[] intConditions))
{
if (!ConditionsPass(IntTraitProvider, intConditions, dataId))
{
return(false);
}
}
if (conditions.TryGetType(out ICondition <System.Single>[] floatConditions))
{
if (!ConditionsPass(FloatTraitProvider, floatConditions, dataId))
{
return(false);
}
}
if (conditions.TryGetType(out ICondition <System.String>[] stringConditions))
{
if (!ConditionsPass(StringTraitProvider, stringConditions, dataId))
{
return(false);
}
}
if (conditions.TryGetType(out ICondition <UnityEngine.Pose>[] poseConditions))
{
if (!ConditionsPass(PoseTraitProvider, poseConditions, dataId))
{
return(false);
}
}
if (conditions.TryGetType(out ICondition <UnityEngine.Vector2>[] vector2Conditions))
{
if (!ConditionsPass(Vector2TraitProvider, vector2Conditions, dataId))
{
return(false);
}
}
return(true);
}
public void SetupBeforeEach()
{
SlowTaskModule.instance.ClearTasks();
m_GameObject = new GameObject("pipeline test condition source");
SetupObject(m_GameObject);
m_Child1GameObject = new GameObject("pipeline test member 1");
m_Child1GameObject.AddComponent <Proxy>();
m_Child2GameObject = new GameObject("pipeline test member 2");
m_Child2GameObject.AddComponent <Proxy>();
ProxyConditions.FromGameObject <Proxy>(m_Child1GameObject);
ProxyConditions.FromGameObject <Proxy>(m_Child2GameObject);
m_Ratings.Clear();
m_Db.Clear();
k_Intersection.Clear();
}
[TestCase(0.05f, 0.06f, 0.08f, 0.1f, 0.05f, 0.1f)] // 4 near-failures
public void GetRatingForId_ImplementsInversePowerReduction(
float one, float two, float three, float four, // condition ratings
float minBound, float maxBound) // expected boundaries
{
const int dataId = 3;
var rwo = m_GameObject.AddComponent <Proxy>();
m_GameObject.AddTestFloatCondition();
m_GameObject.AddTestFloatCondition();
m_GameObject.AddTestVector2Condition();
m_GameObject.AddSemanticTagCondition();
var conditions = ProxyConditions.FromGenericIMRObject(rwo);
var proposal = new ConditionRatingsData(conditions);
proposal[typeof(float)][0].Add(dataId, one);
proposal[typeof(float)][1].Add(dataId, two);
proposal[typeof(Vector2)][0].Add(dataId, three);
proposal[typeof(bool)][0].Add(dataId, four);
AssertBetween(proposal.RatingForId(dataId), minBound, maxBound);
}
public void ExcludedTagsNotUsedAsIntersectionStartingPoint()
{
var tagConditions = new ISemanticTagCondition[2];
tagConditions[0] = m_TestObject.AddSemanticTagCondition("exclude", SemanticTagMatchRule.Exclude);
tagConditions[1] = m_TestObject.AddSemanticTagCondition("match");
var conditions = new ProxyConditions(tagConditions);
var ratings = new ConditionRatingsData(conditions)
{
MatchRuleIndexes = { SemanticTagMatchRule.Exclude, SemanticTagMatchRule.Match }
};
// fake like we rated conditions
var excludeRuleSet = new [] { 0, 1 };
var excludeRuleRatings = ratings[typeof(bool)][0];
foreach (var t in excludeRuleSet)
{
excludeRuleRatings.Add(t, 1);
}
var matchRuleSet = new [] { 2, 3, 4 };
var matchRuleRatings = ratings[typeof(bool)][1];
foreach (var t in matchRuleSet)
{
matchRuleRatings.Add(t, 1);
}
var matchSet = new HashSet <int>();
FindMatchProposalsTransform.GetStartingIdSet(ratings, matchSet);
// because we can't use the excluding tag ratings as the starting set for intersection,
// it should skip them & use another set, even though they come first in the ratings in our setup
Assert.True(matchSet.SetEquals(matchRuleSet));
}
public void Setup()
{
m_ConditionsGameObject = new GameObject("test conditions object");
var conditionsRoot = m_ConditionsGameObject.AddComponent <TestMRObject>();
for (var i = 0; i < k_ConditionsPerType; ++i)
{
var tagCondition = m_ConditionsGameObject.AddComponent <TestSemanticTagCondition>();
tagCondition.Initialize(i);
var floatCondition = m_ConditionsGameObject.AddComponent <FloatCondition>();
floatCondition.Initialize(i);
var vector2Condition = m_ConditionsGameObject.AddComponent <Vector2Condition>();
vector2Condition.Initialize(i);
}
m_Conditions = ProxyConditions.FromGenericIMRObject(conditionsRoot);
m_QueryMatchId = QueryMatchID.Generate();
m_FloatProvider = new MARSDataProvider <float>();
m_FloatUser = new TestMarsDataUser <float>();
}
public void DisabledConditionComponentsAreIgnored()
{
var go = new GameObject("ignored conditions test");
var conditionsRoot = go.AddComponent <TestMRObject>();
var tagCondition = go.AddComponent <SemanticTagCondition>();
var ignoredFloatCondition = go.AddComponent <FloatCondition>();
ignoredFloatCondition.enabled = false;
var ignoredVector2Condition = go.AddComponent <Vector2Condition>();
ignoredVector2Condition.enabled = false;
var newConditions = ProxyConditions.FromGenericIMRObject(conditionsRoot);
Object.DestroyImmediate(go);
newConditions.TryGetType(out ICondition <float>[] floatConditions);
Assert.Zero(floatConditions.Length);
newConditions.TryGetType(out ICondition <Vector2>[] vector2Conditions);
Assert.Zero(vector2Conditions.Length);
newConditions.TryGetType(out ISemanticTagCondition[] semanticTagConditions);
Assert.AreEqual(1, semanticTagConditions.Length);
}
/// <summary>
/// Pre-allocate the storage for match ratings for a condition set.
/// </summary>
/// <param name="conditions">The set of conditions to store the results for</param>
public ConditionRatingsData(ProxyConditions conditions)
{
Initialize(conditions);
}
public CachedTraitCollection(ProxyConditions conditions)
{
// FromConditions' actual implementation is in generated code
FromConditions(conditions);
}
public void FromConditions(ProxyConditions conditions)
{
m_Count = 0;
s_TypeIndex = 0;
var semanticTagLength = conditions.GetTypeCount(out ISemanticTagCondition[] semanticTagConditions);
if (semanticTagLength > 0)
{
m_Count += semanticTagLength;
TypeToIndex[typeof(System.Boolean)] = s_TypeIndex;
var list = new List <Dictionary <int, float> >();
list.Fill(semanticTagLength);
AllRatings.Add(list);
m_SemanticTagListIndex = s_TypeIndex;
s_TypeIndex++;
}
var intLength = conditions.GetTypeCount(out ICondition <System.Int32>[] intConditions);
if (intLength > 0)
{
m_Count += intLength;
TypeToIndex[typeof(System.Int32)] = s_TypeIndex;
var list = new List <Dictionary <int, float> >();
list.Fill(intLength);
AllRatings.Add(list);
s_TypeIndex++;
}
var floatLength = conditions.GetTypeCount(out ICondition <System.Single>[] floatConditions);
if (floatLength > 0)
{
m_Count += floatLength;
TypeToIndex[typeof(System.Single)] = s_TypeIndex;
var list = new List <Dictionary <int, float> >();
list.Fill(floatLength);
AllRatings.Add(list);
s_TypeIndex++;
}
var stringLength = conditions.GetTypeCount(out ICondition <System.String>[] stringConditions);
if (stringLength > 0)
{
m_Count += stringLength;
TypeToIndex[typeof(System.String)] = s_TypeIndex;
var list = new List <Dictionary <int, float> >();
list.Fill(stringLength);
AllRatings.Add(list);
s_TypeIndex++;
}
var poseLength = conditions.GetTypeCount(out ICondition <UnityEngine.Pose>[] poseConditions);
if (poseLength > 0)
{
m_Count += poseLength;
TypeToIndex[typeof(UnityEngine.Pose)] = s_TypeIndex;
var list = new List <Dictionary <int, float> >();
list.Fill(poseLength);
AllRatings.Add(list);
s_TypeIndex++;
}
var vector2Length = conditions.GetTypeCount(out ICondition <UnityEngine.Vector2>[] vector2Conditions);
if (vector2Length > 0)
{
m_Count += vector2Length;
TypeToIndex[typeof(UnityEngine.Vector2)] = s_TypeIndex;
var list = new List <Dictionary <int, float> >();
list.Fill(vector2Length);
AllRatings.Add(list);
s_TypeIndex++;
}
}
void FromConditions(ProxyConditions conditions)
{
var semanticTagLength = conditions.GetTypeCount(out ISemanticTagCondition[] semanticTagConditions);
if (semanticTagLength > 0)
{
SemanticTagCollections = new List <Dictionary <int, System.Boolean> >();
for (var i = 0; i < semanticTagLength; i++)
{
SemanticTagCollections.Add(null);
}
}
var intLength = conditions.GetTypeCount(out ICondition <System.Int32>[] intConditions);
if (intLength > 0)
{
IntCollections = new List <Dictionary <int, System.Int32> >();
for (var i = 0; i < intLength; i++)
{
IntCollections.Add(null);
}
}
var floatLength = conditions.GetTypeCount(out ICondition <System.Single>[] floatConditions);
if (floatLength > 0)
{
FloatCollections = new List <Dictionary <int, System.Single> >();
for (var i = 0; i < floatLength; i++)
{
FloatCollections.Add(null);
}
}
var stringLength = conditions.GetTypeCount(out ICondition <System.String>[] stringConditions);
if (stringLength > 0)
{
StringCollections = new List <Dictionary <int, System.String> >();
for (var i = 0; i < stringLength; i++)
{
StringCollections.Add(null);
}
}
var poseLength = conditions.GetTypeCount(out ICondition <UnityEngine.Pose>[] poseConditions);
if (poseLength > 0)
{
PoseCollections = new List <Dictionary <int, UnityEngine.Pose> >();
for (var i = 0; i < poseLength; i++)
{
PoseCollections.Add(null);
}
}
var vector2Length = conditions.GetTypeCount(out ICondition <UnityEngine.Vector2>[] vector2Conditions);
if (vector2Length > 0)
{
Vector2Collections = new List <Dictionary <int, UnityEngine.Vector2> >();
for (var i = 0; i < vector2Length; i++)
{
Vector2Collections.Add(null);
}
}
}
public bool UpdateQueryMatchInternal(int dataID,
ProxyConditions conditions, ProxyTraitRequirements requirements, QueryResult result)
{
if (conditions.TryGetType(out ICondition <System.Int32>[] intConditions))
{
foreach (var condition in intConditions)
{
if (!IntTraitProvider.TryGetTraitValue(dataID, condition.traitName, out var traitValue))
{
return(false);
}
if (condition.PassesCondition(ref traitValue))
{
result.SetTrait(condition.traitName, traitValue);
}
else
{
return(false);
}
}
}
if (conditions.TryGetType(out ICondition <System.Single>[] floatConditions))
{
foreach (var condition in floatConditions)
{
if (!FloatTraitProvider.TryGetTraitValue(dataID, condition.traitName, out var traitValue))
{
return(false);
}
if (condition.PassesCondition(ref traitValue))
{
result.SetTrait(condition.traitName, traitValue);
}
else
{
return(false);
}
}
}
if (conditions.TryGetType(out ICondition <System.String>[] stringConditions))
{
foreach (var condition in stringConditions)
{
if (!StringTraitProvider.TryGetTraitValue(dataID, condition.traitName, out var traitValue))
{
return(false);
}
if (condition.PassesCondition(ref traitValue))
{
result.SetTrait(condition.traitName, traitValue);
}
else
{
return(false);
}
}
}
if (conditions.TryGetType(out ICondition <UnityEngine.Vector2>[] vector2Conditions))
{
foreach (var condition in vector2Conditions)
{
if (!Vector2TraitProvider.TryGetTraitValue(dataID, condition.traitName, out var traitValue))
{
return(false);
}
if (condition.PassesCondition(ref traitValue))
{
result.SetTrait(condition.traitName, traitValue);
}
else
{
return(false);
}
}
}
return(true);
}
bool FindTraitsInternal(ProxyConditions conditions, CachedTraitCollection cache)
{
if (conditions.GetTypeCount(out ISemanticTagCondition[] semanticTagConditions) > 0)
{
if (!cache.TryGetType(out List <Dictionary <int, System.Boolean> > semanticTagCollections))
{
return(false);
}
for (var i = 0; i < semanticTagConditions.Length; i++)
{
var condition = semanticTagConditions[i];
if (!SemanticTagTraitProvider.TryGetAllTraitValues(condition.traitName, out Dictionary <int, System.Boolean> traits))
{
if (condition.matchRule == SemanticTagMatchRule.Match)
{
return(false);
}
}
semanticTagCollections[i] = traits;
}
}
if (conditions.GetTypeCount(out ICondition <System.Int32>[] intConditions) > 0)
{
if (!cache.TryGetType(out List <Dictionary <int, System.Int32> > intCollections))
{
return(false);
}
for (var i = 0; i < intConditions.Length; i++)
{
var condition = intConditions[i];
if (!IntTraitProvider.TryGetAllTraitValues(condition.traitName, out Dictionary <int, System.Int32> traits))
{
return(false);
}
intCollections[i] = traits;
}
}
if (conditions.GetTypeCount(out ICondition <System.Single>[] floatConditions) > 0)
{
if (!cache.TryGetType(out List <Dictionary <int, System.Single> > floatCollections))
{
return(false);
}
for (var i = 0; i < floatConditions.Length; i++)
{
var condition = floatConditions[i];
if (!FloatTraitProvider.TryGetAllTraitValues(condition.traitName, out Dictionary <int, System.Single> traits))
{
return(false);
}
floatCollections[i] = traits;
}
}
if (conditions.GetTypeCount(out ICondition <System.String>[] stringConditions) > 0)
{
if (!cache.TryGetType(out List <Dictionary <int, System.String> > stringCollections))
{
return(false);
}
for (var i = 0; i < stringConditions.Length; i++)
{
var condition = stringConditions[i];
if (!StringTraitProvider.TryGetAllTraitValues(condition.traitName, out Dictionary <int, System.String> traits))
{
return(false);
}
stringCollections[i] = traits;
}
}
if (conditions.GetTypeCount(out ICondition <UnityEngine.Pose>[] poseConditions) > 0)
{
if (!cache.TryGetType(out List <Dictionary <int, UnityEngine.Pose> > poseCollections))
{
return(false);
}
for (var i = 0; i < poseConditions.Length; i++)
{
var condition = poseConditions[i];
if (!PoseTraitProvider.TryGetAllTraitValues(condition.traitName, out Dictionary <int, UnityEngine.Pose> traits))
{
return(false);
}
poseCollections[i] = traits;
}
}
if (conditions.GetTypeCount(out ICondition <UnityEngine.Vector2>[] vector2Conditions) > 0)
{
if (!cache.TryGetType(out List <Dictionary <int, UnityEngine.Vector2> > vector2Collections))
{
return(false);
}
for (var i = 0; i < vector2Conditions.Length; i++)
{
var condition = vector2Conditions[i];
if (!Vector2TraitProvider.TryGetAllTraitValues(condition.traitName, out Dictionary <int, UnityEngine.Vector2> traits))
{
return(false);
}
vector2Collections[i] = traits;
}
}
return(true);
}
/// <summary>
/// Tries to fill out a QueryResult with updated data for a query that has been matched.
/// This also checks if the data no longer meets the given conditions.
/// </summary>
/// <param name="dataID">ID for the data used by the query match</param>
/// <param name="conditions">Criteria that the data must continue to meet</param>
/// <param name="result">Object that will contain the updated data that still matches the conditions</param>
/// <returns>True if the data still matches the conditions, false otherwise</returns>
public static bool TryUpdateQueryMatchData(this IUsesDatabaseQuerying obj, int dataID, ProxyConditions conditions, ProxyTraitRequirements requirements, QueryResult result)
{
return(IUsesDatabaseQueryingMethods.TryUpdateQueryMatchData(dataID, conditions, requirements, result));
}
static TryBestMatchArguments MatchArgsForConditions(ProxyConditions conditions, Exclusivity exclusivity)
{
return(new TryBestMatchArguments(conditions, exclusivity));
}
