1 line
12 KiB
C
Executable File
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();
|
|
}
|
|
}
|
|
|