Graphics/Sprites/fire_and_sprites/source/main.cpp

/*---------------------------------------------------------------------------------
        $Id: main.cpp,v 1.16 2008-11-29 22:58:58 wntrmute Exp $

        -- dovoto

---------------------------------------------------------------------------------*/

#include <stdlib.h>
#include <string.h>
#include <nds.h>

//include our ball pcx file (auto generated)
#include "ball_pcx.h"

#define NUM_SPRITES 128 

SpriteEntry OAMCopySub[128];

//simple sprite struct
typedef struct {
        int x,y;                        // screen co-ordinates 
        int dx, dy;                     // velocity
        SpriteEntry* oam;       // pointer to the sprite attributes in OAM
        int gfxID;                      // graphics lovation
}Sprite;


//---------------------------------------------------------------------------------
void MoveSprite(Sprite* sp) {
//---------------------------------------------------------------------------------
        int x = sp->x >> 8;
        int y = sp->y >> 8;

        sp->oam->x = x;
        sp->oam->y = y;

} 



//---------------------------------------------------------------------------------
void initOAM(void) {
//---------------------------------------------------------------------------------
        int i;

        for(i = 0; i < 128; i++) {
                OAMCopySub[i].attribute[0] = ATTR0_DISABLED;
        }       
}

//---------------------------------------------------------------------------------
void updateOAM(void) {
//---------------------------------------------------------------------------------
        memcpy(OAM_SUB, OAMCopySub, 128 * sizeof(SpriteEntry));
}



//---------------------------------------------------------------------------------
int main(void) {
//---------------------------------------------------------------------------------
        
        uint16* back = VRAM_A;
        uint16* front = VRAM_B;

        Sprite sprites[NUM_SPRITES];

        int i, delta = 0;
        int ix = 0;
        int iy = 0;
        int screen = 1;
        uint16* map0 = (uint16*)SCREEN_BASE_BLOCK_SUB(1);
        uint16* map1 = (uint16*)SCREEN_BASE_BLOCK_SUB(2);
        uint16 red;

        //set main display to render directly from the frame buffer
        videoSetMode(MODE_FB1);
        
        //set up the sub display
        videoSetModeSub(MODE_0_2D | 
                                        DISPLAY_SPR_1D_LAYOUT | 
                                        DISPLAY_SPR_ACTIVE | 
                                        DISPLAY_BG0_ACTIVE |
                                        DISPLAY_BG1_ACTIVE );
        
        //vram banks are somewhat complex
        vramSetMainBanks(VRAM_A_LCD, VRAM_B_LCD, VRAM_C_SUB_BG, VRAM_D_SUB_SPRITE);     

        sImage ball;

        //load our ball pcx file into an image
        loadPCX((u8*)ball_pcx, &ball);
        
        //tile it so it is usefull as sprite data
        imageTileData(&ball);

        // Sprite initialisation
        for(i = 0; i < 256; i++)
                SPRITE_PALETTE_SUB[i] = ball.palette[i];

        for(i = 0; i< 32*16; i++)
                SPRITE_GFX_SUB[i] = ball.image.data16[i];
        
        //turn off sprites
        initOAM();

        for(i = 0; i < NUM_SPRITES; i++) {
                //random place and speed
                sprites[i].x = rand() & 0xFFFF;
                sprites[i].y = rand() & 0x7FFF;
                sprites[i].dx = (rand() & 0xFF) + 0x100;
                sprites[i].dy = (rand() & 0xFF) + 0x100;
        
                if(rand() & 1)
                        sprites[i].dx = -sprites[i].dx;
                if(rand() & 1)
                        sprites[i].dy = -sprites[i].dy;
        
                sprites[i].oam = &OAMCopySub[i];
                sprites[i].gfxID = 0;
        
                //set up our sprites OAM entry attributes
                sprites[i].oam->attribute[0] = ATTR0_COLOR_256 | ATTR0_SQUARE;  
                sprites[i].oam->attribute[1] = ATTR1_SIZE_32;
                sprites[i].oam->attribute[2] = sprites[i].gfxID;
        }

        //set up two backgrounds to scroll around
        REG_BG0CNT_SUB = BG_COLOR_256 | (1 << MAP_BASE_SHIFT);
        REG_BG1CNT_SUB = BG_COLOR_256 | (2 << MAP_BASE_SHIFT);

        BG_PALETTE_SUB[0] = RGB15(10,10,10);
        BG_PALETTE_SUB[1] = RGB15(0,16,0);
        BG_PALETTE_SUB[2] = RGB15(0,0,31);
        
        //load the maps with alternating tiles (0,1 for bg0 and 0,2 for bg1)
        for(iy = 0; iy < 32; iy++) {
                for(ix = 0; ix <32; ix++) {
                        map0[iy * 32 + ix] = (ix ^ iy) & 1;
                        map1[iy * 32 + ix] = ((ix ^ iy) & 1)<<1;
                }
        }    

        //fill 2 tiles with different colors
        for(i = 0; i < 64 / 2; i++) {
                BG_GFX_SUB[i+32] = 0x0101;
                BG_GFX_SUB[i+32+32] = 0x0202;
        }       

        while (1) {
                //scroll the background
                REG_BG0HOFS = delta ;
                REG_BG0VOFS = delta++ ;
                
                //move the sprites
                for(i = 0; i < NUM_SPRITES; i++) {
                        sprites[i].x += sprites[i].dx;
                        sprites[i].y += sprites[i].dy;
                        
                        //check for collision with the screen boundries
                        if(sprites[i].x < (1<<8) || sprites[i].x > (247 << 8))
                                sprites[i].dx = -sprites[i].dx;

                        if(sprites[i].y < (1<<8) || sprites[i].y > (182 << 8))
                                sprites[i].dy = -sprites[i].dy;
                        
                        //reposition the sprites
                        MoveSprite(&sprites[i]);
                }
                

        
                //do the plasma/fire
                for(ix = 0; ix < SCREEN_WIDTH; ix++) {
                        back[ix + SCREEN_WIDTH * (SCREEN_HEIGHT - 1)] = rand()& 0xFFFF;
                        back[ix + SCREEN_WIDTH * (SCREEN_HEIGHT - 2)] = rand()& 0xFFFF;
                }

                back++;
                
                for(iy = 1; iy < SCREEN_HEIGHT - 2 ; iy++) {
                        for(ix = 1; ix < SCREEN_WIDTH - 1; ix++)  {
                                red = 0;

                                red += front[0];
                                red += front[2];
        
                                front += SCREEN_WIDTH;

                                red += front[0];
                                red += front[1];
                                red += front[2];
                                
                                front += SCREEN_WIDTH;

                                red += front[0];
                                red += front[1];
                                red += front[2];

                                front -= (2 * SCREEN_WIDTH) - 1;        

                                back[0] =  (red >> 3);  
                                back++;
                        }
                        back += 2;
                        front += 2;
                
                }

                swiWaitForVBlank();
                
                updateOAM();

                //flip screens
                if(screen) {
                        videoSetMode(MODE_FB1);
                        front = VRAM_B;
                        back = VRAM_A;
                        screen = 0;
                } else {
                        videoSetMode(MODE_FB0); 
                        front = VRAM_A;
                        back = VRAM_B;
                        screen = 1;
                }
        }    
        return 0;
}