int main(int argc, char* argv[]) { bool running = true; int i, j, xfrog, yfrog, xfly, yfly, leech[MAX_PLAYERS], tadswim = 0, swavenum[MAX_PLAYERS], swave_clk[MAX_PLAYERS], cls, kk; float dist; int nfrogs = 7; // Number of frogs int sp = 1; // Speed (1-3) int a_i = 3; // AI (1-3) FILE *fp; // Open hiscores.txt if((fp = fopen("hiscores.txt","r")) == NULL) { printf("Can't find file: hiscores.txt\n"); return 1; } for(kk = 0; kk < 32; kk++) { hiscores[kk].name = (char*)malloc(MAX_NAME_LENGTH*sizeof(char)); hiscores[kk].time = 0; } int ret = 1; kk = 0; while(ret != EOF) { ret = fscanf(fp,"%s %d", hiscores[kk].name, &hiscores[kk].time); kk++; } // Close hiscores.txt fclose(fp); // Bubble sort for(i=0; i<31; i++) { for(j=31; j > i; j--) { if(hiscores[j].time > hiscores[j-1].time) { strcpy(buf,hiscores[j-1].name); kk = hiscores[j-1].time; strcpy(hiscores[j-1].name,hiscores[j].name); hiscores[j-1].time = hiscores[j].time; strcpy(hiscores[j].name,buf); hiscores[j].time = kk; } } } #ifdef TADPOLE_COLLISIONS int tempvel; int collisions[MAX_PLAYERS][MAX_PLAYERS]; for(i=0;i<MAX_PLAYERS;i++) { for(j=0;j<MAX_PLAYERS;j++) { collisions[i][j] = 0; } } #endif for(i=0;i<MAX_PLAYERS;i++) { leech[i] = 0; swavenum[i] = 0; swave_clk[i] = 0; leaderboard_rank[i] = -1; } int bwavenum = 0, bwave_clk, mm_clk = 0, suwavenum = 0, suwave_clk = 0; // various wave clocks and wave counters (storing latest wave to be animated) int nherd[10], nflychasers = 0; // nherd[i] counts number of close frogs to ith frog in jumpstate 0. int tadflip = 0, mmtadx = SCREEN_WIDTH/2, mmtady = SCREEN_HEIGHT/2+BANNER_HEIGHT/2; float ran; // random number storing char Tadname[MAX_NAME_LENGTH]; strcpy(Tadname,"Player_0"); // Name of local player, no spaces set_frogclips(); set_tadclips(); set_flyclips(); set_swaveclips(); set_bwaveclips(); set_suwaveclips(); Timer fps; Timer gameclock; Timer flyspan; std::vector<Timer> warpspan(nfrogs); // Setting wave flags to 'not animate / done animation' for(j=0; j<NUMWAVES; j++) { nherd[j] = 0; for(kk=0; kk<MAX_PLAYERS; kk++) { smallwaves[kk][j][0] = 6; } } for(j=0; j<NUMWAVES; j++) { bigwaves[j][0] = 24; suwaves[j][0] = 24; } if (init() == false) return 1; if (load_files() == false) return 1; // Spawn Tadpole // Tadpole myTad; std::vector<Tadpole> myTad(MAX_PLAYERS); // Spawn fly xfly = 10+drand48()*(SCREEN_WIDTH-LEADER_WIDTH-HISCORE_WIDTH-20)+LEADER_WIDTH; yfly = 10+drand48()*(SCREEN_HEIGHT-BANNER_HEIGHT-20) + BANNER_HEIGHT; Fly myfly( xfly, yfly ); // Spawn Frogs std::vector<Frog> myfrogs(nfrogs); for(i = 0; i < nfrogs; i++ ) { xfrog = drand48()*(SCREEN_WIDTH-LEADER_WIDTH-HISCORE_WIDTH-20)+LEADER_WIDTH; yfrog = drand48()*(SCREEN_HEIGHT-BANNER_HEIGHT-20) + BANNER_HEIGHT; if(distance(xfrog, yfrog, mmtadx, mmtady) < (SCREEN_HEIGHT-BANNER_HEIGHT)/4) { i--; } myfrogs[i].Frog_set(xfrog, yfrog, sp, a_i); } for(i=0; i<nfrogs; i++) myfrogs[i].show(sp); myfly.show(); if(SDL_Flip(screen) == -1) return 1; SDL_Delay(500); gameclock.start(); #ifdef PRINT_MESSAGES printf("Tadpole server is up!\n"); #endif #ifdef WITH_SOUND // if(Mix_PlayMusic(ambience, -1) == -1) if(Mix_FadeInMusic(ambience, -1, 2000) == -1) return 1; #endif // Game Server loop while (running) { fps.start(); // Listen for connections, argument 0 means no wait-time int numActiveSockets = SDLNet_CheckSockets(socketSet, 0); if(numActiveSockets > 0) { // Check help socket. If activity detected, then open temporary socket and dump help text. Then close socket. int helpSocketActivity = SDLNet_SocketReady(helpSocket); if(helpSocketActivity != 0) { TCPsocket tempSock = SDLNet_TCP_Accept(helpSocket); SDLNet_TCP_Send(tempSock,(void*)reply,strlen(reply)+1); // Close temporary connection SDLNet_TCP_Close(tempSock); } // Check if our server socket has received any data // Note: SocketReady can only be called on a socket which is part of a set and that has CheckSockets called on it (the set, that is) // SDLNet_SocketRead returns non-zero for activity, and zero is returned for no activity. int serverSocketActivity = SDLNet_SocketReady(serverSocket); // All server activity interpreted as request for TCP connection if(serverSocketActivity != 0) { // If we have room for more clients... if(ntads < MAX_PLAYERS) { int freeSpot = -99; for(int i = 0; i < MAX_PLAYERS; i++) { if(!myTad[i].alive && !myTad[i].TCP_limbo) { freeSpot = i; break; } } // Accept the client connection myTad[freeSpot].socket = SDLNet_TCP_Accept(serverSocket); // get clients IP remoteip = SDLNet_TCP_GetPeerAddress(myTad[freeSpot].socket); if(!remoteip) { #ifdef SERVER_DEBUG printf("SDLNet_TCP_GetPeerAddress: %s\n",SDLNet_GetError()); #endif // No remote ip?! NO CONNECTION! SDLNet_TCP_Close(myTad[freeSpot].socket); } else { #ifdef SERVER_DEBUG ipaddr=SDL_SwapBE32(remoteip->host); printf("Accepted a connection from %d.%d.%d.%d port %hu.", ipaddr>>24, (ipaddr>>16)&0xff, (ipaddr>>8)&0xff, ipaddr&0xff, remoteip->port); printf(" There are now %d client(s) online.\n", ntads+1); #endif ntads++; myTad[freeSpot].TCP_limbo = true; // Add new client socket to socket set, to check activity SDLNet_TCP_AddSocket(socketSet, myTad[freeSpot].socket); // Send 'N' asking for name strcpy(buf,"N"); SDLNet_TCP_Send(myTad[freeSpot].socket,(void*)buf,2); } } else { // No new room for clients #ifdef SERVER_DEBUG printf("No room. Rejecting client.\n"); #endif // Accept client connection to clear it from incoming list TCPsocket tempSock = SDLNet_TCP_Accept(serverSocket); // Send 'X' telling that there is no room strcpy(buf,"X"); SDLNet_TCP_Send(tempSock,(void*)buf,2); // Close temporary connection SDLNet_TCP_Close(tempSock); } }
int main(int argc, char *argv[]) { putenv("SDL_VIDEODRIVER=dga"); if (SDL_Init(SDL_INIT_VIDEO) == -1) { fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } SDL_ClearError(); printf("SDL initialized\n"); atexit(end_SDL); /* Creat a SDL window, and get the window's surface. */ /* PS: use hardware--> SDL_HWSURFACE */ SDL_Surface *screen = NULL; screen = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE); if (screen == NULL) { fprintf(stderr, "SDL_SetVideoMode() failed: %\n", SDL_GetError()); exit(EXIT_FAILURE); } /* Show the SDL window's surface */ if (SDL_Flip(screen) == -1) { fprintf(stderr, "SDL_Flip() failed: %\n", SDL_GetError()); exit(EXIT_FAILURE); } char name[30]; if (SDL_VideoDriverName(name, 30) == NULL) { fprintf(stderr, "SDL_VideoDriverName() failed: %s", SDL_GetError()); exit(EXIT_FAILURE); } printf("name = %s\n", name); const SDL_VideoInfo *info = SDL_GetVideoInfo(); printf("Is it possible to create hardware surfaces: %d\n", info->hw_available); printf("Is there a window manager available: %d\n", info->wm_available); printf("Are hardware to hardware blits accelerated: %d\n", info->blit_hw); printf("Are hardware to hardware colorkey blits accelerated: %d\n", info->blit_hw_CC); printf("Are hardware to hardware alpha blits accelerated: %d\n", info->blit_hw_A); printf("Are software to hardware blits accelerated: %d\n", info->blit_sw); printf("Are software to hardware colorkey blits accelerated: %d\n", info->blit_sw_CC); printf("Are software to hardware alpha blits accelerated: %d\n", info->blit_sw_A); printf("Are color fills accelerated: %d\n", info->blit_fill); printf("Total amount of video memory in Kilobytes: %d\n", info->video_mem); printf("Width of the current video mode: %d\n", info->current_w); printf("Height of the current video mode: %d\n", info->current_h); press_ESC_to_quit(); return 0; }
int main(int argc, char *argv[]) { Uint32 initflags = SDL_INIT_VIDEO; SDL_Surface *ecran; Dimensions fenetre; // main window fenetre.h = WINHI; // en pixels fenetre.w = WINWI; Uint8 video_bpp = 32; // 32 bits de couleur Uint32 videoflags = SDL_HWSURFACE; // utiliser la mémoire vidéo bool continuer; // pour la boucle principale des évènements SDL_Event event; // aussi /* Initialize the SDL library */ if ( SDL_Init(initflags) < 0 ) { fprintf(stderr, "N'arrive pas a` initialiser la SDL : %s\n", SDL_GetError()); exit(1); } /* Set video mode */ ecran = SDL_SetVideoMode(fenetre.w, fenetre.h, video_bpp, videoflags); // surface principale if (ecran == NULL) { fprintf(stderr, "N'arrive pas a` etablir mode video%dx%dx%d : %s\n", fenetre.w, fenetre.h, video_bpp, SDL_GetError()); SDL_Quit(); exit(2); } SDL_WM_SetCaption("Hexcaliba", NULL); // legende de la fenêtre TTF_Init(); extern_init(); SDL_Rect posPionTemp; SDLKey key_pressed ; int coup_valide =0 ,menu=1,j,nb_tour=0, i=0,afficher_rolldice=0,afficher_resultat=0,de1,de2,afficher_valider=0,retour_bouton=0; int qui_commence = 0,contre_IA=0; continuer = true; // un furieux du c ferait plutôt une boucle infinie. Je préfère rester correct. int now=105, before=100, interval=50,k; default_menu1(ecran); while (continuer) { now = SDL_GetTicks(); while ( SDL_PollEvent(&event)) { switch (event.type) { case SDL_MOUSEMOTION: if(menu==1) hover_menu1(ecran,event); else if(menu==2) hover_choix_adversaire(ecran,event); else if(menu==3) hover_choix_difficulte(ecran,event); else if(menu==4) { if(!afficher_rolldice) hover_roll_dice(ecran,event); if((afficher_resultat)&&(afficher_rolldice)&&(!afficher_valider)) hover_valider(ecran,event); if((afficher_resultat)&&(afficher_rolldice)&&(afficher_valider)) hover_jouer(ecran,event); } else if( menu == 5) { hover_historique(ecran, event); } else if (menu == 6) hover_charger(ecran,event); else if (menu ==7) hover_quitter(ecran,event); else if (menu == 8) hover_winner(ecran,event); break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == SDL_BUTTON_LEFT) { int clicX = event.motion.x; int clicY = event.motion.y; if (menu==1) button_menu1(&menu,&continuer,clicX,clicY); else if (menu==2) button_choix_adversaire(&menu,&continuer,clicX,clicY,&i,&afficher_resultat,&afficher_rolldice,&afficher_valider,&retour_bouton,&contre_IA,&qui_commence); else if (menu==3) button_choix_difficulte(&menu,clicX,clicY,&contre_IA); else if (menu==4) { if(!afficher_rolldice) { button_roll_dice(clicX,clicY,&de1,&de2,&afficher_rolldice); if(de1==de2) { afficher_rolldice=0; afficher_resultat=0; }else if (de1<de2) qui_commence++; } if((afficher_rolldice)&&(afficher_resultat)) button_valider(&afficher_valider,clicX,clicY); if((afficher_rolldice)&&(afficher_resultat)&&(afficher_valider)) button_jouer(&menu,&continuer,clicX,clicY,&i, &nb_tour, &retour_bouton,qui_commence,contre_IA); } else if (menu == 5 ) { button_historique(&menu, clicX, clicY); }else if (menu == 6) button_charger(&menu,clicX,clicY,&i,&afficher_rolldice,&afficher_resultat,&afficher_valider); else if (menu == 7 && retour_bouton) button_quitter_2(&menu,clicX,clicY,i); else if (menu == 7 && !retour_bouton) button_quitter(&menu,&continuer,clicX,clicY,i); else if (menu == 8) button_winner(&menu, clicX,clicY,i); } break; case SDL_KEYDOWN: key_pressed = event.key.keysym.sym; // on récupère la touche switch (key_pressed) { case SDLK_ESCAPE: /* Esc keypress quits the app... */ if (menu == 4) menu = 7; else continuer=0; break; } break; case SDL_QUIT: if (menu == 4) menu = 7; else continuer=0; break; default: if(menu==1) default_menu1(ecran); else if(menu==2) default_choix_adversaire(ecran); else if(menu==3) default_choix_difficulte(ecran); else if(menu==4) { if(!afficher_rolldice) default_roll_dice(ecran); if((!afficher_resultat)&&(afficher_rolldice)) { default_roll_resultat(ecran,de1,de2); afficher_resultat++; } if((afficher_resultat)&&(afficher_rolldice)&&(!afficher_valider)) default_valider(ecran,de1,de2); if((afficher_resultat)&&(afficher_rolldice)&&(afficher_valider)) default_jouer(ecran,i, qui_commence, &menu); } else if(menu == 5) { default_historique(ecran,i); } else if (menu == 6) default_charger(ecran); else if (menu == 7) default_quitter(ecran); else if (menu == 8) default_winner(ecran,qui_commence,i); break; } } if (now-before<interval) SDL_Delay(interval-(now-before)); // refresh screen // mettre ici tous les blit utiles s'il y a des changements dans les surfaces, board, nouveaux pions SDL_Flip(ecran); //maj des surfaces pour affichage before=now; } /* Clean up the SDL library */ SDL_FreeSurface(pionBleu); SDL_FreeSurface(pionRouge); SDL_FreeSurface(ecran); SDL_FreeSurface(board); SDL_FreeSurface(background); SDL_FreeSurface(bienvenue); SDL_FreeSurface(texte_Charger); SDL_FreeSurface(texte_Jouer); SDL_FreeSurface(texte_Quitter); SDL_FreeSurface(ia); SDL_FreeSurface(ia1); SDL_FreeSurface(retour); SDL_FreeSurface(ia2); SDL_FreeSurface(human); SDL_FreeSurface(difficulte); SDL_FreeSurface(adversaire); SDL_FreeSurface(background2); SDL_FreeSurface(historique); SDL_FreeSurface(sauvegarder); SDL_FreeSurface(undo); SDL_FreeSurface(valider); SDL_FreeSurface(stringHist); SDL_FreeSurface(names); TTF_CloseFont(fontMenu); TTF_CloseFont(fontSousMenu); TTF_CloseFont(fontSousMenu2); TTF_Quit(); SDL_Quit(); fclose(f_in); return(0); }
void GlobalEvent::on_button_press(const SDL_KeyboardEvent& event) { switch (event.keysym.sym) { case SDLK_F10: config_manager.set_print_fps(!config_manager.get_print_fps()); break; case SDLK_RETURN: if (event.keysym.mod & KMOD_ALT) { config_manager.set_fullscreen(!config_manager.get_fullscreen()); } break; case SDLK_TAB: // unlock mouse grab if Alt-Tab is pressed to allow the user to change windows if (config_manager.get_mouse_grab()) { if (event.keysym.mod & KMOD_ALT) { // FIXME: should suspend the grab till the user clicks the // window again, not completely disable it config_manager.set_mouse_grab(false); } } break; case SDLK_F11: config_manager.set_fullscreen(!config_manager.get_fullscreen()); break; case SDLK_F5: if (!dynamic_cast<OptionMenu*>(ScreenManager::instance()->get_current_screen().get())) ScreenManager::instance()->push_screen(std::make_shared<OptionMenu>()); break; case SDLK_o: if (event.keysym.mod & KMOD_CTRL) { if (!dynamic_cast<OptionMenu*>(ScreenManager::instance()->get_current_screen().get())) ScreenManager::instance()->push_screen(std::make_shared<OptionMenu>()); } break; case SDLK_F6: if (globals::developer_mode) { if (!dynamic_cast<AddOnMenu*>(ScreenManager::instance()->get_current_screen().get())) ScreenManager::instance()->push_screen(std::make_shared<AddOnMenu>()); } break; case SDLK_F12: { Screenshot::make_screenshot(); } break; case SDLK_c: if (globals::developer_mode) globals::draw_collision_map = !globals::draw_collision_map; break; case SDLK_k: if (globals::developer_mode) { #ifdef OLD_SDL1 log_info("Low level screen clear triggered"); SDL_Surface* screen = SDL_GetVideoSurface(); SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 0)); SDL_Flip(screen); #endif } break; case SDLK_m: if (event.keysym.mod & KMOD_CTRL) { log_info("Developer Mode: %1%", globals::developer_mode); globals::developer_mode = !globals::developer_mode; } break; case SDLK_g: if (event.keysym.mod & KMOD_CTRL) { config_manager.set_mouse_grab(!config_manager.get_mouse_grab()); } break; case SDLK_KP_PLUS: globals::game_speed -= 5; if (globals::game_speed < 5) globals::game_speed = 5; break; case SDLK_KP_MINUS: globals::game_speed += 5; break; case SDLK_KP_ENTER: globals::game_speed = 20; break; default: // console << "GlobalEvent: Unknown key pressed: " << key.id; break; } }
int main( int argc, char* args[] ) { quit = 0; Tile *tiles[ TOTAL_TILES ]; Timer fps; levelwon = 0; //Initialize if( init() == false ) { return 1; } if( TTF_Init() == -1 ) { return false; } //Initialize SDL_mixer if( Mix_OpenAudio( 22050, MIX_DEFAULT_FORMAT, 2, 4096 ) == -1 ) { return false; } //Load the files if( load_files() == false ) { return 1; } //Clip the tile sheeti if( Mix_PlayMusic( music, -1 ) == -1 ) { return 1; } clip_tiles(); if(!welcome)return 1; SDL_BlitSurface(welcome, NULL, screen, NULL ); SDL_Flip( screen ); SDL_Delay(6000); robin robinp; while(quit ==false) { if(level!= 1) { SDL_BlitSurface( prepare, NULL, screen, NULL ); SDL_Flip(screen); SDL_Delay(3000); } robinp.reset(); //Set the tiles if( set_tiles( tiles ) == false ) { return 1; } // SDL_Delay(3000); first=1; ///////////////////////////////////////////////////////////////////////////////////// while( quit == false && levelwon == 0)/////////////////////////////////// { //Start the frame timer fps.start(); //While there's events to handle while( SDL_PollEvent( &event ) ) { robinp.handle_events(); //If the user has Xed out the window if( event.type == SDL_QUIT ) { //Quit the program quit = true; } } SDL_BlitSurface( background, NULL, screen, NULL ); robinp.move(tiles); robinp.set_camera(); for( int t = 0; t < TOTAL_TILES; t++ ) { tiles[ t ]->show(); } for(int i=0;i< en_num;i++) { enemys[en_num]->show(); //robinp.reset(); } robinp.show(); showscore(); //Update the screen if( SDL_Flip( screen ) == -1 ) { return 1; } //Cap the frame rate if( fps.get_ticks() < 1000 / FRAMES_PER_SECOND ) { SDL_Delay( ( 1000 / FRAMES_PER_SECOND ) - fps.get_ticks() ); } } clean_up(tiles); level++; levelwon = 0; ///////////////////////////////////////////////////////////////////////////////////// //cout<<"out of level"; } SDL_FreeSurface( background ); SDL_FreeSurface( gameover ); SDL_FreeSurface( tileSheet ); //Free the music Mix_FreeMusic( music ); Mix_FreeChunk( jumpsou ); Mix_FreeChunk( coinsou ); Mix_FreeChunk( hitsou ); Mix_FreeChunk( diamoundsou ); //Close the font TTF_CloseFont( font ); //Quit SDL_mixer Mix_CloseAudio(); SDL_Quit(); //Quit SDL_ttf TTF_Quit(); return 0; }
int main( int argc, char* args[] ) { // this is the last time (SDL_Getticks()) that beasts were evaluated int beastLastEval=0; // this is how many times per second the beasts should be evaluated int beastEvalsPerSec = 30; paused = 0; //get a random seed. sgenrand(time(NULL)); //mouse variables and cell types int x, y, sleepTime = 0, countVar = 0; //mouse is held variables int mouseStatusLeft = 0, mouseStatusRight = 0; // these keep track of the position of the right mouse button when it was clicked down int mouseRDx; int mouseRDy; //make sure the program waits for a quit int quit = false; init_mats(); init_graphics(); init_controls(); //Initialize if( init() == false ) return 1; //Load the files if( load_files() == false ) return 2; //Update the screen if( SDL_Flip( screen ) == -1 ) return 3; gen_world(); // these keep track of the WASD keys. int keyw=0, keya=0, keys=0, keyd=0; int key; // used as a stand-int for the verbose event.key.keysym.sym bool keyF3=true; //these are used to calculating and keeping track of the FPS int ticksSinceLastFPSUpdate = 0; int cumulativeFrames = 0; int currentTicks = 0; SDL_Rect screenRect; screenRect.x = screenRect.y = 0; screenRect.w = SCREEN_WIDTH; screenRect.h = SCREEN_HEIGHT; //While the user hasn't quit while(1){ //While there's an event to handle while( SDL_PollEvent( &event ) ){ //If the user has Xed out the window if( event.type == SDL_QUIT || quit == true ){ //Quit the program clean_up(); return 0; } if( event.type == SDL_MOUSEBUTTONDOWN ){ /// mouse down x = event.motion.x; y = event.motion.y; if( event.button.button == SDL_BUTTON_LEFT ){ mouseStatusLeft = 1; } else if( event.button.button == SDL_BUTTON_RIGHT ){ mouseStatusRight = 1; mouseRDx = x; mouseRDy = y; } else if( event.button.button == SDL_BUTTON_WHEELUP ) ;//zoom_in(x,y); else if( event.button.button == SDL_BUTTON_WHEELDOWN ) ;//zoom_out(x,y); } else if(event.type == SDL_MOUSEBUTTONUP){ /// mouse up x = event.motion.x; y = event.motion.y; if( event.button.button == SDL_BUTTON_LEFT ){ mouseStatusLeft = 0; } else if( event.button.button == SDL_BUTTON_RIGHT ){ mouseStatusRight = 0; } } else if( event.type == SDL_MOUSEMOTION ){ /// mouse motion x = event.motion.x; y = event.motion.y; /* // if the alt key (camera panning key) is down and the coordinates have changed, then let the screen be panned! if(alt && x != mouse_x_when_pan && y != mouse_y_when_pan){ // this adjusts the x-axis camera (this scales with the CELL_SIZE) camera_x += (x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE; camera_y += (y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE; //calculate the remainders of the mouse motion. // these values represent the motion of the mouse that is not utilized by the discrete nature of the operation on the camera_x and camera_y values. remainder_panning_motion_x = (x-mouse_x_when_pan+remainder_panning_motion_x) - (int)((x-mouse_x_when_pan+remainder_panning_motion_x)/CELL_SIZE)*CELL_SIZE; remainder_panning_motion_y = (y-mouse_y_when_pan+remainder_panning_motion_y) - (int)((y-mouse_y_when_pan+remainder_panning_motion_y)/CELL_SIZE)*CELL_SIZE; // make sure the camera is not out of bounds. verify_camera(); //reset the user's curcor position to the original position the curcor was in when the user started panning the camera SDL_WarpMouse(mouse_x_when_pan, mouse_y_when_pan); } */ } else if(event.type == SDL_VIDEORESIZE){ /// window resize // don't resize the grid. //float new_cell_size = CELL_SIZE * event.resize.h/((float)SCREEN_HEIGHT); // adjust the pixel size. //if(new_cell_size - ((int)new_cell_size) >= 0.5f) CELL_SIZE = new_cell_size + 1; //else CELL_SIZE = new_cell_size; screenRect.w = SCREEN_WIDTH = event.resize.w; screenRect.h = SCREEN_HEIGHT = event.resize.h; set_window_size(event.resize.w, event.resize.h); // set window to correct dimensions } if( event.type == SDL_KEYDOWN ){ ///keyboard event key = event.key.keysym.sym; if (key == controlsGame.pan[d_up]) camera_pan(d_up); // pan up else if(key == controlsGame.pan[d_down]) camera_pan(d_down); // pan down else if(key == controlsGame.pan[d_left]) camera_pan(d_left); // pan left else if(key == controlsGame.pan[d_right]) camera_pan(d_right); // pan right else if(key == controlsGame.debug) keyF3 ^= 1; // toggle the keyF3 state } if( event.type == SDL_KEYUP ){ ///keyboard event // nothing here yet } } // end while(event) //no more events to handle at the moment. if(mouseStatusLeft==true && beast_find_at_cell(x/CELL_SIZE+cameraX,y/CELL_SIZE+cameraY) == NULL){ // add beast function struct beastData *myBeast; myBeast = beast_create(NULL); if(myBeast != NULL ){ myBeast->x = x/CELL_SIZE + cameraX; myBeast->y = y/CELL_SIZE + cameraY; } } if(SDL_GetTicks()-beastLastEval > 1000/beastEvalsPerSec){ // evaluate all beasts beasts_evaluate(); beastLastEval = SDL_GetTicks(); } // print the grid data print_grid(screen); print_beasts(screen); print_beasts_targets(screen); // print debugging information if(keyF3) print_debugging_information(screen); //updates the screen SDL_Flip( screen ); SDL_FillRect(screen, &screenRect, 0); //---------------------------------------------------- // FPS calculation and variable handling //---------------------------------------------------- currentTicks = SDL_GetTicks(); // it is officially the next second if(currentTicks >= ticksSinceLastFPSUpdate + 1000){ // calculate the FPS FPS = cumulativeFrames;//(cumulativeFrames*1000 ) / (currentTicks-ticksSinceLastFPSUpdate); cumulativeFrames=0; // reset cumulative amount of frames ticksSinceLastFPSUpdate = currentTicks; // reset the last FPS update to the number of ticks now. } cumulativeFrames++; }// end while(quit == false) //Free the surface and quit SDL clean_up(); return 0; }
void vultures_refresh(void) { SDL_Flip( vultures_screen ); }
void DrawScreen(SDL_Surface* screen, Audio *audio, int xx) { if(SDL_MUSTLOCK(screen)) { if(SDL_LockSurface(screen) < 0) return; } int ii, xs, ys; Real value; int red, green, blue; for (ii=0; ii<(HEIGHT/Y_STRETCH); ii++) { value = frequency_component( audio, frequency( FREQ_BASE + (((double)(ii*Y_STRETCH)) * FREQ_MULT) ) ); #ifdef FORMAT_AMP value = value * (Real)ii; #endif ((Real *)fourier->data)[ii] = value; } #ifdef NORMALIZE_FOURIER normalize( fourier ); audio_scale( fourier, 20000.0 ); #endif for (ii=0; ii<(HEIGHT/Y_STRETCH); ii++) { value = ((Real *)fourier->data)[ii]; #ifdef SQUARE_SUPPRESS value *= 0.001; value *= value; #endif value *= 0.001; #ifndef SQUARE_SUPPRESS if (value < 0) value = -value; #endif /* #ifdef FORMANT_AMP value *= (Real)ii; #endif */ // If capturing, sum the frequencies if (capturing) { ((Real *)captured->data)[ii] += value; captured_slices++; } red = (int)value; green = 0; blue = 0; if (red > 16000) { red = 0; green = 255; blue = 0; } else if (red > 255) { green = (int)((value-255.0)/20.0); if (blue > 512) { blue = (int)((value-512.0)/100.0); } red = 255; } // x stretch for (xs=0; xs<X_STRETCH; xs++) { for (ys=0; ys<Y_STRETCH; ys++) { setpixel(screen, xx+xs, (HEIGHT-1)-(ii*Y_STRETCH)-ys, red, green, blue); } } if (xx+X_STRETCH < WIDTH-X_STRETCH) { for (ys=Y_STRETCH; ys<HEIGHT; ys++) { if (windowing) { setpixel(screen, xx+X_STRETCH, ys, 0, 0, 255); } else { setpixel(screen, xx+X_STRETCH, ys, 0, 255, 0); } } } } if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen); SDL_Flip(screen); }
SDL_Surface *Movement(SDL_Surface *screen) { // Movement // D -- Mario move LEFT // A -- Mario move RIGHT SDL_Surface *background = NULL; SDL_Surface *mario0 = NULL; //SDL_Surface *mario1 = NULL; //SDL_Surface *mario2 = NULL; SDL_Surface *mario3 = NULL; //SDL_Surface *mario4 = NULL; //SDL_Surface *mario5 = NULL; int x,y; x = 125; y = 520; // Image filenames const char *background_image = "bin/stage.bmp"; const char *mario_image0 = "bin/IMG0.bmp"; //const char *mario_image1 = "bin/IMG1.bmp"; //const char *mario_image2 = "bin/IMG2.bmp"; const char *mario_image3 = "bin/IMG3.bmp"; //const char *mario_image4 = "bin/IMG4.bmp"; //const char *mario_image5 = "bin/IMG5.bmp"; background = scrnfunk::load_image(background_image); mario0 = scrnfunk::load_image(mario_image0); //mario1 = scrnfunk::load_image(mario_image1); //mario2 = scrnfunk::load_image(mario_image2); mario3 = scrnfunk::load_image(mario_image3); //mario4 = scrnfunk::load_image(mario_image4); //mario5 = scrnfunk::load_image(mario_image5); SDL_Rect clip; clip.x = x; clip.y = y; clip.w = 100; clip.h = 100; scrnfunk::RemoveColor(mario0, 0x00, 0x00, 0xFF); // Blue //scrnfunk::RemoveColor(mario1, 0x00, 0x00, 0xFF); // Blue //scrnfunk::RemoveColor(mario2, 0x00, 0x00, 0xFF); // Blue scrnfunk::RemoveColor(mario3, 0x00, 0x00, 0xFF); // Blue scrnfunk::apply_image(x, y, mario0, screen); if(screen != 0) SDL_Flip(screen); SDL_Event event; while(1) { while(SDL_PollEvent(&event)) { if(event.type == SDL_QUIT) return NULL; else if(event.type == SDL_KEYDOWN) { if(event.key.keysym.sym == SDLK_d) // RIGHT { scrnfunk::apply_image(x, y, background, screen, &clip); // Cover current Mario x=x+10; clip.x = x; scrnfunk::apply_image(x, y, mario3, screen); // Place new Mario } else if(event.key.keysym.sym == SDLK_a) // LEFT { scrnfunk::apply_image(x, y, background, screen, &clip); // Cover current Mario x=x-10; clip.x = x; scrnfunk::apply_image(x, y, mario3, screen); // Place new Mario } } } if(screen != 0) SDL_Flip(screen); else fprintf(stderr, "Couldn't update screen.\n"); } return screen; }
//Fonction principale du jeu du Pendu, elle gérera l'affichage des différentes étapes d'une partie int jouer_Pendu(SDL_Surface *ecran, char j1[], char j2[]) { //Déclaration des variables locales nécassaires pour la fonction SDL_Surface *s_mot_cache = NULL, *s_mot_decouvert = NULL, *resultat = NULL, *joueur = NULL; SDL_Rect position_mot_decouvert={200,500,0,0}, positionresultat = {50,400,0,0}, positionjoueur = {0,350,0,0}; SDL_Event event; TTF_Font *police = NULL, *police2 = NULL; SDL_Color couleurNoire = {0, 0, 0, 0}; int j=0, i, continuer=1, coups_reussis=0, coups_rates=1, joueuractuel = 1, joueur1, joueur2; char c, ch[30], mot_cache[30], mot_decouvert[30]; Mix_Chunk *son1, *son2; son1 = Mix_LoadWAV("../Music/Mini-jeux/coup_reussi_pendu.ogg"); son2 = Mix_LoadWAV("../Music/Mini-jeux/coup_rate_pendu.ogg"); srand(time(NULL)); //Chargement de la police police = TTF_OpenFont("../Police/comicbd.ttf", 30); police2 = TTF_OpenFont("../Police/comicbd.ttf", 40); SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255)); joueur1 = joueur2 = 0; //Point de départ d'un tour (On retourne à cette ligne pour alterner les tours entre les joueurs) debut: /*Initialisation des variables utilisées durant une partie*/ c = '0'; //Génération d'un nombre au hasard entre 1 et 100, ce nombre sera l'indice du mot caché qui sera chargé du fichier mots.txt avec la fonction chargement_Mot i = rand()%100+1; chargement_Mot(mot_cache,i); //Initialisation de la chaine qui va contenir le mot saisi par un joueur initialiser(mot_cache,mot_decouvert); s_mot_decouvert = TTF_RenderText_Blended(police, mot_decouvert, couleurNoire); j++; continuer = 1; //Alternance du tour if(joueuractuel == 1) sprintf(ch,"Joueur : %s",j1); else sprintf(ch,"Joueur : %s",j2); joueur = TTF_RenderText_Blended(police2, ch, couleurNoire); //Boucle while qui gérera l'affichage des différentes étapes du jeu while(continuer) { SDL_WaitEvent(&event); switch(event.type) { //En cas de fermeture de la fenêtre case SDL_QUIT: continuer = 0; return 0; break; //En cas d'appuie sur un bouton, stocker le caractère dans la variable c case SDL_KEYDOWN : switch(event.key.keysym.sym) { default : c = event.key.keysym.sym; break; } //Si c'est une lettre en majuscule, la convertir en minuscule if(c >= 'A' && c <= 'Z') c -= 32; //Si c'est une lettre, faire les tests nécessaires pour voir si le mot caché contient la lettre saisie if(c >= 'a' && c <= 'z') { //Si la lettre saisie existe dans le mot caché, l'afficher dans sa/ses position(s) dans le mot découvert (le mot qui contient n tirets | n c'est la longueur du mot caché) if (existe(mot_cache,c) > existe(mot_decouvert,c)) { coups_reussis++; Mix_PlayChannel(1,son1,0); for (i = 0; mot_cache[i] != '\0'; i++) { if (mot_cache[i] == c) mot_decouvert[i] = c; } s_mot_decouvert = TTF_RenderText_Blended(police, mot_decouvert, couleurNoire); } /*Si la lettre n'existe pas dans mot_cache, on incrémente les coups ratés de 1, puis on appelle la fonction bonhomme avec le nombre coups_rates qui s'occupera d'afficher l'image correspondante du pendu*/ else if(existe(mot_cache,c) == existe(mot_decouvert,c)){ Mix_PlayChannel(1,son2,0); coups_rates++; } } break; default : break; } SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255)); bonhomme(ecran,coups_rates); SDL_BlitSurface(s_mot_decouvert,NULL, ecran, &position_mot_decouvert); //Si le joueur atteint le nombre max de coups ratés, on affiche le mot caché et on garde le nombre de coups ratés afin de le comparer avec celui de l'autre joueur. if(coups_rates == 10) { if(joueuractuel == 1) {joueuractuel = 2; joueur1 = coups_rates;} else {joueuractuel = 1; joueur2 = coups_rates;} continuer = 0; coups_rates = 1; sprintf(ch,"Le mot etait '%s'",mot_cache); resultat = TTF_RenderText_Blended(police2, ch, couleurNoire); SDL_BlitSurface(resultat,NULL, ecran, &positionresultat); } //Si le joueur trouve le mot caché, on affiche le texte correspondant et on garde le nombre de coups ratés afin de le comparer avec celui de l'autre joueur. else if(!strcmp(mot_cache,mot_decouvert)) { if(joueuractuel == 1) {joueuractuel = 2; joueur1 = coups_rates;} else {joueuractuel = 1; joueur2 = coups_rates;} sprintf(ch,"Bravoo !"); resultat = TTF_RenderText_Blended(police2, ch, couleurNoire); SDL_BlitSurface(resultat,NULL, ecran, &positionresultat); continuer = 0; coups_rates = 1; } SDL_BlitSurface(joueur,NULL, ecran, &positionjoueur); SDL_Flip(ecran); } sleep(2); //Si les 2 joueurs ont le même score ou si c'est le tour du 2ème joueur, relancer le jeu avec un mot différent. if(joueur1 == joueur2 || j&1) goto debut; SDL_FreeSurface(s_mot_decouvert); SDL_FreeSurface(s_mot_cache); SDL_FreeSurface(resultat); Mix_FreeChunk(son1);//Libération du son Mix_FreeChunk(son2);//Libération du son //Renvoie de l'indice du gagnant if(joueur1 > joueur2) return 2; else return 1; }
void Graphics::flip(){ SDL_Flip(screen_); }
/*Cette fonction sert de page d'accueil du jeu du Pendu, elle fait appel à la fonction jouer_Pendu quand l'utilisateur appuie sur "Entrer", et à la fin elle récupère l'indice du gagnant et le renvoie à son tour*/ int Accueil_Pendu(SDL_Surface *ecran, char *j1, char *j2) { //Déclaration des variables locales nécessaires pour la fonction. SDL_Surface *texte1 = NULL, *texte2 = NULL, *pendu = NULL; SDL_Rect positiontexte1, positiontexte2, positionpendu; SDL_Event event; TTF_Font *police1 = NULL, *police2 = NULL; SDL_Color couleurNoire = {0, 0, 0, 0}, couleurBlanche = {255, 255, 255, 0}; int continuer = 1, gagnant; Mix_Music *musique; //Création d'un pointeur de type Mix_Music Mix_VolumeMusic(MIX_MAX_VOLUME); musique = Mix_LoadMUS("../Music/Mini-jeux/pendu.ogg"); //Chargement de la musique Mix_PlayMusic(musique, -1); //Jouer infiniment la musique //Chargement de l'image du pendu pendu = IMG_Load("../images/Mini-jeux/Pendu10.png"); //Chargement de la police police1 = TTF_OpenFont("../Police/chata.ttf", 65); police2 = TTF_OpenFont("../Police/chata.ttf", 25); //Initialisation du texte texte1 = TTF_RenderText_Shaded(police1, "Le Pendu", couleurNoire, couleurBlanche); texte2 = TTF_RenderText_Shaded(police2, "Appuyer sur entrer pour commencer", couleurNoire, couleurBlanche); SDL_SetColorKey(texte1, SDL_SRCCOLORKEY, SDL_MapRGB(texte1->format, 255, 255, 255)); SDL_SetColorKey(texte2, SDL_SRCCOLORKEY, SDL_MapRGB(texte2->format, 255, 255, 255)); //Remplissage de l'écran principal avec la couleur blanche SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 200, 100)); //Initialisation des positions des différentes surfaces et textes positiontexte1.x = (ecran->w - texte1->w) / 2; positiontexte1.y = 0; positiontexte2.x = (ecran->w - texte2->w) / 2; positiontexte2.y = 250 + (ecran->h - texte2->h) / 2; positionpendu.x = (ecran->w / 2) - (pendu->w / 2); positionpendu.y = (ecran->h / 2) - (pendu->h / 2); //Remplissage de l'écran principal avec la couleur blanche SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 200, 100)); //Blit du texte de la page d'accueil SDL_BlitSurface(texte1, NULL, ecran, &positiontexte1); SDL_BlitSurface(texte2, NULL, ecran, &positiontexte2); //Blit de l'image du pendu SDL_BlitSurface(pendu, NULL, ecran, &positionpendu); //Mise à jour de l'écran SDL_Flip(ecran); /*Une boucle infine afin de maintenir l'affichage et quitter le programme quand l'utilisateur ferme la fenêtre*/ while (continuer) { SDL_PollEvent(&event); switch(event.type) { case SDL_QUIT: continuer = 0; break; //En cas d'apuui sur un bouton case SDL_KEYDOWN : //S'il s'agit du bouton "Entrer", appeler la fonction joueur_Pendu if(event.key.keysym.sym == SDLK_RETURN) gagnant = jouer_Pendu(ecran,j1,j2); continuer = 0; break; default: break; } } //Libération de la mémoire occupée par les surfaces et les polices et arrêt de la SDL TTF_CloseFont(police1); TTF_CloseFont(police2); SDL_FreeSurface(pendu); SDL_FreeSurface(texte1); SDL_FreeSurface(texte2); Mix_FreeMusic(musique); //Libération de la musique return gagnant; }
int main(int argc, char **argv) { if (argc < 2) { fprintf(stderr, "Usage: %s <bbbout-file>\n", argv[0]); return 1; } int err; bbbout_stream *bbbout = bbbout_open_read(argv[1], &err); if (err != BBBOUT_SUCCESS) { fprintf(stderr, "%s: while reading '%s': %s", argv[0], argv[1], bbbout_strerror(err)); return 1; } const int width = bbbout->width, height = bbbout->height; if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0) { fprintf(stderr, "Error initializing SDL: %s\n", SDL_GetError()); return 1; } screen = SDL_SetVideoMode(width, height, 32, SDL_HWSURFACE | SDL_DOUBLEBUF); if (screen == NULL) { fprintf(stderr, "Unable to set %ix%i at 32 bpp: %s\n", width, height, SDL_GetError()); } uint32_t gen_id; char *alive = malloc(width * height * sizeof(char)); char *dying = malloc(width * height * sizeof(char)); err = bbbout_read_generation(bbbout, &gen_id, alive, dying); while (err == BBBOUT_SUCCESS) { unsigned int ticks1 = SDL_GetTicks(); handle_events(); int i; for (i = 0; i < width * height; i++) { if (dying[i]) { struct rgb24 team_color = bbbout->team_colors[(unsigned char) dying[i]]; *((uint32_t *) screen->pixels + i) = SDL_MapRGB(screen->format, team_color.red/2, team_color.green/2, team_color.blue/2); } else { *((uint32_t *) screen->pixels + i) = 0; } } for (i = 0; i < width * height; i++) { if (alive[i]) { struct rgb24 team_color = bbbout->team_colors[(unsigned char) alive[i]]; *((uint32_t *) screen->pixels + i) = SDL_MapRGB(screen->format, team_color.red, team_color.green, team_color.blue); } } SDL_Flip(screen); char *temp = dying; dying = alive; alive = temp; err = bbbout_read_generation(bbbout, &gen_id, alive, NULL); unsigned int ticks2 = SDL_GetTicks(); if (ticks2 - ticks1 >= 33) { SDL_Delay(1); } else { SDL_Delay(33 - (ticks2 - ticks1)); } } if (err < BBBOUT_SUCCESS) { puts(bbbout_strerror(err)); } free(alive); free(dying); SDL_Quit(); return 0; }
/*----------------------------------------------------------------- * Desc: should do roughly what getchar() does, but in raw * (SLD) keyboard mode. * * Return: the (SDLKey) of the next key-pressed event cast to (int) * *-----------------------------------------------------------------*/ int getchar_raw (void) { SDL_Event event; int Returnkey = 0; // keyboard_update (); /* treat all pending keyboard-events */ while ( !Returnkey ) { while (!SDL_WaitEventTimeout (&event, 10)) /* wait for next event */ SDL_Flip (ne_screen); switch (event.type) { case SDL_KEYDOWN: /* * here we use the fact that, I cite from SDL_keyboard.h: * "The keyboard syms have been cleverly chosen to map to ASCII" * ... I hope that this design feature is portable, and durable ;) */ Returnkey = (int) event.key.keysym.sym; if ( event.key.keysym.mod & KMOD_SHIFT ) Returnkey = toupper( (int)event.key.keysym.sym ); break; case SDL_JOYBUTTONDOWN: #ifdef JOY_BUTTON_COUNT if (event.jbutton.button < JOY_BUTTON_COUNT) Returnkey = joy_button_map[event.jbutton.button]; #else if (event.jbutton.button == 0) Returnkey = JOY_BUTTON1; else if (event.jbutton.button == 1) Returnkey = JOY_BUTTON2; else if (event.jbutton.button == 2) Returnkey = JOY_BUTTON3; #endif break; case SDL_MOUSEBUTTONDOWN: if (event.button.button == SDL_BUTTON_LEFT) Returnkey = MOUSE_BUTTON1; else if (event.button.button == SDL_BUTTON_RIGHT) Returnkey = MOUSE_BUTTON2; else if (event.button.button == SDL_BUTTON_MIDDLE) Returnkey = MOUSE_BUTTON3; else if (event.button.button == SDL_BUTTON_WHEELUP) Returnkey = MOUSE_WHEELUP; else if (event.button.button == SDL_BUTTON_WHEELDOWN) Returnkey = MOUSE_WHEELDOWN; break; default: SDL_PushEvent (&event); /* put this event back into the queue */ update_input (); /* and treat it the usual way */ continue; } } /* while(1) */ return ( Returnkey ); } /* getchar_raw() */
int your_test(int argc, char **argv) { int done=0; /* check args */ if(argc!=2) { fprintf(stderr,"%s file.ttf\n",argv[0]); return 1; } /* initialize the cache to NULL */ memset(text,0,sizeof(text)); /* start SDL video */ if(SDL_Init(SDL_INIT_VIDEO)==-1) { printf("SDL_Init: %s\n",SDL_GetError()); return 1; } atexit(SDL_Quit); /* remember to quit SDL */ /* open the screen */ if(!(screen=SDL_SetVideoMode(1200,1000,0,0))) { printf("SDL_SetVideoMode: %s\n",SDL_GetError()); return 1; } /* allow for key repeat (so the user can hold down a key...) */ SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); /* start SDL_ttf */ if(TTF_Init()==-1) { printf("TTF_Init: %s\n", TTF_GetError()); return 2; } atexit(TTF_Quit); /* remember to quit SDL_ttf */ atexit(free_font); /* remember to free any loaded font and glyph cache */ while(!done) { SDL_Event event; static int x=0, y=0, need_draw=1,last_size=0, last_start_glyph=-1; /* smartly load font and generate new glyph cache (font_size change) */ if(last_size!=font_size) { if(font_size<1) font_size=1; load_font(argv[1], font_size); need_draw=1; last_size=font_size; } /* smartly generate new glyph cache (page change) */ if(last_start_glyph!=start_glyph) { cache_glyphs(); need_draw=1; last_start_glyph=start_glyph; } /* smartly redraw as needed */ if(need_draw) { SDL_FillRect(screen,0,~0); draw_table(x,y); SDL_Flip(screen); need_draw=0; } /* wait for events and handle them */ /* this waits for one, then handles all that are queued before finishing */ if(SDL_WaitEvent(&event)) do { switch(event.type) { case SDL_QUIT: done=1; break; case SDL_KEYDOWN: switch(event.key.keysym.sym) { case '0': start_glyph=0; break; case SDLK_LEFT: start_glyph=(start_glyph+0x10000-0x80)&0xffff; break; case SDLK_RIGHT: start_glyph=(start_glyph+0x80)&0xffff; break; case SDLK_UP: font_size++; break; case SDLK_DOWN: font_size--; break; case 'n': style=TTF_STYLE_NORMAL; last_start_glyph=-1; break; case 'b': style^=TTF_STYLE_BOLD; last_start_glyph=-1; break; case 'i': style^=TTF_STYLE_ITALIC; last_start_glyph=-1; break; case 'u': style^=TTF_STYLE_UNDERLINE; last_start_glyph=-1; break; case 's': style^=TTF_STYLE_STRIKETHROUGH; last_start_glyph=-1; break; case 'k': kerning=!kerning; printf("kerning=%d\n",kerning); last_start_glyph=-1; break; case 'h': hinting=(hinting+1)%4; printf("hinting=%s\n", hinting==0?"Normal": hinting==1?"Light": hinting==2?"Mono": hinting==3?"None": "Unknonwn"); last_start_glyph=-1; break; case '=': ++outline; printf("outline=%d\n",outline); last_start_glyph=-1; break; case '-': if(outline>0) --outline; printf("outline=%d\n",outline); last_start_glyph=-1; break; case 'q': case SDLK_ESCAPE: done=1; break; default: break; } break; case SDL_MOUSEMOTION: if(event.motion.state) { x=event.motion.x; y=event.motion.y; need_draw=1; } break; case SDL_MOUSEBUTTONDOWN: x=event.button.x; y=event.button.y; need_draw=1; break; } } while(SDL_PollEvent(&event)); } /* main loop */ return 0; }
int SDL_WM_ToggleFullScreen(SDL_Surface * surface) { int length; void *pixels; Uint8 *src, *dst; int row; int window_w; int window_h; if (!SDL_PublicSurface) { SDL_SetError("SDL_SetVideoMode() hasn't been called"); return 0; } /* Copy the old bits out */ length = SDL_PublicSurface->w * SDL_PublicSurface->format->BytesPerPixel; pixels = SDL_malloc(SDL_PublicSurface->h * length); if (pixels) { src = (Uint8*)SDL_PublicSurface->pixels; dst = (Uint8*)pixels; for (row = 0; row < SDL_PublicSurface->h; ++row) { SDL_memcpy(dst, src, length); src += SDL_PublicSurface->pitch; dst += length; } } /* Do the physical mode switch */ if (SDL_GetWindowFlags(SDL_VideoWindow) & SDL_WINDOW_FULLSCREEN) { if (SDL_SetWindowFullscreen(SDL_VideoWindow, 0) < 0) { return 0; } SDL_PublicSurface->flags &= ~SDL_FULLSCREEN; } else { if (SDL_SetWindowFullscreen(SDL_VideoWindow, 1) < 0) { return 0; } SDL_PublicSurface->flags |= SDL_FULLSCREEN; } /* Recreate the screen surface */ SDL_WindowSurface = SDL_GetWindowSurface(SDL_VideoWindow); if (!SDL_WindowSurface) { /* We're totally hosed... */ return 0; } /* Center the public surface in the window surface */ SDL_GetWindowSize(SDL_VideoWindow, &window_w, &window_h); SDL_VideoViewport.x = (window_w - SDL_VideoSurface->w)/2; SDL_VideoViewport.y = (window_h - SDL_VideoSurface->h)/2; SDL_VideoViewport.w = SDL_VideoSurface->w; SDL_VideoViewport.h = SDL_VideoSurface->h; /* Do some shuffling behind the application's back if format changes */ if (SDL_VideoSurface->format->format != SDL_WindowSurface->format->format) { if (SDL_ShadowSurface) { if (SDL_ShadowSurface->format->format == SDL_WindowSurface->format->format) { /* Whee! We don't need a shadow surface anymore! */ SDL_VideoSurface->flags &= ~SDL_DONTFREE; SDL_FreeSurface(SDL_VideoSurface); SDL_free(SDL_ShadowSurface->pixels); SDL_VideoSurface = SDL_ShadowSurface; SDL_VideoSurface->flags |= SDL_PREALLOC; SDL_ShadowSurface = NULL; } else { /* No problem, just change the video surface format */ SDL_FreeFormat(SDL_VideoSurface->format); SDL_VideoSurface->format = SDL_WindowSurface->format; SDL_VideoSurface->format->refcount++; SDL_InvalidateMap(SDL_ShadowSurface->map); } } else { /* We can make the video surface the shadow surface */ SDL_ShadowSurface = SDL_VideoSurface; SDL_ShadowSurface->pitch = SDL_CalculatePitch(SDL_ShadowSurface); SDL_ShadowSurface->pixels = SDL_malloc(SDL_ShadowSurface->h * SDL_ShadowSurface->pitch); if (!SDL_ShadowSurface->pixels) { /* Uh oh, we're hosed */ SDL_ShadowSurface = NULL; return 0; } SDL_ShadowSurface->flags &= ~SDL_PREALLOC; SDL_VideoSurface = SDL_CreateRGBSurfaceFrom(NULL, 0, 0, 32, 0, 0, 0, 0, 0); SDL_VideoSurface->flags = SDL_ShadowSurface->flags; SDL_VideoSurface->flags |= SDL_PREALLOC; SDL_FreeFormat(SDL_VideoSurface->format); SDL_VideoSurface->format = SDL_WindowSurface->format; SDL_VideoSurface->format->refcount++; SDL_VideoSurface->w = SDL_ShadowSurface->w; SDL_VideoSurface->h = SDL_ShadowSurface->h; } } /* Update the video surface */ SDL_VideoSurface->pitch = SDL_WindowSurface->pitch; SDL_VideoSurface->pixels = (void *)((Uint8 *)SDL_WindowSurface->pixels + SDL_VideoViewport.y * SDL_VideoSurface->pitch + SDL_VideoViewport.x * SDL_VideoSurface->format->BytesPerPixel); SDL_SetClipRect(SDL_VideoSurface, NULL); /* Copy the old bits back */ if (pixels) { src = (Uint8*)pixels; dst = (Uint8*)SDL_PublicSurface->pixels; for (row = 0; row < SDL_PublicSurface->h; ++row) { SDL_memcpy(dst, src, length); src += length; dst += SDL_PublicSurface->pitch; } SDL_Flip(SDL_PublicSurface); SDL_free(pixels); } /* We're done! */ return 1; }
int main( int argc, char* args[] ) { //Quit flag bool quit = false; //The timer starting time Uint32 start = 0; //The timer start/stop flag bool running = true; //Initialize if( init() == false ) { return 1; } //Load the files if( load_files() == false ) { return 1; } //Generate the message surface startStop = TTF_RenderText_Solid( font, "Press S to start or stop the timer", textColor ); //Start the timer start = SDL_GetTicks(); //While the user hasn't quit while( quit == false ) { //While there's an event to handle while( SDL_PollEvent( &event ) ) { //If a key was pressed if( event.type == SDL_KEYDOWN ) { //If s was pressed if( event.key.keysym.sym == SDLK_s ) { //If the timer is running if( running == true ) { //Stop the timer running = false; start = 0; } else { //Start the timer running = true; start = SDL_GetTicks(); } } } //If the user has Xed out the window else if( event.type == SDL_QUIT ) { //Quit the program quit = true; } } //Apply the background apply_surface( 0, 0, background, screen ); //Apply the message apply_surface( ( SCREEN_WIDTH - startStop->w ) / 2, 200, startStop, screen ); //If the timer is running if( running == true ) { //The timer's time as a string std::stringstream time; //Convert the timer's time to a string time << "Timer: " << SDL_GetTicks() - start; //Render the time surface seconds = TTF_RenderText_Solid( font, time.str().c_str(), textColor ); //Apply the time surface apply_surface( ( SCREEN_WIDTH - seconds->w ) / 2, 50, seconds, screen ); //Free the time surface SDL_FreeSurface( seconds ); } //Update the screen if( SDL_Flip( screen ) == -1 ) { return 1; } } //Clean up clean_up(); return 0; }
int main ( int argc, char *argv[] ) { bool quit = false; int sprite_x = 0; int inc_val = 0; char m[80]; int u = 0; int bgX = 0; int bgY = 0; if( init() == false ) return EXIT_FAILURE; if( load_files() == false ) return EXIT_FAILURE; clip[0].x = 0; clip[0].y = 0; clip[0].w = 32; clip[0].h = 32; //apply_surface( 0, 0, background, screen ); apply_surface( 10, 10, sprite_image, screen, &clip[0] ); //apply_surface( 10, 10, sprite_image, screen ); if( SDL_Flip( screen ) == -1 ) { return EXIT_FAILURE; } next_time = SDL_GetTicks() + TICK_INTERVAL; while( quit == false ){ SDL_Rect tmp; SDL_Rect tmp2; tmp.x = sprite_x; tmp.y = 0; tmp.w = 32; tmp.h = 32; quit = handle_events( &inc_val ); tmp2.x = 210 + 150; tmp2.y = 0; tmp2.w = 16; tmp2.h = 16; if( rightdown ) inc_val++; if( inc_val > 0 && leftdown ) inc_val--; //rightdown = false; //leftdown = false; // //fprintf(stderr, "x = %d\n", sprite_x); sprintf( m, "%d", inc_val ); message = TTF_RenderText_Solid( font, m, textColor ); SDL_FillRect( screen, NULL, SDL_MapRGB( screen->format, 0, 0, 0 ) ); //apply_surface( 10, 10, sprite_image, screen, &tmp ); //apply_surface( 100, 100, sprite_image2, screen, &tmp2 ); draw(); bgX -= 2; if( bgX <= -background->w ){ bgX = 0; } /* if( !updown && u != 50 ){ u = 100; } */ apply_surface( bgX, bgY, background, screen ); apply_surface( bgX + background->w, bgY, background, screen ); apply_surface( 50, 50, message, screen ); //apply_surface( 10, 10, sprite_image, screen ); if( SDL_Flip( screen ) == -1 ) { return EXIT_FAILURE; } sprite_x = (sprite_x + 32) % 256; //SDL_Delay(30); SDL_Delay( time_left() ); //SDL_free( tmp ); next_time += TICK_INTERVAL; } //SDL_Delay(5000); return EXIT_SUCCESS; }/* ---------- end of function main ---------- */
void PrintMissingFilesToScreen() { SDL_ShowCursor(SDL_ENABLE); std::string instruction = "Dune Legacy uses the data files from original Dune II. The following files are missing:\n"; std::vector<std::string> MissingFiles = FileManager::getMissingFiles(LNG_ENG); std::vector<std::string>::const_iterator iter; for(iter = MissingFiles.begin(); iter != MissingFiles.end(); ++iter) { instruction += " " + *iter + "\n"; } instruction += "\nPut them in one of the following directories:\n"; std::vector<std::string> searchPath = FileManager::getSearchPath(); std::vector<std::string>::const_iterator searchPathIter; for(searchPathIter = searchPath.begin(); searchPathIter != searchPath.end(); ++searchPathIter) { instruction += " " + *searchPathIter + "\n"; } instruction += "\nYou may want to add GERMAN.PAK or FRENCH.PAK for playing in these languages.\n"; instruction += "\n\nPress ESC to exit."; SDL_Surface* pSurface = pFontManager->createSurfaceWithMultilineText(instruction, 255, FONT_STD12); SDL_Rect dest = { 30, 30, pSurface->w, pSurface->h }; SDL_BlitSurface(pSurface, NULL, screen, &dest); SDL_FreeSurface(pSurface); SDL_Flip(screen); SDL_Event event; bool quiting = false; while(!quiting) { SDL_Delay(20); while(SDL_PollEvent(&event)) { //check the events switch (event.type) { case (SDL_KEYDOWN): // Look for a keypress { switch(event.key.keysym.sym) { case SDLK_ESCAPE: quiting = true; break; default: break; } } break; case SDL_QUIT: quiting = true; break; default: break; } } } }
int main( int argc, char* args[] ) { if ( SDL_Init( SDL_INIT_VIDEO ) == -1 ) return 1; SDL_Surface *screen = SDL_SetVideoMode( WIDTH, HEIGHT, 32, SDL_SWSURFACE ); if ( !screen ) return 1; // Initialize the grid from the BMP file. SDL_Surface *temp = SDL_LoadBMP( "test.bmp" ); temp = SDL_ConvertSurface( temp, screen->format, SDL_SWSURFACE ); SDL_LockSurface( temp ); for( int y=0;y<HEIGHT;y++ ) { for ( int x=0;x<WIDTH;x++ ) { Uint8 r,g,b; Uint32 *src = ( (Uint32 *)( (Uint8 *)temp->pixels + y*temp->pitch ) ) + x; SDL_GetRGB( *src, temp->format, &r, &g, &b ); // Points inside get marked with a dx/dy of zero. // Points outside get marked with an infinitely large distance. if ( g < 128 ) { Put( grid1, x, y, inside ); Put( grid2, x, y, empty ); } else { Put( grid2, x, y, inside ); Put( grid1, x, y, empty ); } } } SDL_UnlockSurface( temp ); // Generate the SDF. GenerateSDF( grid1 ); GenerateSDF( grid2 ); // Render out the results. SDL_LockSurface( screen ); for( int y=0;y<HEIGHT;y++ ) { for ( int x=0;x<WIDTH;x++ ) { // Calculate the actual distance from the dx/dy int dist1 = (int)( sqrt( (double)Get( grid1, x, y ).DistSq() ) ); int dist2 = (int)( sqrt( (double)Get( grid2, x, y ).DistSq() ) ); int dist = dist1 - dist2; // Clamp and scale it, just for display purposes. int c = dist*3 + 128; if ( c < 0 ) c = 0; if ( c > 255 ) c = 255; Uint32 *dest = ( (Uint32 *)( (Uint8 *)screen->pixels + y*screen->pitch ) ) + x; *dest = SDL_MapRGB( screen->format, c, c, c ); } } SDL_UnlockSurface( screen ); SDL_Flip( screen ); // Wait for a keypress SDL_Event event; while( true ) { if ( SDL_PollEvent( &event ) ) switch( event.type ) { case SDL_QUIT: case SDL_KEYDOWN: return true; } } return 0; }
//Shows menu texts void Game::showMenu() { Surface::apply_surface(0, 200, menu, screen); Surface::apply_surface(0, 300, menu2, screen); SDL_Flip(screen); }
bool CGame::Start() { // Esta variable nos ayudara a controlar la salida del juego... int salirJuego = false; int i = 0; while (salirJuego == false) { //Maquina de estados switch (estado) { case Estado::ESTADO_INICIANDO: //inicializando printf("1.- Estado_Iniciando"); Iniciando(); InicializandoStage(); estado = ESTADO_MENU; //estado = ESTADO_MENU break; case Estado::ESTADO_MENU: //MENU menu->Pintar(); textos->Pintar(MODULO_FondoTexto_TITULO,160,50); textos->Pintar(MODULO_FondoMenu_NOMBRE,400, 410); Menu(); //estado= ESTADO_JUGANDO break; case ESTADO_PRE_JUGANDO: NivelActual = 0; vida = 1; enemigosEliminados = 0; estado = ESTADO_JUGANDO; break; case Estado::ESTADO_JUGANDO: //JUGAR for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++) { enemigoArreglo[i]->GetNaveObjeto()->Actualizar(); } MoverEnemigo(); fondo->Pintar(); //SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); keys = SDL_GetKeyState(NULL); if (keys[SDLK_RIGHT]) { if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_DERECHO)) nave->MoverDerecha(nivel[NivelActual].VelocidadNavePropia); } if (keys[SDLK_LEFT]) { if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_IZQUIERDO)) nave->MoverIzquierda(nivel[NivelActual].VelocidadNavePropia); } if (keys[SDLK_UP]) { if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_SUPERIOR)) nave->MoverArriba(nivel[NivelActual].VelocidadNavePropia); } if (keys[SDLK_DOWN]) { if (!EsLimitePantalla(nave->GetNaveObjeto(), BORDE_INFERIOR)) nave->MoverAbajo(nivel[NivelActual].VelocidadNavePropia); } if (keys[SDLK_SPACE]) { nave->Disparar(NAVE_PROPIA, nivel[NivelActual].BalasMaximas); } //////////////simulacion de coliciones if (keys[SDLK_x]){//bala enemigo a nuestra nave nave->simularColision(true); } if (keys[SDLK_c]){//nuestra bala a nave enemigo int enemigoAEliminar = rand() % nivel[NivelActual].NumeroEnemigosVisibles; enemigoArreglo[enemigoAEliminar]->simularColision(true); } if (keys[SDLK_v]){//nuestra nave a nave enemigo } /////////////////////////////////////////////// //control de coliciones for (int i = 0; i<nivel[NivelActual].NumeroEnemigosVisibles; i++){ if (enemigoArreglo[i]->estaColicionandoConBala(nave)) vida--; if (nave->estaColicionandoConBala(enemigoArreglo[i])){ enemigoArreglo[i]->setVisible(false); enemigosEliminados++; nave->simularColision(false); if (enemigosEliminados < nivel[NivelActual].NumeroEnemigoAEliminar){ enemigoArreglo[i]->CrearNuevo(); } } } /////////////////////////////////////// if (vida <= 0) estado = ESTADO_TERMINANDO; if (enemigosEliminados >= nivel[NivelActual].NumeroEnemigoAEliminar){ NivelActual++; } nave->Pintar(NAVE_PROPIA); for (int i = 0; i < nivel[NivelActual].NumeroEnemigosVisibles; i++) { enemigoArreglo[i]->Pintar(NAVE_ENEMIGO); enemigoArreglo[i]->AutoDispara(nivel[NivelActual].BalasMaximas); } if (keys[SDLK_ESCAPE]) { } break; case Estado::ESTADO_TERMINANDO: //TERMINAR break; case Estado::ESTADO_FINALIZADO: //FINALIZAR break; } while (SDL_PollEvent(&event)) { if (event.type == SDL_QUIT) { salirJuego = true; } // Si se detecta una salida if (event.type == SDL_KEYDOWN) {} // una dirección (abajo) del teclado. } SDL_Flip(screen); //guarda en memoria buffer //calculando FPS tiempoFrameFinal = SDL_GetTicks(); while (tiempoFrameFinal < (tiempoFrameInicial + FPS_DELAY)){ tiempoFrameFinal = SDL_GetTicks(); SDL_Delay(1); } printf("Frames:%d Tiempo:%d Tiempo Promedio:%f Tiempo Por Frame:%d FPS:%f\n", tick, SDL_GetTicks(), (float)SDL_GetTicks() / (float)tick, tiempoFrameFinal - tiempoFrameInicial,1000.0f / (float) (tiempoFrameFinal-tiempoFrameInicial)); tiempoFrameInicial = tiempoFrameFinal; //Marcamos el inicio nuevamente tick++; } return true; }
bool SDLDraw::copyDoubleBufferandFlip() { if(SDL_Flip(FrontBuffer)==0) return true; return false; }
int main (int argc, char **argv) { SDL_Surface *image; nile_t *nl; char mem[500000]; uint32_t texture_pixels[TEXTURE_WIDTH * TEXTURE_HEIGHT] = {0}; real angle = 0; real scale; if (SDL_Init (SDL_INIT_VIDEO) == -1) DIE ("SDL_Init failed: %s", SDL_GetError ()); if (!SDL_SetVideoMode (DEFAULT_WIDTH, DEFAULT_HEIGHT, 0, SDL_HWSURFACE | SDL_ANYFORMAT | SDL_DOUBLEBUF)) DIE ("SDL_SetVideoMode failed: %s", SDL_GetError ()); image = SDL_GetVideoSurface (); nl = nile_new (NTHREADS, mem, sizeof (mem)); ilInit (); ilBindImage (iluGenImage ()); if (argc < 3) return -1; printf ("loading: %s\n", argv[1]); ilLoadImage (argv[1]); ilCopyPixels (0, 0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT, 1, IL_BGRA, IL_UNSIGNED_BYTE, &texture_pixels); int filter = atoi (argv[2]); for (;;) { angle += 0.001; scale = fabs (angle - (int) angle - 0.5) * 10; SDL_Event event; if (SDL_PollEvent (&event) && event.type == SDL_QUIT) break; SDL_FillRect (image, NULL, 0); SDL_LockSurface (image); matrix_t M = matrix_new (); M = matrix_translate (M, 250, 250); M = matrix_rotate (M, angle); M = matrix_scale (M, scale, scale); M = matrix_translate (M, -250, -250); matrix_t I = matrix_inverse (M); nile_Kernel_t *texture = gezira_ReadFromImage_ARGB32 (nl, texture_pixels, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_WIDTH); /* */ texture = nile_Pipeline (nl, gezira_ImageExtendReflect (nl, TEXTURE_WIDTH, TEXTURE_HEIGHT), texture, NULL); if (filter == 2) texture = gezira_BilinearFilter (nl, texture); if (filter == 3) texture = gezira_BicubicFilter (nl, texture); /* */ texture = nile_Pipeline (nl, gezira_TransformPoints (nl, I.a, I.b, I.c, I.d, I.e - 150, I.f - 125), texture, NULL); nile_Kernel_t *pipeline = nile_Pipeline (nl, gezira_TransformBeziers (nl, M.a, M.b, M.c, M.d, M.e, M.f), gezira_ClipBeziers (nl, 0, 0, DEFAULT_WIDTH, DEFAULT_HEIGHT), gezira_Rasterize (nl), gezira_ApplyTexture (nl, texture), gezira_WriteToImage_ARGB32 (nl, image->pixels, DEFAULT_WIDTH, DEFAULT_HEIGHT, image->pitch / 4), NULL); nile_feed (nl, pipeline, path, 6, path_n, 1); nile_sync (nl); SDL_UnlockSurface (image); SDL_Flip (image); } nile_free (nl); printf ("done\n"); return 0; }
void place_life(t_struct *st) { st->img = IMG_Load(LIFE1); SDL_BlitSurface(st->img, NULL, st->ecran, &st->pos); SDL_Flip(st->ecran); }
int main(int argc, char *argv[]) { //Network vars int udpSd, tcpSd; char buffer[5]; int myId; //SDL vars SDL_Event event; //Screen SDL_Surface* screen = NULL; //Tanks SDL_Surface* blueTank = NULL; SDL_Surface* blueCannon = NULL; SDL_Surface* redTank = NULL; SDL_Surface* redCannon = NULL; //Bullet SDL_Surface* bullet = NULL; //WorldMap SDL_Surface* worldMap = NULL; //rotation Images //SDL_Surface* rotatedTank[6] = {NULL,NULL,NULL,NULL,NULL,NULL}; //SDL_Surface* rotatedCannon[6] = {NULL,NULL,NULL,NULL,NULL,NULL}; SDL_Surface* rotatedBullet[6] = {NULL,NULL,NULL,NULL,NULL,NULL}; //SDL_Rect Tankoffset[6] = {400,300,0,0}; //SDL_Rect Cannonoffset[6] = {400,300,0,0}; //UserInterface vars SDL_Surface* UIhealth; SDL_Surface* UIreload; SDL_Surface* UIredPoints; SDL_Surface* UIbluePoints; TTF_Font *font = NULL; TTF_Font *reloadFont = NULL; SDL_Color textColor = { 255, 255, 255 }; char textBuffer[32]; char reload[32] = "FIRE: "; //Thread vars pthread_t reciveUdpData; //Game vars int run; struct playerInfo player[6]; struct timerInfo fps; struct cameraInfo camera; int bulletAngle[6]; //int oldCannonAngle[6]; //int oldTankAngle[6]; //Other vars int i; //Inits the player struct for (i = 0; i < MAX_PLAYERS; i++) { player[i].slot = -1; player[i].connected = 0; } //inits Sdl and opens the screen screen = init_sdl(); if(screen == 0) { printf("Error initializing SDL\n"); return 0; } //Makes the connection to the server if(!(init_udp_tcp(&udpSd, &tcpSd, argv[1], argv[2]))) { printf("Error making connection\n"); return 0; } //load the images (Function maybe) blueTank = load_image( "./images/blueTank.bmp" ); blueCannon = load_image( "./images/blueCannon.bmp" ); redTank = load_image( "./images/redTank.bmp" ); redCannon = load_image( "./images/redCannon.bmp" ); worldMap = load_image( "./images/worldMap.bmp" ); bullet = load_image( "./images/bullet.bmp" ); //Load the fonts font = TTF_OpenFont( "./fonts/Army.ttf", 24 ); reloadFont = TTF_OpenFont( "./fonts/Armyfat.ttf", 24 ); //Moves udp info to global var udpInfo.udpSd = udpSd; strcpy(udpInfo.serverIp, argv[1]); //Recives the first information from the server recv(tcpSd, buffer, sizeof(buffer), 0); myId = atoi(buffer); //Starts the Recive data thread pthread_create( &reciveUdpData, NULL, recive_udp_data, &(player)); while (run) { //Start the timer timer_start(&fps); while( SDL_PollEvent( &event ) ) { if( event.type == SDL_QUIT || event.key.keysym.sym == SDLK_ESCAPE) { run = FALSE; } handel_input(&event, tcpSd ); } camera.xCord = -player[myId].xCord; camera.yCord = -player[myId].yCord; //From here we draw stuff on the screen SDL_FillRect(screen,NULL, 0x000000); //Draws WorldMAps draw_map(player[myId].xCord,player[myId].yCord, worldMap, screen); //DISPLAYES YOUR TANK+++++++++++++++++++++++++++++ if (player[myId].team == 1) { draw_tank_self(player[myId].tankAngle, blueTank, screen); draw_cannon_self(player[myId].cannonAngle, blueCannon, screen); } else { draw_tank_self(player[myId].tankAngle, redTank, screen); draw_cannon_self(player[myId].cannonAngle, redCannon, screen); } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //DISPLAYES OTHER TANKS+++++++++++++++++++++++++++++ for (i = 0; i < MAX_PLAYERS; i++) { if (player[i].slot == myId) { continue; } if (player[i].slot > -1 && player[i].connected == 1) { if (player[i].team == 1) { draw_tank_other(player[i].xCord,player[i].yCord,camera.xCord,camera.yCord,player[i].tankAngle,blueTank,screen); if (player[i].dead == 0) draw_cannon_other(player[i].xCord,player[i].yCord,camera.xCord,camera.yCord,player[i].cannonAngle,blueCannon,screen); } else { draw_tank_other(player[i].xCord,player[i].yCord,camera.xCord,camera.yCord,player[i].tankAngle,redTank,screen); if (player[i].dead == 0) draw_cannon_other(player[i].xCord,player[i].yCord,camera.xCord,camera.yCord,player[i].cannonAngle,redCannon,screen); } } } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //DRAWS ALL THE BULLETS ON THE SCREEEN+++++++++++++++++++++++++++ for (i = 0; i < MAX_PLAYERS; i++) { if (player[i].slot > -1 && player[i].connected == 1) { if (player[i].fire > 0) { if (bulletAngle[i] == 0) { SDL_FreeSurface( rotatedBullet[i] ); rotatedBullet[i] = rotozoomSurface(bullet,player[i].cannonAngle,1.0,0); playSound(soundShoot); } draw_bullet(&player[i], &camera, rotatedBullet[i], screen ); bulletAngle[i] = 1; } if (player[i].fire == 0) { bulletAngle[i]=0; } } } //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //DRAWS THE USER INTERFACE ON SCREEN+++++++++++++++++++++++++++++ textColor.r=0; textColor.g=0; textColor.b=255; sprintf(textBuffer, "BLUE POINTS: %d", bluePoints); UIbluePoints = TTF_RenderText_Solid( font, textBuffer, textColor ); draw_UI( 10, 10, UIbluePoints, screen); textColor.r=255; textColor.g=0; textColor.b=0; sprintf(textBuffer, "RED POINTS: %d", redPoints); UIredPoints = TTF_RenderText_Solid( font, textBuffer, textColor ); draw_UI( 600, 10, UIredPoints, screen); textColor.r=255; textColor.g=0; textColor.b=0; sprintf(textBuffer, "HP: %d", player[myId].healthPoints); UIhealth = TTF_RenderText_Solid( font, textBuffer, textColor ); draw_UI( 20, 570, UIhealth, screen); textColor.r=255; textColor.g=0; textColor.b=0; if (player[myId].fire == 0) { strcpy(reload, "FIRE: READY"); UIreload = TTF_RenderText_Solid( font, reload, textColor ); } else { strcpy(reload, "FIRE: RELOADING"); UIreload = TTF_RenderText_Solid( font, reload, textColor ); } draw_UI( 580, 570, UIreload, screen); //Update Screen SDL_Flip( screen ); //Cap the frame rate if( timer_get_ticks(&fps) < 1000 / FPS ) { SDL_Delay( ( 1000 / FPS ) - timer_get_ticks(&fps) ); } } pthread_cancel(reciveUdpData); return 0; }
int main() { SDL_Surface* background, *background2, *background3, *background4; SDL_Rect src, dest; int frames; Uint32 colorkey; SDL_AudioSpec desired, obtained; sound_t bus_sound; /*initialize video and sound subsystem*/ if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) != 0){ printf("Unable to initialize video: %s\n.", SDL_GetError()); return 1; } /*ensure all subsystems exit safely*/ atexit(SDL_Quit); atexit(SDL_CloseAudio); /*set video mode*/ screen = SDL_SetVideoMode(640, 480, 16, SDL_DOUBLEBUF | SDL_HWSURFACE); if (screen == NULL) { printf("Unable to set video mode: %s\n", SDL_GetError()); return 1; } /*load background images*/ background = SDL_LoadBMP("img/src.bmp"); if (background == NULL) { printf("Unable to load image."); return 1; } background2 = SDL_LoadBMP("img/background2.bmp"); if (background2 == NULL) { printf("Unable to load background2."); return 1; } background3 = SDL_LoadBMP("img/background3.bmp"); if (background3 == NULL) { printf("Unable to load background3."); return 1; } background4 = SDL_LoadBMP("img/background4.bmp"); if (background4 == NULL) { printf("Unable to load background4."); return 1; } /*load bus*/ bus = SDL_LoadBMP("img/bus.bmp"); if (bus == NULL) { printf("Unable to load image."); return 1; } colorkey = SDL_MapRGB(bus->format, 255, 255, 255); /*set color key*/ SDL_SetColorKey(bus, SDL_SRCCOLORKEY, colorkey); /*load man*/ man = SDL_LoadBMP("img/man.bmp"); if (man == NULL) { printf("Unable to load image"); return 1; } colorkey = SDL_MapRGB(man->format, 255, 255, 255); /*set color key*/ SDL_SetColorKey(man, SDL_SRCCOLORKEY, colorkey); man2 = SDL_LoadBMP("img/man2.bmp"); if (man2 == NULL) { printf("Unable to load image"); return 1; } colorkey = SDL_MapRGB(man2->format, 255, 255, 255); /*set color key*/ SDL_SetColorKey(man2, SDL_SRCCOLORKEY, colorkey); car1 = SDL_LoadBMP("img/car1.bmp"); if (car1 == NULL) { printf("Unable to load image"); return 1; } colorkey = SDL_MapRGB(car1->format, 255, 255, 255); /*set color key*/ SDL_SetColorKey(car1, SDL_SRCCOLORKEY, colorkey); car2 = SDL_LoadBMP("img/car2.bmp"); if (car2 == NULL) { printf("Unable to load image"); return 1; } colorkey = SDL_MapRGB(car2->format, 255, 255, 255); /*set color key*/ SDL_SetColorKey(car2, SDL_SRCCOLORKEY, colorkey); //open audio device desired.freq = 44100; desired.format = AUDIO_S16; desired.samples = 4096; desired.channels = 2; desired.callback = AudioCallback; desired.userdata = NULL; if (SDL_OpenAudio(&desired, &obtained) < 0) { printf("Unable to open audio device: %s\n", SDL_GetError()); return 1; } //load sound files and convert them to sound card's format if (LoadAndConvertSound("audio/bus-pass.wav", &obtained, &bus_sound) != 0) { printf("Unable to load sound.\n"); return 1; } ClearPlayingSounds(); SDL_PauseAudio(0); init_bus(); init_man(); int passenger_in = 0; PlaySound(&bus_sound); while (psv.x > 0) { src.x = 0; src.y = 0; src.w = background->w; src.h = background->h; dest = src; SDL_BlitSurface(background, &src, screen, &dest); draw_obj(&psv, bus); if (psv.x < screen->w/2 && !passenger_in) { /*pause bus for passenger to enter*/ SDL_PauseAudio(1); if (passenger.x > psv.x + 40){ /*check if passenger has got in*/ passenger_in = 1; SDL_PauseAudio(0); } draw_man(); SDL_Flip(screen); move_obj(&passenger); } else { SDL_Flip(screen); move_obj(&psv); } } psv.x = 639; psv.y = 320; init_cars(); PlaySound(&bus_sound); while (psv.x + bus->w/2 > 0) { SDL_BlitSurface(background2, &src, screen, &dest); draw_obj(&priv1, car1); draw_obj(&priv2, car2); draw_obj(&psv, bus); SDL_Flip(screen); move_obj(&psv); move_obj(&priv1); move_obj(&priv2); } psv.x = 639; psv.y = 350; PlaySound(&bus_sound); while (psv.x + bus->w/2 > 0) { SDL_BlitSurface(background3, &src, screen, &dest); draw_obj(&psv, bus); SDL_Flip(screen); move_obj(&psv); } psv.x = 639; psv.y = 267; passenger.y = 270; passenger_in = 1; int has_paused = 0; PlaySound(&bus_sound); while (psv.x + bus->w/2 > 0) { SDL_BlitSurface(background4, &src, screen, &dest); if (screen->w/2 > psv.x && passenger_in == 1) { SDL_PauseAudio(1); if (has_paused == 0) { SDL_Delay(1000); has_paused = 1;} if (passenger.x > 639) {passenger_in = 0; SDL_PauseAudio(0);} draw_obj(&psv, bus); draw_man(); SDL_Flip(screen); move_obj(&passenger); } else { draw_obj(&psv, bus); SDL_Flip(screen); move_obj(&psv); } } //pause and lock sound system SDL_PauseAudio(1); SDL_LockAudio(); free(bus_sound.samples); SDL_UnlockAudio(); SDL_FreeSurface(background4); SDL_FreeSurface(background3); SDL_FreeSurface(background2); SDL_FreeSurface(background); SDL_FreeSurface(man); SDL_FreeSurface(bus); return 0; }
void UnlockScreen() { if(SDL_MUSTLOCK(screen)) SDL_UnlockSurface(screen); SDL_Flip(screen); }
/****************************************************************************** Description.: this is the main worker thread it loops forever, grabs a fresh frame, decompressed the JPEG and displays the decoded data using SDL Input Value.: Return Value: ******************************************************************************/ void *worker_thread(void *arg) { int frame_size = 0, firstrun = 1; SDL_Surface *screen = NULL, *image = NULL; decompressed_image rgbimage; /* initialze the buffer for the decompressed image */ rgbimage.buffersize = 0; rgbimage.buffer = NULL; /* initialze the SDL video subsystem */ if(SDL_Init(SDL_INIT_VIDEO) < 0) { fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); exit(EXIT_FAILURE); } /* just allocate a large buffer for the JPEGs */ if((frame = malloc(4096 * 1024)) == NULL) { OPRINT("not enough memory for worker thread\n"); exit(EXIT_FAILURE); } /* set cleanup handler to cleanup allocated ressources */ pthread_cleanup_push(worker_cleanup, NULL); while(!pglobal->stop) { DBG("waiting for fresh frame\n"); pthread_cond_wait(&pglobal->db_update, &pglobal->db); /* read buffer */ frame_size = pglobal->size; memcpy(frame, pglobal->buf, frame_size); pthread_mutex_unlock(&pglobal->db); /* decompress the JPEG and store results in memory */ if(decompress_jpeg(frame, frame_size, &rgbimage)) { DBG("could not properly decompress JPEG data\n"); continue; } if(firstrun) { /* create the primary surface (the visible window) */ screen = SDL_SetVideoMode(rgbimage.width, rgbimage.height, 0, SDL_ANYFORMAT | SDL_HWSURFACE); SDL_WM_SetCaption("MJPG-Streamer Viewer", NULL); /* create a SDL surface to display the data */ image = SDL_AllocSurface(SDL_SWSURFACE, rgbimage.width, rgbimage.height, 24, #if SDL_BYTEORDER == SDL_LIL_ENDIAN 0x0000FF, 0x00FF00, 0xFF0000, #else 0xFF0000, 0x00FF00, 0x0000FF, #endif 0); /* copy the decoded data across */ memcpy(image->pixels, rgbimage.buffer, rgbimage.width * rgbimage.height * 3); free(rgbimage.buffer); /* now, that we know the dimensions, we can directly copy to the right surface */ rgbimage.buffer = image->pixels; rgbimage.buffersize = rgbimage.width * rgbimage.height * 3; firstrun = 0; } /* copy the image to the primary surface */ SDL_BlitSurface(image, NULL, screen, NULL); /* redraw the whole surface */ SDL_Flip(screen); } pthread_cleanup_pop(1); /* get rid of the image */ SDL_FreeSurface(image); return NULL; }
void start_freehand_drawing(void) { FreehandGeometry geometry; int oldmouse_x, oldmouse_y; int offsetx = cxoff + canvas->get_absxpos(); int offsety = cyoff + canvas->get_absypos(); //SDL_Surface *sur = canvas->get_image(canvas->get_active_image_n()); SDL_Surface *behind = SDLGui::createSurface(screen->w, screen->h); blit(screen, behind, 0, 0, 0, 0, screen->w, screen->h); SDL_Event event; oldmouse_x = mouse.x; oldmouse_y = mouse.y; unsigned processed = 0; StlStroke& stroke = *(geometry.currStroke); while(mouse.b == SDL_BUTTON_LEFT) { // Update the screen with the last round of geometry read from the // event queue. SDL_PumpEvents(); for (unsigned i = processed; i < stroke.size(); i++) { if (i == 0) { //putpixel(screen, stroke[i].x + offsetx, // stroke[i].y + offsety, BLACK); continue; } aalineRGBA(screen, (int) stroke[i - 1].x + offsetx, (int) stroke[i - 1].y + offsety, (int) stroke[i].x + offsetx, (int) stroke[i].y + offsety, 0, 0, 0, 128); processed++; } SDL_PumpEvents(); SDL_Flip(screen); // Wait for a new event. SDL_WaitEvent(&event); // Process all events in the queue. do { switch (event.type) { case SDL_MOUSEMOTION: mouse.x = event.motion.x; mouse.y = event.motion.y; if ((oldmouse_x != mouse.x) || (oldmouse_y != mouse.y)) { geometry.addPoint(mouse.x - offsetx, mouse.y - offsety); oldmouse_x = mouse.x; oldmouse_y = mouse.y; } break; case SDL_MOUSEBUTTONUP: mouse.b = 0; break; case SDL_QUIT: mouse.kill_sig = 1; break; default: break; } } while ((mouse.b != 0) && SDL_PollEvent(&event)); } //qDebug("Points: %d", (int) points.size()); SDL_FastBlit(behind, screen, 0, 0, 0, 0, screen->w, screen->h); SDL_FreeSurface(behind); if (lastFreehand == NULL) { strokeTimerID = SDL_AddTimer(strokeTimeout, freehand_timer_callback, NULL); lastFreehand = new Freehand(geometry); // Visibility graph stuff: visalgo->obj_add(lastFreehand); //QT canvas_deselect_shapes(); } else { SDL_RemoveTimer(strokeTimerID); strokeTimerID = SDL_AddTimer(strokeTimeout, freehand_timer_callback, NULL); lastFreehand->addStroke(geometry); visalgo->obj_resize(lastFreehand); } #if defined(__APPLE__) // After using carbon for mouse input, we need to resync the sdl mouse. GUI_DummyMouseEvent(); while(SDL_PollEvent(&event)); // noop; reset_mouse(); mouse.bstate = mouse.b = 0; #endif repaint_canvas(); }