// Returns the index of the first OutputChangeType that matches the InputConditionType or -1 if no matches public int OutputChangeTypeMatch(InputCondition inputCondition, MappingType inputConditionMappingType, List <EntityType> allEntityTypes) { for (int i = 0; i < outputChanges.Count; i++) { OutputChange outputChange = outputChanges[i]; if (inputCondition.inputConditionType == null) { Debug.LogError("MappingType " + inputConditionMappingType.name + " has an InputCondition with no InputConditionType. Please Fix."); return(-1); } if (outputChange.outputChangeType == null) { Debug.LogError("MappingType " + name + " has an OutputChange with no OutputChangeType. Please Fix."); return(-1); } if (inputCondition.inputConditionType.matchingOCTs != null && inputCondition.inputConditionType.matchingOCTs.Contains(outputChange.outputChangeType) && outputChange.outputChangeType.PreMatch(outputChange, this, inputCondition, inputConditionMappingType, allEntityTypes)) { return(i); } } return(-1); }
public bool AnyInventoryGroupingMatches(MappingType mappingType, List <EntityType> entityTypes) { List <TypeGroup> groupings = InventoryTypeGroups(mappingType, out List <int> indexesToSet); List <EntityType> matches = TypeGroup.InAllTypeGroups(groupings, entityTypes, true); return(matches != null && matches.Count > 0); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { List <InputCondition> inputConditionsFromOC = outputChangeMappingType.EntityTypeInputConditions(); List <EntityType> entityTypes = TypeGroup.PossibleEntityTypes(inputConditionsFromOC, agent.memoryType.GetKnownEntityTypes(agent)); if (inputConditionMappingType.AnyEntityTypeMatchesTypeGroups(entityTypes) && inputCondition.levelType == outputChange.levelType) { // Same EntityType and same TagType - match adding tag to needing tag and removing tag to can't have tag if (!outputChange.boolValue && ((HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.DoesNotHaveOwnerTag || (HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.DoesNotHaveTag)) { return(true); } else if (outputChange.boolValue && ((HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.HasTagButNotOwner || (HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.HasTagIgnoreOwnership || (HasTagICT.Scope)inputCondition.enumValueIndex == HasTagICT.Scope.HasTagIsOwner)) { return(true); } } return(false); }
public override bool PreMatch(OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType, List <EntityType> allEntityTypes) { // Matches OtherInventoryAmountICT // This needs to be giving the corrent EntityType (InventoryGroupings) based on what the ICT needs (InventoryGroupings) if (outputChange.inventoryTypeGroupMatchIndex == -1) { return(false); } InputCondition outputChangeInputCondition = outputChangeMappingType.inputConditions[outputChange.inventoryTypeGroupMatchIndex]; List <TypeGroup> groupings = outputChangeInputCondition.InventoryTypeGroups(outputChangeMappingType, out List <int> indexesToSet); // groupings is now the EntityTypes that are possible to be given List <EntityType> entityTypes = TypeGroup.InAllTypeGroups(groupings, allEntityTypes); // See if any of these EntityTypes matches what the IC of OtherInventoryAmountICT needs bool inventoryGroupMatches = inputCondition.AnyInventoryGroupingMatches(inputConditionMappingType, entityTypes); // Also need to make sure that possible EntityTypes from both MappingTypes have some overlap bool groupMatches = outputChangeMappingType.AnyEntityTypeMatchesTypeGroups(inputConditionMappingType, allEntityTypes); if (inventoryGroupMatches && groupMatches) { return(true); } return(false); }
// Figure out how close to get to the target when doing a GoTo action public override float GetArriveDistance(Agent agent, Entity target, Mapping mapping) { // Chain of priority for distance: MappingType > ActionType > InputOutputType - default to 1.5 MappingType mappingType = mapping.mappingType; float distance = 2.5f; if (mappingType.maxDistanceAsInput > 0) { distance = mappingType.maxDistanceAsInput; } else if (mappingType.actionType.maxDistanceAsInput > 0) { distance = mappingType.actionType.maxDistanceAsInput; } else if (mappingType.outputChanges != null && mappingType.outputChanges.Count > 0 && mappingType.outputChanges[0].outputChangeType.name == "NearEntityOCT" && mapping.parent != null && mapping.parent.mappingType.actionType.maxDistanceAsInput > 0) { distance = mapping.parent.mappingType.actionType.maxDistanceAsInput; } else if (target != null && target.entityType.maxDistanceAsInput > 0) { distance = target.entityType.maxDistanceAsInput; } else if (target != null && target.entityType.maxDistanceAsInput > 0) { distance = target.entityType.maxDistanceAsInput; } //Debug.Log("GetArriveDistance for " + passedInTarget.name + " Distance = " + distance); return(distance); }
public OutputChange Previous(MappingType mappingType) { int index = mappingType.outputChanges.IndexOf(this); if (index == 0) { return(null); } return(mappingType.outputChanges[index - 1]); }
public OutputChange Next(MappingType mappingType) { int index = mappingType.outputChanges.IndexOf(this); if (index + 1 == mappingType.outputChanges.Count) { return(null); } return(mappingType.outputChanges[index + 1]); }
public Mapping(MappingType mappingType) { this.mappingType = mappingType; target = null; inventoryTargets = null; parent = null; children = null; reasonForChildren = null; childIndex = 0; isComplete = false; }
public override bool PreMatch(OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType, List <EntityType> allEntityTypes) { // The EntityType being created need match with the ICMT's EntityType TypeGroup Target List <TypeGroup> typeGroups = inputConditionMappingType.EntityTypeGroupings(); if (outputChange.entityType.InAllTypeGroups(typeGroups)) { return(true); } return(false); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { List <InputCondition> inputConditionsFromOC = outputChangeMappingType.EntityTypeInputConditions(); List <EntityType> entityTypes = TypeGroup.PossibleEntityTypes(inputConditionsFromOC, agent.memoryType.GetKnownEntityTypes(agent)); if (inputConditionMappingType.AnyEntityTypeMatchesTypeGroups(entityTypes)) { return(true); } return(false); }
public override bool PreMatch(OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType, List <EntityType> allEntityTypes) { // This OTC can change the drive level positive or negative for the agent or a drive level for its target agent if (outputChange.targetType == OutputChange.TargetType.ToSelf) { // Match this to DriveLevelICTs that are checking this agent's Drive Levels (boolValue == false) // Need the change amount to push the level towards the ICTs min-max range // No access the game state since this is run before to cache the IC to MT matches // If DriveLevelICT fails do we want to push the level up or down to fix it? // With a middle range (40-60) we have no way to know unless we know the agent's level // if its end ranges though (0-10 or 90-100) we do know // Switch to have a floatValue and say <= or >= // Or have runtime checks - have it match both increase and decrease // then check agent's drive level and filter out one of them if (inputCondition.levelType == outputChange.levelType && !inputCondition.boolValue) { if (inputCondition.max == 100) { // The ICT wants a high drive level - Make sure OCT is pushing the value up if (outputChange.valueType == OutputChange.ValueType.FloatValue && outputChange.floatValue > 0 || outputChange.valueType == OutputChange.ValueType.ActionSkillCurve && outputChange.actionSkillCurve.max > 0) { return(true); } } else if (inputCondition.min == 0) { // The ICT wants a low drive level - Make sure OCT is pushing the value up if (outputChange.valueType == OutputChange.ValueType.FloatValue && outputChange.floatValue < 0 || outputChange.valueType == OutputChange.ValueType.ActionSkillCurve && outputChange.actionSkillCurve.min < 0) { return(true); } } else { // Not sure - we need to know agent's level so we need to do a runtime check return(true); } return(false); } } else { // TODO: What does a Drive Level change to target agent match with? } return(false); }
public void CreateICToMTDictionary() { if (settings.driveLevelICT == null) { return; } fixesInputCondition = new Dictionary <InputCondition, List <FixInputCondition> >(); fakeDriveLevelMappingTypes = new Dictionary <DriveType, MappingType>(); // TODO: Will this work in runtime? List <MappingType> allMappingTypes = new List <MappingType>(); string[] guids = AssetDatabase.FindAssets("t:MappingType"); foreach (string guid in guids) { allMappingTypes.Add((MappingType)AssetDatabase.LoadMainAssetAtPath(AssetDatabase.GUIDToAssetPath(guid))); } List <DriveType> allDriveTypes = new List <DriveType>(); guids = AssetDatabase.FindAssets("t:DriveType"); foreach (string guid in guids) { allDriveTypes.Add((DriveType)AssetDatabase.LoadMainAssetAtPath(AssetDatabase.GUIDToAssetPath(guid))); } // Add in Drive InputConditions that don't exist in the MappingTypes (Goals) foreach (DriveType driveType in allDriveTypes) { MappingType mappingType = ScriptableObject.CreateInstance <MappingType>(); mappingType.name = "AutoGeneratedFor" + driveType.name; InputCondition inputCondition = new InputCondition(driveType, settings.driveLevelICT, false); mappingType.inputConditions = new List <InputCondition>() { inputCondition }; fakeDriveLevelMappingTypes.Add(driveType, mappingType); FindMatchingMappingTypes(inputCondition, mappingType, allMappingTypes); } foreach (MappingType mappingType in allMappingTypes) { foreach (InputCondition inputCondition in mappingType.inputConditions) { FindMatchingMappingTypes(inputCondition, mappingType, allMappingTypes); } } Debug.Log("ICT to MappingType Lookup Dictionary Created."); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { // This matches WorldObjectStateICT List <InputCondition> inputConditionsFromOC = outputChangeMappingType.EntityTypeInputConditions(); List <EntityType> entityTypes = TypeGroup.PossibleEntityTypes(inputConditionsFromOC, agent.memoryType.GetKnownEntityTypes(agent)); if (inputConditionMappingType.AnyEntityTypeMatchesTypeGroups(entityTypes) && outputChange.stringValue == inputCondition.stringValue) { return(true); } return(false); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { // Trying to match with ItemAmountICT with this (InventoryPickupOCT) // So make sure InventoryGrouping from ItemAmountICT overlaps with the Grouping for InventoryPickupOCT List <EntityType> entityTypes = TypeGroup.PossibleEntityTypes(outputChangeMappingType.inputConditions, agent.memoryType.GetKnownEntityTypes(agent)); if (inputCondition.GetInventoryTypeGroup().AnyMatches(entityTypes)) { return(true); } return(false); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { return(true); /* * List<InputCondition> inputConditionsFromOC = outputChangeMappingType.EntityTypeInputConditions(); * List<EntityType> entityTypes = Grouping.PossibleEntityTypes(inputConditionsFromOC, agent.memoryType.GetKnownEntityTypes(agent)); * * if (inputConditionMappingType.AnyEntityTypeMatchesGroupings(entityTypes) && * outputChange.boolValue == inputCondition.boolValue) * return true; * return false; */ }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { // This matches with InventoryAmountICT // Matches the InventoryAmountICT InventoryGroup with this OC's InventoryGroup InputCondition outputChangeInputCondition = outputChangeMappingType.inputConditions[outputChange.inventoryTypeGroupMatchIndex]; List <TypeGroup> groupings = outputChangeInputCondition.InventoryTypeGroups(outputChangeMappingType, out List <int> indexesToSet); // Groupings is now the EntityTypes that are possible to be taken // Need to use allEntityTypes in world since agent may be trying to get an EntityType this is in inventory List <EntityType> entityTypes = TypeGroup.InAllTypeGroups(groupings, agent.totalAIManager.allEntityTypes); if (inputCondition.AnyInventoryGroupingMatches(inputConditionMappingType, entityTypes)) { return(true); } return(false); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { // Matches OtherInventoryAmountICT // This needs to be giving the corrent EntityType (InventoryGroupings) based on what the ICT needs (InventoryGroupings) InputCondition outputChangeInputCondition = outputChangeMappingType.inputConditions[outputChange.inventoryTypeGroupMatchIndex]; List <TypeGroup> groupings = outputChangeInputCondition.InventoryTypeGroups(outputChangeMappingType, out List <int> indexesToSet); // groupings is now the EntityTypes that are possible to be given List <EntityType> entityTypes = TypeGroup.InAllTypeGroups(groupings, agent.memoryType.GetKnownEntityTypes(agent, true)); // See if any of these EntityTypes matches what the IC of OtherInventoryAmountICT needs if (inputCondition.AnyInventoryGroupingMatches(inputConditionMappingType, entityTypes)) { return(true); } return(false); }
private void ResetNoPlans() { noPlansMappingType = agentType.defaultNoPlansMappingType; foreach (AgentTypeOverride agentTypeOverride in entityTypeOverrides) { if (agentTypeOverride != null && agentTypeOverride.defaultNoPlansMappingType != null) { noPlansMappingType = agentTypeOverride.defaultNoPlansMappingType; } } noneDriveType = agentType.defaultNoPlansDriveType; foreach (AgentTypeOverride agentTypeOverride in entityTypeOverrides) { if (agentTypeOverride != null && agentTypeOverride.defaultNoPlansDriveType != null) { noneDriveType = agentTypeOverride.defaultNoPlansDriveType; } } }
public virtual Mapping CreateGoToMapping(Mapping mapping) { MappingType mappingType = CreateInstance <MappingType>(); mappingType.inputConditions = new List <InputCondition>(); mappingType.outputChanges = new List <OutputChange>(); mappingType.actionType = mapping.mappingType.goToActionType; mappingType.selectors = mapping.mappingType.goToSelectors; mappingType.overrideDefaultSelectors = mapping.mappingType.overrideDefaultGoToSelectors; mappingType.name = mappingType.actionType.name + (mapping.target == null ? "Location" : mapping.target.name); Mapping goToMapping = new Mapping(mappingType) { target = mapping.target, parent = mapping, isComplete = true }; return(goToMapping); }
static AssetDeleteResult OnWillDeleteAsset(string path, RemoveAssetOptions opt) { if (AssetDatabase.GetMainAssetTypeAtPath(path) == typeof(MappingType)) { MappingType mappingType = AssetDatabase.LoadAssetAtPath <MappingType>(path); ActionType actionType = mappingType.actionType; if (actionType != null) { if (actionType.mappingTypes.Contains(mappingType)) { actionType.mappingTypes.Remove(mappingType); EditorUtility.SetDirty(actionType); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); } } } return(AssetDeleteResult.DidNotDelete); }
// Returns true if this and mappingType have any EntityTypes that match both public bool AnyEntityTypeMatchesTypeGroups(MappingType mappingType, List <EntityType> entityTypes) { List <TypeGroup> typeGroups = EntityTypeGroupings(true); if (typeGroups.Count == 0) { return(false); } List <TypeGroup> otherTypeGroups = mappingType.EntityTypeGroupings(true); if (otherTypeGroups.Count == 0) { return(false); } List <TypeGroup> combinedTypeGroups = typeGroups.Union(otherTypeGroups).Distinct().ToList(); List <EntityType> matches = TypeGroup.InAllTypeGroups(combinedTypeGroups, entityTypes, true); return(matches != null && matches.Count > 0); }
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { foreach (string path in importedAssets) { if (AssetDatabase.GetMainAssetTypeAtPath(path) == typeof(MappingType)) { MappingType mappingType = AssetDatabase.LoadAssetAtPath <MappingType>(path); ActionType actionType = mappingType.actionType; if (actionType != null) { if (!actionType.mappingTypes.Contains(mappingType)) { actionType.mappingTypes.Add(mappingType); EditorUtility.SetDirty(actionType); AssetDatabase.SaveAssets(); AssetDatabase.Refresh(); } } } } }
// Updates fixesInputCondition with any MappingTypes that resolve the inputCondition private void FindMatchingMappingTypes(InputCondition inputCondition, MappingType inputConditionMappingType, List <MappingType> allMappingTypes) { foreach (MappingType outputChangeMappingType in allMappingTypes) { // Current limitation is that MT can only be in a plan tree once (Due to relying on IC for Dicts) // So it makes sense to prevent this - not sure if you would ever want an MT to link to itself? if (outputChangeMappingType == inputConditionMappingType) { continue; } // Ask outputChangeMappingType if it has any matching OutputChanges int outputChangeIndex = outputChangeMappingType.OutputChangeTypeMatch(inputCondition, inputConditionMappingType, allEntityTypes); if (outputChangeIndex != -1) { FixInputCondition fixInputCondition = new FixInputCondition() { mappingType = outputChangeMappingType, outputChangeIndex = outputChangeIndex }; if (!fixesInputCondition.ContainsKey(inputCondition)) { // New entry in dictionary - inputCondition has not been seen before List <FixInputCondition> fixInputConditions = new List <FixInputCondition>() { fixInputCondition }; fixesInputCondition.Add(inputCondition, fixInputConditions); } else { fixesInputCondition[inputCondition].Add(fixInputCondition); } } } }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { return(false); }
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { // TODO: Handle middle ranges return(true); }
// Returns all Groupings that this InventoryGrouping needs to match based on sharesInventoryGroupWith // TODO: Have a way to ignore the indexesToSet - don't always need it public List <TypeGroup> InventoryTypeGroups(MappingType mappingType, out List <int> indexesToSet) { indexesToSet = new List <int>(); if (!inputConditionType.typeInfo.usesInventoryTypeGroup) { return(null); } List <TypeGroup> groupings = new List <TypeGroup>() { GetInventoryTypeGroup() }; // See if this shares InventoryGroupings with any other IC // See if inputCondition shares its InventoryGrouping with any other ICs int thisIndex = -1; int[] sharesWith = new int[mappingType.inputConditions.Count]; for (int i = 0; i < mappingType.inputConditions.Count; i++) { InputCondition inputCondition = mappingType.inputConditions[i]; if (inputCondition.inputConditionType.typeInfo.usesInventoryTypeGroupShareWith) { sharesWith[i] = inputCondition.sharesInventoryTypeGroupWith; } else { sharesWith[i] = -1; } if (inputCondition == this) { thisIndex = i; indexesToSet.Add(i); } } // Need to know if this sharesWith or if any other ICs share with this one for (int i = 0; i < mappingType.inputConditions.Count; i++) { if (sharesWith[i] == thisIndex) { groupings.Add(mappingType.inputConditions[i].GetInventoryTypeGroup()); indexesToSet.Add(i); } else if (i == thisIndex && sharesWith[i] != -1) { groupings.Add(mappingType.inputConditions[sharesWith[i]].GetInventoryTypeGroup()); indexesToSet.Add(sharesWith[i]); } } if (groupings.Any(x => x == null)) { Debug.LogError("MappingType " + mappingType.name + " Has null InventoryGroupings in ICs that need them. Please fix."); return(null); } return(groupings); }
public int Index(MappingType mappingType) { return(mappingType.outputChanges.IndexOf(this)); }
public virtual bool PreMatch(OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType, List <EntityType> allEntityTypes) { return(true); }
public abstract bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType);
public override bool Match(Agent agent, OutputChange outputChange, MappingType outputChangeMappingType, InputCondition inputCondition, MappingType inputConditionMappingType) { // All matching needed is done in PreMatch (since the specific EntityType being created needs to be specified) return(true); }