diff --git a/stella/src/emucore/TIA.cxx b/stella/src/emucore/TIA.cxx index 2085f2ed2..76c589a23 100644 --- a/stella/src/emucore/TIA.cxx +++ b/stella/src/emucore/TIA.cxx @@ -13,7 +13,7 @@ // See the file "license" for information on usage and redistribution of // this file, and for a DISCLAIMER OF ALL WARRANTIES. // -// $Id: TIA.cxx,v 1.103 2009-01-24 18:17:34 stephena Exp $ +// $Id: TIA.cxx,v 1.104 2009-02-08 21:07:06 stephena Exp $ //============================================================================ //#define DEBUG_HMOVE @@ -143,12 +143,12 @@ void TIA::reset() // Some default values for the "current" variables myCurrentGRP0 = 0; myCurrentGRP1 = 0; - myCurrentBLMask = TIATables::BallMaskTable[0][0]; - myCurrentM0Mask = TIATables::MissleMaskTable[0][0][0]; - myCurrentM1Mask = TIATables::MissleMaskTable[0][0][0]; - myCurrentP0Mask = TIATables::PlayerMaskTable[0][0][0]; - myCurrentP1Mask = TIATables::PlayerMaskTable[0][0][0]; - myCurrentPFMask = TIATables::PlayfieldTable[0]; + myCurrentBLMask = TIATables::BLMask[0][0]; + myCurrentM0Mask = TIATables::MxMask[0][0][0]; + myCurrentM1Mask = TIATables::MxMask[0][0][0]; + myCurrentP0Mask = TIATables::PxMask[0][0][0]; + myCurrentP1Mask = TIATables::PxMask[0][0][0]; + myCurrentPFMask = TIATables::PFMask[0]; myMotionClockP0 = 0; myMotionClockP1 = 0; @@ -341,12 +341,12 @@ bool TIA::save(Serializer& out) const out.putByte((char)myCurrentGRP1); // pointers -// myCurrentBLMask = TIATables::BallMaskTable[0][0]; -// myCurrentM0Mask = TIATables::MissleMaskTable[0][0][0]; -// myCurrentM1Mask = TIATables::MissleMaskTable[0][0][0]; -// myCurrentP0Mask = TIATables::PlayerMaskTable[0][0][0]; -// myCurrentP1Mask = TIATables::PlayerMaskTable[0][0][0]; -// myCurrentPFMask = TIATables::PlayfieldTable[0]; +// myCurrentBLMask = TIATables::BLMask[0][0]; +// myCurrentM0Mask = TIATables::MxMask[0][0][0]; +// myCurrentM1Mask = TIATables::MxMask[0][0][0]; +// myCurrentP0Mask = TIATables::PxMask[0][0][0]; +// myCurrentP1Mask = TIATables::PxMask[0][0][0]; +// myCurrentPFMask = TIATables::PFMask[0]; out.putInt(myLastHMOVEClock); out.putBool(myHMOVEBlankEnabled); @@ -438,12 +438,12 @@ bool TIA::load(Deserializer& in) myCurrentGRP1 = (uInt8) in.getByte(); // pointers -// myCurrentBLMask = TIATables::BallMaskTable[0][0]; -// myCurrentM0Mask = TIATables::MissleMaskTable[0][0][0]; -// myCurrentM1Mask = TIATables::MissleMaskTable[0][0][0]; -// myCurrentP0Mask = TIATables::PlayerMaskTable[0][0][0]; -// myCurrentP1Mask = TIATables::PlayerMaskTable[0][0][0]; -// myCurrentPFMask = TIATables::PlayfieldTable[0]; +// myCurrentBLMask = TIATables::BLMask[0][0]; +// myCurrentM0Mask = TIATables::MxMask[0][0][0]; +// myCurrentM1Mask = TIATables::MxMask[0][0][0]; +// myCurrentP0Mask = TIATables::PxMask[0][0][0]; +// myCurrentP1Mask = TIATables::PxMask[0][0][0]; +// myCurrentPFMask = TIATables::PFMask[0]; myLastHMOVEClock = (Int32) in.getInt(); myHMOVEBlankEnabled = in.getBool(); @@ -812,7 +812,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) myCOLUP0 : ((myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK); if((myCurrentGRP0 & *mP0) && (myCurrentGRP1 & *mP1)) - myCollision |= TIATables::CollisionTable[P0Bit | P1Bit]; + myCollision |= TIATables::CollisionMask[P0Bit | P1Bit]; ++mP0; ++mP1; ++myFramePointer; } @@ -913,7 +913,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) *myFramePointer = *mM0 ? myCOLUP0 : (*mM1 ? myCOLUP1 : myCOLUBK); if(*mM0 && *mM1) - myCollision |= TIATables::CollisionTable[M0Bit | M1Bit]; + myCollision |= TIATables::CollisionMask[M0Bit | M1Bit]; ++mM0; ++mM1; ++myFramePointer; } @@ -940,7 +940,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) *myFramePointer = (*mM0 ? myCOLUP0 : (*mBL ? myCOLUPF : myCOLUBK)); if(*mBL && *mM0) - myCollision |= TIATables::CollisionTable[BLBit | M0Bit]; + myCollision |= TIATables::CollisionMask[BLBit | M0Bit]; ++mBL; ++mM0; ++myFramePointer; } @@ -967,7 +967,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) *myFramePointer = (*mBL ? myCOLUPF : (*mM0 ? myCOLUP0 : myCOLUBK)); if(*mBL && *mM0) - myCollision |= TIATables::CollisionTable[BLBit | M0Bit]; + myCollision |= TIATables::CollisionMask[BLBit | M0Bit]; ++mBL; ++mM0; ++myFramePointer; } @@ -995,7 +995,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) *myFramePointer = (*mM1 ? myCOLUP1 : (*mBL ? myCOLUPF : myCOLUBK)); if(*mBL && *mM1) - myCollision |= TIATables::CollisionTable[BLBit | M1Bit]; + myCollision |= TIATables::CollisionMask[BLBit | M1Bit]; ++mBL; ++mM1; ++myFramePointer; } @@ -1023,7 +1023,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) *myFramePointer = (*mBL ? myCOLUPF : (*mM1 ? myCOLUP1 : myCOLUBK)); if(*mBL && *mM1) - myCollision |= TIATables::CollisionTable[BLBit | M1Bit]; + myCollision |= TIATables::CollisionMask[BLBit | M1Bit]; ++mBL; ++mM1; ++myFramePointer; } @@ -1051,7 +1051,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) (*mBL ? myCOLUPF : myCOLUBK); if(*mBL && (myCurrentGRP1 & *mP1)) - myCollision |= TIATables::CollisionTable[BLBit | P1Bit]; + myCollision |= TIATables::CollisionMask[BLBit | P1Bit]; ++mBL; ++mP1; ++myFramePointer; } @@ -1079,7 +1079,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) ((myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK); if(*mBL && (myCurrentGRP1 & *mP1)) - myCollision |= TIATables::CollisionTable[BLBit | P1Bit]; + myCollision |= TIATables::CollisionMask[BLBit | P1Bit]; ++mBL; ++mP1; ++myFramePointer; } @@ -1106,7 +1106,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) myCOLUP0 : ((myPF & *mPF) ? myCOLUPF : myCOLUBK); if((myPF & *mPF) && (myCurrentGRP0 & *mP0)) - myCollision |= TIATables::CollisionTable[PFBit | P0Bit]; + myCollision |= TIATables::CollisionMask[PFBit | P0Bit]; ++mPF; ++mP0; ++myFramePointer; } @@ -1134,7 +1134,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) ((myCurrentGRP0 & *mP0) ? myCOLUP0 : myCOLUBK); if((myPF & *mPF) && (myCurrentGRP0 & *mP0)) - myCollision |= TIATables::CollisionTable[PFBit | P0Bit]; + myCollision |= TIATables::CollisionMask[PFBit | P0Bit]; ++mPF; ++mP0; ++myFramePointer; } @@ -1162,7 +1162,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) myCOLUP1 : ((myPF & *mPF) ? myCOLUPF : myCOLUBK); if((myPF & *mPF) && (myCurrentGRP1 & *mP1)) - myCollision |= TIATables::CollisionTable[PFBit | P1Bit]; + myCollision |= TIATables::CollisionMask[PFBit | P1Bit]; ++mPF; ++mP1; ++myFramePointer; } @@ -1190,7 +1190,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) ((myCurrentGRP1 & *mP1) ? myCOLUP1 : myCOLUBK); if((myPF & *mPF) && (myCurrentGRP1 & *mP1)) - myCollision |= TIATables::CollisionTable[PFBit | P1Bit]; + myCollision |= TIATables::CollisionMask[PFBit | P1Bit]; ++mPF; ++mP1; ++myFramePointer; } @@ -1218,7 +1218,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) *myFramePointer = ((myPF & *mPF) || *mBL) ? myCOLUPF : myCOLUBK; if((myPF & *mPF) && *mBL) - myCollision |= TIATables::CollisionTable[PFBit | BLBit]; + myCollision |= TIATables::CollisionMask[PFBit | BLBit]; ++mPF; ++mBL; ++myFramePointer; } @@ -1248,7 +1248,7 @@ inline void TIA::updateFrameScanline(uInt32 clocksToUpdate, uInt32 hpos) if((myEnabledObjects & M0Bit) && myCurrentM0Mask[hpos]) enabled |= M0Bit; - myCollision |= TIATables::CollisionTable[enabled]; + myCollision |= TIATables::CollisionMask[enabled]; *myFramePointer = myColor[myPriorityEncoder[hpos < 80 ? 0 : 1] [enabled | myPlayfieldPriorityAndScore]]; } @@ -1344,14 +1344,14 @@ void TIA::updateFrame(Int32 clock) if(myClocksToEndOfScanLine == 228) { // Yes, so set PF mask based on current CTRLPF reflection state - myCurrentPFMask = TIATables::PlayfieldTable[myCTRLPF & 0x01]; + myCurrentPFMask = TIATables::PFMask[myCTRLPF & 0x01]; // TODO: These should be reset right after the first copy of the player // has passed. However, for now we'll just reset at the end of the // scanline since the other way would be to slow (01/21/99). - myCurrentP0Mask = &TIATables::PlayerMaskTable[myPOSP0 & 0x03] + myCurrentP0Mask = &TIATables::PxMask[myPOSP0 & 0x03] [0][myNUSIZ0 & 0x07][160 - (myPOSP0 & 0xFC)]; - myCurrentP1Mask = &TIATables::PlayerMaskTable[myPOSP1 & 0x03] + myCurrentP1Mask = &TIATables::PxMask[myPOSP1 & 0x03] [0][myNUSIZ1 & 0x07][160 - (myPOSP1 & 0xFC)]; #ifndef NO_HMOVE_FIXES @@ -1372,18 +1372,18 @@ void TIA::updateFrame(Int32 clock) if(myM0CosmicArkCounter == 1) { // Stretch this missle so it's at least 2 pixels wide - myCurrentM0Mask = &TIATables::MissleMaskTable[myPOSM0 & 0x03] + myCurrentM0Mask = &TIATables::MxMask[myPOSM0 & 0x03] [myNUSIZ0 & 0x07][((myNUSIZ0 & 0x30) >> 4) | 0x01] [160 - (myPOSM0 & 0xFC)]; } else if(myM0CosmicArkCounter == 2) { // Missle is disabled on this line - myCurrentM0Mask = &TIATables::DisabledMaskTable[0]; + myCurrentM0Mask = &TIATables::DisabledMask[0]; } else { - myCurrentM0Mask = &TIATables::MissleMaskTable[myPOSM0 & 0x03] + myCurrentM0Mask = &TIATables::MxMask[myPOSM0 & 0x03] [myNUSIZ0 & 0x07][(myNUSIZ0 & 0x30) >> 4][160 - (myPOSM0 & 0xFC)]; } } @@ -1547,7 +1547,7 @@ void TIA::poke(uInt16 addr, uInt8 value) addr = addr & 0x003f; Int32 clock = mySystem->cycles() * 3; - Int16 delay = TIATables::PokeDelayTable[addr]; + Int16 delay = TIATables::PokeDelay[addr]; // See if this is a poke to a PF register if(delay == -1) @@ -1641,10 +1641,10 @@ void TIA::poke(uInt16 addr, uInt8 value) // TODO: Technically the "enable" part, [0], should depend on the current // enabled or disabled state. This mean we probably need a data member // to maintain that state (01/21/99). - myCurrentP0Mask = &TIATables::PlayerMaskTable[myPOSP0 & 0x03] + myCurrentP0Mask = &TIATables::PxMask[myPOSP0 & 0x03] [0][myNUSIZ0 & 0x07][160 - (myPOSP0 & 0xFC)]; - myCurrentM0Mask = &TIATables::MissleMaskTable[myPOSM0 & 0x03] + myCurrentM0Mask = &TIATables::MxMask[myPOSM0 & 0x03] [myNUSIZ0 & 0x07][(myNUSIZ0 & 0x30) >> 4][160 - (myPOSM0 & 0xFC)]; break; @@ -1657,10 +1657,10 @@ void TIA::poke(uInt16 addr, uInt8 value) // TODO: Technically the "enable" part, [0], should depend on the current // enabled or disabled state. This mean we probably need a data member // to maintain that state (01/21/99). - myCurrentP1Mask = &TIATables::PlayerMaskTable[myPOSP1 & 0x03] + myCurrentP1Mask = &TIATables::PxMask[myPOSP1 & 0x03] [0][myNUSIZ1 & 0x07][160 - (myPOSP1 & 0xFC)]; - myCurrentM1Mask = &TIATables::MissleMaskTable[myPOSM1 & 0x03] + myCurrentM1Mask = &TIATables::MxMask[myPOSM1 & 0x03] [myNUSIZ1 & 0x07][(myNUSIZ1 & 0x30) >> 4][160 - (myPOSM1 & 0xFC)]; break; @@ -1723,10 +1723,10 @@ void TIA::poke(uInt16 addr, uInt8 value) // we're still on the left hand side of the playfield if(((clock - myClockWhenFrameStarted) % 228) < (68 + 79)) { - myCurrentPFMask = TIATables::PlayfieldTable[myCTRLPF & 0x01]; + myCurrentPFMask = TIATables::PFMask[myCTRLPF & 0x01]; } - myCurrentBLMask = &TIATables::BallMaskTable[myPOSBL & 0x03] + myCurrentBLMask = &TIATables::BLMask[myPOSBL & 0x03] [(myCTRLPF & 0x30) >> 4][160 - (myPOSBL & 0xFC)]; break; @@ -1738,7 +1738,7 @@ void TIA::poke(uInt16 addr, uInt8 value) if(((value & 0x08) && !myREFP0) || (!(value & 0x08) && myREFP0)) { myREFP0 = (value & 0x08); - myCurrentGRP0 = TIATables::PlayerReflectTable[myCurrentGRP0]; + myCurrentGRP0 = TIATables::GRPReflect[myCurrentGRP0]; } break; } @@ -1749,7 +1749,7 @@ void TIA::poke(uInt16 addr, uInt8 value) if(((value & 0x08) && !myREFP1) || (!(value & 0x08) && myREFP1)) { myREFP1 = (value & 0x08); - myCurrentGRP1 = TIATables::PlayerReflectTable[myCurrentGRP1]; + myCurrentGRP1 = TIATables::GRPReflect[myCurrentGRP1]; } break; } @@ -1796,7 +1796,7 @@ void TIA::poke(uInt16 addr, uInt8 value) Int32 newx = hpos < HBLANK ? 3 : (((hpos - HBLANK) + 5) % 160); // Find out under what condition the player is being reset - Int8 when = TIATables::PlayerPositionResetWhenTable[myNUSIZ0 & 7][myPOSP0][newx]; + Int8 when = TIATables::PxPosResetWhen[myNUSIZ0 & 7][myPOSP0][newx]; #ifdef DEBUG_HMOVE if((clock - myLastHMOVEClock) < (24 * 3)) @@ -1817,7 +1817,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSP0 = newx; // Setup the mask to skip the first copy of the player - myCurrentP0Mask = &TIATables::PlayerMaskTable[myPOSP0 & 0x03] + myCurrentP0Mask = &TIATables::PxMask[myPOSP0 & 0x03] [1][myNUSIZ0 & 0x07][160 - (myPOSP0 & 0xFC)]; } // Player is being reset in neither the delay nor display section @@ -1826,7 +1826,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSP0 = newx; // So we setup the mask to skip the first copy of the player - myCurrentP0Mask = &TIATables::PlayerMaskTable[myPOSP0 & 0x03] + myCurrentP0Mask = &TIATables::PxMask[myPOSP0 & 0x03] [1][myNUSIZ0 & 0x07][160 - (myPOSP0 & 0xFC)]; } // Player is being reset during the delay section of one of its copies @@ -1835,7 +1835,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSP0 = newx; // So we setup the mask to display all copies of the player - myCurrentP0Mask = &TIATables::PlayerMaskTable[myPOSP0 & 0x03] + myCurrentP0Mask = &TIATables::PxMask[myPOSP0 & 0x03] [0][myNUSIZ0 & 0x07][160 - (myPOSP0 & 0xFC)]; } break; @@ -1847,7 +1847,7 @@ void TIA::poke(uInt16 addr, uInt8 value) Int32 newx = hpos < HBLANK ? 3 : (((hpos - HBLANK) + 5) % 160); // Find out under what condition the player is being reset - Int8 when = TIATables::PlayerPositionResetWhenTable[myNUSIZ1 & 7][myPOSP1][newx]; + Int8 when = TIATables::PxPosResetWhen[myNUSIZ1 & 7][myPOSP1][newx]; #ifdef DEBUG_HMOVE if((clock - myLastHMOVEClock) < (24 * 3)) @@ -1868,7 +1868,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSP1 = newx; // Setup the mask to skip the first copy of the player - myCurrentP1Mask = &TIATables::PlayerMaskTable[myPOSP1 & 0x03] + myCurrentP1Mask = &TIATables::PxMask[myPOSP1 & 0x03] [1][myNUSIZ1 & 0x07][160 - (myPOSP1 & 0xFC)]; } // Player is being reset in neither the delay nor display section @@ -1877,7 +1877,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSP1 = newx; // So we setup the mask to skip the first copy of the player - myCurrentP1Mask = &TIATables::PlayerMaskTable[myPOSP1 & 0x03] + myCurrentP1Mask = &TIATables::PxMask[myPOSP1 & 0x03] [1][myNUSIZ1 & 0x07][160 - (myPOSP1 & 0xFC)]; } // Player is being reset during the delay section of one of its copies @@ -1886,7 +1886,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSP1 = newx; // So we setup the mask to display all copies of the player - myCurrentP1Mask = &TIATables::PlayerMaskTable[myPOSP1 & 0x03] + myCurrentP1Mask = &TIATables::PxMask[myPOSP1 & 0x03] [0][myNUSIZ1 & 0x07][160 - (myPOSP1 & 0xFC)]; } break; @@ -1920,7 +1920,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSM0 = 8; } #endif - myCurrentM0Mask = &TIATables::MissleMaskTable[myPOSM0 & 0x03] + myCurrentM0Mask = &TIATables::MxMask[myPOSM0 & 0x03] [myNUSIZ0 & 0x07][(myNUSIZ0 & 0x30) >> 4][160 - (myPOSM0 & 0xFC)]; break; } @@ -1946,7 +1946,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSM1 = 3; } #endif - myCurrentM1Mask = &TIATables::MissleMaskTable[myPOSM1 & 0x03] + myCurrentM1Mask = &TIATables::MxMask[myPOSM1 & 0x03] [myNUSIZ1 & 0x07][(myNUSIZ1 & 0x30) >> 4][160 - (myPOSM1 & 0xFC)]; break; } @@ -2018,7 +2018,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myPOSBL = 8; } #endif - myCurrentBLMask = &TIATables::BallMaskTable[myPOSBL & 0x03] + myCurrentBLMask = &TIATables::BLMask[myPOSBL & 0x03] [(myCTRLPF & 0x30) >> 4][160 - (myPOSBL & 0xFC)]; break; } @@ -2075,11 +2075,11 @@ void TIA::poke(uInt16 addr, uInt8 value) // Get the "current" data for GRP0 base on delay register and reflect uInt8 grp0 = myVDELP0 ? myDGRP0 : myGRP0; - myCurrentGRP0 = myREFP0 ? TIATables::PlayerReflectTable[grp0] : grp0; + myCurrentGRP0 = myREFP0 ? TIATables::GRPReflect[grp0] : grp0; // Get the "current" data for GRP1 base on delay register and reflect uInt8 grp1 = myVDELP1 ? myDGRP1 : myGRP1; - myCurrentGRP1 = myREFP1 ? TIATables::PlayerReflectTable[grp1] : grp1; + myCurrentGRP1 = myREFP1 ? TIATables::GRPReflect[grp1] : grp1; // Set enabled object bits if(myCurrentGRP0 != 0) @@ -2108,11 +2108,11 @@ void TIA::poke(uInt16 addr, uInt8 value) // Get the "current" data for GRP0 base on delay register uInt8 grp0 = myVDELP0 ? myDGRP0 : myGRP0; - myCurrentGRP0 = myREFP0 ? TIATables::PlayerReflectTable[grp0] : grp0; + myCurrentGRP0 = myREFP0 ? TIATables::GRPReflect[grp0] : grp0; // Get the "current" data for GRP1 base on delay register uInt8 grp1 = myVDELP1 ? myDGRP1 : myGRP1; - myCurrentGRP1 = myREFP1 ? TIATables::PlayerReflectTable[grp1] : grp1; + myCurrentGRP1 = myREFP1 ? TIATables::GRPReflect[grp1] : grp1; // Set enabled object bits if(myCurrentGRP0 != 0) @@ -2212,7 +2212,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myVDELP0 = value & 0x01; uInt8 grp0 = myVDELP0 ? myDGRP0 : myGRP0; - myCurrentGRP0 = myREFP0 ? TIATables::PlayerReflectTable[grp0] : grp0; + myCurrentGRP0 = myREFP0 ? TIATables::GRPReflect[grp0] : grp0; if(myCurrentGRP0 != 0) myEnabledObjects |= P0Bit; @@ -2226,7 +2226,7 @@ void TIA::poke(uInt16 addr, uInt8 value) myVDELP1 = value & 0x01; uInt8 grp1 = myVDELP1 ? myDGRP1 : myGRP1; - myCurrentGRP1 = myREFP1 ? TIATables::PlayerReflectTable[grp1] : grp1; + myCurrentGRP1 = myREFP1 ? TIATables::GRPReflect[grp1] : grp1; if(myCurrentGRP1 != 0) myEnabledObjects |= P1Bit; @@ -2260,7 +2260,7 @@ void TIA::poke(uInt16 addr, uInt8 value) middle = 4; myPOSM0 = (myPOSP0 + middle) % 160; - myCurrentM0Mask = &TIATables::MissleMaskTable[myPOSM0 & 0x03] + myCurrentM0Mask = &TIATables::MxMask[myPOSM0 & 0x03] [myNUSIZ0 & 0x07][(myNUSIZ0 & 0x30) >> 4][160 - (myPOSM0 & 0xFC)]; } @@ -2288,7 +2288,7 @@ void TIA::poke(uInt16 addr, uInt8 value) middle = 4; myPOSM1 = (myPOSP1 + middle) % 160; - myCurrentM1Mask = &TIATables::MissleMaskTable[myPOSM1 & 0x03] + myCurrentM1Mask = &TIATables::MxMask[myPOSM1 & 0x03] [myNUSIZ1 & 0x07][(myNUSIZ1 & 0x30) >> 4][160 - (myPOSM1 & 0xFC)]; } @@ -2313,11 +2313,11 @@ void TIA::poke(uInt16 addr, uInt8 value) myHMOVEBlankEnabled = true; } - myPOSP0 += TIATables::CompleteMotionTable[x][myHMP0]; - myPOSP1 += TIATables::CompleteMotionTable[x][myHMP1]; - myPOSM0 += TIATables::CompleteMotionTable[x][myHMM0]; - myPOSM1 += TIATables::CompleteMotionTable[x][myHMM1]; - myPOSBL += TIATables::CompleteMotionTable[x][myHMBL]; + myPOSP0 += TIATables::CompleteMotion[x][myHMP0]; + myPOSP1 += TIATables::CompleteMotion[x][myHMP1]; + myPOSM0 += TIATables::CompleteMotion[x][myHMM0]; + myPOSM1 += TIATables::CompleteMotion[x][myHMM1]; + myPOSBL += TIATables::CompleteMotion[x][myHMBL]; if(myPOSP0 >= 160) myPOSP0 -= 160; @@ -2344,17 +2344,17 @@ void TIA::poke(uInt16 addr, uInt8 value) else if(myPOSBL < 0) myPOSBL += 160; - myCurrentBLMask = &TIATables::BallMaskTable[myPOSBL & 0x03] + myCurrentBLMask = &TIATables::BLMask[myPOSBL & 0x03] [(myCTRLPF & 0x30) >> 4][160 - (myPOSBL & 0xFC)]; - myCurrentP0Mask = &TIATables::PlayerMaskTable[myPOSP0 & 0x03] + myCurrentP0Mask = &TIATables::PxMask[myPOSP0 & 0x03] [0][myNUSIZ0 & 0x07][160 - (myPOSP0 & 0xFC)]; - myCurrentP1Mask = &TIATables::PlayerMaskTable[myPOSP1 & 0x03] + myCurrentP1Mask = &TIATables::PxMask[myPOSP1 & 0x03] [0][myNUSIZ1 & 0x07][160 - (myPOSP1 & 0xFC)]; - myCurrentM0Mask = &TIATables::MissleMaskTable[myPOSM0 & 0x03] + myCurrentM0Mask = &TIATables::MxMask[myPOSM0 & 0x03] [myNUSIZ0 & 0x07][(myNUSIZ0 & 0x30) >> 4][160 - (myPOSM0 & 0xFC)]; - myCurrentM1Mask = &TIATables::MissleMaskTable[myPOSM1 & 0x03] + myCurrentM1Mask = &TIATables::MxMask[myPOSM1 & 0x03] [myNUSIZ1 & 0x07][(myNUSIZ1 & 0x30) >> 4][160 - (myPOSM1 & 0xFC)]; // Remember what clock HMOVE occured at diff --git a/stella/src/emucore/TIATables.cxx b/stella/src/emucore/TIATables.cxx index 81b90df4a..f1bee25d6 100644 --- a/stella/src/emucore/TIATables.cxx +++ b/stella/src/emucore/TIATables.cxx @@ -13,7 +13,7 @@ // See the file "license" for information on usage and redistribution of // this file, and for a DISCLAIMER OF ALL WARRANTIES. // -// $Id: TIATables.cxx,v 1.2 2009-02-07 21:50:05 stephena Exp $ +// $Id: TIATables.cxx,v 1.3 2009-02-08 21:07:06 stephena Exp $ //============================================================================ #include @@ -25,210 +25,73 @@ void TIATables::computeAllTables() { for(uInt32 i = 0; i < 640; ++i) - DisabledMaskTable[i] = 0; + DisabledMask[i] = 0; - computeBallMaskTable(); - computeCollisionTable(); - computeMissleMaskTable(); - computePlayerMaskTable(); - computePlayerPositionResetWhenTable(); - computePlayerReflectTable(); - computePlayfieldMaskTable(); + buildCollisionMaskTable(); + buildPxMaskTable(); + buildMxMaskTable(); + buildBLMaskTable(); + buildPFMaskTable(); + buildGRPReflectTable(); + buildPxPosResetWhenTable(); } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computeBallMaskTable() -{ - // First, calculate masks for alignment 0 - for(Int32 size = 0; size < 4; ++size) - { - Int32 x; - - // Set all of the masks to false to start with - for(x = 0; x < 160; ++x) - { - BallMaskTable[0][size][x] = false; - } - - // Set the necessary fields true - for(x = 0; x < 160 + 8; ++x) - { - if((x >= 0) && (x < (1 << size))) - { - BallMaskTable[0][size][x % 160] = true; - } - } - - // Copy fields into the wrap-around area of the mask - for(x = 0; x < 160; ++x) - { - BallMaskTable[0][size][x + 160] = BallMaskTable[0][size][x]; - } - } - - // Now, copy data for alignments of 1, 2 and 3 - for(uInt32 align = 1; align < 4; ++align) - { - for(uInt32 size = 0; size < 4; ++size) - { - for(uInt32 x = 0; x < 320; ++x) - { - BallMaskTable[align][size][x] = BallMaskTable[0][size][(x + 320 - align) % 320]; - } - } - } -} - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computeCollisionTable() +void TIATables::buildCollisionMaskTable() { for(uInt8 i = 0; i < 64; ++i) { - CollisionTable[i] = 0; + CollisionMask[i] = 0; if((i & M0Bit) && (i & P1Bit)) // M0-P1 - CollisionTable[i] |= 0x0001; + CollisionMask[i] |= 0x0001; if((i & M0Bit) && (i & P0Bit)) // M0-P0 - CollisionTable[i] |= 0x0002; + CollisionMask[i] |= 0x0002; if((i & M1Bit) && (i & P0Bit)) // M1-P0 - CollisionTable[i] |= 0x0004; + CollisionMask[i] |= 0x0004; if((i & M1Bit) && (i & P1Bit)) // M1-P1 - CollisionTable[i] |= 0x0008; + CollisionMask[i] |= 0x0008; if((i & P0Bit) && (i & PFBit)) // P0-PF - CollisionTable[i] |= 0x0010; + CollisionMask[i] |= 0x0010; if((i & P0Bit) && (i & BLBit)) // P0-BL - CollisionTable[i] |= 0x0020; + CollisionMask[i] |= 0x0020; if((i & P1Bit) && (i & PFBit)) // P1-PF - CollisionTable[i] |= 0x0040; + CollisionMask[i] |= 0x0040; if((i & P1Bit) && (i & BLBit)) // P1-BL - CollisionTable[i] |= 0x0080; + CollisionMask[i] |= 0x0080; if((i & M0Bit) && (i & PFBit)) // M0-PF - CollisionTable[i] |= 0x0100; + CollisionMask[i] |= 0x0100; if((i & M0Bit) && (i & BLBit)) // M0-BL - CollisionTable[i] |= 0x0200; + CollisionMask[i] |= 0x0200; if((i & M1Bit) && (i & PFBit)) // M1-PF - CollisionTable[i] |= 0x0400; + CollisionMask[i] |= 0x0400; if((i & M1Bit) && (i & BLBit)) // M1-BL - CollisionTable[i] |= 0x0800; + CollisionMask[i] |= 0x0800; if((i & BLBit) && (i & PFBit)) // BL-PF - CollisionTable[i] |= 0x1000; + CollisionMask[i] |= 0x1000; if((i & P0Bit) && (i & P1Bit)) // P0-P1 - CollisionTable[i] |= 0x2000; + CollisionMask[i] |= 0x2000; if((i & M0Bit) && (i & M1Bit)) // M0-M1 - CollisionTable[i] |= 0x4000; + CollisionMask[i] |= 0x4000; } } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computeMissleMaskTable() -{ - // First, calculate masks for alignment 0 - Int32 x, size, number; - - // Clear the missle table to start with - for(number = 0; number < 8; ++number) - for(size = 0; size < 4; ++size) - for(x = 0; x < 160; ++x) - MissleMaskTable[0][number][size][x] = false; - - for(number = 0; number < 8; ++number) - { - for(size = 0; size < 4; ++size) - { - for(x = 0; x < 160 + 72; ++x) - { - // Only one copy of the missle - if((number == 0x00) || (number == 0x05) || (number == 0x07)) - { - if((x >= 0) && (x < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - } - // Two copies - close - else if(number == 0x01) - { - if((x >= 0) && (x < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 16) >= 0) && ((x - 16) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - } - // Two copies - medium - else if(number == 0x02) - { - if((x >= 0) && (x < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 32) >= 0) && ((x - 32) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - } - // Three copies - close - else if(number == 0x03) - { - if((x >= 0) && (x < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 16) >= 0) && ((x - 16) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 32) >= 0) && ((x - 32) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - } - // Two copies - wide - else if(number == 0x04) - { - if((x >= 0) && (x < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 64) >= 0) && ((x - 64) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - } - // Three copies - medium - else if(number == 0x06) - { - if((x >= 0) && (x < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 32) >= 0) && ((x - 32) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - else if(((x - 64) >= 0) && ((x - 64) < (1 << size))) - MissleMaskTable[0][number][size][x % 160] = true; - } - } - - // Copy data into wrap-around area - for(x = 0; x < 160; ++x) - MissleMaskTable[0][number][size][x + 160] = - MissleMaskTable[0][number][size][x]; - } - } - - // Now, copy data for alignments of 1, 2 and 3 - for(uInt32 align = 1; align < 4; ++align) - { - for(number = 0; number < 8; ++number) - { - for(size = 0; size < 4; ++size) - { - for(x = 0; x < 320; ++x) - { - MissleMaskTable[align][number][size][x] = - MissleMaskTable[0][number][size][(x + 320 - align) % 320]; - } - } - } - } -} - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computePlayerMaskTable() +void TIATables::buildPxMaskTable() // [4][2][8][320] { // First, calculate masks for alignment 0 Int32 x, enable, mode; @@ -237,7 +100,7 @@ void TIATables::computePlayerMaskTable() for(enable = 0; enable < 2; ++enable) for(mode = 0; mode < 8; ++mode) for(x = 0; x < 160; ++x) - PlayerMaskTable[0][enable][mode][x] = 0x00; + PxMask[0][enable][mode][x] = 0x00; // Now, compute the player mask table for(enable = 0; enable < 2; ++enable) @@ -246,71 +109,73 @@ void TIATables::computePlayerMaskTable() { for(x = 0; x < 160 + 72; ++x) { - if(mode == 0x00) + switch(mode) { - if((enable == 0) && (x >= 0) && (x < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> x; - } - else if(mode == 0x01) - { - if((enable == 0) && (x >= 0) && (x < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> x; - else if(((x - 16) >= 0) && ((x - 16) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 16); - } - else if(mode == 0x02) - { - if((enable == 0) && (x >= 0) && (x < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> x; - else if(((x - 32) >= 0) && ((x - 32) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 32); - } - else if(mode == 0x03) - { - if((enable == 0) && (x >= 0) && (x < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> x; - else if(((x - 16) >= 0) && ((x - 16) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 16); - else if(((x - 32) >= 0) && ((x - 32) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 32); - } - else if(mode == 0x04) - { - if((enable == 0) && (x >= 0) && (x < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> x; - else if(((x - 64) >= 0) && ((x - 64) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 64); - } - else if(mode == 0x05) - { - // For some reason in double size mode the player's output - // is delayed by one pixel thus we use > instead of >= - if((enable == 0) && (x > 0) && (x <= 16)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> ((x - 1)/2); - } - else if(mode == 0x06) - { - if((enable == 0) && (x >= 0) && (x < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> x; - else if(((x - 32) >= 0) && ((x - 32) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 32); - else if(((x - 64) >= 0) && ((x - 64) < 8)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> (x - 64); - } - else if(mode == 0x07) - { - // For some reason in quad size mode the player's output - // is delayed by one pixel thus we use > instead of >= - if((enable == 0) && (x > 0) && (x <= 32)) - PlayerMaskTable[0][enable][mode][x % 160] = 0x80 >> ((x - 1)/4); + case 0x00: + if((enable == 0) && (x >= 0) && (x < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> x; + break; + + case 0x01: + if((enable == 0) && (x >= 0) && (x < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> x; + else if(((x - 16) >= 0) && ((x - 16) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 16); + break; + + case 0x02: + if((enable == 0) && (x >= 0) && (x < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> x; + else if(((x - 32) >= 0) && ((x - 32) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 32); + break; + + case 0x03: + if((enable == 0) && (x >= 0) && (x < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> x; + else if(((x - 16) >= 0) && ((x - 16) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 16); + else if(((x - 32) >= 0) && ((x - 32) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 32); + break; + + case 0x04: + if((enable == 0) && (x >= 0) && (x < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> x; + else if(((x - 64) >= 0) && ((x - 64) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 64); + break; + + case 0x05: + // For some reason in double size mode the player's output + // is delayed by one pixel thus we use > instead of >= + if((enable == 0) && (x > 0) && (x <= 16)) + PxMask[0][enable][mode][x % 160] = 0x80 >> ((x - 1)/2); + break; + + case 0x06: + if((enable == 0) && (x >= 0) && (x < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> x; + else if(((x - 32) >= 0) && ((x - 32) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 32); + else if(((x - 64) >= 0) && ((x - 64) < 8)) + PxMask[0][enable][mode][x % 160] = 0x80 >> (x - 64); + break; + + case 0x07: + // For some reason in quad size mode the player's output + // is delayed by one pixel thus we use > instead of >= + if((enable == 0) && (x > 0) && (x <= 32)) + PxMask[0][enable][mode][x % 160] = 0x80 >> ((x - 1)/4); + break; } } // Copy data into wrap-around area for(x = 0; x < 160; ++x) { - PlayerMaskTable[0][enable][mode][x + 160] = - PlayerMaskTable[0][enable][mode][x]; + PxMask[0][enable][mode][x + 160] = + PxMask[0][enable][mode][x]; } } } @@ -324,8 +189,8 @@ void TIATables::computePlayerMaskTable() { for(x = 0; x < 320; ++x) { - PlayerMaskTable[align][enable][mode][x] = - PlayerMaskTable[0][enable][mode][(x + 320 - align) % 320]; + PxMask[align][enable][mode][x] = + PxMask[0][enable][mode][(x + 320 - align) % 320]; } } } @@ -333,7 +198,200 @@ void TIATables::computePlayerMaskTable() } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computePlayerPositionResetWhenTable() +void TIATables::buildMxMaskTable() // [4][8][4][320] +{ + // First, calculate masks for alignment 0 + Int32 x, size, number; + + // Clear the missle table to start with + for(number = 0; number < 8; ++number) + for(size = 0; size < 4; ++size) + for(x = 0; x < 160; ++x) + MxMask[0][number][size][x] = false; + + for(number = 0; number < 8; ++number) + { + for(size = 0; size < 4; ++size) + { + for(x = 0; x < 160 + 72; ++x) + { + // Only one copy of the missle + if((number == 0x00) || (number == 0x05) || (number == 0x07)) + { + if((x >= 0) && (x < (1 << size))) + MxMask[0][number][size][x % 160] = true; + } + // Two copies - close + else if(number == 0x01) + { + if((x >= 0) && (x < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 16) >= 0) && ((x - 16) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + } + // Two copies - medium + else if(number == 0x02) + { + if((x >= 0) && (x < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 32) >= 0) && ((x - 32) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + } + // Three copies - close + else if(number == 0x03) + { + if((x >= 0) && (x < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 16) >= 0) && ((x - 16) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 32) >= 0) && ((x - 32) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + } + // Two copies - wide + else if(number == 0x04) + { + if((x >= 0) && (x < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 64) >= 0) && ((x - 64) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + } + // Three copies - medium + else if(number == 0x06) + { + if((x >= 0) && (x < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 32) >= 0) && ((x - 32) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + else if(((x - 64) >= 0) && ((x - 64) < (1 << size))) + MxMask[0][number][size][x % 160] = true; + } + } + + // Copy data into wrap-around area + for(x = 0; x < 160; ++x) + MxMask[0][number][size][x + 160] = + MxMask[0][number][size][x]; + } + } + + // Now, copy data for alignments of 1, 2 and 3 + for(uInt32 align = 1; align < 4; ++align) + { + for(number = 0; number < 8; ++number) + { + for(size = 0; size < 4; ++size) + { + for(x = 0; x < 320; ++x) + { + MxMask[align][number][size][x] = + MxMask[0][number][size][(x + 320 - align) % 320]; + } + } + } + } +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void TIATables::buildBLMaskTable() // [4][4][320] +{ + // First, calculate masks for alignment 0 + for(Int32 size = 0; size < 4; ++size) + { + Int32 x; + + // Set all of the masks to false to start with + for(x = 0; x < 160; ++x) + { + BLMask[0][size][x] = false; + } + + // Set the necessary fields true + for(x = 0; x < 160 + 8; ++x) + { + if((x >= 0) && (x < (1 << size))) + { + BLMask[0][size][x % 160] = true; + } + } + + // Copy fields into the wrap-around area of the mask + for(x = 0; x < 160; ++x) + { + BLMask[0][size][x + 160] = BLMask[0][size][x]; + } + } + + // Now, copy data for alignments of 1, 2 and 3 + for(uInt32 align = 1; align < 4; ++align) + { + for(uInt32 size = 0; size < 4; ++size) + { + for(uInt32 x = 0; x < 320; ++x) + { + BLMask[align][size][x] = BLMask[0][size][(x + 320 - align) % 320]; + } + } + } +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void TIATables::buildPFMaskTable() // [2][160] +{ + Int32 x; + + // Compute playfield mask table for non-reflected mode + for(x = 0; x < 160; ++x) + { + if(x < 16) + PFMask[0][x] = 0x00001 << (x / 4); + else if(x < 48) + PFMask[0][x] = 0x00800 >> ((x - 16) / 4); + else if(x < 80) + PFMask[0][x] = 0x01000 << ((x - 48) / 4); + else if(x < 96) + PFMask[0][x] = 0x00001 << ((x - 80) / 4); + else if(x < 128) + PFMask[0][x] = 0x00800 >> ((x - 96) / 4); + else if(x < 160) + PFMask[0][x] = 0x01000 << ((x - 128) / 4); + } + + // Compute playfield mask table for reflected mode + for(x = 0; x < 160; ++x) + { + if(x < 16) + PFMask[1][x] = 0x00001 << (x / 4); + else if(x < 48) + PFMask[1][x] = 0x00800 >> ((x - 16) / 4); + else if(x < 80) + PFMask[1][x] = 0x01000 << ((x - 48) / 4); + else if(x < 112) + PFMask[1][x] = 0x80000 >> ((x - 80) / 4); + else if(x < 144) + PFMask[1][x] = 0x00010 << ((x - 112) / 4); + else if(x < 160) + PFMask[1][x] = 0x00008 >> ((x - 144) / 4); + } +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void TIATables::buildGRPReflectTable() +{ + for(uInt16 i = 0; i < 256; ++i) + { + uInt8 r = 0; + + for(uInt16 t = 1; t <= 128; t *= 2) + { + r = (r << 1) | ((i & t) ? 0x01 : 0x00); + } + + GRPReflect[i] = r; + } +} + +// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +void TIATables::buildPxPosResetWhenTable() { uInt32 mode, oldx, newx; @@ -349,7 +407,7 @@ void TIATables::computePlayerPositionResetWhenTable() // Set everything to 0 for non-delay/non-display section for(newx = 0; newx < 160; ++newx) { - PlayerPositionResetWhenTable[mode][oldx][newx] = 0; + PxPosResetWhen[mode][oldx][newx] = 0; } // Now, we'll set the entries for non-delay/non-display section @@ -358,94 +416,94 @@ void TIATables::computePlayerPositionResetWhenTable() if(mode == 0x00) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x01) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 16)) && (newx < (oldx + 16 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 16 + 4) && (newx < (oldx + 16 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x02) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 32)) && (newx < (oldx + 32 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 32 + 4) && (newx < (oldx + 32 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x03) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 16)) && (newx < (oldx + 16 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 32)) && (newx < (oldx + 32 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 16 + 4) && (newx < (oldx + 16 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 32 + 4) && (newx < (oldx + 32 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x04) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 64)) && (newx < (oldx + 64 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 64 + 4) && (newx < (oldx + 64 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x05) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 16))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x06) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 32)) && (newx < (oldx + 32 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; else if((newx >= (oldx + 64)) && (newx < (oldx + 64 + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 32 + 4) && (newx < (oldx + 32 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; else if((newx >= oldx + 64 + 4) && (newx < (oldx + 64 + 4 + 8))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } else if(mode == 0x07) { if((newx >= oldx) && (newx < (oldx + 4))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = -1; + PxPosResetWhen[mode][oldx][newx % 160] = -1; if((newx >= oldx + 4) && (newx < (oldx + 4 + 32))) - PlayerPositionResetWhenTable[mode][oldx][newx % 160] = 1; + PxPosResetWhen[mode][oldx][newx % 160] = 1; } } @@ -453,9 +511,9 @@ void TIATables::computePlayerPositionResetWhenTable() uInt32 s1 = 0, s2 = 0; for(newx = 0; newx < 160; ++newx) { - if(PlayerPositionResetWhenTable[mode][oldx][newx] == -1) + if(PxPosResetWhen[mode][oldx][newx] == -1) ++s1; - if(PlayerPositionResetWhenTable[mode][oldx][newx] == 1) + if(PxPosResetWhen[mode][oldx][newx] == 1) ++s2; } assert((s1 % 4 == 0) && (s2 % 8 == 0)); @@ -464,72 +522,16 @@ void TIATables::computePlayerPositionResetWhenTable() } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computePlayerReflectTable() -{ - for(uInt16 i = 0; i < 256; ++i) - { - uInt8 r = 0; - - for(uInt16 t = 1; t <= 128; t *= 2) - { - r = (r << 1) | ((i & t) ? 0x01 : 0x00); - } - - PlayerReflectTable[i] = r; - } -} +uInt8 TIATables::BLMask[4][4][320]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -void TIATables::computePlayfieldMaskTable() -{ - Int32 x; - - // Compute playfield mask table for non-reflected mode - for(x = 0; x < 160; ++x) - { - if(x < 16) - PlayfieldTable[0][x] = 0x00001 << (x / 4); - else if(x < 48) - PlayfieldTable[0][x] = 0x00800 >> ((x - 16) / 4); - else if(x < 80) - PlayfieldTable[0][x] = 0x01000 << ((x - 48) / 4); - else if(x < 96) - PlayfieldTable[0][x] = 0x00001 << ((x - 80) / 4); - else if(x < 128) - PlayfieldTable[0][x] = 0x00800 >> ((x - 96) / 4); - else if(x < 160) - PlayfieldTable[0][x] = 0x01000 << ((x - 128) / 4); - } - - // Compute playfield mask table for reflected mode - for(x = 0; x < 160; ++x) - { - if(x < 16) - PlayfieldTable[1][x] = 0x00001 << (x / 4); - else if(x < 48) - PlayfieldTable[1][x] = 0x00800 >> ((x - 16) / 4); - else if(x < 80) - PlayfieldTable[1][x] = 0x01000 << ((x - 48) / 4); - else if(x < 112) - PlayfieldTable[1][x] = 0x80000 >> ((x - 80) / 4); - else if(x < 144) - PlayfieldTable[1][x] = 0x00010 << ((x - 112) / 4); - else if(x < 160) - PlayfieldTable[1][x] = 0x00008 >> ((x - 144) / 4); - } -} +uInt16 TIATables::CollisionMask[64]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt8 TIATables::BallMaskTable[4][4][320]; +uInt8 TIATables::DisabledMask[640]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt16 TIATables::CollisionTable[64]; - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt8 TIATables::DisabledMaskTable[640]; - -// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -const Int16 TIATables::PokeDelayTable[64] = { +const Int16 TIATables::PokeDelay[64] = { 0, 1, 0, 0, 8, 8, 0, 0, 0, 0, 0, 1, 1, -1, -1, -1, 0, 0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -537,7 +539,7 @@ const Int16 TIATables::PokeDelayTable[64] = { }; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt8 TIATables::MissleMaskTable[4][8][4][320]; +uInt8 TIATables::MxMask[4][8][4][320]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - const bool TIATables::HMOVEBlankEnableCycles[76] = { @@ -552,7 +554,7 @@ const bool TIATables::HMOVEBlankEnableCycles[76] = { }; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -const Int32 TIATables::CompleteMotionTable[76][16] = { +const Int32 TIATables::CompleteMotion[76][16] = { { 0, -1, -2, -3, -4, -5, -6, -7, 8, 7, 6, 5, 4, 3, 2, 1}, // HBLANK { 0, -1, -2, -3, -4, -5, -6, -7, 8, 7, 6, 5, 4, 3, 2, 1}, // HBLANK { 0, -1, -2, -3, -4, -5, -6, -7, 8, 7, 6, 5, 4, 3, 2, 1}, // HBLANK @@ -632,13 +634,13 @@ const Int32 TIATables::CompleteMotionTable[76][16] = { }; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt8 TIATables::PlayerMaskTable[4][2][8][320]; +uInt8 TIATables::PxMask[4][2][8][320]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -Int8 TIATables::PlayerPositionResetWhenTable[8][160][160]; +Int8 TIATables::PxPosResetWhen[8][160][160]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt8 TIATables::PlayerReflectTable[256]; +uInt8 TIATables::GRPReflect[256]; // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -uInt32 TIATables::PlayfieldTable[2][160]; +uInt32 TIATables::PFMask[2][160]; diff --git a/stella/src/emucore/TIATables.hxx b/stella/src/emucore/TIATables.hxx index 77134cb6e..d08c59c1c 100644 --- a/stella/src/emucore/TIATables.hxx +++ b/stella/src/emucore/TIATables.hxx @@ -13,7 +13,7 @@ // See the file "license" for information on usage and redistribution of // this file, and for a DISCLAIMER OF ALL WARRANTIES. // -// $Id: TIATables.hxx,v 1.1 2009-01-19 16:52:32 stephena Exp $ +// $Id: TIATables.hxx,v 1.2 2009-02-08 21:07:06 stephena Exp $ //============================================================================ #ifndef TIA_TABLES_HXX @@ -102,7 +102,7 @@ enum { here. @author Stephen Anthony - @version $Id: TIATables.hxx,v 1.1 2009-01-19 16:52:32 stephena Exp $ + @version $Id: TIATables.hxx,v 1.2 2009-02-08 21:07:06 stephena Exp $ */ class TIATables { @@ -112,61 +112,61 @@ class TIATables */ static void computeAllTables(); - // Ball mask table (entries are true or false) - static uInt8 BallMaskTable[4][4][320]; - // Used to set the collision register to the correct value - static uInt16 CollisionTable[64]; + static uInt16 CollisionMask[64]; // A mask table which can be used when an object is disabled - static uInt8 DisabledMaskTable[640]; + static uInt8 DisabledMask[640]; // Indicates the update delay associated with poking at a TIA address - static const Int16 PokeDelayTable[64]; - - // Missle mask table (entries are true or false) - static uInt8 MissleMaskTable[4][8][4][320]; + static const Int16 PokeDelay[64]; // Used to convert value written in a motion register into // its internal representation - static const Int32 CompleteMotionTable[76][16]; + static const Int32 CompleteMotion[76][16]; // Indicates if HMOVE blanks should occur for the corresponding cycle static const bool HMOVEBlankEnableCycles[76]; // Player mask table - static uInt8 PlayerMaskTable[4][2][8][320]; + static uInt8 PxMask[4][2][8][320]; - // Indicates if player is being reset during delay, display or other times - static Int8 PlayerPositionResetWhenTable[8][160][160]; + // Missle mask table (entries are true or false) + static uInt8 MxMask[4][8][4][320]; - // Used to reflect a players graphics - static uInt8 PlayerReflectTable[256]; + // Ball mask table (entries are true or false) + static uInt8 BLMask[4][4][320]; // Playfield mask table for reflected and non-reflected playfields - static uInt32 PlayfieldTable[2][160]; + static uInt32 PFMask[2][160]; + + // Used to reflect a players graphics + static uInt8 GRPReflect[256]; + + // Indicates if player is being reset during delay, display or other times + static Int8 PxPosResetWhen[8][160][160]; private: - // Compute the ball mask table - static void computeBallMaskTable(); - // Compute the collision decode table - static void computeCollisionTable(); - - // Compute the missle mask table - static void computeMissleMaskTable(); + static void buildCollisionMaskTable(); // Compute the player mask table - static void computePlayerMaskTable(); + static void buildPxMaskTable(); - // Compute the player position reset when table - static void computePlayerPositionResetWhenTable(); + // Compute the missle mask table + static void buildMxMaskTable(); - // Compute the player reflect table - static void computePlayerReflectTable(); + // Compute the ball mask table + static void buildBLMaskTable(); // Compute playfield mask table - static void computePlayfieldMaskTable(); + static void buildPFMaskTable(); + + // Compute the player reflect table + static void buildGRPReflectTable(); + + // Compute the player position reset when table + static void buildPxPosResetWhenTable(); }; #endif