Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Nov 19th, 2010  |  syntax: None  |  size: 16.80 KB  |  views: 157  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
This paste has a previous version, view the difference. Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. /*===========================================
  2.         GRRLIB (GX Version)
  3.         - Template Code -
  4.  
  5.         Minimum Code To Use GRRLIB
  6. ============================================*/
  7. #include <grrlib.h>
  8.  
  9. #include <stdlib.h>
  10. #include <wiiuse/wpad.h>
  11.  
  12. #include "custcolors.h"
  13. #include "objects.h"
  14. #include "font.h"
  15. #include "font.c"
  16.  
  17. extern const unsigned char font[];
  18. extern const int font_size;
  19.  
  20. struct cursor
  21. {
  22.         int x;
  23.         int y;
  24.         int rot;
  25. };
  26.  
  27. struct gametile
  28. {
  29.         unsigned char chunk_id;
  30.         GRRLIB_texImg *tile_bottom; // this is the backgrond tile
  31.         GRRLIB_texImg *tile_top; // this is the foreground tile
  32.         GRRLIB_texImg *tile_col; // this one will be used for collision
  33. };
  34.  
  35. /*----------------------------------------------------------------------
  36.         These level index collapse/uncollapse functions were provided by GerbilSoft from Sonic Retro,
  37.         they're for turning 2d tile coordinates into a 1d level array value and vice-versa
  38. ----------------------------------------------------------------------*/
  39.  
  40. inline int rowcolToIdx(int row, int col)
  41. {
  42.     return (col + (row * 256));
  43. }
  44.  
  45. inline int rowFromIdx(int idx)
  46. {
  47.     return (idx >> 8);
  48. }
  49.  
  50. inline int colFromIdx(int idx)
  51. {
  52.     return (idx & 0xFF);
  53. }
  54.  
  55. /*----------------------------------------------------------------------
  56.         LoadMap() is a direct hack from PieChart at the moment. Remember that the new level format
  57.         is a series of horizontal tiles and wraps every 256 entries. It'll also probably need to be
  58.         split somehow to load object layouts as well. tilearray[] is the series of u8 values for
  59.         tileID's that make up the level. tuledata[] is the struct that holds all of the PNG images
  60.         for each tile.
  61. -----------------------------------------------------------------------*/
  62.  
  63. struct gametile tiledata[255]; // This holds the tile data
  64. u8 tilearray[2560]; // every 256 entries is one 'row', making for 10 rows total.
  65.  
  66. bool LoadMap(u8 level)
  67. {
  68.         u16 h;
  69.         FILE *leveldata;
  70.         //u8 levelarray[2560];
  71.         char levelpath[35];
  72.         char FG_path[35];
  73.         char BG_path[35];
  74.         char COL_path[35];
  75.         char sizemessage[30];
  76.         unsigned short filesize;
  77.        
  78.         GRRLIB_ttfFont *error_font = GRRLIB_LoadTTF(font, font_size);
  79.        
  80.         sprintf(levelpath,"sd:/apps/SonicWii/maps/%d/%d.bin", level, level);
  81.        
  82.         leveldata = fopen(levelpath, "rb");
  83.        
  84.         if (leveldata == NULL)
  85.         {
  86.                 while(1)
  87.                 {
  88.                         WPAD_ScanPads();
  89.                         GRRLIB_FillScreen(GRRLIB_BLACK);
  90.                         GRRLIB_PrintfTTF(90,90, error_font, "Error Loading Map", 18, GRRLIB_WHITE);
  91.                         GRRLIB_PrintfTTF(90,110, error_font, levelpath, 18, GRRLIB_WHITE);
  92.                         GRRLIB_PrintfTTF(90,130, error_font, "Press [HOME] to exit.", 14, GRRLIB_WHITE);
  93.                        
  94.                         if (WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_HOME)
  95.                         {
  96.                                 GRRLIB_Exit();
  97.                                 exit(0);
  98.                         }
  99.                         GRRLIB_Render();
  100.                 }
  101.                 return false; // error protection, file didn't load
  102.         }
  103.        
  104.         /*if (false) // old tile debugging routine. Use for checking GRRLIB_LoadTextureFromFile
  105.         {
  106.                 tile_error:
  107.                 while(1)
  108.                 {
  109.                         WPAD_ScanPads();
  110.                         GRRLIB_FillScreen(GRRLIB_BLACK);
  111.                         GRRLIB_PrintfTTF(90,90, error_font, "Error Loading Tile", 18, GRRLIB_WHITE);
  112.                         GRRLIB_PrintfTTF(90,110, error_font, COL_path, 18, GRRLIB_WHITE);
  113.                         GRRLIB_PrintfTTF(90,130, error_font, "Press [HOME] to exit.", 14, GRRLIB_WHITE);
  114.                        
  115.                         if (WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_HOME)
  116.                         {
  117.                                 GRRLIB_Exit();
  118.                                 exit(0);
  119.                         }
  120.                         GRRLIB_Render();
  121.                 }
  122.                 return false; // error protection, file didn't load
  123.         }*/
  124.  
  125.         fseek(leveldata, 0 , SEEK_END);
  126.         filesize = ftell(leveldata);
  127.         if (ftell(leveldata) != 0xa00)
  128.         {
  129.                 sprintf(sizemessage,"filesize is %d, expected 2560", filesize);
  130.                 while(1)
  131.                 {
  132.                         WPAD_ScanPads();
  133.                         GRRLIB_FillScreen(GRRLIB_BLACK);
  134.                         GRRLIB_PrintfTTF(90,90, error_font, "Error Loading Map: Size Mismatch", 18, GRRLIB_WHITE);
  135.                         GRRLIB_PrintfTTF(90,110, error_font, sizemessage, 18, GRRLIB_WHITE);
  136.                         GRRLIB_PrintfTTF(90,130, error_font, "Press [HOME] to exit.", 14, GRRLIB_WHITE);
  137.                        
  138.                         if (WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_HOME)
  139.                         {
  140.                                 GRRLIB_Exit();
  141.                                 exit(0);
  142.                         }
  143.                         GRRLIB_Render();
  144.                 }
  145.                 return false; // error protection, file didn't load
  146.         }
  147.        
  148.         rewind(leveldata);
  149.         fread(&tilearray, 1,2560,leveldata);
  150.        
  151.         /*for(h=0;h < 2560;h++)
  152.         {
  153.                 tilearray[h] = levelarray[h];// walk through file byte by byte and assign tile ID's accordingly
  154.         }*/
  155.        
  156.         for(h=0; h <= 255; h++)
  157.         {
  158.                 sprintf(COL_path,"maps/%d/%02d.png", level, h);
  159.                 tiledata[h].chunk_id = h;              
  160.                 if (GRRLIB_LoadTextureFromFile(COL_path) != NULL)
  161.                 {
  162.                         tiledata[h].tile_col = GRRLIB_LoadTextureFromFile(COL_path);
  163.                         //GRRLIB_InitTileSet(tiledata[h].tile_col, 256, 256, 0);
  164.                 }
  165.                 /*tiledata[h].tile_top = GRRLIB_CreateEmptyTexture(2,2);
  166.                 tiledata[h].tile_bottom = GRRLIB_CreateEmptyTexture(2,2);*/
  167.         }
  168.        
  169.         fclose(leveldata);
  170.         return true;
  171. }
  172.  
  173. /*------------------------------------------------------------------------------------------
  174.         ProcessPlayer()
  175.         ----------------
  176.         All of the player's physics and collision calculations will be processed by this function.
  177.         First, the player's state gets passed to a switch statement that decides wether to apply air
  178.         physics, ground physics, etc.
  179. -------------------------------------------------------------------------------------------*/
  180.  
  181. void ProcessPlayer(struct PLAYEROBJ *player)
  182. {
  183.         enum player_states playerstate;
  184.        
  185.         player->gnd_speed = player->x_speed + player->y_speed;
  186.  
  187.         switch(playerstate)
  188.         {
  189.                 case(PLAYER_GROUND): // All ground physics/collision calcs go here.
  190.                         if ((WPAD_ButtonsUp(0) & WIIMOTE_BUTTON_UP) && (WPAD_ButtonsUp(0) & WIIMOTE_BUTTON_DOWN))
  191.                         {
  192.                                 // no D-Pad input, we need to apply surface friction value
  193.                                 // We'll also need to add Collision checks here and at the D-Pad hold to make sure
  194.                                 // sonic doesn't go out of bounds
  195.                                 if (abs(player->x_speed) < FRICTION) player->x_speed = 0;
  196.                                 else if (player->x_speed < 0) player->x_speed = player->x_speed += (FRICTION*-1);
  197.                                 else if (player->x_speed > 0) player->x_speed = player->x_speed += (FRICTION*1);
  198.                         }
  199.                        
  200.                         if (WPAD_ButtonsHeld(0) & WIIMOTE_BUTTON_UP)
  201.                         {
  202.                                 /* we're holding left on the D-Pad. First we'll need to check our ground speed is
  203.                                 over the limit, then if it isn't, start adding acceleration to the x_speed value.
  204.                                 We'll also want to branch out of this if collision to the left returns true.*/
  205.                                 if (abs(player->x_speed) > MAXSPEED)
  206.                                 {
  207.                                         if (player->x_speed > 0) player->x_speed = MAXSPEED;
  208.                                         if (player->x_speed < 0) player->x_speed = NEG_MAXSPD;
  209.                                 }
  210.                                
  211.                                 if ((player->x_speed != MAXSPEED) && (player->x_speed != NEG_MAXSPD))
  212.                                 {
  213.                                         if (player->x_speed > 0) player->x_speed += DECELERATION;
  214.                                         if (player->x_speed < 0) player->x_speed -= ACCELERATION;
  215.                                 }
  216.                         } else if (WPAD_ButtonsHeld(0) & WIIMOTE_BUTTON_DOWN)
  217.                         {
  218.                                 /* we're holding right on the D-Pad. First we'll need to check our ground speed is
  219.                                 over the limit, then if it isn't, start adding acceleration to the x_speed value.
  220.                                 We'll also want to branch out of this if collision to the left returns true.*/
  221.                                 if (abs(player->x_speed) > MAXSPEED)
  222.                                 {
  223.                                         if (player->x_speed > 0) player->x_speed = MAXSPEED;
  224.                                         if (player->x_speed < 0) player->x_speed = NEG_MAXSPD;
  225.                                 }
  226.                                
  227.                                 if ((player->x_speed != MAXSPEED) && (player->x_speed != NEG_MAXSPD))
  228.                                 {
  229.                                         if (player->x_speed < 0) player->x_speed += DECELERATION;
  230.                                         if (player->x_speed > 0) player->x_speed -= ACCELERATION;
  231.                                 }
  232.                         }
  233.                         break; // Done with ground physics
  234.                
  235.                 case(PLAYER_AIR): // All player air physics/collision goes here
  236.                 break;
  237.                
  238.                 case(PLAYER_LEFT_WALL): // player left wall physics
  239.                 break;
  240.                
  241.                 case(PLAYER_RIGHT_WALL): // player right wall physics
  242.                 break;
  243.                
  244.                 case(PLAYER_CEILING): // player right wall physics
  245.                 break;
  246.                
  247.                 default: // insert some error handling here, as this state is 'unreachable'
  248.                 break;
  249.         }
  250. }
  251.  
  252. /*---------------------------------------------------------------------------------
  253.         GameLoop() is where most of the real action happens, all of the game's runtime calculations
  254.         occur here or are initiated here. Expect this function to change the most. The first thing
  255.         we need to do is to load all of P1's graphics. Don't forget that the wii's screen real
  256.         estate is 640x480, approximately double the Genesis' 320x244, with some black bars
  257.         on top for proper aspect ratio keeping.
  258. -----------------------------------------------------------------------------------*/
  259. void GameLoop()
  260. {
  261.         ir_t ir;
  262.         u8 level=1;
  263.        
  264.         // sonic       
  265.         GRRLIB_texImg *tex_sonic_walk = GRRLIB_LoadTextureFromFile("images/sonic/sonic_walk.png");
  266.         GRRLIB_texImg *tex_sonic_stand = GRRLIB_LoadTextureFromFile("images/sonic/sonic_stand.png");
  267.         GRRLIB_texImg *tex_sonic_ball = GRRLIB_LoadTextureFromFile("images/sonic/sonic_ball.png");
  268.         GRRLIB_texImg *tex_sonic_run = GRRLIB_LoadTextureFromFile("images/sonic/sonic_run.png");
  269.         GRRLIB_InitTileSet(tex_sonic_walk, 80, 80, 0);
  270.         GRRLIB_InitTileSet(tex_sonic_stand, 80, 80, 0);
  271.         GRRLIB_InitTileSet(tex_sonic_ball, 80, 80, 0);
  272.         GRRLIB_InitTileSet(tex_sonic_run, 80, 80, 0);
  273.         unsigned int count;
  274.         struct CAMOBJ camera;
  275.         struct PLAYEROBJ sonic_obj;
  276.         sonic_obj.score = 0;
  277.         sonic_obj.lives = 4;
  278.         sonic_obj.anim = 0;
  279.         sonic_obj.frame = 0;
  280.         sonic_obj.x_coord = 77;
  281.         sonic_obj.y_coord = 446;
  282.        
  283.         // ring
  284.         GRRLIB_texImg *tex_ring = GRRLIB_LoadTextureFromFile("images/ring.png");       
  285.         GRRLIB_ttfFont *font1 = GRRLIB_LoadTTF(font, font_size);
  286.         GRRLIB_texImg *tex_pointer = GRRLIB_LoadTextureFromFile("images/cursor.png");
  287.        
  288.         // cursor for collision picking
  289.         struct cursor pointer;
  290.         pointer.x=200;
  291.         pointer.y=200;
  292.        
  293.         /*----------------======Game Variables=========----------------------*/
  294.         unsigned int tickcounter=0;
  295.         u8 framecounter=0;
  296.         u8 secondcounter=0;
  297.         unsigned int minutecounter=0;  
  298.         char score_string[18]="";
  299.         char time_string[15]="";
  300.         char ring_string[11]="";
  301.         char debug_ln1[30]="";
  302.         char debug_ln2[30]="";
  303.         char debug_ln3[30]="";
  304.         char debug_ln4[30]="";
  305.         bool debugflag=false;
  306.         bool mapflag=false;
  307.         camera.x=6;
  308.         camera.y=222;
  309.         /*----------------======END Game Variables=====-----------------------*/
  310.        
  311.        
  312.         /*----------------=======Level Processing=====------------------------*/
  313.         unsigned int vis_tiles_1[3];
  314.         unsigned int vis_tiles_2[3];
  315.         unsigned int vis_tiles_3[3];
  316.         unsigned int vis_tiles_4[3];
  317.         unsigned int first_tile;
  318.         unsigned int x_current,y_current;
  319.         unsigned short h;
  320.         LoadMap(level);
  321.         /*---------------------=========END level processing====----------------------------*/
  322.        
  323.         // Done loading, begin game loop.
  324.         while(1)
  325.         {
  326.                 tickcounter++;
  327.                
  328.                 if (framecounter < 60) framecounter ++;
  329.        
  330.                 if ((framecounter == 60) && (secondcounter < 60))
  331.                 {
  332.                         framecounter = 0;
  333.                         secondcounter++;
  334.                 }
  335.                
  336.                 if ((framecounter == 60) && (secondcounter == 60))
  337.                 {
  338.                         framecounter = 0;
  339.                         secondcounter = 0;
  340.                         minutecounter++;
  341.                 }
  342.                
  343.                 /*------------====Control Collection/Gameplay Calc=====-------------
  344.                 Obviously comes before drawing =P
  345.                 --------------------------------------------------------------------*/
  346.                 WPAD_ScanPads();  // Scan the Wiimotes
  347.                 WPAD_IR(WPAD_CHAN_0, &ir);
  348.                
  349.                 pointer.x = ir.x;
  350.                 pointer.y = ir.y;
  351.                
  352.                 if (WPAD_ButtonsHeld(0) & WPAD_BUTTON_RIGHT) camera.y--;
  353.                 if (WPAD_ButtonsHeld(0) & WPAD_BUTTON_LEFT) camera.y++;
  354.                 if (WPAD_ButtonsHeld(0) & WPAD_BUTTON_UP) camera.x--;
  355.                 if (WPAD_ButtonsHeld(0) & WPAD_BUTTON_DOWN) camera.x++;
  356.                
  357.                 if ((WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_ONE) && (debugflag == false)) debugflag = true;
  358.                 else if ((WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_ONE) && (debugflag == true)) debugflag = false;
  359.                
  360.                 if (WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_TWO) mapflag = true;
  361.                
  362.                 /*--------------========END game calc===========--------------------*/
  363.                
  364.                 GRRLIB_FillScreen(GRRLIB_BLACK);
  365.                
  366.                 /*---------------------------------------------------------------
  367.                 Map drawing will need to be split into 2 different passes, so that the characters can
  368.                 be drawn inbetween the 2 layers. This is the first of 2 passes. At any given time, 16
  369.                 tiles will be in the level renderer. To figure out which tiles to draw and how far to
  370.                 offset them, we'll need to use the camera's coordinates and divide by 256 to find our
  371.                 starting tile. The rest can be filled in automatically, as each line is 4 tiles long.
  372.                 4 arrays were created for holding this render queue, named "vis_tiles_x[4]"
  373.                 respectively. A member of CAMOBJ called in_tile was added for computing where in the
  374.                 main tile array to search.
  375.                 -------------------------------------------------------------------*/
  376.                 // first we fill our screen cache
  377.                 camera.in_tile[0] = camera.x/256; // row
  378.                 camera.in_tile[1] = camera.y/256; // column
  379.                 first_tile = rowcolToIdx(camera.in_tile[0], camera.in_tile[1]);
  380.                
  381.                 for(h = 0; h < 4; h++) // first row
  382.                 {
  383.                         vis_tiles_1[h] = first_tile + h;
  384.                 }
  385.                
  386.                 for(h = 0; h < 4; h++) // second row
  387.                 {
  388.                         vis_tiles_2[h] = (first_tile + 256) + h;
  389.                 }
  390.                
  391.                 for(h = 0; h < 4; h++) // third row
  392.                 {
  393.                         vis_tiles_3[h] = (first_tile + 512) + h;
  394.                 }
  395.                
  396.                 for(h = 0; h < 4; h++) // fourth row
  397.                 {
  398.                         vis_tiles_4[h] = (first_tile + 768) + h;
  399.                 }
  400.                
  401.                 // this is the actual display loop, first pass 
  402.                 for(h = 0; h < 4; h++)
  403.                 {
  404.                         x_current = rowFromIdx(vis_tiles_1[h]) * 256;
  405.                         y_current = colFromIdx(vis_tiles_1[h]) * 256;
  406.                         GRRLIB_DrawImg(x_current - camera.x, y_current - camera.y, tiledata[tilearray[vis_tiles_1[h]]].tile_col, 0, 1, 1, GRRLIB_WHITE);
  407.                 }
  408.                
  409.                 for(h = 0; h < 4; h++)
  410.                 {
  411.                         x_current = rowFromIdx(vis_tiles_2[h]) * 256;
  412.                         y_current = colFromIdx(vis_tiles_2[h]) * 256;
  413.                         GRRLIB_DrawImg(x_current - camera.x, y_current - camera.y, tiledata[tilearray[vis_tiles_2[h]]].tile_col, 0, 1, 1, GRRLIB_WHITE);
  414.                 }
  415.                
  416.                 for(h = 0; h < 4; h++)
  417.                 {
  418.                         x_current = rowFromIdx(vis_tiles_3[h]) * 256;
  419.                         y_current = colFromIdx(vis_tiles_3[h]) * 256;
  420.                         GRRLIB_DrawImg(x_current - camera.x, y_current - camera.y, tiledata[tilearray[vis_tiles_3[h]]].tile_col, 0, 1, 1, GRRLIB_WHITE);
  421.                 }
  422.                
  423.                 for(h = 0; h < 4; h++)
  424.                 {
  425.                         x_current = rowFromIdx(vis_tiles_4[h]) * 256;
  426.                         y_current = colFromIdx(vis_tiles_4[h]) * 256;
  427.                         GRRLIB_DrawImg(x_current - camera.x, y_current - camera.y, tiledata[tilearray[vis_tiles_4[h]]].tile_col, 0, 1, 1, GRRLIB_WHITE);
  428.                 }
  429.  
  430.                 // Draw Sonic
  431.                 GRRLIB_DrawTile(sonic_obj.x_coord - camera.x, sonic_obj.y_coord - camera.y, tex_sonic_stand, 0,1,1,GRRLIB_WHITE,sonic_obj.frame);
  432.                 GRRLIB_Rectangle(pointer.x, pointer.y, 80, 2, GRRLIB_RED, true);
  433.                
  434.                 // second level render pass goes here.
  435.                
  436.                 // Drawing HUD - this will need to get moved to the end of the drawchain to show up
  437.                 // on top of everything else
  438.                 sprintf(score_string, "Score: %d", sonic_obj.score);
  439.                 sprintf(time_string, "Time: %d:%d:%d", minutecounter,secondcounter,framecounter);
  440.                 sprintf(ring_string, "Rings: %d", sonic_obj.rings);
  441.                 GRRLIB_PrintfTTF(32,32, font1, score_string, 26, GRRLIB_WHITE);
  442.                 GRRLIB_PrintfTTF(32,64, font1, time_string, 26, GRRLIB_WHITE);
  443.                 GRRLIB_PrintfTTF(32,98, font1, ring_string, 26, GRRLIB_WHITE);
  444.                
  445.                 if ((debugflag == true) && (mapflag == false))
  446.                 {
  447.                         sprintf(debug_ln1, "x: %d", camera.x);
  448.                         sprintf(debug_ln2, "y: %d", camera.y);
  449.                         sprintf(debug_ln3, "tile: %d:%d | %d", camera.in_tile[0], camera.in_tile[1], first_tile);
  450.                         GRRLIB_PrintfTTF(420,32, font1, debug_ln1, 18, GRRLIB_WHITE);
  451.                         GRRLIB_PrintfTTF(420,64, font1, debug_ln2, 18, GRRLIB_WHITE);
  452.                         GRRLIB_PrintfTTF(420,98, font1, debug_ln3, 18, GRRLIB_WHITE);
  453.                 }
  454.                
  455.                 while (mapflag == true)
  456.                 {
  457.                         WPAD_ScanPads();
  458.                         debugflag = false;
  459.                         sprintf(debug_ln1, "%d | %d | %d | %d", vis_tiles_1[0], vis_tiles_1[1], vis_tiles_1[2], vis_tiles_1[3]);
  460.                         sprintf(debug_ln2, "%d | %d | %d | %d", vis_tiles_2[0], vis_tiles_2[1], vis_tiles_2[2], vis_tiles_2[3]);
  461.                         sprintf(debug_ln3, "%d | %d | %d | %d", vis_tiles_3[0], vis_tiles_3[1], vis_tiles_3[2], vis_tiles_3[3]);
  462.                         sprintf(debug_ln4, "%d | %d | %d | %d", vis_tiles_4[0], vis_tiles_4[1], vis_tiles_4[2], vis_tiles_4[3]);
  463.                         GRRLIB_PrintfTTF(50,32, font1, debug_ln1, 22, GRRLIB_WHITE);
  464.                         GRRLIB_PrintfTTF(50,64, font1, debug_ln2, 22, GRRLIB_WHITE);
  465.                         GRRLIB_PrintfTTF(50,98, font1, debug_ln3, 22, GRRLIB_WHITE);
  466.                         GRRLIB_PrintfTTF(50,130, font1, debug_ln4, 22, GRRLIB_WHITE);
  467.                        
  468.                         if (WPAD_ButtonsHeld(0) & WIIMOTE_BUTTON_ONE)
  469.                         {
  470.                                 mapflag = false;
  471.                                 break;
  472.                         } else if (WPAD_ButtonsHeld(0) & WPAD_BUTTON_HOME)
  473.                         {
  474.                                 GRRLIB_Exit();
  475.                                 exit(0);
  476.                         }
  477.                        
  478.                         GRRLIB_Render();
  479.                 }
  480.                
  481.                
  482.                 if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME) break;
  483.                 if (WPAD_ButtonsDown(0) & WIIMOTE_BUTTON_A) GRRLIB_ScrShot("screenshot.png");
  484.                
  485.                 GRRLIB_Render();
  486.         }
  487.         return;
  488. }
  489.  
  490. int main(int argc, char **argv)
  491. {
  492.     // Initialise the Graphics & Video subsystem
  493.     GRRLIB_Init();
  494.  
  495.     // Initialise the Wiimotes
  496.     WPAD_Init();
  497.         WPAD_SetDataFormat(WPAD_CHAN_0, WPAD_FMT_BTNS_ACC_IR);
  498.  
  499.         GameLoop();
  500.        
  501.     GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB
  502.  
  503.     exit(0);  // Use exit() to exit a program, do not use 'return' from main()
  504. }