First draft for child sections

Author: Fulgen301

src/C4Game.cpp

@@ -960,6 +960,12 @@ bool C4Game::RemoveSection(uint32_t number)
 		std::unique_ptr<C4Section> section{std::move(*it)};
 		Sections.erase(it);
 		SectionsPendingDeletion.emplace_back(std::move(section));
+
+		for (const auto &otherSection : Sections)
+		{
+			otherSection->ClearSectionPointers(*section);
+		}
+
 		return true;
 	}
 
@@ -1200,7 +1206,7 @@ void C4Game::DrawCursors(C4FacetEx &cgo, int32_t iPlayer)
 	for (C4Player *pPlr = Players.First; pPlr; pPlr = pPlr->Next)
 		if (pPlr->Number == iPlayer || iPlayer == NO_OWNER)
 			if (pPlr->CursorFlash || pPlr->SelectFlash)
-				if (pPlr->Cursor)
+				if (pPlr->Cursor && pPlr->Cursor->Section == pPlr->ViewSection)
 				{
 					cursor = pPlr->Cursor;
 					if (Inside<int32_t>(cursor->x - fctCursor.Wdt / 2 - cgo.TargetX, 1 - fctCursor.Wdt, cgo.Wdt) && Inside<int32_t>(cursor->y - cursor->Def->Shape.Hgt / 2 - fctCursor.Hgt - cgo.TargetY, 1 - fctCursor.Hgt, cgo.Hgt))

src/C4GraphicsSystem.cpp

@@ -384,7 +384,7 @@ void C4GraphicsSystem::RecalculateViewports()
 			cOffWdt = cOffHgt = 0;
 			int32_t ViewportScrollBorder = Application.isFullScreen ? C4ViewportScrollBorder : 0;
 
-			C4Section &section{cvp->get()->GetViewSection()};
+			C4Section &section{cvp->get()->GetViewRootSection()};
 			if (ciViewsX * std::min<int32_t>(cViewWdt, section.Landscape.Width + 2 * ViewportScrollBorder) < ViewportArea.Wdt)
 				cOffX = (ViewportArea.Wdt - ciViewsX * std::min<int32_t>(cViewWdt, section.Landscape.Width + 2 * ViewportScrollBorder)) / 2;
 			if (iViewsH * std::min<int32_t>(cViewHgt, section.Landscape.Height + 2 * ViewportScrollBorder) < ViewportArea.Hgt)
@@ -544,7 +544,7 @@ bool C4GraphicsSystem::DoSaveScreenshot(bool fSaveAll, const char *szFilename)
 		// get viewport to draw in
 		const auto &pVP = Viewports.front();
 		// create image large enough to hold the landcape
-		C4Landscape &landscape{pVP->GetViewSection().Landscape};
+		C4Landscape &landscape{pVP->GetViewRootSection().Landscape};
 		int32_t lWdt = static_cast<int32_t>(ceilf(landscape.Width * scale)), lHgt = static_cast<int32_t>(ceilf(landscape.Height * scale));
 		StdBitmap bmp(lWdt, lHgt, false);
 		// get backbuffer size

src/C4MainMenu.cpp

@@ -957,7 +957,7 @@ bool C4MainMenu::ActivateObserver()
 	C4Viewport *const viewport{Game.GraphicsSystem.GetViewport(NO_OWNER)};
 	if (!viewport) return false;
 	// Menu symbol/init
-	InitRefSym(C4GUI::Icon::GetIconFacet(C4GUI::Ico_View), viewport->GetViewSection(), LoadResStr(C4ResStrTableKey::IDS_TEXT_VIEW), NO_OWNER, C4MN_Extra_None, 0, C4MN_Observer, C4MN_Style_Context);
+	InitRefSym(C4GUI::Icon::GetIconFacet(C4GUI::Ico_View), viewport->GetViewRootSection(), LoadResStr(C4ResStrTableKey::IDS_TEXT_VIEW), NO_OWNER, C4MN_Extra_None, 0, C4MN_Observer, C4MN_Style_Context);
 	SetAlignment(C4MN_Align_Left | C4MN_Align_Bottom);
 	// Players added in Refill
 	Refill();

src/C4MouseControl.cpp

@@ -464,10 +464,10 @@ void C4MouseControl::UpdateCursorTarget()
 	// Movement
 	if (!FogOfWar && !IsPassive()) Cursor = C4MC_Cursor_Crosshair;
 
-	C4Section &section{Viewport->GetViewSection()};
+	const auto &[section, childX, childY] = Viewport->MapPointToChildSectionPoint(X, Y);
 
 	// Dig
-	if (!FogOfWar && section.Landscape.GBackSolid(X, Y) && !IsPassive())
+	if (!FogOfWar && section.Landscape.GBackSolid(childX, childY) && !IsPassive())
 	{
 		Cursor = C4MC_Cursor_Dig;
 		if (ControlDown) Cursor = C4MC_Cursor_DigMaterial;
@@ -501,8 +501,8 @@ void C4MouseControl::UpdateCursorTarget()
 		}
 		// Chop (reduced range)
 		if (ocf & OCF_Chop)
-			if (Inside<int32_t>(X - iObjX, -TargetObject->Shape.Wdt / 3, +TargetObject->Shape.Wdt / 3))
-				if (Inside<int32_t>(Y - iObjY, -TargetObject->Shape.Wdt / 2, +TargetObject->Shape.Wdt / 3))
+			if (Inside<int32_t>(childX - iObjX, -TargetObject->Shape.Wdt / 3, +TargetObject->Shape.Wdt / 3))
+				if (Inside<int32_t>(childY - iObjY, -TargetObject->Shape.Wdt / 2, +TargetObject->Shape.Wdt / 3))
 					Cursor = C4MC_Cursor_Chop;
 		// Enter
 		if (ocf & OCF_Entrance)
@@ -528,11 +528,18 @@ void C4MouseControl::UpdateCursorTarget()
 	if (pPlrCursor)
 		if (!pPlrCursor->Contained)
 			if (pPlrCursor->GetProcedure() == DFA_WALK)
-				if (Inside<int32_t>(Y - pPlrCursor->y, -25, -10))
+			{
+				std::int32_t plrCursorSectionChildX{X};
+				std::int32_t plrCursorSectionChildY{Y};
+
+				pPlrCursor->Section->ParentPointToPoint(plrCursorSectionChildX, plrCursorSectionChildY);
+
+				if (Inside<int32_t>(plrCursorSectionChildY - pPlrCursor->y, -25, -10))
 				{
-					if (Inside<int32_t>(X - pPlrCursor->x, -15, -1)) Cursor = C4MC_Cursor_JumpLeft;
-					if (Inside<int32_t>(X - pPlrCursor->x, +1, +15)) Cursor = C4MC_Cursor_JumpRight;
+					if (Inside<int32_t>(plrCursorSectionChildX - pPlrCursor->x, -15, -1)) Cursor = C4MC_Cursor_JumpLeft;
+					if (Inside<int32_t>(plrCursorSectionChildX - pPlrCursor->x, +1, +15)) Cursor = C4MC_Cursor_JumpRight;
 				}
+			}
 
 	// Help
 	if (Help)
@@ -597,7 +604,7 @@ void C4MouseControl::UpdateCursorTarget()
 				break;
 
 			case C4MC_Cursor_DigMaterial:
-				if (section.MatValid(section.Landscape.GetMat(X, Y)))
+				if (section.MatValid(section.Landscape.GetMat(childX, childY)))
 				{
 					SetCaption<C4ResStrTableKey::IDS_CON_DIGOUT>(Game.Defs.ID2Def(section.Material.Map[section.Landscape.GetMat(X, Y)].Dig2Object), true);
 				}
@@ -849,34 +856,35 @@ void C4MouseControl::DragMoving()
 			if (UpdatePutTarget(false))
 				return;
 		// In liquid: drop
-		C4Section &section{Viewport->GetViewSection()};
-		if (section.Landscape.GBackLiquid(X, Y))
+		const auto &[section, x, y] = Viewport->MapPointToChildSectionPoint(X, Y);
+		if (section.Landscape.GBackLiquid(x, y))
 		{
 			Cursor = C4MC_Cursor_Drop; return;
 		}
 		// In free: drop or throw
-		if (!section.Landscape.GBackSolid(X, Y))
+		if (!section.Landscape.GBackSolid(x, y))
 		{
 			// Check drop
-			int32_t iX = X, iY = Y;
+			int32_t iX = x, iY = y;
 			while ((iY < section.Landscape.Height) && !section.Landscape.GBackSolid(iX, iY)) iY++;
-			if (Inside<int32_t>(X - iX, -5, +5) && Inside<int32_t>(Y - iY, -5, +5))
+			if (Inside<int32_t>(x - iX, -5, +5) && Inside<int32_t>(y - iY, -5, +5))
 			{
 				Cursor = C4MC_Cursor_Drop; return;
 			}
 			// Throwing physical
 			C4Fixed fixThrow = ValByPhysical(400, 50000);
 			if (pPlayer->Cursor) fixThrow = ValByPhysical(400, pPlayer->Cursor->GetPhysical()->Throw);
 			// Preferred throwing direction
-			int32_t iDir = +1; if (pPlayer->Cursor) if (pPlayer->Cursor->x > X) iDir = -1;
+			int32_t iDir = +1; if (pPlayer->Cursor) if (pPlayer->Cursor->x > x) iDir = -1;
 			// Throwing height
 			int32_t iHeight = 20; if (pPlayer->Cursor) iHeight = pPlayer->Cursor->Shape.Hgt;
 			// Check throw
-			if (section.Landscape.FindThrowingPosition(X, Y, fixThrow * iDir, -fixThrow, iHeight, iX, iY)
-				|| section.Landscape.FindThrowingPosition(X, Y, fixThrow * (iDir *= -1), -fixThrow, iHeight, iX, iY))
+			if (section.Landscape.FindThrowingPosition(x, y, fixThrow * iDir, -fixThrow, iHeight, iX, iY)
+				|| section.Landscape.FindThrowingPosition(x, y, fixThrow * (iDir *= -1), -fixThrow, iHeight, iX, iY))
 			{
 				Cursor = (iDir == -1) ? C4MC_Cursor_ThrowLeft : C4MC_Cursor_ThrowRight;
 				ShowPointX = iX; ShowPointY = iY;
+				section.PointToParentPoint(ShowPointX, ShowPointY);
 				return;
 			}
 		}
@@ -1225,6 +1233,8 @@ void C4MouseControl::SendCommand(int32_t iCommand, int32_t iX, int32_t iY, C4Obj
 	if (!pPlr || pPlr->Eliminated) return;
 	// User add multiple command mode
 	if (ShiftDown) iAddMode |= C4P_Command_Append;
+	// Map coordinates
+	pPlr->ViewSection.Denumerated()->ParentPointToPoint(iX, iY);
 	// Command to control queue
 	Game.Input.Add(CID_PlrCommand,
 		new C4ControlPlayerCommand(Player, iCommand, iX, iY, pTarget, pTarget2, iData, iAddMode));
@@ -1271,7 +1281,8 @@ void C4MouseControl::UpdateFogOfWar()
 	// Assume no fog of war
 	FogOfWar = false;
 	// Check for fog of war
-	if ((pPlayer->fFogOfWar && !pPlayer->FoWIsVisible(X, Y)) || X < 0 || Y < 0 || X >= Viewport->GetViewSection().Landscape.Width || Y >= Viewport->GetViewSection().Landscape.Height)
+	C4Section &rootSection{pPlayer->ViewSection->GetRootSection()};
+	if (X < 0 || Y < 0 || X >= rootSection.Landscape.Width || Y >= rootSection.Landscape.Height || (pPlayer->fFogOfWar && !pPlayer->FoWIsVisible(X, Y)))
 	{
 		FogOfWar = true;
 		// allow dragging, scrolling, region selection and manipulations of objects not affected by FoW
@@ -1321,10 +1332,12 @@ const char *C4MouseControl::GetCaption()
 C4Object *C4MouseControl::GetTargetObject(int32_t iX, int32_t iY, uint32_t &dwOCF, C4Object *pExclude)
 {
 	// find object
-	C4Object *pObj = Viewport->GetViewSection().FindVisObject(ViewX, ViewY, Player, fctViewport, iX, iY, 0, 0, dwOCF, pExclude);
+	const auto &[section, x, y] = Viewport->MapPointToChildSectionPoint(iX, iY);
+
+	C4Object *pObj = section.FindVisObject(ViewX, ViewY, Player, fctViewport, x, y, 0, 0, dwOCF, pExclude);
 	if (!pObj) return nullptr;
 	// adjust OCF
-	pObj->GetOCFForPos(iX, iY, dwOCF);
+	pObj->GetOCFForPos(x, y, dwOCF);
 	return pObj;
 }
 

src/C4Object.cpp

@@ -5848,6 +5848,20 @@ void C4Object::UnSelect(bool fCursor)
 	Call(PSF_CrewSelection, {C4VBool(true), C4VBool(fCursor)});
 }
 
+void C4Object::GetViewPos(int32_t &riX, int32_t &riY, int32_t tx, int32_t ty, const C4Facet &fctViewport) // get position this object is seen at (for given scroll)
+{
+	if (Category & C4D_Parallax)
+	{
+		GetViewPosPar(riX, riY, tx, ty, fctViewport);
+	}
+	else
+	{
+		riX = x; riY = y;
+	}
+
+	Section->PointToParentPoint(riX, riY);
+}
+
 void C4Object::GetViewPosPar(int32_t &riX, int32_t &riY, int32_t tx, int32_t ty, const C4Facet &fctViewport)
 {
 	int iParX = Local[0].getInt(), iParY = Local[1].getInt();

src/C4Object.h

@@ -410,10 +410,7 @@ class C4Object
 	bool DoSelect(bool fCursor = false); // select in crew (or just set cursor) if not disabled
 	void UnSelect(bool fCursor = false); // unselect in crew (or just task away cursor)
 
-	void GetViewPos(int32_t &riX, int32_t &riY, int32_t tx, int32_t ty, const C4Facet &fctViewport) // get position this object is seen at (for given scroll)
-	{
-		if (Category & C4D_Parallax) GetViewPosPar(riX, riY, tx, ty, fctViewport); else { riX = x; riY = y; }
-	}
+	void GetViewPos(int32_t &riX, int32_t &riY, int32_t tx, int32_t ty, const C4Facet &fctViewport);
 
 	void GetViewPosPar(int32_t &riX, int32_t &riY, int32_t tx, int32_t ty, const C4Facet &fctViewport); // get position this object is seen at, calculating parallaxity
 	bool PutAwayUnusedObject(C4Object *pToMakeRoomForObject); // either directly put the least-needed object away, or add a command to do it - return whether successful

src/C4Player.cpp

@@ -1723,6 +1723,7 @@ void C4Player::UpdateView()
 		{
 			ViewX = pViewObj->x; ViewY = pViewObj->y;
 			ViewSection = pViewObj->Section;
+			ViewSection->PointToParentPoint(ViewX, ViewY);
 		}
 		break;
 	}
@@ -1731,6 +1732,7 @@ void C4Player::UpdateView()
 		{
 			ViewX = ViewTarget->x; ViewY = ViewTarget->y;
 			ViewSection = ViewTarget->Section;
+			ViewSection->PointToParentPoint(ViewX, ViewY);
 		}
 		break;
 	case C4PVM_Scrolling:
@@ -1945,48 +1947,106 @@ void C4Player::InitControl(C4Section &initialSection)
 	PressedComs = 0;
 }
 
+namespace
+{
+	struct ObjectInSection
+	{
+		ObjectInSection(const C4Section &viewRootSection, const C4Object &obj) noexcept
+			: ObjX{obj.x}, ObjY{obj.y}
+		{
+			if (obj.Contained && obj.Contained->Def->ClosedContainer == 1)
+			{
+				visibleToEachOther = false;
+			}
+			else if (&viewRootSection == obj.Section)
+			{
+				visibleToEachOther = true;
+			}
+			else if (obj.Section->IsChildOf(viewRootSection))
+			{
+				visibleToEachOther = true;
+				obj.Section->PointToParentPoint(ObjX, ObjY, &viewRootSection);
+			}
+			else
+			{
+				visibleToEachOther = false;
+			}
+		}
+
+		explicit operator bool() const noexcept { return visibleToEachOther; }
+
+	public:
+		std::int32_t ObjX;
+		std::int32_t ObjY;
+
+	private:
+		bool visibleToEachOther;
+	};
+}
+
 void C4Player::FoW2Map(CClrModAddMap &rMap, int iOffX, int iOffY)
 {
 	// No fog of war
 	if (!fFogOfWar) return;
 	// Add view for all FoW-repellers - keep track of FoW-generators, which should be avaluated finally
 	// so they override repellers
+	C4Section &viewRootSection{ViewSection->GetRootSection()};
 	bool fAnyGenerators = false;
 	C4Object *cobj; C4ObjectLink *clnk;
 	for (clnk = FoWViewObjs.First; clnk && (cobj = clnk->Obj); clnk = clnk->Next)
-		if (cobj->Section == ViewSection && (!cobj->Contained || cobj->Contained->Def->ClosedContainer != 1))
+	{
+		if (const ObjectInSection objInSection{viewRootSection, *cobj}; objInSection)
+		{
 			if (cobj->PlrViewRange > 0)
-				rMap.ReduceModulation(cobj->x + iOffX, cobj->y + iOffY, cobj->PlrViewRange * 2 / 3, cobj->PlrViewRange);
+			{
+				rMap.ReduceModulation(objInSection.ObjX + iOffX, objInSection.ObjY + iOffY, cobj->PlrViewRange * 2 / 3, cobj->PlrViewRange);
+			}
 			else
+			{
 				fAnyGenerators = true;
+			}
+		}
+	}
 	// Add view for target view object
 	if (ViewMode == C4PVM_Target)
+	{
 		if (ViewTarget)
-			if (!ViewTarget->Contained || ViewTarget->Contained->Def->ClosedContainer != 1)
+		{
+			if (const ObjectInSection objInSection{viewRootSection, *ViewTarget}; objInSection)
 			{
 				int iRange = ViewTarget->PlrViewRange;
 				if (!iRange && Cursor) iRange = Cursor->PlrViewRange;
 				if (!iRange) iRange = C4FOW_Def_View_RangeX;
-				rMap.ReduceModulation(ViewTarget->x + iOffX, ViewTarget->y + iOffY, iRange * 2 / 3, iRange);
+
+				rMap.ReduceModulation(objInSection.ObjX	+ iOffX, objInSection.ObjY + iOffY, iRange * 2 / 3, iRange);
 			}
+		}
+	}
 	// apply generators
 	// do this check, be cause in 99% of all normal scenarios, there will be no FoW-generators
-	if (fAnyGenerators) FoWGenerators2Map(rMap, iOffX, iOffY);
+	if (fAnyGenerators) FoWGenerators2Map(rMap, viewRootSection, iOffX, iOffY);
 }
 
-void C4Player::FoWGenerators2Map(CClrModAddMap &rMap, int iOffX, int iOffY)
+void C4Player::FoWGenerators2Map(CClrModAddMap &rMap, C4Section &viewRootSection, int iOffX, int iOffY)
 {
 	// add fog to any generator pos (view range
 	C4Object *cobj; C4ObjectLink *clnk;
 	for (clnk = FoWViewObjs.First; clnk && (cobj = clnk->Obj); clnk = clnk->Next)
-		if (cobj->Section == ViewSection && (!cobj->Contained || cobj->Contained->Def->ClosedContainer != 1))
-			if (cobj->PlrViewRange < 0)
-				rMap.AddModulation(cobj->x + iOffX, cobj->y + iOffY, -cobj->PlrViewRange, -cobj->PlrViewRange + 200, cobj->ColorMod >> 24);
+	{
+		if (cobj->PlrViewRange < 0)
+		{
+			if (const ObjectInSection objInSection{viewRootSection, *cobj}; objInSection)
+			{
+				rMap.AddModulation(objInSection.ObjX + iOffX, objInSection.ObjY + iOffY, -cobj->PlrViewRange, -cobj->PlrViewRange + 200, cobj->ColorMod >> 24);
+			}
+		}
+	}
 }
 
 bool C4Player::FoWIsVisible(int32_t x, int32_t y)
 {
 	// check repellers and generators and ViewTarget
+	C4Section &viewRootSection{ViewSection->GetRootSection()};
 	bool fSeen = false;
 	C4Object *cobj = nullptr; C4ObjectLink *clnk;
 	clnk = FoWViewObjs.First;
@@ -2008,15 +2068,17 @@ bool C4Player::FoWIsVisible(int32_t x, int32_t y)
 			if (!iRange && Cursor) iRange = Cursor->PlrViewRange;
 			if (!iRange) iRange = C4FOW_Def_View_RangeX;
 		}
-		if (cobj->Section == ViewSection && (!cobj->Contained || cobj->Contained->Def->ClosedContainer != 1))
-			if (Distance(cobj->x, cobj->y, x, y) < Abs(iRange))
+		if (const ObjectInSection objInSection{viewRootSection, *cobj}; objInSection)
+		{
+			if (Distance(objInSection.ObjX, objInSection.ObjY, x, y) < Abs(iRange))
 				if (iRange < 0)
 				{
 					if (!(cobj->ColorMod & 0xff000000)) // faded generators generate darkness only; no FoW blocking
 						return false; // shadowed by FoW-generator
 				}
 				else
 					fSeen = true; // made visible by FoW-repeller
+		}
 	}
 	return fSeen;
 }

src/C4Player.h

@@ -233,7 +233,7 @@ class C4Player : public C4PlayerInfoCore
 	void EvaluateLeague(bool fDisconnected, bool fWon);
 
 	void FoW2Map(CClrModAddMap &rMap, int iOffX, int iOffY);
-	void FoWGenerators2Map(CClrModAddMap &rMap, int iOffX, int iOffY);
+	void FoWGenerators2Map(CClrModAddMap &rMap, C4Section &viewRootSection, int iOffX, int iOffY);
 	bool FoWIsVisible(int32_t x, int32_t y); // check whether a point in the landscape is visible
 
 	// runtime statistics

src/C4Rect.h

@@ -37,17 +37,17 @@ class C4Rect
 	void Add(const C4Rect &r2);
 	bool operator==(const C4Rect &r2) const { return !((x - r2.x) | (y - r2.y) | (Wdt - r2.Wdt) | (Hgt - r2.Hgt)); }
 
-	bool Contains(int32_t iX, int32_t iY)
+	constexpr bool Contains(int32_t iX, int32_t iY) const noexcept
 	{
 		return iX >= x && iX < x + Wdt && iY >= y && iY < y + Hgt;
 	}
 
-	bool Contains(int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt)
+	constexpr bool Contains(int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt) const noexcept
 	{
 		return iX >= x && iX + iWdt < x + Wdt && iY >= y && iY + iHgt < y + Hgt;
 	}
 
-	bool Contains(const C4Rect &rect)
+	constexpr bool Contains(const C4Rect &rect) const noexcept
 	{
 		return Contains(rect.x, rect.y, rect.Wdt, rect.Hgt);
 	}