1 line
28 KiB
C
Executable File
1 line
28 KiB
C
Executable File
|
|
//============================================================================
|
|
//----------------------------------------------------------------------------
|
|
// HouseLegal.c
|
|
//----------------------------------------------------------------------------
|
|
//============================================================================
|
|
|
|
|
|
#include <NumberFormatting.h>
|
|
#include <StringCompare.h>
|
|
#include "Externs.h"
|
|
#include "ObjectEdit.h"
|
|
#include "RectUtils.h"
|
|
|
|
|
|
void WrapBannerAndTrailer (void);
|
|
void ValidateNumberOfRooms (void);
|
|
void CheckDuplicateFloorSuite (void);
|
|
void CompressHouse (void);
|
|
void LopOffExtraRooms (void);
|
|
void ValidateRoomNumbers (void);
|
|
void CountUntitledRooms (void);
|
|
void CheckRoomNameLength (void);
|
|
void MakeSureNumObjectsJives (void);
|
|
void KeepAllObjectsLegal (void);
|
|
void CheckForStaircasePairs (void);
|
|
|
|
|
|
short houseErrors, wasRoom;
|
|
Boolean isHouseChecks;
|
|
|
|
extern short numberRooms;
|
|
|
|
|
|
//============================================================== Functions
|
|
//-------------------------------------------------------------- KeepObjectLegal
|
|
|
|
// Does a test of the current object active for any illegal boundsÉ
|
|
// or values. It corrects the erros and returns true if any changesÉ
|
|
// were made.
|
|
|
|
Boolean KeepObjectLegal (void)
|
|
{
|
|
objectType *theObject;
|
|
Rect bounds, roomRect;
|
|
short direction, dist;
|
|
char wasState;
|
|
Boolean unchanged;
|
|
|
|
unchanged = true;
|
|
#ifndef COMPILEDEMO
|
|
|
|
theObject = &thisRoom->objects[objActive];
|
|
|
|
if (objActive == kInitialGliderSelected)
|
|
{
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
if ((*thisHouse)->initial.h < 0)
|
|
(*thisHouse)->initial.h = 0;
|
|
if ((*thisHouse)->initial.v < 0)
|
|
(*thisHouse)->initial.v = 0;
|
|
if ((*thisHouse)->initial.h > (kRoomWide - kGliderWide))
|
|
(*thisHouse)->initial.h = kRoomWide - kGliderWide;
|
|
if ((*thisHouse)->initial.v > (kTileHigh - kGliderHigh))
|
|
(*thisHouse)->initial.v = kTileHigh - kGliderHigh;
|
|
HSetState((Handle)thisHouse, wasState);
|
|
return (true);
|
|
}
|
|
|
|
QSetRect(&roomRect, 0, 0, kRoomWide, kTileHigh);
|
|
|
|
switch (theObject->what)
|
|
{
|
|
case kFloorVent:
|
|
case kCeilingVent:
|
|
case kFloorBlower:
|
|
case kCeilingBlower:
|
|
case kSewerGrate:
|
|
case kLeftFan:
|
|
case kRightFan:
|
|
case kTaper:
|
|
case kCandle:
|
|
case kStubby:
|
|
case kTiki:
|
|
case kBBQ:
|
|
case kInvisBlower:
|
|
case kGrecoVent:
|
|
case kSewerBlower:
|
|
case kLiftArea:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.a.topLeft.h = bounds.left;
|
|
theObject->data.a.topLeft.v = bounds.top;
|
|
unchanged = false;
|
|
if (theObject->what == kLiftArea)
|
|
{
|
|
theObject->data.a.distance = RectWide(&bounds);
|
|
theObject->data.a.tall = RectTall(&bounds) / 2;
|
|
}
|
|
}
|
|
if ((theObject->what == kStubby) && (theObject->data.a.topLeft.h % 2 == 0))
|
|
{
|
|
theObject->data.a.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
if (((theObject->what == kTaper) || (theObject->what == kCandle) ||
|
|
(theObject->what == kTiki) || (theObject->what == kBBQ)) &&
|
|
(theObject->data.a.topLeft.h % 2 != 0))
|
|
{
|
|
theObject->data.a.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kFloorVent) && (theObject->data.a.topLeft.v != kFloorVentTop))
|
|
{
|
|
theObject->data.a.topLeft.v = kFloorVentTop;
|
|
theObject->data.a.distance += 2;
|
|
}
|
|
if ((theObject->what == kFloorBlower) &&
|
|
(theObject->data.a.topLeft.v != kFloorBlowerTop))
|
|
{
|
|
theObject->data.a.topLeft.v = kFloorBlowerTop;
|
|
theObject->data.a.distance += 2;
|
|
}
|
|
if ((theObject->what == kSewerGrate) &&
|
|
(theObject->data.a.topLeft.v != kSewerGrateTop))
|
|
{
|
|
theObject->data.a.topLeft.v = kSewerGrateTop;
|
|
theObject->data.a.distance += 2;
|
|
}
|
|
if ((theObject->what == kFloorTrans) &&
|
|
(theObject->data.a.topLeft.v != kFloorTransTop))
|
|
{
|
|
theObject->data.a.topLeft.v = kFloorTransTop;
|
|
theObject->data.a.distance += 2;
|
|
}
|
|
if (ObjectHasHandle(&direction, &dist))
|
|
{
|
|
switch (direction)
|
|
{
|
|
case kAbove:
|
|
dist = bounds.top - dist;
|
|
if ((theObject->what == kFloorVent) ||
|
|
(theObject->what == kFloorBlower) ||
|
|
(theObject->what == kTaper) ||
|
|
(theObject->what == kCandle) ||
|
|
(theObject->what == kStubby))
|
|
{
|
|
if (dist < 36)
|
|
{
|
|
theObject->data.a.distance += dist - 36;
|
|
unchanged = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dist < 0)
|
|
{
|
|
theObject->data.a.distance += dist;
|
|
unchanged = false;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kToRight:
|
|
dist = bounds.right + dist;
|
|
if (dist > kRoomWide)
|
|
{
|
|
theObject->data.a.distance += (kRoomWide - dist);
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kBelow:
|
|
dist = bounds.bottom + dist;
|
|
if (dist > kTileHigh)
|
|
{
|
|
theObject->data.a.distance += (kTileHigh - dist);
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kToLeft:
|
|
dist = bounds.left - dist;
|
|
if (dist < 0)
|
|
{
|
|
theObject->data.a.distance += dist;
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kTable:
|
|
case kShelf:
|
|
case kCabinet:
|
|
case kFilingCabinet:
|
|
case kWasteBasket:
|
|
case kMilkCrate:
|
|
case kCounter:
|
|
case kDresser:
|
|
case kDeckTable:
|
|
case kStool:
|
|
case kTrunk:
|
|
case kInvisObstacle:
|
|
case kManhole:
|
|
case kBooks:
|
|
case kInvisBounce:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.b.bounds = bounds;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kManhole) &&
|
|
(((bounds.left - 3) % 64) != 0))
|
|
{
|
|
theObject->data.b.bounds.left =
|
|
(((bounds.left + 29) / 64) * 64) + 3;
|
|
theObject->data.b.bounds.right =
|
|
theObject->data.b.bounds.left +
|
|
RectWide(&srcRects[kManhole]);
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kRedClock:
|
|
case kBlueClock:
|
|
case kYellowClock:
|
|
case kCuckoo:
|
|
case kPaper:
|
|
case kBattery:
|
|
case kBands:
|
|
case kGreaseRt:
|
|
case kGreaseLf:
|
|
case kFoil:
|
|
case kInvisBonus:
|
|
case kStar:
|
|
case kSparkle:
|
|
case kHelium:
|
|
case kSlider:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.c.topLeft.h = bounds.left;
|
|
theObject->data.c.topLeft.v = bounds.top;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kGreaseRt) &&
|
|
(bounds.right + theObject->data.c.length > kRoomWide))
|
|
{
|
|
theObject->data.c.length = kRoomWide - bounds.right;
|
|
unchanged = false;
|
|
}
|
|
else if ((theObject->what == kGreaseLf) &&
|
|
(bounds.left - theObject->data.c.length < 0))
|
|
{
|
|
theObject->data.c.length = bounds.left;
|
|
unchanged = false;
|
|
}
|
|
else if ((theObject->what == kSlider) &&
|
|
(bounds.left + theObject->data.c.length > kRoomWide))
|
|
{
|
|
theObject->data.c.length = kRoomWide - bounds.left;
|
|
unchanged = false;
|
|
}
|
|
if (theObject->data.c.topLeft.h % 2 != 0)
|
|
{
|
|
theObject->data.c.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what != kStar) &&
|
|
(theObject->data.c.length % 2 != 0))
|
|
{
|
|
theObject->data.c.length--;
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kUpStairs:
|
|
case kDownStairs:
|
|
case kMailboxLf:
|
|
case kMailboxRt:
|
|
case kFloorTrans:
|
|
case kCeilingTrans:
|
|
case kDoorInLf:
|
|
case kDoorInRt:
|
|
case kDoorExRt:
|
|
case kDoorExLf:
|
|
case kWindowInLf:
|
|
case kWindowInRt:
|
|
case kWindowExRt:
|
|
case kWindowExLf:
|
|
case kInvisTrans:
|
|
case kDeluxeTrans:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.d.topLeft.h = bounds.left;
|
|
theObject->data.d.topLeft.v = bounds.top;
|
|
unchanged = false;
|
|
if (theObject->what == kDeluxeTrans)
|
|
{
|
|
theObject->data.d.tall = ((RectWide(&bounds) / 4) << 8) +
|
|
(RectTall(&bounds) / 4);
|
|
}
|
|
}
|
|
if ((theObject->what == kDoorInLf) ||
|
|
(theObject->what == kDoorInRt))
|
|
{
|
|
if (theObject->data.d.topLeft.h +
|
|
HalfRectWide(&srcRects[kDoorInLf]) > (kRoomWide / 2))
|
|
{
|
|
theObject->data.d.topLeft.h = kDoorInRtLeft;
|
|
theObject->what = kDoorInRt;
|
|
}
|
|
else
|
|
{
|
|
theObject->data.d.topLeft.h = kDoorInLfLeft;
|
|
theObject->what = kDoorInLf;
|
|
}
|
|
}
|
|
if ((theObject->what == kDoorExRt) ||
|
|
(theObject->what == kDoorExLf))
|
|
{
|
|
if (theObject->data.d.topLeft.h +
|
|
HalfRectWide(&srcRects[kDoorExRt]) > (kRoomWide / 2))
|
|
{
|
|
theObject->data.d.topLeft.h = kDoorExRtLeft;
|
|
theObject->what = kDoorExRt;
|
|
}
|
|
else
|
|
{
|
|
theObject->data.d.topLeft.h = kDoorExLfLeft;
|
|
theObject->what = kDoorExLf;
|
|
}
|
|
}
|
|
if ((theObject->what == kWindowInLf) ||
|
|
(theObject->what == kWindowInRt))
|
|
{
|
|
if (theObject->data.d.topLeft.h +
|
|
HalfRectWide(&srcRects[kWindowInLf]) > (kRoomWide / 2))
|
|
{
|
|
theObject->data.d.topLeft.h = kWindowInRtLeft;
|
|
theObject->what = kWindowInRt;
|
|
}
|
|
else
|
|
{
|
|
theObject->data.d.topLeft.h = kWindowInLfLeft;
|
|
theObject->what = kWindowInLf;
|
|
}
|
|
}
|
|
if ((theObject->what == kWindowExRt) ||
|
|
(theObject->what == kWindowExLf))
|
|
{
|
|
if (theObject->data.d.topLeft.h +
|
|
HalfRectWide(&srcRects[kWindowExRt]) > (kRoomWide / 2))
|
|
{
|
|
theObject->data.d.topLeft.h = kWindowExRtLeft;
|
|
theObject->what = kWindowExRt;
|
|
}
|
|
else
|
|
{
|
|
theObject->data.d.topLeft.h = kWindowExLfLeft;
|
|
theObject->what = kWindowExLf;
|
|
}
|
|
}
|
|
|
|
if ((theObject->what == kInvisTrans) &&
|
|
((theObject->data.d.topLeft.v +
|
|
theObject->data.d.tall) > kTileHigh))
|
|
{
|
|
theObject->data.d.tall = kTileHigh -
|
|
theObject->data.d.topLeft.v;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kInvisTrans) &&
|
|
(theObject->data.d.wide < 0))
|
|
{
|
|
theObject->data.d.wide = 0;
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kLightSwitch:
|
|
case kMachineSwitch:
|
|
case kThermostat:
|
|
case kPowerSwitch:
|
|
case kKnifeSwitch:
|
|
case kInvisSwitch:
|
|
case kTrigger:
|
|
case kLgTrigger:
|
|
case kSoundTrigger:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.e.topLeft.h = bounds.left;
|
|
theObject->data.e.topLeft.v = bounds.top;
|
|
unchanged = false;
|
|
}
|
|
if (theObject->data.e.topLeft.h % 2 != 0)
|
|
{
|
|
theObject->data.e.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kCeilingLight:
|
|
case kLightBulb:
|
|
case kTableLamp:
|
|
case kHipLamp:
|
|
case kDecoLamp:
|
|
case kFlourescent:
|
|
case kTrackLight:
|
|
case kInvisLight:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
if ((theObject->what == kFlourescent) || (theObject->what == kTrackLight))
|
|
{
|
|
if (theObject->data.f.topLeft.h < bounds.left)
|
|
theObject->data.f.topLeft.h = bounds.left;
|
|
|
|
if (theObject->data.f.topLeft.v < bounds.top)
|
|
theObject->data.f.topLeft.v = bounds.top;
|
|
|
|
if ((theObject->data.f.topLeft.h + theObject->data.f.length) > bounds.right)
|
|
theObject->data.f.length = bounds.right - theObject->data.f.topLeft.h;
|
|
}
|
|
else
|
|
{
|
|
theObject->data.f.topLeft.h = bounds.left;
|
|
theObject->data.f.topLeft.v = bounds.top;
|
|
}
|
|
unchanged = false;
|
|
}
|
|
if (((theObject->what == kFlourescent) ||
|
|
(theObject->what == kTrackLight)) &&
|
|
((bounds.right > kRoomWide) || (bounds.left < 0)))
|
|
{
|
|
if (theObject->data.f.topLeft.h < 0)
|
|
{
|
|
theObject->data.f.topLeft.h = 0;
|
|
unchanged = false;
|
|
}
|
|
if (bounds.left < 0)
|
|
{
|
|
bounds.left = 0;
|
|
unchanged = false;
|
|
}
|
|
if (theObject->data.f.topLeft.h > kRoomWide)
|
|
{
|
|
theObject->data.f.topLeft.h = kRoomWide;
|
|
unchanged = false;
|
|
}
|
|
if (bounds.right > kRoomWide)
|
|
{
|
|
bounds.right = kRoomWide;
|
|
unchanged = false;
|
|
}
|
|
theObject->data.f.length = kRoomWide - bounds.left;
|
|
}
|
|
break;
|
|
|
|
case kShredder:
|
|
case kToaster:
|
|
case kMacPlus:
|
|
case kGuitar:
|
|
case kTV:
|
|
case kCoffee:
|
|
case kOutlet:
|
|
case kVCR:
|
|
case kStereo:
|
|
case kMicrowave:
|
|
case kCinderBlock:
|
|
case kFlowerBox:
|
|
case kCDs:
|
|
case kCustomPict:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.g.topLeft.h = bounds.left;
|
|
theObject->data.g.topLeft.v = bounds.top;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kToaster) &&
|
|
(bounds.top - theObject->data.g.height < 0))
|
|
{
|
|
theObject->data.g.height = bounds.top;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kTV) &&
|
|
(theObject->data.g.topLeft.h % 2 == 0))
|
|
{
|
|
theObject->data.g.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
if (((theObject->what == kToaster) ||
|
|
(theObject->what == kMacPlus) ||
|
|
(theObject->what == kCoffee) ||
|
|
(theObject->what == kOutlet) ||
|
|
(theObject->what == kVCR) ||
|
|
(theObject->what == kStereo) ||
|
|
(theObject->what == kMicrowave)) &&
|
|
(theObject->data.g.topLeft.h % 2 != 0))
|
|
{
|
|
theObject->data.g.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kBalloon:
|
|
case kCopterLf:
|
|
case kCopterRt:
|
|
case kDartLf:
|
|
case kDartRt:
|
|
case kBall:
|
|
case kDrip:
|
|
case kFish:
|
|
case kCobweb:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.h.topLeft.h = bounds.left;
|
|
theObject->data.h.topLeft.v = bounds.top;
|
|
unchanged = false;
|
|
}
|
|
if (((theObject->what == kBall) ||
|
|
(theObject->what == kFish)) &&
|
|
(bounds.top - theObject->data.h.length < 0))
|
|
{
|
|
theObject->data.h.length = bounds.top;
|
|
unchanged = false;
|
|
}
|
|
if ((theObject->what == kDrip) &&
|
|
(bounds.bottom + theObject->data.h.length > kTileHigh))
|
|
{
|
|
theObject->data.h.length = kTileHigh - bounds.bottom;
|
|
unchanged = false;
|
|
}
|
|
if (((theObject->what == kBalloon) ||
|
|
(theObject->what == kCopterLf) ||
|
|
(theObject->what == kCopterRt) ||
|
|
(theObject->what == kBall) ||
|
|
(theObject->what == kDrip) ||
|
|
(theObject->what == kFish)) &&
|
|
(theObject->data.h.topLeft.h % 2 != 0))
|
|
{
|
|
theObject->data.h.topLeft.h--;
|
|
unchanged = false;
|
|
}
|
|
break;
|
|
|
|
case kOzma:
|
|
case kMirror:
|
|
case kMousehole:
|
|
case kFireplace:
|
|
case kFlower:
|
|
case kWallWindow:
|
|
case kBear:
|
|
case kCalendar:
|
|
case kVase1:
|
|
case kVase2:
|
|
case kBulletin:
|
|
case kCloud:
|
|
case kFaucet:
|
|
case kRug:
|
|
case kChimes:
|
|
GetObjectRect(&thisRoom->objects[objActive], &bounds);
|
|
if (ForceRectInRect(&bounds, &roomRect))
|
|
{
|
|
theObject->data.i.bounds = bounds;
|
|
unchanged = false;
|
|
}
|
|
if (theObject->what == kMirror)
|
|
{
|
|
if (theObject->data.i.bounds.left % 2 != 0)
|
|
{
|
|
theObject->data.i.bounds.left--;
|
|
unchanged = false;
|
|
}
|
|
if (theObject->data.i.bounds.right % 2 != 0)
|
|
{
|
|
theObject->data.i.bounds.right--;
|
|
unchanged = false;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return (unchanged);
|
|
}
|
|
|
|
//-------------------------------------------------------------- WrapBannerAndTrailer
|
|
|
|
// Tries to wrap around the text of the banner and trailer messages.
|
|
|
|
#ifndef COMPILEDEMO
|
|
void WrapBannerAndTrailer (void)
|
|
{
|
|
char wasState;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
WrapText((*thisHouse)->banner, 40);
|
|
WrapText((*thisHouse)->trailer, 64);
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- ValidateNumberOfRooms
|
|
|
|
// Makes sure the number of room count and actual number of rooms match.
|
|
|
|
void ValidateNumberOfRooms (void)
|
|
{
|
|
long countedRooms, reportsRooms;
|
|
char wasState;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
reportsRooms = (long)(*thisHouse)->nRooms;
|
|
countedRooms = (GetHandleSize((Handle)thisHouse) -
|
|
sizeof(houseType)) / sizeof(roomType);
|
|
if (reportsRooms != countedRooms)
|
|
{
|
|
(*thisHouse)->nRooms = (short)countedRooms;
|
|
numberRooms = (*thisHouse)->nRooms;
|
|
houseErrors++;
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- CheckDuplicateFloorSuite
|
|
|
|
// Error check, looks for rooms with the same floor suite (stacked).
|
|
|
|
void CheckDuplicateFloorSuite (void)
|
|
{
|
|
#define kRoomsTimesSuites 8192
|
|
short i, numRooms, bitPlace;
|
|
char *pidgeonHoles;
|
|
char wasState;
|
|
|
|
pidgeonHoles = (char *)NewPtrClear(sizeof(char) * kRoomsTimesSuites);
|
|
if (pidgeonHoles == nil)
|
|
return;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
|
|
{
|
|
bitPlace = (((*thisHouse)->rooms[i].floor + 7) * 128) +
|
|
(*thisHouse)->rooms[i].suite;
|
|
if ((bitPlace < 0) || (bitPlace >= 8192))
|
|
DebugStr("\pBlew array");
|
|
if (pidgeonHoles[bitPlace] != 0)
|
|
{
|
|
houseErrors++;
|
|
(*thisHouse)->rooms[i].suite = kRoomIsEmpty;
|
|
}
|
|
else
|
|
pidgeonHoles[bitPlace]++;
|
|
}
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
|
|
DisposePtr((Ptr)pidgeonHoles);
|
|
}
|
|
|
|
//-------------------------------------------------------------- CompressHouse
|
|
|
|
// Removes place-holder (deleted) rooms from the middle of the file.
|
|
|
|
void CompressHouse (void)
|
|
{
|
|
short wasFirstRoom, roomNumber, probe;
|
|
char wasState;
|
|
Boolean compressing, probing;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
wasFirstRoom = (*thisHouse)->firstRoom;
|
|
compressing = true;
|
|
roomNumber = (*thisHouse)->nRooms - 1; // start with last room
|
|
do
|
|
{
|
|
if ((*thisHouse)->rooms[roomNumber].suite != kRoomIsEmpty)
|
|
{ // if not an empty roomÉ
|
|
probe = 0; // start looking for empty slot
|
|
probing = true;
|
|
do
|
|
{ // test room at probe to see if empty
|
|
if ((*thisHouse)->rooms[probe].suite == kRoomIsEmpty)
|
|
{ // if it is, copy room there
|
|
(*thisHouse)->rooms[probe] = (*thisHouse)->rooms[roomNumber];
|
|
(*thisHouse)->rooms[roomNumber].suite = kRoomIsEmpty;
|
|
if (roomNumber == wasFirstRoom)
|
|
(*thisHouse)->firstRoom = probe;
|
|
if (roomNumber == wasRoom)
|
|
wasRoom = probe;
|
|
probing = false;
|
|
}
|
|
probe++; // bump probe up to next room
|
|
if ((probing) && (probe >= roomNumber))
|
|
{ // we reached the current room
|
|
probing = false; // we can look no further
|
|
compressing = false; // so we can compress no more
|
|
}
|
|
}
|
|
while (probing);
|
|
}
|
|
roomNumber--; // go on to room preceding
|
|
if (roomNumber <= 0) // stop if we reach the first room
|
|
compressing = false;
|
|
}
|
|
while (compressing);
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- LopOffExtraRooms
|
|
|
|
// Deletes all empty rooms hanging off the end of the house file.
|
|
|
|
void LopOffExtraRooms (void)
|
|
{
|
|
long newSize;
|
|
short r, count;
|
|
char wasState;
|
|
Str255 message;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
count = 0;
|
|
r = (*thisHouse)->nRooms; // begin at last room
|
|
do
|
|
{
|
|
r--; // look for trailing empties
|
|
if ((*thisHouse)->rooms[r].suite == kRoomIsEmpty)
|
|
count++;
|
|
else
|
|
r = 0;
|
|
}
|
|
while (r > 0);
|
|
|
|
if (count > 0) // if there were trailing emptiesÉ
|
|
{
|
|
r = (*thisHouse)->nRooms - count;
|
|
newSize = sizeof(houseType) + (sizeof(roomType) * (long)r);
|
|
HUnlock((Handle)thisHouse); // resize house handle (shrink)
|
|
SetHandleSize((Handle)thisHouse, newSize);
|
|
if (MemError() != noErr) // problem?
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(16, message);
|
|
SetMessageWindowMessage(message);
|
|
}
|
|
HLock((Handle)thisHouse); // reflect new room count
|
|
(*thisHouse)->nRooms -= count;
|
|
numberRooms = (*thisHouse)->nRooms;
|
|
}
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- ValidateRoomNumbers
|
|
|
|
// Error check - ensures that the floor and suite numbers are within legal ranges.
|
|
|
|
void ValidateRoomNumbers (void)
|
|
{
|
|
short i, numRooms;
|
|
char wasState;
|
|
Str255 message;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
if (numRooms < 0)
|
|
{
|
|
(*thisHouse)->nRooms = 0;
|
|
numRooms = 0;
|
|
}
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
|
|
{
|
|
if (((*thisHouse)->rooms[i].floor > 56) ||
|
|
((*thisHouse)->rooms[i].floor < -7))
|
|
{
|
|
(*thisHouse)->rooms[i].suite = kRoomIsEmpty;
|
|
ForeColor(redColor);
|
|
GetLocalizedString(17, message);
|
|
SetMessageWindowMessage(message);
|
|
houseErrors++;
|
|
ForeColor(blackColor);
|
|
}
|
|
if (((*thisHouse)->rooms[i].suite >= 128) ||
|
|
((*thisHouse)->rooms[i].suite < 0))
|
|
{
|
|
(*thisHouse)->rooms[i].suite = kRoomIsEmpty;
|
|
ForeColor(redColor);
|
|
GetLocalizedString(18, message);
|
|
SetMessageWindowMessage(message);
|
|
houseErrors++;
|
|
ForeColor(blackColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- CountUntitledRooms
|
|
|
|
// Returns the number of rooms left "Untitled".
|
|
|
|
void CountUntitledRooms (void)
|
|
{
|
|
short i, numRooms;
|
|
char wasState;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
if (((*thisHouse)->rooms[i].suite != kRoomIsEmpty) &&
|
|
(EqualString((*thisHouse)->rooms[i].name, "\pUntitled Room", false, true)))
|
|
houseErrors++;
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- CheckRoomNameLength
|
|
|
|
// Error check - ensures the length of the room name is legal.
|
|
|
|
void CheckRoomNameLength (void)
|
|
{
|
|
short i, numRooms;
|
|
char wasState;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
(*thisHouse)->rooms[i].unusedByte = 0;
|
|
|
|
if (((*thisHouse)->rooms[i].suite != kRoomIsEmpty) &&
|
|
((*thisHouse)->rooms[i].name[0] > 27))
|
|
{
|
|
(*thisHouse)->rooms[i].name[0] = 27;
|
|
houseErrors++;
|
|
}
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- MakeSureNumObjectsJives
|
|
|
|
// Error check - ensures the actual count of objects equals number of objects.
|
|
|
|
void MakeSureNumObjectsJives (void)
|
|
{
|
|
short i, h, numRooms, count;
|
|
char wasState;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
|
|
{
|
|
count = 0;
|
|
for (h = 0; h < kMaxRoomObs; h++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].objects[h].what != kObjectIsEmpty)
|
|
count++;
|
|
}
|
|
if (count != (*thisHouse)->rooms[i].numObjects)
|
|
{
|
|
houseErrors++;
|
|
(*thisHouse)->rooms[i].numObjects = count;
|
|
}
|
|
}
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- KeepAllObjectsLegal
|
|
|
|
// Repeatedly calls KeepObjectLegal() on ALL objects in a house. Wow!
|
|
|
|
void KeepAllObjectsLegal (void)
|
|
{
|
|
short i, h, numRooms;
|
|
char wasState;
|
|
Str255 message;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
|
|
{
|
|
ForceThisRoom(i);
|
|
for (h = 0; h < kMaxRoomObs; h++)
|
|
{
|
|
objActive = h;
|
|
if (thisRoom->objects[objActive].what != kObjectIsEmpty)
|
|
{
|
|
if (!KeepObjectLegal())
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(19, message);
|
|
SetMessageWindowMessage(message);
|
|
houseErrors++;
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
}
|
|
CopyThisRoomToRoom();
|
|
}
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
|
|
//-------------------------------------------------------------- CheckForStaircasePairs
|
|
|
|
// Ensures that for every up-stair there is a down-stair.
|
|
|
|
void CheckForStaircasePairs (void)
|
|
{
|
|
short i, h, g, numRooms, neighbor;
|
|
char wasState;
|
|
Boolean hasStairs;
|
|
Str255 message;
|
|
|
|
wasState = HGetState((Handle)thisHouse);
|
|
HLock((Handle)thisHouse);
|
|
|
|
numRooms = (*thisHouse)->nRooms;
|
|
for (i = 0; i < numRooms; i++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].suite != kRoomIsEmpty)
|
|
{
|
|
for (h = 0; h < kMaxRoomObs; h++)
|
|
{
|
|
if ((*thisHouse)->rooms[i].objects[h].what == kUpStairs)
|
|
{
|
|
thisRoomNumber = i;
|
|
neighbor = GetNeighborRoomNumber(kNorthRoom);
|
|
if (neighbor == kRoomIsEmpty)
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(20, message);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
else
|
|
{
|
|
hasStairs = false;
|
|
for (g = 0; g < kMaxRoomObs; g++)
|
|
{
|
|
if ((*thisHouse)->rooms[neighbor].objects[g].what ==
|
|
kDownStairs)
|
|
hasStairs = true;
|
|
}
|
|
if (!hasStairs)
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(21, message);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
}
|
|
else if ((*thisHouse)->rooms[i].objects[h].what == kDownStairs)
|
|
{
|
|
thisRoomNumber = i;
|
|
neighbor = GetNeighborRoomNumber(kSouthRoom);
|
|
if (neighbor == kRoomIsEmpty)
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(22, message);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
else
|
|
{
|
|
hasStairs = false;
|
|
for (g = 0; g < kMaxRoomObs; g++)
|
|
{
|
|
if ((*thisHouse)->rooms[neighbor].objects[g].what ==
|
|
kUpStairs)
|
|
hasStairs = true;
|
|
}
|
|
if (!hasStairs)
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(23, message);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
HSetState((Handle)thisHouse, wasState);
|
|
}
|
|
#endif
|
|
|
|
//-------------------------------------------------------------- CheckHouseForProblems
|
|
|
|
// Calls all the above functions and reports (and corrects) errors.
|
|
|
|
void CheckHouseForProblems (void)
|
|
{
|
|
#ifndef COMPILEDEMO
|
|
Str255 message, message2;
|
|
short wasActive;
|
|
|
|
houseErrors = 0;
|
|
CopyThisRoomToRoom();
|
|
wasRoom = thisRoomNumber;
|
|
wasActive = objActive;
|
|
GetLocalizedString(24, message);
|
|
OpenMessageWindow(message);
|
|
|
|
SpinCursor(3);
|
|
GetLocalizedString(25, message);
|
|
SetMessageWindowMessage(message);
|
|
WrapBannerAndTrailer();
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
GetLocalizedString(26, message);
|
|
SetMessageWindowMessage(message);
|
|
ValidateNumberOfRooms();
|
|
if (houseErrors != 0)
|
|
{
|
|
GetLocalizedString(27, message);
|
|
SetMessageWindowMessage(message);
|
|
DelayTicks(60);
|
|
houseErrors = 0;
|
|
}
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
houseErrors = 0;
|
|
CheckDuplicateFloorSuite();
|
|
if (houseErrors != 0)
|
|
{
|
|
NumToString((long)houseErrors, message);
|
|
GetLocalizedString(28, message2);
|
|
PasStringConcat(message, message2);
|
|
ForeColor(redColor);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(45);
|
|
}
|
|
}
|
|
|
|
SpinCursor(3);
|
|
CompressHouse();
|
|
SpinCursor(3);
|
|
LopOffExtraRooms();
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
ValidateRoomNumbers();
|
|
if (houseErrors != 0)
|
|
{
|
|
NumToString((long)houseErrors, message);
|
|
GetLocalizedString(29, message2);
|
|
PasStringConcat(message, message2);
|
|
ForeColor(redColor);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
houseErrors = 0;
|
|
CountUntitledRooms();
|
|
if (houseErrors != 0)
|
|
{
|
|
NumToString((long)houseErrors, message);
|
|
GetLocalizedString(30, message2);
|
|
PasStringConcat(message, message2);
|
|
ForeColor(blueColor);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(45);
|
|
}
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
houseErrors = 0;
|
|
CheckRoomNameLength();
|
|
if (houseErrors != 0)
|
|
{
|
|
NumToString((long)houseErrors, message);
|
|
GetLocalizedString(31, message2);
|
|
PasStringConcat(message, message2);
|
|
ForeColor(blueColor);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(45);
|
|
}
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
houseErrors = 0;
|
|
MakeSureNumObjectsJives();
|
|
if (houseErrors != 0)
|
|
{
|
|
NumToString((long)houseErrors, message);
|
|
GetLocalizedString(32, message2);
|
|
PasStringConcat(message, message2);
|
|
ForeColor(redColor);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
houseErrors = 0;
|
|
GetLocalizedString(33, message);
|
|
SetMessageWindowMessage(message);
|
|
KeepAllObjectsLegal();
|
|
if (houseErrors != 0)
|
|
{
|
|
NumToString((long)houseErrors, message);
|
|
GetLocalizedString(34, message2);
|
|
PasStringConcat(message, message2);
|
|
ForeColor(redColor);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
houseErrors = 0;
|
|
CheckForStaircasePairs();
|
|
}
|
|
|
|
if (isHouseChecks)
|
|
{
|
|
SpinCursor(3);
|
|
if (CountStarsInHouse() < 1)
|
|
{
|
|
ForeColor(redColor);
|
|
GetLocalizedString(35, message);
|
|
SetMessageWindowMessage(message);
|
|
ForeColor(blackColor);
|
|
DelayTicks(60);
|
|
}
|
|
}
|
|
|
|
InitCursor();
|
|
CloseMessageWindow();
|
|
ForceThisRoom(wasRoom);
|
|
objActive = wasActive;
|
|
#endif
|
|
}
|
|
|