private void DispatchForItem(GameObject item, DispatcherType dispType, D20DispatcherKey dispKey,
object dispIo)
{
var condArray = item.GetInt32Array(obj_f.item_pad_wielder_condition_array);
var argArrayCount = 0; // there's only one argument list for all attached conditions
for (var i = 0; i < condArray.Count; i++)
{
var condNameHash = condArray[i];
var condition = Conditions.GetByHash(condNameHash);
if (condition != null)
{
using var condArgsInMem = MemoryPool <int> .Shared.Rent(condition.numArgs);
var condArgsIn = condArgsInMem.Memory.Slice(0, condition.numArgs).Span;
foreach (ref var arg in condArgsIn)
{
arg = item.GetInt32(obj_f.item_pad_wielder_argument_array, argArrayCount++);
}
condArgsIn[2] = -1; // ... why?
ItemDispatcher.DispatcherProcessorForItems(condition, condArgsIn, dispType, dispKey, dispIo);
}
}
}
public static FluentConfig DefaultDispatcher(this FluentConfig self, DispatcherType dispatcherType, int throughput = 100, TimeSpan?throughputDeadlineTimeout = null)
{
var type = dispatcherType.GetName();
self.ConfigureDispatcher(type, throughput, throughputDeadlineTimeout);
return(self);
}
private static Timer _createTimerImpl(Int64 _interval, bool _auto_reset, DispatcherType _type)
{
++s_max_timer_id;
Timer timer = new Timer(s_max_timer_id, _type);
timer.Interval = _interval;
timer.AutoReset = _auto_reset;
return(timer);
}
/// <summary>
/// Gets the lead dispatcher.
/// </summary>
/// <param name="dispatcherType">Type of the dispatcher.</param>
/// <returns></returns>
public ILeadDispatcher GetDispatcher(DispatcherType dispatcherType)
{
ILeadDispatcher leadDispatcher;
switch (dispatcherType)
{
case DispatcherType.TerritoryDispatcher:
leadDispatcher = new TerritoryDispatcher();
break;
default:
leadDispatcher = new TerritoryDispatcher();
break;
}
return leadDispatcher;
}
//分发事件
public void Dispatcher(DispatcherType type,string str)
{
if (DispatcherType.Error == type)
{
if (error != null)
{
error.SetContent(str);
}
}
else if (DispatcherType.Building == type)
{
if (output != null)
{
output.SetContent(str);
}
}
}
public void Process(DispatcherType type, D20DispatcherKey key, object dispIo)
{
if (_dispCounter > DISPATCHER_MAX)
{
Logger.Error("Dispatcher maximum recursion reached!");
return;
}
_dispCounter++;
foreach (var subDispNode in GetSubDispatcher(type))
{
if ((subDispNode.subDispDef.dispKey == key ||
subDispNode.subDispDef.dispKey == D20DispatcherKey.NONE) && !subDispNode.condNode.IsExpired)
{
DispIoTypeImmunityTrigger dispIoImmunity = DispIoTypeImmunityTrigger.Default;
dispIoImmunity.condNode = subDispNode.condNode;
if (type != DispatcherType.ImmunityTrigger || key != D20DispatcherKey.IMMUNITY_SPELL)
{
Process(DispatcherType.ImmunityTrigger, D20DispatcherKey.IMMUNITY_SPELL, dispIoImmunity);
}
if (dispIoImmunity.interrupt == 1 && type != DispatcherType.Unused63)
{
// dispType63 is essentially <. Minor globe of invulnerability
dispIoImmunity.interrupt = 0;
dispIoImmunity.val2 = 10;
Process(DispatcherType.Unused63, D20DispatcherKey.NONE, dispIo);
if (dispIoImmunity.interrupt == 0)
{
var args = new DispatcherCallbackArgs(subDispNode, _owner, type, key, dispIo);
subDispNode.subDispDef.callback(in args);
}
}
else
{
var args = new DispatcherCallbackArgs(subDispNode, _owner, type, key, dispIo);
subDispNode.subDispDef.callback(in args);
}
}
}
_dispCounter--;
}
public static void DispatcherProcessorForItems(ConditionSpec condStruct, Span <int> condArgs,
DispatcherType dispType, D20DispatcherKey key, object dispIo)
{
var condAttachment = new ConditionAttachment(condStruct);
for (int i = 0; i < condStruct.numArgs; i++)
{
condAttachment.args[i] = condArgs[i];
}
for (int i = 0; i < condStruct.subDispDefs.Length; i++)
{
var sdd = condStruct.subDispDefs[i];
if (sdd.dispType == dispType && (sdd.dispKey == key || sdd.dispKey == D20DispatcherKey.NONE))
{
var attachment = new SubDispatcherAttachment();
attachment.subDispDef = sdd;
attachment.condNode = condAttachment;
var callbackArgs = new DispatcherCallbackArgs(attachment, null, dispType, key, dispIo);
sdd.callback(in callbackArgs);
}
}
}
public TypeAttribute(DispatcherType type)
{
Type = type;
}
public static Timer CreateAutoResetTimer(Int64 _interval, DispatcherType _type = DispatcherType.Game)
{
return(_createTimerImpl(_interval, true, _type));
}
private Timer(UInt64 _timer_id, DispatcherType _type)
{
m_timer_id = _timer_id;
m_dispatcher_type = _type;
}
public static string GetName(this DispatcherType self)
{
//TODO: switch case return string?
return(self.ToString());
}
public static ConditionSpec.Builder AddHandler <T, U>(this ConditionSpec.Builder builder, DispatcherType type,
D20DispatcherKey key, SubDispatcherCallback <T, U> handler, T data1, U data2)
{
void HandlerWithArgs(in DispatcherCallbackArgs args) => handler(in args, data1, data2);
return(builder.AddHandler(type, key, HandlerWithArgs));
}
public static void DispatchDamage(this GameObject critter, DispatcherType type, DispIoDamage dispIo)
{
var dispatcher = critter.GetDispatcher();
dispatcher?.Process(type, D20DispatcherKey.NONE, dispIo);
}
public static int DispatchForCritter(this GameObject obj, DispIoBonusList eventObj, DispatcherType dispType,
D20DispatcherKey dispKey)
{
if (obj == null || !obj.IsCritter())
{
return(0);
}
var dispatcher = obj.GetDispatcher();
if (dispatcher == null)
{
return(0);
}
if (eventObj == null)
{
eventObj = DispIoBonusList.Default;
}
dispatcher.Process(dispType, dispKey, eventObj);
return(eventObj.bonlist.OverallBonus);
}
/// <summary>
/// Creates a new <see cref="UwpDispatcher"/>.
/// </summary>
public UwpDispatcher()
{
DispatcherType = DispatcherType.Main;
}
/// <summary>
/// Gets the first found <see cref="IDispatcher"/> with the specified <see cref="DispatcherType"/> flag.
/// </summary>
/// <param name="dispatchers">The collection of available <see cref="IDispatcher"/>s.</param>
/// <param name="type">The <see cref="DispatcherType"/> requested from the desired <see cref="IDispatcher"/>.</param>
/// <returns>The <see cref="IDispatcher"/> managing the background thread.</returns>
public static IDispatcher GetDispatcher(this IEnumerable <IDispatcher> dispatchers, DispatcherType type)
{
if (dispatchers == null || !dispatchers.Any())
{
throw new ArgumentException("The collection must contain at least one available IDispatcher.", nameof(dispatchers));
}
var background = dispatchers.FirstOrDefault(d => d.DispatcherType.HasFlag(type));
if (background != null)
{
return(background);
}
else
{
throw new ArgumentException($"No IDispatchers of the specified type {type} were avaliable in the provided collection", nameof(dispatchers));
}
}
/// <summary>
/// Creates a new <see cref="WpfDispatcher"/>.
/// </summary>
public WpfDispatcher()
{
DispatcherType = DispatcherType.Main;
}
public static ConditionSpec.Builder AddHandler <T>(this ConditionSpec.Builder builder, DispatcherType type,
SubDispatcherCallback <T> handler, T data)
{
void HandlerWithArgs(in DispatcherCallbackArgs args) => handler(in args, data);
return(builder.AddHandler(type, HandlerWithArgs));
}
/// <summary>
/// Creates a new <see cref="BaseDispatcher"/> with the specified flags.
/// </summary>
/// <param name="dispatcherType">A set of <see cref="DispatcherType"/> flags indicating whether this <see cref="IDispatcher"/> manages special kinds of threads, which can (and should) be utilized in scenarios such as updating UI elements from code.</param>
public BaseDispatcher(DispatcherType dispatcherType = DispatcherType.None)
{
DispatcherType = dispatcherType;
}
public static FluentConfig DefaultDispatcher(this FluentConfig self, DispatcherType dispatcherType,
int throughput = 100, TimeSpan? throughputDeadlineTimeout = null)
{
string type = dispatcherType.GetName();
self.ConfigureDispatcher(type, throughput, throughputDeadlineTimeout);
return self;
}
