Subversion Repositories Kolibri OS

// 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:

//      Main loop menu stuff.

//      Default Config File.

//      PCX Screenshots.

//

//-----------------------------------------------------------------------------

static const char

rcsid[] = "$Id: m_misc.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";

#include 

#include 

//#include "//kolibc.h"

//extern int access(char *file, int mode);

#include "doomdef.h"

#include "z_zone.h"

#include "m_swap.h"

#include "m_argv.h"

#include "w_wad.h"

#include "i_system.h"

#include "i_video.h"

#include "v_video.h"

#include "hu_stuff.h"

// State.

#include "doomstat.h"

// Data.

#include "dstrings.h"

#include "m_misc.h"

//

// M_DrawText

// Returns the final X coordinate

// HU_Init must have been called to init the font

//

extern patch_t*         hu_font[HU_FONTSIZE];

int

M_DrawText

( int           x,

  int           y,

  boolean       direct,

  char*         string )

{

    int         c;

    int         w;

    while (*string)

    {

        c = toupper(*string) - HU_FONTSTART;

        string++;

        if (c < 0 || c> HU_FONTSIZE)

        {

            x += 4;

            continue;

        }

        w = SHORT (hu_font[c]->width);

        if (x+w > SCREENWIDTH)

            break;

        if (direct)

            V_DrawPatchDirect(x, y, 0, hu_font[c]);

        else

            V_DrawPatch(x, y, 0, hu_font[c]);

        x+=w;

    }

    return x;

}

//

// M_WriteFile

//

#ifndef O_BINARY

#define O_BINARY 0

#endif

boolean

M_WriteFile

( char const*   name,

  void*         source,

  int           length )

{

    FILE       *handle;

    int         count;

    handle = fopen ( name, "wb");

    if (handle == NULL)

        return false;

  //  count = fwrite (source, 1, length, handle);

    fclose (handle);

    if (count < length)

        return false;

    return true;

}

//

// M_ReadFile

//

int

M_ReadFile

( char const*   name,

  byte**        buffer )

{

    FILE *handle;

    int count, length;

    byte        *buf;

    handle=0;

    buf=0;

    handle = fopen (name, "rb");

    if (handle == NULL)

        I_Error ("Couldn't read file %s", name);

    fseek(handle, 0, SEEK_END);

    length = ftell(handle);

    rewind(handle);

    buf = Z_Malloc (length, PU_STATIC, NULL);

    count = fread (buf, 1, length, handle);

    fclose (handle);

    if (count < length)

        I_Error ("Couldn't read file %s", name);

    *buffer = buf;

    return length;

}

//

// DEFAULTS

//

int             usemouse;

int             usejoystick;

extern int      key_right;

extern int      key_left;

extern int      key_up;

extern int      key_down;

extern int      key_strafeleft;

extern int      key_straferight;

extern int      key_fire;

extern int      key_use;

extern int      key_strafe;

extern int      key_speed;

extern int      mousebfire;

extern int      mousebstrafe;

extern int      mousebforward;

extern int      joybfire;

extern int      joybstrafe;

extern int      joybuse;

extern int      joybspeed;

extern int      viewwidth;

extern int      viewheight;

extern int      mouseSensitivity;

extern int      showMessages;

extern int      detailLevel;

extern int      screenblocks;

extern int      showMessages;

// machine-independent sound params

extern  int     numChannels;

extern char*    chat_macros[];

typedef struct

{

    char*       name;

    int*        location;

    int         defaultvalue;

    int         scantranslate;          // PC scan code hack

    int         untranslated;           // lousy hack

} default_t;

default_t       defaults[] =

{

    {"mouse_sensitivity",&mouseSensitivity, 5},

    {"sfx_volume",&snd_SfxVolume, 8},

    {"music_volume",&snd_MusicVolume, 8},

    {"show_messages",&showMessages, 1},

    {"key_right",&key_right, KEY_RIGHTARROW},

    {"key_left",&key_left, KEY_LEFTARROW},

    {"key_up",&key_up, KEY_UPARROW},

    {"key_down",&key_down, KEY_DOWNARROW},

//    {"key_right",&key_right, KEY_D},

//    {"key_left",&key_left, KEY_A},

//    {"key_up",&key_up, KEY_W},

//    {"key_down",&key_down, KEY_S},

    {"key_strafeleft",&key_strafeleft, ','},

    {"key_straferight",&key_straferight, '.'},

    {"key_fire",&key_fire, KEY_RCTRL},

    {"key_use",&key_use, ' '},

    {"key_strafe",&key_strafe, KEY_RALT},

    {"key_speed",&key_speed, KEY_RSHIFT},

    {"use_mouse",&usemouse, 1},

    {"mouseb_fire",&mousebfire,0},

    {"mouseb_strafe",&mousebstrafe,1},

    {"mouseb_forward",&mousebforward,2},

    {"use_joystick",&usejoystick, 0},

    {"joyb_fire",&joybfire,0},

    {"joyb_strafe",&joybstrafe,1},

    {"joyb_use",&joybuse,3},

    {"joyb_speed",&joybspeed,2},

    {"screenblocks",&screenblocks, 9},

    {"detaillevel",&detailLevel, 0},

    {"snd_channels",&numChannels, 3},

    {"usegamma",&usegamma, 0},

#ifndef __BEOS__

    {"chatmacro0", (int *) &chat_macros[0], (int) HUSTR_CHATMACRO0 },

    {"chatmacro1", (int *) &chat_macros[1], (int) HUSTR_CHATMACRO1 },

    {"chatmacro2", (int *) &chat_macros[2], (int) HUSTR_CHATMACRO2 },

    {"chatmacro3", (int *) &chat_macros[3], (int) HUSTR_CHATMACRO3 },

    {"chatmacro4", (int *) &chat_macros[4], (int) HUSTR_CHATMACRO4 },

    {"chatmacro5", (int *) &chat_macros[5], (int) HUSTR_CHATMACRO5 },

    {"chatmacro6", (int *) &chat_macros[6], (int) HUSTR_CHATMACRO6 },

    {"chatmacro7", (int *) &chat_macros[7], (int) HUSTR_CHATMACRO7 },

    {"chatmacro8", (int *) &chat_macros[8], (int) HUSTR_CHATMACRO8 },

    {"chatmacro9", (int *) &chat_macros[9], (int) HUSTR_CHATMACRO9 }

#endif

};

int     numdefaults;

char*   defaultfile;

//

// M_SaveDefaults

//

void M_SaveDefaults (void)

{

    int         i;

    int         v;

    FILE*       f;

    f = fopen (defaultfile, "w");

    if (!f)

        return; // can't write the file, but don't complain

    for (i=0 ; i

    {

        if (defaults[i].defaultvalue > -0xfff

            && defaults[i].defaultvalue < 0xfff)

        {

            v = *defaults[i].location;

            printf ("%s\t\t%i\n",defaults[i].name,v);

        } else {

            printf ("%s\t\t\"%s\"\n",defaults[i].name,

                     * (char **) (defaults[i].location));

        }

    }

    fclose (f);

}

//

// M_LoadDefaults

//

extern byte     scantokey[128];

size_t FileSize(FILE *handle);

void M_LoadDefaults (void)

{

    int         i;

    int         len;

    FILE*       f;

    char        def[80];

    char        strparm[100];

    char*       newstring;

    int         parm;

    boolean     isstring;

    char        *buf;

    char        *p;

    size_t val;

    // set everything to base values

    numdefaults = sizeof(defaults)/sizeof(defaults[0]);

    for (i=0 ; i

        *defaults[i].location = defaults[i].defaultvalue;

    // check for a custom default file

    i = M_CheckParm ("-config");

    if (i && i

    {

        defaultfile = myargv[i+1];

//      __libclog_printf ("     default file: %s\n",defaultfile);

    }

    else

        defaultfile = basedefault;

    // read the file in, overriding any set defaults

    f = fopen (defaultfile, "rb");

    if (f)

    {

      len=FileSize(f)+1;

      buf = malloc(len);

      memset(buf,0,len);

      val = fread(buf,1,len,f);

      fclose (f);

      p = buf;

      while(*p)

      {

        isstring = false;

        if (sscanf (p, "%79s %[^\n]\n", def, strparm) == 2)

        {

          if (strparm[0] == '"')

          {

                    // get a string default

            isstring = true;

            len = strlen(strparm);

            newstring = (char *) malloc(len);

            strparm[len-1] = 0;

            strcpy(newstring, strparm+1);

          }

          else

           if (strparm[0] == '0' && strparm[1] == 'x')

             sscanf(strparm+2, "%x", &parm);

           else

             sscanf(strparm, "%i", &parm);

           for (i=0 ; i

             if (!strcmp(def, defaults[i].name))

             {

               if (!isstring)

                 *defaults[i].location = parm;

               else

                 *defaults[i].location = (int) newstring;

               break;

             }

        };

        p=strchr(p, '\n')+1;

      };

      free(buf);

    };

};

//

// SCREEN SHOTS

//

typedef struct

{

    char                manufacturer;

    char                version;

    char                encoding;

    char                bits_per_pixel;

    unsigned short      xmin;

    unsigned short      ymin;

    unsigned short      xmax;

    unsigned short      ymax;

    unsigned short      hres;

    unsigned short      vres;

    unsigned char       palette[48];

    char                reserved;

    char                color_planes;

    unsigned short      bytes_per_line;

    unsigned short      palette_type;

    char                filler[58];

    unsigned char       data;           // unbounded

} pcx_t;

//

// WritePCXfile

//

void

WritePCXfile

( char*         filename,

  byte*         data,

  int           width,

  int           height,

  byte*         palette )

{

    int         i;

    int         length;

    pcx_t*      pcx;

    byte*       pack;

    pcx = Z_Malloc (width*height*2+1000, PU_STATIC, NULL);

    pcx->manufacturer = 0x0a;           // PCX id

    pcx->version = 5;                   // 256 color

    pcx->encoding = 1;                  // uncompressed

    pcx->bits_per_pixel = 8;            // 256 color

    pcx->xmin = 0;

    pcx->ymin = 0;

    pcx->xmax = SHORT(width-1);

    pcx->ymax = SHORT(height-1);

    pcx->hres = SHORT(width);

    pcx->vres = SHORT(height);

    memset (pcx->palette,0,sizeof(pcx->palette));

    pcx->color_planes = 1;              // chunky image

    pcx->bytes_per_line = SHORT(width);

    pcx->palette_type = SHORT(2);       // not a grey scale

    memset (pcx->filler,0,sizeof(pcx->filler));

    // pack the image

    pack = &pcx->data;

    for (i=0 ; i

    {

        if ( (*data & 0xc0) != 0xc0)

            *pack++ = *data++;

        else

        {

            *pack++ = 0xc1;

            *pack++ = *data++;

        }

    }

    // write the palette

    *pack++ = 0x0c;     // palette ID byte

    for (i=0 ; i<768 ; i++)

        *pack++ = *palette++;

    // write output file

    length = pack - (byte *)pcx;

    M_WriteFile (filename, pcx, length);

    Z_Free (pcx);

}

//

// M_ScreenShot

//

void M_ScreenShot (void)

{

    int         i;

    byte*       linear;

    char        lbmname[12];

    // munge planar buffer to linear

    linear = screens[2];

    I_ReadScreen (linear);

    // find a file name to save it to

    strcpy(lbmname,"DOOM00.pcx");

    for (i=0 ; i<=99 ; i++)

    {

        lbmname[4] = i/10 + '0';

        lbmname[5] = i%10 + '0';

        if (access(lbmname,0) == -1)

            break;      // file doesn't exist

    }

    if (i==100)

        I_Error ("M_ScreenShot: Couldn't create a PCX");

    // save the pcx file

    WritePCXfile (lbmname, linear,

                  SCREENWIDTH, SCREENHEIGHT,

                  W_CacheLumpName ("PLAYPAL",PU_CACHE));

    players[consoleplayer].message = "screen shot";

}