Пример #1
0
  Menu   *
menu_new (MenuItems items,IIM_Surface * selimage)
{
  Menu   *m = (Menu *)malloc (sizeof (Menu));

  m->items = items;

  m->nb_items = 0;
  while (items[m->nb_items++].name);

  m->sep_size = 20;							// taille d'un separateur.

  m->active_item = -1;
  m->sound_move = m->sound_valid = NULL;

  m->visible = m->appears = m->hide = 0;
  menu_update_hauteur (m);

  menu_next_item (m);

  
  m->menuselector = selimage;;
      
  return m;
}
Пример #2
0
void PuyoCommander::optionMenuLoop(PuyoDrawable *d)
{
  menu_show(optionMenu);
  while (1) {
    SDL_Event e;

    while (SDL_PollEvent (&e)) {
      GameControlEvent controlEvent;
      getControlEvent(e, &controlEvent);

      switch (controlEvent.cursorEvent) {
        case GameControlEvent::kQuit:
          exit(0);
          goto mml_fin;
          break;
        case GameControlEvent::kUp:
          menu_prev_item (optionMenu);
          break;
        case GameControlEvent::kDown:
          menu_next_item (optionMenu);
          break;
        case GameControlEvent::kStart:
          menu_validate (optionMenu);
          if (menu_active_is (optionMenu, "Back"))
            goto mml_fin;
          if (menu_active_is (optionMenu, kFullScreen)) {
            fullscreen  = menu_switch_on_off(optionMenu, kFullScreen);
            SetBoolPreference(kFullScreen,fullscreen);
            if (useGL)
            {
              menu_hide(optionMenu);
              backLoop(mustRestartMenu,d);
              menu_show(optionMenu);
            }
            else
            {
#ifdef _WIN32
                menu_hide(optionMenu);
                backLoop(mustRestartMenu,d);
                menu_show(optionMenu);
#else
                SDL_QuitSubSystem(SDL_INIT_VIDEO);
                SDL_InitSubSystem(SDL_INIT_VIDEO);
                display = SDL_SetVideoMode(320, 240, 0,
                                           SDL_SWSURFACE
                                           |(fullscreen?SDL_FULLSCREEN:0));
#endif
              /* IIM_ReConvertAll();
              SoFont_Refresh(menuFont);
              SoFont_Refresh(smallFont);
              SoFont_Refresh(darkFont); */
            }
          }
          if (menu_active_is (optionMenu, kOpenGL)) {
            bool useGL2 = menu_switch_on_off(optionMenu, kOpenGL);
            SetBoolPreference(kOpenGL,useGL2);
            menu_hide(optionMenu);
            backLoop(mustRestartMenu,d);
            menu_show(optionMenu);
          }
          if (menu_active_is (optionMenu, kMusic)) {
            sound = menu_switch_on_off(optionMenu, kMusic);
            SetBoolPreference(kMusic,sound);
            audio_set_music_on_off(sound);
            if (sound) audio_music_start(0);
          }
          if (menu_active_is (optionMenu, kAudioFX)) {
            fx = menu_switch_on_off(optionMenu, kAudioFX);
            SetBoolPreference(kAudioFX,fx);
            audio_set_sound_on_off(fx);
          }
          if (menu_active_is (optionMenu, kControls)) {
            menu_hide (optionMenu);
            controlsMenuLoop(d);
            menu_show(optionMenu);
          }
          break;
        case GameControlEvent::kBack:
          goto mml_fin;
          break;
        default:
          break;
      }
    }

    updateAll(d);
  }
mml_fin:
  menu_hide (optionMenu);
}
Пример #3
0
void PuyoCommander::controlsMenuLoop(PuyoDrawable *d)
{
  char newKeyName[250];

  getKeyName(kPlayer1LeftControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer1Left, newKeyName,0);
  getKeyName(kPlayer1RightControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer1Right, newKeyName,0);
  getKeyName(kPlayer1DownControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer1Down, newKeyName,0);
  getKeyName(kPlayer1ClockwiseControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer1Clockwise, newKeyName,0);
  getKeyName(kPlayer1CounterclockwiseControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer1Counterclockwise, newKeyName,0);


  getKeyName(kPlayer2LeftControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer2Left, newKeyName,0);
  getKeyName(kPlayer2RightControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer2Right, newKeyName,0);
  getKeyName(kPlayer2DownControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer2Down, newKeyName,0);
  getKeyName(kPlayer2ClockwiseControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer2Clockwise, newKeyName,0);
  getKeyName(kPlayer2CounterclockwiseControl, newKeyName);
  menu_set_value(controlsMenu, kPlayer2Counterclockwise, newKeyName,1);


  menu_show(controlsMenu);
  while (1) {
    SDL_Event e;

    while (SDL_PollEvent (&e)) {
      char *chosenControl = NULL;
      int chosenControlIndex;
      GameControlEvent controlEvent;
      getControlEvent(e, &controlEvent);

      switch (controlEvent.cursorEvent) {
        case GameControlEvent::kQuit:
          exit(0);
          goto mml_fin;
          break;
        case GameControlEvent::kUp:
          menu_prev_item (controlsMenu);
          break;
        case GameControlEvent::kDown:
          menu_next_item (controlsMenu);
          break;
        case GameControlEvent::kStart:
          menu_validate (controlsMenu);
          if (menu_active_is (controlsMenu, "Back"))
            goto mml_fin;

          if (menu_active_is (controlsMenu, kPlayer1Left)) {
            chosenControl = kPlayer1Left;
            chosenControlIndex = kPlayer1LeftControl;
          }
          if (menu_active_is (controlsMenu, kPlayer1Right)) {
            chosenControl = kPlayer1Right;
            chosenControlIndex = kPlayer1RightControl;
          }
          if (menu_active_is (controlsMenu, kPlayer1Down)) {
            chosenControl = kPlayer1Down;
            chosenControlIndex = kPlayer1DownControl;
          }
          if (menu_active_is (controlsMenu, kPlayer1Clockwise)) {
            chosenControl = kPlayer1Clockwise;
            chosenControlIndex = kPlayer1ClockwiseControl;
          }
          if (menu_active_is (controlsMenu, kPlayer1Counterclockwise)) {
            chosenControl = kPlayer1Counterclockwise;
            chosenControlIndex = kPlayer1CounterclockwiseControl;
          }

          if (menu_active_is (controlsMenu, kPlayer2Left)) {
            chosenControl = kPlayer2Left;
            chosenControlIndex = kPlayer2LeftControl;
          }
          if (menu_active_is (controlsMenu, kPlayer2Right)) {
            chosenControl = kPlayer2Right;
            chosenControlIndex = kPlayer2RightControl;
          }
          if (menu_active_is (controlsMenu, kPlayer2Down)) {
            chosenControl = kPlayer2Down;
            chosenControlIndex = kPlayer2DownControl;
          }
          if (menu_active_is (controlsMenu, kPlayer2Clockwise)) {
            chosenControl = kPlayer2Clockwise;
            chosenControlIndex = kPlayer2ClockwiseControl;
          }
          if (menu_active_is (controlsMenu, kPlayer2Counterclockwise)) {
            chosenControl = kPlayer2Counterclockwise;
            chosenControlIndex = kPlayer2CounterclockwiseControl;
          }

          if (chosenControl != NULL) {
            char prevValue[255];
            strcpy(prevValue, menu_get_value (controlsMenu, chosenControl));
            menu_set_value(controlsMenu, chosenControl, "<Choose>");
            if (changeControlLoop(chosenControlIndex, d)) {
              getKeyName(chosenControlIndex, newKeyName);
              menu_set_value(controlsMenu, chosenControl, newKeyName);
              menu_next_item (controlsMenu);
            }
            else {
              menu_set_value(controlsMenu, chosenControl, prevValue);
            }
          }
          break;
        case GameControlEvent::kBack:
          goto mml_fin;
          break;
        default:
          break;
      }
    }

    updateAll(d);
  }
mml_fin:
  saveControls();
  menu_hide (controlsMenu);
}
Пример #4
0
void PuyoCommander::run()
{
    Menu   *menu = mainMenu;

    cycle = 0;
    lastRenderedCycle = 0;
    maxFrameDrop = 10;

    start_time = SDL_GetTicks ();

    audio_music_start (0);

    /*  PuyoStory *introStory = new PuyoStory(this, 0);
    introStory->loop();
    delete introStory; */

    menu_show (menu);

    while (1) {
        SDL_Event e;

        while (SDL_PollEvent (&e)) {
            GameControlEvent controlEvent;
            getControlEvent(e, &controlEvent);

            switch (controlEvent.cursorEvent) {
                case GameControlEvent::kQuit:
                    goto mml_fin;
                    break;
                case GameControlEvent::kDown:
                    menu_next_item (menu);
                    break;
                case GameControlEvent::kUp:
                    menu_prev_item (menu);
                    break;
                case GameControlEvent::kStart:
                    menu_validate (menu);
                    if (menu_active_is (menu, "Quit"))
                        goto mml_fin;
                    if (menu_active_is (menu, "Options")) {
                        menu_hide (menu);
                        optionMenuLoop(NULL);
                        menu_show (menu);
                    }
                    if (menu_active_is (menu, kHighScores)) {
                        menu_hide(menu);
                        updateHighScoresMenu();
                        backLoop(highScoresMenu);
                        menu_show(menu);
                    }
                    if (menu_active_is (menu, "Rules")) {
                        menu_hide(menu);
                        backLoop(rulesMenu);
                        menu_show(menu);
                    }
                    if (menu_active_is (menu, "About FloboPuyo")) {
                        menu_hide(menu);
                        backLoop(aboutMenu);
                        menu_show(menu);
                    }
                    if (menu_active_is (menu, SINGLE_PLAYER_GAME)) {
                        menu_hide (menu);
                        startSingleGameLoop();
                        menu_show (menu);
                    }
                    if (menu_active_is (menu, TWO_PLAYERS_GAME)) {
                        menu_hide (menu);
                        startTwoPlayerGameLoop();
                        menu_show (menu);
                        audio_music_start(0);
                    }
                    break;
                case GameControlEvent::kBack:
                    goto mml_fin;
                    break;
                default:
                    break;
            }
        }
    updateAll(NULL);
  }
mml_fin:
  menu_hide (menu);
}
Пример #5
0
void PuyoCommander::startSingleGameLoop()
{
  char playerName[256];

    char * defaultName = getenv("USER");
    if (defaultName == NULL)
      defaultName = "Player";
    if (!(defaultName[0]>=32))
      defaultName = "Player";
    if ((defaultName[0]>='a') && (defaultName[0]<='z'))
      defaultName[0] += 'A' - 'a';

  GetStrPreference("Player Name", playerName, defaultName);
  menu_set_value(singleGameMenu, kPlayerName, playerName, 0);

  while (!menu_active_is(singleGameMenu,kLevelMedium))
    menu_next_item(singleGameMenu);

  menu_show(singleGameMenu);
  while (1) {
    SDL_Event e;

    while (SDL_PollEvent (&e)) {
      GameControlEvent controlEvent;
        getControlEvent(e, &controlEvent);
        switch (controlEvent.cursorEvent) {
            case GameControlEvent::kQuit:
                exit(0);
                break;
            case GameControlEvent::kDown:
                menu_next_item (singleGameMenu);
                break;
            case GameControlEvent::kUp:
                menu_prev_item (singleGameMenu);
                break;
            case GameControlEvent::kStart:
                menu_validate (singleGameMenu);
                if (menu_active_is(singleGameMenu,kPlayerName))
                  enterStringLoop(singleGameMenu,kPlayerName,playerName);
                else
                  goto mml_play;
                break;
            case GameControlEvent::kBack:
                menu_hide(singleGameMenu);
                return;
                break;
        }
    }
    updateAll(NULL);
  }

mml_play:
  menu_hide (singleGameMenu);

  SelIA ia1[] = { {RANDOM, 350}, {FLOBO, 350}, {FLOBO, 250}, {FLOBO, 180}, {FLOBO,  90}, {JEKO, 350}, {TANIA, 320}, {FLOBO, 62}, {RANDOM,0} };
  SelIA ia2[] = { {FLOBO,  190}, {JEKO , 180}, {TANIA, 160}, {FLOBO,  90}, {GYOM , 210}, {TANIA, 90}, {JEKO,   80}, {GYOM,  90}, {RANDOM,0} };
  SelIA ia3[] = { {TANIA,  130}, {JEKO , 100}, {GYOM ,  90}, {JEKO,   80}, {TANIA,  60}, {GYOM,  60}, {GYOM,   40}, {GYOM,  30}, {RANDOM,0} };

  SelIA *ia = &(ia1[0]);

  gameLevel = 1;
  GAME_ACCEL = 2000;
  if (menu_active_is (singleGameMenu, kLevelMedium)) {
    ia = &(ia2[0]);
    GAME_ACCEL = 1500;
    gameLevel = 2;
  }
  else if (menu_active_is (singleGameMenu, kLevelHard)) {
    ia = &(ia3[0]);
    GAME_ACCEL = 1000;
    gameLevel = 3;
  }

  int score1 = 0;
  int score2 = 0;
  int lives  = 3;
  if (menu_active_is(finishedMenu,  "NO"))
    menu_next_item(finishedMenu);
  if (menu_active_is(looserMenu   ,  "NO"))
    menu_next_item(looserMenu);
  if (menu_active_is(nextLevelMenu,  "NO"))
    menu_next_item(nextLevelMenu);
  if (menu_active_is(gameOver2PMenu, "NO"))
    menu_next_item(gameOver2PMenu);
  gameOverMenu = nextLevelMenu;

  int lastPoints = 0;
  int currentMusicTheme = 0;

  int fini = 0;
  while (!fini)
  {
    PuyoStory myStory(this, score2+1);
    myStory.loop();
    PuyoStarter myStarter(this, true, ia[score2].level, ia[score2].type, currentMusicTheme);
    p1name = playerName;
    p2name = AI_NAMES[score2];
    doom_melt_start(melt, menuBGImage);
    audio_music_switch_theme(currentMusicTheme);
    myStarter.run(score1, score2, lives, lastPoints, 0);
    lastPoints = myStarter.rightPlayerPoints();
    score1 += myStarter.leftPlayerWin();
    score2 += myStarter.rightPlayerWin();
    if (!myStarter.rightPlayerWin())
      lives--;
    else {
      currentMusicTheme = (currentMusicTheme + 1) % NB_MUSIC_THEME;
    }

    if (ia[score2].level == 0) {
      lastPoints += 100000;
      if (menu_active_is (singleGameMenu, kLevelMedium))
        lastPoints += 150000;
      if (menu_active_is (singleGameMenu, kLevelHard))
        lastPoints += 250000;
      fini = 1;
    }

    if (!(menu_active_is(gameOverMenu, "YES") && (lives >= 0)))
      fini = 1;

    if (fini)
    {
      audio_music_start(0);
      doom_melt_start(melt, gameScreen);
      int newOne = setHiScore(lastPoints, p1name);
      if (newOne >= 0)
      {
        updateHighScoresMenu(newOne);
        backLoop(highScoresMenu, NULL);
      }
    }
  }
  SetStrPreference("Player Name", playerName);
}
Пример #6
0
void PuyoCommander::startTwoPlayerGameLoop()
{
  char player1Name[256];
  char player2Name[256];

  GetStrPreference("Player1 Name", player1Name, "Player 1");
  GetStrPreference("Player2 Name", player2Name, "Player 2");
  menu_set_value(twoPlayerGameMenu, kPlayer1Name, player1Name, 0);
  menu_set_value(twoPlayerGameMenu, kPlayer2Name, player2Name, 0);

  while (!menu_active_is(twoPlayerGameMenu,kLevelMedium))
    menu_next_item(twoPlayerGameMenu);

  menu_show(twoPlayerGameMenu);
  while (1) {
    SDL_Event e;

    while (SDL_PollEvent (&e)) {
      GameControlEvent controlEvent;
        getControlEvent(e, &controlEvent);
        switch (controlEvent.cursorEvent) {
            case GameControlEvent::kQuit:
                exit(0);
                break;
            case GameControlEvent::kDown:
                menu_next_item (twoPlayerGameMenu);
                break;
            case GameControlEvent::kUp:
                menu_prev_item (twoPlayerGameMenu);
                break;
            case GameControlEvent::kStart:
                menu_validate (twoPlayerGameMenu);
                if (menu_active_is(twoPlayerGameMenu,kPlayer2Name)) {
                  enterStringLoop(twoPlayerGameMenu,kPlayer2Name,player2Name);
                  menu_next_item (twoPlayerGameMenu);
                }
                else if (menu_active_is(twoPlayerGameMenu,kPlayer1Name)) {
                  enterStringLoop(twoPlayerGameMenu,kPlayer1Name,player1Name);
                  menu_next_item (twoPlayerGameMenu);
                }
                else
                  goto mml_play;
                break;
            case GameControlEvent::kBack:
                menu_hide(twoPlayerGameMenu);
                return;
                break;
        }
    }
    updateAll(NULL);
  }

mml_play:
  menu_hide (twoPlayerGameMenu);

  GAME_ACCEL = 2000;
  gameLevel = 1;
  if (menu_active_is (twoPlayerGameMenu, kLevelMedium)) {
    GAME_ACCEL = 1500;
    gameLevel = 2;
  }
  else if (menu_active_is (twoPlayerGameMenu, kLevelHard)) {
    GAME_ACCEL = 1000;
    gameLevel = 3;
  }

  int score1 = 0;
  int score2 = 0;
  gameOverMenu = gameOver2PMenu;
  int currentMusicTheme = 0;
  if (menu_active_is(gameOverMenu, "NO"))
    menu_next_item(gameOverMenu);
  while (menu_active_is(gameOverMenu, "YES")) {
    menu_next_item(gameOverMenu);
    PuyoStarter myStarter(this,false,0,RANDOM,currentMusicTheme);
    audio_music_switch_theme(currentMusicTheme);
    p1name = player1Name;
    p2name = player2Name;
    GAME_ACCEL = 1500;
    doom_melt_start(melt, menuBGImage);
    myStarter.run(score1, score2, 0, 0, 0);
    score1 += myStarter.leftPlayerWin();
    score2 += myStarter.rightPlayerWin();
    currentMusicTheme = (currentMusicTheme + 1) % NB_MUSIC_THEME;
  }

  SetStrPreference("Player1 Name", player1Name);
  SetStrPreference("Player2 Name", player2Name);
  doom_melt_start(melt, gameScreen);
}