From 0767025ba11c44bd2683483c2dee295458beff06 Mon Sep 17 00:00:00 2001
From: billw2012 <billw2011@gmail.com>
Date: Fri, 13 Sep 2019 00:46:33 +0100
Subject: [PATCH 1/4] Graphics Paging v2 basic hard coded implementation

---
 Assets/XML/GlobalDefines.xml         |   6 +-
 Sources/C2C (VS2019).vcxproj         |   1 +
 Sources/C2C (VS2019).vcxproj.filters |   3 +
 Sources/CvCity.cpp                   |   2 +-
 Sources/CvGame.cpp                   | 198 +++++++++++---
 Sources/CvGameCoreDLL.h              |   1 +
 Sources/CvPlot.cpp                   | 370 ++++++++++++++++-----------
 Sources/CvPlot.h                     |  48 +++-
 Sources/Stopwatch.h                  | 190 ++++++++++++++
 9 files changed, 634 insertions(+), 185 deletions(-)
 create mode 100644 Sources/Stopwatch.h

diff --git a/Assets/XML/GlobalDefines.xml b/Assets/XML/GlobalDefines.xml
index 4ec80eed68..a5079e2ea6 100644
--- a/Assets/XML/GlobalDefines.xml
+++ b/Assets/XML/GlobalDefines.xml
@@ -26,7 +26,11 @@
 		<DefineName>MAX_DESIRED_MEMORY_USED</DefineName>
 		<iDefineIntVal>1835008</iDefineIntVal>
 	</Define>
-	
+
+	<Define>
+		<DefineName>PAGING_FRAME_TIME_MS</DefineName>
+		<iDefineIntVal>200</iDefineIntVal>
+	</Define>
 	<!--
  Default uses the normal tag for the language set in Civ4's option dialog.
 	     All tags used in the text files are possible with English used as fallback when the chosen language is not available for some text.
diff --git a/Sources/C2C (VS2019).vcxproj b/Sources/C2C (VS2019).vcxproj
index 256a368955..13fe2ac5fb 100644
--- a/Sources/C2C (VS2019).vcxproj	
+++ b/Sources/C2C (VS2019).vcxproj	
@@ -306,6 +306,7 @@
     <ClInclude Include="CvDLLUtilityIFaceBase.h" />
     <ClInclude Include="CvDLLWidgetData.h" />
     <ClInclude Include="CvDLLXMLIFaceBase.h" />
+    <ClInclude Include="Stopwatch.h" />
     <ClInclude Include="wchar_utils.h" />
     <ClInclude Include="CvEnums.h" />
     <ClInclude Include="CvEventReporter.h" />
diff --git a/Sources/C2C (VS2019).vcxproj.filters b/Sources/C2C (VS2019).vcxproj.filters
index 43d5d843a8..79a19a8848 100644
--- a/Sources/C2C (VS2019).vcxproj.filters	
+++ b/Sources/C2C (VS2019).vcxproj.filters	
@@ -851,6 +851,9 @@
     <ClInclude Include="idinfo_iterator.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Stopwatch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="CvGameCoreDLL.rc">
diff --git a/Sources/CvCity.cpp b/Sources/CvCity.cpp
index 9f12579cf2..5dcfab54e5 100644
--- a/Sources/CvCity.cpp
+++ b/Sources/CvCity.cpp
@@ -21793,7 +21793,7 @@ class VisibleBuildingComparator
 void CvCity::getVisibleBuildings(std::list<BuildingTypes>& kChosenVisible, int& iChosenNumGenerics)
 {
 
-	if ( !plot()->shouldHaveFullGraphics() )
+	if ( !plot()->isGraphicsRequiredVisible(PLOT_GRAPHICS_CITY) )
 	{
 		iChosenNumGenerics = 0;
 		return;
diff --git a/Sources/CvGame.cpp b/Sources/CvGame.cpp
index 11b95dea2e..b4ccb4201c 100644
--- a/Sources/CvGame.cpp
+++ b/Sources/CvGame.cpp
@@ -2647,6 +2647,36 @@ int CvGame::getTeamClosenessScore(int** aaiDistances, int* aiStartingLocs)
 	return iScore;
 }
 
+float ToroidalDistanceSq (int x1, int y1, int x2, int y2, int w, int h)
+{
+	float dx = std::abs(x2 - x1);
+	float dy = std::abs(y2 - y1);
+
+	if (dx > w/2)
+		dx = w - dx;
+
+	if (dy > h/2)
+		dy = h - dy;
+
+	return dx * dx + dy * dy;
+}
+
+struct PlotDist
+{
+	CvPlot* plot;
+	int dist2;
+
+	PlotDist(CvPlot* plot, int dist2) : plot(plot), dist2(dist2)
+	{
+	}
+
+	PlotDist() : plot(NULL), dist2(0) {}
+
+	bool operator<(const PlotDist& other) const
+	{
+		return dist2 < other.dist2;
+	}
+};
 
 void CvGame::update()
 {
@@ -2674,53 +2704,161 @@ void CvGame::update()
 		bool bPagingEnabled = getBugOptionBOOL("MainInterface__EnableGraphicalPaging", true);
 		GC.setGraphicalDetailPagingEnabled(bPagingEnabled);
 
-		if ( m_bWasGraphicsPagingEnabled != bPagingEnabled)
+		//if (m_bWasGraphicsPagingEnabled != bPagingEnabled)
+		//{
+		//	for(int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
+		//	{
+		//		CvPlot*	pPlot = GC.getMapINLINE().plotByIndexINLINE(iI);
+		//		if ( pPlot != NULL )
+		//		{
+		//			if (m_bWasGraphicsPagingEnabled)
+		//			{
+		//				pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+		//			}
+		//			else
+		//			{
+		//				pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, false);
+		//			}
+		//		}
+		//	}
+		//}
+
+		//m_bWasGraphicsPagingEnabled = bPagingEnabled;
+
 		{
-			for(int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
+			int pageInRange2 = GC.getGraphicalDetailPageInRange() * GC.getGraphicalDetailPageInRange();
+			win32::Stopwatch pageTimer;
+			pageTimer.Start();
+			int centerX = lookatPlot->getX_INLINE();
+			int centerY = lookatPlot->getY_INLINE();
+			
+			int moveDist2 = (centerX - m_iLastLookatX) * (centerX - m_iLastLookatX) + (centerY - m_iLastLookatY) * (centerY - m_iLastLookatY);
+
+			int pagingFrameTime = 10 + 200 / (1 + moveDist2);
+
+			// Evict graphics first
+			while (CvPlot::EvictGraphicsIfNecessary() && pageTimer.ElapsedMilliseconds() < pagingFrameTime * 0.5) {}
+
+			static int Distances[] = {
+				100, //  PLOT_GRAPHICS_SYMBOLS
+				7, 	 //  PLOT_GRAPHICS_FEATURE
+				40,  //  PLOT_GRAPHICS_RIVER
+				100, //  PLOT_GRAPHICS_ROUTE
+				15,  //  PLOT_GRAPHICS_UNIT
+				5,  //  PLOT_GRAPHICS_CITY
+			};
+
+
+			std::vector<PlotDist> plots;
+			CvMap& map = GC.getMapINLINE();
+			plots.reserve(map.numPlotsINLINE());
+			for (int i = 0; i < map.numPlotsINLINE(); i++)
 			{
-				CvPlot*	pPlot = GC.getMapINLINE().plotByIndexINLINE(iI);
-				if ( pPlot != NULL )
+				CvPlot* plot = map.plotByIndexINLINE(i);
+				if (plot != NULL)
 				{
-					if ( m_bWasGraphicsPagingEnabled )
-					{
-						pPlot->setShouldHaveFullGraphics(true);
-					}
-					else
-					{
-						pPlot->setShouldHaveFullGraphics(false);
-					}
+					plots.push_back(PlotDist(map.plotByIndexINLINE(i), ToroidalDistanceSq(centerX, centerY, plot->getX_INLINE(), plot->getY_INLINE(), map.getGridWidthINLINE(), map.getGridHeightINLINE())));
 				}
 			}
-		}
 
-		m_bWasGraphicsPagingEnabled = bPagingEnabled;
+			std::sort(plots.begin(), plots.end());
 
-		if ( GC.getGraphicalDetailPagingEnabled() )
-		{
-			if ( (m_iLastLookatX != lookatPlot->getX_INLINE() || m_iLastLookatY != lookatPlot->getY_INLINE()) )
+			//for (int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE() && pageTimer.ElapsedMilliseconds() < pagingFrameTime; iI++)
+			for(std::vector<PlotDist>::iterator itr = plots.begin(); itr != plots.end() && pageTimer.ElapsedMilliseconds() < pagingFrameTime; ++itr)
 			{
-				int pageInRange = GC.getGraphicalDetailPageInRange();
-				CvPlot::notePageRenderStart((pageInRange*2+1)*(pageInRange*2+1));
-
-				for(int iX = -pageInRange; iX <= pageInRange; iX++)
+				//CvPlot* pPlot = itr->plot;
+				if (bPagingEnabled)
 				{
-					for(int iY = -pageInRange; iY <= pageInRange; iY++)
+					//pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_FLAG, true);
+					for (int graphicsType = 0; graphicsType < PLOT_GRAPHICS_NUM; ++graphicsType)
 					{
-						CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(),lookatPlot->getY_INLINE(),iX,iY);
-
-						if ( pPlot != NULL )
+						if (Distances[graphicsType] != -1)
 						{
-							pPlot->setShouldHaveFullGraphics(true);
+							itr->plot->setRequireGraphicsVisible(static_cast<ECvPlotGraphics>(1 << graphicsType), itr->dist2 < Distances[graphicsType] * Distances[graphicsType]);
 						}
 					}
 				}
-
-				m_iLastLookatX = lookatPlot->getX_INLINE();
-				m_iLastLookatY = lookatPlot->getY_INLINE();
+				else
+				{
+					itr->plot->disableGraphicsPaging();
+				}
 			}
 
-			CvPlot::EvictGraphicsIfNecessary();
+			m_iLastLookatX = lookatPlot->getX_INLINE();
+			m_iLastLookatY = lookatPlot->getY_INLINE();
 		}
+
+		//if ( GC.getGraphicalDetailPagingEnabled() )
+		//{
+		//	//if ( (m_iLastLookatX != lookatPlot->getX_INLINE() || m_iLastLookatY != lookatPlot->getY_INLINE()) )
+		//	//{
+		//	int pageInRange = GC.getGraphicalDetailPageInRange();
+		//	//CvPlot::notePageRenderStart((pageInRange * 2 + 1) * (pageInRange * 2 + 1));
+
+		//	win32::Stopwatch pageTimer;
+		//	pageTimer.Start();
+		//	int pagingFrameTime = GC.getDefineINT("PAGING_FRAME_TIME_MS", 20);
+		//	// Spiral outward from center
+		//	for (int i = 0; i < pageInRange && pageTimer.ElapsedMilliseconds() < pagingFrameTime; i++)
+		//	{
+		//		for (int x = -i; x <= i && pageTimer.ElapsedMilliseconds() < pagingFrameTime; x++)
+		//		{
+		//			{
+		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), x, i);
+
+		//				if (pPlot != NULL)
+		//				{
+		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+		//				}
+		//			}
+		//			{
+		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), x, -i);
+
+		//				if (pPlot != NULL)
+		//				{
+		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+		//				}
+		//			}
+		//		}
+		//		for (int y = -i; y <= i && pageTimer.ElapsedMilliseconds() < pagingFrameTime; y++)
+		//		{
+		//			{
+		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), i, y);
+
+		//				if (pPlot != NULL)
+		//				{
+		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+		//				}
+		//			}
+		//			{
+		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), -i, y);
+
+		//				if (pPlot != NULL)
+		//				{
+		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+		//				}
+		//			}
+		//		}
+		//	}
+		//	//for (int iX = -pageInRange; iX <= pageInRange && pageTimer.ElapsedMilliseconds() < pagingFrameTime; iX++)
+		//	//{
+		//	//	for (int iY = -pageInRange; iY <= pageInRange && pageTimer.ElapsedMilliseconds() < pagingFrameTime; iY++)
+		//	//	{
+		//	//		CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), iX, iY);
+
+		//	//		if (pPlot != NULL)
+		//	//		{
+		//	//			pPlot->setShouldHaveFullGraphics(true);
+		//	//		}
+		//	//	}
+		//	//}
+
+		//	m_iLastLookatX = lookatPlot->getX_INLINE();
+		//	m_iLastLookatY = lookatPlot->getY_INLINE();
+		//	//}
+
+		//	CvPlot::EvictGraphicsIfNecessary();
+		//}
 	}
 
 	//OutputDebugString(CvString::format("Start profiling(false) for CvGame::update()\n").c_str());
diff --git a/Sources/CvGameCoreDLL.h b/Sources/CvGameCoreDLL.h
index 8d7b15661b..16f559a82c 100644
--- a/Sources/CvGameCoreDLL.h
+++ b/Sources/CvGameCoreDLL.h
@@ -235,6 +235,7 @@ namespace python = boost::python;
 
 #include "FAssert.h"
 #include "CheckSum.h"
+#include "Stopwatch.h"
 #include "CvGameCoreDLLDefNew.h"
 #include "FDataStreamBase.h"
 #include "FFreeListArrayBase.h"
diff --git a/Sources/CvPlot.cpp b/Sources/CvPlot.cpp
index dc466c4592..e66b0d9f35 100644
--- a/Sources/CvPlot.cpp
+++ b/Sources/CvPlot.cpp
@@ -39,12 +39,16 @@ static stdext::hash_map<int, unitDefenderInfo>*	g_bestDefenderCache = NULL;
 // Public Functions...
 
 #pragma warning( disable : 4355 )
-CvPlot::CvPlot() : m_GameObject(this),
-m_Properties(this)
+CvPlot::CvPlot() 
+	: m_GameObject(this)
+	, m_Properties(this)
+	, m_visibleGraphics(PLOT_GRAPHICS_NONE)
+	, m_requiredVisibleGraphics(PLOT_GRAPHICS_NONE)
+	, m_iGraphicsPageIndex(-1)
 {
 	if ( m_resultHashMap == NULL )
 	{
-		m_resultHashMap = new	stdext::hash_map<int,int>();
+		m_resultHashMap = new stdext::hash_map<int,int>();
 	}
 
 	if ( g_bestDefenderCache == NULL )
@@ -106,7 +110,6 @@ m_Properties(this)
 	m_iCanHaveImprovementAsUpgradeCache = -1;
 	m_iCurrentRoundofUpgradeCache = 0;
 	m_iImprovementCurrentValue = 0;
-	m_iGraphicsPageIndex = -1;
 
 	m_szScriptData = NULL;
 	//Afforess: use async rand so as to not pollute mp games
@@ -384,29 +387,27 @@ void CvPlot::reset(int iX, int iY, bool bConstructorCall)
 struct GraphicsPagingInfo
 {
 	CvPlot* pPlot;
-	int		iSeq;
-	GraphicsPagingInfo () : pPlot(NULL), iSeq(0)
-	{}
+	unsigned int iSeq;
+	GraphicsPagingInfo () : pPlot(NULL), iSeq(0U) {}
 };
 
-static int iNumPagedInPlots = 0;
-static int iPageTableSize = 0;
-static int iRenderStartSeq = 0;
-static int iCurrentSeq = 0;
-static int iOldestSearchSeqHint = 0;
-static GraphicsPagingInfo* pagingTable = NULL;
+static unsigned int iNumPagedInPlots = 0;
+// static unsigned int iRenderStartSeq = 0;
+static unsigned int iCurrentSeq = 0;
+static unsigned int iOldestSearchSeqHint = 0;
+static std::vector<GraphicsPagingInfo> pagingTable;
 
 #define	MAX_VALID_PAGING_INDEX 65534
 
 int findFreePagingTableSlot()
 {
-	static int iSearchStartHintIndex = 0;
+	static size_t iSearchStartHintIndex = 0;
 
-	for(int iI = 0; iI < iPageTableSize; iI++)
+	for(size_t iI = 0; iI < pagingTable.size(); iI++)
 	{
 		int iIndex = iSearchStartHintIndex++;
 
-		if ( iSearchStartHintIndex >= iPageTableSize )
+		if (iSearchStartHintIndex >= pagingTable.size())
 		{
 			iSearchStartHintIndex = 0;
 		}
@@ -422,33 +423,25 @@ int findFreePagingTableSlot()
 
 int allocateNewPagingEntry()
 {
-	if ( iPageTableSize <= iNumPagedInPlots++ )
+	if (pagingTable.size() <= iNumPagedInPlots++ )
 	{
-		int iNewSize = std::max(64, iPageTableSize + std::min(iPageTableSize,512));
-
-		GraphicsPagingInfo* newTable = new GraphicsPagingInfo[iNewSize];
-
-		if ( iPageTableSize > 0 )
-		{
-			memcpy(newTable, pagingTable, iPageTableSize*sizeof(GraphicsPagingInfo));
-			SAFE_DELETE_ARRAY(pagingTable);
-		}
-		
-		pagingTable = newTable;
-		iPageTableSize = iNewSize;
+		pagingTable.push_back(GraphicsPagingInfo());
+		return pagingTable.size() - 1;
+	}
+	else
+	{
+		return findFreePagingTableSlot();
 	}
-
-	return findFreePagingTableSlot();
 }
 
 int findOldestEvictablePagingEntry()
 {
-	int iOldest = MAX_INT;
+	unsigned int iOldest = MAX_INT;
 	int iResult = -1;
 
-	for(int iI = 0; iI < iNumPagedInPlots; iI++)
+	for(int iI = 0; iI < static_cast<int>(pagingTable.size()); iI++)
 	{
-		if ( pagingTable[iI].pPlot != NULL && pagingTable[iI].iSeq < iRenderStartSeq )
+		if ( pagingTable[iI].pPlot != NULL && pagingTable[iI].pPlot->getNonRequiredGraphicsMask() != PLOT_GRAPHICS_NONE)
 		{
 			if ( pagingTable[iI].iSeq < iOldest )
 			{
@@ -498,131 +491,210 @@ bool NeedToFreeMemory()
 	}
 }
 
-static bool bFoundEvictable = true;
+// static bool bFoundEvictable = true;
 
-void CvPlot::EvictGraphicsIfNecessary()
+bool CvPlot::EvictGraphicsIfNecessary()
 {
-	bFoundEvictable = true;
-
-	while(bFoundEvictable && NeedToFreeMemory())
-	{
-		int iEvictionIndex = findOldestEvictablePagingEntry();
+	//bool bFoundEvictable = true;
 
-		if ( iEvictionIndex == -1 )
-		{
-			bFoundEvictable = false;
-			break;
-		}
+	//while(bFoundEvictable && NeedToFreeMemory())
+	//{
+	int iEvictionIndex = findOldestEvictablePagingEntry();
 
-		pagingTable[iEvictionIndex].pPlot->setShouldHaveFullGraphics(false);
+	if ( iEvictionIndex == -1 )
+	{
+		return false;
 	}
+
+	pagingTable[iEvictionIndex].pPlot->hideNonRequiredGraphics();
+	return true;
+	//}
 }
 
 void CvPlot::pageGraphicsOut()
 {
-	bFoundEvictable = true;
+	//bFoundEvictable = true;
 
 	if ( m_iGraphicsPageIndex != -1 )
 	{
 		pagingTable[m_iGraphicsPageIndex].pPlot = NULL;
+		--iNumPagedInPlots;
+		//if ( --iNumPagedInPlots == 0 )
+		//{
+		//	SAFE_DELETE_ARRAY(pagingTable);
 
-		if ( --iNumPagedInPlots == 0 )
-		{
-			SAFE_DELETE_ARRAY(pagingTable);
-
-			iPageTableSize = 0;
-		}
+		//	iPageTableSize = 0;
+		//}
 	}
 
 	m_iGraphicsPageIndex = -1;
 }
 
-void CvPlot::notePageRenderStart(int iRenderArea)
-{
-	iRenderStartSeq = std::max(0,iCurrentSeq-iRenderArea);
-}
+//void CvPlot::notePageRenderStart(int iRenderArea)
+//{
+//	iRenderStartSeq = std::max(0, iCurrentSeq-iRenderArea);
+//}
 
-void	CvPlot::setShouldHaveFullGraphics(bool bShouldHaveFullGraphics)
+void CvPlot::setRequireGraphicsVisible(ECvPlotGraphics graphics, bool visible)
 {
-	bool bChanged;
-
-	if ( !GC.getGraphicalDetailPagingEnabled() )
+	if (visible)
 	{
-		bChanged = true;
-
-		m_iGraphicsPageIndex = -1;
-
-		if ( pagingTable != NULL )
-		{
-			SAFE_DELETE_ARRAY(pagingTable);
-
-			iNumPagedInPlots = 0;
-			iPageTableSize = 0;
-		}
+		m_requiredVisibleGraphics = static_cast<ECvPlotGraphics>(static_cast<int>(m_requiredVisibleGraphics) | static_cast<int>(graphics));
 	}
 	else
 	{
-		//	A set to false is only ever used to switch out paged in graphics
-		//	or when truning the entire mechanism on from it previously being off.
-		//	In both of these cases we want to treat it as a change
-		bChanged = (!bShouldHaveFullGraphics || ((m_iGraphicsPageIndex != -1) != bShouldHaveFullGraphics));
+		m_requiredVisibleGraphics = static_cast<ECvPlotGraphics>(static_cast<int>(m_requiredVisibleGraphics) & ~static_cast<int>(graphics));
+	}
 
-		if ( bShouldHaveFullGraphics )
-		{
-			if ( m_iGraphicsPageIndex == -1 )
-			{
-				m_iGraphicsPageIndex = allocateNewPagingEntry();
-			}
+	showRequiredGraphics();
+}
 
-			GraphicsPagingInfo* pPagingInfo = &pagingTable[m_iGraphicsPageIndex];
+bool CvPlot::isGraphicsVisible(ECvPlotGraphics graphics) const
+{
+	return (static_cast<int>(m_visibleGraphics) & static_cast<int>(graphics)) != 0;
+}
 
-			pPagingInfo->iSeq = ++iCurrentSeq;
-			pPagingInfo->pPlot = this;
+bool CvPlot::isGraphicsRequiredVisible(ECvPlotGraphics graphics) const
+{
+	return (static_cast<int>(m_requiredVisibleGraphics) & static_cast<int>(graphics)) != 0;
+}
 
-			if ( iCurrentSeq == MAX_INT )
-			{
-				iCurrentSeq = 0;
-			}
+bool CvPlot::isGraphicPagingEnabled() const
+{
+	return m_iGraphicsPageIndex != -1;
+}
 
-			EvictGraphicsIfNecessary();
-		}
-		else
-		{
-			pageGraphicsOut();
-		}
+void CvPlot::showRequiredGraphics()
+{
+	ECvPlotGraphics toShow = static_cast<ECvPlotGraphics>((m_requiredVisibleGraphics ^ m_visibleGraphics) & m_requiredVisibleGraphics);
+
+	if (!isGraphicPagingEnabled())
+	{
+		enableGraphicsPaging();
 	}
 
-	if ( bChanged )
+	if (toShow != PLOT_GRAPHICS_NONE)
 	{
 		setLayoutDirty(true);
-		if ( getPlotCity() != NULL )
+	}
+	if (toShow & PLOT_GRAPHICS_SYMBOLS)
+	{
+		updateSymbols();
+	}
+	if (toShow & PLOT_GRAPHICS_FEATURE)
+	{
+		updateFeatureSymbol();
+	}
+	if (toShow & PLOT_GRAPHICS_RIVER)
+	{
+		updateRiverSymbol();
+	}
+	if (toShow & PLOT_GRAPHICS_ROUTE)
+	{
+		updateRouteSymbol();
+	}
+	if (toShow & PLOT_GRAPHICS_UNIT)
+	{
+		updateCenterUnit();
+		updateFlagSymbol();
+	}
+	if (toShow & PLOT_GRAPHICS_CITY)
+	{
+		if (getPlotCity() != NULL)
 		{
 			getPlotCity()->setLayoutDirty(true);
 		}
+	}
+
+	m_visibleGraphics = static_cast<ECvPlotGraphics>(m_visibleGraphics | toShow);
+}
+
+void CvPlot::hideNonRequiredGraphics()
+{
+	ECvPlotGraphics toHide = getNonRequiredGraphicsMask();
 
-		if ( bShouldHaveFullGraphics )
+	if (toHide & PLOT_GRAPHICS_SYMBOLS)
+	{
+		deleteAllSymbols();
+	}
+	if (toHide & PLOT_GRAPHICS_FEATURE)
+	{
+		gDLL->getFeatureIFace()->destroy(m_pFeatureSymbol);
+		m_pFeatureSymbol = NULL;
+		if (m_pPlotBuilder)
 		{
-			//gDLL->getEngineIFace()->RebuildPlot(getViewportX(), getViewportY(),false,true);
-			updateSymbols();
-			updateFeatureSymbol();
-			updateRiverSymbol();
-			updateRouteSymbol();
+			gDLL->getPlotBuilderIFace()->destroy(m_pPlotBuilder);
+			m_pPlotBuilder = NULL;
 		}
-		else
+	}
+	if (toHide & PLOT_GRAPHICS_RIVER)
+	{
+		gDLL->getRiverIFace()->destroy(m_pRiverSymbol);
+		m_pRiverSymbol = NULL;
+	}
+	if (toHide & PLOT_GRAPHICS_ROUTE)
+	{
+		gDLL->getRouteIFace()->destroy(m_pRouteSymbol);
+		m_pRouteSymbol = NULL;
+	}
+	if (toHide & PLOT_GRAPHICS_UNIT)
+	{
+		updateCenterUnit();
+		m_pCenterUnit = NULL;
+		gDLL->getFlagEntityIFace()->destroy(m_pFlagSymbol);
+		gDLL->getFlagEntityIFace()->destroy(m_pFlagSymbolOffset);
+		m_pFlagSymbol = NULL;
+		m_pFlagSymbolOffset = NULL;
+	}
+	if (toHide & PLOT_GRAPHICS_CITY)
+	{
+		if (getPlotCity() != NULL)
 		{
-			destroyGraphics();
+			getPlotCity()->setLayoutDirty(true);
 		}
+	}
 
-		updateCenterUnit();
+	m_visibleGraphics = static_cast<ECvPlotGraphics>(m_visibleGraphics & ~toHide);
+	// All graphics are pages out now so we can remove ourselves from the active plot list
+	if (m_visibleGraphics == PLOT_GRAPHICS_NONE)
+	{
+		pageGraphicsOut();
 	}
+
 }
 
-bool	CvPlot::shouldHaveFullGraphics() const
+ECvPlotGraphics CvPlot::getNonRequiredGraphicsMask() const
 {
-	return (!GC.getGraphicalDetailPagingEnabled() || m_iGraphicsPageIndex != -1) && shouldHaveGraphics();
+	return static_cast<ECvPlotGraphics>((m_requiredVisibleGraphics ^ m_visibleGraphics) & m_visibleGraphics);
+}
+
+void CvPlot::enableGraphicsPaging()
+{
+	FAssertMsg(!isGraphicPagingEnabled(), "Graphics paging is already enabled");
+
+	m_iGraphicsPageIndex = allocateNewPagingEntry();
+
+	GraphicsPagingInfo* pPagingInfo = &pagingTable[m_iGraphicsPageIndex];
+
+	pPagingInfo->iSeq = ++iCurrentSeq;
+	pPagingInfo->pPlot = this;
 }
 
-bool	CvPlot::shouldHaveGraphics() const
+void CvPlot::disableGraphicsPaging()
+{
+	FAssertMsg(isGraphicPagingEnabled(), "Graphics paging is not enabled");
+	// Show all graphics, as we aren't paging any more
+	setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+	// Disable paging 
+	m_iGraphicsPageIndex = -1;
+}
+
+//bool	CvPlot::shouldHaveFullGraphics() const
+//{
+//	return (!GC.getGraphicalDetailPagingEnabled() || m_iGraphicsPageIndex != -1) && shouldHaveGraphics();
+//}
+
+bool CvPlot::shouldHaveGraphics() const
 {
 	return GC.IsGraphicsInitialized() && isInViewport(); // && isRevealed(GC.getGame().getActiveTeam(), false);
 }
@@ -1220,7 +1292,7 @@ void CvPlot::updateSymbolDisplay()
 	CvSymbol* pLoopSymbol;
 	int iLoop;
 
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsVisible(PLOT_GRAPHICS_SYMBOLS))
 	{
 		return;
 	}
@@ -1253,7 +1325,7 @@ void CvPlot::updateSymbolVisibility()
 	CvSymbol* pLoopSymbol;
 	int iLoop;
 
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsVisible(PLOT_GRAPHICS_SYMBOLS) )
 	{
 		return;
 	}
@@ -1285,7 +1357,7 @@ bool CvPlot::updateSymbolsInternal()
 	MEMORY_TRACK_EXEMPT();
 	PROFILE_FUNC();
 
-	if ( ! shouldHaveFullGraphics())
+	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_SYMBOLS))
 	{
 		return false;
 	}
@@ -1392,7 +1464,7 @@ void CvPlot::updateCenterUnit()
 	CvUnit* pOldCenterUnit = getCenterUnit();
 	CvUnit* pNewCenterUnit;
 
-	if ( m_bInhibitCenterUnitCalculation || !shouldHaveFullGraphics() )
+	if ( m_bInhibitCenterUnitCalculation || !isGraphicsRequiredVisible(PLOT_GRAPHICS_UNIT) )
 	{
 		//	Because we are inhibitting recalculation until all the adjusting code has run
 		//	(rather than have it update multiple times) the currently cached center unit
@@ -2726,7 +2798,7 @@ bool CvPlot::shouldProcessDisplacementPlot(int dx, int dy, int range, DirectionT
 		{
 			return false;
 		}
-        
+		
 		/*
 		DirectionTypes leftDirection = GC.getTurnLeftDirection(eFacingDirection);
 		DirectionTypes rightDirection = GC.getTurnRightDirection(eFacingDirection);
@@ -6319,14 +6391,14 @@ bool CvPlot::isHasValidBonus() const
 	}
 	if (GET_TEAM(getTeam()).isHasTech((TechTypes)(GC.getBonusInfo((BonusTypes)m_eBonusType).getTechReveal())))
 	{
-        if (GC.getImprovementInfo(getImprovementType()).isImprovementBonusTrade(getBonusType()))
+		if (GC.getImprovementInfo(getImprovementType()).isImprovementBonusTrade(getBonusType()))
 		{
 			return true;
 		}
 	}
 	if (GET_TEAM(getTeam()).isHasTech((TechTypes)(GC.getBonusInfo((BonusTypes)m_eBonusType).getTechReveal())) && GET_TEAM(getTeam()).isHasTech((TechTypes)(GC.getBonusInfo((BonusTypes)m_eBonusType).getTechObsolete())))
 	{
-        if (GC.getImprovementInfo(getImprovementType()).isImprovementBonusTrade(getBonusType()))
+		if (GC.getImprovementInfo(getImprovementType()).isImprovementBonusTrade(getBonusType()))
 		{
 			return true;
 		}
@@ -6703,7 +6775,7 @@ bool CvPlot::isCanMoveAllUnits() const
 bool CvPlot::isCanMoveLandUnits() const
 {
 	//Check is only to determine if there's a tunnel.
- 	if (isSeaTunnel())
+	if (isSeaTunnel())
 	{
 		return true;
 	}
@@ -6734,7 +6806,7 @@ bool CvPlot::isCanUseRouteSeaUnits() const
 {
 	if (isSeaTunnel())
 	{
-	 	return false;
+		return false;
 	}
 
 	return true;
@@ -6742,9 +6814,9 @@ bool CvPlot::isCanUseRouteSeaUnits() const
 
 bool CvPlot::isSeaTunnel() const
 {
- 	if (isRoute())
+	if (isRoute())
 	{
-	 	if (GC.getRouteInfo(getRouteType()).isSeaTunnel())
+		if (GC.getRouteInfo(getRouteType()).isSeaTunnel())
 		{
 			return true;
 		}
@@ -7064,12 +7136,12 @@ bool CvPlot::isImpassable(TeamTypes eTeam) const
 		}
 	}
 	else if (isPeak2(true))
-    {
-        if (eTeam == NO_TEAM || !GET_TEAM(eTeam).isCanPassPeaks())
-        {
-            return true;
-        }
-    }
+	{
+		if (eTeam == NO_TEAM || !GET_TEAM(eTeam).isCanPassPeaks())
+		{
+			return true;
+		}
+	}
 	
 /************************************************************************************************/
 /* Afforess	Mountains End       END        		                                             */
@@ -9376,24 +9448,24 @@ void CvPlot::setRouteType(RouteTypes eNewValue, bool bUpdatePlotGroups)
 /************************************************************************************************/
 		if (eNewValue == NO_ROUTE && bOldSeaRoute)
 		{
-		    CLLNode<IDInfo>* pUnitNode;
-            CvUnit* pLoopUnit;
-            pUnitNode = headUnitNode();
+			CLLNode<IDInfo>* pUnitNode;
+			CvUnit* pLoopUnit;
+			pUnitNode = headUnitNode();
 
-            while (pUnitNode != NULL)
-            {
-                pLoopUnit = ::getUnit(pUnitNode->m_data);
-                pUnitNode = nextUnitNode(pUnitNode);
+			while (pUnitNode != NULL)
+			{
+				pLoopUnit = ::getUnit(pUnitNode->m_data);
+				pUnitNode = nextUnitNode(pUnitNode);
 
-                if (pLoopUnit->getDomainType() == DOMAIN_LAND)
-                {
+				if (pLoopUnit->getDomainType() == DOMAIN_LAND)
+				{
 					if (!pLoopUnit->isCargo() && !pLoopUnit->canMoveAllTerrain())
 					{
-	                    pLoopUnit->kill(true);//MIGHT need to also specify if the unit isn't cargo of a land unit that isn't cargo itself.  Shouldn't have to though because if the carrier would die, then that would dunk the carrier's units, likely in a fatal manner.
+						pLoopUnit->kill(true);//MIGHT need to also specify if the unit isn't cargo of a land unit that isn't cargo itself.  Shouldn't have to though because if the carrier would die, then that would dunk the carrier's units, likely in a fatal manner.
 					}
-                }
-            }
-        }
+				}
+			}
+		}
 /************************************************************************************************/
 /* JOOYO_ADDON                          END                                                     */
 /************************************************************************************************/
@@ -9560,8 +9632,8 @@ void CvPlot::updateWorkingCity()
 							  (GC.getCityPlotPriority()[iI] < GC.getCityPlotPriority()[iBestPlot]) ||
 							  ((GC.getCityPlotPriority()[iI] == GC.getCityPlotPriority()[iBestPlot]) &&
 							   ((pLoopCity->getGameTurnFounded() < pBestCity->getGameTurnFounded()) ||
-							    ((pLoopCity->getGameTurnFounded() == pBestCity->getGameTurnFounded()) &&
-							     (pLoopCity->getID() < pBestCity->getID())))))
+								((pLoopCity->getGameTurnFounded() == pBestCity->getGameTurnFounded()) &&
+								 (pLoopCity->getID() < pBestCity->getID())))))
 						{
 							iBestPlot = iI;
 							pBestCity = pLoopCity;
@@ -12177,7 +12249,7 @@ void CvPlot::updateFeatureSymbolVisibility()
 {
 	PROFILE_FUNC();
 
-	if ( !shouldHaveFullGraphics() )
+	if (!isGraphicsVisible(PLOT_GRAPHICS_FEATURE))
 	{
 		return;
 	}
@@ -12221,7 +12293,7 @@ void CvPlot::updateFeatureSymbol(bool bForce)
 		gDLL->getEngineIFace()->RebuildTileArt(getViewportX(),getViewportY());
 	}
 
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_FEATURE) )
 	{
 		return;
 	}
@@ -12268,7 +12340,7 @@ void CvPlot::updateRouteSymbol(bool bForce, bool bAdjacent)
 	RouteTypes eRoute;
 	int iI;
 
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_ROUTE) )
 	{
 		return;
 	}
@@ -12328,7 +12400,7 @@ void CvPlot::updateRiverSymbol(bool bForce, bool bAdjacent)
 
 	CvPlot* pAdjacentPlot;
 
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_RIVER) )
 	{
 		return;
 	}
@@ -12432,7 +12504,7 @@ void CvPlot::updateFlagSymbol()
 {
 	PROFILE_FUNC();
 
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_UNIT) )
 	{
 		return;
 	}
@@ -14560,7 +14632,7 @@ void CvPlot::setLayoutDirty(bool bDirty)
 
 bool CvPlot::updatePlotBuilder()
 {
-	if ( !shouldHaveFullGraphics() )
+	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_FEATURE) )
 	{
 		return false;
 	}
@@ -16712,7 +16784,7 @@ void	CvPlot::setDeferredPlotGroupRecalculationMode(bool bDefer)
 
 int CvPlot::getNumAfflictedUnits(PlayerTypes eOwner, PromotionLineTypes eAfflictionLine) const
 {
-    return plotCount(PUF_isAfflicted, eAfflictionLine, -1, NULL, eOwner);
+	return plotCount(PUF_isAfflicted, eAfflictionLine, -1, NULL, eOwner);
 }
 
 void CvPlot::enableCenterUnitRecalc(bool bEnable)
diff --git a/Sources/CvPlot.h b/Sources/CvPlot.h
index 4e907c2472..56f3d4e0ab 100644
--- a/Sources/CvPlot.h
+++ b/Sources/CvPlot.h
@@ -68,6 +68,19 @@ class canBuildCache
 };
 #endif
 
+enum ECvPlotGraphics
+{
+	PLOT_GRAPHICS_NONE = 0,
+	PLOT_GRAPHICS_SYMBOLS = 1 << 0,
+	PLOT_GRAPHICS_FEATURE = 1 << 1,
+	PLOT_GRAPHICS_RIVER = 1 << 2,
+	PLOT_GRAPHICS_ROUTE = 1 << 3,
+	PLOT_GRAPHICS_UNIT = 1 << 4,
+	PLOT_GRAPHICS_CITY = 1 << 5,
+	PLOT_GRAPHICS_ALL = PLOT_GRAPHICS_SYMBOLS | PLOT_GRAPHICS_FEATURE | PLOT_GRAPHICS_RIVER | PLOT_GRAPHICS_ROUTE | PLOT_GRAPHICS_UNIT | PLOT_GRAPHICS_CITY,
+	PLOT_GRAPHICS_NUM = 6
+}; 
+
 class CvPlot
 {
 friend CvPathPlotInfoStore;
@@ -503,10 +516,34 @@ friend CvPathPlotInfoStore;
 		return m_iY;
 	}
 	bool isInViewport(int comfortBorderSize = 0) const;
-	static void EvictGraphicsIfNecessary();
-	void setShouldHaveFullGraphics(bool bShouldHaveFullGraphics);
-	bool shouldHaveFullGraphics() const;
+
+	static bool EvictGraphicsIfNecessary();
+
+	// Set what graphics we require to be visible (probably based on camera position)
+	void setRequireGraphicsVisible(ECvPlotGraphics graphics, bool visible);
+	bool isGraphicsVisible(ECvPlotGraphics graphics) const;
+	bool isGraphicsRequiredVisible(ECvPlotGraphics graphics) const;
+	bool isGraphicPagingEnabled() const;
+
+	//// Show or hide specific graphic
+	//void setGraphicsVisible(ECvPlotGraphics graphics, bool visible);
+
+	// Show all required but not visible graphics
+	void showRequiredGraphics();
+
+	// Hide all non required but visible graphics
+	void hideNonRequiredGraphics();
+
+
+	// Get mask of all graphics components that aren't required to be visible but currently are
+	ECvPlotGraphics getNonRequiredGraphicsMask() const;
+	void enableGraphicsPaging();
+	void disableGraphicsPaging();
+
+	//void setShouldHaveFullGraphics(bool bShouldHaveFullGraphics);
+	//bool shouldHaveFullGraphics() const;
 	bool shouldHaveGraphics() const;
+
 	bool at(int iX, int iY) const;																																		// Exposed to Python
 // BUG - Lat/Long Coordinates - start
 	int calculateMinutes(int iPlotIndex, int iPlotCount, bool bWrap, int iDegreeMin, int iDegreeMax) const;
@@ -1091,11 +1128,14 @@ friend CvPathPlotInfoStore;
 	const CvProperties* getPropertiesConst() const;
 
 	void pageGraphicsOut();
-	static void notePageRenderStart(int iRenderArea);
+	//static void notePageRenderStart(int iRenderArea);
 
 protected:
 	bool m_bInhibitCenterUnitCalculation;
 	bool m_bIgnoringImprovementUpgrade;
+
+	ECvPlotGraphics m_requiredVisibleGraphics;
+	ECvPlotGraphics m_visibleGraphics;
 	short m_iGraphicsPageIndex;
 };
 
diff --git a/Sources/Stopwatch.h b/Sources/Stopwatch.h
new file mode 100644
index 0000000000..46a703cd4d
--- /dev/null
+++ b/Sources/Stopwatch.h
@@ -0,0 +1,190 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+// Stopwatch.h  -- A simple stopwatch implementation, based on Windows
+//                 high-performance timers.
+//                 Can come in handy when measuring elapsed times of
+//                 portions of C++ code.
+//
+// Copyright (C) 2016 by Giovanni Dicanio <giovanni.dicanio@gmail.com>
+//
+// The MIT License (MIT)
+// 
+// Copyright (c) 2016 Giovanni Dicanio
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this softwareand associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and /or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions :
+// 
+// The above copyright noticeand this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+
+#pragma once
+
+//#include <crtdbg.h>     // For _ASSERTE
+#include <Windows.h>    // For high-performance timers
+
+
+namespace win32
+{
+
+
+	//------------------------------------------------------------------------------
+	// Class to measure time intervals, for benchmarking portions of code.
+	// It's a convenient wrapper around the Win32 high-resolution timer APIs
+	// QueryPerformanceCounter() and QueryPerformanceFrequency().
+	//------------------------------------------------------------------------------
+	class Stopwatch
+	{
+	public:
+		// Initialize the stopwatch to a safe initial state
+		Stopwatch();
+
+		// Clear the stopwatch state
+		void Reset();
+
+		// Start measuring time.
+		// When finished, call Stop().
+		// Can call ElapsedTime() also before calling Stop(): in this case,
+		// the elapsed time is measured since the Start() call.
+		void Start();
+
+		// Stop measuring time.
+		// Call ElapsedMilliseconds() to get the elapsed time from the Start() call.
+		void Stop();
+
+		// Return elapsed time interval duration, in milliseconds.
+		// Can be called both after Stop() and before it. 
+		// (Start() must have been called to initiate time interval measurements).
+		double ElapsedMilliseconds() const;
+
+
+		//
+		// Ban copy
+		//
+	private:
+		Stopwatch(const Stopwatch&);
+		Stopwatch& operator=(const Stopwatch&);
+
+
+		//
+		// *** IMPLEMENTATION ***
+		//
+	private:
+		bool m_running;                 // is the timer running?
+		long long m_start;              // start tick count
+		long long m_finish;             // end tick count
+		const long long m_frequency;    // cached frequency value
+
+		//
+		// According to MSDN documentation:
+		// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx
+		//
+		// The frequency of the performance counter is fixed at system boot and 
+		// is consistent across all processors. 
+		// Therefore, the frequency need only be queried upon application 
+		// initialization, and the result can be cached.
+		//
+
+		// Wrapper to Win32 API QueryPerformanceCounter()
+		static long long Counter();
+
+		// Wrapper to Win32 API QueryPerformanceFrequency()
+		static long long Frequency();
+
+		// Calculate elapsed time in milliseconds,
+		// given a start tick and end tick counts.
+		double ElapsedMilliseconds(long long start, long long finish) const;
+	};
+
+
+
+	//
+	// Inline implementations
+	//
+
+
+	inline Stopwatch::Stopwatch()
+		: m_running(false)
+		, m_start(0)
+		, m_finish(0)
+		, m_frequency(Frequency())
+	{}
+
+
+	inline void Stopwatch::Reset()
+	{
+		m_finish = m_start = 0;
+		m_running = false;
+	}
+
+
+	inline void Stopwatch::Start()
+	{
+		m_running = true;
+		m_finish = 0;
+
+		m_start = Counter();
+	}
+
+
+	inline void Stopwatch::Stop()
+	{
+		m_finish = Counter();
+		m_running = false;
+	}
+
+
+	inline double Stopwatch::ElapsedMilliseconds() const
+	{
+		if (m_running)
+		{
+			const long long current = Counter();
+			return ElapsedMilliseconds(m_start, current);
+		}
+
+		return ElapsedMilliseconds(m_start, m_finish);
+	}
+
+
+	inline long long Stopwatch::Counter()
+	{
+		LARGE_INTEGER li;
+		::QueryPerformanceCounter(&li);
+		return li.QuadPart;
+	}
+
+
+	inline long long Stopwatch::Frequency()
+	{
+		LARGE_INTEGER li;
+		::QueryPerformanceFrequency(&li);
+		return li.QuadPart;
+	}
+
+
+	inline double Stopwatch::ElapsedMilliseconds(long long start, long long finish) const
+	{
+		//_ASSERTE(start >= 0);
+		//_ASSERTE(finish >= 0);
+		//_ASSERTE(start <= finish);
+
+		return ((finish - start) * 1000.0) / m_frequency;
+	}
+
+
+} // namespace win32
+

From f19039468062a02ce06b1904ae4b1079112ad4e7 Mon Sep 17 00:00:00 2001
From: billw2012 <billw2011@gmail.com>
Date: Sat, 14 Sep 2019 11:25:47 +0100
Subject: [PATCH 2/4] feat(Paging v2): Configurable graphics paging options

Refactored the paging system into a separate file.
Also some other stuff into its own files from the game core header.
---
 Assets/XML/GlobalDefines.xml         |  51 ++-
 Sources/C2C (VS2019).vcxproj         |   4 +
 Sources/C2C (VS2019).vcxproj.filters |  12 +
 Sources/CvCity.cpp                   |   2 +-
 Sources/CvGame.cpp                   | 204 +----------
 Sources/CvGame.h                     |   4 -
 Sources/CvGameCoreDLL.h              |  89 +----
 Sources/CvPlot.cpp                   | 250 +++----------
 Sources/CvPlot.h                     | 524 ++++++++++++++-------------
 Sources/CvPlotPaging.cpp             | 313 ++++++++++++++++
 Sources/CvPlotPaging.h               |  13 +
 Sources/EnumFlags.h                  |  59 +++
 Sources/NiPoint.h                    | 102 ++++++
 13 files changed, 876 insertions(+), 751 deletions(-)
 create mode 100644 Sources/CvPlotPaging.cpp
 create mode 100644 Sources/CvPlotPaging.h
 create mode 100644 Sources/EnumFlags.h
 create mode 100644 Sources/NiPoint.h

diff --git a/Assets/XML/GlobalDefines.xml b/Assets/XML/GlobalDefines.xml
index a5079e2ea6..7baaacde75 100644
--- a/Assets/XML/GlobalDefines.xml
+++ b/Assets/XML/GlobalDefines.xml
@@ -22,15 +22,62 @@
 		<iDefineIntVal>100</iDefineIntVal>
 	</Define>
 
+	<!-- GRAPHICS PAGING OPTIONS -->
+
+	<!-- Start paging out if memory exceeds this amount (in KB) -->
 	<Define>
 		<DefineName>MAX_DESIRED_MEMORY_USED</DefineName>
 		<iDefineIntVal>1835008</iDefineIntVal>
 	</Define>
 
+	<!-- If specified, instead of MAX_DESIRED_MEMORY_USED, a set of test 
+		allocations will be performed to test for low memory conditions -->
+	<!-- Size of each test allocation -->
+	<!-- <Define>
+		<DefineName>PAGING_TEST_ALLOC</DefineName>
+		<iDefineIntVal>10240</iDefineIntVal>
+	</Define> -->
+	<!-- Number of test allocations -->
+	<!-- <Define>
+		<DefineName>PAGING_TEST_ALLOC_NUM</DefineName>
+		<iDefineIntVal>5</iDefineIntVal>
+	</Define> -->
+
+	<!-- Maximum amount of time in a frame that can be spent on paging operations.
+		Higher values mean faster paging in at the expense of more stuttering.
+	 -->
 	<Define>
-		<DefineName>PAGING_FRAME_TIME_MS</DefineName>
-		<iDefineIntVal>200</iDefineIntVal>
+		<DefineName>MAX_PAGING_FRAME_TIME_MS</DefineName>
+		<iDefineIntVal>100</iDefineIntVal>
+	</Define>
+	<!-- Distance in tiles at which to page in different components -->
+	 <Define>
+		<DefineName>PAGE_IN_DIST_SYMBOLS</DefineName>
+		<iDefineIntVal>100</iDefineIntVal>
+	</Define>
+	<Define>
+		<DefineName>PAGE_IN_DIST_FEATURES</DefineName>
+		<iDefineIntVal>5</iDefineIntVal>
 	</Define>
+	<Define>
+		<DefineName>PAGE_IN_DIST_RIVER</DefineName>
+		<iDefineIntVal>40</iDefineIntVal>
+	</Define>
+	<Define>
+		<DefineName>PAGE_IN_DIST_ROUTE</DefineName>
+		<iDefineIntVal>100</iDefineIntVal>
+	</Define>
+	<Define>
+		<DefineName>PAGE_IN_DIST_UNIT</DefineName>
+		<iDefineIntVal>15</iDefineIntVal>
+	</Define>
+	<Define>
+		<DefineName>PAGE_IN_DIST_CITY</DefineName>
+		<iDefineIntVal>15</iDefineIntVal>
+	</Define>
+	
+	<!-- GRAPHICS PAGING OPTIONS END -->
+
 	<!--
  Default uses the normal tag for the language set in Civ4's option dialog.
 	     All tags used in the text files are possible with English used as fallback when the chosen language is not available for some text.
diff --git a/Sources/C2C (VS2019).vcxproj b/Sources/C2C (VS2019).vcxproj
index 13fe2ac5fb..157b0bdc22 100644
--- a/Sources/C2C (VS2019).vcxproj	
+++ b/Sources/C2C (VS2019).vcxproj	
@@ -120,6 +120,7 @@
   <ItemGroup>
     <ClCompile Include="CvAllocator.cpp" />
     <ClCompile Include="CvAllocator.h" />
+    <ClCompile Include="CvPlotPaging.cpp" />
     <ClCompile Include="CyPlayerInterface3.cpp" />
     <ClCompile Include="_precompile.cpp" />
     <ClCompile Include="BetterBTSAI.cpp" />
@@ -263,6 +264,8 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BetterBTSAI.h" />
+    <ClInclude Include="CvPlotPaging.h" />
+    <ClInclude Include="EnumFlags.h" />
     <ClInclude Include="idinfo_iterator.h" />
     <ClInclude Include="CvMapExternal.h" />
     <ClInclude Include="CvMapInterfaceBase.h" />
@@ -306,6 +309,7 @@
     <ClInclude Include="CvDLLUtilityIFaceBase.h" />
     <ClInclude Include="CvDLLWidgetData.h" />
     <ClInclude Include="CvDLLXMLIFaceBase.h" />
+    <ClInclude Include="NiPoint.h" />
     <ClInclude Include="Stopwatch.h" />
     <ClInclude Include="wchar_utils.h" />
     <ClInclude Include="CvEnums.h" />
diff --git a/Sources/C2C (VS2019).vcxproj.filters b/Sources/C2C (VS2019).vcxproj.filters
index 79a19a8848..5e4baf7985 100644
--- a/Sources/C2C (VS2019).vcxproj.filters	
+++ b/Sources/C2C (VS2019).vcxproj.filters	
@@ -441,6 +441,9 @@
     <ClCompile Include="CvAllocator.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="CvPlotPaging.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="BetterBTSAI.h">
@@ -854,6 +857,15 @@
     <ClInclude Include="Stopwatch.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="EnumFlags.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="NiPoint.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="CvPlotPaging.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="CvGameCoreDLL.rc">
diff --git a/Sources/CvCity.cpp b/Sources/CvCity.cpp
index 5dcfab54e5..17e8715a74 100644
--- a/Sources/CvCity.cpp
+++ b/Sources/CvCity.cpp
@@ -21793,7 +21793,7 @@ class VisibleBuildingComparator
 void CvCity::getVisibleBuildings(std::list<BuildingTypes>& kChosenVisible, int& iChosenNumGenerics)
 {
 
-	if ( !plot()->isGraphicsRequiredVisible(PLOT_GRAPHICS_CITY) )
+	if ( !plot()->isGraphicsRequiredVisible(ECvPlotGraphics::CITY) )
 	{
 		iChosenNumGenerics = 0;
 		return;
diff --git a/Sources/CvGame.cpp b/Sources/CvGame.cpp
index b4ccb4201c..a2afd80049 100644
--- a/Sources/CvGame.cpp
+++ b/Sources/CvGame.cpp
@@ -31,9 +31,6 @@ CvGame::CvGame()
 : m_GameObject()
 , m_Properties(this)
 , m_iChokePointCalculationVersion(0)
-, m_iLastLookatX(-1)
-, m_iLastLookatY(-1)
-, m_bWasGraphicsPagingEnabled(false)
 , m_eCurrentMap(MAP_INITIAL)
 
 {
@@ -1183,9 +1180,8 @@ void CvGame::reset(HandicapTypes eHandicap, bool bConstructorCall)
 	m_lastGraphicUpdateRequestTickCount = -1;
 
 	m_plotGroupHashesInitialized = false;
-	m_bWasGraphicsPagingEnabled = false;
-	m_iLastLookatX = -1;
-	m_iLastLookatY = -1;
+
+	CvPlotPaging::ResetPaging();
 }
 
 
@@ -2647,37 +2643,6 @@ int CvGame::getTeamClosenessScore(int** aaiDistances, int* aiStartingLocs)
 	return iScore;
 }
 
-float ToroidalDistanceSq (int x1, int y1, int x2, int y2, int w, int h)
-{
-	float dx = std::abs(x2 - x1);
-	float dy = std::abs(y2 - y1);
-
-	if (dx > w/2)
-		dx = w - dx;
-
-	if (dy > h/2)
-		dy = h - dy;
-
-	return dx * dx + dy * dy;
-}
-
-struct PlotDist
-{
-	CvPlot* plot;
-	int dist2;
-
-	PlotDist(CvPlot* plot, int dist2) : plot(plot), dist2(dist2)
-	{
-	}
-
-	PlotDist() : plot(NULL), dist2(0) {}
-
-	bool operator<(const PlotDist& other) const
-	{
-		return dist2 < other.dist2;
-	}
-};
-
 void CvGame::update()
 {
 	MEMORY_TRACE_FUNCTION();
@@ -2696,170 +2661,7 @@ void CvGame::update()
 
 	startProfilingDLL(false);
 
-	CvPlot* lookatPlot = gDLL->getInterfaceIFace()->getLookAtPlot();
-	if ( lookatPlot != NULL )
-	{
-		//	Sample th BUG setting in the main thread on entry to game update here (it requires a Python call
-		//	so we don't want it happening in background, or more frequently than once per turn slice)
-		bool bPagingEnabled = getBugOptionBOOL("MainInterface__EnableGraphicalPaging", true);
-		GC.setGraphicalDetailPagingEnabled(bPagingEnabled);
-
-		//if (m_bWasGraphicsPagingEnabled != bPagingEnabled)
-		//{
-		//	for(int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
-		//	{
-		//		CvPlot*	pPlot = GC.getMapINLINE().plotByIndexINLINE(iI);
-		//		if ( pPlot != NULL )
-		//		{
-		//			if (m_bWasGraphicsPagingEnabled)
-		//			{
-		//				pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
-		//			}
-		//			else
-		//			{
-		//				pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, false);
-		//			}
-		//		}
-		//	}
-		//}
-
-		//m_bWasGraphicsPagingEnabled = bPagingEnabled;
-
-		{
-			int pageInRange2 = GC.getGraphicalDetailPageInRange() * GC.getGraphicalDetailPageInRange();
-			win32::Stopwatch pageTimer;
-			pageTimer.Start();
-			int centerX = lookatPlot->getX_INLINE();
-			int centerY = lookatPlot->getY_INLINE();
-			
-			int moveDist2 = (centerX - m_iLastLookatX) * (centerX - m_iLastLookatX) + (centerY - m_iLastLookatY) * (centerY - m_iLastLookatY);
-
-			int pagingFrameTime = 10 + 200 / (1 + moveDist2);
-
-			// Evict graphics first
-			while (CvPlot::EvictGraphicsIfNecessary() && pageTimer.ElapsedMilliseconds() < pagingFrameTime * 0.5) {}
-
-			static int Distances[] = {
-				100, //  PLOT_GRAPHICS_SYMBOLS
-				7, 	 //  PLOT_GRAPHICS_FEATURE
-				40,  //  PLOT_GRAPHICS_RIVER
-				100, //  PLOT_GRAPHICS_ROUTE
-				15,  //  PLOT_GRAPHICS_UNIT
-				5,  //  PLOT_GRAPHICS_CITY
-			};
-
-
-			std::vector<PlotDist> plots;
-			CvMap& map = GC.getMapINLINE();
-			plots.reserve(map.numPlotsINLINE());
-			for (int i = 0; i < map.numPlotsINLINE(); i++)
-			{
-				CvPlot* plot = map.plotByIndexINLINE(i);
-				if (plot != NULL)
-				{
-					plots.push_back(PlotDist(map.plotByIndexINLINE(i), ToroidalDistanceSq(centerX, centerY, plot->getX_INLINE(), plot->getY_INLINE(), map.getGridWidthINLINE(), map.getGridHeightINLINE())));
-				}
-			}
-
-			std::sort(plots.begin(), plots.end());
-
-			//for (int iI = 0; iI < GC.getMapINLINE().numPlotsINLINE() && pageTimer.ElapsedMilliseconds() < pagingFrameTime; iI++)
-			for(std::vector<PlotDist>::iterator itr = plots.begin(); itr != plots.end() && pageTimer.ElapsedMilliseconds() < pagingFrameTime; ++itr)
-			{
-				//CvPlot* pPlot = itr->plot;
-				if (bPagingEnabled)
-				{
-					//pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_FLAG, true);
-					for (int graphicsType = 0; graphicsType < PLOT_GRAPHICS_NUM; ++graphicsType)
-					{
-						if (Distances[graphicsType] != -1)
-						{
-							itr->plot->setRequireGraphicsVisible(static_cast<ECvPlotGraphics>(1 << graphicsType), itr->dist2 < Distances[graphicsType] * Distances[graphicsType]);
-						}
-					}
-				}
-				else
-				{
-					itr->plot->disableGraphicsPaging();
-				}
-			}
-
-			m_iLastLookatX = lookatPlot->getX_INLINE();
-			m_iLastLookatY = lookatPlot->getY_INLINE();
-		}
-
-		//if ( GC.getGraphicalDetailPagingEnabled() )
-		//{
-		//	//if ( (m_iLastLookatX != lookatPlot->getX_INLINE() || m_iLastLookatY != lookatPlot->getY_INLINE()) )
-		//	//{
-		//	int pageInRange = GC.getGraphicalDetailPageInRange();
-		//	//CvPlot::notePageRenderStart((pageInRange * 2 + 1) * (pageInRange * 2 + 1));
-
-		//	win32::Stopwatch pageTimer;
-		//	pageTimer.Start();
-		//	int pagingFrameTime = GC.getDefineINT("PAGING_FRAME_TIME_MS", 20);
-		//	// Spiral outward from center
-		//	for (int i = 0; i < pageInRange && pageTimer.ElapsedMilliseconds() < pagingFrameTime; i++)
-		//	{
-		//		for (int x = -i; x <= i && pageTimer.ElapsedMilliseconds() < pagingFrameTime; x++)
-		//		{
-		//			{
-		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), x, i);
-
-		//				if (pPlot != NULL)
-		//				{
-		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
-		//				}
-		//			}
-		//			{
-		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), x, -i);
-
-		//				if (pPlot != NULL)
-		//				{
-		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
-		//				}
-		//			}
-		//		}
-		//		for (int y = -i; y <= i && pageTimer.ElapsedMilliseconds() < pagingFrameTime; y++)
-		//		{
-		//			{
-		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), i, y);
-
-		//				if (pPlot != NULL)
-		//				{
-		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
-		//				}
-		//			}
-		//			{
-		//				CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), -i, y);
-
-		//				if (pPlot != NULL)
-		//				{
-		//					pPlot->setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
-		//				}
-		//			}
-		//		}
-		//	}
-		//	//for (int iX = -pageInRange; iX <= pageInRange && pageTimer.ElapsedMilliseconds() < pagingFrameTime; iX++)
-		//	//{
-		//	//	for (int iY = -pageInRange; iY <= pageInRange && pageTimer.ElapsedMilliseconds() < pagingFrameTime; iY++)
-		//	//	{
-		//	//		CvPlot* pPlot = plotXY(lookatPlot->getX_INLINE(), lookatPlot->getY_INLINE(), iX, iY);
-
-		//	//		if (pPlot != NULL)
-		//	//		{
-		//	//			pPlot->setShouldHaveFullGraphics(true);
-		//	//		}
-		//	//	}
-		//	//}
-
-		//	m_iLastLookatX = lookatPlot->getX_INLINE();
-		//	m_iLastLookatY = lookatPlot->getY_INLINE();
-		//	//}
-
-		//	CvPlot::EvictGraphicsIfNecessary();
-		//}
-	}
+	CvPlotPaging::UpdatePaging();
 
 	//OutputDebugString(CvString::format("Start profiling(false) for CvGame::update()\n").c_str());
 	PROFILE_BEGIN("CvGame::update");
diff --git a/Sources/CvGame.h b/Sources/CvGame.h
index be7f03c365..e2fb31d9fd 100644
--- a/Sources/CvGame.h
+++ b/Sources/CvGame.h
@@ -1014,10 +1014,6 @@ class CvGame
 	//	points evaluated
 	int m_iChokePointCalculationVersion;
 
-	int m_iLastLookatX;
-	int m_iLastLookatY;
-	bool m_bWasGraphicsPagingEnabled;
-
 public:
 	//	Super forts adaptation to C2C - calc choke points if not already done
 	void ensureChokePointsEvaluated();
diff --git a/Sources/CvGameCoreDLL.h b/Sources/CvGameCoreDLL.h
index 16f559a82c..8e897148ba 100644
--- a/Sources/CvGameCoreDLL.h
+++ b/Sources/CvGameCoreDLL.h
@@ -18,6 +18,8 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <MMSystem.h>
+#include <EnumFlags.h>
+
 //#if defined _DEBUG && !defined USE_MEMMANAGER
 //#define USE_MEMMANAGER
 //#include <crtdbg.h>
@@ -41,92 +43,7 @@
 
 #define DllExport   __declspec( dllexport ) 
 
-//
-// GameBryo
-//
-class NiColor
-{
-public:
-	float r, g, b;
-};
-class NiColorA 
-{
-public:
-	NiColorA(float fr, float fg, float fb, float fa) : r(fr), g(fg), b(fb), a(fa) {}
-	NiColorA() {}
-	float r, g, b, a;
-};
-class NiPoint2
-{
-public:
-	NiPoint2() {}
-	NiPoint2(float fx, float fy) : x(fx),y(fy) {}
-
-	float x, y;
-};
-class NiPoint3
-{
-public:
-	NiPoint3(): x(0.0f), y(0.0f), z(0.0f) {}
-	NiPoint3(float fx, float fy, float fz) : x(fx),y(fy),z(fz) {} 
-
-	bool operator== (const NiPoint3& pt) const
-	{	return (x == pt.x && y == pt.y && z == pt.z);	}
-
-	inline NiPoint3 operator+ (const NiPoint3& pt) const
-	{	return NiPoint3(x+pt.x,y+pt.y,z+pt.z);	}
-
-	inline NiPoint3 operator- (const NiPoint3& pt) const
-	{	return NiPoint3(x-pt.x,y-pt.y,z-pt.z);	}
-
-	inline float operator* (const NiPoint3& pt) const
-	{	return x*pt.x+y*pt.y+z*pt.z;	}
-
-	inline NiPoint3 operator* (float fScalar) const
-	{	return NiPoint3(fScalar*x,fScalar*y,fScalar*z);	}
-
-	inline NiPoint3 operator/ (float fScalar) const
-	{
-		float fInvScalar = 1.0f/fScalar;
-		return NiPoint3(fInvScalar*x,fInvScalar*y,fInvScalar*z);
-	}
-
-	inline NiPoint3 operator- () const
-	{	return NiPoint3(-x,-y,-z);	}
-
-	inline float Length() const
-	{ return sqrt(x * x + y * y + z * z); }
-
-	inline float Unitize()
-	{
-		float length = Length();
-		if(length != 0)
-		{
-			x /= length;
-			y /= length;
-			z /= length;
-		}
-		return length;
-	}
-
-//	inline NiPoint3 operator* (float fScalar, const NiPoint3& pt)
-//	{	return NiPoint3(fScalar*pt.x,fScalar*pt.y,fScalar*pt.z);	}
-	float x, y, z;
-};
-
-namespace NiAnimationKey
-{
-	enum KeyType
-	{
-		NOINTERP,
-		LINKEY,
-		BEZKEY,
-		TCBKEY,
-		EULERKEY,
-		STEPKEY,
-		NUMKEYTYPES
-	};
-};
+#include "NiPoint.h"
 
 typedef unsigned char    byte;
 typedef unsigned short   word;
diff --git a/Sources/CvPlot.cpp b/Sources/CvPlot.cpp
index e66b0d9f35..8e844e03b5 100644
--- a/Sources/CvPlot.cpp
+++ b/Sources/CvPlot.cpp
@@ -4,17 +4,8 @@
 #include "CvDLLSymbolIFaceBase.h"
 #include "CvDLLPlotBuilderIFaceBase.h"
 #include "CvDLLFlagEntityIFaceBase.h"
-/************************************************************************************************/
-/* Afforess	                  Start		 04/14/10                                               */
-/*                                                                                              */
-/*                                                                                              */
-/************************************************************************************************/
-#include <time.h>
-#include <psapi.h>
-/************************************************************************************************/
-/* Afforess	                     END                                                            */
-/************************************************************************************************/
 
+#include "CvPlotPaging.h"
 
 #define STANDARD_MINIMAP_ALPHA		(0.6f)
 
@@ -42,9 +33,9 @@ static stdext::hash_map<int, unitDefenderInfo>*	g_bestDefenderCache = NULL;
 CvPlot::CvPlot() 
 	: m_GameObject(this)
 	, m_Properties(this)
-	, m_visibleGraphics(PLOT_GRAPHICS_NONE)
-	, m_requiredVisibleGraphics(PLOT_GRAPHICS_NONE)
-	, m_iGraphicsPageIndex(-1)
+	, m_visibleGraphics(ECvPlotGraphics::NONE)
+	, m_requiredVisibleGraphics(ECvPlotGraphics::NONE)
+	, m_pagingHandle(CvPlotPaging::INVALID_HANDLE)
 {
 	if ( m_resultHashMap == NULL )
 	{
@@ -384,221 +375,81 @@ void CvPlot::reset(int iX, int iY, bool bConstructorCall)
 	m_bPlotGroupsDirty = false;
 }
 
-struct GraphicsPagingInfo
-{
-	CvPlot* pPlot;
-	unsigned int iSeq;
-	GraphicsPagingInfo () : pPlot(NULL), iSeq(0U) {}
-};
-
-static unsigned int iNumPagedInPlots = 0;
-// static unsigned int iRenderStartSeq = 0;
-static unsigned int iCurrentSeq = 0;
-static unsigned int iOldestSearchSeqHint = 0;
-static std::vector<GraphicsPagingInfo> pagingTable;
-
-#define	MAX_VALID_PAGING_INDEX 65534
-
-int findFreePagingTableSlot()
-{
-	static size_t iSearchStartHintIndex = 0;
-
-	for(size_t iI = 0; iI < pagingTable.size(); iI++)
-	{
-		int iIndex = iSearchStartHintIndex++;
-
-		if (iSearchStartHintIndex >= pagingTable.size())
-		{
-			iSearchStartHintIndex = 0;
-		}
-
-		if ( pagingTable[iIndex].pPlot == NULL )
-		{
-			return iIndex;
-		}
-	}
-
-	return -1;
-}
-
-int allocateNewPagingEntry()
-{
-	if (pagingTable.size() <= iNumPagedInPlots++ )
-	{
-		pagingTable.push_back(GraphicsPagingInfo());
-		return pagingTable.size() - 1;
-	}
-	else
-	{
-		return findFreePagingTableSlot();
-	}
-}
-
-int findOldestEvictablePagingEntry()
-{
-	unsigned int iOldest = MAX_INT;
-	int iResult = -1;
-
-	for(int iI = 0; iI < static_cast<int>(pagingTable.size()); iI++)
-	{
-		if ( pagingTable[iI].pPlot != NULL && pagingTable[iI].pPlot->getNonRequiredGraphicsMask() != PLOT_GRAPHICS_NONE)
-		{
-			if ( pagingTable[iI].iSeq < iOldest )
-			{
-				iOldest = pagingTable[iI].iSeq;
-				iResult = iI;
-			}
-		}
-	}
-
-	return iResult;
-}
-
-#define DEFAULT_MAX_WORKING_SET_THRESHOLD_BEFORE_EVICTION ((size_t)1024*(size_t)1024*(size_t)1024*(size_t)2)
-#define DEFAULT_OS_MEMORY_ALLOWANCE ((size_t)1024*(size_t)1024*(size_t)512)
-
-bool NeedToFreeMemory()
-{
-	PROCESS_MEMORY_COUNTERS pmc;
-	static unsigned int uiMaxMem = 0xFFFFFFFF;
-
-	if ( uiMaxMem == 0xFFFFFFFF )
-	{
-		MEMORYSTATUSEX memoryStatus;
-
-		memoryStatus.dwLength = sizeof(memoryStatus);
-		GlobalMemoryStatusEx(&memoryStatus);
-
-		uiMaxMem = 1024*GC.getDefineINT("MAX_DESIRED_MEMORY_USED", DEFAULT_MAX_WORKING_SET_THRESHOLD_BEFORE_EVICTION/1024);
-
-		DWORDLONG usableMemory = memoryStatus.ullTotalPhys - 1024*(DWORDLONG)GC.getDefineINT("OS_MEMORY_ALLOWANCE", DEFAULT_OS_MEMORY_ALLOWANCE/1024);
-		if ( usableMemory < uiMaxMem )
-		{
-			uiMaxMem = (unsigned int)usableMemory;
-		}
-	}
-
-	GetProcessMemoryInfo( GetCurrentProcess(), &pmc, sizeof(pmc));
-	
-	if ( pmc.WorkingSetSize > uiMaxMem )
-	{
-		OutputDebugString(CvString::format("Found need to free memory: %d used vs %d target\n", pmc.WorkingSetSize, uiMaxMem).c_str());
-		return true;
-	}
-	else
-	{
-		return false;
-	}
-}
-
-// static bool bFoundEvictable = true;
-
-bool CvPlot::EvictGraphicsIfNecessary()
-{
-	//bool bFoundEvictable = true;
-
-	//while(bFoundEvictable && NeedToFreeMemory())
-	//{
-	int iEvictionIndex = findOldestEvictablePagingEntry();
-
-	if ( iEvictionIndex == -1 )
-	{
-		return false;
-	}
-
-	pagingTable[iEvictionIndex].pPlot->hideNonRequiredGraphics();
-	return true;
-	//}
-}
 
 void CvPlot::pageGraphicsOut()
 {
-	//bFoundEvictable = true;
-
-	if ( m_iGraphicsPageIndex != -1 )
+	if ( m_pagingHandle != CvPlotPaging::INVALID_HANDLE)
 	{
-		pagingTable[m_iGraphicsPageIndex].pPlot = NULL;
-		--iNumPagedInPlots;
-		//if ( --iNumPagedInPlots == 0 )
-		//{
-		//	SAFE_DELETE_ARRAY(pagingTable);
-
-		//	iPageTableSize = 0;
-		//}
+		CvPlotPaging::RemovePlot(m_pagingHandle);
+		m_pagingHandle = CvPlotPaging::INVALID_HANDLE;
 	}
 
-	m_iGraphicsPageIndex = -1;
 }
 
-//void CvPlot::notePageRenderStart(int iRenderArea)
-//{
-//	iRenderStartSeq = std::max(0, iCurrentSeq-iRenderArea);
-//}
-
-void CvPlot::setRequireGraphicsVisible(ECvPlotGraphics graphics, bool visible)
+void CvPlot::setRequireGraphicsVisible(ECvPlotGraphics::type graphics, bool visible)
 {
 	if (visible)
 	{
-		m_requiredVisibleGraphics = static_cast<ECvPlotGraphics>(static_cast<int>(m_requiredVisibleGraphics) | static_cast<int>(graphics));
+		m_requiredVisibleGraphics = m_requiredVisibleGraphics | graphics;
 	}
 	else
 	{
-		m_requiredVisibleGraphics = static_cast<ECvPlotGraphics>(static_cast<int>(m_requiredVisibleGraphics) & ~static_cast<int>(graphics));
+		m_requiredVisibleGraphics = m_requiredVisibleGraphics & ~graphics;
 	}
 
 	showRequiredGraphics();
 }
 
-bool CvPlot::isGraphicsVisible(ECvPlotGraphics graphics) const
+bool CvPlot::isGraphicsVisible(ECvPlotGraphics::type graphics) const
 {
-	return (static_cast<int>(m_visibleGraphics) & static_cast<int>(graphics)) != 0;
+	return (m_visibleGraphics & graphics) != 0;
 }
 
-bool CvPlot::isGraphicsRequiredVisible(ECvPlotGraphics graphics) const
+bool CvPlot::isGraphicsRequiredVisible(ECvPlotGraphics::type graphics) const
 {
-	return (static_cast<int>(m_requiredVisibleGraphics) & static_cast<int>(graphics)) != 0;
+	return (m_requiredVisibleGraphics & graphics) != 0;
 }
 
 bool CvPlot::isGraphicPagingEnabled() const
 {
-	return m_iGraphicsPageIndex != -1;
+	return m_pagingHandle != CvPlotPaging::INVALID_HANDLE;
 }
 
 void CvPlot::showRequiredGraphics()
 {
-	ECvPlotGraphics toShow = static_cast<ECvPlotGraphics>((m_requiredVisibleGraphics ^ m_visibleGraphics) & m_requiredVisibleGraphics);
+	ECvPlotGraphics::type toShow = (m_requiredVisibleGraphics ^ m_visibleGraphics) & m_requiredVisibleGraphics;
 
 	if (!isGraphicPagingEnabled())
 	{
 		enableGraphicsPaging();
 	}
 
-	if (toShow != PLOT_GRAPHICS_NONE)
+	if (toShow != ECvPlotGraphics::NONE)
 	{
 		setLayoutDirty(true);
 	}
-	if (toShow & PLOT_GRAPHICS_SYMBOLS)
+	if (toShow & ECvPlotGraphics::SYMBOLS)
 	{
 		updateSymbols();
 	}
-	if (toShow & PLOT_GRAPHICS_FEATURE)
+	if (toShow & ECvPlotGraphics::FEATURE)
 	{
 		updateFeatureSymbol();
 	}
-	if (toShow & PLOT_GRAPHICS_RIVER)
+	if (toShow & ECvPlotGraphics::RIVER)
 	{
 		updateRiverSymbol();
 	}
-	if (toShow & PLOT_GRAPHICS_ROUTE)
+	if (toShow & ECvPlotGraphics::ROUTE)
 	{
 		updateRouteSymbol();
 	}
-	if (toShow & PLOT_GRAPHICS_UNIT)
+	if (toShow & ECvPlotGraphics::UNIT)
 	{
 		updateCenterUnit();
 		updateFlagSymbol();
 	}
-	if (toShow & PLOT_GRAPHICS_CITY)
+	if (toShow & ECvPlotGraphics::CITY)
 	{
 		if (getPlotCity() != NULL)
 		{
@@ -606,18 +457,18 @@ void CvPlot::showRequiredGraphics()
 		}
 	}
 
-	m_visibleGraphics = static_cast<ECvPlotGraphics>(m_visibleGraphics | toShow);
+	m_visibleGraphics = m_visibleGraphics | toShow;
 }
 
 void CvPlot::hideNonRequiredGraphics()
 {
-	ECvPlotGraphics toHide = getNonRequiredGraphicsMask();
+	ECvPlotGraphics::type toHide = getNonRequiredGraphicsMask();
 
-	if (toHide & PLOT_GRAPHICS_SYMBOLS)
+	if (toHide & ECvPlotGraphics::SYMBOLS)
 	{
 		deleteAllSymbols();
 	}
-	if (toHide & PLOT_GRAPHICS_FEATURE)
+	if (toHide & ECvPlotGraphics::FEATURE)
 	{
 		gDLL->getFeatureIFace()->destroy(m_pFeatureSymbol);
 		m_pFeatureSymbol = NULL;
@@ -627,17 +478,17 @@ void CvPlot::hideNonRequiredGraphics()
 			m_pPlotBuilder = NULL;
 		}
 	}
-	if (toHide & PLOT_GRAPHICS_RIVER)
+	if (toHide & ECvPlotGraphics::RIVER)
 	{
 		gDLL->getRiverIFace()->destroy(m_pRiverSymbol);
 		m_pRiverSymbol = NULL;
 	}
-	if (toHide & PLOT_GRAPHICS_ROUTE)
+	if (toHide & ECvPlotGraphics::ROUTE)
 	{
 		gDLL->getRouteIFace()->destroy(m_pRouteSymbol);
 		m_pRouteSymbol = NULL;
 	}
-	if (toHide & PLOT_GRAPHICS_UNIT)
+	if (toHide & ECvPlotGraphics::UNIT)
 	{
 		updateCenterUnit();
 		m_pCenterUnit = NULL;
@@ -646,7 +497,7 @@ void CvPlot::hideNonRequiredGraphics()
 		m_pFlagSymbol = NULL;
 		m_pFlagSymbolOffset = NULL;
 	}
-	if (toHide & PLOT_GRAPHICS_CITY)
+	if (toHide & ECvPlotGraphics::CITY)
 	{
 		if (getPlotCity() != NULL)
 		{
@@ -654,39 +505,34 @@ void CvPlot::hideNonRequiredGraphics()
 		}
 	}
 
-	m_visibleGraphics = static_cast<ECvPlotGraphics>(m_visibleGraphics & ~toHide);
+	m_visibleGraphics = m_visibleGraphics & ~toHide;
 	// All graphics are pages out now so we can remove ourselves from the active plot list
-	if (m_visibleGraphics == PLOT_GRAPHICS_NONE)
+	if (m_visibleGraphics == ECvPlotGraphics::NONE)
 	{
 		pageGraphicsOut();
 	}
 
 }
 
-ECvPlotGraphics CvPlot::getNonRequiredGraphicsMask() const
+ECvPlotGraphics::type CvPlot::getNonRequiredGraphicsMask() const
 {
-	return static_cast<ECvPlotGraphics>((m_requiredVisibleGraphics ^ m_visibleGraphics) & m_visibleGraphics);
+	return (m_requiredVisibleGraphics ^ m_visibleGraphics) & m_visibleGraphics;
 }
 
 void CvPlot::enableGraphicsPaging()
 {
 	FAssertMsg(!isGraphicPagingEnabled(), "Graphics paging is already enabled");
 
-	m_iGraphicsPageIndex = allocateNewPagingEntry();
-
-	GraphicsPagingInfo* pPagingInfo = &pagingTable[m_iGraphicsPageIndex];
-
-	pPagingInfo->iSeq = ++iCurrentSeq;
-	pPagingInfo->pPlot = this;
+	m_pagingHandle = CvPlotPaging::AddPlot(this);
 }
 
 void CvPlot::disableGraphicsPaging()
 {
 	FAssertMsg(isGraphicPagingEnabled(), "Graphics paging is not enabled");
 	// Show all graphics, as we aren't paging any more
-	setRequireGraphicsVisible(PLOT_GRAPHICS_ALL, true);
+	setRequireGraphicsVisible(ECvPlotGraphics::ALL, true);
 	// Disable paging 
-	m_iGraphicsPageIndex = -1;
+	pageGraphicsOut();
 }
 
 //bool	CvPlot::shouldHaveFullGraphics() const
@@ -1292,7 +1138,7 @@ void CvPlot::updateSymbolDisplay()
 	CvSymbol* pLoopSymbol;
 	int iLoop;
 
-	if ( !isGraphicsVisible(PLOT_GRAPHICS_SYMBOLS))
+	if ( !isGraphicsVisible(ECvPlotGraphics::SYMBOLS))
 	{
 		return;
 	}
@@ -1325,7 +1171,7 @@ void CvPlot::updateSymbolVisibility()
 	CvSymbol* pLoopSymbol;
 	int iLoop;
 
-	if ( !isGraphicsVisible(PLOT_GRAPHICS_SYMBOLS) )
+	if ( !isGraphicsVisible(ECvPlotGraphics::SYMBOLS) )
 	{
 		return;
 	}
@@ -1357,7 +1203,7 @@ bool CvPlot::updateSymbolsInternal()
 	MEMORY_TRACK_EXEMPT();
 	PROFILE_FUNC();
 
-	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_SYMBOLS))
+	if ( !isGraphicsRequiredVisible(ECvPlotGraphics::SYMBOLS))
 	{
 		return false;
 	}
@@ -1464,7 +1310,7 @@ void CvPlot::updateCenterUnit()
 	CvUnit* pOldCenterUnit = getCenterUnit();
 	CvUnit* pNewCenterUnit;
 
-	if ( m_bInhibitCenterUnitCalculation || !isGraphicsRequiredVisible(PLOT_GRAPHICS_UNIT) )
+	if ( m_bInhibitCenterUnitCalculation || !isGraphicsRequiredVisible(ECvPlotGraphics::UNIT) )
 	{
 		//	Because we are inhibitting recalculation until all the adjusting code has run
 		//	(rather than have it update multiple times) the currently cached center unit
@@ -12249,7 +12095,7 @@ void CvPlot::updateFeatureSymbolVisibility()
 {
 	PROFILE_FUNC();
 
-	if (!isGraphicsVisible(PLOT_GRAPHICS_FEATURE))
+	if (!isGraphicsVisible(ECvPlotGraphics::FEATURE))
 	{
 		return;
 	}
@@ -12293,7 +12139,7 @@ void CvPlot::updateFeatureSymbol(bool bForce)
 		gDLL->getEngineIFace()->RebuildTileArt(getViewportX(),getViewportY());
 	}
 
-	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_FEATURE) )
+	if ( !isGraphicsRequiredVisible(ECvPlotGraphics::FEATURE) )
 	{
 		return;
 	}
@@ -12340,7 +12186,7 @@ void CvPlot::updateRouteSymbol(bool bForce, bool bAdjacent)
 	RouteTypes eRoute;
 	int iI;
 
-	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_ROUTE) )
+	if ( !isGraphicsRequiredVisible(ECvPlotGraphics::ROUTE) )
 	{
 		return;
 	}
@@ -12400,7 +12246,7 @@ void CvPlot::updateRiverSymbol(bool bForce, bool bAdjacent)
 
 	CvPlot* pAdjacentPlot;
 
-	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_RIVER) )
+	if ( !isGraphicsRequiredVisible(ECvPlotGraphics::RIVER) )
 	{
 		return;
 	}
@@ -12504,7 +12350,7 @@ void CvPlot::updateFlagSymbol()
 {
 	PROFILE_FUNC();
 
-	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_UNIT) )
+	if ( !isGraphicsRequiredVisible(ECvPlotGraphics::UNIT) )
 	{
 		return;
 	}
@@ -14632,7 +14478,7 @@ void CvPlot::setLayoutDirty(bool bDirty)
 
 bool CvPlot::updatePlotBuilder()
 {
-	if ( !isGraphicsRequiredVisible(PLOT_GRAPHICS_FEATURE) )
+	if ( !isGraphicsRequiredVisible(ECvPlotGraphics::FEATURE) )
 	{
 		return false;
 	}
diff --git a/Sources/CvPlot.h b/Sources/CvPlot.h
index 56f3d4e0ab..0e8ecfc91a 100644
--- a/Sources/CvPlot.h
+++ b/Sources/CvPlot.h
@@ -2,9 +2,6 @@
 
 // CvPlot.h
 
-#ifndef CIV4_PLOT_H
-#define CIV4_PLOT_H
-
 //#include "CvStructs.h"
 #include "LinkedList.h"
 #include <bitset>
@@ -13,6 +10,8 @@
 #include "CvUnit.h"
 #include "idinfo_iterator.h"
 
+#include "CvPlotPaging.h"
+
 class CvSelectionGroup;
 
 #pragma warning( disable: 4251 )		// needs to have dll-interface to be used by clients of class
@@ -68,18 +67,40 @@ class canBuildCache
 };
 #endif
 
-enum ECvPlotGraphics
+// Enum representing the graphical various components of a plot
+struct ECvPlotGraphics
 {
-	PLOT_GRAPHICS_NONE = 0,
-	PLOT_GRAPHICS_SYMBOLS = 1 << 0,
-	PLOT_GRAPHICS_FEATURE = 1 << 1,
-	PLOT_GRAPHICS_RIVER = 1 << 2,
-	PLOT_GRAPHICS_ROUTE = 1 << 3,
-	PLOT_GRAPHICS_UNIT = 1 << 4,
-	PLOT_GRAPHICS_CITY = 1 << 5,
-	PLOT_GRAPHICS_ALL = PLOT_GRAPHICS_SYMBOLS | PLOT_GRAPHICS_FEATURE | PLOT_GRAPHICS_RIVER | PLOT_GRAPHICS_ROUTE | PLOT_GRAPHICS_UNIT | PLOT_GRAPHICS_CITY,
-	PLOT_GRAPHICS_NUM = 6
-}; 
+	enum type {
+		// WHAT					MEM		SPEED
+		// ==================================
+		NONE = 0,
+		// Yield icons			Low		Fast 
+		SYMBOLS = 1 << 0,
+		// Improvements,
+		// Resources,
+		// Terrain features		High	Slow
+		FEATURE = 1 << 1,
+		// Rivers				Low		Fast
+		RIVER = 1 << 2,
+		// Roads, paths, rail	Low		Fast
+		ROUTE = 1 << 3,
+		// Units				High	Med
+		// Depends a lot on line of sight
+		UNIT = 1 << 4,
+		// Cities				High	Med
+		CITY = 1 << 5,
+		ALL = SYMBOLS | FEATURE | RIVER | ROUTE | UNIT | CITY,
+		NUM = 6
+	};
+
+	// Get enum flag by index, for use in for loops and the like
+	static inline type fromIndex(int idx) 
+	{ 
+		FAssertMsg(idx >= 0 && idx < type::NUM, "Enum index out of range");
+		return static_cast<type>(1 << idx); 
+	}
+};
+DEFINE_ENUM_FLAG_OPERATORS(ECvPlotGraphics::type);
 
 class CvPlot
 {
@@ -122,8 +143,8 @@ friend CvPathPlotInfoStore;
 	void setupGraphical();
 	void updateGraphicEra();
 
-	void erase();																																								// Exposed to Python
-																																							// Exposed to Python
+	void erase(); // Exposed to Python
+
 /*********************************/
 /***** Parallel Maps - Begin *****/
 /*********************************/
@@ -134,15 +155,15 @@ friend CvPathPlotInfoStore;
 /***** Parallel Maps - End *****/
 /*******************************/	
 
-	DllExport float getPointX() const;														
-	DllExport float getPointY() const;														
-	DllExport NiPoint3 getPoint() const;																																	// Exposed to Python
+	DllExport float getPointX() const;
+	DllExport float getPointY() const;
+	DllExport NiPoint3 getPoint() const; // Exposed to Python
 
 	float getSymbolSize() const;
 	DllExport float getSymbolOffsetX(int iID) const;
 	DllExport float getSymbolOffsetY(int iID) const;
 
-	TeamTypes getTeam() const;																																	// Exposed to Python
+	TeamTypes getTeam() const; // Exposed to Python
 
 	void doTurn();
 
@@ -165,25 +186,25 @@ friend CvPathPlotInfoStore;
 
 	void verifyUnitValidPlot();
 
-	void nukeExplosion(int iRange, CvUnit* pNukeUnit = NULL);																							// Exposed to Python
+	void nukeExplosion(int iRange, CvUnit* pNukeUnit = NULL); // Exposed to Python
 
-	bool isConnectedTo( const CvCity* pCity) const;																												// Exposed to Python
-	bool isConnectedToCapital(PlayerTypes ePlayer = NO_PLAYER) const;																			// Exposed to Python
-	int getPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const;													// Exposed to Python
-	bool isPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const;								// Exposed to Python
-	bool isAdjacentPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const;				// Exposed to Python
+	bool isConnectedTo( const CvCity* pCity) const; // Exposed to Python
+	bool isConnectedToCapital(PlayerTypes ePlayer = NO_PLAYER) const; // Exposed to Python
+	int getPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const; // Exposed to Python
+	bool isPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const; // Exposed to Python
+	bool isAdjacentPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const; // Exposed to Python
 	void updatePlotGroupBonus(bool bAdd);
 
 	bool isAdjacentToArea(int iAreaID) const;
-	bool isAdjacentToArea(const CvArea* pArea) const;																						// Exposed to Python
-	bool shareAdjacentArea( const CvPlot* pPlot) const;																					// Exposed to Python
-	bool isAdjacentToLand() const;																															// Exposed to Python 
-	bool isCoastalLand(int iMinWaterSize = -1) const;																																	// Exposed to Python
+	bool isAdjacentToArea(const CvArea* pArea) const; // Exposed to Python
+	bool shareAdjacentArea( const CvPlot* pPlot) const; // Exposed to Python
+	bool isAdjacentToLand() const; // Exposed to Python 
+	bool isCoastalLand(int iMinWaterSize = -1) const; // Exposed to Python
 
 	bool isVisibleWorked() const;
-	bool isWithinTeamCityRadius(TeamTypes eTeam, PlayerTypes eIgnorePlayer = NO_PLAYER) const;	// Exposed to Python
+	bool isWithinTeamCityRadius(TeamTypes eTeam, PlayerTypes eIgnorePlayer = NO_PLAYER) const; // Exposed to Python
 
-	DllExport bool isLake() const;																															// Exposed to Python
+	DllExport bool isLake() const; // Exposed to Python
 /************************************************************************************************/
 /* Afforess	                  Start		 07/22/10                                               */
 /*                                                                                              */
@@ -192,27 +213,27 @@ friend CvPathPlotInfoStore;
 /*
 	bool isFreshWater() const;
 */
-	bool isFreshWater(bool bIgnoreJungle = false) const;
+	bool isFreshWater(bool bIgnoreJungle = false) const; // Exposed to Python ?
 /************************************************************************************************/
 /* Afforess	                     END                                                            */
 /************************************************************************************************/
-																													// Exposed to Python
-	bool isPotentialIrrigation() const;																													// Exposed to Python
-	bool canHavePotentialIrrigation() const;																										// Exposed to Python
-	DllExport bool isIrrigationAvailable(bool bIgnoreSelf = false) const;												// Exposed to Python
+
+	bool isPotentialIrrigation() const; // Exposed to Python
+	bool canHavePotentialIrrigation() const; // Exposed to Python
+	DllExport bool isIrrigationAvailable(bool bIgnoreSelf = false) const; // Exposed to Python
 
 	bool isRiverMask() const;
 	DllExport bool isRiverCrossingFlowClockwise(DirectionTypes eDirection) const;
-	bool isRiverSide() const;																																		// Exposed to Python
-	bool isRiver() const;																																				// Exposed to Python
-	bool isRiverConnection(DirectionTypes eDirection) const;																		// Exposed to Python
+	bool isRiverSide() const; // Exposed to Python
+	bool isRiver() const; // Exposed to Python
+	bool isRiverConnection(DirectionTypes eDirection) const; // Exposed to Python
 
 	CvPlot* getNearestLandPlotInternal(int iDistance) const;
-	int getNearestLandArea() const;																															// Exposed to Python
-	CvPlot* getNearestLandPlot() const;																													// Exposed to Python
+	int getNearestLandArea() const; // Exposed to Python
+	CvPlot* getNearestLandPlot() const; // Exposed to Python
 
-	int seeFromLevel(TeamTypes eTeam) const;																										// Exposed to Python  
-	int seeThroughLevel() const;																																// Exposed to Python
+	int seeFromLevel(TeamTypes eTeam) const; // Exposed to Python  
+	int seeThroughLevel() const; // Exposed to Python
 	void changeAdjacentSight(TeamTypes eTeam, int iRange, bool bIncrement, CvUnit* pUnit, bool bUpdatePlotGroups);
 	bool canSeePlot(CvPlot *plot, TeamTypes eTeam, int iRange, DirectionTypes eFacingDirection) const;
 	bool canSeeDisplacementPlot(TeamTypes eTeam, int dx, int dy, int originalDX, int originalDY, bool firstPlot, bool outerRing) const;
@@ -229,28 +250,28 @@ friend CvPathPlotInfoStore;
 /*                                                                                              */
 /*                                                                                              */
 /************************************************************************************************/
-	bool canHaveImprovement(ImprovementTypes eImprovement, TeamTypes eTeam = NO_TEAM, bool bPotential = false, bool bOver = true, bool bUpgradeCheck = false) const;		// Exposed to Python
+	bool canHaveImprovement(ImprovementTypes eImprovement, TeamTypes eTeam = NO_TEAM, bool bPotential = false, bool bOver = true, bool bUpgradeCheck = false) const; // Exposed to Python
 /************************************************************************************************/
 /* Afforess	                     END                                                            */
 /************************************************************************************************/
 
-	bool canBuild(BuildTypes eBuild, PlayerTypes ePlayer = NO_PLAYER, bool bTestVisible = false, bool bIncludePythonOverrides = true) const;						// Exposed to Python												// Exposed to Python
+	bool canBuild(BuildTypes eBuild, PlayerTypes ePlayer = NO_PLAYER, bool bTestVisible = false, bool bIncludePythonOverrides = true) const; // Exposed to Python												// Exposed to Python
 	static bool hasCachedCanBuildEntry(int iX, int iY, BuildTypes eBuild, PlayerTypes ePlayer, struct canBuildCacheEntry*& entry);
 	long canBuildFromPython(BuildTypes eBuild, PlayerTypes ePlayer) const;
 	long canBuildFromPythonInternal(BuildTypes eBuild, PlayerTypes ePlayer) const;
-	int getBuildTime(BuildTypes eBuild) const;																																										// Exposed to Python
+	int getBuildTime(BuildTypes eBuild) const; // Exposed to Python
 // BUG - Partial Builds - start
 	int getBuildTurnsLeft(BuildTypes eBuild, PlayerTypes ePlayer) const;
-	int getBuildTurnsLeft(BuildTypes eBuild, int iNowExtra, int iThenExtra, bool bIncludeUnits = true) const;																			// Exposed to Python
+	int getBuildTurnsLeft(BuildTypes eBuild, int iNowExtra, int iThenExtra, bool bIncludeUnits = true) const; // Exposed to Python
 // BUG - Partial Builds - end
-	int getFeatureProduction(BuildTypes eBuild, TeamTypes eTeam, CvCity** ppCity) const;																// Exposed to Python
+	int getFeatureProduction(BuildTypes eBuild, TeamTypes eTeam, CvCity** ppCity) const; // Exposed to Python
 
 	DllExport CvUnit* getBestDefenderExternal(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false) const;
-	CvUnit* getBestDefender(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false, bool bAssassinate = false, bool bClearCache = false) const;		// Exposed to Python
+	CvUnit* getBestDefender(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false, bool bAssassinate = false, bool bClearCache = false) const; // Exposed to Python
 	CvUnit* getFirstDefender(PlayerTypes eOwner, PlayerTypes eAttackingPlayer, const CvUnit* pAttacker, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false) const;
-	int AI_sumStrength(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, DomainTypes eDomainType = NO_DOMAIN, bool bDefensiveBonuses = true, bool bTestAtWar = false, bool bTestPotentialEnemy = false, int iRange = 0) const;	
-	CvUnit* getSelectedUnit() const;																																// Exposed to Python				
-	int getUnitPower(PlayerTypes eOwner = NO_PLAYER) const;																					// Exposed to Python	
+	int AI_sumStrength(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, DomainTypes eDomainType = NO_DOMAIN, bool bDefensiveBonuses = true, bool bTestAtWar = false, bool bTestPotentialEnemy = false, int iRange = 0) const;
+	CvUnit* getSelectedUnit() const; // Exposed to Python				
+	int getUnitPower(PlayerTypes eOwner = NO_PLAYER) const; // Exposed to Python	
 	/*int getUnitNukeIntercept(PlayerTypes eOwner) const;*/
 
 	// Super Forts begin *bombard*
@@ -283,22 +304,21 @@ friend CvPathPlotInfoStore;
 	void calculateChokeValue();
 	// Super Forts end
 
-	int defenseModifier(TeamTypes eDefender, bool bIgnoreBuilding, bool bHelp = false) const;									// Exposed to Python				
-	int movementCost(const CvUnit* pUnit, const CvPlot* pFromPlot) const;														// Exposed to Python				
+	int defenseModifier(TeamTypes eDefender, bool bIgnoreBuilding, bool bHelp = false) const; // Exposed to Python				
+	int movementCost(const CvUnit* pUnit, const CvPlot* pFromPlot) const; // Exposed to Python				
 	static void flushMovementCostCache();
 
-	int getExtraMovePathCost() const;																																// Exposed to Python
-	void changeExtraMovePathCost(int iChange);		
-																														// Exposed to Python
+	int getExtraMovePathCost() const; // Exposed to Python
+	void changeExtraMovePathCost(int iChange); // Exposed to Python
 	//	Koshling - count of mountain leaders present per team maintained for efficiency of movement calculations
 	// TB: This was not working properly so has been changed to a plotcount method.
 	int getHasMountainLeader(TeamTypes eTeam) const;
 	
-	bool isAdjacentOwned() const;																																		// Exposed to Python
-	bool isAdjacentPlayer(PlayerTypes ePlayer, bool bLandOnly = false) const;												// Exposed to Python
-	bool isAdjacentTeam(TeamTypes eTeam, bool bLandOnly = false) const;															// Exposed to Python
-	bool isWithinCultureRange(PlayerTypes ePlayer, int* iFoundRange = NULL) const;																						// Exposed to Python
-	int getNumCultureRangeCities(PlayerTypes ePlayer) const;																				// Exposed to Python
+	bool isAdjacentOwned() const; // Exposed to Python
+	bool isAdjacentPlayer(PlayerTypes ePlayer, bool bLandOnly = false) const; // Exposed to Python
+	bool isAdjacentTeam(TeamTypes eTeam, bool bLandOnly = false) const; // Exposed to Python
+	bool isWithinCultureRange(PlayerTypes ePlayer, int* iFoundRange = NULL) const; // Exposed to Python
+	int getNumCultureRangeCities(PlayerTypes ePlayer) const; // Exposed to Python
 /************************************************************************************************/
 /* BETTER_BTS_AI_MOD                      11/30/08                                jdog5000      */
 /*                                                                                              */
@@ -379,7 +399,7 @@ friend CvPathPlotInfoStore;
 	CvUnit* getWorstDefender(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false) const;
 	bool isBorder(bool bIgnoreWater = false) const;
 	
-	int getNumVisibleAdjacentEnemyDefenders(const CvUnit* pUnit) const;		
+	int getNumVisibleAdjacentEnemyDefenders(const CvUnit* pUnit) const;
 	
 	void addSign(PlayerTypes ePlayer, CvWString szMessage);
 	void removeSign(PlayerTypes ePlayer);
@@ -421,36 +441,36 @@ friend CvPathPlotInfoStore;
 	int plotStrength(UnitValueFlags eFlags, ConstPlotUnitFunc funcA, int iData1A = -1, int iData2A = -1, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM, ConstPlotUnitFunc funcB = NULL, int iData1B = -1, int iData2B = -1, int iRange = 0) const;
 	int plotStrengthTimes100(UnitValueFlags eFlags, ConstPlotUnitFunc funcA, int iData1A = -1, int iData2A = -1, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM, ConstPlotUnitFunc funcB = NULL, int iData1B = -1, int iData2B = -1, int iRange = 0) const;
 
-	bool isOwned() const;																																							// Exposed to Python
-	bool isBarbarian() const;																																						// Exposed to Python
-	bool isNPC() const;																																					// Exposed to Python
-	bool isHominid() const;																																					// Exposed to Python
-	bool isRevealedBarbarian() const;																																	// Exposed to Python
-
-	bool isVisible(TeamTypes eTeam, bool bDebug) const;																			// Exposed to Python
-	DllExport bool isActiveVisible(bool bDebug) const;																								// Exposed to Python
-	bool isVisibleToCivTeam() const;																																	// Exposed to Python
-	bool isVisibleToWatchingHuman() const;																														// Exposed to Python
-	bool isAdjacentVisible(TeamTypes eTeam, bool bDebug) const;																				// Exposed to Python
-	bool isAdjacentNonvisible(TeamTypes eTeam) const;																				// Exposed to Python
-
-	DllExport bool isGoody(TeamTypes eTeam = NO_TEAM) const;																					// Exposed to Python
-	bool isRevealedGoody(TeamTypes eTeam = NO_TEAM) const;																						// Exposed to Python
-	void removeGoody();																																								// Exposed to Python
-
-	DllExport bool isCity(bool bCheckImprovement = false, TeamTypes eForTeam = NO_TEAM) const;																																		// Exposed to Python
-	bool isFriendlyCity(const CvUnit& kUnit, bool bCheckImprovement) const;																												// Exposed to Python
-	bool isEnemyCity(const CvUnit& kUnit, bool bOnlyRealCities = false) const;																													// Exposed to Python
-
-	bool isOccupation() const;																																				// Exposed to Python
-	bool isBeingWorked() const;																															// Exposed to Python
-
-	bool isUnit() const;																																							// Exposed to Python
-	bool isInvestigate(TeamTypes eTeam) const;																												// Exposed to Python
-	bool isVisibleEnemyDefender(const CvUnit* pUnit) const;																						// Exposed to Python
+	bool isOwned() const; // Exposed to Python
+	bool isBarbarian() const; // Exposed to Python
+	bool isNPC() const; // Exposed to Python
+	bool isHominid() const; // Exposed to Python
+	bool isRevealedBarbarian() const; // Exposed to Python
+
+	bool isVisible(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
+	DllExport bool isActiveVisible(bool bDebug) const; // Exposed to Python
+	bool isVisibleToCivTeam() const; // Exposed to Python
+	bool isVisibleToWatchingHuman() const; // Exposed to Python
+	bool isAdjacentVisible(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
+	bool isAdjacentNonvisible(TeamTypes eTeam) const; // Exposed to Python
+
+	DllExport bool isGoody(TeamTypes eTeam = NO_TEAM) const; // Exposed to Python
+	bool isRevealedGoody(TeamTypes eTeam = NO_TEAM) const; // Exposed to Python
+	void removeGoody(); // Exposed to Python
+
+	DllExport bool isCity(bool bCheckImprovement = false, TeamTypes eForTeam = NO_TEAM) const; // Exposed to Python
+	bool isFriendlyCity(const CvUnit& kUnit, bool bCheckImprovement) const; // Exposed to Python
+	bool isEnemyCity(const CvUnit& kUnit, bool bOnlyRealCities = false) const; // Exposed to Python
+
+	bool isOccupation() const; // Exposed to Python
+	bool isBeingWorked() const; // Exposed to Python
+
+	bool isUnit() const; // Exposed to Python
+	bool isInvestigate(TeamTypes eTeam) const; // Exposed to Python
+	bool isVisibleEnemyDefender(const CvUnit* pUnit) const; // Exposed to Python
 	CvUnit *getVisibleEnemyDefender(PlayerTypes ePlayer) const;
 	int getNumDefenders(PlayerTypes ePlayer) const;
-	int getNumAttackers(PlayerTypes ePlayer) const;																													// Exposed to Python
+	int getNumAttackers(PlayerTypes ePlayer) const; // Exposed to Python
 	int getNumVisibleEnemyDefenders(const CvUnit* pUnit) const;
 	int getNumCriminals() const;
 	int getNumPlayerUnitAI(UnitAITypes eUnitAI, PlayerTypes ePlayer) const;
@@ -459,39 +479,39 @@ friend CvPathPlotInfoStore;
 	int getNumVisiblePotentialEnemyDefenderless(const CvUnit* pUnit) const;
 	bool isVisiblePotentialEnemyDefender(const CvUnit* pUnit) const;
 	bool isVisiblePotentialEnemyDefenderless(const CvUnit* pUnit) const;
-	DllExport bool isVisibleEnemyUnit(PlayerTypes ePlayer) const;																			// Exposed to Python
+	DllExport bool isVisibleEnemyUnit(PlayerTypes ePlayer) const; // Exposed to Python
 	DllExport int getNumVisibleUnits(PlayerTypes ePlayer) const;
 	bool isVisibleEnemyUnit(const CvUnit* pUnit) const;
-	bool isVisibleOtherUnit(PlayerTypes ePlayer) const;																								// Exposed to Python
-	DllExport bool isFighting() const;																																// Exposed to Python
+	bool isVisibleOtherUnit(PlayerTypes ePlayer) const; // Exposed to Python
+	DllExport bool isFighting() const; // Exposed to Python
 
 /************************************************************************************************/
 /* Afforess	                  Start		 01/31/10                                               */
 /*                                                                                              */
 /*   New parameter                                                                              */
 /************************************************************************************************/
-	bool canHaveFeature(FeatureTypes eFeature, bool bOverExistingFeature = false) const;																				// Exposed to Python
+	bool canHaveFeature(FeatureTypes eFeature, bool bOverExistingFeature = false) const; // Exposed to Python
 /************************************************************************************************/
 /* Afforess	                     END                                                            */
-/************************************************************************************************/																			// Exposed to Python
-
-	DllExport bool isRoute() const;																																		// Exposed to Python
-	bool isValidRoute(const CvUnit* pUnit) const;																											// Exposed to Python
-	bool isTradeNetworkImpassable(TeamTypes eTeam) const;																														// Exposed to Python
-	bool isNetworkTerrain(TeamTypes eTeam) const;																											// Exposed to Python
-	bool isBonusNetwork(TeamTypes eTeam) const;																												// Exposed to Python
-	bool isTradeNetwork(TeamTypes eTeam) const;																												// Exposed to Python
-	bool isTradeNetworkConnected(const CvPlot * pPlot, TeamTypes eTeam) const;												// Exposed to Python
+/************************************************************************************************/
+
+	DllExport bool isRoute() const; // Exposed to Python
+	bool isValidRoute(const CvUnit* pUnit) const; // Exposed to Python
+	bool isTradeNetworkImpassable(TeamTypes eTeam) const; // Exposed to Python
+	bool isNetworkTerrain(TeamTypes eTeam) const; // Exposed to Python
+	bool isBonusNetwork(TeamTypes eTeam) const; // Exposed to Python
+	bool isTradeNetwork(TeamTypes eTeam) const; // Exposed to Python
+	bool isTradeNetworkConnected(const CvPlot * pPlot, TeamTypes eTeam) const; // Exposed to Python
 	bool isRiverNetwork(TeamTypes eTeam) const;
 
-	bool isValidDomainForLocation(const CvUnit& unit) const;																					// Exposed to Python
-	bool isValidDomainForAction(const CvUnit& unit) const;																						// Exposed to Python
+	bool isValidDomainForLocation(const CvUnit& unit) const; // Exposed to Python
+	bool isValidDomainForAction(const CvUnit& unit) const; // Exposed to Python
 /************************************************************************************************/
 /* Afforess	Mountains Start		 09/18/09                                           		 */
 /*                                                                                              */
 /*                                                                                              */
 /************************************************************************************************/
-	//bool isImpassable() const;																														// Exposed to Python
+	//bool isImpassable() const; // Exposed to Python
 	bool isImpassable(TeamTypes eTeam = NO_TEAM) const;
 /************************************************************************************************/
 /* Afforess	Mountains End       END        		                                             */
@@ -506,7 +526,7 @@ friend CvPathPlotInfoStore;
 	{
 		return m_iX;
 	}
-	DllExport int getViewportY() const;																																				// Exposed to Python
+	DllExport int getViewportY() const; // Exposed to Python
 	inline int getY() const
 	{
 		return m_iY;
@@ -517,46 +537,42 @@ friend CvPathPlotInfoStore;
 	}
 	bool isInViewport(int comfortBorderSize = 0) const;
 
-	static bool EvictGraphicsIfNecessary();
-
+	// ==========================================================================================
+	// PAGING SYSTEM
+	//
 	// Set what graphics we require to be visible (probably based on camera position)
-	void setRequireGraphicsVisible(ECvPlotGraphics graphics, bool visible);
-	bool isGraphicsVisible(ECvPlotGraphics graphics) const;
-	bool isGraphicsRequiredVisible(ECvPlotGraphics graphics) const;
+	void setRequireGraphicsVisible(ECvPlotGraphics::type graphics, bool visible);
+	bool isGraphicsVisible(ECvPlotGraphics::type graphics) const;
+	bool isGraphicsRequiredVisible(ECvPlotGraphics::type graphics) const;
 	bool isGraphicPagingEnabled() const;
 
-	//// Show or hide specific graphic
-	//void setGraphicsVisible(ECvPlotGraphics graphics, bool visible);
-
 	// Show all required but not visible graphics
 	void showRequiredGraphics();
 
 	// Hide all non required but visible graphics
 	void hideNonRequiredGraphics();
 
-
 	// Get mask of all graphics components that aren't required to be visible but currently are
-	ECvPlotGraphics getNonRequiredGraphicsMask() const;
+	ECvPlotGraphics::type getNonRequiredGraphicsMask() const;
 	void enableGraphicsPaging();
 	void disableGraphicsPaging();
+	// ==========================================================================================
 
-	//void setShouldHaveFullGraphics(bool bShouldHaveFullGraphics);
-	//bool shouldHaveFullGraphics() const;
 	bool shouldHaveGraphics() const;
 
-	bool at(int iX, int iY) const;																																		// Exposed to Python
+	bool at(int iX, int iY) const; // Exposed to Python
 // BUG - Lat/Long Coordinates - start
 	int calculateMinutes(int iPlotIndex, int iPlotCount, bool bWrap, int iDegreeMin, int iDegreeMax) const;
-	int getLongitudeMinutes() const;																																		// Exposed to Python
-	int getLatitudeMinutes() const;																																		// Exposed to Python
+	int getLongitudeMinutes() const; // Exposed to Python
+	int getLatitudeMinutes() const; // Exposed to Python
 // BUG - Lat/Long Coordinates - end
-	int getLatitude() const;																																					// Exposed to Python  
+	int getLatitude() const; // Exposed to Python  
 	int getLatitudeRaw() const;
-	int getLongitude() const;																																					// Exposed to Python  
+	int getLongitude() const; // Exposed to Python  
 	int getLongitudeRaw() const;
 	int getFOWIndex() const;
 
-	CvArea* area() const;																																							// Exposed to Python
+	CvArea* area() const; // Exposed to Python
 /********************************************************************************/
 /* 	BETTER_BTS_AI_MOD						01/02/09		jdog5000		*/
 /* 																			*/
@@ -571,64 +587,64 @@ friend CvPathPlotInfoStore;
 /********************************************************************************/	
 
 	CvArea* secondWaterArea() const;
-	int getArea() const;																																		// Exposed to Python
-	void setArea(int iNewValue);			
+	int getArea() const; // Exposed to Python
+	void setArea(int iNewValue);
 
-	DllExport int getFeatureVariety() const;																													// Exposed to Python
+	DllExport int getFeatureVariety() const; // Exposed to Python
 
-	int getOwnershipDuration() const;																																	// Exposed to Python
-	bool isOwnershipScore() const;																																		// Exposed to Python
-	void setOwnershipDuration(int iNewValue);																													// Exposed to Python
-	void changeOwnershipDuration(int iChange);																												// Exposed to Python
+	int getOwnershipDuration() const; // Exposed to Python
+	bool isOwnershipScore() const; // Exposed to Python
+	void setOwnershipDuration(int iNewValue); // Exposed to Python
+	void changeOwnershipDuration(int iChange); // Exposed to Python
 
-	int getImprovementDuration() const;																																// Exposed to Python
-	void setImprovementDuration(int iNewValue);																												// Exposed to Python
-	void changeImprovementDuration(int iChange);																											// Exposed to Python
+	int getImprovementDuration() const; // Exposed to Python
+	void setImprovementDuration(int iNewValue); // Exposed to Python
+	void changeImprovementDuration(int iChange); // Exposed to Python
 
-	int getUpgradeProgressHundredths() const;																													// Exposed to Python
-	int getUpgradeTimeLeft(ImprovementTypes eImprovement, PlayerTypes ePlayer) const;				// Exposed to Python
-	void setUpgradeProgressHundredths(int iNewValue);																														// Exposed to Python
-	void changeUpgradeProgressHundredths(int iChange);																													// Exposed to Python
+	int getUpgradeProgressHundredths() const; // Exposed to Python
+	int getUpgradeTimeLeft(ImprovementTypes eImprovement, PlayerTypes ePlayer) const; // Exposed to Python
+	void setUpgradeProgressHundredths(int iNewValue); // Exposed to Python
+	void changeUpgradeProgressHundredths(int iChange); // Exposed to Python
 
-	int getForceUnownedTimer() const;																																	// Exposed to Python
-	bool isForceUnowned() const;																																			// Exposed to Python
-	void setForceUnownedTimer(int iNewValue);																													// Exposed to Python
-	void changeForceUnownedTimer(int iChange);																												// Exposed to Python
+	int getForceUnownedTimer() const; // Exposed to Python
+	bool isForceUnowned() const; // Exposed to Python
+	void setForceUnownedTimer(int iNewValue); // Exposed to Python
+	void changeForceUnownedTimer(int iChange); // Exposed to Python
 
-	int getCityRadiusCount() const;																																		// Exposed to Python
-	int isCityRadius() const;																																					// Exposed to Python
+	int getCityRadiusCount() const; // Exposed to Python
+	int isCityRadius() const; // Exposed to Python
 	void changeCityRadiusCount(int iChange);
 
-	bool isStartingPlot() const;																																			// Exposed to Python
-	void setStartingPlot(bool bNewValue);																															// Exposed to Python
+	bool isStartingPlot() const; // Exposed to Python
+	void setStartingPlot(bool bNewValue); // Exposed to Python
 	
-	DllExport bool isNOfRiver() const;																																// Exposed to Python					
-	void setNOfRiver(bool bNewValue, CardinalDirectionTypes eRiverDir);											// Exposed to Python					
-																																																		
-	DllExport bool isWOfRiver() const;																																// Exposed to Python					
-	void setWOfRiver(bool bNewValue, CardinalDirectionTypes eRiverDir);											// Exposed to Python					
-																																																		
-	DllExport CardinalDirectionTypes getRiverNSDirection() const;																			// Exposed to Python					
-	DllExport CardinalDirectionTypes getRiverWEDirection() const;																			// Exposed to Python					
-
-	CvPlot* getInlandCorner() const;																																	// Exposed to Python
+	DllExport bool isNOfRiver() const; // Exposed to Python					
+	void setNOfRiver(bool bNewValue, CardinalDirectionTypes eRiverDir); // Exposed to Python					
+										
+	DllExport bool isWOfRiver() const; // Exposed to Python					
+	void setWOfRiver(bool bNewValue, CardinalDirectionTypes eRiverDir); // Exposed to Python					
+										
+	DllExport CardinalDirectionTypes getRiverNSDirection() const; // Exposed to Python					
+	DllExport CardinalDirectionTypes getRiverWEDirection() const; // Exposed to Python					
+
+	CvPlot* getInlandCorner() const; // Exposed to Python
 	bool hasCoastAtSECorner() const;
 
-	bool isIrrigated() const;																																					// Exposed to Python
+	bool isIrrigated() const; // Exposed to Python
 	void setIrrigated(bool bNewValue);
 	void updateIrrigated();
 
-	bool isPotentialCityWork() const;																																						// Exposed to Python
-	bool isPotentialCityWorkForArea(CvArea* pArea) const;																												// Exposed to Python
+	bool isPotentialCityWork() const; // Exposed to Python
+	bool isPotentialCityWorkForArea(CvArea* pArea) const; // Exposed to Python
 	void updatePotentialCityWork();
 
 	bool isShowCitySymbols() const;
 	void updateShowCitySymbols();
 
-	bool isFlagDirty() const;																																										// Exposed to Python
-	void setFlagDirty(bool bNewValue);																																					// Exposed to Python
+	bool isFlagDirty() const; // Exposed to Python
+	void setFlagDirty(bool bNewValue); // Exposed to Python
 
-	DllExport PlayerTypes getOwner() const;																																			// Exposed to Python
+	DllExport PlayerTypes getOwner() const; // Exposed to Python
 #ifdef _USRDLL
 	inline PlayerTypes getOwnerINLINE() const
 	{
@@ -638,92 +654,92 @@ friend CvPathPlotInfoStore;
 	void setOwner(PlayerTypes eNewValue, bool bCheckUnits, bool bUpdatePlotGroup);
 	static void	setDeferredPlotGroupRecalculationMode(bool bDefer);
 
-	PlotTypes getPlotType() const;																																			// Exposed to Python
-	bool isWater() const;																																								// Exposed to Python
-	DllExport bool isWaterExternal() const;																																								// Exposed to Python
-	bool isFlatlands() const;																																											// Exposed to Python
-	DllExport bool isHills() const;																																			// Exposed to Python
-	DllExport bool isPeak() const;																																							// Exposed to Python
-	bool isPeak2(bool bCountsAs = false) const;																																								// Exposed to Python
-	void setPlotType(PlotTypes eNewValue, bool bRecalculate = true, bool bRebuildGraphics = true);			// Exposed to Python
-
-	DllExport TerrainTypes getTerrainTypeExternal() const;																																	// Exposed to Python
-	TerrainTypes getTerrainType() const;																																	// Exposed to Python
-	void setTerrainType(TerrainTypes eNewValue, bool bRecalculate = true, bool bRebuildGraphics = true);	// Exposed to Python
-
-	DllExport FeatureTypes getFeatureTypeExternal() const;																																	// Exposed to Python
-	FeatureTypes getFeatureType() const;																																	// Exposed to Python
-	void setFeatureType(FeatureTypes eNewValue, int iVariety = -1, bool bImprovementSet = false);																				// Exposed to Python
-	void setFeatureDummyVisibility(const char *dummyTag, bool show);																				// Exposed to Python
+	PlotTypes getPlotType() const; // Exposed to Python
+	bool isWater() const; // Exposed to Python
+	DllExport bool isWaterExternal() const; // Exposed to Python
+	bool isFlatlands() const; // Exposed to Python
+	DllExport bool isHills() const; // Exposed to Python
+	DllExport bool isPeak() const; // Exposed to Python
+	bool isPeak2(bool bCountsAs = false) const; // Exposed to Python
+	void setPlotType(PlotTypes eNewValue, bool bRecalculate = true, bool bRebuildGraphics = true); // Exposed to Python
+
+	DllExport TerrainTypes getTerrainTypeExternal() const; // Exposed to Python
+	TerrainTypes getTerrainType() const; // Exposed to Python
+	void setTerrainType(TerrainTypes eNewValue, bool bRecalculate = true, bool bRebuildGraphics = true); // Exposed to Python
+
+	DllExport FeatureTypes getFeatureTypeExternal() const; // Exposed to Python
+	FeatureTypes getFeatureType() const; // Exposed to Python
+	void setFeatureType(FeatureTypes eNewValue, int iVariety = -1, bool bImprovementSet = false); // Exposed to Python
+	void setFeatureDummyVisibility(const char *dummyTag, bool show); // Exposed to Python
 	void addFeatureDummyModel(const char *dummyTag, const char *modelTag);
 	void setFeatureDummyTexture(const char *dummyTag, const char *textureTag);
 	CvString pickFeatureDummyTag(int mouseX, int mouseY);
 	void resetFeatureModel();
 
-	DllExport BonusTypes getBonusType(TeamTypes eTeam = NO_TEAM) const;																							// Exposed to Python
-	BonusTypes getNonObsoleteBonusType(TeamTypes eTeam = NO_TEAM) const;																	// Exposed to Python
-	void setBonusType(BonusTypes eNewValue);																															// Exposed to Python
+	DllExport BonusTypes getBonusType(TeamTypes eTeam = NO_TEAM) const; // Exposed to Python
+	BonusTypes getNonObsoleteBonusType(TeamTypes eTeam = NO_TEAM) const; // Exposed to Python
+	void setBonusType(BonusTypes eNewValue); // Exposed to Python
 
 	void setImprovementCurrentValue();
 	int getImprovementCurrentValue() const;
 
-	DllExport ImprovementTypes getImprovementType() const;																													// Exposed to Python
-	void setImprovementType(ImprovementTypes eNewValue);																									// Exposed to Python
+	DllExport ImprovementTypes getImprovementType() const; // Exposed to Python
+	void setImprovementType(ImprovementTypes eNewValue); // Exposed to Python
 
-	RouteTypes getRouteType() const;																																			// Exposed to Python
-	void setRouteType(RouteTypes eNewValue, bool bUpdatePlotGroup);																															// Exposed to Python
+	RouteTypes getRouteType() const; // Exposed to Python
+	void setRouteType(RouteTypes eNewValue, bool bUpdatePlotGroup); // Exposed to Python
 	void updateCityRoute(bool bUpdatePlotGroup);
 
-	DllExport CvCity* getPlotCity() const;																																					// Exposed to Python
+	DllExport CvCity* getPlotCity() const; // Exposed to Python
 	void setPlotCity(CvCity* pNewValue);
 
-	CvCity* getWorkingCity() const;																																				// Exposed to Python
+	CvCity* getWorkingCity() const; // Exposed to Python
 	void updateWorkingCity();
 
-	CvCity* getWorkingCityOverride() const;																															// Exposed to Python
+	CvCity* getWorkingCityOverride() const; // Exposed to Python
 	void setWorkingCityOverride( const CvCity* pNewValue);
 
-	int getRiverID() const;																																							// Exposed to Python
-	void setRiverID(int iNewValue);																																			// Exposed to Python
+	int getRiverID() const; // Exposed to Python
+	void setRiverID(int iNewValue); // Exposed to Python
 
-	int getMinOriginalStartDist() const;																																// Exposed to Python
+	int getMinOriginalStartDist() const; // Exposed to Python
 	void setMinOriginalStartDist(int iNewValue);
 
-	int getReconCount() const;																																					// Exposed to Python
+	int getReconCount() const; // Exposed to Python
 	void changeReconCount(int iChange);
 
-	int getRiverCrossingCount() const;																																	// Exposed to Python
+	int getRiverCrossingCount() const; // Exposed to Python
 	void changeRiverCrossingCount(int iChange);
 
 	short* getYield();
-	DllExport int getYield(YieldTypes eIndex) const;																										// Exposed to Python
-	int calculateNatureYield(YieldTypes eIndex, TeamTypes eTeam, bool bIgnoreFeature = false) const;		// Exposed to Python
-	int calculateBestNatureYield(YieldTypes eIndex, TeamTypes eTeam) const;															// Exposed to Python
-	int calculateTotalBestNatureYield(TeamTypes eTeam) const;																						// Exposed to Python
+	DllExport int getYield(YieldTypes eIndex) const; // Exposed to Python
+	int calculateNatureYield(YieldTypes eIndex, TeamTypes eTeam, bool bIgnoreFeature = false) const; // Exposed to Python
+	int calculateBestNatureYield(YieldTypes eIndex, TeamTypes eTeam) const; // Exposed to Python
+	int calculateTotalBestNatureYield(TeamTypes eTeam) const; // Exposed to Python
 /************************************************************************************************/
 /* BETTER_BTS_AI_MOD                      10/06/09                                jdog5000      */
 /*                                                                                              */
 /* City AI                                                                                      */
 /************************************************************************************************/
-	int calculateImprovementYieldChange(ImprovementTypes eImprovement, YieldTypes eYield, PlayerTypes ePlayer, bool bOptimal = false, bool bBestRoute = false) const;	// Exposed to Python
+	int calculateImprovementYieldChange(ImprovementTypes eImprovement, YieldTypes eYield, PlayerTypes ePlayer, bool bOptimal = false, bool bBestRoute = false) const; // Exposed to Python
 /************************************************************************************************/
 /* BETTER_BTS_AI_MOD                       END                                                  */
 /************************************************************************************************/
-	int calculateYield(YieldTypes eIndex, bool bDisplay = false) const;												// Exposed to Python
-	bool hasYield() const;																																		// Exposed to Python
+	int calculateYield(YieldTypes eIndex, bool bDisplay = false) const; // Exposed to Python
+	bool hasYield() const; // Exposed to Python
 	void updateYield();
 	int calculateMaxYield(YieldTypes eYield) const;
 	int getYieldWithBuild(BuildTypes eBuild, YieldTypes eYield, bool bWithUpgrade) const;
 
-	int getCulture(PlayerTypes eIndex) const;																									// Exposed to Python
-	int countTotalCulture() const;																														// Exposed to Python
+	int getCulture(PlayerTypes eIndex) const; // Exposed to Python
+	int countTotalCulture() const; // Exposed to Python
 	int countFriendlyCulture(TeamTypes eTeam) const;
-	TeamTypes findHighestCultureTeam() const;																														// Exposed to Python
+	TeamTypes findHighestCultureTeam() const; // Exposed to Python
 	PlayerTypes findHighestCulturePlayer() const;
-	int calculateCulturePercent(PlayerTypes eIndex) const;																		// Exposed to Python
-	int calculateTeamCulturePercent(TeamTypes eIndex) const;																						// Exposed to Python
-	void setCulture(PlayerTypes eIndex, int iNewValue, bool bUpdate, bool bUpdatePlotGroups);																		// Exposed to Python
-	void changeCulture(PlayerTypes eIndex, int iChange, bool bUpdate);																	// Exposed to Python
+	int calculateCulturePercent(PlayerTypes eIndex) const; // Exposed to Python
+	int calculateTeamCulturePercent(TeamTypes eIndex) const; // Exposed to Python
+	void setCulture(PlayerTypes eIndex, int iNewValue, bool bUpdate, bool bUpdatePlotGroups); // Exposed to Python
+	void changeCulture(PlayerTypes eIndex, int iChange, bool bUpdate); // Exposed to Python
 	int countNumAirUnits(TeamTypes eTeam) const;
 	int countNumAirUnitCargoVolume(TeamTypes eTeam) const;
 	int airUnitSpaceAvailable(TeamTypes eTeam) const;
@@ -737,13 +753,13 @@ friend CvPathPlotInfoStore;
 /* 	BETTER_BTS_AI_MOD						END								*/
 /********************************************************************************/
 
-	int getFoundValue(PlayerTypes eIndex);																															// Exposed to Python
-	bool isBestAdjacentFound(PlayerTypes eIndex);																												// Exposed to Python
+	int getFoundValue(PlayerTypes eIndex); // Exposed to Python
+	bool isBestAdjacentFound(PlayerTypes eIndex); // Exposed to Python
 	void clearFoundValue(PlayerTypes eIndex);
 	void setFoundValue(PlayerTypes eIndex, int iNewValue);
 
-	int getPlayerCityRadiusCount(PlayerTypes eIndex) const;																							// Exposed to Python
-	bool isPlayerCityRadius(PlayerTypes eIndex) const;																									// Exposed to Python
+	int getPlayerCityRadiusCount(PlayerTypes eIndex) const; // Exposed to Python
+	bool isPlayerCityRadius(PlayerTypes eIndex) const; // Exposed to Python
 	void changePlayerCityRadiusCount(PlayerTypes eIndex, int iChange);
 
 	int getPlotGroupId(PlayerTypes ePlayer) const;
@@ -754,44 +770,44 @@ friend CvPathPlotInfoStore;
 	void updatePlotGroup(PlayerTypes ePlayer, bool bRecalculate = true, bool bRecalculateBonuses = true);
 
 	void clearVisibilityCounts();
-	int getVisibilityCount(TeamTypes eTeam) const;																											// Exposed to Python
-	void changeVisibilityCount(TeamTypes eTeam, int iChange, InvisibleTypes eSeeInvisible, bool bUpdatePlotGroups, int iIntensity = 0, int iUnitID = 0);							// Exposed to Python
+	int getVisibilityCount(TeamTypes eTeam) const; // Exposed to Python
+	void changeVisibilityCount(TeamTypes eTeam, int iChange, InvisibleTypes eSeeInvisible, bool bUpdatePlotGroups, int iIntensity = 0, int iUnitID = 0); // Exposed to Python
 
 	int getDangerCount(int /*PlayerTypes*/ ePlayer);
 	void setDangerCount(int /*PlayerTypes*/ ePlayer, int iNewCount);
 
-	int getStolenVisibilityCount(TeamTypes eTeam) const;																								// Exposed to Python
+	int getStolenVisibilityCount(TeamTypes eTeam) const; // Exposed to Python
 	void changeStolenVisibilityCount(TeamTypes eTeam, int iChange);
 
 	int getLastVisibleTurn(TeamTypes eTeam) const;
 	void setLastVisibleTurn(TeamTypes eTeam, short turn);
 
-	int getBlockadedCount(TeamTypes eTeam) const;																								// Exposed to Python
+	int getBlockadedCount(TeamTypes eTeam) const; // Exposed to Python
 	void changeBlockadedCount(TeamTypes eTeam, int iChange);
 	void resetBlockadedCounts();
 
-	DllExport PlayerTypes getRevealedOwner(TeamTypes eTeam, bool bDebug) const;													// Exposed to Python
-	TeamTypes getRevealedTeam(TeamTypes eTeam, bool bDebug) const;														// Exposed to Python
+	DllExport PlayerTypes getRevealedOwner(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
+	TeamTypes getRevealedTeam(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
 	void setRevealedOwner(TeamTypes eTeam, PlayerTypes eNewValue);
 	void updateRevealedOwner(TeamTypes eTeam);
 
-	DllExport bool isRiverCrossing(DirectionTypes eIndex) const;																				// Exposed to Python
+	DllExport bool isRiverCrossing(DirectionTypes eIndex) const; // Exposed to Python
 	void updateRiverCrossing(DirectionTypes eIndex);
 	void updateRiverCrossing();
 
-	DllExport bool isRevealed(TeamTypes eTeam, bool bDebug) const;																								// Exposed to Python
-	void setRevealed(TeamTypes eTeam, bool bNewValue, bool bTerrainOnly, TeamTypes eFromTeam, bool bUpdatePlotGroup);	// Exposed to Python
-	bool isAdjacentRevealed(TeamTypes eTeam, bool bDebug = false) const;																				// Exposed to Python
-	bool isAdjacentNonrevealed(TeamTypes eTeam) const;																				// Exposed to Python
+	DllExport bool isRevealed(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
+	void setRevealed(TeamTypes eTeam, bool bNewValue, bool bTerrainOnly, TeamTypes eFromTeam, bool bUpdatePlotGroup); // Exposed to Python
+	bool isAdjacentRevealed(TeamTypes eTeam, bool bDebug = false) const; // Exposed to Python
+	bool isAdjacentNonrevealed(TeamTypes eTeam) const; // Exposed to Python
 
-	ImprovementTypes getRevealedImprovementType(TeamTypes eTeam, bool bDebug) const;					// Exposed to Python
-	void setRevealedImprovementType(TeamTypes eTeam, ImprovementTypes eNewValue);			
+	ImprovementTypes getRevealedImprovementType(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
+	void setRevealedImprovementType(TeamTypes eTeam, ImprovementTypes eNewValue);
 
-	RouteTypes getRevealedRouteType(TeamTypes eTeam, bool bDebug) const;											// Exposed to Python
-	void setRevealedRouteType(TeamTypes eTeam, RouteTypes eNewValue);							
+	RouteTypes getRevealedRouteType(TeamTypes eTeam, bool bDebug) const; // Exposed to Python
+	void setRevealedRouteType(TeamTypes eTeam, RouteTypes eNewValue);
 
-	int getBuildProgress(BuildTypes eBuild) const;																											// Exposed to Python  
-	bool changeBuildProgress(BuildTypes eBuild, int iChange, TeamTypes eTeam = NO_TEAM);								// Exposed to Python 
+	int getBuildProgress(BuildTypes eBuild) const; // Exposed to Python  
+	bool changeBuildProgress(BuildTypes eBuild, int iChange, TeamTypes eTeam = NO_TEAM); // Exposed to Python 
 
 // BUG - Partial Builds - start
 	bool hasAnyBuildProgress() const;
@@ -800,14 +816,14 @@ friend CvPathPlotInfoStore;
 	void updateFeatureSymbolVisibility(); 
 	void updateFeatureSymbol(bool bForce = false);
 
-	DllExport bool isLayoutDirty() const;							// The plot layout contains bonuses and improvements --- it is, like the city layout, passively computed by LSystems
+	DllExport bool isLayoutDirty() const; // The plot layout contains bonuses and improvements --- it is, like the city layout, passively computed by LSystems
 	DllExport void setLayoutDirty(bool bDirty);
 	DllExport bool isLayoutStateDifferent() const;
 	DllExport void setLayoutStateToCurrent();
 	bool updatePlotBuilder();
 
-	DllExport void getVisibleImprovementState(ImprovementTypes& eType, bool& bWorked);				// determines how the improvement state is shown in the engine
-	DllExport void getVisibleBonusState(BonusTypes& eType, bool& bImproved, bool& bWorked);		// determines how the bonus state is shown in the engine
+	DllExport void getVisibleImprovementState(ImprovementTypes& eType, bool& bWorked); // determines how the improvement state is shown in the engine
+	DllExport void getVisibleBonusState(BonusTypes& eType, bool& bImproved, bool& bWorked); // determines how the bonus state is shown in the engine
 	bool shouldUsePlotBuilder();
 	CvPlotBuilder* getPlotBuilder() { return m_pPlotBuilder; }
 
@@ -828,13 +844,13 @@ friend CvPathPlotInfoStore;
 	DllExport CvUnit* getDebugCenterUnit() const;
 	void setCenterUnit(CvUnit* pNewValue);
 
-	int getCultureRangeCities(PlayerTypes eOwnerIndex, int iRangeIndex) const;														// Exposed to Python
-	bool isCultureRangeCity(PlayerTypes eOwnerIndex, int iRangeIndex) const;															// Exposed to Python
+	int getCultureRangeCities(PlayerTypes eOwnerIndex, int iRangeIndex) const; // Exposed to Python
+	bool isCultureRangeCity(PlayerTypes eOwnerIndex, int iRangeIndex) const; // Exposed to Python
 	//void changeCultureRangeCities(PlayerTypes eOwnerIndex, int iRangeIndex, int iChange, bool bUpdatePlotGroups);
 
-	int getInvisibleVisibilityCount(TeamTypes eTeam, InvisibleTypes eInvisible) const;										// Exposed to Python
-	bool isInvisibleVisible(TeamTypes eTeam, InvisibleTypes eInvisible) const;														// Exposed to Python
-	void changeInvisibleVisibilityCount(TeamTypes eTeam, InvisibleTypes eInvisible, int iChange, int iIntensity, int iUnitID = 0);					// Exposed to Python
+	int getInvisibleVisibilityCount(TeamTypes eTeam, InvisibleTypes eInvisible) const; // Exposed to Python
+	bool isInvisibleVisible(TeamTypes eTeam, InvisibleTypes eInvisible) const; // Exposed to Python
+	void changeInvisibleVisibilityCount(TeamTypes eTeam, InvisibleTypes eInvisible, int iChange, int iIntensity, int iUnitID = 0); // Exposed to Python
 
 	int getNumPlotTeamVisibilityIntensity() const;
 	PlotTeamVisibilityIntensity& getPlotTeamVisibilityIntensity(int iIndex);
@@ -847,8 +863,8 @@ friend CvPathPlotInfoStore;
 	bool HaveCachedPathValidityResult(void* entity, bool bIsAlternateResult, bool& cachedResult);
 	void CachePathValidityResult(void* entity, bool bIsAlternateResult, bool cachedResult);
 
-	int getNumUnits() const;																																		// Exposed to Python
-	CvUnit* getUnitByIndex(int iIndex) const;																													// Exposed to Python
+	int getNumUnits() const; // Exposed to Python
+	CvUnit* getUnitByIndex(int iIndex) const; // Exposed to Python
 	void addUnit(CvUnit* pUnit, bool bUpdate = true);
 	void removeUnit(CvUnit* pUnit, bool bUpdate = true);
 	DllExport CLLNode<IDInfo>* nextUnitNode(CLLNode<IDInfo>* pNode) const;
@@ -883,8 +899,8 @@ friend CvPathPlotInfoStore;
 	void deleteAllSymbols();
 
 	// Script data needs to be a narrow string for pickling in Python
-	CvString getScriptData() const;																											// Exposed to Python
-	void setScriptData(const char* szNewValue);																					// Exposed to Python
+	CvString getScriptData() const; // Exposed to Python
+	void setScriptData(const char* szNewValue); // Exposed to Python
 
 	bool canTrigger(EventTriggerTypes eTrigger, PlayerTypes ePlayer) const;
 	bool canApplyEvent(EventTypes eEvent) const;
@@ -995,13 +1011,13 @@ friend CvPathPlotInfoStore;
 	std::vector<PlotTeamVisibilityIntensity> m_aPlotTeamVisibilityIntensity;
 	unsigned int* m_aiFoundValue;
 	char* m_aiPlayerCityRadiusCount;
-	int* m_aiPlotGroup;			// IDs - keep as int
+	int* m_aiPlotGroup; // IDs - keep as int
 	short* m_aiVisibilityCount;
 	short* m_aiStolenVisibilityCount;
 	short* m_aiBlockadedCount;
 	char* m_aiRevealedOwner;
 
-	bool* m_abRiverCrossing;	// bit vector
+	bool* m_abRiverCrossing; // bit vector
 	bool* m_abRevealed;
 
 	short* /*ImprovementTypes*/ m_aeRevealedImprovementType;
@@ -1025,7 +1041,7 @@ friend CvPathPlotInfoStore;
 	CvFlagEntity* m_pFlagSymbolOffset;
 	CvUnit* m_pCenterUnit;
 
-	CvPlotBuilder* m_pPlotBuilder;		// builds bonuses and improvements
+	CvPlotBuilder* m_pPlotBuilder; // builds bonuses and improvements
 
 	char** m_apaiCultureRangeCities;
 	short** m_apaiInvisibleVisibilityCount;
@@ -1086,8 +1102,8 @@ friend CvPathPlotInfoStore;
 
 protected:
 	//	Directly accessed cached pathing info per plot for performance reasons
-	volatile mutable int				m_pathGenerationSeq;
-	mutable CvPathGeneratorPlotInfo*	m_currentPathInfo;
+	volatile mutable int m_pathGenerationSeq;
+	mutable CvPathGeneratorPlotInfo* m_currentPathInfo;
 
 public:
 	int m_groupGenerationNumber;
@@ -1127,16 +1143,14 @@ friend CvPathPlotInfoStore;
 	CvProperties* getProperties();
 	const CvProperties* getPropertiesConst() const;
 
+private:
 	void pageGraphicsOut();
-	//static void notePageRenderStart(int iRenderArea);
 
 protected:
 	bool m_bInhibitCenterUnitCalculation;
 	bool m_bIgnoringImprovementUpgrade;
 
-	ECvPlotGraphics m_requiredVisibleGraphics;
-	ECvPlotGraphics m_visibleGraphics;
-	short m_iGraphicsPageIndex;
+	ECvPlotGraphics::type m_requiredVisibleGraphics;
+	ECvPlotGraphics::type m_visibleGraphics;
+	CvPlotPaging::paging_handle m_pagingHandle;
 };
-
-#endif
diff --git a/Sources/CvPlotPaging.cpp b/Sources/CvPlotPaging.cpp
new file mode 100644
index 0000000000..e85af504d3
--- /dev/null
+++ b/Sources/CvPlotPaging.cpp
@@ -0,0 +1,313 @@
+
+#include "CvGameCoreDLL.h"
+
+#include "CvPlotPaging.h"
+
+#include <psapi.h>
+
+namespace {
+
+	struct GraphicsPagingInfo
+	{
+		CvPlot* pPlot;
+		unsigned int iSeq;
+		GraphicsPagingInfo () : pPlot(NULL), iSeq(0U) {}
+	};
+
+	unsigned int g_iNumPagedInPlots = 0;
+	unsigned int g_iCurrentSeq = 0;
+	unsigned int g_iOldestSearchSeqHint = 0;
+	std::vector<GraphicsPagingInfo> g_pagingTable;
+
+	int g_iLastLookatX = -1;
+	int g_iLastLookatY = -1;
+	int g_bWasGraphicsPagingEnabled = false;
+
+	int findFreePagingTableSlot()
+	{
+		static size_t iSearchStartHintIndex = 0;
+
+		for (size_t iI = 0; iI < g_pagingTable.size(); iI++)
+		{
+			int iIndex = iSearchStartHintIndex++;
+
+			if (iSearchStartHintIndex >= g_pagingTable.size())
+			{
+				iSearchStartHintIndex = 0;
+			}
+
+			if (g_pagingTable[iIndex].pPlot == NULL)
+			{
+				return iIndex;
+			}
+		}
+
+		return -1;
+	}
+
+	int allocateNewPagingEntry()
+	{
+		if (g_pagingTable.size() <= g_iNumPagedInPlots++)
+		{
+			g_pagingTable.push_back(GraphicsPagingInfo());
+			return g_pagingTable.size() - 1;
+		}
+		else
+		{
+			return findFreePagingTableSlot();
+		}
+	}
+
+	int findOldestEvictablePagingEntry()
+	{
+		unsigned int iOldest = MAX_INT;
+		int iResult = -1;
+
+		for (int iI = 0; iI < static_cast<int>(g_pagingTable.size()); iI++)
+		{
+			if (g_pagingTable[iI].pPlot != NULL && g_pagingTable[iI].pPlot->getNonRequiredGraphicsMask() != ECvPlotGraphics::NONE)
+			{
+				if (g_pagingTable[iI].iSeq < iOldest)
+				{
+					iOldest = g_pagingTable[iI].iSeq;
+					iResult = iI;
+				}
+			}
+		}
+
+		return iResult;
+	}
+
+	const int DEFAULT_MAX_WORKING_SET_THRESHOLD_BEFORE_EVICTION = 1024 * 1024 * 1024 * 2; // 2 GB
+	const int DEFAULT_OS_MEMORY_ALLOWANCE = 1024 * 1024 * 512; // 512 MB
+
+	bool NeedToFreeMemory()
+	{
+		PROCESS_MEMORY_COUNTERS pmc;
+		static unsigned int uiMaxMem = 0xFFFFFFFF;
+		static const unsigned int PAGING_TEST_ALLOC = GC.getDefineINT("PAGING_TEST_ALLOC", 0);
+		static const unsigned int PAGING_TEST_ALLOC_NUM = GC.getDefineINT("PAGING_TEST_ALLOC_NUM", 0);
+
+		if (PAGING_TEST_ALLOC != 0 && PAGING_TEST_ALLOC_NUM != 0)
+		{
+			std::vector<void*> test_allocs;
+			bool success = true;
+			for (int i = 0; i < PAGING_TEST_ALLOC_NUM; ++i)
+			{
+				void* test_alloc = malloc(PAGING_TEST_ALLOC);
+				if (test_alloc == NULL)
+				{
+					success = false;
+					break;
+				}
+				else
+				{
+					test_allocs.push_back(test_alloc);
+				}
+			}
+			for (int i = 0; i < test_allocs.size(); ++i)
+			{
+				free(test_allocs[i]);
+			}
+
+			return false;
+		}
+		else
+		{
+			if (uiMaxMem == 0xFFFFFFFF)
+			{
+				MEMORYSTATUSEX memoryStatus;
+
+				memoryStatus.dwLength = sizeof(memoryStatus);
+				GlobalMemoryStatusEx(&memoryStatus);
+
+				uiMaxMem = 1024 * GC.getDefineINT("MAX_DESIRED_MEMORY_USED", DEFAULT_MAX_WORKING_SET_THRESHOLD_BEFORE_EVICTION / 1024);
+
+				DWORDLONG usableMemory = memoryStatus.ullTotalPhys - 1024 * (DWORDLONG)GC.getDefineINT("OS_MEMORY_ALLOWANCE", DEFAULT_OS_MEMORY_ALLOWANCE / 1024);
+				if (usableMemory < uiMaxMem)
+				{
+					uiMaxMem = (unsigned int)usableMemory;
+				}
+			}
+
+			GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
+
+			if (pmc.WorkingSetSize > uiMaxMem)
+			{
+				OutputDebugString(CvString::format("Found need to free memory: %d used vs %d target\n", pmc.WorkingSetSize, uiMaxMem).c_str());
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+	}
+}
+
+bool EvictGraphics()
+{
+	int iEvictionIndex = findOldestEvictablePagingEntry();
+
+	if (iEvictionIndex == -1)
+	{
+		return false;
+	}
+
+	g_pagingTable[iEvictionIndex].pPlot->hideNonRequiredGraphics();
+	return true;
+}
+
+struct PlotDist
+{
+	CvPlot* plot;
+	int dist2;
+
+	PlotDist(CvPlot* plot, int dist2) : plot(plot), dist2(dist2)
+	{
+	}
+
+	PlotDist() : plot(NULL), dist2(0) {}
+
+	bool operator<(const PlotDist& other) const
+	{
+		return dist2 < other.dist2;
+	}
+};
+
+CvPlotPaging::paging_handle CvPlotPaging::AddPlot(CvPlot* plot)
+{
+	int newHandle = allocateNewPagingEntry();
+
+	GraphicsPagingInfo* pPagingInfo = &g_pagingTable[newHandle];
+
+	pPagingInfo->iSeq = ++g_iCurrentSeq;
+	pPagingInfo->pPlot = plot;
+
+	return newHandle;
+}
+
+void CvPlotPaging::RemovePlot(CvPlotPaging::paging_handle handle)
+{
+	FAssertMsg(handle >= 0 && handle < g_pagingTable.size(), "CvPlot paging handle is not valid");
+	FAssertMsg(g_pagingTable[handle].pPlot != NULL, "CvPlot was not paged");
+	g_pagingTable[handle].pPlot = NULL;
+	--g_iNumPagedInPlots;
+}
+void CvPlotPaging::ResetPaging()
+{
+	g_bWasGraphicsPagingEnabled = false;
+	g_iLastLookatX = -1;
+	g_iLastLookatY = -1;
+}
+
+// Straight line distance squared, wrapped in x and y direction.
+// It doesn't really matter that some maps don't wrap, perf of the paging will
+// be consistent regardless.
+int ToroidalDistanceSq (int x1, int y1, int x2, int y2, int w, int h)
+{
+	int dx = std::abs(x2 - x1);
+	int dy = std::abs(y2 - y1);
+
+	if (dx > w / 2)
+		dx = w - dx;
+
+	if (dy > h / 2)
+		dy = h - dy;
+
+	return dx * dx + dy * dy;
+}
+
+
+void CvPlotPaging::UpdatePaging()
+{
+	const CvPlot* lookatPlot = gDLL->getInterfaceIFace()->getLookAtPlot();
+	if (lookatPlot == NULL)
+	{
+		return;
+	}
+
+	// Check if the paging setting changed
+	bool bPagingEnabled = getBugOptionBOOL("MainInterface__EnableGraphicalPaging", true);
+	GC.setGraphicalDetailPagingEnabled(bPagingEnabled);
+
+	if (!bPagingEnabled && g_bWasGraphicsPagingEnabled != bPagingEnabled)
+	{
+		const CvMap& map = GC.getMapINLINE();
+		for (int i = 0; i < map.numPlotsINLINE(); i++)
+		{
+			CvPlot* plot = map.plotByIndexINLINE(i);
+			if (plot != NULL)
+			{
+				plot->disableGraphicsPaging();
+			}
+		}
+	}
+	else if(bPagingEnabled)
+	{
+		win32::Stopwatch pageTimer;
+		pageTimer.Start();
+
+		const int centerX = lookatPlot->getX_INLINE();
+		const int centerY = lookatPlot->getY_INLINE();
+
+		// How far did the camera move since last frame?
+		const int moveDist2 = (centerX - g_iLastLookatX) * (centerX - g_iLastLookatX) + (centerY - g_iLastLookatY) * (centerY - g_iLastLookatY);
+
+		// How much time we can allow for paging this frame, it varies by how fast the camera is moving
+		const int pagingFrameTime = 10 + GC.getDefineINT("PAGING_FRAME_TIME_MS", 100) / (1 + moveDist2);
+
+		// Evict graphics first, allowing at least 1/2 our time budget for it (we definitely want to make sure we don't run out of memory!)
+		while (NeedToFreeMemory() && pageTimer.ElapsedMilliseconds() < pagingFrameTime * 0.5) 
+		{
+			if (!EvictGraphics())
+			{
+				// we in trouble now!
+				break;
+			}
+		}
+
+		// The min distance different plot graphics should be paged in at
+		const int pageInDistances[] = {
+			GC.getDefineINT("PAGE_IN_DIST_SYMBOLS", 100),
+			GC.getDefineINT("PAGE_IN_DIST_FEATURES", 7),
+			GC.getDefineINT("PAGE_IN_DIST_RIVER", 40),
+			GC.getDefineINT("PAGE_IN_DIST_ROUTE", 100),
+			GC.getDefineINT("PAGE_IN_DIST_UNIT", 15),
+			GC.getDefineINT("PAGE_IN_DIST_CITY", 5),
+		};
+
+		// Gather and sort all plots by distance to view center
+		std::vector<PlotDist> plots;
+		const CvMap& map = GC.getMapINLINE();
+		plots.reserve(map.numPlotsINLINE());
+		for (int i = 0; i < map.numPlotsINLINE(); i++)
+		{
+			CvPlot* plot = map.plotByIndexINLINE(i);
+			if (plot != NULL)
+			{
+				plots.push_back(PlotDist(map.plotByIndexINLINE(i), ToroidalDistanceSq(centerX, centerY, plot->getX_INLINE(), plot->getY_INLINE(), map.getGridWidthINLINE(), map.getGridHeightINLINE())));
+			}
+		}
+		std::sort(plots.begin(), plots.end());
+
+		// Loop all plots in order from distance to the view center, toggling the appropriate plot graphics flags
+		for (std::vector<PlotDist>::iterator itr = plots.begin(); itr != plots.end() && pageTimer.ElapsedMilliseconds() < pagingFrameTime; ++itr)
+		{
+			for (int graphicsType = 0; graphicsType < ECvPlotGraphics::NUM; ++graphicsType)
+			{
+				if (pageInDistances[graphicsType] != -1)
+				{
+					itr->plot->setRequireGraphicsVisible(ECvPlotGraphics::fromIndex(graphicsType), itr->dist2 < pageInDistances[graphicsType] * pageInDistances[graphicsType]);
+				}
+			}
+		}
+
+		g_iLastLookatX = lookatPlot->getX_INLINE();
+		g_iLastLookatY = lookatPlot->getY_INLINE();
+	}
+
+	g_bWasGraphicsPagingEnabled = bPagingEnabled;
+}
+
+const int CvPlotPaging::INVALID_HANDLE = -1;
diff --git a/Sources/CvPlotPaging.h b/Sources/CvPlotPaging.h
new file mode 100644
index 0000000000..1c7bb6ba86
--- /dev/null
+++ b/Sources/CvPlotPaging.h
@@ -0,0 +1,13 @@
+#pragma once
+
+struct CvPlotPaging
+{
+	typedef int paging_handle;
+	static const int INVALID_HANDLE;
+
+	static void ResetPaging();
+	static void UpdatePaging();
+
+	static paging_handle AddPlot(class CvPlot* plot);
+	static void RemovePlot(paging_handle handle);
+};
\ No newline at end of file
diff --git a/Sources/EnumFlags.h b/Sources/EnumFlags.h
new file mode 100644
index 0000000000..9b91c18811
--- /dev/null
+++ b/Sources/EnumFlags.h
@@ -0,0 +1,59 @@
+#pragma once
+
+// Taken from newer version of winnt.h
+
+
+// Define operator overloads to enable bit operations on enum values that are
+// used to define flags. Use DEFINE_ENUM_FLAG_OPERATORS(YOUR_TYPE) to enable these
+// operators on YOUR_TYPE.
+
+// Moved here from objbase.w.
+
+// Templates are defined here in order to avoid a dependency on C++ <type_traits> header file,
+// or on compiler-specific constructs.
+extern "C++" {
+	template <size_t S>
+	struct _ENUM_FLAG_INTEGER_FOR_SIZE;
+
+	template <>
+	struct _ENUM_FLAG_INTEGER_FOR_SIZE<1>
+	{
+		typedef INT8 type;
+	};
+
+	template <>
+	struct _ENUM_FLAG_INTEGER_FOR_SIZE<2>
+	{
+		typedef INT16 type;
+	};
+
+	template <>
+	struct _ENUM_FLAG_INTEGER_FOR_SIZE<4>
+	{
+		typedef INT32 type;
+	};
+
+	template <>
+	struct _ENUM_FLAG_INTEGER_FOR_SIZE<8>
+	{
+		typedef INT64 type;
+	};
+
+	// used as an approximation of std::underlying_type<T>
+	template <class T>
+	struct _ENUM_FLAG_SIZED_INTEGER
+	{
+		typedef typename _ENUM_FLAG_INTEGER_FOR_SIZE<sizeof(T)>::type type;
+	};
+}
+
+#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) \
+extern "C++" { \
+inline ENUMTYPE operator | (ENUMTYPE a, ENUMTYPE b) throw() { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) | ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator |= (ENUMTYPE &a, ENUMTYPE b) throw() { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) |= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE operator & (ENUMTYPE a, ENUMTYPE b) throw() { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) & ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator &= (ENUMTYPE &a, ENUMTYPE b) throw() { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) &= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE operator ~ (ENUMTYPE a) throw() { return ENUMTYPE(~((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a)); } \
+inline ENUMTYPE operator ^ (ENUMTYPE a, ENUMTYPE b) throw() { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) ^ ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator ^= (ENUMTYPE &a, ENUMTYPE b) throw() { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) ^= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+}
diff --git a/Sources/NiPoint.h b/Sources/NiPoint.h
new file mode 100644
index 0000000000..26b27ad385
--- /dev/null
+++ b/Sources/NiPoint.h
@@ -0,0 +1,102 @@
+#pragma once
+
+//
+// GameBryo
+//
+class NiColor
+{
+public:
+	float r, g, b;
+};
+class NiColorA
+{
+public:
+	NiColorA(float fr, float fg, float fb, float fa) : r(fr), g(fg), b(fb), a(fa) {}
+	NiColorA() {}
+	float r, g, b, a;
+};
+class NiPoint2
+{
+public:
+	NiPoint2() {}
+	NiPoint2(float fx, float fy) : x(fx), y(fy) {}
+
+	float x, y;
+};
+class NiPoint3
+{
+public:
+	NiPoint3() : x(0.0f), y(0.0f), z(0.0f) {}
+	NiPoint3(float fx, float fy, float fz) : x(fx), y(fy), z(fz) {}
+
+	bool operator== (const NiPoint3& pt) const
+	{
+		return (x == pt.x && y == pt.y && z == pt.z);
+	}
+
+	inline NiPoint3 operator+ (const NiPoint3& pt) const
+	{
+		return NiPoint3(x + pt.x, y + pt.y, z + pt.z);
+	}
+
+	inline NiPoint3 operator- (const NiPoint3& pt) const
+	{
+		return NiPoint3(x - pt.x, y - pt.y, z - pt.z);
+	}
+
+	inline float operator* (const NiPoint3& pt) const
+	{
+		return x * pt.x + y * pt.y + z * pt.z;
+	}
+
+	inline NiPoint3 operator* (float fScalar) const
+	{
+		return NiPoint3(fScalar * x, fScalar * y, fScalar * z);
+	}
+
+	inline NiPoint3 operator/ (float fScalar) const
+	{
+		float fInvScalar = 1.0f / fScalar;
+		return NiPoint3(fInvScalar * x, fInvScalar * y, fInvScalar * z);
+	}
+
+	inline NiPoint3 operator- () const
+	{
+		return NiPoint3(-x, -y, -z);
+	}
+
+	inline float Length() const
+	{
+		return sqrt(x * x + y * y + z * z);
+	}
+
+	inline float Unitize()
+	{
+		float length = Length();
+		if (length != 0)
+		{
+			x /= length;
+			y /= length;
+			z /= length;
+		}
+		return length;
+	}
+
+	//	inline NiPoint3 operator* (float fScalar, const NiPoint3& pt)
+	//	{	return NiPoint3(fScalar*pt.x,fScalar*pt.y,fScalar*pt.z);	}
+	float x, y, z;
+};
+
+namespace NiAnimationKey
+{
+	enum KeyType
+	{
+		NOINTERP,
+		LINKEY,
+		BEZKEY,
+		TCBKEY,
+		EULERKEY,
+		STEPKEY,
+		NUMKEYTYPES
+	};
+};

From 2b12cdb1919c108f81280dd9883e220d1dccaed0 Mon Sep 17 00:00:00 2001
From: billw2012 <billw2011@gmail.com>
Date: Sat, 14 Sep 2019 11:37:03 +0100
Subject: [PATCH 3/4] Fixing warnings about int sizes and conversions

---
 Sources/CvPlotPaging.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Sources/CvPlotPaging.cpp b/Sources/CvPlotPaging.cpp
index e85af504d3..83370db4f8 100644
--- a/Sources/CvPlotPaging.cpp
+++ b/Sources/CvPlotPaging.cpp
@@ -21,7 +21,7 @@ namespace {
 
 	int g_iLastLookatX = -1;
 	int g_iLastLookatY = -1;
-	int g_bWasGraphicsPagingEnabled = false;
+	bool g_bWasGraphicsPagingEnabled = false;
 
 	int findFreePagingTableSlot()
 	{
@@ -78,8 +78,8 @@ namespace {
 		return iResult;
 	}
 
-	const int DEFAULT_MAX_WORKING_SET_THRESHOLD_BEFORE_EVICTION = 1024 * 1024 * 1024 * 2; // 2 GB
-	const int DEFAULT_OS_MEMORY_ALLOWANCE = 1024 * 1024 * 512; // 512 MB
+	static const unsigned int DEFAULT_MAX_WORKING_SET_THRESHOLD_BEFORE_EVICTION = 1024U * 1024U * 1024U * 2U; // 2 GB
+	static const unsigned int DEFAULT_OS_MEMORY_ALLOWANCE = 1024U * 1024U * 512U; // 512 MB
 
 	bool NeedToFreeMemory()
 	{
@@ -92,7 +92,7 @@ namespace {
 		{
 			std::vector<void*> test_allocs;
 			bool success = true;
-			for (int i = 0; i < PAGING_TEST_ALLOC_NUM; ++i)
+			for (unsigned int i = 0; i < PAGING_TEST_ALLOC_NUM; ++i)
 			{
 				void* test_alloc = malloc(PAGING_TEST_ALLOC);
 				if (test_alloc == NULL)
@@ -105,7 +105,7 @@ namespace {
 					test_allocs.push_back(test_alloc);
 				}
 			}
-			for (int i = 0; i < test_allocs.size(); ++i)
+			for (size_t i = 0; i < test_allocs.size(); ++i)
 			{
 				free(test_allocs[i]);
 			}
@@ -189,7 +189,7 @@ CvPlotPaging::paging_handle CvPlotPaging::AddPlot(CvPlot* plot)
 
 void CvPlotPaging::RemovePlot(CvPlotPaging::paging_handle handle)
 {
-	FAssertMsg(handle >= 0 && handle < g_pagingTable.size(), "CvPlot paging handle is not valid");
+	FAssertMsg(handle >= 0 && handle < static_cast<CvPlotPaging::paging_handle>(g_pagingTable.size()), "CvPlot paging handle is not valid");
 	FAssertMsg(g_pagingTable[handle].pPlot != NULL, "CvPlot was not paged");
 	g_pagingTable[handle].pPlot = NULL;
 	--g_iNumPagedInPlots;

From ea3daa15ffcc0246ae3529726db192a7ab55d116 Mon Sep 17 00:00:00 2001
From: billw2012 <billw2011@gmail.com>
Date: Sat, 14 Sep 2019 11:40:08 +0100
Subject: [PATCH 4/4] Tweak to hopefully fix fake missing header file error

---
 Sources/CvGameCoreDLL.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/CvGameCoreDLL.h b/Sources/CvGameCoreDLL.h
index 8e897148ba..1e8cac46ab 100644
--- a/Sources/CvGameCoreDLL.h
+++ b/Sources/CvGameCoreDLL.h
@@ -18,7 +18,6 @@
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <MMSystem.h>
-#include <EnumFlags.h>
 
 //#if defined _DEBUG && !defined USE_MEMMANAGER
 //#define USE_MEMMANAGER
@@ -43,6 +42,7 @@
 
 #define DllExport   __declspec( dllexport ) 
 
+#include "EnumFlags.h"
 #include "NiPoint.h"
 
 typedef unsigned char    byte;