public static void OnSelectionChanged()
{
if (Selection.activeObject == null)
{
return;
}
var assetPath = FileAndPathUtils.MakeProjectRelative(AssetDatabase.GetAssetPath(Selection.activeObject));
if (GameDataTracker.IsGameDataFile(assetPath) == false)
{
return;
}
try
{
var selectedAssetType = Selection.activeObject.GetType();
var inspectorWindowType = typeof(PopupWindow).Assembly.GetType("UnityEditor.InspectorWindow");
var inspectorWindow = EditorWindow.GetWindow(inspectorWindowType);
var activeEditorTracker = inspectorWindow.HasProperty("tracker") ?
inspectorWindow.GetPropertyValue("tracker") :
inspectorWindow.GetFieldValue("m_Tracker");
var customEditorAttributesType = typeof(PopupWindow).Assembly.GetType("UnityEditor.CustomEditorAttributes");
var customEditorsList = (System.Collections.IList)customEditorAttributesType.GetFieldValue("kSCustomEditors");
var cachedCustomEditorsList = customEditorAttributesType.HasField("kCachedEditorForType") ?
(Dictionary <Type, Type>)customEditorAttributesType.GetFieldValue("kCachedEditorForType") :
null;
foreach (var customEditor in customEditorsList)
{
if (customEditor == null || (Type)customEditor.GetFieldValue("m_InspectedType") != selectedAssetType)
{
continue;
}
var originalInspectorType = (Type)customEditor.GetFieldValue("m_InspectorType");
// override inspector
customEditor.SetFieldValue("m_InspectorType", typeof(GameDataInspector));
if (cachedCustomEditorsList != null)
{
cachedCustomEditorsList[selectedAssetType] = typeof(GameDataInspector);
}
// force rebuild editor list
activeEditorTracker.Invoke("ForceRebuild");
inspectorWindow.Repaint();
// restore original inspector
customEditor.SetFieldValue("m_InspectorType", originalInspectorType);
if (cachedCustomEditorsList != null)
{
cachedCustomEditorsList.Remove(selectedAssetType);
}
}
}
catch (Exception updateEditorError)
{
if (Settings.Current.Verbose)
{
Debug.LogError(updateEditorError);
}
}
}
private void OnTriggerEnter(Collider trig)
{
if (trig.CompareTag("Player") && GameDataTracker.cutsceneMode == GameDataTracker.cutsceneModeOptions.Mobile)
{
GameDataTracker.AddItem(ItemID);
GameDataTracker.playerData.GatheredItemsDictionary[sceneName].Add(instanceID);
Destroy(gameObject);
}
}
public void Start()
{
GameDataTracker.spawnLastTransitionObject();
//SpawnsPartner
if (GameDataTracker.playerData.CurrentCompanion > 0)
{
SpawnPartner(GameDataTracker.playerData.CurrentCompanion);
}
}
//public static List<Character> EnemyList;
void Awake()
{
//MAKES THIS OBJECT PERSIST IN EVERY SCENE
if (DataTracker == null)
{
DontDestroyOnLoad(gameObject);
DataTracker = this;
}
else if (DataTracker != this)
{
Destroy(gameObject);
}
}
public void StartGame(string saveFileName)
{
GameDataTracker.saveFileName = saveFileName;
GameDataTracker.Load();
if (GameDataTracker.playerData.fileName == "New Game")
{
FirstMenu.SetActive(false);
FileNameMenu.SetActive(true);
}
else
{
SceneManager.LoadScene(startSceneName, LoadSceneMode.Single);
}
}
override public bool Activate()
{
Animator animatorStorage;
if (string.IsNullOrEmpty(TargetName))
{
animatorStorage = parent.GetComponent <Animator>();
}
else
{
animatorStorage = GameDataTracker.findCharacterByName(TargetName, GameDataTracker.CharacterList).CharacterObject.GetComponent <Animator>();
}
animatorStorage.SetTrigger(TriggerName);
return(false);
}
private static bool OnOpenAsset(int instanceID, int exceptionId)
{
var gameDataPath = AssetDatabase.GetAssetPath(instanceID);
if (GameDataTracker.IsGameDataFile(gameDataPath) == false)
{
return(false);
}
var reference = ValidationException.GetReference(exceptionId);
loadEditorTask = new Coroutine <bool>(LoadEditor(gameDataPath, reference, loadEditorTask));
loadEditorTask.ContinueWith(t => EditorUtility.ClearProgressBar());
return(true);
}
// ReSharper disable once UnusedMember.Local
// ReSharper disable once IdentifierTypo
private static void OnPostprocessAllAssets(string[] _, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
if (Settings.Current == null)
{
return;
}
foreach (var deletedPath in deletedAssets)
{
if (!GameDataTracker.Untrack(deletedPath))
{
continue;
}
if (Settings.Current.Verbose)
{
Debug.Log("GameData deleted: " + deletedPath);
}
GameDataHashByPath.Remove(deletedPath);
}
for (var i = 0; i < movedAssets.Length; i++)
{
var fromPath = FileAndPathUtils.MakeProjectRelative(movedFromAssetPaths[i]);
var toPath = FileAndPathUtils.MakeProjectRelative(movedAssets[i]);
if (fromPath == null || toPath == null)
{
continue;
}
if (!GameDataTracker.IsTracked(fromPath))
{
continue;
}
GameDataTracker.Untrack(fromPath);
GameDataTracker.Track(toPath);
if (Settings.Current.Verbose)
{
Debug.Log("GameData moved: " + toPath + " from: " + fromPath);
}
GameDataHashByPath.Remove(fromPath);
GameDataHashByPath.Remove(toPath);
}
}
// Update is called once per frame
void Update()
{
//text.text = "Score: " + score;
text.text = "Score: " + GameDataTracker.GameScore;
if (GameDataTracker.Lives <= 0)
{ //SHOW STARTAPP INTERSTIATIAL EVERY 2 RUNS
if (GameDataTracker.GameRuns % 3 == 0 && GameDataTracker.AD_AlreadyShown == false)
{
//if true => Show ad
#if UNITY_ANDROID
StartAppWrapper.showAd();
StartAppWrapper.loadAd();
#endif
GameDataTracker.AD_AlreadyShown = true;
}
//Report Score to leaderboard
//
GameObject ExitDoor = GameObject.FindGameObjectWithTag("ExitDoor");
Destroy(ExitDoor);
GameObject BALL = GameObject.FindGameObjectWithTag("Ball");
DestroyObject(BALL);
// ... tell the animator the game is over.
anim.SetTrigger("GameOver");
// .. increment a timer to count up to restarting.
restartTimer += Time.deltaTime;
//ADD SUCCES SCREEN MOT GAMER OVER AND SHOW PROGRESS
// .. if it reaches the restart delay...
if (restartTimer >= restartDelay)
{
GameDataTracker.Reset();
// .. then reload the currently loaded level.
//Application.LoadLevel(Application.loadedLevel);
UnityEngine.SceneManagement.SceneManager.LoadScene("MainMenu", UnityEngine.SceneManagement.LoadSceneMode.Single);
}
}
}
override public bool Activate()
{
if (TargetObject == string.Empty)
{
TObject = OverworldController.Player;
agent = TObject.GetComponent <NavMeshAgent>();
agent.enabled = true;
}
else
{
TObject = GameDataTracker.findCharacterByName(TargetObject, GameDataTracker.CharacterList).CharacterObject;
agent = TObject.GetComponent <NavMeshAgent>();
}
if (ReferenceObject == string.Empty)
{
RObject = parent;
}
else
{
RObject = GameObject.Find(ReferenceObject);
if (RObject == null)
{
RObject = GameDataTracker.findCharacterByName(TargetObject, GameDataTracker.CharacterList).CharacterObject;
}
}
waypointPosition = RObject.transform.position;
waypointPosition += PositionOffset;
NavMeshHit hit;
NavMesh.SamplePosition(waypointPosition, out hit, 2, NavMesh.AllAreas);
waypointPosition = hit.position;
agent.SetDestination(waypointPosition);
active = true;
return(Wait);
}
private void DialogueNodeRead()
{
GameObject textbox = Resources.Load <GameObject>("TextBox");
Character findCharacter = GameDataTracker.findCharacterByName(speakerName, GameDataTracker.CharacterList);
if (GameDataTracker.combatExecutor != null)
{
GameDataTracker.combatExecutor.FocusOnCharacter(findCharacter.CharacterObject);
}
FriendlyNPCClass friendlyNPC = findCharacter.CharacterObject.GetComponent <FriendlyNPCClass>();
if (friendlyNPC != null)
{
letter_noises = friendlyNPC.ObjectInfo.LetterNoises;
letters_per_noise_list = friendlyNPC.ObjectInfo.LetterNoisesPerList;
}
else
{
letter_noises = null;
letters_per_noise_list = null;
}
Transform target;
float dialogueHeight;
target = findCharacter.CharacterObject.transform;
dialogueHeight = findCharacter.ObjectInfo.GetDialogueHeightOverSpeaker();
spawnedTextBox = Instantiate <GameObject>(textbox, new Vector3(target.position.x, target.position.y + dialogueHeight, target.position.z + 0.2f), Quaternion.identity);
TextBoxController tbController = spawnedTextBox.GetComponent <TextBoxController>();
tbController.textfile = inputText;
tbController.choices = currentLinks;
tbController.speakerName = speakerName;
tbController.scriptSource = deconstructerSource;
tbController.letter_noises = letter_noises;
tbController.letters_per_noise_list = letters_per_noise_list;
}
public override void OverWorldUse(int itemIndex)
{
base.OverWorldUse(itemIndex);
GameDataTracker.ChangeHealth(2);
}
public void Awake()
{
AllMorganTorches = new List <MorganTorchScript>();
MorganMaterialReset();
AreaInfo = AreaInfoInput;
controls = new GameControls();
GameDataTracker.clearCharacterList();
PauseMenu = Instantiate(pauseMenu, Vector3.zero, Quaternion.identity);
PauseMenu.SetActive(false);
if (GameDataTracker.lastAreaWasCombat == false)
{
if (GameDataTracker.previousArea != null)
{
foreach (GameObject sceneTransfer in SceneTransfers)
{
//SPAWNS PLAYER AT THE DESIGNATED AREA ENTRANCE
if (sceneTransfer.GetComponent <SceneMover>().sceneName == GameDataTracker.previousArea)
{
Player = Instantiate(playerInput, sceneTransfer.transform.position, Quaternion.identity);
GameDataTracker.cutsceneMode = GameDataTracker.cutsceneModeOptions.Cutscene;
PlayerTravelDirection pm = ScriptableObject.CreateInstance <PlayerTravelDirection>();
SceneMover.exitDirectionOptions entranceDirection = sceneTransfer.GetComponent <SceneMover>().exitDirection;
if (entranceDirection == SceneMover.exitDirectionOptions.up)
{
pm.endPosition = Player.transform.position + new Vector3(0, 0, -2);
pm.travelDirection = SceneMover.exitDirectionOptions.down;
}
else if (entranceDirection == SceneMover.exitDirectionOptions.left)
{
pm.endPosition = Player.transform.position + new Vector3(2, 0, 0);
pm.travelDirection = SceneMover.exitDirectionOptions.right;
}
else if (entranceDirection == SceneMover.exitDirectionOptions.right)
{
pm.endPosition = Player.transform.position + new Vector3(-2, 0, 0);
pm.travelDirection = SceneMover.exitDirectionOptions.left;
}
else if (entranceDirection == SceneMover.exitDirectionOptions.down)
{
pm.endPosition = Player.transform.position + new Vector3(0, 0, 2);
pm.travelDirection = SceneMover.exitDirectionOptions.up;
}
CutsceneController.addCutsceneEvent(pm, Player, true, GameDataTracker.cutsceneModeOptions.Cutscene);
}
}
}
else
{
//SPAWNS PLAYERS AT A SPAWNPOINT
Player = Instantiate(playerInput, spawnPoint.transform.position, Quaternion.identity);
}
}
else
{
//SPAWNS PLAYER WHERE THEY STARTED COMBAT
Player = Instantiate(playerInput, GameDataTracker.combatStartPosition, Quaternion.identity);
GameDataTracker.lastAreaWasCombat = false;
}
trackingCamera = Instantiate <GameObject>(trackingCameraInput, Player.transform.position + new Vector3(0, 1, -2), Quaternion.Euler(25f, 0, 0));
trackingCamera.GetComponent <CameraFollow>().ObjectToTrack = Player;
trackingCamera.GetComponent <CameraFollow>().combat = false;
updateTrackingCameraY(Player.transform.position.y);
}
//private void OnEnable()
//{
//EventSystem.current.SetSelectedGameObject(null);
//EventSystem.current.SetSelectedGameObject(characterMenuFirstFocus);
//}
public void SaveGame()
{
GameDataTracker.Save();
}
public void DeleteSave(string deleteFileName)
{
GameDataTracker.DeleteFile(deleteFileName);
UpdateAllFileName();
}
public void StartNewGame()
{
GameDataTracker.playerData.fileName = NewGameTextField.GetComponent <TMP_InputField>().text;
GameDataTracker.Save();
SceneManager.LoadScene(startSceneName, LoadSceneMode.Single);
}
public override void OnInspectorGUI()
{
var gameDataAsset = (Object)this.target;
var gameDataPath = FileAndPathUtils.MakeProjectRelative(AssetDatabase.GetAssetPath(gameDataAsset));
var assetPath = FileAndPathUtils.MakeProjectRelative(AssetDatabase.GetAssetPath(Selection.activeObject));
if (GameDataTracker.IsGameDataFile(assetPath) == false)
{
this.DrawDefaultInspector();
return;
}
if (this.lastAsset != gameDataAsset || this.gameDataSettings == null)
{
this.gameDataSettings = GameDataSettings.Load(gameDataPath);
this.gameDataSettings.ScriptingAssemblies = this.gameDataSettings.ScriptingAssemblies ?? new string[0];
this.lastAsset = gameDataAsset;
this.newScriptingAssembly = null;
this.newScriptingAssemblyName = null;
}
GUI.enabled = true;
GUILayout.Label(Path.GetFileName(gameDataPath), EditorStyles.boldLabel);
this.gameDataSettings.Generator = (int)(GameDataSettings.CodeGenerator)EditorGUILayout.EnumPopup(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATOR, (GameDataSettings.CodeGenerator) this.gameDataSettings.Generator);
if (this.gameDataSettings.Generator != (int)GameDataSettings.CodeGenerator.None)
{
this.codeGenerationFold = EditorGUILayout.Foldout(this.codeGenerationFold, Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATION_LABEL);
if (this.codeGenerationFold)
{
this.gameDataSettings.AutoGeneration = EditorGUILayout.Toggle(Resources.UI_UNITYPLUGIN_INSPECTOR_AUTO_GENERATION,
this.gameDataSettings.AutoGeneration);
var codeAsset = !string.IsNullOrEmpty(this.gameDataSettings.CodeGenerationPath) && File.Exists(this.gameDataSettings.CodeGenerationPath) ? AssetDatabase.LoadAssetAtPath <TextAsset>(this.gameDataSettings.CodeGenerationPath) : null;
var assetAsset = !string.IsNullOrEmpty(this.gameDataSettings.AssetGenerationPath) && File.Exists(this.gameDataSettings.AssetGenerationPath) ? AssetDatabase.LoadAssetAtPath <ScriptableObject>(this.gameDataSettings.AssetGenerationPath) : null;
if (codeAsset != null)
{
this.gameDataSettings.CodeGenerationPath = AssetDatabase.GetAssetPath(EditorGUILayout.ObjectField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATION_PATH, codeAsset, typeof(TextAsset), false));
}
else
{
this.gameDataSettings.CodeGenerationPath = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_GENERATION_PATH,
this.gameDataSettings.CodeGenerationPath);
}
if (this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharpCodeAndAsset)
{
if (assetAsset != null)
{
this.gameDataSettings.AssetGenerationPath = AssetDatabase.GetAssetPath(EditorGUILayout.ObjectField(Resources.UI_UNITYPLUGIN_INSPECTOR_ASSET_GENERATION_PATH, assetAsset, typeof(ScriptableObject), false));
}
else
{
this.gameDataSettings.AssetGenerationPath = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_ASSET_GENERATION_PATH, this.gameDataSettings.AssetGenerationPath);
}
}
if ((this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharp ||
this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharpCodeAndAsset) &&
Path.GetExtension(this.gameDataSettings.CodeGenerationPath) != ".cs")
{
this.gameDataSettings.CodeGenerationPath = Path.ChangeExtension(this.gameDataSettings.CodeGenerationPath, ".cs");
}
if (this.gameDataSettings.Generator == (int)GameDataSettings.CodeGenerator.CSharpCodeAndAsset &&
Path.GetExtension(this.gameDataSettings.AssetGenerationPath) != ".asset")
{
this.gameDataSettings.AssetGenerationPath = Path.ChangeExtension(this.gameDataSettings.AssetGenerationPath, ".asset");
}
this.gameDataSettings.Namespace = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_NAMESPACE,
this.gameDataSettings.Namespace);
this.gameDataSettings.GameDataClassName = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_API_CLASS_NAME,
this.gameDataSettings.GameDataClassName);
this.gameDataSettings.DocumentClassName = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_DOCUMENT_CLASS_NAME,
this.gameDataSettings.DocumentClassName);
this.gameDataSettings.LineEnding = (int)(GameDataSettings.LineEndings)EditorGUILayout.EnumPopup(
Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_LINE_ENDINGS, (GameDataSettings.LineEndings) this.gameDataSettings.LineEnding);
this.gameDataSettings.Indentation = (int)(GameDataSettings.Indentations)EditorGUILayout.EnumPopup(
Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_INDENTATION, (GameDataSettings.Indentations) this.gameDataSettings.Indentation);
this.gameDataSettings.Options = (int)(CodeGenerationOptions)EditorGUILayout.EnumMaskField(
Resources.UI_UNITYPLUGIN_INSPECTOR_CODE_OPTIONS, (CodeGenerationOptions)this.gameDataSettings.Options);
}
}
this.scriptingAssembliesFold = EditorGUILayout.Foldout(this.scriptingAssembliesFold, Resources.UI_UNITYPLUGIN_INSPECTOR_SCRIPTING_ASSEMBLIES_LABEL);
if (this.scriptingAssembliesFold)
{
for (var i = 0; i < this.gameDataSettings.ScriptingAssemblies.Length; i++)
{
var watchedAssetPath = this.gameDataSettings.ScriptingAssemblies[i];
var assetExists = !string.IsNullOrEmpty(watchedAssetPath) && (File.Exists(watchedAssetPath) || Directory.Exists(watchedAssetPath));
var watchedAsset = assetExists ? AssetDatabase.LoadMainAssetAtPath(watchedAssetPath) : null;
if (watchedAsset != null)
{
this.gameDataSettings.ScriptingAssemblies[i] = AssetDatabase.GetAssetPath(EditorGUILayout.ObjectField(Resources.UI_UNITYPLUGIN_INSPECTOR_ASSET_LABEL, watchedAsset, typeof(Object), false));
}
else
{
this.gameDataSettings.ScriptingAssemblies[i] = EditorGUILayout.TextField(Resources.UI_UNITYPLUGIN_INSPECTOR_NAME_LABEL, watchedAssetPath);
}
}
EditorGUILayout.Space();
this.newScriptingAssembly = EditorGUILayout.ObjectField("<" + Resources.UI_UNITYPLUGIN_INSPECTOR_ADD_ASSET_BUTTON + ">", this.newScriptingAssembly, typeof(Object), false);
if (Event.current.type == EventType.repaint && this.newScriptingAssembly != null)
{
var assemblies = new HashSet <string>(this.gameDataSettings.ScriptingAssemblies);
assemblies.Remove("");
assemblies.Add(AssetDatabase.GetAssetPath(this.newScriptingAssembly));
this.gameDataSettings.ScriptingAssemblies = assemblies.ToArray();
this.newScriptingAssembly = null;
GUI.changed = true;
}
EditorGUILayout.BeginHorizontal();
this.newScriptingAssemblyName = EditorGUILayout.TextField("<" + Resources.UI_UNITYPLUGIN_INSPECTOR_ADD_NAME_BUTTON + ">", this.newScriptingAssemblyName);
if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_ADD_BUTTON, EditorStyles.toolbarButton, GUILayout.Width(70), GUILayout.Height(18)))
{
var assemblies = new HashSet <string>(this.gameDataSettings.ScriptingAssemblies);
assemblies.Remove("");
assemblies.Add(this.newScriptingAssemblyName);
this.gameDataSettings.ScriptingAssemblies = assemblies.ToArray();
this.newScriptingAssemblyName = null;
GUI.changed = true;
this.Repaint();
}
GUILayout.Space(5);
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.Space();
GUILayout.Label(Resources.UI_UNITYPLUGIN_INSPECTOR_ACTIONS_GROUP, EditorStyles.boldLabel);
if (EditorApplication.isCompiling)
{
EditorGUILayout.HelpBox(Resources.UI_UNITYPLUGIN_COMPILING_WARNING, MessageType.Warning);
}
else if (CoroutineScheduler.IsRunning)
{
EditorGUILayout.HelpBox(Resources.UI_UNITYPLUGIN_COROUTINE_IS_RUNNIG_WARNING, MessageType.Warning);
}
EditorGUILayout.BeginHorizontal();
GUI.enabled = !CoroutineScheduler.IsRunning && !EditorApplication.isCompiling;
if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_EDIT_BUTTON))
{
AssetDatabase.OpenAsset(gameDataAsset);
this.Repaint();
}
if (this.gameDataSettings.Generator != (int)GameDataSettings.CodeGenerator.None && string.IsNullOrEmpty(this.gameDataSettings.CodeGenerationPath) == false)
{
if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_RUN_GENERATOR_BUTTON))
{
CoroutineScheduler.Schedule(Menu.GenerateCodeAndAssetsAsync(gameDataPath, ProgressUtils.ReportToLog(Resources.UI_UNITYPLUGIN_INSPECTOR_GENERATION_PREFIX + " ")), "generation::" + gameDataPath)
.ContinueWith(_ => this.Repaint());
}
}
GUI.enabled = !CoroutineScheduler.IsRunning && !EditorApplication.isCompiling;
if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_VALIDATE_BUTTON))
{
CoroutineScheduler.Schedule(Menu.ValidateAsync(gameDataPath, ProgressUtils.ReportToLog(Resources.UI_UNITYPLUGIN_INSPECTOR_VALIDATION_PREFIX + " ")), "validation::" + gameDataPath)
.ContinueWith(_ => this.Repaint());
}
if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_BACKUP_BUTTON))
{
this.Backup(gameDataPath);
}
if (GUILayout.Button(Resources.UI_UNITYPLUGIN_INSPECTOR_RESTORE_BUTTON))
{
this.Restore(gameDataPath);
}
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
if (GUI.changed)
{
this.gameDataSettings.Save(gameDataPath);
}
}
private static void Update()
{
if (Settings.Current == null)
{
return;
}
if (LastWatchedGameDataTrackerVersion != GameDataTracker.Version)
{
var gameDataPaths = new HashSet <string>(GameDataTracker.All);
foreach (var gameDataPath in gameDataPaths)
{
if (Watchers.ContainsKey(gameDataPath) || File.Exists(gameDataPath) == false)
{
continue;
}
try
{
var fullPath = Path.GetFullPath(gameDataPath);
var directoryName = Path.GetDirectoryName(fullPath);
var watcher = new FileSystemWatcher(directoryName)
{
NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.Size
};
watcher.Filter = Path.GetFileName(fullPath);
watcher.Changed += GameDataChanged;
Watchers.Add(gameDataPath, watcher);
try { GameDataHashByPath[gameDataPath] = FileAndPathUtils.ComputeHash(gameDataPath); }
catch
{
// ignored
}
watcher.EnableRaisingEvents = true;
}
catch (Exception e)
{
Debug.LogError("Failed to create FileSystemWatcher for GameData " + gameDataPath + ": " + e);
}
}
foreach (var gameDataPath in Watchers.Keys.ToArray())
{
if (gameDataPaths.Contains(gameDataPath))
{
continue;
}
var watcher = Watchers[gameDataPath];
Watchers.Remove(gameDataPath);
try { watcher.Dispose(); }
catch (Exception e) { Debug.LogError("Failed to dispose FileSystemWatcher of GameData: " + e); }
}
LastWatchedGameDataTrackerVersion = GameDataTracker.Version;
}
var changedAssetsCopy = default(string[]);
lock (ChangedAssetPaths)
{
if (ChangedAssetPaths.Count > 0)
{
changedAssetsCopy = ChangedAssetPaths.ToArray();
ChangedAssetPaths.Clear();
}
}
if (changedAssetsCopy != null)
{
foreach (var changedAsset in changedAssetsCopy)
{
if (Settings.Current.Verbose)
{
Debug.Log("Changed Asset: " + changedAsset);
}
if (!File.Exists(changedAsset) || GameDataTracker.IsTracked(changedAsset) == false)
{
continue;
}
var gameDataSettings = GameDataSettings.Load(changedAsset);
if (!gameDataSettings.AutoGeneration)
{
continue;
}
var assetHash = default(string);
try
{
assetHash = FileAndPathUtils.ComputeHash(changedAsset);
}
catch (Exception e)
{
Debug.LogWarning("Failed to compute hash of " + changedAsset + ": " + e);
continue;
}
var oldAssetHash = default(string);
if (GameDataHashByPath.TryGetValue(changedAsset, out oldAssetHash) && assetHash == oldAssetHash)
{
continue; // not changed
}
if (EditorApplication.isUpdating)
{
continue;
}
if (Settings.Current.Verbose)
{
Debug.Log("Asset's " + changedAsset + " hash has changed from " + (oldAssetHash ?? "<none>") + " to " + assetHash);
}
GameDataHashByPath[changedAsset] = assetHash;
CoroutineScheduler.Schedule
(
Menu.GenerateCodeAndAssetsAsync(
path: changedAsset,
progressCallback: ProgressUtils.ReportToLog("Generation(Auto): ")),
"generation::" + changedAsset
);
}
}
}
public static void OnSelectionChanged()
{
if (Selection.activeObject == null)
{
return;
}
var assetPath = FileAndPathUtils.MakeProjectRelative(AssetDatabase.GetAssetPath(Selection.activeObject));
if (GameDataTracker.IsGameDataFile(assetPath) == false)
{
return;
}
try
{
var selectedAssetType = Selection.activeObject.GetType();
var inspectorWindowType = typeof(PopupWindow).Assembly.GetType("UnityEditor.InspectorWindow");
var inspectorWindow = EditorWindow.GetWindow(inspectorWindowType);
var activeEditorTracker = inspectorWindow.HasProperty("tracker") ?
inspectorWindow.GetPropertyValue("tracker") :
inspectorWindow.GetFieldValue("m_Tracker");
var customEditorAttributesType = typeof(PopupWindow).Assembly.GetType("UnityEditor.CustomEditorAttributes");
var customEditorsList = customEditorAttributesType.GetFieldValue("kSCustomEditors") as IList;
var customEditorsDictionary = customEditorAttributesType.GetFieldValue("kSCustomEditors") as IDictionary;
var monoEditorType = customEditorAttributesType.GetNestedType("MonoEditorType", BindingFlags.NonPublic);
// after unity 2018.*
if (customEditorsDictionary != null)
{
foreach (IEnumerable customEditors in customEditorsDictionary.Values)
{
foreach (var customEditor in customEditors)
{
if (customEditor == null || (Type)customEditor.GetFieldValue("m_InspectedType") != selectedAssetType)
{
continue;
}
var originalInspectorType = (Type)customEditor.GetFieldValue("m_InspectorType");
// override inspector
customEditor.SetFieldValue("m_InspectorType", typeof(GameDataInspector));
// force rebuild editor list
activeEditorTracker.Invoke("ForceRebuild");
inspectorWindow.Repaint();
// restore original inspector
customEditor.SetFieldValue("m_InspectorType", originalInspectorType);
break;
}
}
var newMonoEditorType = Activator.CreateInstance(monoEditorType);
newMonoEditorType.SetFieldValue("m_InspectedType", selectedAssetType);
newMonoEditorType.SetFieldValue("m_InspectorType", typeof(GameDataInspector));
newMonoEditorType.SetFieldValue("m_EditorForChildClasses", false);
if (monoEditorType.HasField("m_IsFallback"))
{
newMonoEditorType.SetFieldValue("m_IsFallback", false);
}
var newMonoEditorTypeList = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(monoEditorType));
newMonoEditorTypeList.Add(newMonoEditorType);
// override inspector
customEditorsDictionary[selectedAssetType] = newMonoEditorTypeList;
// force rebuild editor list
activeEditorTracker.Invoke("ForceRebuild");
inspectorWindow.Repaint();
// restore original inspector
customEditorsDictionary.Remove(selectedAssetType);
}
// prior to unity 2018.*
else if (customEditorsList != null)
{
var cachedCustomEditorsByType = customEditorAttributesType.HasField("kCachedEditorForType") ?
(IDictionary <Type, Type>)customEditorAttributesType.GetFieldValue("kCachedEditorForType") :
null;
foreach (var customEditor in customEditorsList)
{
if (customEditor == null || (Type)customEditor.GetFieldValue("m_InspectedType") != selectedAssetType)
{
continue;
}
var originalInspectorType = (Type)customEditor.GetFieldValue("m_InspectorType");
// override inspector
customEditor.SetFieldValue("m_InspectorType", typeof(GameDataInspector));
if (cachedCustomEditorsByType != null)
{
cachedCustomEditorsByType[selectedAssetType] = typeof(GameDataInspector);
}
// force rebuild editor list
activeEditorTracker.Invoke("ForceRebuild");
inspectorWindow.Repaint();
// restore original inspector
customEditor.SetFieldValue("m_InspectorType", originalInspectorType);
if (cachedCustomEditorsByType != null)
{
cachedCustomEditorsByType.Remove(selectedAssetType);
}
break;
}
var newMonoEditorType = Activator.CreateInstance(monoEditorType);
newMonoEditorType.SetFieldValue("m_InspectedType", selectedAssetType);
newMonoEditorType.SetFieldValue("m_InspectorType", typeof(GameDataInspector));
newMonoEditorType.SetFieldValue("m_EditorForChildClasses", false);
if (monoEditorType.HasField("m_IsFallback"))
{
newMonoEditorType.SetFieldValue("m_IsFallback", false);
}
// override inspector
customEditorsList.Insert(0, newMonoEditorType);
if (cachedCustomEditorsByType != null)
{
cachedCustomEditorsByType[selectedAssetType] = typeof(GameDataInspector);
}
// force rebuild editor list
activeEditorTracker.Invoke("ForceRebuild");
inspectorWindow.Repaint();
// restore original inspector
customEditorsList.Remove(newMonoEditorType);
if (cachedCustomEditorsByType != null)
{
cachedCustomEditorsByType.Remove(selectedAssetType);
}
}
}
catch (Exception updateEditorError)
{
if (Settings.Current.Verbose)
{
Debug.LogError(updateEditorError);
}
}
}
public turnPhases NextTurn()
{
foreach (TurnsPassedTriggerInfo turnsPassedTrigger in CombatExecutor.CutsceneDataManager.TurnsPassedTriggers)
{
if (turnsPassedTrigger.Turns == turnCount)
{
if (CombatExecutor.CutsceneDataManager.TriggerATrigger(turnsPassedTrigger.Label))
{
GameDataTracker.combatExecutor.AddCutsceneToQueue(Resources.Load <DialogueContainer>(turnsPassedTrigger.CutscenePath), name, null);
}
}
}
if (GameDataTracker.combatExecutor.DialogueContainerList.Count > 0)
{
return(turnPhases.Cutscene);
}
if (GameDataTracker.combatExecutor.Clip.GetComponent <FighterClass>().Dead&&
GameDataTracker.combatExecutor.Partner.GetComponent <FighterClass>().Dead)
{
GameDataTracker.GameOver();
SceneManager.LoadScene("MainMenu", LoadSceneMode.Single);
return(turnPhases.GameOver);
}
if (requiredEnemiesDead() && goalType == 0)
{
if (CombatEndDialogue())
{
return(turnPhases.Cutscene);
}
SceneManager.LoadScene(GameDataTracker.previousArea);
return(turnPhases.GameOver);
}
if (goalType == 1)
{
foreach (GoalBlock goalBlock in CombatExecutor.goalBlockList)
{
if (goalBlock.active == true)
{
if (CombatEndDialogue())
{
return(turnPhases.Cutscene);
}
SceneManager.LoadScene(GameDataTracker.previousArea);
return(turnPhases.GameOver);
}
}
}
if (goalType == 2)
{
bool allActive = true;
if (CombatExecutor.goalBlockList.Count == 0)
{
allActive = false;
}
foreach (GoalBlock goalBlock in CombatExecutor.goalBlockList)
{
if (goalBlock.active == false)
{
allActive = false;
break;
}
}
if (allActive)
{
if (CombatEndDialogue())
{
return(turnPhases.Cutscene);
}
SceneManager.LoadScene(GameDataTracker.previousArea);
return(turnPhases.GameOver);
}
}
turnQueue.Add(turnQueue[0]);
turnQueue.RemoveAt(0);
if (turnQueue[0] == turnPhases.RoundOver)
{
turnCount++;
turnQueue.Add(turnQueue[0]);
turnQueue.RemoveAt(0);
}
Debug.Log(turnQueue[0]);
return(turnQueue[0]);
}
void UpdateFileName(string fileName, GameObject textUI)
{
GameDataTracker.saveFileName = fileName;
GameDataTracker.Load();
textUI.GetComponent <Text>().text = GameDataTracker.playerData.fileName;
}
