racemanmenu.cpp

Go to the documentation of this file.

/***************************************************************************
 
    file        : racemanmenu.cpp
    created     : Fri Jan  3 22:24:41 CET 2003
    copyright   : (C) 2003-2026 by Eric Espié, Bernhard Wymann
    email       : berniw@bluewin.ch
 
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 <stdlib.h>
#include <stdio.h>
#include <tgfclient.h>
#include <raceman.h>
#include <racescreens.h>
#include <driverconfig.h>
#include <portability.h>
 
#include "raceengine.h"
#include "racemain.h"
#include "raceinit.h"
#include "racestate.h"
 
#include "racemanmenu.h"
 
static float red[4]  = {1.0, 0.0, 0.0, 1.0};
 
static void *racemanMenuHdle = NULL;
static void *newTrackMenuHdle = NULL;
static int newRaceButtonId = -1;
static tRmTrackSelect ts;
static tRmDrvSelect ds;
static tRmRaceParam rp;
static tRmFileSelect fs;
static const char *NoDriversSelectedMessage = "No drivers selected. Configure Race and select at least one";
 
static void reConfigRunState(void);
 
static int
reHasSelectedDrivers(void)
{
    return ReInfo && ReInfo->params && GfParmGetEltNb(ReInfo->params, RM_SECT_DRIVERS) > 0;
}
 
static void
reUpdateNewRaceState(void)
{
    const int hasSelectedDrivers = reHasSelectedDrivers();
 
    if (!racemanMenuHdle) {
        return;
    }
 
    if (newRaceButtonId >= 0) {
        GfuiEnable(racemanMenuHdle, newRaceButtonId, hasSelectedDrivers ? GFUI_ENABLE : GFUI_DISABLE);
    }
}
 
static void
reStartNewRace(void)
{
    if (!reHasSelectedDrivers()) {
        reUpdateNewRaceState();
        return;
    }
 
    ReStartNewRace(NULL);
}
 
static void
reConfigBack(void)
{
    void *params = ReInfo->params;
 
    /* Go back one step in the conf */
    GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 
            GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1) - 2);
 
    reConfigRunState();
}
 
 
/***************************************************************/
/* Callback hooks used only to run the automaton on activation */
static void *configHookHandle = 0;
 
static void
configHookActivate(void)
{
    reConfigRunState();
}
 
static void *
reConfigHookInit(void)
{
    if (configHookHandle) {
        return configHookHandle;
    }
 
    configHookHandle = GfuiHookCreateAction(configHookActivate);
    return configHookHandle;
}
 
/***************************************************************/
/* Config Back Hook */
 
static void *ConfigBackHookHandle = 0;
 
static void
ConfigBackHookActivate(void)
{
    reConfigBack();
}
 
static void *
reConfigBackHookInit(void)
{
    if (ConfigBackHookHandle) {
        return ConfigBackHookHandle;
    }
 
    ConfigBackHookHandle = GfuiHookCreateAction(ConfigBackHookActivate);
    return ConfigBackHookHandle;
}
 
static void
reConfigRunState(void)
{
    int i;
    const char* opt;
    const char* conf;
    int curConf;
    int numOpt;
    void *params = ReInfo->params;
    const int BUFSIZE = 1024;
    char path[BUFSIZE];
    
    curConf = (int)GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
    if (curConf > GfParmGetEltNb(params, RM_SECT_CONF)) {
        GfOut("End of configuration\n");
        GfParmWriteFile(NULL, ReInfo->params, ReInfo->_reName);
        goto menuback;
    }
    
    snprintf(path, BUFSIZE, "%s/%d", RM_SECT_CONF, curConf);
    conf = GfParmGetStr(params, path, RM_ATTR_TYPE, 0);
    if (!conf) {
        GfOut("no %s here %s\n", RM_ATTR_TYPE, path);
        goto menuback;
    }
    
    GfOut("Configuration step %s\n", conf);
    if (!strcmp(conf, RM_VAL_TRACKSEL)) {
        /* Track Select Menu */
        ts.nextScreen = reConfigHookInit();
        if (curConf == 1) {
            ts.prevScreen = racemanMenuHdle;
        } else {
            ts.prevScreen = reConfigBackHookInit();
        }
        ts.param = ReInfo->params;
        ts.trackItf = ReInfo->_reTrackItf;
        RmTrackSelect(&ts);  
    } else if (!strcmp(conf, RM_VAL_DRVSEL)) {
        /* Drivers select menu */
        ds.nextScreen = reConfigHookInit();
        if (curConf == 1) {
            ds.prevScreen = racemanMenuHdle;
        } else {
            ds.prevScreen = reConfigBackHookInit();
        }
        ds.param = ReInfo->params;
        RmDriversSelect(&ds);
    
    } else if (!strcmp(conf, RM_VAL_RACECONF)) {
        /* Race Options menu */
        rp.nextScreen = reConfigHookInit();
        if (curConf == 1) {
            rp.prevScreen = racemanMenuHdle;
        } else {
            rp.prevScreen = reConfigBackHookInit();
        }
        rp.param = ReInfo->params;
        rp.title = GfParmGetStr(params, path, RM_ATTR_RACE, "Race");
        /* Select options to configure */
        rp.confMask = 0;
        snprintf(path, BUFSIZE, "%s/%d/%s", RM_SECT_CONF, curConf, RM_SECT_OPTIONS);
        numOpt = GfParmGetEltNb(params, path);
        for (i = 1; i < numOpt + 1; i++) {
            snprintf(path, BUFSIZE, "%s/%d/%s/%d", RM_SECT_CONF, curConf, RM_SECT_OPTIONS, i);
            opt = GfParmGetStr(params, path, RM_ATTR_TYPE, "");
            if (!strcmp(opt, RM_VAL_CONFRACELEN)) {
            /* Configure race length */
            rp.confMask |= RM_CONF_RACE_LEN;
            } else {
            if (!strcmp(opt, RM_VAL_CONFDISPMODE)) {
                /* Configure display mode */
                rp.confMask |= RM_CONF_DISP_MODE;
            }
            }
        }
        RmRaceParamMenu(&rp);
    }
    
    curConf++;
    GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, curConf);
    
    return;
 
    /* Back to the race menu */
 menuback:
    reUpdateNewRaceState();
    GfuiScreenActivate(racemanMenuHdle);
    return;
}
 
static void
reConfigureMenu(void)
{
    void *params = ReInfo->params;
 
    /* Reset configuration automaton */
    GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
    reConfigRunState();
}
 
static void
reSelectLoadFile(char *filename)
{
    const int BUFSIZE = 1024;
    char buf[BUFSIZE];
    
    snprintf(buf, BUFSIZE, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename);
    GfOut("Loading Saved File %s...\n", buf);
    ReInfo->results = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
    ReInfo->_reRaceName = ReInfo->_reName;
    RmShowStandings(ReInfo->_reGameScreen, ReInfo);
}
 
// FIXME: remove this static shared buffer!
const int VARBUFSIZE = 1024;
char varbuf[VARBUFSIZE];
 
static void
reLoadMenu(void *prevHandle)
{
    void *params = ReInfo->params;
    
    fs.prevScreen = prevHandle;
    fs.select = reSelectLoadFile;
    
    const char* str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0);
    if (str) {
        fs.title = str;
    }
 
    snprintf(varbuf, VARBUFSIZE, "%sresults/%s", GetLocalDir(), ReInfo->_reFilename);
    fs.path = varbuf;
    
    RmFileSelect((void*)&fs);
}
 
int
ReRacemanMenu(void)
{
    void    *params = ReInfo->params;
 
    if (racemanMenuHdle) {
        GfuiScreenRelease(racemanMenuHdle);
    }
    newRaceButtonId = -1;
 
    racemanMenuHdle = GfuiScreenCreateExAction(NULL,
                    tGfuiAction(),
                    tGfuiAction(),
                    1);
 
    const char* str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
    if (str) {
        GfuiScreenAddBgImg(racemanMenuHdle, str);
    }
    
    GfuiMenuDefaultKeysAdd(racemanMenuHdle);
 
    str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, 0);
    if (str) {
        GfuiTitleCreate(racemanMenuHdle, str, strlen(str));
    }
 
 
    newRaceButtonId = GfuiMenuButtonCreateActionWithDisabledTip(racemanMenuHdle,
            "New Race", "Start a New Race", NoDriversSelectedMessage,
            reStartNewRace);
 
    GfuiMenuButtonCreateAction(racemanMenuHdle,
            "Configure Race", "Configure The Race",
            reConfigureMenu);
 
/*     GfuiMenuButtonCreate(racemanMenuHdle, */
/*           "Configure Players", "Players configuration menu", */
/*           TorcsDriverMenuInit(racemanMenuHdle), GfuiScreenActivate); */
 
    if (GfParmGetEltNb(params, RM_SECT_TRACKS) > 1) {
        GfuiMenuButtonCreateAction(racemanMenuHdle,
                    "Load", "Load a Previously Saved Game",
                    [] { reLoadMenu(racemanMenuHdle); });
    }
    
    GfuiMenuBackQuitButtonCreateAction(racemanMenuHdle,
                "Back to Main", "Return to previous Menu",
                [] { GfuiScreenActivate(ReInfo->_reMenuScreen); });
 
    reUpdateNewRaceState();
    GfuiScreenActivate(racemanMenuHdle);
 
    return RM_ASYNC | RM_NEXT_STEP;
}
 
static void
reStateManage(void)
{
    ReStateManage();
}
 
int
ReNewTrackMenu(void)
{
    void *params = ReInfo->params;
    void *results = ReInfo->results;
    const int BUFSIZE = 1024;
    char buf[BUFSIZE];
    
    if (newTrackMenuHdle) {
        GfuiScreenRelease(newTrackMenuHdle);
    }
 
    newTrackMenuHdle = GfuiScreenCreateExAction(NULL,
                        tGfuiAction(),
                        tGfuiAction(),
                        1);
    
    const char* str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0);
    if (str) {
        GfuiScreenAddBgImg(newTrackMenuHdle, str);
    }
 
    str = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, "");
    GfuiTitleCreate(newTrackMenuHdle, str, strlen(str));
    
    GfuiMenuDefaultKeysAdd(newTrackMenuHdle);
    
    snprintf(buf, BUFSIZE, "Race Day #%d/%d on %s",
        (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1),
        GfParmGetEltNb(params, RM_SECT_TRACKS),
        ReInfo->track->name);
    
    GfuiLabelCreateEx(newTrackMenuHdle,
                buf,
                red,
                GFUI_FONT_MEDIUM_C,
                320, 420,
                GFUI_ALIGN_HC_VB, 50);
    
    GfuiMenuButtonCreateAction(newTrackMenuHdle,
                "Start Event", "Start The Current Race",
                reStateManage);
    
    
    GfuiMenuButtonCreateAction(newTrackMenuHdle,
                "Abandon", "Abandon The Race",
                [] { GfuiScreenActivate(ReInfo->_reMenuScreen); });
    
    GfuiAddKeyAction(newTrackMenuHdle, 27,  "Abandon", [] { GfuiScreenActivate(ReInfo->_reMenuScreen); }, tGfuiAction());
    
    GfuiScreenActivate(newTrackMenuHdle);
    
    return RM_ASYNC | RM_NEXT_STEP;
}