/// <summary>
/// Sends conversion event to Optimizely.
/// </summary>
/// <param name="eventKey">Event key representing the event which needs to be recorded</param>
/// <param name="userId">ID for user</param>
/// <param name="userAttributes">Attributes of the user</param>
/// <param name="eventTags">eventTags array Hash representing metadata associated with the event.</param>
public void Track(string eventKey, string userId, UserAttributes userAttributes = null, EventTags eventTags = null)
{
if (!IsValid)
{
Logger.Log(LogLevel.ERROR, "Datafile has invalid format. Failing 'track'.");
return;
}
var inputValues = new Dictionary <string, string>
{
{ USER_ID, userId },
{ EVENT_KEY, eventKey }
};
if (!ValidateStringInputs(inputValues))
{
return;
}
var eevent = Config.GetEvent(eventKey);
if (eevent.Key == null)
{
Logger.Log(LogLevel.INFO, string.Format("Not tracking user {0} for event {1}.", userId, eventKey));
return;
}
if (eventTags != null)
{
eventTags = eventTags.FilterNullValues(Logger);
}
var conversionEvent = EventBuilder.CreateConversionEvent(Config, eventKey,
userId, userAttributes, eventTags);
Logger.Log(LogLevel.INFO, string.Format("Tracking event {0} for user {1}.", eventKey, userId));
Logger.Log(LogLevel.DEBUG, string.Format("Dispatching conversion event to URL {0} with params {1}.",
conversionEvent.Url, conversionEvent.GetParamsAsJson()));
try
{
EventDispatcher.DispatchEvent(conversionEvent);
}
catch (Exception exception)
{
Logger.Log(LogLevel.ERROR, string.Format("Unable to dispatch conversion event. Error {0}", exception.Message));
}
NotificationCenter.SendNotifications(NotificationCenter.NotificationType.Track, eventKey, userId,
userAttributes, eventTags, conversionEvent);
}
private void OnPlayeDamageTake(GeneralEvent e)
{
DamageResult result = e.data as DamageResult;
if (result != null)
{
_hudController.OnPlayerHealthChange(result.newHealth);
if (_playerCombatController.isDead)
{
_dispatcher.DispatchEvent(GameplayEventType.GAME_COMPLETE, false, false);
}
}
}
/// <inheritdoc />
public async Task <MetadataDefinitionDto> HandleResult(AddValidatorCommand command, CancellationToken token)
{
var definition = _dynamicMetadataDefinitionService.GetById(command.DefinitionId);
if (definition == null)
{
throw new NotFoundException();
}
var validatorConfiguration = _mapper.Map <ValidatorConfiguration>(command.ValidatorData);
validatorConfiguration.ValidatorId = Guid.NewGuid().ToString();
bool result = _validationFactory.CreateValidatorFor(validatorConfiguration, definition);
if (!result)
{
throw new BadRequestException("Validator has invalid configuration");
}
definition.Validators.Add(validatorConfiguration);
_dynamicMetadataDefinitionWriteService.UpdateItem(definition, token);
await _eventDispatcher.DispatchEvent(new RefreshValidationEvent
{
DefinitionId = definition.Id
});
return(_mapper.Map <MetadataDefinitionDto>(definition));
}
async Task IConfigurationStorage.SaveChanges(
Models.Client.ConfigurationSettings configurationSettings)
{
await _configurationStorage.SaveChanges(configurationSettings).ConfigureAwait(false);
_eventDispatcher.DispatchEvent(new ViewEvents.ConfigurationSettingsSaved());
}
/// <inheritdoc />
public async Task <MetadataDefinitionDto> HandleResult(RemoveValidatorCommand command, CancellationToken token)
{
var definition = _dynamicMetadataDefinitionService.GetById(command.DefinitionId);
if (definition == null)
{
throw new NotFoundException();
}
var validator = definition.Validators.FirstOrDefault(x => x.ValidatorId == command.ValidatorId);
if (validator == null)
{
throw new NotFoundException();
}
definition.Validators.Remove(validator);
_dynamicMetadataDefinitionWriteService.UpdateItem(definition, token);
await _eventDispatcher.DispatchEvent(new RefreshValidationEvent
{
DefinitionId = definition.Id
});
return(_mapper.Map <MetadataDefinitionDto>(definition));
}
/// <inheritdoc />
public async Task <MetadataDefinitionDto> HandleResult(UpdateValidatorConfigurationCommand command, CancellationToken token)
{
var definition = _dynamicMetadataDefinitionService.GetById(command.DefinitionId);
if (definition == null)
{
throw new NotFoundException();
}
var validator = definition.Validators.FirstOrDefault(x => x.ValidatorId == command.ValidatorId);
if (validator == null)
{
throw new NotFoundException();
}
validator.Parameters = command.ValidatorConfiguration.Parameters;
bool result = _validationFactory.CreateValidatorFor(validator, definition);
if (!result)
{
throw new BadRequestException("Validator has invalid configuration");
}
_dynamicMetadataDefinitionWriteService.UpdateItem(definition, token);
await _eventDispatcher.DispatchEvent(new RefreshValidationEvent
{
DefinitionId = definition.Id
});
return(_mapper.Map <MetadataDefinitionDto>(definition));
}
/// <summary>
/// Dispatches the module event.
/// </summary>
/// <param name="evt">The event object.</param>
public void DispatchModuleEvent(Event evt)
{
if (m_moduleEventDispatcher != null)
{
m_moduleEventDispatcher.DispatchEvent(evt);
}
}
/// <summary>
/// Dispatches the global event.
/// </summary>
/// <param name="evt">The event object.</param>
public void Dispatch(Event evt)
{
if (m_contextEventDispatcher != null)
{
m_contextEventDispatcher.DispatchEvent(evt);
}
}
async Task ICardDatabaseManager.UpdateCardDatabase(
int version,
Stream updateStream)
{
await _cardDatabaseManager.UpdateCardDatabase(version, updateStream).ConfigureAwait(false);
_eventDispatcher.DispatchEvent(new ViewEvents.CardDatabaseUpdated());
}
public void OnClick()
{
var @event = new StyleChangedEvent {
Style = _style
};
_eventDispatcher.DispatchEvent(@event);
}
private void onLootPickedUp(GhostGen.GeneralEvent e)
{
LootConfig.LootItemDef itemDef = e.data as LootConfig.LootItemDef;
if (itemDef != null)
{
AddItem(itemDef.type, itemDef.GetQuantitiy());
_dispatcher.DispatchEvent(GameplayEventType.INVENTORY_UPDATED, false, itemDef.type);
}
}
IEnumerator Start()
{
yield return(new WaitForSeconds(2f));
Debug.Log("Dispatch event");
_eventManager.DispatchEvent(new MyEvent {
_index = 2
});
}
public DamageResult TakeDamage(object attacker, float damage)
{
DamageResult result = new DamageResult();
result.prevHealth = health;
health = Mathf.Max(health - damage, 0.0f);
result.newHealth = health;
result.victim = this;
result.attacker = attacker;
if (isDead && result.prevHealth > 0.0f)
{
Singleton.instance.particleGod.GenerateParticle(Particle.Type.EnemyDeath, _view.transform.position);
Singleton.instance.audioSystem.PlaySound(SoundBank.Type.MonsterDeath, null, true);
_view.Die();
_dispatcher.DispatchEvent(GameplayEventType.ENEMY_KILLED, false, this);
}
return(result);
}
public void OnClick()
{
var @event = new StyleChangedEvent {
Style = _style
};
//here event is being fired to context and than to all of it's dependencies
//and gameobjects that contains Injector
_eventDispatcher.DispatchEvent(@event);
}
//this handler will actually fire off multiple events instead of just creating the payment, we should ideally refactor this with a payment service
// and split the functionality up as the process gets more complicated.
public async Task <Response <Guid> > Handle(CreatePaymentCommand request, CancellationToken cancellationToken)
{
var paymentExists = await IsPaymentDuplicate(request.Id);
if (paymentExists)
{
return(Response.Failure <Guid>($"Error, a payment with id {request.Id} already exists"));
}
// dont need to create the payment and process the events. we can get a payment by processing the events on the fly
// see GetPaymentHandler for details. For now just dispatch the necessary events.
var createPaymentEvent = new CreatePaymentEvent(DateTime.UtcNow, request.Id, request.CardNumber, request.Currency, request.Amount);
await _eventDispatcher.DispatchEvent(createPaymentEvent);
await _eventDispatcher.DispatchEvent(new PaymentSentToAcquiringBankEvent(DateTime.UtcNow, request.Id));
//TODO: Extract this to a config file property in appsettings.json
var baseUrl = "http://localhost:4000";
var response = await _acquiringBankHttpClient.Post <Guid>($"{baseUrl}/api/AcquiringBank", new
{
request.CardNumber,
request.MonthExpired,
request.YearExpired,
request.Ccv,
request.Amount,
request.Currency
});
if (!response.Error)
{
await _eventDispatcher.DispatchEvent(new PaymentSucceededEvent(DateTime.UtcNow, request.Id, response.Data));
return(Response.Success <Guid>(response.Data, response.Message));
}
else
{
await _eventDispatcher.DispatchEvent(new PaymentFailedEvent(DateTime.UtcNow, request.Id, response.Message));
return(Response.Failure(response.Message, response.Data));
}
}
private IEnumerable <ChunkColumn> GenerateChunks(ChunkCoordinates center, int renderDistance)
{
var oldChunks = _loadedChunks.ToArray();
double radiusSquared = Math.Pow(renderDistance, 2);
List <ChunkCoordinates> newChunkCoordinates = new List <ChunkCoordinates>();
List <ChunkCoordinates> results = new List <ChunkCoordinates>();
for (int y = center.Z - renderDistance; y <= center.Z + renderDistance; y++)
{
for (int x = center.X - renderDistance; x <= center.X + renderDistance; x++)
{
var cc = new ChunkCoordinates(x, y);
newChunkCoordinates.Add(cc);
if (!_loadedChunks.Contains(cc))
{
ChunkColumn chunk =
_generator.GenerateChunkColumn(cc);
if (chunk == null)
{
continue;
}
_loadedChunks.Add(cc);
yield return(chunk);
}
}
}
foreach (var chunk in oldChunks)
{
if (!newChunkCoordinates.Contains(chunk) && chunk != center)
{
//UnloadChunk(chunk.X, chunk.Z);
ChunkUnloadEvent unloadEvent = new ChunkUnloadEvent(chunk);
EventDispatcher.DispatchEvent(unloadEvent);
if (!unloadEvent.IsCancelled)
{
_loadedChunks.Remove(chunk);
}
}
}
}
public void Process(UserEvent userEvent)
{
var logEvent = EventFactory.CreateLogEvent(userEvent, Logger);
try
{
EventDispatcher.DispatchEvent(logEvent);
NotificationCenter?.SendNotifications(NotificationCenter.NotificationType.LogEvent, logEvent);
}
catch (Exception ex)
{
Logger.Log(LogLevel.ERROR, $"Error dispatching event: {logEvent.GetParamsAsJson()}. {ex.Message}");
ErrorHandler.HandleError(ex);
}
}
/// <inheritdoc />
public async Task <MetadataDefinitionDto> HandleResult(ChangePropertyTypeAndDefaultValueCommand command, CancellationToken token)
{
var definition = _dynamicMetadataDefinitonService.GetById(command.DefinitionId);
if (definition == null)
{
throw new NotFoundException();
}
var existingProperty = definition.Properties.SingleOrDefault(x => x.Id == command.PropertyKey);
if (existingProperty == null)
{
throw new BadRequestException("Property doesn't already exist");
}
DynamicMetadataProperty property;
try
{
property = _inputDataParser.DeserializeItem(command.PropertyKey, command.UpdatedObject.Type, command.UpdatedObject.DefaultValue);
}
catch (JsonException exception)
{
throw new AggregatedValidationException("Invalid type mismatch")
{
ErrorCode = 11231,
ValidationErrors = new List <Error>()
};
}
// parsing property
definition.Properties.Remove(existingProperty);
definition.Properties.Add(property);
_dynamicMetadataDefinitionWriteService.UpdateItem(definition, token);
await _eventDispatcher.DispatchEvent(new PropertyDefinitionUpdatedEvent
{
UpdatedPropertyKey = property.Id,
DefinitionId = command.DefinitionId
});
return(_mapper.Map <MetadataDefinitionDto>(definition));
}
public void ClosePopUp(IPopupMediator popupMediator)
{
if (_popups.Contains(popupMediator))
{
_popups.Remove(popupMediator);
}
try{
//TODO: remove! Fallback because of old modal and other popups, remove after cleaning all old shiath
var type = popupMediator.GetType();
popupMediator.Destroy();
EventDispatcher.DispatchEvent(new PopupClosedEvent(type));
}
catch (Exception e)
{
Debug.LogWarningFormat("<color=\"red\">{0} : {1}</color>", this, e);
}
}
private void Start()
{
var dependency = new CommandDependency();
var evt = new Event();
var context = Context.Create()
.RegisterDependency(dependency)
.RegisterCommand <Event, Command>();
IEventDispatcher dispatcher = (IEventDispatcher)context.Resolve(typeof(IEventDispatcher));
dispatcher.DispatchEvent(evt);
Assert.True(dependency.Executed, "command executed");
Assert.NotNull(dependency.WithEvent, "command event setter");
context.Destroy();
}
public void FireWeapon(Vector3 targetPos)
{
if (_fireTimer > 0 || !isEnabled || isDead)
{
return;
}
Vector3 visualWeaponPos = _view.weaponBarrelPosition;
Vector3 viewDir = getFireDirection(_view._rotateTransform.forward, 0.08f);//(targetPos - visualWeaponPos).normalized;
viewDir.y = 0;
Vector3 adjustedPos = visualWeaponPos + (viewDir * 50.0f);
Vector3 rayPoint = _view.viewPosition;
rayPoint.y = visualWeaponPos.y;
Ray ray = new Ray(visualWeaponPos, viewDir);
Singleton.instance.audioSystem.PlaySound(SoundBank.Type.WeaponFire, null, true);
IDamageable target;
RaycastHit hit;
bool targetFound = getTarget(ray, out hit, out target);
if (targetFound)
{
Vector3 force = viewDir * 110.0f;
DamageResult dResult = target.TakeDamage(this, _config.weapon.damage);
_dispatcher.DispatchEvent(GameplayEventType.DAMAGE_TAKEN, false, dResult);
if (target.physbody)
{
target.physbody.AddForceAtPosition(force, hit.point, ForceMode.Impulse);
}
adjustedPos = hit.point;
}
Debug.DrawRay(adjustedPos, Vector3.up, Color.red);
_view.VisualFireWeapon(_config.weapon.bulletSpeed, adjustedPos);
_fireTimer = _config.weapon.fireCooldown;
}
private void RedispatchKeyEvent(IEventDispatcher targetComponent, ICloneable systemManagerKeyEvent)
{
_keyEvent = (KeyboardEvent)systemManagerKeyEvent.Clone();
_keyEvent.Target = targetComponent;
/**
* 1) Dispatch from here
* */
DispatchEvent(_keyEvent);
// the event might be canceled
if (_keyEvent.Canceled)
{
return;
}
/**
* 2) Dispatch from the component
* */
targetComponent.DispatchEvent(_keyEvent);
}
void IPlayerDeckTrackerInterface.TrackDeck(
Models.Client.Decklist decklist)
{
Reset();
IEventDispatcher eventDispatcher = _eventDispatcherFactory.Create();
_viewModel =
new PlayerDeckTrackerViewModel(
_cardInfoProvider,
_configurationSource,
eventDispatcher,
_viewEventDispatcher,
decklist);
_cancellation = new CancellationTokenSource();
Task.Run(
async() =>
{
using (IEventStream eventStream = _eventStreamFactory.Create())
{
while (true)
{
object @event = await eventStream.ReadNext(_cancellation.Token);
if (@event == null)
{
return;
}
eventDispatcher.DispatchEvent(@event);
}
}
});
_view = new PlayerDeckTrackerView(_viewModel);
_view.Show();
}
/// <inheritdoc />
public async Task <MetadataDefinitionDto> HandleResult(RemoveMovieMetadataCommand command, CancellationToken token)
{
var definition = _dynamicMetadataDefinitonService.GetById(command.MetadataDefinitionId);
if (definition == null)
{
throw new NotFoundException();
}
var existingProperty = definition.Properties.SingleOrDefault(x => x.Id == command.MetadataKey);
if (existingProperty == null)
{
throw new NotFoundException();
}
var validator = _validationFactory.GetValidator(definition);
if (validator.WillUseProperty(existingProperty.Id))
{
throw new BadRequestException("Property is used by validator")
{
ErrorCode = 11,
};
}
definition.Properties.Remove(existingProperty);
_dynamicMetadataDefinitionWriteService.UpdateItem(definition, token);
await _eventDispatcher.DispatchEvent(new PropertyRemovedFromMetadataDefinitionEvent
{
RemovedPropertyKey = command.MetadataKey,
DefinitionId = command.MetadataDefinitionId
});
return(_mapper.Map <MetadataDefinitionDto>(definition));
}
protected void DispatchEvent <TEvent>(TEvent e) where TEvent : AbstractEvent
{
EventDispatcher.DispatchEvent(e);
}
public void ReceiveEvent(Event @event)
{
dispatcher.DispatchEvent(@event);
}
/// <summary>
/// As Commands should not listen to events but just dispatch them,
/// this only way how they need to interact with dispatcher
/// </summary>
/// <param name="e"></param>
protected void DispatchEvent <T>(T e) where T : AbstractEvent
{
_eventDispatcher.DispatchEvent(e);
}
private void RedispatchKeyEvent(IEventDispatcher targetComponent, ICloneable systemManagerKeyEvent)
{
_keyEvent = (KeyboardEvent)systemManagerKeyEvent.Clone();
_keyEvent.Target = targetComponent;
/**
* 1) Dispatch from here
* */
DispatchEvent(_keyEvent);
// the event might be canceled
if (_keyEvent.Canceled)
return;
/**
* 2) Dispatch from the component
* */
targetComponent.DispatchEvent(_keyEvent);
}
public void ApplyEvent(IEvent evt)
{
_eventDispatcher.DispatchEvent(this, evt);
Version++;
}
private void MenuItemClickedHandler(ListItemClickedEvent e)
{
var item = _menuPanelList.GetDataproviderAt(e.ItemIndex);
_eventDispatcher.DispatchEvent(new MenuItemSelectedEvent(item.ItemIdId));
}
/**
* @language zh_CN
* 更新骨架和动画。
* @param passedTime 两帧之间的时间间隔。 (以秒为单位)
* @see DragonBones.IAnimateble
* @see DragonBones.WorldClock
* @version DragonBones 3.0
*/
public void AdvanceTime(float passedTime)
{
if (_armatureData == null)
{
DragonBones.Assert(false, "The armature has been disposed.");
return;
}
else if (_armatureData.parent == null)
{
DragonBones.Assert(false, "The armature data has been disposed.");
return;
}
// Bones and slots.
if (_bonesDirty)
{
_bonesDirty = false;
_sortBones();
}
if (_slotsDirty)
{
_slotsDirty = false;
_sortSlots();
}
var prevCacheFrameIndex = _animation._cacheFrameIndex;
// Update animations.
_animation._advanceTime(passedTime);
var currentCacheFrameIndex = _animation._cacheFrameIndex;
int i = 0, l = 0;
if (currentCacheFrameIndex < 0 || currentCacheFrameIndex != prevCacheFrameIndex)
{
// Update bones.
for (i = 0, l = _bones.Count; i < l; ++i)
{
var bone = _bones[i];
bone._update(currentCacheFrameIndex);
}
// Update slots.
for (i = 0, l = _slots.Count; i < l; ++i)
{
_slots[i]._update(currentCacheFrameIndex);
}
}
//
if (!_lockDispose)
{
_lockDispose = true;
// Events. (Dispatch event before action.)
l = _events.Count;
if (l > 0)
{
for (i = 0; i < l; ++i)
{
var eventObject = _events[i];
_proxy.DispatchEvent(eventObject.type, eventObject);
if (eventObject.type == EventObject.SOUND_EVENT)
{
_eventManager.DispatchEvent(eventObject.type, eventObject);
}
eventObject.ReturnToPool();
}
_events.Clear();
}
// Actions.
l = _actions.Count;
if (l > 0)
{
for (i = 0; i < l; ++i)
{
var action = _actions[i];
if (action.slot != null)
{
var slot = GetSlot(action.slot.name);
if (slot != null)
{
var childArmature = slot.childArmature;
if (childArmature != null)
{
childArmature._doAction(action);
}
}
}
else if (action.bone != null)
{
for (int iA = 0, lA = _slots.Count; iA < lA; ++iA)
{
var childArmature = _slots[iA].childArmature;
if (childArmature != null)
{
childArmature._doAction(action);
}
}
}
else
{
_doAction(action);
}
}
_actions.Clear();
}
_lockDispose = false;
}
if (_delayDispose)
{
ReturnToPool();
}
}