Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 325 → Rev 333

/programs/games/doom/trunk/d_main.c
31,27 → 31,11
#define FGCOLOR 8
 
 
#define R_OK 4
 
#include <stdio.h>
#include <stdlib.h>
 
extern int access(char *file, int mode);
 
#define R_OK 4
#if 0
static int access(char *file, int mode)
{
FILE *test_fp;
 
test_fp = fopen(file, "r");
if ( test_fp != NULL ) {
fclose(test_fp);
return(0);
}
return(-1);
}
#endif
 
 
#include "doomdef.h"
#include "doomstat.h"
 
58,7 → 42,6
#include "dstrings.h"
#include "sounds.h"
 
 
#include "z_zone.h"
#include "w_wad.h"
#include "s_sound.h"
86,8 → 69,13
#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,
243,9 → 231,7
if (gamestate != wipegamestate)
{
wipe = true;
XXX(4);
wipe_StartScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
XXX(5);
}
else
wipe = false;
253,9 → 239,7
 
if (gamestate == GS_LEVEL && gametic)
{
XXX(7);
HU_Erase();
XXX(8);
}
// do buffered drawing
XXX(9);
414,9 → 398,8
if (M_CheckParm ("-debugfile"))
{
char filename[20];
char filename[32];
sprintf (filename,"debug%i.txt",consoleplayer);
// __libclog_printf ("debug output to: %s\n",filename);
debugfile = fopen (filename,"w");
}
432,35 → 415,28
// process one or more tics
if (singletics)
{
XXX(201);
I_StartTic ();
XXX(202);
 
D_ProcessEvents ();
XXX(203);
 
G_BuildTiccmd (&netcmds[consoleplayer][maketic%BACKUPTICS]);
XXX(204);
if (advancedemo)
{
D_DoAdvanceDemo ();
XXX(205);
};
M_Ticker ();
XXX(206);
G_Ticker ();
gametic++;
maketic++;
}
else
{
XXX(102);
TryRunTics (); // will run at least one tic
XXX(103);
}
 
S_UpdateSounds (players[consoleplayer].mo);// move positional sounds
 
// Update display, next frame, with current state.
XXX(104);
D_Display ();
I_UpdateSound();
// I_UpdateSound();
XXX(105);
}
}
640,7 → 616,6
// 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);
656,12 → 631,11
// Bug, dear Shawn.
// Insufficient malloc, caused spurious realloc errors.
plutoniawad = malloc(strlen(doomwaddir)+1+/*9*/12+1);
sprintf(plutoniawad, "%s/plutonia.wad", doomwaddir);
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);
718,7 → 692,6
// C'est ridicule!
// Let's handle languages in config files, okay?
language = french;
// __libclog_printf("French version\n");
D_AddFile (doom2fwad);
return;
}
765,7 → 738,7
return;
}
 
// __libclog_printf("Game mode indeterminate.\n");
printf("Game mode indeterminate.\n");
gamemode = indetermined;
 
// We don't abort. Let's see what the PWAD contains.
802,12 → 775,12
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);
// 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++)
839,7 → 812,7
// DISPLAY ARGS
// __libclog_printf("%d command-line args:\n",myargc);
for (k=1;k<myargc;k++)
// for (k=1;k<myargc;k++)
// __libclog_printf("%s\n",myargv[k]);
 
break;
859,9 → 832,6
IdentifyVersion ();
 
// I_BeginSplash();
 
// setbuf (stdout, NULL);
modifiedgame = false;
nomonsters = M_CheckParm ("-nomonsters");
931,7 → 901,7
// __libclog_printf ("%s\n",title);
 
if (devparm)
// __libclog_printf(D_DEVSTR);
printf(D_DEVSTR);
// turbo option
if ( (p=M_CheckParm ("-turbo")) )
946,7 → 916,7
scale = 10;
if (scale > 400)
scale = 400;
// __libclog_printf ("turbo scale: %i%%\n",scale);
printf ("turbo scale: %i%%\n",scale);
forwardmove[0] = forwardmove[0]*scale/100;
forwardmove[1] = forwardmove[1]*scale/100;
sidemove[0] = sidemove[0]*scale/100;
971,8 → 941,6
case registered:
sprintf (file,"~"DEVMAPS"E%cM%c.wad",
myargv[p+1][0], myargv[p+2][0]);
// __libclog_printf("Warping to Episode %s, Map %s.\n",
// myargv[p+1],myargv[p+2]);
break;
case commercial:
1006,7 → 974,6
{
sprintf (file,"%s.lmp", myargv[p+1]);
D_AddFile (file);
printf("Playing demo %s.lmp.\n",myargv[p+1]);
}
// get skill / episode / map from parms
1015,7 → 982,6
startmap = 1;
autostart = false;
 
p = M_CheckParm ("-skill");
if (p && p < myargc-1)
{
1036,7 → 1002,6
{
int time;
time = atoi(myargv[p+1]);
printf("Levels will end after %d minute",time);
if (time>1)
printf("s");
printf(".\n");
1059,21 → 1024,20
autostart = true;
}
 
// init subsystems
printf ("V_Init: allocate screens.\n");
printf ("V_Init: allocate screens.\n\r");
V_Init ();
 
printf ("M_LoadDefaults: Load system defaults.\n");
printf ("M_LoadDefaults: Load system defaults.\n\r");
M_LoadDefaults (); // load before initing other systems
 
printf ("Z_Init: Init zone memory allocation daemon. \n");
printf ("Z_Init: Init zone memory allocation daemon. \n\r");
Z_Init ();
 
printf ("W_Init: Init WADfiles.\n");
printf ("W_Init: Init WADfiles.\n\r");
W_InitMultipleFiles (wadfiles);
printf("added\n");
 
// Check for -file in shareware
if (modifiedgame)
{
1088,7 → 1052,7
int i;
if ( gamemode == shareware)
I_Error("\nYou cannot -file with the shareware "
I_Error("\n\rYou cannot -file with the shareware "
"version. Register!");
 
// Check for fake IWAD with right name,
1096,20 → 1060,20
if (gamemode == registered)
for (i = 0;i < 23; i++)
if (W_CheckNumForName(name[i])<0)
I_Error("\nThis is not the registered version.");
I_Error("\n\rThis is not the registered version.");
}
// Iff additonal PWAD files are used, print modified banner
if (modifiedgame)
{
printf (
"===========================================================================\n"
"ATTENTION: This version of DOOM has been modified. If you would like to\n"
"get a copy of the original game, call 1-800-IDGAMES or see the readme file.\n"
" You will not receive technical support for modified games.\n"
" press enter to continue\n"
"===========================================================================\n"
);
// //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 ();
}
1119,21 → 1083,21
{
case shareware:
case indetermined:
printf (
"===========================================================================\n"
" Shareware!\n"
"===========================================================================\n"
);
// //printf (
// "===========================================================================\n\r"
// " Shareware!\n\r"
// "===========================================================================\n\r"
// );
break;
case registered:
case retail:
case commercial:
printf (
"===========================================================================\n"
" Commercial product - do not distribute!\n"
" Please report software piracy to the SPA: 1-800-388-PIR8\n"
"===========================================================================\n"
);
// //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:
1141,30 → 1105,28
break;
}
 
printf ("M_Init: Init miscellaneous info.\n");
printf ("M_Init: Init miscellaneous info.\n\r");
M_Init ();
 
printf ("R_Init: Init DOOM refresh daemon - ");
printf ("R_Init: Init DOOM refresh daemon - \n\r");
R_Init ();
 
printf ("\nP_Init: Init Playloop state.\n");
printf ("\nP_Init: Init Playloop state.\n\r");
P_Init ();
 
printf ("I_Init: Setting up machine state.\n");
printf ("I_Init: Setting up machine state.\n\r");
I_Init ();
 
printf ("D_CheckNetGame: Checking network game status.\n");
printf ("D_CheckNetGame: Checking network game status.\n\r");
D_CheckNetGame ();
 
printf ("S_Init: Setting up sound.\n");
S_Init (snd_SfxVolume /* *8 */, snd_MusicVolume /* *8*/ );
// 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");
printf ("HU_Init: Setting up heads up display.\n\r");
HU_Init ();
 
// I_EndSplash();
 
printf ("ST_Init: Init status bar.\n");
printf ("ST_Init: Init status bar.\n\r");
ST_Init ();
 
// check for a driver that wants intermission stats
1175,7 → 1137,7
extern void* statcopy;
 
statcopy = (void*)atoi(myargv[p+1]);
printf ("External statistics registered.\n");
//printf ("External statistics registered.\n\r");
}
// start the apropriate game based on parms
/programs/games/doom/trunk/d_net.c
674,8 → 674,7
frameon++;
 
if (debugfile)
fprintf (debugfile,
"=======real: %i avail: %i game: %i\n",
printf ( "=======real: %i avail: %i game: %i\n",
realtics, availabletics,counts);
 
if (!demoplayback)
/programs/games/doom/trunk/f_finale.c
28,8 → 28,8
#include <ctype.h>
 
// Functions.
#include "i_system.h"
#include "m_swap.h"
#include "i_system.h"
#include "z_zone.h"
#include "v_video.h"
#include "w_wad.h"
/programs/games/doom/trunk/g_game.c
253,9 → 253,9
consistancy[consoleplayer][maketic%BACKUPTICS];
 
strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe]
|| joybuttons[joybstrafe];
speed = gamekeydown[key_speed] || joybuttons[joybspeed];
strafe = gamekeydown[key_strafe]; // || mousebuttons[mousebstrafe]
// || joybuttons[joybstrafe];
speed = gamekeydown[key_speed]; // || joybuttons[joybspeed];
forward = side = 0;
312,13 → 312,13
}
if (gamekeydown[key_down])
{
// fprintf(stderr, "down\n");
forward -= forwardmove[speed];
// printf("forward= %d\n\r", forward);
}
if (joyymove < 0)
forward += forwardmove[speed];
if (joyymove > 0)
forward -= forwardmove[speed];
// if (joyymove < 0)
// forward += forwardmove[speed];
// if (joyymove > 0)
// forward -= forwardmove[speed];
if (gamekeydown[key_straferight])
side += sidemove[speed];
if (gamekeydown[key_strafeleft])
402,7 → 402,7
}
}
forward += mousey;
// forward += mousey;
if (strafe)
side += mousex*2;
else
705,10 → 705,10
{
case BTS_PAUSE:
paused ^= 1;
if (paused)
S_PauseSound ();
else
S_ResumeSound ();
// if (paused)
// S_PauseSound ();
// else
// S_ResumeSound ();
break;
case BTS_SAVEGAME:
882,8 → 882,8
, ss->sector->floorheight
, MT_TFOG);
if (players[consoleplayer].viewz != 1)
S_StartSound (mo, sfx_telept); // don't start sound on first frame
// if (players[consoleplayer].viewz != 1)
// S_StartSound (mo, sfx_telept); // don't start sound on first frame
return true;
}
1369,7 → 1369,7
if (paused)
{
paused = false;
S_ResumeSound ();
// S_ResumeSound ();
}
 
/programs/games/doom/trunk/hu_lib.c
25,11 → 25,10
 
#include <ctype.h>
 
#include "m_swap.h"
 
#include "doomdef.h"
 
#include "v_video.h"
#include "m_swap.h"
 
#include "hu_lib.h"
#include "r_local.h"
/programs/games/doom/trunk/i_main.c
24,24 → 24,32
static const char
rcsid[] = "$Id: i_main.c,v 1.4 1997/02/03 22:45:10 b1 Exp $";
 
 
//#include "SDL.h"
 
#include "doomdef.h"
 
#include "m_argv.h"
#include "d_main.h"
#include "kolibri.h"
 
int
main( int argc, char** argv)
int main(int argc, char **argv)
{
static char * tmp[]=
{"/hd/1/menuetos/doom/mdoom",
NULL};
// static char * tmp[]=
// {"/hd/1/menuetos/doom/mdoom",
// NULL};
myargc = 1;
myargv = tmp;
myargv = argv;
// chdir("/hd/1/menuetos/doom");
// InitHeap(32*1024*1024);
_asm
{
push ebx
push ecx
mov eax, 66
mov ebx, 1
mov ecx, 1
int 0x40
pop ecx
pop ebx
};
 
D_DoomMain ();
 
/programs/games/doom/trunk/i_net.c
1,3 → 1,4
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
9,6 → 10,18
#include "doomstat.h"
#include "i_net.h"
 
#ifdef DLHEAP
 
void* _cdecl dlmalloc(size_t);
void _cdecl dlfree(void*);
void _cdecl mf_init();
 
#define malloc dlmalloc
#define free dlfree
#define realloc dlrealloc
 
#endif
 
#ifndef B_HOST_IS_LENDIAN
#define B_HOST_IS_LENDIAN 1
#endif
56,6 → 69,7
 
static int first_user_port=IPPORT_USERRESERVED+0x1D+0x10;
 
/**********
int GetAvailPort(void)
{
int i,d0;
70,11 → 84,11
I_Error("Unable to get new port\n");
return -1;
}
**********/
 
 
int CreateInputUDPsocket(void)
{
int d0;
int d0=0;
//__asm__ __volatile__(
// "int $0x40"
// :"=a"(d0)
109,6 → 123,11
{
int c;
doomdata_t sw;
//printf("ERROR Packet Send\n\r");
 
// byte swap
sw.checksum = htonl(netbuffer->checksum);
sw.player = netbuffer->player;
158,6 → 177,7
//
// I_InitNetwork
//
 
void I_InitNetwork (void)
{
boolean trueval = true;
226,16 → 246,20
// __libclog_printf("DOOM: Input UDP socket is %d\n",insocket);
}
 
 
void I_NetCmd (void)
{
 
 
//printf("ERROR NetCmd");
 
 
if (doomcom->command == CMD_SEND)
{
netsend ();
// netsend ();
}
else if (doomcom->command == CMD_GET)
{
netget ();
// netget ();
}
else
I_Error ("Bad net cmd: %i\n",doomcom->command);
/programs/games/doom/trunk/i_sound.c
332,8 → 332,8
channels[i] = 0;
}
 
for (i=-128 ; i<128 ; i++)
steptablemid[i] = (int)(pow(2.0, (i/64.0))*65536.0);
// for (i=-128 ; i<128 ; i++)
// steptablemid[i] = (int)(pow(2.0, (i/64.0))*65536.0);
// Generates volume lookup tables
// which also turn the unsigned samples
515,7 → 515,7
leftout += step;
rightout += step;
}
I_SubmitSound(mixbuffer);
// I_SubmitSound(mixbuffer);
}
 
 
/programs/games/doom/trunk/i_system.c
26,8 → 26,6
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
//#include "SDL.h"
//#include "SDL_timer.h"
 
#include "doomdef.h"
#include "m_misc.h"
39,24 → 37,11
 
 
#include "i_system.h"
 
#include "kolibri.h"
 
int mb_used = 6;
int mb_used = 8;
 
 
int I_strncasecmp(char *str1, char *str2, int len)
{
char c1, c2;
 
while ( *str1 && *str2 && len-- ) {
c1 = *str1++;
c2 = *str2++;
if ( toupper(c1) != toupper(c2) )
return(1);
}
return(0);
}
 
void
I_Tactile
( int on,
91,22 → 76,18
// returns time in 1/35 second tics
//
 
__declspec(dllimport) unsigned int __stdcall GetTickCount(void);
 
int I_GetTime (void)
{
unsigned int tm;
// _asm
// {
// mov eax, 26
// mov ebx, 9
// int 0x40
// mov [tm], eax
// };
_asm
{ push ebx
mov eax, 26
mov ebx, 9
int 0x40
mov dword ptr [tm], eax
pop ebx
};
tm=GetTickCount()/10;
return (tm*TICRATE)/100;
}
 
118,7 → 99,7
void I_Init (void)
{
I_InitGraphics();
I_InitSound();
// I_InitSound();
}
 
//
148,6 → 129,7
{
}
 
/***********
byte* I_AllocLow(int length)
{
byte* mem;
156,8 → 138,8
memset (mem,0,length);
return mem;
}
************/
 
 
//
// I_Error
//
170,8 → 152,8
// Message first.
va_start (argptr,error);
printf ("Error: ");
printf (argptr);
printf ("\n");
printf (error,argptr);
printf ("\n\r");
va_end (argptr);
 
// Shutdown. Here might be other errors.
/programs/games/doom/trunk/i_video.c
26,9 → 26,7
 
#include <stdlib.h>
 
//#include "SDL.h"
 
//#include "m_swap.h"
#include "m_swap.h"
#include "doomstat.h"
#include "i_system.h"
#include "v_video.h"
36,14 → 34,16
#include "d_main.h"
 
#include "doomdef.h"
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
 
#include "kolibri.h"
 
void BlitDIB();
 
typedef struct SURFACE
{
unsigned char *pixels;
int w, h;
int pitch;
unsigned char *pixels;
int offset;
} SURFACE;
58,113 → 58,30
// to use ....
static int multiply=2;
 
void WinError(char *msg);
static int disableVerticalMouse = 0;
 
static int scr_w =0;
static int scr_h =0;
static int win_x, win_y;
static int win_w, win_h;
 
int BPP;
byte *hicolortable;
short hicolortransmask1,hicolortransmask2;
int X_width;
int X_height;
static int disableVerticalMouse = 0;
static int closed=0;
static int windowActive = 0;
 
HWND win;
static HINSTANCE inst;
static HDC dibDC;
static LOGPALETTE *palette;
static HPALETTE dibPal;
BITMAPINFO *bminfo;
static unsigned char *dibData;
static int bits8;
int palette_color[256];
 
//int palette_color[256];
 
 
static int lastmousex = 0;
static int lastmousey = 0;
boolean mousemoved = false;
boolean shmFinished;
 
 
 
//
// Translates the key
//
 
/*******
int xlatekey(SDL_keysym *key)
void I_ShutdownGraphics(void)
{
 
int rc;
 
switch(key->sym)
{
case SDLK_LEFT: rc = KEY_LEFTARROW; break;
case SDLK_RIGHT: rc = KEY_RIGHTARROW; break;
case SDLK_DOWN: rc = KEY_DOWNARROW; break;
case SDLK_UP: rc = KEY_UPARROW; break;
case SDLK_ESCAPE: rc = KEY_ESCAPE; break;
case SDLK_RETURN: rc = KEY_ENTER; break;
case SDLK_TAB: rc = KEY_TAB; break;
case SDLK_F1: rc = KEY_F1; break;
case SDLK_F2: rc = KEY_F2; break;
case SDLK_F3: rc = KEY_F3; break;
case SDLK_F4: rc = KEY_F4; break;
case SDLK_F5: rc = KEY_F5; break;
case SDLK_F6: rc = KEY_F6; break;
case SDLK_F7: rc = KEY_F7; break;
case SDLK_F8: rc = KEY_F8; break;
case SDLK_F9: rc = KEY_F9; break;
case SDLK_F10: rc = KEY_F10; break;
case SDLK_F11: rc = KEY_F11; break;
case SDLK_F12: rc = KEY_F12; break;
case SDLK_BACKSPACE:
case SDLK_DELETE: rc = KEY_BACKSPACE; break;
 
case SDLK_PAUSE: rc = KEY_PAUSE; break;
 
case SDLK_EQUALS: rc = KEY_EQUALS; break;
 
case SDLK_KP_MINUS:
case SDLK_MINUS: rc = KEY_MINUS; break;
 
case SDLK_LSHIFT:
case SDLK_RSHIFT:
rc = KEY_RSHIFT;
break;
case 'z':
case SDLK_LCTRL:
case SDLK_RCTRL:
rc = KEY_RCTRL;
break;
case SDLK_LALT:
case SDLK_LMETA:
case SDLK_RALT:
case SDLK_RMETA:
rc = KEY_RALT;
break;
default:
rc = key->sym;
break;
}
 
return rc;
 
}
**********/
 
void I_ShutdownGraphics(void)
{
// SDL_Quit();
}
 
 
 
//
// I_StartFrame
//
172,110 → 89,90
{
// er?
 
}
//printf("start new frame\n\r" );
 
/* This processes SDL events */
/*****
void I_GetEvent(SDL_Event *Event)
{
Uint8 buttonstate;
event_t event;
 
switch (Event->type)
{
case SDL_KEYDOWN:
event.type = ev_keydown;
event.data1 = xlatekey(&Event->key.keysym);
D_PostEvent(&event);
break;
case SDL_KEYUP:
event.type = ev_keyup;
event.data1 = xlatekey(&Event->key.keysym);
D_PostEvent(&event);
break;
case SDL_QUIT:
I_Quit();
break;
}
}
 
*******/
int test_for_event(void)
{ int retval;
_asm
{ push ebx
push ecx
push edx
push esi
push edi
mov eax,11
int 0x40
mov [retval], eax
pop edi
pop esi
pop edx
pop ecx
pop ebx
};
return retval;
};
 
 
 
 
void I_GetEvent(void)
{
MSG msg;
POINT point;
static LONG prevX, prevY;
static int hadMouse = 0;
event_t event;
RECT rect;
int lb, rb;
static int prevlb = 0, prevrb = 0;
event_t evnt;
int val;
int key;
//printf("begin get_event()\n\r");
do
{ val= test_for_event();
switch(val)
{ case EV_REDRAW:
BeginDraw();
DrawWindow(win_x,win_y,win_w,win_h,0x404040,3,0,0,0);
EndDraw();
BlitDIB();
break;
/* Dispatch all messages: */
while ( PeekMessage(&msg, NULL, 0, 0xFFFFFFFF, PM_REMOVE) )
case EV_KEY:
if(!get_key(&key))
{
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
switch(key)
{ case 0xE0:
case 0xE1:
continue;
default:
if(key&0x80)
{ //printf("key released\n\r");
evnt.type = ev_keyup;
}
else
{ //printf("key pressed %x\n\r",key);
evnt.type = ev_keydown;
};
key&=0x7F;
evnt.data1=remap_key(key);
if ( evnt.data1 != 0 )
D_PostEvent(&evnt);
continue;
};
};
continue;
 
/* Check mouse and generate events if necessary: */
if ( !GetCursorPos(&point) )
WinError("GetCursorPos() failed");
if ( hadMouse && windowActive)
{
lb = (GetAsyncKeyState(VK_LBUTTON) < 0);
rb = (GetAsyncKeyState(VK_RBUTTON) < 0);
case EV_BUTTON:
switch(get_button_id())
{ case 1:
return;
if ( (prevX != point.x) || (prevY != point.y) ||
(prevlb != lb) || (prevrb != rb) )
{
event.type = ev_mouse;
event.data1 = lb | (rb << 1);
event.data2 = (point.x - prevX)*9;
if ( disableVerticalMouse )
event.data3 = 0;
else
event.data3 = (prevY - point.y)*9;
prevX = point.x;
prevY = point.y;
prevlb = lb;
prevrb = rb;
D_PostEvent(&event);
default:;
};
};
}while(val);
}
 
if ( grabMouse )
{
GetWindowRect(win, &rect);
if ( !SetCursorPos((rect.left + rect.right) / 2,
(rect.top + rect.bottom) / 2) )
WinError("SetCursorPos() failed");
prevX = (rect.left + rect.right) / 2;
prevY = (rect.top + rect.bottom) / 2;
}
}
else
{
prevX = point.x;
prevY = point.y;
hadMouse = 1;
}
}
 
 
 
//
// I_StartTic
//
void I_StartTic (void)
{
// SDL_Event Event;
 
// while ( SDL_PollEvent(&Event) )
// I_GetEvent(&Event);
I_GetEvent();
 
}
302,136 → 199,49
// I_SetPalette
//
 
typedef struct SDL_Color
{
byte r;
byte g;
byte b;
byte unused;
} SDL_Color;
unsigned int colors[256];
 
SDL_Color colors[256];
 
void I_SetPalette (byte* palette)
{
int i;
RGBQUAD *rgb;
unsigned int r;
unsigned int g;
unsigned int b;
 
//
// for ( i=0; i<256; ++i ) {
// colors[i].r = gammatable[usegamma][*palette++];
// colors[i].g = gammatable[usegamma][*palette++];
// colors[i].b = gammatable[usegamma][*palette++];
// colors[i].unused = 0;
// }
// SDL_SetColors(screen, colors, 0, 256);
 
rgb = bminfo->bmiColors;
for ( i = 0; i < 256; i++ )
for ( i=0; i<256; ++i )
{
rgb->rgbRed = gammatable[usegamma][*palette++];
rgb->rgbGreen = gammatable[usegamma][*palette++];
rgb->rgbBlue = gammatable[usegamma][*palette++];
rgb->rgbReserved = 0;
rgb++;
};
 
 
r = gammatable[usegamma][*palette++];
g = gammatable[usegamma][*palette++];
b = gammatable[usegamma][*palette++];
colors[i]= b|(g<<8)|(r<<16);
}
 
 
 
int makecol(int r, int g, int b)
{
// assert(BPP==2);
return (b >> 3) | ((g >> 3) << 5) | ((r >> 3) << 10);
}
 
int TranslateKey(unsigned k)
{
/*wtf? if ( (k >= VK_0) && (k <= VK_9) )*/
if ( (k >= 0x30) && (k <= 0x39) )
return (k - 0x30 + '0');
if ( (k >= 0x41) && (k <= 0x5a) )
return (k - 0x41 + 'a');
void BeginDraw()
{ _asm
{ push ebx
mov eax,12
mov ebx, 1
int 0x40
pop ebx
};
};
 
#define K(a,b) case a: return b;
switch ( k )
{
K(VK_LEFT, KEY_LEFTARROW);
K(VK_RIGHT, KEY_RIGHTARROW);
K(VK_UP, KEY_UPARROW);
K(VK_DOWN, KEY_DOWNARROW);
K(VK_BACK, KEY_BACKSPACE);
K(VK_TAB, KEY_TAB);
K(VK_RETURN, KEY_ENTER);
K(VK_SHIFT, KEY_RSHIFT);
K(VK_CONTROL, KEY_RCTRL);
K(VK_MENU, KEY_RALT);
K(VK_PAUSE, KEY_PAUSE);
K(VK_ESCAPE, KEY_ESCAPE);
K(VK_SPACE, ' ');
K(VK_DELETE, KEY_BACKSPACE);
K(VK_ADD, '+');
K(VK_SUBTRACT, KEY_MINUS);
K(0xBC, ',');
K(0xBE, '.');
K(VK_F1, KEY_F1);
K(VK_F2, KEY_F2);
K(VK_F3, KEY_F3);
K(VK_F4, KEY_F4);
K(VK_F5, KEY_F5);
K(VK_F6, KEY_F6);
K(VK_F7, KEY_F7);
K(VK_F8, KEY_F8);
K(VK_F9, KEY_F9);
K(VK_F10, KEY_F10);
K(VK_F11, KEY_F11);
K(VK_F12, KEY_F12);
}
void EndDraw()
{ _asm
{ push ebx
mov eax,12
mov ebx, 2
int 0x40
pop ebx
};
};
 
return 0;
}
 
void WinError(char *msg)
{
printf("Windows Error: %s, GetLastError(): %u\n", msg, GetLastError());
exit(EXIT_FAILURE);
}
 
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam);
 
void BlitDIB(void)
{
RECT rect;
 
GetClientRect(win, &rect);
if ( StretchDIBits(dibDC, rect.left, rect.top, rect.right-rect.left,
rect.bottom-rect.top, 0, 0, SCREENWIDTH*2,
SCREENHEIGHT*2, dibData, bminfo, DIB_RGB_COLORS,
SRCCOPY)
== GDI_ERROR )
WinError("StrecthDIBits failed");
GdiFlush();
}
 
void I_InitGraphics(void)
{
static int firsttime=1;
WNDCLASS wc;
unsigned i, x, y, j;
WORD *d;
unsigned char *b;
int bits;
int frameX, frameY, capY;
RECT rect;
int width, height;
RGBQUAD *rgb;
int retval;
int frameX, frameY;
 
if (!firsttime)
return;
446,8 → 256,8
if (M_CheckParm("-4"))
multiply = 4;
 
X_width = SCREENWIDTH * multiply;
X_height = SCREENHEIGHT * multiply;
win_w = SCREENWIDTH * multiply;
win_h = SCREENHEIGHT * multiply;
 
// check if the user wants to grab the mouse (quite unnice)
grabMouse = !!M_CheckParm("-grabmouse");
458,409 → 268,111
 
/* Build and initialize the window: */
inst = (HINSTANCE) GetModuleHandle(NULL);
frameX = 0;
frameY = 18;
 
frameX = GetSystemMetrics(SM_CXFRAME);
frameY = GetSystemMetrics(SM_CYFRAME);
capY = GetSystemMetrics(SM_CYCAPTION);
GetScreenSize(&scr_w, &scr_h);
win_x = (scr_w-win_w)/2;
win_y = (scr_h-win_h)/2;
 
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = inst;
wc.hIcon = NULL;
if ( grabMouse )
wc.hCursor = LoadCursor( 0, IDC_ARROW );
else
wc.hCursor = LoadCursor( 0, IDC_ARROW );
/*wc.hbrBackground = GetStockObject( WHITE_BRUSH );*/
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = "DoomWindowClass";
// hCursor = LoadCursor( 0, IDC_ARROW );
 
retval= RegisterClass(&wc);
printf("I_InitGraphics: Client area: %ux%u\n\r", win_w, win_h);
 
width = X_width + 2*frameX;
height = X_height + 2*frameY + capY;
 
win = CreateWindow("DoomWindowClass", "NTDOOM",
WS_OVERLAPPEDWINDOW | WS_VISIBLE, 200, 200, width, height,
NULL, NULL, inst, NULL);
 
/* Display the window: */
ShowWindow(win, SW_SHOW);
UpdateWindow(win);
 
GetClientRect(win, &rect);
printf("I_InitGraphics: Client area: %ux%u\n",
rect.right-rect.left, rect.bottom-rect.top);
 
if ( (rect.right-rect.left) != X_width )
{
printf("I_InitGraphics: Fixing width\n");
width += X_width - (rect.right-rect.left);
MoveWindow(win, 0, 0, width, height, TRUE);
}
if ( (rect.bottom-rect.top) != X_height )
{
printf("I_InitGraphics: Fixing height\n");
height += X_height - (rect.bottom-rect.top);
MoveWindow(win, 0, 0, width, height, TRUE);
}
 
GetClientRect(win, &rect);
printf("I_InitGraphics: Client area: %ux%u\n",
rect.right-rect.left, rect.bottom-rect.top);
dibDC = GetDC(win);
BPP=1;
bits = 8; //GetDeviceCaps(dibDC, BITSPIXEL);
printf("I_InitGraphics: %i bpp screen\n", bits);
 
if ( BPP == 1 )
bminfo = malloc(sizeof(BITMAPINFOHEADER) + 4*256);
else
bminfo = malloc(sizeof(BITMAPINFOHEADER));
 
if ( BPP == 1 )
{
rgb = bminfo->bmiColors;
for ( i = 0; i < 256; i++ )
{
rgb->rgbRed = i;
rgb->rgbGreen = i;
rgb->rgbBlue = i;
rgb->rgbReserved = 0;
rgb++;
}
}
bminfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bminfo->bmiHeader.biWidth = 640; X_width;
bminfo->bmiHeader.biHeight = -400 ;X_height;
bminfo->bmiHeader.biPlanes = 1;
if ( BPP == 1 )
bminfo->bmiHeader.biBitCount = 8;
else
bminfo->bmiHeader.biBitCount = 16;
bminfo->bmiHeader.biCompression = BI_RGB;
bminfo->bmiHeader.biSizeImage = 0;
bminfo->bmiHeader.biXPelsPerMeter = 0;
bminfo->bmiHeader.biYPelsPerMeter = 0;
bminfo->bmiHeader.biClrUsed = 0;
bminfo->bmiHeader.biClrImportant = 0;
dibData = malloc(640*400*BPP);
 
// BlitDIB();
 
screen.pixels=(unsigned char *) (dibData);
screen.h=400;
screen.w=640;
screen.pixels= (byte*) UserAlloc(640*400*4);
screen.h = win_w;
screen.w = win_h;
screen.pitch=640;
// screens[0] = malloc(320*200);
BeginDraw();
DrawWindow(win_x,win_y,win_w,win_h,0x404040,3,0,0,0);
EndDraw();
 
/* Build magic highcolor table: */
if (BPP==2)
{
byte *tempptr, *tempptr2;
 
tempptr=hicolortable=(byte *)malloc(256*32*9);
for (i=0;i<32;i++)
{
for (j=0;j<256;j++)
{
*tempptr=j*gammatable[3][i*(256/32)]/256;
tempptr++;
}
}
for (i=1;i<=8;i++)
{
tempptr2=hicolortable;
for (j=0;j<(256*32);j++)
{
*tempptr=(byte)(((int)(*tempptr2))*(8-i)/8);
tempptr++; tempptr2++;
}
}
hicolortransmask1=makecol(127,127,127);
hicolortransmask2=makecol(63,63,63);
}
}
 
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
WPARAM wparam, LPARAM lparam)
{
event_t event;
RECT rect;
switch ( message )
{
case WM_DESTROY:
if ( grabMouse )
{
ClipCursor(NULL);
ShowCursor(TRUE);
}
printf("WM_DESTROY\n");
PostQuitMessage(0);
closed = 1;
break;
void conv(char *dst, char *src);
 
case WM_MOVE:
GetWindowRect(win, &rect);
printf("%u,%u - %u, %u\n",
rect.left,rect.top,rect.right,rect.bottom);
ClipCursor(&rect);
break;
 
case WM_ACTIVATE:
printf("WM_ACTIVATE %u\n", (unsigned) LOWORD(wparam));
if ( LOWORD(wparam) )
void BlitDIB()
{
if ( !windowActive )
{
if ( grabMouse )
{
ClipCursor(NULL); /* helps with Win95? */
GetWindowRect(win, &rect);
printf("%u,%u - %u, %u\n",
rect.left,rect.top,rect.right,rect.bottom);
ClipCursor(&rect);
ShowCursor(FALSE);
_asm
{ push ebx
push ecx
push edx
mov eax, 7
mov ebx, dword ptr [screen]
mov ecx, 0x02800190
xor edx, edx
int 0x40
pop edx
pop ecx
pop ebx
}
}
windowActive = 1;
if ( bits8 )
{
if ( SetPaletteEntries(dibPal, 0, 256, palette->palPalEntry) != 256 )
WinError("SetPaletteEntries failed");
if ( !UnrealizeObject(dibPal) )
WinError("UnrealizeObject failed");
if ( SelectPalette(dibDC, dibPal, FALSE) == NULL )
WinError("SelectPalette failed");
}
}
else
{
if ( grabMouse )
{
ClipCursor(NULL);
ShowCursor(TRUE);
}
windowActive = 0;
}
return DefWindowProc(hwnd, message, wparam, lparam);
};
 
case WM_KEYDOWN:
event.type = ev_keydown;
event.data1 = TranslateKey(wparam);
if ( event.data1 != 0 )
D_PostEvent(&event);
break;
 
case WM_KEYUP:
event.type = ev_keyup;
event.data1 = TranslateKey(wparam);
if ( event.data1 != 0 )
D_PostEvent(&event);
break;
default:
return(DefWindowProc(hwnd, message, wparam, lparam));
}
 
return 0;
}
 
//
// I_FinishUpdate
//
void I_FinishUpdate (void)
{
char *dst0;
char *dst1;
char *src;
 
static int lasttic;
int tics;
int i;
int x, y;
 
// draws little dots on the bottom of the screen
if (devparm)
{ i = I_GetTime();
tics = i - lasttic;
lasttic = i;
if (tics > 20)
tics = 20;
 
for (i=0 ; i<tics*2 ; i+=2)
screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
for ( ; i<20*2 ; i+=2)
screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
}
 
// scales the screen size before blitting it
if (multiply == 1)
{
unsigned char *olineptr;
unsigned char *ilineptr;
int y;
 
ilineptr = (unsigned char *) screens[0];
olineptr = (unsigned char *) screen.pixels;
 
dst0 = &((char *)screen.pixels)[0];
dst1 = dst0+640*3;
src= (char*)screens[0];
y = SCREENHEIGHT;
while (y--)
{
memcpy(olineptr, ilineptr, screen.w);
ilineptr += SCREENWIDTH;
olineptr += screen.pitch;
}
}
else if (multiply == 2)
{
unsigned int *olineptrs[2];
unsigned int *ilineptr;
int x, y, i;
unsigned int twoopixels;
unsigned int twomoreopixels;
unsigned int fouripixels;
 
ilineptr = (unsigned int *) (screens[0]);
for (i=0 ; i<2 ; i++) {
olineptrs[i] =
(unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
}
 
y = SCREENHEIGHT;
while (y--)
{
x = SCREENWIDTH;
do
{
fouripixels = *ilineptr++;
twoopixels = (fouripixels & 0xff000000)
| ((fouripixels>>8) & 0xffff00)
| ((fouripixels>>16) & 0xff);
twomoreopixels = ((fouripixels<<16) & 0xff000000)
| ((fouripixels<<8) & 0xffff00)
| (fouripixels & 0xff);
*olineptrs[0]++ = twomoreopixels;
*olineptrs[1]++ = twomoreopixels;
*olineptrs[0]++ = twoopixels;
*olineptrs[1]++ = twoopixels;
} while (x-=4);
olineptrs[0] += screen.pitch/4;
olineptrs[1] += screen.pitch/4;
conv(dst0,src);
src+=320;
dst0+=640*3*2;
dst1+=640*3*2;
}
 
BlitDIB();
}
else if (multiply == 3)
{
unsigned int *olineptrs[3];
unsigned int *ilineptr;
int x, y, i;
unsigned int fouropixels[3];
unsigned int fouripixels;
 
ilineptr = (unsigned int *) (screens[0]);
for (i=0 ; i<3 ; i++) {
olineptrs[i] =
(unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
}
 
y = SCREENHEIGHT;
while (y--)
void conv(char *dst, char *src)
{
x = SCREENWIDTH;
do
_asm
{
fouripixels = *ilineptr++;
fouropixels[0] = (fouripixels & 0xff000000)
| ((fouripixels>>8) & 0xff0000)
| ((fouripixels>>16) & 0xffff);
fouropixels[1] = ((fouripixels<<8) & 0xff000000)
| (fouripixels & 0xffff00)
| ((fouripixels>>8) & 0xff);
fouropixels[2] = ((fouripixels<<16) & 0xffff0000)
| ((fouripixels<<8) & 0xff00)
| (fouripixels & 0xff);
*olineptrs[0]++ = fouropixels[2];
*olineptrs[1]++ = fouropixels[2];
*olineptrs[2]++ = fouropixels[2];
*olineptrs[0]++ = fouropixels[1];
*olineptrs[1]++ = fouropixels[1];
*olineptrs[2]++ = fouropixels[1];
*olineptrs[0]++ = fouropixels[0];
*olineptrs[1]++ = fouropixels[0];
*olineptrs[2]++ = fouropixels[0];
} while (x-=4);
olineptrs[0] += 2*screen.pitch/4;
olineptrs[1] += 2*screen.pitch/4;
olineptrs[2] += 2*screen.pitch/4;
}
push ebx
push ecx
push esi
push edi
 
}
BlitDIB();
}
mov ecx, 320
mov esi, [src]
mov edi, [dst]
cld
l1:
lodsb
movzx eax, al
mov eax, [colors+eax*4]
mov ebx, eax
bswap ebx
and ebx, 0xFF000000
or eax, ebx
mov [edi],eax
mov [edi+640*3], eax
shr eax, 8
mov [edi+4], ax
mov [edi+640*3+4], ax
add edi, 6
dec ecx
jnz l1
 
pop edi
pop esi
pop ecx
pop ebx
};
};
 
 
 
/**
void I_InitGraphics(void)
{
 
static int firsttime=1;
int video_w, video_h, w, h;
byte video_bpp;
unsigned int video_flags;
 
if (!firsttime)
return;
firsttime = 0;
 
video_flags = (SDL_SWSURFACE|SDL_HWPALETTE);
if (!!M_CheckParm("-fullscreen"))
video_flags |= SDL_FULLSCREEN;
 
if (M_CheckParm("-2"))
multiply = 2;
 
if (M_CheckParm("-3"))
multiply = 3;
 
// check if the user wants to grab the mouse (quite unnice)
grabMouse = !!M_CheckParm("-grabmouse");
 
video_w = w = SCREENWIDTH * multiply;
video_h = h = SCREENHEIGHT * multiply;
video_bpp = 8;
 
if ( multiply > 3 ) {
I_Error("Smallest available mode (%dx%d) is too large!",
video_w, video_h);
}
screen = SDL_SetVideoMode(video_w, video_h, 8, video_flags);
if ( screen == NULL ) {
I_Error("Could not set %dx%d video mode: %s", video_w, video_h,
SDL_GetError());
}
SDL_ShowCursor(0);
SDL_WM_SetCaption("MenuetOS-DOOM", "doom");
 
w = SCREENWIDTH * multiply;
h = SCREENHEIGHT * multiply;
if (multiply == 1 && !SDL_MUSTLOCK(screen) ) {
screens[0] = (unsigned char *) screen->pixels;
} else {
screens[0] = (unsigned char *) malloc (SCREENWIDTH * SCREENHEIGHT);
if ( screens[0] == NULL )
I_Error("Couldn't allocate screen memory");
}
}
*****/
/programs/games/doom/trunk/m_argv.c
26,8 → 26,6
 
#include <string.h>
 
#include "i_system.h"
 
int myargc;
char** myargv;
 
46,7 → 44,7
 
for (i = 1;i<myargc;i++)
{
if ( !I_strncasecmp(check, myargv[i], strlen(check)) )
if ( !strnicmp(check, myargv[i], strlen(check)) )
return i;
}
 
/programs/games/doom/trunk/m_misc.c
29,8 → 29,9
 
#include <stdlib.h>
#include <ctype.h>
//#include "//kolibc.h"
 
extern int access(char *file, int mode);
//extern int access(char *file, int mode);
 
#include "doomdef.h"
 
119,7 → 120,7
if (handle == NULL)
return false;
 
count = fwrite (source, 1, length, handle);
// count = fwrite (source, 1, length, handle);
fclose (handle);
if (count < length)
141,6 → 142,9
int count, length;
byte *buf;
handle=0;
buf=0;
handle = fopen (name, "rb");
if (handle == NULL)
I_Error ("Couldn't read file %s", name);
228,6 → 232,12
{"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, '.'},
 
310,6 → 320,8
//
extern byte scantokey[128];
 
size_t FileSize(FILE *handle);
 
void M_LoadDefaults (void)
{
int i;
320,7 → 332,10
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<numdefaults ; i++)
335,15 → 350,24
}
else
defaultfile = basedefault;
/**********
 
// read the file in, overriding any set defaults
f = fopen (defaultfile, "r");
f = fopen (defaultfile, "rb");
if (f)
{
while (!feof(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 (fscanf (f, "%79s %[^\n]\n", def, strparm) == 2)
 
if (sscanf (p, "%79s %[^\n]\n", def, strparm) == 2)
{
if (strparm[0] == '"')
{
354,7 → 378,8
strparm[len-1] = 0;
strcpy(newstring, strparm+1);
}
else if (strparm[0] == '0' && strparm[1] == 'x')
else
if (strparm[0] == '0' && strparm[1] == 'x')
sscanf(strparm+2, "%x", &parm);
else
sscanf(strparm, "%i", &parm);
364,19 → 389,19
if (!isstring)
*defaults[i].location = parm;
else
*defaults[i].location =
(int) newstring;
*defaults[i].location = (int) newstring;
break;
}
}
}
};
p=strchr(p, '\n')+1;
};
free(buf);
};
};
fclose (f);
}
**********/
}
 
 
 
//
// SCREEN SHOTS
//
/programs/games/doom/trunk/m_swap.c
31,6 → 31,9
#include "m_swap.h"
 
 
// Not needed with big endian.
#ifndef __BIG_ENDIAN__
 
// Swap 16bit, that is, MSB and LSB byte.
unsigned short SwapSHORT(unsigned short x)
{
49,3 → 52,6
}
 
 
#endif
 
 
/programs/games/doom/trunk/r_data.c
27,19 → 27,11
static const char
rcsid[] = "$Id: r_data.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
 
#ifdef __BEOS__
#ifdef __GNUC__
extern void *alloca(int);
#else
#include <alloca.h>
#endif
#endif /* __BEOS__ */
#include "i_system.h"
#include "z_zone.h"
 
#include "m_swap.h"
 
#include "i_system.h"
#include "z_zone.h"
 
#include "w_wad.h"
 
#include "doomdef.h"
49,8 → 41,11
#include "doomstat.h"
#include "r_sky.h"
 
#include <malloc.h>
 
 
#include "r_data.h"
#include <malloc.h>
 
//
// Graphics.
// DOOM graphics for walls and sprites
122,7 → 117,7
// All the patches[patchcount]
// are drawn back to front into the cached texture.
short patchcount;
short int patchcount;
texpatch_t patches[1];
} texture_t;
291,6 → 286,8
Z_ChangeTag (block, PU_CACHE);
}
 
 
 
//
// R_GenerateLookup
//
531,17 → 528,7
texture->height = SHORT(mtexture->height);
texture->patchcount = SHORT(mtexture->patchcount);
 
// memcpy() generates a BUS error on Solaris with optimization on */
#if 1
memcpy (texture->name, mtexture->name, sizeof(texture->name));
#else
{ char *src; char *dst;
src = (char *)mtexture->name;
dst = (char *)texture->name;
for (j=0; j<sizeof(texture->name); ++j )
*dst++ = *src++;
}
#endif
mpatch = &mtexture->patches[0];
patch = &texture->patches[0];
 
665,13 → 652,13
void R_InitData (void)
{
R_InitTextures ();
printf ("\nInitTextures");
printf ("InitTextures\n\r");
R_InitFlats ();
printf ("\nInitFlats");
printf ("InitFlats\n\r");
R_InitSpriteLumps ();
printf ("\nInitSprites");
printf ("InitSprites\n\r");
R_InitColormaps ();
printf ("\nInitColormaps");
printf ("InitColormaps\n\r");
}
 
 
713,14 → 700,12
return 0;
for (i=0 ; i<numtextures ; i++)
if (!I_strncasecmp (textures[i]->name, name, 8) )
if (!strnicmp (textures[i]->name, name, 8) )
return i;
return -1;
}
 
 
 
//
// R_TextureNumForName
// Calls R_CheckTextureNumForName,
/programs/games/doom/trunk/r_main.c
24,7 → 24,7
//-----------------------------------------------------------------------------
 
 
static const char rcsid[] = "$Id: r_main.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
//static const char rcsid[] = "$Id: r_main.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
 
 
 
773,22 → 773,22
void R_Init (void)
{
R_InitData ();
printf ("\nR_InitData");
printf ("R_InitData\n\r");
R_InitPointToAngle ();
printf ("\nR_InitPointToAngle");
printf ("R_InitPointToAngle\n\r");
R_InitTables ();
// viewwidth / viewheight / detailLevel are set by the defaults
printf ("\nR_InitTables");
printf ("R_InitTables\n\r");
 
R_SetViewSize (screenblocks, detailLevel);
R_InitPlanes ();
printf ("\nR_InitPlanes");
printf ("R_InitPlanes\n\r");
R_InitLightTables ();
printf ("\nR_InitLightTables");
printf ("R_InitLightTables\n\r");
R_InitSkyMap ();
printf ("\nR_InitSkyMap");
printf ("R_InitSkyMap\n\r");
R_InitTranslationTables ();
printf ("\nR_InitTranslationsTables");
printf ("R_InitTranslationsTables\n\r");
framecount = 0;
}
/programs/games/doom/trunk/s_sound.c
169,7 → 169,7
 
printf("S_Init: default sfx volume %d\n", sfxVolume);
 
I_CreateSound();
//I_CreateSound();
numChannels = NUM_CHANNELS;
 
// Whatever these did with DMX, these are rather dummies now.
372,8 → 372,7
// Assigns the handle to one of the channels in the
// mix/output buffer.
//WriteDebug("I_StartSound...\n");
channels[cnum].handle = I_StartSound(sfx_id,/*sfx->data,*/volume,sep,pitch,priority,origin);
//cnum = I_StartSound(sfx_id,/*sfx->data,*/volume,sep,pitch,priority,origin);
channels[cnum].handle = I_StartSound(sfx_id,volume,sep,pitch,priority);
channels[cnum].handle = cnum;
channels[cnum].sfxinfo = sfx;
channels[cnum].origin = origin;
/programs/games/doom/trunk/st_lib.c
32,6 → 32,8
#include "z_zone.h"
#include "v_video.h"
 
#include "m_swap.h"
 
#include "i_system.h"
 
#include "w_wad.h"
94,8 → 96,8
int numdigits = n->width;
int num = *n->num;
int w = (n->p[0]->width);
int h = (n->p[0]->height);
int w = SHORT(n->p[0]->width);
int h = SHORT(n->p[0]->height);
int x = n->x;
int neg;
222,10 → 224,10
{
if (mi->oldinum != -1)
{
x = mi->x - (mi->p[mi->oldinum]->leftoffset);
y = mi->y - (mi->p[mi->oldinum]->topoffset);
w = (mi->p[mi->oldinum]->width);
h = (mi->p[mi->oldinum]->height);
x = mi->x - SHORT(mi->p[mi->oldinum]->leftoffset);
y = mi->y - SHORT(mi->p[mi->oldinum]->topoffset);
w = SHORT(mi->p[mi->oldinum]->width);
h = SHORT(mi->p[mi->oldinum]->height);
 
if (y - ST_Y < 0)
I_Error("updateMultIcon: y - ST_Y < 0");
271,10 → 273,10
if (*bi->on
&& (bi->oldval != *bi->val || refresh))
{
x = bi->x - (bi->p->leftoffset);
y = bi->y - (bi->p->topoffset);
w = (bi->p->width);
h = (bi->p->height);
x = bi->x - SHORT(bi->p->leftoffset);
y = bi->y - SHORT(bi->p->topoffset);
w = SHORT(bi->p->width);
h = SHORT(bi->p->height);
 
if (y - ST_Y < 0)
I_Error("updateBinIcon: y - ST_Y < 0");
/programs/games/doom/trunk/st_stuff.c
1074,7 → 1074,7
 
STlib_updateBinIcon(&w_armsbg, refresh);
 
for (i=0;i<5;i++)
for (i=0;i<6;i++)
STlib_updateMultIcon(&w_arms[i], refresh);
 
STlib_updateMultIcon(&w_faces, refresh);
1273,7 → 1273,7
for (i=0;i<3;i++)
keyboxes[i] = -1;
 
// STlib_init();
STlib_init();
 
}
 
/programs/games/doom/trunk/v_video.c
225,9 → 225,9
|| y+SHORT(patch->height)>SCREENHEIGHT
|| (unsigned)scrn>4)
{
printf("Patch at %d,%d exceeds LFB\n", x,y );
//printf("Patch at %d,%d exceeds LFB\n", x,y );
// No I_Error abort - what is up with TNT.WAD?
printf("V_DrawPatch: bad patch (ignored)\n");
//printf("V_DrawPatch: bad patch (ignored)\n");
return;
}
#endif
292,7 → 292,7
|| y+SHORT(patch->height)>SCREENHEIGHT
|| (unsigned)scrn>4)
{
printf("Patch origin %d,%d exceeds LFB\n", x,y );
//printf("Patch origin %d,%d exceeds LFB\n", x,y );
I_Error ("Bad V_DrawPatch in V_DrawPatchFlipped");
}
#endif
/programs/games/doom/trunk/w_sound.c
24,8 → 24,6
static const char
rcsid[] = "$Id: i_unix.c,v 1.5 1997/02/03 22:45:10 b1 Exp $";
 
#include <windows.h>
#include <dsound.h>
#include "sounds.h"
 
char MsgText[256];
67,13 → 65,13
hret = DirectSoundCreate8(NULL, &lpDS, NULL);
if (hret != DS_OK)
{
printf("failed DirectSoundCreate");
//printf("failed DirectSoundCreate");
return;
}
 
hret = lpDS->lpVtbl->SetCooperativeLevel(lpDS, win, DSSCL_PRIORITY);
if (hret != DS_OK)
printf("failled DirectSound.SetCooperativeLevel");
//printf("failled DirectSound.SetCooperativeLevel");
 
memset( &wfx,0, sizeof(WAVEFORMATEX) );
wfx.wFormatTag = WAVE_FORMAT_PCM;
119,7 → 117,7
hret=lpMix[mixbuff]->lpVtbl->Lock(lpMix[mixbuff],0,MIXBUFFERSIZE,&pPtr1,
&dwSize1,&pPtr2,&dwSize2,0);
if (hret!=DS_OK)
{ printf("Error locking on play start");
{ //printf("Error locking on play start");
return ;
}
memcpy(pPtr1, (void*)mixbuffer, MIXBUFFERSIZE);
/programs/games/doom/trunk/w_wad.c
40,6 → 40,27
#include <malloc.h>
 
 
extern char *main_file;
 
#ifdef DLHEAP
 
void* _cdecl dlmalloc(size_t);
void _cdecl dlfree(void*);
void _cdecl mf_init();
 
#define malloc dlmalloc
#define free dlfree
#define realloc dlrealloc
 
#endif
 
size_t FileSize(FILE *handle);
 
int _stdcall read_file (char *name, void *buff,
size_t offset, size_t count, size_t *reads);
 
 
 
//
// GLOBALS
//
50,19 → 71,6
 
void** lumpcache;
 
 
int filelength (FILE *handle)
{
unsigned long pos, size;
pos = ftell(handle);
fseek(handle, 0, SEEK_END);
size = ftell(handle);
fseek(handle, pos, SEEK_SET);
return (int)size;
}
 
 
void
ExtractFileBase
( char* path,
115,13 → 123,6
// specially to allow map reloads.
// But: the reload feature is a fragile hack...
 
#ifdef __BEOS__
#ifdef __GNUC__
extern void *alloca(int);
#else
#include <alloca.h>
#endif
#endif /* __BEOS__ */
 
int reloadlump;
char* reloadname;
138,6 → 139,8
filelump_t* fileinfo;
filelump_t singleinfo;
int storehandle;
int err;
size_t bytes;
// open the file and add to directory
 
155,15 → 158,15
return;
}
 
printf (" adding %s\n",filename);
printf (" adding %s\n\r",filename);
startlump = numlumps;
if (I_strncasecmp (filename+strlen(filename)-3 , "wad", 3 ) )
if (strnicmp (filename+strlen(filename)-3 , "wad", 3 ) )
{
// single lump file
fileinfo = &singleinfo;
singleinfo.filepos = 0;
singleinfo.size = LONG(filelength(handle));
singleinfo.size = FileSize(handle);
ExtractFileBase (filename, singleinfo.name);
numlumps++;
}
170,9 → 173,8
else
{
//WAD file
printf("f1 at %x,%u\n",&header,handle);
fread (&header, 1, sizeof(header), handle);
printf("f2\n");
 
if (strncmp(header.identification,"IWAD",4))
{
printf("No IWAD id\n");
182,23 → 184,19
I_Error ("Wad file %s doesn't have IWAD "
"or PWAD id\n", filename);
}
// printf("WAD magic OK\n");
printf("WAD magic OK\n");
// ???modifiedgame = true;
}
printf("after checking hdr\n");
header.numlumps = LONG(header.numlumps);
printf("%u lumps in WAD\n",header.numlumps);
 
header.infotableofs = LONG(header.infotableofs);
printf("infor table at %x\n",header.infotableofs);
 
length = header.numlumps*sizeof(filelump_t);
printf("length %u\n",length);
 
fileinfo = alloca(length);
printf("seeking to info table\n");
fseek (handle, header.infotableofs, SEEK_SET);
printf("f3\n");
fread (fileinfo, 1, length, handle);
printf("f4\n");
numlumps += header.numlumps;
}
 
249,17 → 247,14
if ( (handle = fopen (reloadname,"rb")) == NULL)
I_Error ("W_Reload: couldn't open %s",reloadname);
 
printf("f5\n");
fread (&header, 1, sizeof(header), handle);
printf("f6\n");
lumpcount = LONG(header.numlumps);
header.infotableofs = LONG(header.infotableofs);
length = lumpcount*sizeof(filelump_t);
fileinfo = malloc (length);
fseek (handle, header.infotableofs, SEEK_SET);
printf("f7\n");
fread (fileinfo, 1, length, handle);
printf("f8\n");
// Fill in lumpinfo
lump_p = &lumpinfo[reloadlump];
278,8 → 273,6
fclose (handle);
}
 
 
 
//
// W_InitMultipleFiles
// Pass a null terminated list of files to use.
301,7 → 294,7
numlumps = 0;
 
// will be realloced as lumps are added
lumpinfo = malloc(1);
lumpinfo = malloc(16384);
 
for ( ; *filenames ; filenames++)
W_AddFile (*filenames);
440,6 → 433,7
int c;
lumpinfo_t* l;
FILE *handle;
size_t bytes;
if (lump >= numlumps)
I_Error ("W_ReadLump: %i >= numlumps",lump);
482,7 → 476,7
{
byte* ptr;
 
if ((unsigned)lump >= numlumps)
if ((unsigned)lump >= (unsigned)numlumps)
I_Error ("W_CacheLumpNum: %i >= numlumps",lump);
if (!lumpcache[lump])
568,14 → 562,21
for ( ; j<8 ; j++)
name[j] = ' ';
 
printf ("%s ",name);
//printf ("%s ",name);
 
for (j=0 ; j<profilecount ; j++)
fprintf (f," %c",info[i][j]);
 
printf ("\n");
//printf ("\n");
}
fclose (f);
}
 
#endif
 
 
 
 
 
 
 
/programs/games/doom/trunk/z_zone.c
339,11 → 339,11
{
memblock_t* block;
printf ("zone size: %i location: %p\n",
mainzone->size,mainzone);
//printf ("zone size: %i location: %p\n",
// mainzone->size,mainzone);
printf ("tag range: %i to %i\n",
lowtag, hightag);
//printf ("tag range: %i to %i\n",
// lowtag, hightag);
for (block = mainzone->blocklist.next ; ; block = block->next)
{
376,11 → 376,11
{
memblock_t* block;
fprintf (f,"zone size: %i location: %p\n",mainzone->size,mainzone);
//printf ("zone size: %i location: %p\n",mainzone->size,mainzone);
for (block = mainzone->blocklist.next ; ; block = block->next)
{
fprintf (f,"block:%p size:%7i user:%p tag:%3i\n",
printf ("block:%p size:%7i user:%p tag:%3i\n",
block, block->size, block->user, block->tag);
if (block->next == &mainzone->blocklist)
390,13 → 390,13
}
if ( (byte *)block + block->size != (byte *)block->next)
fprintf (f,"ERROR: block size does not touch the next block\n");
printf ("ERROR: block size does not touch the next block\n");
 
if ( block->next->prev != block)
fprintf (f,"ERROR: next block doesn't have proper back link\n");
printf ("ERROR: next block doesn't have proper back link\n");
 
if (!block->user && !block->next->user)
fprintf (f,"ERROR: two consecutive free blocks\n");
printf ("ERROR: two consecutive free blocks\n");
}
}