My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

XtreamRacing

By: a guest | Mar 16th, 2010 | Syntax: C | Size: 7.53 KB | Hits: 45 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. /**XtreamRacing - Main file - Leo |
  2. \---------------------------------/
  3. /An XtreamLua.com Project\
  4. ###################################
  5. */
  6.  
  7. #include <time.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <stdio.h>
  11. #include <pspkernel.h>
  12. #include <pspdebug.h>
  13. #include <libge/libge.h>
  14. #include <ctype.h>
  15. #include <math.h>
  16.  
  17. //u32 geImagePixel(int x, int y, ge_Image* img) pour la couleur d'un pixel. Et pour comparer tu fais if(geIma..xel(..) == RGBA(rouge, vert, bleu, alpha)
  18. #define setXY pspDebugScreenSetXY
  19. #define printf pspDebugScreenPrintf
  20. #define square(x) ((x) * (x))//Macro pour le carre
  21.  
  22.  
  23. #define VITESSE_MAX -6 //Vitesse Maximum d'un vaisseau
  24. #define VITESSE_MAX_ARR 4 //Vitesse Maximum d'un vaisseau en marche arriere
  25. #define S_PAD 60 //Intervalle autour de 0 ou le pad n'est pas prit en compte (Pour gerer la defaillance du materiel, qui ne se remmet jamais a 0;0 tout seul)
  26.  
  27. PSP_MODULE_INFO("LibGE Sample", PSP_MODULE_USER, 0, 1);
  28. PSP_HEAP_SIZE_KB(2048);
  29.  
  30. //-------------------Prototypes des fonctions-------------------
  31. typedef struct //Structure Point, on en a besoin dans les fonctions, donc on le defnit avant la boucle
  32. {
  33.         float x, y;
  34.         float vitesse;
  35. } Point;
  36.  
  37. float GetDegrees(double radian);
  38. void MoveTo( Point *Depart, Point Direction);
  39. void PrintSplash();
  40.  
  41. //-------------------Fonction Main-------------------
  42. int main(int args, char** argc)
  43. {
  44.         pspDebugScreenInit();//Initialise le pspDebug
  45.         geInit();//Initialise la LibGE
  46.         SceCtrlData pad;
  47.         PrintSplash();//On affiche le splash
  48.         printf("Please wait : Loading data");
  49.         int i,j;
  50.         char Path[20];
  51.         ge_Image *ImgFond[2][3];
  52.         for (i = 0; i < 2; ++i)
  53.         {
  54.                 for (j = 0; j < 3; ++j)
  55.                 {
  56.                         sprintf(Path,"./fond%d%d.png",i,j);
  57.                         ImgFond[i][j] = geLoadImage(Path);
  58.                         geSwizzle (ImgFond[i][j]);
  59.                 }
  60.         }
  61.         ge_Image *ImgVaisseau = geLoadImage("./vaisseau.png");
  62.         geSwizzle(ImgVaisseau);
  63.        
  64.         typedef struct
  65.         {
  66.                 Point position;
  67.                 float angle;
  68.         } Vaisseau;
  69.        
  70.         Vaisseau Joueur1;
  71.         Point Direction;
  72.         Point Fond;
  73.        
  74.         Joueur1.position.x = 240, Joueur1.position.y = 136; Joueur1.position.vitesse = 0;
  75.         Fond.x = -343, Fond.y = -337;
  76.         Direction.x = 60, Direction.y = 60;
  77.         Fond.vitesse = 0;
  78.         Joueur1.angle = 90;
  79.         u32 ColorTest = geGetDrawBuffer()[(int)Joueur1.position.x+(int)Joueur1.position.y*512];//Premiere initialisation
  80.        
  81.         while(1)
  82.         {
  83.                 sceCtrlReadBufferPositive(&pad, 1);
  84.                 geClearScreen();
  85.                 /*Debut de controle de touches*/
  86.        
  87.                 //NB: Les quatres conditions suivantes retournent des vitesses invers?es, car elles servent a l'affichage du fond
  88.                 if((pad.Buttons & PSP_CTRL_CROSS) && (Fond.vitesse > VITESSE_MAX))//Accelerer
  89.                 {
  90.                         Fond.vitesse -= 0.5;
  91.                 }
  92.                 else if (Fond.vitesse < 0)//Ralentissement si on relache la touche (On va vers l'arret)
  93.                 {
  94.                         Fond.vitesse += 0.5;
  95.                 }
  96.                 if((pad.Buttons & PSP_CTRL_SQUARE) && (Fond.vitesse < VITESSE_MAX_ARR))//Marche arriere
  97.                 {
  98.                         Fond.vitesse += 0.5;
  99.                 }
  100.                 else if (Fond.vitesse > 0)//Ralentissement si on relache la touche (On va vers l'arret)
  101.                 {
  102.                         Fond.vitesse -= 0.5;
  103.                 }
  104.                 /*Debut du blocage en cas de collision*/
  105.                 if (ColorTest == RGBA(255,95,95,0))
  106.                 {
  107.                         Fond.vitesse = 40;
  108.                         MoveTo(&Fond, Direction);
  109.                         Fond.vitesse = 0;
  110.                 }
  111.                 /*fin du blocage en cas de collision*/
  112.                
  113.                
  114.                
  115.                 if ((pad.Lx - 128 > S_PAD) || (pad.Ly - 128 > S_PAD) || (pad.Lx - 128 < -S_PAD)||(pad.Ly - 128 < -S_PAD))//Sensibilit? du pad
  116.                 {
  117.                         Direction.x =  pad.Lx - 128;//Si le pad bouge suffisament, Direction prend sa valeur -128
  118.                         Direction.y = pad.Ly - 128;//(On a ainsi Direction comprit dans [-127;-S_PAD]U[S_PAD;128])
  119.                 }
  120.                 /*Fin de controle de touches*/
  121.  
  122.                 //Rajout du scrolling de Fond
  123.                 MoveTo( &Fond, Direction);
  124.                
  125.                 Joueur1.angle = GetDegrees(acos((Direction.x * 1)/127));//Servira lorsque la fonction rotated sera fonctionnelle
  126.                 {//On isole cette partie pour que w et z ne soient utilisables qu'a l'interieur (prends moins de place en memoire ^^)
  127.                         int h,w;//Pour l'affichage, i et j sont declar?s plus haut
  128.                         for (i = 0, h = 0; i < 2; ++i,h = h + 512)//Eh oui, on peut mettre plusieurs variables a incrementer dans un for (en les separant par des virgule)
  129.                         {
  130.                                 for (j = 0, w = 0; j < 3; ++j, w = w + 512)
  131.                                 {
  132.                                         geBlitImage( (int)Fond.x + w, (int)Fond.y + h, ImgFond[i][j], 0, 0, ImgFond[i][j]->width, ImgFond[i][j]->height, 1);//Haut/gauche
  133.                                 }
  134.                         }
  135.                 }
  136.                 ColorTest = geGetDrawBuffer()[(int)Joueur1.position.x+(int)Joueur1.position.y*512];
  137.                 geBlitImage( (int)Joueur1.position.x-10 , (int)Joueur1.position.y-10 , ImgVaisseau, 0, 0, ImgVaisseau->width, ImgVaisseau->height, true);
  138.                 setXY(1,1);
  139.                 printf("%d/fps", geFps());
  140.                 geSwapBuffers();//On swap les buffers
  141.         }
  142.        
  143. }
  144. //-------------------Declaration des fonctions-------------------
  145. float GetDegrees(double radian)
  146. {
  147.         return  180 * radian / M_PI;//Relation entre les radians et les degr?s
  148. }
  149. void MoveTo( Point *Depart, Point Direction)
  150. {
  151.         if ((Direction.x >= 0)&&(Direction.y >= 0)) // |?
  152.         {
  153.                 //On doit incrementer les x et les y
  154.                 if (Direction.x >= Direction.y)
  155.                 {
  156.                         Depart->x += Depart->vitesse;
  157.                         Depart->y += (Direction.y /Direction.x)*Depart->vitesse;
  158.                 }
  159.                 else
  160.                 {
  161.                         Depart->x += (Direction.x/Direction.y)*Depart->vitesse;
  162.                         Depart->y += Depart->vitesse;
  163.                 }
  164.         }
  165.         else if ((Direction.x < 0)&&(Direction.y < 0))// _|
  166.         {
  167.                 //On doit decrementer les x et les y
  168.                 if (Direction.x <= Direction.y)
  169.                 {
  170.                         Depart->x -= Depart->vitesse;
  171.                         Depart->y -= (Direction.y / Direction.x)*Depart->vitesse;//La fraction de deux nombres negatifs est positive, donc on soustrait
  172.                 }
  173.                 else
  174.                 {
  175.                         Depart->x -= (Direction.x / Direction.y)*Depart->vitesse;//La fraction de deux nombres negatifs est positive, donc on soustrait
  176.                         Depart->y -= Depart->vitesse;
  177.                 }
  178.                
  179.         }
  180.         else if ((Direction.x >= 0)&&(Direction.y < 0))// |_
  181.         {
  182.                 //On doit incrementer les x, et decrementer les y
  183.                 if (Direction.x >= abs(Direction.y))//On utilise la valeur absolue pour ne pas tenir compte du signe de y
  184.                 {
  185.                         Depart->x += Depart->vitesse;//la vitesse est positive, donc on additionne
  186.                         Depart->y += (Direction.y /Direction.x)*Depart->vitesse;//La fraction est negative, donc on additione
  187.                 }
  188.                 else
  189.                 {
  190.                         Depart->x -= (Direction.x/Direction.y)*Depart->vitesse;//La fraction est negative, donc on soustrait
  191.                         Depart->y -= Depart->vitesse;//la vitesse est positive, donc on soustrait
  192.                 }
  193.         }
  194.         else if ((Direction.x < 0)&&(Direction.y >= 0))// ?|
  195.         {
  196.                 //On doit decrementer les x, et incrementer les y
  197.                 if (abs(Direction.x) >= Direction.y)//On utilise la valeur absolue pour ne pas tenir compte du signe de x
  198.                 {
  199.                         Depart->x -= Depart->vitesse;
  200.                         Depart->y -= (Direction.y /Direction.x)*Depart->vitesse;//La fraction est negative, donc on soustrait
  201.                 }
  202.                 else
  203.                 {              
  204.                         Depart->x += (Direction.x/Direction.y)*Depart->vitesse;//La fraction est negative, donc on additionne
  205.                         Depart->y += Depart->vitesse;
  206.                 }
  207.         }
  208. }  
  209. void PrintSplash()
  210. {
  211.         printf("Loading...\n");
  212.         int i;
  213.         ge_Font* Police = geLoadFont("./space_age.ttf");
  214.         printf("Done!\n Printing...");
  215.         for (i = 272; i >= 170; i--)
  216.         {
  217.                 geClearScreen();
  218.                 geFontSize(Police, 40);
  219.                 geFontPrintScreen(30, 68, Police, "xtremLua.com", RGB(255,255,255));
  220.                 geFontSize(Police, 20);
  221.                 geFontPrintScreen(120, i, Police, "La communauté" , RGB(255,255,255));
  222.                 geFontPrintScreen(170, i + 20, Police, "amicale", RGB(255,255,255));
  223.                 geFontPrintScreen(96, i + 40, Police, "de developpement!", RGB(255,255,255));
  224.                 geSwapBuffers();//On swap les buffers
  225.         }
  226.         printf("Avant");
  227.         sceKernelDelayThread(4000);//Pause avant de lancer le jeu
  228.         printf("Apres");
  229.         geFreeFont( Police);
  230.         printf("Done!\n");
  231. }
create new paste | create new version of this paste RAW Paste Data