public string CreateCloudBuildMethods()
{
var classTextAsset = ClassTemplate?.text;
var methodsTextAsset = MethodsTemplate?.text;
if (string.IsNullOrEmpty(classTextAsset))
{
Debug.LogWarning($"CreateCloudBuildClass: ERROR CLASS {ClassTemplatePath} NULL value");
return(string.Empty);
}
if (string.IsNullOrEmpty(methodsTextAsset))
{
Debug.LogWarning($"CreateCloudBuildMethods: ERROR METHODS {MethodsTemplatePath} NULL value");
return(string.Empty);
}
var commands = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
var methodsValue = string.Empty;
foreach (var command in commands)
{
var guid = AssetEditorTools.GetGUID(command);
var methodValue = methodsTextAsset.Replace(ConfigGUIDKey, guid);
var methodName = command.name.RemoveSpecialAndDotsCharacters();
methodsValue += methodValue.Replace(BuildConfigKey, methodName);
}
return(classTextAsset.Replace(MethodsKey, methodsValue));
}
public void Refresh()
{
configurations.Clear();
var configs = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
configurations.AddRange(configs);
}
public static void RefreshUiSettings()
{
var uiSettings = AssetEditorTools.GetAssets <ViewsSettings>();
foreach (var source in uiSettings)
{
Build(source);
}
}
static BuildConfigurationsPostProcessor()
{
AssemblyReloadEvents.afterAssemblyReload += () =>
{
var assets = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
commandsMapPaths.Clear();
commandsMapPaths.AddRange(assets.Select(AssetDatabase.GetAssetPath));
};
}
public static void Rebuild()
{
var settings = AssetEditorTools.GetAssets <ModelViewsModuleSettings>();
foreach (var setting in settings)
{
Rebuild(setting);
EditorUtility.SetDirty(setting);
}
}
public void RebuildViewSettings()
{
var viewSettings = AssetEditorTools.GetAssets <ViewsSettings>();
foreach (var setting in viewSettings)
{
Build(setting);
setting.MarkDirty();
}
}
public string[] GetBuildMethods()
{
var map = new List <string>();
var commands = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
foreach (var command in commands)
{
map.Add(CreateBuildMethod(command));
}
return(map.ToArray());
}
private static void SetFastModeToManagers(bool isFastMode)
{
var atlasManagers = AssetEditorTools.GetAssets <AddressableSpriteAtlasConfiguration>();
foreach (var manager in atlasManagers)
{
manager.isFastMode = isFastMode;
manager.MarkDirty();
GameLog.Log($"Set fast mode [{isFastMode}] to {manager.name}");
}
}
private List <TView> LoadUiViews <TView>(IReadOnlyList <string> paths)
where TView : class, IView
{
var assets = AssetEditorTools.GetAssets <GameObject>(paths.ToArray());
var views = assets
.Select(x => x.GetComponent <TView>())
.Where(x => x != null)
.Where(x => !proceedViews.Contains(x)).ToList();
return(views);
}
private void UpdateSearchResults()
{
ClearResults();
_filterTypes.Clear();
var assetType = objectTypeFilter is MonoScript scriptObject?
scriptObject.GetClass() :
objectTypeFilter?.GetType();
assetType?.AddToCollection(_filterTypes);
var assets = AssetEditorTools.GetAssets <Object>(filter, folderFilter.ToArray());
if (singleTarget)
{
assets.Add(singleTarget);
}
//remove all filtered
assets.RemoveAll(x => FilterAsset(x) == false);
var searchData = new SearchData()
{
assets = assets.ToArray(),
regExFilters = ignoreFilter.
Concat(ignoreFolders).
Select(EditorFileUtils.FixUnityPath).
ToArray(),
fileTypes = typeFilter.ToArray(),
};
var result = AssetReferenceFinder.FindReferences(searchData);
foreach (var reference in result.referenceMap)
{
var assetItem = reference.Key;
var referencesData = reference.Value.
Select(x => x.asset).
ToList();
var referenceData = new ReferencesInfoData()
{
source = assetItem.ToEditorResource(),
references = referencesData
};
_referencesData.Add(referenceData);
}
FilterReferences();
}
public static void Reimport()
{
var atlases = AssetEditorTools.GetAssets <SpriteAtlas>();
var addressableAtlases = atlases.
Where(x => x.IsInAnyAddressableAssetGroup()).
Select(x => new AssetReferenceSpriteAtlas(AssetEditorTools.GetGUID(x))).
ToList();
var atlasManagers = AssetEditorTools.GetAssets <AddressableSpriteAtlasConfiguration>();
foreach (var manager in atlasManagers)
{
SetupMap(manager, addressableAtlases);
manager.MarkDirty();
}
}
public string CreateCloudBuildMethods()
{
var methodsTextAsset = LoadMethodsTemplate();
var commands = AssetEditorTools.GetAssets <UniBuildCommandsMap>();
var methodsValue = string.Empty;
foreach (var command in commands)
{
var guid = AssetEditorTools.GetGUID(command);
var methodValue = methodsTextAsset.Replace(ConfigGUIDKey, guid);
var methodName = command.name.RemoveSpecialAndDotsCharacters();
methodsValue += methodValue.Replace(BuildConfigKey, methodName);
}
var classTextAsset = ClassTemplate.Replace(ClassNameTemplate, ClassName);
return(classTextAsset.Replace(MethodsKey, methodsValue));
}
/// <summary>
/// Sync folder assets by spreadsheet data
/// </summary>
/// <param name="filterType"></param>
/// <param name="folder"></param>
/// <param name="createMissing">if true - create missing assets</param>
/// <param name="spreadsheetData"></param>
/// <param name="maxItems"></param>
/// <param name="overrideSheetId"></param>
/// <returns></returns>
public List <Object> SyncFolderAssets(
Type filterType,
string folder,
bool createMissing,
ISpreadsheetData spreadsheetData,
int maxItems = -1,
string overrideSheetId = "")
{
if (!filterType.IsScriptableObject() && !filterType.IsComponent())
{
Debug.LogError($"SyncFolderAssets: BAD target type {filterType}");
return(null);
}
var assets = AssetEditorTools.GetAssets <Object>(filterType, folder);
var result = SyncFolderAssets(
filterType,
folder,
spreadsheetData,
assets.ToArray(),
createMissing, maxItems, overrideSheetId);
return(result);
}
public IEnumerable <TUnityCommand> GetPostBuildCommands()
{
return(AssetEditorTools.GetAssets <TUnityCommand>());
}
public void Initialize()
{
_mapInfos = AssetEditorTools.GetAssets <CellItemsMapInfo>();
}
public static void UpdateCellsSkins()
{
var skinsMap = AssetEditorTools.GetAssets <CellItemsMapInfo>().FirstOrDefault();
var cellSkins = AssetEditorTools.GetComponentAssets <CellItemView>();
var graphs = AssetEditorTools.GetAssets <UniStatesGraph>();
var mapPath = AssetDatabase.GetAssetPath(skinsMap);
var skinPaths = cellSkins.Select(x => AssetDatabase.GetAssetPath(x)).ToList();
var skinTypes = skinPaths.ToDictionary(x => x, x => Path.GetFileName(Path.GetDirectoryName(x).ToLowerInvariant()));
var mapFolder = Path.GetDirectoryName(mapPath);
var skinFolder = mapFolder + "\\" + SkinsFolderPath + "\\";
skinsMap.Clear();
if (Directory.Exists(skinFolder))
{
Directory.Delete(skinFolder, true);
}
if (!Directory.Exists(skinFolder))
{
Directory.CreateDirectory(skinFolder);
}
var skins = new Dictionary <string, CellSkinsInfo>();
for (var i = 0; i < cellSkins.Count; i++)
{
var cellItemView = cellSkins[i];
var path = skinPaths[i];
var skinType = skinTypes[path];
var skinDirectory = skinFolder + skinType;
if (!skins.TryGetValue(skinType, out var skinInfo))
{
skinInfo = AssetEditorTools.
CreateAsset <CellSkinsInfo>("skin_type_" + skinType, skinFolder);
skins[skinType] = skinInfo;
skinInfo.Name = skinType;
skinInfo.CellItemInfos = new List <CellItemInfo>();
EditorUtility.SetDirty(skinInfo);
}
if (!Directory.Exists(skinDirectory))
{
Directory.CreateDirectory(skinDirectory);
}
var skinItemInfo = AssetEditorTools.CreateAsset <CellItemInfo>(skinType + "_skin_" + i, skinDirectory);
skinInfo.CellItemInfos.Add(skinItemInfo);
var graph = Select(graphs, string.Format($"{skinType}_cell_actor"));
if (graph == null)
{
graph = Select(graphs, string.Format($"{DefaultCellBehaviour}_cell_actor"));
}
skinItemInfo.Initialize(skinType, graph, cellItemView);
EditorUtility.SetDirty(skinItemInfo);
}
foreach (var skin in skins)
{
skinsMap.Add(skin.Value);
EditorUtility.SetDirty(skin.Value);
foreach (var itemInfo in skin.Value.CellItemInfos)
{
EditorUtility.SetDirty(itemInfo);
}
}
EditorUtility.SetDirty(skinsMap);
AssetDatabase.SaveAssets();
}
public List <ViewFlowControllerAsset> GetFlowTypes()
{
return(AssetEditorTools.GetAssets <ViewFlowControllerAsset>());
}
public static List <Object> GetAssetsByType(Type baseType)
{
var result = AssetEditorTools.GetAssets <Object>(baseType);
return(result);
}
