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); } }