public List<LocationOfInterest> GetInterestingLocations(Avatar observer)
		{
			List<LocationOfInterest> locationsOfInterest = new List<LocationOfInterest>();

			MapTile observerTile = _quest.GetAvatarMapTile(observer);
			Point observerLocation = _quest.Map.GetMapTileLocation(observerTile);
			PointList visibleLocations = _quest.Map.GetPointsWithinLineOfSightOf(observerLocation);

			//// Get a list of all actionable map tiles
			PointList interestingLocations = _quest.Map.GetActionableMapPoints(observer.Faction);
			
			// Filter out interesting locations that are not in the visible set
			PointList visibleInterestingLocations = interestingLocations.Intersects(visibleLocations);

			// Create paths to each of these points
			PathfindingNode observerNode = _quest.Map.GetPathfindingNodeForTile(observerTile);
			foreach (Point point in visibleInterestingLocations)
			{
				PathfindingNode pointNode = _quest.Map.GetPathfindingNodeForLocation(point.X, point.Y);
				List<PathfindingNode> path = _quest.Map.PathfindingGraph.FindRoute(observerNode, pointNode);
				if (path != null)
				{
					PointList pathSteps = new PointList();
					for (int i = 1; i < path.Count; i++)
					{ pathSteps.Add(_quest.Map.GetPointForPathfindingNode(path[i])); }

					LocationOfInterest interest = new LocationOfInterest(pathSteps);
					locationsOfInterest.Add(interest);
				}
			}

			return locationsOfInterest;
		}
		public MovementTurnStepAction(Avatar actor, PointList stepsToLocation, MapTile interestingLocation=null)
			: base(false)
		{
			_avatar = actor;
			_stepsToLocation = stepsToLocation;
			RequiresMovement = true;

			HasMoreTurns = (_stepsToLocation.Count > 1) ? true : false; // If there are more steps, then we can be used in subsequent turns!
			AcceptsAvatarFocus = HasMoreTurns;
		}
		override public TurnStepAction FindAction(Avatar currentAvatar, AvatarTurnState avatarTurnState, QuestAnalyzer mapAnalyzer, ChanceProvider chanceProvider)
		{
			List<AbstractTileAction> actionsForCurrentLocation = mapAnalyzer.GetActionsAtObserverLocation(currentAvatar);
			if (actionsForCurrentLocation.Count <= 0)
			{ return null; }

			AbstractTileAction tileAction = actionsForCurrentLocation[0];
			TurnStepAction action = new ActionableTurnStepAction(tileAction, currentAvatar);

			return action;
		}
		override public TurnStepAction FindAction(Avatar currentAvatar, AvatarTurnState avatarTurnState, QuestAnalyzer mapAnalyzer, ChanceProvider chanceProvider)
		{
			List<LocationOfInterest> interestingDestinations = mapAnalyzer.GetInterestingLocationsCheating(currentAvatar);
			if (interestingDestinations.Count <= 0)
			{ return null; }

			interestingDestinations = interestingDestinations.OrderBy(item => item.StepsToLocation).ToList();

			MovementTurnStepAction action = new MovementTurnStepAction(currentAvatar, interestingDestinations[0].StepsToLocation);
			return action;
		}
		override public TurnStepAction FindAction(Avatar currentAvatar, AvatarTurnState avatarTurnState, QuestAnalyzer mapAnalyzer, ChanceProvider chanceProvider)
		{
			PointList unwalkedTiles = mapAnalyzer.GetAdjacentUnvisitedLocations(currentAvatar);
			if (unwalkedTiles.Count <= 0)
			{ return null; }

			// Just pick the first tile, and see if that opens up any other actions...
			PointList path = new PointList() { unwalkedTiles[0] };

			MovementTurnStepAction action = new MovementTurnStepAction(currentAvatar, path);
			return action;
		}
		public QuestView(AbstractQuest quest, ChanceProvider chanceProvider, StoryTeller storyTeller)
		{
			InitializeComponent();

			_quest = quest;
			_chanceProvider = chanceProvider;
			_storyTeller = storyTeller;

			_turnTakers = new List<Avatar>();
			_currentTurnTaker = null;
			_currentTurnTakerIndex = -1;

			_turnTimer = new DispatcherTimer();
			_turnTimer.Interval = TimeSpan.FromMilliseconds(500);
			_turnTimer.Tick += OnTurnTimerTick;

			Loaded += OnLoaded;
		}
		public List<LocationOfInterest> GetInterestingLocationsCheating(Avatar observer)
		{
			List<LocationOfInterest> locationsOfInterest = new List<LocationOfInterest>();

			MapTile observerTile = _quest.GetAvatarMapTile(observer);
			Point observerLocation = _quest.Map.GetMapTileLocation(observerTile);
			PointList visibleLocations = _quest.Map.GetPointsWithinLineOfSightOf(observerLocation);

			//// Get a list of all actionable map tiles
			PointList interestingLocations = _quest.Map.GetActionableMapPoints(observer.Faction);

			// Find the closest location by straight-line distance.  It was too expensive to calculate Pathfinding distance.
			PathfindingNode observerNode = _quest.Map.GetPathfindingNodeForTile(observerTile);
			Point closestDistanceInterestingLocation = null;
			double closestDistance = float.MaxValue;
			foreach (Point point in interestingLocations)
			{
				double distance = Math.Sqrt(Math.Pow(observerLocation.X - point.X, 2) + Math.Pow(observerLocation.Y - point.Y, 2));
				if (distance < closestDistance)
				{
					closestDistanceInterestingLocation = point;
					closestDistance = distance;
				}
			}

			if (closestDistanceInterestingLocation != null)
			{
				PathfindingNode pointNode = _quest.Map.GetPathfindingNodeForLocation(closestDistanceInterestingLocation.X, closestDistanceInterestingLocation.Y);
				List<PathfindingNode> path = _quest.Map.PathfindingGraph.FindRoute(observerNode, pointNode);
				if (path != null)
				{
					PointList pathSteps = new PointList();
					for (int i = 1; i < path.Count; i++)
					{ pathSteps.Add(_quest.Map.GetPointForPathfindingNode(path[i])); }

					LocationOfInterest interest = new LocationOfInterest(pathSteps);
					locationsOfInterest.Add(interest);
					return locationsOfInterest;
				}
			}

			return locationsOfInterest;
		}
		public List<AbstractTileAction> GetActionsAtObserverLocation(Avatar observer)
		{
			MapTile observerTile = _quest.GetAvatarMapTile(observer);
			Point observerLocation = _quest.Map.GetMapTileLocation(observerTile);

			//// Get a list of all actionable map tiles
			PointList interestingLocations = _quest.Map.GetActionableMapPoints(observer.Faction);

			// Filter out interesting locations that are not in the visible set
			PointList observerLocations = new PointList();
			observerLocations.Add(observerLocation);
			PointList visibleInterestingLocations = interestingLocations.Intersects(observerLocations);

			List<AbstractTileAction> actions = new List<AbstractTileAction>();
			for (int i = 0; i < visibleInterestingLocations.Count; i++)
			{
				List<AbstractTileAction> actionsAtInterestingLocation = _quest.Map.GetActionsForPoint(observerLocation);
				foreach (AbstractTileAction actionAtInterestingLocation in actionsAtInterestingLocation)
				{ actions.Add(actionAtInterestingLocation); }
			}

			return actions;
		}
		public void SetAvatar(Avatar avatar)
		{ _avatar = avatar; }
		public List<Avatar> GetVisibleEnemies(Avatar observer)
		{
			List<Avatar> visibleEnemies = new List<Avatar>();

			MapTile observerMapTile = _quest.GetAvatarMapTile(observer);
			Point observerLocation = _quest.Map.GetMapTileLocation(observerMapTile);
			PointList visibleLocations = _quest.Map.GetPointsWithinLineOfSightOf(observerLocation);

			List<Avatar> allEnemies = _quest.GetEnemiesOfAvatar(observer);
			foreach (Avatar enemy in allEnemies)
			{
				MapTile enemyMapTile = _quest.GetAvatarMapTile(enemy);
				Point enemyPoint = _quest.Map.GetMapTileLocation(enemyMapTile);
				if (visibleLocations.ContainsLocation(enemyPoint.X, enemyPoint.Y))
				{ visibleEnemies.Add(enemy); }
			}
			return visibleEnemies;
		}
Example #11
0
		public Boolean CouldBeEquipedBy(Avatar avatar)
		{ return true; }
		private void PerformNextTurnCycle()
		{
			_turnTimer.Stop();

			// Check to make sure there is a living hero left.  If not, stop the timer, and end the game.  
			// This has to be above all of the turn loops to make sure that the "Hero is dead" action comes up for each one.
			if (!_quest.AreAnyHeroesAlive)
			{
				if (HeroesLose != null)
				{ HeroesLose(this, new EventArgs()); }
			}
			else
			{
				TurnStepAction action = _currentTurnTaker.DoTakeTurnStep(_questAnalyzer, _chanceProvider);

				if (action == null) // The current player has no more steps to take
				{
					_currentTurnTakerIndex++;
					if (_currentTurnTakerIndex > _turnTakers.Count - 1)
					{ _currentTurnTakerIndex = 0; }
					_currentTurnTaker = _turnTakers[_currentTurnTakerIndex];
					_currentTurnTaker.StartTurn();
					PerformNextTurnCycle();
				}
				else
				{
					action.Complete += OnCurrentActionCommitComplete;
					action.Commit(_quest, _storyTeller);
				}

				RenderQuestBoard();
			}
		}
		private void BeginTurnCycle()
		{
			_storyTeller.StoryComplete -= OnQuestIntroductionStoryComplete;

			_turnTakers.Clear();
			foreach (Hero hero in _quest.Heroes)
			{ _turnTakers.Add(hero); }
			foreach (Monster monster in _quest.Monsters)
			{ _turnTakers.Add(monster); }

			// Make the first person in the list the current player
			_currentTurnTakerIndex = 0;
			_currentTurnTaker = _turnTakers[_currentTurnTakerIndex];
			_currentTurnTaker.StartTurn();

			_questAnalyzer = new QuestAnalyzer(_quest);
			PerformNextTurnCycle(); // Immediately take one turn
		}
		public List<Avatar> GetAdjacentEnemies(Avatar observer, Boolean includeDiagonalTiles)
		{
			List<Avatar> adjacentEnemies = new List<Avatar>();

			MapTile observerMapTile = _quest.GetAvatarMapTile(observer);
			Point observerLocation = _quest.Map.GetMapTileLocation(observerMapTile);

			double minimumDistance = includeDiagonalTiles ? Math.Sqrt(2) : 1;
			List<Avatar> allEnemies = _quest.GetEnemiesOfAvatar(observer);
			foreach (Avatar enemy in allEnemies)
			{
				MapTile enemyMapTile = _quest.GetAvatarMapTile(enemy);
				Point enemyPoint = _quest.Map.GetMapTileLocation(enemyMapTile);
				double distance = Math.Sqrt(Math.Pow(enemyPoint.X - observerLocation.X, 2) + Math.Pow(enemyPoint.Y - observerLocation.Y, 2));
				if (distance <= minimumDistance)
				{ adjacentEnemies.Add(enemy); }
			}

			return adjacentEnemies;
		}
		public ConfusedTurnStepAction(Avatar actor)
			: base(false)
		{
			_actor = actor;
		}
		public virtual TurnStepAction FindAction(Avatar currentAvatar, AvatarTurnState avatarTurnState, QuestAnalyzer mapAnalyzer, ChanceProvider chanceProvider)
		{ return null; } // Override in subclasses
		public ActionableTurnStepAction(AbstractTileAction tileAction, Avatar avatar):base(false)
		{
			_tileAction = tileAction;
			_avatar = avatar;
		}
		override public TurnStepAction FindAction(Avatar currentAvatar, AvatarTurnState avatarTurnState, QuestAnalyzer mapAnalyzer, ChanceProvider chanceProvider)
		{
			List<Avatar> enemies = mapAnalyzer.GetAdjacentEnemies(currentAvatar, currentAvatar.CanAttackAdjacent);

			return null;
		}
		public DeadTurnStepAction(Avatar actor)
			: base(false)
		{
			_actor = actor;
		}
		public PointList GetAdjacentUnvisitedLocations(Avatar observer)
		{
			MapTile observerTile = _quest.GetAvatarMapTile(observer);
			Point observerLocation = _quest.Map.GetMapTileLocation(observerTile);
			PointList points = _quest.Map.GetAdjacentUnwalkedTiles(observerLocation, observer.Faction);

			// Favor points in the direction of the Avatars' movement vector
			Point desiredPoint = new Point(
				observerLocation.X + observer.movementVector.X,
				observerLocation.Y + observer.movementVector.Y
			);

			if (!points.ContainsLocation(desiredPoint.X, desiredPoint.Y))
			{ return points; }

			PointList match = new PointList() { desiredPoint };
			points = points.Intersects(match);

			return points;
		}