GliderPRO/Sources/ObjectDraw2.c
John Calhoun 7a70d18ba6 First check-in.
Sources for Glider PRO, a Macintosh game written by John Calhoun and
published by Casady & Greene, Inc. I believe it was using CodeWarrior
IDE to create a fat (68K and PowerPC) binary.
2016-01-28 08:10:38 -08:00

1 line
38 KiB
C
Executable File

//============================================================================
//----------------------------------------------------------------------------
// ObjectDraw2.c
//----------------------------------------------------------------------------
//============================================================================
#include <Resources.h>
#include <TextUtils.h>
#include "Externs.h"
#include "Environ.h"
#include "Objects.h"
#include "RectUtils.h"
#include "Room.h"
#include "Utilities.h"
#define k8WhiteColor 0
#define kIntenseYellowColor 5
#define kPaleVioletColor 42
#define kDarkFleshColor 58
#define k8TanColor 94
#define k8PissYellowColor 95
#define k8BrownColor 137
#define k8SkyColor 150
#define k8EarthBlueColor 170
#define k8DkRed2Color 223
#define kIntenseGreenColor 225
#define kIntenseBlueColor 235
#define k8LtstGrayColor 245
#define k8LtstGray4Color 247
#define k8LtstGray5Color 248
#define k8LtGrayColor 249
#define k8Gray2Color 251
#define k8DkGrayColor 252
#define k8DkGray2Color 253
#define kBBQMaskID 3900
#define kUpStairsMaskID 3901
#define kTrunkMaskID 3902
#define kMailboxRightMaskID 3903
#define kMailboxLeftMaskID 3904
#define kDoorInLeftMaskID 3905
#define kDoorInRightMaskID 3906
#define kWindowInLeftMaskID 3907
#define kWindowInRightMaskID 3908
#define kHipLampMaskID 3909
#define kDecoLampMaskID 3910
#define kGuitarMaskID 3911
#define kTVMaskID 3912
#define kVCRMaskID 3913
#define kStereoMaskID 3914
#define kMicrowaveMaskID 3915
#define kFireplaceMaskID 3916
#define kBearMaskID 3917
#define kVase1MaskID 3918
#define kVase2MaskID 3919
#define kManholeMaskID 3920
#define kBooksMaskID 3922
#define kCloudMaskID 3921
#define kRugMaskID 3923
#define kChimesMaskID 3924
#define kCinderMaskID 3925
#define kFlowerBoxMaskID 3926
#define kCobwebMaskID 3927
#define kCobwebPictID 3958
#define kFlowerBoxPictID 3959
#define kCinderPictID 3960
#define kChimesPictID 3961
#define kRugPictID 3962
#define kBooksPictID 3964
#define kCloudPictID 3965
#define kBulletinPictID 3966
#define kManholePictID 3967
#define kVase2PictID 3968
#define kVase1PictID 3969
#define kCalendarPictID 3970
#define kMicrowavePictID 3971
#define kBearPictID 3972
#define kFireplacePictID 3973
#define kOzmaPictID 3975
#define kWindowExRightPictID 3977
#define kWindowExLeftPictID 3978
#define kWindowInRightPictID 3979
#define kWindowInLeftPictID 3980
#define kDoorExLeftPictID 3981
#define kDoorExRightPictID 3982
#define kDoorInRightPictID 3983
#define kDoorInLeftPictID 3984
#define kMailboxRightPictID 3985
#define kMailboxLeftPictID 3986
#define kTrunkPictID 3987
#define kBBQPictID 3988
#define kStereoPictID 3989
#define kVCRPictID 3990
#define kGuitarPictID 3991
#define kTVPictID 3992
#define kDecoLampPictID 3993
#define kHipLampPictID 3994
#define kFilingCabinetPictID 3995
#define kDownStairsPictID 3996
#define kUpStairsPictID 3997
#define kMailboxBase 296
#define kMonthStringID 1005
//============================================================== Functions
//-------------------------------------------------------------- DrawMailboxLeft
void DrawMailboxLeft (Rect *theRect, short down)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
long darkGrayC, lightWoodC, darkWoodC;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
if (thisMac.isDepth == 4)
{
darkGrayC = 13;
lightWoodC = 9;
darkWoodC = 11;
}
else
{
darkGrayC = k8DkGray2Color;
lightWoodC = k8PissYellowColor;
darkWoodC = k8BrownColor;
}
if (theRect->bottom < down + kMailboxBase)
{
ColorLine(theRect->left + 49, theRect->bottom,
theRect->left + 49, down + kMailboxBase, darkGrayC);
ColorLine(theRect->left + 50, theRect->bottom,
theRect->left + 50, down + kMailboxBase + 1, lightWoodC);
ColorLine(theRect->left + 51, theRect->bottom,
theRect->left + 51, down + kMailboxBase + 2, lightWoodC);
ColorLine(theRect->left + 52, theRect->bottom,
theRect->left + 52, down + kMailboxBase + 3, lightWoodC);
ColorLine(theRect->left + 53, theRect->bottom,
theRect->left + 53, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 54, theRect->bottom,
theRect->left + 54, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 55, theRect->bottom,
theRect->left + 55, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 56, theRect->bottom,
theRect->left + 56, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 57, theRect->bottom,
theRect->left + 57, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 58, theRect->bottom,
theRect->left + 58, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 59, theRect->bottom,
theRect->left + 59, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 60, theRect->bottom,
theRect->left + 60, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 61, theRect->bottom,
theRect->left + 61, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 62, theRect->bottom,
theRect->left + 62, down + kMailboxBase + 3, darkGrayC);
}
SetGWorld(wasCPort, wasWorld);
bounds = srcRects[kMailboxLf];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(kMailboxLeftPictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(kMailboxLeftMaskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kMailboxLf], &srcRects[kMailboxLf], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
//-------------------------------------------------------------- DrawMailboxRight
void DrawMailboxRight (Rect *theRect, short down)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
long darkGrayC, lightWoodC, darkWoodC;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
if (thisMac.isDepth == 4)
{
darkGrayC = 13;
lightWoodC = 9;
darkWoodC = 11;
}
else
{
darkGrayC = k8DkGray2Color;
lightWoodC = k8PissYellowColor;
darkWoodC = k8BrownColor;
}
if (theRect->bottom < down + kMailboxBase)
{
ColorLine(theRect->left + 34, theRect->bottom,
theRect->left + 34, down + kMailboxBase, darkGrayC);
ColorLine(theRect->left + 35, theRect->bottom,
theRect->left + 35, down + kMailboxBase + 1, lightWoodC);
ColorLine(theRect->left + 36, theRect->bottom,
theRect->left + 36, down + kMailboxBase + 2, lightWoodC);
ColorLine(theRect->left + 37, theRect->bottom,
theRect->left + 37, down + kMailboxBase + 3, lightWoodC);
ColorLine(theRect->left + 38, theRect->bottom,
theRect->left + 38, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 39, theRect->bottom,
theRect->left + 39, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 40, theRect->bottom,
theRect->left + 40, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 41, theRect->bottom,
theRect->left + 41, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 42, theRect->bottom,
theRect->left + 42, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 43, theRect->bottom,
theRect->left + 43, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 44, theRect->bottom,
theRect->left + 44, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 45, theRect->bottom,
theRect->left + 45, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 46, theRect->bottom,
theRect->left + 46, down + kMailboxBase + 3, darkWoodC);
ColorLine(theRect->left + 47, theRect->bottom,
theRect->left + 47, down + kMailboxBase + 3, darkGrayC);
}
SetGWorld(wasCPort, wasWorld);
bounds = srcRects[kMailboxRt];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(kMailboxRightPictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(kMailboxRightMaskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kMailboxRt], &srcRects[kMailboxRt], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
//-------------------------------------------------------------- DrawSimpleTransport
void DrawSimpleTransport (short what, Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(transSrcMap),
(BitMap *)*GetGWorldPixMap(transMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
}
//-------------------------------------------------------------- DrawInvisTransport
void DrawInvisTransport (Rect *theRect)
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorFrameRect(theRect, 32);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawLightSwitch
void DrawLightSwitch (Rect *theRect, Boolean state)
{
if (state)
{
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&lightSwitchSrc[0], theRect, srcCopy, nil);
}
else
{
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&lightSwitchSrc[1], theRect, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawMachineSwitch
void DrawMachineSwitch (Rect *theRect, Boolean state)
{
if (state)
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&machineSwitchSrc[0], theRect, srcCopy, nil);
else
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&machineSwitchSrc[1], theRect, srcCopy, nil);
}
//-------------------------------------------------------------- DrawThermostat
void DrawThermostat (Rect *theRect, Boolean state)
{
if (state)
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&thermostatSrc[0], theRect, srcCopy, nil);
else
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&thermostatSrc[1], theRect, srcCopy, nil);
}
//-------------------------------------------------------------- DrawPowerSwitch
void DrawPowerSwitch (Rect *theRect, Boolean state)
{
if (state)
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&powerSrc[0], theRect, srcCopy, nil);
else
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&powerSrc[1], theRect, srcCopy, nil);
}
//-------------------------------------------------------------- DrawKnifeSwitch
void DrawKnifeSwitch (Rect *theRect, Boolean state)
{
if (state)
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&knifeSwitchSrc[0], theRect, srcCopy, nil);
else
CopyBits((BitMap *)*GetGWorldPixMap(switchSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&knifeSwitchSrc[1], theRect, srcCopy, nil);
}
//-------------------------------------------------------------- DrawInvisibleSwitch
void DrawInvisibleSwitch (Rect *theRect)
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorFrameRect(theRect, kIntenseGreenColor);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawTrigger
void DrawTrigger (Rect *theRect)
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorFrameRect(theRect, kIntenseBlueColor);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawSoundTrigger
void DrawSoundTrigger (Rect *theRect)
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorFrameRect(theRect, kIntenseYellowColor);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawSimpleLight
void DrawSimpleLight (short what, Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(lightSrcMap),
(BitMap *)*GetGWorldPixMap(lightMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
}
//-------------------------------------------------------------- DrawFlourescent
void DrawFlourescent (Rect *theRect)
{
Rect partRect;
long grayC, gray2C, gray3C, gray4C, violetC;
CGrafPtr wasCPort;
GDHandle wasWorld;
if (thisMac.isDepth == 4)
{
grayC = 7L;
gray2C = 5L;
gray3C = 4L;
gray4C = 1L;
violetC = 3L;
}
else
{
grayC = k8LtGrayColor;
gray2C = k8LtstGray5Color;
gray3C = k8LtstGray4Color;
gray4C = k8LtstGrayColor;
violetC = kPaleVioletColor;
}
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorLine(theRect->left + 16, theRect->top,
theRect->right - 17, theRect->top, grayC);
ColorLine(theRect->left + 16, theRect->top + 1,
theRect->right - 17, theRect->top + 1, gray2C);
ColorLine(theRect->left + 16, theRect->top + 2,
theRect->right - 17, theRect->top + 2, gray2C);
ColorLine(theRect->left + 16, theRect->top + 3,
theRect->right - 17, theRect->top + 3, gray3C);
ColorLine(theRect->left + 16, theRect->top + 4,
theRect->right - 17, theRect->top + 4, gray4C);
ColorLine(theRect->left + 16, theRect->top + 5,
theRect->right - 17, theRect->top + 5, violetC);
ColorLine(theRect->left + 16, theRect->top + 6,
theRect->right - 17, theRect->top + 6, k8WhiteColor);
ColorLine(theRect->left + 16, theRect->top + 7,
theRect->right - 17, theRect->top + 7, k8WhiteColor);
ColorLine(theRect->left + 16, theRect->top + 8,
theRect->right - 17, theRect->top + 8, k8WhiteColor);
ColorLine(theRect->left + 16, theRect->top + 9,
theRect->right - 17, theRect->top + 9, k8WhiteColor);
ColorLine(theRect->left + 16, theRect->top + 10,
theRect->right - 17, theRect->top + 10, k8WhiteColor);
ColorLine(theRect->left + 16, theRect->top + 11,
theRect->right - 17, theRect->top + 11, violetC);
SetGWorld(wasCPort, wasWorld);
partRect = flourescentSrc1;
ZeroRectCorner(&partRect);
QOffsetRect(&partRect, theRect->left, theRect->top);
CopyMask((BitMap *)*GetGWorldPixMap(lightSrcMap),
(BitMap *)*GetGWorldPixMap(lightMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&flourescentSrc1, &flourescentSrc1, &partRect);
partRect = flourescentSrc2;
ZeroRectCorner(&partRect);
QOffsetRect(&partRect, -partRect.right, 0);
QOffsetRect(&partRect, theRect->right, theRect->top);
CopyMask((BitMap *)*GetGWorldPixMap(lightSrcMap),
(BitMap *)*GetGWorldPixMap(lightMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&flourescentSrc2, &flourescentSrc2, &partRect);
}
//-------------------------------------------------------------- DrawTrackLight
void DrawTrackLight (Rect *theRect)
{
#define kTrackLightSpacing 64
Rect partRect;
long grayC, gray2C, gray3C, gray4C;
short which, howMany, i, spread;
CGrafPtr wasCPort;
GDHandle wasWorld;
if (thisMac.isDepth == 4)
{
grayC = 7L;
gray2C = 8L;
gray3C = 4L;
gray4C = 11L;
}
else
{
grayC = k8LtGrayColor;
gray2C = k8Gray2Color;
gray3C = k8LtstGray4Color;
gray4C = k8DkGrayColor;
}
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorLine(theRect->left, theRect->top - 3,
theRect->right - 1, theRect->top - 3, gray2C);
ColorLine(theRect->left, theRect->top - 2,
theRect->right - 1, theRect->top - 2, grayC);
ColorLine(theRect->left, theRect->top - 1,
theRect->right - 1, theRect->top - 1, grayC);
ColorLine(theRect->left, theRect->top,
theRect->right - 1, theRect->top, gray3C);
ColorLine(theRect->left, theRect->top + 1,
theRect->right - 1, theRect->top + 1, gray4C);
ColorLine(theRect->left, theRect->top + 2,
theRect->right - 1, theRect->top + 2, gray3C);
SetGWorld(wasCPort, wasWorld);
partRect = trackLightSrc[0]; // left most track light
ZeroRectCorner(&partRect);
QOffsetRect(&partRect, theRect->left, theRect->top);
which = 0;
CopyMask((BitMap *)*GetGWorldPixMap(lightSrcMap),
(BitMap *)*GetGWorldPixMap(lightMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&trackLightSrc[which], &trackLightSrc[which], &partRect);
partRect = trackLightSrc[0]; // right most track light
ZeroRectCorner(&partRect);
QOffsetRect(&partRect, -partRect.right, 0);
QOffsetRect(&partRect, theRect->right, theRect->top);
which = 2;
CopyMask((BitMap *)*GetGWorldPixMap(lightSrcMap),
(BitMap *)*GetGWorldPixMap(lightMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&trackLightSrc[which], &trackLightSrc[which], &partRect);
howMany = ((RectWide(theRect) - RectWide(&trackLightSrc[0])) /
kTrackLightSpacing) - 1;
if (howMany > 0)
{
which = 0;
spread = (RectWide(theRect) - RectWide(&trackLightSrc[0])) / (howMany + 1);
for (i = 0; i < howMany; i++)
{
partRect = trackLightSrc[0]; // filler track lights
ZeroRectCorner(&partRect);
QOffsetRect(&partRect, theRect->left, theRect->top);
QOffsetRect(&partRect, spread * (i + 1), 0);
which++;
if (which >= kNumTrackLights)
which = 0;
CopyMask((BitMap *)*GetGWorldPixMap(lightSrcMap),
(BitMap *)*GetGWorldPixMap(lightMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&trackLightSrc[which], &trackLightSrc[which], &partRect);
}
}
}
//-------------------------------------------------------------- DrawInvisLight
void DrawInvisLight (Rect *theRect)
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
ColorFrameOval(theRect, 17);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawSimpleAppliance
void DrawSimpleAppliance (short what, Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(applianceMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
}
//-------------------------------------------------------------- DrawMacPlus
void DrawMacPlus (Rect *theRect, Boolean isOn, Boolean isLit)
{
Rect screen;
if (isLit)
{
CopyMask((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(applianceMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kMacPlus], &srcRects[kMacPlus], theRect);
}
screen = plusScreen1;
ZeroRectCorner(&screen);
QOffsetRect(&screen, theRect->left + 10, theRect->top + 7);
if (isOn)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&plusScreen2, &screen, srcCopy, nil);
}
else
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&plusScreen1, &screen, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawTV
void DrawTV (Rect *theRect, Boolean isOn, Boolean isLit)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
if (isLit)
{
GetGWorld(&wasCPort, &wasWorld);
bounds = srcRects[kTV];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(kTVPictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(kTVMaskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kTV], &srcRects[kTV], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
bounds = tvScreen1;
ZeroRectCorner(&bounds);
QOffsetRect(&bounds, theRect->left + 17, theRect->top + 10);
if (isOn)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&tvScreen2, &bounds, srcCopy, nil);
}
else
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&tvScreen1, &bounds, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawCoffee
void DrawCoffee (Rect *theRect, Boolean isOn, Boolean isLit)
{
Rect light;
if (isLit)
{
CopyMask((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(applianceMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kCoffee], &srcRects[kCoffee], theRect);
}
light = coffeeLight1;
ZeroRectCorner(&light);
QOffsetRect(&light, theRect->left + 32, theRect->top + 57);
if (isOn)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&coffeeLight2, &light, srcCopy, nil);
}
else
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&coffeeLight1, &light, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawOutlet
void DrawOutlet (Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(applianceMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kOutlet], &srcRects[kOutlet], theRect);
}
//-------------------------------------------------------------- DrawVCR
void DrawVCR (Rect *theRect, Boolean isOn, Boolean isLit)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
if (isLit)
{
GetGWorld(&wasCPort, &wasWorld);
bounds = srcRects[kVCR];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(kVCRPictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(kVCRMaskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kVCR], &srcRects[kVCR], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
bounds = vcrTime1;
ZeroRectCorner(&bounds);
QOffsetRect(&bounds, theRect->left + 64, theRect->top + 6);
if (isOn)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&vcrTime2, &bounds, srcCopy, nil);
}
else
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&vcrTime1, &bounds, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawStereo
void DrawStereo (Rect *theRect, Boolean isOn, Boolean isLit)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
if (isLit)
{
GetGWorld(&wasCPort, &wasWorld);
bounds = srcRects[kStereo];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(kStereoPictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(kStereoMaskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kStereo], &srcRects[kStereo], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
bounds = stereoLight1;
ZeroRectCorner(&bounds);
QOffsetRect(&bounds, theRect->left + 56, theRect->top + 20);
if (isOn)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&stereoLight2, &bounds, srcCopy, nil);
}
else
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&stereoLight1, &bounds, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawMicrowave
void DrawMicrowave (Rect *theRect, Boolean isOn, Boolean isLit)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
if (isLit)
{
GetGWorld(&wasCPort, &wasWorld);
bounds = srcRects[kMicrowave];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(kMicrowavePictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(kMicrowaveMaskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[kMicrowave], &srcRects[kMicrowave], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
bounds = microOn;
ZeroRectCorner(&bounds);
QOffsetRect(&bounds, theRect->left + 14, theRect->top + 13);
if (isOn)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&microOn, &bounds, srcCopy, nil);
QOffsetRect(&bounds, 16, 0);
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&microOn, &bounds, srcCopy, nil);
QOffsetRect(&bounds, 16, 0);
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&microOn, &bounds, srcCopy, nil);
}
else if (isLit)
{
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&microOff, &bounds, srcCopy, nil);
QOffsetRect(&bounds, 16, 0);
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&microOff, &bounds, srcCopy, nil);
QOffsetRect(&bounds, 16, 0);
CopyBits((BitMap *)*GetGWorldPixMap(applianceSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&microOff, &bounds, srcCopy, nil);
}
}
//-------------------------------------------------------------- DrawBalloon
void DrawBalloon (Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(balloonSrcMap),
(BitMap *)*GetGWorldPixMap(balloonMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&balloonSrc[1], &balloonSrc[1], theRect);
}
//-------------------------------------------------------------- DrawCopter
void DrawCopter (Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(copterSrcMap),
(BitMap *)*GetGWorldPixMap(copterMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&copterSrc[1], &copterSrc[1], theRect);
}
//-------------------------------------------------------------- DrawDart
void DrawDart (Rect *theRect, short which)
{
if (which == kDartLf)
{
CopyMask((BitMap *)*GetGWorldPixMap(dartSrcMap),
(BitMap *)*GetGWorldPixMap(dartMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&dartSrc[0], &dartSrc[0], theRect);
}
else
{
CopyMask((BitMap *)*GetGWorldPixMap(dartSrcMap),
(BitMap *)*GetGWorldPixMap(dartMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&dartSrc[2], &dartSrc[2], theRect);
}
}
//-------------------------------------------------------------- DrawBall
void DrawBall (short what, Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(ballSrcMap),
(BitMap *)*GetGWorldPixMap(ballMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
}
//-------------------------------------------------------------- DrawFish
void DrawFish (short what, Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(enemySrcMap),
(BitMap *)*GetGWorldPixMap(enemyMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
}
//-------------------------------------------------------------- DrawDrip
void DrawDrip (Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(dripSrcMap),
(BitMap *)*GetGWorldPixMap(dripMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&dripSrc[3], &dripSrc[3], theRect);
}
//-------------------------------------------------------------- DrawMirror
void DrawMirror (Rect *mirror)
{
Rect tempRect;
long grayC;
CGrafPtr wasCPort;
GDHandle wasWorld;
if (thisMac.isDepth == 4)
{
grayC = 13;
}
else
{
grayC = k8DkGray2Color;
}
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
tempRect = *mirror;
ColorRect(&tempRect, k8WhiteColor);
ColorFrameRect(&tempRect, grayC);
InsetRect(&tempRect, 1, 1);
ColorFrameRect(&tempRect, k8EarthBlueColor);
InsetRect(&tempRect, 1, 1);
ColorFrameRect(&tempRect, k8EarthBlueColor);
InsetRect(&tempRect, 1, 1);
ColorFrameRect(&tempRect, grayC);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawSimpleClutter
void DrawSimpleClutter (short what, Rect *theRect)
{
CopyMask((BitMap *)*GetGWorldPixMap(clutterSrcMap),
(BitMap *)*GetGWorldPixMap(clutterMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
}
//-------------------------------------------------------------- DrawFlower
void DrawFlower (Rect *theRect, short which)
{
CopyMask((BitMap *)*GetGWorldPixMap(clutterSrcMap),
(BitMap *)*GetGWorldPixMap(clutterMaskMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&flowerSrc[which], &flowerSrc[which], theRect);
}
//-------------------------------------------------------------- DrawWallWindow
void DrawWallWindow (Rect *window)
{
#define kWindowSillThick 7
Rect tempRect, tempRect2;
long brownC, tanC, dkstRedC;
short halfWay;
CGrafPtr wasCPort;
GDHandle wasWorld;
if (thisMac.isDepth == 4)
{
brownC = 11;
tanC = 9;
dkstRedC = 15;
}
else
{
brownC = k8BrownColor;
tanC = k8TanColor;
dkstRedC = k8DkRed2Color;
}
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
tempRect = *window;
InsetRect(&tempRect, 3, 0);
ColorRect(&tempRect, brownC);
HiliteRect(&tempRect, tanC, dkstRedC);
tempRect = *window; // top sill
tempRect.bottom = tempRect.top + kWindowSillThick;
tempRect.left++;
tempRect.right--;
ColorRect(&tempRect, brownC);
HiliteRect(&tempRect, tanC, dkstRedC);
tempRect.left--;
tempRect.right++;
tempRect.top += 2;
tempRect.bottom -= 2;
ColorRect(&tempRect, brownC);
HiliteRect(&tempRect, tanC, dkstRedC);
tempRect = *window; // bottom sill
tempRect.top = tempRect.bottom - kWindowSillThick;
QOffsetRect(&tempRect, 0, -4);
tempRect.left++;
tempRect.right--;
ColorRect(&tempRect, brownC);
HiliteRect(&tempRect, tanC, dkstRedC);
tempRect.left--;
tempRect.right++;
tempRect.top += 2;
tempRect.bottom -= 2;
ColorRect(&tempRect, brownC);
HiliteRect(&tempRect, tanC, dkstRedC);
tempRect = *window; // inside frame
tempRect.left += 8;
tempRect.right -= 8;
tempRect.top += 11;
tempRect.bottom -= 15;
HiliteRect(&tempRect, dkstRedC, tanC);
halfWay = (tempRect.top + tempRect.bottom) / 2;
tempRect2 = tempRect; // top pane
tempRect2.bottom = halfWay + 2;
InsetRect(&tempRect2, 5, 5);
HiliteRect(&tempRect2, dkstRedC, tanC);
InsetRect(&tempRect2, 1, 1);
if (thisMac.isDepth == 4)
ColorRect(&tempRect2, 5);
else
ColorRect(&tempRect2, k8SkyColor);
tempRect2 = tempRect; // bottom pane
tempRect2.top = halfWay - 3;
InsetRect(&tempRect2, 5, 5);
HiliteRect(&tempRect2, dkstRedC, tanC);
InsetRect(&tempRect2, 1, 1);
if (thisMac.isDepth == 4)
ColorRect(&tempRect2, 5);
else
ColorRect(&tempRect2, k8SkyColor);
ColorLine(tempRect2.left - 5, tempRect2.top - 7,
tempRect2.right + 5, tempRect2.top - 7, tanC);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawCalendar
void DrawCalendar (Rect *theRect)
{
DateTimeRec timeRec;
Rect bounds;
PicHandle thePicture;
Str255 monthStr;
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
thePicture = GetPicture(kCalendarPictID);
if (thePicture == nil)
RedAlert(kErrFailedGraphicLoad);
HLock((Handle)thePicture);
bounds = (*thePicture)->picFrame;
HUnlock((Handle)thePicture);
QOffsetRect(&bounds, -bounds.left, -bounds.top);
QOffsetRect(&bounds, theRect->left, theRect->top);
DrawPicture(thePicture, &bounds);
ReleaseResource((Handle)thePicture);
SetPort((GrafPtr)backSrcMap);
TextFace(bold);
TextFont(applFont);
TextSize(9);
GetTime(&timeRec);
GetIndString(monthStr, kMonthStringID, timeRec.month);
MoveTo(theRect->left + ((64 - StringWidth(monthStr)) / 2), theRect->top + 55);
ColorText(monthStr, kDarkFleshColor);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawBulletin
void DrawBulletin (Rect *theRect)
{
Rect bounds;
PicHandle thePicture;
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
thePicture = GetPicture(kBulletinPictID);
if (thePicture == nil)
RedAlert(kErrFailedGraphicLoad);
HLock((Handle)thePicture);
bounds = (*thePicture)->picFrame;
HUnlock((Handle)thePicture);
QOffsetRect(&bounds, -bounds.left, -bounds.top);
QOffsetRect(&bounds, theRect->left, theRect->top);
DrawPicture(thePicture, &bounds);
ReleaseResource((Handle)thePicture);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawPictObject
void DrawPictObject (short what, Rect *theRect)
{
Rect bounds;
PicHandle thePicture;
short pictID;
CGrafPtr wasCPort;
GDHandle wasWorld;
switch (what)
{
case kFilingCabinet:
pictID = kFilingCabinetPictID;
break;
case kDownStairs:
pictID = kDownStairsPictID;
break;
case kDoorExRt:
pictID = kDoorExRightPictID;
break;
case kDoorExLf:
pictID = kDoorExLeftPictID;
break;
case kWindowExRt:
pictID = kWindowExRightPictID;
break;
case kWindowExLf:
pictID = kWindowExLeftPictID;
break;
case kOzma:
pictID = kOzmaPictID;
break;
}
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
thePicture = GetPicture(pictID);
if (thePicture == nil)
RedAlert(kErrFailedGraphicLoad);
bounds = srcRects[what];
QOffsetRect(&bounds, theRect->left, theRect->top);
DrawPicture(thePicture, &bounds);
ReleaseResource((Handle)thePicture);
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- DrawPictWithMaskObject
void DrawPictWithMaskObject (short what, Rect *theRect)
{
Rect bounds;
GWorldPtr tempMap;
GWorldPtr tempMask;
short pictID, maskID;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
GetGWorld(&wasCPort, &wasWorld);
switch (what)
{
case kCobweb:
pictID = kCobwebPictID;
maskID = kCobwebMaskID;
break;
case kCloud:
pictID = kCloudPictID;
maskID = kCloudMaskID;
break;
}
bounds = srcRects[what];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(pictID);
theErr = CreateOffScreenGWorld(&tempMask, &bounds, 1);
SetGWorld(tempMask, nil);
LoadGraphic(maskID);
CopyMask((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(tempMask),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], &srcRects[what], theRect);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
DisposeGWorld(tempMask);
// SetPort((GrafPtr)backSrcMap);
}
//-------------------------------------------------------------- DrawPictSansWhiteObject
void DrawPictSansWhiteObject (short what, Rect *theRect)
{
Rect bounds;
CGrafPtr tempMap;
short pictID;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
GetGWorld(&wasCPort, &wasWorld);
switch (what)
{
case kBBQ:
pictID = kBBQPictID;
break;
case kTrunk:
pictID = kTrunkPictID;
break;
case kManhole:
pictID = kManholePictID;
break;
case kBooks:
pictID = kBooksPictID;
break;
case kUpStairs:
pictID = kUpStairsPictID;
break;
case kDoorInLf:
pictID = kDoorInLeftPictID;
break;
case kDoorInRt:
pictID = kDoorInRightPictID;
break;
case kWindowInLf:
pictID = kWindowInLeftPictID;
break;
case kWindowInRt:
pictID = kWindowInRightPictID;
break;
case kHipLamp:
pictID = kHipLampPictID;
break;
case kDecoLamp:
pictID = kDecoLampPictID;
break;
case kGuitar:
pictID = kGuitarPictID;
break;
case kCinderBlock:
pictID = kCinderPictID;
break;
case kFlowerBox:
pictID = kFlowerBoxPictID;
break;
case kFireplace:
pictID = kFireplacePictID;
break;
case kBear:
pictID = kBearPictID;
break;
case kVase1:
pictID = kVase1PictID;
break;
case kVase2:
pictID = kVase2PictID;
break;
case kRug:
pictID = kRugPictID;
break;
case kChimes:
pictID = kChimesPictID;
break;
}
bounds = srcRects[what];
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(pictID);
CopyBits((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&srcRects[what], theRect, transparent, nil);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
// SetPort((GrafPtr)backSrcMap);
}
//-------------------------------------------------------------- DrawCustPictSansWhite
void DrawCustPictSansWhite (short pictID, Rect *theRect)
{
Rect bounds;
GWorldPtr tempMap;
CGrafPtr wasCPort;
GDHandle wasWorld;
OSErr theErr;
GetGWorld(&wasCPort, &wasWorld);
bounds = *theRect;
ZeroRectCorner(&bounds);
theErr = CreateOffScreenGWorld(&tempMap, &bounds, kPreferredDepth);
SetGWorld(tempMap, nil);
LoadGraphic(pictID);
CopyBits((BitMap *)*GetGWorldPixMap(tempMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&bounds, theRect, transparent, nil);
SetGWorld(wasCPort, wasWorld);
DisposeGWorld(tempMap);
// SetPort((GrafPtr)backSrcMap);
}