xrally/xrally/menu.c

/***************************************************************************
                          menu.c  -  description
                             -------------------
    begin                : Sat Jan 15 2000
    copyright            : (C) 2000 by Perdig
    email                : perdig@linuxbr.com.br

    $Id: menu.c,v 1.23 2001/01/11 15:28:03 perdig Exp $
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "config.h"
#include "menu.h"
#include "graphics.h"
#include "effects.h"
#include "game.h"
#include "level.h"
#include "score.h"
#include "dirent.h"
#ifdef USE_SOUND
#include "sound.h"
#endif
#include "limits.h"
#include <stdio.h>
#include <string.h>

#define MENU_WINDOW_WIDTH (480 + 128)
#define MENU_WINDOW_HEIGHT (480)

//#include "images/logo.xpm"
//#include "images/logocar.xpm"
//
/* Menu screen geometry
 *  <---------- 614 --------->
 * |-------------------------| /\
 * ||-----|         |------| | ||
 * ||     |         |      | | ||
 * ||menu |         |      | | ||
 * ||-----|         | help | |
 * |                |      | | 482
 * |                |------| |
 * |                         | ||
 * |                         | ||
 * |                         | ||
 * |                         | ||
 * |                         | ||
 * |                         | \/
 * ---------------------------
 * menu_window -> x = 10
 *                y = 10
 *                w = max textwidth + 32 + 8 + 2
 *                h = (textheight+pad)*len + 8
 *
 * menu_text   -> x = 10 + 4 + 32 + 2
 *                y = 10 + 4
 *                w = max textwidth
 *                h = max textheight
 *
 * help_window -> x = 614 - w - 10
 *                y = 10
 *                w = max textwidth + 8
 *                h = max textheight + 8
 *
 * help_text   -> x = 614 - w - 10 + 4
 *                y = 10 + 4
 *                w = textwidth
 *                h = textheight
 *
 * cursor      -> x = 10
 *                y = 10 + (textheight+pad)*(pos+0.5) - CAROFF
 *                w = 32
 *                h = 32
 *
 * Splash Screen geometry
 *
 *  <---------- 614 --------->
 * |-------------------------| /\
 * ||------------|  |-------|| ||
 * || info win   |  |       || ||
 * ||------------|  | level || ||
 * |                |       ||
 * |                | desc  || 482
 * |                |       ||
 * ||----------|    |       || ||
 * || help win |    |       || ||
 * ||----------|    |-------|| ||
 * |                         | ||
 * ||----  progress bar  ---|| ||
 * |                         | \/
 * ---------------------------
 *
 * progress bar: x = 10
 *               y = 482 - 10 - h
 *               h = 32
 *               w = 614 - 10 - 10
 *
 * level desc:   x = 614 - w - 10
 *               y = 10
 *               w = textwidth + 8
 *               h = textheight + 8
 *
 * level desc text: x = 614 - w - 10 + 4
 *                  y = 10 + 4
 *                  w = textwidth
 *                  h = textheight
 *
 * info win: x = 10
 *           y = 10
 *           w = textwidth + 8
 *           h = textheight + 8
 *
 * info win text: x = 10 + 4
 *                y = 10 + 4
 *                w = textwidth
 *                h = textheight
 *
 * help win: x = 10
 *           y = level desc y + level desc h - h
 *           w = textwidth + 8
 *           h = textheight + 8
 *
 * help win text: x = help win x + 4
 *                y = help win y + 4
 *                w = textwidth
 *                h = textheight
 */

#define splText(TEXT) do { \
  draw_window(40, 179, 365, 12 + text_height(FONT_BIG) + 12); \
  text(dbuffer(), 52, 191, TEXT, get_color(COLOR_TEXT), FONT_BIG); } while (0)

#define splText2(TEXT) do { \
  draw_window(95, 25 + 144 + 5 + 30, 430, 100); \
  text(dbuffer(), 102, 239, TEXT, get_color(COLOR_TEXT), FONT_BIG); } while (0)

Pixmap logo;
Pixmap logocar[2];
Pixmap logocar_mask[2];
GC bufGC;
GC dbufGC;

// Score struct
extern scoreStruct score;

// Splash struct
struct splash_struct spl;

// Help and Info text
static char info[512];

static char game_help[] = "*Game control*\nArrow keys: Move the car around\nSpace bar: Use smoke\nEscape: Quit level";

static char menu_help[] = "*Menu control*\n\nArrow keys\n  Move the cursor around\nEnter key\n  Select an option\nESC key\n  Return to previous screen\n";

// Size of sprite
extern int SPRITE_SIZE;
extern int TILE_WIDTH;
extern int TILE_HEIGHT;

// Blend cache
blend_cache_t blend_cache;

char *chooseLevel() {
  struct dirent **dirlist = NULL;
  char **options = NULL;
  char **info = NULL;
  int levNum;
  int n = 0, m = 0;

  // Search the dir
  n = scandir("./maps", &dirlist, 0, alphasort);
  if (n <= 0) {
    hdbg("Can't find the maps directory");
    return NULL;
  }
  // Create the string list
  // Allocate memory
  options = (char **)calloc(n, sizeof(char *));
  while (n--) {
    if (*dirlist[n]->d_name != '.' && strcmp(dirlist[n]->d_name, "CVS") != 0) {
      options[m] = dirlist[n]->d_name;
      m++;
    }
  }

  // Create the info list
  info = (char **)calloc(m, sizeof(char *));
  for (n = 0; n < m; n++) {
    info[n] = levelDescription(options[n]);
  }

  levNum = create_menu(options, info, m);

  for (n = 0; n < m; n++) {
    free(info[n]);
  }

  if (levNum == 255)
    return NULL;
  else
    return options[levNum];
}

int chooseMap(int num) {
  char **maps;
  int a, len, cmd;
  maps = (char **)calloc(num, sizeof(char *));
  if (num < 10)
    len = 1;
  else if (num < 100)
    len = 2;
  else
    len = 3;
  for (a = 0; a < num; a++) {
    maps[a] = (char *)malloc(sizeof(char) * len);
    sprintf(maps[a], "%d", a+1);
  }
  cmd = create_menu(maps, NULL, num);
  if (cmd == 255)
    return -1;
  else
    return cmd;
}

void endScreen(levelStruct *level, int oldscore, int mode) {
  char msg[512];
  int pos = -1;
  char *name;
  int x = (WINDOW_WIDTH - 134)/2 - 175;
  int y = (WINDOW_HEIGHT - 2)/2 - 65;
  XImage *clean_window;

  // Victory message
  if (mode == VICTORY) {
    sprintf(msg, "Congratulations!\nYou won the %s!\n"
      "Regular score: %9d\n"
      "Winning bonus: %9d\n"
      "Total:         %9d",
    level->name, oldscore, score.value-oldscore, score.value);
  }

  // Game over message
  if (mode == GAME_OVER) {
    sprintf(msg, "That's too bad! You lost!\n"
      "Better luck next time!\n"
      "Regular score: %9d\n"
      "Winning bonus: %9d\n"
      "Total:         %9d",
    oldscore, score.value-oldscore, score.value);
  }

  clean_window = get_image(dbuffer(), x, y, 350, 130);

  // Draw window
  draw_window( x, y, 350, 130);
  // Draw text
  text(dbuffer(), x+12, y+12, msg, get_color(COLOR_TEXT), FONT_FIXED);
  graphics_sync();
  wait_key();


  // Now checks for the hiscore!
  if (level->map && newRecord(level, &score)) {
    ldbg("You got a new record!");
    sound_select (16);
    sound_volume (64);
    sound_start ();
    // Clean up
    i_blit(clean_window, dbuffer(), x, y, 350, 130);
    name = getName();
    if (name != NULL && *name != 0)
      pos = addRecord(level, &score, name);
  }

  // Puts the window backs to its original size
  if (WINDOW_WIDTH != MENU_WINDOW_WIDTH || WINDOW_HEIGHT != MENU_WINDOW_HEIGHT) {
    resize_window(MENU_WINDOW_WIDTH, MENU_WINDOW_HEIGHT);
  }

  ldbg("Position: %d", pos);
  displayHiscores(pos, level, false);
  return;
}

char *getName() {
  int cmd = -1;
  char temp[3];
  char msg[256];
  char *name = (char *)malloc(256 * sizeof(char));
  int x = (WINDOW_WIDTH-134)/2 - 175;
  int y = (WINDOW_HEIGHT-2)/2 - 65;
  KeySym key;
  XImage *window_img;
  // If we don't do that, the window will get darker with
  // every keystroke!
  draw_window(x, y, 350, 130);
  window_img = get_image(dbuffer(), x, y, 350, 130);
  // Now window_img has a XImage of the window we want! How beautiful is that?
  strcpy(name, "");
  while (cmd < 0) {
    strcpy(msg, "Congratulations!\nYou made into the hiscores!\nPlease enter your name:");
    // Draw window
    i_blit(window_img, dbuffer(), x, y, 350, 130);
    text(dbuffer(), x+12, y+12, msg, get_color(COLOR_TEXT), FONT_FIXED);
    text(dbuffer(), x+12, y+22+3*text_height(FONT_FIXED), name, get_color("#BB0000"), FONT_FIXED);
    graphics_sync();
    /* Get the player name */
    key = wait_char(temp);
    if (key == XK_Return)
      break;
    if (key == XK_Escape)
      return NULL;
    if (key == XK_Delete || key == XK_BackSpace) {
      if (strlen(name) >= 1)
        name[ strlen(name)-1 ] = 0;
      continue;
    }
    if (temp)
      strcat(name, temp);
  }
  return name;
}

void initIntro() {
  //cleanScr();
  text(dbuffer(), MENU_WINDOW_WIDTH/2-50, MENU_WINDOW_HEIGHT/2, "Hold on...",
    get_color(COLOR_WHITE), FONT_BIG);
  graphics_sync();
  load_pixmap(&logocar[0], &logocar_mask[0], "images/logocar.xpm",
    NULL, NULL);
  graphics_sync();
  load_pixmap(&logocar[1], &logocar_mask[1], "images/logocar2.xpm",
    NULL, NULL);
  graphics_sync();
  load_pixmap(&logo, 0, "images/xrally.xpm", NULL, NULL );
  graphics_sync();
  strcpy(info, "");
}

void introAnim() {
  s_blit(logo, dbuffer(), 0, 0, 614, 484);
  wait_time(1000000); /* wait a few seconds so we can see the intro screen */
}

void showLogo() {
  //m_blit(logo, 0,  dbuffer(), dbufGC, 604, 144, 5, 5);
  //m_blit(logo, 0,  dbuffer(), dbufGC, 614, 484, 0, 0);
  blit(logo, dbuffer(), 0, 0, 614, 484);
}

#define CH (text_height(FONT_MEDIUM))
#define PADDING 4
#define CAROFF 18
void draw_cursor(int pos) {
  m_blit(logocar[0], logocar_mask[0], dbuffer(), 10 + 4 + 232*(pos/20), 14 + (CH+PADDING)*(2*(pos%20)+1)/2 - CAROFF, 32, 32);
}

void cleanScr() {
  rect(dbuffer(), 0, 0, MENU_WINDOW_WIDTH, MENU_WINDOW_HEIGHT, get_color(COLOR_BACK), 1);
}

int get_user_option() {
  int cmd = -1;
  char **options;
  char **help_msg;
  options = (char **)calloc(3, sizeof(char *));
  options[0] = (char *)malloc(16 * sizeof(char));
  options[1] = (char *)malloc(16 * sizeof(char));
  options[2] = (char *)malloc(16 * sizeof(char));
  help_msg = (char **)calloc(3, sizeof(char *));
  help_msg[0] = menu_help;
  help_msg[1] = menu_help;
  help_msg[2] = menu_help;
  strcpy(options[0], "New Game");
  strcpy(options[1], "View Hiscores");
  strcpy(options[2], "Exit");
  cmd = create_menu(options, help_msg, 3);
  if (cmd == 255)
    return 2;
  else
    return cmd;
}

int create_menu(char **options, char **info, int len) {
  int cmd = -1;
  int currentOption = 0;
  int cnt;
  XColor color;
  Pixmap menu_pixmap;
  Pixmap help_pixmap;
  XImage *help_image = NULL;
  XImage *old_menu_image = NULL;
  XImage *old_help_image = NULL;
  int menu_x, menu_y, menu_w, menu_h;
  int help_x, help_y, help_w, help_h, tmp_w, tmp_h;

  /* Geometry */
  // menu
  menu_x = 10;
  menu_y = 10;
  menu_w = 0;
  menu_h = 0;
  for (cnt = 0; cnt < len; cnt++) {
    text_rectangle(options[cnt], FONT_MEDIUM, &tmp_w, &tmp_h);
    if (tmp_w > menu_w)
      menu_w = tmp_w;
    if (tmp_h > menu_h)
      menu_h = tmp_h;
  }
  menu_w+=42 + (len/20)*(menu_w+PADDING);
  menu_h = (menu_h+PADDING)*(len>20?20:len) + 8;
  // help
  help_w = 0;
  help_h = 0;
  for (cnt = 0; cnt < len; cnt++) {
    if (info)
      text_rectangle(info[cnt], FONT_MEDIUM, &tmp_w, &tmp_h);
    else
      tmp_w = tmp_h = 0;
    if (tmp_w > help_w)
      help_w = tmp_w;
    if (tmp_h > help_h)
      help_h = tmp_h;
  }
  help_w+=8;
  help_h+=8;
  help_x = MENU_WINDOW_WIDTH - help_w - 10;
  help_y = 10;

  color.red = color.blue = color.green = 0;
  /* Creates the menu pixmap */
  menu_pixmap = create_pixmap(menu_w, menu_h);
  /* Background -> shaded image */
  i_blit( blend_image(logo, menu_x, menu_y, menu_w, menu_h, &blend_cache),
          menu_pixmap, 0, 0, menu_w, menu_h);
  /* Text -> options list */
  for (cnt = 0; cnt < len; cnt++) {
    text(menu_pixmap, 32 + 4 + 2, 4 + (text_height(FONT_MEDIUM)+PADDING)*cnt, options[cnt], get_color(COLOR_TEXT), FONT_MEDIUM);
  }
  /* Creates the help pixmap */
  help_pixmap = create_pixmap(help_w, help_h);
  /* Background -> shaded image */
  help_image = blend_image(logo, help_x , help_y, help_w, help_h, &blend_cache);
  i_blit( help_image, help_pixmap, 0, 0, help_w, help_h);
  /* Text -> infoText */
  if (info)
    text(help_pixmap, 4, 4, info[currentOption], get_color(COLOR_TEXT), FONT_MEDIUM);

  old_menu_image = get_image(logo, menu_x, menu_y, menu_w, menu_h);
  old_help_image = get_image(logo, help_x , help_y, help_w, help_h);

  s_blit(menu_pixmap, dbuffer(), menu_x, menu_y, menu_w, menu_h);
  s_blit(help_pixmap, dbuffer(), help_x, help_y, help_w, help_h);
  // Main loop
  while (cmd < 0) {
    cleanScr();
    showLogo();
    i_blit( help_image, help_pixmap, 0, 0, help_w, help_h);
    if (info)
      text(help_pixmap, 4, 4, info[currentOption], get_color(COLOR_TEXT), FONT_MEDIUM);
    blit(menu_pixmap, dbuffer(), menu_x, menu_y, menu_w, menu_h);
    blit(help_pixmap, dbuffer(), help_x, help_y, help_w, help_h);
    draw_cursor(currentOption);
    //optionList(menu_pixmap, options, len);
    graphics_sync();
    if (!userOption(&currentOption)) {
      cmd = currentOption;
    }
    currentOption = (currentOption < 0) ? 0 : currentOption;
    currentOption = (currentOption > (len-1)) ? (len-1) : currentOption;
  }
  ldbg("Cmd: %d", cmd);
  usi_blit(old_menu_image, dbuffer(), menu_x, menu_y, menu_w, menu_h);
  usi_blit(old_help_image, dbuffer(), help_x, help_y, help_w, help_h);
  return cmd;
}

void displayHiscores(int mark, levelStruct *level, bool loadAgain) {
  char *levelFile = NULL;
  char **lines;
  int num, a;
  int cmd = -1;
  int limit = 10;
  char pos[9] = "";
  int offset = 0;
  struct splash_struct splScr;
  XImage *blend_hiscores;
  XImage *old_blend_hiscores;
  if (loadAgain) {
    levelFile = chooseLevel();
    if (levelFile == NULL)
      return;
    sprintf(splScr.txt, "Loading hiscores for %s", levelFile);
    splScr.n = 9;
    splScr.mode = 2;
    splash(splScr, levelFile);
    if (!levelFile)
      return;
    if (!quickLoadLevel(level, levelFile)) {
      hdbg("Can't load level!");
      return;
    }
  }
  lines = listRecords(level);
  if (!lines) {
    ldbg("No record with that name!");
    num = 0;
  } else {
    num = (int)*lines[0];
  }
  if (num == 0) {
    ldbg("No record with that name!");
  }
  lines++;
  limit = (num < 10) ? num : 10;
  blend_hiscores = blend_image(logo, 5 - 3, 179 - 3, 600,
                  (limit != 0 ? limit * 30 : 30), &blend_cache);
  old_blend_hiscores = get_image(logo, 5 - 3, 179 - 3, 600,
                  (limit != 0 ? limit * 30 : 30));
  cleanScr();
  showLogo();
  graphics_sync();
  si_blit(blend_hiscores, dbuffer(), 5 - 3, 179 - 3, 600, (limit != 0 ? limit * 30 : 30));
  while (cmd < 0) {
    cleanScr();
    showLogo();
    i_blit(blend_hiscores, dbuffer(), 5 - 3, 179 - 3, 600, (limit != 0 ? limit * 30 : 30));
    for (a = 0; a < limit; a++) {
      sprintf(pos, "%2d-", a+offset+1);
      if ((a+offset) != mark) {
        text(dbuffer(), 57, 179+30*(a%10), lines[a+offset], get_color(COLOR_TEXT), FONT_MEDIUM);
        text(dbuffer(), 5, 179+30*(a%10), pos, get_color(COLOR_TEXT), FONT_MEDIUM);
      }
      else {
        text(dbuffer(), 57, 179+30*(a%10), lines[a+offset], get_color("#BB0000"), FONT_MEDIUM);
        text(dbuffer(), 5, 179+30*(a%10), pos, get_color("#BB0000"), FONT_MEDIUM);
      }
    }
    if (num == 0) {
      text(dbuffer(), 5, 179, "This level doesn't have any Hiscore", get_color(COLOR_TEXT), FONT_MEDIUM);
    }

    graphics_sync();
    if (!userOption(&offset)) {
      usi_blit(old_blend_hiscores, dbuffer(), 5 - 3, 179 - 3, 600, (limit != 0 ? limit * 30 : 30));
      return;
    }
    offset = (offset > (num-10)) ? num - 10 : offset;
    offset = (offset < 0) ? 0 : offset;
  }
  usi_blit(old_blend_hiscores, dbuffer(), 5 - 3, 179 - 3, 600, (limit != 0 ? limit * 30 : 30));
  return;
}

bool userOption(int *cmd) {
    KeySym key;
    int a;
    a = *cmd;
    while (a == *cmd) {
      key = wait_key();
      switch(key) {
        case(XK_KP_8):
        case(XK_Up):
        case(XK_KP_Up):
          *cmd-=1;
          return true;
          break;
        case(XK_KP_4):
        case(XK_Left):
        case(XK_KP_Left):
          *cmd-=10;
          return true;
          break;
        case(XK_KP_2):
        case(XK_Down):
        case(XK_KP_Down):
          *cmd+=1;
          return true;
          break;
        case(XK_KP_6):
        case(XK_Right):
        case(XK_KP_Right):
          *cmd+=10;
          return true;
          break;
        case(XK_KP_Enter):
        case(XK_Return):
          return false;
          break;
        case(XK_Escape):
        case 'Q':
        case 'q':
          *cmd=255;
          return false;
        default:
          break;
      }
    }

    return true;
}

void splash(struct splash_struct spl_arg, char *filename) {
  strncpy(spl.txt, spl_arg.txt, 256);
  spl.info = levelDescription(filename);
  spl.n = spl_arg.n;
  spl.mode = spl_arg.mode;
  spl.cur = 0;
  update_splash();
}

void update_splash_hiscore() {
  splText2(spl.txt);
  rect(dbuffer(), 3, 387, 608, 36, get_color("#AA6800"), 1);
  rect(dbuffer(), 5, 389, (572*spl.cur)/spl.n, 32, get_color("#86A886"), 1);
  m_blit(logocar[0], logocar_mask[0], dbuffer(), 5 + (572*spl.cur)/spl.n, 389, 32, 32);
}

void update_splash() {
  XImage *blend_info;
  XImage *blend_help;
  XImage *blend_desc;
  int info_x, info_y, info_w, info_h;
  int help_x, help_y, help_w, help_h;
  int desc_x, desc_y, desc_w, desc_h;
  cleanScr();
  showLogo();
  if (spl.mode == 2) {
    update_splash_hiscore();
  } else {
    // Info window
    info_x = 10;
    text_rectangle(spl.txt, FONT_BIG, &info_w, &info_h);
    info_w+=8;
    info_h+=8;
    info_y = 10;
    // Desc window
    desc_y = 10;
    text_rectangle(spl.info, FONT_MEDIUM, &desc_w, &desc_h);
    desc_w+=8;
    desc_h+=8;
    desc_x = 614 - desc_w - 10;
    // Help window
    help_x = 10;
    text_rectangle(game_help, FONT_MEDIUM, &help_w, &help_h);
    help_w+=8;
    help_h+=8;
    help_y = desc_y + desc_h - help_h;
    // Get windows
    blend_info = blend_image(logo, info_x, info_y, info_w, info_h, &blend_cache);
    blend_help = blend_image(logo, help_x, help_y, help_w, help_h, &blend_cache);
    blend_desc = blend_image(logo, desc_x, desc_y, desc_w, desc_h, &blend_cache);
    // Draw windows
    i_blit(blend_info, dbuffer(), info_x, info_y, info_w, info_h);
    i_blit(blend_help, dbuffer(), help_x, help_y, help_w, help_h);
    i_blit(blend_desc, dbuffer(), desc_x, desc_y, desc_w, desc_h);
    // Draw texts
    text(dbuffer(), info_x + 4, info_y + 4, spl.txt, get_color(COLOR_TEXT), FONT_BIG);
    text(dbuffer(), help_x + 4, help_y + 4, game_help,  get_color(COLOR_TEXT), FONT_MEDIUM);
    text(dbuffer(), desc_x + 4, desc_y + 4, spl.info, get_color(COLOR_TEXT), FONT_MEDIUM);
    // Lower sound
    #ifdef USE_SOUND
    sound_changevol (-4);
    #endif
    // Draw progress bar
    rect(dbuffer(), 10, 482 - 10 - 32, 614 - 10 - 10, 32, get_color("#AA6800"), 1);
    rect(dbuffer(), 10, 482 - 10 - 32, ((614 - 10 - 10)*spl.cur)/spl.n, 32, get_color(COLOR_GREEN), 1);
    m_blit(logocar[0], logocar_mask[0], dbuffer(), 10 + ((614-10-10)*spl.cur)/spl.n, 482-10-32, 32, 32);
  }
  graphics_sync();
  spl.cur++;
  if (spl.cur > spl.n)
    spl.cur = spl.n;
}

char *levelDescription(char *level) {
  char *desc;
  char livStr[16] = "";
  char bonStr[64] = "";
  levelStruct lev;
  desc = (char *)malloc(512 * sizeof(char));
  quickLoadLevel(&lev, level);
  if (lev.lives < 0) {
    sprintf(livStr, "No Lives!");
  }
  else if (lev.lives == 1) {
    sprintf(livStr, "1 live");
  }
  else {
    sprintf(livStr, "%d lives", lev.lives);
  }

  if (lev.livesbonus < 0 && lev.lives >= 0) {
    sprintf(bonStr, "%d pts / lives\nbeyond %d at\nend of level", -lev.livesbonus, lev.lives);
  }
  else if (lev.livesbonus >= 0) {
    sprintf(bonStr, "%d pts / live at\nend of level", lev.livesbonus);
  }

  sprintf(desc, "**%s**\n\nTileset: %s\n%d map%c\n%s\n%d pts / extra live\n%s\n\n*First map:*\nPlayer speed: %d\nEnemy speed: %d\n", lev.name, lev.tileset, lev.number, (lev.number>1)?'s':' ', livStr, lev.extra, bonStr, lev.map[0].carVel, lev.map[0].aiVel);

  return desc;
}