Iskhodnyy_kod_Doom

1.8 dstrings.h

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//This program is free software; you can redistribute it and/or

//modify it under the terms of the GNU General Public License

//as published by the Free Software Foundation; either version 2

//of the License, or (at your option) any later version.

//

//This program is distributed in the hope that it will be useful,

//but WITHOUT ANY WARRANTY; without even the implied warranty of

//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

//GNU General Public License for more details.

//

//

//$Log:$

//DESCRIPTION:

//DOOM strings, by language.

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

#ifndef __DSTRINGS__ #define __DSTRINGS__

//All important printed strings.

//Language selection (message strings).

//Use -DFRENCH etc.

#ifdef FRENCH #include "d_french.h" #else

#include "d_englsh.h" #endif

//

//File locations,

//relative to current position.

//Path names are OS-sensitive.

#define DEVMAPS "devmaps" #define DEVDATA "devdata"

//Not done in french?

//QuitDOOM messages

#define NUM_QUITMESSAGES 22

extern char* endmsg[];

21

#endif //-----------------------------------------------------------------------------

//

// $Log:$

//

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

2 Automap

2.1 am map.c

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//This program is free software; you can redistribute it and/or

//modify it under the terms of the GNU General Public License

//as published by the Free Software Foundation; either version 2

//of the License, or (at your option) any later version.

//

//This program is distributed in the hope that it will be useful,

//but WITHOUT ANY WARRANTY; without even the implied warranty of

//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

//GNU General Public License for more details.

//

//

//

//$Log:$

//DESCRIPTION: the automap code

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

static const char rcsid[] = "$Id: am_map.c,v 1.4 1997/02/03 21:24:33 b1 Exp $";

#include <stdio.h>

#include "z_zone.h" #include "doomdef.h" #include "st_stuff.h" #include "p_local.h" #include "w_wad.h"

#include "m_cheat.h" #include "i_system.h"

//Needs access to LFB. #include "v_video.h"

//State.

#include "doomstat.h" #include "r_state.h"

22

#define AM_NUMMARKPOINTS 10

// scale on entry

#define INITSCALEMTOF (.2*FRACUNIT)

//how much the automap moves window per tic in frame-buffer coordinates

//moves 140 pixels in 1 second

//how much zoom-in per tic

//goes to 2x in 1 second

//how much zoom-out per tic

//pulls out to 0.5x in 1 second

23

//translates between frame-buffer and map distances #define FTOM(x) FixedMul(((x)<<16),scale_ftom) #define MTOF(x) (FixedMul((x),scale_mtof)>>16)

//translates between frame-buffer and map coordinates #define CXMTOF(x) (f_x + MTOF((x)-m_x))

#define CYMTOF(y) (f_y + (f_h - MTOF((y)-m_y)))

//the following is crap

#define LINE_NEVERSEE ML_DONTDRAW

typedef struct

{

int x, y;

//

//The vector graphics for the automap.

//A line drawing of the player pointing right,

//starting from the middle.

//

#define R ((8*PLAYERRADIUS)/7) mline_t player_arrow[] = {

{{ -R+R/8, 0 }, { R, 0 } }, // -----

{{ R, 0 }, { R-R/2, R/4 } }, // ----->

{{ R, 0 }, { R-R/2, -R/4 } },

{{ -R+R/8, 0 }, { -R-R/8, R/4 } }, // >---->

{{ -R+R/8, 0 }, { -R-R/8, -R/4 } },

{{ -R+3*R/8, 0 }, { -R+R/8, R/4 } }, // >>--->

{{ -R+3*R/8, 0 }, { -R+R/8, -R/4 } }

}; #undef R

#define NUMPLYRLINES (sizeof(player_arrow)/sizeof(mline_t))

#define R ((8*PLAYERRADIUS)/7) mline_t cheat_player_arrow[] = {

{{ -R+R/8, 0 }, { R, 0 } }, // -----

{{ R, 0 }, { R-R/2, R/6 } }, // ----->

{{ R, 0 }, { R-R/2, -R/6 } },

{{ -R+R/8, 0 }, { -R-R/8, R/6 } }, // >----->

{{ -R+R/8, 0 }, { -R-R/8, -R/6 } },

{{ -R+3*R/8, 0 }, { -R+R/8, R/6 } }, // >>----->

{{ -R+3*R/8, 0 }, { -R+R/8, -R/6 } },

{{ -R/2, 0 }, { -R/2, -R/6 } }, // >>-d--->

24

{{ -R/2, -R/6 }, { -R/2+R/6, -R/6 } },

{{ -R/2+R/6, -R/6 }, { -R/2+R/6, R/4 } },

{{ -R/6, 0 }, { -R/6, -R/6 } }, // >>-dd-->

{{ -R/6, -R/6 }, { 0, -R/6 } },

{{ 0, -R/6 }, { 0, R/4 } },

{{ R/6, R/4 }, { R/6, -R/7 } }, // >>-ddt->

{{ R/6, -R/7 }, { R/6+R/32, -R/7-R/32 } },

{{ R/6+R/32, -R/7-R/32 }, { R/6+R/10, -R/7 } }

}; #undef R

#define NUMCHEATPLYRLINES (sizeof(cheat_player_arrow)/sizeof(mline_t))

#define R (FRACUNIT) mline_t triangle_guy[] = {

{{ -.867*R, -.5*R }, { .867*R, -.5*R } },

{{ .867*R, -.5*R } , { 0, R } },

{{ 0, R }, { -.867*R, -.5*R } }

}; #undef R

#define NUMTRIANGLEGUYLINES (sizeof(triangle_guy)/sizeof(mline_t))

#define R (FRACUNIT)

mline_t thintriangle_guy[] = {

{{ -.5*R, -.7*R }, { R, 0 } },

{{ R, 0 }, { -.5*R, .7*R } },

{{ -.5*R, .7*R }, { -.5*R, -.7*R } }

}; #undef R

#define NUMTHINTRIANGLEGUYLINES (sizeof(thintriangle_guy)/sizeof(mline_t))

25

static fixed_t min_scale_mtof; // used to tell when to stop zooming out static fixed_t max_scale_mtof; // used to tell when to stop zooming in

//old stuff for recovery later static fixed_t old_m_w, old_m_h; static fixed_t old_m_x, old_m_y;

//old location used by the Follower routine static mpoint_t f_oldloc;

//used by MTOF to scale from map-to-frame-buffer coords static fixed_t scale_mtof = INITSCALEMTOF;

//used by FTOM to scale from frame-buffer-to-map coords (=1/scale_mtof) static fixed_t scale_ftom;

static player_t *plr; // the player represented by an arrow

static patch_t *marknums[10]; // numbers used for marking by the automap static mpoint_t markpoints[AM_NUMMARKPOINTS]; // where the points are static int markpointnum = 0; // next point to be assigned

static int followplayer = 1; // specifies whether to follow the player around

static unsigned char cheat_amap_seq[] = { 0xb2, 0x26, 0x26, 0x2e, 0xff }; static cheatseq_t cheat_amap = { cheat_amap_seq, 0 };

static boolean stopped = true;

extern boolean viewactive;

//extern byte screens[][SCREENWIDTH*SCREENHEIGHT];

//Calculates the slope and slope according to the x-axis of a line

//segment in map coordinates (with the upright y-axis n’ all) so

//that it can be used with the brain-dead drawing stuff.

void

AM_getIslope

( mline_t* ml,

{

26

int dx, dy;

dy = ml->a.y - ml->b.y; dx = ml->b.x - ml->a.x;

if (!dy) is->islp = (dx<0?-MAXINT:MAXINT); else is->islp = FixedDiv(dx, dy);

if (!dx) is->slp = (dy<0?-MAXINT:MAXINT); else is->slp = FixedDiv(dy, dx);

}

//

//

//

void AM_activateNewScale(void)

{

m_x += m_w/2; m_y += m_h/2; m_w = FTOM(f_w); m_h = FTOM(f_h); m_x -= m_w/2; m_y -= m_h/2;

m_x2 = m_x + m_w; m_y2 = m_y + m_h;

}

//

//

//

void AM_saveScaleAndLoc(void)

{

old_m_x = m_x; old_m_y = m_y; old_m_w = m_w; old_m_h = m_h;

}

//

//

//

void AM_restoreScaleAndLoc(void)

{

m_w = old_m_w; m_h = old_m_h;

if (!followplayer)

{

m_x = old_m_x; m_y = old_m_y;

} else {

m_x = plr->mo->x - m_w/2; m_y = plr->mo->y - m_h/2;

}

m_x2 = m_x + m_w; m_y2 = m_y + m_h;

// Change the scaling multipliers scale_mtof = FixedDiv(f_w<<FRACBITS, m_w);

scale_ftom = FixedDiv(FRACUNIT, scale_mtof);

}

//

// adds a marker at the current location

//

void AM_addMark(void)

27

{

markpoints[markpointnum].x = m_x + m_w/2; markpoints[markpointnum].y = m_y + m_h/2; markpointnum = (markpointnum + 1) % AM_NUMMARKPOINTS;

}

//

//Determines bounding box of all vertices,

//sets global variables controlling zoom range.

void AM_findMinMaxBoundaries(void)

{

int i; fixed_t a; fixed_t b;

min_x = min_y = MAXINT; max_x = max_y = -MAXINT;

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

{

if (vertexes[i].x < min_x) min_x = vertexes[i].x;

else if (vertexes[i].x > max_x) max_x = vertexes[i].x;

if (vertexes[i].y < min_y) min_y = vertexes[i].y;

else if (vertexes[i].y > max_y) max_y = vertexes[i].y;

}

max_w = max_x - min_x; max_h = max_y - min_y;

min_w = 2*PLAYERRADIUS; // const? never changed? min_h = 2*PLAYERRADIUS;

a = FixedDiv(f_w<<FRACBITS, max_w); b = FixedDiv(f_h<<FRACBITS, max_h);

min_scale_mtof = a < b ? a : b;

max_scale_mtof = FixedDiv(f_h<<FRACBITS, 2*PLAYERRADIUS);

}

//

//

//

void AM_changeWindowLoc(void)

{

if (m_paninc.x || m_paninc.y)

{

followplayer = 0; f_oldloc.x = MAXINT;

}

m_x += m_paninc.x; m_y += m_paninc.y;

if (m_x + m_w/2 > max_x) m_x = max_x - m_w/2;

else if (m_x + m_w/2 < min_x)

28

m_x = min_x - m_w/2;

if (m_y + m_h/2 > max_y) m_y = max_y - m_h/2;

else if (m_y + m_h/2 < min_y) m_y = min_y - m_h/2;

m_x2 = m_x + m_w; m_y2 = m_y + m_h;

}

//

//

//

void AM_initVariables(void)

{

int pnum;

static event_t st_notify = { ev_keyup, AM_MSGENTERED };

automapactive = true; fb = screens[0];

f_oldloc.x = MAXINT; amclock = 0; lightlev = 0;

m_paninc.x = m_paninc.y = 0; ftom_zoommul = FRACUNIT; mtof_zoommul = FRACUNIT;

m_w = FTOM(f_w);

m_h = FTOM(f_h);

// find player to center on initially

if (!playeringame[pnum = consoleplayer]) for (pnum=0;pnum<MAXPLAYERS;pnum++)

if (playeringame[pnum]) break;

plr = &players[pnum];

m_x = plr->mo->x - m_w/2; m_y = plr->mo->y - m_h/2; AM_changeWindowLoc();

//for saving & restoring old_m_x = m_x;

old_m_y = m_y; old_m_w = m_w; old_m_h = m_h;

//inform the status bar of the change ST_Responder(&st_notify);

}

//

//

//

void AM_loadPics(void)

{

int i;

char namebuf[9];

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

29

{

sprintf(namebuf, "AMMNUM%d", i);

marknums[i] = W_CacheLumpName(namebuf, PU_STATIC);

}

}

void AM_unloadPics(void)

{

int i;

for (i=0;i<10;i++) Z_ChangeTag(marknums[i], PU_CACHE);

}

void AM_clearMarks(void)

{

int i;

for (i=0;i<AM_NUMMARKPOINTS;i++) markpoints[i].x = -1; // means empty

markpointnum = 0;

}

//

//should be called at the start of every level

//right now, i figure it out myself

//

void AM_LevelInit(void)

{

leveljuststarted = 0;

f_x = f_y = 0;

f_w = finit_width; f_h = finit_height;

AM_clearMarks();

AM_findMinMaxBoundaries();

scale_mtof = FixedDiv(min_scale_mtof, (int) (0.7*FRACUNIT)); if (scale_mtof > max_scale_mtof)

scale_mtof = min_scale_mtof;

scale_ftom = FixedDiv(FRACUNIT, scale_mtof);

}

//

//

//

void AM_Stop (void)

{

static event_t st_notify = { 0, ev_keyup, AM_MSGEXITED };

AM_unloadPics(); automapactive = false; ST_Responder(&st_notify); stopped = true;

}

//

//

//

30