private void SubscribeByInterfaceAndTopic <T>(IConsume <T> consumer, Func <T, bool> topic, Action <Exception> onError)
{
IDisposable subscription = GetSubscriptionSubject <T>();
IObservableWithOutcomes <T> subject = (IObservableWithOutcomes <T>)subscription;
SubscribeWithInterface(consumer, subject, onError, topic);
}
private void SubscribeByInterface <T>(IConsume <T> consumer, Action <Exception> onError)
{
var subscription = GetSubscriptionSubject <T>();
var subject = (IObservableWithOutcomes <T>)subscription;
SubscribeWithInterface(consumer, subject, onError);
}
public void SetupQueuedConsumer()
{
_delegatingConsumer = new DelegatingConsumer<TestMessages.TestMessage> ((msg) => {
_received.Add(msg);
});
_queuedConsumer = new QueuedConsumer<TestMessages.TestMessage> (_delegatingConsumer);
}
public void UseItem(int selected)
{
if (activeFilter == Item.Categories.Misc || activeFilter == Item.Categories.Ammo)
{
GD.Print("Nothing to do with these.");
return;
}
ItemData dat = itemData[selected];
Actor player = Session.session.player;
int playerItemIndex = player.IndexOf(dat.type, dat.name);
switch (activeFilter)
{
case Item.Categories.Weapons:
player.EquipItem(playerItemIndex);
break;
case Item.Categories.Apparel:
player.EquipItem(playerItemIndex);
break;
case Item.Categories.Aid:
ItemData retrieved = player.RetrieveItem(playerItemIndex);
IConsume consumable = Item.FromData(retrieved) as IConsume;
if (consumable != null)
{
consumable.Consume(player);
}
break;
}
RefreshInventory();
RefreshStashItemInfo();
}
private IObservable <T> InitializeConsumer()
{
_cancel = new CancellationTokenSource();
_collection = new BlockingCollection <T>();
_undeliverableConsumer = new ActionConsumer <T>(@event => { });
return(_collection.AsConsumingObservable(_cancel.Token));
}
public void Subscribe <TMessage>(string topic, IConsume <TMessage> consumer) where TMessage : IMessage
{
subscriptions.AddOrUpdate(topic, key => new MultiPlexer(new NarrowingConsumer <TMessage>(consumer)),
(key, multiPlexer) =>
{
multiPlexer.Add(new NarrowingConsumer <TMessage>(consumer));
return(multiPlexer);
});
}
public void OnBeforeConsume <TMessage, TConsumer>(IConsume <TMessage> consumer, TMessage message) where TMessage : class where TConsumer : IConsume <TMessage>
{
if (!CreateStateHandlerIfConsumerRequiresState <TConsumer, TMessage>())
{
return;
}
handler.LoadState(consumer, message);
}
public void RegisterHandler <T>(IConsume <T> handler) where T : class, Event
{
if (_registry.ContainsKey(typeof(T)))
{
_registry[typeof(T)] += e => handler.Consume(e as T);
}
else
{
_registry.Add(typeof(T), e => handler.Consume(e as T));
}
}
public void OnBeforeConsume <TMessage, TConsumer>(IConsume <TMessage> consumer, TMessage message) where TMessage : class where TConsumer : IConsume <TMessage>
{
var requiresLocking = typeof(TConsumer).IsOfGenericType(typeof(IConsumeLocked <>));
if (!requiresLocking)
{
return;
}
_lock = locker.AcquireLock(GetCorrelationIdentifier <TMessage, TConsumer>(message));
}
public void Enter(PlayerMachine.Data playerControll)
{
result = null;
data = playerControll;
item = (IConsume)data.character.Equipment.ItemSlots.Items[data.slotIndex].item;
data.cost = 1;
data.lineRender[0].enabled = false;
data.lineRender[1].enabled = false;
var gui = Object.FindObjectOfType <GUIControll>();
gui.GUIEnabled.mission.Distance.SetActive(false);
}
private void SubscribeWithInterface <T>(IConsume <T> consumer, IObservableWithOutcomes <T> observable,
Action <Exception> onError, Func <T, bool> filter = null)
{
var subscriptionType = typeof(T);
var unsubscription = _unsubscriptions.GetOrAdd(subscriptionType, t => new CancellationTokenSource());
if (filter != null)
{
observable.Subscribe(@event =>
{
try
{
if (!filter(@event))
{
observable.Outcomes.Add(new ObservableOutcome {
Result = false
});
}
else
{
var result = Handle(consumer, @event);
observable.Outcomes.Add(new ObservableOutcome {
Result = result
});
}
}
catch (Exception ex)
{
OnHandlerError(onError, ex, observable);
}
}, e => OnError(e, observable), () => OnCompleted(observable), unsubscription.Token);
}
else
{
observable.Subscribe(@event =>
{
try
{
var result = Handle(consumer, @event);
observable.Outcomes.Add(new ObservableOutcome {
Result = result
});
}
catch (Exception ex)
{
OnHandlerError(onError, ex, observable);
}
}, e => OnError(e, observable), () => OnCompleted(observable), unsubscription.Token);
}
}
public void Consume <T>(string name, IConsume <T> consumer) where T : class
{
lock (this)
{
if (!consumers.Any(c => c.Consumer == consumer))
{
consumers.Add(new ConsumerAndName
{
Name = name,
Consumer = consumer
});
}
}
}
public ActionConsumer(Action <T> @delegate, IConsume <T> forwardTo)
{
_delegate = async @event =>
{
try
{
@delegate(@event);
return(await forwardTo.HandleAsync(@event));
}
catch (Exception)
{
return(false);
}
};
}
private BackgroundThreadProducer(BlockingCollection <T> source, bool @internal = true)
{
_buffer = source;
_internal = @internal;
MaxDegreeOfParallelism = 1;
_uptime = new Stopwatch();
_cancel = new CancellationTokenSource();
_empty = new SemaphoreSlim(1);
var devNull = new ActionConsumer <QueuedMessage <T> >(message => { });
_consumer = devNull;
_backlogConsumer = devNull;
_undeliverableConsumer = devNull;
}
public BackgroundThreadProducer(BlockingCollection <T> source)
{
Buffer = source;
MaxDegreeOfParallelism = 1;
_uptime = new Stopwatch();
_cancel = new CancellationTokenSource();
_empty = new SemaphoreSlim(1);
RetryPolicy = new RetryPolicy();
RateLimitPolicy = new RateLimitPolicy();
var devNull = new ActionConsumer <T>(@event => { });
_consumer = devNull;
_backlogConsumer = devNull;
_undeliverableConsumer = devNull;
}
public IConsume(IConsume item)
{
RemoveAllState = item.RemoveAllState;
AddState = item.AddState;
RemoveState = item.RemoveState;
AddTrait = item.AddTrait;
RemoveTrait = item.RemoveTrait;
Stats = item.Stats;
Recover = item.Recover;
Name = item.Name;
Icon = item.Icon;
Category = item.Category;
Description = item.Description;
Value = item.Value;
Stack = item.Stack;
}
private static bool Handle <T>(IConsume <T> consumer, T @event)
{
if (consumer is IConsumeScoped <T> before)
{
if (!before.Before())
{
return(false);
}
}
var result = consumer.HandleAsync(@event).ConfigureAwait(false).GetAwaiter().GetResult();
if (consumer is IConsumeScoped <T> after)
{
result = after.After(result);
}
return(result);
}
public void ConsumeItem(IConsume item)
{
Stats.AddStats(item.Stats);
Effects.RemoveAll(x => StaticValues.States.States[x.State].TypeState == item.RemoveAllState && item.RemoveAllState != TypeState.None);
foreach (var state in item.AddState)
{
AddEffect(StaticValues.States.States[state]);
}
foreach (var state in item.RemoveState)
{
Effects.RemoveAll(x => x.State == state);
}
foreach (var trait in item.AddTrait)
{
AddTrait(trait);
}
foreach (var trait in item.RemoveTrait)
{
Traits.Remove(trait);
}
if (item.Recover.hp > 0)
{
currentStats.lifeStats.RecoverHP(item.Recover.hp);
}
if (item.Recover.mp > 0)
{
currentStats.lifeStats.RecoverMP(item.Recover.mp);
}
if (item.Recover.precent_hp > 0)
{
currentStats.lifeStats.RecoverHP_Precent(item.Recover.precent_hp);
}
if (item.Recover.precent_mp > 0)
{
currentStats.lifeStats.RecoverMP_Precent(item.Recover.precent_mp);
}
UpdateStats();
}
public void HarvestTarget(Transform target)
{
if (!isHarvesting)
{
isHarvesting = true;
StartCoroutine(AttackCooldown());
IHaveMass _mass = target.GetComponent <IHaveMass>();
IHaveBiteSize _bite = GetComponent <IHaveBiteSize>();
if (_mass != null)
{
if (_bite != null)
{
if (_mass.Mass - _bite.BiteSize > 0)
{
_mass.Mass -= _bite.BiteSize;
IConsume _consumeFood = GetComponent <IConsume>();
if (_consumeFood != null)
{
_consumeFood.IAddFood(_bite.BiteSize);
}
}
else
{
IConsume _consumeFood = GetComponent <IConsume>();
if (_consumeFood != null)
{
_consumeFood.IAddFood(_mass.Mass);
EvaluateSurroundings _surroundings = GetComponent <EvaluateSurroundings>();
if (_surroundings != null)
{
_surroundings.CheckDetectedCreature(target, false);
}
}
_mass.Mass = 0;
}
}
}
}
}
public ConsumeEnd(IMessage message, IConsume consumer, string queueName)
{
Message = message;
Consumer = consumer;
QueueName = queueName;
}
public Channel(IConsume<Event> handler)
{
_handler = handler;
}
public void Attach(IConsume <T> consumer)
{
_handler = consumer.HandleAsync;
}
public Channel(IConsume <Event> handler)
{
_handler = handler;
}
public void Attach(IConsume <T> consumer)
{
_producer.Attach(consumer);
}
public void Add(IConsume <IMessage> consumer)
{
consumers.Enqueue(consumer);
}
public void Subscribe <T>(IConsume <T> consumer, Func <T, bool> topic, Action <Exception> onError)
{
SubscribeByInterfaceAndTopic(consumer, topic, onError ?? NoopErrorHandler);
}
public void Subscribe <T>(IConsume <T> consumer, Action <Exception> onError = null)
{
SubscribeByInterface(consumer, onError ?? NoopErrorHandler);
}
private static bool Handle <T>(IConsume <T> consumer, T @event)
{
return(consumer.HandleAsync(@event).ConfigureAwait(false).GetAwaiter().GetResult());
}
public SimpleConsumerFactory(IConsume consume)
{
this.consume = consume;
}
public void SetUp()
{
_output = new FakeOutput();
_consumer = new DeploymentProcessOutputConsumer(_output);
}
public DetermineNextStateOfDeadCell(IConsume <CellLived> cellLivedChannel,
IConsume <CellDied> cellDiedChannel)
{
_cellLivedChannel = cellLivedChannel;
_cellDiedChannel = cellDiedChannel;
}
public void Attach(IConsume <T> consumer)
{
_consumer = consumer;
}
public virtual void Attach(IConsume <IEnumerable <ScheduledTask> > consumer)
{
Background.Attach(consumer);
}
public virtual void Attach(IConsume <T> consumer)
{
Background.Attach(consumer);
}
public CellStateAggregator(IConsume <OneGenerationOfCellStatesAggregated> channel)
{
_channel = channel;
_count = 0;
}
