void initState(int state) {
if (state == STARTSCREEN) {
loadPalette(startScreenPal);
DMANow(3, startScreenTiles, &CHARBLOCKBASE[0], startScreenTilesLen);
DMANow(3, startScreenMap, &SCREENBLOCKBASE[27], startScreenMapLen);
DMANow(3, startScreenTiles, &CHARBLOCKBASE[1], startScreenTilesLen);
DMANow(3, startScreenMap, &SCREENBLOCKBASE[25], startScreenMapLen);
selector = 0;
selectRow = 100;
selectCol = 56;
}
else if (state == PAUSESCREEN) {
loadPalette(startScreenPal);
DMANow(3, pauseScreenTiles, &CHARBLOCKBASE[0], pauseScreenTilesLen);
DMANow(3, pauseScreenMap, &SCREENBLOCKBASE[27], pauseScreenMapLen);
DMANow(3, pauseScreenTiles, &CHARBLOCKBASE[1], pauseScreenTilesLen);
DMANow(3, pauseScreenMap, &SCREENBLOCKBASE[25], pauseScreenMapLen);
}
else if (state == INSTRUCTIONSCREEN) {
DMANow(3, instructionScreenTiles, &CHARBLOCKBASE[0], instructionScreenTilesLen);
DMANow(3, instructionScreenMap, &SCREENBLOCKBASE[27], instructionScreenMapLen);
DMANow(3, instructionScreenTiles, &CHARBLOCKBASE[1], instructionScreenTilesLen);
DMANow(3, instructionScreenMap, &SCREENBLOCKBASE[25], instructionScreenMapLen);
}
else if (state == WINSCREEN) {
loadPalette(startScreenPal);
DMANow(3, winScreenTiles, &CHARBLOCKBASE[0], winScreenTilesLen);
DMANow(3, winScreenMap, &SCREENBLOCKBASE[27], winScreenMapLen);
DMANow(3, winScreenTiles, &CHARBLOCKBASE[1], winScreenTilesLen);
DMANow(3, winScreenMap, &SCREENBLOCKBASE[25], winScreenMapLen);
}
else if (state == LOSESCREEN) {
loadPalette(startScreenPal);
DMANow(3, loseScreenTiles, &CHARBLOCKBASE[0], loseScreenTilesLen);
DMANow(3, loseScreenMap, &SCREENBLOCKBASE[27], loseScreenMapLen);
DMANow(3, loseScreenTiles, &CHARBLOCKBASE[1], loseScreenTilesLen);
DMANow(3, loseScreenMap, &SCREENBLOCKBASE[25], loseScreenMapLen);
}
hideSprites();
clearShadowOAM();
if (state == PAUSESCREEN) {
pauseSound();
}
else {
stopSound();
}
REG_BG0HOFS = 0;
REG_BG0VOFS = 0;
REG_BG1HOFS = 0;
}
GfxPalette32::GfxPalette32(ResourceManager *resMan)
: _resMan(resMan),
// Palette versioning
_version(1),
_needsUpdate(false),
_currentPalette(),
_sourcePalette(),
_nextPalette(),
// Palette varying
_varyStartPalette(nullptr),
_varyTargetPalette(nullptr),
_varyFromColor(0),
_varyToColor(255),
_varyLastTick(0),
_varyTime(0),
_varyDirection(0),
_varyTargetPercent(0),
_varyNumTimesPaused(0),
// Palette cycling
_cyclers(),
_cycleMap() {
_varyPercent = _varyTargetPercent;
for (int i = 0, len = ARRAYSIZE(_fadeTable); i < len; ++i) {
_fadeTable[i] = 100;
}
loadPalette(999);
}
// Returns index of passed paletteAsset in video memory. DMA copies it if needed
uint8 assets::getPalette(paletteAsset *pal)
{
// Don't do anything if passed NULL
if (!pal) return 0;
// Return its index if it's already loaded
if (pal->vmLoaded)
return pal->index;
// If it's not in main memory for some reason, load it
if (!pal->mmLoaded)
loadPalette(pal);
// Keep track of which index a palette can be loaded into
static int curIndex = 0;
// TODO: add support for 256 color palettes
static const int numColors = 16;
DC_FlushRange(pal->data, pal->length);
dmaCopyHalfWordsAsynch(3, pal->data, &SPRITE_PALETTE[curIndex * numColors], pal->length);
// Update the paletteAsset's information
pal->vmLoaded = true;
pal->index = curIndex;
//iprintf("pal vmLoaded -> %d\n", curIndex);
// Update the index for the next call
curIndex++;
// return index
return curIndex - 1;
}
void lose() {
REG_DISPCTL = MODE4 | BG2_ENABLE;
loadPalette(gameover_screenPal);
drawBackgroundImage4(gameover_screenBitmap);
while (1) {
oldButtons = buttons;
buttons = BUTTONS;
if (BUTTON_PRESSED(BUTTON_A)) {
init();
setupLevel();
state = GAME;
return;
}
if (BUTTON_PRESSED(BUTTON_SELECT)) {
playSoundB(menuSound, MENUSOUNDLEN, MENUSOUNDFREQ, 0);
playSoundA(titleSong, TITLESONGLEN, TITLESONGFREQ, 1);
state = SPLASH;
return;
}
}
}
void PaletteEditor::paletteIndexChangedAction(const QModelIndex& idx)
{
if (!idx.isValid()) return;
loadPalette(idx.row());
setPaletteView();
emit paletteChanged();
emit undoStateSignal();
}
PaletteEditor::PaletteEditor ( QWidget* parent )
: QWidget(parent), checkers(15)
{
setupUi ( this );
loadPalette(0);
m_palettesView->setModel(&m_flamPalettes);
m_browseView->setModel(&m_browsePalettes);
hasUGR = false;
QSettings settings;
settings.beginGroup("paletteeditor");
m_tabWidget->setCurrentIndex(settings.value("tabwidgetindex", 0).toInt());
m_lastBrowseDir = settings.value("lastdirectory", QDir::homePath()).toString();
m_gradientEnds->setArrowDirection(Qt::DownArrow);
m_gradientEnds->setMenuEnabled(false);
m_gradientSpreadGroup = new QButtonGroup(this);
m_gradientSpreadGroup->addButton(m_padSpreadButton, QGradient::PadSpread);
m_gradientSpreadGroup->addButton(m_repeatSpreadButton, QGradient::RepeatSpread);
m_gradientSpreadGroup->addButton(m_reflectSpreadButton, QGradient::ReflectSpread);
m_padSpreadButton->setChecked(true);
// restore the gradient from settings
int nstops( settings.beginReadArray("gradient") );
if (nstops > 1)
{
GradientStops stops;
for (int n = 0 ; n < nstops ; n++)
{
settings.setArrayIndex(n);
double pos( settings.value("pos").toDouble() );
QColor color( settings.value("color").value<QColor>()) ;
stops.append(GradientStop( pos, color ));
}
settings.endArray();
p_stops = stops;
m_gradientStops->setStops(stops);
}
stopsChangedAction();
connect(m_palettesView, SIGNAL(pressed(const QModelIndex&)), this, SLOT(paletteIndexChangedAction(const QModelIndex&)));
connect(m_browseView, SIGNAL(pressed(const QModelIndex&)), this, SLOT(selectGradientAction(const QModelIndex&)));
connect(m_rotateSlider, SIGNAL(valueChanged(int)), this, SLOT(paletteRotatedAction(int)));
connect(m_rotateSlider, SIGNAL(sliderReleased()), this, SIGNAL(undoStateSignal()));
connect(m_openButton, SIGNAL(clicked(bool)), this, SLOT(openGradientAction(bool)));
connect(m_gradientStops, SIGNAL(stopsChanged()), this, SLOT(stopsChangedAction()));
connect(m_gradientStops, SIGNAL(stopsDropped()), this, SIGNAL(undoStateSignal()));
connect(m_gradientEnds, SIGNAL(stopsChanged()), this, SLOT(stopsChangedAction()));
connect(m_gradientEnds, SIGNAL(stopsDropped()), this, SIGNAL(undoStateSignal()));
connect(m_gradientSpreadGroup, SIGNAL(buttonClicked(int)), this, SLOT(stopsChangedAction()));
connect(m_gradientSpreadGroup, SIGNAL(buttonClicked(int)), this, SIGNAL(undoStateSignal()));
connect(m_resetGradientButton, SIGNAL(clicked(bool)), this, SLOT(resetGradientAction()));
connect(m_resetGradientButton, SIGNAL(clicked(bool)), this, SIGNAL(undoStateSignal()));
connect(m_saveGradientButton, SIGNAL(clicked(bool)), this, SLOT(saveGradientAction()));
connect(m_browseLineEdit, SIGNAL(returnPressed()), this, SLOT(browsePathChangedAction()));
connect(m_randomGradientButton, SIGNAL(clicked(bool)), this, SLOT(createRandomGradientAction()));
connect(m_randomGradientButton, SIGNAL(clicked(bool)), this, SIGNAL(undoStateSignal()));
}
int main()
{
REG_DISPCTL = MODE4 | BG2_ENABLE | BUFFER1FLAG;
loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
int state = BEGIN;
while(1)
{
switch(state)
{
case BEGIN:
// loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
drawImage4(0, 0, 240, 160, (u16*)screen);
waitForVblank();
FlipPage();
while(!KEY_DOWN_NOW(BUTTON_START));
state = GAME;
break;
case GAME:
state = play();
break;
case WIN:
loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
drawImage4(0, 0, 240, 160, (u16*)win);
drawString4(5, 8, "Press Select", PALETTE[0]);
waitForVblank();
FlipPage();
while(!KEY_DOWN_NOW(BUTTON_SELECT));
state = BEGIN;
break;
case LOSE:
// loadPalette(pics_palette, PICS_PALETTE_SIZE, 0);
drawImage4(0, 0, 240, 160, (u16*)die);
waitForVblank();
FlipPage();
while(!KEY_DOWN_NOW(BUTTON_SELECT));
state = BEGIN;
break;
default:
break;
}
}
return 0;
}
bool IFFDecoder::loadStream(Common::SeekableReadStream &stream) {
destroy();
const uint32 form = stream.readUint32BE();
if (form != ID_FORM) {
warning("Failed reading IFF-file");
return false;
}
stream.skip(4);
const uint32 type = stream.readUint32BE();
switch (type) {
case ID_ILBM:
_type = TYPE_ILBM;
break;
case ID_PBM:
_type = TYPE_PBM;
break;
}
if (type == TYPE_UNKNOWN) {
warning("Failed reading IFF-file");
return false;
}
while (1) {
const uint32 chunkType = stream.readUint32BE();
const uint32 chunkSize = stream.readUint32BE();
if (stream.eos())
break;
switch (chunkType) {
case ID_BMHD:
loadHeader(stream);
break;
case ID_CMAP:
loadPalette(stream, chunkSize);
break;
case ID_CRNG:
loadPaletteRange(stream, chunkSize);
break;
case ID_BODY:
loadBitmap(stream);
break;
default:
stream.skip(chunkSize);
}
}
return true;
}
MainWindow::MainWindow(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
setupUi(this);
menuView->addAction(fileBrowserDock->toggleViewAction());
menuView->addAction(informationDock->toggleViewAction());
menuView->addAction(drawingDock->toggleViewAction());
// Load and initialize palettes
_ildaPalette = loadPalette(":/data/ilda.palette");
_pangolinPalette = loadPalette(":/data/pangolin.palette");
_currentPalette = &_ildaPalette;
// File browser
QFileSystemModel *fsModel = new QFileSystemModel(this);
fsModel->setRootPath(QDir::rootPath());
fsModel->setNameFilterDisables(false);
fsModel->setNameFilters(QStringList() << "*.ild");
treeView->setModel(fsModel);
treeView->header()->setResizeMode(0, QHeaderView::ResizeToContents);
//treeView->setSortingEnabled(true);
//treeView->sortByColumn(0, Qt::AscendingOrder);
treeView->setColumnHidden(2, true);
treeView->setColumnHidden(3, true);
//treeView->setRootIndex(fsModel->index(QDir::homePath()));
// Create the connections
connect(actionOpen, SIGNAL(triggered()), this, SLOT(fileOpen()));
connect(actionSaveAs, SIGNAL(triggered()), this, SLOT(fileSaveAs()));
connect(actionPangolin_palette, SIGNAL(triggered()), SLOT(usePangolinPalette()));
connect(actionILDA_palette, SIGNAL(triggered()), SLOT(useILDAPalette()));
connect(actionAbout, SIGNAL(triggered()), SLOT(about()));
connect(treeView, SIGNAL(clicked(QModelIndex)), SLOT(fileBrowserItemClicked(QModelIndex)));
connect(treeView, SIGNAL(doubleClicked(QModelIndex)), SLOT(fileBrowserItemDblClicked(QModelIndex)));
connect(normalRadioButton, SIGNAL(clicked()), SLOT(drawModeChanged()));
connect(diagnosticRadioButton, SIGNAL(clicked()), SLOT(drawModeChanged()));
// restore settings
readSettings();
}
/**
* Initialize the game state
*/
Common::ErrorCode MortevielleEngine::initialize() {
// Initialize graphics mode
initGraphics(SCREEN_WIDTH, SCREEN_HEIGHT, true);
// Set debug channels
DebugMan.addDebugChannel(kMortevielleCore, "core", "Core debugging");
DebugMan.addDebugChannel(kMortevielleGraphics, "graphics", "Graphics debugging");
// Set up an intermediate screen surface
_screenSurface.create(SCREEN_WIDTH, SCREEN_HEIGHT, Graphics::PixelFormat::createFormatCLUT8());
_txxFileFl = false;
// Load texts from TXX files
loadTexts();
// Load the mort.dat resource
Common::ErrorCode result = loadMortDat();
if (result != Common::kNoError) {
_screenSurface.free();
return result;
}
// Load some error messages (was previously in chartex())
_hintPctMessage = getString(580); // You should have noticed %d hints
// Set default EGA palette
_paletteManager.setDefaultPalette();
// Setup the mouse cursor
initMouse();
loadPalette();
loadCFIPH();
loadCFIEC();
decodeNumber(&_cfiecBuffer[161 * 16], (_cfiecBufferSize - (161 * 16)) / 64);
_x26KeyCount = 1;
initMaxAnswer();
initMouse();
loadPlaces();
_soundOff = false;
_largestClearScreen = false;
testKeyboard();
showConfigScreen();
testKeyboard();
clearScreen();
_soundManager.loadNoise();
_soundManager.loadAmbiantSounds();
return Common::kNoError;
}
Uint32 LoadPaletteCallback( Uint32 interval, void *param)
{
new GUI_FileDialog( topWin, false, "*.txt", "Untitled.txt", [](const char *fn) -> bool {
GUI_Log( "File Load Pal: %s\n", fn );
loadPalette( fn );
for( int i=0; i<numColor; i++ ) {
c[i]->color = mainPalette[activePalette][i];
}
return true;
});
return 0;
}
MainWindow::MainWindow(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
setupUi(this);
frameSlider->setPageStep(1);
frameSlider->setSingleStep(1);
connect(actionOpen, SIGNAL(triggered()), this, SLOT(fileOpen()));
connect(actionPangolin_palette, SIGNAL(triggered()), SLOT(usePangolinPalette()));
connect(actionILDA_palette, SIGNAL(triggered()), SLOT(useILDAPalette()));
connect(actionAbout, SIGNAL(triggered()), SLOT(about()));
QGraphicsScene *scene = new QGraphicsScene();
_noFileLoadedItem = scene->addText(tr("No ILDA sequence loaded"));
graphicsView->setScene(scene);
_ildaPalette = loadPalette(":/data/ilda.palette");
_pangolinPalette = loadPalette(":/data/pangolin.palette");
_currentPalette = &_ildaPalette;
readSettings();
}
void instructions() {
REG_DISPCTL = MODE4 | BG2_ENABLE;
loadPalette(instructionsPal);
drawBackgroundImage4(instructionsBitmap);
while(!BUTTON_HELD(BUTTON_B));
playSoundB(menuSound, MENUSOUNDLEN, MENUSOUNDFREQ, 0);
state = SPLASH;
}
void ImageLoaderBmp::loadUncompressed1BitData
(
Graphic::Image& pImage,
ImageLoaderBmpHeader& pHeader,
ImageLoaderBmpInfoHeader& pInfoHeader,
Core::File& pFile
) const
{
unsigned char b[32];
unsigned long pixels;
int x, y, j, k;
pImage.create(pInfoHeader.getWidth(),pInfoHeader.getHeight(),8);
loadPalette(pImage,pHeader,pInfoHeader,pFile);
for(y = pInfoHeader.getHeight()-1; y >= 0; --y)
{
for (x=0; x < pInfoHeader.getWidth(); ++x)
{
j = x % 32;
if (j == 0)
{
pixels = pFile.readInt32();
for (k = 0; k < 32; ++k)
{
b[31-k] = (char)(pixels & 1);
pixels = pixels >> 1;
}
}
/**
* @todo Verificar se esse problema naum é causado por bytes little endian/big endian
* @details
* Em modo monocromático os dados são guardados em conjuntos de
* 32 em 32, sendo que os 8 primeiros bits são na verdade os
* 8 últimos bits desse conjunto de 32, e os próximos 8 bits
* são os 8 antes dos 8 últimos e assim sucessitivamente O.o,
* não sei pq eles complicam as coisas aff
*/
k = ( (int)(j / 8) + 1) * 8;
pImage.drawPixel
(
x,
y,
b[32-k+(j%8)]
);
}
}
void ImageFile::load(Common::SeekableReadStream &stream, bool skipPalette, bool animImages) {
loadPalette(stream);
int streamSize = stream.size();
while (stream.pos() < streamSize) {
ImageFrame frame;
frame._width = stream.readUint16LE() + 1;
frame._height = stream.readUint16LE() + 1;
frame._paletteBase = stream.readByte();
if (animImages) {
// Animation cutscene image files use a 16-bit x offset
frame._offset.x = stream.readUint16LE();
frame._rleEncoded = (frame._offset.x & 0xff) == 1;
frame._offset.y = stream.readByte();
} else {
// Standard image files have a separate byte for the RLE flag, and an 8-bit X offset
frame._rleEncoded = stream.readByte() == 1;
frame._offset.x = stream.readByte();
frame._offset.y = stream.readByte();
}
frame._rleEncoded = !skipPalette && frame._rleEncoded;
if (frame._paletteBase) {
// Nibble packed frame data
frame._size = (frame._width * frame._height) / 2;
} else if (frame._rleEncoded) {
// This size includes the header size, which we subtract
frame._size = stream.readUint16LE() - 11;
frame._rleMarker = stream.readByte();
} else {
// Uncompressed data
frame._size = frame._width * frame._height;
}
// Load data for frame and decompress it
byte *data = new byte[frame._size + 4];
stream.read(data, frame._size);
Common::fill(data + frame._size, data + frame._size + 4, 0);
frame.decompressFrame(data, IS_ROSE_TATTOO);
delete[] data;
push_back(frame);
}
}
void winLevel() {
REG_DISPCTL = MODE4 | BG2_ENABLE;
loadPalette(win_level_screenPal);
drawBackgroundImage4(win_level_screenBitmap);
while (1) {
oldButtons = buttons;
buttons = BUTTONS;
if (BUTTON_PRESSED(BUTTON_A)) {
if (currentLevel + 1 <= NUMLEVELS) {
currentLevel++;
init();
setupLevel();
state = GAME;
}
else {
state = GAMEEND;
}
return;
}
if (BUTTON_PRESSED(BUTTON_SELECT)) {
playSoundB(menuSound, MENUSOUNDLEN, MENUSOUNDFREQ, 0);
playSoundA(titleSong, TITLESONGLEN, TITLESONGFREQ, 1);
state = SPLASH;
return;
}
}
}
void CCharacter::Init(Vector2 *position) {
//CXMLParser *data = new CXMLParser("sakuya");
CXMLParser *xmlRaw = new CXMLParser(_name);
//xmlRaw->printData();
_position = new Vector2(*position);
_groundY = _position->getY();
_jumping = CInputs::DirStand;
_maxActiveMovement = 5;
loadAttributes(xmlRaw->getDataByTag("data"));
loadPalette();
loadMovements(xmlRaw->getDataByTag("movements"));
loadProjMovements(xmlRaw->getDataByTag("projMovements"));
//_currentMovement = &_movementList[0];
//_currentMovement->StartMovement(_position);
_indexMovement = (u16)CInputs::Stand;
_movementList[_indexMovement]->StartMovement();
//delete xmlRaw;
} // Init
GfxPalette32::GfxPalette32(ResourceManager *resMan)
: _resMan(resMan),
// Palette versioning
_version(1),
_needsUpdate(false),
#ifdef USE_RGB_COLOR
_hardwarePalette(),
#endif
_currentPalette(),
_sourcePalette(),
_nextPalette(),
// Palette varying
_varyStartPalette(nullptr),
_varyTargetPalette(nullptr),
_varyFromColor(0),
_varyToColor(255),
_varyLastTick(0),
_varyTime(0),
_varyDirection(0),
_varyPercent(0),
_varyTargetPercent(0),
_varyNumTimesPaused(0),
// Palette cycling
_cycleMap(),
// Gamma correction
_gammaLevel(-1),
_gammaChanged(false) {
for (int i = 0, len = ARRAYSIZE(_fadeTable); i < len; ++i) {
_fadeTable[i] = 100;
}
loadPalette(999);
}
// Level-independant setup logic
void init() {
REG_DISPCTL = MODE0 | BG2_ENABLE | SPRITE_ENABLE;
REG_BG0CNT = CBB(0) | SBB(26) | BG_SIZE0 | COLOR256 | 0; // Priority 0
REG_BG1CNT = CBB(1) | SBB(27) | BG_SIZE0 | COLOR256 | 1; // Priority 1
REG_BG2CNT = CBB(2) | SBB(28) | BG_SIZE1 | COLOR256 | 2; // Priority 2
// Put Sprite on Screen
loadSpritePalette(sprite_actorPal);
DMANow(3, sprite_actorTiles, &CHARBLOCKBASE[4], sprite_actorTilesLen / 2);
// DMA background 0
loadPalette(pause_screenPal);
DMANow(3, pause_screenMap, &SCREENBLOCKBASE[26], pause_screenMapLen / 2);
DMANow(3, pause_screenTiles, &CHARBLOCKBASE[0], pause_screenTilesLen / 2);
// Initialize level-independant player values
player.deltaRow = 1;
player.deltaCol = 0;
player.isRunning = 0;
player.isJumping = 0;
player.frameCount = 0;
player.width = 16;
player.height = 16;
player.currentFrame = 0;
player.facing = 0; // Facing to the right (1 is facing to the left)
canJump = 0; // subject to change depending how beginning is designed
hideSprites();
// Season-indicator icon position for all levels
icon.row = 5;
icon.col = 219;
}
void splash() {
REG_DISPCTL = MODE4 | BG2_ENABLE;
loadPalette(splash_screenPal);
drawBackgroundImage4(splash_screenBitmap);
while (1) {
oldButtons = buttons;
buttons = BUTTONS;
if (BUTTON_PRESSED(BUTTON_START)) {
init();
setupGame();
playSoundA(gameSong, GAMESONGLEN, GAMESONGFREQ, 1);
playSoundB(menuSound, MENUSOUNDLEN, MENUSOUNDFREQ, 0);
state = GAME;
return;
}
if (BUTTON_PRESSED(BUTTON_SELECT)) {
playSoundB(menuSound, MENUSOUNDLEN, MENUSOUNDFREQ, 0);
state = INSTRUCTIONS;
return;
}
}
}
// Level-dependent setup logic
void setupLevel() {
// Level 0 is the only one that starts in NEUTRAL season
if (currentLevel <= 1) {
season = NEUTRAL;
}
else if (currentLevel > (NUMLEVELS - 1)) {
season = SPRING;
}
// Each level starts at an incrementally different season
else {
season = SPRING + (currentLevel % 4);
}
// Turn on snow or leaves when appropriate
if (season >= FALL) {
REG_DISPCTL |= BG1_ENABLE;
if (season == FALL) {
loadPalette(bg_fallPal);
DMANow(3, bg_fallMap, &SCREENBLOCKBASE[27], bg_fallMapLen / 2);
DMANow(3, bg_fallTiles, &CHARBLOCKBASE[1], bg_fallTilesLen / 2);
}
else { // season is WINTER
loadPalette(bg_snowPal);
DMANow(3, bg_snowMap, &SCREENBLOCKBASE[27], bg_snowMapLen / 2);
DMANow(3, bg_snowTiles, &CHARBLOCKBASE[1], bg_snowTilesLen / 2);
}
}
switch (currentLevel) {
case 1:
// DMA background 2
loadPalette(bg_00_neutralscrnPal);
DMANow(3, bg_00_neutralscrnMap, &SCREENBLOCKBASE[28], bg_00_neutralscrnMapLen / 2);
DMANow(3, bg_00_neutralscrnTiles, &CHARBLOCKBASE[2], bg_00_neutralscrnTilesLen / 2);
// Spawn loction for this level
player.row = 10;
player.col = 112;
vOff = 0;
hOff = 0;
break;
case 2:
loadPalette(bg_02_fallscrnPal);
DMANow(3, bg_02_fallscrnMap, &SCREENBLOCKBASE[28], bg_02_fallscrnMapLen / 2);
DMANow(3, bg_02_fallscrnTiles, &CHARBLOCKBASE[2], bg_02_fallscrnTilesLen / 2);
player.row = 50;
player.col = 112;
vOff = 0;
hOff = 184;
break;
case 3:
loadPalette(bg_03_winterscrnPal);
DMANow(3, bg_03_winterscrnMap, &SCREENBLOCKBASE[28], bg_03_winterscrnMapLen / 2);
DMANow(3, bg_03_winterscrnTiles, &CHARBLOCKBASE[2], bg_03_winterscrnTilesLen / 2);
player.row = 50;
player.col = 112;
vOff = 0;
hOff = 120;
break;
case 4:
loadPalette(bg_04_springscrnPal);
DMANow(3, bg_04_springscrnMap, &SCREENBLOCKBASE[28], bg_04_springscrnMapLen / 2);
DMANow(3, bg_04_springscrnTiles, &CHARBLOCKBASE[2], bg_04_springscrnTilesLen / 2);
player.row = 50;
player.col = 40;
vOff = 0;
hOff = 0;
break;
case 5:
loadPalette(bg_05_summerscrnPal);
DMANow(3, bg_05_summerscrnMap, &SCREENBLOCKBASE[28], bg_05_summerscrnMapLen / 2);
DMANow(3, bg_05_summerscrnTiles, &CHARBLOCKBASE[2], bg_05_summerscrnTilesLen / 2);
player.row = 30;
player.col = 112;
vOff = 0;
hOff = 136;
break;
case 6:
loadPalette(bg_06_fallscrnPal);
DMANow(3, bg_06_fallscrnMap, &SCREENBLOCKBASE[28], bg_06_fallscrnMapLen / 2);
DMANow(3, bg_06_fallscrnTiles, &CHARBLOCKBASE[2], bg_06_fallscrnTilesLen / 2);
player.row = 30;
player.col = 8;
vOff = 0;
hOff = 0;
break;
case 7:
loadPalette(bg_07_winterscrnPal);
DMANow(3, bg_07_winterscrnMap, &SCREENBLOCKBASE[28], bg_07_winterscrnMapLen / 2);
DMANow(3, bg_07_winterscrnTiles, &CHARBLOCKBASE[2], bg_07_winterscrnTilesLen / 2);
player.row = 30;
player.col = 40;
vOff = 0;
hOff = 0;
break;
case 8:
loadPalette(bg_08_springscrnPal);
DMANow(3, bg_08_springscrnMap, &SCREENBLOCKBASE[28], bg_08_springscrnMapLen / 2);
DMANow(3, bg_08_springscrnTiles, &CHARBLOCKBASE[2], bg_08_springscrnTilesLen / 2);
player.row = 30;
player.col = 112;
vOff = 0;
hOff = 96;
break;
case 9:
loadPalette(bg_09_summerscrnPal);
DMANow(3, bg_09_summerscrnMap, &SCREENBLOCKBASE[28], bg_09_summerscrnMapLen / 2);
DMANow(3, bg_09_summerscrnTiles, &CHARBLOCKBASE[2], bg_09_summerscrnTilesLen / 2);
player.row = 30;
player.col = 112;
vOff = 0;
hOff = 128;
break;
case 10:
loadPalette(bg_10_fallscrnPal);
DMANow(3, bg_10_fallscrnMap, &SCREENBLOCKBASE[28], bg_10_fallscrnMapLen / 2);
DMANow(3, bg_10_fallscrnTiles, &CHARBLOCKBASE[2], bg_10_fallscrnTilesLen / 2);
player.row = 30;
player.col = 112;
vOff = 0;
hOff = 128;
break;
case 11:
loadPalette(bg_final_springscrnPal);
DMANow(3, bg_final_springscrnMap, &SCREENBLOCKBASE[28], bg_final_springscrnMapLen / 2);
DMANow(3, bg_final_springscrnTiles, &CHARBLOCKBASE[2], bg_final_springscrnTilesLen / 2);
player.row = 30;
player.col = 10;
vOff = 0;
hOff = 0;
break;
}
}
int
main(int argc, char *argv[])
{
/* initialize SDL */
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
GUI_Log("Could not initialize SDL");
}
if (TTF_Init() != 0){
GUI_Log( "TTF_Init failed.");
SDL_Quit();
return 1;
}
if( GUI_Init() != 0 ) {
GUI_Log( "GUI_Init failed." );
TTF_Quit();
SDL_Quit();
return 1;
}
char *pref = SDL_GetPrefPath( "JimmySoftware.com", "ToolBarDialog" );
strcpy( preferenctPath, pref );
strcat( preferenctPath, "preference.conf" );
SDL_Log( "Pref: %s\n", preferenctPath );
if( access( preferenctPath, 0 ) != -1 ) {
GUI_Log( "File Existed\n" );
loadPalette( preferenctPath );
} else {
GUI_Log( "File not existed\n" );
for( int i=0; i<numPalette; i++ ) {
for( int j=0; j<numColor; j++ ) {
mainPalette[i][j] = mColor[j];
}
}
}
activePalette = 0;
//int sx = 720, sy = 405;
#if __IPHONEOS__ or __ANDROID__
int sx = 640, sy = 360;
#else
int sx = 640, sy = 360;
#endif
SDL_Window *window = GUI_CreateWindow( "GUI", sx, sy );
if (window == NULL) {
fatalError("GUI_CreateWindow Error");
return 1;
}
SCREEN_WIDTH = GUI_windowWidth;
SCREEN_HEIGHT = GUI_windowHeight;
topWin=new GUI_TopWin( "TopWin", GUI_Rect(0,0,GUI_windowWidth,GUI_windowHeight),0,
[]( GUI_WinBase *tw ) {
//tw->clear();
}
);
textureFileIcon = loadTexture( "icon_file.png", GUI_renderer );
GUI_WinBase *topBar = new GUI_WinBase( topWin, "TopBar", 0, 0, GUI_windowWidth, 48, cDarkGrey );
if( topBar ) {
GUI_Button *bttnFile = new GUI_Button( topBar, "F", 8, 8, 32, 32, cGrey,
[](GUI_Button *bt) {
if( menuFile == NULL ) {
GUI_Log( "create new MenuFile\n" );
static const char *menuText[] = {
"File", "Open", "Save", "Exit", NULL
};
menuFile = new GUI_List( topWin, menuText, 4, bt->tw_area.x, bt->tw_area.y+bt->tw_area.w+10, 240, 0, 0, true,
[](GUI_List *l,const char *sel, int index) {
switch (index) {
case 1:
OpenFile();
break;
case 3:
SDL_AddTimer( 100, ExitCallback, NULL );
break;
default:
break;
}
menuFile = NULL;
}
);
menuFile->title_str = "Menu File";
menuFile->onClose = [] (GUI_WinBase *) -> bool {
menuFile = NULL;
return true;
};
}
}
);
bttnFile->texImage = textureFileIcon;
bttnFile->color = cClear;
new GUI_Button( topBar, "C", 48, 8, 32, 32, cGrey,
[](GUI_Button *bt) {
OpenColor();
}
);
GUI_WinBase *colorBox = new GUI_WinBase( topBar, "สี", 88, 6, 32*9+18, 36, cClear,
[](GUI_WinBase *wb) {
GUI_FillRoundRect( 0, 0, wb->tw_area.w, wb->tw_area.h, wb->tw_area.h/2, sdl_color( 0x484848ff ) );
}
);
if( colorBox ) {
for( int i=0; i<numColor; i++ ) {
c[i] = new GUI_Button( colorBox, "", 6+32*i, 3, 31, 31, mainPalette[activePalette][i], setActiveColor );
c[i]->tag = i;
c[i]->radius = 15;
c[i]->border = 1;
}
setActiveColor( c[0] );
GUI_WinBase *paletteButton = new GUI_WinBase( colorBox, "Palette", 6+32*numColor+5, 3+8, 25, 15, cClear,
[](GUI_WinBase *w)
{
//GUI_DrawRect( GUI_MakeRect(0, 0, w->tw_area.w, w->tw_area.h), cBlack );
SDL_RenderCopy(GUI_renderer, GUI_dropdownTexture, NULL, GUI_MakeRect(1, 1, w->tw_area.w-2, w->tw_area.h-2));
}
);
paletteButton->handle_event_cmd = [](GUI_WinBase *w, SDL_Event* ev ) -> bool {
switch (ev->type) {
case SDL_MOUSEBUTTONUP: {
static const char *menuPalette[] = {
"Palette1", "Palette2", "Palette3", "Palette4", "Palette5", "---", "Load", "Save", NULL
};
//GUI_Log( "Palette\n" );
GUI_List *listPal = new GUI_List( topWin, menuPalette, 8, w->tw_area.x, w->tw_area.y+w->tw_area.h+18, 240, 0, 0, true,
[](GUI_List* l,const char*sz,int n) {
if( n < numPalette ) {
activePalette = n;
l->setCheck( n );
for( int i=0; i<numColor; i++ ) {
c[i]->color = mainPalette[n][i];
}
}
else if( n == numPalette + 1 ) {
SDL_AddTimer( 100, LoadPaletteCallback, NULL );
}
else if( n == numPalette + 2 ) {
SDL_AddTimer( 100, SavePaletteCallback, NULL );
}
});
for( int i=0; i<numPalette; i++ ) {
GUI_ListCell *cell = listPal->getCell( i );
cell->checkable = true;
cell->display_cmd = cellDraw;
}
listPal->setCheck( activePalette );
}
}
return false;
};
}
}
GUI_WinBase *sizeBox = new GUI_WinBase( topBar, "สี", 402, 6, 32*3+6, 36, cClear,
[](GUI_WinBase *wb) {
GUI_FillRoundRect( 0, 0, wb->tw_area.w, wb->tw_area.h, 10, sdl_color( 0x484848ff ) );
}
);
if( sizeBox ) {
for( int i=0; i<numSize; i++ ) {
s[i] = new GUI_Button( sizeBox, "", 3+32*i, 3, 30, 30, cClear, setActiveSize );
s[i]->tag = i;
s[i]->radius = 5;
s[i]->border = 1;
s[i]->display_cmd = [](GUI_WinBase *w) {
int bw = 12 + w->tag * 6;
int cw = 0;
if( w->tag == 1 )
cw -= 3;
GUI_FillRect( cw+(w->tw_area.w-bw)/2, (w->tw_area.h-bw)/2, bw, bw, cGrey );
GUI_DrawRect( cw+(w->tw_area.w-bw)/2, (w->tw_area.h-bw)/2, bw, bw, ((GUI_Button*)w)->borderColor );
};
}
setActiveSize( s[0] );
}
GUI_WinBase *bottomBar = new GUI_WinBase( topWin, "BottomBar", 0, GUI_windowHeight-48, GUI_windowWidth, 48, cDarkGrey );
//createTestWindows( 20, 20, "Red", cRed );
GUI_Run();
savePalette( preferenctPath );
/* shutdown SDL */
GUI_Quit();
TTF_Quit();
SDL_Quit();
return 0;
}
Object* FileManager::load( QString strFileName )
{
if ( !QFile::exists( strFileName ) )
{
qCDebug( mLog ) << "ERROR - File doesn't exist.";
return cleanUpWithErrorCode( Status::FILE_NOT_FOUND );
}
emit progressUpdated( 0.f );
Object* obj = new Object;
obj->setFilePath( strFileName );
obj->createWorkingDir();
QString strMainXMLFile;
QString strDataFolder;
// Test file format: new zipped .pclx or old .pcl?
bool oldFormat = isOldForamt( strFileName );
if ( oldFormat )
{
qCDebug( mLog ) << "Recognized Old Pencil File Format (*.pcl) !";
strMainXMLFile = strFileName;
strDataFolder = strMainXMLFile + "." + PFF_OLD_DATA_DIR;
}
else
{
qCDebug( mLog ) << "Recognized New zipped Pencil File Format (*.pclx) !";
unzip( strFileName, obj->workingDir() );
strMainXMLFile = QDir( obj->workingDir() ).filePath( PFF_XML_FILE_NAME );
strDataFolder = QDir( obj->workingDir() ).filePath( PFF_DATA_DIR );
}
qDebug() << "XML=" << strMainXMLFile;
qDebug() << "Data Folder=" << strDataFolder;
qDebug() << "Working Folder=" << obj->workingDir();
obj->setDataDir( strDataFolder );
obj->setMainXMLFile( strMainXMLFile );
QFile file( strMainXMLFile );
if ( !file.open( QFile::ReadOnly ) )
{
return cleanUpWithErrorCode( Status::ERROR_FILE_CANNOT_OPEN );
}
qCDebug( mLog ) << "Checking main XML file...";
QDomDocument xmlDoc;
if ( !xmlDoc.setContent( &file ) )
{
return cleanUpWithErrorCode( Status::ERROR_INVALID_XML_FILE );
}
QDomDocumentType type = xmlDoc.doctype();
if ( !( type.name() == "PencilDocument" || type.name() == "MyObject" ) )
{
return cleanUpWithErrorCode( Status::ERROR_INVALID_PENCIL_FILE );
}
QDomElement root = xmlDoc.documentElement();
if ( root.isNull() )
{
return cleanUpWithErrorCode( Status::ERROR_INVALID_PENCIL_FILE );
}
// Create object.
qCDebug( mLog ) << "Start to load object..";
loadPalette( obj );
bool ok = true;
if ( root.tagName() == "document" )
{
ok = loadObject( obj, root );
}
else if ( root.tagName() == "object" || root.tagName() == "MyOject" ) // old Pencil format (<=0.4.3)
{
ok = loadObjectOldWay( obj, root );
}
if ( !ok )
{
delete obj;
return cleanUpWithErrorCode( Status::ERROR_INVALID_PENCIL_FILE );
}
verifyObject( obj );
return obj;
}
bool Sprite::loadFromBMP(Common::SeekableReadStream &bmp) {
discard();
if (!bmp.seek(0))
return false;
uint32 fSize = bmp.size();
// 'BM'
if (bmp.readUint16BE() != 0x424D)
return false;
// Size of image + reserved + reserved
bmp.skip(8);
uint32 bmpDataOffset = bmp.readUint32LE();
if (bmpDataOffset >= fSize)
return false;
// Header size
if (bmp.readUint32LE() != 40)
return false;
int32 width = (int32) bmp.readUint32LE();
int32 height = (int32) bmp.readUint32LE();
// Sanity checks
assert((width > 0) && (height > 0) && (width <= 0x7FFF) && (height <= 0x7FFF));
// Create surfaces
create(width, height);
// Number of color planes
if (bmp.readUint16LE() != 1)
return false;
// Bits per pixel
if (bmp.readUint16LE() != 8)
return false;
uint32 compression = bmp.readUint32LE();
if ((compression != 0) && (compression != 2))
return false;
uint32 bmpDataSize = bmp.readUint32LE();
// Sprite's feet position
_feetX = (int32) MIN<uint16>(ABS(((int16) bmp.readUint16LE())), width - 1);
_feetY = (int32) MIN<uint16>(ABS(((int16) bmp.readUint16LE())), height - 1);
// Default coordinates
_defaultX = (int32) bmp.readUint16LE();
_defaultY = (int32) bmp.readUint16LE();
uint32 numPalColors = bmp.readUint32LE();
if (numPalColors == 0)
numPalColors = 256;
if (numPalColors > 256)
numPalColors = 256;
if (bmpDataOffset == 54) {
// Image data begins right after the header => no palette
numPalColors = 0;
}
// Important colors
bmp.skip(4);
loadPalette(bmp, numPalColors);
if (!bmp.seek(bmpDataOffset))
return false;
if (compression == 0) {
if (!readBMPDataComp0(bmp, bmpDataSize))
return false;
} else if (compression == 2) {
if (!readBMPDataComp2(bmp, bmpDataSize))
return false;
}
createTransparencyMap();
convertToTrueColor();
return true;
}
void showLevel(int level) {
int i;
/*****************************************************************
*
* Step 1 -- Tile Images
*
* This data tells us what each different tile will look like
* It will be copied into a character block
*
****************************************************************/
/*****************************************************************
*
* Step 2 -- Screen Image (map)
*
* The numbers in this array tell us which tile we want in each
* tile location on the screen. We will copy this data into a
* screen block
*
****************************************************************/
/*****************************************************************
*
* Step 3 -- Palette
*
****************************************************************/
/*****************************************************************
*
* Step 4 -- Store Tile Images
*
****************************************************************/
int nTiles = 256;
int total = nTiles*64/2;
switch(level) {
case 1:
for(i=0; i < total; i++) { // There are 10 tiles. Each tile is described by 64 chars
// but we are storing them two to a short so we are
// storing data in 64/2 shorts per tile
//CHARBLOCKBASE[0].tileimg[i] = myTileImages[i*2] | (myTileImages[i*2+1]<<8);
CHARBLOCKBASE[0].tileimg[i] = Level1Tiles[i*2] | (Level1Tiles[i*2+1]<<8);
}
break;
}
/*****************************************************************
*
* Step 5 -- Store map
*
****************************************************************/
int totalMap;
switch(level) {
case 1:
totalMap = 32*32; //1024
loadMapBlock(0, Level1Map);
for(i=0; i < totalMap; i++) {
//SCREENBLOCKBASE[31].tilemap[i] = Level1Map[i];
//SCREENBLOCKBASE[30].tilemap[i] = myScreenMap[i];
SCREENBLOCKBASE[28].tilemap[i] = myBackgroundMap[i];
}
break;
}
/*****************************************************************
*
* Step 6 -- Store palette
*
****************************************************************/
switch(level) {
case 1:
//loadPalette(myPalette);
loadPalette(Level1Pal);
break;
}
/*****************************************************************
*
* Step 7 -- Set image controls
*
****************************************************************/
//REG_DISPCTL = MODE0 | BG0_ENABLE | BG1_ENABLE | BG2_ENABLE;
//SETMODE(MODE0 | BG0_ENABLE | BG1_ENABLE | BG2_ENABLE | SPRITE_ENABLE);
SETMODE(MODE0 | BG0_ENABLE | /*BG1_ENABLE |*/ BG2_ENABLE | SPRITE_ENABLE);
REG_BG0HOFS = 0;
REG_BG0VOFS = 0;
// MyGUI: Texts,... Comment out this line to turn off BG0
//REG_BG0CNT = BG_SIZE0 | SBB(31) | COLOR256 | CBB(0);
// Game
REG_BG0CNT = BG_SIZE0 | SBB(30) | COLOR256 | CBB(0);
// Background
REG_BG2CNT = BG_SIZE0 | SBB(28) | COLOR256 | CBB(0);
// DeuXieme part ;) // 30
//REG_BG1CNT = BG_SIZE0 | SBB(31) | COLOR256 | CBB(0);
}
void MainWindow::createActions()
{
newAct = new QAction(tr("&New Project"), this);
newAct->setShortcuts(QKeySequence::New);
newAct->setStatusTip(tr("Create a new file"));
connect(newAct, SIGNAL(triggered()), this, SLOT(newFile()));
openAct = new QAction(tr("&Open Examples"), this);
openAct->setShortcuts(QKeySequence::Open);
openAct->setStatusTip(tr("Open an existing file"));
connect(openAct, SIGNAL(triggered()), this, SLOT(open()));
loadAct = new QAction(tr("&Load Project"), this);
loadAct->setShortcuts(QKeySequence::Save);
loadAct->setStatusTip(tr("Load "));
connect(loadAct, SIGNAL(triggered()), this, SLOT(load()));
saveAct = new QAction(tr("&Save"), this);
saveAct->setShortcuts(QKeySequence::Save);
saveAct->setStatusTip(tr("Save the document to disk"));
connect(saveAct, SIGNAL(triggered()), this, SLOT(save()));
saveAsAct = new QAction(tr("&SaveAs"), this);
saveAsAct ->setShortcuts(QKeySequence::Save);
saveAsAct ->setStatusTip(tr("Save the document to disk"));
connect(saveAsAct , SIGNAL(triggered()), this, SLOT(save()));
savePaletteAct = new QAction(tr("&SavePalette"), this);
savePaletteAct ->setShortcuts(QKeySequence::Save);
savePaletteAct ->setStatusTip(tr("Save the document to Palette"));
connect( savePaletteAct , SIGNAL(triggered()), this, SLOT(savePalette()));
loadPaletteAct = new QAction(tr("&LoadPalette"), this);
loadPaletteAct->setShortcuts(QKeySequence::Save);
loadPaletteAct ->setStatusTip(tr("Load the Document"));
connect(loadPaletteAct , SIGNAL(triggered()), this, SLOT(loadPalette()));
xportAct = new QAction(tr("E&xport"), this);
xportAct->setShortcuts(QKeySequence::Print);
xportAct->setStatusTip(tr("Export the document"));
connect(xportAct , SIGNAL(triggered()), this, SLOT(xport()));
printAct = new QAction(tr("&Print..."), this);
printAct->setShortcuts(QKeySequence::Print);
printAct->setStatusTip(tr("Print the document"));
connect(printAct, SIGNAL(triggered()), this, SLOT(print()));
quitAct = new QAction(tr("&Quit"), this);
quitAct ->setShortcuts(QKeySequence::Quit);
quitAct ->setStatusTip(tr("Exit the application"));
connect(quitAct, SIGNAL(triggered()), this, SLOT(close()));
undoAct = new QAction(tr("&Undo"), this);
undoAct->setShortcuts(QKeySequence::Undo);
undoAct->setStatusTip(tr("Undo the last operation"));
connect(undoAct, SIGNAL(triggered()), this, SLOT(undo()));
redoAct = new QAction(tr("&Redo"), this);
redoAct->setShortcuts(QKeySequence::Redo);
redoAct->setStatusTip(tr("Redo the last operation"));
connect(redoAct, SIGNAL(triggered()), this, SLOT(redo()));
cutAct = new QAction(tr("Cu&t"), this);
cutAct->setShortcuts(QKeySequence::Cut);
cutAct->setStatusTip(tr("Cut the current selection's contents to the "
"clipboard"));
connect(cutAct, SIGNAL(triggered()), this, SLOT(cut()));
copyAct = new QAction(tr("&Copy"), this);
copyAct->setShortcuts(QKeySequence::Copy);
copyAct->setStatusTip(tr("Copy the current selection's contents to the "
"clipboard"));
connect(copyAct, SIGNAL(triggered()), this, SLOT(copy()));
pasteAct = new QAction(tr("&Paste"), this);
pasteAct->setShortcuts(QKeySequence::Paste);
pasteAct->setStatusTip(tr("Paste the clipboard's contents into the current "
"selection"));
connect(pasteAct, SIGNAL(triggered()), this, SLOT(paste()));
fullSelectionAct = new QAction(tr("&Fill Selection"), this);
fullSelectionAct->setShortcut(tr("CTRL+I"));
fullSelectionAct->setStatusTip(tr("Fill selection"));
connect(fullSelectionAct, SIGNAL(triggered()), this, SLOT(fullSelection()));
blendToolAct = new QAction(tr("&Blend Tool"), this);
blendToolAct->setShortcut(tr("CTRL+D"));
blendToolAct->setStatusTip(tr("Blend Tool"));
connect(blendToolAct, SIGNAL(triggered()), this, SLOT(blendTool()));
copyCurrentLayerAct = new QAction(tr("&Copy Current Layer"), this);
copyCurrentLayerAct->setShortcuts(QKeySequence::Paste);
copyCurrentLayerAct->setStatusTip(tr("Copy Current Laye"));
connect(copyCurrentLayerAct, SIGNAL(triggered()), this, SLOT(copyCurrentLayer()));
resetAllParametersAct= new QAction(tr("&Reset All Parameters"), this);
resetAllParametersAct->setShortcuts(QKeySequence::Paste);
resetAllParametersAct->setStatusTip(tr("reset All Parameters"));
connect(resetAllParametersAct, SIGNAL(triggered()), this, SLOT(resetAllParameters()));
cropInputAct = new QAction(tr("&Crop Input"), this);
cropInputAct->setShortcuts(QKeySequence::Paste);
cropInputAct->setStatusTip(tr("Crop Input"));
connect(cropInputAct, SIGNAL(triggered()), this, SLOT(cropInput()));
cropOutputAct = new QAction(tr("&Crop Output"), this);
cropOutputAct ->setShortcuts(QKeySequence::Paste);
cropOutputAct ->setStatusTip(tr("Crop Output"));
connect(cropOutputAct , SIGNAL(triggered()), this, SLOT(cropOutput ()));
zoomInAct = new QAction(tr("&zoom In"), this);
zoomInAct ->setShortcuts(QKeySequence::Paste);
zoomInAct ->setStatusTip(tr("zoom In"));
connect(zoomInAct , SIGNAL(triggered()), this, SLOT(zoomIn()));
zoomOutAct = new QAction(tr("&zoom Out"), this);
zoomOutAct ->setShortcuts(QKeySequence::Paste);
zoomOutAct ->setStatusTip(tr("zoom Out"));
connect(zoomOutAct , SIGNAL(triggered()), this, SLOT(zoomOut() ));
fitWindowAct = new QAction(tr("&fit Window"), this);
fitWindowAct ->setShortcuts(QKeySequence::Paste);
fitWindowAct ->setStatusTip(tr("fit Window"));
connect(fitWindowAct , SIGNAL(triggered()), this, SLOT(fitWindow()));
fullscreenAct= new QAction(tr("&full Screen"), this);
fullscreenAct ->setShortcuts(QKeySequence::Paste);
fullscreenAct ->setStatusTip(tr("full Screen"));
connect(fullscreenAct , SIGNAL(triggered()), this, SLOT(fullscreen()));
/*
toggleSectionsAct = new QAction(tr("&Toggle Sections "), this);
toggleSectionsAct ->setShortcuts(QKeySequence::Paste);
toggleSectionsAct ->setStatusTip(tr("Crop Output"));
connect(toggleSectionsAct , SIGNAL(triggered()), this, SLOT(toggleSections ()));
*/
/*
boldAct = new QAction(tr("&Bold"), this);
boldAct->setCheckable(true);
boldAct->setShortcut(QKeySequence::Bold);
boldAct->setStatusTip(tr("Make the text bold"));
connect(boldAct, SIGNAL(triggered()), this, SLOT(bold()));
QFont boldFont = boldAct->font();
boldFont.setBold(true);
boldAct->setFont(boldFont);
italicAct = new QAction(tr("&Italic"), this);
italicAct->setCheckable(true);
italicAct->setShortcut(QKeySequence::Italic);
italicAct->setStatusTip(tr("Make the text italic"));
connect(italicAct, SIGNAL(triggered()), this, SLOT(italic()));
QFont italicFont = italicAct->font();
italicFont.setItalic(true);
italicAct->setFont(italicFont);
setLineSpacingAct = new QAction(tr("Set &Line Spacing..."), this);
setLineSpacingAct->setStatusTip(tr("Change the gap between the lines of a "
"paragraph"));
connect(setLineSpacingAct, SIGNAL(triggered()), this, SLOT(setLineSpacing()));
setParagraphSpacingAct = new QAction(tr("Set &Paragraph Spacing..."), this);
setParagraphSpacingAct->setStatusTip(tr("Change the gap between paragraphs"));
connect(setParagraphSpacingAct, SIGNAL(triggered()),
this, SLOT(setParagraphSpacing()));
aboutAct = new QAction(tr("&About"), this);
aboutAct->setStatusTip(tr("Show the application's About box"));
connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));
aboutQtAct = new QAction(tr("About &Qt"), this);
aboutQtAct->setStatusTip(tr("Show the Qt library's About box"));
connect(aboutQtAct, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
connect(aboutQtAct, SIGNAL(triggered()), this, SLOT(aboutQt()));
leftAlignAct = new QAction(tr("&Left Align"), this);
leftAlignAct->setCheckable(true);
leftAlignAct->setShortcut(tr("Ctrl+L"));
leftAlignAct->setStatusTip(tr("Left align the selected text"));
connect(leftAlignAct, SIGNAL(triggered()), this, SLOT(leftAlign()));
rightAlignAct = new QAction(tr("&Right Align"), this);
rightAlignAct->setCheckable(true);
rightAlignAct->setShortcut(tr("Ctrl+R"));
rightAlignAct->setStatusTip(tr("Right align the selected text"));
connect(rightAlignAct, SIGNAL(triggered()), this, SLOT(rightAlign()));
justifyAct = new QAction(tr("&Justify"), this);
justifyAct->setCheckable(true);
justifyAct->setShortcut(tr("Ctrl+J"));
justifyAct->setStatusTip(tr("Justify the selected text"));
connect(justifyAct, SIGNAL(triggered()), this, SLOT(justify()));
centerAct = new QAction(tr("&Center"), this);
centerAct->setCheckable(true);
centerAct->setShortcut(tr("Ctrl+E"));
centerAct->setStatusTip(tr("Center the selected text"));
connect(centerAct, SIGNAL(triggered()), this, SLOT(center()));
alignmentGroup = new QActionGroup(this);
alignmentGroup->addAction(leftAlignAct);
alignmentGroup->addAction(rightAlignAct);
alignmentGroup->addAction(justifyAct);
alignmentGroup->addAction(centerAct);
leftAlignAct->setChecked(true);*/
}
void pause() {
REG_DISPCTL = MODE0 | BG3_ENABLE | SPRITE_ENABLE;
REG_BG3CNT = CBB(0) | SBB(28) | BG_SIZE3 | COLOR256;
loadPalette(stats_screenPal);
DMANow(3, (unsigned int*)stats_screenTiles, &CHARBLOCKBASE[0], stats_screenTilesLen);
DMANow(3, (unsigned int*)stats_screenMap, &SCREENBLOCKBASE[28], stats_screenMapLen);
//sets up selector arrow
shadowOAM[127].attr0 = 56 | ATTR0_8BPP | ATTR0_SQUARE;
shadowOAM[127].attr1 = 25 | ATTR1_SIZE8;
shadowOAM[127].attr2 = 772;
//sets up points remaining indicator
shadowOAM[126].attr0 = 32 | ATTR0_8BPP | ATTR0_SQUARE;
shadowOAM[126].attr1 = 106 | ATTR1_SIZE8;
shadowOAM[126].attr2 = 800;
//sets up vitality points indicator
shadowOAM[125].attr0 = 57 | ATTR0_8BPP | ATTR0_SQUARE;
shadowOAM[125].attr1 = 90 | ATTR1_SIZE8;
shadowOAM[125].attr2 = 802;
//sets up strength points indicator
shadowOAM[124].attr0 = 73 | ATTR0_8BPP | ATTR0_SQUARE;
shadowOAM[124].attr1 = 90 | ATTR1_SIZE8;
shadowOAM[124].attr2 = 802;
//Disable unused sprites
int i;
for (i=0; i<128; ++i) {
OAM[i].attr0 = ATTR0_HIDE;
}
//This loop keeps the background from being redrawn continously
int button_pushed = 0;
while (!button_pushed) {
OAM[127] = shadowOAM[127];
OAM[126] = shadowOAM[126];
OAM[125] = shadowOAM[125];
OAM[124] = shadowOAM[124];
shadowOAM[126].attr2 = 800 + (2 * points);
key_poll();
if (key_hit(BUTTON_A) || (key_hit(BUTTON_B)))
button_pushed = 1;
if (key_hit(BUTTON_UP) && (selector_position > 0)) {
--selector_position;
shadowOAM[127].attr0 = 56 | ATTR0_8BPP | ATTR0_SQUARE;
}
if (key_hit(BUTTON_DOWN) && (selector_position < 1)) {
++selector_position;
shadowOAM[127].attr0 = 72 | ATTR0_8BPP | ATTR0_SQUARE;
}
if (key_hit(BUTTON_RIGHT) && (selector_position == 0) && (points > 0)) {
++playerHealth;
--points;
shadowOAM[125].attr2 = 800 + (2 * playerHealth);
}
if (key_hit(BUTTON_LEFT) && (selector_position == 0) && (playerHealth > 1)) {
--playerHealth;
++points;
shadowOAM[125].attr2 = 800 + (2 * playerHealth);
}
if (key_hit(BUTTON_RIGHT) && (selector_position == 1) && (points > 0)) {
++player_damage;
--points;
shadowOAM[124].attr2 = 800 + (2 * player_damage);
}
if (key_hit(BUTTON_LEFT) && (selector_position == 1) && (player_damage > 1)) {
--player_damage;
++points;
shadowOAM[124].attr2 = 800 + (2 * player_damage);
}
}
if (key_hit(BUTTON_A)) {
int i;
for (i=0; i<128; ++i) {
OAM[i].attr0 = ATTR0_HIDE;
}
state = GAME_OVERWORLD;
}
}
void seasonChange() {
season = prevSeason;
incrementSeason();
// Turn snow and falling leaves off
if (season < FALL) {
REG_DISPCTL &= ~(BG1_ENABLE);
}
switch (season) {
case NEUTRAL:
switch (currentLevel) {
case 1:
loadPalette(bg_00_neutralscrnPal);
DMANow(3, bg_00_neutralscrnMap, &SCREENBLOCKBASE[28], bg_00_neutralscrnMapLen / 2);
DMANow(3, bg_00_neutralscrnTiles, &CHARBLOCKBASE[2], bg_00_neutralscrnTilesLen / 2);
break;
case 2:
loadPalette(bg_02_neutralscrnPal);
DMANow(3, bg_02_neutralscrnMap, &SCREENBLOCKBASE[28], bg_02_neutralscrnMapLen / 2);
DMANow(3, bg_02_neutralscrnTiles, &CHARBLOCKBASE[2], bg_02_neutralscrnTilesLen / 2);
break;
case 3:
loadPalette(bg_03_neutralscrnPal);
DMANow(3, bg_03_neutralscrnMap, &SCREENBLOCKBASE[28], bg_03_neutralscrnMapLen / 2);
DMANow(3, bg_03_neutralscrnTiles, &CHARBLOCKBASE[2], bg_03_neutralscrnTilesLen / 2);
break;
case 4:
loadPalette(bg_04_springscrnPal);
DMANow(3, bg_04_neutralscrnMap, &SCREENBLOCKBASE[28], bg_04_neutralscrnMapLen / 2);
DMANow(3, bg_04_neutralscrnTiles, &CHARBLOCKBASE[2], bg_04_neutralscrnTilesLen / 2);
break;
case 5:
loadPalette(bg_05_neutralscrnPal);
DMANow(3, bg_05_neutralscrnMap, &SCREENBLOCKBASE[28], bg_05_neutralscrnMapLen / 2);
DMANow(3, bg_05_neutralscrnTiles, &CHARBLOCKBASE[2], bg_05_neutralscrnTilesLen / 2);
break;
case 6:
loadPalette(bg_06_neutralscrnPal);
DMANow(3, bg_06_neutralscrnMap, &SCREENBLOCKBASE[28], bg_06_neutralscrnMapLen / 2);
DMANow(3, bg_06_neutralscrnTiles, &CHARBLOCKBASE[2], bg_06_neutralscrnTilesLen / 2);
break;
case 7:
loadPalette(bg_07_neutralscrnPal);
DMANow(3, bg_07_neutralscrnMap, &SCREENBLOCKBASE[28], bg_07_neutralscrnMapLen / 2);
DMANow(3, bg_07_neutralscrnTiles, &CHARBLOCKBASE[2], bg_07_neutralscrnTilesLen / 2);
break;
case 8:
loadPalette(bg_08_neutralscrnPal);
DMANow(3, bg_08_neutralscrnMap, &SCREENBLOCKBASE[28], bg_08_neutralscrnMapLen / 2);
DMANow(3, bg_08_neutralscrnTiles, &CHARBLOCKBASE[2], bg_08_neutralscrnTilesLen / 2);
break;
case 9:
loadPalette(bg_09_neutralscrnPal);
DMANow(3, bg_09_neutralscrnMap, &SCREENBLOCKBASE[28], bg_09_neutralscrnMapLen / 2);
DMANow(3, bg_09_neutralscrnTiles, &CHARBLOCKBASE[2], bg_09_neutralscrnTilesLen / 2);
break;
case 10:
loadPalette(bg_10_neutralscrnPal);
DMANow(3, bg_10_neutralscrnMap, &SCREENBLOCKBASE[28], bg_10_neutralscrnMapLen / 2);
DMANow(3, bg_10_neutralscrnTiles, &CHARBLOCKBASE[2], bg_10_neutralscrnTilesLen / 2);
break;
case 11:
loadPalette(bg_final_neutralscrnPal);
DMANow(3, bg_final_neutralscrnMap, &SCREENBLOCKBASE[28], bg_final_neutralscrnMapLen / 2);
DMANow(3, bg_final_neutralscrnTiles, &CHARBLOCKBASE[2], bg_final_neutralscrnTilesLen / 2);
break;
}
break;
case SPRING:
switch (currentLevel) {
case 1:
loadPalette(bg_00_springscrnPal);
DMANow(3, bg_00_springscrnMap, &SCREENBLOCKBASE[28], bg_00_springscrnMapLen / 2);
DMANow(3, bg_00_springscrnTiles, &CHARBLOCKBASE[2], bg_00_springscrnTilesLen / 2);
break;
case 2:
loadPalette(bg_02_springscrnPal);
DMANow(3, bg_02_springscrnMap, &SCREENBLOCKBASE[28], bg_02_springscrnMapLen / 2);
DMANow(3, bg_02_springscrnTiles, &CHARBLOCKBASE[2], bg_02_springscrnTilesLen / 2);
break;
case 3:
loadPalette(bg_03_springscrnPal);
DMANow(3, bg_03_springscrnMap, &SCREENBLOCKBASE[28], bg_03_springscrnMapLen / 2);
DMANow(3, bg_03_springscrnTiles, &CHARBLOCKBASE[2], bg_03_springscrnTilesLen / 2);
break;
case 4:
loadPalette(bg_04_springscrnPal);
DMANow(3, bg_04_springscrnMap, &SCREENBLOCKBASE[28], bg_04_springscrnMapLen / 2);
DMANow(3, bg_04_springscrnTiles, &CHARBLOCKBASE[2], bg_04_springscrnTilesLen / 2);
break;
case 5:
loadPalette(bg_05_springscrnPal);
DMANow(3, bg_05_springscrnMap, &SCREENBLOCKBASE[28], bg_05_springscrnMapLen / 2);
DMANow(3, bg_05_springscrnTiles, &CHARBLOCKBASE[2], bg_05_springscrnTilesLen / 2);
break;
case 6:
loadPalette(bg_06_springscrnPal);
DMANow(3, bg_06_springscrnMap, &SCREENBLOCKBASE[28], bg_06_springscrnMapLen / 2);
DMANow(3, bg_06_springscrnTiles, &CHARBLOCKBASE[2], bg_06_springscrnTilesLen / 2);
break;
case 7:
loadPalette(bg_07_springscrnPal);
DMANow(3, bg_07_springscrnMap, &SCREENBLOCKBASE[28], bg_07_springscrnMapLen / 2);
DMANow(3, bg_07_springscrnTiles, &CHARBLOCKBASE[2], bg_07_springscrnTilesLen / 2);
break;
case 8:
loadPalette(bg_08_springscrnPal);
DMANow(3, bg_08_springscrnMap, &SCREENBLOCKBASE[28], bg_08_springscrnMapLen / 2);
DMANow(3, bg_08_springscrnTiles, &CHARBLOCKBASE[2], bg_08_springscrnTilesLen / 2);
break;
case 9:
loadPalette(bg_09_springscrnPal);
DMANow(3, bg_09_springscrnMap, &SCREENBLOCKBASE[28], bg_09_springscrnMapLen / 2);
DMANow(3, bg_09_springscrnTiles, &CHARBLOCKBASE[2], bg_09_springscrnTilesLen / 2);
break;
case 10:
loadPalette(bg_10_springscrnPal);
DMANow(3, bg_10_springscrnMap, &SCREENBLOCKBASE[28], bg_10_springscrnMapLen / 2);
DMANow(3, bg_10_springscrnTiles, &CHARBLOCKBASE[2], bg_10_springscrnTilesLen / 2);
break;
case 11:
loadPalette(bg_final_springscrnPal);
DMANow(3, bg_final_springscrnMap, &SCREENBLOCKBASE[28], bg_final_springscrnMapLen / 2);
DMANow(3, bg_final_springscrnTiles, &CHARBLOCKBASE[2], bg_final_springscrnTilesLen / 2);
break;
}
break;
case SUMMER:
switch (currentLevel) {
case 1:
loadPalette(bg_00_summerscrnPal);
DMANow(3, bg_00_summerscrnMap, &SCREENBLOCKBASE[28], bg_00_summerscrnMapLen / 2);
DMANow(3, bg_00_summerscrnTiles, &CHARBLOCKBASE[2], bg_00_summerscrnTilesLen / 2);
break;
case 2:
loadPalette(bg_02_summerscrnPal);
DMANow(3, bg_02_summerscrnMap, &SCREENBLOCKBASE[28], bg_02_summerscrnMapLen / 2);
DMANow(3, bg_02_summerscrnTiles, &CHARBLOCKBASE[2], bg_02_summerscrnTilesLen / 2);
break;
case 3:
loadPalette(bg_03_summerscrnPal);
DMANow(3, bg_03_summerscrnMap, &SCREENBLOCKBASE[28], bg_03_summerscrnMapLen / 2);
DMANow(3, bg_03_summerscrnTiles, &CHARBLOCKBASE[2], bg_03_summerscrnTilesLen / 2);
break;
case 4:
loadPalette(bg_04_summerscrnPal);
DMANow(3, bg_04_summerscrnMap, &SCREENBLOCKBASE[28], bg_04_summerscrnMapLen / 2);
DMANow(3, bg_04_summerscrnTiles, &CHARBLOCKBASE[2], bg_04_summerscrnTilesLen / 2);
break;
case 5:
loadPalette(bg_05_summerscrnPal);
DMANow(3, bg_05_summerscrnMap, &SCREENBLOCKBASE[28], bg_05_summerscrnMapLen / 2);
DMANow(3, bg_05_summerscrnTiles, &CHARBLOCKBASE[2], bg_05_summerscrnTilesLen / 2);
break;
case 6:
loadPalette(bg_06_summerscrnPal);
DMANow(3, bg_06_summerscrnMap, &SCREENBLOCKBASE[28], bg_06_summerscrnMapLen / 2);
DMANow(3, bg_06_summerscrnTiles, &CHARBLOCKBASE[2], bg_06_summerscrnTilesLen / 2);
break;
case 7:
loadPalette(bg_07_summerscrnPal);
DMANow(3, bg_07_summerscrnMap, &SCREENBLOCKBASE[28], bg_07_summerscrnMapLen / 2);
DMANow(3, bg_07_summerscrnTiles, &CHARBLOCKBASE[2], bg_07_summerscrnTilesLen / 2);
break;
case 8:
loadPalette(bg_08_summerscrnPal);
DMANow(3, bg_08_summerscrnMap, &SCREENBLOCKBASE[28], bg_08_summerscrnMapLen / 2);
DMANow(3, bg_08_summerscrnTiles, &CHARBLOCKBASE[2], bg_08_summerscrnTilesLen / 2);
break;
case 9:
loadPalette(bg_09_summerscrnPal);
DMANow(3, bg_09_summerscrnMap, &SCREENBLOCKBASE[28], bg_09_summerscrnMapLen / 2);
DMANow(3, bg_09_summerscrnTiles, &CHARBLOCKBASE[2], bg_09_summerscrnTilesLen / 2);
break;
case 10:
loadPalette(bg_10_summerscrnPal);
DMANow(3, bg_10_summerscrnMap, &SCREENBLOCKBASE[28], bg_10_summerscrnMapLen / 2);
DMANow(3, bg_10_summerscrnTiles, &CHARBLOCKBASE[2], bg_10_summerscrnTilesLen / 2);
break;
case 11:
loadPalette(bg_final_summerscrnPal);
DMANow(3, bg_final_summerscrnMap, &SCREENBLOCKBASE[28], bg_final_summerscrnMapLen / 2);
DMANow(3, bg_final_summerscrnTiles, &CHARBLOCKBASE[2], bg_final_summerscrnTilesLen / 2);
break;
}
break;
case FALL:
// Turn on falling leaves
REG_DISPCTL |= BG1_ENABLE;
loadPalette(bg_fallPal);
DMANow(3, bg_fallMap, &SCREENBLOCKBASE[27], bg_fallMapLen / 2);
DMANow(3, bg_fallTiles, &CHARBLOCKBASE[1], bg_fallTilesLen / 2);
switch (currentLevel) {
case 1:
loadPalette(bg_00_fallscrnPal);
DMANow(3, bg_00_fallscrnMap, &SCREENBLOCKBASE[28], bg_00_fallscrnMapLen / 2);
DMANow(3, bg_00_fallscrnTiles, &CHARBLOCKBASE[2], bg_00_fallscrnTilesLen / 2);
break;
case 2:
loadPalette(bg_02_fallscrnPal);
DMANow(3, bg_02_fallscrnMap, &SCREENBLOCKBASE[28], bg_02_fallscrnMapLen / 2);
DMANow(3, bg_02_fallscrnTiles, &CHARBLOCKBASE[2], bg_02_fallscrnTilesLen / 2);
break;
case 3:
loadPalette(bg_03_fallscrnPal);
DMANow(3, bg_03_fallscrnMap, &SCREENBLOCKBASE[28], bg_03_fallscrnMapLen / 2);
DMANow(3, bg_03_fallscrnTiles, &CHARBLOCKBASE[2], bg_03_fallscrnTilesLen / 2);
break;
case 4:
loadPalette(bg_04_fallscrnPal);
DMANow(3, bg_04_fallscrnMap, &SCREENBLOCKBASE[28], bg_04_fallscrnMapLen / 2);
DMANow(3, bg_04_fallscrnTiles, &CHARBLOCKBASE[2], bg_04_fallscrnTilesLen / 2);
break;
case 5:
loadPalette(bg_05_fallscrnPal);
DMANow(3, bg_05_fallscrnMap, &SCREENBLOCKBASE[28], bg_05_fallscrnMapLen / 2);
DMANow(3, bg_05_fallscrnTiles, &CHARBLOCKBASE[2], bg_05_fallscrnTilesLen / 2);
break;
case 6:
loadPalette(bg_06_fallscrnPal);
DMANow(3, bg_06_fallscrnMap, &SCREENBLOCKBASE[28], bg_06_fallscrnMapLen / 2);
DMANow(3, bg_06_fallscrnTiles, &CHARBLOCKBASE[2], bg_06_fallscrnTilesLen / 2);
break;
case 7:
loadPalette(bg_07_fallscrnPal);
DMANow(3, bg_07_fallscrnMap, &SCREENBLOCKBASE[28], bg_07_fallscrnMapLen / 2);
DMANow(3, bg_07_fallscrnTiles, &CHARBLOCKBASE[2], bg_07_fallscrnTilesLen / 2);
break;
case 8:
loadPalette(bg_08_fallscrnPal);
DMANow(3, bg_08_fallscrnMap, &SCREENBLOCKBASE[28], bg_08_fallscrnMapLen / 2);
DMANow(3, bg_08_fallscrnTiles, &CHARBLOCKBASE[2], bg_08_fallscrnTilesLen / 2);
break;
case 9:
loadPalette(bg_09_fallscrnPal);
DMANow(3, bg_09_fallscrnMap, &SCREENBLOCKBASE[28], bg_09_fallscrnMapLen / 2);
DMANow(3, bg_09_fallscrnTiles, &CHARBLOCKBASE[2], bg_09_fallscrnTilesLen / 2);
break;
case 10:
loadPalette(bg_10_fallscrnPal);
DMANow(3, bg_10_fallscrnMap, &SCREENBLOCKBASE[28], bg_10_fallscrnMapLen / 2);
DMANow(3, bg_10_fallscrnTiles, &CHARBLOCKBASE[2], bg_10_fallscrnTilesLen / 2);
break;
case 11:
loadPalette(bg_final_fallscrnPal);
DMANow(3, bg_final_fallscrnMap, &SCREENBLOCKBASE[28], bg_final_fallscrnMapLen / 2);
DMANow(3, bg_final_fallscrnTiles, &CHARBLOCKBASE[2], bg_final_fallscrnTilesLen / 2);
break;
}
break;
case WINTER:
// Turn on snow
REG_DISPCTL |= BG1_ENABLE;
loadPalette(bg_snowPal);
DMANow(3, bg_snowMap, &SCREENBLOCKBASE[27], bg_snowMapLen / 2);
DMANow(3, bg_snowTiles, &CHARBLOCKBASE[1], bg_snowTilesLen / 2);
switch (currentLevel) {
case 1:
loadPalette(bg_00_winterscrnPal);
DMANow(3, bg_00_winterscrnMap, &SCREENBLOCKBASE[28], bg_00_winterscrnMapLen / 2);
DMANow(3, bg_00_winterscrnTiles, &CHARBLOCKBASE[2], bg_00_winterscrnTilesLen / 2);
break;
case 2:
loadPalette(bg_02_winterscrnPal);
DMANow(3, bg_02_winterscrnMap, &SCREENBLOCKBASE[28], bg_02_winterscrnMapLen / 2);
DMANow(3, bg_02_winterscrnTiles, &CHARBLOCKBASE[2], bg_02_winterscrnTilesLen / 2);
break;
case 3:
loadPalette(bg_03_winterscrnPal);
DMANow(3, bg_03_winterscrnMap, &SCREENBLOCKBASE[28], bg_03_winterscrnMapLen / 2);
DMANow(3, bg_03_winterscrnTiles, &CHARBLOCKBASE[2], bg_03_winterscrnTilesLen / 2);
break;
case 4:
loadPalette(bg_04_winterscrnPal);
DMANow(3, bg_04_winterscrnMap, &SCREENBLOCKBASE[28], bg_04_winterscrnMapLen / 2);
DMANow(3, bg_04_winterscrnTiles, &CHARBLOCKBASE[2], bg_04_winterscrnTilesLen / 2);
break;
case 5:
loadPalette(bg_05_winterscrnPal);
DMANow(3, bg_05_winterscrnMap, &SCREENBLOCKBASE[28], bg_05_winterscrnMapLen / 2);
DMANow(3, bg_05_winterscrnTiles, &CHARBLOCKBASE[2], bg_05_winterscrnTilesLen / 2);
break;
case 6:
loadPalette(bg_06_winterscrnPal);
DMANow(3, bg_06_winterscrnMap, &SCREENBLOCKBASE[28], bg_06_winterscrnMapLen / 2);
DMANow(3, bg_06_winterscrnTiles, &CHARBLOCKBASE[2], bg_06_winterscrnTilesLen / 2);
break;
case 7:
loadPalette(bg_07_winterscrnPal);
DMANow(3, bg_07_winterscrnMap, &SCREENBLOCKBASE[28], bg_07_winterscrnMapLen / 2);
DMANow(3, bg_07_winterscrnTiles, &CHARBLOCKBASE[2], bg_07_winterscrnTilesLen / 2);
break;
case 8:
loadPalette(bg_08_winterscrnPal);
DMANow(3, bg_08_winterscrnMap, &SCREENBLOCKBASE[28], bg_08_winterscrnMapLen / 2);
DMANow(3, bg_08_winterscrnTiles, &CHARBLOCKBASE[2], bg_08_winterscrnTilesLen / 2);
break;
case 9:
loadPalette(bg_09_winterscrnPal);
DMANow(3, bg_09_winterscrnMap, &SCREENBLOCKBASE[28], bg_09_winterscrnMapLen / 2);
DMANow(3, bg_09_winterscrnTiles, &CHARBLOCKBASE[2], bg_09_winterscrnTilesLen / 2);
break;
case 10:
loadPalette(bg_10_winterscrnPal);
DMANow(3, bg_10_winterscrnMap, &SCREENBLOCKBASE[28], bg_10_winterscrnMapLen / 2);
DMANow(3, bg_10_winterscrnTiles, &CHARBLOCKBASE[2], bg_10_winterscrnTilesLen / 2);
break;
case 11:
loadPalette(bg_final_winterscrnPal);
DMANow(3, bg_final_winterscrnMap, &SCREENBLOCKBASE[28], bg_final_winterscrnMapLen / 2);
DMANow(3, bg_final_winterscrnTiles, &CHARBLOCKBASE[2], bg_final_winterscrnTilesLen / 2);
break;
}
break;
}
}
void Graphics::init() {
loadPalette();
loadCursors();
loadFonts();
}
