[Gcblue-commits] gcb_wx/src/ai Blackboard.cpp, 1.3, 1.4 Brain.cpp, 1.13, 1.14 tcCAPMission.cpp, 1.2, 1.3 tcMission.cpp, 1.2, 1.3 tcMissionManager.cpp, 1.2, 1.3

[Dewitt C. <ddc...@us...>]

Update of /cvsroot/gcblue/gcb_wx/src/ai
In directory sc8-pr-cvs2.sourceforge.net:/tmp/cvs-serv8446/src/ai

Modified Files:
	Blackboard.cpp Brain.cpp tcCAPMission.cpp tcMission.cpp 
	tcMissionManager.cpp 
Log Message:


Index: Blackboard.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/ai/Blackboard.cpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -C2 -d -r1.3 -r1.4
*** Blackboard.cpp	12 Dec 2005 02:37:01 -0000	1.3
--- Blackboard.cpp	24 Oct 2006 01:34:01 -0000	1.4
***************
*** 29,32 ****
--- 29,34 ----
  #include "ai/BlackboardItem.h"
  #include "tcScenarioLogger.h"
+ #include "common/tcStream.h"
+ #include "common/tcObjStream.h"
  
  #ifdef _DEBUG
***************
*** 37,40 ****
--- 39,164 ----
  
  
+ bool Blackboard::multiplayerClientMode = false;
+ 
+ bool Blackboard::GetMultiplayerClientMode()
+ {
+ 	return multiplayerClientMode;
+ }
+ 
+ void Blackboard::SetMultiplayerClientMode(bool state)
+ {
+ 	multiplayerClientMode = state;
+ }
+ 
+ 
+ 
+ /**
+ * Loads state from command stream
+ */
+ tcCommandStream& Blackboard::operator<<(tcCommandStream& stream)
+ {
+ 	unsigned char nItems;
+ 	stream >> nItems;
+ 
+ 	if (multiplayerClientMode)
+ 	{
+ 		content.clear();
+ 	}
+ 
+ 	// add items to blackboard
+ 	for (unsigned char n=0; n<nItems; n++)
+ 	{
+ 		bool valid;
+ 		stream >> valid;
+ 		if (valid)
+ 		{
+ 			std::string key;
+ 			std::string message;
+ 			float priority;
+ 
+ 			stream >> key;
+ 			stream >> message;
+ 			stream >> priority;
+ 
+ 			if (multiplayerClientMode)
+ 			{
+ 				//fprintf(stdout, "CLIENT BB wrote (%s, %s)\n", key.c_str(), message.c_str());
+ 				content[key] = BlackboardItem(0, priority, message);
+ 			}
+ 			else
+ 			{
+ 				//fprintf(stdout, "SERVER BB wrote (%s, %s)\n", key.c_str(), message.c_str());
+ 				Write(key, 0, priority, message);
+ 			}
+ 		}
+ 	}
+ 
+     return stream;
+ }
+ 
+ /**
+ * Saves state to command stream
+ * Only saves top level (author 0) blackboard items
+ */
+ tcCommandStream& Blackboard::operator>>(tcCommandStream& stream)
+ {
+ 	std::map<std::string, BlackboardItem>* map = 0;
+ 
+ 	if (multiplayerClientMode)
+ 	{
+ 		map = &clientContent;
+ 	}
+ 	else
+ 	{
+ 		map = &content;
+ 	}
+ 
+ 	unsigned char nItems = (unsigned char)map->size();
+ 	wxASSERT(map->size() <= 255);
+ 
+ 	stream << nItems;
+ 
+ 	// iterate through clientContent
+     std::map<std::string, BlackboardItem>::iterator iter = map->begin();
+     std::map<std::string, BlackboardItem>::iterator& done = map->end(); 
+     for (;iter != done; ++iter)
+     {
+ 		BlackboardItem item = iter->second;
+ 		
+ 		// only send items written at top level (author = 0)
+ 		bool sendItem = (item.author == 0);
+ 		stream << sendItem;
+ 
+ 		if (sendItem)
+ 		{
+ 			stream << iter->first;
+ 			stream << item.message;
+ 			float priority = float(item.priority);
+ 			stream << priority;
+ 
+ 			//fprintf(stdout, "BB sent (%s, %s)\n", iter->first.c_str(), item.message.c_str());
+ 		}
+ 		else
+ 		{
+ 			//fprintf(stdout, "BB skipped (%s, %s, %d)\n", iter->first.c_str(), item.message.c_str(), item.author);
+ 		}
+     }
+ 
+     return stream;
+ }
+ 
+ void Blackboard::ClearNewCommand()
+ {
+ 	clientContent.clear();
+ 	hasNewCommand = false;
+ }
+ 
+ bool Blackboard::HasNewCommand() const
+ {
+ 	return hasNewCommand;
+ }
+ 
+ 
+ 
  
  void Blackboard::Erase(const std::string& key, double priority)
***************
*** 204,208 ****
          content[key] = item;
      }
!     
      return true;
  }
--- 328,338 ----
          content[key] = item;
      }
! 
!     if (multiplayerClientMode)
! 	{
! 		clientContent[key] = item;
! 	}
! 	hasNewCommand = true;
! 
      return true;
  }
***************
*** 232,239 ****
--- 362,376 ----
      }
      
+ 	if (multiplayerClientMode)
+ 	{
+ 		clientContent[key] = BlackboardItem(author, priority, message);
+ 	}
+ 	hasNewCommand = true;
+ 
      return true;
  }
  
  Blackboard::Blackboard()
+ : hasNewCommand(false)
  {
  }

Index: Brain.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/ai/Brain.cpp,v
retrieving revision 1.13
retrieving revision 1.14
diff -C2 -d -r1.13 -r1.14
*** Brain.cpp	27 Aug 2006 21:28:54 -0000	1.13
--- Brain.cpp	24 Oct 2006 01:34:01 -0000	1.14
***************
*** 62,90 ****
  tcCommandStream& Brain::operator<<(tcCommandStream& stream)
  {
! 	wxASSERT(platform->IsClientMode());
  
! 	unsigned char nTasks;
! 	stream >> nTasks;
  
! 	RemoveAllTasks();
  
! 	for (unsigned char n=0; n<nTasks; n++)
! 	{
! 		std::string taskName;
! 		stream >> taskName;
  
! 		float priority;
! 		stream >> priority;
  
! 		int attributes;
! 		stream >> attributes;
  
! 		AddTask(taskName, (double)priority, attributes);
! 	}
  
! 	// update waypoints if nav task exists
! 	if (ai::Nav* nav = GetNavTask())
  	{
! 		nav->operator<<(stream);
  	}
  
--- 62,117 ----
  tcCommandStream& Brain::operator<<(tcCommandStream& stream)
  {
! 	// client update
! 	if (platform->IsClientMode())
! 	{
! 		unsigned char nTasks;
! 		stream >> nTasks;
  
! 		RemoveAllTasks();
  
! 		for (unsigned char n=0; n<nTasks; n++)
! 		{
! 			std::string taskName;
! 			stream >> taskName;
  
! 			float priority;
! 			stream >> priority;
  
! 			int attributes;
! 			stream >> attributes;
  
! 			AddTaskDirectly(taskName, (double)priority, attributes);
! 		}
  
! 		// update waypoints if nav task exists
! 		if (ai::Nav* nav = GetNavTask())
! 		{
! 			nav->operator<<(stream);
! 		}
  
! 		//fprintf(stdout, "CLIENT loading board cmds (%s)\n", platform->mzUnit.c_str());
! 		board.operator<<(stream);
! 	}
! 	// server update
! 	else
  	{
! 		clientTasks.clear();
! 
! 		unsigned char nTasks;
! 		stream >> nTasks;
! 
! 		for (unsigned char n=0; n<nTasks; n++)
! 		{
! 			AddTaskCommand cmd;
! 
! 			stream >> cmd.taskName;
! 			stream >> cmd.priority;
! 			stream >> cmd.attributes;
! 			
! 			clientTasks.push_back(cmd); // queue for add in next update
! 		}
! 
! 		//fprintf(stdout, "SERVER loading board cmds (%s)\n", platform->mzUnit.c_str());
! 		board.operator<<(stream);
  	}
  
***************
*** 97,126 ****
  tcCommandStream& Brain::operator>>(tcCommandStream& stream)
  {
! 	wxASSERT(!platform->IsClientMode());
  
! 	unsigned char nTasks = taskMap.size();
! 	stream << nTasks;
  
! 	// iterate through task map and update tasks
!     std::map<std::string, Task*>::iterator iter = taskMap.begin();
!     std::map<std::string, Task*>::iterator& done = taskMap.end(); 
!     for (;iter != done; ++iter)
!     {
! 		Task* task = iter->second;
!         wxASSERT(task);
  
! 		stream << task->GetTaskName();
  
! 		float priority = (float)task->GetPriority();
! 		stream << priority;
  
! 		int attributes = task->GetAttributes();
! 		stream << attributes;
!     }
  
! 	// update waypoints if nav task exists
! 	if (ai::Nav* nav = GetNavTask())
  	{
! 		nav->operator>>(stream);
  	}
  
--- 124,174 ----
  tcCommandStream& Brain::operator>>(tcCommandStream& stream)
  {
! 	if (!platform->IsClientMode())
! 	{
! 		unsigned char nTasks = taskMap.size();
! 		stream << nTasks;
  
! 		// iterate through task map and update tasks
! 		std::map<std::string, Task*>::iterator iter = taskMap.begin();
! 		std::map<std::string, Task*>::iterator& done = taskMap.end(); 
! 		for (;iter != done; ++iter)
! 		{
! 			Task* task = iter->second;
! 			wxASSERT(task);
  
! 			stream << task->GetTaskName();
  
! 			float priority = (float)task->GetPriority();
! 			stream << priority;
  
! 			int attributes = task->GetAttributes();
! 			stream << attributes;
! 		}
  
! 		// update waypoints if nav task exists
! 		if (ai::Nav* nav = GetNavTask())
! 		{
! 			nav->operator>>(stream);
! 		}
  
! 		//fprintf(stdout, "SERVER writing board cmds (%s)\n", platform->mzUnit.c_str());
! 		board.operator>>(stream);
! 	}
! 	else
  	{
! 		unsigned char nTasks = (unsigned char)clientTasks.size();
! 		wxASSERT(clientTasks.size() <= 255);
! 
! 		stream << nTasks;
! 		for (unsigned char n=0; n<nTasks; n++)
! 		{
! 			stream << clientTasks[n].taskName;
! 			stream << clientTasks[n].priority;
! 			stream << clientTasks[n].attributes;
! 		}
! 
! 
! 		//fprintf(stdout, "CLIENT writing board cmds (%s)\n", platform->mzUnit.c_str());
! 		board.operator>>(stream);
  	}
  
***************
*** 132,140 ****
  	hasNewCommand = false;
  
  }
  
  bool Brain::HasNewCommand() const
  {
! 	return hasNewCommand;
  }
  
--- 180,194 ----
  	hasNewCommand = false;
  
+ 	if (platform->IsClientMode())
+ 	{
+ 		clientTasks.clear();
+ 	}
+ 
+ 	board.ClearNewCommand();
  }
  
  bool Brain::HasNewCommand() const
  {
! 	return hasNewCommand || board.HasNewCommand();
  }
  
***************
*** 268,273 ****
--- 322,353 ----
  }
  
+ /**
+ * Version that pushes task to command list and marks new command for multiplayer
+ */
  void Brain::AddTask(const std::string& taskName, double priority_, int attributes_)
  {
+ 	if (platform->IsClientMode())
+ 	{
+ 		AddTaskCommand cmd;
+ 		cmd.taskName = taskName;
+ 		cmd.priority = float(priority_);
+ 		cmd.attributes = attributes_;
+ 
+ 		clientTasks.push_back(cmd);
+ 
+ 		SetNewCommand();
+ 		return;
+ 	}
+ 
+ 	hasNewCommand = true;
+ 
+ 	AddTaskDirectly(taskName, priority_, attributes_);
+ }
+ 
+ /**
+ * Adds task without any multiplayer operations
+ */
+ void Brain::AddTaskDirectly(const std::string& taskName, double priority_, int attributes_)
+ {
      // if task already exists, update priority and attributes
      std::map<std::string, Task*>::iterator tm_iter = taskMap.find(taskName);
***************
*** 281,286 ****
      }
  
- 	hasNewCommand = true;
- 
      // check taskNameMap for C++ task, otherwise assume python script task
      std::map<std::string, int>::iterator iter = taskNameLookup.find(taskName);
--- 361,364 ----
***************
*** 398,401 ****
--- 476,490 ----
      RemovePending();
      
+ 	// in multiplayer, add pending client tasks
+ 	size_t nPendingClientTasks = clientTasks.size();
+ 	if (nPendingClientTasks > 0)
+ 	{
+ 		for (size_t n=0; n<nPendingClientTasks; n++)
+ 		{
+ 			AddTask(clientTasks[n].taskName, clientTasks[n].priority, clientTasks[n].attributes);
+ 		}
+ 		clientTasks.clear();
+ 	}
+ 
      updating = true;
      

Index: tcMission.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/ai/tcMission.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** tcMission.cpp	1 Oct 2006 21:07:40 -0000	1.2
--- tcMission.cpp	24 Oct 2006 01:34:02 -0000	1.3
***************
*** 33,36 ****
--- 33,38 ----
  #endif
  
+ using namespace ai;
+ 
  unsigned long tcMission::nextId = 1;
  
***************
*** 43,47 ****
  	for (size_t n=0; n<missionAircraft.size(); n++)
  	{
! 		if (missionManager->GetAircraft(missionAircraft[n]) != 0)
  		{
  			return false;
--- 45,49 ----
  	for (size_t n=0; n<missionAircraft.size(); n++)
  	{
! 		if (missionManager->GetAircraft(missionAircraft[n].id) != 0)
  		{
  			return false;
***************
*** 65,69 ****
  }
  
! const std::vector<long>& tcMission::GetMissionAircraft() const
  {
  	return missionAircraft;
--- 67,71 ----
  }
  
! const std::vector<MissionAircraftInfo>& tcMission::GetMissionAircraft() const
  {
  	return missionAircraft;
***************
*** 86,89 ****
--- 88,92 ----
  	stage = src.stage;
  	missionAircraft = src.missionAircraft;
+ 	lastUpdate = src.lastUpdate;
  
  	return *this;
***************
*** 95,99 ****
    id(src.id),
    stage(src.stage),
!   missionAircraft(src.missionAircraft)
  {
  }
--- 98,103 ----
    id(src.id),
    stage(src.stage),
!   missionAircraft(src.missionAircraft),
!   lastUpdate(src.lastUpdate)
  {
  }
***************
*** 102,106 ****
  : missionManager(0),
    id(nextId++),
!   stage("init")
  {
  
--- 106,111 ----
  : missionManager(0),
    id(nextId++),
!   stage("init"),
!   lastUpdate(0)
  {
  

Index: tcCAPMission.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/ai/tcCAPMission.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** tcCAPMission.cpp	1 Oct 2006 21:07:40 -0000	1.2
--- tcCAPMission.cpp	24 Oct 2006 01:34:01 -0000	1.3
***************
*** 28,33 ****
--- 28,37 ----
  #include "ai/tcCAPMission.h"
  #include "ai/tcMissionManager.h"
+ #include "ai/Brain.h"
+ #include "ai/BlackboardInterface.h"
  #include "tcWeaponDBObject.h"
  #include "tcAirObject.h"
+ #include "tcPlatformObject.h"
+ #include "tcSimState.h"
  
  #ifdef _DEBUG
***************
*** 35,38 ****
--- 39,79 ----
  #endif
  
+ using namespace ai;
+ 
+ 
+ void tcCAPMission::CalculatePatrolOffset()
+ {
+ 	tcGameObject* parent = missionManager->GetFlightportParent();
+ 	if (parent == 0)
+ 	{
+ 		wxASSERT(false);
+ 		return;
+ 	}
+ 
+ 	range_km = parent->mcKin.RangeToKm(station.x, station.y);
+ 	az_deg = C_180OVERPI * parent->mcKin.HeadingToGeoRad(station.x, station.y);
+ }
+ 
+ 
+ /**
+ * If no mission aircraft are in flight with an active "CAP" task,
+ * then restart the mission
+ */
+ void tcCAPMission::MonitorMissionInProgress()
+ {
+ 	tcSimState* simState = tcSimState::Get();
+ 
+ 	bool anyInFlight = false;
+ 	for (size_t n=0; (n<missionAircraft.size()) && (!anyInFlight); n++)
+ 	{
+ 		tcPlatformObject* obj = dynamic_cast<tcPlatformObject*>(simState->GetObjectByName(missionAircraft[n].name));
+ 		if (obj != 0)
+ 		{
+ 			if (obj->GetBrain()->TaskExists("CAP")) anyInFlight = true;
+ 		}
+ 	}
+ 
+ 	if (!anyInFlight) stage = "init"; // launch another patrol
+ }
  
  void tcCAPMission::SetStation(float lon_rad, float lat_rad)
***************
*** 52,56 ****
  	// step 3, create tasks for mission on each aircraft
  	// step 4, order launch of aircraft
! 	// step 5, when all aircraft launched, delete mission
  
  
--- 93,98 ----
  	// step 3, create tasks for mission on each aircraft
  	// step 4, order launch of aircraft
! 	// step 5, when all aircraft launched, wait until aircraft landed
! 	// step 6, start over (recurring mission)
  
  
***************
*** 58,63 ****
  	{
  		// query available aircraft and take first from list
! 		std::vector<long> candidates = missionManager->GetAvailableAircraft(AIR_TARGET);
  		missionAircraft.clear();
  		for (size_t n=0; (n<quantity)&&(n<candidates.size()); n++)
  		{
--- 100,106 ----
  	{
  		// query available aircraft and take first from list
! 		std::vector<MissionAircraftInfo> candidates = missionManager->GetAvailableAircraft(AIR_TARGET);
  		missionAircraft.clear();
+ 
  		for (size_t n=0; (n<quantity)&&(n<candidates.size()); n++)
  		{
***************
*** 66,69 ****
--- 109,114 ----
  		if (missionAircraft.size() == 0) return; // none available
  
+ 		CalculatePatrolOffset();
+ 
  		stage = "outfit";
  	}
***************
*** 74,78 ****
  		for (size_t n=0; n<missionAircraft.size(); n++)
  		{
! 			tcAirObject* aircraft = missionManager->GetAircraft(missionAircraft[n]);
  			if (aircraft != 0)
  			{
--- 119,123 ----
  		for (size_t n=0; n<missionAircraft.size(); n++)
  		{
! 			tcAirObject* aircraft = missionManager->GetAircraft(missionAircraft[n].id);
  			if (aircraft != 0)
  			{
***************
*** 88,91 ****
--- 133,158 ----
  	else if (stage == "task")
  	{
+ 		wxString s;
+ 		for (size_t n=0; n<missionAircraft.size(); n++)
+ 		{
+ 			tcAirObject* aircraft = missionManager->GetAircraft(missionAircraft[n].id);
+ 			if (aircraft != 0)
+ 			{
+ 				ai::Brain* brain = aircraft->GetBrain();
+ 				brain->AddTask("CAP", 2.0);
+ 				brain->AddTask("EngageAll", 3.0);
+ 				ai::BlackboardInterface bb = brain->GetBlackboardInterface();
+ 				
+ 				s.Printf("%.1f", range_km);
+ 				bb.Write("PatrolRange_km", s.c_str());
+ 
+ 				s.Printf("%.1f", az_deg);
+ 				bb.Write("PatrolAzimuth_deg", s.c_str());
+ 
+ 				s.Printf("%d", missionManager->GetFlightportParentId());
+ 				bb.Write("AnchorPlatformId", s.c_str());
+ 			}
+ 		}
+ 
  		stage = "launch";
  	}
***************
*** 94,110 ****
  		for (size_t n=0; n<missionAircraft.size(); n++)
  		{
! 			missionManager->LaunchAircraft(missionAircraft[n]);
  		}
! 		stage = "finish";
  	}
! 	else if (stage == "finish")
  	{
  		// verify all aircraft have launched and end mission
  		if (AllMissionAircraftDeparted())
  		{
! 			EndMission();
  		}
  	}
  
  }
  
--- 161,187 ----
  		for (size_t n=0; n<missionAircraft.size(); n++)
  		{
! 			missionManager->LaunchAircraft(missionAircraft[n].id);
  		}
! 		stage = "waitlaunch";
  	}
! 	else if (stage == "waitlaunch")
  	{
  		// verify all aircraft have launched and end mission
  		if (AllMissionAircraftDeparted())
  		{
! 			stage = "waitland";
  		}
  	}
  
+ 	// do following at slower update
+ 	double dt = t - lastUpdate;
+ 	if (dt < 20.0) return;
+ 	lastUpdate = t;
+ 
+ 	if (stage == "waitland")
+ 	{
+ 		MonitorMissionInProgress();
+ 	}
+ 
  }
  
***************
*** 122,126 ****
  
  tcCAPMission::tcCAPMission(const tcCAPMission& src)
! : tcMission(src)
  {
  }
--- 199,207 ----
  
  tcCAPMission::tcCAPMission(const tcCAPMission& src)
! : tcMission(src),
!   quantity(src.quantity),
!   range_km(src.range_km),
!   az_deg(src.az_deg),
!   station(src.station)
  {
  }
***************
*** 128,132 ****
  tcCAPMission::tcCAPMission()
  : tcMission(),
!   quantity(2)
  {
  
--- 209,215 ----
  tcCAPMission::tcCAPMission()
  : tcMission(),
!   quantity(2),
!   range_km(80),
!   az_deg(225)
  {
  

Index: tcMissionManager.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/ai/tcMissionManager.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** tcMissionManager.cpp	1 Oct 2006 21:07:40 -0000	1.2
--- tcMissionManager.cpp	24 Oct 2006 01:34:02 -0000	1.3
***************
*** 36,40 ****
  #endif
  
! 
  
  
--- 36,40 ----
  #endif
  
! using namespace ai;
  
  
***************
*** 55,61 ****
  }
  
! std::vector<long>& tcMissionManager::GetAvailableAircraft(int targetMask)
  {
! 	static std::vector<long> availableAircraft;
  	availableAircraft.clear();
  
--- 55,61 ----
  }
  
! std::vector<MissionAircraftInfo>& tcMissionManager::GetAvailableAircraft(int targetMask)
  {
! 	static std::vector<MissionAircraftInfo> availableAircraft;
  	availableAircraft.clear();
  
***************
*** 75,79 ****
  			if ((platform != 0) && (platform->IsCapableVsTargetType(targetMask)))
  			{
! 				availableAircraft.push_back(id);
  			}
  		}
--- 75,82 ----
  			if ((platform != 0) && (platform->IsCapableVsTargetType(targetMask)))
  			{
! 				MissionAircraftInfo info;
! 				info.id = id;
! 				info.name = airState->obj->mzUnit.c_str();
! 				availableAircraft.push_back(info);
  			}
  		}
***************
*** 85,88 ****
--- 88,100 ----
  }
  
+ tcGameObject* tcMissionManager::GetFlightportParent()
+ {
+ 	return flightPort->parent;
+ }
+ 
+ long tcMissionManager::GetFlightportParentId() const
+ {
+ 	return flightPort->parent->mnID;
+ }
  
  bool tcMissionManager::IsAircraftReserved(long id) const
***************
*** 152,161 ****
  	for (size_t n=0; n<missions.size(); n++)
  	{
! 		const std::vector<long>& missionAircraft = missions[n]->GetMissionAircraft();
  		unsigned int missionId = missions[n]->GetId();
  		
  		for (size_t k=0; k<missionAircraft.size(); k++)
  		{
! 			reserved[missionAircraft[k]] = missionId;
  		}
  	}
--- 164,173 ----
  	for (size_t n=0; n<missions.size(); n++)
  	{
! 		const std::vector<MissionAircraftInfo>& missionAircraft = missions[n]->GetMissionAircraft();
  		unsigned int missionId = missions[n]->GetId();
  		
  		for (size_t k=0; k<missionAircraft.size(); k++)
  		{
! 			reserved[missionAircraft[k].id] = missionId;
  		}
  	}