/// <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); }