AlicizaX/DragonECS
1
0
Fork 0
mirror of https://github.com/DCFApixels/DragonECS.git synced 2025-09-18 01:44:35 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update runner

Browse Source
This commit is contained in:
Mikhail 2023-03-12 01:33:48 +08:00
parent 66b136df92
commit 6ae6775e00
7 changed files with 32 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/Builtin/InjectProcessor.cs
View File

@ -6,8 +6,13 @@ using System.Threading.Tasks;
namespace DCFApixels.DragonECS
{
public interface IEcsInject<T>
{
public void Inject(T obj);
}
public class InjectProcessor<T> : IDo<_PreInit>
{
private T _injectedData;
public InjectProcessor(T injectedData)

1
src/Interfaces/IEcsProcessor.cs
View File

@ -1,6 +1,5 @@
namespace DCFApixels.DragonECS
{
public interface IEcsProcessor { }
public struct _PreInit { }
public struct _Init { }

50
src/React/EcsProcessorsMessenger.cs
View File

@ -1,50 +0,0 @@
using System.Collections.Generic;
using System;
namespace DCFApixels.DragonECS
{
public interface IEcsProcessorsMessenger
{
public EcsSession Source { get; }
}
public interface IEcsProcessorsMessenger<TMessage> : IEcsProcessorsMessenger where TMessage : IEcsMessage { }
public class EcsProcessorsMessenger<TMessage> : IEcsProcessorsMessenger<TMessage>, IDisposable
where TMessage : IEcsMessage
{
private readonly EcsSession _source;
private readonly IReceive<TMessage>[] _targets;
public EcsSession Source => _source;
public IReadOnlyList<IReceive<TMessage>> Targets => _targets;
internal EcsProcessorsMessenger(EcsSession source)
{
_source = source;
List<IReceive<TMessage>> list = new List<IReceive<TMessage>>();
foreach (var item in _source.AllProcessors)
{
if (item is IReceive<TMessage> targetItem)
{
list.Add(targetItem);
}
}
_targets = list.ToArray();
}
public void Send(TMessage message)
{
Send(in message);
}
public void Send(in TMessage message)
{
foreach (var item in _targets)
{
item.Do(_source, in message);
}
}
public void Destroy() => _source.OnMessengerDetroyed(this);
void IDisposable.Dispose() => Destroy();
}
}

45
src/React/EcsProcessorsRunner.cs
View File

@ -1,45 +0,0 @@
using System;
using System.Collections.Generic;
namespace DCFApixels.DragonECS
{
public interface IEcsProcessorsRunner
{
public EcsSession Source { get; }
public void Run();
}
public class EcsProcessorsRunner<TDoTag> : IEcsProcessorsRunner, IDisposable
{
private readonly EcsSession _source;
private readonly IDo<TDoTag>[] _targets;
public EcsSession Source => _source;
public IReadOnlyList<IDo<TDoTag>> Targets => _targets;
internal EcsProcessorsRunner(EcsSession source)
{
_source = source;
List<IDo<TDoTag>> list = new List<IDo<TDoTag>>();
foreach (var item in _source.AllProcessors)
{
if (item is IDo<TDoTag> targetItem)
{
list.Add(targetItem);
}
}
_targets = list.ToArray();
}
public void Run()
{
foreach (var item in _targets)
{
item.Do(_source);
}
}
public void Destroy() => _source.OnRunnerDetroyed(this);
void IDisposable.Dispose() => Destroy();
}
}

55
src/React/RunnerHandler.cs → src/React/EcsRunner.cs
View File

@ -7,35 +7,35 @@ using System.Runtime.CompilerServices;
namespace DCFApixels.DragonECS
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
sealed class RunnerFilterAttribute : Attribute
sealed class EcsRunnerFilterAttribute : Attribute
{
public readonly Type interfaceType;
public readonly object filter;
public RunnerFilterAttribute(Type interfaceType, object filter)
public EcsRunnerFilterAttribute(Type interfaceType, object filter)
{
this.interfaceType = interfaceType;
this.filter = filter;
}
}
public interface IProcessor { }
public interface IEcsProcessor { }
public static class IProcessorExtensions
public static class IEcsProcessorExtensions
{
public static bool IsRunner(this IProcessor self)
public static bool IsRunner(this IEcsProcessor self)
{
return self is IRunner;
return self is IEcsRunner;
}
}
internal static class RunnerActivator
internal static class EcsRunnerActivator
{
private static bool _isInit = false;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static void Init()
{
if (_isInit) return;
Type targetType = typeof(Runner<>);
Type targetType = typeof(EcsRunner<>);
var subclasses = Assembly.GetAssembly(targetType).GetTypes().Where(type => type.BaseType != null && type.BaseType.IsGenericType && targetType == type.BaseType.GetGenericTypeDefinition());
foreach (var item in subclasses)
{
@ -45,10 +45,11 @@ namespace DCFApixels.DragonECS
}
}
public interface IRunner { }
public abstract class Runner<TInterface> : IProcessor, IRunner
where TInterface : IProcessor
public interface IEcsRunner { }
public abstract class EcsRunner<TInterface> : IEcsProcessor, IEcsRunner
where TInterface : IEcsProcessor
{
internal static void Init(Type subclass)
{
@ -66,58 +67,56 @@ namespace DCFApixels.DragonECS
{
throw new ArgumentException($"{typeof(TInterface).FullName} is not interface");
}
if (interfaces.Length != 1 || interfaces[0] != typeof(IProcessor))
if (interfaces.Length != 1 || interfaces[0] != typeof(IEcsProcessor))
{
throw new ArgumentException($"{typeof(TInterface).FullName} does not directly inherit the {nameof(IProcessor)} interface");
throw new ArgumentException($"{typeof(TInterface).FullName} does not directly inherit the {nameof(IEcsProcessor)} interface");
}
#endif
_subclass = subclass;
}
public static TInterface Instantiate(IEnumerable<IProcessor> targets, object filter)
public static TInterface Instantiate(IEnumerable<IEcsProcessor> targets, object filter)
{
Type interfaceType = typeof(TInterface);
IEnumerable<IProcessor> newTargets;
IEnumerable<TInterface> newTargets = targets.OfType<TInterface>();
if (filter != null)
{
newTargets = targets.Where(o =>
newTargets = newTargets.Where(o =>
{
if (o is TInterface == false) return false;
var atr = o.GetType().GetCustomAttribute<RunnerFilterAttribute>();
var atr = o.GetType().GetCustomAttribute<EcsRunnerFilterAttribute>();
return atr != null && atr.interfaceType == interfaceType && atr.filter.Equals(filter);
});
}
else
{
newTargets = targets.Where(o =>
newTargets = newTargets.Where(o =>
{
if (o is TInterface == false) return false;
var atr = o.GetType().GetCustomAttribute<RunnerFilterAttribute>();
var atr = o.GetType().GetCustomAttribute<EcsRunnerFilterAttribute>();
return atr == null || atr.interfaceType == interfaceType && atr.filter == null;
});
}
return Instantiate(newTargets.Select(o => (TInterface)o).ToArray());
return Instantiate(newTargets.ToArray());
}
public static TInterface Instantiate(IEnumerable<IProcessor> targets)
public static TInterface Instantiate(IEnumerable<IEcsProcessor> targets)
{
return Instantiate(targets.Where(o => o is TInterface).Select(o => (TInterface)o).ToArray());
return Instantiate(targets.OfType<TInterface>().ToArray());
}
internal static TInterface Instantiate(TInterface[] targets)
{
RunnerActivator.Init();
var instance = (Runner<TInterface>)Activator.CreateInstance(_subclass);
return (TInterface)(IProcessor)instance.Set(targets);
EcsRunnerActivator.Init();
var instance = (EcsRunner<TInterface>)Activator.CreateInstance(_subclass);
return (TInterface)(IEcsProcessor)instance.Set(targets);
}
private static Type _subclass;
protected TInterface[] targets;
private Runner<TInterface> Set(TInterface[] targets)
private EcsRunner<TInterface> Set(TInterface[] targets)
{
this.targets = targets;
return this;

0
src/React/RunnerHandler.cs.meta → src/React/EcsRunner.cs.meta
View File

15
src/React/WorldFilterAttribute.cs
View File

@ -1,15 +0,0 @@
using System;
namespace DCFApixels.Assets.DragonECS.src.React
{
[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
sealed class WorldFilterAttribute : Attribute //TODO
{
public readonly string[] worlds;
public WorldFilterAttribute(params string[] worlds)
{
this.worlds = worlds;
}
}
}