app/aesop-client/main.cpp

Go to the documentation of this file.

/*
 * main.cpp
 *
 * Copyright (C) 2008,2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

// includes --------------------------------------------------------------------
#include "aesop-map/map.h"
#include "cmdline/cmdline.h"
#include "client-game-logic/client-game-logic.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "glut/glut.h"
#include "glut-app/application.h"
#include "mapzone/mapzone.h"
#include "model-loader/model-loader.h"
#include "netlib/netlib.h"
#include "perf/perf.h"
#include "physics-loader/physics-loader.h"
#include "util/file.h"


// statics and typedefs --------------------------------------------------------
static const int s_defaultWidth                 = 800;
static const int s_defaultHeight                = 600;



















static void
initClient
(
IN int argc,
IN const char * argv[],
OUT std::string& title,
OUT std::string& gameModeString,
OUT smart_ptr<glut::Host>& host
)
{
        perf::Timer timer("initClient");

        // reset output
        title.clear();
        gameModeString.clear();
        host = NULL;

        smart_ptr<CommandLine> cmd = CommandLine::create(argc, argv);
        ASSERT(cmd, "failed to create new command line object");

        // look up config
        const char * pfile = getSingleKeyValue(cmd, "client-config", true,
            "local client configuration file");

        // determine config parent directory
        std::string config_root;
        GetParentDirectory(pfile, config_root);
        DPRINTF("Using configuration root path: %s", config_root.c_str());

        // game mode string (optional) -- used to drive fullscreen mode
        // TODO: better to put this in config?  Fullscreen is a bit hacky
        const char * gms = getSingleKeyValue(cmd, "game-mode-string", false,
            "parameters for glutEnterGameMode");
        if (gms) {
                DPRINTF("using game-mode-string = '%s'", gms);
                gameModeString = gms;
        }

        // load parameters
        smart_ptr<Datahash> params = readHashFromTextFile(pfile);
        ASSERT(params, "failed to construct datahash from config file");

        // get locale
        const char * locale = i18n::getHostLocale();
        ASSERT_THROW(locale, "failed to determine host locale?");
        DPRINTF("Using locale = '%s'", locale);

        // create story object
        const char * storyDir = getString(params, "storyDir");
        smart_ptr<story::Story> story =
            story::Story::create(locale, storyDir);
        ASSERT(story, "null");

        // remember title
        title = story->getTitle();

        // register map loaders
        smart_ptr<aesop::MapFormatReader> reader =
            mapzone::getMapFormatReader();
        ASSERT(reader, "null");
        aesop::registerMapFormatReader(reader);

        // register 3D model loaders
        smart_ptr<aesop::TypeComponentLoader> model_loader =
            aesop::createModelLoader(story);
        ASSERT(model_loader, "null");
        aesop::registerTypeComponentLoader(model_loader);

        // register physics object loaders
        smart_ptr<aesop::TypeComponentLoader> physics_loader =
            aesop::getPhysicsLoader();
        ASSERT(physics_loader, "null");
        aesop::registerTypeComponentLoader(physics_loader);

        // create game logic object
        smart_ptr<aesop::ClientGameLogic> gameLogic =
            aesop::createClientGameLogic();
        ASSERT(gameLogic, "failed to create game logic object");

        // start up application after all other base initialization
        host = aesop::Application::create(config_root.c_str(), params,
            gameLogic, story);
        ASSERT(host, "failed to create application object");
}



static void
execClient
(
IN int argc,
IN const char * argv[]
)
{
        std::string title, gameModeString;
        smart_ptr<glut::Host> host;
        initClient(argc, argv, title, gameModeString, host);
        ASSERT(host, "null");

        // all done with initialization!
        glut::start(argc, argv,
                s_defaultWidth, s_defaultHeight,
                title.c_str(),
                gameModeString.c_str(),
                host);
}






//
//      entry point
//

int
main
(
IN int argc,
IN const char * argv[]
)
{
        // start everything up
        int retval = 1;
        try {
                execClient(argc, argv);
        } catch (std::exception& e) {
                DPRINTF("Exception during startup!");
                DPRINTF("%s", e.what());
        } catch (...) {
                DPRINTF("Unknown exception during startup!");
                retval = 2;
        }

        // only get here on error
        return retval;
}