public Task ExecuteActionAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
switch (action.Type)
{
case "addEv":
return(_addEvExecutor.ExecuteAsync(action, context, notificationSession));
case "addEa":
return(_addEaExecutor.ExecuteAsync(action, context, notificationSession));
case "addItem":
return(_addItemExecutor.ExecuteAsync(action, context, notificationSession));
case "removeItem":
return(_removeItemExecutor.ExecuteAsync(action, context, notificationSession));
case "addEffect":
return(_addEffectExecutor.ExecuteAsync(action, context, notificationSession));
case "addCustomModifier":
return(_addCustomModifierExecutor.ExecuteAsync(action, context, notificationSession));
default:
return(Task.CompletedTask);
}
}
public void StartCombat(Group group, INotificationSession notificationSession)
{
var groupData = _jsonUtil.Deserialize <GroupData>(group.Data) ?? new GroupData();
if (groupData.InCombat == true)
{
throw new GroupAlreadyInCombatException();
}
groupData.InCombat = true;
group.Loots ??= new List <Loot>();
var loot = new Loot
{
Name = "Combat",
GroupId = group.Id
};
group.CombatLoot = loot;
group.AddHistoryEntry(_groupHistoryUtil.CreateLogStartCombat(group));
notificationSession.NotifyGroupChangeGroupData(group.Id, groupData);
group.Data = _jsonUtil.Serialize(groupData);
}
public Task ExecuteAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
if (action.Type != ActionType)
{
throw new InvalidActionTypeException(action.Type, ActionType);
}
if (action.Data == null)
{
throw new InvalidActionDataException(action.Type);
}
if (!action.Data.Ev.HasValue)
{
throw new InvalidActionDataException(action.Type);
}
var oldEv = context.TargetCharacter.Ev ?? 0;
var newEv = oldEv + action.Data.Ev.Value;
context.TargetCharacter.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeEv(context.TargetCharacter, oldEv, newEv));
context.TargetCharacter.Ev = newEv;
notificationSession.NotifyCharacterChangeEv(context.TargetCharacter);
return(Task.CompletedTask);
}
public Task ExecuteAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
if (action.Type != ActionType)
{
throw new InvalidActionTypeException(action.Type, ActionType);
}
if (action.Data == null)
{
throw new InvalidActionDataException(action.Type);
}
if (!action.Data.Ea.HasValue)
{
throw new InvalidActionDataException(action.Type);
}
if (!context.TargetCharacter.Ea.HasValue) // DO not touch ea of character that does no have any
{
return(Task.CompletedTask);
}
var oldEa = context.TargetCharacter.Ea;
var newEa = oldEa + action.Data.Ea.Value;
context.TargetCharacter.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeEa(context.TargetCharacter, oldEa, newEa));
context.TargetCharacter.Ea = newEa;
notificationSession.NotifyCharacterChangeEa(context.TargetCharacter);
return(Task.CompletedTask);
}
public void SetUp()
{
_jsonUtil = Substitute.For <IJsonUtil>();
_groupHistoryUtil = Substitute.For <IGroupHistoryUtil>();
_util = new GroupUtil(
_jsonUtil,
_groupHistoryUtil
);
_notificationSession = Substitute.For <INotificationSession>();
}
public Task ExecuteAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
if (action.Type != ActionType)
{
throw new InvalidActionTypeException(action.Type, ActionType);
}
if (action.Data?.Modifier == null)
{
throw new InvalidActionDataException(action.Type);
}
var modifier = action.Data.Modifier;
var characterModifier = new CharacterModifier
{
Name = modifier.Name,
Permanent = false,
DurationType = modifier.DurationType,
Duration = modifier.Duration,
Type = modifier.Type,
Description = modifier.Description,
Reusable = modifier.Reusable,
IsActive = true,
CombatCount = modifier.CombatCount,
CurrentCombatCount = modifier.CombatCount,
TimeDuration = modifier.TimeDuration,
CurrentTimeDuration = modifier.TimeDuration,
LapCount = modifier.LapCount,
CurrentLapCount = modifier.LapCount,
Values = modifier.Values.Select(v => new CharacterModifierValue
{
Type = v.Type,
StatName = v.Stat,
Value = v.Value
}).ToList()
};
if (context.TargetCharacter.Modifiers == null)
{
context.TargetCharacter.Modifiers = new List <CharacterModifier>();
}
context.TargetCharacter.Modifiers.Add(characterModifier);
context.TargetCharacter.AddHistoryEntry(_characterHistoryUtil.CreateLogAddModifier(context.TargetCharacter, characterModifier));
notificationSession.NotifyCharacterAddModifier(context.TargetCharacter.Id, characterModifier, true);
return(Task.CompletedTask);
}
public void EndCombat(Group group, INotificationSession notificationSession)
{
var groupData = _jsonUtil.Deserialize <GroupData>(group.Data) ?? new GroupData();
if (groupData.InCombat != true)
{
throw new GroupNotInCombatException();
}
groupData.InCombat = false;
group.AddHistoryEntry(_groupHistoryUtil.CreateLogEndCombat(group));
notificationSession.NotifyGroupChangeGroupData(group.Id, groupData);
group.Data = _jsonUtil.Serialize(groupData);
}
public NhbkDate AddTimeAndNotify(Group group, NhbkDateOffset timeOffset, INotificationSession notificationSession)
{
var groupData = _jsonUtil.Deserialize <GroupData>(group.Data) ?? new GroupData();
if (groupData.Date == null)
{
throw new GroupDateNotSetException();
}
groupData.Date.Add(timeOffset);
group.AddHistoryEntry(_groupHistoryUtil.CreateLogAddTime(group, groupData.Date, timeOffset));
notificationSession.NotifyGroupChangeGroupData(group.Id, groupData);
group.Data = _jsonUtil.Serialize(groupData);
return(groupData.Date);
}
public Task ExecuteAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
if (action.Type != ActionType)
{
throw new InvalidActionTypeException(action.Type, ActionType);
}
if (_itemUtil.DecrementQuantityOrDeleteItem(context.UsedItem))
{
context.UnitOfWork.Items.Remove(context.UsedItem);
notificationSession.NotifyItemDeleteItem(context.UsedItem);
}
return(Task.CompletedTask);
}
public async Task ExecuteAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
if (action.Type != ActionType)
{
throw new InvalidActionTypeException(action.Type, ActionType);
}
if (action.Data == null)
{
throw new InvalidActionDataException(action.Type);
}
if (!action.Data.TemplateId.HasValue)
{
throw new InvalidActionDataException(action.Type);
}
var itemTemplate = await context.UnitOfWork.ItemTemplates.GetAsync(action.Data.TemplateId.Value);
if (itemTemplate == null)
{
throw new ItemTemplateNotFoundException(action.Data.TemplateId.Value);
}
var itemData = new ItemData();
if (!string.IsNullOrEmpty(action.Data.ItemName))
{
itemData.Name = action.Data.ItemName;
}
if (action.Data.Quantity.HasValue)
{
itemData.Quantity = action.Data.Quantity.Value;
}
var item = _itemFactory.CreateItem(ItemOwnerType.Character, context.SourceCharacter.Id, itemTemplate, itemData);
context.UnitOfWork.Items.Add(item);
notificationSession.NotifyCharacterAddItem(context.SourceCharacter.Id, item, true);
}
public void ApplyChangesAndNotify(Group group, PatchGroupRequest request, INotificationSession notificationSession)
{
var groupData = _jsonUtil.Deserialize <GroupData>(group.Data) ?? new GroupData();
if (request.Mankdebol.HasValue)
{
group.AddHistoryEntry(_groupHistoryUtil.CreateLogChangeMankdebol(group, groupData.Mankdebol, request.Mankdebol.Value));
groupData.Mankdebol = request.Mankdebol.Value;
}
if (request.Debilibeuk.HasValue)
{
group.AddHistoryEntry(_groupHistoryUtil.CreateLogChangeDebilibeuk(group, groupData.Debilibeuk, request.Debilibeuk.Value));
groupData.Debilibeuk = request.Debilibeuk.Value;
}
if (request.Date != null)
{
var newDate = new NhbkDate(request.Date);
group.AddHistoryEntry(_groupHistoryUtil.CreateLogChangeDate(group, groupData.Date, newDate));
groupData.Date = newDate;
}
if (request.FighterIndex != null)
{
groupData.CurrentFighterIndex = request.FighterIndex.Value;
}
if (request.Name != null)
{
group.Name = request.Name;
}
notificationSession.NotifyGroupChangeGroupData(group.Id, groupData);
group.Data = _jsonUtil.Serialize(groupData);
}
private void ApplyChangeOnMonsterModifier(Monster monster, IList <ActiveStatsModifier> modifiers, IModifierChange change, INotificationSession notificationSession)
{
var newModifier = change.Modifier;
var modifier = modifiers.First(m => m.Id == newModifier.Id);
if (!newModifier.Active && !modifier.Reusable)
{
modifiers.Remove(modifier);
notificationSession.NotifyMonsterRemoveModifier(monster.Id, modifier.Id);
}
else
{
modifier.Active = newModifier.Active;
modifier.CurrentCombatCount = newModifier.CurrentCombatCount;
modifier.CurrentLapCount = newModifier.CurrentLapCount;
modifier.CurrentTimeDuration = newModifier.CurrentTimeDuration;
notificationSession.NotifyMonsterUpdateModifier(monster.Id, modifier);
}
}
public void ApplyChangesAndNotify(Group group, PatchGroupConfigRequest request, INotificationSession notificationSession)
{
var config = _jsonUtil.DeserializeOrCreate <GroupConfig>(group.Config);
if (request.AllowPlayersToAddObject.HasValue)
{
config.AllowPlayersToAddObject = request.AllowPlayersToAddObject.Value;
}
if (request.AllowPlayersToSeeSkillGmDetails.HasValue)
{
config.AllowPlayersToSeeSkillGmDetails = request.AllowPlayersToSeeSkillGmDetails.Value;
}
if (request.AllowPlayersToSeeGemPriceWhenIdentified.HasValue)
{
config.AllowPlayersToSeeGemPriceWhenIdentified = request.AllowPlayersToSeeGemPriceWhenIdentified.Value;
}
group.Config = _jsonUtil.SerializeNonNull(config);
notificationSession.NotifyGroupChangeConfig(group.Id, config);
}
public async Task ExecuteAsync(
NhbkAction action,
ActionContext context,
INotificationSession notificationSession
)
{
if (action.Type != ActionType)
{
throw new InvalidActionTypeException(action.Type, ActionType);
}
if (action.Data == null)
{
throw new InvalidActionDataException(action.Type);
}
if (!action.Data.EffectId.HasValue)
{
throw new InvalidActionDataException(action.Type);
}
if (action.Data.EffectData == null)
{
throw new InvalidActionDataException(action.Type);
}
var effect = await context.UnitOfWork.Effects.GetWithEffectWithModifiersAsync(action.Data.EffectId.Value);
if (effect == null)
{
throw new EffectNotFoundException();
}
var combatCount = effect.CombatCount;
var timeDuration = effect.TimeDuration;
var duration = effect.Duration;
var lapCount = effect.LapCount;
var customDurationType = action.Data.EffectData.Value <string?>("durationType");
if (!string.IsNullOrEmpty(customDurationType))
{
timeDuration = null;
duration = null;
combatCount = null;
lapCount = null;
switch (customDurationType)
{
case "combat":
combatCount = action.Data.EffectData.Value <int?>("combatCount");
break;
case "time":
timeDuration = action.Data.EffectData.Value <int?>("timeDuration");
break;
case "custom":
duration = action.Data.EffectData.Value <string>("duration");
break;
case "lap":
lapCount = action.Data.EffectData.Value <int?>("lapCount");
break;
case "forever":
break;
default:
throw new InvalidCustomDurationActionException(customDurationType);
}
}
var characterModifier = new CharacterModifier
{
Name = effect.Name,
Permanent = false,
DurationType = customDurationType ?? effect.DurationType,
Duration = duration,
Type = effect.SubCategory.Name,
Description = effect.Description,
Reusable = false,
IsActive = true,
CombatCount = combatCount,
CurrentCombatCount = combatCount,
TimeDuration = timeDuration,
CurrentTimeDuration = timeDuration,
LapCount = lapCount,
CurrentLapCount = lapCount,
Values = effect.Modifiers.Select(v => new CharacterModifierValue
{
Type = v.Type,
StatName = v.StatName,
Value = v.Value
}).ToList()
};
if (context.TargetCharacter.Modifiers == null)
{
context.TargetCharacter.Modifiers = new List <CharacterModifier>();
}
context.TargetCharacter.Modifiers.Add(characterModifier);
context.TargetCharacter.AddHistoryEntry(_characterHistoryUtil.CreateLogAddModifier(context.TargetCharacter, characterModifier));
notificationSession.NotifyCharacterAddModifier(context.TargetCharacter.Id, characterModifier, true);
}
private void UpdateMonsterDuration(Monster monster, IList <IDurationChange> changes, INotificationSession notificationSession)
{
var modifiers = _jsonUtil.DeserializeOrCreate <List <ActiveStatsModifier> >(monster.Modifiers);
foreach (var change in changes.OfType <ModifierDurationChange>())
{
ApplyChangeOnMonsterModifier(monster, modifiers, change, notificationSession);
}
UpdateItemsDuration(monster.Items, changes.OfType <IITemDurationChange>(), notificationSession);
monster.Modifiers = _jsonUtil.Serialize(modifiers);
}
private void UpdateItemsDuration(ICollection <Item> items, IEnumerable <IITemDurationChange> changes, INotificationSession notificationSession)
{
foreach (var(item, change) in items.Join(changes.OfType <ItemModifierDurationChange>(), i => i.Id, c => c.ItemId, (item, change) => (item, change)))
{
var modifiers = _jsonUtil.DeserializeOrCreate <List <ActiveStatsModifier> >(item.Modifiers);
ApplyChangeOnItemModifier(modifiers, change);
item.Modifiers = _jsonUtil.Serialize(modifiers);
notificationSession.NotifyItemUpdateModifier(item);
}
}
private void UpdateCharacterDuration(Character character, IList <IDurationChange> changes, INotificationSession notificationSession)
{
foreach (var change in changes.OfType <ModifierDurationChange>())
{
ApplyChangeOnCharacterModifier(character, character.Modifiers, change, notificationSession);
}
UpdateItemsDuration(character.Items, changes.OfType <IITemDurationChange>(), notificationSession);
}
private void ApplyChangeOnCharacterModifier(Character character, ICollection <CharacterModifier> modifiers, ModifierDurationChange change, INotificationSession notificationSession)
{
var newModifier = change.Modifier;
var modifier = modifiers.First(m => m.Id == newModifier.Id);
if (!newModifier.Active && !modifier.Reusable)
{
modifiers.Remove(modifier);
notificationSession.NotifyCharacterRemoveModifier(character.Id, modifier.Id);
}
else
{
modifier.IsActive = newModifier.Active;
modifier.CurrentCombatCount = newModifier.CurrentCombatCount;
modifier.CurrentLapCount = newModifier.CurrentLapCount;
modifier.CurrentTimeDuration = newModifier.CurrentTimeDuration;
notificationSession.NotifyCharacterUpdateModifier(character.Id, modifier);
}
}
public void ApplyCharactersChange(NaheulbookExecutionContext executionContext, PatchCharacterRequest request, Character character, INotificationSession notificationSession)
{
if (request.Debilibeuk.HasValue)
{
_authorizationUtil.EnsureIsGroupOwner(executionContext, character.Group);
var gmData = _jsonUtil.Deserialize <CharacterGmData>(character.GmData) ?? new CharacterGmData();
gmData.Debilibeuk = request.Debilibeuk.Value;
character.GmData = _jsonUtil.Serialize(gmData);
notificationSession.NotifyCharacterGmChangeData(character, gmData);
}
if (request.Mankdebol.HasValue)
{
_authorizationUtil.EnsureIsGroupOwner(executionContext, character.Group);
var gmData = _jsonUtil.Deserialize <CharacterGmData>(character.GmData) ?? new CharacterGmData();
gmData.Mankdebol = request.Mankdebol.Value;
character.GmData = _jsonUtil.Serialize(gmData);
notificationSession.NotifyCharacterGmChangeData(character, gmData);
}
if (request.IsActive.HasValue)
{
_authorizationUtil.EnsureIsGroupOwner(executionContext, character.Group);
character.IsActive = request.IsActive.Value;
notificationSession.NotifyCharacterGmChangeActive(character);
}
if (request.Color != null)
{
_authorizationUtil.EnsureIsGroupOwner(executionContext, character.Group);
character.Color = request.Color;
notificationSession.NotifyCharacterGmChangeColor(character);
}
if (request.OwnerId != null)
{
_authorizationUtil.EnsureIsGroupOwner(executionContext, character.Group);
character.OwnerId = request.OwnerId.Value;
}
if (request.Target != null)
{
_authorizationUtil.EnsureIsGroupOwner(executionContext, character.Group);
if (request.Target.IsMonster)
{
character.TargetedCharacterId = null;
character.TargetedMonsterId = request.Target.Id;
}
else
{
character.TargetedMonsterId = null;
character.TargetedCharacterId = request.Target.Id;
}
notificationSession.NotifyCharacterGmChangeTarget(character, request.Target);
}
if (request.Ev.HasValue)
{
character.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeEv(character, character.Ev, request.Ev));
character.Ev = request.Ev;
notificationSession.NotifyCharacterChangeEv(character);
}
if (request.Ea.HasValue)
{
character.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeEa(character, character.Ea, request.Ea));
character.Ea = request.Ea;
notificationSession.NotifyCharacterChangeEa(character);
}
if (request.FatePoint.HasValue)
{
character.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeFatePoint(character, character.FatePoint, request.FatePoint));
character.FatePoint = request.FatePoint.Value;
notificationSession.NotifyCharacterChangeFatePoint(character);
}
if (request.Experience.HasValue)
{
character.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeExperience(character, character.Experience, request.Experience));
character.Experience = request.Experience.Value;
notificationSession.NotifyCharacterChangeExperience(character);
}
if (request.Sex != null)
{
character.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeSex(character, character.Sex, request.Sex));
character.Sex = request.Sex;
notificationSession.NotifyCharacterChangeSex(character);
}
if (request.Name != null)
{
character.AddHistoryEntry(_characterHistoryUtil.CreateLogChangeName(character, character.Name, request.Name));
character.Name = request.Name;
notificationSession.NotifyCharacterChangeName(character);
}
if (request.Notes != null)
{
character.Notes = request.Notes;
notificationSession.NotifyCharacterChangeNotes(character);
}
}
