general.cpp

上面上传的autotools一文（也就是《使用GNU autotools 改造一个软件项目》）配套的示例程序源代码。

   PlaySound(SND_FLASH);
   for (i = 0; i < 12; i++) {
      EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265);
      EraseArea(dstrect.x, dstrect.y, dstrect.w, 30);

      dstrect.x = 245;
      dstrect.y = 235;
      dstrect.w = m_imgFlash1->w;
      dstrect.h = m_imgFlash1->h;

      SDL_BlitSurface(m_imgFlash1, NULL, gpScreen, &dstrect);
      DrawTile(t, 280, 255);
      UpdateScreen(20, 235, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 235);

      UTIL_Delay(50);

      EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265);
      EraseArea(dstrect.x, dstrect.y, dstrect.w, 30);

      dstrect.w = m_imgFlash2->w;
      dstrect.h = m_imgFlash2->h;

      SDL_BlitSurface(m_imgFlash2, NULL, gpScreen, &dstrect);
      DrawTile(t, 280, 255);
      UpdateScreen(20, 235, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 235);
      UTIL_Delay(50);
   }

   UTIL_Delay(20);
   EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265);
   EraseArea(dstrect.x, dstrect.y, dstrect.w, 30);

   dstrect.w = m_imgFlash1->w;
   dstrect.h = m_imgFlash1->h;

   SDL_BlitSurface(m_imgFlash1, NULL, gpScreen, &dstrect);
   DrawTile(t, 280, 255);
   DrawUTF8Text(msg("out_selfdrawn"), 215, 265, 2, 255, 255, 255);
   UpdateScreen(20, 205, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 205);
   UTIL_Delay(1000);
   EraseArea(20, 265, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 265);
   EraseArea(dstrect.x, dstrect.y, dstrect.w, 30);
   UpdateScreen(20, 205, TILE_WIDTH * 10, 303 + TILE_HEIGHT_SHOWN - 205);
}

void CGeneral::AnimOut(const CTile &t)
{
   EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94);
   UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64);
   int i;
   SDL_Rect dstrect, dhand;

   SDL_Surface *save = SDL_CreateRGBSurface(gpScreen->flags & (~SDL_HWSURFACE),
      m_imgHand->w, m_imgHand->h, gpScreen->format->BitsPerPixel,
      gpScreen->format->Rmask, gpScreen->format->Gmask,
      gpScreen->format->Bmask, gpScreen->format->Amask);

   dhand.x = 218;
   dhand.y = 125;
   dhand.w = m_imgHand->w;
   dhand.h = m_imgHand->h;

   SDL_BlitSurface(gpScreen, &dhand, save, NULL);
   SDL_BlitSurface(m_imgHand, NULL, gpScreen, &dhand);
   UpdateScreen(dhand.x, dhand.y, dhand.w, dhand.h);

   PlaySound(SND_FLASH);
   dhand.h = m_imgFlash2->h - (125 - 94);
   for (i = 0; i < 10; i++) {
      EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94);
      EraseArea(245, 94, m_imgFlash2->w, m_imgFlash2->h);

      dstrect.x = 245;
      dstrect.y = 94;
      dstrect.w = m_imgFlash1->w;
      dstrect.h = m_imgFlash1->h;

      SDL_BlitSurface(m_imgFlash1, NULL, gpScreen, &dstrect);
      DrawTile(t, 280, 104);
      SDL_BlitSurface(m_imgHand, NULL, gpScreen, &dhand);
      UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64);

      UTIL_Delay(50);

      EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94);
      EraseArea(dstrect.x, dstrect.y, dstrect.w, dstrect.h);

      dstrect.w = m_imgFlash2->w;
      dstrect.h = m_imgFlash2->h;
      SDL_BlitSurface(m_imgFlash2, NULL, gpScreen, &dstrect);
      DrawTile(t, 280, 104);
      SDL_BlitSurface(m_imgHand, NULL, gpScreen, &dhand);
      UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64);
      UTIL_Delay(50);
   }

   dhand.h = m_imgHand->h;
   UTIL_Delay(120);
   DrawUTF8Text(msg("out_discard"), 215, 114, 2, 255, 255, 255);
   UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64);
   UTIL_Delay(1000);
   EraseArea(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 94);
   EraseArea(dstrect.x, dstrect.y, dstrect.w, dstrect.h);
   SDL_BlitSurface(save, NULL, gpScreen, &dhand);
   SDL_FreeSurface(save);
   UpdateScreen(620 - 10 * TILE_WIDTH, 94, TILE_WIDTH * 10, 132 + TILE_HEIGHT_SHOWN - 64);
   UpdateScreen(dhand.x, dhand.y, dhand.w, dhand.h);
}

void CGeneral::LoadImages()
{
   m_imgGirls[0][GIRL_COLOR] = LoadImgFile(IMAGES_DIR "mjgirl1b.jpg");
   m_imgGirls[0][GIRL_GRAYSTYLE] = UTIL_GrayStyle(m_imgGirls[0][GIRL_COLOR]);
   m_imgGirls[0][GIRL_FULL] = LoadImgFile(IMAGES_DIR "mjgirl1c.jpg");
   m_imgGirls[1][GIRL_COLOR] = LoadImgFile(IMAGES_DIR "mjgirl2b.jpg");
   m_imgGirls[1][GIRL_GRAYSTYLE] = UTIL_GrayStyle(m_imgGirls[1][GIRL_COLOR]);
   m_imgGirls[1][GIRL_FULL] = LoadImgFile(IMAGES_DIR "mjgirl2c.jpg");
   m_imgGirls[2][GIRL_COLOR] = LoadImgFile(IMAGES_DIR "mjgirl3b.jpg");
   m_imgGirls[2][GIRL_GRAYSTYLE] = UTIL_GrayStyle(m_imgGirls[2][GIRL_COLOR]);
   m_imgGirls[2][GIRL_FULL] = LoadImgFile(IMAGES_DIR "mjgirl3c.jpg");
   m_imgGirls[3][GIRL_COLOR] = LoadImgFile(IMAGES_DIR "mjgirl4b.jpg");
   m_imgGirls[3][GIRL_GRAYSTYLE] = UTIL_GrayStyle(m_imgGirls[3][GIRL_COLOR]);
   m_imgGirls[3][GIRL_FULL] = LoadImgFile(IMAGES_DIR "mjgirl4c.jpg");

   m_imgElectron = LoadImgFile(IMAGES_DIR "electron.jpg");
   m_imgGameOver = LoadImgFile(IMAGES_DIR "gameover.jpg");
   m_imgTiles = LoadImgFile(IMAGES_DIR "tiles.jpg");

   m_imgBonusGame = LoadImgFile(IMAGES_DIR "bgame.jpg");

   m_imgFire1 = LoadImgFile(IMAGES_DIR "fire1.bmp");
   m_imgFire2 = LoadImgFile(IMAGES_DIR "fire2.bmp");
   m_imgFlash1 = LoadImgFile(IMAGES_DIR "flash1.bmp");
   m_imgFlash2 = LoadImgFile(IMAGES_DIR "flash2.bmp");
   m_imgHand = LoadImgFile(IMAGES_DIR "hand.bmp");

   SDL_SetColorKey(m_imgFire1, SDL_SRCCOLORKEY, SDL_MapRGBA(m_imgFire1->format, 98, 101, 98, 0));
   SDL_SetColorKey(m_imgFire2, SDL_SRCCOLORKEY, SDL_MapRGBA(m_imgFire2->format, 98, 101, 98, 0));
   SDL_SetColorKey(m_imgFlash1, SDL_SRCCOLORKEY, SDL_MapRGBA(m_imgFlash1->format, 98, 101, 98, 0));
   SDL_SetColorKey(m_imgFlash2, SDL_SRCCOLORKEY, SDL_MapRGBA(m_imgFlash2->format, 98, 101, 98, 0));
   SDL_SetColorKey(m_imgHand, SDL_SRCCOLORKEY, SDL_MapRGBA(m_imgHand->format, 98, 101, 98, 0));
}

void CGeneral::DeleteImages()
{
   SDL_FreeSurface(m_imgGirls[0][GIRL_GRAYSTYLE]);
   SDL_FreeSurface(m_imgGirls[0][GIRL_COLOR]);
   SDL_FreeSurface(m_imgGirls[0][GIRL_FULL]);
   SDL_FreeSurface(m_imgGirls[1][GIRL_GRAYSTYLE]);
   SDL_FreeSurface(m_imgGirls[1][GIRL_COLOR]);
   SDL_FreeSurface(m_imgGirls[1][GIRL_FULL]);
   SDL_FreeSurface(m_imgGirls[2][GIRL_GRAYSTYLE]);
   SDL_FreeSurface(m_imgGirls[2][GIRL_COLOR]);
   SDL_FreeSurface(m_imgGirls[2][GIRL_FULL]);
   SDL_FreeSurface(m_imgGirls[3][GIRL_GRAYSTYLE]);
   SDL_FreeSurface(m_imgGirls[3][GIRL_COLOR]);
   SDL_FreeSurface(m_imgGirls[3][GIRL_FULL]);

   SDL_FreeSurface(m_imgGameOver);
   SDL_FreeSurface(m_imgTiles);

   SDL_FreeSurface(m_imgBonusGame);
   SDL_FreeSurface(m_imgFire1);
   SDL_FreeSurface(m_imgFire2);
}

void CGeneral::LoadFonts()
{
   // Small fonts
   m_fontKai = LoadFontFile(FONTS_DIR "gkai00mp.ttf", 24); // Chinese fonts (Kai Ti)
   m_fontBrush = LoadFontFile(FONTS_DIR "brush.ttf", 24); // English/Number fonts

   // Large fonts
   m_fontKaiL = LoadFontFile(FONTS_DIR "gkai00mp.ttf", 36); // Chinese fonts (Kai Ti)
   m_fontBrushL = LoadFontFile(FONTS_DIR "brush.ttf", 36); // English/Number fonts

   // Huge fonts
   m_fontKaiH = LoadFontFile(FONTS_DIR "gkai00mp.ttf", 72); // Chinese fonts (Kai Ti)
   m_fontBrushH = LoadFontFile(FONTS_DIR "brush.ttf", 72); // English/Number fonts
}

void CGeneral::DeleteFonts()
{
   TTF_CloseFont(m_fontKai);
   TTF_CloseFont(m_fontBrush);
   TTF_CloseFont(m_fontKaiL);
   TTF_CloseFont(m_fontBrushL);
   TTF_CloseFont(m_fontKaiH);
   TTF_CloseFont(m_fontBrushH);
}

void CGeneral::LoadMusic()
{
   if (g_fNoMusic) {
      return;
   }

   m_musBG[0] = LoadMusicFile(MUSIC_DIR "music.ogg");
   m_musBG[1] = LoadMusicFile(MUSIC_DIR "music1.ogg");
   m_musBG[2] = LoadMusicFile(MUSIC_DIR "musicc.ogg");
   m_musBG[3] = LoadMusicFile(MUSIC_DIR "musicp.ogg");
   m_musBG[4] = LoadMusicFile(MUSIC_DIR "bet.ogg");
   m_musBG[5] = LoadMusicFile(MUSIC_DIR "bonus.ogg");
   m_musBG[6] = LoadMusicFile(MUSIC_DIR "musicb.ogg");

   m_musGameOver = LoadMusicFile(MUSIC_DIR "gameover.ogg");
   m_musWin = LoadMusicFile(MUSIC_DIR "win.ogg");
   m_musEndRound = LoadMusicFile(MUSIC_DIR "musice.ogg");
   m_musBGame = LoadMusicFile(MUSIC_DIR "bgame.ogg");

}

void CGeneral::DeleteMusic()
{
   if (g_fNoMusic) {
      return;
   }

   Mix_FreeMusic(m_musBG[0]);
   Mix_FreeMusic(m_musBG[1]);
   Mix_FreeMusic(m_musBG[2]);
   Mix_FreeMusic(m_musBG[3]);
   Mix_FreeMusic(m_musBG[4]);
   Mix_FreeMusic(m_musBG[5]);
   Mix_FreeMusic(m_musBG[6]);

   Mix_FreeMusic(m_musGameOver);
   Mix_FreeMusic(m_musWin);
   Mix_FreeMusic(m_musEndRound);
   Mix_FreeMusic(m_musBGame);
}

void CGeneral::LoadSound()
{
   if (g_fNoSound) {
      return;
   }

   m_snd[SND_DISCARD1] = LoadSoundFile(SOUND_DIR "discard.wav");
   m_snd[SND_DISCARD2] = LoadSoundFile(SOUND_DIR "discard2.wav");
   m_snd[SND_DING] = LoadSoundFile(SOUND_DIR "ding.wav");
   m_snd[SND_SOUND1] = LoadSoundFile(SOUND_DIR "snd1.wav");
   m_snd[SND_SOUND2] = LoadSoundFile(SOUND_DIR "snd2.wav");
   m_snd[SND_SOUND3] = LoadSoundFile(SOUND_DIR "snd3.wav");
   m_snd[SND_SOUND4] = LoadSoundFile(SOUND_DIR "snd4.wav");
   m_snd[SND_REACH] = LoadSoundFile(SOUND_DIR "reach.wav");

   m_snd[SND_BOOM] = LoadSoundFile(SOUND_DIR "boom.wav");
   m_snd[SND_FLASH] = LoadSoundFile(SOUND_DIR "flash.wav");
   m_snd[SND_FIRE] = LoadSoundFile(SOUND_DIR "fire.wav");
}

void CGeneral::DeleteSound()
{
   if (g_fNoSound) {
      return;
   }

   Mix_FreeChunk(m_snd[SND_DISCARD1]);
   Mix_FreeChunk(m_snd[SND_DISCARD2]);
   Mix_FreeChunk(m_snd[SND_DING]);
   Mix_FreeChunk(m_snd[SND_SOUND1]);
   Mix_FreeChunk(m_snd[SND_SOUND2]);
   Mix_FreeChunk(m_snd[SND_SOUND3]);
   Mix_FreeChunk(m_snd[SND_SOUND4]);
   Mix_FreeChunk(m_snd[SND_REACH]);
   Mix_FreeChunk(m_snd[SND_BOOM]);
   Mix_FreeChunk(m_snd[SND_FLASH]);
   Mix_FreeChunk(m_snd[SND_FIRE]);
}

SDL_Surface *CGeneral::LoadImgFile(const char *filename)
{
   SDL_Surface *pic = IMG_Load(filename);

   if (pic == NULL) {
      TerminateOnError("Cannot load Image file %s: %s", filename, SDL_GetError());
   }

   return pic;
}

TTF_Font *CGeneral::LoadFontFile(const char *filename, int size)
{
   TTF_Font *f = TTF_OpenFont(filename, size);

   if (f == NULL) {
      TerminateOnError("Cannot load font file %s (%dpt): %s",
         filename, size, SDL_GetError());
   }

   return f;
}

Mix_Music *CGeneral::LoadMusicFile(const char *filename)
{
   if (g_fNoMusic) {
      return NULL;
   }

   Mix_Music *m = Mix_LoadMUS(filename);

   if (m == NULL) {
      TerminateOnError("Cannot load music file %s: %s",
         filename, SDL_GetError());
   }

   return m;
}

Mix_Chunk *CGeneral::LoadSoundFile(const char *filename)
{
   if (g_fNoSound) {
      return NULL;
   }

   Mix_Chunk *s = Mix_LoadWAV(filename);

   if (s == NULL) {
      TerminateOnError("Cannot load sound file %s: %s",
         filename, SDL_GetError());
   }

   return s;
}

void CGeneral::InitCursor()
{
   char cursor_data[22 + 1][18 + 1] = {
      "*****  ***********",
      "**** )) **********",
      "**** )) **********",
      "**** )) **********",
      "**** )) **********",
      "**** ))   ********",
      "**** )) ))   *****",
      "**** )) )) ))  ***",
      "**** )) )) )) ) **",
      "   ) )) )) )) )) *",
      " ))  )))))))) )) *",
      " ))) ))))))))))) *",
      "* )) ))))))))))) *",
      "** ) ))))))))))) *",
      "** ))))))))))))) *",
      "*** )))))))))))) *",
      "*** ))))))))))) **",
      "**** )))))))))) **",
      "**** )))))))))) **",
      "***** )))))))) ***",
      "***** )))))))) ***",
      "*****          ***"
   };

   unsigned char data[24 * 3], mask[24 * 3];

   int i, j, index = -1;

   for (i = 0; i < 24 * 3; i++) {
      data[i] = mask[i] = 0;
   }

   for (i = 0; i < 22; i++) {
      for (j = 0; j < 24; j++) {
         if (j % 8 != 0) {
            data[index] <<= 1;
            mask[index] <<= 1;
         } else {
            index++;
         }

         if (j >= 18) {
            continue;
         }

         switch (cursor_data[i][j]) {
            case ')':
               mask[index] |= 1;
               break;

            case ' ':
               data[index] |= 1;
               mask[index] |= 1;
               break;
         }
      }
   }

   m_HandCursor = SDL_CreateCursor(data, mask, 24, 24, 0, 0);
   SDL_SetCursor(m_HandCursor);
}

void CGeneral::DeleteCursor()
{
   SDL_FreeCursor(m_HandCursor);
}