Partial resolution change support

GpApp/DynamicMaps.cpp

@@ -112,6 +112,8 @@ short ReBackUpSavedMap (Rect *theRect, short where, short who)
 			foundIndex = i;
 			mapRect = *theRect;
 			ZeroRectCorner(&mapRect);
+
+			savedMaps[foundIndex].dest = *theRect;
 			
 			CopyBits((BitMap *)*GetGWorldPixMap(backSrcMap), 
 					GetPortBitMapForCopyBits(savedMaps[foundIndex].map), 
@@ -544,7 +546,7 @@ void BackUpPendulum (Rect *src, short index)
 
 // Backs up the pendulums in the event of lights going on or off.
 
-void ReBackUpPendulum (short where, short who)
+void ReBackUpPendulum (short where, short who, short h, short v)
 {
 	short		i, f;
 	
@@ -556,7 +558,12 @@ void ReBackUpPendulum (short where, short who)
 			{
 				if (pendulums[f].who == i)
 				{
-					BackUpPendulum(&pendulums[f].dest, i);
+					Rect &pendulumDest = pendulums[f].dest;
+					pendulumDest.right += h - pendulumDest.left;
+					pendulumDest.bottom += v - pendulumDest.top;
+					pendulumDest.left = h;
+					pendulumDest.top = v;
+					BackUpPendulum(&pendulumDest, i);
 					return;
 				}
 			}

GpApp/Dynamics3.cpp

@@ -153,6 +153,48 @@ void RenderDynamics (void)
 	}
 }
 
+//--------------------------------------------------------------  ZeroDinah
+
+void ZeroDinah(dynaType &dinah)
+{
+	dinah.type = kObjectIsEmpty;
+	QSetRect(&dinah.dest, 0, 0, 0, 0);
+	QSetRect(&dinah.whole, 0, 0, 0, 0);
+	dinah.hVel = 0;
+	dinah.vVel = 0;
+	dinah.count = 0;
+	dinah.frame = 0;
+	dinah.timer = 0;
+	dinah.position = 0;
+	dinah.room = 0;
+	dinah.byte0 = 0;
+	dinah.active = false;
+}
+
+//--------------------------------------------------------------  ZeroDinahsNotInRoom
+void ZeroDinahsNotInRoom (SInt16 room)
+{
+	short		i;
+	short		newNumDynamics = 0;
+
+	for (i = 0; i < numDynamics; i++)
+	{
+		dynaType &dinah = dinahs[i];
+		if (dinah.room == room)
+		{
+			if (newNumDynamics != numDynamics)
+				memcpy(&dinahs[newNumDynamics], &dinahs[i], sizeof(dynaType));
+
+			newNumDynamics++;
+		}
+	}
+
+	for (i = newNumDynamics; i < kMaxDynamicObs; i++)
+		ZeroDinah(dinahs[i]);
+
+	numDynamics = newNumDynamics;
+}
+
 //--------------------------------------------------------------  ZeroDinahs
 
 // This clears all dynamics - zeros them all out.  Used to initialize them.
@@ -162,20 +204,8 @@ void ZeroDinahs (void)
 	short		i;
 	
 	for (i = 0; i < kMaxDynamicObs; i++)
-	{
-		dinahs[i].type = kObjectIsEmpty;
-		QSetRect(&dinahs[i].dest, 0, 0, 0, 0);
-		QSetRect(&dinahs[i].whole, 0, 0, 0, 0);
-		dinahs[i].hVel = 0;
-		dinahs[i].vVel = 0;
-		dinahs[i].count = 0;
-		dinahs[i].frame = 0;
-		dinahs[i].timer = 0;
-		dinahs[i].position = 0;
-		dinahs[i].room = 0;
-		dinahs[i].byte0 = 0;
-		dinahs[i].active = false;
-	}
+		ZeroDinah(dinahs[i]);
+
 	numDynamics = 0;
 }
 
@@ -553,3 +583,12 @@ short AddDynamicObject (short what, Rect *where, objectType *who,
 	return (numDynamics - 1);
 }
 
+void OffsetDynamics(SInt16 h, SInt16 v)
+{
+	for (int i = 0; i < numDynamics; i++)
+	{
+		dynaType &dinah = dinahs[i];
+		//QOffsetRect(&dinah.dest, h, v);
+		//QOffsetRect(&dinah.whole, h, v);
+	}
+}

GpApp/Environ.cpp

@@ -8,12 +8,14 @@
 
 #include "PLResources.h"
 #include "PLPasStr.h"
+#include "DisplayDeviceManager.h"
 #include "Externs.h"
 #include "Environ.h"
 #include "HostDisplayDriver.h"
 #include "HostSystemServices.h"
+#include "MenuManager.h"
 #include "IGpDisplayDriver.h"
-
+#include "WindowManager.h"
 
 #define	kSwitchDepthAlert		130
 #define kSetMemoryAlert			180
@@ -272,6 +274,18 @@ short HowManyUsableScreens (Boolean use1Bit, Boolean use4Bit, Boolean use8Bit)
 	return 1;
 }
 
+//--------------------------------------------------------------  FlushResolutionChange
+void FlushResolutionChange(void)
+{
+	if (thisMac.isResolutionDirty)
+	{
+		GetDeviceRect(&thisMac.screen);
+		thisMac.gray = thisMac.screen;
+		thisMac.gray.top = 20;
+		thisMac.isResolutionDirty = false;
+	}
+}
+
 //--------------------------------------------------------------  CheckOurEnvirons  
 // Calls all the above functions in order to fill out a sort of "spec sheet"<22>
 // for the current Mac.
@@ -293,10 +307,41 @@ void CheckOurEnvirons (void)
 	thisMac.can4Bit = true;
 	thisMac.can8Bit = true;
 	thisMac.numScreens = HowManyUsableScreens(false, true, true);
-	GetDeviceRect(&thisMac.screen);
 	
 	thisMac.wasDepth = WhatsOurDepth();
 	thisMac.wasColorOrGray = AreWeColorOrGrayscale();
+
+	thisMac.isResolutionDirty = true;
+	FlushResolutionChange();
+}
+
+//--------------------------------------------------------------  HandleResolutionChange
+// Installs handler
+void HandleResolutionChange(uint32_t prevWidth, uint32_t prevHeight, uint32_t newWidth, uint32_t newHeight)
+{
+	PortabilityLayer::WindowManager::GetInstance()->HandleScreenResolutionChange(prevWidth, prevHeight, newWidth, newHeight);
+	PortabilityLayer::MenuManager::GetInstance()->DrawMenuBar();
+	thisMac.isResolutionDirty = true;	// Because of legacy code, we don't want to update thisMac.screen immediately, but rather, let the editor or game pick it up
+}
+
+class GpAppResolutionChangeHandler final : public PortabilityLayer::DisplayDeviceManager::IResolutionChangeHandler
+{
+public:
+	void OnResolutionChanged(uint32_t prevWidth, uint32_t prevHeight, uint32_t newWidth, uint32_t newHeight) override
+	{
+		HandleResolutionChange(prevWidth, prevHeight, newWidth, newHeight);
+	}
+
+	static GpAppResolutionChangeHandler ms_instance;
+};
+
+GpAppResolutionChangeHandler GpAppResolutionChangeHandler::ms_instance;
+
+//--------------------------------------------------------------  InstallResolutionHandler
+// Installs handler
+void InstallResolutionHandler(void)
+{
+	PortabilityLayer::DisplayDeviceManager::GetInstance()->SetResolutionChangeHandler(&GpAppResolutionChangeHandler::ms_instance);
 }
 
 //--------------------------------------------------------------  ReflectMonitor2Environs

GpApp/Environ.h

@@ -28,9 +28,10 @@ typedef struct
 	Boolean		hasSM3;
 	Boolean		hasQT;
 	Boolean		hasDrag;
+	Boolean		isResolutionDirty;
 } macEnviron;
 
 
 extern macEnviron	thisMac;
 
-
+void FlushResolutionChange(void);

GpApp/Externs.h

@@ -167,6 +167,7 @@ void IgnoreThisClick (void);
 short WhatsOurDepth (void);								// --- Environs.c
 void SwitchToDepth (short, Boolean);
 void CheckOurEnvirons (void);
+void InstallResolutionHandler (void);
 //void ReflectSecondMonitorEnvirons (Boolean, Boolean, Boolean);
 void HandleDepthSwitching (void);
 void RestoreColorDepth (void);

GpApp/GliderProtos.h

@@ -34,7 +34,7 @@ void ReBackUpTikiFlames (SInt16, SInt16);
 void AddTikiFlame (SInt16, SInt16, SInt16, SInt16);
 void ReBackUpBBQCoals (SInt16, SInt16);
 void AddBBQCoals (SInt16, SInt16, SInt16, SInt16);
-void ReBackUpPendulum (SInt16, SInt16);
+void ReBackUpPendulum (SInt16, SInt16, SInt16, SInt16);
 void AddPendulum (SInt16, SInt16, SInt16, SInt16);
 void ReBackUpStar (SInt16, SInt16);
 void AddStar (SInt16, SInt16, SInt16, SInt16);
@@ -73,7 +73,10 @@ void HandleFish (SInt16);
 void HandleDynamics (void);								// --- Dynamics3.c
 void RenderDynamics (void);
 void ZeroDinahs (void);
+void ZeroDinahsNotInRoom (SInt16);
+
 SInt16 AddDynamicObject (SInt16, Rect *, objectType *, SInt16, SInt16, Boolean);
+void OffsetDynamics(SInt16 h, SInt16 v);
 
 void DoGameOver (void);									// --- GameOver.c
 void FlagGameOver (void);
@@ -132,6 +135,7 @@ void FlagStillOvers (gliderPtr);
 
 void InitializeMenus (void);							// --- InterfaceInit.c
 void GetExtraCursors (void);
+void RecomputeInterfaceRects (void);
 void VariableInit (void);
 
 void GetDemoInput (gliderPtr);							// --- Input.c
@@ -407,7 +411,8 @@ Boolean DoesRoomHaveFloor (void);
 Boolean DoesRoomHaveCeiling (void);
 
 void ReadyLevel (void);									// --- RoomGraphics.c
-void DrawLocale (void);
+void ResetLocale (Boolean soft);
+void DrawLocale (Boolean soft);
 void RedrawRoomLighting (void);
 
 Boolean PictIDExists (SInt16);							// --- RoomInfo.c
@@ -470,6 +475,7 @@ void InitEnemies (void);
 void CreateOffscreens (void);							// --- StructuresInit2.c
 void CreatePointers (void);
 void InitSrcRects (void);
+PLError_t RecreateOffscreens (void);
 
 void UpdateToolsWindow (void);							// --- Tools.c
 void EraseSelectedTool (void);

GpApp/Grease.cpp

@@ -28,8 +28,7 @@ short		numGrease;
 
 extern	hotPtr		hotSpots;
 extern	savedType	savedMaps[];
-extern	Point		shieldPt;
-extern	Rect		greaseSrcRt[], greaseSrcLf[], shieldRect;
+extern	Rect		greaseSrcRt[], greaseSrcLf[];
 
 
 //==============================================================  Functions

GpApp/InterfaceInit.cpp

@@ -27,11 +27,10 @@ struct IGpCursor;
 extern	THandle<Rect>	mirrorRects;
 extern	WindowPtr		mapWindow, toolsWindow, linkWindow;
 extern	WindowPtr		menuWindow;
-extern	Rect			shieldRect, boardSrcRect, localRoomsDest[];
+extern	Rect			boardSrcRect, localRoomsDest[];
 extern	IGpCursor		*handCursor, *vertCursor, *horiCursor;
 extern	IGpCursor		*diagCursor;
 extern	MenuHandle		appleMenu, gameMenu, optionsMenu, houseMenu;
-extern	Point			shieldPt;
 extern	long			incrementModeTime;
 extern	UInt32			doubleTime;
 extern	short			fadeInSequence[], idleMode;
@@ -99,6 +98,34 @@ void GetExtraCursors (void)
 		RedAlert(kErrFailedResourceLoad);
 }
 
+//--------------------------------------------------------------  RecomputeScreenRects
+void RecomputeInterfaceRects (void)
+{
+	houseRect = thisMac.screen;
+	houseRect.bottom -= kScoreboardTall;
+	if (houseRect.right > kMaxViewWidth)
+		houseRect.right = kMaxViewWidth;
+	if (houseRect.bottom > kMaxViewHeight)
+		houseRect.bottom = kMaxViewHeight;
+
+	playOriginH = (RectWide(&thisMac.screen) - kRoomWide) / 2;
+	playOriginV = (RectTall(&thisMac.screen) - kTileHigh) / 2;
+
+	for (int i = 0; i < 9; i++)
+	{
+		QSetRect(&localRoomsDest[i], 0, 0, kRoomWide, kTileHigh);
+		QOffsetRect(&localRoomsDest[i], playOriginH, playOriginV);
+	}
+	QOffsetRect(&localRoomsDest[kNorthRoom], 0, -kVertLocalOffset);
+	QOffsetRect(&localRoomsDest[kNorthEastRoom], kRoomWide, -kVertLocalOffset);
+	QOffsetRect(&localRoomsDest[kEastRoom], kRoomWide, 0);
+	QOffsetRect(&localRoomsDest[kSouthEastRoom], kRoomWide, kVertLocalOffset);
+	QOffsetRect(&localRoomsDest[kSouthRoom], 0, kVertLocalOffset);
+	QOffsetRect(&localRoomsDest[kSouthWestRoom], -kRoomWide, kVertLocalOffset);
+	QOffsetRect(&localRoomsDest[kWestRoom], -kRoomWide, 0);
+	QOffsetRect(&localRoomsDest[kNorthWestRoom], -kRoomWide, -kVertLocalOffset);
+}
+
 //--------------------------------------------------------------  VariableInit
 
 // All the simple interface variables are intialized here - Booleans,<2C>
@@ -108,10 +135,6 @@ void VariableInit (void)
 {
 	short		i;
 	
-	shieldPt.h = 0;
-	shieldPt.v = 0;
-	shieldRect = thisMac.screen;
-	
 	menusUp = false;
 	quitting = false;
 	houseOpen = false;
@@ -186,28 +209,5 @@ void VariableInit (void)
 	nailSrcMap = nil;
 	menuWindow = nil;
 	
-	houseRect = thisMac.screen;
-	houseRect.bottom -= kScoreboardTall;
-	if (houseRect.right > kMaxViewWidth)
-		houseRect.right = kMaxViewWidth;
-	if (houseRect.bottom > kMaxViewHeight)
-		houseRect.bottom = kMaxViewHeight;
-	
-	playOriginH = (RectWide(&thisMac.screen) - kRoomWide) / 2;
-	playOriginV = (RectTall(&thisMac.screen) - kTileHigh) / 2;
-	
-	for (i = 0; i < 9; i++)
-	{
-		QSetRect(&localRoomsDest[i], 0, 0, kRoomWide, kTileHigh);
-		QOffsetRect(&localRoomsDest[i], playOriginH, playOriginV);
-	}
-	QOffsetRect(&localRoomsDest[kNorthRoom], 0, -kVertLocalOffset);
-	QOffsetRect(&localRoomsDest[kNorthEastRoom], kRoomWide, -kVertLocalOffset);
-	QOffsetRect(&localRoomsDest[kEastRoom], kRoomWide, 0);
-	QOffsetRect(&localRoomsDest[kSouthEastRoom], kRoomWide, kVertLocalOffset);
-	QOffsetRect(&localRoomsDest[kSouthRoom], 0, kVertLocalOffset);
-	QOffsetRect(&localRoomsDest[kSouthWestRoom], -kRoomWide, kVertLocalOffset);
-	QOffsetRect(&localRoomsDest[kWestRoom], -kRoomWide, 0);
-	QOffsetRect(&localRoomsDest[kNorthWestRoom], -kRoomWide, -kVertLocalOffset);
+	RecomputeInterfaceRects();
 }
-

GpApp/Main.cpp

@@ -315,6 +315,7 @@ int gpAppMain()
 	
 	ToolBoxInit();
 	CheckOurEnvirons();
+	InstallResolutionHandler();
 	if (!thisMac.hasColor)
 		RedAlert(kErrNeedColorQD);
 	if (!thisMac.hasSystem7)

GpApp/ObjectDrawAll.cpp

@@ -333,8 +333,10 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 					if (legit != -1)
 					{
 						DrawCuckoo(&itsRect);
+						short pendulumH = itsRect.left + 4;
+						short pendulumV = itsRect.top + 46;
 						if (redraw)
-							ReBackUpPendulum(localNumbers[neighbor], i);
+							ReBackUpPendulum(localNumbers[neighbor], i, pendulumH, pendulumV);
 						else
 							AddPendulum(localNumbers[neighbor], i, 
 									itsRect.left + 4, itsRect.top + 46);

GpApp/Play.cpp

@@ -8,6 +8,7 @@
 
 #include "PLResources.h"
 #include "PLStandardColors.h"
+#include "DisplayDeviceManager.h"
 #include "Externs.h"
 #include "Environ.h"
 #include "House.h"
@@ -66,6 +67,7 @@ extern	short		numStarsRemaining, numChimes, saidFollow;
 extern	Boolean		quitting, isMusicOn, gameOver, hasMirror, onePlayerLeft;
 extern	Boolean		isPlayMusicIdle, failedMusic, quickerTransitions;
 extern	Boolean		switchedOut;
+extern	short		wasScoreboardTitleMode;
 
 
 //==============================================================  Functions
@@ -156,7 +158,7 @@ void NewGame (short mode)
 	
 //	DebugStr("\pIf screen isn't black, exit to shell.");	// TEMP TEMP TEMP
 	
-	DrawLocale();
+	ResetLocale(false);
 	RefreshScoreboard(kNormalTitleMode);
 //	if (quickerTransitions)
 //		DissBitsChunky(&justRoomsRect);
@@ -362,12 +364,42 @@ void SetHouseToSavedRoom (void)
 	ForceThisRoom(smallGame.roomNumber);
 }
 
+//--------------------------------------------------------------  HandleGameResolutionChange
+
+void HandleGameResolutionChange(void)
+{
+	short prevPlayOriginH = playOriginH;
+	short prevPlayOriginV = playOriginV;
+
+	Rect prevResolution = thisMac.screen;
+	FlushResolutionChange();
+
+	RecomputeInterfaceRects();
+	RecreateOffscreens();
+	CloseMainWindow();
+	OpenMainWindow();
+
+	if (hasMovie)
+		theMovie.m_surface = &mainWindow->m_surface;
+
+	OffsetDynamics(playOriginH - prevPlayOriginH, playOriginV - prevPlayOriginV);
+
+	ResetLocale(true);
+	RefreshScoreboard(wasScoreboardTitleMode);
+	DumpScreenOn(&justRoomsRect);
+}
+
 //--------------------------------------------------------------  PlayGame
 
 void PlayGame (void)
 {
 	while ((playing) && (!quitting))
 	{
+		if (thisMac.isResolutionDirty)
+		{
+			HandleGameResolutionChange();
+		}
+
 		gameFrame++;
 		evenFrame = !evenFrame;
 		
@@ -730,7 +762,7 @@ void RestoreEntireGameScreen (void)
 	surface->SetForeColor(StdColors::Black());
 	surface->FillRect(tempRect);
 	
-	DrawLocale();
+	ResetLocale(false);
 	RefreshScoreboard(kNormalTitleMode);
 //	if (quickerTransitions)
 //		DissBitsChunky(&justRoomsRect);

GpApp/Render.cpp

@@ -34,9 +34,7 @@ void CopyRectsQD (void);
 
 Rect		work2MainRects[kMaxGarbageRects];
 Rect		back2WorkRects[kMaxGarbageRects];
-Rect		shieldRect;
 THandle<Rect>	mirrorRects;
-Point		shieldPt;
 long		nextFrame;
 short		numWork2Main, numBack2Work;
 Boolean		hasMirror;

GpApp/RoomGraphics.cpp

@@ -42,33 +42,39 @@ extern	Boolean		shadowVisible, takingTheStairs;
 //==============================================================  Functions
 //--------------------------------------------------------------  DrawLocale
 
-void DrawLocale (void)
+void ResetLocale (Boolean soft)
 {
-	short		i, roomV;
+	short		i;
 	char		wasState;
-	DrawSurface	*wasCPort;
-		
-	ZeroFlamesAndTheLike();
-	ZeroDinahs();
-	KillAllBands();
-	ZeroMirrorRegion();
-	ZeroTriggers();
-	numTempManholes = 0;
-	FlushAnyTriggerPlaying();
-	DumpTriggerSound();
-	tvInRoom = false;
-	tvWithMovieNumber = -1;
-	
-	roomV = (*thisHouse)->rooms[thisRoomNumber].floor;
-	
-	for (i = 0; i < 9; i++)
+
+	if (soft)
 	{
-		localNumbers[i] = GetNeighborRoomNumber(i);
-		isStructure[i] = IsRoomAStructure(localNumbers[i]);
 	}
-	ListAllLocalObjects();
-	
-	wasCPort = GetGraphicsPort();
+	else
+	{
+		ZeroFlamesAndTheLike();
+		ZeroDinahs();
+		KillAllBands();
+		ZeroMirrorRegion();
+		ZeroTriggers();
+		numTempManholes = 0;
+		FlushAnyTriggerPlaying();
+		DumpTriggerSound();
+		tvInRoom = false;
+		tvWithMovieNumber = -1;
+
+		for (i = 0; i < 9; i++)
+		{
+			localNumbers[i] = GetNeighborRoomNumber(i);
+			isStructure[i] = IsRoomAStructure(localNumbers[i]);
+		}
+		ListAllLocalObjects();
+	}
+
+	takingTheStairs = false;
+
+	DrawSurface	*wasCPort = GetGraphicsPort();
+	const short roomV = (*thisHouse)->rooms[thisRoomNumber].floor;
 
 	backSrcMap->SetForeColor(StdColors::Black());
 	backSrcMap->FillRect(backSrcRect);
@@ -77,52 +83,51 @@ void DrawLocale (void)
 	{
 		numLights = GetNumberOfLights(localNumbers[kNorthWestRoom]);
 		DrawRoomBackground(localNumbers[kNorthWestRoom], kNorthWestRoom, roomV + 1);
-		DrawARoomsObjects(kNorthWestRoom, false);
+		DrawARoomsObjects(kNorthWestRoom, soft);
 		
 		numLights = GetNumberOfLights(localNumbers[kNorthEastRoom]);
 		DrawRoomBackground(localNumbers[kNorthEastRoom], kNorthEastRoom, roomV + 1);
-		DrawARoomsObjects(kNorthEastRoom, false);
+		DrawARoomsObjects(kNorthEastRoom, soft);
 		
 		numLights = GetNumberOfLights(localNumbers[kNorthRoom]);
 		DrawRoomBackground(localNumbers[kNorthRoom], kNorthRoom, roomV + 1);
-		DrawARoomsObjects(kNorthRoom, false);
+		DrawARoomsObjects(kNorthRoom, soft);
 		
 		numLights = GetNumberOfLights(localNumbers[kSouthWestRoom]);
 		DrawRoomBackground(localNumbers[kSouthWestRoom], kSouthWestRoom, roomV - 1);
-		DrawARoomsObjects(kSouthWestRoom, false);
+		DrawARoomsObjects(kSouthWestRoom, soft);
 		
 		numLights = GetNumberOfLights(localNumbers[kSouthEastRoom]);
 		DrawRoomBackground(localNumbers[kSouthEastRoom], kSouthEastRoom, roomV - 1);
-		DrawARoomsObjects(kSouthEastRoom, false);
+		DrawARoomsObjects(kSouthEastRoom, soft);
 		
 		numLights = GetNumberOfLights(localNumbers[kSouthRoom]);
 		DrawRoomBackground(localNumbers[kSouthRoom], kSouthRoom, roomV - 1);
-		DrawARoomsObjects(kSouthRoom, false);
+		DrawARoomsObjects(kSouthRoom, soft);
 	}
 	
 	if (numNeighbors > 1)
 	{
 		numLights = GetNumberOfLights(localNumbers[kWestRoom]);
 		DrawRoomBackground(localNumbers[kWestRoom], kWestRoom, roomV);
-		DrawARoomsObjects(kWestRoom, false);
+		DrawARoomsObjects(kWestRoom, soft);
 		DrawLighting();
 		
 		numLights = GetNumberOfLights(localNumbers[kEastRoom]);
 		DrawRoomBackground(localNumbers[kEastRoom], kEastRoom, roomV);
-		DrawARoomsObjects(kEastRoom, false);
+		DrawARoomsObjects(kEastRoom, soft);
 		DrawLighting();
 	}
 	
 	numLights = GetNumberOfLights(localNumbers[kCentralRoom]);
 	DrawRoomBackground(localNumbers[kCentralRoom], kCentralRoom, roomV);
-	DrawARoomsObjects(kCentralRoom, false);
+	DrawARoomsObjects(kCentralRoom, soft);
 	DrawLighting();
 
 	if (numNeighbors > 3)
 		DrawFloorSupport();
 	RestoreWorkMap();
 	shadowVisible = IsShadowVisible();
-	takingTheStairs = false;
 	
 	SetGraphicsPort(wasCPort);
 }
@@ -385,7 +390,7 @@ void ReadyLevel (void)
 #endif
 	
 	DetermineRoomOpenings();
-	DrawLocale();
+	ResetLocale(false);
 	InitGarbageRects();
 }
 

GpApp/Scoreboard.cpp

@@ -43,6 +43,7 @@ Rect		badgesDestRects[4];
 DrawSurface	*boardPSrcMap;
 long		displayedScore;
 short		wasScoreboardMode;
+short		wasScoreboardTitleMode;
 Boolean		doRollScore;
 
 extern	Rect		localRoomsDest[], justRoomsRect;
@@ -63,6 +64,7 @@ void MarkScoreboardPortDirty(void)
 
 void RefreshScoreboard (SInt16 mode)
 {
+	wasScoreboardTitleMode = mode;
 	doRollScore = true;
 	
 	RefreshRoomTitle(mode);

GpApp/StructuresInit2.cpp

@@ -11,6 +11,7 @@
 #include "GameOver.h"
 #include "MainWindow.h"
 #include "Objects.h"
+#include "QDManager.h"
 #include "RectUtils.h"
 #include "ResourceManager.h"
 #include "Room.h"
@@ -112,6 +113,34 @@ void InitAngel (void)
 	LoadGraphic(angelMaskMap, kAngelPictID + 1);
 }
 
+//--------------------------------------------------------------  RecreateOffscreens
+// Recreates resolution-dependent offscreen work
+PLError_t RecreateOffscreens(void)
+{
+	PLError_t		theErr;
+
+	PortabilityLayer::QDManager::GetInstance()->SetPort(nullptr);
+
+	if (workSrcMap)
+		DisposeGWorld(workSrcMap);
+
+	if (backSrcMap)
+		DisposeGWorld(backSrcMap);
+
+	justRoomsRect = houseRect;
+	ZeroRectCorner(&justRoomsRect);
+
+	workSrcRect = houseRect;			// Set up work map
+	ZeroRectCorner(&workSrcRect);
+	theErr = CreateOffScreenGWorld(&workSrcMap, &workSrcRect, kPreferredPixelFormat);
+
+	backSrcRect = houseRect;			// Set up background map
+	ZeroRectCorner(&backSrcRect);
+	theErr = CreateOffScreenGWorld(&backSrcMap, &backSrcRect, kPreferredPixelFormat);
+
+	return PLErrors::kNone;
+}
+
 //--------------------------------------------------------------  CreateOffscreens
 // All "utility" or "work" offscreen pix/bit maps are created here.
 // These would be offscreens that are reused throughout a game - they<65>
@@ -121,17 +150,8 @@ void InitAngel (void)
 void CreateOffscreens (void)
 {
 	PLError_t		theErr;
-	
-	justRoomsRect = houseRect;
-	ZeroRectCorner(&justRoomsRect);
-	
-	workSrcRect = houseRect;			// Set up work map
-	ZeroRectCorner(&workSrcRect);
-	theErr = CreateOffScreenGWorld(&workSrcMap, &workSrcRect, kPreferredPixelFormat);
-	
-	backSrcRect = houseRect;			// Set up background map
-	ZeroRectCorner(&backSrcRect);
-	theErr = CreateOffScreenGWorld(&backSrcMap, &backSrcRect, kPreferredPixelFormat);
+
+	theErr = RecreateOffscreens();
 	
 	InitScoreboardMap();	SpinCursor(1);
 	InitGliderMap();		SpinCursor(1);