GliderPRO/Sources/RoomGraphics.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
12 KiB
C
Executable File

//============================================================================
//----------------------------------------------------------------------------
// RoomGraphics.c
//----------------------------------------------------------------------------
//============================================================================
#include <Resources.h>
#include "Externs.h"
#include "Environ.h"
#include "MainWindow.h"
#include "RectUtils.h"
#include "Room.h"
#define kManholeThruFloor 3957
void LoadGraphicSpecial (short);
void DrawRoomBackground (short, short, short);
void DrawFloorSupport (void);
void ReadyBackMap (void);
void RestoreWorkMap (void);
void DrawLighting (void);
Rect suppSrcRect;
GWorldPtr suppSrcMap;
Rect localRoomsDest[9];
Rect houseRect;
short numNeighbors, numLights, thisTiles[kNumTiles];
short localNumbers[9], thisBackground;
Boolean isStructure[9], wardBitSet;
extern CGrafPtr savedMaps[];
extern Rect tempManholes[];
extern short numTempManholes, tvWithMovieNumber;
extern Boolean shadowVisible, takingTheStairs;
//============================================================== Functions
//-------------------------------------------------------------- DrawLocale
void DrawLocale (void)
{
short i, roomV;
char wasState;
CGrafPtr wasCPort;
GDHandle wasWorld;
ZeroFlamesAndTheLike();
ZeroDinahs();
KillAllBands();
ZeroMirrorRegion();
ZeroTriggers();
numTempManholes = 0;
FlushAnyTriggerPlaying();
DumpTriggerSound();
tvInRoom = false;
tvWithMovieNumber = -1;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
roomV = (*thisHouse)->rooms[thisRoomNumber].floor;
HSetState((Handle)thisHouse, wasState);
for (i = 0; i < 9; i++)
{
localNumbers[i] = GetNeighborRoomNumber(i);
isStructure[i] = IsRoomAStructure(localNumbers[i]);
}
ListAllLocalObjects();
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
PaintRect(&backSrcRect);
if (numNeighbors > 3)
{
numLights = GetNumberOfLights(localNumbers[kNorthWestRoom]);
DrawRoomBackground(localNumbers[kNorthWestRoom], kNorthWestRoom, roomV + 1);
DrawARoomsObjects(kNorthWestRoom, false);
numLights = GetNumberOfLights(localNumbers[kNorthEastRoom]);
DrawRoomBackground(localNumbers[kNorthEastRoom], kNorthEastRoom, roomV + 1);
DrawARoomsObjects(kNorthEastRoom, false);
numLights = GetNumberOfLights(localNumbers[kNorthRoom]);
DrawRoomBackground(localNumbers[kNorthRoom], kNorthRoom, roomV + 1);
DrawARoomsObjects(kNorthRoom, false);
numLights = GetNumberOfLights(localNumbers[kSouthWestRoom]);
DrawRoomBackground(localNumbers[kSouthWestRoom], kSouthWestRoom, roomV - 1);
DrawARoomsObjects(kSouthWestRoom, false);
numLights = GetNumberOfLights(localNumbers[kSouthEastRoom]);
DrawRoomBackground(localNumbers[kSouthEastRoom], kSouthEastRoom, roomV - 1);
DrawARoomsObjects(kSouthEastRoom, false);
numLights = GetNumberOfLights(localNumbers[kSouthRoom]);
DrawRoomBackground(localNumbers[kSouthRoom], kSouthRoom, roomV - 1);
DrawARoomsObjects(kSouthRoom, false);
}
if (numNeighbors > 1)
{
numLights = GetNumberOfLights(localNumbers[kWestRoom]);
DrawRoomBackground(localNumbers[kWestRoom], kWestRoom, roomV);
DrawARoomsObjects(kWestRoom, false);
DrawLighting();
numLights = GetNumberOfLights(localNumbers[kEastRoom]);
DrawRoomBackground(localNumbers[kEastRoom], kEastRoom, roomV);
DrawARoomsObjects(kEastRoom, false);
DrawLighting();
}
numLights = GetNumberOfLights(localNumbers[kCentralRoom]);
DrawRoomBackground(localNumbers[kCentralRoom], kCentralRoom, roomV);
DrawARoomsObjects(kCentralRoom, false);
DrawLighting();
if (numNeighbors > 3)
DrawFloorSupport();
RestoreWorkMap();
shadowVisible = IsShadowVisible();
takingTheStairs = false;
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- LoadGraphicSpecial
void LoadGraphicSpecial (short resID)
{
Rect bounds;
PicHandle thePicture;
thePicture = GetPicture(resID);
if (thePicture == nil)
{
thePicture = (PicHandle)GetResource('Date', resID);
if (thePicture == nil)
{
thePicture = GetPicture(2000);
if (thePicture == nil)
RedAlert(kErrFailedGraphicLoad);
}
}
HLock((Handle)thePicture);
bounds = (*thePicture)->picFrame;
HUnlock((Handle)thePicture);
OffsetRect(&bounds, -bounds.left, -bounds.top);
DrawPicture(thePicture, &bounds);
ReleaseResource((Handle)thePicture);
}
//-------------------------------------------------------------- DrawRoomBackground
void DrawRoomBackground (short who, short where, short elevation)
{
Rect src, dest;
short i, pictID;
short tiles[kNumTiles];
char wasState;
if (where == kCentralRoom)
{
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
thisBackground = (*thisHouse)->rooms[who].background;
for (i = 0; i < kNumTiles; i++)
thisTiles[i] = (*thisHouse)->rooms[who].tiles[i];
HSetState((Handle)thisHouse, wasState);
}
if ((numLights == 0) && (who != kRoomIsEmpty))
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
PaintRect(&localRoomsDest[where]);
SetGWorld(wasCPort, wasWorld);
return;
}
if (who == kRoomIsEmpty) // This call should be smarter than this
{
if (wardBitSet)
{
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
PaintRect(&localRoomsDest[where]);
SetGWorld(wasCPort, wasWorld);
return;
}
if (elevation > 1)
{
pictID = kSky;
for (i = 0; i < kNumTiles; i++)
tiles[i] = 2;
}
else if (elevation == 1)
{
pictID = kMeadow;
for (i = 0; i < kNumTiles; i++)
tiles[i] = 0;
}
else
{
pictID = kDirt;
for (i = 0; i < kNumTiles; i++)
tiles[i] = 0;
}
}
else
{
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
pictID = (*thisHouse)->rooms[who].background;
for (i = 0; i < kNumTiles; i++)
tiles[i] = (*thisHouse)->rooms[who].tiles[i];
HSetState((Handle)thisHouse, wasState);
}
SetPort((GrafPtr)workSrcMap);
LoadGraphicSpecial(pictID);
QSetRect(&src, 0, 0, kTileWide, kTileHigh);
QSetRect(&dest, 0, 0, kTileWide, kTileHigh);
QOffsetRect(&dest, localRoomsDest[where].left, localRoomsDest[where].top);
for (i = 0; i < kNumTiles; i++)
{
src.left = tiles[i] * kTileWide;
src.right = src.left + kTileWide;
CopyBits((BitMap *)*GetGWorldPixMap(workSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
QOffsetRect(&dest, kTileWide, 0);
}
}
//-------------------------------------------------------------- DrawFloorSupport
void DrawFloorSupport (void)
{
Rect src, dest, whoCares;
short i;
CGrafPtr wasCPort;
GDHandle wasWorld;
GetGWorld(&wasCPort, &wasWorld);
SetGWorld(backSrcMap, nil);
src = suppSrcRect;
if (isStructure[kNorthWestRoom])
{
dest = suppSrcRect; // left room's ceiling
QOffsetRect(&dest, localRoomsDest[kWestRoom].left,
localRoomsDest[kCentralRoom].top - suppSrcRect.bottom);
CopyBits((BitMap *)*GetGWorldPixMap(suppSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
for (i = 0; i < numTempManholes; i++)
if (SectRect(&dest, &tempManholes[i], &whoCares))
{
tempManholes[i].top = dest.top;
tempManholes[i].bottom = dest.bottom;
LoadScaledGraphic(kManholeThruFloor, &tempManholes[i]);
}
}
if (isStructure[kWestRoom])
{
dest = suppSrcRect; // left room's floor
QOffsetRect(&dest, localRoomsDest[kWestRoom].left,
localRoomsDest[kCentralRoom].bottom);
CopyBits((BitMap *)*GetGWorldPixMap(suppSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
for (i = 0; i < numTempManholes; i++)
if (SectRect(&dest, &tempManholes[i], &whoCares))
{
tempManholes[i].top = dest.top;
tempManholes[i].bottom = dest.bottom;
LoadScaledGraphic(kManholeThruFloor, &tempManholes[i]);
}
}
if (isStructure[kNorthRoom])
{
dest = suppSrcRect; // directly above main room
QOffsetRect(&dest, localRoomsDest[kCentralRoom].left,
localRoomsDest[kCentralRoom].top - suppSrcRect.bottom);
CopyBits((BitMap *)*GetGWorldPixMap(suppSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
for (i = 0; i < numTempManholes; i++)
if (SectRect(&dest, &tempManholes[i], &whoCares))
{
tempManholes[i].top = dest.top;
tempManholes[i].bottom = dest.bottom;
LoadScaledGraphic(kManholeThruFloor, &tempManholes[i]);
}
}
if (isStructure[kCentralRoom])
{
dest = suppSrcRect; // directly below main room
QOffsetRect(&dest, localRoomsDest[kCentralRoom].left,
localRoomsDest[kCentralRoom].bottom);
CopyBits((BitMap *)*GetGWorldPixMap(suppSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
for (i = 0; i < numTempManholes; i++)
if (SectRect(&dest, &tempManholes[i], &whoCares))
{
tempManholes[i].top = dest.top;
tempManholes[i].bottom = dest.bottom;
LoadScaledGraphic(kManholeThruFloor, &tempManholes[i]);
}
}
if (isStructure[kNorthEastRoom])
{
dest = suppSrcRect;
QOffsetRect(&dest, localRoomsDest[kEastRoom].left,
localRoomsDest[kCentralRoom].top - suppSrcRect.bottom);
CopyBits((BitMap *)*GetGWorldPixMap(suppSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
for (i = 0; i < numTempManholes; i++)
if (SectRect(&dest, &tempManholes[i], &whoCares))
{
tempManholes[i].top = dest.top;
tempManholes[i].bottom = dest.bottom;
LoadScaledGraphic(kManholeThruFloor, &tempManholes[i]);
}
}
if (isStructure[kEastRoom])
{
dest = suppSrcRect;
QOffsetRect(&dest, localRoomsDest[kEastRoom].left,
localRoomsDest[kCentralRoom].bottom);
CopyBits((BitMap *)*GetGWorldPixMap(suppSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&src, &dest, srcCopy, nil);
for (i = 0; i < numTempManholes; i++)
if (SectRect(&dest, &tempManholes[i], &whoCares))
{
tempManholes[i].top = dest.top;
tempManholes[i].bottom = dest.bottom;
LoadScaledGraphic(kManholeThruFloor, &tempManholes[i]);
}
}
SetGWorld(wasCPort, wasWorld);
}
//-------------------------------------------------------------- ReadyBackMap
void ReadyBackMap (void)
{
CopyBits((BitMap *)*GetGWorldPixMap(workSrcMap),
(BitMap *)*GetGWorldPixMap(backSrcMap),
&workSrcRect, &workSrcRect, srcCopy, nil);
}
//-------------------------------------------------------------- RestoreWorkMap
void RestoreWorkMap (void)
{
Rect dest;
dest = backSrcRect;
CopyBits((BitMap *)*GetGWorldPixMap(backSrcMap),
(BitMap *)*GetGWorldPixMap(workSrcMap),
&backSrcRect, &backSrcRect, srcCopy, nil);
}
//-------------------------------------------------------------- ReadyLevel
void ReadyLevel (void)
{
NilSavedMaps();
#ifdef COMPILEQT
if ((thisMac.hasQT) && (hasMovie) && (tvInRoom))
{
tvInRoom = false;
tvWithMovieNumber = -1;
StopMovie(theMovie);
}
#endif
DetermineRoomOpenings();
DrawLocale();
InitGarbageRects();
}
//-------------------------------------------------------------- DrawLighting
void DrawLighting (void)
{
if (numLights == 0)
return;
else
{
// for future construction
}
}
//-------------------------------------------------------------- RedrawRoomLighting
void RedrawRoomLighting (void)
{
short roomV;
char wasState;
Boolean wasLit, isLit;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
roomV = (*thisHouse)->rooms[thisRoomNumber].floor;
HSetState((Handle)thisHouse, wasState);
wasLit = numLights > 0;
numLights = GetNumberOfLights(localNumbers[kCentralRoom]);
isLit = numLights > 0;
if (wasLit != isLit)
{
DrawRoomBackground(localNumbers[kCentralRoom], kCentralRoom, roomV);
DrawARoomsObjects(kCentralRoom, true);
DrawLighting();
UpdateOutletsLighting(localNumbers[kCentralRoom], numLights);
if (numNeighbors > 3)
DrawFloorSupport();
RestoreWorkMap();
AddRectToWorkRects(&localRoomsDest[kCentralRoom]);
shadowVisible = IsShadowVisible();
}
}