コード例 #1
0
	/// <summary>
	/// compare the fed worldstate to a newly generated one, if they have different enemy data, replan.
	/// </summary>
	/// <param name="_worldState">World state.</param>
	public override bool Sense(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		bool changeSensed = false;

		GoapWorldstate oldState = _worldState,
		newState = new GoapWorldstate();

		//generate a new worldstate
		newState.generateWorldState(core.actor);

		//if the enemy data is different, the enemies have changed and a new plan should be forged
		if (CompareEnemyData(oldState.enemyData, newState.enemyData))
		{
			//drop the current target enemy
			core.actor.targetEnemy = null;

			changeSensed = true;
		}

		//push the new worldstate into the core
		core.setWorldState(newState);

		//return the verdict
		return changeSensed;
	}
コード例 #2
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		//target a visible enemy

		//if there is only one enemy visible, target it
		if (_worldState.enemyData.Count == 1)
		{
			core.actor.targetEnemy = _worldState.enemyData[0].enemy;
		}
		else //if there are more, choose the closest
		{
			ActorBase closest = null;
			float closestDistance = float.PositiveInfinity;

			foreach (EnemyPosition _enemyData in _worldState.enemyData)
			{
				float testDistance = Vector3.Distance(core.actor.transform.position, _enemyData.enemy.transform.position);

				if (testDistance < closestDistance)
				{
					closest = _enemyData.enemy;
					closestDistance = testDistance;
				}
			}
			core.actor.targetEnemy = closest;
		}
		return true;
	}
コード例 #3
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		GameObject goalNode = null;

		//if the path has not already been made
		if (_currentPlan.plannedPath.Value == null || _currentPlan.plannedPath.Key != actionName)
		{
			KeyValuePair<string, List<GameObject>> tempPath = new KeyValuePair<string, List<GameObject>>(actionName, _currentPlan.plannedPath.Value);
			_currentPlan.plannedPath = tempPath;

			TruncOct enemyTroct= core.actor.targetEnemy.currentTrOct.GetComponent<TruncOct>();

			List<TruncOct> inLineTrocts = new List<TruncOct>();

			//List all trocts leading from enemy location
			//loop through all faces of the troct
			for (int i = 0; i < enemyTroct.Faces.Count; i++)
			{
				//if the current face has no connection, continue to the next face.
				if (enemyTroct.connections[i] != TruncOct.connectionState.Connected)
				{
					continue;
				}
				else //else it it connected and should be pushed as far as it can go outwards
				{
					//get the next troct
					TruncOct newTroct = _worldState.topology[enemyTroct.connectionObjects[i]].GetComponent<TruncOct>();

					List<TruncOct> direction = new List<TruncOct>();
					direction.Add(newTroct);

					inLineTrocts.AddRange (TroctsInDirection(direction, i, newTroct, _worldState));
				}
			}

			//find the closest one that is avaliable
			float closestDistance = float.MaxValue;
			TruncOct closestTroct;

			for (int i = 0; i < inLineTrocts.Count; i++)
			{
				float tempDist = Vector3.Distance(core.actor.currentTrOct.transform.position, inLineTrocts[i].transform.position);
				if (tempDist < closestDistance)
				{
					closestDistance = tempDist;
					closestTroct = inLineTrocts[i];

					goalNode = closestTroct.gameObject;
				}
			}
		
			//now plot a route to A* pathfind to
			_currentPlan.plotRoute(core.actor, core.actor.currentTrOct, goalNode);
		}

		//try to follow the A* path
		return ProceedAlongPath(_currentPlan);
	}
コード例 #4
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		//if we have 2 action points left, heal otherwise remove last action points and continue
		if (!core.actor.TryToRepair())
		{
			core.actor.actionPoints = 0;
			return false;
		}

		return true;
	}
コード例 #5
0
	//does this action need to be done.
	public override bool Test(GoapWorldstate _worldState)
	{
		//if there is not a target enemy
		if (core.actor.targetEnemy == null)
		{
			//the we need to target one
			return true;
		}

		//there is already a target
		return false;
	}
コード例 #6
0
ファイル: Heal.cs プロジェクト: MrMrSam/Creative-Tech-Project
	public override float calcWeight (GoapWorldstate _actorWorldState)
	{
		float totalWeight = 1 - (core.actor.health / 100f);

		//if not at full health and there are no visible enemies, it may as well heal
		if (core.actor.health != core.actor.maxHealth && _actorWorldState.enemyData.Count == 0)
		{
			baseWeight = 1f;
		}

		return totalWeight;
	}
コード例 #7
0
	//does this action need to be done.
	public override bool Test(GoapWorldstate _worldState)
	{
		GoapWorldstate worldState = core.getworldState ();

		//if enemies are in this actor's worldstate, they dont need to find enemies.
		if (worldState.enemyData.Count != 0)
		{
			return false;
		}
		else //else this does need to be done and enemies need to be found.
		{
			return true;
		}
	}
コード例 #8
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		GameObject goalNode = null;

		//if there is not currently a path, plot a course towards a random undiscovered area
		if (_currentPlan.plannedPath.Value == null)
		{
			//compile a list of all trocts concealed by the fow
			List<GameObject> undiscoveredTrocts = new List<GameObject>();
			foreach (GameObject _trOctObj in _worldState.topology)
			{
				if (_trOctObj.GetComponent<TruncOct>().inFow)
				{
					undiscoveredTrocts.Add(_trOctObj);
				}
			}

			//find the one with the largest combined distance from all allies
			float biggestDistance = 0f;
			GameObject furthestTroct;
			for (int i = 0; i < undiscoveredTrocts.Count; i++)
			{
				float totalDistance = 0f;

				for (int j = 0; j < _worldState.allies.Count; j++)
				{
					totalDistance += Vector3.Distance(undiscoveredTrocts[i].transform.position, _worldState.allies[j].currentTrOct.transform.position);
				}

				if (totalDistance > biggestDistance)
				{
					furthestTroct = undiscoveredTrocts[i];
					biggestDistance = totalDistance;

					//this will be the goal TrOct
					goalNode = furthestTroct;
				}
			}

			//plot a route using the central A* plotter through the current plan
			_currentPlan.plotRoute(core.actor, core.actor.currentTrOct, goalNode);
		}

		// attempt to follow the path that was either preexisting or was just generated
		return ProceedAlongPath(_currentPlan);
	}
コード例 #9
0
	private List<TruncOct> TroctsInDirection(List<TruncOct> _troctsInLine, int _facing, TruncOct _rootTroct, GoapWorldstate _worldState)
	{
		//see if the facing is connected
		if (_rootTroct.connections[_facing] != TruncOct.connectionState.Connected)
		{
			return _troctsInLine;
		}
		else //there is a connection
		{
			TruncOct newTroct = _worldState.topology[_rootTroct.connectionObjects[_facing]].GetComponent<TruncOct>();
			_troctsInLine.Add(newTroct);

			_troctsInLine = (TroctsInDirection(_troctsInLine, _facing, newTroct, _worldState));
		}

		return _troctsInLine;		
	}
コード例 #10
0
	//does this action need to be done?
	public override bool Test(GoapWorldstate _worldState)
	{
		//are we currently facing the enemy already?

		if (!core.actor.targetEnemy)
		{
			return true;
		}

		//get the enemy's troct
		TruncOct enemyTroct = core.actor.targetEnemy.currentTrOct.GetComponent<TruncOct>();

		//if the direction towards an enemy is the same as the direction of facing
		if ((enemyTroct.transform.position - core.actor.currentTrOct.transform.position).normalized == core.actor.transform.forward)
		{
			float distance = Vector3.Distance(enemyTroct.transform.position , core.actor.currentTrOct.transform.position);

			for (int j = 0; j < _worldState.allies.Count; j++)
			{
				TruncOct allyTroct = _worldState.allies[j].currentTrOct.GetComponent<TruncOct>();
				//check there are no allies in the way.

				//is the ally in the same direction as the enemy but closer?
				if (((allyTroct.transform.position - core.actor.currentTrOct.transform.position).normalized == core.actor.transform.forward) &&
					Vector3.Distance(allyTroct.transform.position , core.actor.currentTrOct.transform.position) < distance)
				{
					//an ally is in the way, move to a different position
					return true;
				}
				else 
				{
					//no allies in the way and enemy a head
					return false;
				}
			}
		}

		//if here is reached there are no enemies within current sight.
		return true;
	}
コード例 #11
0
	/// <summary>
	/// If the actor is facing the next troct on the path and the path is obstructed and the current actor has action points left, replan
	/// </summary>
	/// <param name="_worldState">World state.</param>
	public override bool Sense(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{

		//make a copy of the current path
		List<GameObject> path = _currentPlan.plannedPath.Value;

		//if the path is empty or we are at the end of the path, return false as no replanning has to be done as a result of the sensed state
		if (_currentPlan.plannedPath.Value == null)
		{
			return false;
		}
		else
		{
			if (_currentPlan.plannedPath.Value [0] == core.actor.currentTrOct)
			{
				_currentPlan.plannedPath.Value.RemoveAt (0);
			}
		}


		//find the next GO on the currentPath
		GameObject targetTroct = path[0];

		Vector3 towardsTarget = (targetTroct.transform.position - core.actor.currentTrOct.transform.position).normalized;

		//is this actor facing the troct?
		if (towardsTarget == core.actor.transform.forward)
		{
			//is the target troct occupied?
			if (targetTroct.GetComponent<TruncOct>().containedActor != null)
			{
				//if so, replan
				return true;
			}
		}

		return false;
	}
コード例 #12
0
	public void TakeTurn ()
	{
		worldState = UpdateWorldstate();

		//sort the goal priorities for this turn.
		GoapGoal tempGoal = SortGoals (worldState);

		//if the goal has changed, or the sensors demand it, a new plan must be formulated
		if (tempGoal != currentGoal || currentPlan == null)
		{
			currentGoal = tempGoal;

			currentPlan = FormulatePlan(currentGoal, worldState);
		}

		//loop the plan execution until all 
		while (actor.actionPoints > 0)
		{
			//process and execute the plan, setting it to be the new plan
			currentPlan = ExecutePlan (currentPlan, worldState);
		}

		return;
	}
コード例 #13
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		//SHOOT FORWARDS
		return core.actor.Shootforwards();
	}
コード例 #14
0
	public void setWorldState(GoapWorldstate _worldState)
	{
		worldState = _worldState;
	}
コード例 #15
0
	/// <summary>
	/// Updates the worldstate.
	/// </summary>
	/// <returns>The new worldstate.</returns>
	private GoapWorldstate UpdateWorldstate ()
	{
		GoapWorldstate newWorldState = new GoapWorldstate();

		newWorldState.generateWorldState (actor);

		return newWorldState;
	}
コード例 #16
0
	private GoapGoal SortGoals (GoapWorldstate _worldState)
	{
		GoapGoal newGoal = new GoapGoal();
		float highestWeight = float.MinValue,
		testWeight;

		for (int i = 0; i < goals.Count; i++)
		{
			testWeight = goals[i].calcWeight(worldState);

			if (testWeight > highestWeight)
			{
				highestWeight = testWeight;
				newGoal = goals[i];
			}
		}

		return newGoal;
	}
コード例 #17
0
	public override float calcWeight (GoapWorldstate _actorWorldState)
	{
		float totalWeight = baseWeight;

		return totalWeight;
	}
コード例 #18
0
	/// <summary>
	/// Formulates a plan from the given goal and current actor state.
	/// </summary>
	/// <returns>The plan.</returns>
	/// <param name="_goal">Goal.</param>
	/// <param name="_worldstate">Worldstate.</param>
	private GoapPlan FormulatePlan (GoapGoal _goal, GoapWorldstate _worldstate)
	{
		GoapPlan newPlan = new GoapPlan();

		newPlan.actionOrder = new List<GoapAction> ();

		//according to the goal form an initial prerequisite of what we want to do
		newPlan.goalBeingFulfilled = _goal;

		string initPrereq = _goal.initPrerequisite;

		//add the initial action onto the stack to start constructing the plan
		foreach (GoapAction _action in actionPool)
		{
			if (_action.fulfillment == initPrereq)
			{
				newPlan.actionOrder.Insert (0, _action);
				break;
			}
		}

		List<string> prerequisites = newPlan.actionOrder[0].prerequisites;

		newPlan.actionOrder = FulfillPrereqs (newPlan.actionOrder, prerequisites, _worldstate);

		return newPlan;
	}
コード例 #19
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		return false;
	}
コード例 #20
0
	calls; 						//the base function that is used to change the worldstate

	public abstract bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState);
コード例 #21
0
	//does this action need to be done.
	public override bool Test(GoapWorldstate _worldState)
	{
		TruncOct currentTroct = core.actor.currentTrOct.GetComponent<TruncOct>();

		//are we already in line with the target?

		if (!core.actor.targetEnemy)
		{
			return true;
		}

		//do any enemy directions line up with the current troct faces?
		TruncOct enemyTroct = core.actor.targetEnemy.currentTrOct.GetComponent<TruncOct>();

		foreach (Vector3 _facing in currentTroct.Faces)
		{

			if ((enemyTroct.transform.position - currentTroct.transform.position).normalized == _facing.normalized)
			{
				//they line up and so we do not need to line up a shot
				return false;
			}
		}

		return true;
	}
コード例 #22
0
	public override bool Action(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		//try to rotate towards the target enemy
		return core.actor.TryRotate(core.actor.targetEnemy.transform);
	}
コード例 #23
0
	//does this action need to be done.
	public override bool  Test(GoapWorldstate _worldState)
	{

		return false;

	}
コード例 #24
0
	private List<GoapAction> FulfillPrereqs (List<GoapAction> _currentActionList, List<string> _currentPrerequisites, GoapWorldstate _worldstate)
	{
		foreach (string _prereq in _currentPrerequisites)
		{
			//find the item to fulfill the current prereq
			foreach (GoapAction _action in actionPool)
			{
				if (_action.fulfillment == _prereq)
				{
					//if the action does not need to be done, no more need to be added, so just return the actionlist as is
					if (!_action.Test (_worldstate))
					{
						return _currentActionList;
					}
					else
					{
						_currentActionList.Insert (0, _action);

						List<string> prereqs = _action.prerequisites;

						_currentActionList = FulfillPrereqs (_currentActionList, prereqs, _worldstate);
					}
				}
			}
		}

		return _currentActionList;
	}
コード例 #25
0
	public abstract bool Sense(GoapPlan _currentPlan, GoapWorldstate _worldState);
コード例 #26
0
	//does this action need to be done.
	public override bool Test(GoapWorldstate _worldState)
	{
		//this is the end action so it always need to be attempted.
		return true;
	}
コード例 #27
0
	/// <summary>
	/// Calculates the total weight of this goal.
	/// </summary>
	/// <returns>The weight.</returns>
	/// <param name="_actorWorldState">Actor world state.</param>
	public virtual float calcWeight (GoapWorldstate _actorWorldState) {return 0f;}
コード例 #28
0
	private GoapPlan ExecutePlan(GoapPlan _currentPlan, GoapWorldstate _worldState)
	{
		bool actionSuccess = true;

		int currentPlanAction = 0;

		//try to carry out the plan until an action attempt fails (or sensors interrupt)
		while (actor.actionPoints > 0)
		{

			//test all actions up to the current int value for retroactive analysis
			for (int i = 0; i < currentPlanAction; i++)
			{
				if (_currentPlan.actionOrder[i].Test(_worldState))
				{
					currentPlanAction = i;
					break;
				}
			}


			//if the action on the top of the stack needs to be done
			if (_currentPlan.actionOrder[currentPlanAction].Test (_worldState))
			{
				//run sensors
				GoapPlan tempPlan = CheckSensors(_currentPlan, _worldState);

				//if the plans differ
				if (!ComparePlans(_currentPlan, tempPlan))
				{
					return tempPlan;
				}

				//try to carry it out and have it set the result of actionSuccess depending on a success or failure
				actionSuccess = _currentPlan.actionOrder[currentPlanAction].Action(_currentPlan, _worldState);

				if (actionSuccess) //if an action was successfully done,check if it will need to be continued (with a new worldstate)
				{
					_worldState.generateWorldState (actor);

					//if the action no longer needs to be done, pop it from the stack
					if (!_currentPlan.actionOrder[currentPlanAction].Test (_worldState))
					{
						currentPlanAction ++;
					}

					tempPlan = CheckSensors (_currentPlan, getworldState ()); //call sensors as a precaution

					if (!ComparePlans(_currentPlan, tempPlan))
					{
						return tempPlan;
					}
				}
			}
			else//move to the next operation in the plan the plan, as it doesnt need to be carried out
			{
				currentPlanAction++;
			}
		}

		//return the plan now that it has been processed and attempted
		return _currentPlan;
	}
コード例 #29
0
	public abstract bool Test(GoapWorldstate _worldState);
コード例 #30
0
	/// <summary>
	/// Calls the sensors one at a time in order to see if the plan needs changing in accordance to worldstate changes
	/// </summary>
	/// <returns>The altered goal if the sensors call for a replan</returns>
	/// <param name="">.</param>
	private GoapPlan CheckSensors (GoapPlan _currentPlan, GoapWorldstate _worldState)
	{

		foreach (GoapSensor _sensor in sensors)
		{
			//if a replan is needed according to the current sensor
			if (_sensor.Sense(_currentPlan, _worldState))
			{
				//resort goals, and from this formulate a new plan
				return FormulatePlan(SortGoals(_worldState), _worldState);
			}
		}
		//if all is fine, return the plan back as it was, it is fine.
		return _currentPlan;
	}