public CharacterMovement AddMovement(CharacterMovement characterMovement, Movement movement = null)
{
MovableCharacter defaultCharacter = this.Repository.CharacterByName[HeroVirtualTabletop.AnimatedAbility.DefaultAbilities.CHARACTERNAME] as MovableCharacter;
if (movement == null)
{
movement = GetNewMovement();
}
CharacterMovement charMovement = new CharacterMovementImpl(movement);
if (this != defaultCharacter || (this == defaultCharacter && characterMovement.Movement != null))
{
defaultCharacter.Movements.InsertAction(charMovement);
if (this == defaultCharacter)
{
characterMovement = charMovement;
}
else
{
characterMovement.Movement = movement;
}
}
else
{
characterMovement.Movement = movement;
}
return(characterMovement);
}
public void RemoveMovement_RemovesMovementFromDefaultCharacterAsWell()
{
//arrange
MovableCharacter character = TestObjectFactory.MovableCharacterUnderTest;
MovableCharacter defaultCharacter = TestObjectFactory.DefaultCharacterUnderTest;
Movement mov = TestObjectFactory.MovementUnderTest;
AnimatedCharacterRepository repo = defaultCharacter.Repository;
repo.Characters.Add(character);
character.Repository = repo;
Movement mov1 = TestObjectFactory.MovementUnderTest;
Movement mov2 = TestObjectFactory.MovementUnderTest;
character.AddMovement(mov1);
character.AddMovement(mov2);
// first check if default character has both these movemements
Assert.IsTrue(defaultCharacter.Movements.Any(m => m.Movement == mov1));
Assert.IsTrue(defaultCharacter.Movements.Any(m => m.Movement == mov2));
//act
character.RemoveMovement(mov1);
character.RemoveMovement(mov2);
//assert
Assert.IsFalse(defaultCharacter.Movements.Any(m => m.Movement == mov1));
Assert.IsFalse(defaultCharacter.Movements.Any(m => m.Movement == mov2));
}
public async Task TurnAfterCollision_CanTurnAwayfromCollions()
{
MovableCharacter character = TestObjectFactory.MovableCharacterUnderTestWithMockDesktopNavigator;
character.Position.FacingVector = TestObjectFactory.MockPosition.Vector;
character.DesktopNavigator.Destination = null;
Movement movement = TestObjectFactory.MovementUnderTest;
DesktopNavigator desktopNavigator = character.DesktopNavigator;
var mocker = Mock.Get <DesktopNavigator>(desktopNavigator);
// first move the character forward normally
character.DesktopNavigator.IsInCollision = false;
await movement.Move(character, Direction.Forward);
mocker.Verify(x => x.Navigate(character.Position, Direction.Forward, movement.Speed, movement.HasGravity, It.IsAny <List <Position> >()), Times.Once);
// now set collision and see if character navigates
mocker.ResetCalls();
character.DesktopNavigator.IsInCollision = true;
await movement.Move(character, Direction.Forward);
mocker.Verify(x => x.Navigate(character.Position, Direction.Forward, movement.Speed, true, It.IsAny <List <Position> >()), Times.Never);
// now try to turn around and test again
mocker.ResetCalls();
await movement.Turn(character, TurnDirection.Right);
Assert.IsFalse(character.DesktopNavigator.IsInCollision);
}
private async Task MoveByDistance(List <MovableCharacter> targets, double distance)
{
MovableCharacter target = GetLeadingCharacterForMovement(targets);
if (target.DesktopNavigator.Direction == Direction.None)
{
target.DesktopNavigator.Direction = Direction.Forward;
}
PlayAppropriateAbility(target.DesktopNavigator.Direction, targets);
target.DesktopNavigator.ChangeDirection(target.DesktopNavigator.Direction);
List <Position> followerPositions = targets.Where(t => t != target).Select(t => t.Position).ToList();
await target.DesktopNavigator.NavigateByDistance(target.Position, distance, target.DesktopNavigator.Direction, this.Speed, this.HasGravity, followerPositions);
if (target.DesktopNavigator.IsKnockbackNavigation)
{
PlayAppropriateAbility(Direction.Downward, targets);
}
PlayAppropriateAbility(Direction.Still, targets);
targets.ForEach(t => t.AlignGhost());
this.Stop(target);
target.ActiveMovement.IsCharacterMovingToDestination = false;
target.ActiveMovement.IsCharacterTurning = false;
target.Movements.Active = null;
}
private void ChangeDirection(List <MovableCharacter> targets, Direction direction)
{
MovableCharacter target = GetLeadingCharacterForMovement(targets);
// Play movement
if (targets.Any(t => target.ActiveMovement.IsCharacterMovingToDestination && (t.ActiveMovement == null || !t.ActiveMovement.IsActive)))
{
PlayAppropriateAbility(direction, new List <MovableCharacter> {
target
});
foreach (MovableCharacter movingTarget in targets.Where(t => t != target))
{
var alternateMember = movingTarget.DefaultMovement.Movement.MovementMembers.First(mm => mm.Direction == direction);
PlayAppropriateAbility(direction, new List <MovableCharacter> {
movingTarget
});
}
}
else
{
PlayAppropriateAbility(direction, targets);
}
target.DesktopNavigator.ResetNavigation();
target.DesktopNavigator.ChangeDirection(direction);
//ContinueMovement(target, 1);
}
private async Task ExecuteMove(List <MovableCharacter> targets)
{
MovableCharacter target = GetLeadingCharacterForMovement(targets);
if (!this.IsPaused && target.ActiveMovement != null)
{
if (target.DesktopNavigator.Destination != null)
{
await MoveToDestination(targets, target.DesktopNavigator.Destination);
}
else if (target.ActiveMovement.IsCharacterTurning && this.currentTurnDirection != TurnDirection.None)
{
await TurnToDirection(targets, this.currentTurnDirection, this.currentTurnAngle);
}
else if (target.DesktopNavigator.Direction != Direction.None)
{
if (target.DesktopNavigator.Direction == target.DesktopNavigator.PreviousDirection)
{
await AdvanceInMovementDirection(targets);
}
else
{
ChangeDirection(targets, target.DesktopNavigator.Direction);
await AdvanceInMovementDirection(targets);
}
}
}
}
private async Task MoveToDestination(List <MovableCharacter> targets, Position destination)
{
MovableCharacter target = GetLeadingCharacterForMovement(targets);
if (target.DesktopNavigator.Direction == Direction.None)
{
target.DesktopNavigator.Direction = Direction.Forward;
}
PlayAppropriateAbility(target.DesktopNavigator.Direction, targets);
target.DesktopNavigator.ChangeDirection(target.DesktopNavigator.Direction);
List <Position> followerPositions = targets.Where(t => t != target).Select(t => t.Position).ToList();
followerPositions.AddRange(targets.Where(t => t.GhostShadow != null).Select(t => t.GhostShadow.Position));
await target.DesktopNavigator.NavigateToDestination(target.Position, destination, target.DesktopNavigator.Direction, this.Speed, this.HasGravity, followerPositions);
PlayAppropriateAbility(Direction.Still, targets);
targets.ForEach(t => t.AlignGhost());
this.Stop(target);
target.ActiveMovement.IsCharacterMovingToDestination = false;
target.ActiveMovement.IsCharacterTurning = false;
if (DefaultMovements.CurrentActiveMovementForMovingCharacters == null)
{
target.Movements.Active = null;
}
}
public async Task Start(List <MovableCharacter> charactersToMove, Position destination = null, double speed = 0f)
{
MovableCharacter mainCharacterToMove = GetLeadingCharacterForMovement(charactersToMove);
mainCharacterToMove.DesktopNavigator.ResetNavigation();
mainCharacterToMove.UnFollow();
mainCharacterToMove.IsMoving = true;
foreach (var character in charactersToMove.Where(t => t != mainCharacterToMove))
{
character.AlignFacingWith(mainCharacterToMove);
}
if (speed == 0f)
{
speed = 1f;
}
this.Speed = speed;
if (destination != null)
{
mainCharacterToMove.DesktopNavigator.Destination = destination;
mainCharacterToMove.Position.TurnTowards(destination);
mainCharacterToMove.GhostShadow?.Position.TurnTowards(destination);
}
else
{
PlayAppropriateAbility(Direction.Still, charactersToMove);
}
await ExecuteMove(charactersToMove);
}
protected override void OnEnd()
{
if (!MovableCharacter.IsUnfreezeIsTemporary())
{
MovableCharacter.Animator.enabled = true;
}
}
public override void OnUpdate()
{
MovableCharacter.Animator.Play("attack");
if (MovableCharacter.AttackTarget == null && TimeSinceAttackMade > MovableCharacter.AttackReloadPeriod)
{
MovableCharacter.MakeIdle();
}
}
protected override void LoadContent()
{
base.LoadContent();
this.CustomDrawing += StrategyGame_CustomDrawing;
character = new MovableCharacter(Content.Load <Texture2D>("Foulu"), Vector2.Zero);
}
public override void OnUpdate()
{
MovableCharacter.Animator.Play("attacked");
if (MovableCharacter.IsAttackReationFinished())
{
MovableCharacter.MakeIdle();
}
}
private void LoadAvailableMovements()
{
this.defaultCharacter = DefaultAbilities.DefaultCharacter as MovableCharacter;
string currentMovementName = this.CurrentCharacterMovement.Movement != null ? this.CurrentCharacterMovement.Movement.Name : "";
var allMovements = defaultCharacter.Movements.Select((cm) => { return(cm.Movement); }).Where(m => m != null).Distinct();
var editingCharacterMovements = (this.CurrentCharacterMovement.Owner as MovableCharacter).Movements.Select((cm) => { return(cm.Movement); }).Where(m => m != null && m.Name != currentMovementName).Distinct();
this.AvailableMovements = new ObservableCollection <Movement>(allMovements.Except(editingCharacterMovements));
}
public async Task MoveForwardTo(MovableCharacter characterToMove, Position destination, double speed = 0f)
{
characterToMove.DesktopNavigator.Destination = destination;
if (characterToMove.IsMoving)
{
characterToMove.Position.TurnTowards(destination);
}
await Move(characterToMove, Direction.Forward, destination, speed);
}
public void CopyMovementsTo(MovableCharacter targetCharacter)
{
foreach (CharacterMovement cm in this.Movements.Where(m => !defaultMovementNames.Contains(m.Movement.Name)))
{
CharacterMovement characterMovement = cm.Clone() as CharacterMovement;
characterMovement.Name = targetCharacter.GetNewValidCharacterMovementName(characterMovement.Name);
targetCharacter.Movements.InsertAction(characterMovement);
}
}
private string GetNewValidMovementName(MovableCharacter defaultCharacter, string name = "Movement")
{
string suffix = string.Empty;
int i = 0;
while ((defaultCharacter.Movements.Any((CharacterMovement cm) => { return(cm.Movement != null && cm.Movement.Name == name + suffix); })))
{
suffix = string.Format(" ({0})", ++i);
}
return(string.Format("{0}{1}", name, suffix).Trim());
}
public async Task MoveCharacterForward_AlignsGhostInNewPosition()
{
Movement movement = TestObjectFactory.MovementUnderTest;
MovableCharacter character = TestObjectFactory.MockMovableCharacterWithActionGroupsAndActiveMovement;
character.DesktopNavigator = TestObjectFactory.MockDesktopNavigator;
await movement.Move(character, Direction.Forward);
Mock.Get <MovableCharacter>(character).Verify(mc => mc.AlignGhost());
}
public override void OnUpdate()
{
MovableCharacter.Animator.Play("walk");
float sqrRemainingDistance = MovableCharacter.GetTargetDistance();
if (sqrRemainingDistance <= 0.1f)
{
_conductor.StopStickIfNeeded();
MovableCharacter.MakeIdle();
}
CalculatePosition();
}
public static void AddToSelectedCharacters(MovableCharacter character)
{
foreach (MovableCharacter alreadySelected in _SelectedCharacters)
{
if (alreadySelected == character)
{
return;
}
}
_SelectedCharacters.Add(character);
character.IsSelected = true;
}
public void CharacterMovementSpeedIsNotSet_IsTakenFromMovement()
{
//arrange
MovableCharacter character = TestObjectFactory.MovableCharacterUnderTestWithCharacterMovement;
CharacterMovement movement = character.Movements.FirstOrDefault();
//act
movement.Speed = 0f;
//assert
Assert.AreEqual(movement.Speed, movement.Movement.Speed);
}
public async Task MoveByKeyPress(MovableCharacter characterToMove, Key key, double speed = 0f)
{
Direction direction =
(from mov in MovementMembers where mov.Key == key select mov.Direction).FirstOrDefault();
if (direction != Direction.None)
{
characterToMove.DesktopNavigator.Direction = direction;
}
await Move(characterToMove, direction, null, speed);
}
public async Task MoveByKeyPress(List <MovableCharacter> charactersToMove, Key key, double speed = 0f)
{
Direction direction =
(from mov in this.MovementMembers where mov.Key == key select mov.Direction).FirstOrDefault();
if (direction != Direction.None)
{
MovableCharacter mainCharacterToMove = GetLeadingCharacterForMovement(charactersToMove);
mainCharacterToMove.DesktopNavigator.Direction = direction;
}
//Logging.LogManagerImpl.ForceLog("ActiveKey:{0}", key);
await Move(charactersToMove, direction, null, speed);
}
protected void CalculatePosition()
{
if (MovableCharacter.GetTarget() != default(Vector2))
{
Vector3 newPosition = Vector3.MoveTowards(MovableCharacter.transform.position, MovableCharacter.GetTarget(), MovableCharacter.Velocity * Time.deltaTime);
newPosition.z = -1;
MovableCharacter.transform.position = newPosition;
}
else
{
MovableCharacter.MakeIdle();
}
}
public async Task MoveToDestination_PlaysStillAfterReachingDestination()
{
// arrange
MovableCharacter character = TestObjectFactory.MovableCharacterUnderTestWithMockDesktopNavigator;
Movement movement = TestObjectFactory.MovementUnderTest;
// act
await movement.MoveForwardTo(character, character.DesktopNavigator.Destination);
// assert
var mocker = Mock.Get <AnimatedAbility.AnimatedAbility>(movement.MovementMembers.First(mm => mm.Direction == Direction.Still).Ability);
mocker.Verify(x => x.Play(It.Is <List <AnimatedCharacter> >(t => t.Contains(character))), Times.Once);
}
private void DisablePower()
{
MovableCharacter PlayerLink = Target.transform.parent.GetComponent <MovableCharacter>();
PlayerLink.moveSpeed -= fPlayerRunSpeed;
KillPeanut PlayerLink1 = Target.GetComponent <KillPeanut>();
PlayerLink1.fExtendedGateTime -= fExtendedGateTime;
PlayerLink1.fHealChilliValue -= fChilliHealing;
isActive = false;
}
public void MovementCommands_DelegatesToActiveMovement()
{
//arrange
MovableCharacter character = TestObjectFactory.MovableCharacterUnderTestWithCharacterMovement;
//act
character.Movements.FirstOrDefault().Play();
character.Move(Direction.Right);
character.Move(Direction.Forward);
//assert
var mocker = Mock.Get <Movement>(character.Movements.FirstOrDefault().Movement);
mocker.Verify(x => x.Move(character, Direction.Forward, null, character.Movements.FirstOrDefault().Speed));
}
private async Task TurnToDirection(List <MovableCharacter> targets, TurnDirection turnDirection, float turnAngle)
{
MovableCharacter target = GetLeadingCharacterForMovement(targets);
Key key = GetKeyFromDirection(turnDirection);
foreach (MovableCharacter character in targets)
{
character.Position.Turn(turnDirection, turnAngle);
character.GhostShadow?.Position?.Turn(turnDirection, turnAngle);
}
await Task.Delay(2);
Reset(target);
}
public void PlayCharacterMovement_SetsAndStartsActiveMovement()
{
MovableCharacter character = TestObjectFactory.MovableCharacterUnderTestWithCharacterMovement;
DefaultMovements.CurrentActiveMovementForMovingCharacters = null;
var characterMovement = character.Movements.First();
characterMovement.Play();
Assert.AreEqual(character.ActiveMovement, characterMovement);
var mockMovement = Mock.Get <Movement>(characterMovement.Movement);
mockMovement.Verify(m => m.Start(It.Is <List <MovableCharacter> >(t => t.Contains(character)), null, 0));
}
public async Task Move(MovableCharacter characterToMove, Direction direction, Position destination = null, double speed = 0f)
{
characterToMove.DesktopNavigator.Direction = direction;
if (!characterToMove.IsMoving)
{
await Start(characterToMove, destination, speed);
}
else
{
await ExecuteMove(new List <MovableCharacter> {
characterToMove
});
}
}
public async Task Move(List <MovableCharacter> charactersToMove, Direction direction, Position destination = null, double speed = 0f)
{
MovableCharacter mainCharacterToMove = GetLeadingCharacterForMovement(charactersToMove);
mainCharacterToMove.DesktopNavigator.Direction = direction;
//Logging.LogManagerImpl.ForceLog("CurrentDirection:{0}", direction);
if (!mainCharacterToMove.IsMoving)
{
await Start(charactersToMove, destination, speed);
}
else
{
await ExecuteMove(charactersToMove);
}
}
