/// <summary>
/// Associates a given entity (either transient or associated with another session) to the given session.
/// </summary>
/// <param name="event">The event triggering the re-association </param>
/// <param name="entity">The entity to be associated </param>
/// <param name="id">The id of the entity. </param>
/// <param name="persister">The entity's persister instance. </param>
/// <returns> An EntityEntry representing the entity within this session. </returns>
protected EntityEntry Reassociate(AbstractEvent @event, object entity, object id, IEntityPersister persister)
{
if (log.IsDebugEnabled)
{
log.Debug("Reassociating transient instance: " +
MessageHelper.InfoString(persister, id, @event.Session.Factory));
}
IEventSource source = @event.Session;
EntityKey key = new EntityKey(id, persister, source.EntityMode);
source.PersistenceContext.CheckUniqueness(key, entity);
//get a snapshot
object[] values = persister.GetPropertyValues(entity, source.EntityMode);
TypeFactory.DeepCopy(values, persister.PropertyTypes, persister.PropertyUpdateability, values, source);
object version = Versioning.GetVersion(values, persister);
EntityEntry newEntry = source.PersistenceContext.AddEntity(entity, Status.Loaded, values, key, version, LockMode.None, true, persister, false, true);
new OnLockVisitor(source, id, entity).Process(entity, persister);
persister.AfterReassociate(entity, source);
return(newEntry);
}
public QueuedMessage(String messageName, List <MessageFragment> messageFragments, int secondsDelay, AbstractEvent abstractEvent)
{
this.messageName = compoundMessageIdentifier + messageName;
this.messageFolders = getMessageFolders(messageFragments, false);
this.dueTime = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + (secondsDelay * 1000) + updateInterval;
this.abstractEvent = abstractEvent;
}
public async Task <int> ReceiveExternalEventAsync(AbstractEvent e)
{
receivedEventCount++;
externalEventQueue.Data.Enqueue(e);
return(0);
}
/// <summary>
/// Associates a given entity (either transient or associated with another session) to the given session.
/// </summary>
/// <param name="event">The event triggering the re-association </param>
/// <param name="entity">The entity to be associated </param>
/// <param name="id">The id of the entity. </param>
/// <param name="persister">The entity's persister instance. </param>
/// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param>
/// <returns> An EntityEntry representing the entity within this session. </returns>
protected async Task <EntityEntry> ReassociateAsync(AbstractEvent @event, object entity, object id, IEntityPersister persister, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (log.IsDebugEnabled())
{
log.Debug("Reassociating transient instance: {0}", MessageHelper.InfoString(persister, id, @event.Session.Factory));
}
IEventSource source = @event.Session;
EntityKey key = source.GenerateEntityKey(id, persister);
source.PersistenceContext.CheckUniqueness(key, entity);
//get a snapshot
object[] values = persister.GetPropertyValues(entity);
TypeHelper.DeepCopy(values, persister.PropertyTypes, persister.PropertyUpdateability, values, source);
object version = Versioning.GetVersion(values, persister);
EntityEntry newEntry = source.PersistenceContext.AddEntity(
entity,
persister.IsMutable ? Status.Loaded : Status.ReadOnly,
values,
key,
version,
LockMode.None,
true,
persister,
false);
await(new OnLockVisitor(source, id, entity).ProcessAsync(entity, persister, cancellationToken)).ConfigureAwait(false);
persister.AfterReassociate(entity, source);
return(newEntry);
}
public void processingStep()
{
AbstractEvent externalEvent = null;
if (externalEventQueue.Data.TryDequeue(out externalEvent))
{
var processingStart = stopwatch.ElapsedMilliseconds;
externalEvent.knownToNodes.Add(this.nodeName);
processQueries(externalEvent);
benchmarkMeter.registerProcessedEvent(externalEvent, processingStart, stopwatch.ElapsedMilliseconds);
}
AbstractEvent internalEvent = null;
if (internalEventQueue.Data.TryDequeue(out internalEvent))
{
var processingStart = stopwatch.ElapsedMilliseconds;
processQueries(internalEvent);
forwardRuleProcessor.processEvent(internalEvent);
benchmarkMeter.registerProcessedEvent(internalEvent, processingStart, stopwatch.ElapsedMilliseconds);
}
benchmarkMeter.tick(stopwatch.ElapsedMilliseconds);
updateRemainingTimePrinter(stopwatch.ElapsedMilliseconds);
}
private void NotifySubscribers(AbstractEvent eventData)
{
List <EventSubscriber> subscribers = gameEvents[eventData.type];
for (int cnt = subscribers.Count - 1; cnt >= 0; cnt--) // Trigger buffs, then argument effects, then debuffs
// This check is LITERALLY for only one status effect - Resonance.
// Because Resonance will remove all other Resonance subscribers during its own NotifyOfEvent, and the original notification happens here...
// If there were 5 resonance listeners, the subscribers.count would go from 5->0 in the first iteration, but the for loop would still iterate 4 more times.
// This causes an array-out-of-index error. Ideally, this check prevents that.
// I don't want to have to keep doing hacks like this as it's gonna come back to bite me, but it works.
// TODO: Rework Resonance implementation to prevent having to use this
{
if (cnt >= subscribers.Count)
{
continue;
}
EventSubscriber subscriber = subscribers[cnt];
subscriber.NotifyOfEvent(eventData);
}
// update ui
List <ITriggerOnEvent> UISubscribers = UIEvents[eventData.type];
foreach (ITriggerOnEvent subscriber in UISubscribers)
{
subscriber.TriggerOnEvent(eventData);
}
}
private void triggerEvent(String eventName, AbstractEvent abstractEvent, GameStateData previousGameState, GameStateData currentGameState)
{
try
{
abstractEvent.trigger(previousGameState, currentGameState);
}
catch (Exception e)
{
if (faultingEventsCount.ContainsKey(eventName))
{
faultingEventsCount[eventName]++;
if (faultingEventsCount[eventName] > 5)
{
Console.WriteLine("Event " + eventName +
" has failed > 5 times in this session");
}
}
if (!faultingEvents.ContainsKey(eventName))
{
Console.WriteLine("Event " + eventName + " threw exception " + e.Message);
Console.WriteLine("This is the first time this event has failed in this session");
faultingEvents.Add(eventName, e.Message);
faultingEventsCount.Add(eventName, 1);
}
else if (faultingEvents[eventName] != e.Message)
{
Console.WriteLine("Event " + eventName + " threw a different exception: " + e.Message);
faultingEvents[eventName] = e.Message;
}
}
}
/// <summary>
/// Associates a given entity (either transient or associated with another session) to the given session.
/// </summary>
/// <param name="event">The event triggering the re-association </param>
/// <param name="entity">The entity to be associated </param>
/// <param name="id">The id of the entity. </param>
/// <param name="persister">The entity's persister instance. </param>
/// <returns> An EntityEntry representing the entity within this session. </returns>
protected EntityEntry Reassociate(AbstractEvent @event, object entity, object id, IEntityPersister persister)
{
if (log.IsDebugEnabled)
{
log.Debug("Reassociating transient instance: " + MessageHelper.InfoString(persister, id, @event.Session.Factory));
}
IEventSource source = @event.Session;
EntityKey key = source.GenerateEntityKey(id, persister);
source.PersistenceContext.CheckUniqueness(key, entity);
//get a snapshot
object[] values = persister.GetPropertyValues(entity, source.EntityMode);
TypeHelper.DeepCopy(values, persister.PropertyTypes, persister.PropertyUpdateability, values, source);
object version = Versioning.GetVersion(values, persister);
EntityEntry newEntry = source.PersistenceContext.AddEntity(
entity,
persister.IsMutable ? Status.Loaded : Status.ReadOnly,
values,
key,
version,
LockMode.None,
true,
persister,
false,
true);
new OnLockVisitor(source, id, entity).Process(entity, persister);
persister.AfterReassociate(entity, source);
return newEntry;
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
if (eventData.type == EventType.POISE_APPLIED)
{
EventPoiseApplied data = (EventPoiseApplied)eventData;
if (data.target.OWNER == this.OWNER)
{
NegotiationManager.Instance.AddAction(new AddStacksToArgumentAction(this, 1));
}
}
else if (eventData.type == EventType.TURN_END)
{
EventTurnEnd data = (EventTurnEnd)eventData;
if (data.end == this.OWNER)
{
NegotiationManager.Instance.AddAction(new DestroyArgumentAction(this));
}
}
else if (eventData.type == EventType.ARGUMENT_DESTROYED)
{
EventArgDestroyed data = (EventArgDestroyed)eventData;
if (data.argumentDestroyed == this)
{
AbstractCharacter enemy = TurnManager.Instance.GetOtherCharacter(this.OWNER);
NegotiationManager.Instance.AddAction(new DamageAction(null, enemy, this.stacks, this.stacks, this));
}
}
}
private static void EnsureTransaction(AbstractEvent @event)
{
if (@event.Session.Transaction == null || [email protected])
{
throw new InvalidProgramException("Nenhuma transação foi iniciada.");
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
NegotiationManager.Instance.AddAction(new ApplyPoiseAction(this.OWNER, this.OWNER.GetCoreArgument(), this.stacks));
foreach (AbstractArgument arg in this.OWNER.GetSupportArguments())
{
NegotiationManager.Instance.AddAction(new ApplyPoiseAction(this.OWNER, arg, this.stacks));
}
}
/// <summary>
/// Does the work, after checking that the entity type is indeed indexed.
/// </summary>
/// <param name="entity"></param>
/// <param name="id"></param>
/// <param name="workType"></param>
/// <param name="e"></param>
protected void ProcessWork(Object entity, object id, WorkType workType, AbstractEvent e)
{
if (EntityIsIndexed(entity))
{
Work work = new Work(entity, id, workType);
searchFactory.Worker.PerformWork(work, e.Session);
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
if (this.OWNER.GetHand().Contains(this))
{
int modifier = this.OWNER.GetSupportArguments().Count;
this.COST = cardCost - modifier;
}
}
public override bool check(AbstractEvent primitiveCandidateComponent, AbstractEvent primitiveBufferedComponent)
{
if (primitiveBufferedComponent.type.Equals(typeToCheck) && primitiveCandidateComponent.type.Equals(typeToCheck))
{
return(primitiveCandidateComponent.ID.Equals(primitiveBufferedComponent.ID));
}
return(false);
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventCardDrawn data = (EventCardDrawn)eventData;
if (data.cardDrawn.AMBIENCE == CardAmbient.DIALOGUE)
{
NegotiationManager.Instance.AddAction(new DeployArgumentAction(data.cardDrawn.OWNER, new ArgumentFinesse(), 1));
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventAmbientStateShift data = (EventAmbientStateShift)eventData;
if (data.newState > data.oldState)
{
NegotiationManager.Instance.AddAction(new DrawCardsAction(this.OWNER, this.stacks));
}
}
public QueuedMessage(String messageName, DelayedMessageEvent delayedMessageEvent, int secondsDelay, AbstractEvent abstractEvent)
{
this.messageName = compoundMessageIdentifier + messageName;
this.delayedMessageEvent = delayedMessageEvent;
this.delayMessageResolution = true;
this.dueTime = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + (secondsDelay * 1000) + updateInterval;
this.delayMessageResolution = true;
this.abstractEvent = abstractEvent;
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventTurnEnd data = (EventTurnEnd)eventData;
if (data.end == this.OWNER)
{
NegotiationManager.Instance.AddAction(new DestroyArgumentAction(this));
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventTurnStart data = (EventTurnStart)eventData;
if (data.start == this.OWNER)
{
NegotiationManager.Instance.AddAction(new PlantArgumentAction(TurnManager.Instance.GetOtherCharacter(this.OWNER), new ArgumentStress(), this.stacks), this);
}
}
private void OnGameStateChanged(AbstractEvent e)
{
var evt = e as GameStateChangeEvent;
SearchingForServerUI.SetActive(evt.GameState == GameController.GameStates.SearchingForServer);
SearchingForMarker.SetActive(evt.GameState == GameController.GameStates.SearchingForMarker);
SearchingForTrackerUI.SetActive(evt.GameState == GameController.GameStates.SearchingForTracker);
PlayingUI.SetActive(evt.GameState == GameController.GameStates.Playing);
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventTurnStart data = (EventTurnStart)eventData;
if (data.start == this.OWNER)
{
NegotiationManager.Instance.AddAction(new ApplyPoiseAction(this.OWNER, this.OWNER.GetCoreArgument(), this.stacks));
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventTurnEnd data = (EventTurnEnd)eventData;
if (data.end == this.host.OWNER)
{
this.ExpireEffect();
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventTurnEnd person = (EventTurnEnd)eventData;
if (person.end == this.OWNER)
{
AbstractCharacter opponent = TurnManager.Instance.GetOtherCharacter(this.OWNER);
NegotiationManager.Instance.AddAction(new DamageAction(null, opponent, stacks, stacks, this));
}
}
public QueuedMessage(String message, int secondsDelay, AbstractEvent abstractEvent)
{
this.messageName = message;
List <MessageFragment> messageFragments = new List <MessageFragment>();
messageFragments.Add(MessageFragment.Text(message));
this.messageFolders = getMessageFolders(messageFragments, false);
this.dueTime = (DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond) + (secondsDelay * 1000) + updateInterval;
this.abstractEvent = abstractEvent;
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventArgDestroyed data = (EventArgDestroyed)eventData;
if (data.destroyingCard == this)
{
GameState.mastery += 1;
}
return;
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventArgStacksAdded data = (EventArgStacksAdded)eventData;
if (data.argumentAddedTo == this && data.newStackCount >= 10)
{
NegotiationManager.Instance.AddAction(new DamageAction(this.OWNER.coreArgument, this.OWNER, this.OWNER.coreArgument.curHP / 2, this.OWNER.coreArgument.curHP / 2, this));
NegotiationManager.Instance.AddAction(new DestroyArgumentAction(this));
}
}
public void OnFlushInternal(AbstractEvent e)
{
var added = DoWithEntities(entitiesToAdd, e.Session.Transaction, d => solr.Add(d, AddParameters));
var deleted = DoWithEntities(entitiesToDelete, e.Session.Transaction, d => solr.Delete(d));
if (Commit && (added || deleted))
{
solr.Commit();
}
}
protected void ApplyChange(AbstractEvent @event)
{
this.ApplyEvent(@event);
this.Version++;
@event.EventSourcedId = this.Id;
@event.EventSourcedVersion = this.Version;
@event.TimeStamp = DateTime.UtcNow;
@event.CorrelationId = this.CurrentCorrelationId;
this.changes.Enqueue(@event);
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventArgDestroyed data = (EventArgDestroyed)eventData;
if (data.argumentDestroyed.OWNER != this.OWNER)
{
this.OWNER.curAP += this.stacks;
NegotiationManager.Instance.AddAction(new DrawCardsAction(this.OWNER, this.stacks));
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventTurnEnd person = (EventTurnEnd)eventData;
if (person.end == this.OWNER)
{
NegotiationManager.Instance.AddAction(new DamageAction(null, TurnManager.Instance.GetOtherCharacter(this.OWNER), stacks, stacks, this));
NegotiationManager.Instance.AddAction(new AddStacksToArgumentAction(this, 1));
}
}
public override void NotifyOfEvent(AbstractEvent eventData)
{
EventArgDestroyed data = (EventArgDestroyed)eventData;
if (data.destroyingCard == this)
{
NegotiationManager.Instance.AddAction(new DrawCardsAction(this.OWNER, DRAW));
this.OWNER.curAP += this.ACTIONS;
}
return;
}
public static void Unhook(AbstractEvent abstractEvent) {
abstractEvent.MyEvent -= new SimpleDelegate(CallMe);
}
