public static bool RateConditionMatchesInternal(Conditions conditions,
CachedTraitCollection traits, ConditionRatingsData ratings)
{
conditions.TryGetType(out ICondition <System.Int32>[] intConditions);
if (!RateConditionType(intConditions, traits, ratings[typeof(System.Int32)]))
{
return(false);
}
conditions.TryGetType(out ICondition <System.Single>[] floatConditions);
if (!RateConditionType(floatConditions, traits, ratings[typeof(System.Single)]))
{
return(false);
}
conditions.TryGetType(out ICondition <System.String>[] stringConditions);
if (!RateConditionType(stringConditions, traits, ratings[typeof(System.String)]))
{
return(false);
}
conditions.TryGetType(out ICondition <UnityEngine.Pose>[] poseConditions);
if (!RateConditionType(poseConditions, traits, ratings[typeof(UnityEngine.Pose)]))
{
return(false);
}
conditions.TryGetType(out ICondition <UnityEngine.Vector2>[] vector2Conditions);
if (!RateConditionType(vector2Conditions, traits, ratings[typeof(UnityEngine.Vector2)]))
{
return(false);
}
return(true);
}
public void Modify(QueryMatchID id, int index, SetChildArgs args)
{
Assert.IsTrue(MatchIdToIndex.ContainsKey(id) &&
QueryMatchIds[index].Equals(id) &&
ValidIndices.Contains(index),
$"Invalid query match id {id} or invalid index {index}");
Exclusivities[index] = args.tryBestMatchArgs.exclusivity;
Required[index] = args.required;
BestMatchDataIds[index] = (int)ReservedDataIDs.Invalid;
CachedTraits[index] = new CachedTraitCollection(args.tryBestMatchArgs.conditions);
Conditions[index] = args.tryBestMatchArgs.conditions;
TraitRequirements[index] = args.TraitRequirements;
RelationMemberships[index] = null;
ConditionRatings[index].Recycle();
ConditionRatings[index] = Pools.ConditionRatings.Get().Initialize(args.tryBestMatchArgs.conditions);
ReducedConditionRatings[index].Clear();
ConditionMatchSets[index].Clear();
QueryResults[index] = new QueryResult {
queryMatchId = id
};
AcquiringIndices.Add(index);
UpdatingIndices.Remove(index);
}
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);
}
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 bool RateConditionType(ICondition <UnityEngine.Pose>[] typeConditions,
CachedTraitCollection traitCollections, List <Dictionary <int, float> > ratings)
{
if (typeConditions.Length == 0)
{
return(true);
}
if (!traitCollections.TryGetType(out List <Dictionary <int, UnityEngine.Pose> > traits))
{
return(false);
}
return(RateConditionMatches(typeConditions, traits, ratings));
}
internal static bool RateConditionMatches(ProxyConditions conditions, CachedTraitCollection traitCache,
ConditionRatingsData resultData)
{
if (conditions.Count <= 0)
{
return(false);
}
conditions.TryGetType(out ISemanticTagCondition[] semanticTagConditions);
traitCache.TryGetType(out List <Dictionary <int, bool> > semanticTagTraits);
var semanticTagsMatched = RateSemanticTagConditionMatches(semanticTagConditions,
semanticTagTraits, resultData[typeof(bool)], resultData.MatchRuleIndexes);
return(semanticTagsMatched && RateConditionMatchesInternal(conditions, traitCache, resultData));
}
internal bool DataIdPassesAll(ProxyConditions conditions, CachedTraitCollection traitCache, int dataId)
{
conditions.TryGetType(out ISemanticTagCondition[] semanticTagConditions);
traitCache.TryGetType(out List <Dictionary <int, bool> > semanticTagTraits);
for (var i = 0; i < semanticTagConditions.Length; i++)
{
var tagCondition = semanticTagConditions[i];
var tagTraitCollection = semanticTagTraits[i];
if (!tagTraitCollection.TryGetValue(dataId, out var traitValue))
{
switch (tagCondition.matchRule)
{
case SemanticTagMatchRule.Exclude:
continue;
case SemanticTagMatchRule.Match:
return(false);
}
}
var rating = tagCondition.RateDataMatch(ref traitValue);
switch (tagCondition.matchRule)
{
case SemanticTagMatchRule.Exclude:
if (rating > 0f)
{
return(false);
}
break;
case SemanticTagMatchRule.Match:
if (rating <= 0f)
{
return(false);
}
break;
}
}
return(DataPassesAllConditionsInternal(traitCache, dataId));
}
public void Modify(QueryMatchID id, QueryArgs args)
{
if (!MatchIdToIndex.TryGetValue(id, out var index))
{
return;
}
Assert.IsTrue(QueryMatchIds[index].Equals(id),
$"{index} mismatch with {id}!");
QueryArgs[index] = args;
Exclusivities[index] = args.exclusivity;
BestMatchDataIds[index] = (int)ReservedDataIDs.Invalid;
TimeOuts[index] = args.commonQueryData.timeOut;
ReAcquireOnLoss[index] = args.commonQueryData.reacquireOnLoss;
Priority[index] = args.commonQueryData.priority;
UpdateMatchInterval[index] = args.commonQueryData.updateMatchInterval;
CachedTraits[index] = new CachedTraitCollection(args.conditions);
TraitRequirements[index] = args.traitRequirements;
Conditions[index] = args.conditions;
ConditionRatings[index] = Pools.ConditionRatings.Get().Initialize(args.conditions);
ConditionMatchSets[index] = Pools.DataIdHashSets.Get();
ReducedConditionRatings[index] = Pools.Ratings.Get();
QueryResults[index] = new QueryResult {
queryMatchId = id
};
AcquireHandlers[index] = args.onAcquire;
UpdateHandlers[index] = args.onMatchUpdate;
LossHandlers[index] = args.onLoss;
TimeoutHandlers[index] = args.onTimeout;
if (!AcquiringIndices.Contains(index))
{
AcquiringIndices.Add(index);
}
UpdatingIndices.Remove(index);
}
public void Register(QueryMatchID id, QueryArgs args)
{
if (MatchIdToIndex.ContainsKey(id))
{
return; // query is already registered
}
var index = GetInsertionIndex();
QueryMatchIds[index] = id;
QueryArgs[index] = args;
Exclusivities[index] = args.exclusivity;
BestMatchDataIds[index] = (int)ReservedDataIDs.Invalid;
TimeOuts[index] = args.commonQueryData.timeOut;
ReAcquireOnLoss[index] = args.commonQueryData.reacquireOnLoss;
Priority[index] = args.commonQueryData.priority;
UpdateMatchInterval[index] = args.commonQueryData.updateMatchInterval;
CachedTraits[index] = new CachedTraitCollection(args.conditions);
TraitRequirements[index] = args.traitRequirements;
Conditions[index] = args.conditions;
ConditionRatings[index] = Pools.ConditionRatings.Get().Initialize(args.conditions);
ConditionMatchSets[index] = Pools.DataIdHashSets.Get();
ReducedConditionRatings[index] = Pools.Ratings.Get();
QueryResults[index] = new QueryResult {
queryMatchId = id
};
AcquireHandlers[index] = args.onAcquire;
UpdateHandlers[index] = args.onMatchUpdate;
LossHandlers[index] = args.onLoss;
TimeoutHandlers[index] = args.onTimeout;
m_Count++;
ValidIndices.Add(index);
MatchIdToIndex.Add(id, index);
AcquiringIndices.Add(index);
}
internal void FillQueryResult(int dataId, ProxyConditions conditions, CachedTraitCollection traits,
ProxyTraitRequirements requirements, QueryMatchID matchId, QueryResult result)
{
result.queryMatchId = matchId;
result.SetDataId(dataId);
FillRequiredTraitsAction(dataId, requirements, result);
FillQueryResultInternal(dataId, conditions, traits, matchId, result);
conditions.TryGetType(out ICondition <Pose>[] poseConditions);
traits.TryGetType(out List <Dictionary <int, Pose> > poseCollections);
for (var i = 0; i < poseConditions.Length; i++)
{
var poseCollection = poseCollections[i];
var nonOffsetValue = poseCollection[dataId];
var poseValue = applyOffsetToPose(nonOffsetValue);
var refiner = poseConditions[i] as IPoseRefiner;
if (refiner != null)
{
poseValue = refiner.RefinePose(poseValue, true);
}
result.SetTrait(poseConditions[i].traitName, poseValue);
}
if (!conditions.TryGetType(out ISemanticTagCondition[] semanticTagConditions))
{
return;
}
// tags can take a shortcut with query filling - they're really just a test for presence or absence,
// so if that test has already been passed, we can just assign a bool representing the result
foreach (var condition in semanticTagConditions)
{
var isExcluding = condition.matchRule == SemanticTagMatchRule.Exclude;
result.SetTrait(condition.traitName, !isExcluding);
}
}
internal static void FillQueryResultInternal(int dataId, Conditions conditions, CachedTraitCollection traits,
QueryMatchID matchId, QueryResult result)
{
traits.TryGetType(out List <Dictionary <int, System.Int32> > intCollections);
conditions.TryGetType(out ICondition <System.Int32>[] intConditions);
FillQueryResult <System.Int32>(dataId, intConditions, intCollections, result);
traits.TryGetType(out List <Dictionary <int, System.Single> > floatCollections);
conditions.TryGetType(out ICondition <System.Single>[] floatConditions);
FillQueryResult <System.Single>(dataId, floatConditions, floatCollections, result);
traits.TryGetType(out List <Dictionary <int, System.String> > stringCollections);
conditions.TryGetType(out ICondition <System.String>[] stringConditions);
FillQueryResult <System.String>(dataId, stringConditions, stringCollections, result);
traits.TryGetType(out List <Dictionary <int, UnityEngine.Pose> > poseCollections);
conditions.TryGetType(out ICondition <UnityEngine.Pose>[] poseConditions);
FillQueryResult <UnityEngine.Pose>(dataId, poseConditions, poseCollections, result);
traits.TryGetType(out List <Dictionary <int, UnityEngine.Vector2> > vector2Collections);
conditions.TryGetType(out ICondition <UnityEngine.Vector2>[] vector2Conditions);
FillQueryResult <UnityEngine.Vector2>(dataId, vector2Conditions, vector2Collections, result);
}
