/// <summary>
/// Used to add an effect to a character.
/// </summary>
/// <param name="callerId">The user identifier of the caller.</param>
/// <param name="effectName">The name of the effect to add to the character.</param>
public async Task <IResult> AddEffectAsync(ulong callerId, string effectName)
{
var character = await _charProvider.GetActiveCharacterAsync(callerId);
if (character == null)
{
return(CharacterResult.CharacterNotFound());
}
var effect = await _effectProvider.GetEffectAsync(effectName);
if (effect == null)
{
return(EffectResult.EffectNotFound());
}
if (character.Effects == null)
{
character.Effects = new List <Effect>();
}
if (character.Effects.Count(x => x.Id == effect.Id) > 0)
{
return(EffectResult.EffectAlreadyAdded());
}
character.Effects.Add(effect);
await _charProvider.UpdateCharacterAsync(character);
return(EffectResult.EffectAdded());
}
/// <summary>
/// Used to remove an effect from a character.
/// </summary>
/// <param name="callerId">The user identifier of the caller.</param>
/// <param name="effectName">The name of the effect to remove from the character.</param>
public async Task <IResult> RemoveEffectAsync(ulong callerId, string effectName)
{
var character = await _charProvider.GetActiveCharacterAsync(callerId);
if (character == null)
{
return(CharacterResult.CharacterNotFound());
}
var effect = await _effectProvider.GetEffectAsync(effectName);
if (effect == null)
{
return(EffectResult.EffectNotFound());
}
var match = character.Effects.FirstOrDefault(x => x.Id == effect.Id);
if (match == null)
{
return(EffectResult.EffectNotFound());
}
character.Effects.Remove(match);
await _charProvider.UpdateCharacterAsync(character);
return(EffectResult.EffectRemoved());
}
ResponseContext IAccessControlPrivacyService.ExecuteSecurityProcess(JObject user, JObject[] resource, string action, string collectionName, JObject environment)
{
_user = user;
_collectionName = collectionName;
_action = action;
_environment = environment;
environment.AddAnnotation(action);
EffectResult effect = AccessControlCollectionPolicyProcessing();
if (effect == EffectResult.Deny)
{
return(new ResponseContext(EffectResult.Deny, null));
}
var accessControlRecordPolicies = _accessControlPolicyRepository.GetPolicies(collectionName, action, true);
_policyCombining = accessControlRecordPolicies.Count > 0 ? _accessControlPolicyRepository.GetPolicyCombining(accessControlRecordPolicies)
: "permit-overrides";
_resource = new List <JObject>();
foreach (var record in resource)
{
if (AccessControlRecordPolicyProcessing(record, _policyCombining, accessControlRecordPolicies) != null)
{
_resource.Add(record);
}
}
if (_resource.Count == 0)
{
return(new ResponseContext(EffectResult.Deny, null));
}
if (!action.Equals("read"))
{
return(new ResponseContext(EffectResult.Permit, _resource));
}
_collectionPrivacyRules = GetFieldCollectionRules();
var privacyRecords = new JArray();
//Parallel.ForEach(_resource, record =>
//{
// var privacyField = GetPrivacyRecordField(record, policies);
// var privacyRecord = PrivacyProcessing(record, privacyField);
// Console.WriteLine(privacyRecord);
// privacyRecords.Add(privacyRecord);
//});
foreach (var record in _resource)
{
Console.WriteLine(DateTime.Now.Millisecond);
var privacyFields = GetPrivacyRecordField(record);
var privacyRecord = PrivacyProcessing(record, privacyFields);
Console.WriteLine(DateTime.Now.Millisecond);
privacyRecords.Add(privacyRecord);
}
return(new ResponseContext(EffectResult.Permit, privacyRecords));
}
/// <summary>
/// Sets the statistic effects of the specified effect.
/// </summary>
/// <param name="effectName">The name of the effect to set the value to.</param>
/// <param name="statName">The name of the statistic to associate the value with.</param>
/// <param name="value">The value to add (or subtract) to the statistic.</param>
/// <returns>
/// A result detailing if the operation was successful or why it failed.
/// </returns>
public async Task <IResult> SetStatisticEffectAsync(string effectName, string statName, int value)
{
var effect = await _effectProvider.GetEffectAsync(effectName);
if (effect == null)
{
return(EffectResult.EffectNotFound());
}
var stat = await _statProvider.GetStatisticAsync(statName);
if (stat == null)
{
return(StatisticResult.StatisticNotFound());
}
var match = effect.StatisticEffects.FirstOrDefault(x => x.Statistic.Equals(stat));
if (match == null)
{
effect.StatisticEffects.Add(new StatisticMapping(stat, new StatisticValue(value)));
}
else
{
match.StatisticValue.Value = value;
}
await _effectProvider.UpdateEffectAsync(effect);
return(EffectResult.EffectUpdatedSucessfully());
}
ResponseContext IAccessControlService.ExecuteProcess(JObject user, JObject[] resource, string action, string collectionName, JObject environment)
{
_user = user;
_collectionName = collectionName;
_action = action;
_environment = environment;
environment.AddAnnotation(action);
EffectResult effect = CollectionAccessControlProcess();
if (effect == EffectResult.Deny)
{
return(new ResponseContext(EffectResult.Deny, null));
}
else if (effect == EffectResult.Permit)
{
return(new ResponseContext(EffectResult.Permit, resource));
}
var accessControlRecordPolicies = _accessControlPolicyRepository.GetPolicies(collectionName, action, true);
if (accessControlRecordPolicies.Count == 0)
{
return(new ResponseContext(EffectResult.Deny, null));
}
string policyCombining = _accessControlPolicyRepository.GetPolicyCombining(accessControlRecordPolicies);
ICollection <JObject> _resource = new List <JObject>();
if (resource.Length > 1000)
{
Parallel.ForEach(resource, record =>
{
if (RowAccessControlProcess(record, policyCombining, accessControlRecordPolicies) != null)
{
lock (_resource)
_resource.Add(record);
}
});
}
else
{
foreach (var record in resource)
{
if (RowAccessControlProcess(record, policyCombining, accessControlRecordPolicies) != null)
{
_resource.Add(record);
}
}
}
if (_resource.Count == 0)
{
return(new ResponseContext(EffectResult.Deny, null));
}
return(new ResponseContext(EffectResult.Permit, _resource));
}
/// <summary>
/// 일시적인 효과(버프/디버프)를 적용하는 함수.
/// </summary>
/// <param name="effect"></param>
/// <returns></returns>
private IEnumerator TempEffect(EffectResult effect)
{
status.ChangeStat(effect.type, effect.amount);
yield return(new WaitForSeconds(effect.duration));
status.ChangeStat(effect.type, -effect.amount);
}
private EffectResult CollectionAccessControlProcess()
{
EffectResult result = EffectResult.NotApplicable;
ICollection <AccessControlPolicy> collectionPolicies = _accessControlPolicyRepository.GetPolicies(_collectionName, _action, false);
if (collectionPolicies.Count == 0)
{
return(EffectResult.NotApplicable);
}
string policyCombining = _accessControlPolicyRepository.GetPolicyCombining(collectionPolicies);
var targetPolicies = new List <AccessControlPolicy>();
foreach (var policy in collectionPolicies)
{
bool isTarget = _expressionService.Evaluate(policy.Target, _user, null, _environment);
if (isTarget)
{
targetPolicies.Add(policy);
}
}
foreach (var policy in targetPolicies)
{
string policyEffect = String.Empty;
foreach (var rule in policy.Rules)
{
bool isApplied = _expressionService.Evaluate(rule.Condition, _user, null, _environment);
if (isApplied && rule.Effect.Equals("Permit") && policy.RuleCombining.Equals("permit-overrides"))
{
policyEffect = "Permit";
break;
}
if (isApplied && rule.Effect.Equals("Deny") && policy.RuleCombining.Equals("deny-overrides"))
{
policyEffect = "Deny";
break;
}
}
if (policyEffect.Equals("Permit") && policyCombining.Equals("permit-overrides"))
{
result = EffectResult.Permit;
break;
}
else if (policyEffect.Equals("Deny") && policyCombining.Equals("deny-overrides"))
{
result = EffectResult.Deny;
break;
}
}
return(result);
}
public override EffectResult OnStart(L2Character caster, L2Character target)
{
target.CharacterStat.Apply(this);
EffectResult ter = new EffectResult
{
TotalUi = 1
};
return(ter);
}
public async Task CreateEffectAsync_ValidInput_ReturnSuccess()
{
var charProvider = new MockCharacterProvider();
var effectProvider = new MockEffectProvider();
var statProvider = new MockStatisticProvider();
var controller = new EffectController(charProvider, effectProvider, statProvider, new GeneralOptions());
var result = await controller.CreateEffectAsync(1, "ValidInput");
Assert.Equal(EffectResult.EffectCreatedSuccessfully(), result);
}
/// <summary>
/// Deletes a Effect in the database.
/// </summary>
/// <param name="statName">The name for the new skill.</param>
/// A result detailing if the operation was successful or why it failed.
/// </returns>
public async Task <IResult> DeleteEffectAsync(string statName)
{
var Effect = await _effectProvider.GetEffectAsync(statName);
if (Effect == null)
{
return(EffectResult.EffectNotFound());
}
await _effectProvider.DeleteEffectAsync(Effect);
return(EffectResult.EffectDeletedSuccessfully());
}
public async Task SetStatisticEffectAsync_InvalidEffectName_ReturnEffectNotFound()
{
// Arrange
var charProvider = new MockCharacterProvider();
var effectProvider = new MockEffectProvider();
var statProvider = new MockStatisticProvider();
var controller = new EffectController(charProvider, effectProvider, statProvider, null);
var result = await controller.SetStatisticEffectAsync("DoesNotExist", "Strength", 1);
Assert.Equal(EffectResult.EffectNotFound(), result);
}
public async Task CreateEffectAsync_AlreadyExists_ReturnNameAlreadyExists()
{
var charProvider = new MockCharacterProvider();
var effectProvider = new MockEffectProvider();
var statProvider = new MockStatisticProvider();
var controller = new EffectController(charProvider, effectProvider, statProvider, new GeneralOptions());
await controller.CreateEffectAsync(1, "AlreadyExists");
var result = await controller.CreateEffectAsync(1, "AlreadyExists");
Assert.Equal(EffectResult.NameAlreadyExists(), result);
}
public async Task <EffectResult> ReceiveEffect(EffectInfo effectInfo)
{
EffectResult effectResult = null;
await QueueActionAndAwait(() =>
{
effectResult = effectInfo.Effect.ExecuteEffect(effectInfo.SkillInfo);
});
await AnimateEffectResult(effectResult);
return(effectResult);
}
public override EffectResult OnStart(L2Character caster, L2Character target)
{
if (!(target is L2Player))
{
return(Nothing);
}
((L2Player)target).SpecEffects.Add(_ef);
EffectResult ter = new EffectResult();
ter.AddSu(StatusUpdate.Evasion, target.CharacterStat.GetStat(EffectType.BEvasion));
return(Nothing);
}
public async Task DeleteEffect_InvalidEffectName_ReturnNotFound()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var effectProvider = new MockEffectProvider();
var controller = new EffectController(charProvider, effectProvider, statProvider, new GeneralOptions());
// Act
var result = await controller.DeleteEffectAsync("DoesNotExist");
// Assert
Assert.Equal(result, EffectResult.EffectNotFound());
}
/// <summary>
/// Sets an effect's description.
/// </summary>
/// <param name="effectName">The name of the effect to set the description to.</param>
/// <param name="desc">The new description of the effect.</param>
/// <returns>A result detailing if the operation was successful or why it failed.</returns>
public async Task <IResult> SetDescriptionAsync(string effectName, string desc)
{
var stat = await _effectProvider.GetEffectAsync(effectName);
if (stat == null)
{
return(EffectResult.EffectNotFound());
}
stat.Description = desc;
await _effectProvider.UpdateEffectAsync(stat);
return(EffectResult.EffectUpdatedSucessfully());
}
public async Task SetStatisticEffectAsync_ValidInput_ReturnSuccess()
{
// Arrange
var charProvider = new MockCharacterProvider();
var effectProvider = new MockEffectProvider();
var statProvider = new MockStatisticProvider();
var controller = new EffectController(charProvider, effectProvider, statProvider, null);
await effectProvider.CreateEffectAsync(1, "ValidInput");
var result = await controller.SetStatisticEffectAsync("ValidInput", "Strength", 1);
Assert.Equal(EffectResult.EffectUpdatedSucessfully(), result);
}
/// <summary>
/// Gets the caller's active character and returns its active effects.
/// </summary>
/// <param name="callerId">Discord ID of the caller.</param>
/// <returns>A new EffectResult object.</returns>
public async Task <IResult> ShowCharacterEffectsAsync(ulong callerId)
{
var character = await _charProvider.GetActiveCharacterAsync(callerId);
if (character == null)
{
return(CharacterResult.CharacterNotFound());
}
if (character.Effects == null || character.Effects.Count <= 0)
{
return(EffectResult.NoEffects());
}
return(EffectResult.ShowCharacterEffects(character));
}
public async Task DeleteEffect_ValidInput_ReturnSuccess()
{
// Arrange
var charProvider = new MockCharacterProvider();
var statProvider = new MockStatisticProvider();
var effectProvider = new MockEffectProvider();
var controller = new EffectController(charProvider, effectProvider, statProvider, new GeneralOptions());
// Act
await effectProvider.CreateEffectAsync(1, "ValidInput");
var result = await controller.DeleteEffectAsync("ValidInput");
// Assert
Assert.Equal(result, EffectResult.EffectDeletedSuccessfully());
}
public void SpawnText(EffectResult result, Vector3 worldPosition)
{
TextType textType = TextType.Damage;
switch (result.effect)
{
case TalentEffect.Damage:
case TalentEffect.DamageStamina:
case TalentEffect.ApplyCondition:
textType = TextType.Damage;
break;
case TalentEffect.Heal:
case TalentEffect.RestoreStamina:
textType = TextType.Healing;
break;
}
SpawnText(result.ToString(), textType, worldPosition);
}
/// <summary>
/// Renames an already existing Effect.
/// </summary>
/// <param name="effectName">The name of the Effect to rename.</param>
/// <param name="newName">The new name of the Effect.</param>
/// <returns>A result detailing if the operation was successful or why it failed.</returns>
/// <remarks>This method will also clear its aliases.</remarks>
public async Task <IResult> RenameEffectAsync(string effectName, string newName)
{
var stat = await _effectProvider.GetEffectAsync(effectName);
if (stat == null)
{
return(EffectResult.EffectNotFound());
}
if (await _effectProvider.GetEffectAsync(newName) != null)
{
return(EffectResult.NameAlreadyExists());
}
stat.Name = newName;
await _effectProvider.UpdateEffectAsync(stat);
return(EffectResult.EffectUpdatedSucessfully());
}
/*
* Metodo encargado de gestionar los efectos secundarios de los ataques, como bajadas de stats o estados alterados
*/
IEnumerator RunMoveEffects(MoveEffects effects, Pokemon source, Pokemon target, MoveTarget moveTarget)
{
//Boosts
if (effects.Boosts != null) //de momento solo contemplamos los ataques de estado que implican boosts
{
if (moveTarget == MoveTarget.Self)
{
source.ApplyBoosts(effects.Boosts);
}
else if (moveTarget == MoveTarget.Foe)
{
target.ApplyBoosts(effects.Boosts);
}
}
//Status conditions
if (effects.Status != ConditionID.none)
{
//TODO: Estamos suponiendo que el target del status es el enemigo y no uno mismo
EffectResult result = target.SetStatus(effects.Status);
if (result == EffectResult.AlreadyOne)
{
yield return(dialogBox.TypeDialog($"{source.CurrentMove.Base.Name} had no effect!"));
}
else if (result == EffectResult.Inmune)
{
yield return(dialogBox.TypeDialog($"{target.Base.Name} it's inmune!"));
}
}
//Volatile Status conditions
if (effects.VolatileStatus != ConditionID.none)
{
//TODO: Estamos suponiendo que el target del status es el enemigo y no uno mismo
target.SetVolatileStatus(effects.VolatileStatus);
}
//Mostramos en el dialogo las bajadas y subidas de stats de ambos pokemons
yield return(ShowStatusChanges(source));
yield return(ShowStatusChanges(target));
}
public EffectResult Apply(List <Effect> effects, L2Character caster)
{
EffectResult result = new EffectResult();
foreach (EffectResult ter in effects.Select(effect => effect.OnStart(caster, _owner)))
{
if (result.TotalUi == 0)
{
result.TotalUi = ter.TotalUi;
}
if (ter.Sus != null)
{
result.AddAll(ter.Sus);
}
}
return(result);
}
/// <summary>
/// Creates a new Effect in the database.
/// </summary>
/// <param name="effectName">The name for the new effect.</param>
/// <returns>
/// A result detailing if the operation was successful or why it failed.
/// </returns>
public async Task <IResult> CreateEffectAsync(ulong callerId, string effectName)
{
if (await _effectProvider.GetEffectAsync(effectName) != null)
{
return(EffectResult.NameAlreadyExists());
}
if ((await _effectProvider.GetUserEffectsAsync(callerId)).Count() >= _options.EffectsLimit)
{
return(EffectResult.TooManyEffects());
}
var result = await _effectProvider.CreateEffectAsync(callerId, effectName);
if (result == null)
{
return(EffectResult.EffectCreationFailed());
}
return(EffectResult.EffectCreatedSuccessfully());
}
AdventureStatus ProcessEffectResult(EffectResult result, IBattleEntity attacker, IBattleEntity target, RPGMessageBuilder message)
{
if (result == null)
{
return(AdventureStatus.MonsterBattle);
}
switch (result.Type)
{
case EffectResultType.DamageSelf:
attacker.Hit((int)result.Argument);
return(CheckStatus(attacker, target, message));
case EffectResultType.NewEffectTarget:
(target as MonsterBattleEntity)?.AddEffect((ITemporaryEffect)result.Argument);
return(AdventureStatus.MonsterBattle);
default:
return(AdventureStatus.MonsterBattle);
}
}
public void Update()
{
Tick++;
EffectResult effectResult = UpdateEffects();
foreach (GameEffect toRemove in _effectsToRemove)
{
_effects.Remove(toRemove);
}
_effectsToRemove.Clear();
if (!effectResult.Locked)
{
_gameResult = _creatureManager.UpdateCreatures(GameWorld.GetCreatures(Hero.Depth));
foreach (GameEvent gameEvent in _gameResult.Events)
{
_effects.Add(gameEvent.Effect);
}
}
}
private EffectResult UpdateEffects()
{
EffectResult effectResult = new EffectResult();
foreach (GameEffect effect in _effects)
{
if (effect.Gain())
{
effectResult.CanRender = true;
bool running = effect.Update(Hero.CurrentLevel);
if (!running)
{
_effectsToRemove.Add(effect);
}
}
if (effect.LockActors)
{
effectResult.Locked = true;
}
}
return(effectResult);
}
public ResponseContext(EffectResult effect, JArray data, string message = null)
{
Effect = effect;
Data = data;
Message = message;
}
public Ability(EffectResult effect)
{
this.Effect = effect;
}
public ApplyFeatEffect(Battler battler, EffectResult result)
{
_battler = battler;
_result = result;
}
public ResponseContext(EffectResult effect, ICollection <JObject> data)
{
Effect = effect;
JsonObjects = data;
}
