protected override void Execute(List <Ent> entities) { foreach (var ent in entities) { if (!ent.Is <GenCompEntApiInterface_ForSingleContext>() && ent.Get_ <ContextNamesComp>().Values.Count < 2) { continue; } { var template = ent.Has_ <PublicFieldsComp>() ? STANDARD_TEMPLATE : FLAG_TEMPLATE; var filePath = "Components" + Path.DirectorySeparatorChar + "Interfaces" + Path.DirectorySeparatorChar + "I" + ent.ComponentName(_contexts) + "Entity.cs"; var contents = template.Replace(_contexts, ent, String.Empty); var generatedBy = GetType( ).FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } var contextNames = ent.Get_ <ContextNamesComp>().Values; foreach (var contextName in contextNames) { var filePath = contextName + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + ent.ComponentNameWithContext(contextName).AddComponentSuffix() + ".cs"; var contents = ENTITY_INTERFACE_TEMPLATE.Replace(_contexts, ent, contextName); var generatedBy = GetType( ).FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } } }
protected override void Execute(List <Ent> ents) { var settings = _contexts.Get <Settings>( ); _generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated"); _isDryRun = settings.Is <RunInDryMode>(); var stringBuilder = new StringBuilder( ); DeleteNonGenFiles(ents, stringBuilder); foreach (var ent in ents) { WriteFile(ent, stringBuilder); } if (settings.Is <LogGeneratedPaths>()) { var s = stringBuilder.ToString( ); if (String.IsNullOrEmpty(s)) { Log("No changes found since previous run\n"); } else { Log(s); } } }
public static void ProvideEventCompNewEnts(Contexts contexts, Entity <Main> ent) { var mainContext = contexts.Get <Main>(); var settingsContext = contexts.Get <Settings>(); foreach (var contextName in ent.Get_ <ContextNamesComp>().Values) { foreach (var eventInfo in ent.Get_ <EventComp>().Values) { var componentName = ent.Get_ <Comp>().FullTypeName.ToComponentName(settingsContext.Is <IgnoreNamespaces>()); var optionalContextName = ent.Get_ <ContextNamesComp>().Values.Count > 1 ? contextName : string.Empty; var eventTypeSuffix = ent.GetEventTypeSuffix(eventInfo); var theAnySuffix = eventInfo.EventTarget == EventTarget.Any ? "Any" : ""; var listenerComponentName = optionalContextName + theAnySuffix + componentName + eventTypeSuffix + "Listener"; var eventCompFullTypeName = listenerComponentName.AddComponentSuffix(); var eventListenerCompEnt = mainContext.CreateEntity( ); eventListenerCompEnt.Flag <EventListenerComp>(true); eventListenerCompEnt.Add_(new Comp(listenerComponentName, eventCompFullTypeName)); eventListenerCompEnt.Add_(new ContextNamesComp(new List <String> { contextName })); eventListenerCompEnt.Add_(new PublicFieldsComp(new List <FieldInfo> { new FieldInfo("System.Collections.Generic.List<I" + listenerComponentName + ">", "value") })); } } }
public static string WrapInNamespace(this string s, Contexts contexts) { var value = contexts.Get <Settings>().Has_ <GeneratedNamespace>() ? contexts.Get <Settings>().Get_ <GeneratedNamespace>().Value : null; return(String.IsNullOrEmpty(value) ? s : $"namespace {value} {{\n{s}\n}}\n"); }
public PostProcWriteGenPathsToCsprojSystem(Contexts contexts) : base(contexts.Get <Settings>()) { _contexts = contexts; _generatedGroup = contexts.Get <Main>().GetGroup(Matcher <Entity <Main> > .AllOf( Matcher <Main, GeneratedFileComp> .I) .NoneOf( Matcher <Main, Destroy> .I)); }
protected override void Execute(List <Ent> entities) { var settingsGrammar = Hub.SettingsGrammar; var settingsContext = _contexts.Get <Settings>( ); var d = _contexts .Get <Settings>( ) .Get_ <SettingsDict>( ) .Dict; if (d.ContainsKey(nameof(LogGeneratedPaths))) { settingsContext.Flag <LogGeneratedPaths>(settingsGrammar.BoolFromStr(d[nameof(LogGeneratedPaths)].FirstOrDefault( ))); } else { settingsContext.Flag <LogGeneratedPaths>(true); } if (d.ContainsKey(nameof(IgnoreNamespaces))) { settingsContext.Flag <IgnoreNamespaces>(settingsGrammar.BoolFromStr(d[nameof(IgnoreNamespaces)].FirstOrDefault( ))); } else { settingsContext.Flag <IgnoreNamespaces>(false); } if (d.ContainsKey(nameof(RunInDryMode))) { settingsContext.Flag <RunInDryMode>(settingsGrammar.BoolFromStr(d[nameof(RunInDryMode)].FirstOrDefault( ))); } else { settingsContext.Flag <RunInDryMode>(false); } settingsContext.Replace_(d.ContainsKey(nameof(GeneratedNamespace)) ? new GeneratedNamespace(d[nameof(GeneratedNamespace)].FirstOrDefault( )) : new GeneratedNamespace("")); settingsContext.Replace_(d.ContainsKey(nameof(GeneratePath)) ? new GeneratePath(d[nameof(GeneratePath)].FirstOrDefault( )) : new GeneratePath("")); settingsContext.Replace_(d.ContainsKey(nameof(WriteGeneratedPathsToCsProj)) ? new WriteGeneratedPathsToCsProj(d[nameof(WriteGeneratedPathsToCsProj)].FirstOrDefault( )) : new WriteGeneratedPathsToCsProj("")); if (!Directory.Exists(settingsContext.Get_ <GeneratePath>( ).Value)) { throw new DirectoryNotFoundException($"Generate path does not exist: '{settingsContext.Get_<GeneratePath>( ).Value}'"); } }
protected override void Execute(List <Ent> entities) { var settings = _contexts.Get <Settings>(); if (settings.Is <RunInDryMode>()) { return; } var generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated"); var dirInfo = new DirectoryInfo(generatePath); if (!dirInfo.Exists) { return; } foreach (var file in dirInfo.GetFiles( )) { file.Delete( ); } foreach (var dir in dirInfo.GetDirectories( )) { dir.Delete(true); } }
protected override void Execute(List <Ent> entities) { var path = entities[0].Get_ <WriteGeneratedPathsToCsProj>().Value; if (String.IsNullOrEmpty(path)) { return; } if (!File.Exists(path)) { throw new FileNotFoundException(path); } var settings = _contexts.Get <Settings>(); _generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated"); var contents = File.ReadAllText(path); contents = RemoveExistingGeneratedEntires(contents); contents = AddGeneratedEntires(contents); File.WriteAllText(path, contents); }
protected override void Execute(List <Ent> entities) { foreach (var ent in entities) { var contextNames = ent.Get_ <ContextNamesComp>().Values; foreach (var contextName in contextNames) { var template = ent.Has_ <PublicFieldsComp>() ? STANDARD_TEMPLATE : FLAG_TEMPLATE; var filePath = contextName + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + contextName + ent.Get_ <Comp>().Name.AddComponentSuffix( ) + ".cs"; var contents = template .Replace(_contexts, ent, contextName); if (ent.Has_ <PublicFieldsComp>()) { contents = contents .Replace("${memberAssignmentList}", GenerateMemberAssignmentList(ent.Get_ <PublicFieldsComp>().Values.ToArray( ))); } var generatedBy = GetType().FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } } }
protected override void Execute(List <Ent> entities) { foreach (var ent in entities) { var contextNames = ent.Get_ <ContextNamesComp>().Values; foreach (var contextName in contextNames) { var eventInfos = ent.Get_ <EventComp>().Values; foreach (var eventInfo in eventInfos) { var filePath = "Events" + Path.DirectorySeparatorChar + "Interfaces" + Path.DirectorySeparatorChar + "I" + ent.EventListener(_contexts, contextName, eventInfo) + ".cs"; var contents = TEMPLATE .Replace("${methodParameters}", ent.GetEventMethodArgs(eventInfo , ent.Has_ <PublicFieldsComp>() ? ", " + ent.Get_ <PublicFieldsComp>().Values.GetMethodParameters(false) : "")) .Replace(_contexts, ent, contextName, eventInfo); var generatedBy = GetType().FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } } } }
protected override void Execute(List <Ent> entities) { var d = entities[0].Get_ <SettingsDict>().Dict; _contexts.Get <Settings>().Replace_(new RoslynPathToSolution(d.ContainsKey(nameof(RoslynPathToSolution)) ? d[nameof(RoslynPathToSolution)].FirstOrDefault( ) : "")); }
protected override void Execute(List <Ent> entities) { for (var i = 0; i < entities.Count; i++) { var ent = entities[i]; var contextName = ent.Get_ <ContextComp>().Name; var filePath = contextName + Path.DirectorySeparatorChar + contextName.AddMatcherSuffix( ) + ".cs"; var contents = TEMPLATE.Replace(contextName); var generatedBy = GetType( ).FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } }
public void Execute( ) { var entities = _contexts.Get <Main>().GetGroup(Matcher <Ent> .AllOf( Matcher <Main, Comp> .I, Matcher <Main, PublicFieldsComp> .I)) .GetEntities( ); var entityIndexData = new List <EntityIndexData>( ); foreach (var ent in entities) { foreach (var field in ent.Get_ <PublicFieldsComp>().Values) { if (field.EntityIndexInfo == null) { continue; } entityIndexData.Add(field.EntityIndexInfo.EntityIndexData); } } var entsCustomIndex = _contexts.Get <Main>().GetGroup(Matcher <Main, CustomEntityIndexComp> .I).GetEntities( ); foreach (var ent in entsCustomIndex) { entityIndexData.Add(ent.Get_ <CustomEntityIndexComp>().EntityIndexData); } if (entityIndexData.Count == 0) { return; } entityIndexData.Sort((a, b) => a.GetEntityIndexName( ).CompareTo(b.GetEntityIndexName( ))); generateEntityIndices(entityIndexData.ToArray( )); }
protected override void Execute(List <Ent> entities) { var contextNames = new List <String>( ); for (var i = 0; i < entities.Count; i++) { var ent = entities[i]; contextNames.Add(ent.Get_ <ContextComp>().Name); } contextNames.Sort((a, b) => String.Compare(a, b, StringComparison.Ordinal)); var fileEnt = _contexts.Get <Main>().CreateEntity( ); var contents = Generate(contextNames.ToArray( )); fileEnt.Add_(new GeneratedFileComp("Contexts.cs", contents.WrapInNamespace(_contexts), GetType( ).FullName)); }
protected override void Execute(List <Ent> entities) { for (var i = 0; i < entities.Count; i++) { var ent = entities[i]; var nonIComp = ent.Get_ <NonIComp>(); var filePath = "Components" + Path.DirectorySeparatorChar + nonIComp.FullCompName + ".cs"; var contents = Generate(nonIComp.FullCompName, nonIComp.FieldTypeName); var generatedBy = GetType( ).FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } }
protected override void Execute(List <Ent> entities) { var contextNames = new HashSet <String>( ); foreach (var ent in entities) { contextNames.UnionWith(ent.Get_ <ContextNamesComp>().Values); } foreach (var name in contextNames) { var ent = _contexts.Get <Main>().CreateEntity( ); ent.Add_(new ContextComp(name)); } }
protected override void Execute(List <Ent> entities) { var contextEnts = new Dictionary <String, List <Ent> >( ); foreach (var ent in entities) { foreach (var contextName in ent.Get_ <ContextNamesComp>().Values) { if (!contextEnts.ContainsKey(contextName)) { contextEnts[contextName] = new List <Ent>( ); } contextEnts[contextName].Add(ent); } } foreach (var contextName in contextEnts.Keys.ToArray()) { contextEnts[contextName] = contextEnts[contextName] .OrderBy(ent => ent.Get_ <Comp>().FullTypeName) .ToList(); } foreach (var kv in contextEnts) { var ents = kv.Value; var componentConstantsList = string.Join("\n", ents.ToArray() .Select((ent, index) => K_TYPE_V_INDEX .Replace("${ComponentType}", ent.Get_ <Comp>().FullTypeName) .Replace("${Index}", index.ToString())).ToArray()); var contextName = kv.Key; var filePath = contextName + Path.DirectorySeparatorChar + contextName + "ComponentsLookupDicts.cs"; var generatedBy = GetType().FullName; var contents = TEMPLATE .Replace("${Lookup}", contextName + CodeGeneratorExtentions.LOOKUP) .Replace("${kTypeVIndexList}", componentConstantsList); var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } }
protected override void Execute(List <Ent> entities) { foreach (var ent in entities) { var contextNames = ent.Get_ <ContextNamesComp>().Values; foreach (var contextName in contextNames) { var filePath = contextName + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + contextName + ent.Get_ <Comp>().Name.AddComponentSuffix( ) + ".cs"; var contents = TEMPLATE .Replace("${componentNames}", contextName + CodeGeneratorExtentions.LOOKUP + ".componentNames") .Replace(_contexts, ent, contextName); var generatedBy = GetType().FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } } }
protected override void Execute(List <Ent> entities) { foreach (var ent in entities) { var contextNames = ent.Get_ <ContextNamesComp>().Values; foreach (var contextName in contextNames) { var eventInfos = ent.Get_ <EventComp>().Values; foreach (var eventInfo in eventInfos) { var filePath = "Events" + Path.DirectorySeparatorChar + "Components" + Path.DirectorySeparatorChar + ent.EventListener(_contexts, contextName, eventInfo).AddComponentSuffix() + ".cs"; var contents = TEMPLATE.Replace(_contexts, ent, contextName, eventInfo); var generatedBy = GetType().FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } } } }
protected override void Execute(List <Ent> entities) { var settings = _contexts.Get <Settings>(); var generatePath = Path.Combine(settings.Get_ <GeneratePath>().Value, "Generated"); var stringBuilder = new StringBuilder( ); foreach (var ent in entities) { var targetPath = Path.Combine(generatePath, ent.Get_ <GeneratedFileComp>().FilePath); if (settings.Is <LogGeneratedPaths>()) { stringBuilder.Append(targetPath); stringBuilder.Append(" - "); stringBuilder.Append(ent.Get_ <GeneratedFileComp>().GeneratedBy); stringBuilder.Append("\n"); } if (settings.Is <RunInDryMode>()) { continue; } var dirPath = Path.GetDirectoryName(targetPath); if (dirPath != null && !Directory.Exists(dirPath)) { Directory.CreateDirectory(dirPath); } File.WriteAllText(targetPath, ent.Get_ <GeneratedFileComp>().Contents); } if (settings.Is <LogGeneratedPaths>()) { var s = stringBuilder.ToString( ); Console.Write(s); #if UNITY_EDITOR UnityEngine.Debug.Log(s); #endif } }
protected override void Execute(List <Ent> entities) { for (var i = 0; i < entities.Count; i++) { var ent = entities[i]; var contents = COMPONENT_TEMPLATE .Replace("${FullComponentName}", ent.Get_ <Comp>().Name); contents = contents .Replace( "${memberList}", ent.Has_ <PublicFieldsComp>() ? GenerateMemberAssignmentList(ent.Get_ <PublicFieldsComp>().Values) : "" ); var filePath = "Components" + Path.DirectorySeparatorChar + ent.Get_ <Comp>().Name.AddComponentSuffix( ) + ".cs"; var generatedBy = GetType( ).FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); } }
protected override void Execute(List <Ent> entities) { var contextNamesWithEvents = new HashSet <String>( ); foreach (var ent in entities) { contextNamesWithEvents.UnionWith(ent.Get_ <ContextNamesComp>().Values); } var contextNames = contextNamesWithEvents.ToList( ); contextNames.Sort( ); var generatedBy = GetType( ).FullName; var filePath = "Events" + Path.DirectorySeparatorChar + "EventSystems.cs"; var contents = TEMPLATE .Replace("${systemsList}", GenerateSystemList(contextNames)); var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); }
private void CreateFileEnt(Ent ent, EventInfo eventInfo, string contextName) { var methodArgs = ent.GetEventMethodArgs(eventInfo, ", " + (!ent.Has_ <PublicFieldsComp>() ? ent.PrefixedComponentName(_contexts) : GetMethodArgs(ent.Get_ <PublicFieldsComp>().Values.ToArray( )))); var filePath = "Events" + Path.DirectorySeparatorChar + "Systems" + Path.DirectorySeparatorChar + ent.Event(_contexts, contextName, eventInfo) + "EventSystem.cs"; var template = eventInfo.EventTarget == EventTarget.Self ? TEMPLATE_SELF : TEMPLATE_ANY; var cachedAccess = !ent.Has_ <PublicFieldsComp>() ? string.Empty : "var component = e." + ent.ComponentName(_contexts).LowercaseFirst( ) + ";"; if (eventInfo.EventType == EventType.Removed) { methodArgs = string.Empty; cachedAccess = string.Empty; } var contents = template .Replace("${GroupEvent}", eventInfo.EventType.ToString( )) .Replace("${filter}", GetFilter(ent, contextName, eventInfo)) .Replace("${cachedAccess}", cachedAccess) .Replace("${methodArgs}", methodArgs) .Replace(_contexts, ent, contextName, eventInfo); var generatedBy = GetType( ).FullName; var fileEnt = _contexts.Get <Main>().CreateEntity( ); fileEnt.Add_(new GeneratedFileComp(filePath, contents.WrapInNamespace(_contexts), generatedBy)); }
public GenComponentSystem(Contexts contexts) : base(contexts.Get <Main>()) { _contexts = contexts; }
public static string ComponentName(this Entity <Main> ent, Contexts contexts) { return(ent.Get_ <Comp>().FullTypeName.ToComponentName(contexts.Get <Settings>().Is <IgnoreNamespaces>())); }
public PostProcApplyDiffToDiskSystem(Contexts contexts) : base(contexts.Get <Main>()) { _contexts = contexts; }
public Gen_AllEventSystems_System(Contexts contexts) : base(contexts.Get <Main>()) { _contexts = contexts; }
public GenEventListenerCompSystem(Contexts contexts) : base(contexts.Get <Main>()) { _contexts = contexts; }
public SettingsSetCoreSettingsSystem(Contexts contexts) : base(contexts.Get <Settings>()) { _contexts = contexts; }
public GenCompEntityApiSystem(Contexts contexts) : base(contexts.Get <Main>()) { _contexts = contexts; }