public virtual void Setup()
{
m_TraitDefinition = DynamicStruct.Create <TraitDefinition>();
m_TraitDefinition.CreateProperty <int>("FieldA");
SaveAsset(m_TraitDefinition, Path.Combine(k_TraitAssetsPath, "TraitA.asset"));
m_EnumDefinition = ScriptableObject.CreateInstance <EnumDefinition>();
m_EnumDefinition.CreateProperty <string>("ValueA");
m_EnumDefinition.CreateProperty <string>("ValueB");
m_EnumDefinition.CreateProperty <string>("ValueC");
SaveAsset(m_EnumDefinition, Path.Combine(k_EnumAssetsPath, "EnumA.asset"));
SetupTerminationDefinition("TerminationA.asset");
SetupActionDefinition("ActionA.asset");
m_ProblemDefinition = ScriptableObject.CreateInstance <ProblemDefinition>();
m_ProblemDefinition.ActionDefinitions = new[]
{
m_ActionDefinition
};
m_ProblemDefinition.StateTerminationDefinitions = new[]
{
m_StateTerminationDefinition
};
SaveAsset(m_ProblemDefinition, Path.Combine(k_AssetsPath, "PlanA.asset"));
PlannerAssetDatabase.Refresh(new [] { Path.Combine("Assets", "Temp") });
}
void OnEnable()
{
m_FieldList = new NoHeaderReorderableList(serializedObject, serializedObject.FindProperty("m_Fields"),
DrawFieldListElement, 3);
PlannerAssetDatabase.Refresh();
}
void OnEnable()
{
PlannerAssetDatabase.Refresh();
PlannerCustomTypeCache.Refresh();
InitializeReorderableLists();
}
public static void ShowRewardModifierMenu(SerializedObject serializedObject, SerializedProperty propertyList, Type[] rewardTypes)
{
var menu = new GenericMenu();
for (var i = 0; i < rewardTypes.Length; i++)
{
var rewardTypeName = rewardTypes[i].FullName;
var displayName = rewardTypes[i].Name;
string builtinModule;
if ((builtinModule = PlannerAssetDatabase.GetBuiltinModuleName(rewardTypes[i].Namespace)) != null)
{
displayName = $"{builtinModule}/{displayName}";
}
menu.AddItem(new GUIContent(displayName), false, () =>
{
serializedObject.Update();
var newFieldProperty = propertyList.InsertArrayElement();
var typeProperty = newFieldProperty.FindPropertyRelative("m_Typename");
typeProperty.stringValue = rewardTypeName;
var parametersProperty = newFieldProperty.FindPropertyRelative("m_Parameters");
parametersProperty.arraySize = 0;
serializedObject.ApplyModifiedProperties();
});
}
menu.ShowAsContext();
}
void DrawTerminationListElement(Rect rect, int index, bool isActive, bool isFocused)
{
var list = m_TerminationList.serializedProperty;
var value = list.GetArrayElementAtIndex(index);
rect.y += EditorGUIUtility.standardVerticalSpacing;
rect.height = EditorGUIUtility.singleLineHeight;
if (value.objectReferenceValue != null)
{
var displayName = value.objectReferenceValue.name;
string builtinModule;
if ((builtinModule = PlannerAssetDatabase.GetBuiltinModuleName(value.objectReferenceValue)) != null)
{
displayName = $"{displayName} <color=grey>({builtinModule})</color>";
}
if (GUI.Button(rect, displayName, EditorStyleHelper.richTextField))
{
EditorGUIUtility.PingObject(value.objectReferenceValue);
}
}
else
{
EditorGUI.LabelField(rect, "Termination not found", EditorStyleHelper.grayLabel);
}
}
void AssignPlanGUI(SerializedProperty definition)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("Create and assign a Problem Definition to start working with the AI Planner", MessageType.Info);
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("+", EditorStyles.miniButtonMid, GUILayout.Width(22)))
{
var newPlan = PlannerAssetDatabase.CreateNewPlannerAsset <ProblemDefinition>("Plan");
definition.objectReferenceValue = newPlan;
}
EditorGUILayout.PropertyField(definition, GUIContent.none);
EditorGUILayout.EndHorizontal();
EditorGUILayout.Space();
}
static bool Build(bool rebuildStateRepresentation)
{
EditorUtility.DisplayProgressBar(k_TitleBuildPopup, "Refresh Planner database", 0.1f);
PlannerAssetDatabase.Refresh();
var codeGenerator = new CodeGenerator();
var validator = new AssetValidator();
validator.errorLogged += (errorMessage, asset) => Debug.LogError($"<b>{AssetDatabase.GetAssetPath(asset)}</b>: {errorMessage}");
bool stateRepresentationAssemblyValid = true;
if (rebuildStateRepresentation || !File.Exists(k_TempOutputStateRepresentationAssembly))
{
EditorUtility.DisplayProgressBar(k_TitleBuildPopup, "State Representation assembly compilation", 0.4f);
if (!validator.CheckStateRepresentationAssetsValidity())
{
Debug.LogError("All Planner asset errors have to be fixed to generate AI State Representation assembly.");
return(false);
}
stateRepresentationAssemblyValid = CreateStateRepresentationPackage(codeGenerator);
}
if (stateRepresentationAssemblyValid)
{
EditorUtility.DisplayProgressBar(k_TitleBuildPopup, "Plan assembly compilation", 0.6f);
var customAssembly = BuildCustomCodeAssembly();
if (customAssembly == null)
{
Debug.LogError("Custom code errors have to be fixed to generate AI Plans assembly.");
return(false);
}
if (!validator.CheckPlansAssetsValidity(customAssembly))
{
Debug.LogError("All Planner asset errors have to be fixed to generate AI Plans assembly.");
return(false);
}
CreatePlansPackage(codeGenerator, customAssembly);
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport | ImportAssetOptions.ImportRecursive);
return(true);
}
return(false);
}
void ShowAddTerminationMenu(Rect rect, ReorderableList list)
{
var menu = new GenericMenu();
foreach (var termination in PlannerAssetDatabase.StateTerminationDefinitions)
{
var displayName = termination.Name;
string builtinModule;
if ((builtinModule = PlannerAssetDatabase.GetBuiltinModuleName(termination)) != null)
{
displayName = $"{builtinModule}/{displayName}";
}
var alreadyInList = false;
m_TerminationList.serializedProperty.ForEachArrayElement(a => alreadyInList |= (a.objectReferenceValue == termination));
if (!alreadyInList)
{
menu.AddItem(new GUIContent(displayName), false, () =>
{
serializedObject.Update();
var newTerminationProperty = list.serializedProperty.InsertArrayElement();
newTerminationProperty.objectReferenceValue = termination;
serializedObject.ApplyModifiedProperties();
});
}
else
{
menu.AddDisabledItem(new GUIContent(displayName));
}
}
menu.AddSeparator(string.Empty);
menu.AddItem(new GUIContent("New Termination..."), false, () =>
{
Object mewTermination;
if ((mewTermination = PlannerAssetDatabase.CreateNewPlannerAsset <StateTerminationDefinition>("Termination")) != null)
{
serializedObject.Update();
var newTerminationProperty = list.serializedProperty.InsertArrayElement();
newTerminationProperty.objectReferenceValue = mewTermination;
serializedObject.ApplyModifiedProperties();
}
});
menu.ShowAsContext();
}
static void QueueBuild()
{
if (PlannerAssetDatabase.HasValidProblemDefinition())
{
if (EditorApplication.delayCall == null || !EditorApplication.delayCall.GetInvocationList().Any(
d =>
{
var methodInfo = d.Method;
return(methodInfo.Name == nameof(BuildWhenReady) && methodInfo.DeclaringType == typeof(PlannerAssemblyBuilder));
}))
{
EditorApplication.delayCall += BuildWhenReady;
}
}
}
void OnEnable()
{
m_EnumList = new NoHeaderReorderableList(serializedObject, serializedObject.FindProperty("m_Values"), DrawEnumListElement, 1);
PlannerAssetDatabase.Refresh();
}
void OnEnable()
{
PlannerAssetDatabase.Refresh();
}
static void OnPlayModeStateChanged(PlayModeStateChange playMode)
{
if (AIPlannerPreferences.GetOrCreatePreferences().AutoCompile)
{
if (playMode == PlayModeStateChange.EnteredPlayMode && EditorApplication.isCompiling)
{
// If we're still compiling the domain will reload and cause an error, so as a safeguard simply exit play mode
EditorApplication.ExitPlaymode();
return;
}
if (playMode == PlayModeStateChange.ExitingEditMode && !EditorApplication.isCompiling)
{
if (!PlannerAssetDatabase.HasValidProblemDefinition())
{
return;
}
var assetChangedPath = string.Empty;
bool stateRepresentationNeedBuild = !PlannerAssetDatabase.StateRepresentationPackageExists();
if (!stateRepresentationNeedBuild)
{
DateTime lastStateRepresentationBuildTime = GetAssemblyBuildTime(TypeHelper.StateRepresentationQualifier);
stateRepresentationNeedBuild = PlannerAssetDatabase.TryFindNewerAsset(PlannerAssetDatabase.stateRepresentationAssetTypeNames, lastStateRepresentationBuildTime, ref assetChangedPath);
if (stateRepresentationNeedBuild)
{
Debug.Log($"Rebuilding AI Planner State Representation assembly because {assetChangedPath} is newer");
}
}
else
{
Debug.Log($"Rebuilding AI Planner assemblies because AI Planner State Representation package cannot be found");
}
bool planNeedBuild = !PlannerAssetDatabase.PlansPackageExists();
if (!planNeedBuild)
{
DateTime lastPlanBuildTime = GetAssemblyBuildTime(TypeHelper.PlansQualifier);
planNeedBuild = PlannerAssetDatabase.TryFindNewerAsset(PlannerAssetDatabase.planAssetTypeNames, lastPlanBuildTime, ref assetChangedPath);
if (planNeedBuild)
{
Debug.Log($"Rebuilding AI Plan assembly because {assetChangedPath} is newer");
}
}
else
{
Debug.Log($"Rebuilding AI Planner assemblies because AI Plan package cannot be found");
}
if (stateRepresentationNeedBuild || planNeedBuild)
{
EditorApplication.ExitPlaymode();
try
{
if (Build(stateRepresentationNeedBuild))
{
CompilationPipeline.compilationFinished += context => EditorApplication.EnterPlaymode();
}
}
finally
{
EditorUtility.ClearProgressBar();
}
}
}
}
}
public virtual void TearDown()
{
CleanupFiles();
AssetDatabase.Refresh();
PlannerAssetDatabase.Refresh();
}
