GliderPRO/Sources/House.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
20 KiB
C
Executable File
Raw Blame History

//============================================================================
//----------------------------------------------------------------------------
// House.c
//----------------------------------------------------------------------------
//============================================================================
#include <Navigation.h>
#include <NumberFormatting.h>
#include <Resources.h>
#include <Sound.h>
#include "DialogUtils.h"
#include "Externs.h"
#include "House.h"
#include "RectUtils.h"
#define kGoToDialogID 1043
void UpdateGoToDialog (DialogPtr);
pascal Boolean GoToFilter (DialogPtr, EventRecord *, short *);
houseHand thisHouse;
linksPtr linksList;
Str32 thisHouseName;
short srcLocations[kMaxRoomObs];
short destLocations[kMaxRoomObs];
short wasFloor, wasSuite;
retroLink retroLinkList[kMaxRoomObs];
Boolean houseUnlocked;
extern gameType smallGame;
extern short numberRooms, mapLeftRoom, mapTopRoom, numStarsRemaining;
extern Boolean houseOpen, noRoomAtAll;
extern Boolean twoPlayerGame, wardBitSet, phoneBitSet;
//============================================================== Functions
//-------------------------------------------------------------- CreateNewHouse
// Called to create a new house file.
#ifndef COMPILEDEMO
Boolean CreateNewHouse (void)
{
AEKeyword theKeyword;
DescType actualType;
Size actualSize;
NavReplyRecord theReply;
NavDialogOptions dialogOptions;
FSSpec tempSpec;
FSSpec theSpec;
OSErr theErr;
theErr = NavGetDefaultDialogOptions(&dialogOptions);
theErr = NavPutFile(nil, &theReply, &dialogOptions, nil, 'gliH', 'ozm5', nil);
if (theErr == userCanceledErr)
return false;
if (!theReply.validRecord)
return (false);
theErr = AEGetNthPtr(&(theReply.selection), 1, typeFSS, &theKeyword,
&actualType, &theSpec, sizeof(FSSpec), &actualSize);
if (theReply.replacing)
{
theErr = FSMakeFSSpec(theSpec.vRefNum, theSpec.parID,
theSpec.name, &tempSpec);
if (!CheckFileError(theErr, theSpec.name))
return (false);
theErr = FSpDelete(&tempSpec);
if (!CheckFileError(theErr, theSpec.name))
return (false);
}
if (houseOpen)
{
if (!CloseHouse())
return (false);
}
theErr = FSpCreate(&theSpec, 'ozm5', 'gliH', theReply.keyScript);
if (!CheckFileError(theErr, "\pNew House"))
return (false);
HCreateResFile(theSpec.vRefNum, theSpec.parID, theSpec.name);
if (ResError() != noErr)
YellowAlert(kYellowFailedResCreate, ResError());
PasStringCopy(theSpec.name, thisHouseName);
AddExtraHouse(&theSpec);
BuildHouseList();
InitCursor();
if (!OpenHouse())
return (false);
return (true);
}
#endif
//-------------------------------------------------------------- InitializeEmptyHouse
// Initializes all the structures for an empty (new) house.
#ifndef COMPILEDEMO
Boolean InitializeEmptyHouse (void)
{
houseType *thisHousePtr;
Str255 tempStr;
if (thisHouse != nil)
DisposeHandle((Handle)thisHouse);
thisHouse = (houseHand)NewHandle(sizeof(houseType));
if (thisHouse == nil)
{
YellowAlert(kYellowUnaccounted, 1);
return (false);
}
HLock((Handle)thisHouse);
thisHousePtr = *thisHouse;
thisHousePtr->version = kHouseVersion;
thisHousePtr->firstRoom = -1;
thisHousePtr->timeStamp = 0L;
thisHousePtr->flags = 0L;
thisHousePtr->initial.h = 32;
thisHousePtr->initial.v = 32;
ZeroHighScores();
GetLocalizedString(11, tempStr);
PasStringCopy(tempStr, thisHousePtr->banner);
GetLocalizedString(12, tempStr);
PasStringCopy(tempStr, thisHousePtr->trailer);
thisHousePtr->hasGame = false;
thisHousePtr->nRooms = 0;
wardBitSet = false;
phoneBitSet = false;
HUnlock((Handle)thisHouse);
numberRooms = 0;
mapLeftRoom = 60;
mapTopRoom = 50;
thisRoomNumber = kRoomIsEmpty;
previousRoom = -1;
houseUnlocked = true;
OpenMapWindow();
UpdateMapWindow();
noRoomAtAll = true;
fileDirty = true;
UpdateMenus(false);
ReflectCurrentRoom(true);
return (true);
}
#endif
//-------------------------------------------------------------- RealRoomNumberCount
// Returns the real number of rooms in a house (some rooms may still<6C>
// be place-holders - they were deleted earlier and are flagged as<61>
// deleted but still occupy space in the file).
short RealRoomNumberCount (void)
{
short realRoomCount, i;
char wasState;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
realRoomCount = (*thisHouse)->nRooms;
if (realRoomCount != 0)
{
for (i = 0; i < (*thisHouse)->nRooms; i++)
{
if ((*thisHouse)->rooms[i].suite == kRoomIsEmpty)
realRoomCount--;
}
}
HSetState((Handle)thisHouse, wasState);
return (realRoomCount);
}
//-------------------------------------------------------------- GetFirstRoomNumber
// Returns the room number (indicee into house file) of the room where<72>
// the player is to begin.
short GetFirstRoomNumber (void)
{
short firstRoom;
char wasState;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
if ((*thisHouse)->nRooms <= 0)
{
firstRoom = -1;
noRoomAtAll = true;
}
else
{
firstRoom = (*thisHouse)->firstRoom;
if ((firstRoom >= (*thisHouse)->nRooms) || (firstRoom < 0))
firstRoom = 0;
}
HSetState((Handle)thisHouse, wasState);
return (firstRoom);
}
//-------------------------------------------------------------- WhereDoesGliderBegin
// Returns a rectangle indicating where in the first room the player's<>
// glider is to appear.
void WhereDoesGliderBegin (Rect *theRect, short mode)
{
Point initialPt;
char wasState;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
if (mode == kResumeGameMode)
initialPt = smallGame.where;
else if (mode == kNewGameMode)
initialPt = (*thisHouse)->initial;
HSetState((Handle)thisHouse, wasState);
QSetRect(theRect, 0, 0, kGliderWide, kGliderHigh);
QOffsetRect(theRect, initialPt.h, initialPt.v);
}
//-------------------------------------------------------------- HouseHasOriginalPicts
// Returns true is the current house has custom artwork imbedded.
Boolean HouseHasOriginalPicts (void)
{
short nPicts;
nPicts = Count1Resources('PICT');
return (nPicts > 0);
}
//-------------------------------------------------------------- CountHouseLinks
// Counts up the number of linked objects in a house.
short CountHouseLinks (void)
{
houseType *thisHousePtr;
short numRooms, numLinks;
short r, i, what;
char wasState;
numLinks = 0;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
thisHousePtr = *thisHouse;
numRooms = thisHousePtr->nRooms;
for (r = 0; r < numRooms; r++)
{
for (i = 0; i < kMaxRoomObs; i++)
{
what = thisHousePtr->rooms[r].objects[i].what;
switch (what)
{
case kLightSwitch:
case kMachineSwitch:
case kThermostat:
case kPowerSwitch:
case kKnifeSwitch:
case kInvisSwitch:
case kTrigger:
case kLgTrigger:
if (thisHousePtr->rooms[r].objects[i].data.e.where != -1)
numLinks++;
break;
case kMailboxLf:
case kMailboxRt:
case kFloorTrans:
case kCeilingTrans:
case kInvisTrans:
case kDeluxeTrans:
if (thisHousePtr->rooms[r].objects[i].data.d.where != -1)
numLinks++;
break;
}
}
}
HSetState((Handle)thisHouse, wasState);
return (numLinks);
}
//-------------------------------------------------------------- GenerateLinksList
// Generates a list of all objects that have links and what rooms<6D>
// and objects they are linked to. It is called in order to preserve<76>
// the links if the objects or rooms in a house are to be shuffled<65>
// around.
#ifndef COMPILEDEMO
void GenerateLinksList (void)
{
houseType *thisHousePtr;
objectType thisObject;
short numLinks, numRooms, r, i, what;
short floor, suite, roomLinked, objectLinked;
char wasState;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
thisHousePtr = *thisHouse;
numRooms = thisHousePtr->nRooms;
numLinks = 0;
for (r = 0; r < numRooms; r++)
{
for (i = 0; i < kMaxRoomObs; i++)
{
what = thisHousePtr->rooms[r].objects[i].what;
switch (what)
{
case kLightSwitch:
case kMachineSwitch:
case kThermostat:
case kPowerSwitch:
case kKnifeSwitch:
case kInvisSwitch:
case kTrigger:
case kLgTrigger:
thisObject = thisHousePtr->rooms[r].objects[i];
if (thisObject.data.e.where != -1)
{
ExtractFloorSuite(thisObject.data.e.where, &floor, &suite);
roomLinked = GetRoomNumber(floor, suite);
objectLinked = (short)thisObject.data.e.who;
linksList[numLinks].srcRoom = r;
linksList[numLinks].srcObj = i;
linksList[numLinks].destRoom = roomLinked;
linksList[numLinks].destObj = objectLinked;
numLinks++;
}
break;
case kMailboxLf:
case kMailboxRt:
case kFloorTrans:
case kCeilingTrans:
case kInvisTrans:
case kDeluxeTrans:
thisObject = thisHousePtr->rooms[r].objects[i];
if (thisObject.data.d.where != -1)
{
ExtractFloorSuite(thisObject.data.d.where, &floor, &suite);
roomLinked = GetRoomNumber(floor, suite);
objectLinked = (short)thisObject.data.d.who;
linksList[numLinks].srcRoom = r;
linksList[numLinks].srcObj = i;
linksList[numLinks].destRoom = roomLinked;
linksList[numLinks].destObj = objectLinked;
numLinks++;
}
break;
}
}
}
HSetState((Handle)thisHouse, wasState);
}
#endif
//-------------------------------------------------------------- SortRoomObjects
// I'm a little fuzzy on what this does.
#ifndef COMPILEDEMO
void SortRoomsObjects (short which)
{
short probe, probe2, room, obj;
Boolean busy, looking;
busy = true;
probe = 0;
do
{
if ((*thisHouse)->rooms[which].objects[probe].what == kObjectIsEmpty)
{
looking = true;
probe2 = probe + 1; // begin by looking at the next object
do
{
if ((*thisHouse)->rooms[which].objects[probe2].what != kObjectIsEmpty)
{
(*thisHouse)->rooms[which].objects[probe] =
(*thisHouse)->rooms[which].objects[probe2];
(*thisHouse)->rooms[which].objects[probe2].what = kObjectIsEmpty;
if (srcLocations[probe2] != -1)
linksList[srcLocations[probe2]].srcObj = probe;
if (destLocations[probe2] != -1)
{
linksList[destLocations[probe2]].destObj = probe;
room = linksList[destLocations[probe2]].srcRoom;
obj = linksList[destLocations[probe2]].srcObj;
(*thisHouse)->rooms[room].objects[obj].data.e.who = probe;
}
fileDirty = true;
looking = false;
}
probe2++;
if ((probe2 >= kMaxRoomObs) && (looking))
{
looking = false;
busy = false;
}
}
while (looking);
}
probe++;
if (probe >= (kMaxRoomObs - 1))
busy = false;
}
while (busy);
}
#endif
//-------------------------------------------------------------- SortHouseObjects
// I'm a little fuzzy on what this does exactly either.
#ifndef COMPILEDEMO
void SortHouseObjects (void)
{
houseType *thisHousePtr;
short numLinks, numRooms, r, i, l;
char wasState;
SpinCursor(3);
CopyThisRoomToRoom();
numLinks = CountHouseLinks();
if (numLinks == 0)
return;
linksList = nil;
linksList = (linksPtr)NewPtr(sizeof(linksType) * numLinks);
if (linksList == nil)
RedAlert(kErrNoMemory);
GenerateLinksList();
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
thisHousePtr = *thisHouse;
numRooms = thisHousePtr->nRooms;
for (r = 0; r < numRooms; r++)
{
for (i = 0; i < kMaxRoomObs; i++) // initialize arrays
{
srcLocations[i] = -1;
destLocations[i] = -1;
}
for (i = 0; i < kMaxRoomObs; i++) // walk object list
{
for (l = 0; l < numLinks; l++) // walk link list
{
if ((linksList[l].srcRoom == r) && (linksList[l].srcObj == i))
srcLocations[i] = l;
if ((linksList[l].destRoom == r) && (linksList[l].destObj == i))
destLocations[i] = l;
}
}
SortRoomsObjects(r);
if ((r & 0x0007) == 0x0007)
IncrementCursor();
}
SpinCursor(3);
HSetState((Handle)thisHouse, wasState);
if (linksList != nil)
DisposePtr((Ptr)linksList);
ForceThisRoom(thisRoomNumber);
}
#endif
//-------------------------------------------------------------- CountRoomsVisited
// Goes through and counts the number of rooms a player has been to in<69>
// the current game.
short CountRoomsVisited (void)
{
houseType *thisHousePtr;
short numRooms, r, count;
char wasState;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
thisHousePtr = *thisHouse;
numRooms = thisHousePtr->nRooms;
count = 0;
for (r = 0; r < numRooms; r++)
{
if (thisHousePtr->rooms[r].visited)
count++;
}
HSetState((Handle)thisHouse, wasState);
return (count);
}
//-------------------------------------------------------------- GenerateRetroLinks
// Walk entire house looking for objects which are linked to objects<74>
// in the current room.
void GenerateRetroLinks (void)
{
houseType *thisHousePtr;
objectType thisObject;
short i, r, numRooms, floor, suite;
short what, roomLinked, objectLinked;
char wasState;
for (i = 0; i < kMaxRoomObs; i++) // Initialize array.
retroLinkList[i].room = -1;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
thisHousePtr = *thisHouse;
numRooms = thisHousePtr->nRooms;
for (r = 0; r < numRooms; r++)
{
for (i = 0; i < kMaxRoomObs; i++)
{
what = thisHousePtr->rooms[r].objects[i].what;
switch (what)
{
case kLightSwitch:
case kMachineSwitch:
case kThermostat:
case kPowerSwitch:
case kKnifeSwitch:
case kInvisSwitch:
case kTrigger:
case kLgTrigger:
thisObject = thisHousePtr->rooms[r].objects[i];
if (thisObject.data.e.where != -1)
{
ExtractFloorSuite(thisObject.data.e.where, &floor, &suite);
roomLinked = GetRoomNumber(floor, suite);
if (roomLinked == thisRoomNumber)
{
objectLinked = (short)thisObject.data.e.who;
if (retroLinkList[objectLinked].room == -1)
{
retroLinkList[objectLinked].room = r;
retroLinkList[objectLinked].object = i;
}
}
}
break;
case kMailboxLf:
case kMailboxRt:
case kFloorTrans:
case kCeilingTrans:
case kInvisTrans:
case kDeluxeTrans:
thisObject = thisHousePtr->rooms[r].objects[i];
if (thisObject.data.d.where != -1)
{
ExtractFloorSuite(thisObject.data.d.where, &floor, &suite);
roomLinked = GetRoomNumber(floor, suite);
if (roomLinked == thisRoomNumber)
{
objectLinked = (short)thisObject.data.d.who;
if (retroLinkList[objectLinked].room == -1)
{
retroLinkList[objectLinked].room = r;
retroLinkList[objectLinked].object = i;
}
}
}
break;
}
}
}
HSetState((Handle)thisHouse, wasState);
}
//-------------------------------------------------------------- UpdateGoToDialog
// Redraws the "Go To Room..." dialog.
void UpdateGoToDialog (DialogPtr theDialog)
{
DrawDialog(theDialog);
DrawDefaultButton(theDialog);
FrameDialogItemC(theDialog, 10, kRedOrangeColor8);
}
//-------------------------------------------------------------- GoToFilter
// Dialog filter for the "Go To Room..." dialog.
pascal Boolean GoToFilter (DialogPtr dial, EventRecord *event, short *item)
{
switch (event->what)
{
case keyDown:
switch ((event->message) & charCodeMask)
{
case kReturnKeyASCII:
case kEnterKeyASCII:
FlashDialogButton(dial, kOkayButton);
*item = kOkayButton;
return(true);
break;
default:
return(false);
}
break;
case updateEvt:
SetPort((GrafPtr)dial);
BeginUpdate(GetDialogWindow(dial));
UpdateGoToDialog(dial);
EndUpdate(GetDialogWindow(dial));
event->what = nullEvent;
return(false);
break;
default:
return(false);
break;
}
}
//-------------------------------------------------------------- DoGoToDialog
// "Go To Room..." dialog.
void DoGoToDialog (void)
{
#define kGoToFirstButt 2
#define kGoToPrevButt 3
#define kGoToFSButt 4
#define kFloorEditText 5
#define kSuiteEditText 6
DialogPtr theDialog;
long tempLong;
short item, roomToGoTo;
Boolean leaving, canceled;
ModalFilterUPP goToFilterUPP;
goToFilterUPP = NewModalFilterUPP(GoToFilter);
BringUpDialog(&theDialog, kGoToDialogID);
if (GetFirstRoomNumber() == thisRoomNumber)
MyDisableControl(theDialog, kGoToFirstButt);
if ((!RoomNumExists(previousRoom)) || (previousRoom == thisRoomNumber))
MyDisableControl(theDialog, kGoToPrevButt);
SetDialogNumToStr(theDialog, kFloorEditText, (long)wasFloor);
SetDialogNumToStr(theDialog, kSuiteEditText, (long)wasSuite);
SelectDialogItemText(theDialog, kFloorEditText, 0, 1024);
leaving = false;
canceled = false;
while (!leaving)
{
ModalDialog(goToFilterUPP, &item);
if (item == kOkayButton)
{
roomToGoTo = -1;
canceled = true;
leaving = true;
}
else if (item == kGoToFirstButt)
{
roomToGoTo = GetFirstRoomNumber();
leaving = true;
}
else if (item == kGoToPrevButt)
{
roomToGoTo = previousRoom;
leaving = true;
}
else if (item == kGoToFSButt)
{
GetDialogNumFromStr(theDialog, kFloorEditText, &tempLong);
wasFloor = (short)tempLong;
GetDialogNumFromStr(theDialog, kSuiteEditText, &tempLong);
wasSuite = (short)tempLong;
roomToGoTo = GetRoomNumber(wasFloor, wasSuite);
leaving = true;
}
}
DisposeDialog(theDialog);
DisposeModalFilterUPP(goToFilterUPP);
if (!canceled)
{
if (RoomNumExists(roomToGoTo))
{
DeselectObject();
CopyRoomToThisRoom(roomToGoTo);
ReflectCurrentRoom(false);
}
else
SysBeep(1);
}
}
//-------------------------------------------------------------- ConvertHouseVer1To2
// This function goes through an old version 1 house and converts it<69>
// to version 2.
void ConvertHouseVer1To2 (void)
{
Str255 roomStr, message;
short wasRoom, floor, suite;
short i, h, numRooms;
char wasState;
CopyThisRoomToRoom();
wasRoom = thisRoomNumber;
GetLocalizedString(13, message);
OpenMessageWindow(message);
SpinCursor(3);
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
numRooms = (*thisHouse)->nRooms;
for (i = 0; i < numRooms; i++)
{
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
{
NumToString((long)i, roomStr);
GetLocalizedString(14, message);
PasStringConcat(message, roomStr);
SetMessageWindowMessage(message);
SpinCursor(1);
ForceThisRoom(i);
for (h = 0; h < kMaxRoomObs; h++)
{
switch (thisRoom->objects[h].what)
{
case kMailboxLf:
case kMailboxRt:
case kFloorTrans:
case kCeilingTrans:
case kInvisTrans:
case kDeluxeTrans:
if (thisRoom->objects[h].data.d.where != -1)
{
ExtractFloorSuite(thisRoom->objects[h].data.d.where, &floor, &suite);
floor += kNumUndergroundFloors;
thisRoom->objects[h].data.d.where = MergeFloorSuite(floor, suite);
}
break;
case kLightSwitch:
case kMachineSwitch:
case kThermostat:
case kPowerSwitch:
case kKnifeSwitch:
case kInvisSwitch:
case kTrigger:
case kLgTrigger:
if (thisRoom->objects[h].data.e.where != -1)
{
ExtractFloorSuite(thisRoom->objects[h].data.e.where, &floor, &suite);
floor += kNumUndergroundFloors;
thisRoom->objects[h].data.e.where = MergeFloorSuite(floor, suite);
}
break;
}
}
CopyThisRoomToRoom();
}
}
(*thisHouse)->version = kHouseVersion;
HSetState((Handle)thisHouse, wasState);
InitCursor();
CloseMessageWindow();
ForceThisRoom(wasRoom);
}
//-------------------------------------------------------------- ShiftWholeHouse
void ShiftWholeHouse (short howFar)
{
#pragma unused (howFar)
short wasRoom;
short i, h, numRooms;
char wasState;
OpenMessageWindow("\pShifting Whole House<73>");
SpinCursor(3);
CopyThisRoomToRoom();
wasRoom = thisRoomNumber;
wasState = HGetState((Handle)thisHouse);
HLock((Handle)thisHouse);
numRooms = (*thisHouse)->nRooms;
for (i = 0; i < numRooms; i++)
{
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
{
SpinCursor(1);
ForceThisRoom(i);
for (h = 0; h < kMaxRoomObs; h++)
{
}
CopyThisRoomToRoom();
}
}
HSetState((Handle)thisHouse, wasState);
ForceThisRoom(wasRoom);
InitCursor();
CloseMessageWindow();
}