---

f_main.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine 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.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/08 20:08:15 $
// By           :       $Author: kolrabi $
// $Id: f_main.cpp,v 1.2 2002/12/08 20:08:15 kolrabi Exp $ 

/*

  $Log: f_main.cpp,v $
  Revision 1.2  2002/12/08 20:08:15  kolrabi
  Now really runs under X11

  Revision 1.1.1.1  2002/12/07 19:02:06  kolrabi
  initial release


*/
 
#include            <string>

#include            "zlib.h"

#include            "omicron/internal.h"
#include            "omicron/file.h"
#include            "omicron/list.h"
#include            "omicron/array.h"
// #include            "omicron/string.h"

// never user DBGSTAMP here
#undef  DBGSTAMP
#define DBGSTAMP

// --@@@PAK
// marker for pak files attached to executable. it is interleaved because
// when searching for it, it would find itself.
static const char   _pak_mark1[] =          "-@@A";
static const char   _pak_mark2[] =          "-@PK";
static char         _pak_mark[9];
static ulong        attachedpakpos = 0;
 
/**************************************************************************** 
 **************************************************************************** 
 * VARIABLES **************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 

file_manager_c::file_manager_c()
{
    int     i;

    SafeDelete(gv.fileman);

    gv.fileman  = this;
    async_files = new list_c<file_t>;
    files       = new array_c<file_t>;
    pak_names   = new array_c<char>;

    // find marker in executable
    for (i=0; i<8; i++)
        _pak_mark[i] = i%2?_pak_mark2[i/2]:_pak_mark1[i/2];

    _pak_mark[i] = 0;

    FILE    *f = fopen(gv.init.argv[0], "rb");

    if (f)
    {
        ulong fit = 0;
        ulong p = 0;
        char  ch = 0;

        ch = fgetc(f);

        while(!feof(f))
        {
            if (ch==_pak_mark[fit])
                fit++;
            else
                fit = 0;

            if (fit == 8)
                break;

            ch = fgetc(f);
            p++;
        }

        if (fit == 8)
            attachedpakpos = p+1;
        else
            attachedpakpos = 0;

        if (attachedpakpos)
            _log_printf(MSG_DEBUG, "attached pak found at %08x", attachedpakpos);
        else
            _log_printf(MSG_DEBUG, "attached pak not found");

        fclose(f);
    }

    sprintf(datadir, "data");
}

file_manager_c::~file_manager_c()
{
    AssertThis;

    close_paks();

    for (slong i=0; i<files->get_count(); i++)
    {
        file_t *f = files->get(i); 
        if (f) close(f);
    }

    SafeDelete(files);
    SafeDelete(pak_names);
    SafeDelete(async_files); 
    gv.fileman = NULL;
}
 
/**************************************************************************** 
 **************************************************************************** 
 * FILE ACCESS FUNCTIONS **************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
file_t *
file_manager_c::load_from_disk
(
    const char      *filename,          
    bool            async               
)
{ 
    AssertThisV;

    FILE        *f;                 // the file 
    ulong       s;                  // for file size 
    file_t      *file;              // the file descriptor 
    std::string      szFile;

    szFile = datadir;
    szFile += "/";
    szFile += filename;
 
#if defined(WIN32)
    int i;

    for (i=0; i<szFile.length(); i++)
      if (szFile.at(i)=='/')
        szFile.replace(i,1,"\\");
#endif
 
    _log_printf(MSG_DEBUG, "trying to load file '%s' from disk", szFile.c_str()); 
 
    file = new file_t; 
    AssertReturnValue1(file, NULL);
 
    file->asyncloading  = async?1:0; 
    file->size          = 0;
    file->pos           = 0;        // set cursor to 0 
    file->buf           = NULL;
 
    // open file 
    f = fopen(szFile.c_str(), "rb"); 
    if (!f) 
    { 
        _log_printf(MSG_DEBUG, "file not found"); 
        SafeDelete(file); 
        return NULL; 
    } 
 
    // get size of file 
    fseek(f, 0, SEEK_END); 
    s = ftell(f); 
    fseek(f, 0, SEEK_SET); 
    file->size = s; 
 
    if (async) 
    { 
        file->f = f; 
        async_files->add_first(file); 
    } 
    else 
    { 
        // and load it 
        file->buf = new char[s]; 
        if (!file->buf) 
        { 
            fclose(f); 
            SafeDelete(file); 
            return NULL; 
        } 
        fread( file->buf, 1, (unsigned)s, f ); 
        fclose(f); 
 
        file->f = NULL; 
    } 
 
    _log_printf(MSG_NORMAL, "successfully loaded file: %s", szFile.c_str()); 
    file->pos = 0;                  // set cursor to 0 
    return file; 
} // loadfromdisk 
 
file_t *
file_manager_c::load_from_pak
(
    const char      *filename           
)
{ 
    AssertThisV;

    file_t     *file = NULL;       // the file descriptor 
 
    std::string      szFile;

    szFile = filename;

#if defined(WIN32)
    int i;

    for (i=0; i<szFile.length(); i++)
      if (szFile.at(i)=='\\')
        szFile.replace(i,1,"/");
#endif

    _log_printf(MSG_DEBUG, "trying to load file '%s' from pak", szFile.c_str());

    for ( slong pak=0; pak<pak_names->get_count(); pak++)
    {
        char  *pname = pak_names->get(pak);

        if (!pname)
            break;

        FILE  *f = fopen(pname, "rb");

        pak_header_t h;
        fileentry_t  fe;

        fread(&h, sizeof(h), 1, f);

        for (ulong e = 0; e<h.entrycount; e++)
        {
            fread(&fe, sizeof(fe), 1, f);
            if (!strcmpi( szFile.c_str(), fe.filename )) 
            { 
                file = create();
                // save size 
                file->size = fe.realsize; 
 
                // create buffer and "load" file 
                file->buf = new char[fe.realsize]; 

                if (!file->buf) 
                { 
                    SafeDelete(file); 
                    continue;
                } 

                // if realsize == size then file is uncompressed 
                if (fe.size ==  
                    fe.realsize) 
                { 
                    fseek(f, fe.offset, SEEK_SET);
                    fread(file->buf, 1, file->size, f);

                    fclose(f);
                    return file; 
                } 
                else // it is compressed 
                { 
                    char *tmpbuf = new char[fe.size];
                    fseek(f, fe.offset, SEEK_SET);
                    fread(tmpbuf, 1, fe.size, f);

                    // file is at beginning of _pak_header + offset 
                    uncompress((uchar*)file->buf, 
                        (ulong*)&file->size, 
                        (uchar*)(tmpbuf), 
                        (ulong)fe.size); 
 
                    fclose(f);
                    SafeArrayDelete(tmpbuf);

                    _log_printf(MSG_NORMAL, 
                      "successfully loaded file: %s", szFile.c_str());
                    return file; 
                } 
            }
        }

        fclose(f);
    }

    // try to load from attached
    if (attachedpakpos)
    {
        FILE  *f = fopen(gv.init.argv[0], "rb");

        fseek(f, attachedpakpos, SEEK_SET);

        pak_header_t h;
        fileentry_t  fe;

        fread(&h, sizeof(h), 1, f);
        for (ulong e = 0; e<h.entrycount; e++)
        {
            fread(&fe, sizeof(fe), 1, f);
            if (!strcmpi( szFile.c_str(), fe.filename )) 
            { 
                file = create();
                // save size 
                file->size = fe.realsize; 
 
                // create buffer and "load" file 
                file->buf = new char[fe.realsize]; 

                if (!file->buf) 
                { 
                    SafeDelete(file); 
                    continue;
                } 

                // if realsize == size then file is uncompressed 
                if (fe.size ==  
                    fe.realsize) 
                { 
                    fseek(f, fe.offset+attachedpakpos, SEEK_SET);
                    fread(file->buf, 1, file->size, f);

                    fclose(f);
                    return file; 
                } 
                else // it is compressed 
                { 
                    char *tmpbuf = new char[fe.size];
                    fseek(f, fe.offset+attachedpakpos, SEEK_SET);
                    fread(tmpbuf, 1, fe.size, f);

                    // file is at beginning of _pak_header + offset 
                    uncompress((uchar*)file->buf, 
                        (ulong*)&file->size, 
                        (uchar*)(tmpbuf), 
                        (ulong)fe.size); 
 
                    fclose(f);
                    SafeArrayDelete(tmpbuf);

                    _log_printf(MSG_NORMAL, 
                      "successfully loaded file: %s", szFile.c_str());
                    return file; 
                } 
            }
        }

        fclose(f);
    }
 
    if (file) SafeDelete(file); 
    return NULL;                  // file will be NULL here anyway 
} // loadfrompak 


file_t *
file_manager_c::load
( 
    const char      *filename,          
    bool            async               
)
{
    AssertThisV;

    file_t *f; 
 
    /* try loading from disk */
    f = load_from_disk( filename, async ); 
 
    if (f) return f; 
 
    /* try loading from disk */
    f = load_from_pak( filename ); 
 
    if (!f) 
        _log_printf(MSG_WARNING, "file not found: %s", filename); 
 
    return f; 
} // load 

ulong
file_manager_c::load_pak
(
    const char      *filename           
)
{
    AssertThisV;

    char *str = new char[strlen(filename)+1+strlen(datadir)+1];

    sprintf(str, "%s/%s", datadir, filename);
    _convert_file_path(str);

    FILE    *f = fopen(str, "rb");
    if (!f)
    {
        _log_printf(MSG_NORMAL, "loadpak() - file not found - '%s'", str); 

        SafeArrayDelete(str);
        return 0;
    }
    fclose(f);

    pak_names->add(str);
 
    return 1;
} // loadpak 

void
file_manager_c::save 
(
    file_t          *file,              
    const char      *filename           
)
{
    AssertThis;

    std::string fname;

    AssertReturn2(file, filename);

    fname = filename;

#if defined(WIN32)
    int i;

    for (i=0; i<fname.length(); i++)
        if (fname.at(i)=='/')
            fname.replace(i,1,"\\");
#endif

    FILE *f = fopen(fname.c_str(), "wb"); 
    if (!f) return; 

    if (file->buf) 
        fwrite(file->buf, 1, file->size, f); 

    fclose(f);
} // save 
 
void
file_manager_c::resize 
( 
    file_t          *file,              
    ulong           newsize             
) 
{ 
    AssertThis;

    if (!file) 
        return; 
 
    if (!newsize) 
    { 
        SafeArrayDelete(file->buf); 
        file->size = file->pos = 0; 
        return; 
    } 
 
    char  *buf = new char[newsize]; 
    long  copysize = newsize>file->size?file->size:newsize; 
 
    memcpy(buf, file->buf, copysize); 
    file->size = newsize; 
    SafeArrayDelete(file->buf); 
    file->buf = buf; 
} 
 
file_t *
file_manager_c::create
(
)
{
    AssertThisV;

    file_t *f; 
     
    f = new file_t; 
    AssertReturnValue1(f, NULL);
 
    f->buf          = NULL; 
    f->pos          = 0; 
    f->size         = 0; 
    f->asyncloading = 0; 
 
    return f;
} // create


void
file_manager_c::close
(
    file_t          *file               
)
{
    AssertThis;

    AssertReturn1(file);

    files->remove_ptr(file);
    SafeArrayDelete(file->buf);
    SafeDelete(file);
} // close

ulong
file_manager_c::tell
(
    file_t          *f                  
)
{
    AssertThisV;

    return f->pos; 
} 

void
file_manager_c::close_paks
() 
{ 
    AssertThis;

    for (slong i=0; i<pak_names->get_count(); i++) 
    { 
        char *pname = pak_names->get(i);
        if (!pname) continue;

        _log_printf(MSG_DEBUG2, "closing pak file %u (%s)", i, pname); 
        pak_names->remove(i);
        SafeArrayDelete(pname);
    } 
} // closepak 
 
void
file_manager_c::unload_pak
(
    ulong           n                   
) 
{
    AssertThis;

    char *pname = pak_names->get(n);
    if (!pname) return;

    _log_printf(MSG_DEBUG2, "closing pak file %u (%s)", n, pname); 
    pak_names->remove(n);
    SafeArrayDelete(pname);
} // unloadpak 
 
ulong
file_manager_c::seek
( 
    file_t          *f,                 
    slong           offset,             
    ulong           origin              
) 
{ 
    AssertThisV;

    if (!f || !f->buf) 
        return 0; 
 
    switch(origin) 
    { 
        case SEEK_CUR: f->pos += (slong)offset; break; 
        case SEEK_END: f->pos = f->size-offset; break; 
        case SEEK_SET: f->pos = offset; break; 
        default: return 0; 
    } 
 
    if (f->pos<0 || f->pos>f->size || !f->buf) 
        return 0; 
 
    return 1; 
} // seek 

bool
file_manager_c::eof
( 
    file_t          *file               
) 
{ 
    AssertThisValue(true);

    AssertReturnValue1(file, true);

    return file->pos>=file->size; 
}
 
void
file_manager_c::update
() 
{ 
    AssertThis;

    /* handle asynchronous files */
    if (async_files) 
    { 
        file_t *f = (file_t *)async_files->get_first(); 
 
        /* for every asynchronous file */
        while(f) 
        { 
            if (f->f) 
            { 
                ulong l = 0; 
 
                if (f->pos<f->size) 
                { 
                    /* read a bit */
                    l = fread(f->buf+f->pos, 1, 1024, f->f); 
                    f->pos += l; 
                    f = (file_t *)async_files->get_next(); 
                } 
                else 
                { 
                    /* if done reading, close file */
                    fclose(f->f); 

                    /* mark as loaded */
                    f->pos = 0; 
                    f->asyncloading = 0; 

                    /* remove from list */
                    async_files->remove(f); 
                    f = (file_t *)async_files->get_first(); 
                } 
            } 
            else 
            { 
                /* has no open file -> mark as loaded, remove */
                f->pos = 0; 
                f->asyncloading = 0; 
                async_files->remove(f); 
                f = (file_t *)async_files->get_first(); 
             } 
        } 
    } 
} 

---