Fix up most other appliances and enemies on res change

GpApp/DynamicMaps.cpp

@@ -377,7 +377,7 @@ void BackUpTikiFlames (Rect *src, short index)
 
 // This is like the function ReBackUpFlames() but customized for Tiki torches.
 
-void ReBackUpTikiFlames (short where, short who)
+void ReBackUpTikiFlames (short where, short who, short h, short v)
 {
 	short		i, f;
 	
@@ -389,6 +389,7 @@ void ReBackUpTikiFlames (short where, short who)
 			{
 				if (tikiFlames[f].who == i)
 				{
+					QOffsetRect(&tikiFlames[f].dest, h - tikiFlames[f].dest.left, v - tikiFlames[f].dest.top);
 					BackUpTikiFlames(&tikiFlames[f].dest, i);
 					return;
 				}
@@ -463,7 +464,7 @@ void BackUpBBQCoals (Rect *src, short index)
 
 // Sense a pattern here?
 
-void ReBackUpBBQCoals (short where, short who)
+void ReBackUpBBQCoals (short where, short who, short h, short v)
 {
 	short		i, f;
 	
@@ -475,6 +476,7 @@ void ReBackUpBBQCoals (short where, short who)
 			{
 				if (bbqCoals[f].who == i)
 				{
+					QOffsetRect(&bbqCoals[f].dest, h - bbqCoals[f].dest.left, v - bbqCoals[f].dest.top);
 					BackUpBBQCoals(&bbqCoals[f].dest, i);
 					return;
 				}
@@ -644,7 +646,7 @@ void BackUpStar (Rect *src, short index)
 
 // Re-backs up the stars - in the event of lighting switch.
 
-void ReBackUpStar (short where, short who)
+void ReBackUpStar (short where, short who, short h, short v)
 {
 	short		i, f;
 	
@@ -656,6 +658,7 @@ void ReBackUpStar (short where, short who)
 			{
 				if (theStars[f].who == i)
 				{
+					QOffsetRect(&theStars[f].dest, h - theStars[f].dest.left, v - theStars[f].dest.top);
 					BackUpStar(&theStars[f].dest, i);
 					return;
 				}

GpApp/Dynamics3.cpp

@@ -215,290 +215,369 @@ void ZeroDinahs (void)
 // This function sets up the structures to handle them.
 
 short AddDynamicObject (short what, Rect *where, objectType *who, 
-		short room, short index, Boolean isOn)
+		short room, short index, Boolean isOn, Boolean keepExisting)
 {
 	short		position, velocity;
 	Boolean		lilFrame;
 
+	short		dynIndex = -1;
+
+	if (!keepExisting)
+	{
 		if (numDynamics >= kMaxDynamicObs)
 			return (-1);
 
-	dinahs[numDynamics].type = what;
+		dynIndex = numDynamics;
+		numDynamics++;
+
+		dinahs[dynIndex].type = what;
+	}
+	else
+	{
+		for (int i = 0; i < numDynamics; i++)
+		{
+			if (dinahs[i].type == what && dinahs[i].room == room && dinahs[i].byte0 == index)
+			{
+				dynIndex = i;
+				break;
+			}
+		}
+
+		if (dynIndex == -1)
+			return (-1);
+	}
+	
 	switch (what)
 	{
 	case kSparkle:
-		dinahs[numDynamics].dest = sparkleSrc[0];
+		dinahs[dynIndex].dest = sparkleSrc[0];
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, where->left, where->top);
+		QOffsetRect(&dinahs[dynIndex].dest, where->left, where->top);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+
-		dinahs[numDynamics].vVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].count = 0;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = 0;
-		dinahs[numDynamics].timer = RandomInt(60) + 15;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].count = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].timer = RandomInt(60) + 15;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kToaster:
-		dinahs[numDynamics].dest = breadSrc[0];
+		{
-		CenterRectInRect(&dinahs[numDynamics].dest, where);
+			short baselineDelta = 0;
-		VOffsetRect(&dinahs[numDynamics].dest, 
+			if (keepExisting)
-				where->top - dinahs[numDynamics].dest.top);
+				baselineDelta = dinahs[dynIndex].dest.top - (where->top - 2);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+
-		dinahs[numDynamics].hVel = where->top + 2;	// hVel used as clip
+			dinahs[dynIndex].dest = breadSrc[0];
+			CenterRectInRect(&dinahs[dynIndex].dest, where);
+			VOffsetRect(&dinahs[dynIndex].dest, 
+				where->top - dinahs[dynIndex].dest.top + baselineDelta);
+
+			dinahs[dynIndex].whole = dinahs[dynIndex].dest;
+			dinahs[dynIndex].hVel = where->top + 2;	// hVel used as clip
+
+			if (!keepExisting)
+			{
 				position = who->data.g.height;				// reverse engineer init. vel.
 				velocity = 0;
 				do
 				{
 					velocity++;
 					position -= velocity;
+				} while (position > 0);
+				dinahs[dynIndex].vVel = -velocity;
+				dinahs[dynIndex].count = velocity;		// count = initial velocity
+				dinahs[dynIndex].frame = (short)who->data.g.delay * 3;
+				dinahs[dynIndex].timer = dinahs[dynIndex].frame;
+				dinahs[dynIndex].position = 0;			// launch/idle state
+				dinahs[dynIndex].room = room;
+				dinahs[dynIndex].byte0 = (Byte)index;
+				dinahs[dynIndex].byte1 = 0;
+				dinahs[dynIndex].moving = false;
+				dinahs[dynIndex].active = isOn;
+			}
 		}
-		while (position > 0);
-		dinahs[numDynamics].vVel = -velocity;
-		dinahs[numDynamics].count = velocity;		// count = initial velocity
-		dinahs[numDynamics].frame = (short)who->data.g.delay * 3;
-		dinahs[numDynamics].timer = dinahs[numDynamics].frame;
-		dinahs[numDynamics].position = 0;			// launch/idle state
-		dinahs[numDynamics].room = room;
-		dinahs[numDynamics].byte0 = (Byte)index;
-		dinahs[numDynamics].byte1 = 0;
-		dinahs[numDynamics].moving = false;
-		dinahs[numDynamics].active = isOn;
 		break;
 		
 	case kMacPlus:
-		dinahs[numDynamics].dest = plusScreen1;
+		dinahs[dynIndex].dest = plusScreen1;
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH + 10, 
 				where->top + playOriginV + 7);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].vVel = 0;
+		{
-		dinahs[numDynamics].count = 0;
+			dinahs[dynIndex].hVel = 0;
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].timer = 0;
+			dinahs[dynIndex].count = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].timer = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].byte0 = (Byte)index;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kTV:
-		dinahs[numDynamics].dest = tvScreen1;
+		dinahs[dynIndex].dest = tvScreen1;
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH + 17, 
 				where->top + playOriginV + 10);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].vVel = 0;
+		{
-		dinahs[numDynamics].count = 0;
+			dinahs[dynIndex].hVel = 0;
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].timer = 0;
+			dinahs[dynIndex].count = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].timer = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].byte0 = (Byte)index;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kCoffee:
-		dinahs[numDynamics].dest = coffeeLight1;
+		dinahs[dynIndex].dest = coffeeLight1;
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH + 32, 
 				where->top + playOriginV + 57);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+
-		dinahs[numDynamics].vVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].count = 0;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = 0;
+			dinahs[dynIndex].vVel = 0;
+			dinahs[dynIndex].count = 0;
+			dinahs[dynIndex].frame = 0;
 			if (isOn)
-			dinahs[numDynamics].timer = 200;
+				dinahs[dynIndex].timer = 200;
 			else
-			dinahs[numDynamics].timer = 0;
+				dinahs[dynIndex].timer = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].byte0 = (Byte)index;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].byte1 = 0;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].moving = false;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kOutlet:
-		dinahs[numDynamics].dest = outletSrc[0];
+		dinahs[dynIndex].dest = outletSrc[0];
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH, 
 				where->top + playOriginV);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = numLights;
+
-		dinahs[numDynamics].vVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].count = ((short)who->data.g.delay * 6) / kTicksPerFrame;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = numLights;
-		dinahs[numDynamics].timer = dinahs[numDynamics].count;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].position = 0;			// launch/idle state
+			dinahs[dynIndex].count = ((short)who->data.g.delay * 6) / kTicksPerFrame;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].timer = dinahs[dynIndex].count;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].position = 0;			// launch/idle state
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kVCR:
-		dinahs[numDynamics].dest = vcrTime1;
+		dinahs[dynIndex].dest = vcrTime1;
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH + 64, 
 				where->top + playOriginV + 6);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+
-		dinahs[numDynamics].vVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].count = 0;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = 0;
+			dinahs[dynIndex].vVel = 0;
+			dinahs[dynIndex].count = 0;
+			dinahs[dynIndex].frame = 0;
 			if (isOn)
-			dinahs[numDynamics].timer = 115;
+				dinahs[dynIndex].timer = 115;
 			else
-			dinahs[numDynamics].timer = 0;
+				dinahs[dynIndex].timer = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].byte0 = (Byte)index;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].byte1 = 0;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].moving = false;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kStereo:
-		dinahs[numDynamics].dest = stereoLight1;
+		dinahs[dynIndex].dest = stereoLight1;
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH + 56, 
 				where->top + playOriginV + 20);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+
-		dinahs[numDynamics].vVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].count = 0;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = 0;
-		dinahs[numDynamics].timer = 0;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].count = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].timer = 0;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kMicrowave:
-		dinahs[numDynamics].dest = microOn;
+		dinahs[dynIndex].dest = microOn;
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + playOriginH + 14, 
 				where->top + playOriginV + 13);
-		dinahs[numDynamics].dest.right = dinahs[numDynamics].dest.left + 48;
+		dinahs[dynIndex].dest.right = dinahs[dynIndex].dest.left + 48;
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+
-		dinahs[numDynamics].vVel = 0;
+		if (!keepExisting)
-		dinahs[numDynamics].count = 0;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = 0;
-		dinahs[numDynamics].timer = 0;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].count = 0;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].timer = 0;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kBalloon:
-		dinahs[numDynamics].dest = balloonSrc[0];
+		dinahs[dynIndex].dest = balloonSrc[0];
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, where->left, 0);
+		QOffsetRect(&dinahs[dynIndex].dest, where->left, 0);
-		dinahs[numDynamics].dest.bottom = kBalloonStart;
+		dinahs[dynIndex].dest.bottom = kBalloonStart;
-		dinahs[numDynamics].dest.top = dinahs[numDynamics].dest.bottom - 
+		dinahs[dynIndex].dest.top = dinahs[dynIndex].dest.bottom - 
 				RectTall(&balloonSrc[0]);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+
-		dinahs[numDynamics].vVel = -2;
+		if (!keepExisting)
-		dinahs[numDynamics].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
+		{
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].hVel = 0;
-		dinahs[numDynamics].timer = dinahs[numDynamics].count;
+			dinahs[dynIndex].vVel = -2;
-		dinahs[numDynamics].position = 0;
+			dinahs[dynIndex].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].timer = dinahs[dynIndex].count;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].position = 0;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].active = isOn;			// initially idle
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;			// initially idle
+		}
 		break;
 		
 	case kCopterLf:
 	case kCopterRt:
-		dinahs[numDynamics].dest = copterSrc[0];
+		dinahs[dynIndex].dest = copterSrc[0];
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, where->left, 0);
+		QOffsetRect(&dinahs[dynIndex].dest, where->left, 0);
-		dinahs[numDynamics].dest.top = kCopterStart;
+		dinahs[dynIndex].dest.top = kCopterStart;
-		dinahs[numDynamics].dest.bottom = dinahs[numDynamics].dest.top + 
+		dinahs[dynIndex].dest.bottom = dinahs[dynIndex].dest.top + 
 				RectTall(&copterSrc[0]);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
+		dinahs[dynIndex].position = dinahs[dynIndex].dest.left;
+
+		if (!keepExisting)
+		{
 			if (what == kCopterLf)
-			dinahs[numDynamics].hVel = -1;
+				dinahs[dynIndex].hVel = -1;
 			else
-			dinahs[numDynamics].hVel = 1;
+				dinahs[dynIndex].hVel = 1;
-		dinahs[numDynamics].vVel = 2;
+			dinahs[dynIndex].vVel = 2;
-		dinahs[numDynamics].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
+			dinahs[dynIndex].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
-		dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].frame = 0;
-		dinahs[numDynamics].timer = dinahs[numDynamics].count;
+			dinahs[dynIndex].timer = dinahs[dynIndex].count;
-		dinahs[numDynamics].position = dinahs[numDynamics].dest.left;
+			dinahs[dynIndex].room = room;
-		dinahs[numDynamics].room = room;
+			dinahs[dynIndex].byte0 = (Byte)index;
-		dinahs[numDynamics].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
-		dinahs[numDynamics].byte1 = 0;
+			dinahs[dynIndex].moving = false;
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].active = isOn;			// initially idle
-		dinahs[numDynamics].active = isOn;			// initially idle
+		}
 		break;
 		
 	case kDartLf:
 	case kDartRt:
-		dinahs[numDynamics].dest = dartSrc[0];
+		dinahs[dynIndex].dest = dartSrc[0];
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
 		if (what == kDartLf)
 		{
-			QOffsetRect(&dinahs[numDynamics].dest, 
+			QOffsetRect(&dinahs[dynIndex].dest, 
 					kRoomWide - RectWide(&dartSrc[0]), where->top);
-			dinahs[numDynamics].hVel = -kDartVelocity;
+			dinahs[dynIndex].hVel = -kDartVelocity;
-			dinahs[numDynamics].frame = 0;
+			dinahs[dynIndex].frame = 0;
 		}
 		else
 		{
-			QOffsetRect(&dinahs[numDynamics].dest, 0, where->top);
+			QOffsetRect(&dinahs[dynIndex].dest, 0, where->top);
-			dinahs[numDynamics].hVel = kDartVelocity;
+			dinahs[dynIndex].hVel = kDartVelocity;
-			dinahs[numDynamics].frame = 2;
+			dinahs[dynIndex].frame = 2;
+		}
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
+		dinahs[dynIndex].position = dinahs[dynIndex].dest.top;
+
+		if (!keepExisting)
+		{
+			dinahs[dynIndex].vVel = 2;
+			dinahs[dynIndex].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
+			dinahs[dynIndex].timer = dinahs[dynIndex].count;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;			// initially idle
 		}
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
-		dinahs[numDynamics].vVel = 2;
-		dinahs[numDynamics].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
-		dinahs[numDynamics].timer = dinahs[numDynamics].count;
-		dinahs[numDynamics].position = dinahs[numDynamics].dest.top;
-		dinahs[numDynamics].byte0 = (Byte)index;
-		dinahs[numDynamics].byte1 = 0;
-		dinahs[numDynamics].moving = false;
-		dinahs[numDynamics].active = isOn;			// initially idle
 		break;
 		
 	case kBall:
-		dinahs[numDynamics].dest = ballSrc[0];
+		dinahs[dynIndex].dest = ballSrc[0];
-		ZeroRectCorner(&dinahs[numDynamics].dest);
+		ZeroRectCorner(&dinahs[dynIndex].dest);
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left, where->top);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = 0;
+		dinahs[dynIndex].position = dinahs[dynIndex].dest.bottom;
+
+		if (!keepExisting)
+		{
+			dinahs[dynIndex].hVel = 0;
 			position = who->data.h.length;			// reverse engineer init. vel.
 			velocity = 0;
 			evenFrame = true;
@@ -509,46 +588,53 @@ short AddDynamicObject (short what, Rect *where, objectType *who,
 					velocity++;
 				lilFrame = !lilFrame;
 				position -= velocity;
+			} while (position > 0);
+			dinahs[dynIndex].vVel = -velocity;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].count = -velocity;	// count = initial velocity
+			dinahs[dynIndex].frame = 0;
+			dinahs[dynIndex].timer = 0;
+			dinahs[dynIndex].room = room;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].active = isOn;
 		}
-		while (position > 0);
-		dinahs[numDynamics].vVel = -velocity;
-		dinahs[numDynamics].moving = false;
-		dinahs[numDynamics].count = -velocity;	// count = initial velocity
-		dinahs[numDynamics].frame = 0;
-		dinahs[numDynamics].timer = 0;
-		dinahs[numDynamics].position = dinahs[numDynamics].dest.bottom;
-		dinahs[numDynamics].room = room;
-		dinahs[numDynamics].byte0 = (Byte)index;
-		dinahs[numDynamics].byte1 = 0;
-		dinahs[numDynamics].active = isOn;
 		break;
 		
 	case kDrip:
-		dinahs[numDynamics].dest = dripSrc[0];
+		dinahs[dynIndex].dest = dripSrc[0];
-		CenterRectInRect(&dinahs[numDynamics].dest, where);
+		CenterRectInRect(&dinahs[dynIndex].dest, where);
-		VOffsetRect(&dinahs[numDynamics].dest, 
+		VOffsetRect(&dinahs[dynIndex].dest, 
-				where->top - dinahs[numDynamics].dest.top);
+				where->top - dinahs[dynIndex].dest.top);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = dinahs[numDynamics].dest.top;	// remember
+		dinahs[dynIndex].hVel = dinahs[dynIndex].dest.top;	// remember
-		dinahs[numDynamics].vVel = 0;
+		dinahs[dynIndex].position = dinahs[dynIndex].dest.top +
-		dinahs[numDynamics].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
-		dinahs[numDynamics].frame = 3;
-		dinahs[numDynamics].timer = dinahs[numDynamics].count;
-		dinahs[numDynamics].position = dinahs[numDynamics].dest.top + 
 			who->data.h.length;
-		dinahs[numDynamics].room = room;
+
-		dinahs[numDynamics].byte0 = (Byte)index;
+		if (!keepExisting)
-		dinahs[numDynamics].byte1 = 0;
+		{
-		dinahs[numDynamics].moving = false;
+			dinahs[dynIndex].vVel = 0;
-		dinahs[numDynamics].active = isOn;
+			dinahs[dynIndex].count = ((short)who->data.h.delay * 6) / kTicksPerFrame;
+			dinahs[dynIndex].frame = 3;
+			dinahs[dynIndex].timer = dinahs[dynIndex].count;
+			dinahs[dynIndex].room = room;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
+		}
 		break;
 		
 	case kFish:
-		dinahs[numDynamics].dest = fishSrc[0];
+		dinahs[dynIndex].dest = fishSrc[0];
-		QOffsetRect(&dinahs[numDynamics].dest, 
+		QOffsetRect(&dinahs[dynIndex].dest, 
 				where->left + 10, where->top + 8);
-		dinahs[numDynamics].whole = dinahs[numDynamics].dest;
+		dinahs[dynIndex].whole = dinahs[dynIndex].dest;
-		dinahs[numDynamics].hVel = ((short)who->data.h.delay * 6) / kTicksPerFrame;
+		dinahs[dynIndex].position = dinahs[dynIndex].dest.bottom;
+
+		if (!keepExisting)
+		{
+			dinahs[dynIndex].hVel = ((short)who->data.h.delay * 6) / kTicksPerFrame;
 			position = who->data.g.height;			// reverse engineer init. vel.
 			velocity = 0;
 			evenFrame = true;
@@ -559,28 +645,24 @@ short AddDynamicObject (short what, Rect *where, objectType *who,
 					velocity++;
 				lilFrame = !lilFrame;
 				position -= velocity;
+			} while (position > 0);
+			dinahs[dynIndex].vVel = -velocity;
+			dinahs[dynIndex].count = -velocity;	// count = initial velocity
+			dinahs[dynIndex].frame = 0;
+			dinahs[dynIndex].timer = dinahs[dynIndex].hVel;
+			dinahs[dynIndex].room = room;
+			dinahs[dynIndex].byte0 = (Byte)index;
+			dinahs[dynIndex].byte1 = 0;
+			dinahs[dynIndex].moving = false;
+			dinahs[dynIndex].active = isOn;
 		}
-		while (position > 0);
-		dinahs[numDynamics].vVel = -velocity;
-		dinahs[numDynamics].count = -velocity;	// count = initial velocity
-		dinahs[numDynamics].frame = 0;
-		dinahs[numDynamics].timer = dinahs[numDynamics].hVel;
-		dinahs[numDynamics].position = dinahs[numDynamics].dest.bottom;
-		dinahs[numDynamics].room = room;
-		dinahs[numDynamics].byte0 = (Byte)index;
-		dinahs[numDynamics].byte1 = 0;
-		dinahs[numDynamics].moving = false;
-		dinahs[numDynamics].active = isOn;
 		break;
 		
 	default:
-		return (-1);
 		break;
 	}
 
-	numDynamics++;
+	return dynIndex;
-	
-	return (numDynamics - 1);
 }
 
 void OffsetDynamics(SInt16 h, SInt16 v)

GpApp/GliderProtos.h

@@ -30,13 +30,13 @@ void AddSparkle (Rect *);
 void AddFlyingPoint (Rect *, SInt16, SInt16, SInt16);
 void ReBackUpFlames (SInt16, SInt16, SInt16, SInt16);
 void AddCandleFlame (SInt16, SInt16, SInt16, SInt16);
-void ReBackUpTikiFlames (SInt16, SInt16);
+void ReBackUpTikiFlames (SInt16, SInt16, SInt16, SInt16);
 void AddTikiFlame (SInt16, SInt16, SInt16, SInt16);
-void ReBackUpBBQCoals (SInt16, SInt16);
+void ReBackUpBBQCoals (SInt16, SInt16, SInt16, SInt16);
 void AddBBQCoals (SInt16, SInt16, SInt16, SInt16);
 void ReBackUpPendulum (SInt16, SInt16, SInt16, SInt16);
 void AddPendulum (SInt16, SInt16, SInt16, SInt16);
-void ReBackUpStar (SInt16, SInt16);
+void ReBackUpStar (SInt16, SInt16, SInt16, SInt16);
 void AddStar (SInt16, SInt16, SInt16, SInt16);
 void StopPendulum (SInt16, SInt16);
 void StopStar (SInt16, SInt16);
@@ -75,7 +75,7 @@ void RenderDynamics (void);
 void ZeroDinahs (void);
 void ZeroDinahsNotInRoom (SInt16);
 
-SInt16 AddDynamicObject (SInt16, Rect *, objectType *, SInt16, SInt16, Boolean);
+SInt16 AddDynamicObject(SInt16 what, Rect *where, objectType *who, SInt16 room, SInt16 index, Boolean isOn, Boolean keepExisting);
 void OffsetDynamics(SInt16 h, SInt16 v);
 
 void DoGameOver (void);									// --- GameOver.c

GpApp/ObjectDrawAll.cpp

@@ -179,15 +179,18 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				break;
 				
 				case kTiki:
+				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
+					const short h = itsRect.left + 10;
+					const short v = itsRect.top - 9;
 					if (isLit)
 						DrawTiki(&itsRect, playOriginV + VerticalRoomOffset(neighbor));
 					if (redraw)
-					ReBackUpTikiFlames(localNumbers[neighbor], i);
+						ReBackUpTikiFlames(localNumbers[neighbor], i, h, v);
 					else
-					AddTikiFlame(localNumbers[neighbor], i, 
+						AddTikiFlame(localNumbers[neighbor], i, h, v);
-							itsRect.left + 10, itsRect.top - 9);
+				}
 				break;
 				
 				case kBBQ:
@@ -195,13 +198,14 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				OffsetRectRoomRelative(&itsRect, neighbor);
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
+					const short h = itsRect.left + 16;
+					const short v = itsRect.top + 9;
 					if (isLit)
 						DrawPictSansWhiteObject(thisObject.what, &itsRect);
 					if (redraw)
-						ReBackUpBBQCoals(localNumbers[neighbor], i);
+						ReBackUpBBQCoals(localNumbers[neighbor], i, h, v);
 					else
-						AddBBQCoals(localNumbers[neighbor], i, 
+						AddBBQCoals(localNumbers[neighbor], i, h, v);
-								itsRect.left + 16, itsRect.top + 9);
 				}
 				break;
 				
@@ -455,7 +459,7 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 					if (legit != -1)
 					{
 						if (redraw)
-							ReBackUpStar(localNumbers[neighbor], i);
+							ReBackUpStar(localNumbers[neighbor], i, itsRect.left, itsRect.top);
 						else
 							AddStar(localNumbers[neighbor], i, itsRect.left, 
 									itsRect.top);
@@ -469,12 +473,12 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				OffsetRectRoomRelative(&itsRect, neighbor);
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
-					if ((!redraw) && (neighbor == kCentralRoom))
+					if (neighbor == kCentralRoom)
 					{
 						rectA = itsRect;
 						QOffsetRect(&rectA, -playOriginH, -playOriginV);
 						dynamicNum = AddDynamicObject(kSparkle, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.c.state);
+								localNumbers[neighbor], i, thisObject.data.c.state, redraw);
 					}
 				}
 				break;
@@ -665,12 +669,12 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawSimpleAppliance(thisObject.what, &itsRect);
-					if ((!redraw) && (neighbor == kCentralRoom))
+					if (neighbor == kCentralRoom)
 					{
 						rectA = itsRect;
 						QOffsetRect(&rectA, -playOriginH, -playOriginV);
 						dynamicNum = AddDynamicObject(kToaster, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+								localNumbers[neighbor], i, thisObject.data.g.state, redraw);
 					}
 				}
 				break;
@@ -681,13 +685,10 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawMacPlus(&itsRect, thisObject.data.g.state, isLit);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kMacPlus, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
-					}
 				}
 				break;
 				
@@ -711,12 +712,12 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 					}
 #endif
 					DrawTV(&itsRect, thisObject.data.g.state, isLit);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kTV, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
+					if (!redraw)
+					{
 #ifdef COMPILEQT
 						if ((thisMac.hasQT) && (hasMovie) && (neighbor == kCentralRoom) && 
 								(!tvInRoom))
@@ -735,13 +736,10 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawCoffee(&itsRect, thisObject.data.g.state, isLit);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kCoffee, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
-					}
 				}
 				break;
 				
@@ -752,13 +750,10 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				{
 					if (isLit)
 						DrawOutlet(&itsRect);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kOutlet, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
-					}
 				}
 				break;
 				
@@ -768,13 +763,10 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawVCR(&itsRect, thisObject.data.g.state, isLit);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kVCR, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
-					}
 				}
 				break;
 				
@@ -784,13 +776,10 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawStereo(&itsRect, isPlayMusicGame, isLit);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kStereo, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
-					}
 				}
 				break;
 				
@@ -800,79 +789,76 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawMicrowave(&itsRect, thisObject.data.g.state, isLit);
-					if (!redraw)
-					{
 					rectA = itsRect;
 					QOffsetRect(&rectA, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kMicrowave, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.g.state);
+							localNumbers[neighbor], i, thisObject.data.g.state, redraw);
-					}
 				}
 				break;
 				
 				case kBalloon:
-				if ((neighbor == kCentralRoom) && (!redraw))
+				if (neighbor == kCentralRoom)
 				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
 					QOffsetRect(&itsRect, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kBalloon, &itsRect, &thisObject, 
-							localNumbers[neighbor], i, thisObject.data.h.state);
+							localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 				}
 				break;
 				
 				case kCopterLf:
-				if ((neighbor == kCentralRoom) && (!redraw))
+				if (neighbor == kCentralRoom)
 				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
 					QOffsetRect(&itsRect, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kCopterLf, &itsRect, &thisObject, 
-							localNumbers[neighbor], i, thisObject.data.h.state);
+							localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 				}
 				break;
 				
 				case kCopterRt:
-				if ((neighbor == kCentralRoom) && (!redraw))
+				if (neighbor == kCentralRoom)
 				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
 					QOffsetRect(&itsRect, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kCopterRt, &itsRect, &thisObject, 
-							localNumbers[neighbor], i, thisObject.data.h.state);
+							localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 				}
 				break;
 				
 				case kDartLf:
-				if ((neighbor == kCentralRoom) && (!redraw))
+				if (neighbor == kCentralRoom)
 				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
 					QOffsetRect(&itsRect, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kDartLf, &itsRect, &thisObject, 
-							localNumbers[neighbor], i, thisObject.data.h.state);
+							localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 				}
 				break;
 				
 				case kDartRt:
-				if ((neighbor == kCentralRoom) && (!redraw))
+				if (neighbor == kCentralRoom)
 				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
 					QOffsetRect(&itsRect, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kDartRt, &itsRect, &thisObject, 
-							localNumbers[neighbor], i, thisObject.data.h.state);
+							localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 				}
 				break;
 				
 				case kBall:
-				if ((neighbor == kCentralRoom) && (!redraw))
+				if (neighbor == kCentralRoom)
 				{
 					GetObjectRect(&thisObject, &itsRect);
 					OffsetRectRoomRelative(&itsRect, neighbor);
 					QOffsetRect(&itsRect, -playOriginH, -playOriginV);
 					dynamicNum = AddDynamicObject(kBall, &itsRect, &thisObject, 
-							localNumbers[neighbor], i, thisObject.data.h.state);
+							localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 				}
 				break;
 				
@@ -882,12 +868,12 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawDrip(&itsRect);
-					if ((!redraw) && (neighbor == kCentralRoom))
+					if (neighbor == kCentralRoom)
 					{
 						rectA = itsRect;
 						QOffsetRect(&rectA, -playOriginH, -playOriginV);
 						dynamicNum = AddDynamicObject(kDrip, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.h.state);
+								localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 					}
 				}
 				break;
@@ -898,12 +884,12 @@ void DrawARoomsObjects (short neighbor, Boolean redraw)
 				if (SectRect(&itsRect, &testRect, &whoCares))
 				{
 					DrawFish(thisObject.what, &itsRect);
-					if ((!redraw) && (neighbor == kCentralRoom))
+					if (neighbor == kCentralRoom)
 					{
 						rectA = itsRect;
 						QOffsetRect(&rectA, -playOriginH, -playOriginV);
 						dynamicNum = AddDynamicObject(kFish, &rectA, &thisObject, 
-								localNumbers[neighbor], i, thisObject.data.h.state);
+								localNumbers[neighbor], i, thisObject.data.h.state, redraw);
 					}
 				}
 				break;