- Added Dealtar's and Zilpin's Airport Externalization

- Needed GameDir files are already committet to SVN GameDir git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@2759 3b4a5df2-a311-0410-b5c6-a8a6f20db521
2026-08-12 14:10:23 +02:00 · 2009-04-21 20:27:56 +00:00
parent dffb0fc7fe
commit 598709f33d
21 changed files with 1893 additions and 40 deletions
@@ -0,0 +1,730 @@
+#include "SaveLoadMap.h"
+#include "Structure Wrap.h"
+#include "Tactical Save.h"
+#include "postalservice.h"
+#include "strategic.h"
+#include "strategicmap.h"
+#include "random.h"
+#include "game clock.h"
+#include <list>
+#include <string>
+#include <iostream>
+
+using namespace std;
+
+/************************************************************************************/
+/* New shipping system															    */
+/* ===================																*/
+/*																					*/
+/*	Old C-functions used:															*/
+/*	- GridNoInVisibleWorldTile()													*/
+/*	- SetOpenableStructureToClosed()												*/
+/*	- ChangeStatusOfOpenableStructInUnloadedSector()								*/
+/*	- CreateItem()																	*/
+/*	- CreateItems()																	*/
+/*	- AddItemToPool()																*/
+/*	- AddItemsToUnLoadedSector()													*/
+/*	- Random()																		*/
+/*	- AddFutureDayStrategicEvent()													*/
+/*																					*/
+/*	Old defines/macros:																*/
+/*	- CALCULATE_STRATEGIC_INDEX()													*/
+/*	- Assert() (for debugging)														*/
+/*																					*/
+/*	Old structs:																	*/
+/*	- OBJECTTYPE																	*/
+/*																					*/
+/*	Old globals:																	*/
+/*	- StrategicMapElement StrategicMap[]											*/
+/************************************************************************************/
+
+extern StrategicMapElement StrategicMap[];
+
+/////////////////////////////////////////////////////
+// CShipmentManipulator member implementation
+/////////////////////////////////////////////////////
+CShipmentManipulator::CShipmentManipulator(PCPostalService Owner, PShipmentStruct Shipment)
+{
+	this->_Shipment = Shipment;
+	this->_fContinueCallbackChain = TRUE;
+	this->_PostalService = Owner;
+}
+
+INT16 CShipmentManipulator::GetSenderID(void)
+{
+	return _Shipment->sSenderID;
+}
+
+RefToDestinationStruct CShipmentManipulator::GetDestination(void) const
+{
+	return *_Shipment->pDestination;
+}
+
+void CShipmentManipulator::ContinueCallbackChain(BOOLEAN fContinue)
+{
+	_fContinueCallbackChain = fContinue;
+}
+
+void CShipmentManipulator::CancelDelivery(void)
+{
+	_Shipment->ShipmentStatus = SHIPMENT_CANCEL_DELIVERY;
+}
+
+//////////////////////////////////////////
+// CPostalService member implementation
+/////////////////////////////////////////
+
+DestinationList CPostalService::_Destinations;
+vector<BOOLEAN> CPostalService::_UsedDestinationIDList;
+OBJECTTYPE	CPostalService::tempObject;
+
+CPostalService::CPostalService()
+{
+}
+
+UINT16 CPostalService::CreateNewShipment(UINT16 usDestinationID, UINT8  ubDeliveryMethodIndex, INT16 sSenderID)
+{
+	if(	usDestinationID > _UsedDestinationIDList.size() ||
+		!_UsedDestinationIDList[usDestinationID] ||
+		ubDeliveryMethodIndex > _DeliveryMethods.size() )
+	{
+		Assert(0);
+		return 0;
+	}
+
+	_Destinations.sort(DESTINATION_LIST_ASCENDING);
+	RefToDestinationListIterator dli = _Destinations.begin();
+	
+	while(DESTINATION(dli).usID != usDestinationID)
+	{
+		if(dli == _Destinations.end())
+		{
+			Assert(0);
+			return 0;
+		}
+		dli++;
+	}
+
+	UINT16 usNewID = 1;
+	if(_UsedShipmentIDList.empty())
+	{
+		_UsedShipmentIDList.push_back(FALSE);
+		_UsedShipmentIDList.push_back(TRUE);
+	}
+	else
+	{
+		while(1)
+		{
+			if(usNewID == _UsedShipmentIDList.size() - 1)	// All IDs assigned, add a new one
+			{
+				usNewID++;
+				_UsedShipmentIDList.push_back(TRUE);
+				break;
+			}
+
+			if(!_UsedShipmentIDList[usNewID])	// Found an ID that is not assigned
+			{
+				_UsedShipmentIDList[usNewID] = TRUE;
+				break;	
+			}
+
+			usNewID++;
+		}
+	}
+
+	ShipmentStruct shs;
+	shs.usID			= usNewID;
+	shs.pDestination	= &(DESTINATION(dli));
+	shs.pDestinationDeliveryInfo = &(_DeliveryMethods[ubDeliveryMethodIndex].pDestinationDeliveryInfos->at(DESTINATION(dli).usID));
+	shs.sSenderID		= sSenderID;
+	shs.ShipmentStatus	= SHIPMENT_STATIONARY;
+	shs.uiOrderDate		= GetWorldDay();
+
+	_Shipments.push_back(shs);
+
+	return usNewID;
+}
+
+BOOLEAN CPostalService::AddPackageToShipment(UINT16 usShipmentID, UINT16 usItemIndex, UINT8 ubNumber, INT8 bItemQuality)
+{
+	if(	usShipmentID > _UsedShipmentIDList.size() ||
+		!_UsedShipmentIDList[usShipmentID])
+	{
+		Assert(0);
+		return FALSE;
+	}
+
+	_Shipments.sort(SHIPMENT_LIST_ASCENDING);
+	RefToShipmentListIterator sli = _Shipments.begin();
+
+	while(SHIPMENT(sli).usID != usShipmentID)
+	{
+		if(sli == _Shipments.end())
+		{
+			Assert(0);
+			return FALSE;
+		}
+		sli++;
+	}
+
+	ShipmentPackageStruct sps;
+	sps.usItemIndex = usItemIndex;
+	sps.ubNumber = ubNumber;
+	sps.bItemQuality = bItemQuality;
+
+	SHIPMENT(sli).ShipmentPackages.push_back(sps);
+
+	return TRUE;
+}
+
+BOOLEAN CPostalService::SendShipment(UINT16 usShipmentID)
+{
+	if( usShipmentID > _UsedShipmentIDList.size() ||
+		!_UsedShipmentIDList[usShipmentID])
+	{
+		Assert(0);
+		return FALSE;
+	}
+
+	RefToShipmentListIterator sli = _Shipments.begin();
+
+	while(SHIPMENT(sli).usID != usShipmentID)
+	{
+		if(sli == _Shipments.end())
+		{
+			Assert(0);
+			return FALSE;
+		}
+		sli++;
+	}
+
+	SHIPMENT(sli).ShipmentStatus = SHIPMENT_INTRANSIT;
+		
+	AddFutureDayStrategicEvent( EVENT_POSTAL_SERVICE_SHIPMENT, (8 + Random(4) ) * 60, usShipmentID, 
+								SHIPMENT(sli).pDestinationDeliveryInfo->bDaysAhead);
+	return TRUE;
+}
+
+BOOLEAN CPostalService::DeliverShipment(UINT16 usShipmentID)
+{
+	if(	usShipmentID > _UsedShipmentIDList.size() ||
+		!_UsedShipmentIDList[usShipmentID])
+	{
+		Assert(0);
+		return FALSE;
+	}
+
+	RefToShipmentListIterator sli = _Shipments.begin();
+
+	while(SHIPMENT(sli).usID != usShipmentID)
+	{
+		if(sli == _Shipments.end())
+		{
+			Assert(0);
+			return FALSE;
+		}
+		sli++;
+	}
+
+	if(SHIPMENT(sli).ShipmentStatus == SHIPMENT_STATIONARY)
+	{
+		return FALSE;
+	}
+	
+	PCShipmentManipulator ShipmentManipulator = new CShipmentManipulator(this, &SHIPMENT(sli));
+
+	// Delivery callback code goes here
+	if(_DeliveryCallbacks[0].DeliveryCallbackFunc)
+	{
+		_DeliveryCallbacks[0].DeliveryCallbackFunc(*ShipmentManipulator);
+	}
+
+	if(ShipmentManipulator->_fContinueCallbackChain)
+	{
+		if( SHIPMENT(sli).sSenderID + 2 <= (INT16)_DeliveryCallbacks.size() &&
+			_DeliveryCallbacks[SHIPMENT(sli).sSenderID + 1].DeliveryCallbackFunc)
+		{
+			_DeliveryCallbacks[SHIPMENT(sli).sSenderID + 1].DeliveryCallbackFunc(*ShipmentManipulator);
+		}
+	}
+	
+
+	if(SHIPMENT(sli).ShipmentStatus == SHIPMENT_CANCEL_DELIVERY)
+	{
+		SHIPMENT(sli).ShipmentStatus = SHIPMENT_STATIONARY;
+		return FALSE;
+	}
+
+
+	RefToShipmentStruct shs = SHIPMENT(sli);
+
+	if( StrategicMap[ CALCULATE_STRATEGIC_INDEX( shs.pDestination->ubMapX, shs.pDestination->ubMapY ) ].fEnemyControlled )
+	{
+		return FALSE;
+	}
+
+	if( (shs.pDestination->ubMapX > 0) && 
+		(shs.pDestination->ubMapX < MAP_WORLD_X - 1) &&
+		(shs.pDestination->ubMapY > 0) && 
+		(shs.pDestination->ubMapY < MAP_WORLD_Y - 1) && 
+		GridNoOnVisibleWorldTile(shs.pDestination->sGridNo) )
+	{
+		BOOLEAN fSectorLoaded = ( gWorldSectorX == shs.pDestination->ubMapX ) && 
+								( gWorldSectorY == shs.pDestination->ubMapY ) && 
+								( gbWorldSectorZ == shs.pDestination->ubMapZ);
+
+		if(fSectorLoaded)
+		{
+			SetOpenableStructureToClosed( shs.pDestination->sGridNo, 0 );
+		}
+		else
+		{
+			ChangeStatusOfOpenableStructInUnloadedSector(	shs.pDestination->ubMapX, shs.pDestination->ubMapY, 
+															shs.pDestination->ubMapZ, shs.pDestination->sGridNo, FALSE );
+		}
+
+		UINT16 usNumberOfItems=0;
+		for(int i = 0; i < (int)shs.ShipmentPackages.size(); i++)
+		{
+			usNumberOfItems += shs.ShipmentPackages[i].ubNumber;
+		}
+
+		OBJECTTYPE *pObject;
+		if(!fSectorLoaded)
+		{
+			pObject = new OBJECTTYPE[usNumberOfItems];
+
+			if(!pObject)
+			{
+				Assert(0);
+				return FALSE;
+			}
+		}
+
+		UINT		uiCount=0;
+		UINT8		ubItemsDelivered, ubTempNumItems;
+		UINT16		usItem;
+		
+		for(int i=0; i < (int)shs.ShipmentPackages.size(); i++)
+		{
+			ubItemsDelivered = shs.ShipmentPackages[i].ubNumber;
+			usItem = shs.ShipmentPackages[i].usItemIndex;
+
+			CreateItem(usItem, 100, &tempObject);
+
+			while ( ubItemsDelivered )
+			{
+				//ubTempNumItems = __min( ubItemsDelivered, ItemSlotLimit(usItem, BIGPOCK1POS) );
+				ubTempNumItems = __min( ubItemsDelivered, ItemSlotLimit(&tempObject, BIGPOCK1POS) );
+				CreateItems( usItem, shs.ShipmentPackages[i].bItemQuality, ubTempNumItems, &tempObject );
+
+				if( fSectorLoaded )
+				{
+					AddItemToPool( shs.pDestination->sGridNo, &tempObject, -1, 0, 0, 0 );
+				}
+				else
+				{
+					pObject[ uiCount ] = tempObject;
+					uiCount++;
+				}
+
+				ubItemsDelivered -= ubTempNumItems;
+			}
+		}
+
+		if( !fSectorLoaded )
+		{
+			if( !AddItemsToUnLoadedSector(	shs.pDestination->ubMapX, shs.pDestination->ubMapY, 
+				shs.pDestination->ubMapZ, shs.pDestination->sGridNo, uiCount, pObject, 0, 0, 0, -1, FALSE ) )
+			{
+				Assert( 0 );
+			}
+			delete[]( pObject );
+			pObject = NULL;
+		}
+
+		shs.ShipmentPackages.clear();
+		shs.pDestination = NULL;
+		shs.pDestinationDeliveryInfo = NULL;
+		shs.ShipmentStatus = SHIPMENT_STATIONARY;
+		_UsedShipmentIDList[usShipmentID] = FALSE;
+
+		_Shipments.erase(sli);
+
+		return TRUE;
+	}
+	else
+		Assert(0);
+
+	return FALSE;
+}
+
+BOOLEAN CPostalService::RegisterDeliveryCallback(INT16 sSenderID, PtrToDeliveryCallbackFunc DeliveryCallbackFunc)
+{
+	if(sSenderID < - 1 || !DeliveryCallbackFunc)
+	{
+		Assert(0);
+		return 0;
+	}
+
+	DeliveryCallbackDataStruct dcd;
+	
+	dcd.sSenderID=-1;
+	dcd.DeliveryCallbackFunc = NULL;
+	if(_DeliveryCallbacks.empty())
+	{
+		_DeliveryCallbacks.push_back(dcd);
+	}
+
+	if(sSenderID == -1)
+	{
+		dcd.DeliveryCallbackFunc = DeliveryCallbackFunc;
+		_DeliveryCallbacks[0].DeliveryCallbackFunc = DeliveryCallbackFunc;
+	}
+	else
+	{
+		// Note: For size comparsions, sSenderID has to be offset by 2, as index 0 of the callback vector is used by the default callback,
+		//		 taking up 1 element already
+		if(sSenderID + 2 > (INT16)_DeliveryCallbacks.size())
+		{
+			_DeliveryCallbacks.resize(sSenderID+2);
+			_DeliveryCallbacks[sSenderID+1].DeliveryCallbackFunc = DeliveryCallbackFunc;
+			_DeliveryCallbacks[sSenderID+1].sSenderID = sSenderID;
+		}
+		else
+		{
+			_DeliveryCallbacks[sSenderID+1].sSenderID = sSenderID;
+			_DeliveryCallbacks[sSenderID+1].DeliveryCallbackFunc = DeliveryCallbackFunc;
+		}
+	}
+
+	return TRUE;
+}
+
+BOOLEAN CPostalService::LoadShipmentListFromSaveGameFile(HWFILE hFile)
+{
+	UINT32 uiBytesRead=0;
+	ShipmentListSaveFileDataHeaderStruct sls;
+	// Read in shipment list data header
+
+	if(!_Shipments.empty())
+	{
+		_Shipments.clear();
+	}
+
+	FileRead(hFile, &sls, sizeof(ShipmentListSaveFileDataHeaderStruct), &uiBytesRead);
+	if(uiBytesRead != sizeof(ShipmentListSaveFileDataHeaderStruct))
+	{
+		return FALSE;
+	}
+	
+	ShipmentSaveFileDataStruct	sfs;
+	ShipmentPackageStruct		sps;
+	ShipmentStruct				shs;
+		
+	for(int i = 0; i < (int)sls.uiNumberOfShipments; i++)
+	{
+		// Read in shipment data header
+		memset(&sfs, 0, sizeof(ShipmentSaveFileDataStruct));
+		uiBytesRead = 0;
+		FileRead(hFile, &sfs, sizeof(ShipmentSaveFileDataStruct), &uiBytesRead);
+		if(uiBytesRead != sizeof(ShipmentSaveFileDataStruct))
+		{
+			return FALSE;
+		}
+
+		// Add shipment
+		memset(&shs, 0, sizeof(ShipmentStruct));
+		shs.pDestination	= &(_GetDestination(sfs.usDestinationID));
+		shs.pDestinationDeliveryInfo = &(_DeliveryMethods[sfs.ubDeliveryMethodIndex].pDestinationDeliveryInfos->at(sfs.usDestinationID));
+		shs.ShipmentStatus	= sfs.ShipmentStatus;
+		shs.sReceiverID		= sfs.sReceiverID;
+		shs.sSenderID		= sfs.sSenderID;
+		shs.usID			= sfs.usID;
+		shs.uiOrderDate		= sfs.uiOrderDate;
+				
+		_UsedShipmentIDList.resize(sfs.usID+1);
+		_UsedShipmentIDList[sfs.usID] = TRUE;
+
+		for(int j=0; j < (int)sfs.uiNumberOfPackages; j++)
+		{
+			uiBytesRead=0;
+			memset(&sps, 0, sizeof(ShipmentPackageStruct));
+			FileRead(hFile, &sps, sizeof(ShipmentPackageStruct), &uiBytesRead);
+			if(uiBytesRead != sizeof(ShipmentPackageStruct))
+			{
+				return FALSE;
+			}
+			shs.ShipmentPackages.push_back(sps);			
+		}
+		_Shipments.push_back(shs);		
+	}
+
+	return TRUE;
+}
+
+BOOLEAN CPostalService::SaveShipmentListToSaveGameFile(HWFILE hFile)
+{
+	ShipmentListSaveFileDataHeaderStruct sls;
+
+	sls.uiNumberOfShipments = _Shipments.size();
+	sls.uiPackageDataSize	= sizeof(ShipmentPackageStruct);
+	sls.uiShipmentDataSize	= sizeof(ShipmentSaveFileDataStruct);
+
+	UINT32 uiBytesWritten=0;
+	FileWrite(hFile, &sls, sizeof(ShipmentListSaveFileDataHeaderStruct), &uiBytesWritten);
+	if(uiBytesWritten != sizeof(ShipmentListSaveFileDataHeaderStruct))
+	{
+		return FALSE;
+	}
+
+	if(_Shipments.empty())
+	{
+		return TRUE;
+	}
+
+	RefToShipmentListIterator	sli = _Shipments.begin();
+	ShipmentSaveFileDataStruct	sfs;
+	ShipmentPackageStruct		sps;
+
+	while(sli != _Shipments.end() )
+	{
+		memset(&sfs, 0, sizeof(ShipmentSaveFileDataStruct));
+		uiBytesWritten = 0;
+
+		sfs.ShipmentStatus			= SHIPMENT(sli).ShipmentStatus;
+		sfs.sReceiverID				= SHIPMENT(sli).sReceiverID;
+		sfs.sSenderID				= SHIPMENT(sli).sSenderID;
+		sfs.ubDeliveryMethodIndex	= SHIPMENT(sli).pDestinationDeliveryInfo->ubParentDeliveryMethodIndex;;
+		sfs.uiNumberOfPackages		= SHIPMENT(sli).ShipmentPackages.size();
+		sfs.usDestinationID			= SHIPMENT(sli).pDestination->usID;
+		sfs.usID					= SHIPMENT(sli).usID;
+		sfs.uiOrderDate				= SHIPMENT(sli).uiOrderDate;
+		
+		FileWrite(hFile, &sfs, sizeof(ShipmentSaveFileDataStruct), &uiBytesWritten);		
+		if(uiBytesWritten != sizeof(ShipmentSaveFileDataStruct))
+		{
+			return FALSE;
+		}
+
+		for(int i = 0; i < (int)SHIPMENT(sli).ShipmentPackages.size(); i++)
+		{
+			memset(&sps, 0, sizeof(ShipmentPackageStruct));
+			uiBytesWritten = 0;
+
+			sps.bItemQuality	= SHIPMENT(sli).ShipmentPackages[i].bItemQuality;
+			sps.ubNumber		= SHIPMENT(sli).ShipmentPackages[i].ubNumber;
+			sps.usItemIndex		= SHIPMENT(sli).ShipmentPackages[i].usItemIndex;
+			FileWrite(hFile, &sps, sizeof(ShipmentPackageStruct), &uiBytesWritten);
+			if(uiBytesWritten != sizeof(ShipmentPackageStruct))
+			{
+				return FALSE;
+			}
+		}
+
+		sli++;
+	}
+
+	return TRUE;
+}
+
+UINT16 CPostalService::AddDestination(UINT32 uiIndex, UINT8 ubMapX, UINT8 ubMapY, UINT8 ubMapZ, INT16 sGridNo, STR16 pszName)
+{
+	UINT16	usNewID=1;
+	// We need to find an ID first
+	if(_UsedDestinationIDList.empty())	// No IDs assigned yet
+	{
+		_UsedDestinationIDList.push_back(FALSE);	// We're not using ID 0 to avoid confusion
+		_UsedDestinationIDList.push_back(TRUE);		// This is the very first Destination so we use ID 1
+	}
+	else	// There are IDs assigned, let's see if there are any gaps
+	{
+		while(1)
+		{
+			if(usNewID == _UsedDestinationIDList.size() - 1)	// All IDs assigned, add a new one
+			{
+				usNewID++;
+				_UsedDestinationIDList.push_back(TRUE);
+				break;
+			}
+
+			if(!_UsedDestinationIDList[usNewID])	// Found an ID that is not assigned
+			{
+				_UsedDestinationIDList[usNewID] = TRUE;
+				break;	
+			}
+
+			usNewID++;
+		}
+	}
+
+	// Alright, we've found a suitable ID, let's add the destination
+	DestinationStruct newDestination;
+
+	newDestination.sGridNo	=	sGridNo;
+	newDestination.wstrName =	pszName;
+	newDestination.uiIndex	=	uiIndex;
+	newDestination.ubMapX	=	ubMapX;
+	newDestination.ubMapY	=	ubMapY;
+	newDestination.ubMapZ	=	ubMapZ;
+	newDestination.usID		=	usNewID;
+
+	_Destinations.push_back(newDestination);
+
+	return usNewID;
+}
+
+RefToDestinationList CPostalService::LookupDestinationList(void) const
+{
+	return _Destinations;
+}
+
+UINT16 CPostalService::RemoveDestination(UINT16 usDestinationID)
+{
+	if( _Destinations.empty() || usDestinationID >= _UsedDestinationIDList.size() || _UsedDestinationIDList[usDestinationID] == FALSE )
+	{
+		// ID is not in use or unknown or the list is actually empty
+		Assert(0);
+		return 0;
+	}
+	// ID  is known and in use
+	_Destinations.sort(DESTINATION_LIST_ASCENDING);
+	DestinationList::iterator dli = _Destinations.begin();
+
+	while( ( (RefToDestinationStruct)*dli ).usID != usDestinationID )
+		dli++;
+
+	_Destinations.erase(dli);
+	_UsedDestinationIDList[usDestinationID] = FALSE;
+
+	// TO-DO: Add some lines to check and clean up the used destination ID list, i.e. remove empty elements at the end of the list
+
+	return usDestinationID;
+}
+
+UINT16 CPostalService::GetShipmentCount(SHIPMENT_STATUS TargetedShipmentStatus)
+{
+	if(_Shipments.empty())
+	{
+		return 0;
+	}
+
+	RefToShipmentListIterator sli = _Shipments.begin();
+	
+	UINT16 usCnt=0;
+	while(sli != _Shipments.end())
+	{
+		usCnt += (SHIPMENT(sli).ShipmentStatus == TargetedShipmentStatus);
+		sli++;
+	}
+	return usCnt;
+}
+
+RefToShipmentList CPostalService::LookupShipmentList(void) const
+{
+	return (RefToShipmentList)_Shipments;
+}
+
+RefToDestinationStruct CPostalService::GetDestination(UINT16 usDestinationID) const
+{
+	if(	usDestinationID > _UsedDestinationIDList.size() ||
+		!_UsedDestinationIDList[usDestinationID])
+	{
+		Assert(0);
+		return DESTINATION(_Destinations.end());
+	}
+
+	DestinationList::const_iterator dli = _Destinations.begin();
+
+	while(DESTINATION(dli).usID != usDestinationID)
+	{
+		if(dli == _Destinations.end())
+		{
+			Assert(0);
+			return DESTINATION(_Destinations.end());
+		}
+		dli++;
+	}
+
+	return DESTINATION(dli);
+}
+
+UINT8 CPostalService::AddDeliveryMethod(STR16 pszDescription)
+{
+	DeliveryMethodStruct dms;
+
+	dms.wstrDescription = pszDescription;
+	dms.pDestinationDeliveryInfos = new DestinationDeliveryInfoTable;
+
+	_DeliveryMethods.push_back(dms);
+
+	return _DeliveryMethods.size() - 1;
+}
+
+UINT16 CPostalService::SetDestinationDeliveryInfo(UINT8 ubDeliveryMethodIndex, UINT32 uiDestinationIndex, UINT16 usDestinationFee, INT8 bDaysAhead)
+{
+	if( (ubDeliveryMethodIndex > _DeliveryMethods.size() - 1) )
+	{
+		Assert(0);
+		return 0;
+	}
+
+	_DeliveryMethods[ubDeliveryMethodIndex].pDestinationDeliveryInfos->resize(_UsedDestinationIDList.size());
+
+	_Destinations.sort(DESTINATION_LIST_ASCENDING);
+
+	RefToDestinationListIterator dli = _Destinations.begin();
+
+	while( DESTINATION(dli).uiIndex != uiDestinationIndex)
+	{
+		if(dli == _Destinations.end() )
+		{
+			Assert(0);
+			return 0;	// No destination with the specified index found
+		}
+		dli++;
+	}
+
+	_DeliveryMethods[ubDeliveryMethodIndex].pDestinationDeliveryInfos->at(DESTINATION(dli).usID).ubParentDeliveryMethodIndex = ubDeliveryMethodIndex;
+	_DeliveryMethods[ubDeliveryMethodIndex].pDestinationDeliveryInfos->at(DESTINATION(dli).usID).usDestinationFee = usDestinationFee;
+	_DeliveryMethods[ubDeliveryMethodIndex].pDestinationDeliveryInfos->at(DESTINATION(dli).usID).bDaysAhead = bDaysAhead;
+	
+	return uiDestinationIndex;
+}
+
+UINT16 CPostalService::GetDestinationFee(UINT8 ubDeliveryMethodIndex, UINT16 usDestinationID)
+{
+	if(_UsedDestinationIDList.empty() || 
+		usDestinationID > _UsedDestinationIDList.size() ||
+		!_UsedDestinationIDList[usDestinationID])
+	{
+		Assert(0);
+		return 0;
+	}
+
+	return _DeliveryMethods[ubDeliveryMethodIndex].pDestinationDeliveryInfos->at(usDestinationID).usDestinationFee;
+}
+
+RefToDestinationStruct CPostalService::_GetDestination(UINT16 usDestinationID)
+{
+	if(	usDestinationID > _UsedDestinationIDList.size() ||
+		!_UsedDestinationIDList[usDestinationID])
+	{
+		Assert(0);
+		return DESTINATION(_Destinations.end());
+	}
+
+	RefToDestinationListIterator dli = _Destinations.begin();
+
+	while(DESTINATION(dli).usID != usDestinationID)
+	{
+		if(dli == _Destinations.end())
+		{
+			Assert(0);
+			return DESTINATION(_Destinations.end());
+		}
+		dli++;
+	}
+
+	return DESTINATION(dli);
+}