WebSVN – Kolibri OS – Diff – /programs/games/doom/trunk/d_main.c


// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
//      DOOM main program (D_DoomMain) and game loop (D_DoomLoop),
//      plus functions to determine game mode (shareware, registered),
//      parse command line parameters, configure game parameters (turbo),
//      and call the startup functions.
//
//-----------------------------------------------------------------------------
 
 
static const char rcsid[] = "$Id: d_main.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
 
#define BGCOLOR         7
#define FGCOLOR         8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
#define R_OK    4
 
#include 
#include 
 
#include "doomdef.h"
#include "doomstat.h"
 
#include "dstrings.h"
#include "sounds.h"
 
 
#include "z_zone.h"
#include "w_wad.h"
#include "s_sound.h"
#include "v_video.h"
 
#include "f_finale.h"
#include "f_wipe.h"
 
#include "m_argv.h"
#include "m_misc.h"
#include "m_menu.h"
 
#include "i_system.h"
#include "i_sound.h"
#include "i_video.h"
 
#include "g_game.h"
 
#include "hu_stuff.h"
#include "wi_stuff.h"
#include "st_stuff.h"
#include "am_map.h"
 
#include "p_setup.h"
#include "r_local.h"
 
 
 
#include "d_main.h"
//#include "kolibri.h"
 
 
extern int access(char *file, int mode);
 
//
// D-DoomLoop()
// Not a globally visible function,
//  just included for source reference,
//  called by D_DoomMain, never exits.
// Manages timing and IO,
//  calls all ?_Responder, ?_Ticker, and ?_Drawer,
//  calls I_GetTime, I_StartFrame, and I_StartTic
//
void D_DoomLoop (void);
 
 
char*   wadfiles[MAXWADFILES];
 
 
boolean devparm;        // started game with -devparm
boolean nomonsters;     // checkparm of -nomonsters
boolean respawnparm;    // checkparm of -respawn
boolean fastparm;       // checkparm of -fast
 
boolean  drone;
 
boolean         singletics = false; // debug flag to cancel adaptiveness
 
 
 
//extern int soundVolume;
//extern  int   sfxVolume;
//extern  int   musicVolume;
 
extern  boolean inhelpscreens;
 
skill_t         startskill;
int             startepisode;
int             startmap;
boolean         autostart;
 
FILE*           debugfile;
 
boolean         advancedemo;
 
 
 
 
char            wadfile[1024];          // primary wad file
char            mapdir[1024];           // directory of development maps
char            basedefault[1024];      // default file
 
 
void D_CheckNetGame (void);
void D_ProcessEvents (void);
void G_BuildTiccmd (ticcmd_t* cmd);
void D_DoAdvanceDemo (void);
 
 
//
// EVENT HANDLING
//
// Events are asynchronous inputs generally generated by the game user.
// Events can be discarded if no responder claims them
//
event_t         events[MAXEVENTS];
int             eventhead;
int             eventtail;
 
 
//
// D_PostEvent
// Called by the I/O functions when input is detected
//
void D_PostEvent (event_t* ev)
{
    events[eventhead] = *ev;
    eventhead = (++eventhead)&(MAXEVENTS-1);
}
 
 
//
// D_ProcessEvents
// Send all the events of the given timestamp down the responder chain
//
void D_ProcessEvents (void)
{
    event_t*    ev;
        
    // IF STORE DEMO, DO NOT ACCEPT INPUT
    if ( ( gamemode == commercial )
         && (W_CheckNumForName("map01")<0) )
      return;
        
    for ( ; eventtail != eventhead ; eventtail = (++eventtail)&(MAXEVENTS-1) )
    {
        ev = &events[eventtail];
        if (M_Responder (ev))
            continue;               // menu ate the event
        G_Responder (ev);
    }
}
 
 
 
 
//
// D_Display
//  draw current display, possibly wiping it from the previous
//
 
// wipegamestate can be set to -1 to force a wipe on the next draw
gamestate_t     wipegamestate = GS_DEMOSCREEN;
extern  boolean setsizeneeded;
extern  int             showMessages;
void R_ExecuteSetViewSize (void);
 
 
// #define XXX(n)       __libclog_printf("d_main.c: %u\n",n)
#define XXX(n)
 
void D_Display (void)
{
    static  boolean             viewactivestate = false;
    static  boolean             menuactivestate = false;
    static  boolean             inhelpscreensstate = false;
    static  boolean             fullscreen = false;
    static  gamestate_t         oldgamestate = -1;
    static  int                 borderdrawcount;
    int                         nowtime;
    int                         tics;
    int                         wipestart;
    int                         y;
    boolean                     done;
    boolean                     wipe;
    boolean                     redrawsbar;
 
    if (nodrawers)
    {
        XXX(0);
        return;                    // for comparative timing / profiling
    }           
    redrawsbar = false;
    
    // change the view size if needed
    if (setsizeneeded)
    {
        XXX(1);
        R_ExecuteSetViewSize ();
        XXX(2);
        oldgamestate = -1;                      // force background redraw
        borderdrawcount = 3;
    }
 
    // save the current screen if about to wipe
        XXX(3);
    if (gamestate != wipegamestate)
    {
        wipe = true;
 
        wipe_StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
 
    }
    else 
        wipe = false;
        XXX(6);
 
    if (gamestate == GS_LEVEL && gametic)
    {
 
        HU_Erase();
 
    }
    // do buffered drawing
        XXX(9);
    switch (gamestate)
    {
      case GS_LEVEL:
        XXX(10);
        if (!gametic)
            break;
        if (automapactive)
            AM_Drawer ();
        if (wipe || (viewheight != 200 && fullscreen) )
            redrawsbar = true;
        if (inhelpscreensstate && !inhelpscreens)
            redrawsbar = true;              // just put away the help screen
        ST_Drawer (viewheight == 200, redrawsbar );
        fullscreen = viewheight == 200;
        break;
 
      case GS_INTERMISSION:
        XXX(11);
        WI_Drawer ();
        break;
 
      case GS_FINALE:
        XXX(12);
        F_Drawer ();
        break;
 
      case GS_DEMOSCREEN:
        XXX(13);
        D_PageDrawer ();
        XXX(14);
        break;
    }
    
    // draw buffered stuff to screen
        XXX(15);
    I_UpdateNoBlit ();
        XXX(16);
    
    // draw the view directly
    if (gamestate == GS_LEVEL && !automapactive && gametic)
        R_RenderPlayerView (&players[displayplayer]);
        XXX(17);
 
    if (gamestate == GS_LEVEL && gametic)
        HU_Drawer ();
        XXX(18);
    
    // clean up border stuff
    if (gamestate != oldgamestate && gamestate != GS_LEVEL)
        I_SetPalette (W_CacheLumpName ("PLAYPAL",PU_CACHE));
        XXX(19);
 
    // see if the border needs to be initially drawn
    if (gamestate == GS_LEVEL && oldgamestate != GS_LEVEL)
    {
        XXX(20);
        viewactivestate = false;        // view was not active
        R_FillBackScreen ();    // draw the pattern into the back screen
        XXX(21);
    }
        XXX(22);
 
    // see if the border needs to be updated to the screen
    if (gamestate == GS_LEVEL && !automapactive && scaledviewwidth != 320)
    {
        XXX(23);
        if (menuactive || menuactivestate || !viewactivestate)
            borderdrawcount = 3;
        if (borderdrawcount)
        {
        XXX(24);
            R_DrawViewBorder ();    // erase old menu stuff
        XXX(25);
            borderdrawcount--;
        }
 
    }
        XXX(26);
 
    menuactivestate = menuactive;
    viewactivestate = viewactive;
    inhelpscreensstate = inhelpscreens;
    oldgamestate = wipegamestate = gamestate;
    
    // draw pause pic
    if (paused)
    {
        if (automapactive)
            y = 4;
        else
            y = viewwindowy+4;
        V_DrawPatchDirect(viewwindowx+(scaledviewwidth-68)/2,
                          y,0,W_CacheLumpName ("M_PAUSE", PU_CACHE));
    }
 
 
    // menus go directly to the screen
        XXX(27);
    M_Drawer ();          // menu is drawn even on top of everything
        XXX(28);
    NetUpdate ();         // send out any new accumulation
        XXX(29);
 
 
    // normal update
    if (!wipe)
    {
        XXX(30);
        I_FinishUpdate ();              // page flip or blit buffer
        XXX(31);
        return;
    }
        XXX(32);
    
    // wipe update
    wipe_EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
        XXX(33);
 
    wipestart = I_GetTime () - 1;
 
        XXX(34);
    do
    {
        do
        {
            nowtime = I_GetTime ();
            tics = nowtime - wipestart;
        } while (!tics);
        wipestart = nowtime;
        XXX(35);
        done = wipe_ScreenWipe(wipe_Melt
                               , 0, 0, SCREENWIDTH, SCREENHEIGHT, tics);
        XXX(36);
        I_UpdateNoBlit ();
        XXX(37);
        M_Drawer ();                            // menu is drawn even on top of wipes
        XXX(38);
        I_FinishUpdate ();                      // page flip or blit buffer
        XXX(39);
    } while (!done);
        XXX(40);
}
 
//
//  D_DoomLoop
//
extern  boolean         demorecording;
 
void D_DoomLoop (void)
{
    if (demorecording)
        G_BeginRecording ();
                
    if (M_CheckParm ("-debugfile"))
    {
        char    filename[32];
        sprintf (filename,"debug%i.txt",consoleplayer);
 
        debugfile = fopen (filename,"w");
    }
        
    I_InitGraphics ();
 
    while (1)
    {
        // frame syncronous IO operations
        XXX(100);
        I_StartFrame ();                
        XXX(101);
        
        // process one or more tics
        if (singletics)
        {
 
          I_StartTic ();
 
          D_ProcessEvents ();
 
          G_BuildTiccmd (&netcmds[consoleplayer][maketic%BACKUPTICS]);
                    
          if (advancedemo)
          { 
             D_DoAdvanceDemo ();
          };  
          M_Ticker ();
 
          G_Ticker ();
          gametic++;
          maketic++;
        }
        else
 
 
          TryRunTics (); // will run at least one tic
 
 
 
        S_UpdateSounds (players[consoleplayer].mo);// move positional sounds
 
 
 
        D_Display ();
//      I_UpdateSound();        
        XXX(105);
    }
}
 
 
 
//
//  DEMO LOOP
//
int             demosequence;
int             pagetic;
char                    *pagename;
 
 
//
// D_PageTicker
// Handles timing for warped projection
//
void D_PageTicker (void)
{
   if (--pagetic < 0)
      D_AdvanceDemo ();
}
 
 
 
//
// D_PageDrawer
//
void D_PageDrawer (void)
{
    V_DrawPatch (0,0, 0, W_CacheLumpName(pagename, PU_CACHE));
}
 
 
//
// D_AdvanceDemo
// Called after each demo or intro demosequence finishes
//
void D_AdvanceDemo (void)
{
    advancedemo = true;
}
 
 
//
// This cycles through the demo sequences.
// FIXME - version dependend demo numbers?
//
 void D_DoAdvanceDemo (void)
{
    players[consoleplayer].playerstate = PST_LIVE;  // not reborn
    advancedemo = false;
    usergame = false;               // no save / end game here
    paused = false;
    gameaction = ga_nothing;
 
    if ( gamemode == retail )
      demosequence = (demosequence+1)%7;
    else
      demosequence = (demosequence+1)%6;
    
    switch (demosequence)
    {
      case 0:
        if ( gamemode == commercial )
            pagetic = 35 * 11;
        else
            pagetic = 170;
        gamestate = GS_DEMOSCREEN;
        pagename = "TITLEPIC";
//      if ( gamemode == commercial )
//        S_StartMusic(mus_dm2ttl);
//      else
//        S_StartMusic (mus_intro);
        break;
      case 1:
        G_DeferedPlayDemo ("demo1");
        break;
      case 2:
        pagetic = 200;
        gamestate = GS_DEMOSCREEN;
        pagename = "CREDIT";
        break;
      case 3:
        G_DeferedPlayDemo ("demo2");
        break;
      case 4:
        gamestate = GS_DEMOSCREEN;
        if ( gamemode == commercial)
        {
            pagetic = 35 * 11;
            pagename = "TITLEPIC";
//          S_StartMusic(mus_dm2ttl);
        }
        else
        {
            pagetic = 200;
 
            if ( gamemode == retail )
              pagename = "CREDIT";
            else
              pagename = "HELP2";
        }
        break;
      case 5:
        G_DeferedPlayDemo ("demo3");
        break;
        // THE DEFINITIVE DOOM Special Edition demo
      case 6:
        G_DeferedPlayDemo ("demo4");
        break;
    }
}
 
 
 
//
// D_StartTitle
//
void D_StartTitle (void)
{
    gameaction = ga_nothing;
    demosequence = -1;
    D_AdvanceDemo ();
}
 
 
 
 
//      print title for every printed line
char            title[128];
 
 
 
//
// D_AddFile
//
void D_AddFile (char *file)
{
    int     numwadfiles;
    char    *newfile;
        
    for (numwadfiles = 0 ; wadfiles[numwadfiles] ; numwadfiles++)
        ;
 
    newfile = malloc (strlen(file)+1);
    strcpy (newfile, file);
        
    wadfiles[numwadfiles] = newfile;
}
 
//
// IdentifyVersion
// Checks availability of IWAD files by name,
// to determine whether registered/commercial features
// should be executed (notably loading PWAD's).
//
void IdentifyVersion (void)
{
 
    char*       doom1wad;
    char*       doomwad;
    char*       doomuwad;
    char*       doom2wad;
 
    char*       doom2fwad;
    char*       plutoniawad;
    char*       tntwad;
 
    char *home;
    char *doomwaddir;
//    doomwaddir = getenv("DOOMWADDIR");
//    if (!doomwaddir)
    doomwaddir = ".";
 
    // Commercial.
    doom2wad = malloc(strlen(doomwaddir)+1+9+1);
    sprintf(doom2wad, "%s/doom2.wad", doomwaddir);
 
    // Retail.
    doomuwad = malloc(strlen(doomwaddir)+1+8+1);
    sprintf(doomuwad, "%s/doomu.wad", doomwaddir);
    
    // Registered.
    doomwad = malloc(strlen(doomwaddir)+1+8+1);
    sprintf(doomwad, "%s/doom.wad", doomwaddir);
    
    // Shareware.
    doom1wad = malloc(strlen(doomwaddir)+1+9+1);
    sprintf(doom1wad, "%s/doom1.wad", doomwaddir);
 
     // Bug, dear Shawn.
    // Insufficient malloc, caused spurious realloc errors.
    plutoniawad = malloc(strlen(doomwaddir)+1+/*9*/12+1);
    sprintf(plutoniawad, "%splutonia.wad", doomwaddir);
 
    tntwad = malloc(strlen(doomwaddir)+1+9+1);
    sprintf(tntwad, "%s/tnt.wad", doomwaddir);
 
 
    // French stuff.
    doom2fwad = malloc(strlen(doomwaddir)+1+10+1);
    sprintf(doom2fwad, "%s/doom2f.wad", doomwaddir);
 
//    home = getenv("HOME");
//    if (!home)
    home = ".";
    sprintf(basedefault, "%s/doomrc.txt", home);
 
    if (M_CheckParm ("-shdev"))
    {
        gamemode = shareware;
        devparm = true;
        D_AddFile (DEVDATA"doom1.wad");
        D_AddFile (DEVMAPS"data_se/texture1.lmp");
        D_AddFile (DEVMAPS"data_se/pnames.lmp");
        strcpy (basedefault,DEVDATA"default.cfg");
        return;
    }
 
    if (M_CheckParm ("-regdev"))
    {
        gamemode = registered;
        devparm = true;
        D_AddFile (DEVDATA"doom.wad");
        D_AddFile (DEVMAPS"data_se/texture1.lmp");
        D_AddFile (DEVMAPS"data_se/texture2.lmp");
        D_AddFile (DEVMAPS"data_se/pnames.lmp");
        strcpy (basedefault,DEVDATA"default.cfg");
        return;
    }
 
    if (M_CheckParm ("-comdev"))
    {
        gamemode = commercial;
        devparm = true;
        /* I don't bother
        if(plutonia)
            D_AddFile (DEVDATA"plutonia.wad");
        else if(tnt)
            D_AddFile (DEVDATA"tnt.wad");
        else*/
            D_AddFile (DEVDATA"doom2.wad");
            
        D_AddFile (DEVMAPS"cdata/texture1.lmp");
        D_AddFile (DEVMAPS"cdata/pnames.lmp");
        strcpy (basedefault,DEVDATA"default.cfg");
        return;
    }
 
    if ( !access (doom2fwad,R_OK) )
    {
        gamemode = commercial;
        // C'est ridicule!
        // Let's handle languages in config files, okay?
        language = french;
 
        D_AddFile (doom2fwad);
        return;
    }
 
    if ( !access (doom2wad,R_OK) )
    {
        gamemode = commercial;
        D_AddFile (doom2wad);
        return;
    }
 
    if ( !access (plutoniawad, R_OK ) )
    {
      gamemode = commercial;
      D_AddFile (plutoniawad);
      return;
    }
 
    if ( !access ( tntwad, R_OK ) )
    {
      gamemode = commercial;
      D_AddFile (tntwad);
      return;
    }
 
    if ( !access (doomuwad,R_OK) )
    {
      gamemode = retail;
      D_AddFile (doomuwad);
      return;
    }
 
    if ( !access (doomwad,R_OK) )
    {
      gamemode = registered;
      D_AddFile (doomwad);
      return;
    }
 
    if ( !access (doom1wad,R_OK) )
    {
      gamemode = shareware;
      D_AddFile (doom1wad);
      return;
    }
 
    printf("Game mode indeterminate.\n");
    gamemode = indetermined;
 
    // We don't abort. Let's see what the PWAD contains.
    //exit(1);
    //I_Error ("Game mode indeterminate\n");
}
 
//
// Find a Response File
//
void FindResponseFile (void)
{
    int             i;
#define MAXARGVS        100
        
    for (i = 1;i < myargc;i++)
        if (myargv[i][0] == '@')
        {
            FILE *          handle;
            int             size;
            int             k;
            int             index;
            int             indexinfile;
            char    *infile;
            char    *file;
            char    *moreargs[20];
            char    *firstargv;
                        
            // READ THE RESPONSE FILE INTO MEMORY
            handle = fopen (&myargv[i][1],"rb");
            if (!handle)
            {
//              __libclog_printf ("\nNo such response file!");
                exit(1);
            }
//          __libclog_printf("Found response file %s!\n",&myargv[i][1]);
//            fseek (handle,0,SEEK_END);
//            size = ftell(handle);
//            fseek (handle,0,SEEK_SET);
//            file = malloc (size);
//            fread (file,size,1,handle);
//            fclose (handle);
                        
            // KEEP ALL CMDLINE ARGS FOLLOWING @RESPONSEFILE ARG
            for (index = 0,k = i+1; k < myargc; k++)
                moreargs[index++] = myargv[k];
                        
            firstargv = myargv[0];
            myargv = malloc(sizeof(char *)*MAXARGVS);
            memset(myargv,0,sizeof(char *)*MAXARGVS);
            myargv[0] = firstargv;
                        
            infile = file;
            indexinfile = k = 0;
            indexinfile++;  // SKIP PAST ARGV[0] (KEEP IT)
            do
            {
                myargv[indexinfile++] = infile+k;
                while(k < size &&
                      ((*(infile+k)>= ' '+1) && (*(infile+k)<='z')))
                    k++;
                *(infile+k) = 0;
                while(k < size &&
                      ((*(infile+k)<= ' ') || (*(infile+k)>'z')))
                    k++;
            } while(k < size);
                        
            for (k = 0;k < index;k++)
                myargv[indexinfile++] = moreargs[k];
            myargc = indexinfile;
        
            // DISPLAY ARGS
//          __libclog_printf("%d command-line args:\n",myargc);
//            for (k=1;k
//              __libclog_printf("%s\n",myargv[k]);
 
            break;
        }
}
 
 
//
// D_DoomMain
//
void D_DoomMain (void)
{
    int             p;
    char                    file[256];
 
    FindResponseFile ();
 
    IdentifyVersion ();
 
 
 
 
    modifiedgame = false;
        
    nomonsters = M_CheckParm ("-nomonsters");
    respawnparm = M_CheckParm ("-respawn");
    fastparm = M_CheckParm ("-fast");
    devparm = M_CheckParm ("-devparm");
    if (M_CheckParm ("-altdeath"))
        deathmatch = 2;
    else if (M_CheckParm ("-deathmatch"))
        deathmatch = 1;
 
    switch ( gamemode )
    {
      case retail:
        sprintf (title,
                 "                         "
                 "The Ultimate DOOM Startup v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
      case shareware:
        sprintf (title,
                 "                            "
                 "DOOM Shareware Startup v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
      case registered:
        sprintf (title,
                 "                            "
                 "DOOM Registered Startup v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
      case commercial:
        sprintf (title,
                 "                         "
                 "DOOM 2: Hell on Earth v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
/*FIXME
       case pack_plut:
        sprintf (title,
                 "                   "
                 "DOOM 2: Plutonia Experiment v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
      case pack_tnt:
        sprintf (title,
                 "                     "
                 "DOOM 2: TNT - Evilution v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
*/
      default:
        sprintf (title,
                 "                     "
                 "Public DOOM - v%i.%i"
                 "                           ",
                 VERSION_NUM/100,VERSION_NUM%100);
        break;
    }
    
//    __libclog_printf ("%s\n",title);
 
    if (devparm)
      printf(D_DEVSTR);
    
    // turbo option
    if ( (p=M_CheckParm ("-turbo")) )
    {
        int     scale = 200;
        extern int forwardmove[2];
        extern int sidemove[2];
        
        if (p
            scale = atoi (myargv[p+1]);
        if (scale < 10)
            scale = 10;
        if (scale > 400)
            scale = 400;
        printf ("turbo scale: %i%%\n",scale);
        forwardmove[0] = forwardmove[0]*scale/100;
        forwardmove[1] = forwardmove[1]*scale/100;
        sidemove[0] = sidemove[0]*scale/100;
        sidemove[1] = sidemove[1]*scale/100;
    }
    
    // add any files specified on the command line with -file wadfile
    // to the wad list
    //
    // convenience hack to allow -wart e m to add a wad file
    // prepend a tilde to the filename so wadfile will be reloadable
    p = M_CheckParm ("-wart");
    if (p)
    {
        myargv[p][4] = 'p';     // big hack, change to -warp
 
        // Map name handling.
        switch (gamemode )
        {
          case shareware:
          case retail:
          case registered:
            sprintf (file,"~"DEVMAPS"E%cM%c.wad",
                     myargv[p+1][0], myargv[p+2][0]);
 
 
            break;
            
          case commercial:
          default:
            p = atoi (myargv[p+1]);
            if (p<10)
              sprintf (file,"~"DEVMAPS"cdata/map0%i.wad", p);
            else
              sprintf (file,"~"DEVMAPS"cdata/map%i.wad", p);
            break;
        }
        D_AddFile (file);
    }
        
    p = M_CheckParm ("-file");
    if (p)
    {
        // the parms after p are wadfile/lump names,
        // until end of parms or another - preceded parm
        modifiedgame = true;            // homebrew levels
        while (++p != myargc && myargv[p][0] != '-')
            D_AddFile (myargv[p]);
    }
 
    p = M_CheckParm ("-playdemo");
 
    if (!p)
        p = M_CheckParm ("-timedemo");
 
    if (p && p < myargc-1)
    {
        sprintf (file,"%s.lmp", myargv[p+1]);
        D_AddFile (file);
 
    }
    
    // get skill / episode / map from parms
    startskill = sk_medium;
    startepisode = 1;
    startmap = 1;
    autostart = false;
 
                
    p = M_CheckParm ("-skill");
    if (p && p < myargc-1)
    {
        startskill = myargv[p+1][0]-'1';
        autostart = true;
    }
 
    p = M_CheckParm ("-episode");
    if (p && p < myargc-1)
    {
        startepisode = myargv[p+1][0]-'0';
        startmap = 1;
        autostart = true;
    }
        
    p = M_CheckParm ("-timer");
    if (p && p < myargc-1 && deathmatch)
    {
        int     time;
        time = atoi(myargv[p+1]);
 
        if (time>1)
            printf("s");
         printf(".\n");
    }
 
    p = M_CheckParm ("-avg");
    if (p && p < myargc-1 && deathmatch)
      printf("Austin Virtual Gaming: Levels will end after 20 minutes\n");
 
    p = M_CheckParm ("-warp");
    if (p && p < myargc-1)
    {
        if (gamemode == commercial)
            startmap = atoi (myargv[p+1]);
        else
        {
            startepisode = myargv[p+1][0]-'0';
            startmap = myargv[p+2][0]-'0';
        }
        autostart = true;
    }
 
 
    // init subsystems
    printf ("V_Init: allocate screens.\n\r");
    V_Init ();
 
    printf ("M_LoadDefaults: Load system defaults.\n\r");
    M_LoadDefaults ();              // load before initing other systems
 
    printf ("Z_Init: Init zone memory allocation daemon. \n\r");
 
 
    Z_Init ();
 
    printf ("W_Init: Init WADfiles.\n\r");
    W_InitMultipleFiles (wadfiles);
 
    // Check for -file in shareware
    if (modifiedgame)
    {
        // These are the lumps that will be checked in IWAD,
        // if any one is not present, execution will be aborted.
        char name[23][8]=
        {
            "e2m1","e2m2","e2m3","e2m4","e2m5","e2m6","e2m7","e2m8","e2m9",
            "e3m1","e3m3","e3m3","e3m4","e3m5","e3m6","e3m7","e3m8","e3m9",
            "dphoof","bfgga0","heada1","cybra1","spida1d1"
        };
        int i;
        
        if ( gamemode == shareware)
            I_Error("\n\rYou cannot -file with the shareware "
                    "version. Register!");
 
        // Check for fake IWAD with right name,
        // but w/o all the lumps of the registered version. 
        if (gamemode == registered)
            for (i = 0;i < 23; i++)
                if (W_CheckNumForName(name[i])<0)
                    I_Error("\n\rThis is not the registered version.");
    }
    
    // Iff additonal PWAD files are used, print modified banner
    if (modifiedgame)
    {
//        //printf (
//          "===========================================================================\n\r"
//          "ATTENTION:  This version of DOOM has been modified.  If you would like to\n\r"
//          "get a copy of the original game, call 1-800-IDGAMES or see the readme file.\n\r"
//          "        You will not receive technical support for modified games.\n\r"
//          "                      press enter to continue\n\r"
//          "===========================================================================\n\r"
//          );
//        getchar ();
    }
        
 
    // Check and print which version is executed.
    switch ( gamemode )
    {
      case shareware:
      case indetermined:
//        //printf (
//          "===========================================================================\n\r"
//          "                                Shareware!\n\r"
//          "===========================================================================\n\r"
//      );
        break;
      case registered:
      case retail:
      case commercial:
//        //printf (
//          "===========================================================================\n\r"
//          "                 Commercial product - do not distribute!\n\r"
//          "         Please report software piracy to the SPA: 1-800-388-PIR8\n\r"
//          "===========================================================================\n\r"
//      );
        break;
        
      default:
        // Ouch.
        break;
    }
 
    printf ("M_Init: Init miscellaneous info.\n\r");
    M_Init ();
 
    printf ("R_Init: Init DOOM refresh daemon - \n\r");
    R_Init ();
 
    printf ("\nP_Init: Init Playloop state.\n\r");
    P_Init ();
 
    printf ("I_Init: Setting up machine state.\n\r");
    I_Init ();
 
    printf ("D_CheckNetGame: Checking network game status.\n\r");
 
 
    D_CheckNetGame ();
 
//    printf ("S_Init: Setting up sound.\n\r");
//    S_Init (snd_SfxVolume /* *8 */, snd_MusicVolume /* *8*/ );
 
    printf ("HU_Init: Setting up heads up display.\n\r");
    HU_Init ();
 
    printf ("ST_Init: Init status bar.\n\r");
    ST_Init ();
 
    // check for a driver that wants intermission stats
    p = M_CheckParm ("-statcopy");
    if (p && p
    {
        // for statistics driver
        extern  void*   statcopy;                            
 
        statcopy = (void*)atoi(myargv[p+1]);
        //printf ("External statistics registered.\n\r");
    }
    
    // start the apropriate game based on parms
    p = M_CheckParm ("-record");
 
    if (p && p < myargc-1)
    {
        G_RecordDemo (myargv[p+1]);
        autostart = true;
    }
        
    p = M_CheckParm ("-playdemo");
    if (p && p < myargc-1)
    {
        singledemo = true;              // quit after one demo
        G_DeferedPlayDemo (myargv[p+1]);
        D_DoomLoop ();  // never returns
    }
        
    p = M_CheckParm ("-timedemo");
    if (p && p < myargc-1)
    {
        G_TimeDemo (myargv[p+1]);
        D_DoomLoop ();  // never returns
    }
        
    p = M_CheckParm ("-loadgame");
    if (p && p < myargc-1)
    {
        if (M_CheckParm("-cdrom"))
            sprintf(file, "c:\\doomdata\\"SAVEGAMENAME"%c.dsg",myargv[p+1][0]);
        else
            sprintf(file, SAVEGAMENAME"%c.dsg",myargv[p+1][0]);
        G_LoadGame (file);
    }
        
 
    if ( gameaction != ga_loadgame )
    {
        if (autostart || netgame)
            G_InitNew (startskill, startepisode, startmap);
        else
            D_StartTitle ();                // start up intro loop
 
    }
 
    D_DoomLoop ();  // never returns
}
>
>
>
>
//>
>

Rev 300	Rev 333
1	// Emacs style mode select -- C++ --	1	// Emacs style mode select -- C++ --
2	//-----------------------------------------------------------------------------	2	//-----------------------------------------------------------------------------
3	//	3	//
4	// $Id:$	4	// $Id:$
5	//	5	//
6	// Copyright (C) 1993-1996 by id Software, Inc.	6	// Copyright (C) 1993-1996 by id Software, Inc.
7	//	7	//
8	// This source is available for distribution and/or modification	8	// This source is available for distribution and/or modification
9	// only under the terms of the DOOM Source Code License as	9	// only under the terms of the DOOM Source Code License as
10	// published by id Software. All rights reserved.	10	// published by id Software. All rights reserved.
11	//	11	//
12	// The source is distributed in the hope that it will be useful,	12	// The source is distributed in the hope that it will be useful,
13	// but WITHOUT ANY WARRANTY; without even the implied warranty of	13	// but WITHOUT ANY WARRANTY; without even the implied warranty of
14	// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License	14	// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
15	// for more details.	15	// for more details.
16	//	16	//
17	// $Log:$	17	// $Log:$
18	//	18	//
19	// DESCRIPTION:	19	// DESCRIPTION:
20	// DOOM main program (D_DoomMain) and game loop (D_DoomLoop),	20	// DOOM main program (D_DoomMain) and game loop (D_DoomLoop),
21	// plus functions to determine game mode (shareware, registered),	21	// plus functions to determine game mode (shareware, registered),
22	// parse command line parameters, configure game parameters (turbo),	22	// parse command line parameters, configure game parameters (turbo),
23	// and call the startup functions.	23	// and call the startup functions.
24	//	24	//
25	//-----------------------------------------------------------------------------	25	//-----------------------------------------------------------------------------
26		26
27		27
28	static const char rcsid[] = "$Id: d_main.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";	28	static const char rcsid[] = "$Id: d_main.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
29		29
30	#define BGCOLOR 7	30	#define BGCOLOR 7
31	#define FGCOLOR 8	31	#define FGCOLOR 8
32		32
33		-
34	#include	-
35	#include	-
36		-
37	extern int access(char *file, int mode);	-
38		33
39	#define R_OK 4	-
40	#if 0	-
41	static int access(char *file, int mode)	-
42	{	-
43	FILE *test_fp;	-
44		-
45	test_fp = fopen(file, "r");	-
46	if ( test_fp != NULL ) {	-
47	fclose(test_fp);	-
48	return(0);	-
49	}	-
50	return(-1);	-
51	}	-
-		34	#define R_OK 4
-		35
52	#endif	36	#include
53		37	#include
54		38
55	#include "doomdef.h"	39	#include "doomdef.h"
56	#include "doomstat.h"	40	#include "doomstat.h"
57		41
58	#include "dstrings.h"	42	#include "dstrings.h"
59	#include "sounds.h"	43	#include "sounds.h"
60		-
61		44
62	#include "z_zone.h"	45	#include "z_zone.h"
63	#include "w_wad.h"	46	#include "w_wad.h"
64	#include "s_sound.h"	47	#include "s_sound.h"
65	#include "v_video.h"	48	#include "v_video.h"
66		49
67	#include "f_finale.h"	50	#include "f_finale.h"
68	#include "f_wipe.h"	51	#include "f_wipe.h"
69		52
70	#include "m_argv.h"	53	#include "m_argv.h"
71	#include "m_misc.h"	54	#include "m_misc.h"
72	#include "m_menu.h"	55	#include "m_menu.h"
73		56
74	#include "i_system.h"	57	#include "i_system.h"
75	#include "i_sound.h"	58	#include "i_sound.h"
76	#include "i_video.h"	59	#include "i_video.h"
77		60
78	#include "g_game.h"	61	#include "g_game.h"
79		62
80	#include "hu_stuff.h"	63	#include "hu_stuff.h"
81	#include "wi_stuff.h"	64	#include "wi_stuff.h"
82	#include "st_stuff.h"	65	#include "st_stuff.h"
83	#include "am_map.h"	66	#include "am_map.h"
84		67
85	#include "p_setup.h"	68	#include "p_setup.h"
86	#include "r_local.h"	69	#include "r_local.h"
87		70
-		71
88		72
-		73	#include "d_main.h"
-		74	//#include "kolibri.h"
-		75
-		76
89	#include "d_main.h"	77	extern int access(char *file, int mode);
90		78
91	//	79	//
92	// D-DoomLoop()	80	// D-DoomLoop()
93	// Not a globally visible function,	81	// Not a globally visible function,
94	// just included for source reference,	82	// just included for source reference,
95	// called by D_DoomMain, never exits.	83	// called by D_DoomMain, never exits.
96	// Manages timing and IO,	84	// Manages timing and IO,
97	// calls all ?_Responder, ?_Ticker, and ?_Drawer,	85	// calls all ?_Responder, ?_Ticker, and ?_Drawer,
98	// calls I_GetTime, I_StartFrame, and I_StartTic	86	// calls I_GetTime, I_StartFrame, and I_StartTic
99	//	87	//
100	void D_DoomLoop (void);	88	void D_DoomLoop (void);
101		89
102		90
103	char* wadfiles[MAXWADFILES];	91	char* wadfiles[MAXWADFILES];
104		92
105		93
106	boolean devparm; // started game with -devparm	94	boolean devparm; // started game with -devparm
107	boolean nomonsters; // checkparm of -nomonsters	95	boolean nomonsters; // checkparm of -nomonsters
108	boolean respawnparm; // checkparm of -respawn	96	boolean respawnparm; // checkparm of -respawn
109	boolean fastparm; // checkparm of -fast	97	boolean fastparm; // checkparm of -fast
110		98
111	boolean drone;	99	boolean drone;
112		100
113	boolean singletics = false; // debug flag to cancel adaptiveness	101	boolean singletics = false; // debug flag to cancel adaptiveness
114		102
115		103
116		104
117	//extern int soundVolume;	105	//extern int soundVolume;
118	//extern int sfxVolume;	106	//extern int sfxVolume;
119	//extern int musicVolume;	107	//extern int musicVolume;
120		108
121	extern boolean inhelpscreens;	109	extern boolean inhelpscreens;
122		110
123	skill_t startskill;	111	skill_t startskill;
124	int startepisode;	112	int startepisode;
125	int startmap;	113	int startmap;
126	boolean autostart;	114	boolean autostart;
127		115
128	FILE* debugfile;	116	FILE* debugfile;
129		117
130	boolean advancedemo;	118	boolean advancedemo;
131		119
132		120
133		121
134		122
135	char wadfile[1024]; // primary wad file	123	char wadfile[1024]; // primary wad file
136	char mapdir[1024]; // directory of development maps	124	char mapdir[1024]; // directory of development maps
137	char basedefault[1024]; // default file	125	char basedefault[1024]; // default file
138		126
139		127
140	void D_CheckNetGame (void);	128	void D_CheckNetGame (void);
141	void D_ProcessEvents (void);	129	void D_ProcessEvents (void);
142	void G_BuildTiccmd (ticcmd_t* cmd);	130	void G_BuildTiccmd (ticcmd_t* cmd);
143	void D_DoAdvanceDemo (void);	131	void D_DoAdvanceDemo (void);
144		132
145		133
146	//	134	//
147	// EVENT HANDLING	135	// EVENT HANDLING
148	//	136	//
149	// Events are asynchronous inputs generally generated by the game user.	137	// Events are asynchronous inputs generally generated by the game user.
150	// Events can be discarded if no responder claims them	138	// Events can be discarded if no responder claims them
151	//	139	//
152	event_t events[MAXEVENTS];	140	event_t events[MAXEVENTS];
153	int eventhead;	141	int eventhead;
154	int eventtail;	142	int eventtail;
155		143
156		144
157	//	145	//
158	// D_PostEvent	146	// D_PostEvent
159	// Called by the I/O functions when input is detected	147	// Called by the I/O functions when input is detected
160	//	148	//
161	void D_PostEvent (event_t* ev)	149	void D_PostEvent (event_t* ev)
162	{	150	{
163	events[eventhead] = *ev;	151	events[eventhead] = *ev;
164	eventhead = (++eventhead)&(MAXEVENTS-1);	152	eventhead = (++eventhead)&(MAXEVENTS-1);
165	}	153	}
166		154
167		155
168	//	156	//
169	// D_ProcessEvents	157	// D_ProcessEvents
170	// Send all the events of the given timestamp down the responder chain	158	// Send all the events of the given timestamp down the responder chain
171	//	159	//
172	void D_ProcessEvents (void)	160	void D_ProcessEvents (void)
173	{	161	{
174	event_t* ev;	162	event_t* ev;
175		163
176	// IF STORE DEMO, DO NOT ACCEPT INPUT	164	// IF STORE DEMO, DO NOT ACCEPT INPUT
177	if ( ( gamemode == commercial )	165	if ( ( gamemode == commercial )
178	&& (W_CheckNumForName("map01")<0) )	166	&& (W_CheckNumForName("map01")<0) )
179	return;	167	return;
180		168
181	for ( ; eventtail != eventhead ; eventtail = (++eventtail)&(MAXEVENTS-1) )	169	for ( ; eventtail != eventhead ; eventtail = (++eventtail)&(MAXEVENTS-1) )
182	{	170	{
183	ev = &events[eventtail];	171	ev = &events[eventtail];
184	if (M_Responder (ev))	172	if (M_Responder (ev))
185	continue; // menu ate the event	173	continue; // menu ate the event
186	G_Responder (ev);	174	G_Responder (ev);
187	}	175	}
188	}	176	}
189		177
190		178
191		179
192		180
193	//	181	//
194	// D_Display	182	// D_Display
195	// draw current display, possibly wiping it from the previous	183	// draw current display, possibly wiping it from the previous
196	//	184	//
197		185
198	// wipegamestate can be set to -1 to force a wipe on the next draw	186	// wipegamestate can be set to -1 to force a wipe on the next draw
199	gamestate_t wipegamestate = GS_DEMOSCREEN;	187	gamestate_t wipegamestate = GS_DEMOSCREEN;
200	extern boolean setsizeneeded;	188	extern boolean setsizeneeded;
201	extern int showMessages;	189	extern int showMessages;
202	void R_ExecuteSetViewSize (void);	190	void R_ExecuteSetViewSize (void);
203		191
204		192
205	// #define XXX(n) __libclog_printf("d_main.c: %u\n",n)	193	// #define XXX(n) __libclog_printf("d_main.c: %u\n",n)
206	#define XXX(n)	194	#define XXX(n)
207		195
208	void D_Display (void)	196	void D_Display (void)
209	{	197	{
210	static boolean viewactivestate = false;	198	static boolean viewactivestate = false;
211	static boolean menuactivestate = false;	199	static boolean menuactivestate = false;
212	static boolean inhelpscreensstate = false;	200	static boolean inhelpscreensstate = false;
213	static boolean fullscreen = false;	201	static boolean fullscreen = false;
214	static gamestate_t oldgamestate = -1;	202	static gamestate_t oldgamestate = -1;
215	static int borderdrawcount;	203	static int borderdrawcount;
216	int nowtime;	204	int nowtime;
217	int tics;	205	int tics;
218	int wipestart;	206	int wipestart;
219	int y;	207	int y;
220	boolean done;	208	boolean done;
221	boolean wipe;	209	boolean wipe;
222	boolean redrawsbar;	210	boolean redrawsbar;
223		211
224	if (nodrawers)	212	if (nodrawers)
225	{	213	{
226	XXX(0);	214	XXX(0);
227	return; // for comparative timing / profiling	215	return; // for comparative timing / profiling
228	}	216	}
229	redrawsbar = false;	217	redrawsbar = false;
230		218
231	// change the view size if needed	219	// change the view size if needed
232	if (setsizeneeded)	220	if (setsizeneeded)
233	{	221	{
234	XXX(1);	222	XXX(1);
235	R_ExecuteSetViewSize ();	223	R_ExecuteSetViewSize ();
236	XXX(2);	224	XXX(2);
237	oldgamestate = -1; // force background redraw	225	oldgamestate = -1; // force background redraw
238	borderdrawcount = 3;	226	borderdrawcount = 3;
239	}	227	}
240		228
241	// save the current screen if about to wipe	229	// save the current screen if about to wipe
242	XXX(3);	230	XXX(3);
243	if (gamestate != wipegamestate)	231	if (gamestate != wipegamestate)
244	{	232	{
245	wipe = true;	233	wipe = true;
246	XXX(4);	-
247	wipe_StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);	234	wipe_StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
248	XXX(5);	-
249	}	235	}
250	else	236	else
251	wipe = false;	237	wipe = false;
252	XXX(6);	238	XXX(6);
253		239
254	if (gamestate == GS_LEVEL && gametic)	240	if (gamestate == GS_LEVEL && gametic)
255	{	241	{
256	XXX(7);	-
257	HU_Erase();	242	HU_Erase();
258	XXX(8);	-
259	}	243	}
260	// do buffered drawing	244	// do buffered drawing
261	XXX(9);	245	XXX(9);
262	switch (gamestate)	246	switch (gamestate)
263	{	247	{
264	case GS_LEVEL:	248	case GS_LEVEL:
265	XXX(10);	249	XXX(10);
266	if (!gametic)	250	if (!gametic)
267	break;	251	break;
268	if (automapactive)	252	if (automapactive)
269	AM_Drawer ();	253	AM_Drawer ();
270	if (wipe \|\| (viewheight != 200 && fullscreen) )	254	if (wipe \|\| (viewheight != 200 && fullscreen) )
271	redrawsbar = true;	255	redrawsbar = true;
272	if (inhelpscreensstate && !inhelpscreens)	256	if (inhelpscreensstate && !inhelpscreens)
273	redrawsbar = true; // just put away the help screen	257	redrawsbar = true; // just put away the help screen
274	ST_Drawer (viewheight == 200, redrawsbar );	258	ST_Drawer (viewheight == 200, redrawsbar );
275	fullscreen = viewheight == 200;	259	fullscreen = viewheight == 200;
276	break;	260	break;
277		261
278	case GS_INTERMISSION:	262	case GS_INTERMISSION:
279	XXX(11);	263	XXX(11);
280	WI_Drawer ();	264	WI_Drawer ();
281	break;	265	break;
282		266
283	case GS_FINALE:	267	case GS_FINALE:
284	XXX(12);	268	XXX(12);
285	F_Drawer ();	269	F_Drawer ();
286	break;	270	break;
287		271
288	case GS_DEMOSCREEN:	272	case GS_DEMOSCREEN:
289	XXX(13);	273	XXX(13);
290	D_PageDrawer ();	274	D_PageDrawer ();
291	XXX(14);	275	XXX(14);
292	break;	276	break;
293	}	277	}
294		278
295	// draw buffered stuff to screen	279	// draw buffered stuff to screen
296	XXX(15);	280	XXX(15);
297	I_UpdateNoBlit ();	281	I_UpdateNoBlit ();
298	XXX(16);	282	XXX(16);
299		283
300	// draw the view directly	284	// draw the view directly
301	if (gamestate == GS_LEVEL && !automapactive && gametic)	285	if (gamestate == GS_LEVEL && !automapactive && gametic)
302	R_RenderPlayerView (&players[displayplayer]);	286	R_RenderPlayerView (&players[displayplayer]);
303	XXX(17);	287	XXX(17);
304		288
305	if (gamestate == GS_LEVEL && gametic)	289	if (gamestate == GS_LEVEL && gametic)
306	HU_Drawer ();	290	HU_Drawer ();
307	XXX(18);	291	XXX(18);
308		292
309	// clean up border stuff	293	// clean up border stuff
310	if (gamestate != oldgamestate && gamestate != GS_LEVEL)	294	if (gamestate != oldgamestate && gamestate != GS_LEVEL)
311	I_SetPalette (W_CacheLumpName ("PLAYPAL",PU_CACHE));	295	I_SetPalette (W_CacheLumpName ("PLAYPAL",PU_CACHE));
312	XXX(19);	296	XXX(19);
313		297
314	// see if the border needs to be initially drawn	298	// see if the border needs to be initially drawn
315	if (gamestate == GS_LEVEL && oldgamestate != GS_LEVEL)	299	if (gamestate == GS_LEVEL && oldgamestate != GS_LEVEL)
316	{	300	{
317	XXX(20);	301	XXX(20);
318	viewactivestate = false; // view was not active	302	viewactivestate = false; // view was not active
319	R_FillBackScreen (); // draw the pattern into the back screen	303	R_FillBackScreen (); // draw the pattern into the back screen
320	XXX(21);	304	XXX(21);
321	}	305	}
322	XXX(22);	306	XXX(22);
323		307
324	// see if the border needs to be updated to the screen	308	// see if the border needs to be updated to the screen
325	if (gamestate == GS_LEVEL && !automapactive && scaledviewwidth != 320)	309	if (gamestate == GS_LEVEL && !automapactive && scaledviewwidth != 320)
326	{	310	{
327	XXX(23);	311	XXX(23);
328	if (menuactive \|\| menuactivestate \|\| !viewactivestate)	312	if (menuactive \|\| menuactivestate \|\| !viewactivestate)
329	borderdrawcount = 3;	313	borderdrawcount = 3;
330	if (borderdrawcount)	314	if (borderdrawcount)
331	{	315	{
332	XXX(24);	316	XXX(24);
333	R_DrawViewBorder (); // erase old menu stuff	317	R_DrawViewBorder (); // erase old menu stuff
334	XXX(25);	318	XXX(25);
335	borderdrawcount--;	319	borderdrawcount--;
336	}	320	}
337		321
338	}	322	}
339	XXX(26);	323	XXX(26);
340		324
341	menuactivestate = menuactive;	325	menuactivestate = menuactive;
342	viewactivestate = viewactive;	326	viewactivestate = viewactive;
343	inhelpscreensstate = inhelpscreens;	327	inhelpscreensstate = inhelpscreens;
344	oldgamestate = wipegamestate = gamestate;	328	oldgamestate = wipegamestate = gamestate;
345		329
346	// draw pause pic	330	// draw pause pic
347	if (paused)	331	if (paused)
348	{	332	{
349	if (automapactive)	333	if (automapactive)
350	y = 4;	334	y = 4;
351	else	335	else
352	y = viewwindowy+4;	336	y = viewwindowy+4;
353	V_DrawPatchDirect(viewwindowx+(scaledviewwidth-68)/2,	337	V_DrawPatchDirect(viewwindowx+(scaledviewwidth-68)/2,
354	y,0,W_CacheLumpName ("M_PAUSE", PU_CACHE));	338	y,0,W_CacheLumpName ("M_PAUSE", PU_CACHE));
355	}	339	}
356		340
357		341
358	// menus go directly to the screen	342	// menus go directly to the screen
359	XXX(27);	343	XXX(27);
360	M_Drawer (); // menu is drawn even on top of everything	344	M_Drawer (); // menu is drawn even on top of everything
361	XXX(28);	345	XXX(28);
362	NetUpdate (); // send out any new accumulation	346	NetUpdate (); // send out any new accumulation
363	XXX(29);	347	XXX(29);
364		348
365		349
366	// normal update	350	// normal update
367	if (!wipe)	351	if (!wipe)
368	{	352	{
369	XXX(30);	353	XXX(30);
370	I_FinishUpdate (); // page flip or blit buffer	354	I_FinishUpdate (); // page flip or blit buffer
371	XXX(31);	355	XXX(31);
372	return;	356	return;
373	}	357	}
374	XXX(32);	358	XXX(32);
375		359
376	// wipe update	360	// wipe update
377	wipe_EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);	361	wipe_EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
378	XXX(33);	362	XXX(33);
379		363
380	wipestart = I_GetTime () - 1;	364	wipestart = I_GetTime () - 1;
381		365
382	XXX(34);	366	XXX(34);
383	do	367	do
384	{	368	{
385	do	369	do
386	{	370	{
387	nowtime = I_GetTime ();	371	nowtime = I_GetTime ();
388	tics = nowtime - wipestart;	372	tics = nowtime - wipestart;
389	} while (!tics);	373	} while (!tics);
390	wipestart = nowtime;	374	wipestart = nowtime;
391	XXX(35);	375	XXX(35);
392	done = wipe_ScreenWipe(wipe_Melt	376	done = wipe_ScreenWipe(wipe_Melt
393	, 0, 0, SCREENWIDTH, SCREENHEIGHT, tics);	377	, 0, 0, SCREENWIDTH, SCREENHEIGHT, tics);
394	XXX(36);	378	XXX(36);
395	I_UpdateNoBlit ();	379	I_UpdateNoBlit ();
396	XXX(37);	380	XXX(37);
397	M_Drawer (); // menu is drawn even on top of wipes	381	M_Drawer (); // menu is drawn even on top of wipes
398	XXX(38);	382	XXX(38);
399	I_FinishUpdate (); // page flip or blit buffer	383	I_FinishUpdate (); // page flip or blit buffer
400	XXX(39);	384	XXX(39);
401	} while (!done);	385	} while (!done);
402	XXX(40);	386	XXX(40);
403	}	387	}
404		388
405	//	389	//
406	// D_DoomLoop	390	// D_DoomLoop
407	//	391	//
408	extern boolean demorecording;	392	extern boolean demorecording;
409		393
410	void D_DoomLoop (void)	394	void D_DoomLoop (void)
411	{	395	{
412	if (demorecording)	396	if (demorecording)
413	G_BeginRecording ();	397	G_BeginRecording ();
414		398
415	if (M_CheckParm ("-debugfile"))	399	if (M_CheckParm ("-debugfile"))
416	{	400	{
417	char filename[20];	401	char filename[32];
418	sprintf (filename,"debug%i.txt",consoleplayer);	402	sprintf (filename,"debug%i.txt",consoleplayer);
419	// __libclog_printf ("debug output to: %s\n",filename);	-
420	debugfile = fopen (filename,"w");	403	debugfile = fopen (filename,"w");
421	}	404	}
422		405
423	I_InitGraphics ();	406	I_InitGraphics ();
424		407
425	while (1)	408	while (1)
426	{	409	{
427	// frame syncronous IO operations	410	// frame syncronous IO operations
428	XXX(100);	411	XXX(100);
429	I_StartFrame ();	412	I_StartFrame ();
430	XXX(101);	413	XXX(101);
431		414
432	// process one or more tics	415	// process one or more tics
433	if (singletics)	416	if (singletics)
434	{	417	{
435	XXX(201);	-
436	I_StartTic ();	418	I_StartTic ();
437	XXX(202);	419
438	D_ProcessEvents ();	420	D_ProcessEvents ();
439	XXX(203);	421
440	G_BuildTiccmd (&netcmds[consoleplayer][maketic%BACKUPTICS]);	422	G_BuildTiccmd (&netcmds[consoleplayer][maketic%BACKUPTICS]);
441	XXX(204);	423
442	if (advancedemo)	424	if (advancedemo)
-		425	{
443	D_DoAdvanceDemo ();	426	D_DoAdvanceDemo ();
444	XXX(205);	427	};
445	M_Ticker ();	428	M_Ticker ();
446	XXX(206);	-
447	G_Ticker ();	429	G_Ticker ();
448	gametic++;	430	gametic++;
449	maketic++;	431	maketic++;
450	}	432	}
451	else	433	else
452	{	-
453	XXX(102);	-
454	TryRunTics (); // will run at least one tic	434	TryRunTics (); // will run at least one tic
455	XXX(103);	-
456	}	-
457		435
458	S_UpdateSounds (players[consoleplayer].mo);// move positional sounds	436	S_UpdateSounds (players[consoleplayer].mo);// move positional sounds
459		-
460	// Update display, next frame, with current state.	-
461	XXX(104);	437
462	D_Display ();	438	D_Display ();
463	I_UpdateSound();	439	// I_UpdateSound();
464	XXX(105);	440	XXX(105);
465	}	441	}
466	}	442	}
467		443
468		444
469		445
470	//	446	//
471	// DEMO LOOP	447	// DEMO LOOP
472	//	448	//
473	int demosequence;	449	int demosequence;
474	int pagetic;	450	int pagetic;
475	char *pagename;	451	char *pagename;
476		452
477		453
478	//	454	//
479	// D_PageTicker	455	// D_PageTicker
480	// Handles timing for warped projection	456	// Handles timing for warped projection
481	//	457	//
482	void D_PageTicker (void)	458	void D_PageTicker (void)
483	{	459	{
484	if (--pagetic < 0)	460	if (--pagetic < 0)
485	D_AdvanceDemo ();	461	D_AdvanceDemo ();
486	}	462	}
487		463
488		464
489		465
490	//	466	//
491	// D_PageDrawer	467	// D_PageDrawer
492	//	468	//

Subversion Repositories Kolibri OS

(root)/programs/games/doom/trunk/d_main.c – Rev 300 → 333