private void TogglePlayOption(object obj)
{
if (SelectedOption != null && SelectedOption is AnimatedAbility && !(obj is AnimatedAbility))
{
StopOption(SelectedOption);
}
//SelectedOption = (T)obj;
if (SelectedOption is AnimatedAbility)
{
AnimatedAbility ability = obj as AnimatedAbility;
if (!ability.IsActive)
{
PlayOption(obj);
}
else
{
StopOption(obj);
}
}
else if (SelectedOption is CharacterMovement)
{
CharacterMovement characterMovement = obj as CharacterMovement;
if (!characterMovement.IsActive)
{
PlayOption(obj);
}
else
{
StopOption(obj);
}
}
}
private void GetDirectionalAbility(MovementDirection direction)
{
AnimatedAbility ability = null;
MovementMember movementMember = null;
switch (direction)
{
case MovementDirection.Left:
movementMember = SelectedMovement.MovementMembers.FirstOrDefault(mm => mm.MovementDirection == MovementDirection.Left);
ability = movementMember.MemberAbility.Reference;
break;
case MovementDirection.Right:
break;
case MovementDirection.Forward:
break;
case MovementDirection.Backward:
break;
case MovementDirection.Upward:
break;
case MovementDirection.Downward:
break;
case MovementDirection.Still:
break;
}
}
private void PlayAnimatedAbility(AnimatedAbility ability)
{
Action d = delegate()
{
if (!ability.IsAttack)
{
IntPtr winHandle = WindowsUtilities.FindWindow("CrypticWindow", null);
WindowsUtilities.SetForegroundWindow(winHandle);
}
Character currentTarget = null;
if (!ability.PlayOnTargeted)
{
this.SpawnAndTargetOwnerCharacter();
currentTarget = this.Owner;
}
else
{
Roster.RosterExplorerViewModel rostExpVM = this.Container.Resolve <Roster.RosterExplorerViewModel>();
currentTarget = rostExpVM.GetCurrentTarget() as Character;
if (currentTarget == null)
{
this.SpawnAndTargetOwnerCharacter();
currentTarget = this.Owner;
}
}
owner.ActiveAbility = ability;
currentTarget.Target();
//ability.Play(Target: currentTarget);
this.eventAggregator.GetEvent <PlayAnimatedAbilityEvent>().Publish(new Tuple <Character, AnimatedAbility>(currentTarget, ability));
};
AsyncDelegateExecuter adex = new Library.Utility.AsyncDelegateExecuter(d, 5);
adex.ExecuteAsyncDelegate();
}
private void SetSelectedOption(T value)
{
if (selectedOption != null && selectedOption is AnimatedAbility)
{
if (selectedOption as AnimatedAbility != value as AnimatedAbility)
{
AnimatedAbility ability = selectedOption as AnimatedAbility;
if (ability.IsActive && !ability.Persistent)
{
StopAnimatedAbility(ability);
}
}
}
selectedOption = value;
if (value is Identity)
{
if (!this.Owner.HasBeenSpawned)
{
this.SpawnAndTargetOwnerCharacter();
}
owner.ActiveIdentity = (Identity)Convert.ChangeType(value, typeof(Identity));
}
else if (value is CharacterMovement)
{
if (!this.Owner.HasBeenSpawned)
{
this.SpawnAndTargetOwnerCharacter();
}
owner.ActiveMovement = (CharacterMovement)Convert.ChangeType(value, typeof(CharacterMovement));
}
}
private void addStateToTargetIfPersistent(AnimatedAbility ability, AnimatedCharacter target)
{
if (ability.Persistent)
{
AnimatableCharacterState newstate = new AnimatableCharacterStateImpl(ability, target);
newstate.AbilityAlreadyPlayed = true;
target.AddState(newstate);
}
}
public void AddDefaultState(string defaultState, bool playImmediately = true)
{
if (Repository.CharacterByName.ContainsKey(HeroVirtualTabletop.AnimatedAbility.DefaultAbilities.CHARACTERNAME))
{
AnimatedAbility defaultAbility = Repository?.CharacterByName?[HeroVirtualTabletop.AnimatedAbility.DefaultAbilities.CHARACTERNAME]
?.Abilities?[defaultState];
if (defaultAbility != null)
{
AnimatableCharacterState state = new AnimatableCharacterStateImpl(defaultAbility, this);
AddState(state, playImmediately);
}
}
NotifyOfPropertyChange(() => ActiveStates.Count);
}
private void PlayOption(object state)
{
if (selectedOption is AnimatedAbility)
{
AnimatedAbility ability = selectedOption as AnimatedAbility;
if (ability != null)
{
PlayAnimatedAbility(ability);
clickTimer_AbilityPlay.Start();
}
}
else
{
CharacterMovement characterMovement = selectedOption as CharacterMovement;
this.eventAggregator.GetEvent <PlayMovementInitiatedEvent>().Publish(characterMovement);
}
}
private void DeActivateAnimatedAbility(AnimatedAbility ability)
{
Character currentTarget = null;
if (!ability.PlayOnTargeted)
{
this.SpawnAndTargetOwnerCharacter();
}
else
{
Roster.RosterExplorerViewModel rostExpVM = this.Container.Resolve <Roster.RosterExplorerViewModel>();
currentTarget = rostExpVM.GetCurrentTarget() as Character;
if (currentTarget == null)
{
this.SpawnAndTargetOwnerCharacter();
currentTarget = this.Owner;
}
}
owner.ActiveAbility = null;
ability.DeActivate(Target: currentTarget);
}
private void StopOption(object state)
{
if (selectedOption is AnimatedAbility)
{
AnimatedAbility abilityToStop = state as AnimatedAbility;
AnimatedAbility ability = selectedOption as AnimatedAbility;
if (ability != null && abilityToStop != null && ability == abilityToStop)
{
StopAnimatedAbility(ability);
}
}
else
{
CharacterMovement characterMovement = selectedOption as CharacterMovement;
if (characterMovement != null && characterMovement.Movement != null && characterMovement.IsActive)
{
owner.ActiveMovement = null;
this.eventAggregator.GetEvent <StopMovementEvent>().Publish(characterMovement);
}
}
}
private void CreateAbilitiesViewSource(ObservableCollection <AnimatedAbility> abilities)
{
abilitiesCVS = new CollectionViewSource();
Attack none = new Attack("None", owner: this.Owner);
abilities.Add(none);
abilitiesCVS.Source = new ObservableCollection <AnimatedAbility>(abilities.Where((an) => { return(an.Owner == this.Owner); }).OrderBy(a => a.Order));
abilitiesCVS.View.Filter += abilitiesCVS_Filter;
AnimatedAbility moveTo = null;
if (EditedIdentity != null)
{
moveTo = EditedIdentity.AnimationOnLoad;
}
else
{
moveTo = none;
}
abilitiesCVS.View.MoveCurrentTo(moveTo);
OnPropertyChanged("AbilitiesCVS");
}
private void StopAnimatedAbility(AnimatedAbility ability)
{
Character currentTarget = null;
if (!ability.PlayOnTargeted)
{
this.SpawnAndTargetOwnerCharacter();
currentTarget = this.Owner;
}
else
{
Roster.RosterExplorerViewModel rostExpVM = this.Container.Resolve <Roster.RosterExplorerViewModel>();
currentTarget = rostExpVM.GetCurrentTarget() as Character;
if (currentTarget == null)
{
this.SpawnAndTargetOwnerCharacter();
currentTarget = this.Owner;
}
}
this.Owner.ActiveAbility = null;
//ability.Stop(Target: currentTarget);
this.eventAggregator.GetEvent <StopAnimatedAbilityEvent>().Publish(new Tuple <Character, AnimatedAbility>(currentTarget, ability));
}
public void Play(List <AnimatedCharacter> targets)
{
// If there is an ability with the same name in any of the targets, we need to construct a list of different abilities to play
bool customAbilityExists = targets.Any(t => t.Abilities.Any(a => a.Name == this.Name));
if (customAbilityExists)
{
List <AnimatedAbility> abilities = new List <AnimatedAbility>();
foreach (AnimatedCharacter target in targets)
{
if (target.Abilities.Any(a => a.Name == this.Name && a != this))
{
AnimatedAbility ability = target.Abilities[this.Name];
ability.Target = target;
abilities.Add(ability);
}
else
{
AnimatedAbility cloneAbility = this.Clone(target);
abilities.Add(cloneAbility);
}
}
Play(abilities);
foreach (var ability in abilities.Where(a => a.Persistent))
{
addStateToTargetIfPersistent(ability, ability.Target);
}
}
else
{
Sequencer.Play(targets);
foreach (var t in targets)
{
addStateToTargetIfPersistent(this, t);
}
}
}
public bool Equals(AnimatedAbility other)
{
if (other.KeyboardShortcut != KeyboardShortcut)
{
return(false);
}
if (other.Name != Name)
{
return(false);
}
if (other.Order != Order)
{
return(false);
}
if (other.Persistent != Persistent)
{
return(false);
}
if (other.Sequencer.Equals(Sequencer) == false)
{
return(false);
}
return(true);
}
public void CopyToClipboard(AnimatedAbility ability)
{
CurrentClipboardAction = ClipboardAction.Clone;
currentClipboardObject = ability;
}
public override ICrowdMember Clone()
{
CrowdMemberModel crowdMemberModel = new CrowdMemberModel()
{
Name = this.Name,
RosterCrowd = null
};
crowdMemberModel.InitializeCharacter();
foreach (AnimatedAbility ab in this.AnimatedAbilities)
{
AnimatedAbility clonedAbility = ab.Clone() as AnimatedAbility;
clonedAbility.Owner = crowdMemberModel;
if (clonedAbility.IsAttack)
{
if ((clonedAbility as Attack).OnHitAnimation != null)
{
(clonedAbility as Attack).OnHitAnimation.Owner = crowdMemberModel;
}
}
crowdMemberModel.AnimatedAbilities.Add(clonedAbility);
}
foreach (Identity id in this.AvailableIdentities)
{
Identity clonedIdentity = id.Clone();
if (id.AnimationOnLoad != null)
{
AnimatedAbility animationOnLoad = crowdMemberModel.AnimatedAbilities.Where(aa => aa.Name == id.AnimationOnLoad.Name).FirstOrDefault();
clonedIdentity.AnimationOnLoad = animationOnLoad;
}
crowdMemberModel.AvailableIdentities.Add(clonedIdentity);
}
if (this.DefaultIdentity != null)
{
Identity defaultIdentity = crowdMemberModel.AvailableIdentities.Where(i => i.Name == this.DefaultIdentity.Name).FirstOrDefault();
crowdMemberModel.DefaultIdentity = defaultIdentity;
}
if (this.ActiveIdentity != null)
{
Identity activeIdentity = crowdMemberModel.AvailableIdentities.Where(i => i.Name == this.ActiveIdentity.Name).FirstOrDefault();
crowdMemberModel.ActiveIdentity = activeIdentity;
}
foreach (CharacterMovement characterMovement in this.Movements)
{
CharacterMovement clonedCharacterMovement = characterMovement.Clone();
clonedCharacterMovement.Character = crowdMemberModel;
crowdMemberModel.Movements.Add(clonedCharacterMovement);
}
if (this.DefaultMovement != null)
{
CharacterMovement defaultCharacterMovement = crowdMemberModel.Movements.FirstOrDefault(cm => cm.Name == this.DefaultMovement.Name);
crowdMemberModel.DefaultMovement = defaultCharacterMovement;
}
// Custom option groups
foreach (var customGroup in this.OptionGroups.Where(og => og.Type == HeroVirtualTabletop.OptionGroups.OptionType.Mixed))
{
OptionGroup <CharacterOption> optGroup = new OptionGroup <CharacterOption>(customGroup.Name);
crowdMemberModel.AddOptionGroup(optGroup);
foreach (var customOption in customGroup.Options)
{
if (customOption is Identity)
{
Identity id = customOption as Identity;
Identity identityToRefer = crowdMemberModel.AvailableIdentities.FirstOrDefault(i => i.Name == id.Name);
if (identityToRefer != null)
{
optGroup.Add(identityToRefer);
}
}
else if (customOption is AnimatedAbility)
{
AnimatedAbility ab = customOption as AnimatedAbility;
AnimatedAbility abilityToRefer = crowdMemberModel.AnimatedAbilities.FirstOrDefault(aa => aa.Name == ab.Name);
if (abilityToRefer != null)
{
optGroup.Add(abilityToRefer);
}
}
else if (customOption is CharacterMovement)
{
CharacterMovement mv = customOption as CharacterMovement;
CharacterMovement characterMovementToRefer = crowdMemberModel.Movements.FirstOrDefault(m => m.Name == mv.Name);
if (characterMovementToRefer != null)
{
optGroup.Add(characterMovementToRefer);
}
}
}
}
return(crowdMemberModel);
}
public PlayAnimatedAbilityEvent(AnimatedAbility ability)
{
this.AbilityToPlay = ability;
}
public AnimationResource(AnimatedAbility reference) : this()
{
this.Reference = reference;
}
public AnimatableCharacterStateImpl(AnimatedAbility ability, AnimatedCharacter target)
{
StateName = ability.Name;
Target = target;
Ability = ability;
}
public EditAnimatedAbilityEvent(AnimatedAbility editedAbility)
{
this.EditedAbility = editedAbility;
}
public AnimationResource(AnimatedAbility reference, string name, params string[] tags) : this(reference)
{
this.Name = name;
this.tags.AddRange(tags);
}
public static bool IsCoreDefaultAbility(AnimatedAbility ability)
{
return(CoreDefaultAbilities.Contains(ability.Name));
}
