@@ unsigned char video_buffer[ PacmanMachine::ScreenWidth * PacmanMachine::ScreenHeight ];
@@ unsigned char * vbuf = video_buffer;
@@ const unsigned * palette = arcade.getPalette();
@@
@@ arcade.renderVideo( vbuf );
@@
@@ for( int y=0; y> 8) & 0xFF;
@@ unsigned char blue = (color >> 16) & 0xFF;
@@
@@ setPixel( x, y, red, green, blue );
@@ }
@@ }
*/
virtual void renderVideo( unsigned char * buffer );
/**
Returns a pointer to the decoded 32 color palette: each entry contains
a color in RGB format encoded as 0x00bbggrr.
*/
const unsigned * getPalette() const {
return palette_;
}
/**
Returns a pointer to the 20K ROM/RAM buffer containing the 16K game
ROM (starting at 0x0000) and 4K of RAM (starting at 0x4000, this
includes the video RAM at 0x4000-0x43FF and the color RAM at
0x4400-0x47FF).
The first 16K of the buffer contain the game ROM as specified in the
setROM() function.
*/
const unsigned char * getRAM() const {
return ram_;
}
/**
Returns a pointer to the current settings of the specified sprite.
This function is only necessary if the application wants to perform
its own rendering, because renderVideo() already draws the sprites.
@see #renderVideo
*/
const PacmanSprite * getSprite( int index ) const {
return &(sprites_[index]);
}
/**
Returns a pointer to the video memory in "normalized" form
(224x288, one byte per pixel).
Note: Pacman has a rather peculiar video/color memory layout but this
buffer is kept "normalized" by the emulator so it has the same
format as the output buffer used by renderVideo(). The raw video
memory can be found in the RAM buffer at 0x4000-0x43FF.
This function is only necessary if the application wants to perform
its own rendering, because renderVideo() already draws the video.
@see #renderVideo
*/
const unsigned char * getVideoMem() const {
return video_mem_;
}
/**
Returns a pointer to the color memory in "normalized" form
(224x288, one byte per pixel).
Note: Pacman has a rather peculiar video/color memory layout but this
buffer is kept "normalized" by the emulator so it has the same
format as the output buffer used by renderVideo(). The raw color
memory can be found in the RAM buffer at 0x4400-0x47FF.
This function is only necessary if the application wants to perform
its own rendering, because renderVideo() already draws the video.
@see #renderVideo
*/
const unsigned char * getColorMem() const {
return color_mem_;
}
/**
Returns the size of the buffer needed to take a snapshot of the machine.
*/
virtual unsigned getSizeOfSnapshotBuffer() const;
/**
Takes a snapshot of the machine.
A snapshot saves all of the machine memory and settings, including RAM,
ROM, CPU status and I/O registers. It can be restored at any time to bring
the machine back to the exact status it had when the snapshot was taken.
Snapshots come very handy to save the progress of a game during a good
performance!
Note: the size of the snapshot buffer must be no less than the size
returned by the getSizeOfSnapshotBuffer() function.
@param buffer buffer where the snapshot data is stored
@return the number of bytes written into the buffer
*/
virtual unsigned takeSnapshot( unsigned char * buffer );
/**
Restores a snapshot taken with takeSnapshot().
This function uses the data saved in the snapshot buffer to restore the
machine status.
@param buffer buffer where the snapshot data is stored
@return the number of bytes read from the buffer
*/
virtual unsigned restoreSnapshot( unsigned char * buffer );
/**
Decodes and expands the 4K ROM containing the character definitions into a 16K RAM
buffer where each byte correspond directly to a 8x8 character pixel.
*/
static void decodeCharSet( unsigned char * mem, unsigned char * charset );
/**
Decodes and expands the 4K ROM containing the sprite definitions into a 16K RAM
buffer where each byte correspond directly to a 16x16 sprite pixel.
*/
static void decodeSprites( unsigned char * mem, unsigned char * sprite_data );
/** Decode one byte from the encoded color palette. */
static unsigned decodePaletteByte( unsigned char b );
/** Returns the status of the start light for player one. */
unsigned char getPlayerOneLight() const {
return output_devices_ & PlayerOneLight ? 1 : 0;
}
/** Returns the status of the start light for player two. */
unsigned char getPlayerTwoLight() const {
return output_devices_ & PlayerTwoLight ? 1 : 0;
}
/** Returns the status of the coin lockout door. */
unsigned char getCoinLockout() const {
return output_devices_ & CoinLockout ? 1 : 0;
}
/**
Enables/disables a common speed hack that allows Pacman to
move four times faster than the ghosts.
@param enabled true to enabled the hack, false to disable
@return 0 if successful, otherwise the patch could not be applied
(probably because the loaded ROM set does not support it)
*/
virtual int setSpeedHack( int enabled );
// Implementation of the CpuEnvironment interface
unsigned char readByte( unsigned addr );
void writeByte( unsigned, unsigned char );
unsigned char readPort( unsigned port );
void writePort( unsigned, unsigned char );
protected:
// Utilities
void drawChar( unsigned char * buffer, int index, int ox, int oy, int color );
void drawSprite( unsigned char * buffer, int index );
// Helper functions for working with ROM data
static void decodeCharByte( unsigned char b, unsigned char * charbuf, int charx, int chary, int charwidth );
static void decodeCharLine( unsigned char * src, unsigned char * charbuf, int charx, int chary, int charwidth );
// Descendants can get write access to some members
unsigned getSizeOfRAM() const {
return sizeof(ram_);
}
unsigned char * getAddrOfRAM() {
return ram_;
}
private:
// Output flip-flops
enum {
FlipScreen = 0x01,
PlayerOneLight = 0x02,
PlayerTwoLight = 0x04,
InterruptEnabled = 0x08,
SoundEnabled = 0x10,
CoinLockout = 0x20,
CoinMeter = 0x40,
AuxBoardEnabled = 0x80
};
void setOutputFlipFlop( unsigned char bit, unsigned char value );
void getDeviceInfo( InputDevice device, unsigned char * mask, unsigned char ** port );
private:
PacmanMachine( const PacmanMachine & );
PacmanMachine & operator = ( const PacmanMachine & );
private:
unsigned char ram_[20*1024]; // ROM (16K) and RAM (4K)
unsigned char charset_rom_[4*1024]; // Character set ROM (4K)
unsigned char spriteset_rom_[4*1024]; // Sprite set ROM (4K)
unsigned char video_mem_[1024]; // Video memory (1K)
unsigned char color_mem_[1024]; // Color memory (1K)
unsigned char color_data_[256];
unsigned char palette_data_[32]; // Encoded palette data
unsigned char charmap_[256*8*8]; // Character data for 256 8x8 characters
unsigned char spritemap_[64*16*16]; // Sprite data for 64 16x16 sprites
unsigned char dip_switches_;
unsigned char port1_;
unsigned char port2_;
unsigned char output_devices_; // Output flip-flops set by the game program
unsigned char interrupt_vector_;
unsigned coin_counter_;
unsigned frame_counter_; // How many times run() has been called since last reset()
NamcoWsg3 sound_chip_;
Z80 * cpu_;
// Internal tables and structures for faster access to data
PacmanSprite sprites_[8]; // Sprites
unsigned palette_[256]; // Color palette
int vchar_to_x_[1024];
int vchar_to_y_[1024];
int vchar_to_i_[1024];
};
/**
Ms.Pacman machine emulator.
Ms. Pacman hardware is identical to the Pacman hardware
with an extra board added. This board mainly contains new ROMs for
both code and graphics.
The MsPacmanMachine class emulates the above hardware by extending the
base PacmanMachine class with the functions needed to emulate only the
extra board and logic. While not optimal for performance, this approach
is remarkably easy to implement are requires very little code.
*/
class MsPacmanMachine : public PacmanMachine
{
public:
/**
Constructor.
*/
MsPacmanMachine() : PacmanMachine(), aux_board_enabled_(0) {
}
/**
Destructor.
*/
virtual ~MsPacmanMachine() {
}
/**
Sets the ROMs found on the auxiliary board.
Note: the original encrypted ROMs must be specified here, they will
be decrypted by the emulator.
@param u5 2K ROM at board location U5
@param u6 4K ROM at board location U6
@param u7 4K ROM at board location U7
*/
void setAuxROM( unsigned char * u5, unsigned char * u6, unsigned char * u7 );
/**
Enables/disables a common speed hack that allows Pacman to
move four times faster than the ghosts.
@param enabled true to enabled the hack, false to disable
@return 0 if successful, otherwise the patch could not be applied
(probably because the loaded ROM set does not support it)
*/
virtual int setSpeedHack( int enabled );
/**
Returns the size of the buffer needed to take a snapshot of the machine.
@see PacmanMachine::getSizeOfSnapshotBuffer
*/
virtual unsigned getSizeOfSnapshotBuffer() const;
/**
Takes a snapshot of the machine.
A snapshot saves all of the machine memory and settings, including RAM,
ROM, CPU status and I/O registers. It can be restored at any time to bring
the machine back to the exact status it had when the snapshot was taken.
Snapshots come very handy to save the progress of a game during a good
performance!
Note: the size of the snapshot buffer must be no less than the size
returned by the getSizeOfSnapshotBuffer() function.
@param buffer buffer where the snapshot data is stored
@return the number of bytes written into the buffer
@see PacmanMachine::takeSnapshot
*/
virtual unsigned takeSnapshot( unsigned char * buffer );
/**
Restores a snapshot taken with takeSnapshot().
This function uses the data saved in the snapshot buffer to restore the
machine status.
@param buffer buffer where the snapshot data is stored
@return the number of bytes read from the buffer
@see PacmanMachine::restoreSnapshot
*/
virtual unsigned restoreSnapshot( unsigned char * buffer );
protected:
// Implementation of the CpuEnvironment interface
unsigned char readByte( unsigned addr );
void writeByte( unsigned, unsigned char );
private:
unsigned char rom_aux_[26*1024]; // 10K new ROM plus 16K to backup old ROM (because it gets patched)
unsigned char aux_board_enabled_; // Whether the aux board has been enabled or not
};
#endif // ARCADE_H_