qoralstmd6825/TigerProject
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

콤보, 체력 감소 및 흡수, 이동 로직 변경

Browse Source
This commit is contained in:
백민승_crow 2026-01-28 16:39:18 +09:00
parent 0d50b5d99d
commit 973d9f0eb0
90 changed files with 882 additions and 5018 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Assets/Block/DestructibleBlock.cs
View File

@ -18,7 +18,7 @@ public class DestructibleBlock : Entity
if (collision.gameObject.CompareTag("Player"))
{
Player player = collision.gameObject.GetComponent<Player>();
if (player != null && player.IsDashing())
if (player != null && player.IsDashing)
{
Die();
}

2
Assets/InputSystem_Actions.inputactions
View File

@ -21,7 +21,7 @@
"id": "1bf656ea-a644-405e-ad96-116a21f4380e",
"expectedControlType": "",
"processors": "",
"interactions": "",
"interactions": "Press(behavior=2)",
"initialStateCheck": false
},
{

8
Assets/NavMeshComponents/Editor.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: d5b48dfc36243e144ab116b1e7eb573b
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

29
Assets/NavMeshComponents/Editor/AgentOverride2dEditor.cs
View File

@ -1,29 +0,0 @@
using UnityEditor;
namespace NavMeshPlus.Extensions.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(AgentOverride2d))]
internal class AgentOverride2dEditor : Editor
{
//SerializedProperty m_OverrideByGrid;
//SerializedProperty m_UseMeshPrefab;
//SerializedProperty m_CompressBounds;
//SerializedProperty m_OverrideVector;
void OnEnable()
{
//m_OverrideByGrid = serializedObject.FindProperty("m_OverrideByGrid");
//m_UseMeshPrefab = serializedObject.FindProperty("m_UseMeshPrefab");
//m_CompressBounds = serializedObject.FindProperty("m_CompressBounds");
//m_OverrideVector = serializedObject.FindProperty("m_OverrideVector");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var agent = target as AgentOverride2d;
EditorGUILayout.LabelField("Agent Override", agent.agentOverride?.GetType().Name);
}
}
}

11
Assets/NavMeshComponents/Editor/AgentOverride2dEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 86cc6cf350c6f62469395948494f0945
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

82
Assets/NavMeshComponents/Editor/CollectSources2dEditor.cs
View File

@ -1,82 +0,0 @@
using UnityEngine;
using UnityEditor;
namespace NavMeshPlus.Extensions.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(CollectSources2d))]
internal class CollectSources2dEditor: Editor
{
SerializedProperty m_OverrideByGrid;
SerializedProperty m_UseMeshPrefab;
SerializedProperty m_CompressBounds;
SerializedProperty m_OverrideVector;
void OnEnable()
{
m_OverrideByGrid = serializedObject.FindProperty("m_OverrideByGrid");
m_UseMeshPrefab = serializedObject.FindProperty("m_UseMeshPrefab");
m_CompressBounds = serializedObject.FindProperty("m_CompressBounds");
m_OverrideVector = serializedObject.FindProperty("m_OverrideVector");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var surf = target as CollectSources2d;
EditorGUILayout.PropertyField(m_OverrideByGrid);
using (new EditorGUI.DisabledScope(!m_OverrideByGrid.boolValue))
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_UseMeshPrefab);
EditorGUI.indentLevel--;
}
EditorGUILayout.PropertyField(m_CompressBounds);
EditorGUILayout.PropertyField(m_OverrideVector);
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
using (new EditorGUI.DisabledScope(Application.isPlaying))
{
GUILayout.BeginHorizontal();
if (GUILayout.Button(new GUIContent("Rotate Surface to XY", "Rotates Surface along XY plane to face toward standard 2d camera.")))
{
foreach (CollectSources2d item in targets)
{
item.transform.rotation = Quaternion.Euler(-90f, 0f, 0f);
}
}
#if UNITY_6000_0_OR_NEWER
GUILayout.EndHorizontal();
foreach (CollectSources2d navSurface in targets)
{
if (!Mathf.Approximately(navSurface.transform.eulerAngles.x, 270f))
{
EditorGUILayout.HelpBox("NavMeshSurface is not rotated respectively to (x-90;y0;z0). Apply rotation unless intended.", MessageType.Warning);
}
}
#else
if (GUILayout.Button(new GUIContent("Tilt Surface", "If your agent get stuck on vertical movement it may help to solve the issue. This will tilt Surface to -89.98. It may impact baking and navigation.")))
{
foreach (CollectSources2d item in targets)
{
item.transform.rotation = Quaternion.Euler(-89.98f, 0f, 0f);
}
}
GUILayout.EndHorizontal();
foreach (CollectSources2d navSurface in targets)
{
if (!Mathf.Approximately(navSurface.transform.eulerAngles.x, 270.0198f) && !Mathf.Approximately(navSurface.transform.eulerAngles.x, 270f))
{
EditorGUILayout.HelpBox("NavMeshSurface is not rotated respectively to (x-90;y0;z0). Apply rotation unless intended.", MessageType.Warning);
}
}
#endif
}
}
}
}

11
Assets/NavMeshComponents/Editor/CollectSources2dEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 3fc821cbc11a48745bc9edea6bfda007
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

40
Assets/NavMeshComponents/Editor/CollectSourcesCache2dEditor.cs
View File

@ -1,40 +0,0 @@
using UnityEngine;
using UnityEditor;
namespace NavMeshPlus.Extensions.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(CollectSourcesCache2d))]
internal class CollectSourcesCache2dEditor : Editor
{
public override void OnInspectorGUI()
{
serializedObject.Update();
var surf = target as CollectSourcesCache2d;
serializedObject.ApplyModifiedProperties();
using (new EditorGUI.DisabledScope(!Application.isPlaying))
{
GUILayout.BeginHorizontal();
GUILayout.Label("Sources:");
if (Application.isPlaying)
{
GUILayout.Label(surf.SourcesCount.ToString());
GUILayout.Label("Cached:");
GUILayout.Label(surf.CahcheCount.ToString());
}
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
GUILayout.Label("Actions:");
if (GUILayout.Button("Update Mesh"))
{
surf.UpdateNavMesh();
}
GUILayout.EndHorizontal();
}
}
}
}

11
Assets/NavMeshComponents/Editor/CollectSourcesCache2dEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 3616009fd1ab770409e0321881372357
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

21
Assets/NavMeshComponents/Editor/NavMeshAgentAttributePropertyDrawer.cs
View File

@ -1,21 +0,0 @@
using NavMeshPlus.Components.Editors;
using UnityEditor;
using UnityEngine;
//***********************************************************************************
// Contributed by author jl-randazzo github.com/jl-randazzo
//***********************************************************************************
namespace NavMeshPlus.Extensions.Editors
{
[CustomPropertyDrawer(typeof(NavMeshAgentAttribute))]
public class NavMeshAgentAttributePropertyDrawer : PropertyDrawer
{
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
NavMeshComponentsGUIUtility.AgentTypePopup(position, label.text, property);
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) => NavMeshComponentsGUIUtility.IsAgentSelectionValid(property) ? 20 : 40;
}
}

11
Assets/NavMeshComponents/Editor/NavMeshAgentAttributePropertyDrawer.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 1d43a96ce80684449a8b4eee132e5d47
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

20
Assets/NavMeshComponents/Editor/NavMeshAreaAttributePropertyDrawer.cs
View File

@ -1,20 +0,0 @@
using NavMeshPlus.Components.Editors;
using UnityEditor;
using UnityEngine;
//***********************************************************************************
// Contributed by author jl-randazzo github.com/jl-randazzo
//***********************************************************************************
namespace NavMeshPlus.Extensions.Editors
{
[CustomPropertyDrawer(typeof(NavMeshAreaAttribute))]
public class NavMeshAreaAttributePropertyDrawer : PropertyDrawer
{
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
NavMeshComponentsGUIUtility.AreaPopup(position, label.text, property);
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label) => 20;
}
}

11
Assets/NavMeshComponents/Editor/NavMeshAreaAttributePropertyDrawer.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 51136e93cfad4dd7883ae6248247b6a2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

334
Assets/NavMeshComponents/Editor/NavMeshAssetManager.cs
View File

@ -1,334 +0,0 @@
using System.Collections.Generic;
using System.IO;
using UnityEditor.SceneManagement;
using UnityEngine.AI;
using UnityEngine;
using UnityEditor;
namespace NavMeshPlus.Components.Editors
{
public class NavMeshAssetManager : ScriptableSingleton<NavMeshAssetManager>
{
internal struct AsyncBakeOperation
{
public NavMeshSurface surface;
public NavMeshData bakeData;
public AsyncOperation bakeOperation;
}
List<AsyncBakeOperation> m_BakeOperations = new List<AsyncBakeOperation>();
internal List<AsyncBakeOperation> GetBakeOperations() { return m_BakeOperations; }
struct SavedPrefabNavMeshData
{
public NavMeshSurface surface;
public NavMeshData navMeshData;
}
List<SavedPrefabNavMeshData> m_PrefabNavMeshDataAssets = new List<SavedPrefabNavMeshData>();
static string GetAndEnsureTargetPath(NavMeshSurface surface)
{
// Create directory for the asset if it does not exist yet.
var activeScenePath = surface.gameObject.scene.path;
var targetPath = "Assets";
if (!string.IsNullOrEmpty(activeScenePath))
{
targetPath = Path.Combine(Path.GetDirectoryName(activeScenePath), Path.GetFileNameWithoutExtension(activeScenePath));
}
else
{
var prefabStage = PrefabStageUtility.GetPrefabStage(surface.gameObject);
var isPartOfPrefab = prefabStage != null && prefabStage.IsPartOfPrefabContents(surface.gameObject);
if (isPartOfPrefab)
{
#if UNITY_2020_1_OR_NEWER
var assetPath = prefabStage.assetPath;
#else
var assetPath = prefabStage.prefabAssetPath;
#endif
if (!string.IsNullOrEmpty(assetPath))
{
var prefabDirectoryName = Path.GetDirectoryName(assetPath);
if (!string.IsNullOrEmpty(prefabDirectoryName))
targetPath = prefabDirectoryName;
}
}
}
if (!Directory.Exists(targetPath))
Directory.CreateDirectory(targetPath);
return targetPath;
}
static void CreateNavMeshAsset(NavMeshSurface surface)
{
var targetPath = GetAndEnsureTargetPath(surface);
var combinedAssetPath = Path.Combine(targetPath, "NavMesh-" + surface.name + ".asset");
combinedAssetPath = AssetDatabase.GenerateUniqueAssetPath(combinedAssetPath);
AssetDatabase.CreateAsset(surface.navMeshData, combinedAssetPath);
}
NavMeshData GetNavMeshAssetToDelete(NavMeshSurface navSurface)
{
if (PrefabUtility.IsPartOfPrefabInstance(navSurface) && !PrefabUtility.IsPartOfModelPrefab(navSurface))
{
// Don't allow deleting the asset belonging to the prefab parent
var parentSurface = PrefabUtility.GetCorrespondingObjectFromSource(navSurface) as NavMeshSurface;
if (parentSurface && navSurface.navMeshData == parentSurface.navMeshData)
return null;
}
// Do not delete the NavMeshData asset referenced from a prefab until the prefab is saved
var prefabStage = PrefabStageUtility.GetPrefabStage(navSurface.gameObject);
var isPartOfPrefab = prefabStage != null && prefabStage.IsPartOfPrefabContents(navSurface.gameObject);
if (isPartOfPrefab && IsCurrentPrefabNavMeshDataStored(navSurface))
return null;
return navSurface.navMeshData;
}
void ClearSurface(NavMeshSurface navSurface)
{
var hasNavMeshData = navSurface.navMeshData != null;
StoreNavMeshDataIfInPrefab(navSurface);
var assetToDelete = GetNavMeshAssetToDelete(navSurface);
navSurface.RemoveData();
if (hasNavMeshData)
{
SetNavMeshData(navSurface, null);
EditorSceneManager.MarkSceneDirty(navSurface.gameObject.scene);
}
if (assetToDelete)
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(assetToDelete));
}
public void StartBakingSurfaces(UnityEngine.Object[] surfaces)
{
// Remove first to avoid double registration of the callback
EditorApplication.update -= UpdateAsyncBuildOperations;
EditorApplication.update += UpdateAsyncBuildOperations;
foreach (NavMeshSurface surf in surfaces)
{
StoreNavMeshDataIfInPrefab(surf);
var oper = new AsyncBakeOperation();
oper.bakeData = InitializeBakeData(surf);
oper.bakeOperation = surf.UpdateNavMesh(oper.bakeData);
oper.surface = surf;
m_BakeOperations.Add(oper);
}
}
static NavMeshData InitializeBakeData(NavMeshSurface surface)
{
var emptySources = new List<NavMeshBuildSource>();
var emptyBounds = new Bounds();
return UnityEngine.AI.NavMeshBuilder.BuildNavMeshData(surface.GetBuildSettings(), emptySources, emptyBounds
, surface.transform.position, surface.transform.rotation);
}
void UpdateAsyncBuildOperations()
{
foreach (var oper in m_BakeOperations)
{
if (oper.surface == null || oper.bakeOperation == null)
continue;
if (oper.bakeOperation.isDone)
{
var surface = oper.surface;
var delete = GetNavMeshAssetToDelete(surface);
if (delete != null)
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(delete));
surface.RemoveData();
SetNavMeshData(surface, oper.bakeData);
if (surface.isActiveAndEnabled)
surface.AddData();
CreateNavMeshAsset(surface);
EditorSceneManager.MarkSceneDirty(surface.gameObject.scene);
}
}
m_BakeOperations.RemoveAll(o => o.bakeOperation == null || o.bakeOperation.isDone);
if (m_BakeOperations.Count == 0)
EditorApplication.update -= UpdateAsyncBuildOperations;
}
public bool IsSurfaceBaking(NavMeshSurface surface)
{
if (surface == null)
return false;
foreach (var oper in m_BakeOperations)
{
if (oper.surface == null || oper.bakeOperation == null)
continue;
if (oper.surface == surface)
return true;
}
return false;
}
public void ClearSurfaces(UnityEngine.Object[] surfaces)
{
foreach (NavMeshSurface s in surfaces)
ClearSurface(s);
}
static void SetNavMeshData(NavMeshSurface navSurface, NavMeshData navMeshData)
{
var so = new SerializedObject(navSurface);
var navMeshDataProperty = so.FindProperty("m_NavMeshData");
navMeshDataProperty.objectReferenceValue = navMeshData;
so.ApplyModifiedPropertiesWithoutUndo();
}
void StoreNavMeshDataIfInPrefab(NavMeshSurface surfaceToStore)
{
var prefabStage = PrefabStageUtility.GetPrefabStage(surfaceToStore.gameObject);
var isPartOfPrefab = prefabStage != null && prefabStage.IsPartOfPrefabContents(surfaceToStore.gameObject);
if (!isPartOfPrefab)
return;
// check if data has already been stored for this surface
foreach (var storedAssetInfo in m_PrefabNavMeshDataAssets)
if (storedAssetInfo.surface == surfaceToStore)
return;
if (m_PrefabNavMeshDataAssets.Count == 0)
{
PrefabStage.prefabSaving -= DeleteStoredNavMeshDataAssetsForOwnedSurfaces;
PrefabStage.prefabSaving += DeleteStoredNavMeshDataAssetsForOwnedSurfaces;
PrefabStage.prefabStageClosing -= ForgetUnsavedNavMeshDataChanges;
PrefabStage.prefabStageClosing += ForgetUnsavedNavMeshDataChanges;
}
var isDataOwner = true;
if (PrefabUtility.IsPartOfPrefabInstance(surfaceToStore) && !PrefabUtility.IsPartOfModelPrefab(surfaceToStore))
{
var basePrefabSurface = PrefabUtility.GetCorrespondingObjectFromSource(surfaceToStore) as NavMeshSurface;
isDataOwner = basePrefabSurface == null || surfaceToStore.navMeshData != basePrefabSurface.navMeshData;
}
m_PrefabNavMeshDataAssets.Add(new SavedPrefabNavMeshData { surface = surfaceToStore, navMeshData = isDataOwner ? surfaceToStore.navMeshData : null });
}
bool IsCurrentPrefabNavMeshDataStored(NavMeshSurface surface)
{
if (surface == null)
return false;
foreach (var storedAssetInfo in m_PrefabNavMeshDataAssets)
{
if (storedAssetInfo.surface == surface)
return storedAssetInfo.navMeshData == surface.navMeshData;
}
return false;
}
void DeleteStoredNavMeshDataAssetsForOwnedSurfaces(GameObject gameObjectInPrefab)
{
// Debug.LogFormat("DeleteStoredNavMeshDataAsset() when saving prefab {0}", gameObjectInPrefab.name);
var surfaces = gameObjectInPrefab.GetComponentsInChildren<NavMeshSurface>(true);
foreach (var surface in surfaces)
DeleteStoredPrefabNavMeshDataAsset(surface);
}
void DeleteStoredPrefabNavMeshDataAsset(NavMeshSurface surface)
{
for (var i = m_PrefabNavMeshDataAssets.Count - 1; i >= 0; i--)
{
var storedAssetInfo = m_PrefabNavMeshDataAssets[i];
if (storedAssetInfo.surface == surface)
{
var storedNavMeshData = storedAssetInfo.navMeshData;
if (storedNavMeshData != null && storedNavMeshData != surface.navMeshData)
{
var assetPath = AssetDatabase.GetAssetPath(storedNavMeshData);
AssetDatabase.DeleteAsset(assetPath);
}
m_PrefabNavMeshDataAssets.RemoveAt(i);
break;
}
}
if (m_PrefabNavMeshDataAssets.Count == 0)
{
PrefabStage.prefabSaving -= DeleteStoredNavMeshDataAssetsForOwnedSurfaces;
PrefabStage.prefabStageClosing -= ForgetUnsavedNavMeshDataChanges;
}
}
void ForgetUnsavedNavMeshDataChanges(PrefabStage prefabStage)
{
// Debug.Log("On prefab closing - forget about this object's surfaces and stop caring about prefab saving");
if (prefabStage == null)
return;
var allSurfacesInPrefab = prefabStage.prefabContentsRoot.GetComponentsInChildren<NavMeshSurface>(true);
NavMeshSurface surfaceInPrefab = null;
var index = 0;
do
{
if (allSurfacesInPrefab.Length > 0)
surfaceInPrefab = allSurfacesInPrefab[index];
for (var i = m_PrefabNavMeshDataAssets.Count - 1; i >= 0; i--)
{
var storedPrefabInfo = m_PrefabNavMeshDataAssets[i];
if (storedPrefabInfo.surface == null)
{
// Debug.LogFormat("A surface from the prefab got deleted after it has baked a new NavMesh but it hasn't saved it. Now the unsaved asset gets deleted. ({0})", storedPrefabInfo.navMeshData);
// surface got deleted, thus delete its initial NavMeshData asset
if (storedPrefabInfo.navMeshData != null)
{
var assetPath = AssetDatabase.GetAssetPath(storedPrefabInfo.navMeshData);
AssetDatabase.DeleteAsset(assetPath);
}
m_PrefabNavMeshDataAssets.RemoveAt(i);
}
else if (surfaceInPrefab != null && storedPrefabInfo.surface == surfaceInPrefab)
{
//Debug.LogFormat("The surface {0} from the prefab was storing the original navmesh data and now will be forgotten", surfaceInPrefab);
var baseSurface = PrefabUtility.GetCorrespondingObjectFromSource(surfaceInPrefab) as NavMeshSurface;
if (baseSurface == null || surfaceInPrefab.navMeshData != baseSurface.navMeshData)
{
var assetPath = AssetDatabase.GetAssetPath(surfaceInPrefab.navMeshData);
AssetDatabase.DeleteAsset(assetPath);
//Debug.LogFormat("The surface {0} from the prefab has baked new NavMeshData but did not save this change so the asset has been now deleted. ({1})",
// surfaceInPrefab, assetPath);
}
m_PrefabNavMeshDataAssets.RemoveAt(i);
}
}
} while (++index < allSurfacesInPrefab.Length);
if (m_PrefabNavMeshDataAssets.Count == 0)
{
PrefabStage.prefabSaving -= DeleteStoredNavMeshDataAssetsForOwnedSurfaces;
PrefabStage.prefabStageClosing -= ForgetUnsavedNavMeshDataChanges;
}
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshAssetManager.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 0d969266144f4fb47be21604dd1e7900
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

276
Assets/NavMeshComponents/Editor/NavMeshComponentsGUIUtility.cs
View File

@ -1,276 +0,0 @@
using UnityEditor;
using UnityEditor.AI;
using UnityEngine;
using UnityEngine.AI;
namespace NavMeshPlus.Components.Editors
{
public static class NavMeshComponentsGUIUtility
{
public static void AreaPopup(Rect rect, string labelName, SerializedProperty areaProperty)
{
var areaIndex = -1;
var areaNames = NavMesh.GetAreaNames();
for (var i = 0; i < areaNames.Length; i++)
{
var areaValue = NavMesh.GetAreaFromName(areaNames[i]);
if (areaValue == areaProperty.intValue)
areaIndex = i;
}
ArrayUtility.Add(ref areaNames, "");
ArrayUtility.Add(ref areaNames, "Open Area Settings...");
EditorGUI.BeginProperty(rect, GUIContent.none, areaProperty);
EditorGUI.BeginChangeCheck();
areaIndex = EditorGUI.Popup(rect, labelName, areaIndex, areaNames);
if (EditorGUI.EndChangeCheck())
{
if (areaIndex >= 0 && areaIndex < areaNames.Length - 2)
areaProperty.intValue = NavMesh.GetAreaFromName(areaNames[areaIndex]);
else if (areaIndex == areaNames.Length - 1)
NavMeshEditorHelpers.OpenAreaSettings();
}
EditorGUI.EndProperty();
}
public static bool IsAgentSelectionValid(SerializedProperty agentTypeID)
{
var count = NavMesh.GetSettingsCount();
for (var i = 0; i < count; i++)
{
var id = NavMesh.GetSettingsByIndex(i).agentTypeID;
var name = NavMesh.GetSettingsNameFromID(id);
if (id == agentTypeID.intValue)
return true;
}
return false;
}
public static void AgentTypePopup(Rect rect, string labelName, SerializedProperty agentTypeID)
{
var index = -1;
var count = NavMesh.GetSettingsCount();
var agentTypeNames = new string[count + 2];
for (var i = 0; i < count; i++)
{
var id = NavMesh.GetSettingsByIndex(i).agentTypeID;
var name = NavMesh.GetSettingsNameFromID(id);
agentTypeNames[i] = name;
if (id == agentTypeID.intValue)
index = i;
}
agentTypeNames[count] = "";
agentTypeNames[count + 1] = "Open Agent Settings...";
bool validAgentType = index != -1;
if (!validAgentType)
{
Rect warningRect = rect;
warningRect.height *= .5f;
warningRect.y += warningRect.height;
EditorGUI.HelpBox(warningRect, "Agent Type invalid.", MessageType.Warning);
rect.height *= .5f;
}
EditorGUI.BeginProperty(rect, GUIContent.none, agentTypeID);
EditorGUI.BeginChangeCheck();
index = EditorGUI.Popup(rect, labelName, index, agentTypeNames);
if (EditorGUI.EndChangeCheck())
{
if (index >= 0 && index < count)
{
var id = NavMesh.GetSettingsByIndex(index).agentTypeID;
agentTypeID.intValue = id;
}
else if (index == count + 1)
{
NavMeshEditorHelpers.OpenAgentSettings(-1);
}
}
EditorGUI.EndProperty();
}
// Agent mask is a set (internally array/list) of agentTypeIDs.
// It is used to describe which agents modifiers apply to.
// There is a special case of "None" which is an empty array.
// There is a special case of "All" which is an array of length 1, and value of -1.
public static void AgentMaskPopup(string labelName, SerializedProperty agentMask)
{
// Contents of the dropdown box.
string popupContent = "";
if (agentMask.hasMultipleDifferentValues)
popupContent = "\u2014";
else
popupContent = GetAgentMaskLabelName(agentMask);
var content = new GUIContent(popupContent);
var popupRect = GUILayoutUtility.GetRect(content, EditorStyles.popup);
EditorGUI.BeginProperty(popupRect, GUIContent.none, agentMask);
popupRect = EditorGUI.PrefixLabel(popupRect, 0, new GUIContent(labelName));
bool pressed = GUI.Button(popupRect, content, EditorStyles.popup);
if (pressed)
{
var show = !agentMask.hasMultipleDifferentValues;
var showNone = show && agentMask.arraySize == 0;
var showAll = show && IsAll(agentMask);
var menu = new GenericMenu();
menu.AddItem(new GUIContent("None"), showNone, SetAgentMaskNone, agentMask);
menu.AddItem(new GUIContent("All"), showAll, SetAgentMaskAll, agentMask);
menu.AddSeparator("");
var count = NavMesh.GetSettingsCount();
for (var i = 0; i < count; i++)
{
var id = NavMesh.GetSettingsByIndex(i).agentTypeID;
var sname = NavMesh.GetSettingsNameFromID(id);
var showSelected = show && AgentMaskHasSelectedAgentTypeID(agentMask, id);
var userData = new object[] { agentMask, id, !showSelected };
menu.AddItem(new GUIContent(sname), showSelected, ToggleAgentMaskItem, userData);
}
menu.DropDown(popupRect);
}
EditorGUI.EndProperty();
}
public static GameObject CreateAndSelectGameObject(string suggestedName, GameObject parent)
{
var parentTransform = parent != null ? parent.transform : null;
var uniqueName = GameObjectUtility.GetUniqueNameForSibling(parentTransform, suggestedName);
var child = new GameObject(uniqueName);
Undo.RegisterCreatedObjectUndo(child, "Create " + uniqueName);
if (parentTransform != null)
Undo.SetTransformParent(child.transform, parentTransform, "Parent " + uniqueName);
Selection.activeGameObject = child;
return child;
}
static bool IsAll(SerializedProperty agentMask)
{
return agentMask.arraySize == 1 && agentMask.GetArrayElementAtIndex(0).intValue == -1;
}
static void ToggleAgentMaskItem(object userData)
{
var args = (object[])userData;
var agentMask = (SerializedProperty)args[0];
var agentTypeID = (int)args[1];
var value = (bool)args[2];
ToggleAgentMaskItem(agentMask, agentTypeID, value);
}
static void ToggleAgentMaskItem(SerializedProperty agentMask, int agentTypeID, bool value)
{
if (agentMask.hasMultipleDifferentValues)
{
agentMask.ClearArray();
agentMask.serializedObject.ApplyModifiedProperties();
}
// Find which index this agent type is in the agentMask array.
int idx = -1;
for (var j = 0; j < agentMask.arraySize; j++)
{
var elem = agentMask.GetArrayElementAtIndex(j);
if (elem.intValue == agentTypeID)
idx = j;
}
// Handle "All" special case.
if (IsAll(agentMask))
{
agentMask.DeleteArrayElementAtIndex(0);
}
// Toggle value.
if (value)
{
if (idx == -1)
{
agentMask.InsertArrayElementAtIndex(agentMask.arraySize);
agentMask.GetArrayElementAtIndex(agentMask.arraySize - 1).intValue = agentTypeID;
}
}
else
{
if (idx != -1)
{
agentMask.DeleteArrayElementAtIndex(idx);
}
}
agentMask.serializedObject.ApplyModifiedProperties();
}
static void SetAgentMaskNone(object data)
{
var agentMask = (SerializedProperty)data;
agentMask.ClearArray();
agentMask.serializedObject.ApplyModifiedProperties();
}
static void SetAgentMaskAll(object data)
{
var agentMask = (SerializedProperty)data;
agentMask.ClearArray();
agentMask.InsertArrayElementAtIndex(0);
agentMask.GetArrayElementAtIndex(0).intValue = -1;
agentMask.serializedObject.ApplyModifiedProperties();
}
static string GetAgentMaskLabelName(SerializedProperty agentMask)
{
if (agentMask.arraySize == 0)
return "None";
if (IsAll(agentMask))
return "All";
if (agentMask.arraySize <= 3)
{
var labelName = "";
for (var j = 0; j < agentMask.arraySize; j++)
{
var elem = agentMask.GetArrayElementAtIndex(j);
var settingsName = NavMesh.GetSettingsNameFromID(elem.intValue);
if (string.IsNullOrEmpty(settingsName))
continue;
if (labelName.Length > 0)
labelName += ", ";
labelName += settingsName;
}
return labelName;
}
return "Mixed...";
}
static bool AgentMaskHasSelectedAgentTypeID(SerializedProperty agentMask, int agentTypeID)
{
for (var j = 0; j < agentMask.arraySize; j++)
{
var elem = agentMask.GetArrayElementAtIndex(j);
if (elem.intValue == agentTypeID)
return true;
}
return false;
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshComponentsGUIUtility.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 6d05c56cb29ad5240bc671605f95db0c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

279
Assets/NavMeshComponents/Editor/NavMeshLinkEditor.cs
View File

@ -1,279 +0,0 @@
using UnityEditor;
using UnityEngine;
namespace NavMeshPlus.Components.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(NavMeshLink))]
class NavMeshLinkEditor : Editor
{
SerializedProperty m_AgentTypeID;
SerializedProperty m_Area;
SerializedProperty m_CostModifier;
SerializedProperty m_AutoUpdatePosition;
SerializedProperty m_Bidirectional;
SerializedProperty m_EndPoint;
SerializedProperty m_StartPoint;
SerializedProperty m_Width;
static int s_SelectedID;
static int s_SelectedPoint = -1;
static Color s_HandleColor = new Color(255f, 167f, 39f, 210f) / 255;
static Color s_HandleColorDisabled = new Color(255f * 0.75f, 167f * 0.75f, 39f * 0.75f, 100f) / 255;
void OnEnable()
{
m_AgentTypeID = serializedObject.FindProperty("m_AgentTypeID");
m_Area = serializedObject.FindProperty("m_Area");
m_CostModifier = serializedObject.FindProperty("m_CostModifier");
m_AutoUpdatePosition = serializedObject.FindProperty("m_AutoUpdatePosition");
m_Bidirectional = serializedObject.FindProperty("m_Bidirectional");
m_EndPoint = serializedObject.FindProperty("m_EndPoint");
m_StartPoint = serializedObject.FindProperty("m_StartPoint");
m_Width = serializedObject.FindProperty("m_Width");
s_SelectedID = 0;
s_SelectedPoint = -1;
}
static Matrix4x4 UnscaledLocalToWorldMatrix(Transform t)
{
return Matrix4x4.TRS(t.position, t.rotation, Vector3.one);
}
void AlignTransformToEndPoints(NavMeshLink navLink)
{
var mat = UnscaledLocalToWorldMatrix(navLink.transform);
var worldStartPt = mat.MultiplyPoint(navLink.startPoint);
var worldEndPt = mat.MultiplyPoint(navLink.endPoint);
var forward = worldEndPt - worldStartPt;
var up = navLink.transform.up;
// Flatten
forward -= Vector3.Dot(up, forward) * up;
var transform = navLink.transform;
transform.rotation = Quaternion.LookRotation(forward, up);
transform.position = (worldEndPt + worldStartPt) * 0.5f;
transform.localScale = Vector3.one;
navLink.startPoint = transform.InverseTransformPoint(worldStartPt);
navLink.endPoint = transform.InverseTransformPoint(worldEndPt);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_AgentTypeID);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_StartPoint);
EditorGUILayout.PropertyField(m_EndPoint);
GUILayout.BeginHorizontal();
GUILayout.Space(EditorGUIUtility.labelWidth);
if (GUILayout.Button("Swap"))
{
foreach (NavMeshLink navLink in targets)
{
var tmp = navLink.startPoint;
navLink.startPoint = navLink.endPoint;
navLink.endPoint = tmp;
}
SceneView.RepaintAll();
}
if (GUILayout.Button("Align Transform"))
{
foreach (NavMeshLink navLink in targets)
{
Undo.RecordObject(navLink.transform, "Align Transform to End Points");
Undo.RecordObject(navLink, "Align Transform to End Points");
AlignTransformToEndPoints(navLink);
}
SceneView.RepaintAll();
}
GUILayout.EndHorizontal();
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_Width);
EditorGUILayout.PropertyField(m_CostModifier);
EditorGUILayout.PropertyField(m_AutoUpdatePosition);
EditorGUILayout.PropertyField(m_Bidirectional);
EditorGUILayout.PropertyField(m_Area);
serializedObject.ApplyModifiedProperties();
EditorGUILayout.Space();
}
static Vector3 CalcLinkRight(NavMeshLink navLink)
{
var dir = navLink.endPoint - navLink.startPoint;
return (new Vector3(-dir.z, 0.0f, dir.x)).normalized;
}
static void DrawLink(NavMeshLink navLink)
{
var right = CalcLinkRight(navLink);
var rad = navLink.width * 0.5f;
Gizmos.DrawLine(navLink.startPoint - right * rad, navLink.startPoint + right * rad);
Gizmos.DrawLine(navLink.endPoint - right * rad, navLink.endPoint + right * rad);
Gizmos.DrawLine(navLink.startPoint - right * rad, navLink.endPoint - right * rad);
Gizmos.DrawLine(navLink.startPoint + right * rad, navLink.endPoint + right * rad);
}
[DrawGizmo(GizmoType.InSelectionHierarchy | GizmoType.Active | GizmoType.Pickable)]
static void RenderBoxGizmo(NavMeshLink navLink, GizmoType gizmoType)
{
if (!EditorApplication.isPlaying && navLink.isActiveAndEnabled)
navLink.UpdateLink();
var color = s_HandleColor;
if (!navLink.enabled)
color = s_HandleColorDisabled;
var oldColor = Gizmos.color;
var oldMatrix = Gizmos.matrix;
Gizmos.matrix = UnscaledLocalToWorldMatrix(navLink.transform);
Gizmos.color = color;
DrawLink(navLink);
Gizmos.matrix = oldMatrix;
Gizmos.color = oldColor;
Gizmos.DrawIcon(navLink.transform.position, "NavMeshLink Icon", true);
}
[DrawGizmo(GizmoType.NotInSelectionHierarchy | GizmoType.Pickable)]
static void RenderBoxGizmoNotSelected(NavMeshLink navLink, GizmoType gizmoType)
{
if (!EditorApplication.isPlaying && navLink.isActiveAndEnabled)
navLink.UpdateLink();
{
var color = s_HandleColor;
if (!navLink.enabled)
color = s_HandleColorDisabled;
var oldColor = Gizmos.color;
var oldMatrix = Gizmos.matrix;
Gizmos.matrix = UnscaledLocalToWorldMatrix(navLink.transform);
Gizmos.color = color;
DrawLink(navLink);
Gizmos.matrix = oldMatrix;
Gizmos.color = oldColor;
}
Gizmos.DrawIcon(navLink.transform.position, "NavMeshLink Icon", true);
}
public void OnSceneGUI()
{
var navLink = (NavMeshLink)target;
if (!navLink.enabled)
return;
var mat = UnscaledLocalToWorldMatrix(navLink.transform);
var startPt = mat.MultiplyPoint(navLink.startPoint);
var endPt = mat.MultiplyPoint(navLink.endPoint);
var midPt = Vector3.Lerp(startPt, endPt, 0.35f);
var startSize = HandleUtility.GetHandleSize(startPt);
var endSize = HandleUtility.GetHandleSize(endPt);
var midSize = HandleUtility.GetHandleSize(midPt);
var zup = Quaternion.FromToRotation(Vector3.forward, Vector3.up);
var right = mat.MultiplyVector(CalcLinkRight(navLink));
var oldColor = Handles.color;
Handles.color = s_HandleColor;
Vector3 pos;
if (navLink.GetInstanceID() == s_SelectedID && s_SelectedPoint == 0)
{
EditorGUI.BeginChangeCheck();
Handles.CubeHandleCap(0, startPt, zup, 0.1f * startSize, Event.current.type);
pos = Handles.PositionHandle(startPt, navLink.transform.rotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(navLink, "Move link point");
navLink.startPoint = mat.inverse.MultiplyPoint(pos);
}
}
else
{
if (Handles.Button(startPt, zup, 0.1f * startSize, 0.1f * startSize, Handles.CubeHandleCap))
{
s_SelectedPoint = 0;
s_SelectedID = navLink.GetInstanceID();
}
}
if (navLink.GetInstanceID() == s_SelectedID && s_SelectedPoint == 1)
{
EditorGUI.BeginChangeCheck();
Handles.CubeHandleCap(0, endPt, zup, 0.1f * startSize, Event.current.type);
pos = Handles.PositionHandle(endPt, navLink.transform.rotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(navLink, "Move link point");
navLink.endPoint = mat.inverse.MultiplyPoint(pos);
}
}
else
{
if (Handles.Button(endPt, zup, 0.1f * endSize, 0.1f * endSize, Handles.CubeHandleCap))
{
s_SelectedPoint = 1;
s_SelectedID = navLink.GetInstanceID();
}
}
EditorGUI.BeginChangeCheck();
pos = Handles.Slider(midPt + right * navLink.width * 0.5f, right, midSize * 0.03f, Handles.DotHandleCap, 0);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(navLink, "Adjust link width");
navLink.width = Mathf.Max(0.0f, 2.0f * Vector3.Dot(right, (pos - midPt)));
}
EditorGUI.BeginChangeCheck();
pos = Handles.Slider(midPt - right * navLink.width * 0.5f, -right, midSize * 0.03f, Handles.DotHandleCap, 0);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(navLink, "Adjust link width");
navLink.width = Mathf.Max(0.0f, 2.0f * Vector3.Dot(-right, (pos - midPt)));
}
Handles.color = oldColor;
}
[MenuItem("GameObject/Navigation/NavMesh Link", false, 2002)]
public static void CreateNavMeshLink(MenuCommand menuCommand)
{
var parent = menuCommand.context as GameObject;
GameObject go = NavMeshComponentsGUIUtility.CreateAndSelectGameObject("NavMesh Link", parent);
go.AddComponent<NavMeshLink>();
var view = SceneView.lastActiveSceneView;
if (view != null)
view.MoveToView(go.transform);
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshLinkEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 03832abc07e3394479eec5708b22e984
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

46
Assets/NavMeshComponents/Editor/NavMeshModifierEditor.cs
View File

@ -1,46 +0,0 @@
using UnityEditor;
namespace NavMeshPlus.Components.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(NavMeshModifier))]
class NavMeshModifierEditor : Editor
{
SerializedProperty m_AffectedAgents;
SerializedProperty m_Area;
SerializedProperty m_IgnoreFromBuild;
SerializedProperty m_OverrideArea;
void OnEnable()
{
m_AffectedAgents = serializedObject.FindProperty("m_AffectedAgents");
m_Area = serializedObject.FindProperty("m_Area");
m_IgnoreFromBuild = serializedObject.FindProperty("m_IgnoreFromBuild");
m_OverrideArea = serializedObject.FindProperty("m_OverrideArea");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_IgnoreFromBuild);
EditorGUILayout.PropertyField(m_OverrideArea);
if (m_OverrideArea.boolValue)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_Area);
EditorGUI.indentLevel--;
}
NavMeshComponentsGUIUtility.AgentMaskPopup("Affected Agents", m_AffectedAgents);
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshModifierEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: b8fce3c13f011874d92d75ca24a90702
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

198
Assets/NavMeshComponents/Editor/NavMeshModifierTilemapEditor.cs
View File

@ -1,198 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEngine.Tilemaps;
//***********************************************************************************
// Contributed by author jl-randazzo github.com/jl-randazzo
//***********************************************************************************
namespace NavMeshPlus.Components.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(NavMeshModifierTilemap))]
class NavMeshModifierTilemapEditor : Editor
{
SerializedProperty m_AffectedAgents;
SerializedProperty m_TileModifiers;
void OnEnable()
{
m_AffectedAgents = serializedObject.FindProperty("m_AffectedAgents");
m_TileModifiers = serializedObject.FindProperty("m_TileModifiers");
}
public override void OnInspectorGUI()
{
NavMeshModifierTilemap modifierTilemap = target as NavMeshModifierTilemap;
serializedObject.Update();
NavMeshComponentsGUIUtility.AgentMaskPopup("Affected Agents", m_AffectedAgents);
EditorGUILayout.PropertyField(m_TileModifiers);
if (modifierTilemap.HasDuplicateTileModifiers())
{
EditorGUILayout.HelpBox("There are duplicate Tile entries in the tilemap modifiers! Only the first will be used.", MessageType.Warning);
}
EditorGUILayout.Space();
Tilemap tilemap = modifierTilemap.GetComponent<Tilemap>();
if (tilemap)
{
if (GUILayout.Button("Add Used Tiles"))
{
AddUsedTiles(tilemap, modifierTilemap);
}
}
else
{
EditorGUILayout.HelpBox("Missing required component 'Tilemap'", MessageType.Error);
}
if (serializedObject.ApplyModifiedProperties())
{
modifierTilemap.CacheModifiers();
}
}
private void AddUsedTiles(Tilemap tilemap, NavMeshModifierTilemap modifierTilemap)
{
Dictionary<TileBase, NavMeshModifierTilemap.TileModifier> tileModifiers = modifierTilemap.GetModifierMap();
BoundsInt bounds = tilemap.cellBounds;
for (int i = bounds.xMin; i <= bounds.xMax; i++)
{
for (int j = bounds.yMin; j <= bounds.yMax; j++)
{
for (int k = bounds.zMin; k <= bounds.zMax; k++)
{
if (tilemap.GetTile(new Vector3Int(i, j, k)) is TileBase tileBase)
{
if (!tileModifiers.ContainsKey(tileBase))
{
tileModifiers.Add(tileBase, new NavMeshModifierTilemap.TileModifier());
int idx = m_TileModifiers.arraySize;
m_TileModifiers.InsertArrayElementAtIndex(idx);
var newElem = m_TileModifiers.GetArrayElementAtIndex(idx);
var tileProperty = newElem.FindPropertyRelative(nameof(NavMeshModifierTilemap.TileModifier.tile));
tileProperty.objectReferenceValue = tileBase;
}
}
}
}
}
}
[CustomPropertyDrawer(typeof(NavMeshModifierTilemap.TileModifier))]
class TileModifierPropertyDrawer : PropertyDrawer
{
private static Dictionary<Object, Texture2D> Previews;
private Rect ClaimAdvance(ref Rect position, float height)
{
Rect retVal = position;
retVal.height = height;
position.y += height;
position.height -= height;
return retVal;
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
Rect expandRect = ClaimAdvance(ref position, 20);
property.isExpanded = EditorGUI.Foldout(expandRect, property.isExpanded, label);
if (property.isExpanded)
{
var tileProperty = property.FindPropertyRelative(nameof(NavMeshModifierTilemap.TileModifier.tile));
Rect tileRect = ClaimAdvance(ref position, 40);
tileRect.width -= 40;
Rect previewRect = tileRect;
previewRect.width = 40;
previewRect.x += tileRect.width;
tileRect.height /= 2;
// Adding the tile selector and a preview image.
EditorGUI.PropertyField(tileRect, tileProperty);
TileBase tileBase = tileProperty.objectReferenceValue as TileBase;
TileData tileData = new TileData();
Texture textureToDraw;
try
{
tileBase?.GetTileData(Vector3Int.zero, null, ref tileData);
textureToDraw = tileData.sprite?.texture;
}
catch
{
try
{
textureToDraw = GetPreview(tileBase);
}
catch
{
textureToDraw = EditorGUIUtility.IconContent("console.erroricon.sml").image;
}
}
if (textureToDraw)
{
EditorGUI.DrawPreviewTexture(previewRect, textureToDraw, null, ScaleMode.ScaleToFit, 0);
}
Rect toggleRect = ClaimAdvance(ref position, 20);
var overrideAreaProperty = property.FindPropertyRelative(nameof(NavMeshModifierTilemap.TileModifier.overrideArea));
EditorGUI.PropertyField(toggleRect, overrideAreaProperty);
if (overrideAreaProperty.boolValue)
{
Rect areaRect = ClaimAdvance(ref position, 20);
var areaProperty = property.FindPropertyRelative(nameof(NavMeshModifierTilemap.TileModifier.area));
EditorGUI.indentLevel++;
EditorGUI.PropertyField(areaRect, areaProperty);
EditorGUI.indentLevel--;
}
}
}
static Texture2D GetPreview(Object objectToPreview)
{
int maxResolution = 128;
Previews ??= new Dictionary<Object, Texture2D>();
if (!Previews.TryGetValue(objectToPreview, out var preview) || preview == null)
{
var path = AssetDatabase.GetAssetPath(objectToPreview);
if (objectToPreview)
{
var editor = CreateEditor(objectToPreview);
preview = editor.RenderStaticPreview(path, null, maxResolution, maxResolution);
preview.Apply();
DestroyImmediate(editor);
Previews[objectToPreview] = preview;
}
}
return preview;
}
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
if (property.isExpanded)
{
var overrideAreaProperty = property.FindPropertyRelative(nameof(NavMeshModifierTilemap.TileModifier.overrideArea));
if (overrideAreaProperty.boolValue)
{
return 100;
}
return 80;
}
return 20;
}
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshModifierTilemapEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 1fa3ed80a7c8401995efba10b64226e9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

137
Assets/NavMeshComponents/Editor/NavMeshModifierVolumeEditor.cs
View File

@ -1,137 +0,0 @@
using UnityEditor.IMGUI.Controls;
using UnityEditorInternal;
using UnityEngine;
using UnityEditor;
namespace NavMeshPlus.Components.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(NavMeshModifierVolume))]
class NavMeshModifierVolumeEditor : Editor
{
SerializedProperty m_AffectedAgents;
SerializedProperty m_Area;
SerializedProperty m_Center;
SerializedProperty m_Size;
static Color s_HandleColor = new Color(187f, 138f, 240f, 210f) / 255;
static Color s_HandleColorDisabled = new Color(187f * 0.75f, 138f * 0.75f, 240f * 0.75f, 100f) / 255;
BoxBoundsHandle m_BoundsHandle = new BoxBoundsHandle();
bool editingCollider
{
get { return EditMode.editMode == EditMode.SceneViewEditMode.Collider && EditMode.IsOwner(this); }
}
void OnEnable()
{
m_AffectedAgents = serializedObject.FindProperty("m_AffectedAgents");
m_Area = serializedObject.FindProperty("m_Area");
m_Center = serializedObject.FindProperty("m_Center");
m_Size = serializedObject.FindProperty("m_Size"); }
Bounds GetBounds()
{
var navModifier = (NavMeshModifierVolume)target;
return new Bounds(navModifier.transform.position, navModifier.size);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditMode.DoEditModeInspectorModeButton(EditMode.SceneViewEditMode.Collider, "Edit Volume",
EditorGUIUtility.IconContent("EditCollider"), GetBounds, this);
EditorGUILayout.PropertyField(m_Size);
EditorGUILayout.PropertyField(m_Center);
EditorGUILayout.PropertyField(m_Area);
NavMeshComponentsGUIUtility.AgentMaskPopup("Affected Agents", m_AffectedAgents);
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
}
[DrawGizmo(GizmoType.InSelectionHierarchy | GizmoType.Active)]
static void RenderBoxGizmo(NavMeshModifierVolume navModifier, GizmoType gizmoType)
{
var color = navModifier.enabled ? s_HandleColor : s_HandleColorDisabled;
var colorTrans = new Color(color.r * 0.75f, color.g * 0.75f, color.b * 0.75f, color.a * 0.15f);
var oldColor = Gizmos.color;
var oldMatrix = Gizmos.matrix;
Gizmos.matrix = navModifier.transform.localToWorldMatrix;
Gizmos.color = colorTrans;
Gizmos.DrawCube(navModifier.center, navModifier.size);
Gizmos.color = color;
Gizmos.DrawWireCube(navModifier.center, navModifier.size);
Gizmos.matrix = oldMatrix;
Gizmos.color = oldColor;
Gizmos.DrawIcon(navModifier.transform.position, "NavMeshModifierVolume Icon", true);
}
[DrawGizmo(GizmoType.NotInSelectionHierarchy | GizmoType.Pickable)]
static void RenderBoxGizmoNotSelected(NavMeshModifierVolume navModifier, GizmoType gizmoType)
{
{
var color = navModifier.enabled ? s_HandleColor : s_HandleColorDisabled;
var oldColor = Gizmos.color;
var oldMatrix = Gizmos.matrix;
Gizmos.matrix = navModifier.transform.localToWorldMatrix;
Gizmos.color = color;
Gizmos.DrawWireCube(navModifier.center, navModifier.size);
Gizmos.matrix = oldMatrix;
Gizmos.color = oldColor;
}
Gizmos.DrawIcon(navModifier.transform.position, "NavMeshModifierVolume Icon", true);
}
void OnSceneGUI()
{
if (!editingCollider)
return;
var vol = (NavMeshModifierVolume)target;
var color = vol.enabled ? s_HandleColor : s_HandleColorDisabled;
using (new Handles.DrawingScope(color, vol.transform.localToWorldMatrix))
{
m_BoundsHandle.center = vol.center;
m_BoundsHandle.size = vol.size;
EditorGUI.BeginChangeCheck();
m_BoundsHandle.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(vol, "Modified NavMesh Modifier Volume");
Vector3 center = m_BoundsHandle.center;
Vector3 size = m_BoundsHandle.size;
vol.center = center;
vol.size = size;
EditorUtility.SetDirty(target);
}
}
}
[MenuItem("GameObject/Navigation/NavMesh Modifier Volume", false, 2001)]
static public void CreateNavMeshModifierVolume(MenuCommand menuCommand)
{
var parent = menuCommand.context as GameObject;
var go = NavMeshComponentsGUIUtility.CreateAndSelectGameObject("NavMesh Modifier Volume", parent);
go.AddComponent<NavMeshModifierVolume>();
var view = SceneView.lastActiveSceneView;
if (view != null)
view.MoveToView(go.transform);
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshModifierVolumeEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 5999826ec8e37f74a80d7f6ee2700a3a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

428
Assets/NavMeshComponents/Editor/NavMeshSurfaceEditor.cs
View File

@ -1,428 +0,0 @@
#define NAVMESHCOMPONENTS_SHOW_NAVMESHDATA_REF
using System.Linq;
using UnityEditor.IMGUI.Controls;
using UnityEditorInternal;
using UnityEngine.AI;
using UnityEngine;
using UnityEditor;
using UnityEditor.AI;
using System.Reflection;
namespace NavMeshPlus.Components.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(NavMeshSurface))]
class NavMeshSurfaceEditor : Editor
{
SerializedProperty m_AgentTypeID;
SerializedProperty m_BuildHeightMesh;
SerializedProperty m_Center;
SerializedProperty m_CollectObjects;
SerializedProperty m_DefaultArea;
SerializedProperty m_LayerMask;
SerializedProperty m_OverrideTileSize;
SerializedProperty m_OverrideVoxelSize;
SerializedProperty m_Size;
SerializedProperty m_TileSize;
SerializedProperty m_UseGeometry;
SerializedProperty m_VoxelSize;
SerializedProperty m_MinRegionArea;
SerializedProperty m_HideEditorLogs;
#if NAVMESHCOMPONENTS_SHOW_NAVMESHDATA_REF
SerializedProperty m_NavMeshData;
#endif
class Styles
{
public readonly GUIContent m_LayerMask = new GUIContent("Include Layers");
public readonly GUIContent m_MinRegionArea = new GUIContent("Minimum Region Area");
public readonly GUIContent m_ShowInputGeom = new GUIContent("Show Input Geom");
public readonly GUIContent m_ShowVoxels = new GUIContent("Show Voxels");
public readonly GUIContent m_ShowRegions = new GUIContent("Show Regions");
public readonly GUIContent m_ShowRawContours = new GUIContent("Show Raw Contours");
public readonly GUIContent m_ShowContours = new GUIContent("Show Contours");
public readonly GUIContent m_ShowPolyMesh = new GUIContent("Show Poly Mesh");
public readonly GUIContent m_ShowPolyMeshDetail = new GUIContent("Show Poly Mesh Detail");
}
static Styles s_Styles;
static bool s_ShowDebugOptions;
static Color s_HandleColor = new Color(127f, 214f, 244f, 100f) / 255;
static Color s_HandleColorSelected = new Color(127f, 214f, 244f, 210f) / 255;
static Color s_HandleColorDisabled = new Color(127f * 0.75f, 214f * 0.75f, 244f * 0.75f, 100f) / 255;
BoxBoundsHandle m_BoundsHandle = new BoxBoundsHandle();
bool editingCollider
{
get { return EditMode.editMode == EditMode.SceneViewEditMode.Collider && EditMode.IsOwner(this); }
}
void OnEnable()
{
m_AgentTypeID = serializedObject.FindProperty("m_AgentTypeID");
m_BuildHeightMesh = serializedObject.FindProperty("m_BuildHeightMesh");
m_Center = serializedObject.FindProperty("m_Center");
m_CollectObjects = serializedObject.FindProperty("m_CollectObjects");
m_DefaultArea = serializedObject.FindProperty("m_DefaultArea");
m_LayerMask = serializedObject.FindProperty("m_LayerMask");
m_OverrideTileSize = serializedObject.FindProperty("m_OverrideTileSize");
m_OverrideVoxelSize = serializedObject.FindProperty("m_OverrideVoxelSize");
m_Size = serializedObject.FindProperty("m_Size");
m_TileSize = serializedObject.FindProperty("m_TileSize");
m_UseGeometry = serializedObject.FindProperty("m_UseGeometry");
m_VoxelSize = serializedObject.FindProperty("m_VoxelSize");
m_MinRegionArea = serializedObject.FindProperty("m_MinRegionArea");
m_HideEditorLogs = serializedObject.FindProperty("m_HideEditorLogs");
#if NAVMESHCOMPONENTS_SHOW_NAVMESHDATA_REF
m_NavMeshData = serializedObject.FindProperty("m_NavMeshData");
#endif
#if !UNITY_2022_2_OR_NEWER
NavMeshVisualizationSettings.showNavigation++;
#endif
}
#if !UNITY_2022_2_OR_NEWER
void OnDisable()
{
NavMeshVisualizationSettings.showNavigation--;
}
#endif
Bounds GetBounds()
{
var navSurface = (NavMeshSurface)target;
return new Bounds(navSurface.transform.position, navSurface.size);
}
public override void OnInspectorGUI()
{
if (s_Styles == null)
s_Styles = new Styles();
serializedObject.Update();
var bs = NavMesh.GetSettingsByID(m_AgentTypeID.intValue);
if (bs.agentTypeID != -1)
{
// Draw image
const float diagramHeight = 80.0f;
Rect agentDiagramRect = EditorGUILayout.GetControlRect(false, diagramHeight);
NavMeshEditorHelpers.DrawAgentDiagram(agentDiagramRect, bs.agentRadius, bs.agentHeight, bs.agentClimb, bs.agentSlope);
}
EditorGUILayout.PropertyField(m_AgentTypeID);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_CollectObjects);
if ((CollectObjects)m_CollectObjects.enumValueIndex == CollectObjects.Volume)
{
EditorGUI.indentLevel++;
EditMode.DoEditModeInspectorModeButton(EditMode.SceneViewEditMode.Collider, "Edit Volume",
EditorGUIUtility.IconContent("EditCollider"), GetBounds, this);
EditorGUILayout.PropertyField(m_Size);
EditorGUILayout.PropertyField(m_Center);
EditorGUI.indentLevel--;
}
else
{
if (editingCollider)
EditMode.QuitEditMode();
}
EditorGUILayout.PropertyField(m_LayerMask, s_Styles.m_LayerMask);
EditorGUILayout.PropertyField(m_UseGeometry);
EditorGUILayout.Space();
m_OverrideVoxelSize.isExpanded = EditorGUILayout.Foldout(m_OverrideVoxelSize.isExpanded, "Advanced");
if (m_OverrideVoxelSize.isExpanded)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_DefaultArea);
// Override voxel size.
EditorGUILayout.PropertyField(m_OverrideVoxelSize);
using (new EditorGUI.DisabledScope(!m_OverrideVoxelSize.boolValue || m_OverrideVoxelSize.hasMultipleDifferentValues))
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_VoxelSize);
if (!m_OverrideVoxelSize.hasMultipleDifferentValues)
{
if (!m_AgentTypeID.hasMultipleDifferentValues)
{
float voxelsPerRadius = m_VoxelSize.floatValue > 0.0f ? (bs.agentRadius / m_VoxelSize.floatValue) : 0.0f;
EditorGUILayout.LabelField(" ", voxelsPerRadius.ToString("0.00") + " voxels per agent radius", EditorStyles.miniLabel);
}
if (m_OverrideVoxelSize.boolValue)
EditorGUILayout.HelpBox("Voxel size controls how accurately the navigation mesh is generated from the level geometry. A good voxel size is 2-4 voxels per agent radius. Making voxel size smaller will increase build time.", MessageType.None);
}
EditorGUI.indentLevel--;
}
// Override tile size
EditorGUILayout.PropertyField(m_OverrideTileSize);
using (new EditorGUI.DisabledScope(!m_OverrideTileSize.boolValue || m_OverrideTileSize.hasMultipleDifferentValues))
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_TileSize);
if (!m_TileSize.hasMultipleDifferentValues && !m_VoxelSize.hasMultipleDifferentValues)
{
float tileWorldSize = m_TileSize.intValue * m_VoxelSize.floatValue;
EditorGUILayout.LabelField(" ", tileWorldSize.ToString("0.00") + " world units", EditorStyles.miniLabel);
}
if (!m_OverrideTileSize.hasMultipleDifferentValues)
{
if (m_OverrideTileSize.boolValue)
EditorGUILayout.HelpBox("Tile size controls the how local the changes to the world are (rebuild or carve). Small tile size allows more local changes, while potentially generating more data overall.", MessageType.None);
}
EditorGUI.indentLevel--;
}
EditorGUILayout.PropertyField(m_MinRegionArea, s_Styles.m_MinRegionArea);
// Height mesh
using (new EditorGUI.DisabledScope(true))
{
EditorGUILayout.PropertyField(m_BuildHeightMesh);
}
EditorGUILayout.PropertyField(m_HideEditorLogs);
EditorGUILayout.Space();
EditorGUI.indentLevel--;
}
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
var hadError = false;
var multipleTargets = targets.Length > 1;
foreach (NavMeshSurface navSurface in targets)
{
var settings = navSurface.GetBuildSettings();
// Calculating bounds is potentially expensive when unbounded - so here we just use the center/size.
// It means the validation is not checking vertical voxel limit correctly when the surface is set to something else than "in volume".
var bounds = new Bounds(Vector3.zero, Vector3.zero);
if (navSurface.collectObjects == CollectObjects.Volume)
{
bounds = new Bounds(navSurface.center, navSurface.size);
}
var errors = settings.ValidationReport(bounds);
if (errors.Length > 0)
{
if (multipleTargets)
EditorGUILayout.LabelField(navSurface.name);
foreach (var err in errors)
{
EditorGUILayout.HelpBox(err, MessageType.Warning);
}
GUILayout.BeginHorizontal();
GUILayout.Space(EditorGUIUtility.labelWidth);
if (GUILayout.Button("Open Agent Settings...", EditorStyles.miniButton))
NavMeshEditorHelpers.OpenAgentSettings(navSurface.agentTypeID);
GUILayout.EndHorizontal();
hadError = true;
}
}
if (hadError)
EditorGUILayout.Space();
#if NAVMESHCOMPONENTS_SHOW_NAVMESHDATA_REF
var nmdRect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
EditorGUI.BeginProperty(nmdRect, GUIContent.none, m_NavMeshData);
var rectLabel = EditorGUI.PrefixLabel(nmdRect, GUIUtility.GetControlID(FocusType.Passive), new GUIContent(m_NavMeshData.displayName));
EditorGUI.EndProperty();
using (new EditorGUI.DisabledScope(true))
{
EditorGUI.BeginProperty(nmdRect, GUIContent.none, m_NavMeshData);
EditorGUI.ObjectField(rectLabel, m_NavMeshData, GUIContent.none);
EditorGUI.EndProperty();
}
#endif
using (new EditorGUI.DisabledScope(Application.isPlaying || m_AgentTypeID.intValue == -1))
{
GUILayout.BeginHorizontal();
GUILayout.Space(EditorGUIUtility.labelWidth);
if (GUILayout.Button("Clear"))
{
NavMeshAssetManager.instance.ClearSurfaces(targets);
SceneView.RepaintAll();
}
if (GUILayout.Button("Bake"))
{
NavMeshAssetManager.instance.StartBakingSurfaces(targets);
}
GUILayout.EndHorizontal();
}
// Show progress for the selected targets
var bakeOperations = NavMeshAssetManager.instance.GetBakeOperations();
for (int i = bakeOperations.Count - 1; i >= 0; --i)
{
if (!targets.Contains(bakeOperations[i].surface))
continue;
var oper = bakeOperations[i].bakeOperation;
if (oper == null)
continue;
var p = oper.progress;
if (oper.isDone)
{
SceneView.RepaintAll();
continue;
}
GUILayout.BeginHorizontal();
if (GUILayout.Button("Cancel", EditorStyles.miniButton))
{
var bakeData = bakeOperations[i].bakeData;
UnityEngine.AI.NavMeshBuilder.Cancel(bakeData);
bakeOperations.RemoveAt(i);
}
EditorGUI.ProgressBar(EditorGUILayout.GetControlRect(), p, "Baking: " + (int)(100 * p) + "%");
if (p <= 1)
Repaint();
GUILayout.EndHorizontal();
}
}
#if UNITY_2022_2_OR_NEWER
[DrawGizmo(GizmoType.InSelectionHierarchy | GizmoType.Active | GizmoType.Pickable)]
static void RenderGizmoSelected(NavMeshSurface navSurface, GizmoType gizmoType)
{
//navSurface.navMeshDataInstance.FlagAsInSelectionHierarchy();
var method = navSurface.navMeshDataInstance.GetType().GetMethod("FlagAsInSelectionHierarchy", BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(navSurface.navMeshDataInstance, null);
RenderBoxGizmo(navSurface, gizmoType, true);
}
[DrawGizmo(GizmoType.NotInSelectionHierarchy | GizmoType.Pickable)]
static void RenderGizmoNotSelected(NavMeshSurface navSurface, GizmoType gizmoType)
{
RenderBoxGizmo(navSurface, gizmoType, false);
}
#else
[DrawGizmo(GizmoType.Selected | GizmoType.Active | GizmoType.Pickable)]
static void RenderBoxGizmoSelected(NavMeshSurface navSurface, GizmoType gizmoType)
{
RenderBoxGizmo(navSurface, gizmoType, true);
}
[DrawGizmo(GizmoType.NotInSelectionHierarchy | GizmoType.Pickable)]
static void RenderBoxGizmoNotSelected(NavMeshSurface navSurface, GizmoType gizmoType)
{
if (NavMeshVisualizationSettings.showNavigation > 0)
RenderBoxGizmo(navSurface, gizmoType, false);
else
Gizmos.DrawIcon(navSurface.transform.position, "NavMeshSurface Icon", true);
}
#endif
static void RenderBoxGizmo(NavMeshSurface navSurface, GizmoType gizmoType, bool selected)
{
var color = selected ? s_HandleColorSelected : s_HandleColor;
if (!navSurface.enabled)
color = s_HandleColorDisabled;
var oldColor = Gizmos.color;
var oldMatrix = Gizmos.matrix;
// Use the unscaled matrix for the NavMeshSurface
var localToWorld = Matrix4x4.TRS(navSurface.transform.position, navSurface.transform.rotation, Vector3.one);
Gizmos.matrix = localToWorld;
if (navSurface.collectObjects == CollectObjects.Volume)
{
Gizmos.color = color;
Gizmos.DrawWireCube(navSurface.center, navSurface.size);
if (selected && navSurface.enabled)
{
var colorTrans = new Color(color.r * 0.75f, color.g * 0.75f, color.b * 0.75f, color.a * 0.15f);
Gizmos.color = colorTrans;
Gizmos.DrawCube(navSurface.center, navSurface.size);
}
}
else
{
if (navSurface.navMeshData != null)
{
var bounds = navSurface.navMeshData.sourceBounds;
Gizmos.color = Color.grey;
Gizmos.DrawWireCube(bounds.center, bounds.size);
}
}
Gizmos.matrix = oldMatrix;
Gizmos.color = oldColor;
Gizmos.DrawIcon(navSurface.transform.position, "NavMeshSurface Icon", true);
}
void OnSceneGUI()
{
if (!editingCollider)
return;
var navSurface = (NavMeshSurface)target;
var color = navSurface.enabled ? s_HandleColor : s_HandleColorDisabled;
var localToWorld = Matrix4x4.TRS(navSurface.transform.position, navSurface.transform.rotation, Vector3.one);
using (new Handles.DrawingScope(color, localToWorld))
{
m_BoundsHandle.center = navSurface.center;
m_BoundsHandle.size = navSurface.size;
EditorGUI.BeginChangeCheck();
m_BoundsHandle.DrawHandle();
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(navSurface, "Modified NavMesh Surface");
Vector3 center = m_BoundsHandle.center;
Vector3 size = m_BoundsHandle.size;
navSurface.center = center;
navSurface.size = size;
EditorUtility.SetDirty(target);
}
}
}
[MenuItem("GameObject/Navigation/NavMesh Surface", false, 2000)]
public static void CreateNavMeshSurface(MenuCommand menuCommand)
{
var parent = menuCommand.context as GameObject;
var go = NavMeshComponentsGUIUtility.CreateAndSelectGameObject("NavMesh Surface", parent);
go.AddComponent<NavMeshSurface>();
var view = SceneView.lastActiveSceneView;
if (view != null)
view.MoveToView(go.transform);
}
}
}

11
Assets/NavMeshComponents/Editor/NavMeshSurfaceEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 3a7b2ae8284a9b14abd6d688cc877cef
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

36
Assets/NavMeshComponents/Editor/RootSources2dEditor.cs
View File

@ -1,36 +0,0 @@
using UnityEditor;
using NavMeshPlus.Components;
namespace NavMeshPlus.Extensions.Editors
{
[CanEditMultipleObjects]
[CustomEditor(typeof(RootSources2d))]
internal class RootSources2dEditor: Editor
{
SerializedProperty _rootSources;
void OnEnable()
{
_rootSources = serializedObject.FindProperty("_rootSources");
}
public override void OnInspectorGUI()
{
serializedObject.Update();
var surf = target as RootSources2d;
EditorGUILayout.HelpBox("Add GameObjects to create NavMesh form it and it's ancestors", MessageType.Info);
if (surf.NavMeshSurfaceOwner.collectObjects != CollectObjects.Children)
{
EditorGUILayout.Space();
EditorGUILayout.HelpBox("Root Sources are only suitable for 'CollectObjects - Children'", MessageType.Info);
EditorGUILayout.Space();
}
EditorGUILayout.PropertyField(_rootSources);
serializedObject.ApplyModifiedProperties();
}
}
}

11
Assets/NavMeshComponents/Editor/RootSources2dEditor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7e3d768af6ee1774cb39815bd8e5b221
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/NavMeshComponents/Scripts.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 641c4284edd67fe44923489f38de3466
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

36
Assets/NavMeshComponents/Scripts/AgentOverride2d.cs
View File

@ -1,36 +0,0 @@
using UnityEngine;
using UnityEngine.AI;
namespace NavMeshPlus.Extensions
{
public interface IAgentOverride
{
void UpdateAgent();
}
public class AgentDefaultOverride : IAgentOverride
{
public void UpdateAgent()
{
}
}
public class AgentOverride2d: MonoBehaviour
{
public NavMeshAgent Agent { get; private set; }
public IAgentOverride agentOverride { get; set; }
private void Awake()
{
Agent = GetComponent<NavMeshAgent>();
}
private void Start()
{
Agent.updateRotation = false;
Agent.updateUpAxis = false;
}
private void Update()
{
agentOverride?.UpdateAgent();
}
}
}

11
Assets/NavMeshComponents/Scripts/AgentOverride2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7e39f6090724e4a4a8aadeb042afa2bc
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

15
Assets/NavMeshComponents/Scripts/AgentRotate2d.cs
View File

@ -1,15 +0,0 @@
using UnityEngine;
namespace NavMeshPlus.Extensions
{
public class AgentRotate2d: MonoBehaviour
{
private AgentOverride2d override2D;
private void Start()
{
override2D = GetComponent<AgentOverride2d>();
override2D.agentOverride = new RotateAgentInstantly(override2D.Agent, override2D);
}
}
}

11
Assets/NavMeshComponents/Scripts/AgentRotate2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 8550f034611a06e4f88fc261204d8a7b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

16
Assets/NavMeshComponents/Scripts/AgentRotateSmooth2d.cs
View File

@ -1,16 +0,0 @@
using UnityEngine;
namespace NavMeshPlus.Extensions
{
class AgentRotateSmooth2d: MonoBehaviour
{
public float angularSpeed;
private AgentOverride2d override2D;
private void Start()
{
override2D = GetComponent<AgentOverride2d>();
override2D.agentOverride = new RotateAgentSmoothly(override2D.Agent, override2D, angularSpeed);
}
}
}

11
Assets/NavMeshComponents/Scripts/AgentRotateSmooth2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 8c7f4db162bab4443818dd13bed4b1dc
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

90
Assets/NavMeshComponents/Scripts/CollectSources2d.cs
View File

@ -1,90 +0,0 @@
using NavMeshPlus.Components;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Tilemaps;
namespace NavMeshPlus.Extensions
{
[ExecuteAlways]
[AddComponentMenu("Navigation/Navigation CollectSources2d", 30)]
public class CollectSources2d: NavMeshExtension
{
[SerializeField]
bool m_OverrideByGrid;
public bool overrideByGrid { get { return m_OverrideByGrid; } set { m_OverrideByGrid = value; } }
[SerializeField]
GameObject m_UseMeshPrefab;
public GameObject useMeshPrefab { get { return m_UseMeshPrefab; } set { m_UseMeshPrefab = value; } }
[SerializeField]
bool m_CompressBounds;
public bool compressBounds { get { return m_CompressBounds; } set { m_CompressBounds = value; } }
[SerializeField]
Vector3 m_OverrideVector = Vector3.one;
public Vector3 overrideVector { get { return m_OverrideVector; } set { m_OverrideVector = value; } }
public override void CalculateWorldBounds(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState)
{
if (surface.collectObjects != CollectObjects.Volume)
{
navNeshState.worldBounds.Encapsulate(CalculateGridWorldBounds(surface, navNeshState.worldToLocal, navNeshState.worldBounds));
}
}
private static Bounds CalculateGridWorldBounds(NavMeshSurface surface, Matrix4x4 worldToLocal, Bounds bounds)
{
var grid = Object.FindAnyObjectByType<Grid>();
var tilemaps = grid?.GetComponentsInChildren<Tilemap>();
if (tilemaps == null || tilemaps.Length < 1)
{
return bounds;
}
foreach (var tilemap in tilemaps)
{
var lbounds = NavMeshSurface.GetWorldBounds(worldToLocal * tilemap.transform.localToWorldMatrix, tilemap.localBounds);
bounds.Encapsulate(lbounds);
if (!surface.hideEditorLogs)
{
Debug.Log($"From Local Bounds [{tilemap.name}]: {tilemap.localBounds}");
Debug.Log($"To World Bounds: {bounds}");
}
}
return bounds;
}
public override void CollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState)
{
if (!surface.hideEditorLogs)
{
if (!Mathf.Approximately(transform.eulerAngles.x, 270f))
{
Debug.LogWarning("NavMeshSurface is not rotated respectively to (x-90;y0;z0). Apply rotation unless intended.");
}
if (Application.isPlaying)
{
if (surface.useGeometry == NavMeshCollectGeometry.PhysicsColliders && Time.frameCount <= 1)
{
Debug.LogWarning("Use Geometry - Physics Colliders option in NavMeshSurface may cause inaccurate mesh bake if executed before Physics update.");
}
}
}
var builder = navNeshState.GetExtraState<NavMeshBuilder2dState>();
builder.defaultArea = surface.defaultArea;
builder.layerMask = surface.layerMask;
builder.agentID = surface.agentTypeID;
builder.useMeshPrefab = useMeshPrefab;
builder.overrideByGrid = overrideByGrid;
builder.compressBounds = compressBounds;
builder.overrideVector = overrideVector;
builder.CollectGeometry = surface.useGeometry;
builder.CollectObjects = (CollectObjects)(int)surface.collectObjects;
builder.parent = surface.gameObject;
builder.hideEditorLogs = surface.hideEditorLogs;
builder.SetRoot(navNeshState.roots);
NavMeshBuilder2d.CollectSources(sources, builder);
}
}
}

11
Assets/NavMeshComponents/Scripts/CollectSources2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 70bd44a44cd62c64fbfc1eea95b24880
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

132
Assets/NavMeshComponents/Scripts/CollectSourcesCache2d.cs
View File

@ -1,132 +0,0 @@
using NavMeshPlus.Components;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
namespace NavMeshPlus.Extensions
{
[ExecuteAlways]
[AddComponentMenu("Navigation/Navigation CacheSources2d", 30)]
public class CollectSourcesCache2d : NavMeshExtension
{
List<NavMeshBuildSource> _sources;
Dictionary<UnityEngine.Object, NavMeshBuildSource> _lookup;
private Bounds _sourcesBounds;
public bool IsDirty { get; protected set; }
private NavMeshBuilder2dState _state;
public int SourcesCount => _sources.Count;
public int CahcheCount => _lookup.Count;
public List<NavMeshBuildSource> Cache { get => _sources; }
protected override void Awake()
{
_lookup = new Dictionary<UnityEngine.Object, NavMeshBuildSource>();
_sources = new List<NavMeshBuildSource>();
IsDirty = false;
Order = -1000;
_sourcesBounds = new Bounds();
base.Awake();
}
protected override void OnDestroy()
{
_state?.Dispose();
base.OnDestroy();
}
public bool AddSource(GameObject gameObject)
{
var res = _lookup.ContainsKey(gameObject);
if (res)
{
return UpdateSource(gameObject);
}
NavMeshBuilder2d.CollectSources(gameObject, _sources, _state);
IsDirty = true;
return true;
}
public bool AddSource(GameObject gameObject, NavMeshBuildSource source)
{
var res = _lookup.ContainsKey(gameObject);
if (res)
{
return UpdateSource(gameObject);
}
_sources.Add(source);
_lookup.Add(gameObject, source);
IsDirty = true;
return true;
}
public bool UpdateSource(GameObject gameObject, int? area = null)
{
var res = _lookup.ContainsKey(gameObject);
if(res)
{
IsDirty = true;
var source = _lookup[gameObject];
var idx = _sources.IndexOf(source);
if (idx >= 0)
{
source.transform = Matrix4x4.TRS(gameObject.transform.position, gameObject.transform.rotation, gameObject.transform.lossyScale);
if (area.HasValue)
{
source.area = area.Value;
}
_sources[idx] = source;
_lookup[gameObject] = source;
}
}
return res;
}
public bool RemoveSource(GameObject gameObject)
{
var res = _lookup.ContainsKey(gameObject);
if (res)
{
IsDirty = true;
var source = _lookup[gameObject];
_lookup.Remove(gameObject);
_sources.Remove(source);
}
return res;
}
public AsyncOperation UpdateNavMesh(NavMeshData data)
{
IsDirty = false;
return NavMeshBuilder.UpdateNavMeshDataAsync(data, NavMeshSurfaceOwner.GetBuildSettings(), _sources, _sourcesBounds);
}
public AsyncOperation UpdateNavMesh()
{
return UpdateNavMesh(NavMeshSurfaceOwner.navMeshData);
}
public override void CollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navMeshState)
{
_lookup.Clear();
IsDirty = false;
_state?.Dispose();
_state = navMeshState.GetExtraState<NavMeshBuilder2dState>(false);
_state.lookupCallback = LookupCallback;
}
private void LookupCallback(UnityEngine.Object component, NavMeshBuildSource source)
{
if (component == null)
{
return;
}
_lookup.Add(component, source);
}
public override void PostCollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState)
{
_sourcesBounds = navNeshState.worldBounds;
_sources = sources;
}
}
}

11
Assets/NavMeshComponents/Scripts/CollectSourcesCache2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 5492b7ed96378624cbcd72212fce093d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

95
Assets/NavMeshComponents/Scripts/CollectTilemapSourcesCache2d.cs
View File

@ -1,95 +0,0 @@
using NavMeshPlus.Components;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Tilemaps;
namespace NavMeshPlus.Extensions
{
[ExecuteAlways]
[AddComponentMenu("Navigation/Navigation CacheTilemapSources2d", 30)]
public class CollectTilemapSourcesCache2d : NavMeshExtension
{
[SerializeField] private Tilemap _tilemap;
[SerializeField] private NavMeshModifier _modifier;
[SerializeField] private NavMeshModifierTilemap _modifierTilemap;
private List<NavMeshBuildSource> _sources;
private Dictionary<Vector3Int, int> _lookup;
private Dictionary<TileBase, NavMeshModifierTilemap.TileModifier> _modifierMap;
protected override void Awake()
{
_modifier ??= _tilemap.GetComponent<NavMeshModifier>();
_modifierTilemap ??= _tilemap.GetComponent<NavMeshModifierTilemap>();
_modifierMap = _modifierTilemap.GetModifierMap();
Order = -1000;
base.Awake();
}
#if UNITY_EDITOR || UNITY_2022_2_OR_NEWER
private void OnTilemapTileChanged(Tilemap tilemap, Tilemap.SyncTile[] syncTiles)
{
if (tilemap == _tilemap)
{
foreach (Tilemap.SyncTile syncTile in syncTiles)
{
Vector3Int position = syncTile.position;
if (syncTile.tile != null && _modifierMap.TryGetValue(syncTile.tile, out NavMeshModifierTilemap.TileModifier tileModifier))
{
int i = _lookup[position];
NavMeshBuildSource source = _sources[i];
source.area = tileModifier.area;
_sources[i] = source;
}
else if (_modifier.overrideArea)
{
int i = _lookup[position];
NavMeshBuildSource source = _sources[i];
source.area = _modifier.area;
_sources[i] = source;
}
}
}
}
#endif
public AsyncOperation UpdateNavMesh(NavMeshData data)
{
return NavMeshBuilder.UpdateNavMeshDataAsync(data, NavMeshSurfaceOwner.GetBuildSettings(), _sources, data.sourceBounds);
}
public AsyncOperation UpdateNavMesh()
{
return UpdateNavMesh(NavMeshSurfaceOwner.navMeshData);
}
public override void PostCollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState)
{
_sources = sources;
if (_lookup == null)
{
_lookup = new Dictionary<Vector3Int, int>();
for (int i = 0; i < _sources.Count; i++)
{
NavMeshBuildSource source = _sources[i];
Vector3Int position = _tilemap.WorldToCell(source.transform.GetPosition());
_lookup[position] = i;
}
}
#if UNITY_EDITOR || UNITY_2022_2_OR_NEWER
Tilemap.tilemapTileChanged -= OnTilemapTileChanged;
Tilemap.tilemapTileChanged += OnTilemapTileChanged;
#endif
}
protected override void OnDestroy()
{
#if UNITY_EDITOR || UNITY_2022_2_OR_NEWER
Tilemap.tilemapTileChanged -= OnTilemapTileChanged;
#endif
base.OnDestroy();
}
}
}

11
Assets/NavMeshComponents/Scripts/CollectTilemapSourcesCache2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 4db9c2c5aca397f41a57740bd678fd51
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

12
Assets/NavMeshComponents/Scripts/NavMeshAgentAttribute.cs
View File

@ -1,12 +0,0 @@
using UnityEngine;
//***********************************************************************************
// Contributed by author jl-randazzo github.com/jl-randazzo
//***********************************************************************************
namespace NavMeshPlus.Extensions
{
[System.Serializable]
public class NavMeshAgentAttribute : PropertyAttribute
{
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshAgentAttribute.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7f3fe2b336bf34749a146f6bf7d462d0
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

13
Assets/NavMeshComponents/Scripts/NavMeshAreaAttribute.cs
View File

@ -1,13 +0,0 @@
using UnityEngine;
//***********************************************************************************
// Contributed by author jl-randazzo github.com/jl-randazzo
//***********************************************************************************
namespace NavMeshPlus.Extensions
{
[System.Serializable]
// See also NavMeshAreaAttributePropertyDrawer
public class NavMeshAreaAttribute : PropertyAttribute
{
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshAreaAttribute.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: ed6d9f7764b9451f97a6658cdc760e00
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

399
Assets/NavMeshComponents/Scripts/NavMeshBuilder2d.cs
View File

@ -1,399 +0,0 @@
using NavMeshPlus.Components;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.SceneManagement;
using UnityEngine.Tilemaps;
using Object = UnityEngine.Object;
namespace NavMeshPlus.Extensions
{
class NavMeshBuilder2dState: IDisposable
{
public Dictionary<Sprite, Mesh> spriteMeshMap;
public Dictionary<uint, Mesh> coliderMeshMap;
public Action<UnityEngine.Object, NavMeshBuildSource> lookupCallback;
public int defaultArea;
public int layerMask;
public int agentID;
public bool overrideByGrid;
public GameObject useMeshPrefab;
public bool compressBounds;
public Vector3 overrideVector;
public NavMeshCollectGeometry CollectGeometry;
public CollectObjects CollectObjects;
public GameObject parent;
public bool hideEditorLogs;
protected IEnumerable<GameObject> _root;
private bool _disposed;
public IEnumerable<GameObject> Root => _root ?? GetRoot();
public NavMeshBuilder2dState()
{
spriteMeshMap = new Dictionary<Sprite, Mesh>();
coliderMeshMap = new Dictionary<uint, Mesh>();
_root = null;
}
public Mesh GetMesh(Sprite sprite)
{
Mesh mesh;
if (spriteMeshMap.ContainsKey(sprite))
{
mesh = spriteMeshMap[sprite];
}
else
{
mesh = new Mesh();
NavMeshBuilder2d.sprite2mesh(sprite, mesh);
spriteMeshMap.Add(sprite, mesh);
}
return mesh;
}
public Mesh GetMesh(Collider2D collider)
{
#if UNITY_2019_3_OR_NEWER
Mesh mesh;
uint hash = collider.GetShapeHash();
if (coliderMeshMap.ContainsKey(hash))
{
mesh = coliderMeshMap[hash];
}
else
{
mesh = collider.CreateMesh(false, false);
coliderMeshMap.Add(hash, mesh);
}
return mesh;
#else
throw new InvalidOperationException("PhysicsColliders supported in Unity 2019.3 and higher.");
#endif
}
public void SetRoot(IEnumerable<GameObject> root)
{
_root = root;
}
public IEnumerable<GameObject> GetRoot()
{
switch (CollectObjects)
{
case CollectObjects.Children: return new[] { parent };
case CollectObjects.Volume:
case CollectObjects.All:
default:
{
var list = new List<GameObject>();
var roots = new List<GameObject>();
for (int i = 0; i < SceneManager.sceneCount; ++i)
{
var s = SceneManager.GetSceneAt(i);
if (!s.isLoaded) continue;
s.GetRootGameObjects(list);
roots.AddRange(list);
}
return roots;
}
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
// TODO: dispose managed state (managed objects).
foreach (var item in spriteMeshMap)
{
#if UNITY_EDITOR
Object.DestroyImmediate(item.Value);
#else
Object.Destroy(item.Value);
#endif
}
foreach (var item in coliderMeshMap)
{
#if UNITY_EDITOR
Object.DestroyImmediate(item.Value);
#else
Object.Destroy(item.Value);
#endif
}
spriteMeshMap.Clear();
coliderMeshMap.Clear();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
_disposed = true;
}
public void Dispose()
{
// Dispose of unmanaged resources.
Dispose(true);
// Suppress finalization.
GC.SuppressFinalize(this);
}
}
class NavMeshBuilder2d
{
public static void CollectSources(List<NavMeshBuildSource> sources, NavMeshBuilder2dState builder)
{
foreach (var it in builder.Root)
{
CollectSources(it, sources, builder);
}
if (!builder.hideEditorLogs) Debug.Log("Sources " + sources.Count);
}
public static void CollectSources(GameObject root, List<NavMeshBuildSource> sources, NavMeshBuilder2dState builder)
{
foreach (var modifier in root.GetComponentsInChildren<NavMeshModifier>())
{
if (((0x1 << modifier.gameObject.layer) & builder.layerMask) == 0)
{
continue;
}
if (!modifier.AffectsAgentType(builder.agentID))
{
continue;
}
int area = builder.defaultArea;
//if it is walkable
if (builder.defaultArea != 1 && !modifier.ignoreFromBuild)
{
AddDefaultWalkableTilemap(sources, builder, modifier);
}
if (modifier.overrideArea)
{
area = modifier.area;
}
if (!modifier.ignoreFromBuild)
{
CollectSources(sources, builder, modifier, area);
}
}
}
public static void CollectSources(List<NavMeshBuildSource> sources, NavMeshBuilder2dState builder, NavMeshModifier modifier, int area)
{
if (builder.CollectGeometry == NavMeshCollectGeometry.PhysicsColliders)
{
var collider = modifier.GetComponent<Collider2D>();
if (collider != null)
{
CollectSources(sources, collider, area, builder);
}
}
else
{
var tilemap = modifier.GetComponent<Tilemap>();
if (tilemap != null)
{
CollectTileSources(sources, tilemap, area, builder);
}
var sprite = modifier.GetComponent<SpriteRenderer>();
if (sprite != null)
{
CollectSources(sources, sprite, area, builder);
}
}
}
private static void AddDefaultWalkableTilemap(List<NavMeshBuildSource> sources, NavMeshBuilder2dState builder, NavMeshModifier modifier)
{
var tilemap = modifier.GetComponent<Tilemap>();
if (tilemap != null)
{
if (builder.compressBounds)
{
tilemap.CompressBounds();
}
if (!builder.hideEditorLogs) Debug.Log($"Walkable Bounds [{tilemap.name}]: {tilemap.localBounds}");
var box = BoxBoundSource(NavMeshSurface.GetWorldBounds(tilemap.transform.localToWorldMatrix, tilemap.localBounds));
box.area = builder.defaultArea;
sources.Add(box);
}
}
public static void CollectSources(List<NavMeshBuildSource> sources, SpriteRenderer spriteRenderer, int area, NavMeshBuilder2dState builder)
{
if (spriteRenderer == null || spriteRenderer.sprite == null)
{
return;
}
Mesh mesh;
mesh = builder.GetMesh(spriteRenderer.sprite);
if (mesh == null)
{
if (!builder.hideEditorLogs) Debug.Log($"{spriteRenderer.name} mesh is null");
return;
}
var src = new NavMeshBuildSource();
src.shape = NavMeshBuildSourceShape.Mesh;
src.component = spriteRenderer;
src.area = area;
src.transform = Matrix4x4.TRS(Vector3.Scale(spriteRenderer.transform.position, builder.overrideVector), spriteRenderer.transform.rotation, spriteRenderer.transform.lossyScale);
src.sourceObject = mesh;
sources.Add(src);
builder.lookupCallback?.Invoke(spriteRenderer.gameObject, src);
}
public static void CollectSources(List<NavMeshBuildSource> sources, Collider2D collider, int area, NavMeshBuilder2dState builder)
{
// 수정: usedByComposite 대신 compositeOperation 확인
if (collider.compositeOperation != Collider2D.CompositeOperation.None)
{
collider = collider.GetComponent<CompositeCollider2D>();
}
Mesh mesh;
mesh = builder.GetMesh(collider);
if (mesh == null)
{
if (!builder.hideEditorLogs) Debug.Log($"{collider.name} mesh is null");
return;
}
var src = new NavMeshBuildSource();
src.shape = NavMeshBuildSourceShape.Mesh;
src.area = area;
src.component = collider;
src.sourceObject = mesh;
if (collider.attachedRigidbody)
{
src.transform = Matrix4x4.TRS(Vector3.Scale(collider.attachedRigidbody.transform.position, builder.overrideVector), collider.attachedRigidbody.transform.rotation, Vector3.one);
}
else
{
src.transform = Matrix4x4.identity;
}
sources.Add(src);
builder.lookupCallback?.Invoke(collider.gameObject, src);
}
public static void CollectTileSources(List<NavMeshBuildSource> sources, Tilemap tilemap, int area, NavMeshBuilder2dState builder)
{
var bound = tilemap.cellBounds;
var modifierTilemap = tilemap.GetComponent<NavMeshModifierTilemap>();
if (modifierTilemap && !modifierTilemap.AffectsAgentType(builder.agentID))
{
return;
}
var vec3int = new Vector3Int(0, 0, 0);
var size = new Vector3(tilemap.layoutGrid.cellSize.x, tilemap.layoutGrid.cellSize.y, 0);
Mesh sharedMesh = null;
Quaternion rot = default;
if (builder.useMeshPrefab != null)
{
sharedMesh = builder.useMeshPrefab.GetComponent<MeshFilter>().sharedMesh;
size = builder.useMeshPrefab.transform.localScale;
rot = builder.useMeshPrefab.transform.rotation;
}
for (int i = bound.xMin; i < bound.xMax; i++)
{
for (int j = bound.yMin; j < bound.yMax; j++)
{
var src = new NavMeshBuildSource();
src.area = area;
vec3int.x = i;
vec3int.y = j;
if (!tilemap.HasTile(vec3int))
{
continue;
}
CollectTile(tilemap, builder, vec3int, size, sharedMesh, rot, ref src);
if (modifierTilemap && modifierTilemap.TryGetTileModifier(vec3int, tilemap, out NavMeshModifierTilemap.TileModifier tileModifier))
{
src.area = tileModifier.overrideArea ? tileModifier.area : area;
}
sources.Add(src);
builder.lookupCallback?.Invoke(tilemap.GetInstantiatedObject(vec3int), src);
}
}
}
private static void CollectTile(Tilemap tilemap, NavMeshBuilder2dState builder, Vector3Int vec3int, Vector3 size, Mesh sharedMesh, Quaternion rot, ref NavMeshBuildSource src)
{
if (!builder.overrideByGrid && tilemap.GetColliderType(vec3int) == Tile.ColliderType.Sprite)
{
var sprite = tilemap.GetSprite(vec3int);
if (sprite != null)
{
Mesh mesh = builder.GetMesh(sprite);
src.component = tilemap;
src.transform = GetCellTransformMatrix(tilemap, builder.overrideVector, vec3int);
src.shape = NavMeshBuildSourceShape.Mesh;
src.sourceObject = mesh;
}
}
else if (builder.useMeshPrefab != null || (builder.overrideByGrid && builder.useMeshPrefab != null))
{
src.transform = Matrix4x4.TRS(Vector3.Scale(tilemap.GetCellCenterWorld(vec3int), builder.overrideVector), rot, size);
src.shape = NavMeshBuildSourceShape.Mesh;
src.sourceObject = sharedMesh;
}
else //default to box
{
src.transform = GetCellTransformMatrix(tilemap, builder.overrideVector, vec3int);
src.shape = NavMeshBuildSourceShape.Box;
src.size = size;
}
}
public static Matrix4x4 GetCellTransformMatrix(Tilemap tilemap, Vector3 scale, Vector3Int vec3int)
{
return Matrix4x4.TRS(Vector3.Scale(tilemap.GetCellCenterWorld(vec3int), scale) - tilemap.layoutGrid.cellGap, tilemap.transform.rotation, tilemap.transform.lossyScale) * tilemap.orientationMatrix * tilemap.GetTransformMatrix(vec3int);
}
internal static void sprite2mesh(Sprite sprite, Mesh mesh)
{
Vector3[] vert = new Vector3[sprite.vertices.Length];
for (int i = 0; i < sprite.vertices.Length; i++)
{
vert[i] = new Vector3(sprite.vertices[i].x, sprite.vertices[i].y, 0);
}
mesh.vertices = vert;
mesh.uv = sprite.uv;
int[] tri = new int[sprite.triangles.Length];
for (int i = 0; i < sprite.triangles.Length; i++)
{
tri[i] = sprite.triangles[i];
}
mesh.triangles = tri;
}
static private NavMeshBuildSource BoxBoundSource(Bounds localBounds)
{
var src = new NavMeshBuildSource();
src.transform = Matrix4x4.Translate(localBounds.center);
src.shape = NavMeshBuildSourceShape.Box;
src.size = localBounds.size;
src.area = 0;
return src;
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshBuilder2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: fc6dd3809c1761a4e9a227c70117ed54
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: e8142b1daeea8d3419cd0ffbd7b17a37, type: 3}
userData:
assetBundleName:
assetBundleVariant:

109
Assets/NavMeshComponents/Scripts/NavMeshBuilderState.cs
View File

@ -1,109 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace NavMeshPlus.Extensions
{
public class NavMeshBuilderState: IDisposable
{
public Matrix4x4 worldToLocal;
public Bounds worldBounds;
public IEnumerable<GameObject> roots;
private CompositeDisposable disposable;
private Dictionary<Type, System.Object> mExtraState;
private bool _disposed;
public T GetExtraState<T>(bool dispose = true) where T : class, new()
{
if (mExtraState == null)
{
mExtraState = new Dictionary<Type, System.Object>();
disposable = new CompositeDisposable();
}
if (!mExtraState.TryGetValue(typeof(T), out System.Object extra))
{
extra = mExtraState[typeof(T)] = new T();
if (dispose)
{
disposable.Add(extra);
}
}
return extra as T;
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
// TODO: dispose managed state (managed objects).
disposable?.Dispose();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
_disposed = true;
}
public void Dispose()
{
// Dispose of unmanaged resources.
Dispose(true);
// Suppress finalization.
GC.SuppressFinalize(this);
}
}
partial class CompositeDisposable: IDisposable
{
private bool _disposed;
private List<IDisposable> extraStates = new List<IDisposable>();
public void Add(IDisposable dispose)
{
extraStates.Add(dispose);
}
public void Add(object dispose)
{
if(dispose is IDisposable)
{
extraStates.Add((IDisposable)dispose);
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
// TODO: dispose managed state (managed objects).
foreach (var item in extraStates)
{
item?.Dispose();
}
extraStates.Clear();
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
_disposed = true;
}
public void Dispose()
{
// Dispose of unmanaged resources.
Dispose(true);
// Suppress finalization.
GC.SuppressFinalize(this);
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshBuilderState.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 710022065e740cf40bf86ccac60e3741
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: e8142b1daeea8d3419cd0ffbd7b17a37, type: 3}
userData:
assetBundleName:
assetBundleVariant:

58
Assets/NavMeshComponents/Scripts/NavMeshExtension.cs
View File

@ -1,58 +0,0 @@
using NavMeshPlus.Components;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
namespace NavMeshPlus.Extensions
{
public abstract class NavMeshExtension: MonoBehaviour
{
public int Order { get; protected set; }
public virtual void CollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState) { }
public virtual void CalculateWorldBounds(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState) { }
public virtual void PostCollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState) { }
public NavMeshSurface NavMeshSurfaceOwner
{
get
{
if (m_navMeshOwner == null)
m_navMeshOwner = GetComponent<NavMeshSurface>();
return m_navMeshOwner;
}
}
NavMeshSurface m_navMeshOwner;
protected virtual void Awake()
{
ConnectToVcam(true);
}
#if UNITY_EDITOR
[UnityEditor.Callbacks.DidReloadScripts]
static void OnScriptReload()
{
var extensions = Resources.FindObjectsOfTypeAll(
typeof(NavMeshExtension)) as NavMeshExtension[];
foreach (var e in extensions)
e.ConnectToVcam(true);
}
#endif
protected virtual void OnEnable() { }
protected virtual void OnDestroy()
{
ConnectToVcam(false);
}
protected virtual void ConnectToVcam(bool connect)
{
if (connect && NavMeshSurfaceOwner == null)
Debug.LogError("NevMeshExtension requires a NavMeshSurface component");
if (NavMeshSurfaceOwner != null)
{
if (connect)
NavMeshSurfaceOwner.NevMeshExtensions.Add(this, Order);
else
NavMeshSurfaceOwner.NevMeshExtensions.Remove(this);
}
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshExtension.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 0528335b682da1f42901dc790b763830
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: e8142b1daeea8d3419cd0ffbd7b17a37, type: 3}
userData:
assetBundleName:
assetBundleVariant:

57
Assets/NavMeshComponents/Scripts/NavMeshExtensionsProvider.cs
View File

@ -1,57 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace NavMeshPlus.Extensions
{
public interface INavMeshExtensionsProvider
{
int Count { get; }
NavMeshExtension this[int index] { get; }
void Add(NavMeshExtension extension, int order);
void Remove(NavMeshExtension extension);
}
internal class NavMeshExtensionMeta
{
public int order;
public NavMeshExtensionMeta(int order, NavMeshExtension extension)
{
this.order = order;
this.extension = extension;
}
public NavMeshExtension extension;
}
internal class NavMeshExtensionsProvider : INavMeshExtensionsProvider
{
List<NavMeshExtensionMeta> _extensions = new List<NavMeshExtensionMeta>();
static Comparer<NavMeshExtensionMeta> Comparer = Comparer<NavMeshExtensionMeta>.Create((x, y) => x.order > y.order ? 1 : x.order < y.order ? -1 : 0);
public NavMeshExtension this[int index] => _extensions[index].extension;
public int Count => _extensions.Count;
public void Add(NavMeshExtension extension, int order)
{
var meta = new NavMeshExtensionMeta(order, extension);
var at = _extensions.BinarySearch(meta, Comparer);
if (at < 0)
{
_extensions.Add(meta);
_extensions.Sort(Comparer);
}
else
{
_extensions.Insert(at, meta);
}
}
public void Remove(NavMeshExtension extension)
{
_extensions.RemoveAll(x => x.extension = extension);
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshExtensionsProvider.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: dc9c5ff0af7a2f247a2c64921cf9d045
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: e8142b1daeea8d3419cd0ffbd7b17a37, type: 3}
userData:
assetBundleName:
assetBundleVariant:

182
Assets/NavMeshComponents/Scripts/NavMeshLink.cs
View File

@ -1,182 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using NavMeshPlus.Extensions;
namespace NavMeshPlus.Components
{
[ExecuteInEditMode]
[DefaultExecutionOrder(-101)]
[AddComponentMenu("Navigation/Navigation Link", 33)]
[HelpURL("https://github.com/Unity-Technologies/NavMeshPlus#documentation-draft")]
public class NavMeshLink : MonoBehaviour
{
[SerializeField, NavMeshAgent]
int m_AgentTypeID;
public int agentTypeID { get { return m_AgentTypeID; } set { m_AgentTypeID = value; UpdateLink(); } }
[SerializeField]
Vector3 m_StartPoint = new Vector3(0.0f, 0.0f, -2.5f);
public Vector3 startPoint { get { return m_StartPoint; } set { m_StartPoint = value; UpdateLink(); } }
[SerializeField]
Vector3 m_EndPoint = new Vector3(0.0f, 0.0f, 2.5f);
public Vector3 endPoint { get { return m_EndPoint; } set { m_EndPoint = value; UpdateLink(); } }
[SerializeField]
float m_Width;
public float width { get { return m_Width; } set { m_Width = value; UpdateLink(); } }
[SerializeField]
int m_CostModifier = -1;
public int costModifier { get { return m_CostModifier; } set { m_CostModifier = value; UpdateLink(); } }
[SerializeField]
bool m_Bidirectional = true;
public bool bidirectional { get { return m_Bidirectional; } set { m_Bidirectional = value; UpdateLink(); } }
[SerializeField]
bool m_AutoUpdatePosition;
public bool autoUpdate { get { return m_AutoUpdatePosition; } set { SetAutoUpdate(value); } }
[SerializeField, NavMeshArea]
int m_Area;
public int area { get { return m_Area; } set { m_Area = value; UpdateLink(); } }
NavMeshLinkInstance m_LinkInstance = new NavMeshLinkInstance();
Vector3 m_LastPosition = Vector3.zero;
Quaternion m_LastRotation = Quaternion.identity;
static readonly List<NavMeshLink> s_Tracked = new List<NavMeshLink>();
void OnEnable()
{
AddLink();
// 수정: .valid 대신 NavMesh.IsLinkValid() 사용
if (m_AutoUpdatePosition && NavMesh.IsLinkValid(m_LinkInstance))
AddTracking(this);
}
void OnDisable()
{
RemoveTracking(this);
// 수정: .Remove() 대신 NavMesh.RemoveLink() 사용
NavMesh.RemoveLink(m_LinkInstance);
}
public void UpdateLink()
{
// 수정: .Remove() 대신 NavMesh.RemoveLink() 사용
NavMesh.RemoveLink(m_LinkInstance);
AddLink();
}
static void AddTracking(NavMeshLink link)
{
#if UNITY_EDITOR
if (s_Tracked.Contains(link))
{
Debug.LogError("Link is already tracked: " + link);
return;
}
#endif
if (s_Tracked.Count == 0)
NavMesh.onPreUpdate += UpdateTrackedInstances;
s_Tracked.Add(link);
}
static void RemoveTracking(NavMeshLink link)
{
s_Tracked.Remove(link);
if (s_Tracked.Count == 0)
NavMesh.onPreUpdate -= UpdateTrackedInstances;
}
void SetAutoUpdate(bool value)
{
if (m_AutoUpdatePosition == value)
return;
m_AutoUpdatePosition = value;
if (value)
AddTracking(this);
else
RemoveTracking(this);
}
void AddLink()
{
#if UNITY_EDITOR
// 수정: .valid 대신 NavMesh.IsLinkValid() 사용
if (NavMesh.IsLinkValid(m_LinkInstance))
{
Debug.LogError("Link is already added: " + this);
return;
}
#endif
var link = new NavMeshLinkData();
link.startPosition = m_StartPoint;
link.endPosition = m_EndPoint;
link.width = m_Width;
link.costModifier = m_CostModifier;
link.bidirectional = m_Bidirectional;
link.area = m_Area;
link.agentTypeID = m_AgentTypeID;
m_LinkInstance = NavMesh.AddLink(link, transform.position, transform.rotation);
// 수정: .valid 및 .owner를 최신 API로 변경
if (NavMesh.IsLinkValid(m_LinkInstance))
NavMesh.SetLinkOwner(m_LinkInstance, this);
m_LastPosition = transform.position;
m_LastRotation = transform.rotation;
}
bool HasTransformChanged()
{
if (m_LastPosition != transform.position) return true;
if (m_LastRotation != transform.rotation) return true;
return false;
}
void OnDidApplyAnimationProperties()
{
UpdateLink();
}
static void UpdateTrackedInstances()
{
foreach (var instance in s_Tracked)
{
if (instance.HasTransformChanged())
instance.UpdateLink();
}
}
#if UNITY_EDITOR
void OnValidate()
{
m_Width = Mathf.Max(0.0f, m_Width);
// 수정: .valid 대신 NavMesh.IsLinkValid() 사용
if (!NavMesh.IsLinkValid(m_LinkInstance))
return;
UpdateLink();
if (!m_AutoUpdatePosition)
{
RemoveTracking(this);
}
else if (!s_Tracked.Contains(this))
{
AddTracking(this);
}
}
#endif
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshLink.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 9b9acdb93a5f98644a2e18d4884f04e2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 68ad4f5d6fe957c4789aedd21ff67ced, type: 3}
userData:
assetBundleName:
assetBundleVariant:

56
Assets/NavMeshComponents/Scripts/NavMeshModifier.cs
View File

@ -1,56 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
using NavMeshPlus.Extensions;
namespace NavMeshPlus.Components
{
[ExecuteInEditMode]
[AddComponentMenu("Navigation/Navigation Modifier", 32)]
[HelpURL("https://github.com/Unity-Technologies/NavMeshComponents#documentation-draft")]
public class NavMeshModifier : MonoBehaviour
{
[SerializeField]
bool m_OverrideArea;
public bool overrideArea { get { return m_OverrideArea; } set { m_OverrideArea = value; } }
[SerializeField, NavMeshArea]
int m_Area;
public int area { get { return m_Area; } set { m_Area = value; } }
[SerializeField]
bool m_IgnoreFromBuild;
public bool ignoreFromBuild { get { return m_IgnoreFromBuild; } set { m_IgnoreFromBuild = value; } }
// List of agent types the modifier is applied for.
// Special values: empty == None, m_AffectedAgents[0] =-1 == All.
[SerializeField]
List<int> m_AffectedAgents = new List<int>(new int[] { -1 }); // Default value is All
static readonly List<NavMeshModifier> s_NavMeshModifiers = new List<NavMeshModifier>();
public static List<NavMeshModifier> activeModifiers
{
get { return s_NavMeshModifiers; }
}
void OnEnable()
{
if (!s_NavMeshModifiers.Contains(this))
s_NavMeshModifiers.Add(this);
}
void OnDisable()
{
s_NavMeshModifiers.Remove(this);
}
public bool AffectsAgentType(int agentTypeID)
{
if (m_AffectedAgents.Count == 0)
return false;
if (m_AffectedAgents[0] == -1)
return true;
return m_AffectedAgents.IndexOf(agentTypeID) != -1;
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshModifier.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 9809bf1345abc5648af68b3a82653f08
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 273c8b5db6e39534781066db3444fe88, type: 3}
userData:
assetBundleName:
assetBundleVariant:

83
Assets/NavMeshComponents/Scripts/NavMeshModifierTilemap.cs
View File

@ -1,83 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using NavMeshPlus.Extensions;
using UnityEngine.Tilemaps;
//***********************************************************************************
// Contributed by author jl-randazzo github.com/jl-randazzo
//***********************************************************************************
namespace NavMeshPlus.Components
{
[AddComponentMenu("Navigation/Navigation Modifier Tilemap", 33)]
[HelpURL("https://github.com/Unity-Technologies/NavMeshComponents#documentation-draft")]
[RequireComponent(typeof(Tilemap))]
[RequireComponent(typeof(NavMeshModifier))]
[DisallowMultipleComponent]
[ExecuteInEditMode]
public class NavMeshModifierTilemap : MonoBehaviour
{
[System.Serializable]
public struct TileModifier
{
public TileBase tile;
public bool overrideArea;
[NavMeshArea] public int area;
}
private class MatchingTileComparator : IEqualityComparer<TileModifier>
{
public static readonly IEqualityComparer<TileModifier> Instance = new MatchingTileComparator();
public bool Equals(TileModifier a, TileModifier b) => a.tile == b.tile;
public int GetHashCode(TileModifier tileModifier) => tileModifier.GetHashCode();
}
// List of agent types the modifier is applied for.
// Special values: empty == None, m_AffectedAgents[0] =-1 == All.
[SerializeField]
List<int> m_AffectedAgents = new List<int>(new int[] { -1 }); // Default value is All
[SerializeField]
List<TileModifier> m_TileModifiers = new List<TileModifier>();
private Dictionary<TileBase, TileModifier> m_ModifierMap;
public Dictionary<TileBase, TileModifier> GetModifierMap() => m_TileModifiers.Where(mod => mod.tile != null).Distinct(MatchingTileComparator.Instance).ToDictionary(mod => mod.tile);
void OnEnable()
{
CacheModifiers();
}
public void CacheModifiers()
{
m_ModifierMap = GetModifierMap();
}
#if UNITY_EDITOR
public bool HasDuplicateTileModifiers()
{
return m_TileModifiers.Count != m_TileModifiers.Distinct(MatchingTileComparator.Instance).Count();
}
#endif // UNITY_EDITOR
public virtual bool TryGetTileModifier(Vector3Int coords, Tilemap tilemap, out TileModifier modifier)
{
if (tilemap.GetTile(coords) is TileBase tileBase)
{
return m_ModifierMap.TryGetValue(tileBase, out modifier);
}
modifier = new TileModifier();
return false;
}
public bool AffectsAgentType(int agentTypeID)
{
if (m_AffectedAgents.Count == 0)
return false;
if (m_AffectedAgents[0] == -1)
return true;
return m_AffectedAgents.IndexOf(agentTypeID) != -1;
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshModifierTilemap.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 709c8d6349be44c68dff3d220992400c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 273c8b5db6e39534781066db3444fe88, type: 3}
userData:
assetBundleName:
assetBundleVariant:

56
Assets/NavMeshComponents/Scripts/NavMeshModifierVolume.cs
View File

@ -1,56 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
using NavMeshPlus.Extensions;
namespace NavMeshPlus.Components
{
[ExecuteInEditMode]
[AddComponentMenu("Navigation/Navigation ModifierVolume", 31)]
[HelpURL("https://github.com/Unity-Technologies/NavMeshComponents#documentation-draft")]
public class NavMeshModifierVolume : MonoBehaviour
{
[SerializeField]
Vector3 m_Size = new Vector3(4.0f, 3.0f, 4.0f);
public Vector3 size { get { return m_Size; } set { m_Size = value; } }
[SerializeField]
Vector3 m_Center = new Vector3(0, 1.0f, 0);
public Vector3 center { get { return m_Center; } set { m_Center = value; } }
[SerializeField, NavMeshArea]
int m_Area;
public int area { get { return m_Area; } set { m_Area = value; } }
// List of agent types the modifier is applied for.
// Special values: empty == None, m_AffectedAgents[0] =-1 == All.
[SerializeField]
List<int> m_AffectedAgents = new List<int>(new int[] { -1 }); // Default value is All
static readonly List<NavMeshModifierVolume> s_NavMeshModifiers = new List<NavMeshModifierVolume>();
public static List<NavMeshModifierVolume> activeModifiers
{
get { return s_NavMeshModifiers; }
}
void OnEnable()
{
if (!s_NavMeshModifiers.Contains(this))
s_NavMeshModifiers.Add(this);
}
void OnDisable()
{
s_NavMeshModifiers.Remove(this);
}
public bool AffectsAgentType(int agentTypeID)
{
if (m_AffectedAgents.Count == 0)
return false;
if (m_AffectedAgents[0] == -1)
return true;
return m_AffectedAgents.IndexOf(agentTypeID) != -1;
}
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshModifierVolume.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7fa0352a4d56abd42ad2fc69deb72448
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 273c8b5db6e39534781066db3444fe88, type: 3}
userData:
assetBundleName:
assetBundleVariant:

551
Assets/NavMeshComponents/Scripts/NavMeshSurface.cs
View File

@ -1,551 +0,0 @@
using NavMeshPlus.Extensions;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.SceneManagement;
#endif
namespace NavMeshPlus.Components
{
public enum CollectObjects
{
All = 0,
Volume = 1,
Children = 2,
}
[ExecuteAlways]
[DefaultExecutionOrder(-102)]
[AddComponentMenu("Navigation/Navigation Surface", 30)]
[HelpURL("https://github.com/Unity-Technologies/NavMeshComponents#documentation-draft")]
public class NavMeshSurface : MonoBehaviour
{
[SerializeField, NavMeshAgent]
int m_AgentTypeID;
public int agentTypeID { get { return m_AgentTypeID; } set { m_AgentTypeID = value; } }
[SerializeField]
CollectObjects m_CollectObjects = CollectObjects.All;
public CollectObjects collectObjects { get { return m_CollectObjects; } set { m_CollectObjects = value; } }
[SerializeField]
Vector3 m_Size = new Vector3(10.0f, 10.0f, 10.0f);
public Vector3 size { get { return m_Size; } set { m_Size = value; } }
[SerializeField]
Vector3 m_Center = new Vector3(0, 2.0f, 0);
public Vector3 center { get { return m_Center; } set { m_Center = value; } }
[SerializeField]
LayerMask m_LayerMask = ~0;
public LayerMask layerMask { get { return m_LayerMask; } set { m_LayerMask = value; } }
[SerializeField]
NavMeshCollectGeometry m_UseGeometry = NavMeshCollectGeometry.RenderMeshes;
public NavMeshCollectGeometry useGeometry { get { return m_UseGeometry; } set { m_UseGeometry = value; } }
[SerializeField, NavMeshArea]
int m_DefaultArea;
public int defaultArea { get { return m_DefaultArea; } set { m_DefaultArea = value; } }
[SerializeField]
bool m_IgnoreNavMeshAgent = true;
public bool ignoreNavMeshAgent { get { return m_IgnoreNavMeshAgent; } set { m_IgnoreNavMeshAgent = value; } }
[SerializeField]
bool m_IgnoreNavMeshObstacle = true;
public bool ignoreNavMeshObstacle { get { return m_IgnoreNavMeshObstacle; } set { m_IgnoreNavMeshObstacle = value; } }
[SerializeField]
bool m_OverrideTileSize;
public bool overrideTileSize { get { return m_OverrideTileSize; } set { m_OverrideTileSize = value; } }
[SerializeField]
int m_TileSize = 256;
public int tileSize { get { return m_TileSize; } set { m_TileSize = value; } }
[SerializeField]
bool m_OverrideVoxelSize;
public bool overrideVoxelSize { get { return m_OverrideVoxelSize; } set { m_OverrideVoxelSize = value; } }
[SerializeField]
float m_VoxelSize;
public float voxelSize { get { return m_VoxelSize; } set { m_VoxelSize = value; } }
// Currently not supported advanced options
[SerializeField]
bool m_BuildHeightMesh;
public bool buildHeightMesh { get { return m_BuildHeightMesh; } set { m_BuildHeightMesh = value; } }
[SerializeField]
float m_MinRegionArea = 0;
public float minRegionArea { get { return m_MinRegionArea; } set { m_MinRegionArea = value; } }
[SerializeField]
bool m_HideEditorLogs;
public bool hideEditorLogs { get { return m_HideEditorLogs; } set { m_HideEditorLogs = value; } }
// Reference to whole scene navmesh data asset.
[UnityEngine.Serialization.FormerlySerializedAs("m_BakedNavMeshData")]
[SerializeField]
NavMeshData m_NavMeshData;
public NavMeshData navMeshData { get { return m_NavMeshData; } set { m_NavMeshData = value; } }
// Do not serialize - runtime only state.
NavMeshDataInstance m_NavMeshDataInstance;
Vector3 m_LastPosition = Vector3.zero;
Quaternion m_LastRotation = Quaternion.identity;
public NavMeshDataInstance navMeshDataInstance => m_NavMeshDataInstance;
static readonly List<NavMeshSurface> s_NavMeshSurfaces = new List<NavMeshSurface>();
public INavMeshExtensionsProvider NevMeshExtensions { get; set; } = new NavMeshExtensionsProvider();
public static List<NavMeshSurface> activeSurfaces
{
get { return s_NavMeshSurfaces; }
}
void OnEnable()
{
Register(this);
AddData();
}
void OnDisable()
{
RemoveData();
Unregister(this);
}
public void AddData()
{
#if UNITY_EDITOR
var isInPreviewScene = EditorSceneManager.IsPreviewSceneObject(this);
var isPrefab = isInPreviewScene || EditorUtility.IsPersistent(this);
if (isPrefab)
{
//Debug.LogFormat("NavMeshData from {0}.{1} will not be added to the NavMesh world because the gameObject is a prefab.",
// gameObject.name, name);
return;
}
#endif
if (m_NavMeshDataInstance.valid)
return;
if (m_NavMeshData != null)
{
m_NavMeshDataInstance = NavMesh.AddNavMeshData(m_NavMeshData, transform.position, transform.rotation);
m_NavMeshDataInstance.owner = this;
}
m_LastPosition = transform.position;
m_LastRotation = transform.rotation;
}
public void RemoveData()
{
m_NavMeshDataInstance.Remove();
m_NavMeshDataInstance = new NavMeshDataInstance();
}
public NavMeshBuildSettings GetBuildSettings()
{
var buildSettings = NavMesh.GetSettingsByID(m_AgentTypeID);
if (buildSettings.agentTypeID == -1)
{
if (!m_HideEditorLogs) Debug.LogWarning("No build settings for agent type ID " + agentTypeID, this);
buildSettings.agentTypeID = m_AgentTypeID;
}
if (overrideTileSize)
{
buildSettings.overrideTileSize = true;
buildSettings.tileSize = tileSize;
}
if (overrideVoxelSize)
{
buildSettings.overrideVoxelSize = true;
buildSettings.voxelSize = voxelSize;
}
buildSettings.minRegionArea = minRegionArea;
return buildSettings;
}
public void BuildNavMesh()
{
using var builderState = new NavMeshBuilderState() { };
var sources = CollectSources(builderState);
// Use unscaled bounds - this differs in behaviour from e.g. collider components.
// But is similar to reflection probe - and since navmesh data has no scaling support - it is the right choice here.
var sourcesBounds = new Bounds(m_Center, Abs(m_Size));
if (m_CollectObjects == CollectObjects.All || m_CollectObjects == CollectObjects.Children)
{
sourcesBounds = CalculateWorldBounds(sources);
}
builderState.worldBounds = sourcesBounds;
for (int i = 0; i < NevMeshExtensions.Count; ++i)
{
NevMeshExtensions[i].PostCollectSources(this, sources, builderState);
}
var data = NavMeshBuilder.BuildNavMeshData(GetBuildSettings(),
sources, sourcesBounds, transform.position, transform.rotation);
if (data != null)
{
data.name = gameObject.name;
RemoveData();
m_NavMeshData = data;
if (isActiveAndEnabled)
AddData();
}
}
// Source: https://github.com/Unity-Technologies/NavMeshComponents/issues/97#issuecomment-528692289
public AsyncOperation BuildNavMeshAsync()
{
RemoveData();
m_NavMeshData = new NavMeshData(m_AgentTypeID)
{
name = gameObject.name,
position = transform.position,
rotation = transform.rotation
};
if (isActiveAndEnabled)
{
AddData();
}
return UpdateNavMesh(m_NavMeshData);
}
public AsyncOperation UpdateNavMesh(NavMeshData data)
{
using var builderState = new NavMeshBuilderState() { };
var sources = CollectSources(builderState);
// Use unscaled bounds - this differs in behaviour from e.g. collider components.
// But is similar to reflection probe - and since navmesh data has no scaling support - it is the right choice here.
var sourcesBounds = new Bounds(m_Center, Abs(m_Size));
if (m_CollectObjects == CollectObjects.All || m_CollectObjects == CollectObjects.Children)
{
sourcesBounds = CalculateWorldBounds(sources);
}
builderState.worldBounds = sourcesBounds;
for (int i = 0; i < NevMeshExtensions.Count; ++i)
{
NevMeshExtensions[i].PostCollectSources(this, sources, builderState);
}
return NavMeshBuilder.UpdateNavMeshDataAsync(data, GetBuildSettings(), sources, sourcesBounds);
}
static void Register(NavMeshSurface surface)
{
#if UNITY_EDITOR
var isInPreviewScene = EditorSceneManager.IsPreviewSceneObject(surface);
var isPrefab = isInPreviewScene || EditorUtility.IsPersistent(surface);
if (isPrefab)
{
//Debug.LogFormat("NavMeshData from {0}.{1} will not be added to the NavMesh world because the gameObject is a prefab.",
// surface.gameObject.name, surface.name);
return;
}
#endif
if (s_NavMeshSurfaces.Count == 0)
NavMesh.onPreUpdate += UpdateActive;
if (!s_NavMeshSurfaces.Contains(surface))
s_NavMeshSurfaces.Add(surface);
}
static void Unregister(NavMeshSurface surface)
{
s_NavMeshSurfaces.Remove(surface);
if (s_NavMeshSurfaces.Count == 0)
NavMesh.onPreUpdate -= UpdateActive;
}
static void UpdateActive()
{
for (var i = 0; i < s_NavMeshSurfaces.Count; ++i)
s_NavMeshSurfaces[i].UpdateDataIfTransformChanged();
}
void AppendModifierVolumes(ref List<NavMeshBuildSource> sources)
{
#if UNITY_EDITOR
var myStage = StageUtility.GetStageHandle(gameObject);
if (!myStage.IsValid())
return;
#endif
// Modifiers
List<NavMeshModifierVolume> modifiers;
if (m_CollectObjects == CollectObjects.Children)
{
modifiers = new List<NavMeshModifierVolume>(GetComponentsInChildren<NavMeshModifierVolume>());
modifiers.RemoveAll(x => !x.isActiveAndEnabled);
}
else
{
modifiers = NavMeshModifierVolume.activeModifiers;
}
foreach (var m in modifiers)
{
if ((m_LayerMask & (1 << m.gameObject.layer)) == 0)
continue;
if (!m.AffectsAgentType(m_AgentTypeID))
continue;
#if UNITY_EDITOR
if (!myStage.Contains(m.gameObject))
continue;
#endif
var mcenter = m.transform.TransformPoint(m.center);
var scale = m.transform.lossyScale;
var msize = new Vector3(m.size.x * Mathf.Abs(scale.x), m.size.y * Mathf.Abs(scale.y), m.size.z * Mathf.Abs(scale.z));
var src = new NavMeshBuildSource();
src.shape = NavMeshBuildSourceShape.ModifierBox;
src.transform = Matrix4x4.TRS(mcenter, m.transform.rotation, Vector3.one);
src.size = msize;
src.area = m.area;
sources.Add(src);
}
}
List<NavMeshBuildSource> CollectSources(NavMeshBuilderState builderState)
{
var sources = new List<NavMeshBuildSource>();
var markups = new List<NavMeshBuildMarkup>();
List<NavMeshModifier> modifiers;
if (m_CollectObjects == CollectObjects.Children)
{
modifiers = new List<NavMeshModifier>(GetComponentsInChildren<NavMeshModifier>());
modifiers.RemoveAll(x => !x.isActiveAndEnabled);
}
else
{
modifiers = NavMeshModifier.activeModifiers;
}
foreach (var m in modifiers)
{
if ((m_LayerMask & (1 << m.gameObject.layer)) == 0)
continue;
if (!m.AffectsAgentType(m_AgentTypeID))
continue;
var markup = new NavMeshBuildMarkup();
markup.root = m.transform;
markup.overrideArea = m.overrideArea;
markup.area = m.area;
markup.ignoreFromBuild = m.ignoreFromBuild;
markups.Add(markup);
}
#if UNITY_EDITOR
if (!EditorApplication.isPlaying)
{
if (m_CollectObjects == CollectObjects.All)
{
UnityEditor.AI.NavMeshEditorHelpers.CollectSourcesInStage(
null, m_LayerMask, m_UseGeometry, m_DefaultArea, markups, gameObject.scene, sources);
}
else if (m_CollectObjects == CollectObjects.Children)
{
UnityEditor.AI.NavMeshEditorHelpers.CollectSourcesInStage(
transform, m_LayerMask, m_UseGeometry, m_DefaultArea, markups, gameObject.scene, sources);
}
else if (m_CollectObjects == CollectObjects.Volume)
{
Matrix4x4 localToWorld = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
var worldBounds = GetWorldBounds(localToWorld, new Bounds(m_Center, m_Size));
UnityEditor.AI.NavMeshEditorHelpers.CollectSourcesInStage(
worldBounds, m_LayerMask, m_UseGeometry, m_DefaultArea, markups, gameObject.scene, sources);
}
for (int i = 0; i < NevMeshExtensions.Count; ++i)
{
NevMeshExtensions[i].CollectSources(this, sources, builderState);
}
}
else
#endif
{
if (m_CollectObjects == CollectObjects.All)
{
NavMeshBuilder.CollectSources(null, m_LayerMask, m_UseGeometry, m_DefaultArea, markups, sources);
}
else if (m_CollectObjects == CollectObjects.Children)
{
NavMeshBuilder.CollectSources(transform, m_LayerMask, m_UseGeometry, m_DefaultArea, markups, sources);
}
else if (m_CollectObjects == CollectObjects.Volume)
{
Matrix4x4 localToWorld = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
var worldBounds = GetWorldBounds(localToWorld, new Bounds(m_Center, m_Size));
NavMeshBuilder.CollectSources(worldBounds, m_LayerMask, m_UseGeometry, m_DefaultArea, markups, sources);
}
for (int i = 0; i < NevMeshExtensions.Count; ++i)
{
NevMeshExtensions[i].CollectSources(this, sources, builderState);
}
}
if (m_IgnoreNavMeshAgent)
sources.RemoveAll((x) => (x.component != null && x.component.gameObject.GetComponent<NavMeshAgent>() != null));
if (m_IgnoreNavMeshObstacle)
sources.RemoveAll((x) => (x.component != null && x.component.gameObject.GetComponent<NavMeshObstacle>() != null));
AppendModifierVolumes(ref sources);
return sources;
}
static Vector3 Abs(Vector3 v)
{
return new Vector3(Mathf.Abs(v.x), Mathf.Abs(v.y), Mathf.Abs(v.z));
}
public static Bounds GetWorldBounds(Matrix4x4 mat, Bounds bounds)
{
var absAxisX = Abs(mat.MultiplyVector(Vector3.right));
var absAxisY = Abs(mat.MultiplyVector(Vector3.up));
var absAxisZ = Abs(mat.MultiplyVector(Vector3.forward));
var worldPosition = mat.MultiplyPoint(bounds.center);
var worldSize = absAxisX * bounds.size.x + absAxisY * bounds.size.y + absAxisZ * bounds.size.z;
return new Bounds(worldPosition, worldSize);
}
public Bounds CalculateWorldBounds(List<NavMeshBuildSource> sources)
{
// Use the unscaled matrix for the NavMeshSurface
Matrix4x4 worldToLocal = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
worldToLocal = worldToLocal.inverse;
var result = new Bounds();
var builderState = new NavMeshBuilderState() { worldBounds = result, worldToLocal = worldToLocal };
for (int i = 0; i < NevMeshExtensions.Count; ++i)
{
NevMeshExtensions[i].CalculateWorldBounds(this, sources, builderState);
result.Encapsulate(builderState.worldBounds);
}
foreach (var src in sources)
{
switch (src.shape)
{
case NavMeshBuildSourceShape.Mesh:
{
var m = src.sourceObject as Mesh;
result.Encapsulate(GetWorldBounds(worldToLocal * src.transform, m.bounds));
break;
}
case NavMeshBuildSourceShape.Terrain:
{
#if IS_TERRAIN_USED
// Terrain pivot is lower/left corner - shift bounds accordingly
var t = src.sourceObject as TerrainData;
result.Encapsulate(GetWorldBounds(worldToLocal * src.transform, new Bounds(0.5f * t.size, t.size)));
#endif
break;
}
case NavMeshBuildSourceShape.Box:
case NavMeshBuildSourceShape.Sphere:
case NavMeshBuildSourceShape.Capsule:
case NavMeshBuildSourceShape.ModifierBox:
result.Encapsulate(GetWorldBounds(worldToLocal * src.transform, new Bounds(Vector3.zero, src.size)));
break;
}
}
// Inflate the bounds a bit to avoid clipping co-planar sources
result.Expand(0.1f);
return result;
}
bool HasTransformChanged()
{
if (m_LastPosition != transform.position) return true;
if (m_LastRotation != transform.rotation) return true;
return false;
}
void UpdateDataIfTransformChanged()
{
if (HasTransformChanged())
{
RemoveData();
AddData();
}
}
#if UNITY_EDITOR
bool UnshareNavMeshAsset()
{
// Nothing to unshare
if (m_NavMeshData == null)
return false;
// Prefab parent owns the asset reference
var isInPreviewScene = EditorSceneManager.IsPreviewSceneObject(this);
var isPersistentObject = EditorUtility.IsPersistent(this);
if (isInPreviewScene || isPersistentObject)
return false;
// An instance can share asset reference only with its prefab parent
var prefab = UnityEditor.PrefabUtility.GetCorrespondingObjectFromSource(this) as NavMeshSurface;
if (prefab != null && prefab.navMeshData == navMeshData)
return false;
// Don't allow referencing an asset that's assigned to another surface
for (var i = 0; i < s_NavMeshSurfaces.Count; ++i)
{
var surface = s_NavMeshSurfaces[i];
if (surface != this && surface.m_NavMeshData == m_NavMeshData)
return true;
}
// Asset is not referenced by known surfaces
return false;
}
void OnValidate()
{
if (UnshareNavMeshAsset())
{
if (!m_HideEditorLogs) Debug.LogWarning("Duplicating NavMeshSurface does not duplicate the referenced navmesh data", this);
m_NavMeshData = null;
}
var settings = NavMesh.GetSettingsByID(m_AgentTypeID);
if (settings.agentTypeID != -1)
{
// When unchecking the override control, revert to automatic value.
const float kMinVoxelSize = 0.01f;
if (!m_OverrideVoxelSize)
m_VoxelSize = settings.agentRadius / 3.0f;
if (m_VoxelSize < kMinVoxelSize)
m_VoxelSize = kMinVoxelSize;
// When unchecking the override control, revert to default value.
const int kMinTileSize = 16;
const int kMaxTileSize = 1024;
const int kDefaultTileSize = 256;
if (!m_OverrideTileSize)
m_TileSize = kDefaultTileSize;
// Make sure tilesize is in sane range.
if (m_TileSize < kMinTileSize)
m_TileSize = kMinTileSize;
if (m_TileSize > kMaxTileSize)
m_TileSize = kMaxTileSize;
}
}
#endif
}
}

11
Assets/NavMeshComponents/Scripts/NavMeshSurface.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: e04976799df50f54ba128eff723155a7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: 444810ca896903c41adf617b35274dc4, type: 3}
userData:
assetBundleName:
assetBundleVariant:

32
Assets/NavMeshComponents/Scripts/RootSources2d.cs
View File

@ -1,32 +0,0 @@
using NavMeshPlus.Components;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.AI;
namespace NavMeshPlus.Extensions
{
[ExecuteAlways]
[AddComponentMenu("Navigation/Navigation RootSources2d", 30)]
public class RootSources2d: NavMeshExtension
{
[SerializeField]
private List<GameObject> _rootSources;
public List<GameObject> RootSources { get => _rootSources; set => _rootSources = value; }
protected override void Awake()
{
Order = -1000;
base.Awake();
}
public override void CollectSources(NavMeshSurface surface, List<NavMeshBuildSource> sources, NavMeshBuilderState navNeshState)
{
navNeshState.roots = _rootSources;
}
}
}

11
Assets/NavMeshComponents/Scripts/RootSources2d.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 6fec7b7904f76c4498a68fd145934563
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: d5b0e13ebe59cd64e9f67284457c6868, type: 3}
userData:
assetBundleName:
assetBundleVariant:

40
Assets/NavMeshComponents/Scripts/RotateAgentInstantly.cs
View File

@ -1,40 +0,0 @@
using UnityEngine;
using UnityEngine.AI;
//***********************************************************************************
// Contributed by author @Lazy_Sloth from unity forum (https://forum.unity.com/)
//***********************************************************************************
namespace NavMeshPlus.Extensions
{
public class RotateAgentInstantly: IAgentOverride
{
public RotateAgentInstantly(NavMeshAgent agent, AgentOverride2d owner)
{
this.agent = agent;
this.owner = owner;
}
private NavMeshAgent agent;
private AgentOverride2d owner;
private Vector3 nextWaypoint;
public void UpdateAgent()
{
if (agent.hasPath && agent.path.corners.Length > 1)
{
if (nextWaypoint != agent.path.corners[1])
{
RotateToPoint(agent.path.corners[1], agent.transform);
nextWaypoint = agent.path.corners[1];
}
}
}
private static void RotateToPoint(Vector3 targetPoint, Transform transform)
{
Vector3 targetVector = targetPoint - transform.position;
float angleDifference = Vector2.SignedAngle(transform.up, targetVector);
transform.rotation = Quaternion.Euler(0, 0, transform.localEulerAngles.z + angleDifference);
}
}
}

11
Assets/NavMeshComponents/Scripts/RotateAgentInstantly.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 5b304bdab91a28c469562d02b8225df3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: e8142b1daeea8d3419cd0ffbd7b17a37, type: 3}
userData:
assetBundleName:
assetBundleVariant:

57
Assets/NavMeshComponents/Scripts/RotateAgentSmoothly.cs
View File

@ -1,57 +0,0 @@
using System.Collections;
using UnityEngine;
using UnityEngine.AI;
//***********************************************************************************
// Contributed by author @Lazy_Sloth from unity forum (https://forum.unity.com/)
//***********************************************************************************
namespace NavMeshPlus.Extensions
{
public class RotateAgentSmoothly: IAgentOverride
{
public RotateAgentSmoothly(NavMeshAgent agent, AgentOverride2d owner, float rotateSpeed)
{
this.agent = agent;
this.owner = owner;
this.rotateSpeed = rotateSpeed;
}
private NavMeshAgent agent;
private AgentOverride2d owner;
private Vector2 nextWaypoint;
private float angleDifference;
private float targetAngle;
public float rotateSpeed;
public void UpdateAgent()
{
if (agent.hasPath && agent.path.corners.Length > 1)
{
if (nextWaypoint != (Vector2)agent.path.corners[1])
{
owner.StartCoroutine(_RotateCoroutine());
nextWaypoint = agent.path.corners[1];
}
}
}
protected IEnumerator _RotateCoroutine()
{
yield return RotateToWaypoints(agent.transform);
}
protected IEnumerator RotateToWaypoints(Transform transform)
{
Vector2 targetVector = agent.path.corners[1] - transform.position;
angleDifference = Vector2.SignedAngle(transform.up, targetVector);
targetAngle = transform.localEulerAngles.z + angleDifference;
if (targetAngle >= 360) { targetAngle -= 360; }
else if (targetAngle < 0) { targetAngle += 360; }
while (transform.localEulerAngles.z < targetAngle - 0.1f || transform.localEulerAngles.z > targetAngle + 0.1f)
{
transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.Euler(0, 0, targetAngle), rotateSpeed * Time.deltaTime);
yield return null;
}
}
}
}

11
Assets/NavMeshComponents/Scripts/RotateAgentSmoothly.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 7f8df5c105d35bd4787c3b4ce3e1c56b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {fileID: 2800000, guid: e8142b1daeea8d3419cd0ffbd7b17a37, type: 3}
userData:
assetBundleName:
assetBundleVariant:

171
Assets/Prefabs/Player.prefab
View File

@ -91,6 +91,144 @@ SpriteRenderer:
m_SpriteTileMode: 0
m_WasSpriteAssigned: 1
m_SpriteSortPoint: 0
--- !u!1 &3357814546354036735
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 2455266088112389998}
- component: {fileID: 5127678640415276595}
- component: {fileID: 8697187445213062801}
m_Layer: 0
m_Name: Foot
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &2455266088112389998
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 3357814546354036735}
serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 4539706167822133972}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!212 &5127678640415276595
SpriteRenderer:
serializedVersion: 2
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 3357814546354036735}
m_Enabled: 0
m_CastShadows: 0
m_ReceiveShadows: 0
m_DynamicOccludee: 1
m_StaticShadowCaster: 0
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_RayTracingMode: 0
m_RayTraceProcedural: 0
m_RayTracingAccelStructBuildFlagsOverride: 0
m_RayTracingAccelStructBuildFlags: 1
m_SmallMeshCulling: 1
m_ForceMeshLod: -1
m_MeshLodSelectionBias: 0
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
- {fileID: 2100000, guid: a97c105638bdf8b4a8650670310a4cd3, type: 2}
m_StaticBatchInfo:
firstSubMesh: 0
subMeshCount: 0
m_StaticBatchRoot: {fileID: 0}
m_ProbeAnchor: {fileID: 0}
m_LightProbeVolumeOverride: {fileID: 0}
m_ScaleInLightmap: 1
m_ReceiveGI: 1
m_PreserveUVs: 0
m_IgnoreNormalsForChartDetection: 0
m_ImportantGI: 0
m_StitchLightmapSeams: 1
m_SelectedEditorRenderState: 0
m_MinimumChartSize: 4
m_AutoUVMaxDistance: 0.5
m_AutoUVMaxAngle: 89
m_LightmapParameters: {fileID: 0}
m_GlobalIlluminationMeshLod: 0
m_SortingLayerID: 0
m_SortingLayer: 0
m_SortingOrder: 0
m_MaskInteraction: 0
m_Sprite: {fileID: 7482667652216324306, guid: 311925a002f4447b3a28927169b83ea6, type: 3}
m_Color: {r: 1, g: 1, b: 1, a: 1}
m_FlipX: 0
m_FlipY: 0
m_DrawMode: 0
m_Size: {x: 1, y: 1}
m_AdaptiveModeThreshold: 0.5
m_SpriteTileMode: 0
m_WasSpriteAssigned: 1
m_SpriteSortPoint: 0
--- !u!61 &8697187445213062801
BoxCollider2D:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 3357814546354036735}
m_Enabled: 1
serializedVersion: 3
m_Density: 1
m_Material: {fileID: 0}
m_IncludeLayers:
serializedVersion: 2
m_Bits: 0
m_ExcludeLayers:
serializedVersion: 2
m_Bits: 0
m_LayerOverridePriority: 0
m_ForceSendLayers:
serializedVersion: 2
m_Bits: 4294967295
m_ForceReceiveLayers:
serializedVersion: 2
m_Bits: 4294967295
m_ContactCaptureLayers:
serializedVersion: 2
m_Bits: 4294967295
m_CallbackLayers:
serializedVersion: 2
m_Bits: 4294967295
m_IsTrigger: 1
m_UsedByEffector: 0
m_CompositeOperation: 0
m_CompositeOrder: 0
m_Offset: {x: 0, y: -0.96}
m_SpriteTilingProperty:
border: {x: 0, y: 0, z: 0, w: 0}
pivot: {x: 0.5, y: 0.5}
oldSize: {x: 1, y: 1}
newSize: {x: 1, y: 1}
adaptiveTilingThreshold: 0.5
drawMode: 0
adaptiveTiling: 0
m_AutoTiling: 0
m_Size: {x: 0.88, y: 0.27}
m_EdgeRadius: 0
--- !u!1 &9138407101546400895
GameObject:
m_ObjectHideFlags: 0
@ -105,6 +243,7 @@ GameObject:
- component: {fileID: 2556996269222904179}
- component: {fileID: 6376878406717916855}
- component: {fileID: 4035999004062947863}
- component: {fileID: 5034967889011811312}
m_Layer: 0
m_Name: Player
m_TagString: Player
@ -126,6 +265,7 @@ Transform:
m_ConstrainProportionsScale: 0
m_Children:
- {fileID: 1023739552815324599}
- {fileID: 2455266088112389998}
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!212 &7073821485941705831
@ -222,7 +362,7 @@ CapsuleCollider2D:
m_CompositeOperation: 0
m_CompositeOrder: 0
m_Offset: {x: 0, y: 0}
m_Size: {x: 1, y: 2}
m_Size: {x: 0.88, y: 2}
m_Direction: 0
--- !u!50 &2556996269222904179
Rigidbody2D:
@ -239,7 +379,7 @@ Rigidbody2D:
m_Mass: 1
m_LinearDamping: 0
m_AngularDamping: 0.05
m_GravityScale: 6
m_GravityScale: 2.3
m_Material: {fileID: 0}
m_IncludeLayers:
serializedVersion: 2
@ -293,3 +433,30 @@ MonoBehaviour:
m_Script: {fileID: 11500000, guid: eae62c41ce858ce478f29843ba0d3dea, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::PlayerController
--- !u!114 &5034967889011811312
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 9138407101546400895}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: b68250b34a148164d9a00b31f0af63d8, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::Player
jumpVelocity: 12.5
moveVelocity: 10
dashDistance: 5
dashDuration: 0.2
gravityRecoveryTime: 0.5
fallMultiplier: 7
lowJumpMultiplier: 8
currentHp: 0
maxHp: 10
enemyLayer:
serializedVersion: 2
m_Bits: 64
attackBoxSize: {x: 2, y: 1}
_isJumping: 0
footCollider: {fileID: 8697187445213062801}

14
Assets/Prefabs/TestEntity.prefab
View File

@ -11,6 +11,7 @@ GameObject:
- component: {fileID: 3182903703610233758}
- component: {fileID: 3818235801779510969}
- component: {fileID: 3096000554608240826}
- component: {fileID: 8429481501366728148}
m_Layer: 6
m_Name: TestEntity
m_TagString: Untagged
@ -138,3 +139,16 @@ BoxCollider2D:
m_AutoTiling: 0
m_Size: {x: 1, y: 1}
m_EdgeRadius: 0
--- !u!114 &8429481501366728148
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 3345230653483034275}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 3eada057783728046bc1f3df10f17294, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::Entity
data: {fileID: 11400000, guid: a5edb67c4940a4e4692478c7267fc1f8, type: 2}

613
Assets/Scenes/tAttackScene.unity
View File

@ -127,45 +127,13 @@ PrefabInstance:
serializedVersion: 3
m_TransformParent: {fileID: 0}
m_Modifications:
- target: {fileID: 1470778168392290969, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_FlipX
value: 0
objectReference: {fileID: 0}
- target: {fileID: 1470778168392290969, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_FlipY
value: 0
objectReference: {fileID: 0}
- target: {fileID: 1665208702870125763, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_Size.x
value: 0.88
objectReference: {fileID: 0}
- target: {fileID: 1888074432508430436, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: data
value:
objectReference: {fileID: 11400000, guid: a5edb67c4940a4e4692478c7267fc1f8, type: 2}
- target: {fileID: 2556996269222904179, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_Constraints
value: 4
objectReference: {fileID: 0}
- target: {fileID: 2556996269222904179, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_Interpolate
value: 1
objectReference: {fileID: 0}
- target: {fileID: 2556996269222904179, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_GravityScale
value: 6
objectReference: {fileID: 0}
- target: {fileID: 2556996269222904179, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_CollisionDetection
value: 1
objectReference: {fileID: 0}
- target: {fileID: 4539706167822133972, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_LocalPosition.x
value: 0
objectReference: {fileID: 0}
- target: {fileID: 4539706167822133972, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_LocalPosition.y
value: 7.97
value: 0
objectReference: {fileID: 0}
- target: {fileID: 4539706167822133972, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_LocalPosition.z
@ -199,85 +167,15 @@ PrefabInstance:
propertyPath: m_LocalEulerAnglesHint.z
value: 0
objectReference: {fileID: 0}
- target: {fileID: 7073821485941705831, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_FlipX
value: 0
objectReference: {fileID: 0}
- target: {fileID: 7073821485941705831, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_FlipY
value: 0
objectReference: {fileID: 0}
- target: {fileID: 9138407101546400895, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
propertyPath: m_Name
value: Player
objectReference: {fileID: 0}
m_RemovedComponents: []
m_RemovedGameObjects: []
m_AddedGameObjects:
- targetCorrespondingSourceObject: {fileID: 4539706167822133972, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
insertIndex: -1
addedObject: {fileID: 519420032}
- targetCorrespondingSourceObject: {fileID: 4539706167822133972, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
insertIndex: -1
addedObject: {fileID: 1840358744}
m_AddedComponents:
- targetCorrespondingSourceObject: {fileID: 9138407101546400895, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
insertIndex: -1
addedObject: {fileID: 1052407373}
m_AddedGameObjects: []
m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
--- !u!1 &306394113
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 306394115}
- component: {fileID: 306394116}
m_Layer: 0
m_Name: MapGenerator
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 0
--- !u!4 &306394115
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 306394113}
serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!114 &306394116
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 306394113}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 5e7d23336d894ca408df792e757e12f2, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::MapGenerator
mapChunkPrefab:
- {fileID: 6341745752034328576, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
startChunkPrefab: {fileID: 6341745752034328576, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
mapChunkSize: 14
playerTransform: {fileID: 0}
groundEnemyPrefabs: []
groundEnemyCount: 2
airEnemyPrefabs: []
airEnemyCount: 1
--- !u!1 &519420028
GameObject:
m_ObjectHideFlags: 0
@ -384,7 +282,7 @@ Camera:
far clip plane: 1000
field of view: 34
orthographic: 1
orthographic size: 7.5
orthographic size: 8
m_Depth: -1
m_CullingMask:
serializedVersion: 2
@ -413,13 +311,53 @@ Transform:
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1052407366}
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &557650576 stripped
--- !u!1 &577101996
GameObject:
m_CorrespondingSourceObject: {fileID: 9138407101546400895, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
m_PrefabInstance: {fileID: 91367892}
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 577101998}
- component: {fileID: 577101997}
m_Layer: 0
m_Name: Grid
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!156049354 &577101997
Grid:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 577101996}
m_Enabled: 1
m_CellSize: {x: 1, y: 1, z: 0}
m_CellGap: {x: 0, y: 0, z: 0}
m_CellLayout: 0
m_CellSwizzle: 0
--- !u!4 &577101998
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 577101996}
serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children:
- {fileID: 1533502549}
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &619394800
GameObject:
m_ObjectHideFlags: 0
@ -504,94 +442,7 @@ Transform:
m_Children: []
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1001 &974281701
PrefabInstance:
m_ObjectHideFlags: 0
serializedVersion: 2
m_Modification:
serializedVersion: 3
m_TransformParent: {fileID: 0}
m_Modifications:
- target: {fileID: 6341745752034328576, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_Name
value: StartPoint
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalPosition.x
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalPosition.y
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalPosition.z
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalRotation.w
value: 1
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalRotation.x
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalRotation.y
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalRotation.z
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalEulerAnglesHint.x
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalEulerAnglesHint.y
value: 0
objectReference: {fileID: 0}
- target: {fileID: 6865574070306004691, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
propertyPath: m_LocalEulerAnglesHint.z
value: 0
objectReference: {fileID: 0}
m_RemovedComponents: []
m_RemovedGameObjects: []
m_AddedGameObjects: []
m_AddedComponents: []
m_SourcePrefab: {fileID: 100100000, guid: f14d701489108ef4aa0c2a723a069b8b, type: 3}
--- !u!4 &1052407366 stripped
Transform:
m_CorrespondingSourceObject: {fileID: 4539706167822133972, guid: ae58a5fa402b1d941b0878d356d1389d, type: 3}
m_PrefabInstance: {fileID: 91367892}
m_PrefabAsset: {fileID: 0}
--- !u!114 &1052407373
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 557650576}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: b68250b34a148164d9a00b31f0af63d8, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::Player
currentHp: 0
maxHp: 10
moveSpeed: 9
jumpSpeed: 18.7
dashTime: 0.2
dashDistance: 5
attackBoxSize: {x: 1, y: 1}
enemyLayer:
serializedVersion: 2
m_Bits: 64
groundLayer:
serializedVersion: 2
m_Bits: 8
--- !u!1 &1840358743
--- !u!1 &1394462045
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
@ -599,46 +450,94 @@ GameObject:
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 1840358744}
- component: {fileID: 1840358745}
- component: {fileID: 1394462047}
- component: {fileID: 1394462046}
m_Layer: 0
m_Name: Square
m_Name: GameManager
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &1840358744
--- !u!114 &1394462046
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1394462045}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: d9e1f81ee45b90c4bbbe2407be6639de, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::GameManager
maxTimeScale: 1.8
comboForMaxSpeed: 30
--- !u!4 &1394462047
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1840358743}
m_GameObject: {fileID: 1394462045}
serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0.47, y: 0.37, z: 0}
m_LocalScale: {x: 0.43, y: 0.55, z: 1}
m_LocalPosition: {x: -16.21681, y: 5.00526, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 1052407366}
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!212 &1840358745
SpriteRenderer:
--- !u!1 &1533502548
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 1533502549}
- component: {fileID: 1533502551}
- component: {fileID: 1533502550}
- component: {fileID: 1533502552}
m_Layer: 3
m_Name: TestTilemap
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &1533502549
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1533502548}
serializedVersion: 2
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 577101998}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!483693784 &1533502550
TilemapRenderer:
serializedVersion: 2
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1840358743}
m_GameObject: {fileID: 1533502548}
m_Enabled: 1
m_CastShadows: 0
m_ReceiveShadows: 0
m_DynamicOccludee: 1
m_StaticShadowCaster: 0
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_LightProbeUsage: 0
m_ReflectionProbeUsage: 0
m_RayTracingMode: 0
m_RayTraceProcedural: 0
m_RayTracingAccelStructBuildFlagsOverride: 0
@ -672,21 +571,289 @@ SpriteRenderer:
m_SortingLayer: 0
m_SortingOrder: 0
m_MaskInteraction: 0
m_Sprite: {fileID: 7482667652216324306, guid: 311925a002f4447b3a28927169b83ea6, type: 3}
m_Color: {r: 1, g: 0.12481479, b: 0, a: 1}
m_FlipX: 0
m_FlipY: 0
m_DrawMode: 0
m_Size: {x: 1, y: 1}
m_AdaptiveModeThreshold: 0.5
m_SpriteTileMode: 0
m_WasSpriteAssigned: 1
m_SpriteSortPoint: 0
m_ChunkSize: {x: 32, y: 32, z: 32}
m_ChunkCullingBounds: {x: 0, y: 0, z: 0}
m_MaxChunkCount: 16
m_MaxFrameAge: 16
m_SortOrder: 0
m_Mode: 0
m_DetectChunkCullingBounds: 0
--- !u!1839735485 &1533502551
Tilemap:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1533502548}
m_Enabled: 1
m_Tiles:
- first: {x: -9, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -8, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -7, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -6, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -5, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -4, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -3, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -2, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: -1, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 0, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 1, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 2, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 3, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 4, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 5, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 6, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
- first: {x: 7, y: -2, z: 0}
second:
serializedVersion: 2
m_TileIndex: 0
m_TileSpriteIndex: 0
m_TileMatrixIndex: 0
m_TileColorIndex: 0
m_TileObjectToInstantiateIndex: 65535
dummyAlignment: 0
m_AllTileFlags: 1073741825
m_AnimatedTiles: {}
m_TileAssetArray:
- m_RefCount: 17
m_Data: {fileID: 11400000, guid: 8309c65724c3a8e40884dda0cfb55bae, type: 2}
m_TileSpriteArray:
- m_RefCount: 17
m_Data: {fileID: -855298285791758126, guid: 9fc32b26c4b0b87459965e872a8507d2, type: 3}
m_TileMatrixArray:
- m_RefCount: 17
m_Data:
e00: 1
e01: 0
e02: 0
e03: 0
e10: 0
e11: 1
e12: 0
e13: 0
e20: 0
e21: 0
e22: 1
e23: 0
e30: 0
e31: 0
e32: 0
e33: 1
m_TileColorArray:
- m_RefCount: 17
m_Data: {r: 1, g: 1, b: 1, a: 1}
m_TileObjectToInstantiateArray: []
m_AnimationFrameRate: 1
m_Color: {r: 1, g: 1, b: 1, a: 1}
m_Origin: {x: -9, y: -2, z: 0}
m_Size: {x: 17, y: 2, z: 1}
m_TileAnchor: {x: 0.5, y: 0.5, z: 0}
m_TileOrientation: 0
m_TileOrientationMatrix:
e00: 1
e01: 0
e02: 0
e03: 0
e10: 0
e11: 1
e12: 0
e13: 0
e20: 0
e21: 0
e22: 1
e23: 0
e30: 0
e31: 0
e32: 0
e33: 1
--- !u!19719996 &1533502552
TilemapCollider2D:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1533502548}
m_Enabled: 1
serializedVersion: 3
m_Density: 1
m_Material: {fileID: 0}
m_IncludeLayers:
serializedVersion: 2
m_Bits: 0
m_ExcludeLayers:
serializedVersion: 2
m_Bits: 0
m_LayerOverridePriority: 0
m_ForceSendLayers:
serializedVersion: 2
m_Bits: 4294967295
m_ForceReceiveLayers:
serializedVersion: 2
m_Bits: 4294967295
m_ContactCaptureLayers:
serializedVersion: 2
m_Bits: 4294967295
m_CallbackLayers:
serializedVersion: 2
m_Bits: 4294967295
m_IsTrigger: 0
m_UsedByEffector: 0
m_CompositeOperation: 0
m_CompositeOrder: 0
m_Offset: {x: 0, y: 0}
m_MaximumTileChangeCount: 1000
m_ExtrusionFactor: 0
m_UseDelaunayMesh: 0
--- !u!1660057539 &9223372036854775807
SceneRoots:
m_ObjectHideFlags: 0
m_Roots:
- {fileID: 619394802}
- {fileID: 519420032}
- {fileID: 91367892}
- {fileID: 306394115}
- {fileID: 974281701}
- {fileID: 577101998}
- {fileID: 1394462047}

21
Assets/Scripts/Chunk/StartPoint.prefab
View File

@ -1033,7 +1033,6 @@ GameObject:
- component: {fileID: 6865574070306004691}
- component: {fileID: 2067336040744889851}
- component: {fileID: 3292794540610925077}
- component: {fileID: -3080825936102063139}
m_Layer: 0
m_Name: StartPoint
m_TagString: Untagged
@ -1111,26 +1110,6 @@ Tilemap:
e31: 0
e32: 0
e33: 1
--- !u!114 &-3080825936102063139
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 6341745752034328576}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 6e6e97c5e9315644da61b9c55d8a0153, type: 3}
m_Name:
m_EditorClassIdentifier: Assembly-CSharp::MapChunk
wallTilemap: {fileID: 6874713491693749632}
breakableTilemap: {fileID: 7647941258413030092}
propsTilemap: {fileID: 8229857193334397147}
availablePropTiles:
- {fileID: 11400000, guid: 27176e78b9a778f4cbafc74696719e6d, type: 2}
- {fileID: 11400000, guid: 8309c65724c3a8e40884dda0cfb55bae, type: 2}
erosionRate: 0.1
propSpawnRate: 0.2
--- !u!1 &7461532452089214047
GameObject:
m_ObjectHideFlags: 0

85
Assets/Scripts/MapChunk.cs
View File

@ -1,85 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Tilemaps;
public class MapChunk : MonoBehaviour
{
[Header("Tilemaps")]
[SerializeField] private Tilemap wallTilemap;
[SerializeField] private Tilemap breakableTilemap;
[SerializeField] private Tilemap propsTilemap;
[Header("Procedural Settings")]
[SerializeField] private TileBase[] availablePropTiles;
[Range(0f, 1f)] [SerializeField] private float erosionRate = 0.1f;
[Range(0f, 1f)] [SerializeField] private float propSpawnRate = 0.2f;
public void InitializeChunk(bool isMirrored)
{
if (isMirrored)
{
Vector3 scale = transform.localScale;
scale.x = -1;
transform.localScale = scale;
}
ErodeTerrain();
GenerateProps();
}
public void SpawnEnemies(GameObject[] groundPrefabs, int groundCount, GameObject[] airPrefabs, int airCount)
{
// 추후 팩토리 패턴 적용 예정
}
private void ErodeTerrain()
{
if (breakableTilemap == null) return;
BoundsInt bounds = breakableTilemap.cellBounds;
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
Vector3Int pos = new Vector3Int(x, y, 0);
if (breakableTilemap.HasTile(pos))
{
if (Random.value < erosionRate)
{
breakableTilemap.SetTile(pos, null);
}
}
}
}
}
private void GenerateProps()
{
if (propsTilemap == null || availablePropTiles.Length == 0) return;
BoundsInt bounds = breakableTilemap.cellBounds;
for (int x = bounds.xMin; x < bounds.xMax; x++)
{
for (int y = bounds.yMin; y < bounds.yMax; y++)
{
Vector3Int currentPos = new Vector3Int(x, y, 0);
Vector3Int abovePos = new Vector3Int(x, y + 1, 0);
bool hasGround = breakableTilemap.HasTile(currentPos);
bool isAirAbove = !wallTilemap.HasTile(abovePos) && !breakableTilemap.HasTile(abovePos);
if (hasGround && isAirAbove)
{
if (Random.value < propSpawnRate)
{
TileBase randomProp = availablePropTiles[Random.Range(0, availablePropTiles.Length)];
propsTilemap.SetTile(abovePos, randomProp);
}
}
}
}
}
}

2
Assets/Scripts/MapChunk.cs.meta
View File

@ -1,2 +0,0 @@
fileFormatVersion: 2
guid: 6e6e97c5e9315644da61b9c55d8a0153

71
Assets/Scripts/MapGenerator.cs
View File

@ -1,71 +0,0 @@
using System.Collections.Generic;
using UnityEngine;
public class MapGenerator : MonoBehaviour
{
[Header("맵 설정용")]
[SerializeField] private GameObject[] mapChunkPrefab;
[SerializeField] private GameObject startChunkPrefab;
[SerializeField] private int mapChunkSize = 14;
private float lateSpawnedChunkLocationY = 0;
[Header("플레이어 설정")]
[SerializeField] private Transform playerTransform;
private Queue<GameObject> chunkQueue = new Queue<GameObject>();
[Header("적 설정")]
[SerializeField] private GameObject[] groundEnemyPrefabs;
[SerializeField] private int groundEnemyCount = 2;
[SerializeField] private GameObject[] airEnemyPrefabs;
[SerializeField] private int airEnemyCount = 1;
private void Start()
{
playerTransform = GameObject.FindGameObjectWithTag("Player").transform;
SpawnChunkPrefab();
SpawnChunkPrefab();
SpawnChunkPrefab();
}
private void SpawnChunkPrefab()
{
if (mapChunkPrefab == null) return;
GameObject spawnedChunkObj = chunkQueue.Count < 1 ? Instantiate(startChunkPrefab) : Instantiate(mapChunkPrefab[Random.Range(0, mapChunkPrefab.Length)]);
spawnedChunkObj.transform.position = new Vector2(0, lateSpawnedChunkLocationY);
chunkQueue.Enqueue(spawnedChunkObj);
MapChunk mapChunk = spawnedChunkObj.GetComponent<MapChunk>();
if (mapChunk != null)
{
bool isMirrored = Random.value > 0.5f;
mapChunk.InitializeChunk(isMirrored);
mapChunk.SpawnEnemies(groundEnemyPrefabs, groundEnemyCount, airEnemyPrefabs, airEnemyCount);
}
else
{
Debug.Log("Script 추가하기");
}
lateSpawnedChunkLocationY -= mapChunkSize;
}
public void Update()
{
if (chunkQueue.Count < 3) return;
float middleChunkY = lateSpawnedChunkLocationY + mapChunkSize;
if (playerTransform.position.y <= middleChunkY)
{
RemoveAndSpawnNewChunk();
}
}
private void RemoveAndSpawnNewChunk()
{
GameObject removedChunk = chunkQueue.Dequeue();
Destroy(removedChunk);
SpawnChunkPrefab();
}
}

2
Assets/Scripts/MapGenerator.cs.meta
View File

@ -1,2 +0,0 @@
fileFormatVersion: 2
guid: 5e7d23336d894ca408df792e757e12f2

11
Assets/Scripts/Monster/Entity.cs
View File

@ -1,3 +1,4 @@
using System;
using UnityEngine;
using UnityEngine.Events;
@ -7,8 +8,12 @@ public class Entity : MonoBehaviour
protected int currentHp;
protected int attackDamage;
private bool isSuicided = false;
[SerializeField] protected EntityData data;
public static event Action<int> OnEnemyDeathEvent;
protected virtual void Awake()
{
if (data != null)
@ -32,13 +37,17 @@ public class Entity : MonoBehaviour
protected virtual void Die()
{
currentHp = 0;
if (!isSuicided)
{
OnEnemyDeathEvent?.Invoke(1);
}
Destroy(gameObject);
}
public virtual void OnHitPlayer(Player player)
{
player.TakeDamage(attackDamage);
isSuicided = true;
Die();
}

16
Assets/Scripts/MonsterFactory.cs
View File

@ -1,16 +0,0 @@
using UnityEngine;
public class MonsterFactory : MonoBehaviour
{
// Start is called once before the first execution of Update after the MonoBehaviour is created
void Start()
{
}
// Update is called once per frame
void Update()
{
}
}

2
Assets/Scripts/MonsterFactory.cs.meta
View File

@ -1,2 +0,0 @@
fileFormatVersion: 2
guid: 46977ad4134ee5948a3da02e0e6e53d3

318
Assets/Scripts/Player/Player.cs
View File

@ -1,7 +1,4 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using System.Collections;
using UnityEngine;
using UnityEngine.InputSystem;
@ -9,179 +6,204 @@ public class Player : MonoBehaviour
{
private Rigidbody2D _rigidbody;
[Header("이동속도")]
[Range(1, 20)] public float jumpVelocity;
[Range(1, 20)] public float moveVelocity;
[Header("대쉬 설정")]
[Range(1,10)] public float dashDistance = 5f;
public float dashDuration = 0.2f;
public float gravityRecoveryTime = 0.15f;
[Header("중력 물리")]
public float fallMultiplier = 2.5f;
public float lowJumpMultiplier = 2f;
private float _gravityWeight = 1f;
[Header("체력")]
[SerializeField] private int currentHp;
[SerializeField] private int maxHp = 10;
private bool isGrounded;
private bool isJumpedOnAir = false;
private bool isDashing;
private List<GameObject> dashHitEnemies = new List<GameObject>();
[SerializeField] private int maxAttackTime = 3;
[SerializeField] private int maxDashTime = 1;
private int currentAttackTime = 0;
private int currentDashTime = 0;
[SerializeField] private float moveSpeed = 9f;
[SerializeField] private float jumpSpeed = 18.2f;
[SerializeField] private float dashTime = 0.5f;
[SerializeField] private float dashDistance = 5f;
private Vector2 inputVector;
[Header("레이어 설정")]
[SerializeField] private LayerMask enemyLayer;
[Header("공격 설정")]
[SerializeField] private Vector2 attackBoxSize = new Vector2(2f, 1f);
[SerializeField] private LayerMask enemyLayer;
[SerializeField] private LayerMask groundLayer;
public bool _isJumping;
private bool _isGrounded;
private bool _isJumpOnAir;
private bool _isDashing;
private bool _isFacingRight;
private void Start()
public Collider2D footCollider;
private Vector2 _inputVector;
private float _gravity;
public bool IsDashing => _isDashing;
void Start()
{
_rigidbody = GetComponent<Rigidbody2D>();
_gravity = Physics2D.gravity.y;
currentHp = maxHp;
_rigidbody = gameObject.GetComponent<Rigidbody2D>();
_isFacingRight = true;
}
public void SetInputVector(InputValue value)
{
_inputVector = value.Get<Vector2>();
if (_inputVector.x != 0)
{
transform.localScale = new Vector3(_inputVector.x > 0 ? 1 : -1, 1, 1);
_isFacingRight = _inputVector.x > 0;
}
}
public void SetJumpState(bool isPressed)
{
_isJumping = isPressed;
if (isPressed)
{
Jump();
}
}
public void Jump()
{
if (isGrounded || !isJumpedOnAir)
{
if (!isGrounded)
{
isJumpedOnAir = true;
}
if (_isDashing) return;
_rigidbody.linearVelocity = new Vector2(_rigidbody.linearVelocity.x, 0);
_rigidbody.AddForce(Vector2.up * jumpSpeed, ForceMode2D.Impulse);
}
}
public void MoveUpdate()
if (_isGrounded || !_isJumpOnAir)
{
if (!isDashing)
_rigidbody.linearVelocity = Vector2.up * jumpVelocity;
if (!_isGrounded)
{
_rigidbody.linearVelocity = new Vector2(inputVector.x * moveSpeed, _rigidbody.linearVelocity.y);
if (inputVector.x != 0)
{
transform.localScale = new Vector3(Mathf.Sign(inputVector.x), 1, 1);
_isJumpOnAir = true;
}
}
}
public void SetXVector(InputValue value)
public void Dash()
{
inputVector = value.Get<Vector2>();
if (_isDashing || _inputVector == Vector2.zero) return;
StartCoroutine(DashRoutine());
}
public void NormalAttack()
public void MoveHorizontal()
{
if (currentAttackTime < maxAttackTime)
{
if (!isGrounded)
{
Debug.Log($"{currentAttackTime + 1} / {maxAttackTime}");
currentAttackTime++;
if (_isDashing) return;
_rigidbody.linearVelocity = new Vector2(_inputVector.x * moveVelocity, _rigidbody.linearVelocity.y);
}
Debug.Log("Attack");
float dir = transform.localScale.x;
Vector2 direction = new Vector2(dir, 0);
Vector2 originPosition = (Vector2)transform.position + (direction * 1);
Collider2D[] enemise = Physics2D.OverlapBoxAll(originPosition, attackBoxSize, 0, enemyLayer);
if (enemise.Length > 0)
public void AddGravityForceOnJump()
{
foreach (Collider2D enemy in enemise)
if (_isDashing) return;
if (GroundCheck())
{
_gravityWeight = 1f;
return;
}
float gravityMultiplier = 0f;
if (_rigidbody.linearVelocity.y < 0)
{
gravityMultiplier = fallMultiplier;
}
else if (_rigidbody.linearVelocity.y > 0 && !_isJumping)
{
gravityMultiplier = lowJumpMultiplier;
}
else
{
gravityMultiplier = 1f;
}
Vector2 gravityForce = Vector2.up * _gravity * (gravityMultiplier - 1) * Time.deltaTime;
_rigidbody.linearVelocity += gravityForce * _gravityWeight;
}
private bool GroundCheck()
{
_isGrounded = footCollider.IsTouchingLayers(LayerMask.GetMask("Ground"));
if (_isGrounded)
{
_isJumpOnAir = false;
}
return _isGrounded;
}
private IEnumerator DashRoutine()
{
float originGravity = _rigidbody.gravityScale;
_rigidbody.gravityScale = 0f;
_isDashing = true;
_gravityWeight = 0f;
float dashSpeed = dashDistance / dashDuration;
Vector2 dashVelocity = _inputVector.normalized * dashSpeed;
float startTime = Time.time;
while (Time.time < startTime + dashDuration)
{
_rigidbody.linearVelocity = dashVelocity;
yield return new WaitForFixedUpdate();
}
_rigidbody.gravityScale = originGravity;
_isDashing = false;
_rigidbody.linearVelocity = Vector2.zero;
float elapsed = 0f;
while (elapsed < gravityRecoveryTime)
{
elapsed += Time.deltaTime;
_gravityWeight = Mathf.Lerp(0f, 1f, elapsed / gravityRecoveryTime);
yield return null;
}
_gravityWeight = 1f;
}
public void TakeDamage(int damage)
{
currentHp -= damage;
if (GameManager.instance != null)
{
GameManager.instance.ResetCombo();
}
if (currentHp <= 0)
{
Die();
}
}
private void Die()
{
Time.timeScale = 1f;
}
public void Heal(int amount)
{
currentHp += amount;
if (currentHp > maxHp) currentHp = maxHp;
}
public void Attack()
{
if (_isDashing)
{
return;
}
Vector2 originPos = transform.TransformPoint(new Vector2(attackBoxSize.x / 2f, 0f));
Collider2D[] enimes = Physics2D.OverlapBoxAll(originPos, attackBoxSize, 0, enemyLayer);
foreach (Collider2D enemy in enimes)
{
enemy.gameObject.GetComponent<Entity>().TakeDamage(10);
}
}
}
}
public void CheckGround()
{
isGrounded = Physics2D.Raycast(transform.position, Vector2.down, 1.25f, groundLayer);
if (isGrounded)
{
isJumpedOnAir = false;
currentAttackTime = 0;
currentDashTime = 0;
}
}
public void DashAttack()
{
if (isDashing) return;
if (currentDashTime < maxDashTime)
{
currentDashTime++;
StartCoroutine(DashPlayerRoutine());
}
}
private IEnumerator DashPlayerRoutine()
{
isDashing = true;
_rigidbody.linearVelocity = Vector2.zero;
dashHitEnemies.Clear();
Vector2 direction = inputVector.normalized;
if (direction == Vector2.zero)
{
direction = new Vector2(transform.localScale.x, 0);
}
if (isGrounded && direction.y < 0)
{
direction.y = 0;
if (direction.x != 0) direction.x = Mathf.Sign(direction.x);
}
Vector2 startPos = _rigidbody.position;
Vector2 targetPos = startPos + (direction.normalized * dashDistance);
float dashTimer = 0f;
while (dashTimer < dashTime)
{
dashTimer += Time.deltaTime;
float t = dashTimer / dashTime;
_rigidbody.MovePosition(Vector2.Lerp(startPos, targetPos, t));
yield return null;
}
isDashing = false;
}
public void AttackOnDash(Collider2D collision)
{
if ((enemyLayer.value & (1 << collision.gameObject.layer)) > 0)
{
if (!dashHitEnemies.Contains(collision.gameObject))
{
dashHitEnemies.Add(collision.gameObject);
collision.gameObject.GetComponent<Entity>().TakeDamage(10);
}
}
}
public bool IsDashing() { return isDashing; }
public void Heal(int heal)
{
if (heal < 0) return;
currentHp += heal;
if (currentHp > maxHp) currentHp = maxHp;
}
public void TakeDamage(int playerAttackDamage)
{
currentHp -= playerAttackDamage;
if (currentHp <= 0)
{
currentHp = 0;
Destroy(gameObject);
}
}
}

46
Assets/Scripts/Player/PlayerController.cs
View File

@ -8,9 +8,6 @@ public class PlayerController : MonoBehaviour
{
private Player player;
private Vector2 inputVector;
private float jumpStartTime;
private void Start()
{
player = GetComponent<Player>();
@ -18,50 +15,51 @@ public class PlayerController : MonoBehaviour
private void FixedUpdate()
{
player.MoveUpdate();
Debug.DrawRay(transform.position, Vector2.down * 1.25f, Color.red);
player.CheckGround();
player.AddGravityForceOnJump();
player.MoveHorizontal();
}
private void OnMove(InputValue value)
{
player.SetXVector(value);
}
private void OnAttack(InputValue value)
{
if (player.IsDashing())
{
return;
}
if (value.isPressed)
{
player.NormalAttack();
}
player.SetInputVector(value);
}
private void OnDash(InputValue value)
{
if (value.isPressed)
{
player.DashAttack();
player.Dash();
}
}
private void OnJump(InputValue value)
{
player._isJumping = value.isPressed;
if(value.isPressed)
{
player.Jump();
}
}
private void OnTriggerEnter2D(Collider2D collision)
private void OnAttack(InputValue value)
{
if (player.IsDashing())
if (player.IsDashing)
{
player.AttackOnDash(collision);
return;
}
if (value.isPressed)
{
player.Attack();
}
}
// private void OnTriggerEnter2D(Collider2D collision)
// {
// if (player.IsDashing())
// {
// player.AttackOnDash(collision);
// }
// }
}

2
Assets/NavMeshComponents.meta → Assets/Scripts/System.meta
View File

@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 1d279d47cd674a34e86965d94da726be
guid: 5ed114ee4199039409f620bd212948bc
folderAsset: yes
DefaultImporter:
externalObjects: {}

63
Assets/Scripts/System/GameManager.cs Normal file
View File

@ -0,0 +1,63 @@
using UnityEngine;
public class GameManager : MonoBehaviour
{
public static GameManager instance;
private Player _player;
private int comboCount = 0;
[SerializeField] private float maxTimeScale = 1.3f;
[SerializeField] private int comboForMaxSpeed = 30;
private void Awake()
{
if(instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
return;
}
GameObject playerObj = GameObject.FindGameObjectWithTag("Player");
if (playerObj != null)
{
_player = playerObj.GetComponent<Player>();
}
}
private void OnEnable()
{
Entity.OnEnemyDeathEvent += OnEnemyKilled;
}
private void OnDisable()
{
Entity.OnEnemyDeathEvent -= OnEnemyKilled;
}
private void OnEnemyKilled(int reward)
{
AddCombo();
_player.Heal(reward);
}
private void AddCombo()
{
comboCount++;
float speedRatio = (float)comboCount / comboForMaxSpeed;
Time.timeScale = 1 + ((maxTimeScale - 1) * speedRatio);
if (Time.timeScale > maxTimeScale) Time.timeScale = maxTimeScale;
}
public void ResetCombo()
{
comboCount = 0;
Time.timeScale = 1f;
}
}

2
Assets/Scripts/System/GameManager.cs.meta Normal file
View File

@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: d9e1f81ee45b90c4bbbe2407be6639de

66
Assets/Settings/UniversalRP.asset
View File

@ -100,42 +100,42 @@ MonoBehaviour:
obsoleteHasProbeVolumes:
m_Keys: []
m_Values:
m_PrefilteringModeMainLightShadows: 1
m_PrefilteringModeMainLightShadows: 4
m_PrefilteringModeAdditionalLight: 4
m_PrefilteringModeAdditionalLightShadows: 1
m_PrefilterXRKeywords: 0
m_PrefilteringModeForwardPlus: 1
m_PrefilteringModeDeferredRendering: 1
m_PrefilteringModeScreenSpaceOcclusion: 1
m_PrefilterDebugKeywords: 0
m_PrefilterWriteRenderingLayers: 0
m_PrefilterHDROutput: 0
m_PrefilterAlphaOutput: 0
m_PrefilterSSAODepthNormals: 0
m_PrefilterSSAOSourceDepthLow: 0
m_PrefilterSSAOSourceDepthMedium: 0
m_PrefilterSSAOSourceDepthHigh: 0
m_PrefilterSSAOInterleaved: 0
m_PrefilterSSAOBlueNoise: 0
m_PrefilterSSAOSampleCountLow: 0
m_PrefilterSSAOSampleCountMedium: 0
m_PrefilterSSAOSampleCountHigh: 0
m_PrefilterDBufferMRT1: 0
m_PrefilterDBufferMRT2: 0
m_PrefilterDBufferMRT3: 0
m_PrefilterSoftShadowsQualityLow: 0
m_PrefilterSoftShadowsQualityMedium: 0
m_PrefilterSoftShadowsQualityHigh: 0
m_PrefilteringModeAdditionalLightShadows: 0
m_PrefilterXRKeywords: 1
m_PrefilteringModeForwardPlus: 0
m_PrefilteringModeDeferredRendering: 0
m_PrefilteringModeScreenSpaceOcclusion: 0
m_PrefilterDebugKeywords: 1
m_PrefilterWriteRenderingLayers: 1
m_PrefilterHDROutput: 1
m_PrefilterAlphaOutput: 1
m_PrefilterSSAODepthNormals: 1
m_PrefilterSSAOSourceDepthLow: 1
m_PrefilterSSAOSourceDepthMedium: 1
m_PrefilterSSAOSourceDepthHigh: 1
m_PrefilterSSAOInterleaved: 1
m_PrefilterSSAOBlueNoise: 1
m_PrefilterSSAOSampleCountLow: 1
m_PrefilterSSAOSampleCountMedium: 1
m_PrefilterSSAOSampleCountHigh: 1
m_PrefilterDBufferMRT1: 1
m_PrefilterDBufferMRT2: 1
m_PrefilterDBufferMRT3: 1
m_PrefilterSoftShadowsQualityLow: 1
m_PrefilterSoftShadowsQualityMedium: 1
m_PrefilterSoftShadowsQualityHigh: 1
m_PrefilterSoftShadows: 0
m_PrefilterScreenCoord: 0
m_PrefilterScreenSpaceIrradiance: 0
m_PrefilterNativeRenderPass: 0
m_PrefilterScreenCoord: 1
m_PrefilterScreenSpaceIrradiance: 1
m_PrefilterNativeRenderPass: 1
m_PrefilterUseLegacyLightmaps: 0
m_PrefilterBicubicLightmapSampling: 0
m_PrefilterReflectionProbeRotation: 0
m_PrefilterReflectionProbeBlending: 0
m_PrefilterReflectionProbeBoxProjection: 0
m_PrefilterReflectionProbeAtlas: 0
m_PrefilterBicubicLightmapSampling: 1
m_PrefilterReflectionProbeRotation: 1
m_PrefilterReflectionProbeBlending: 1
m_PrefilterReflectionProbeBoxProjection: 1
m_PrefilterReflectionProbeAtlas: 1
m_ShaderVariantLogLevel: 0
m_ShadowCascades: 0
m_Textures:

14
Assets/UniversalRenderPipelineGlobalSettings.asset
View File

@ -66,7 +66,19 @@ MonoBehaviour:
- rid: 2333976670676189190
- rid: 2333976670676189191
m_RuntimeSettings:
m_List: []
m_List:
- rid: 7752762179098771456
- rid: 7752762179098771457
- rid: 7752762179098771459
- rid: 7752762179098771461
- rid: 7752762179098771462
- rid: 7752762179098771464
- rid: 7752762179098771466
- rid: 7752762179098771468
- rid: 7752762179098771472
- rid: 7752762179098771476
- rid: 3114554777721110529
- rid: 3114554777721110530
m_AssetVersion: 9
m_ObsoleteDefaultVolumeProfile: {fileID: 0}
m_RenderingLayerNames:

5
ProjectSettings/ProjectSettings.asset
View File

@ -388,7 +388,10 @@ PlayerSettings:
m_Height: 36
m_Kind: 0
m_SubKind:
m_BuildTargetBatching: []
m_BuildTargetBatching:
- m_BuildTarget: Standalone
m_StaticBatching: 1
m_DynamicBatching: 0
m_BuildTargetShaderSettings: []
m_BuildTargetGraphicsJobs: []
m_BuildTargetGraphicsJobMode: []

2
ProjectSettings/UnityConnectSettings.asset
View File

@ -4,7 +4,7 @@
UnityConnectSettings:
m_ObjectHideFlags: 0
serializedVersion: 1
m_Enabled: 0
m_Enabled: 1
m_TestMode: 0
m_EventOldUrl: https://api.uca.cloud.unity3d.com/v1/events
m_EventUrl: https://cdp.cloud.unity3d.com/v1/events