diff options
Diffstat (limited to 'engines/dm/gfx.cpp')
-rw-r--r-- | engines/dm/gfx.cpp | 1510 |
1 files changed, 755 insertions, 755 deletions
diff --git a/engines/dm/gfx.cpp b/engines/dm/gfx.cpp index ceeb28507b..89cba9d2ee 100644 --- a/engines/dm/gfx.cpp +++ b/engines/dm/gfx.cpp @@ -41,7 +41,7 @@ namespace DM { DisplayMan::DisplayMan(DMEngine *dmEngine) : _vm(dmEngine) { - _g348_bitmapScreen = nullptr; + _bitmapScreen = nullptr; _bitmaps = nullptr; _grapItemCount = 0; _packedItemPos = nullptr; @@ -49,95 +49,95 @@ DisplayMan::DisplayMan(DMEngine *dmEngine) : _vm(dmEngine) { _bitmapDecompressedByteCount = nullptr; _packedBitmaps = nullptr; _bitmaps = nullptr; - _g74_tmpBitmap = nullptr; - _g84_bitmapFloor = nullptr; - _g85_bitmapCeiling = nullptr; - _g264_currMapAllowedCreatureTypes = nullptr; - _g639_derivedBitmapByteCount = nullptr; - _g638_derivedBitmaps = nullptr; + _tmpBitmap = nullptr; + _bitmapFloor = nullptr; + _bitmapCeiling = nullptr; + _currMapAllowedCreatureTypes = nullptr; + _derivedBitmapByteCount = nullptr; + _derivedBitmaps = nullptr; _screenWidth = _screenHeight = 0; - _g289_championPortraitOrdinal = 0; - _g266_currMapViAltarIndex = 0; - _g297_drawFloorAndCeilingRequested = true; + _championPortraitOrdinal = 0; + _currMapViAltarIndex = 0; + _drawFloorAndCeilingRequested = true; for (int i = 0; i < 4; i++) - _g75_palChangesProjectile[i] = nullptr; + _palChangesProjectile[i] = nullptr; for (int i = 0; i < k3_AlcoveOrnCount; i++) - _g267_currMapAlcoveOrnIndices[i] = 0; + _currMapAlcoveOrnIndices[i] = 0; for (int i = 0; i < k1_FountainOrnCount; i++) - _g268_currMapFountainOrnIndices[i] = 0; + _currMapFountainOrnIndices[i] = 0; for (int i = 0; i < 2; i++) { for (int j = 0; j < 16; j++) { - _g101_currMapWallOrnInfo[j][i] = 0; - _g102_currMapFloorOrnInfo[j][i] = 0; + _currMapWallOrnInfo[j][i] = 0; + _currMapFloorOrnInfo[j][i] = 0; } for (int j = 0; j < 17; j++) - _g103_currMapDoorOrnInfo[j][i] = 0; + _currMapDoorOrnInfo[j][i] = 0; } for (int i = 0; i < 16; i++) { - _g261_currMapWallOrnIndices[i] = 0; - _g262_currMapFloorOrnIndices[i] = 0; + _currMapWallOrnIndices[i] = 0; + _currMapFloorOrnIndices[i] = 0; } for (int i = 0; i < 18; i++) - _g263_currMapDoorOrnIndices[i] = 0; - - _g290_inscriptionThing = Thing::_none; - _g578_useByteBoxCoordinates = false; - - _g85_bitmapCeiling = nullptr; - _g84_bitmapFloor = nullptr; - _g697_bitmapWallSet_Wall_D3L2 = nullptr; - _g696_bitmapWallSet_Wall_D3R2 = nullptr; - _g698_bitmapWallSet_Wall_D3LCR = nullptr; - _g699_bitmapWallSet_Wall_D2LCR = nullptr; - _g700_bitmapWallSet_Wall_D1LCR = nullptr; - _g701_bitmapWallSet_Wall_D0L = nullptr; - _g702_bitmapWallSet_Wall_D0R = nullptr; - _g703_bitmapWallSet_DoorFrameTop_D2LCR = nullptr; - _g704_bitmapWallSet_DoorFrameTop_D1LCR = nullptr; - _g705_bitmapWallSet_DoorFrameLeft_D3L = nullptr; - _g706_bitmapWallSet_DoorFrameLeft_D3C = nullptr; - _g707_bitmapWallSet_DoorFrameLeft_D2C = nullptr; - _g708_bitmapWallSet_DoorFrameLeft_D1C = nullptr; - _g710_bitmapWallSet_DoorFrameRight_D1C = nullptr; - _g709_bitmapWallSet_DoorFrameFront = nullptr; - _g296_bitmapViewport = nullptr; - - _g231_currentWallSet = -1; - _g230_currentFloorSet = -1; - - _g90_bitmapWall_D3LCR_Flipped = nullptr; - _g91_bitmapWall_D2LCR_Flipped = nullptr; - _g92_bitmapWall_D1LCR_Flipped = nullptr; - _g93_bitmapWall_D0L_Flipped = nullptr; - _g94_bitmapWall_D0R_Flipped = nullptr; - _g95_bitmapWall_D3LCR_Native = nullptr; - _g96_bitmapWall_D2LCR_Native = nullptr; - _g97_bitmapWall_D1LCR_Native = nullptr; - _g98_bitmapWall_D0L_Native = nullptr; - _g99_bitmapWall_D0R_Native = nullptr; - - _g322_paletteSwitchingEnabled = false; - _g304_dungeonViewPaletteIndex = 0; + _currMapDoorOrnIndices[i] = 0; + + _inscriptionThing = Thing::_none; + _useByteBoxCoordinates = false; + + _bitmapCeiling = nullptr; + _bitmapFloor = nullptr; + _bitmapWallSetD3L2 = nullptr; + _bitmapWallSetD3R2 = nullptr; + _bitmapWallSetD3LCR = nullptr; + _bitmapWallSetD2LCR = nullptr; + _bitmapWallSetD1LCR = nullptr; + bitmapWallSetWallD0L = nullptr; + _bitmapWallSetWallD0R = nullptr; + _bitmapWallSetDoorFrameTopD2LCR = nullptr; + _bitmapWallSetDoorFrameTopD1LCR = nullptr; + _bitmapWallSetDoorFrameLeftD3L = nullptr; + _bitmapWallSetDoorFrameLeftD3C = nullptr; + _bitmapWallSetDoorFrameLeftD2C = nullptr; + _bitmapWallSetDoorFrameLeftD1C = nullptr; + _bitmapWallSetDoorFrameRightD1C = nullptr; + _bitmapWallSetDoorFrameFront = nullptr; + _bitmapViewport = nullptr; + + _currentWallSet = -1; + _currentFloorSet = -1; + + _bitmapWallD3LCRFlipped = nullptr; + _bitmapWallD2LCRFlipped = nullptr; + _bitmapWallD1LCRFlipped = nullptr; + _bitmapWallD0LFlipped = nullptr; + _bitmapWallD0RFlipped = nullptr; + _bitmapWallD3LCRNative = nullptr; + _bitmapWallD2LCRNative = nullptr; + _bitmapWallD1LCRNative = nullptr; + _bitmapWallD0LNative = nullptr; + _bitmapWallD0RNative = nullptr; + + _paletteSwitchingEnabled = false; + _dungeonViewPaletteIndex = 0; for (uint16 i = 0; i < 16; ++i) { - _g347_paletteTopAndBottomScreen[i] = 0; - _g346_paletteMiddleScreen[i] = 0; + _paletteTopAndBottomScreen[i] = 0; + _paletteMiddleScreen[i] = 0; } for (uint16 i = 0; i < 32; i++) - _g345_aui_BlankBuffer[i] = 0; + _blankBuffer[i] = 0; - _gK17_paletteFadeFrom = nullptr; + _paletteFadeFrom = nullptr; for (uint16 i = 0; i < 16; ++i) - _gK16_paletteFadeTemporary[i] = 0; + _paletteFadeTemporary[i] = 0; initConstants(); } @@ -417,7 +417,7 @@ void DisplayMan::initConstants() { DisplayMan::~DisplayMan() { delete[] _packedItemPos; delete[] _packedBitmaps; - delete[] _g348_bitmapScreen; + delete[] _bitmapScreen; if (_bitmaps) { delete[] _bitmaps[0]; delete[] _bitmaps; @@ -425,37 +425,37 @@ DisplayMan::~DisplayMan() { delete[] _bitmapCompressedByteCount; delete[] _bitmapDecompressedByteCount; - delete[] _g639_derivedBitmapByteCount; - if (_g638_derivedBitmaps) { + delete[] _derivedBitmapByteCount; + if (_derivedBitmaps) { for (uint16 i = 0; i < k730_DerivedBitmapMaximumCount; ++i) - delete[] _g638_derivedBitmaps[i]; - delete[] _g638_derivedBitmaps; + delete[] _derivedBitmaps[i]; + delete[] _derivedBitmaps; } - delete[] _g85_bitmapCeiling; - delete[] _g84_bitmapFloor; - delete[] _g697_bitmapWallSet_Wall_D3L2; - delete[] _g696_bitmapWallSet_Wall_D3R2; - delete[] _g698_bitmapWallSet_Wall_D3LCR; - delete[] _g699_bitmapWallSet_Wall_D2LCR; - delete[] _g700_bitmapWallSet_Wall_D1LCR; - delete[] _g701_bitmapWallSet_Wall_D0L; - delete[] _g702_bitmapWallSet_Wall_D0R; - delete[] _g703_bitmapWallSet_DoorFrameTop_D2LCR; - delete[] _g704_bitmapWallSet_DoorFrameTop_D1LCR; - delete[] _g705_bitmapWallSet_DoorFrameLeft_D3L; - delete[] _g706_bitmapWallSet_DoorFrameLeft_D3C; - delete[] _g707_bitmapWallSet_DoorFrameLeft_D2C; - delete[] _g708_bitmapWallSet_DoorFrameLeft_D1C; - delete[] _g710_bitmapWallSet_DoorFrameRight_D1C; - delete[] _g709_bitmapWallSet_DoorFrameFront; - delete[] _g296_bitmapViewport; - - delete[] _g90_bitmapWall_D3LCR_Flipped; - delete[] _g91_bitmapWall_D2LCR_Flipped; - delete[] _g92_bitmapWall_D1LCR_Flipped; - delete[] _g93_bitmapWall_D0L_Flipped; - delete[] _g94_bitmapWall_D0R_Flipped; + delete[] _bitmapCeiling; + delete[] _bitmapFloor; + delete[] _bitmapWallSetD3L2; + delete[] _bitmapWallSetD3R2; + delete[] _bitmapWallSetD3LCR; + delete[] _bitmapWallSetD2LCR; + delete[] _bitmapWallSetD1LCR; + delete[] bitmapWallSetWallD0L; + delete[] _bitmapWallSetWallD0R; + delete[] _bitmapWallSetDoorFrameTopD2LCR; + delete[] _bitmapWallSetDoorFrameTopD1LCR; + delete[] _bitmapWallSetDoorFrameLeftD3L; + delete[] _bitmapWallSetDoorFrameLeftD3C; + delete[] _bitmapWallSetDoorFrameLeftD2C; + delete[] _bitmapWallSetDoorFrameLeftD1C; + delete[] _bitmapWallSetDoorFrameRightD1C; + delete[] _bitmapWallSetDoorFrameFront; + delete[] _bitmapViewport; + + delete[] _bitmapWallD3LCRFlipped; + delete[] _bitmapWallD2LCRFlipped; + delete[] _bitmapWallD1LCRFlipped; + delete[] _bitmapWallD0LFlipped; + delete[] _bitmapWallD0RFlipped; delete _doorFrameD1C; } @@ -463,78 +463,78 @@ DisplayMan::~DisplayMan() { void DisplayMan::setUpScreens(uint16 width, uint16 height) { _screenWidth = width; _screenHeight = height; - delete[] _g74_tmpBitmap; - delete[] _g348_bitmapScreen; - _g348_bitmapScreen = new byte[_screenWidth * _screenHeight]; + delete[] _tmpBitmap; + delete[] _bitmapScreen; + _bitmapScreen = new byte[_screenWidth * _screenHeight]; fillScreen(k0_ColorBlack); - _g74_tmpBitmap = new byte[_screenWidth * _screenHeight]; -} - - -void DisplayMan::f460_initializeGraphicData() { - _g85_bitmapCeiling = new byte[224 * 29]; - _g84_bitmapFloor = new byte[224 * 70]; - _g697_bitmapWallSet_Wall_D3L2 = new byte[16 * 49]; - _g696_bitmapWallSet_Wall_D3R2 = new byte[16 * 49]; - _g698_bitmapWallSet_Wall_D3LCR = new byte[128 * 51]; - _g699_bitmapWallSet_Wall_D2LCR = new byte[144 * 71]; - _g700_bitmapWallSet_Wall_D1LCR = new byte[256 * 111]; - _g701_bitmapWallSet_Wall_D0L = new byte[32 * 136]; - _g702_bitmapWallSet_Wall_D0R = new byte[32 * 136]; - _g703_bitmapWallSet_DoorFrameTop_D2LCR = new byte[96 * 3]; - _g704_bitmapWallSet_DoorFrameTop_D1LCR = new byte[128 * 4]; - _g705_bitmapWallSet_DoorFrameLeft_D3L = new byte[32 * 44]; - _g706_bitmapWallSet_DoorFrameLeft_D3C = new byte[32 * 44]; - _g707_bitmapWallSet_DoorFrameLeft_D2C = new byte[48 * 65]; - _g708_bitmapWallSet_DoorFrameLeft_D1C = new byte[32 * 94]; - _g710_bitmapWallSet_DoorFrameRight_D1C = new byte[32 * 94]; - _g709_bitmapWallSet_DoorFrameFront = new byte[32 * 123]; - _g296_bitmapViewport = new byte[224 * 136]; - - if (!_g639_derivedBitmapByteCount) - _g639_derivedBitmapByteCount = new uint16[k730_DerivedBitmapMaximumCount]; - if (!_g638_derivedBitmaps) { - _g638_derivedBitmaps = new byte *[k730_DerivedBitmapMaximumCount]; + _tmpBitmap = new byte[_screenWidth * _screenHeight]; +} + + +void DisplayMan::initializeGraphicData() { + _bitmapCeiling = new byte[224 * 29]; + _bitmapFloor = new byte[224 * 70]; + _bitmapWallSetD3L2 = new byte[16 * 49]; + _bitmapWallSetD3R2 = new byte[16 * 49]; + _bitmapWallSetD3LCR = new byte[128 * 51]; + _bitmapWallSetD2LCR = new byte[144 * 71]; + _bitmapWallSetD1LCR = new byte[256 * 111]; + bitmapWallSetWallD0L = new byte[32 * 136]; + _bitmapWallSetWallD0R = new byte[32 * 136]; + _bitmapWallSetDoorFrameTopD2LCR = new byte[96 * 3]; + _bitmapWallSetDoorFrameTopD1LCR = new byte[128 * 4]; + _bitmapWallSetDoorFrameLeftD3L = new byte[32 * 44]; + _bitmapWallSetDoorFrameLeftD3C = new byte[32 * 44]; + _bitmapWallSetDoorFrameLeftD2C = new byte[48 * 65]; + _bitmapWallSetDoorFrameLeftD1C = new byte[32 * 94]; + _bitmapWallSetDoorFrameRightD1C = new byte[32 * 94]; + _bitmapWallSetDoorFrameFront = new byte[32 * 123]; + _bitmapViewport = new byte[224 * 136]; + + if (!_derivedBitmapByteCount) + _derivedBitmapByteCount = new uint16[k730_DerivedBitmapMaximumCount]; + if (!_derivedBitmaps) { + _derivedBitmaps = new byte *[k730_DerivedBitmapMaximumCount]; for (uint16 i = 0; i < k730_DerivedBitmapMaximumCount; ++i) - _g638_derivedBitmaps[i] = nullptr; + _derivedBitmaps[i] = nullptr; } - _g639_derivedBitmapByteCount[k0_DerivedBitmapViewport] = 112 * 136; - _g639_derivedBitmapByteCount[k1_DerivedBitmapThievesEyeVisibleArea] = 48 * 95; - _g639_derivedBitmapByteCount[k2_DerivedBitmapDamageToCreatureMedium] = 32 * 37; - _g639_derivedBitmapByteCount[k3_DerivedBitmapDamageToCreatureSmall] = 24 * 37; + _derivedBitmapByteCount[k0_DerivedBitmapViewport] = 112 * 136; + _derivedBitmapByteCount[k1_DerivedBitmapThievesEyeVisibleArea] = 48 * 95; + _derivedBitmapByteCount[k2_DerivedBitmapDamageToCreatureMedium] = 32 * 37; + _derivedBitmapByteCount[k3_DerivedBitmapDamageToCreatureSmall] = 24 * 37; for (int16 doorOrnamentIndex = k15_DoorOrnDestroyedMask; doorOrnamentIndex <= k16_DoorOrnThivesEyeMask; doorOrnamentIndex++) { - _g103_currMapDoorOrnInfo[doorOrnamentIndex][k0_NativeBitmapIndex] = doorOrnamentIndex + (k301_DoorMaskDestroyedIndice - k15_DoorOrnDestroyedMask); - _g103_currMapDoorOrnInfo[doorOrnamentIndex][k1_CoordinateSet] = 1; + _currMapDoorOrnInfo[doorOrnamentIndex][k0_NativeBitmapIndex] = doorOrnamentIndex + (k301_DoorMaskDestroyedIndice - k15_DoorOrnDestroyedMask); + _currMapDoorOrnInfo[doorOrnamentIndex][k1_CoordinateSet] = 1; - _g639_derivedBitmapByteCount[doorOrnamentIndex * 2 + k68_DerivedBitmapFirstDoorOrnament_D3] = 24 * 41; - _g639_derivedBitmapByteCount[doorOrnamentIndex * 2 + k69_DerivedBitmapFirstDoorOrnament_D2] = 32 * 61; + _derivedBitmapByteCount[doorOrnamentIndex * 2 + k68_DerivedBitmapFirstDoorOrnament_D3] = 24 * 41; + _derivedBitmapByteCount[doorOrnamentIndex * 2 + k69_DerivedBitmapFirstDoorOrnament_D2] = 32 * 61; } - _g102_currMapFloorOrnInfo[k15_FloorOrnFootprints][k0_NativeBitmapIndex] = k241_FloorOrn_15_D3L_footprints; - _g102_currMapFloorOrnInfo[k15_FloorOrnFootprints][k1_CoordinateSet] = 1; + _currMapFloorOrnInfo[k15_FloorOrnFootprints][k0_NativeBitmapIndex] = k241_FloorOrn_15_D3L_footprints; + _currMapFloorOrnInfo[k15_FloorOrnFootprints][k1_CoordinateSet] = 1; ObjectAspect *objectAspect = _objectAspects209; int16 derivedBitmapIndex; for (int16 objectAspectIndex = 0; objectAspectIndex < k85_ObjAspectCount; ++objectAspectIndex, ++objectAspect) { derivedBitmapIndex = k104_DerivedBitmapFirstObject + objectAspect->_firstDerivedBitmapRelativeIndex; - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(objectAspect->_byteWidth, objectAspect->_height, k16_Scale_D3); - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(objectAspect->_byteWidth, objectAspect->_height, k20_Scale_D2); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(objectAspect->_byteWidth, objectAspect->_height, k16_Scale_D3); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(objectAspect->_byteWidth, objectAspect->_height, k20_Scale_D2); if (getFlag(objectAspect->_graphicInfo, k0x0001_ObjectFlipOnRightMask)) { - _g639_derivedBitmapByteCount[derivedBitmapIndex] = _g639_derivedBitmapByteCount[derivedBitmapIndex - 2]; + _derivedBitmapByteCount[derivedBitmapIndex] = _derivedBitmapByteCount[derivedBitmapIndex - 2]; derivedBitmapIndex++; - _g639_derivedBitmapByteCount[derivedBitmapIndex] = _g639_derivedBitmapByteCount[derivedBitmapIndex - 2]; + _derivedBitmapByteCount[derivedBitmapIndex] = _derivedBitmapByteCount[derivedBitmapIndex - 2]; derivedBitmapIndex++; } if (getFlag(objectAspect->_graphicInfo, k0x0010_ObjectAlcoveMask)) { - _g639_derivedBitmapByteCount[derivedBitmapIndex] = _g639_derivedBitmapByteCount[derivedBitmapIndex - 2]; + _derivedBitmapByteCount[derivedBitmapIndex] = _derivedBitmapByteCount[derivedBitmapIndex - 2]; derivedBitmapIndex++; - _g639_derivedBitmapByteCount[derivedBitmapIndex] = _g639_derivedBitmapByteCount[derivedBitmapIndex - 2]; + _derivedBitmapByteCount[derivedBitmapIndex] = _derivedBitmapByteCount[derivedBitmapIndex - 2]; } } @@ -544,31 +544,31 @@ void DisplayMan::f460_initializeGraphicData() { derivedBitmapIndex = k282_DerivedBitmapFirstProjectile + projectileAspect->_firstDerivedBitmapRelativeIndex; for (int16 projectileScaleIndex = 0; projectileScaleIndex < 6; projectileScaleIndex++) { - int16 bitmapByteCount = f459_getScaledBitmapByteCount(projectileAspect->_byteWidth, projectileAspect->_height, _projectileScales[projectileScaleIndex]); - _g639_derivedBitmapByteCount[derivedBitmapIndex] = bitmapByteCount; + int16 bitmapByteCount = getScaledBitmapByteCount(projectileAspect->_byteWidth, projectileAspect->_height, _projectileScales[projectileScaleIndex]); + _derivedBitmapByteCount[derivedBitmapIndex] = bitmapByteCount; if (getFlag(projectileAspect->_graphicInfo, k0x0003_ProjectileAspectTypeMask) != k3_ProjectileAspectHasNone) { - _g639_derivedBitmapByteCount[derivedBitmapIndex + 6] = bitmapByteCount; + _derivedBitmapByteCount[derivedBitmapIndex + 6] = bitmapByteCount; if (getFlag(projectileAspect->_graphicInfo, k0x0003_ProjectileAspectTypeMask) != k2_ProjectileAspectHasRotation) - _g639_derivedBitmapByteCount[derivedBitmapIndex + 12] = bitmapByteCount; + _derivedBitmapByteCount[derivedBitmapIndex + 12] = bitmapByteCount; } } } } - _g75_palChangesProjectile[0] = _palChangesFloorOrnD3; - _g75_palChangesProjectile[1] = _palChangesFloorOrnD2; - _g75_palChangesProjectile[2] = _g75_palChangesProjectile[3] = _palChangesNoChanges; + _palChangesProjectile[0] = _palChangesFloorOrnD3; + _palChangesProjectile[1] = _palChangesFloorOrnD2; + _palChangesProjectile[2] = _palChangesProjectile[3] = _palChangesNoChanges; derivedBitmapIndex = k438_DerivedBitmapFirstExplosion; ExplosionAspect *expAsp = _explosionAspects; for (uint16 expAspIndex = 0; expAspIndex < k4_ExplosionAspectCount; ++expAspIndex, expAsp++) { for (int16 scale = 4; scale < 32; scale += 2) - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(expAsp->_byteWidth, expAsp->_height, scale); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(expAsp->_byteWidth, expAsp->_height, scale); if (expAspIndex == k3_ExplosionAspectSmoke) - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = expAsp->_byteWidth * expAsp->_height; + _derivedBitmapByteCount[derivedBitmapIndex++] = expAsp->_byteWidth * expAsp->_height; } derivedBitmapIndex = k495_DerivedBitmapFirstCreature; @@ -579,39 +579,39 @@ void DisplayMan::f460_initializeGraphicData() { int16 creatureGraphicInfo = g243_CreatureInfo[creatureIndex]._graphicInfo; creatureAsp->_firstDerivedBitmapIndex = derivedBitmapIndex; - int16 creatureFrontBitmapD3PixelCount = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k16_Scale_D3); - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD3PixelCount; + int16 creatureFrontBitmapD3PixelCount = getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k16_Scale_D3); + _derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD3PixelCount; - int16 creatureFrontBitmapD2PixelCount = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k20_Scale_D2); - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD2PixelCount; + int16 creatureFrontBitmapD2PixelCount = getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k20_Scale_D2); + _derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD2PixelCount; if (getFlag(creatureGraphicInfo, k0x0008_CreatureInfoGraphicMaskSide)) { - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthSide, creatureAsp->_heightSide, k16_Scale_D3); - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthSide, creatureAsp->_heightSide, k20_Scale_D2); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(creatureAsp->_byteWidthSide, creatureAsp->_heightSide, k16_Scale_D3); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(creatureAsp->_byteWidthSide, creatureAsp->_heightSide, k20_Scale_D2); } if (getFlag(creatureGraphicInfo, k0x0010_CreatureInfoGraphicMaskBack)) { - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD3PixelCount; - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD2PixelCount; + _derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD3PixelCount; + _derivedBitmapByteCount[derivedBitmapIndex++] = creatureFrontBitmapD2PixelCount; } if (getFlag(creatureGraphicInfo, k0x0020_CreatureInfoGraphicMaskAttack)) { - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthAttack, creatureAsp->_heightAttack, k16_Scale_D3); - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthAttack, creatureAsp->_heightAttack, k20_Scale_D2); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(creatureAsp->_byteWidthAttack, creatureAsp->_heightAttack, k16_Scale_D3); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(creatureAsp->_byteWidthAttack, creatureAsp->_heightAttack, k20_Scale_D2); } int16 additionalFronGraphicCount = getFlag(creatureGraphicInfo, k0x0003_CreatureInfoGraphicMaskAdditional); if (additionalFronGraphicCount) { do { - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = creatureAsp->_byteWidthFront * creatureAsp->_heightFront; - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k16_Scale_D3); - _g639_derivedBitmapByteCount[derivedBitmapIndex++] = f459_getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k20_Scale_D2); + _derivedBitmapByteCount[derivedBitmapIndex++] = creatureAsp->_byteWidthFront * creatureAsp->_heightFront; + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k16_Scale_D3); + _derivedBitmapByteCount[derivedBitmapIndex++] = getScaledBitmapByteCount(creatureAsp->_byteWidthFront, creatureAsp->_heightFront, k20_Scale_D2); } while (--additionalFronGraphicCount); } } } -void DisplayMan::f479_loadGraphics() { +void DisplayMan::loadGraphics() { Common::File f; f.open("graphics.dat"); _grapItemCount = f.readUint16BE(); @@ -668,15 +668,15 @@ void DisplayMan::unpackGraphics() { } _bitmaps = new byte *[575]; // largest graphic indice (i think) _bitmaps[0] = new byte[unpackedBitmapsSize]; - f466_loadIntoBitmap(0, _bitmaps[0]); + loadIntoBitmap(0, _bitmaps[0]); for (uint16 i = 1; i <= 20; ++i) { _bitmaps[i] = _bitmaps[i - 1] + getPixelWidth(i - 1) * getPixelHeight(i - 1); - f466_loadIntoBitmap(i, _bitmaps[i]); + loadIntoBitmap(i, _bitmaps[i]); } _bitmaps[22] = _bitmaps[20] + getPixelWidth(20) * getPixelHeight(20); for (uint16 i = 23; i <= 532; ++i) { _bitmaps[i] = _bitmaps[i - 1] + getPixelWidth(i - 1) * getPixelHeight(i - 1); - f466_loadIntoBitmap(i, _bitmaps[i]); + loadIntoBitmap(i, _bitmaps[i]); } _bitmaps[k557_FontGraphicIndice] = _bitmaps[532] + getPixelWidth(532) * getPixelHeight(532); loadFNT1intoBitmap(k557_FontGraphicIndice, _bitmaps[k557_FontGraphicIndice]); @@ -697,30 +697,30 @@ void DisplayMan::loadFNT1intoBitmap(uint16 index, byte * destBitmap) { } } -void DisplayMan::f461_allocateFlippedWallBitmaps() { - _g90_bitmapWall_D3LCR_Flipped = new byte[128 * 51]; - _g91_bitmapWall_D2LCR_Flipped = new byte[144 * 71]; - _g92_bitmapWall_D1LCR_Flipped = new byte[256 * 111]; - _g93_bitmapWall_D0L_Flipped = new byte[32 * 136]; - _g94_bitmapWall_D0R_Flipped = new byte[32 * 136]; +void DisplayMan::allocateFlippedWallBitmaps() { + _bitmapWallD3LCRFlipped = new byte[128 * 51]; + _bitmapWallD2LCRFlipped = new byte[144 * 71]; + _bitmapWallD1LCRFlipped = new byte[256 * 111]; + _bitmapWallD0LFlipped = new byte[32 * 136]; + _bitmapWallD0RFlipped = new byte[32 * 136]; } -void DisplayMan::f102_drawDoorBitmap(Frame* frame) { +void DisplayMan::drawDoorBitmap(Frame* frame) { if (frame->_srcByteWidth) { - f132_blitToBitmap(_g74_tmpBitmap, _g296_bitmapViewport, frame->_box, frame->_srcX, frame->_srcY, + blitToBitmap(_tmpBitmap, _bitmapViewport, frame->_box, frame->_srcX, frame->_srcY, frame->_srcByteWidth, k112_byteWidthViewport, k10_ColorFlesh, frame->_srcHeight, k136_heightViewport); } } -void DisplayMan::f103_drawDoorFrameBitmapFlippedHorizontally(byte *bitmap, Frame *frame) { +void DisplayMan::drawDoorFrameBitmapFlippedHorizontally(byte *bitmap, Frame *frame) { if (frame->_srcByteWidth) { - f130_flipBitmapHorizontal(bitmap, frame->_srcByteWidth, frame->_srcHeight); - f132_blitToBitmap(bitmap, _g296_bitmapViewport, frame->_box, frame->_srcX, frame->_srcY, + flipBitmapHorizontal(bitmap, frame->_srcByteWidth, frame->_srcHeight); + blitToBitmap(bitmap, _bitmapViewport, frame->_box, frame->_srcX, frame->_srcY, frame->_srcByteWidth, k112_byteWidthViewport, k10_ColorFlesh, frame->_srcHeight, k136_heightViewport); } } -void DisplayMan::f110_drawDoorButton(int16 doorButtonOrdinal, int16 viewDoorButtonIndex) { +void DisplayMan::drawDoorButton(int16 doorButtonOrdinal, int16 viewDoorButtonIndex) { static byte doorButtonCoordSet[1] = {0}; // @ G0197_auc_Graphic558_DoorButtonCoordinateSet static uint16 doorButtonCoordSets[1][4][6] = { // @ G0208_aaauc_Graphic558_DoorButtonCoordinateSets // X1, X2, Y1, Y2, ByteWidth, Height @@ -742,47 +742,47 @@ void DisplayMan::f110_drawDoorButton(int16 doorButtonOrdinal, int16 viewDoorButt byte *bitmap = nullptr; if (viewDoorButtonIndex == k3_viewDoorButton_D1C) { - bitmap = f489_getNativeBitmapOrGraphic(nativeBitmapIndex); + bitmap = getNativeBitmapOrGraphic(nativeBitmapIndex); _vm->_dungeonMan->_dungeonViewClickableBoxes[k5_ViewCellDoorButtonOrWallOrn]._x1 = coordSetRedEagle[0]; _vm->_dungeonMan->_dungeonViewClickableBoxes[k5_ViewCellDoorButtonOrWallOrn]._x2 = coordSetRedEagle[1]; _vm->_dungeonMan->_dungeonViewClickableBoxes[k5_ViewCellDoorButtonOrWallOrn]._y1 = coordSetRedEagle[2]; _vm->_dungeonMan->_dungeonViewClickableBoxes[k5_ViewCellDoorButtonOrWallOrn]._y2 = coordSetRedEagle[3]; } else { - if (!f491_isDerivedBitmapInCache(doorButtonOrdinal = k102_DerivedBitmapFirstDoorButton + (doorButtonOrdinal * 2) + ((!viewDoorButtonIndex) ? 0 : viewDoorButtonIndex - 1))) { + if (!isDerivedBitmapInCache(doorButtonOrdinal = k102_DerivedBitmapFirstDoorButton + (doorButtonOrdinal * 2) + ((!viewDoorButtonIndex) ? 0 : viewDoorButtonIndex - 1))) { uint16 *coordSetBlueGoat = doorButtonCoordSets[coordSet][k3_viewDoorButton_D1C]; - byte *bitmapNative = f489_getNativeBitmapOrGraphic(nativeBitmapIndex); - f129_blitToBitmapShrinkWithPalChange(bitmapNative, f492_getDerivedBitmap(doorButtonOrdinal), + byte *bitmapNative = getNativeBitmapOrGraphic(nativeBitmapIndex); + blitToBitmapShrinkWithPalChange(bitmapNative, getDerivedBitmap(doorButtonOrdinal), coordSetBlueGoat[4] << 1, coordSetBlueGoat[5], // modified code line coordSetRedEagle[4] << 1, coordSetRedEagle[5], (viewDoorButtonIndex == k2_viewDoorButton_D2C) ? _palChangesDoorButtonAndWallOrnD2 : _palChangesDoorButtonAndWallOrnD3); - f493_addDerivedBitmap(doorButtonOrdinal); + addDerivedBitmap(doorButtonOrdinal); } - bitmap = f492_getDerivedBitmap(doorButtonOrdinal); + bitmap = getDerivedBitmap(doorButtonOrdinal); } - f132_blitToBitmap(bitmap, _g296_bitmapViewport, *(Box *)coordSetRedEagle, 0, 0, + blitToBitmap(bitmap, _bitmapViewport, *(Box *)coordSetRedEagle, 0, 0, coordSetRedEagle[4], k112_byteWidthViewport, k10_ColorFlesh, coordSetRedEagle[5], k136_heightViewport); } } -void DisplayMan::f565_viewportSetPalette(uint16* middleScreenPalette, uint16* topAndBottomScreen) { +void DisplayMan::viewportSetPalette(uint16* middleScreenPalette, uint16* topAndBottomScreen) { if (middleScreenPalette && topAndBottomScreen) - f508_buildPaletteChangeCopperList(middleScreenPalette, topAndBottomScreen); + buildPaletteChangeCopperList(middleScreenPalette, topAndBottomScreen); - f566_viewportBlitToScreen(); + viewportBlitToScreen(); } -void DisplayMan::f566_viewportBlitToScreen() { +void DisplayMan::viewportBlitToScreen() { Box box(0, 223, 33, 33 + 135); - f132_blitToBitmap(_g296_bitmapViewport, _g348_bitmapScreen, box, 0, 0, k112_byteWidthViewport, k160_byteWidthScreen, kM1_ColorNoTransparency, + blitToBitmap(_bitmapViewport, _bitmapScreen, box, 0, 0, k112_byteWidthViewport, k160_byteWidthScreen, kM1_ColorNoTransparency, k136_heightViewport, k200_heightScreen); } -void DisplayMan::f466_loadIntoBitmap(uint16 index, byte *destBitmap) { +void DisplayMan::loadIntoBitmap(uint16 index, byte *destBitmap) { uint8 *data = _packedBitmaps + _packedItemPos[index]; uint16 width = READ_BE_UINT16(data); @@ -832,7 +832,7 @@ void DisplayMan::f466_loadIntoBitmap(uint16 index, byte *destBitmap) { } } -void DisplayMan::f132_blitToBitmap(byte *srcBitmap, byte *destBitmap, Box &box, uint16 srcX, uint16 srcY, uint16 srcByteWidth, +void DisplayMan::blitToBitmap(byte *srcBitmap, byte *destBitmap, Box &box, uint16 srcX, uint16 srcY, uint16 srcByteWidth, uint16 destByteWidth, Color transparent, int16 srcHeight, int16 destHight) { uint16 srcWidth = srcByteWidth * 2; uint16 destWidth = destByteWidth * 2; @@ -848,18 +848,18 @@ void DisplayMan::f132_blitToBitmap(byte *srcBitmap, byte *destBitmap, Box &box, } } -void DisplayMan::D24_fillScreenBox(Box &box, Color color) { +void DisplayMan::fillScreenBox(Box &box, Color color) { uint16 width = box._x2 + 1 - box._x1; // + 1 for inclusive boundaries for (int16 y = box._y1; y < box._y2 + 1; ++y) // + 1 for inclusive boundaries - memset(_g348_bitmapScreen + y * _screenWidth + box._x1, color, sizeof(byte) * width); + memset(_bitmapScreen + y * _screenWidth + box._x1, color, sizeof(byte) * width); } -void DisplayMan::f135_fillBoxBitmap(byte *destBitmap, Box &box, Color color, int16 byteWidth, int16 height) { +void DisplayMan::fillBoxBitmap(byte *destBitmap, Box &box, Color color, int16 byteWidth, int16 height) { for (int16 y = box._y1; y < box._y2 + 1; ++y) // + 1 for inclusive boundaries memset(destBitmap + y * byteWidth * 2 + box._x1, color, sizeof(byte) * (box._x2 - box._x1 + 1)); // + 1 for inclusive boundaries } -void DisplayMan::f133_blitBoxFilledWithMaskedBitmap(byte *src, byte *dest, byte *mask, byte *tmp, Box& box, +void DisplayMan::blitBoxFilledWithMaskedBitmap(byte *src, byte *dest, byte *mask, byte *tmp, Box& box, int16 lastUnitIndex, int16 firstUnitIndex, int16 destByteWidth, Color transparent, int16 xPos, int16 yPos, int16 destHeight, int16 height2) { // make sure to take care of inclusive boundaries, color can have 0x8000 flag to not use mask @@ -868,7 +868,7 @@ void DisplayMan::f133_blitBoxFilledWithMaskedBitmap(byte *src, byte *dest, byte -void DisplayMan::f130_flipBitmapHorizontal(byte *bitmap, uint16 byteWidth, uint16 height) { +void DisplayMan::flipBitmapHorizontal(byte *bitmap, uint16 byteWidth, uint16 height) { uint16 width = byteWidth * 2; for (uint16 y = 0; y < height; ++y) { for (uint16 x = 0; x < width / 2; ++x) @@ -876,7 +876,7 @@ void DisplayMan::f130_flipBitmapHorizontal(byte *bitmap, uint16 byteWidth, uint1 } } -void DisplayMan::f131_flipVertical(byte *bitmap, uint16 byteWidth, uint16 height) { +void DisplayMan::flipBitmapVertical(byte *bitmap, uint16 byteWidth, uint16 height) { uint16 width = byteWidth * 2; byte *tmp = new byte[width]; @@ -889,24 +889,24 @@ void DisplayMan::f131_flipVertical(byte *bitmap, uint16 byteWidth, uint16 height delete[] tmp; } -byte *DisplayMan::f114_getExplosionBitmap(uint16 explosionAspIndex, uint16 scale, int16& returnByteWidth, int16& returnHeight) { +byte *DisplayMan::getExplosionBitmap(uint16 explosionAspIndex, uint16 scale, int16& returnByteWidth, int16& returnHeight) { ExplosionAspect *explAsp = &_explosionAspects[explosionAspIndex]; if (scale > 32) scale = 32; - int16 pixelWidth = M78_getScaledDimension(explAsp->_byteWidth, scale); - int16 height = M78_getScaledDimension(explAsp->_height, scale); + int16 pixelWidth = getScaledDimension(explAsp->_byteWidth, scale); + int16 height = getScaledDimension(explAsp->_height, scale); byte *bitmap; int16 derBitmapIndex = (explosionAspIndex * 14) + scale / 2 + k438_DerivedBitmapFirstExplosion - 2; if ((scale == 32) && (explosionAspIndex != k3_ExplosionAspectSmoke)) - bitmap = f489_getNativeBitmapOrGraphic(explosionAspIndex + k348_FirstExplosionGraphicIndice); - else if (f491_isDerivedBitmapInCache(derBitmapIndex)) - bitmap = f492_getDerivedBitmap(derBitmapIndex); + bitmap = getNativeBitmapOrGraphic(explosionAspIndex + k348_FirstExplosionGraphicIndice); + else if (isDerivedBitmapInCache(derBitmapIndex)) + bitmap = getDerivedBitmap(derBitmapIndex); else { - byte *nativeBitmap = f489_getNativeBitmapOrGraphic(MIN(explosionAspIndex, (uint16)k2_ExplosionAspectPoison) + k348_FirstExplosionGraphicIndice); - bitmap = f492_getDerivedBitmap(derBitmapIndex); - f129_blitToBitmapShrinkWithPalChange(nativeBitmap, bitmap, explAsp->_byteWidth, explAsp->_height, pixelWidth * 2, height, + byte *nativeBitmap = getNativeBitmapOrGraphic(MIN(explosionAspIndex, (uint16)k2_ExplosionAspectPoison) + k348_FirstExplosionGraphicIndice); + bitmap = getDerivedBitmap(derBitmapIndex); + blitToBitmapShrinkWithPalChange(nativeBitmap, bitmap, explAsp->_byteWidth, explAsp->_height, pixelWidth * 2, height, (explosionAspIndex == k3_ExplosionAspectSmoke) ? _palChangeSmoke : _palChangesNoChanges); - f493_addDerivedBitmap(derBitmapIndex); + addDerivedBitmap(derBitmapIndex); } returnByteWidth = pixelWidth; @@ -917,46 +917,46 @@ byte *DisplayMan::f114_getExplosionBitmap(uint16 explosionAspIndex, uint16 scale void DisplayMan::updateScreen() { // apply copper for (uint32 i = 320 * 30; i < 320 * 170; ++i) - _g348_bitmapScreen[i] += 16; - _vm->_system->copyRectToScreen(_g348_bitmapScreen, _screenWidth, 0, 0, _screenWidth, _screenHeight); + _bitmapScreen[i] += 16; + _vm->_system->copyRectToScreen(_bitmapScreen, _screenWidth, 0, 0, _screenWidth, _screenHeight); _vm->_console->onFrame(); _vm->_system->updateScreen(); for (uint32 i = 320 * 30; i < 320 * 170; ++i) - _g348_bitmapScreen[i] -= 16; + _bitmapScreen[i] -= 16; } -void DisplayMan::f97_drawViewport(int16 palSwitchingRequestedState) { +void DisplayMan::drawViewport(int16 palSwitchingRequestedState) { static uint16 *dungeonViewCurrentPalette; // @ K0010_pui_DungeonViewCurrentPalette // ignored code F0510_AMIGA_WaitBottomOfViewPort if (palSwitchingRequestedState == k2_viewportAsBeforeSleepOrFreezeGame) - palSwitchingRequestedState = _g322_paletteSwitchingEnabled ? 1 : 0; + palSwitchingRequestedState = _paletteSwitchingEnabled ? 1 : 0; - if (_g342_refreshDungeonViewPaleteRequested) { - dungeonViewCurrentPalette = _palDungeonView[_g304_dungeonViewPaletteIndex]; - _g342_refreshDungeonViewPaleteRequested = false; + if (_refreshDungeonViewPaleteRequested) { + dungeonViewCurrentPalette = _palDungeonView[_dungeonViewPaletteIndex]; + _refreshDungeonViewPaleteRequested = false; if (palSwitchingRequestedState == k0_viewportNotDungeonView) - _g322_paletteSwitchingEnabled = true; + _paletteSwitchingEnabled = true; else - _g322_paletteSwitchingEnabled = false; + _paletteSwitchingEnabled = false; } - if (palSwitchingRequestedState != (_g322_paletteSwitchingEnabled ? 1 : 0)) { + if (palSwitchingRequestedState != (_paletteSwitchingEnabled ? 1 : 0)) { if (palSwitchingRequestedState) { - f565_viewportSetPalette(dungeonViewCurrentPalette, _g347_paletteTopAndBottomScreen); - _g322_paletteSwitchingEnabled = true; + viewportSetPalette(dungeonViewCurrentPalette, _paletteTopAndBottomScreen); + _paletteSwitchingEnabled = true; } else { - f565_viewportSetPalette(_g347_paletteTopAndBottomScreen, _g347_paletteTopAndBottomScreen); - _g322_paletteSwitchingEnabled = false; + viewportSetPalette(_paletteTopAndBottomScreen, _paletteTopAndBottomScreen); + _paletteSwitchingEnabled = false; } } else - f565_viewportSetPalette(nullptr, nullptr); + viewportSetPalette(nullptr, nullptr); updateScreen(); } byte *DisplayMan::getCurrentVgaBuffer() { - return _g348_bitmapScreen; + return _bitmapScreen; } uint16 DisplayMan::getPixelWidth(uint16 index) { @@ -969,12 +969,12 @@ uint16 DisplayMan::getPixelHeight(uint16 index) { return READ_BE_UINT16(data + 2); } -void DisplayMan::f99_copyBitmapAndFlipHorizontal(byte *srcBitmap, byte *destBitmap, uint16 byteWidth, uint16 height) { +void DisplayMan::copyBitmapAndFlipHorizontal(byte *srcBitmap, byte *destBitmap, uint16 byteWidth, uint16 height) { memmove(destBitmap, srcBitmap, byteWidth * 2 * height * sizeof(byte)); - f130_flipBitmapHorizontal(destBitmap, byteWidth, height); + flipBitmapHorizontal(destBitmap, byteWidth, height); } -void DisplayMan::f108_drawFloorOrnament(uint16 floorOrnOrdinal, uint16 viewFloorIndex) { +void DisplayMan::drawFloorOrnament(uint16 floorOrnOrdinal, uint16 viewFloorIndex) { static byte g191_floorOrnNativeBitmapndexInc[9] = { // @ G0191_auc_Graphic558_FloorOrnamentNativeBitmapIndexIncrements 0, /* D3L */ 1, /* D3C */ @@ -1031,63 +1031,63 @@ void DisplayMan::f108_drawFloorOrnament(uint16 floorOrnOrdinal, uint16 viewFloor if (!drawFootprints || clearFlag(floorOrnOrdinal, k0x8000_FootprintsAspect)) { floorOrnOrdinal--; uint16 floorOrnIndex = floorOrnOrdinal; - int16 nativeBitmapIndex = _g102_currMapFloorOrnInfo[floorOrnIndex][k0_NativeBitmapIndex] + int16 nativeBitmapIndex = _currMapFloorOrnInfo[floorOrnIndex][k0_NativeBitmapIndex] + g191_floorOrnNativeBitmapndexInc[viewFloorIndex]; - uint16 *coordSets = g206_floorOrnCoordSets[_g102_currMapFloorOrnInfo[floorOrnIndex][k1_CoordinateSet]][viewFloorIndex]; + uint16 *coordSets = g206_floorOrnCoordSets[_currMapFloorOrnInfo[floorOrnIndex][k1_CoordinateSet]][viewFloorIndex]; if ((viewFloorIndex == k8_viewFloor_D1R) || (viewFloorIndex == k5_viewFloor_D2R) || (viewFloorIndex == k2_viewFloor_D3R) - || ((floorOrnIndex == k15_FloorOrnFootprints) && _g76_useFlippedWallAndFootprintsBitmap && + || ((floorOrnIndex == k15_FloorOrnFootprints) && _useFlippedWallAndFootprintsBitmap && ((viewFloorIndex == k7_viewFloor_D1C) || (viewFloorIndex == k4_viewFloor_D2C) || (viewFloorIndex == k1_viewFloor_D3C)))) { - bitmap = _g74_tmpBitmap; - f99_copyBitmapAndFlipHorizontal(f489_getNativeBitmapOrGraphic(nativeBitmapIndex), bitmap, coordSets[4], coordSets[5]); + bitmap = _tmpBitmap; + copyBitmapAndFlipHorizontal(getNativeBitmapOrGraphic(nativeBitmapIndex), bitmap, coordSets[4], coordSets[5]); } else - bitmap = f489_getNativeBitmapOrGraphic(nativeBitmapIndex); + bitmap = getNativeBitmapOrGraphic(nativeBitmapIndex); - f132_blitToBitmap(bitmap, _g296_bitmapViewport, + blitToBitmap(bitmap, _bitmapViewport, *(Box *)coordSets, 0, 0, coordSets[4], k112_byteWidthViewport, k10_ColorFlesh, coordSets[5], k136_heightViewport); } if (drawFootprints) - f108_drawFloorOrnament(_vm->indexToOrdinal(k15_FloorOrnFootprints), viewFloorIndex); + drawFloorOrnament(_vm->indexToOrdinal(k15_FloorOrnFootprints), viewFloorIndex); } -void DisplayMan::f111_drawDoor(uint16 doorThingIndex, uint16 doorState, int16* doorNativeBitmapIndices, int16 byteCount, int16 viewDoorOrnIndex, DoorFrames* doorFrames) { +void DisplayMan::drawDoor(uint16 doorThingIndex, uint16 doorState, int16* doorNativeBitmapIndices, int16 byteCount, int16 viewDoorOrnIndex, DoorFrames* doorFrames) { if (doorState == k0_doorState_OPEN) return; DoorFrames *doorFramesTemp = doorFrames; Door *door = (Door *)(_vm->_dungeonMan->_thingData[k0_DoorThingType]) + doorThingIndex; uint16 doorType = door->getType(); - memmove(_g74_tmpBitmap, f489_getNativeBitmapOrGraphic(doorNativeBitmapIndices[doorType]), byteCount * 2); - f109_drawDoorOrnament(door->getOrnOrdinal(), viewDoorOrnIndex); + memmove(_tmpBitmap, getNativeBitmapOrGraphic(doorNativeBitmapIndices[doorType]), byteCount * 2); + drawDoorOrnament(door->getOrnOrdinal(), viewDoorOrnIndex); if (getFlag(_vm->_dungeonMan->_currMapDoorInfo[doorType]._attributes, k0x0004_MaskDoorInfo_Animated)) { if (_vm->getRandomNumber(2)) - f130_flipBitmapHorizontal(_g74_tmpBitmap, doorFramesTemp->_closedOrDestroyed._srcByteWidth, doorFramesTemp->_closedOrDestroyed._srcHeight); + flipBitmapHorizontal(_tmpBitmap, doorFramesTemp->_closedOrDestroyed._srcByteWidth, doorFramesTemp->_closedOrDestroyed._srcHeight); if (_vm->getRandomNumber(2)) - f131_flipVertical(_g74_tmpBitmap, doorFramesTemp->_closedOrDestroyed._srcByteWidth, doorFramesTemp->_closedOrDestroyed._srcHeight); + flipBitmapVertical(_tmpBitmap, doorFramesTemp->_closedOrDestroyed._srcByteWidth, doorFramesTemp->_closedOrDestroyed._srcHeight); } if ((doorFramesTemp == _doorFrameD1C) && _vm->_championMan->_party._event73Count_ThievesEye) - f109_drawDoorOrnament(_vm->indexToOrdinal(k16_DoorOrnThivesEyeMask), k2_ViewDoorOrnament_D1LCR); + drawDoorOrnament(_vm->indexToOrdinal(k16_DoorOrnThivesEyeMask), k2_ViewDoorOrnament_D1LCR); if (doorState == k4_doorState_CLOSED) - f102_drawDoorBitmap(&doorFramesTemp->_closedOrDestroyed); + drawDoorBitmap(&doorFramesTemp->_closedOrDestroyed); else if (doorState == k5_doorState_DESTROYED) { - f109_drawDoorOrnament(_vm->indexToOrdinal(k15_DoorOrnDestroyedMask), viewDoorOrnIndex); - f102_drawDoorBitmap(&doorFramesTemp->_closedOrDestroyed); + drawDoorOrnament(_vm->indexToOrdinal(k15_DoorOrnDestroyedMask), viewDoorOrnIndex); + drawDoorBitmap(&doorFramesTemp->_closedOrDestroyed); } else { doorState--; if (door->opensVertically()) - f102_drawDoorBitmap(&doorFramesTemp->_vertical[doorState]); + drawDoorBitmap(&doorFramesTemp->_vertical[doorState]); else { - f102_drawDoorBitmap(&doorFramesTemp->_leftHorizontal[doorState]); - f102_drawDoorBitmap(&doorFramesTemp->_rightHorizontal[doorState]); + drawDoorBitmap(&doorFramesTemp->_leftHorizontal[doorState]); + drawDoorBitmap(&doorFramesTemp->_rightHorizontal[doorState]); } } } -void DisplayMan::f109_drawDoorOrnament(int16 doorOrnOrdinal, int16 viewDoorOrnIndex) { +void DisplayMan::drawDoorOrnament(int16 doorOrnOrdinal, int16 viewDoorOrnIndex) { static byte palChangesDoorOrnD3[16] = {0, 120, 10, 30, 40, 30, 0, 60, 30, 90, 100, 110, 0, 20, 0, 130}; // @ G0200_auc_Graphic558_PaletteChanges_DoorOrnament_D3 static byte palChangesDoorOrnd2[16] = {0, 10, 20, 30, 40, 30, 60, 70, 50, 90, 100, 110, 120, 130, 140, 150}; // @ G0201_auc_Graphic558_PaletteChanges_DoorOrnament_D2 static uint16 doorOrnCoordSets[4][3][6] = { // @ G0207_aaauc_Graphic558_DoorOrnamentCoordinateSets @@ -1122,23 +1122,23 @@ void DisplayMan::f109_drawDoorOrnament(int16 doorOrnOrdinal, int16 viewDoorOrnIn int16 byteWidth = viewDoorOrnIndex; height--; - int16 nativeBitmapIndex = _g103_currMapDoorOrnInfo[height][k0_NativeBitmapIndex]; - int16 coordSetGreenToad = _g103_currMapDoorOrnInfo[height][k1_CoordinateSet]; + int16 nativeBitmapIndex = _currMapDoorOrnInfo[height][k0_NativeBitmapIndex]; + int16 coordSetGreenToad = _currMapDoorOrnInfo[height][k1_CoordinateSet]; uint16 *coordSetOrangeElk = &doorOrnCoordSets[coordSetGreenToad][byteWidth][0]; byte *blitBitmap; if (byteWidth == k2_ViewDoorOrnament_D1LCR) { - blitBitmap = f489_getNativeBitmapOrGraphic(nativeBitmapIndex); + blitBitmap = getNativeBitmapOrGraphic(nativeBitmapIndex); byteWidth = k48_byteWidth; height = 88; } else { height = k68_DerivedBitmapFirstDoorOrnament_D3 + (height * 2) + byteWidth; - if (!f491_isDerivedBitmapInCache(height)) { + if (!isDerivedBitmapInCache(height)) { uint16 *coordSetRedEagle = &doorOrnCoordSets[coordSetGreenToad][k2_ViewDoorOrnament_D1LCR][0]; - byte *nativeBitmap = f489_getNativeBitmapOrGraphic(nativeBitmapIndex); - f129_blitToBitmapShrinkWithPalChange(nativeBitmap, f492_getDerivedBitmap(height), coordSetRedEagle[4] << 1, coordSetRedEagle[5], coordSetOrangeElk[1] - coordSetOrangeElk[0] + 1, coordSetOrangeElk[5], (byteWidth == k0_ViewDoorOrnament_D3LCR) ? palChangesDoorOrnD3 : palChangesDoorOrnd2); - f493_addDerivedBitmap(height); + byte *nativeBitmap = getNativeBitmapOrGraphic(nativeBitmapIndex); + blitToBitmapShrinkWithPalChange(nativeBitmap, getDerivedBitmap(height), coordSetRedEagle[4] << 1, coordSetRedEagle[5], coordSetOrangeElk[1] - coordSetOrangeElk[0] + 1, coordSetOrangeElk[5], (byteWidth == k0_ViewDoorOrnament_D3LCR) ? palChangesDoorOrnD3 : palChangesDoorOrnd2); + addDerivedBitmap(height); } - blitBitmap = f492_getDerivedBitmap(height); + blitBitmap = getDerivedBitmap(height); if (byteWidth == k0_ViewDoorOrnament_D3LCR) { byteWidth = k24_byteWidth; height = 41; @@ -1149,10 +1149,10 @@ void DisplayMan::f109_drawDoorOrnament(int16 doorOrnOrdinal, int16 viewDoorOrnIn } Box box(coordSetOrangeElk[0], coordSetOrangeElk[1], coordSetOrangeElk[2], coordSetOrangeElk[3]); - f132_blitToBitmap(blitBitmap, _g74_tmpBitmap, box, 0, 0, coordSetOrangeElk[4], byteWidth, k9_ColorGold, coordSetOrangeElk[5], height); + blitToBitmap(blitBitmap, _tmpBitmap, box, 0, 0, coordSetOrangeElk[4], byteWidth, k9_ColorGold, coordSetOrangeElk[5], height); } -void DisplayMan::f112_drawCeilingPit(int16 nativeBitmapIndex, Frame *frame, int16 mapX, int16 mapY, bool flipHorizontal) { +void DisplayMan::drawCeilingPit(int16 nativeBitmapIndex, Frame *frame, int16 mapX, int16 mapY, bool flipHorizontal) { int16 mapIndex = _vm->_dungeonMan->getLocationAfterLevelChange(_vm->_dungeonMan->_currMapIndex, -1, &mapX, &mapY); if (mapIndex < 0) @@ -1161,47 +1161,47 @@ void DisplayMan::f112_drawCeilingPit(int16 nativeBitmapIndex, Frame *frame, int1 int16 mapSquare = _vm->_dungeonMan->_dungeonMapData[mapIndex][mapX][mapY]; if ((Square(mapSquare).getType() == k2_PitElemType) && getFlag(mapSquare, k0x0008_PitOpen)) { if (flipHorizontal) - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(nativeBitmapIndex, *frame); + drawFloorPitOrStairsBitmapFlippedHorizontally(nativeBitmapIndex, *frame); else - f104_drawFloorPitOrStairsBitmap(nativeBitmapIndex, *frame); + drawFloorPitOrStairsBitmap(nativeBitmapIndex, *frame); } } -void DisplayMan::f20_blitToViewport(byte *bitmap, Box& box, int16 byteWidth, Color transparent, int16 height) { - f132_blitToBitmap(bitmap, _g296_bitmapViewport, box, 0, 0, byteWidth, k112_byteWidthViewport, transparent, height, k136_heightViewport); +void DisplayMan::blitToViewport(byte *bitmap, Box& box, int16 byteWidth, Color transparent, int16 height) { + blitToBitmap(bitmap, _bitmapViewport, box, 0, 0, byteWidth, k112_byteWidthViewport, transparent, height, k136_heightViewport); } -void DisplayMan::f20_blitToViewport(byte *bitmap, int16 *box, int16 byteWidth, Color transparent, int16 height) { +void DisplayMan::blitToViewport(byte *bitmap, int16 *box, int16 byteWidth, Color transparent, int16 height) { Box actualBox(box[0], box[1], box[2], box[3]); - f20_blitToViewport(bitmap, actualBox, byteWidth, transparent, height); + blitToViewport(bitmap, actualBox, byteWidth, transparent, height); } -void DisplayMan::f21_blitToScreen(byte *bitmap, int16 *box, int16 byteWidth, Color transparent, int16 height) { +void DisplayMan::blitToScreen(byte *bitmap, int16 *box, int16 byteWidth, Color transparent, int16 height) { Box actualBox(box[0], box[1], box[2], box[3]); - f21_blitToScreen(bitmap, &actualBox, byteWidth, transparent, height); + blitToScreen(bitmap, &actualBox, byteWidth, transparent, height); } -void DisplayMan::f21_blitToScreen(byte *bitmap, Box *box, int16 byteWidth, Color transparent, int16 height) { - _g578_useByteBoxCoordinates = false; - f132_blitToBitmap(bitmap, _g348_bitmapScreen, *box, 0, 0, byteWidth, k160_byteWidthScreen, transparent, height, k200_heightScreen); +void DisplayMan::blitToScreen(byte *bitmap, Box *box, int16 byteWidth, Color transparent, int16 height) { + _useByteBoxCoordinates = false; + blitToBitmap(bitmap, _bitmapScreen, *box, 0, 0, byteWidth, k160_byteWidthScreen, transparent, height, k200_heightScreen); } -void DisplayMan::f101_drawWallSetBitmapWithoutTransparency(byte *bitmap, Frame &f) { +void DisplayMan::drawWallSetBitmapWithoutTransparency(byte *bitmap, Frame &f) { if (!f._srcByteWidth) return; - f132_blitToBitmap(bitmap, _g296_bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, k112_byteWidthViewport, kM1_ColorNoTransparency, f._srcHeight, k136_heightViewport); + blitToBitmap(bitmap, _bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, k112_byteWidthViewport, kM1_ColorNoTransparency, f._srcHeight, k136_heightViewport); } -void DisplayMan::f100_drawWallSetBitmap(byte *bitmap, Frame &f) { +void DisplayMan::drawWallSetBitmap(byte *bitmap, Frame &f) { if (!f._srcByteWidth) return; - f132_blitToBitmap(bitmap, _g296_bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, k112_byteWidthViewport, k10_ColorFlesh, f._srcHeight, k136_heightViewport); + blitToBitmap(bitmap, _bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, k112_byteWidthViewport, k10_ColorFlesh, f._srcHeight, k136_heightViewport); } -void DisplayMan::f116_drawSquareD3L(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD3L(Direction dir, int16 posX, int16 posY) { static Frame doorFrameLeftD3L = Frame(0, 31, 28, 70, 16, 43, 0, 0); // @ G0164_s_Graphic558_Frame_DoorFrameLeft_D3L static Frame frameStairsUpFrontD3L = Frame(0, 79, 25, 70, 40, 46, 0, 0); // @ G0110_s_Graphic558_Frame_StairsUpFront_D3L static Frame frameStairsDownFrontD3L = Frame(0, 79, 28, 68, 40, 41, 0, 0); // @ G0121_s_Graphic558_Frame_StairsDownFront_D3L @@ -1227,17 +1227,17 @@ void DisplayMan::f116_drawSquareD3L(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_StairsFrontElemType: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g675_stairsNativeBitmapIndex_Up_Front_D3L, frameStairsUpFrontD3L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD3L, frameStairsUpFrontD3L); else - f104_drawFloorPitOrStairsBitmap(_g682_stairsNativeBitmapIndex_Down_Front_D3L, frameStairsDownFrontD3L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD3L, frameStairsDownFrontD3L); order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); break; case k0_WallElemType: - f100_drawWallSetBitmap(_g698_bitmapWallSet_Wall_D3LCR, _frameWalls163[k1_ViewSquare_D3L]); - f107_isDrawnWallOrnAnAlcove(squareAspect[k2_RightWallOrnOrdAspect], k0_ViewWall_D3L_RIGHT); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k2_ViewWall_D3L_FRONT)) + drawWallSetBitmap(_bitmapWallSetD3LCR, _frameWalls163[k1_ViewSquare_D3L]); + isDrawnWallOrnAnAlcove(squareAspect[k2_RightWallOrnOrdAspect], k0_ViewWall_D3L_RIGHT); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k2_ViewWall_D3L_FRONT)) order = k0x0000_CellOrder_Alcove; else return; @@ -1246,25 +1246,25 @@ void DisplayMan::f116_drawSquareD3L(Direction dir, int16 posX, int16 posY) { case k18_ElementTypeStairsSide: order = k0x0321_CellOrder_BackLeft_BackRight_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); break; case k17_ElementTypeDoorFront: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k1_ViewSquare_D3L, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); - f100_drawWallSetBitmap(_g705_bitmapWallSet_DoorFrameLeft_D3L, doorFrameLeftD3L); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g693_doorNativeBitmapIndex_Front_D3LCR, bitmapByteCount(48, 41), k0_ViewDoorOrnament_D3LCR, &doorFrameD3L); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k1_ViewSquare_D3L, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); + drawWallSetBitmap(_bitmapWallSetDoorFrameLeftD3L, doorFrameLeftD3L); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD3LCR, bitmapByteCount(48, 41), k0_ViewDoorOrnament_D3LCR, &doorFrameD3L); order = k0x0349_CellOrder_DoorPass2_FrontLeft_FrontRight; break; case k2_ElementTypePit: if (!squareAspect[k2_PitInvisibleAspect]) - f104_drawFloorPitOrStairsBitmap(k49_FloorPit_D3L_GraphicIndice, frameFloorPitD3L); + drawFloorPitOrStairsBitmap(k49_FloorPit_D3L_GraphicIndice, frameFloorPitD3L); // no break on purpose case k5_ElementTypeTeleporter: case k1_ElementTypeCorridor: order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k0_viewFloor_D3L); break; default: skip = true; @@ -1272,13 +1272,13 @@ void DisplayMan::f116_drawSquareD3L(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k1_ViewSquare_D3L, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k1_ViewSquare_D3L, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k1_ViewSquare_D3L], _frameWalls163[k1_ViewSquare_D3L]._box); + drawField(&_fieldAspects188[k1_ViewSquare_D3L], _frameWalls163[k1_ViewSquare_D3L]._box); } -void DisplayMan::f117_drawSquareD3R(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD3R(Direction dir, int16 posX, int16 posY) { static Frame doorFrameRightD3R = Frame(192, 223, 28, 70, 16, 43, 0, 0); // @ G0165_s_Graphic558_Frame_DoorFrameRight_D3R static Frame frameStairsUpFrontD3R = Frame(149, 223, 25, 70, 40, 46, 5, 0); // @ G0112_s_Graphic558_Frame_StairsUpFront_D3R static Frame frameStairsDownFrontD3R = Frame(149, 223, 28, 68, 40, 41, 5, 0); // @ G0123_s_Graphic558_Frame_StairsDownFront_D3R @@ -1305,18 +1305,18 @@ void DisplayMan::f117_drawSquareD3R(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g675_stairsNativeBitmapIndex_Up_Front_D3L, frameStairsUpFrontD3R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexUpFrontD3L, frameStairsUpFrontD3R); else - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g682_stairsNativeBitmapIndex_Down_Front_D3L, frameStairsDownFrontD3R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexDownFrontD3L, frameStairsDownFrontD3R); order = k0x4312_CellOrder_BackRight_BackLeft_FrontRight_FrontLeft; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); break; case k0_ElementTypeWall: - f100_drawWallSetBitmap(_g698_bitmapWallSet_Wall_D3LCR, _frameWalls163[k2_ViewSquare_D3R]); - f107_isDrawnWallOrnAnAlcove(squareAspect[k4_LeftWallOrnOrdAspect], k1_ViewWall_D3R_LEFT); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k4_ViewWall_D3R_FRONT)) + drawWallSetBitmap(_bitmapWallSetD3LCR, _frameWalls163[k2_ViewSquare_D3R]); + isDrawnWallOrnAnAlcove(squareAspect[k4_LeftWallOrnOrdAspect], k1_ViewWall_D3R_LEFT); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k4_ViewWall_D3R_FRONT)) order = k0x0000_CellOrder_Alcove; else return; @@ -1325,29 +1325,29 @@ void DisplayMan::f117_drawSquareD3R(Direction dir, int16 posX, int16 posY) { case k18_ElementTypeStairsSide: order = k0x0412_CellOrder_BackRight_BackLeft_FrontLeft; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); break; case k17_ElementTypeDoorFront: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k2_ViewSquare_D3R, k0x0128_CellOrder_DoorPass1_BackRight_BackLeft); - memmove(_g74_tmpBitmap, _g705_bitmapWallSet_DoorFrameLeft_D3L, 32 * 44); - f103_drawDoorFrameBitmapFlippedHorizontally(_g74_tmpBitmap, &doorFrameRightD3R); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k2_ViewSquare_D3R, k0x0128_CellOrder_DoorPass1_BackRight_BackLeft); + memmove(_tmpBitmap, _bitmapWallSetDoorFrameLeftD3L, 32 * 44); + drawDoorFrameBitmapFlippedHorizontally(_tmpBitmap, &doorFrameRightD3R); if (((Door *)_vm->_dungeonMan->_thingData[k0_DoorThingType])[squareAspect[k3_DoorThingIndexAspect]].hasButton()) - f110_drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k0_viewDoorButton_D3R); + drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k0_viewDoorButton_D3R); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], - squareAspect[k2_DoorStateAspect], _g693_doorNativeBitmapIndex_Front_D3LCR, + drawDoor(squareAspect[k3_DoorThingIndexAspect], + squareAspect[k2_DoorStateAspect], _doorNativeBitmapIndexFrontD3LCR, bitmapByteCount(48, 41), k0_ViewDoorOrnament_D3LCR, &doorFrameD3R); break;; case k2_ElementTypePit: if (!squareAspect[k2_PitInvisibleAspect]) - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(k49_FloorPit_D3L_GraphicIndice, frameFloorPitD3R); + drawFloorPitOrStairsBitmapFlippedHorizontally(k49_FloorPit_D3L_GraphicIndice, frameFloorPitD3R); // No break on purpose case k5_ElementTypeTeleporter: case k1_ElementTypeCorridor: order = k0x4312_CellOrder_BackRight_BackLeft_FrontRight_FrontLeft; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k2_viewFloor_D3R); break; default: skip = true; @@ -1355,13 +1355,13 @@ void DisplayMan::f117_drawSquareD3R(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k2_ViewSquare_D3R, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k2_ViewSquare_D3R, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k2_ViewSquare_D3R], _frameWalls163[k2_ViewSquare_D3R]._box); + drawField(&_fieldAspects188[k2_ViewSquare_D3R], _frameWalls163[k2_ViewSquare_D3R]._box); } -void DisplayMan::f118_drawSquareD3C(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD3C(Direction dir, int16 posX, int16 posY) { static Frame doorFrameLeftD3C = Frame(64, 95, 27, 70, 16, 44, 0, 0); // @ G0166_s_Graphic558_Frame_DoorFrameLeft_D3C static Frame doorFrameRightD3C = Frame(128, 159, 27, 70, 16, 44, 0, 0); // @ G0167_s_Graphic558_Frame_DoorFrameRight_D3C static Frame frameStairsUpFrontD3C = Frame(64, 159, 25, 70, 48, 46, 0, 0); // @ G0111_s_Graphic558_Frame_StairsUpFront_D3C @@ -1389,42 +1389,42 @@ void DisplayMan::f118_drawSquareD3C(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g676_stairsNativeBitmapIndex_Up_Front_D3C, frameStairsUpFrontD3C); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD3C, frameStairsUpFrontD3C); else - f104_drawFloorPitOrStairsBitmap(_g683_stairsNativeBitmapIndex_Down_Front_D3C, frameStairsDownFrontD3C); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD3C, frameStairsDownFrontD3C); order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k1_viewFloor_D3C); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k1_viewFloor_D3C); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ break; case k0_ElementTypeWall: - f101_drawWallSetBitmapWithoutTransparency(_g698_bitmapWallSet_Wall_D3LCR, _frameWalls163[k0_ViewSquare_D3C]); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k3_ViewWall_D3C_FRONT)) + drawWallSetBitmapWithoutTransparency(_bitmapWallSetD3LCR, _frameWalls163[k0_ViewSquare_D3C]); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k3_ViewWall_D3C_FRONT)) order = k0x0000_CellOrder_Alcove; else return; break; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k1_viewFloor_D3C); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k0_ViewSquare_D3C, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); - f100_drawWallSetBitmap(_g706_bitmapWallSet_DoorFrameLeft_D3C, doorFrameLeftD3C); - memmove(_g74_tmpBitmap, _g706_bitmapWallSet_DoorFrameLeft_D3C, 32 * 44); - f103_drawDoorFrameBitmapFlippedHorizontally(_g74_tmpBitmap, &doorFrameRightD3C); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k1_viewFloor_D3C); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k0_ViewSquare_D3C, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); + drawWallSetBitmap(_bitmapWallSetDoorFrameLeftD3C, doorFrameLeftD3C); + memmove(_tmpBitmap, _bitmapWallSetDoorFrameLeftD3C, 32 * 44); + drawDoorFrameBitmapFlippedHorizontally(_tmpBitmap, &doorFrameRightD3C); if (((Door *)_vm->_dungeonMan->_thingData[k0_DoorThingType])[squareAspect[k3_DoorThingIndexAspect]].hasButton()) - f110_drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k1_ViewDoorOrnament_D2LCR); + drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k1_ViewDoorOrnament_D2LCR); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g693_doorNativeBitmapIndex_Front_D3LCR, bitmapByteCount(48, 41), k0_ViewDoorOrnament_D3LCR, &doorFrameD3C); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD3LCR, bitmapByteCount(48, 41), k0_ViewDoorOrnament_D3LCR, &doorFrameD3C); order = k0x0349_CellOrder_DoorPass2_FrontLeft_FrontRight; break; case k2_ElementTypePit: if (!squareAspect[k2_PitInvisibleAspect]) - f104_drawFloorPitOrStairsBitmap(k50_FloorPit_D3C_GraphicIndice, frameFloorPitD3C); + drawFloorPitOrStairsBitmap(k50_FloorPit_D3C_GraphicIndice, frameFloorPitD3C); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k1_viewFloor_D3C); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k1_viewFloor_D3C); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ break; default: skip = true; @@ -1432,13 +1432,13 @@ void DisplayMan::f118_drawSquareD3C(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k0_ViewSquare_D3C, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k0_ViewSquare_D3C, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k0_ViewSquare_D3C], _frameWalls163[k0_ViewSquare_D3C]._box); + drawField(&_fieldAspects188[k0_ViewSquare_D3C], _frameWalls163[k0_ViewSquare_D3C]._box); } -void DisplayMan::f119_drawSquareD2L(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD2L(Direction dir, int16 posX, int16 posY) { static Frame doorFrameTopD2L = Frame(0, 59, 22, 24, 48, 3, 16, 0); // @ G0173_s_Graphic558_Frame_DoorFrameTop_D2L static Frame frameStairsUpFrontD2L = Frame(0, 63, 22, 83, 32, 62, 0, 0); // @ G0113_s_Graphic558_Frame_StairsUpFront_D2L static Frame frameStairsDownFrontD2L = Frame(0, 63, 24, 85, 32, 62, 0, 0); // @ G0124_s_Graphic558_Frame_StairsDownFront_D2L @@ -1467,44 +1467,44 @@ void DisplayMan::f119_drawSquareD2L(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g677_stairsNativeBitmapIndex_Up_Front_D2L, frameStairsUpFrontD2L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD2L, frameStairsUpFrontD2L); else - f104_drawFloorPitOrStairsBitmap(_g684_stairsNativeBitmapIndex_Down_Front_D2L, frameStairsDownFrontD2L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD2L, frameStairsDownFrontD2L); order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ break; case k0_ElementTypeWall: - f100_drawWallSetBitmap(_g699_bitmapWallSet_Wall_D2LCR, _frameWalls163[k4_ViewSquare_D2L]); - f107_isDrawnWallOrnAnAlcove(squareAspect[k2_RightWallOrnOrdAspect], k5_ViewWall_D2L_RIGHT); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k7_ViewWall_D2L_FRONT)) + drawWallSetBitmap(_bitmapWallSetD2LCR, _frameWalls163[k4_ViewSquare_D2L]); + isDrawnWallOrnAnAlcove(squareAspect[k2_RightWallOrnOrdAspect], k5_ViewWall_D2L_RIGHT); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k7_ViewWall_D2L_FRONT)) order = k0x0000_CellOrder_Alcove; else return; break; case k18_ElementTypeStairsSide: - f104_drawFloorPitOrStairsBitmap(_g689_stairsNativeBitmapIndex_Side_D2L, frameStairsSideD2L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexSideD2L, frameStairsSideD2L); // No break on purpose case k16_DoorSideElemType: order = k0x0342_CellOrder_BackRight_FrontLeft_FrontRight; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ break; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k4_ViewSquare_D2L, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); - f100_drawWallSetBitmap(_g703_bitmapWallSet_DoorFrameTop_D2LCR, doorFrameTopD2L); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], _g694_doorNativeBitmapIndex_Front_D2LCR, + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k4_ViewSquare_D2L, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); + drawWallSetBitmap(_bitmapWallSetDoorFrameTopD2LCR, doorFrameTopD2L); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], _doorNativeBitmapIndexFrontD2LCR, bitmapByteCount(64, 61), k1_ViewDoorOrnament_D2LCR, &doorFrameD2L); order = k0x0349_CellOrder_DoorPass2_FrontLeft_FrontRight; break; case k2_ElementTypePit: - f104_drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k57_FloorPir_Invisible_D2L_GraphicIndice : k51_FloorPit_D2L_GraphicIndice, + drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k57_FloorPir_Invisible_D2L_GraphicIndice : k51_FloorPit_D2L_GraphicIndice, frameFloorPitD2L); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k3_viewFloor_D2L); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ break; default: @@ -1513,15 +1513,15 @@ void DisplayMan::f119_drawSquareD2L(Direction dir, int16 posX, int16 posY) { } if (!skip) { - f112_drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &FrameCeilingPitD2L, posX, posY, false); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k4_ViewSquare_D2L, order); + drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &FrameCeilingPitD2L, posX, posY, false); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k4_ViewSquare_D2L, order); } if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k4_ViewSquare_D2L], _frameWalls163[k4_ViewSquare_D2L]._box); + drawField(&_fieldAspects188[k4_ViewSquare_D2L], _frameWalls163[k4_ViewSquare_D2L]._box); } -void DisplayMan::f120_drawSquareD2R(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD2R(Direction dir, int16 posX, int16 posY) { static Frame doorFrameTopD2R = Frame(164, 223, 22, 24, 48, 3, 16, 0); // @ G0175_s_Graphic558_Frame_DoorFrameTop_D2R static Frame frameStairsUpFrontD2R = Frame(160, 223, 22, 83, 32, 62, 0, 0); // @ G0115_s_Graphic558_Frame_StairsUpFront_D2R static Frame frameStairsDownFrontD2R = Frame(160, 223, 24, 85, 32, 62, 0, 0); // @ G0126_s_Graphic558_Frame_StairsDownFront_D2R @@ -1550,50 +1550,50 @@ void DisplayMan::f120_drawSquareD2R(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g677_stairsNativeBitmapIndex_Up_Front_D2L, frameStairsUpFrontD2R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexUpFrontD2L, frameStairsUpFrontD2R); else - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g684_stairsNativeBitmapIndex_Down_Front_D2L, frameStairsDownFrontD2R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexDownFrontD2L, frameStairsDownFrontD2R); order = k0x4312_CellOrder_BackRight_BackLeft_FrontRight_FrontLeft; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_viewFloor_D2R); - f112_drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &frameCeilingPitD2R, posX, posY, true); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_viewFloor_D2R); + drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &frameCeilingPitD2R, posX, posY, true); break; case k0_ElementTypeWall: - f100_drawWallSetBitmap(_g699_bitmapWallSet_Wall_D2LCR, _frameWalls163[k5_ViewSquare_D2R]); - f107_isDrawnWallOrnAnAlcove(squareAspect[k4_LeftWallOrnOrdAspect], k6_ViewWall_D2R_LEFT); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k9_ViewWall_D2R_FRONT)) + drawWallSetBitmap(_bitmapWallSetD2LCR, _frameWalls163[k5_ViewSquare_D2R]); + isDrawnWallOrnAnAlcove(squareAspect[k4_LeftWallOrnOrdAspect], k6_ViewWall_D2R_LEFT); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k9_ViewWall_D2R_FRONT)) order = k0x0000_CellOrder_Alcove; else return; break; case k18_ElementTypeStairsSide: - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g689_stairsNativeBitmapIndex_Side_D2L, frameStairsSideD2R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexSideD2L, frameStairsSideD2R); // No break on purpose case k16_DoorSideElemType: order = k0x0431_CellOrder_BackLeft_FrontRight_FrontLeft; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_viewFloor_D2R); - f112_drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &frameCeilingPitD2R, posX, posY, true); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_viewFloor_D2R); + drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &frameCeilingPitD2R, posX, posY, true); break; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_ViewSquare_D2R); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k5_ViewSquare_D2R, k0x0128_CellOrder_DoorPass1_BackRight_BackLeft); - f100_drawWallSetBitmap(_g703_bitmapWallSet_DoorFrameTop_D2LCR, doorFrameTopD2R); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g694_doorNativeBitmapIndex_Front_D2LCR, bitmapByteCount(64, 61), k1_ViewDoorOrnament_D2LCR, &doorFrameD2R); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_ViewSquare_D2R); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k5_ViewSquare_D2R, k0x0128_CellOrder_DoorPass1_BackRight_BackLeft); + drawWallSetBitmap(_bitmapWallSetDoorFrameTopD2LCR, doorFrameTopD2R); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD2LCR, bitmapByteCount(64, 61), k1_ViewDoorOrnament_D2LCR, &doorFrameD2R); order = k0x0439_CellOrder_DoorPass2_FrontRight_FrontLeft; break; case k2_ElementTypePit: - f105_drawFloorPitOrStairsBitmapFlippedHorizontally( + drawFloorPitOrStairsBitmapFlippedHorizontally( squareAspect[k2_PitInvisibleAspect] ? k57_FloorPir_Invisible_D2L_GraphicIndice : k51_FloorPit_D2L_GraphicIndice, frameFloorPitD2R); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x4312_CellOrder_BackRight_BackLeft_FrontRight_FrontLeft; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_viewFloor_D2R); - f112_drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &frameCeilingPitD2R, posX, posY, true); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k5_viewFloor_D2R); + drawCeilingPit(k63_ceilingPit_D2L_GraphicIndice, &frameCeilingPitD2R, posX, posY, true); break; default: skip = true; @@ -1601,13 +1601,13 @@ void DisplayMan::f120_drawSquareD2R(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k5_ViewSquare_D2R, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k5_ViewSquare_D2R, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k5_ViewSquare_D2R], _frameWalls163[k5_ViewSquare_D2R]._box); + drawField(&_fieldAspects188[k5_ViewSquare_D2R], _frameWalls163[k5_ViewSquare_D2R]._box); } -void DisplayMan::f121_drawSquareD2C(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD2C(Direction dir, int16 posX, int16 posY) { static Frame doorFrameLeftD2C = Frame(48, 95, 22, 86, 24, 65, 0, 0); // @ G0168_s_Graphic558_Frame_DoorFrameLeft_D2C static Frame doorFrameRightD2C = Frame(128, 175, 22, 86, 24, 65, 0, 0); // @ G0169_s_Graphic558_Frame_DoorFrameRight_D2C static Frame doorFrameTopD2C = Frame(64, 159, 22, 24, 48, 3, 0, 0); // @ G0174_s_Graphic558_Frame_DoorFrameTop_D2C @@ -1637,45 +1637,45 @@ void DisplayMan::f121_drawSquareD2C(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g678_stairsNativeBitmapIndex_Up_Front_D2C, frameStairsUpFrontD2C); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD2C, frameStairsUpFrontD2C); else - f104_drawFloorPitOrStairsBitmap(_g685_stairsNativeBitmapIndex_Down_Front_D2C, frameStairsDownFrontD2C); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD2C, frameStairsDownFrontD2C); order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k4_viewFloor_D2C); - f112_drawCeilingPit(k64_ceilingPitD2C_GraphicIndice, &frameCeilingPitD2C, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k4_viewFloor_D2C); + drawCeilingPit(k64_ceilingPitD2C_GraphicIndice, &frameCeilingPitD2C, posX, posY, false); break; case k0_ElementTypeWall: - f101_drawWallSetBitmapWithoutTransparency(_g699_bitmapWallSet_Wall_D2LCR, _frameWalls163[k3_ViewSquare_D2C]); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k8_ViewWall_D2C_FRONT)) + drawWallSetBitmapWithoutTransparency(_bitmapWallSetD2LCR, _frameWalls163[k3_ViewSquare_D2C]); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k8_ViewWall_D2C_FRONT)) order = k0x0000_CellOrder_Alcove; else return; break; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k4_viewFloor_D2C); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k3_ViewSquare_D2C, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); - f100_drawWallSetBitmap(_g703_bitmapWallSet_DoorFrameTop_D2LCR, doorFrameTopD2C); - f100_drawWallSetBitmap(_g707_bitmapWallSet_DoorFrameLeft_D2C, doorFrameLeftD2C); - memcpy(_g74_tmpBitmap, _g707_bitmapWallSet_DoorFrameLeft_D2C, 48 * 65); - f103_drawDoorFrameBitmapFlippedHorizontally(_g74_tmpBitmap, &doorFrameRightD2C); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k4_viewFloor_D2C); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k3_ViewSquare_D2C, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); + drawWallSetBitmap(_bitmapWallSetDoorFrameTopD2LCR, doorFrameTopD2C); + drawWallSetBitmap(_bitmapWallSetDoorFrameLeftD2C, doorFrameLeftD2C); + memcpy(_tmpBitmap, _bitmapWallSetDoorFrameLeftD2C, 48 * 65); + drawDoorFrameBitmapFlippedHorizontally(_tmpBitmap, &doorFrameRightD2C); if (((Door *)_vm->_dungeonMan->_thingData[k0_DoorThingType])[squareAspect[k3_DoorThingIndexAspect]].hasButton()) - f110_drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k2_viewDoorButton_D2C); + drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k2_viewDoorButton_D2C); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g694_doorNativeBitmapIndex_Front_D2LCR, bitmapByteCount(64, 61), k1_ViewDoorOrnament_D2LCR, &doorFrameD2C); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD2LCR, bitmapByteCount(64, 61), k1_ViewDoorOrnament_D2LCR, &doorFrameD2C); order = k0x0349_CellOrder_DoorPass2_FrontLeft_FrontRight; break; case k2_ElementTypePit: - f104_drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k58_FloorPit_invisible_D2C_GraphicIndice : k52_FloorPit_D2C_GraphicIndice, frameFloorPitD2C); + drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k58_FloorPit_invisible_D2C_GraphicIndice : k52_FloorPit_D2C_GraphicIndice, frameFloorPitD2C); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k4_viewFloor_D2C); - f112_drawCeilingPit(k64_ceilingPitD2C_GraphicIndice, &frameCeilingPitD2C, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k4_viewFloor_D2C); + drawCeilingPit(k64_ceilingPitD2C_GraphicIndice, &frameCeilingPitD2C, posX, posY, false); break; default: skip = true; @@ -1683,13 +1683,13 @@ void DisplayMan::f121_drawSquareD2C(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k3_ViewSquare_D2C, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k3_ViewSquare_D2C, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k3_ViewSquare_D2C], _frameWalls163[k3_ViewSquare_D2C]._box); + drawField(&_fieldAspects188[k3_ViewSquare_D2C], _frameWalls163[k3_ViewSquare_D2C]._box); } -void DisplayMan::f122_drawSquareD1L(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD1L(Direction dir, int16 posX, int16 posY) { static Frame doorFrameTopD1L = Frame(0, 31, 14, 17, 64, 4, 16, 0); // @ G0176_s_Graphic558_Frame_DoorFrameTop_D1L static Frame frameStairsUpFrontD1L = Frame(0, 31, 9, 108, 16, 100, 0, 0); // @ G0116_s_Graphic558_Frame_StairsUpFront_D1L static Frame frameStairsDownFrontD1L = Frame(0, 31, 18, 108, 16, 91, 0, 0); // @ G0127_s_Graphic558_Frame_StairsDownFront_D1L @@ -1719,48 +1719,48 @@ void DisplayMan::f122_drawSquareD1L(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g679_stairsNativeBitmapIndex_Up_Front_D1L, frameStairsUpFrontD1L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD1L, frameStairsUpFrontD1L); else - f104_drawFloorPitOrStairsBitmap(_g686_stairsNativeBitmapIndex_Down_Front_D1L, frameStairsDownFrontD1L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD1L, frameStairsDownFrontD1L); order = k0x0032_CellOrder_BackRight_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); - f112_drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1L, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); + drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1L, posX, posY, false); break; case k0_ElementTypeWall: - f100_drawWallSetBitmap(_g700_bitmapWallSet_Wall_D1LCR, _frameWalls163[k7_ViewSquare_D1L]); - f107_isDrawnWallOrnAnAlcove(squareAspect[k2_RightWallOrnOrdAspect], k10_ViewWall_D1L_RIGHT); + drawWallSetBitmap(_bitmapWallSetD1LCR, _frameWalls163[k7_ViewSquare_D1L]); + isDrawnWallOrnAnAlcove(squareAspect[k2_RightWallOrnOrdAspect], k10_ViewWall_D1L_RIGHT); return; case k18_ElementTypeStairsSide: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g690_stairsNativeBitmapIndex_Up_Side_D1L, frameStairsUpSideD1L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpSideD1L, frameStairsUpSideD1L); else - f104_drawFloorPitOrStairsBitmap(_g691_stairsNativeBitmapIndex_Down_Side_D1L, frameStairsDownSideD1L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownSideD1L, frameStairsDownSideD1L); // No break on purpose case k16_DoorSideElemType: order = k0x0032_CellOrder_BackRight_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); - f112_drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1L, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); + drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1L, posX, posY, false); break; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k7_ViewSquare_D1L, k0x0028_CellOrder_DoorPass1_BackRight); - f100_drawWallSetBitmap(_g704_bitmapWallSet_DoorFrameTop_D1LCR, doorFrameTopD1L); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g695_doorNativeBitmapIndex_Front_D1LCR, bitmapByteCount(96, 88), k2_ViewDoorOrnament_D1LCR, &doorFrameD1L); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k7_ViewSquare_D1L, k0x0028_CellOrder_DoorPass1_BackRight); + drawWallSetBitmap(_bitmapWallSetDoorFrameTopD1LCR, doorFrameTopD1L); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD1LCR, bitmapByteCount(96, 88), k2_ViewDoorOrnament_D1LCR, &doorFrameD1L); order = k0x0039_CellOrder_DoorPass2_FrontRight; break; case k2_ElementTypePit: - f104_drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k59_floorPit_invisible_D1L_GraphicIndice : k53_FloorPit_D1L_GraphicIndice, frameFloorPitD1L); + drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k59_floorPit_invisible_D1L_GraphicIndice : k53_FloorPit_D1L_GraphicIndice, frameFloorPitD1L); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x0032_CellOrder_BackRight_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); - f112_drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1L, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k6_viewFloor_D1L); + drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1L, posX, posY, false); break; default: skip = true; @@ -1768,13 +1768,13 @@ void DisplayMan::f122_drawSquareD1L(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k7_ViewSquare_D1L, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k7_ViewSquare_D1L, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k7_ViewSquare_D1L], _frameWalls163[k7_ViewSquare_D1L]._box); + drawField(&_fieldAspects188[k7_ViewSquare_D1L], _frameWalls163[k7_ViewSquare_D1L]._box); } -void DisplayMan::f123_drawSquareD1R(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD1R(Direction dir, int16 posX, int16 posY) { static Frame doorFrameTopD1R = Frame(192, 223, 14, 17, 64, 4, 16, 0); // @ G0178_s_Graphic558_Frame_DoorFrameTop_D1R static Frame frameStairsUpFrontD1R = Frame(192, 223, 9, 108, 16, 100, 0, 0); // @ G0118_s_Graphic558_Frame_StairsUpFront_D1R static Frame frameStairsDownFrontD1R = Frame(192, 223, 18, 108, 16, 91, 0, 0); // @ G0129_s_Graphic558_Frame_StairsDownFront_D1R @@ -1804,47 +1804,47 @@ void DisplayMan::f123_drawSquareD1R(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g679_stairsNativeBitmapIndex_Up_Front_D1L, frameStairsUpFrontD1R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexUpFrontD1L, frameStairsUpFrontD1R); else - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g686_stairsNativeBitmapIndex_Down_Front_D1L, frameStairsDownFrontD1R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexDownFrontD1L, frameStairsDownFrontD1R); order = k0x0041_CellOrder_BackLeft_FrontLeft; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f112_drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1R, posX, posY, true); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1R, posX, posY, true); break; case k0_ElementTypeWall: - f100_drawWallSetBitmap(_g700_bitmapWallSet_Wall_D1LCR, _frameWalls163[k8_ViewSquare_D1R]); - f107_isDrawnWallOrnAnAlcove(squareAspect[k4_LeftWallOrnOrdAspect], k11_ViewWall_D1R_LEFT); + drawWallSetBitmap(_bitmapWallSetD1LCR, _frameWalls163[k8_ViewSquare_D1R]); + isDrawnWallOrnAnAlcove(squareAspect[k4_LeftWallOrnOrdAspect], k11_ViewWall_D1R_LEFT); return; case k18_ElementTypeStairsSide: if (squareAspect[k2_StairsUpAspect]) - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g690_stairsNativeBitmapIndex_Up_Side_D1L, frameStairsUpSideD1R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexUpSideD1L, frameStairsUpSideD1R); else - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g691_stairsNativeBitmapIndex_Down_Side_D1L, frameStairsDownSideD1R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexDownSideD1L, frameStairsDownSideD1R); // No break on purpose case k16_DoorSideElemType: order = k0x0041_CellOrder_BackLeft_FrontLeft; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f112_drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1R, posX, posY, true); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1R, posX, posY, true); break; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k8_ViewSquare_D1R, k0x0018_CellOrder_DoorPass1_BackLeft); - f100_drawWallSetBitmap(_g704_bitmapWallSet_DoorFrameTop_D1LCR, doorFrameTopD1R); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g695_doorNativeBitmapIndex_Front_D1LCR, bitmapByteCount(96, 88), k2_ViewDoorOrnament_D1LCR, &doorFrameD1R); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k8_ViewSquare_D1R, k0x0018_CellOrder_DoorPass1_BackLeft); + drawWallSetBitmap(_bitmapWallSetDoorFrameTopD1LCR, doorFrameTopD1R); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD1LCR, bitmapByteCount(96, 88), k2_ViewDoorOrnament_D1LCR, &doorFrameD1R); order = k0x0049_CellOrder_DoorPass2_FrontLeft; break; case k2_ElementTypePit: - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(squareAspect[k2_PitInvisibleAspect] ? k59_floorPit_invisible_D1L_GraphicIndice + drawFloorPitOrStairsBitmapFlippedHorizontally(squareAspect[k2_PitInvisibleAspect] ? k59_floorPit_invisible_D1L_GraphicIndice : k53_FloorPit_D1L_GraphicIndice, frameFloorPitD1R); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x0041_CellOrder_BackLeft_FrontLeft; - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f112_drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1R, posX, posY, true); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k8_viewFloor_D1R); /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ + drawCeilingPit(k65_ceilingPitD1L_GraphicIndice, &frameCeilingPitD1R, posX, posY, true); break; default: skip = true; @@ -1852,13 +1852,13 @@ void DisplayMan::f123_drawSquareD1R(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k8_ViewSquare_D1R, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k8_ViewSquare_D1R, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k8_ViewSquare_D1R], _frameWalls163[k8_ViewSquare_D1R]._box); + drawField(&_fieldAspects188[k8_ViewSquare_D1R], _frameWalls163[k8_ViewSquare_D1R]._box); } -void DisplayMan::f124_drawSquareD1C(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD1C(Direction dir, int16 posX, int16 posY) { static Frame doorFrameTopD1C = Frame(48, 175, 14, 17, 64, 4, 0, 0); // @ G0177_s_Graphic558_Frame_DoorFrameTop_D1C static Frame frameStairsUpFrontD1C = Frame(32, 191, 9, 108, 80, 100, 0, 0); // @ G0117_s_Graphic558_Frame_StairsUpFront_D1C static Frame frameStairsDownFrontD1C = Frame(32, 191, 18, 108, 80, 91, 0, 0); // @ G0128_s_Graphic558_Frame_StairsDownFront_D1C @@ -1874,62 +1874,62 @@ void DisplayMan::f124_drawSquareD1C(Direction dir, int16 posX, int16 posY) { switch (_vm->_dungeonMan->_squareAheadElement = (ElementType)squareAspect[k0_ElementAspect]) { case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g680_stairsNativeBitmapIndex_Up_Front_D1C, frameStairsUpFrontD1C); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD1C, frameStairsUpFrontD1C); else - f104_drawFloorPitOrStairsBitmap(_g687_stairsNativeBitmapIndex_Down_Front_D1C, frameStairsDownFrontD1C); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD1C, frameStairsDownFrontD1C); order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k7_viewFloor_D1C); - f112_drawCeilingPit(k66_ceilingPitD1C_GraphicIndice, &frameCeilingPitD1C, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k7_viewFloor_D1C); + drawCeilingPit(k66_ceilingPitD1C_GraphicIndice, &frameCeilingPitD1C, posX, posY, false); break; case k0_ElementTypeWall: _vm->_dungeonMan->_isFacingAlcove = false; _vm->_dungeonMan->_isFacingViAltar = false; _vm->_dungeonMan->_isFacingFountain = false; if (_vm->_championMan->_party._event73Count_ThievesEye) { - f491_isDerivedBitmapInCache(k1_DerivedBitmapThievesEyeVisibleArea); - f132_blitToBitmap(_g296_bitmapViewport, f492_getDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea), + isDerivedBitmapInCache(k1_DerivedBitmapThievesEyeVisibleArea); + blitToBitmap(_bitmapViewport, getDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea), boxThievesEyeVisibleArea, _boxThievesEyeViewPortVisibleArea._x1, _boxThievesEyeViewPortVisibleArea._y1, k112_byteWidthViewport, 48, kM1_ColorNoTransparency, 136, 95); - byte *bitmap = f489_getNativeBitmapOrGraphic(k41_holeInWall_GraphicIndice); - f132_blitToBitmap(bitmap, f492_getDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea), + byte *bitmap = getNativeBitmapOrGraphic(k41_holeInWall_GraphicIndice); + blitToBitmap(bitmap, getDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea), boxThievesEyeVisibleArea, 0, 0, 48, 48, k10_ColorFlesh, 95, 95); } - f101_drawWallSetBitmapWithoutTransparency(_g700_bitmapWallSet_Wall_D1LCR, _frameWalls163[k6_ViewSquare_D1C]); - if (f107_isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k12_ViewWall_D1C_FRONT)) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k6_ViewSquare_D1C, k0x0000_CellOrder_Alcove); + drawWallSetBitmapWithoutTransparency(_bitmapWallSetD1LCR, _frameWalls163[k6_ViewSquare_D1C]); + if (isDrawnWallOrnAnAlcove(squareAspect[k3_FrontWallOrnOrdAspect], k12_ViewWall_D1C_FRONT)) + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k6_ViewSquare_D1C, k0x0000_CellOrder_Alcove); if (_vm->_championMan->_party._event73Count_ThievesEye) { - f132_blitToBitmap(f492_getDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea), - _g296_bitmapViewport, _boxThievesEyeViewPortVisibleArea, 0, 0, + blitToBitmap(getDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea), + _bitmapViewport, _boxThievesEyeViewPortVisibleArea, 0, 0, 48, k112_byteWidthViewport, k9_ColorGold, 95, k136_heightViewport); /* BUG0_74 */ - f493_addDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea); - f480_releaseBlock(k1_DerivedBitmapThievesEyeVisibleArea | 0x8000); + addDerivedBitmap(k1_DerivedBitmapThievesEyeVisibleArea); + releaseBlock(k1_DerivedBitmapThievesEyeVisibleArea | 0x8000); } return; case k17_DoorFrontElemType: - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k7_viewFloor_D1C); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k6_ViewSquare_D1C, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); - f100_drawWallSetBitmap(_g704_bitmapWallSet_DoorFrameTop_D1LCR, doorFrameTopD1C); - f100_drawWallSetBitmap(_g708_bitmapWallSet_DoorFrameLeft_D1C, _doorFrameLeftD1C); - f100_drawWallSetBitmap(_g710_bitmapWallSet_DoorFrameRight_D1C, _doorFrameRightD1C); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k7_viewFloor_D1C); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k6_ViewSquare_D1C, k0x0218_CellOrder_DoorPass1_BackLeft_BackRight); + drawWallSetBitmap(_bitmapWallSetDoorFrameTopD1LCR, doorFrameTopD1C); + drawWallSetBitmap(_bitmapWallSetDoorFrameLeftD1C, _doorFrameLeftD1C); + drawWallSetBitmap(_bitmapWallSetDoorFrameRightD1C, _doorFrameRightD1C); if (((Door *)_vm->_dungeonMan->_thingData[k0_DoorThingType])[squareAspect[k3_DoorThingIndexAspect]].hasButton()) - f110_drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k3_viewDoorButton_D1C); + drawDoorButton(_vm->indexToOrdinal(k0_DoorButton), k3_viewDoorButton_D1C); - f111_drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], - _g695_doorNativeBitmapIndex_Front_D1LCR, bitmapByteCount(96, 88), k2_ViewDoorOrnament_D1LCR, _doorFrameD1C); + drawDoor(squareAspect[k3_DoorThingIndexAspect], squareAspect[k2_DoorStateAspect], + _doorNativeBitmapIndexFrontD1LCR, bitmapByteCount(96, 88), k2_ViewDoorOrnament_D1LCR, _doorFrameD1C); order = k0x0349_CellOrder_DoorPass2_FrontLeft_FrontRight; break; case k2_ElementTypePit: - f104_drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k60_floorPitInvisibleD1C_GraphicIndice : k54_FloorPit_D1C_GraphicIndice, frameFloorPitD1C); + drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k60_floorPitInvisibleD1C_GraphicIndice : k54_FloorPit_D1C_GraphicIndice, frameFloorPitD1C); // No break on purpose case k5_ElementTypeTeleporter: case k1_CorridorElemType: order = k0x3421_CellOrder_BackLeft_BackRight_FrontLeft_FrontRight; /* BUG0_64 Floor ornaments are drawn over open pits. There is no check to prevent drawing floor ornaments over open pits */ - f108_drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k7_viewFloor_D1C); - f112_drawCeilingPit(k66_ceilingPitD1C_GraphicIndice, &frameCeilingPitD1C, posX, posY, false); + drawFloorOrnament(squareAspect[k4_FloorOrnOrdAspect], k7_viewFloor_D1C); + drawCeilingPit(k66_ceilingPitD1C_GraphicIndice, &frameCeilingPitD1C, posX, posY, false); break; default: skip = true; @@ -1937,13 +1937,13 @@ void DisplayMan::f124_drawSquareD1C(Direction dir, int16 posX, int16 posY) { } if (!skip) - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k6_ViewSquare_D1C, order); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k6_ViewSquare_D1C, order); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k6_ViewSquare_D1C], _frameWalls163[k6_ViewSquare_D1C]._box); + drawField(&_fieldAspects188[k6_ViewSquare_D1C], _frameWalls163[k6_ViewSquare_D1C]._box); } -void DisplayMan::f125_drawSquareD0L(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD0L(Direction dir, int16 posX, int16 posY) { static Frame frameStairsSideD0L = Frame(0, 15, 73, 85, 8, 13, 0, 0); // @ G0138_s_Graphic558_Frame_StairsSide_D0L static Frame frameFloorPitD0L = Frame(0, 31, 124, 135, 16, 12, 0, 0); // @ G0149_s_Graphic558_Frame_FloorPit_D0L static Frame frameCeilingPitD0L = Frame(0, 15, 0, 3, 8, 4, 0, 0); // @ G0158_s_Graphic558_Frame_CeilingPit_D0L @@ -1952,29 +1952,29 @@ void DisplayMan::f125_drawSquareD0L(Direction dir, int16 posX, int16 posY) { _vm->_dungeonMan->setSquareAspect(squareAspect, dir, posX, posY); switch (squareAspect[k0_ElementAspect]) { case k0_WallElemType: - f100_drawWallSetBitmap(_g701_bitmapWallSet_Wall_D0L, _frameWalls163[k10_ViewSquare_D0L]); + drawWallSetBitmap(bitmapWallSetWallD0L, _frameWalls163[k10_ViewSquare_D0L]); break; case k1_CorridorElemType: case k5_TeleporterElemType: case k16_DoorSideElemType: - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k10_ViewSquare_D0L, k0x0002_CellOrder_BackRight); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k10_ViewSquare_D0L, k0x0002_CellOrder_BackRight); break; case k2_PitElemType: - f104_drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k61_floorPitInvisibleD0L_GraphicIndice : k55_FloorPit_D0L_GraphicIndice, frameFloorPitD0L); + drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k61_floorPitInvisibleD0L_GraphicIndice : k55_FloorPit_D0L_GraphicIndice, frameFloorPitD0L); case k18_StairsSideElemType: if (squareAspect[k2_StairsUpAspect]) - f104_drawFloorPitOrStairsBitmap(_g692_stairsNativeBitmapIndex_Side_D0L, frameStairsSideD0L); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexSideD0L, frameStairsSideD0L); break; default: break; } - f112_drawCeilingPit(k67_ceilingPitD0L_grahicIndice, &frameCeilingPitD0L, posX, posY, false); + drawCeilingPit(k67_ceilingPitD0L_grahicIndice, &frameCeilingPitD0L, posX, posY, false); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k10_ViewSquare_D0L], _frameWalls163[k10_ViewSquare_D0L]._box); + drawField(&_fieldAspects188[k10_ViewSquare_D0L], _frameWalls163[k10_ViewSquare_D0L]._box); } -void DisplayMan::f126_drawSquareD0R(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD0R(Direction dir, int16 posX, int16 posY) { static Frame frameStairsSideD0R = Frame(208, 223, 73, 85, 8, 13, 0, 0); // @ G0139_s_Graphic558_Frame_StairsSide_D0R static Frame frameFloorPitD0R = Frame(192, 223, 124, 135, 16, 12, 0, 0); // @ G0151_s_Graphic558_Frame_FloorPit_D0R static Frame frameCeilingPitD0R = Frame(208, 223, 0, 3, 8, 4, 0, 0); // @ G0160_s_Graphic558_Frame_CeilingPit_D0R @@ -1984,26 +1984,26 @@ void DisplayMan::f126_drawSquareD0R(Direction dir, int16 posX, int16 posY) { _vm->_dungeonMan->setSquareAspect(squareAspect, dir, posX, posY); switch (squareAspect[k0_ElementAspect]) { case k18_ElementTypeStairsSide: - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g692_stairsNativeBitmapIndex_Side_D0L, frameStairsSideD0R); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexSideD0L, frameStairsSideD0R); return; case k2_ElementTypePit: - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(squareAspect[k2_PitInvisibleAspect] ? k61_floorPitInvisibleD0L_GraphicIndice + drawFloorPitOrStairsBitmapFlippedHorizontally(squareAspect[k2_PitInvisibleAspect] ? k61_floorPitInvisibleD0L_GraphicIndice : k55_FloorPit_D0L_GraphicIndice, frameFloorPitD0R); case k1_CorridorElemType: case k16_DoorSideElemType: case k5_ElementTypeTeleporter: - f112_drawCeilingPit(k67_ceilingPitD0L_grahicIndice, &frameCeilingPitD0R, posX, posY, true); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k11_ViewSquare_D0R, k0x0001_CellOrder_BackLeft); + drawCeilingPit(k67_ceilingPitD0L_grahicIndice, &frameCeilingPitD0R, posX, posY, true); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k11_ViewSquare_D0R, k0x0001_CellOrder_BackLeft); break; case k0_ElementTypeWall: - f100_drawWallSetBitmap(_g702_bitmapWallSet_Wall_D0R, _frameWalls163[k11_ViewSquare_D0R]); + drawWallSetBitmap(_bitmapWallSetWallD0R, _frameWalls163[k11_ViewSquare_D0R]); return; } if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k11_ViewSquare_D0R], _frameWalls163[k11_ViewSquare_D0R]._box); + drawField(&_fieldAspects188[k11_ViewSquare_D0R], _frameWalls163[k11_ViewSquare_D0R]._box); } -void DisplayMan::f127_drawSquareD0C(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawSquareD0C(Direction dir, int16 posX, int16 posY) { static Frame doorFrameD0C = Frame(96, 127, 0, 122, 16, 123, 0, 0); // @ G0172_s_Graphic558_Frame_DoorFrame_D0C static Frame frameStairsUpFrontD0L = Frame(0, 31, 58, 101, 16, 44, 0, 0); // @ G0119_s_Graphic558_Frame_StairsUpFront_D0L static Frame frameStairsDownFrontD0L = Frame(0, 31, 76, 135, 16, 60, 0, 0); // @ G0130_s_Graphic558_Frame_StairsDownFront_D0L @@ -2019,195 +2019,195 @@ void DisplayMan::f127_drawSquareD0C(Direction dir, int16 posX, int16 posY) { switch (squareAspect[k0_ElementAspect]) { case k16_DoorSideElemType: if (_vm->_championMan->_party._event73Count_ThievesEye) { - memmove(_g74_tmpBitmap, _g709_bitmapWallSet_DoorFrameFront, 32 * 123); - f132_blitToBitmap(f489_getNativeBitmapOrGraphic(k41_holeInWall_GraphicIndice), - _g74_tmpBitmap, boxThievesEyeHoleInDoorFrame, doorFrameD0C._box._x1 - _boxThievesEyeViewPortVisibleArea._x1, + memmove(_tmpBitmap, _bitmapWallSetDoorFrameFront, 32 * 123); + blitToBitmap(getNativeBitmapOrGraphic(k41_holeInWall_GraphicIndice), + _tmpBitmap, boxThievesEyeHoleInDoorFrame, doorFrameD0C._box._x1 - _boxThievesEyeViewPortVisibleArea._x1, 0, 48, 16, k9_ColorGold, 95, 123); - f100_drawWallSetBitmap(_g74_tmpBitmap, doorFrameD0C); + drawWallSetBitmap(_tmpBitmap, doorFrameD0C); } else - f100_drawWallSetBitmap(_g709_bitmapWallSet_DoorFrameFront, doorFrameD0C); + drawWallSetBitmap(_bitmapWallSetDoorFrameFront, doorFrameD0C); break; case k19_ElementTypeStaisFront: if (squareAspect[k2_StairsUpAspect]) { - f104_drawFloorPitOrStairsBitmap(_g681_stairsNativeBitmapIndex_Up_Front_D0C_Left, frameStairsUpFrontD0L); - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g681_stairsNativeBitmapIndex_Up_Front_D0C_Left, frameStairsUpFrontD0R); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexUpFrontD0CLeft, frameStairsUpFrontD0L); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexUpFrontD0CLeft, frameStairsUpFrontD0R); } else { - f104_drawFloorPitOrStairsBitmap(_g688_stairsNativeBitmapIndex_Down_Front_D0C_Left, frameStairsDownFrontD0L); - f105_drawFloorPitOrStairsBitmapFlippedHorizontally(_g688_stairsNativeBitmapIndex_Down_Front_D0C_Left, frameStairsDownFrontD0R); + drawFloorPitOrStairsBitmap(_stairsNativeBitmapIndexDownFrontD0CLeft, frameStairsDownFrontD0L); + drawFloorPitOrStairsBitmapFlippedHorizontally(_stairsNativeBitmapIndexDownFrontD0CLeft, frameStairsDownFrontD0R); } break; case k2_ElementTypePit: - f104_drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k62_flootPitInvisibleD0C_graphicIndice : k56_FloorPit_D0C_GraphicIndice, frameFloorPitD0C); + drawFloorPitOrStairsBitmap(squareAspect[k2_PitInvisibleAspect] ? k62_flootPitInvisibleD0C_graphicIndice : k56_FloorPit_D0C_GraphicIndice, frameFloorPitD0C); break; } - f112_drawCeilingPit(k68_ceilingPitD0C_graphicIndice, &frameCeilingPitD0C, posX, posY, false); - f115_cthulhu(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k9_ViewSquare_D0C, k0x0021_CellOrder_BackLeft_BackRight); + drawCeilingPit(k68_ceilingPitD0C_graphicIndice, &frameCeilingPitD0C, posX, posY, false); + drawObjectsCreaturesProjectilesExplosions(Thing(squareAspect[k1_FirstGroupOrObjectAspect]), dir, posX, posY, k9_ViewSquare_D0C, k0x0021_CellOrder_BackLeft_BackRight); if ((squareAspect[k0_ElementAspect] == k5_ElementTypeTeleporter) && squareAspect[k2_TeleporterVisibleAspect]) - f113_drawField(&_fieldAspects188[k9_ViewSquare_D0C], _frameWalls163[k9_ViewSquare_D0C]._box); + drawField(&_fieldAspects188[k9_ViewSquare_D0C], _frameWalls163[k9_ViewSquare_D0C]._box); } -void DisplayMan::f128_drawDungeon(Direction dir, int16 posX, int16 posY) { +void DisplayMan::drawDungeon(Direction dir, int16 posX, int16 posY) { static Frame ceilingFrame(0, 223, 0, 28, 112, 29, 0, 0); // @ K0012_s_Frame_Ceiling static Frame floorFrame(0, 223, 66, 135, 112, 70, 0, 0); // @ K0013_s_Frame_Floor static Frame frameWallD3L2 = Frame(0, 15, 25, 73, 8, 49, 0, 0); // @ G0711_s_Graphic558_Frame_Wall_D3L2 - if (_g297_drawFloorAndCeilingRequested) - f98_drawFloorAndCeiling(); + if (_drawFloorAndCeilingRequested) + drawFloorAndCeiling(); - _g578_useByteBoxCoordinates = true; + _useByteBoxCoordinates = true; for (int16 i = 0; i < 6; ++i) _vm->_dungeonMan->_dungeonViewClickableBoxes[i].setToZero(); for (uint16 i = 0; i < 6; ++i) _vm->_dungeonMan->_dungeonViewClickableBoxes[i]._x1 = 255; - _g76_useFlippedWallAndFootprintsBitmap = (posX + posY + dir) & 1; - if (_g76_useFlippedWallAndFootprintsBitmap) { - f100_drawWallSetBitmap(_g85_bitmapCeiling, ceilingFrame); - f99_copyBitmapAndFlipHorizontal(_g84_bitmapFloor, _g74_tmpBitmap, k112_byteWidthViewport, 70); - f100_drawWallSetBitmap(_g74_tmpBitmap, floorFrame); - - _g698_bitmapWallSet_Wall_D3LCR = _g90_bitmapWall_D3LCR_Flipped; - _g699_bitmapWallSet_Wall_D2LCR = _g91_bitmapWall_D2LCR_Flipped; - _g700_bitmapWallSet_Wall_D1LCR = _g92_bitmapWall_D1LCR_Flipped; - _g701_bitmapWallSet_Wall_D0L = _g93_bitmapWall_D0L_Flipped; - _g702_bitmapWallSet_Wall_D0R = _g94_bitmapWall_D0R_Flipped; + _useFlippedWallAndFootprintsBitmap = (posX + posY + dir) & 1; + if (_useFlippedWallAndFootprintsBitmap) { + drawWallSetBitmap(_bitmapCeiling, ceilingFrame); + copyBitmapAndFlipHorizontal(_bitmapFloor, _tmpBitmap, k112_byteWidthViewport, 70); + drawWallSetBitmap(_tmpBitmap, floorFrame); + + _bitmapWallSetD3LCR = _bitmapWallD3LCRFlipped; + _bitmapWallSetD2LCR = _bitmapWallD2LCRFlipped; + _bitmapWallSetD1LCR = _bitmapWallD1LCRFlipped; + bitmapWallSetWallD0L = _bitmapWallD0LFlipped; + _bitmapWallSetWallD0R = _bitmapWallD0RFlipped; } else { - f99_copyBitmapAndFlipHorizontal(_g85_bitmapCeiling, _g74_tmpBitmap, k112_byteWidthViewport, 29); - f100_drawWallSetBitmap(_g74_tmpBitmap, ceilingFrame); - f100_drawWallSetBitmap(_g84_bitmapFloor, floorFrame); + copyBitmapAndFlipHorizontal(_bitmapCeiling, _tmpBitmap, k112_byteWidthViewport, 29); + drawWallSetBitmap(_tmpBitmap, ceilingFrame); + drawWallSetBitmap(_bitmapFloor, floorFrame); } if (_vm->_dungeonMan->getRelSquareType(dir, 3, -2, posX, posY) == k0_WallElemType) - f100_drawWallSetBitmap(_g697_bitmapWallSet_Wall_D3L2, frameWallD3L2); + drawWallSetBitmap(_bitmapWallSetD3L2, frameWallD3L2); if (_vm->_dungeonMan->getRelSquareType(dir, 3, 2, posX, posY) == k0_WallElemType) - f100_drawWallSetBitmap(_g696_bitmapWallSet_Wall_D3R2, _frameWallD3R2); + drawWallSetBitmap(_bitmapWallSetD3R2, _frameWallD3R2); int16 tmpPosX = posX; int16 tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 4, -1, tmpPosX, tmpPosY); - f115_cthulhu(_vm->_dungeonMan->getSquareFirstObject(tmpPosX, tmpPosY), dir, tmpPosX, tmpPosY, kM2_ViewSquare_D4L, k0x0001_CellOrder_BackLeft); + drawObjectsCreaturesProjectilesExplosions(_vm->_dungeonMan->getSquareFirstObject(tmpPosX, tmpPosY), dir, tmpPosX, tmpPosY, kM2_ViewSquare_D4L, k0x0001_CellOrder_BackLeft); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 4, 1, tmpPosX, tmpPosY); - f115_cthulhu(_vm->_dungeonMan->getSquareFirstObject(tmpPosX, tmpPosY), dir, tmpPosX, tmpPosY, kM1_ViewSquare_D4R, k0x0001_CellOrder_BackLeft); + drawObjectsCreaturesProjectilesExplosions(_vm->_dungeonMan->getSquareFirstObject(tmpPosX, tmpPosY), dir, tmpPosX, tmpPosY, kM1_ViewSquare_D4R, k0x0001_CellOrder_BackLeft); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 4, 0, tmpPosX, tmpPosY); - f115_cthulhu(_vm->_dungeonMan->getSquareFirstObject(tmpPosX, tmpPosY), dir, tmpPosX, tmpPosY, kM3_ViewSquare_D4C, k0x0001_CellOrder_BackLeft); + drawObjectsCreaturesProjectilesExplosions(_vm->_dungeonMan->getSquareFirstObject(tmpPosX, tmpPosY), dir, tmpPosX, tmpPosY, kM3_ViewSquare_D4C, k0x0001_CellOrder_BackLeft); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 3, -1, tmpPosX, tmpPosY); - f116_drawSquareD3L(dir, tmpPosX, tmpPosY); + drawSquareD3L(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 3, 1, tmpPosX, tmpPosY); - f117_drawSquareD3R(dir, tmpPosX, tmpPosY); + drawSquareD3R(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 3, 0, tmpPosX, tmpPosY); - f118_drawSquareD3C(dir, tmpPosX, tmpPosY); + drawSquareD3C(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 2, -1, tmpPosX, tmpPosY); - f119_drawSquareD2L(dir, tmpPosX, tmpPosY); + drawSquareD2L(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 2, 1, tmpPosX, tmpPosY); - f120_drawSquareD2R(dir, tmpPosX, tmpPosY); + drawSquareD2R(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 2, 0, tmpPosX, tmpPosY); - f121_drawSquareD2C(dir, tmpPosX, tmpPosY); + drawSquareD2C(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 1, -1, tmpPosX, tmpPosY); - f122_drawSquareD1L(dir, tmpPosX, tmpPosY); + drawSquareD1L(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 1, 1, tmpPosX, tmpPosY); - f123_drawSquareD1R(dir, tmpPosX, tmpPosY); + drawSquareD1R(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 1, 0, tmpPosX, tmpPosY); - f124_drawSquareD1C(dir, tmpPosX, tmpPosY); + drawSquareD1C(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 0, -1, tmpPosX, tmpPosY); - f125_drawSquareD0L(dir, tmpPosX, tmpPosY); + drawSquareD0L(dir, tmpPosX, tmpPosY); tmpPosX = posX; tmpPosY = posY; _vm->_dungeonMan->mapCoordsAfterRelMovement(dir, 0, 1, tmpPosX, tmpPosY); - f126_drawSquareD0R(dir, tmpPosX, tmpPosY); - f127_drawSquareD0C(dir, posX, posY); - - if (_g76_useFlippedWallAndFootprintsBitmap) { - _g698_bitmapWallSet_Wall_D3LCR = _g95_bitmapWall_D3LCR_Native; - _g699_bitmapWallSet_Wall_D2LCR = _g96_bitmapWall_D2LCR_Native; - _g700_bitmapWallSet_Wall_D1LCR = _g97_bitmapWall_D1LCR_Native; - _g701_bitmapWallSet_Wall_D0L = _g98_bitmapWall_D0L_Native; - _g702_bitmapWallSet_Wall_D0R = _g99_bitmapWall_D0R_Native; + drawSquareD0R(dir, tmpPosX, tmpPosY); + drawSquareD0C(dir, posX, posY); + + if (_useFlippedWallAndFootprintsBitmap) { + _bitmapWallSetD3LCR = _bitmapWallD3LCRNative; + _bitmapWallSetD2LCR = _bitmapWallD2LCRNative; + _bitmapWallSetD1LCR = _bitmapWallD1LCRNative; + bitmapWallSetWallD0L = _bitmapWallD0LNative; + _bitmapWallSetWallD0R = _bitmapWallD0RNative; } - f97_drawViewport((_vm->_dungeonMan->_partyMapIndex != k255_mapIndexEntrance) ? 1 : 0); + drawViewport((_vm->_dungeonMan->_partyMapIndex != k255_mapIndexEntrance) ? 1 : 0); if (_vm->_dungeonMan->_partyMapIndex != k255_mapIndexEntrance) - f98_drawFloorAndCeiling(); + drawFloorAndCeiling(); } -void DisplayMan::f98_drawFloorAndCeiling() { +void DisplayMan::drawFloorAndCeiling() { Box box(0, 223, 0, 36); - f135_fillBoxBitmap(_g296_bitmapViewport, box, k0_ColorBlack, k112_byteWidthViewport, k136_heightViewport); - _g297_drawFloorAndCeilingRequested = false; + fillBoxBitmap(_bitmapViewport, box, k0_ColorBlack, k112_byteWidthViewport, k136_heightViewport); + _drawFloorAndCeilingRequested = false; } void DisplayMan::fillScreen(Color color) { memset(getCurrentVgaBuffer(), color, sizeof(byte) * _screenWidth * _screenHeight); } -void DisplayMan::f134_fillBitmap(byte *bitmap, Color color, uint16 byteWidth, uint16 height) { +void DisplayMan::fillBitmap(byte *bitmap, Color color, uint16 byteWidth, uint16 height) { uint16 width = byteWidth * 2; memset(bitmap, color, sizeof(byte) * width * height); } -void DisplayMan::f94_loadFloorSet(FloorSet set) { - if (_g230_currentFloorSet == set) +void DisplayMan::loadFloorSet(FloorSet set) { + if (_currentFloorSet == set) return; - _g230_currentFloorSet = set; + _currentFloorSet = set; int16 index = (set * k2_FloorSetGraphicCount) + k75_FirstFloorSet; - f466_loadIntoBitmap(index, _g84_bitmapFloor); - f466_loadIntoBitmap(index + 1, _g85_bitmapCeiling); + loadIntoBitmap(index, _bitmapFloor); + loadIntoBitmap(index + 1, _bitmapCeiling); } -void DisplayMan::f95_loadWallSet(WallSet set) { - if ((_g231_currentWallSet == set) && !_vm->_restartGameRequest) +void DisplayMan::loadWallSet(WallSet set) { + if ((_currentWallSet == set) && !_vm->_restartGameRequest) return; - _g231_currentWallSet = set; + _currentWallSet = set; int16 graphicIndice = (set * k13_WallSetGraphicCount) + k77_FirstWallSet; - f466_loadIntoBitmap(graphicIndice++, _g709_bitmapWallSet_DoorFrameFront); - f466_loadIntoBitmap(graphicIndice++, _g708_bitmapWallSet_DoorFrameLeft_D1C); - f466_loadIntoBitmap(graphicIndice++, _g707_bitmapWallSet_DoorFrameLeft_D2C); - f466_loadIntoBitmap(graphicIndice++, _g706_bitmapWallSet_DoorFrameLeft_D3C); - f466_loadIntoBitmap(graphicIndice++, _g705_bitmapWallSet_DoorFrameLeft_D3L); - f466_loadIntoBitmap(graphicIndice++, _g704_bitmapWallSet_DoorFrameTop_D1LCR); - f466_loadIntoBitmap(graphicIndice++, _g703_bitmapWallSet_DoorFrameTop_D2LCR); - f466_loadIntoBitmap(graphicIndice++, _g702_bitmapWallSet_Wall_D0R); - f466_loadIntoBitmap(graphicIndice++, _g701_bitmapWallSet_Wall_D0L); - f466_loadIntoBitmap(graphicIndice++, _g700_bitmapWallSet_Wall_D1LCR); - f466_loadIntoBitmap(graphicIndice++, _g699_bitmapWallSet_Wall_D2LCR); - f466_loadIntoBitmap(graphicIndice++, _g698_bitmapWallSet_Wall_D3LCR); - f466_loadIntoBitmap(graphicIndice++, _g697_bitmapWallSet_Wall_D3L2); - - f99_copyBitmapAndFlipHorizontal(_g708_bitmapWallSet_DoorFrameLeft_D1C, _g710_bitmapWallSet_DoorFrameRight_D1C, + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameFront); + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameLeftD1C); + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameLeftD2C); + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameLeftD3C); + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameLeftD3L); + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameTopD1LCR); + loadIntoBitmap(graphicIndice++, _bitmapWallSetDoorFrameTopD2LCR); + loadIntoBitmap(graphicIndice++, _bitmapWallSetWallD0R); + loadIntoBitmap(graphicIndice++, bitmapWallSetWallD0L); + loadIntoBitmap(graphicIndice++, _bitmapWallSetD1LCR); + loadIntoBitmap(graphicIndice++, _bitmapWallSetD2LCR); + loadIntoBitmap(graphicIndice++, _bitmapWallSetD3LCR); + loadIntoBitmap(graphicIndice++, _bitmapWallSetD3L2); + + copyBitmapAndFlipHorizontal(_bitmapWallSetDoorFrameLeftD1C, _bitmapWallSetDoorFrameRightD1C, _doorFrameRightD1C._srcByteWidth, _doorFrameRightD1C._srcHeight); - f99_copyBitmapAndFlipHorizontal(_g697_bitmapWallSet_Wall_D3L2, _g696_bitmapWallSet_Wall_D3R2, + copyBitmapAndFlipHorizontal(_bitmapWallSetD3L2, _bitmapWallSetD3R2, _frameWallD3R2._srcByteWidth, _frameWallD3R2._srcHeight); } -void DisplayMan::f96_loadCurrentMapGraphics() { +void DisplayMan::loadCurrentMapGraphics() { static Box BoxWallD3LCR = Box(0, 115, 0, 50); // @ G0161_s_Graphic558_Box_WallBitmap_D3LCR static Box BoxWallD2LCR = Box(0, 135, 0, 70); // @ G0162_s_Graphic558_Box_WallBitmap_D2LCR static byte doorOrnCoordIndices[12] = { // @ G0196_auc_Graphic558_DoorOrnamentCoordinateSetIndices @@ -2303,123 +2303,123 @@ void DisplayMan::f96_loadCurrentMapGraphics() { 3}; /* Arched Alcove */ static int16 g193_FountainOrnIndices[k1_FountainOrnCount] = {35}; // @ G0193_ai_Graphic558_FountainOrnamentIndices - f94_loadFloorSet(_vm->_dungeonMan->_currMap->_floorSet); - f95_loadWallSet(_vm->_dungeonMan->_currMap->_wallSet); + loadFloorSet(_vm->_dungeonMan->_currMap->_floorSet); + loadWallSet(_vm->_dungeonMan->_currMap->_wallSet); - _g578_useByteBoxCoordinates = true; + _useByteBoxCoordinates = true; - f99_copyBitmapAndFlipHorizontal(_g95_bitmapWall_D3LCR_Native = _g698_bitmapWallSet_Wall_D3LCR, _g74_tmpBitmap, + copyBitmapAndFlipHorizontal(_bitmapWallD3LCRNative = _bitmapWallSetD3LCR, _tmpBitmap, _frameWalls163[k0_ViewSquare_D3C]._srcByteWidth, _frameWalls163[k0_ViewSquare_D3C]._srcHeight); - f134_fillBitmap(_g90_bitmapWall_D3LCR_Flipped, k10_ColorFlesh, 64, 51); - f132_blitToBitmap(_g74_tmpBitmap, _g90_bitmapWall_D3LCR_Flipped, BoxWallD3LCR, 11, 0, 64, 64, kM1_ColorNoTransparency, 51, 51); + fillBitmap(_bitmapWallD3LCRFlipped, k10_ColorFlesh, 64, 51); + blitToBitmap(_tmpBitmap, _bitmapWallD3LCRFlipped, BoxWallD3LCR, 11, 0, 64, 64, kM1_ColorNoTransparency, 51, 51); - f99_copyBitmapAndFlipHorizontal(_g96_bitmapWall_D2LCR_Native = _g699_bitmapWallSet_Wall_D2LCR, _g74_tmpBitmap, + copyBitmapAndFlipHorizontal(_bitmapWallD2LCRNative = _bitmapWallSetD2LCR, _tmpBitmap, _frameWalls163[k3_ViewSquare_D2C]._srcByteWidth, _frameWalls163[k3_ViewSquare_D2C]._srcHeight); - f134_fillBitmap(_g91_bitmapWall_D2LCR_Flipped, k10_ColorFlesh, 72, 71); - f132_blitToBitmap(_g74_tmpBitmap, _g91_bitmapWall_D2LCR_Flipped, BoxWallD2LCR, 8, 0, 72, 72, kM1_ColorNoTransparency, 71, 71); + fillBitmap(_bitmapWallD2LCRFlipped, k10_ColorFlesh, 72, 71); + blitToBitmap(_tmpBitmap, _bitmapWallD2LCRFlipped, BoxWallD2LCR, 8, 0, 72, 72, kM1_ColorNoTransparency, 71, 71); - f99_copyBitmapAndFlipHorizontal(_g97_bitmapWall_D1LCR_Native = _g700_bitmapWallSet_Wall_D1LCR, _g92_bitmapWall_D1LCR_Flipped, + copyBitmapAndFlipHorizontal(_bitmapWallD1LCRNative = _bitmapWallSetD1LCR, _bitmapWallD1LCRFlipped, _frameWalls163[k6_ViewSquare_D1C]._srcByteWidth, _frameWalls163[k6_ViewSquare_D1C]._srcHeight); - f99_copyBitmapAndFlipHorizontal(_g98_bitmapWall_D0L_Native = _g701_bitmapWallSet_Wall_D0L, _g94_bitmapWall_D0R_Flipped, + copyBitmapAndFlipHorizontal(_bitmapWallD0LNative = bitmapWallSetWallD0L, _bitmapWallD0RFlipped, _frameWalls163[k10_ViewSquare_D0L]._srcByteWidth, _frameWalls163[k10_ViewSquare_D0L]._srcHeight); - f99_copyBitmapAndFlipHorizontal(_g99_bitmapWall_D0R_Native = _g702_bitmapWallSet_Wall_D0R, _g93_bitmapWall_D0L_Flipped, + copyBitmapAndFlipHorizontal(_bitmapWallD0RNative = _bitmapWallSetWallD0R, _bitmapWallD0LFlipped, _frameWalls163[k10_ViewSquare_D0L]._srcByteWidth, _frameWalls163[k10_ViewSquare_D0L]._srcHeight); int16 val = _vm->_dungeonMan->_currMap->_wallSet * k18_StairsGraphicCount + k90_FirstStairs; - _g675_stairsNativeBitmapIndex_Up_Front_D3L = val++; - _g676_stairsNativeBitmapIndex_Up_Front_D3C = val++; - _g677_stairsNativeBitmapIndex_Up_Front_D2L = val++; - _g678_stairsNativeBitmapIndex_Up_Front_D2C = val++; - _g679_stairsNativeBitmapIndex_Up_Front_D1L = val++; - _g680_stairsNativeBitmapIndex_Up_Front_D1C = val++; - _g681_stairsNativeBitmapIndex_Up_Front_D0C_Left = val++; - _g682_stairsNativeBitmapIndex_Down_Front_D3L = val++; - _g683_stairsNativeBitmapIndex_Down_Front_D3C = val++; - _g684_stairsNativeBitmapIndex_Down_Front_D2L = val++; - _g685_stairsNativeBitmapIndex_Down_Front_D2C = val++; - _g686_stairsNativeBitmapIndex_Down_Front_D1L = val++; - _g687_stairsNativeBitmapIndex_Down_Front_D1C = val++; - _g688_stairsNativeBitmapIndex_Down_Front_D0C_Left = val++; - _g689_stairsNativeBitmapIndex_Side_D2L = val++; - _g690_stairsNativeBitmapIndex_Up_Side_D1L = val++; - _g691_stairsNativeBitmapIndex_Down_Side_D1L = val++; - _g692_stairsNativeBitmapIndex_Side_D0L = val++; + _stairsNativeBitmapIndexUpFrontD3L = val++; + _stairsNativeBitmapIndexUpFrontD3C = val++; + _stairsNativeBitmapIndexUpFrontD2L = val++; + _stairsNativeBitmapIndexUpFrontD2C = val++; + _stairsNativeBitmapIndexUpFrontD1L = val++; + _stairsNativeBitmapIndexUpFrontD1C = val++; + _stairsNativeBitmapIndexUpFrontD0CLeft = val++; + _stairsNativeBitmapIndexDownFrontD3L = val++; + _stairsNativeBitmapIndexDownFrontD3C = val++; + _stairsNativeBitmapIndexDownFrontD2L = val++; + _stairsNativeBitmapIndexDownFrontD2C = val++; + _stairsNativeBitmapIndexDownFrontD1L = val++; + _stairsNativeBitmapIndexDownFrontD1C = val++; + _stairsNativeBitmapIndexDownFrontD0CLeft = val++; + _stairsNativeBitmapIndexSideD2L = val++; + _stairsNativeBitmapIndexUpSideD1L = val++; + _stairsNativeBitmapIndexDownSideD1L = val++; + _stairsNativeBitmapIndexSideD0L = val++; for (int16 i = 0; i < k3_AlcoveOrnCount; ++i) - _g267_currMapAlcoveOrnIndices[i] = -1; + _currMapAlcoveOrnIndices[i] = -1; for (int16 i = 0; i < k1_FountainOrnCount; ++i) - _g268_currMapFountainOrnIndices[i] = -1; + _currMapFountainOrnIndices[i] = -1; uint16 doorSets[2]; doorSets[0] = _vm->_dungeonMan->_currMap->_doorSet0; doorSets[1] = _vm->_dungeonMan->_currMap->_doorSet1; for (uint16 doorSet = 0; doorSet <= 1; doorSet++) { int16 counter = k108_FirstDoorSet + (doorSets[doorSet] * k3_DoorSetGraphicsCount); - _g693_doorNativeBitmapIndex_Front_D3LCR[doorSet] = counter++; - _g694_doorNativeBitmapIndex_Front_D2LCR[doorSet] = counter++; - _g695_doorNativeBitmapIndex_Front_D1LCR[doorSet] = counter++; + _doorNativeBitmapIndexFrontD3LCR[doorSet] = counter++; + _doorNativeBitmapIndexFrontD2LCR[doorSet] = counter++; + _doorNativeBitmapIndexFrontD1LCR[doorSet] = counter++; } uint16 alcoveCount = 0; uint16 fountainCount = 0; Map &currMap = *_vm->_dungeonMan->_currMap; - _g266_currMapViAltarIndex = -1; + _currMapViAltarIndex = -1; for (int16 ornamentIndex = 0; ornamentIndex <= currMap._wallOrnCount; ornamentIndex++) { - int16 greenOrn = _g261_currMapWallOrnIndices[ornamentIndex]; + int16 greenOrn = _currMapWallOrnIndices[ornamentIndex]; int16 counter = k121_FirstWallOrn + greenOrn * 2; /* Each wall ornament has 2 graphics */ - _g101_currMapWallOrnInfo[ornamentIndex][k0_NativeBitmapIndex] = counter; + _currMapWallOrnInfo[ornamentIndex][k0_NativeBitmapIndex] = counter; for (int16 ornamentCounter = 0; ornamentCounter < k3_AlcoveOrnCount; ornamentCounter++) { if (greenOrn == g192_AlcoveOrnIndices[ornamentCounter]) { - _g267_currMapAlcoveOrnIndices[alcoveCount++] = ornamentIndex; + _currMapAlcoveOrnIndices[alcoveCount++] = ornamentIndex; if (greenOrn == 2) /* Wall ornament #2 is the Vi Altar */ - _g266_currMapViAltarIndex = ornamentIndex; + _currMapViAltarIndex = ornamentIndex; } } for (int16 ornamentCounter = 0; ornamentCounter < k1_FountainOrnCount; ornamentCounter++) { if (greenOrn == g193_FountainOrnIndices[ornamentCounter]) - _g268_currMapFountainOrnIndices[fountainCount++] = ornamentIndex; + _currMapFountainOrnIndices[fountainCount++] = ornamentIndex; } - _g101_currMapWallOrnInfo[ornamentIndex][k1_CoordinateSet] = g194_WallOrnCoordSetIndices[greenOrn]; + _currMapWallOrnInfo[ornamentIndex][k1_CoordinateSet] = g194_WallOrnCoordSetIndices[greenOrn]; } for (uint16 i = 0; i < currMap._floorOrnCount; ++i) { - uint16 ornIndice = _g262_currMapFloorOrnIndices[i]; + uint16 ornIndice = _currMapFloorOrnIndices[i]; uint16 nativeIndice = k247_FirstFloorOrn + ornIndice * 6; - _g102_currMapFloorOrnInfo[i][k0_NativeBitmapIndex] = nativeIndice; - _g102_currMapFloorOrnInfo[i][k1_CoordinateSet] = floorOrnCoordSetIndices[ornIndice]; + _currMapFloorOrnInfo[i][k0_NativeBitmapIndex] = nativeIndice; + _currMapFloorOrnInfo[i][k1_CoordinateSet] = floorOrnCoordSetIndices[ornIndice]; } for (uint16 i = 0; i < currMap._doorOrnCount; ++i) { - uint16 ornIndice = _g263_currMapDoorOrnIndices[i]; + uint16 ornIndice = _currMapDoorOrnIndices[i]; uint16 nativeIndice = k303_FirstDoorOrn + ornIndice; - _g103_currMapDoorOrnInfo[i][k0_NativeBitmapIndex] = nativeIndice; - _g103_currMapDoorOrnInfo[i][k1_CoordinateSet] = doorOrnCoordIndices[ornIndice]; + _currMapDoorOrnInfo[i][k0_NativeBitmapIndex] = nativeIndice; + _currMapDoorOrnInfo[i][k1_CoordinateSet] = doorOrnCoordIndices[ornIndice]; } - f93_applyCreatureReplColors(9, 8); - f93_applyCreatureReplColors(10, 12); + applyCreatureReplColors(9, 8); + applyCreatureReplColors(10, 12); for (uint16 creatureType = 0; creatureType < currMap._creatureTypeCount; ++creatureType) { - CreatureAspect &aspect = _creatureAspects219[_g264_currMapAllowedCreatureTypes[creatureType]]; + CreatureAspect &aspect = _creatureAspects219[_currMapAllowedCreatureTypes[creatureType]]; uint16 replColorOrdinal = aspect.getReplColour9(); if (replColorOrdinal) - f93_applyCreatureReplColors(9, _vm->ordinalToIndex(replColorOrdinal)); + applyCreatureReplColors(9, _vm->ordinalToIndex(replColorOrdinal)); replColorOrdinal = aspect.getReplColour10(); if (replColorOrdinal) - f93_applyCreatureReplColors(10, _vm->ordinalToIndex(replColorOrdinal)); + applyCreatureReplColors(10, _vm->ordinalToIndex(replColorOrdinal)); } - _g297_drawFloorAndCeilingRequested = true; - _g342_refreshDungeonViewPaleteRequested = true; + _drawFloorAndCeilingRequested = true; + _refreshDungeonViewPaleteRequested = true; } -void DisplayMan::f93_applyCreatureReplColors(int replacedColor, int replacementColor) { +void DisplayMan::applyCreatureReplColors(int replacedColor, int replacementColor) { CreatureReplColorSet creatureReplColorSets[13] = { // @ G0220_as_Graphic558_CreatureReplacementColorSets /* { Color, Color, Color, Color, Color, Color, D2 replacement color index (x10), D3 replacement color index (x10) } */ CreatureReplColorSet(0x0CA0, 0x0A80, 0x0860, 0x0640, 0x0420, 0x0200, 90, 90), /* Atari ST: { 0x0650, 0x0540, 0x0430, 0x0320, 0x0210, 0x0100, 90, 90 }, RGB colors are different */ @@ -2444,21 +2444,21 @@ void DisplayMan::f93_applyCreatureReplColors(int replacedColor, int replacementC _palChangesCreatureD3[replacedColor] = creatureReplColorSets[replacementColor]._d3ReplacementColor; } -void DisplayMan::f104_drawFloorPitOrStairsBitmap(uint16 nativeIndex, Frame &f) { +void DisplayMan::drawFloorPitOrStairsBitmap(uint16 nativeIndex, Frame &f) { if (f._srcByteWidth) - f132_blitToBitmap(f489_getNativeBitmapOrGraphic(nativeIndex), _g296_bitmapViewport, f._box, f._srcX, f._srcY, + blitToBitmap(getNativeBitmapOrGraphic(nativeIndex), _bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, k112_byteWidthViewport, k10_ColorFlesh, f._srcHeight, k136_heightViewport); } -void DisplayMan::f105_drawFloorPitOrStairsBitmapFlippedHorizontally(uint16 nativeIndex, Frame &f) { +void DisplayMan::drawFloorPitOrStairsBitmapFlippedHorizontally(uint16 nativeIndex, Frame &f) { if (f._srcByteWidth) { - f99_copyBitmapAndFlipHorizontal(f489_getNativeBitmapOrGraphic(nativeIndex), _g74_tmpBitmap, f._srcByteWidth, f._srcHeight); - f132_blitToBitmap(_g74_tmpBitmap, _g296_bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, + copyBitmapAndFlipHorizontal(getNativeBitmapOrGraphic(nativeIndex), _tmpBitmap, f._srcByteWidth, f._srcHeight); + blitToBitmap(_tmpBitmap, _bitmapViewport, f._box, f._srcX, f._srcY, f._srcByteWidth, k112_byteWidthViewport, k10_ColorFlesh, f._srcHeight, k136_heightViewport); } } -bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWallIndex) { +bool DisplayMan::isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWallIndex) { static Box boxWallPatchBehindInscription = Box(110, 113, 37, 63); // @ G0202_ac_Graphic558_Box_WallPatchBehindInscription static const byte inscriptionLineY[4] = { // @ G0203_auc_Graphic558_InscriptionLineY 48, /* 1 Line */ @@ -2620,14 +2620,14 @@ bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWall return false; wallOrnOrd--; int16 wallOrnamentIndex = wallOrnOrd; - int16 ornNativeBitmapIndex = _g101_currMapWallOrnInfo[wallOrnamentIndex][k0_NativeBitmapIndex]; - int16 wallOrnamentCoordinateSetIndex = _g101_currMapWallOrnInfo[wallOrnamentIndex][k1_CoordinateSet]; + int16 ornNativeBitmapIndex = _currMapWallOrnInfo[wallOrnamentIndex][k0_NativeBitmapIndex]; + int16 wallOrnamentCoordinateSetIndex = _currMapWallOrnInfo[wallOrnamentIndex][k1_CoordinateSet]; byte *ornCoordSet = g205_WallOrnCoordSets[wallOrnamentCoordinateSetIndex][viewWallIndex]; bool isAlcove = _vm->_dungeonMan->isWallOrnAnAlcove(wallOrnamentIndex); unsigned char inscriptionString[70]; bool isInscription = (wallOrnamentIndex == _vm->_dungeonMan->_currMapInscriptionWallOrnIndex); if (isInscription) - _vm->_dungeonMan->decodeText((char*)inscriptionString, _g290_inscriptionThing, k0_TextTypeInscription); + _vm->_dungeonMan->decodeText((char*)inscriptionString, _inscriptionThing, k0_TextTypeInscription); int16 blitPosX; byte *ornBlitBitmap; @@ -2635,9 +2635,9 @@ bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWall if (viewWallIndex >= k10_ViewWall_D1L_RIGHT) { if (viewWallIndex == k12_ViewWall_D1C_FRONT) { if (isInscription) { - f132_blitToBitmap(_g700_bitmapWallSet_Wall_D1LCR, _g296_bitmapViewport, boxWallPatchBehindInscription, 94, 28, _frameWalls163[k6_ViewSquare_D1C]._srcByteWidth, k112_byteWidthViewport, kM1_ColorNoTransparency, _frameWalls163[k6_ViewSquare_D1C]._srcHeight, k136_heightViewport); + blitToBitmap(_bitmapWallSetD1LCR, _bitmapViewport, boxWallPatchBehindInscription, 94, 28, _frameWalls163[k6_ViewSquare_D1C]._srcByteWidth, k112_byteWidthViewport, kM1_ColorNoTransparency, _frameWalls163[k6_ViewSquare_D1C]._srcHeight, k136_heightViewport); byte *inscrString = inscriptionString; - byte *L0092_puc_Bitmap = f489_getNativeBitmapOrGraphic(k120_InscriptionFont); + byte *L0092_puc_Bitmap = getNativeBitmapOrGraphic(k120_InscriptionFont); int16 textLineIndex = 0; do { int16 characterCount = 0; @@ -2649,7 +2649,7 @@ bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWall blitFrame._box._x2 = (blitFrame._box._x1 = 112 - (characterCount << 2)) + 7; blitFrame._box._y1 = (blitFrame._box._y2 = inscriptionLineY[textLineIndex++]) - 7; while (characterCount--) { - f132_blitToBitmap(L0092_puc_Bitmap, _g296_bitmapViewport, blitFrame._box, *inscrString++ << 3, 0, k144_byteWidth, k112_byteWidthViewport, k10_ColorFlesh, 8, k136_heightViewport); + blitToBitmap(L0092_puc_Bitmap, _bitmapViewport, blitFrame._box, *inscrString++ << 3, 0, k144_byteWidth, k112_byteWidthViewport, k10_ColorFlesh, 8, k136_heightViewport); blitFrame._box._x1 += 8; blitFrame._box._x2 += 8; } @@ -2663,19 +2663,19 @@ bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWall } _vm->_dungeonMan->_isFacingAlcove = isAlcove; _vm->_dungeonMan->_isFacingViAltar = - (wallOrnamentIndex == _g266_currMapViAltarIndex); + (wallOrnamentIndex == _currMapViAltarIndex); _vm->_dungeonMan->_isFacingFountain = false; for (int16 idx = 0; idx < k1_FountainOrnCount; idx++) { - if (_g268_currMapFountainOrnIndices[idx] == wallOrnamentIndex) { + if (_currMapFountainOrnIndices[idx] == wallOrnamentIndex) { _vm->_dungeonMan->_isFacingFountain = true; break; } } } - ornBlitBitmap = f489_getNativeBitmapOrGraphic(ornNativeBitmapIndex); + ornBlitBitmap = getNativeBitmapOrGraphic(ornNativeBitmapIndex); if (viewWallIndex == k11_ViewWall_D1R_LEFT) { - f99_copyBitmapAndFlipHorizontal(ornBlitBitmap, _g74_tmpBitmap, ornCoordSet[4], ornCoordSet[5]); - ornBlitBitmap = _g74_tmpBitmap; + copyBitmapAndFlipHorizontal(ornBlitBitmap, _tmpBitmap, ornCoordSet[4], ornCoordSet[5]); + ornBlitBitmap = _tmpBitmap; } blitPosX = 0; } else { @@ -2694,15 +2694,15 @@ bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWall coordinateSetOffset = -6; } blitPosX = (ornCoordSet + coordinateSetOffset)[1] - (ornCoordSet + coordinateSetOffset)[0]; - if (!f491_isDerivedBitmapInCache(wallOrnamentIndex = k4_DerivedBitmapFirstWallOrnament + (wallOrnamentIndex << 2) + wallOrnDerivedBitmapIndexIncrement[viewWallIndex])) { - byte *blitBitmap = f489_getNativeBitmapOrGraphic(ornNativeBitmapIndex); - f129_blitToBitmapShrinkWithPalChange(blitBitmap, f492_getDerivedBitmap(wallOrnamentIndex), ornBlitBitmap[4] << 1, ornBlitBitmap[5], ornCoordSet[4] << 1, ornCoordSet[5], (viewWallIndex <= k4_ViewWall_D3R_FRONT) ? _palChangesDoorButtonAndWallOrnD3 : _palChangesDoorButtonAndWallOrnD2); - f493_addDerivedBitmap(wallOrnamentIndex); + if (!isDerivedBitmapInCache(wallOrnamentIndex = k4_DerivedBitmapFirstWallOrnament + (wallOrnamentIndex << 2) + wallOrnDerivedBitmapIndexIncrement[viewWallIndex])) { + byte *blitBitmap = getNativeBitmapOrGraphic(ornNativeBitmapIndex); + blitToBitmapShrinkWithPalChange(blitBitmap, getDerivedBitmap(wallOrnamentIndex), ornBlitBitmap[4] << 1, ornBlitBitmap[5], ornCoordSet[4] << 1, ornCoordSet[5], (viewWallIndex <= k4_ViewWall_D3R_FRONT) ? _palChangesDoorButtonAndWallOrnD3 : _palChangesDoorButtonAndWallOrnD2); + addDerivedBitmap(wallOrnamentIndex); } - ornBlitBitmap = f492_getDerivedBitmap(wallOrnamentIndex); + ornBlitBitmap = getDerivedBitmap(wallOrnamentIndex); if (flipHorizontal) { - f99_copyBitmapAndFlipHorizontal(ornBlitBitmap, _g74_tmpBitmap, ornCoordSet[4], ornCoordSet[5]); - ornBlitBitmap = _g74_tmpBitmap; + copyBitmapAndFlipHorizontal(ornBlitBitmap, _tmpBitmap, ornCoordSet[4], ornCoordSet[5]); + ornBlitBitmap = _tmpBitmap; blitPosX = 15 - (blitPosX & 0x000F); } else if (viewWallIndex == k7_ViewWall_D2L_FRONT) blitPosX -= ornCoordSet[1] - ornCoordSet[0]; @@ -2730,20 +2730,20 @@ bool DisplayMan::f107_isDrawnWallOrnAnAlcove(int16 wallOrnOrd, ViewWall viewWall } Box tmpBox(ornCoordSet); - f132_blitToBitmap(ornBlitBitmap, _g296_bitmapViewport, tmpBox, + blitToBitmap(ornBlitBitmap, _bitmapViewport, tmpBox, blitPosX, 0, ornCoordSet[4], k112_byteWidthViewport, k10_ColorFlesh, ornCoordSet[5], k136_heightViewport); - if ((viewWallIndex == k12_ViewWall_D1C_FRONT) && _g289_championPortraitOrdinal--) { - f132_blitToBitmap(f489_getNativeBitmapOrGraphic(k26_ChampionPortraitsIndice), _g296_bitmapViewport, boxChampionPortraitOnWall, - (_g289_championPortraitOrdinal & 0x0007) << 5, (_g289_championPortraitOrdinal >> 3) * 29, + if ((viewWallIndex == k12_ViewWall_D1C_FRONT) && _championPortraitOrdinal--) { + blitToBitmap(getNativeBitmapOrGraphic(k26_ChampionPortraitsIndice), _bitmapViewport, boxChampionPortraitOnWall, + (_championPortraitOrdinal & 0x0007) << 5, (_championPortraitOrdinal >> 3) * 29, k128_byteWidth, k112_byteWidthViewport, k1_ColorDarkGary, 87, k136_heightViewport); /* A portrait is 32x29 pixels */ } return isAlcove; } -void DisplayMan::f129_blitToBitmapShrinkWithPalChange(byte *srcBitmap, byte *destBitmap, +void DisplayMan::blitToBitmapShrinkWithPalChange(byte *srcBitmap, byte *destBitmap, int16 srcPixelWidth, int16 srcHeight, int16 destPixelWidth, int16 destHeight, byte *palChange) { warning(false, "DUMMY CODE: f129_blitToBitmapShrinkWithPalChange"); @@ -2766,7 +2766,7 @@ void DisplayMan::f129_blitToBitmapShrinkWithPalChange(byte *srcBitmap, byte *des } } -byte *DisplayMan::f489_getNativeBitmapOrGraphic(uint16 index) { +byte *DisplayMan::getNativeBitmapOrGraphic(uint16 index) { return _bitmaps[index]; } @@ -2778,36 +2778,36 @@ uint32 DisplayMan::getCompressedDataSize(uint16 index) { return _packedItemPos[index + 1] - _packedItemPos[index]; } -void DisplayMan::f113_drawField(FieldAspect* fieldAspect, Box& box) { +void DisplayMan::drawField(FieldAspect* fieldAspect, Box& box) { byte *bitmapMask = nullptr; if (fieldAspect->_mask != kMaskFieldAspectNoMask) { - bitmapMask = _g74_tmpBitmap; - memmove(bitmapMask, f489_getNativeBitmapOrGraphic(k69_FieldMask_D3R_GraphicIndice + getFlag(fieldAspect->_mask, kMaskFieldAspectIndex)), + bitmapMask = _tmpBitmap; + memmove(bitmapMask, getNativeBitmapOrGraphic(k69_FieldMask_D3R_GraphicIndice + getFlag(fieldAspect->_mask, kMaskFieldAspectIndex)), fieldAspect->_height * fieldAspect->_byteWidth * 2); if (getFlag(fieldAspect->_mask, kMaskFieldAspectFlipMask)) { - f130_flipBitmapHorizontal(bitmapMask, fieldAspect->_byteWidth, fieldAspect->_height); + flipBitmapHorizontal(bitmapMask, fieldAspect->_byteWidth, fieldAspect->_height); } } - f491_isDerivedBitmapInCache(k0_DerivedBitmapViewport); - byte *bitmap = f489_getNativeBitmapOrGraphic(k73_FieldTeleporterGraphicIndice + fieldAspect->_nativeBitmapRelativeIndex); - f133_blitBoxFilledWithMaskedBitmap(bitmap, _g296_bitmapViewport, bitmapMask, f492_getDerivedBitmap(k0_DerivedBitmapViewport), box, + isDerivedBitmapInCache(k0_DerivedBitmapViewport); + byte *bitmap = getNativeBitmapOrGraphic(k73_FieldTeleporterGraphicIndice + fieldAspect->_nativeBitmapRelativeIndex); + blitBoxFilledWithMaskedBitmap(bitmap, _bitmapViewport, bitmapMask, getDerivedBitmap(k0_DerivedBitmapViewport), box, _vm->getRandomNumber(2) + fieldAspect->_baseStartUnitIndex, _vm->getRandomNumber(32), k112_byteWidthViewport, (Color)fieldAspect->_transparentColor, fieldAspect->_xPos, 0, 136, fieldAspect->_bitplaneWordCount); - f493_addDerivedBitmap(k0_DerivedBitmapViewport); - f480_releaseBlock(k0_DerivedBitmapViewport | 0x8000); + addDerivedBitmap(k0_DerivedBitmapViewport); + releaseBlock(k0_DerivedBitmapViewport | 0x8000); } -int16 DisplayMan::f459_getScaledBitmapByteCount(int16 byteWidth, int16 height, int16 scale) { - return M77_getNormalizedByteWidth(M78_getScaledDimension(byteWidth, scale)) * M78_getScaledDimension(height, scale); +int16 DisplayMan::getScaledBitmapByteCount(int16 byteWidth, int16 height, int16 scale) { + return getNormalizedByteWidth(getScaledDimension(byteWidth, scale)) * getScaledDimension(height, scale); } -int16 DisplayMan::M78_getScaledDimension(int16 dimension, int16 scale) { +int16 DisplayMan::getScaledDimension(int16 dimension, int16 scale) { return (dimension * scale + scale / 2) / 32; } -void DisplayMan::f115_cthulhu(Thing thingParam, Direction directionParam, int16 mapXpos, +void DisplayMan::drawObjectsCreaturesProjectilesExplosions(Thing thingParam, Direction directionParam, int16 mapXpos, int16 mapYpos, int16 viewSquareIndex, uint16 orderedViewCellOrdinals) { int16 AL_0_creatureGraphicInfoRed; int16 AL_0_creatureIndexRed; @@ -3129,12 +3129,12 @@ T0115015_DrawProjectileAsObject: if ((viewSquareIndex == k9_ViewSquare_D0C) || ((viewSquareIndex >= k6_ViewSquare_D1C) && (AL_2_viewCell >= k2_ViewCellBackRight))) { drawingGrabbableObject = (!viewLane && !drawProjectileAsObject); /* If object is in the center lane (only D0C or D1C with condition above) and is not a projectile */ AL_8_shiftSetIndex = k0_ShiftSet_D0BackD1Front; - bitmapRedBanana = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); /* Use base graphic, no resizing */ + bitmapRedBanana = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); /* Use base graphic, no resizing */ byteWidth = objectAspect->_byteWidth; heightRedEagle = objectAspect->_height; if (flipHorizontal) { - f99_copyBitmapAndFlipHorizontal(bitmapRedBanana, _g74_tmpBitmap, byteWidth, heightRedEagle); - bitmapRedBanana = _g74_tmpBitmap; + copyBitmapAndFlipHorizontal(bitmapRedBanana, _tmpBitmap, byteWidth, heightRedEagle); + bitmapRedBanana = _tmpBitmap; } } else { drawingGrabbableObject = false; @@ -3143,13 +3143,13 @@ T0115015_DrawProjectileAsObject: if ((viewSquareIndex >= k6_ViewSquare_D1C) || ((viewSquareIndex >= k3_ViewSquare_D2C) && (AL_2_viewCell >= k2_ViewCellBackRight))) { derivedBitmapIndex++; AL_8_shiftSetIndex = k1_ShiftSet_D1BackD2Front; - byteWidth = M78_getScaledDimension(objectAspect->_byteWidth, k20_Scale_D2); - heightRedEagle = M78_getScaledDimension(objectAspect->_height, k20_Scale_D2); + byteWidth = getScaledDimension(objectAspect->_byteWidth, k20_Scale_D2); + heightRedEagle = getScaledDimension(objectAspect->_height, k20_Scale_D2); paletteChanges = _palChangesFloorOrnD2; } else { AL_8_shiftSetIndex = k2_ShiftSet_D2BackD3Front; - byteWidth = M78_getScaledDimension(objectAspect->_byteWidth, k16_Scale_D3); - heightRedEagle = M78_getScaledDimension(objectAspect->_height, k16_Scale_D3); + byteWidth = getScaledDimension(objectAspect->_byteWidth, k16_Scale_D3); + heightRedEagle = getScaledDimension(objectAspect->_height, k16_Scale_D3); paletteChanges = _palChangesFloorOrnD3; } if (flipHorizontal) { @@ -3158,15 +3158,15 @@ T0115015_DrawProjectileAsObject: } else if (useAlcoveObjectImage) derivedBitmapIndex += 4; - if (f491_isDerivedBitmapInCache(derivedBitmapIndex)) - bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex); + if (isDerivedBitmapInCache(derivedBitmapIndex)) + bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex); else { - bitmapGreenAnt = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); - f129_blitToBitmapShrinkWithPalChange(bitmapGreenAnt, bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex), objectAspect->_byteWidth << 1, objectAspect->_height, byteWidth << 1, heightRedEagle, paletteChanges); + bitmapGreenAnt = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + blitToBitmapShrinkWithPalChange(bitmapGreenAnt, bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex), objectAspect->_byteWidth << 1, objectAspect->_height, byteWidth << 1, heightRedEagle, paletteChanges); if (flipHorizontal) - f130_flipBitmapHorizontal(bitmapRedBanana, M77_getNormalizedByteWidth(byteWidth), heightRedEagle); + flipBitmapHorizontal(bitmapRedBanana, getNormalizedByteWidth(byteWidth), heightRedEagle); - f493_addDerivedBitmap(derivedBitmapIndex); + addDerivedBitmap(derivedBitmapIndex); } } AL_4_xPos = coordinateSet[0]; @@ -3217,7 +3217,7 @@ T0115015_DrawProjectileAsObject: bitmapRedBanana = bitmapGreenAnt; _vm->_dungeonMan->_pileTopObject[AL_2_viewCell] = thingParam; /* The object is at the top of the pile */ } - f132_blitToBitmap(bitmapRedBanana, _g296_bitmapViewport, boxByteGreen, AL_4_xPos, 0, M77_getNormalizedByteWidth(byteWidth), k112_byteWidthViewport, k10_ColorFlesh, heightRedEagle, k136_heightViewport); + blitToBitmap(bitmapRedBanana, _bitmapViewport, boxByteGreen, AL_4_xPos, 0, getNormalizedByteWidth(byteWidth), k112_byteWidthViewport, k10_ColorFlesh, heightRedEagle, k136_heightViewport); if (drawProjectileAsObject) goto T0115171_BackFromT0115015_DrawProjectileAsObject; } @@ -3364,25 +3364,25 @@ T0115077_DrawSecondHalfSquareCreature: AL_8_shiftSetIndex = k0_ShiftSet_D0BackD1Front; transparentColor = ((CreatureAspect*)objectAspect)->getTranspColour(); if (useCreatureSideBitmap) { - bitmapRedBanana = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + bitmapRedBanana = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); if (creatureDirectionDelta == 1) { - f99_copyBitmapAndFlipHorizontal(bitmapRedBanana, _g74_tmpBitmap, byteWidth, heightRedEagle); - bitmapRedBanana = _g74_tmpBitmap; + copyBitmapAndFlipHorizontal(bitmapRedBanana, _tmpBitmap, byteWidth, heightRedEagle); + bitmapRedBanana = _tmpBitmap; } } else if (useCreatureBackBitmap || !useFlippedHorizontallyCreatureFrontImage) { - bitmapRedBanana = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + bitmapRedBanana = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); if (useCreatureAttackBitmap && getFlag(creatureAspectInt, k0x0040_MaskActiveGroupFlipBitmap)) { - f99_copyBitmapAndFlipHorizontal(bitmapRedBanana, _g74_tmpBitmap, byteWidth, heightRedEagle); - bitmapRedBanana = _g74_tmpBitmap; + copyBitmapAndFlipHorizontal(bitmapRedBanana, _tmpBitmap, byteWidth, heightRedEagle); + bitmapRedBanana = _tmpBitmap; } - } else if (f491_isDerivedBitmapInCache(derivedBitmapIndex)) /* If derived graphic is already in memory */ - bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex); + } else if (isDerivedBitmapInCache(derivedBitmapIndex)) /* If derived graphic is already in memory */ + bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex); else { - bitmapGreenAnt = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + bitmapGreenAnt = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); if (getFlag(AL_0_creatureGraphicInfoRed, k0x0004_CreatureInfoGraphicMaskFlipNonAttack)) - f99_copyBitmapAndFlipHorizontal(bitmapGreenAnt, bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex), byteWidth, heightRedEagle); + copyBitmapAndFlipHorizontal(bitmapGreenAnt, bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex), byteWidth, heightRedEagle); - f493_addDerivedBitmap(derivedBitmapIndex); + addDerivedBitmap(derivedBitmapIndex); } } else { /* Creature is on D2 or D3 */ if (useFlippedHorizontallyCreatureFrontImage) @@ -3402,40 +3402,40 @@ T0115077_DrawSecondHalfSquareCreature: scale = k16_Scale_D3; } - byteWidth = M78_getScaledDimension(sourceByteWidth, scale); - heightRedEagle = M78_getScaledDimension(sourceHeight, scale); + byteWidth = getScaledDimension(sourceByteWidth, scale); + heightRedEagle = getScaledDimension(sourceHeight, scale); transparentColor = paletteChanges[((CreatureAspect*)objectAspect)->getTranspColour()] / 10; - bool derivedBitmapInCache = f491_isDerivedBitmapInCache(derivedBitmapIndex); + bool derivedBitmapInCache = isDerivedBitmapInCache(derivedBitmapIndex); if (derivedBitmapInCache) - bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex); + bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex); else { - bitmapGreenAnt = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); - f129_blitToBitmapShrinkWithPalChange(bitmapGreenAnt, bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex), sourceByteWidth << 1, sourceHeight, byteWidth << 1, heightRedEagle, paletteChanges); - f493_addDerivedBitmap(derivedBitmapIndex); + bitmapGreenAnt = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + blitToBitmapShrinkWithPalChange(bitmapGreenAnt, bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex), sourceByteWidth << 1, sourceHeight, byteWidth << 1, heightRedEagle, paletteChanges); + addDerivedBitmap(derivedBitmapIndex); } if ((useCreatureSideBitmap && (creatureDirectionDelta == 1)) || /* If creature is viewed from the right, the side view must be flipped */ (useCreatureAttackBitmap && getFlag(creatureAspectInt, k0x0040_MaskActiveGroupFlipBitmap)) || (useCreatureSpecialD2FrontBitmap && getFlag(AL_0_creatureGraphicInfoRed, k0x0100_CreatureInfoGraphicMaskSpecialD2FrontIsFlipped)) || (useFlippedHorizontallyCreatureFrontImage && getFlag(AL_0_creatureGraphicInfoRed, k0x0004_CreatureInfoGraphicMaskFlipNonAttack))) { /* If the graphic should be flipped */ if (!useFlippedHorizontallyCreatureFrontImage || !derivedBitmapInCache) { - AL_4_normalizdByteWidth = M77_getNormalizedByteWidth(byteWidth); + AL_4_normalizdByteWidth = getNormalizedByteWidth(byteWidth); if (!useFlippedHorizontallyCreatureFrontImage) { - memcpy(_g74_tmpBitmap, bitmapRedBanana, sizeof(byte) * AL_4_normalizdByteWidth * heightRedEagle); - bitmapRedBanana = _g74_tmpBitmap; + memcpy(_tmpBitmap, bitmapRedBanana, sizeof(byte) * AL_4_normalizdByteWidth * heightRedEagle); + bitmapRedBanana = _tmpBitmap; } - f130_flipBitmapHorizontal(bitmapRedBanana, AL_4_normalizdByteWidth, heightRedEagle); + flipBitmapHorizontal(bitmapRedBanana, AL_4_normalizdByteWidth, heightRedEagle); } creaturePaddingPixelCount = (7 - ((byteWidth - 1) & 0x0007)) << 1; } else creaturePaddingPixelCount = 0; } AL_4_yPos = coordinateSet[1]; - AL_4_yPos += shiftSets[AL_8_shiftSetIndex][M23_getVerticalOffsetM23(creatureAspectInt)]; + AL_4_yPos += shiftSets[AL_8_shiftSetIndex][getVerticalOffsetM23(creatureAspectInt)]; boxByteGreen._y2 = MIN(AL_4_yPos, (int16)135); boxByteGreen._y1 = MAX(0, AL_4_yPos - (heightRedEagle - 1)); AL_4_xPos = coordinateSet[0]; - AL_4_xPos += shiftSets[AL_8_shiftSetIndex][M22_getHorizontalOffsetM22(creatureAspectInt)]; + AL_4_xPos += shiftSets[AL_8_shiftSetIndex][getHorizontalOffsetM22(creatureAspectInt)]; if (viewLane == k1_ViewLaneLeft) AL_4_xPos -= 100; @@ -3455,7 +3455,7 @@ T0115077_DrawSecondHalfSquareCreature: } else AL_0_creaturePosX = creaturePaddingPixelCount + (byteWidth - AL_4_xPos - 1); - f132_blitToBitmap(bitmapRedBanana, _g296_bitmapViewport, boxByteGreen, AL_0_creaturePosX, 0, M77_getNormalizedByteWidth(byteWidth), k112_byteWidthViewport, (Color)transparentColor, heightRedEagle, 136); + blitToBitmap(bitmapRedBanana, _bitmapViewport, boxByteGreen, AL_0_creaturePosX, 0, getNormalizedByteWidth(byteWidth), k112_byteWidthViewport, (Color)transparentColor, heightRedEagle, 136); T0115126_CreatureNotVisible: if (twoHalfSquareCreaturesFrontView) { twoHalfSquareCreaturesFrontView = false; @@ -3500,8 +3500,8 @@ T0115129_DrawProjectiles: if (!doNotScaleWithKineticEnergy) { scale = (scale * MAX(96, projectile->_kineticEnergy + 1)) >> 8; } - byteWidth = M78_getScaledDimension(((ProjectileAspect*)objectAspect)->_byteWidth, scale); - heightRedEagle = M78_getScaledDimension(((ProjectileAspect*)objectAspect)->_height, scale); + byteWidth = getScaledDimension(((ProjectileAspect*)objectAspect)->_byteWidth, scale); + heightRedEagle = getScaledDimension(((ProjectileAspect*)objectAspect)->_height, scale); } bool projectileAspectTypeHasBackGraphicAndRotation = (projectileAspectType == k0_ProjectileAspectHasBackGraphicRotation); if (projectileAspectTypeHasBackGraphicAndRotation) @@ -3538,37 +3538,37 @@ T0115129_DrawProjectiles: AL_4_nativeBitmapIndex += projectileBitmapIndexDelta; paddingPixelCount = 0; if (!scale) { - bitmapRedBanana = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + bitmapRedBanana = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); } else { if (flipHorizontal) paddingPixelCount = (7 - ((byteWidth - 1) & 0x0007)) << 1; - if (doNotScaleWithKineticEnergy && f491_isDerivedBitmapInCache(derivedBitmapIndex = k282_DerivedBitmapFirstProjectile + ((ProjectileAspect*)objectAspect)->_firstDerivedBitmapRelativeIndex + (projectileBitmapIndexDelta * 6) + AL_8_projectileScaleIndex)) { - bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex); + if (doNotScaleWithKineticEnergy && isDerivedBitmapInCache(derivedBitmapIndex = k282_DerivedBitmapFirstProjectile + ((ProjectileAspect*)objectAspect)->_firstDerivedBitmapRelativeIndex + (projectileBitmapIndexDelta * 6) + AL_8_projectileScaleIndex)) { + bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex); } else { - bitmapGreenAnt = f489_getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); + bitmapGreenAnt = getNativeBitmapOrGraphic(AL_4_nativeBitmapIndex); if (doNotScaleWithKineticEnergy) - bitmapRedBanana = f492_getDerivedBitmap(derivedBitmapIndex); + bitmapRedBanana = getDerivedBitmap(derivedBitmapIndex); else - bitmapRedBanana = _g74_tmpBitmap; + bitmapRedBanana = _tmpBitmap; - f129_blitToBitmapShrinkWithPalChange(bitmapGreenAnt, bitmapRedBanana, ((ProjectileAspect*)objectAspect)->_byteWidth << 1, ((ProjectileAspect*)objectAspect)->_height, byteWidth << 1, heightRedEagle, _g75_palChangesProjectile[AL_8_projectileScaleIndex >> 1]); + blitToBitmapShrinkWithPalChange(bitmapGreenAnt, bitmapRedBanana, ((ProjectileAspect*)objectAspect)->_byteWidth << 1, ((ProjectileAspect*)objectAspect)->_height, byteWidth << 1, heightRedEagle, _palChangesProjectile[AL_8_projectileScaleIndex >> 1]); if (doNotScaleWithKineticEnergy) { - f493_addDerivedBitmap(derivedBitmapIndex); + addDerivedBitmap(derivedBitmapIndex); } } } if (flipHorizontal || flipVertical) { - AL_4_normalizdByteWidth = M77_getNormalizedByteWidth(byteWidth); - if (bitmapRedBanana != _g74_tmpBitmap) { - memcpy(_g74_tmpBitmap, bitmapRedBanana, sizeof(byte) * AL_4_normalizdByteWidth * heightRedEagle); - bitmapRedBanana = _g74_tmpBitmap; + AL_4_normalizdByteWidth = getNormalizedByteWidth(byteWidth); + if (bitmapRedBanana != _tmpBitmap) { + memcpy(_tmpBitmap, bitmapRedBanana, sizeof(byte) * AL_4_normalizdByteWidth * heightRedEagle); + bitmapRedBanana = _tmpBitmap; } if (flipVertical) - f131_flipVertical(bitmapRedBanana, AL_4_normalizdByteWidth, heightRedEagle); + flipBitmapVertical(bitmapRedBanana, AL_4_normalizdByteWidth, heightRedEagle); if (flipHorizontal) - f130_flipBitmapHorizontal(bitmapRedBanana, AL_4_normalizdByteWidth, heightRedEagle); + flipBitmapHorizontal(bitmapRedBanana, AL_4_normalizdByteWidth, heightRedEagle); } boxByteGreen._y2 = (heightRedEagle >> 1) + 47; boxByteGreen._y1 = 47 - (heightRedEagle >> 1) + !(heightRedEagle & 0x0001); @@ -3582,7 +3582,7 @@ T0115129_DrawProjectiles: } else AL_4_xPos = MAX(paddingPixelCount, int16(byteWidth - projectilePosX - 1)); /* BUG0_06 Graphical glitch when drawing projectiles or explosions. If a projectile or explosion bitmap is cropped because it is only partly visible on the left side of the viewport (boxByteGreen.X1 = 0) and the bitmap is flipped horizontally (flipHorizontal = true) then a wrong part of the bitmap is drawn on screen. To fix this bug, "+ paddingPixelCount" must be added to the second parameter of this function call */ - f132_blitToBitmap(bitmapRedBanana, _g296_bitmapViewport, boxByteGreen, AL_4_xPos, 0, M77_getNormalizedByteWidth(byteWidth), k112_byteWidthViewport, k10_ColorFlesh, heightRedEagle, k136_heightViewport); + blitToBitmap(bitmapRedBanana, _bitmapViewport, boxByteGreen, AL_4_xPos, 0, getNormalizedByteWidth(byteWidth), k112_byteWidthViewport, k10_ColorFlesh, heightRedEagle, k136_heightViewport); } else { /* Positive value: projectile aspect is the index of a OBJECT_ASPECT */ useAlcoveObjectImage = false; byte projectileCoordinates[2]; @@ -3629,13 +3629,13 @@ T0115171_BackFromT0115015_DrawProjectileAsObject:; } else { if (AL_4_explosionType == k100_ExplosionType_RebirthStep1) { objectAspect = (ObjectAspect*)&_projectileAspect[_vm->ordinalToIndex(-_vm->_dungeonMan->getProjectileAspect(Thing::_explLightningBolt))]; - bitmapRedBanana = f489_getNativeBitmapOrGraphic(((ProjectileAspect*)objectAspect)->_firstNativeBitmapRelativeIndex + (k316_FirstProjectileGraphicIndice + 1)); + bitmapRedBanana = getNativeBitmapOrGraphic(((ProjectileAspect*)objectAspect)->_firstNativeBitmapRelativeIndex + (k316_FirstProjectileGraphicIndice + 1)); explosionCoordinates = rebirthStep1ExplosionCoordinates[AL_1_viewSquareExplosionIndex - 3]; - byteWidth = M78_getScaledDimension((((ProjectileAspect*)objectAspect)->_byteWidth), explosionCoordinates[2]); - heightRedEagle = M78_getScaledDimension((((ProjectileAspect*)objectAspect)->_height), explosionCoordinates[2]); + byteWidth = getScaledDimension((((ProjectileAspect*)objectAspect)->_byteWidth), explosionCoordinates[2]); + heightRedEagle = getScaledDimension((((ProjectileAspect*)objectAspect)->_height), explosionCoordinates[2]); if (AL_1_viewSquareExplosionIndex != k9_ViewSquare_D1C_Explosion) { - f129_blitToBitmapShrinkWithPalChange(bitmapRedBanana, _g74_tmpBitmap, ((ProjectileAspect*)objectAspect)->_byteWidth << 1, ((ProjectileAspect*)objectAspect)->_height, byteWidth << 1, heightRedEagle, _palChangesNoChanges); - bitmapRedBanana = _g74_tmpBitmap; + blitToBitmapShrinkWithPalChange(bitmapRedBanana, _tmpBitmap, ((ProjectileAspect*)objectAspect)->_byteWidth << 1, ((ProjectileAspect*)objectAspect)->_height, byteWidth << 1, heightRedEagle, _palChangesNoChanges); + bitmapRedBanana = _tmpBitmap; } goto T0115200_DrawExplosion; } @@ -3660,14 +3660,14 @@ T0115171_BackFromT0115015_DrawProjectileAsObject:; if (AL_2_explosionSize > 3) AL_4_explosionAspectIndex++; /* Use third graphic in the pattern for large explosion attack */ } - f491_isDerivedBitmapInCache(k0_DerivedBitmapViewport); - bitmapRedBanana = f489_getNativeBitmapOrGraphic(AL_4_explosionAspectIndex + k351_FirstExplosionPatternGraphicIndice); + isDerivedBitmapInCache(k0_DerivedBitmapViewport); + bitmapRedBanana = getNativeBitmapOrGraphic(AL_4_explosionAspectIndex + k351_FirstExplosionPatternGraphicIndice); if (smoke) { - f129_blitToBitmapShrinkWithPalChange(bitmapRedBanana, _g74_tmpBitmap, 48, 32, 48, 32, _palChangeSmoke); - bitmapRedBanana = _g74_tmpBitmap; + blitToBitmapShrinkWithPalChange(bitmapRedBanana, _tmpBitmap, 48, 32, 48, 32, _palChangeSmoke); + bitmapRedBanana = _tmpBitmap; } - f133_blitBoxFilledWithMaskedBitmap(bitmapRedBanana, _g296_bitmapViewport, 0, f492_getDerivedBitmap(k0_DerivedBitmapViewport), boxExplosionPatternD0C, _vm->getRandomNumber(4) + 87, _vm->getRandomNumber(64), k112_byteWidthViewport, Color(k0x0080_BlitDoNotUseMask | k10_ColorFlesh), 0, 0, 136, 93); - f493_addDerivedBitmap(k0_DerivedBitmapViewport); + blitBoxFilledWithMaskedBitmap(bitmapRedBanana, _bitmapViewport, 0, getDerivedBitmap(k0_DerivedBitmapViewport), boxExplosionPatternD0C, _vm->getRandomNumber(4) + 87, _vm->getRandomNumber(64), k112_byteWidthViewport, Color(k0x0080_BlitDoNotUseMask | k10_ColorFlesh), 0, 0, 136, 93); + addDerivedBitmap(k0_DerivedBitmapViewport); warning(false, "DISABLED CODE: f480_releaseBlock in f115_cthulhu"); //f480_releaseBlock(k0_DerivedBitmapViewport | 0x8000); } else { @@ -3688,7 +3688,7 @@ T0115171_BackFromT0115015_DrawProjectileAsObject:; } explosionScale = MAX(4, (MAX(48, explosion->getAttack() + 1) * explosionBaseScales[AL_10_explosionScaleIndex]) >> 8) & (int)0xFFFE; } - bitmapRedBanana = f114_getExplosionBitmap(AL_4_explosionAspectIndex, explosionScale, byteWidth, heightRedEagle); + bitmapRedBanana = getExplosionBitmap(AL_4_explosionAspectIndex, explosionScale, byteWidth, heightRedEagle); T0115200_DrawExplosion: bool flipVertical = _vm->getRandomNumber(2); paddingPixelCount = 0; @@ -3719,67 +3719,67 @@ T0115200_DrawExplosion: if (boxByteGreen._x2 <= boxByteGreen._x1) continue; - byteWidth = M77_getNormalizedByteWidth(byteWidth); + byteWidth = getNormalizedByteWidth(byteWidth); if (flipHorizontal || flipVertical) { - memcpy(_g74_tmpBitmap, bitmapRedBanana, sizeof(byte) * byteWidth * heightRedEagle); - bitmapRedBanana = _g74_tmpBitmap; + memcpy(_tmpBitmap, bitmapRedBanana, sizeof(byte) * byteWidth * heightRedEagle); + bitmapRedBanana = _tmpBitmap; } if (flipHorizontal) - f130_flipBitmapHorizontal(bitmapRedBanana, byteWidth, heightRedEagle); + flipBitmapHorizontal(bitmapRedBanana, byteWidth, heightRedEagle); if (flipVertical) - f131_flipVertical(bitmapRedBanana, byteWidth, heightRedEagle); + flipBitmapVertical(bitmapRedBanana, byteWidth, heightRedEagle); - f132_blitToBitmap(bitmapRedBanana, _g296_bitmapViewport, boxByteGreen, AL_4_xPos, 0, byteWidth, k112_byteWidthViewport, k10_ColorFlesh, heightRedEagle, k136_heightViewport); + blitToBitmap(bitmapRedBanana, _bitmapViewport, boxByteGreen, AL_4_xPos, 0, byteWidth, k112_byteWidthViewport, k10_ColorFlesh, heightRedEagle, k136_heightViewport); } } thingParam = _vm->_dungeonMan->getNextThing(thingParam); } while (thingParam != Thing::_endOfList); - if ((fluxcageExplosion != 0) && (doorFrontViewDrawingPass != 1) && !_g77_doNotDrawFluxcagesDuringEndgame) { /* Fluxcage is an explosion displayed as a field (like teleporters), above all other graphics */ + if ((fluxcageExplosion != 0) && (doorFrontViewDrawingPass != 1) && !_doNotDrawFluxcagesDuringEndgame) { /* Fluxcage is an explosion displayed as a field (like teleporters), above all other graphics */ AL_1_viewSquareExplosionIndex -= 3; /* Convert square index for explosions back to square index */ FieldAspect fieldAspect = _fieldAspects188[viewSquareIndex]; (fieldAspect._nativeBitmapRelativeIndex)++; /* NativeBitmapRelativeIndex is now the index of the Fluxcage field graphic */ - f113_drawField(&fieldAspect, _frameWalls163[viewSquareIndex]._box); + drawField(&fieldAspect, _frameWalls163[viewSquareIndex]._box); } } -uint16 DisplayMan::M77_getNormalizedByteWidth(uint16 byteWidth) { +uint16 DisplayMan::getNormalizedByteWidth(uint16 byteWidth) { return (byteWidth + 7) & 0xFFF8; } -uint16 DisplayMan::M23_getVerticalOffsetM23(uint16 val) { +uint16 DisplayMan::getVerticalOffsetM23(uint16 val) { return (val >> 3) & 0x7; } -uint16 DisplayMan::M22_getHorizontalOffsetM22(uint16 val) { +uint16 DisplayMan::getHorizontalOffsetM22(uint16 val) { return (val & 0x7); } -bool DisplayMan::f491_isDerivedBitmapInCache(int16 derivedBitmapIndex) { - if (_g638_derivedBitmaps[derivedBitmapIndex] == nullptr) { +bool DisplayMan::isDerivedBitmapInCache(int16 derivedBitmapIndex) { + if (_derivedBitmaps[derivedBitmapIndex] == nullptr) { // * 2, because the original uses 4 bits instead of 8 bits to store a pixel - _g638_derivedBitmaps[derivedBitmapIndex] = new byte[_g639_derivedBitmapByteCount[derivedBitmapIndex] * 2]; + _derivedBitmaps[derivedBitmapIndex] = new byte[_derivedBitmapByteCount[derivedBitmapIndex] * 2]; return false; } return true; } -byte* DisplayMan::f492_getDerivedBitmap(int16 derivedBitmapIndex) { - return _g638_derivedBitmaps[derivedBitmapIndex]; +byte* DisplayMan::getDerivedBitmap(int16 derivedBitmapIndex) { + return _derivedBitmaps[derivedBitmapIndex]; } -void DisplayMan::f493_addDerivedBitmap(int16 derivedBitmapIndex) {} +void DisplayMan::addDerivedBitmap(int16 derivedBitmapIndex) {} -void DisplayMan::f480_releaseBlock(uint16 index) { +void DisplayMan::releaseBlock(uint16 index) { index &= ~0x8000; - delete[] _g638_derivedBitmaps[index]; - _g638_derivedBitmaps[index] = nullptr; + delete[] _derivedBitmaps[index]; + _derivedBitmaps[index] = nullptr; } -uint16 DisplayMan::f431_getDarkenedColor(uint16 RGBcolor) { +uint16 DisplayMan::getDarkenedColor(uint16 RGBcolor) { if (getFlag(RGBcolor, D12_MASK_BLUE_COMPONENT)) RGBcolor--; @@ -3792,14 +3792,14 @@ uint16 DisplayMan::f431_getDarkenedColor(uint16 RGBcolor) { return RGBcolor; } -void DisplayMan::f436_STARTEND_FadeToPalette(uint16* P0849_pui_Palette) { - uint16 *paletteRegister = _gK16_paletteFadeTemporary; +void DisplayMan::startEndFadeToPalette(uint16* P0849_pui_Palette) { + uint16 *paletteRegister = _paletteFadeTemporary; for (int16 i = 0; i < 16; i++) - paletteRegister[i] = _gK17_paletteFadeFrom[i]; + paletteRegister[i] = _paletteFadeFrom[i]; for (int16 i = 0; i < 8; i++) { - paletteRegister = _gK16_paletteFadeTemporary; + paletteRegister = _paletteFadeTemporary; for (int16 colIdx = 0; colIdx < 16; colIdx++, paletteRegister++) { uint16 currentRGBColor = getFlag(*paletteRegister, D12_MASK_BLUE_COMPONENT); int16 targetRGBColor = getFlag(P0849_pui_Palette[colIdx], D12_MASK_BLUE_COMPONENT); @@ -3843,12 +3843,12 @@ void DisplayMan::f436_STARTEND_FadeToPalette(uint16* P0849_pui_Palette) { } _vm->delay(1); _vm->_eventMan->discardAllInput(); - f508_buildPaletteChangeCopperList(_gK16_paletteFadeTemporary, _gK16_paletteFadeTemporary); + buildPaletteChangeCopperList(_paletteFadeTemporary, _paletteFadeTemporary); } } -void DisplayMan::f508_buildPaletteChangeCopperList(uint16* middleScreen, uint16* topAndBottom) { - _gK17_paletteFadeFrom = topAndBottom; +void DisplayMan::buildPaletteChangeCopperList(uint16* middleScreen, uint16* topAndBottom) { + _paletteFadeFrom = topAndBottom; byte colorPalette[32 * 3]; for (int i = 0; i < 16; ++i) { colorPalette[i * 3] = (topAndBottom[i] >> 8) * (256 / 16); |