protected virtual void OnSceneGUI()
{
DayNightCycle _target = (DayNightCycle)target;
if (!_target.gameObject.scene.IsValid() || StageUtility.GetMainStage() == null)
{
return;
}
if (_target.sunLight == null || Camera.current == null)
{
return;
}
if (Event.current.type == EventType.Repaint)
{
Handles.color = _target.sunLight.color;
Handles.ArrowHandleCap(
0,
_target.sunLight.transform.position + _target.sunLight.transform.forward,
_target.sunLight.transform.rotation,
Vector3.Distance(Camera.current.transform.position, _target.transform.position) / 5,
EventType.Repaint
);
}
}
public IEnumerator NavMeshSurfacePrefab_WhenEmptyAndInstantiated_InstanceHasEmptyNavMeshData()
{
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath);
var instance = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
Assert.IsNotNull(instance);
instance.name = "Surface" + m_TestCounter + "PrefabInstance";
var instanceSurface = instance.GetComponent <NavMeshSurface>();
Assert.IsTrue(instanceSurface.navMeshData != null, "NavMeshSurface in prefab instance must have NavMeshData.");
AssetDatabase.OpenAsset(prefab);
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>();
NavMeshAssetManager.instance.ClearSurfaces(new Object[] { prefabSurface });
PrefabSavingUtil.SavePrefab(prefabStage);
StageUtility.GoToMainStage();
Assert.IsTrue(instanceSurface.navMeshData == null,
"After the NavMeshSurface in the prefab has been cleared the prefab instance should no longer hold NavMeshData.");
var expectedAreaMask = 1 << k_PrefabDefaultArea;
Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, expectedAreaMask));
#if !KEEP_ARTIFACTS_FOR_INSPECTION
Object.DestroyImmediate(instance);
#endif
yield return(null);
}
static void Place(GameObject go, GameObject parent)
{
if (parent != null)
{
var transform = go.transform;
Undo.SetTransformParent(transform, parent.transform, "Reparenting");
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
transform.localScale = Vector3.one;
go.layer = parent.layer;
if (parent.GetComponent <RectTransform>())
{
ObjectFactory.AddComponent <RectTransform>(go);
}
}
else
{
go.transform.position = Vector3.zero;
StageUtility.PlaceGameObjectInCurrentStage(go); // may change parent
}
// Only at this point do we know the actual parent of the object and can modify its name accordingly.
GameObjectUtility.EnsureUniqueNameForSibling(go);
Undo.SetCurrentGroupName("Create " + go.name);
Selection.activeGameObject = go;
}
public static GameObject CreateNewUI()
{
// Root for the UI
var root = new GameObject("Canvas");
root.layer = LayerMask.NameToLayer(kUILayerName);
Canvas canvas = root.AddComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
root.AddComponent <CanvasScaler>();
root.AddComponent <GraphicRaycaster>();
// Works for all stages.
StageUtility.PlaceGameObjectInCurrentStage(root);
bool customScene = false;
PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (prefabStage != null)
{
root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false);
customScene = true;
}
Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);
// If there is no event system add one...
// No need to place event system in custom scene as these are temporary anyway.
// It can be argued for or against placing it in the user scenes,
// but let's not modify scene user is not currently looking at.
if (!customScene)
{
CreateEventSystem(false);
}
return(root);
}
public IEnumerator Setup()
{
var plane = GameObject.CreatePrimitive(PrimitiveType.Plane);
plane.name = "NavMeshSurface" + (++m_TestCounter) + "Prefab";
var surface = plane.AddComponent <NavMeshSurface>();
surface.collectObjects = CollectObjects.Children;
m_PrefabPath = Path.Combine(m_TempFolder, plane.name + ".prefab");
var planePrefab = PrefabUtility.SaveAsPrefabAsset(plane, m_PrefabPath);
Object.DestroyImmediate(plane);
AssetDatabase.OpenAsset(planePrefab);
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>();
yield return(BakeNavMeshAsync(() => prefabSurface, k_PrefabDefaultArea));
PrefabSavingUtil.SavePrefab(prefabStage);
StageUtility.GoToMainStage();
NavMesh.RemoveAllNavMeshData();
yield return(null);
}
// Helper function that returns a Solver GameObject; preferably a parent of the selection, or other existing Canvas.
private static GameObject GetOrCreateSolverObject()
{
GameObject selectedGo = Selection.activeGameObject;
// Try to find a gameobject that is the selected GO or one if its parents.
ObiSolver solver = (selectedGo != null) ? selectedGo.GetComponentInParent <ObiSolver>() : null;
if (IsValidSolver(solver))
{
return(solver.gameObject);
}
// No solver in selection or its parents? Then use any valid solver.
// We have to find all loaded solvers, not just the ones in main scenes.
ObiSolver[] solverArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType <ObiSolver>();
for (int i = 0; i < solverArray.Length; i++)
{
if (IsValidSolver(solverArray[i]))
{
return(solverArray[i].gameObject);
}
}
// No solver in the scene at all? Then create a new one.
return(CreateNewSolver());
}
protected override void OnEnable()
{
base.OnEnable();
m_PickupAction = (PickupAction)m_Action;
m_EffectProp = serializedObject.FindProperty("m_Effect");
// Collect Pickup Triggers that depend on this Pickup Action.
m_DependentTriggers.Clear();
var pickupTriggers = StageUtility.GetCurrentStageHandle().FindComponentsOfType <PickupTrigger>();
foreach (var trigger in pickupTriggers)
{
if (trigger.GetMode() == PickupTrigger.Mode.SpecificPickups)
{
var specificPickups = trigger.GetSpecificPickupActions();
if (specificPickups.Contains(m_PickupAction))
{
m_DependentTriggers.Add(trigger);
}
}
}
}
static public GameObject CreateNewUI()
{
var root = new GameObject("Canvas");
root.layer = LayerMask.NameToLayer("UI");
Canvas canvas = root.AddComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
root.AddComponent <CanvasScaler>();
root.AddComponent <GraphicRaycaster>();
StageUtility.PlaceGameObjectInCurrentStage(root);
bool customScene = false;
PrefabStage prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (prefabStage != null)
{
root.transform.SetParent(prefabStage.prefabContentsRoot.transform, false);
customScene = true;
}
Undo.RegisterCreatedObjectUndo(root, "Create " + root.name);
if (!customScene)
{
CreateEventSystem(false);
}
return(root);
}
internal void CleanupEditor()
{
bool selectAvatarAsset = StageUtility.GetCurrentStageHandle() == StageUtility.GetMainStageHandle();
m_EditMode = EditMode.Stopping;
DestroyEditor();
ChangeInspectorLock(m_InspectorLocked);
EditorApplication.CallbackFunction CleanUpOnDestroy = null;
CleanUpOnDestroy = () =>
{
// Make sure that we restore the "original" selection if we exit Avatar Editing mode
// from the avatar tooling itself (e.g by clicking done).
if (selectAvatarAsset)
{
SelectAsset();
}
if (!m_CameFromImportSettings)
{
m_EditMode = EditMode.NotEditing;
}
EditorApplication.update -= CleanUpOnDestroy;
};
EditorApplication.update += CleanUpOnDestroy;
// Reset back the Edit Mode specific states (they probably should be better encapsulated)
m_GameObject = null;
m_ModelBones = null;
}
private void OnGUI()
{
this.scroll = EditorGUILayout.BeginScrollView(this.scroll);
var prefabs = Resources.LoadAll("Prefabs/UI/Views");
if (GUILayout.Button("Main scene", GUILayout.Height(40), GUILayout.Width(100)))
{
StageUtility.GoToMainStage();
}
GUILayout.Space(10);
foreach (var item in prefabs)
{
if (item.name.Equals("ExempleScreen"))
{
continue;
}
GUILayout.Space(5);
if (GUILayout.Button(item.name, GUILayout.Height(30), GUILayout.Width(100)))
{
AssetDatabase.OpenAsset(item);
}
}
EditorGUILayout.EndScrollView();
}
// UnityEditor.UI.MenuOptions
public static GameObject GetOrCreateCanvasGameObject()
{
GameObject activeGameObject = Selection.activeGameObject;
Canvas canvas = (!(activeGameObject != null)) ? null : activeGameObject.GetComponentInParent <Canvas>();
GameObject result;
if (SpringGUIMenuOptions.IsValidCanvas(canvas))
{
result = canvas.gameObject;
}
else
{
Canvas[] array = StageUtility.GetCurrentStageHandle().FindComponentsOfType <Canvas>();
for (int i = 0; i < array.Length; i++)
{
if (SpringGUIMenuOptions.IsValidCanvas(array[i]))
{
result = array[i].gameObject;
return(result);
}
}
result = SpringGUIMenuOptions.CreateNewUI();
}
return(result);
}
// UnityEditor.UI.MenuOptions
public static GameObject CreateNewUI()
{
GameObject gameObject = new GameObject("Canvas");
gameObject.layer = LayerMask.NameToLayer("UI");
Canvas canvas = gameObject.AddComponent <Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
gameObject.AddComponent <CanvasScaler>();
gameObject.AddComponent <GraphicRaycaster>();
StageUtility.PlaceGameObjectInCurrentStage(gameObject);
bool flag = false;
PrefabStage currentPrefabStage = PrefabStageUtility.GetCurrentPrefabStage();
if (currentPrefabStage != null)
{
gameObject.transform.SetParent(currentPrefabStage.prefabContentsRoot.transform, false);
flag = true;
}
Undo.RegisterCreatedObjectUndo(gameObject, "Create " + gameObject.name);
if (!flag)
{
SpringGUIMenuOptions.CreateEventSystem(false);
}
return(gameObject);
}
private static bool BelongsToCurrentStage(this GameObject go, PrefabStage prefabStage, StageHandle stageHandleMain)
{
var stageHandleFromObject = StageUtility.GetStageHandle(go);
bool result = prefabStage != null ? (stageHandleFromObject == prefabStage.stageHandle) : (stageHandleFromObject == stageHandleMain);
return(result);
}
private static void OnPrefabStageClosed(PrefabStage prefabStage)
{
if (log)
{
Debug.LogWarning(string.Format("Prefab stage closed, checking NGUI objects | Cameras: {0} | Panels: {1} | Drawcalls: {2}/{3}",
UICamera.list.size, UIPanel.list.Count, UIDrawCall.activeList.size, UIDrawCall.inactiveList.size));
}
CheckNGUIObjects();
// Since no events happened from standpoint of main stage objects, we have force them to update
var stageHandleMain = StageUtility.GetMainStageHandle();
for (int s = 0; s < SceneManager.sceneCount; s++)
{
var sceneFromList = SceneManager.GetSceneAt(s);
if (!sceneFromList.isLoaded)
{
continue;
}
var stageHandleFromList = StageUtility.GetStageHandle(sceneFromList);
if (stageHandleFromList != stageHandleMain)
{
continue;
}
var sceneRootObjects = sceneFromList.GetRootGameObjects();
for (int i = 0; i < sceneRootObjects.Length; i++)
{
FindAndRefreshPanels(sceneRootObjects[i].transform);
}
}
}
void AddCameraToCameraList(Rect rect, ReorderableList list)
{
// Need to do clear the list here otherwise the meu just fills up with more and more entries
validCameras.Clear();
StageHandle stageHandle = StageUtility.GetStageHandle(camera.gameObject);
var allCameras = stageHandle.FindComponentsOfType <Camera>();
foreach (var camera in allCameras)
{
var component = camera.gameObject.GetComponent <UniversalAdditionalCameraData>();
if (component != null)
{
if (validCameraTypes.Contains(component.renderType))
{
validCameras.Add(camera);
}
}
}
var names = new GUIContent[validCameras.Count];
for (int i = 0; i < validCameras.Count; ++i)
{
names[i] = new GUIContent((i + 1) + " " + validCameras[i].name);
}
if (!validCameras.Any())
{
names = new GUIContent[1];
names[0] = new GUIContent("No Overlay Cameras exist.");
}
EditorUtility.DisplayCustomMenu(rect, names, -1, AddCameraToCameraListMenuSelected, null);
}
public override void OnToolGUI(EditorWindow window)
{
var view = window as SceneView;
if (!view || !Selection.activeTransform || Tools.s_Hidden)
{
return;
}
if (!StageUtility.IsGameObjectRenderedByCamera(Selection.activeTransform.gameObject, Camera.current))
{
return;
}
bool isStatic = (!Tools.s_Hidden && EditorApplication.isPlaying && GameObjectUtility.ContainsStatic(Selection.gameObjects));
using (new EditorGUI.DisabledScope(isStatic))
{
Vector3 handlePosition = Tools.handlePosition;
ToolGUI(view, handlePosition, isStatic);
Handles.ShowStaticLabelIfNeeded(handlePosition);
}
}
static void OnPrefabStageClosing(PrefabStage stage)
{
// When closing, we want the bricks that are in the scene
var bricks = StageUtility.GetMainStageHandle().FindComponentsOfType <Brick>();
SetShowBricks(showAllBricks, bricks);
}
public IEnumerator NavMeshSurfacePrefab_AfterClearedInstanceAppliedBack_HasEmptyData()
{
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath);
var instance = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
Assert.IsNotNull(instance);
instance.name = "Surface" + m_TestCounter + "PrefabInstance";
TestNavMeshExistsAloneAtPosition(k_PrefabDefaultArea, Vector3.zero);
var instanceSurface = instance.GetComponent <NavMeshSurface>();
Assert.IsNotNull(instanceSurface);
NavMeshAssetManager.instance.ClearSurfaces(new Object[] { instanceSurface });
var expectedAreaMask = 1 << k_PrefabDefaultArea;
Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, expectedAreaMask));
PrefabUtility.ApplyPrefabInstance(instance, InteractionMode.AutomatedAction);
AssetDatabase.OpenAsset(prefab);
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>();
Assert.IsTrue(prefabSurface.navMeshData == null,
"Prefab should have empty NavMeshData when empty data has been applied back from the instance.");
StageUtility.GoToMainStage();
#if !KEEP_ARTIFACTS_FOR_INSPECTION
Object.DestroyImmediate(instance);
#endif
yield return(null);
}
static void CreateTerrain(MenuCommand menuCommand)
{
// Create the storage for the terrain in the project
// (So we can reuse it in multiple scenes)
TerrainData terrainData = new TerrainData();
const int size = 1025;
terrainData.heightmapResolution = size;
terrainData.size = new Vector3(1000, 600, 1000);
terrainData.heightmapResolution = 512;
terrainData.baseMapResolution = 1024;
terrainData.SetDetailResolution(1024, terrainData.detailResolutionPerPatch);
AssetDatabase.CreateAsset(terrainData, AssetDatabase.GenerateUniqueAssetPath("Assets/New Terrain.asset"));
var parent = menuCommand.context as GameObject;
GameObject terrain = Terrain.CreateTerrainGameObject(terrainData);
terrain.name = "Terrain";
GameObjectUtility.SetParentAndAlign(terrain, parent);
StageUtility.PlaceGameObjectInCurrentStage(terrain);
GameObjectUtility.EnsureUniqueNameForSibling(terrain);
Selection.activeObject = terrain;
Undo.RegisterCreatedObjectUndo(terrain, "Create terrain");
}
internal static void CutGO()
{
m_GOCutboard = Selection.transforms;
m_SelectedObjects = Selection.objects;
// Selection.transform does not provide correct list order, so we have to do it manually
m_GOCutboard = m_GOCutboard.ToList().OrderBy(g => Array.IndexOf(m_SelectedObjects, g.gameObject)).ToArray();
// Return if nothing selected
if (!hasCutboardData)
{
return;
}
m_StageCutWasPerformedIn = StageUtility.GetStage(m_GOCutboard[0].gameObject);
// If cut gameObject is prefab, get its root transform
for (int i = 0; i < m_GOCutboard.Length; i++)
{
if (PrefabUtility.GetPrefabAssetType(m_GOCutboard[i].gameObject) != PrefabAssetType.NotAPrefab)
{
m_GOCutboard[i] = PrefabUtility.GetOutermostPrefabInstanceRoot(m_GOCutboard[i].gameObject)?.transform;
}
}
// Cut gameObjects should be visually marked as cut, so adding them to the hashset
m_CutAffectedGOs.Clear();
foreach (var item in m_GOCutboard)
{
m_CutAffectedGOs.Add(item);
AddChildrenToHashset(item);
}
// Clean pasteboard when cutting gameObjects
Unsupported.ClearPasteboard();
}
protected static System.Collections.Generic.IEnumerable <T> GetObjectsForLightingExplorer <T>() where T : UnityEngine.Component
{
var objects = Resources.FindObjectsOfTypeAll <T>().Where((T obj) =>
{
return(!EditorUtility.IsPersistent(obj) && !obj.hideFlags.HasFlag(HideFlags.HideInHierarchy) && !obj.hideFlags.HasFlag(HideFlags.HideAndDontSave));
});
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
// No prefab mode.
if (prefabStage == null)
{
// Return all object instances in the scene including prefab instances, but not those that are in prefab assets.
return(objects);
}
// In Context prefab mode with Normal rendering mode
else if (prefabStage.mode == PrefabStage.Mode.InContext &&
StageNavigationManager.instance.contextRenderMode == StageUtility.ContextRenderMode.Normal)
{
// Return all object instances in the scene and objects in the opened prefab asset, but not objects in the opened prefab instance.
return(objects.Where((T obj) =>
{
return !StageUtility.IsPrefabInstanceHiddenForInContextEditing(obj.gameObject);
}));
}
// All remaining cases, e.g. In Context with Hidden or GrayedOut rendering mode, or In Isolation prefab mode.
else
{
// Return only objects in the opened prefab asset.
return(objects.Where((T obj) =>
{
return EditorSceneManager.IsPreviewSceneObject(obj);
}));
}
}
private static void CreateEventSystem(bool select, GameObject parent)
{
StageHandle stage = parent == null?StageUtility.GetCurrentStageHandle() : StageUtility.GetStageHandle(parent);
var esys = stage.FindComponentOfType <EventSystem>();
if (esys == null)
{
var eventSystem = new GameObject("EventSystem");
if (parent == null)
{
StageUtility.PlaceGameObjectInCurrentStage(eventSystem);
}
else
{
GameObjectUtility.SetParentAndAlign(eventSystem, parent);
}
esys = eventSystem.AddComponent <EventSystem>();
eventSystem.AddComponent <StandaloneInputModule>();
Undo.RegisterCreatedObjectUndo(eventSystem, "Create " + eventSystem.name);
}
if (select && esys != null)
{
Selection.activeGameObject = esys.gameObject;
}
}
void SaveCameraState(SceneView sceneView, Stage stage)
{
if (stage == null)
{
return;
}
// Allows stage to override which stage should be used for saving the state.
// Useful for Prefab Mode in Context where we want to save the context scene state.
Stage contextStage = stage.GetContextStage();
if (contextStage == null)
{
return;
}
string key = StageUtility.CreateWindowAndStageIdentifier(sceneView.windowGUID, contextStage);
var state = m_StateCache.GetState(key);
if (state == null)
{
state = new SceneViewCameraState();
}
state.SaveStateFromSceneView(sceneView);
m_StateCache.SetState(key, state);
}
/// <summary>
/// Returns true if the given object is being edited in prefab mode.
/// </summary>
/// <param name="obj">Object to check</param>
/// <returns>True if object is in prefab mode</returns>
public static bool IsEditingInPrefabMode(GameObject obj)
{
#if UNITY_EDITOR
if (EditorUtility.IsPersistent(obj))
{
// Stored on disk (some sort of prefab)
return true;
}
else
{
#if UNITY_2018_3_OR_NEWER
// If not persistent, check if in prefab stage
if (StageUtility.GetMainStageHandle() != StageUtility.GetStageHandle(obj))
{
var stage = PrefabStageUtility.GetPrefabStage(obj);
if (stage != null)
{
return true;
}
}
#endif
}
#endif
return false;
}
public static OpenSceneResult OpenSceneWithSavePrompt(string path, bool activate = true)
{
#if UNITY_2018_3_OR_NEWER
StageUtility.GoToMainStage();
#endif
var result = new OpenSceneResult();
var targetScene = SceneManager.GetSceneByPath(path);
if (targetScene == SceneManager.GetActiveScene())
{
result.scene = targetScene;
result.success = true;
result.scenePath = path;
return(result);
}
if (!SaveCurrentModifiedScenesIfUserWantsTo())
{
return(result);
}
return(OpenScene(path, activate));
}
// Helper function that returns a Canvas GameObject; preferably a parent of the selection, or other existing Canvas.
public static GameObject GetOrCreateCanvasGameObject()
{
GameObject selectedGo = Selection.activeGameObject;
// Try to find a gameobject that is the selected GO or one if its parents.
Canvas canvas = (selectedGo != null) ? selectedGo.GetComponentInParent <Canvas>() : null;
if (IsValidCanvas(canvas))
{
return(canvas.gameObject);
}
// No canvas in selection or its parents? Then use any valid canvas.
// We have to find all loaded Canvases, not just the ones in main scenes.
Canvas[] canvasArray = StageUtility.GetCurrentStageHandle().FindComponentsOfType <Canvas>();
for (int i = 0; i < canvasArray.Length; i++)
{
if (IsValidCanvas(canvasArray[i]))
{
return(canvasArray[i].gameObject);
}
}
// No canvas in the scene at all? Then create a new one.
return(CreateNewUI());
}
public override List <Point2> Selecting(Unit _user, KeyCode _key)
{
LightPanelPopper.Instance.AllActiveOff();
List <Point2> returnPoints = new List <Point2>();
var redPoint = RightClickRayShot.GetMouseRayHitObject <BlockPointGetter>();
if (redPoint == null)
{
return(returnPoints);
}
var points = StageUtility.GetCrossPoint(redPoint.point, effectRange);
foreach (var p in points)
{
LightPanelPopper.Instance.ActiveOn(p, Color.red);
}
var pointGetter = RightClickRayShot.GetMouseRayHitObject <BlockPointGetter>(_key);
if (pointGetter != null)
{
returnPoints = StageUtility.GetCrossPoint(pointGetter.point, effectRange);
}
return(returnPoints);
}
public IEnumerator NavMeshSurfacePrefab_AfterBakingInPrefabMode_LeavesMainSceneUntouched()
{
Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero));
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath);
AssetDatabase.OpenAsset(prefab);
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
Assert.IsNotNull(prefabStage);
Assert.IsNotNull(prefabStage.prefabContentsRoot);
var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>();
var initialPrefabNavMeshData = prefabSurface.navMeshData;
yield return(BakeNavMeshAsync(() => prefabSurface, k_RedArea));
Assert.AreNotSame(initialPrefabNavMeshData, prefabSurface.navMeshData);
PrefabSavingUtil.SavePrefab(prefabStage);
StageUtility.GoToMainStage();
Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, NavMesh.AllAreas, 0, 1000.0f));
yield return(null);
}
public List <Point2> GetCanMovePoint(Unit _unit)
{
List <Point2> standingList = CompornentUtility.FindCompornentOnScene <UnitManager>().GetStandingPoints();
List <Point2> canMovePoints = new List <Point2>();
Point2 pivot = _unit.pos;
int moveRange = _unit.GetUnitStatus.moveRange;
var crossPoints = StageUtility.GetCrossPoint(pivot, moveRange);
foreach (var point in crossPoints)
{
//既にunitがいた場合continue
if (standingList.Contains(point))
{
continue;
}
//たどり着けるかチェック
var pathList = pathCreater.GetPath(_unit.pos, point, _unit.GetUnitStatus.stepHeight);
if (pathList == null)
{
continue;
}
//unitの設定歩数で行けるかチェック
if (pathList.Count > moveRange)
{
continue;
}
canMovePoints.Add(point);
}
return(canMovePoints);
}
public IEnumerator NavMeshSurfacePrefab_WhenInstanceCleared_PrefabKeepsNavMeshData()
{
var prefab = AssetDatabase.LoadAssetAtPath <GameObject>(m_PrefabPath);
var instance = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
Assert.IsNotNull(instance);
instance.name = "Surface" + m_TestCounter + "PrefabInstance";
var instanceSurface = instance.GetComponent <NavMeshSurface>();
Assert.IsNotNull(instanceSurface);
var initialPrefabNavMeshData = instanceSurface.navMeshData;
NavMeshAssetManager.instance.ClearSurfaces(new Object[] { instanceSurface });
var expectedAreaMask = 1 << k_PrefabDefaultArea;
Assert.IsFalse(HasNavMeshAtPosition(Vector3.zero, expectedAreaMask));
AssetDatabase.OpenAsset(prefab);
var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
var prefabSurface = prefabStage.prefabContentsRoot.GetComponent <NavMeshSurface>();
var prefabNavMeshData = prefabSurface.navMeshData;
Assert.IsTrue(prefabNavMeshData != null,
"NavMeshSurface in the prefab must still have NavMeshData even though the instance was cleared.");
Assert.AreSame(initialPrefabNavMeshData, prefabNavMeshData);
StageUtility.GoToMainStage();
#if !KEEP_ARTIFACTS_FOR_INSPECTION
Object.DestroyImmediate(instance);
#endif
yield return(null);
}
public override IEnumerator InitializeAsync(SceneUICtrl sceneUICtrl)
{
yield return StartCoroutine (base.InitializeAsync (sceneUICtrl));
uiCtrl = base._sceneUICtrl as StageSelectUICtrl;
stageUtility = Utilities.stageUtility;
}
