commit 5791c4d6cf6bf639083cf29256f673054c4bb345
parent 181908bd2667000b6139f92c8834059b4ec3f98a
Author: ssnf <ssnf@ssnf.xyz>
Date: Thu, 17 Jun 2021 01:37:22 +0000
delete all comments
Diffstat:
| M | src/am_map.c | | | 432 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/am_map.h | | | 64 | ++++++++++++++++++++++++++++++++-------------------------------- |
| M | src/d_englsh.h | | | 146 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_event.h | | | 98 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_french.h | | | 128 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_items.c | | | 86 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_items.h | | | 52 | ++++++++++++++++++++++++++-------------------------- |
| M | src/d_main.c | | | 372 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_main.h | | | 64 | ++++++++++++++++++++++++++++++++-------------------------------- |
| M | src/d_net.c | | | 248 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_net.h | | | 134 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_player.h | | | 176 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/d_textur.h | | | 60 | ++++++++++++++++++++++++++++++------------------------------ |
| M | src/d_think.h | | | 74 | +++++++++++++++++++++++++++++++++++++------------------------------------- |
| M | src/d_ticcmd.h | | | 66 | +++++++++++++++++++++++++++++++++--------------------------------- |
| M | src/doomdata.h | | | 180 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/doomdef.c | | | 50 | +++++++++++++++++++++++++------------------------- |
| M | src/doomdef.h | | | 272 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/doomstat.c | | | 50 | +++++++++++++++++++++++++------------------------- |
| M | src/doomstat.h | | | 256 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/doomtype.h | | | 60 | ++++++++++++++++++++++++++++++------------------------------ |
| M | src/dstrings.c | | | 52 | ++++++++++++++++++++++++++-------------------------- |
| M | src/dstrings.h | | | 78 | +++++++++++++++++++++++++++++++++++++++--------------------------------------- |
| M | src/f_finale.c | | | 190 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/f_finale.h | | | 62 | +++++++++++++++++++++++++++++++------------------------------- |
| M | src/f_wipe.c | | | 74 | +++++++++++++++++++++++++++++++++++++------------------------------------- |
| M | src/f_wipe.h | | | 60 | ++++++++++++++++++++++++++++++------------------------------ |
| M | src/g_game.c | | | 472 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/g_game.h | | | 70 | +++++++++++++++++++++++++++++++++++----------------------------------- |
| M | src/hu_lib.c | | | 94 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/hu_lib.h | | | 158 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/hu_stuff.c | | | 188 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/hu_stuff.h | | | 70 | +++++++++++++++++++++++++++++++++++----------------------------------- |
| M | src/i_main.c | | | 44 | ++++++++++++++++++++++---------------------- |
| M | src/i_net.c | | | 122 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/i_net.h | | | 52 | ++++++++++++++++++++++++++-------------------------- |
| M | src/i_sound.c | | | 634 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/i_sound.h | | | 108 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/i_system.c | | | 76 | ++++++++++++++++++++++++++++++++++++++-------------------------------------- |
| M | src/i_system.h | | | 110 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/i_video.c | | | 260 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/i_video.h | | | 60 | ++++++++++++++++++++++++++++++------------------------------ |
| M | src/info.c | | | 9106 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/info.h | | | 58 | +++++++++++++++++++++++++++++----------------------------- |
| M | src/m_argv.c | | | 54 | +++++++++++++++++++++++++++--------------------------- |
| M | src/m_argv.h | | | 60 | ++++++++++++++++++++++++++++++------------------------------ |
| M | src/m_bbox.c | | | 50 | +++++++++++++++++++++++++------------------------- |
| M | src/m_bbox.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/m_cheat.c | | | 62 | +++++++++++++++++++++++++++++++------------------------------- |
| M | src/m_cheat.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/m_fixed.c | | | 52 | ++++++++++++++++++++++++++-------------------------- |
| M | src/m_fixed.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/m_menu.c | | | 508 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/m_menu.h | | | 82 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/m_misc.c | | | 162 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/m_misc.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/m_random.c | | | 54 | +++++++++++++++++++++++++++--------------------------- |
| M | src/m_random.h | | | 58 | +++++++++++++++++++++++++++++----------------------------- |
| M | src/m_swap.c | | | 52 | ++++++++++++++++++++++++++-------------------------- |
| M | src/m_swap.h | | | 54 | +++++++++++++++++++++++++++--------------------------- |
| M | src/p_ceilng.c | | | 108 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_doors.c | | | 206 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_enemy.c | | | 514 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_floor.c | | | 118 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_inter.c | | | 254 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_inter.h | | | 50 | +++++++++++++++++++++++++------------------------- |
| M | src/p_lights.c | | | 154 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_local.h | | | 148 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_map.c | | | 616 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_maputl.c | | | 334 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_mobj.c | | | 336 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_mobj.h | | | 354 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_plats.c | | | 68 | ++++++++++++++++++++++++++++++++++---------------------------------- |
| M | src/p_pspr.c | | | 354 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_pspr.h | | | 90 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_saveg.c | | | 164 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_saveg.h | | | 54 | +++++++++++++++++++++++++++--------------------------- |
| M | src/p_setup.c | | | 254 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_setup.h | | | 54 | +++++++++++++++++++++++++++--------------------------- |
| M | src/p_sight.c | | | 172 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_spec.c | | | 538 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_spec.h | | | 172 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_switch.c | | | 266 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_telept.c | | | 74 | +++++++++++++++++++++++++++++++++++++------------------------------------- |
| M | src/p_tick.c | | | 116 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/p_tick.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/p_user.c | | | 156 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_bsp.c | | | 254 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_bsp.h | | | 54 | +++++++++++++++++++++++++++--------------------------- |
| M | src/r_data.c | | | 326 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_data.h | | | 66 | +++++++++++++++++++++++++++++++++--------------------------------- |
| M | src/r_defs.h | | | 358 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_draw.c | | | 388 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_draw.h | | | 82 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_local.h | | | 66 | +++++++++++++++++++++++++++++++++--------------------------------- |
| M | src/r_main.c | | | 330 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_main.h | | | 106 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_plane.c | | | 180 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_plane.h | | | 52 | ++++++++++++++++++++++++++-------------------------- |
| M | src/r_segs.c | | | 218 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_segs.h | | | 50 | +++++++++++++++++++++++++------------------------- |
| M | src/r_sky.c | | | 72 | ++++++++++++++++++++++++++++++++++++------------------------------------ |
| M | src/r_sky.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/r_state.h | | | 88 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_things.c | | | 354 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/r_things.h | | | 56 | ++++++++++++++++++++++++++++---------------------------- |
| M | src/s_sound.c | | | 326 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/s_sound.h | | | 98 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/sounds.c | | | 60 | ++++++++++++++++++++++++++++++------------------------------ |
| M | src/sounds.h | | | 110 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/st_lib.c | | | 80 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/st_lib.h | | | 146 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/st_stuff.c | | | 492 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/st_stuff.h | | | 78 | +++++++++++++++++++++++++++++++++++++++--------------------------------------- |
| M | src/tables.c | | | 72 | ++++++++++++++++++++++++++++++++++++------------------------------------ |
| M | src/tables.h | | | 96 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/v_video.c | | | 126 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/v_video.h | | | 72 | ++++++++++++++++++++++++++++++++++++------------------------------------ |
| M | src/w_wad.c | | | 232 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/w_wad.h | | | 64 | ++++++++++++++++++++++++++++++++-------------------------------- |
| M | src/wi_stuff.c | | | 476 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/wi_stuff.h | | | 62 | +++++++++++++++++++++++++++++++------------------------------- |
| M | src/z_zone.c | | | 198 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
| M | src/z_zone.h | | | 94 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
124 files changed, 14278 insertions(+), 14278 deletions(-)
diff --git a/src/am_map.c b/src/am_map.c
@@ -1,25 +1,25 @@
-// 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: the automap code
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char rcsid[] = "$Id: am_map.c,v 1.4 1997/02/03 21:24:33 b1 Exp $";
@@ -35,20 +35,20 @@ static const char rcsid[] = "$Id: am_map.c,v 1.4 1997/02/03 21:24:33 b1 Exp $";
#include "m_cheat.h"
#include "i_system.h"
-// Needs access to LFB.
+
#include "v_video.h"
-// State.
+
#include "doomstat.h"
#include "r_state.h"
-// Data.
+
#include "dstrings.h"
#include "am_map.h"
-// For use if I do walls with outsides/insides
+
#define REDS (256-5*16)
#define REDRANGE 16
#define BLUES (256-4*16+8)
@@ -64,7 +64,7 @@ static const char rcsid[] = "$Id: am_map.c,v 1.4 1997/02/03 21:24:33 b1 Exp $";
#define BLACK 0
#define WHITE (256-47)
-// Automap colors
+
#define BACKGROUND BLACK
#define YOURCOLORS WHITE
#define YOURRANGE 0
@@ -84,7 +84,7 @@ static const char rcsid[] = "$Id: am_map.c,v 1.4 1997/02/03 21:24:33 b1 Exp $";
#define GRIDRANGE 0
#define XHAIRCOLORS GRAYS
-// drawing stuff
+
#define FB 0
#define AM_PANDOWNKEY KEY_DOWNARROW
@@ -103,26 +103,26 @@ static const char rcsid[] = "$Id: am_map.c,v 1.4 1997/02/03 21:24:33 b1 Exp $";
#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
+
+
#define F_PANINC 4
-// how much zoom-in per tic
-// goes to 2x in 1 second
+
+
#define M_ZOOMIN ((int) (1.02*FRACUNIT))
-// how much zoom-out per tic
-// pulls out to 0.5x in 1 second
+
+
#define M_ZOOMOUT ((int) (FRACUNIT/1.02))
-// 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
@@ -152,19 +152,19 @@ typedef struct
-//
-// 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+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+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 } },
{ { -R+3*R/8, 0 }, { -R+R/8, -R/4 } }
};
#undef R
@@ -172,20 +172,20 @@ mline_t player_arrow[] = {
#define R ((8*PLAYERRADIUS)/7)
mline_t cheat_player_arrow[] = {
- { { -R+R/8, 0 }, { R, 0 } }, // -----
- { { R, 0 }, { R-R/2, R/6 } }, // ----->
+ { { -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+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+3*R/8, 0 }, { -R+R/8, -R/6 } },
- { { -R/2, 0 }, { -R/2, -R/6 } }, // >>-d--->
+ { { -R/2, 0 }, { -R/2, -R/6 } },
{ { -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, 0 }, { -R/6, -R/6 } },
{ { -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/4 }, { R/6, -R/7 } },
{ { 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 } }
};
@@ -216,73 +216,73 @@ mline_t thintriangle_guy[] = {
static int cheating = 0;
static int grid = 0;
-static int leveljuststarted = 1; // kluge until AM_LevelInit() is called
+static int leveljuststarted = 1;
boolean automapactive = false;
static int finit_width = SCREENWIDTH;
static int finit_height = SCREENHEIGHT - 32;
-// location of window on screen
+
static int f_x;
static int f_y;
-// size of window on screen
+
static int f_w;
static int f_h;
-static int lightlev; // used for funky strobing effect
-static byte* fb; // pseudo-frame buffer
+static int lightlev;
+static byte* fb;
static int amclock;
-static mpoint_t m_paninc; // how far the window pans each tic (map coords)
-static fixed_t mtof_zoommul; // how far the window zooms in each tic (map coords)
-static fixed_t ftom_zoommul; // how far the window zooms in each tic (fb coords)
+static mpoint_t m_paninc;
+static fixed_t mtof_zoommul;
+static fixed_t ftom_zoommul;
+
+static fixed_t m_x, m_y;
+static fixed_t m_x2, m_y2;
+
+
-static fixed_t m_x, m_y; // LL x,y where the window is on the map (map coords)
-static fixed_t m_x2, m_y2; // UR x,y where the window is on the map (map coords)
-//
-// width/height of window on map (map coords)
-//
static fixed_t m_w;
static fixed_t m_h;
-// based on level size
+
static fixed_t min_x;
static fixed_t min_y;
static fixed_t max_x;
static fixed_t max_y;
-static fixed_t max_w; // max_x-min_x,
-static fixed_t max_h; // max_y-min_y
+static fixed_t max_w;
+static fixed_t max_h;
+
-// based on player size
static fixed_t min_w;
static fixed_t min_h;
-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
+static fixed_t min_scale_mtof;
+static fixed_t max_scale_mtof;
+
-// 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 player_t *plr;
-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 patch_t *marknums[10];
+static mpoint_t markpoints[AM_NUMMARKPOINTS];
+static int markpointnum = 0;
-static int followplayer = 1; // specifies whether to follow the player around
+static int followplayer = 1;
static unsigned char cheat_amap_seq[] = { 0xb2, 0x26, 0x26, 0x2e, 0xff };
static cheatseq_t cheat_amap = { cheat_amap_seq, 0 };
@@ -290,7 +290,7 @@ static cheatseq_t cheat_amap = { cheat_amap_seq, 0 };
static boolean stopped = true;
extern boolean viewactive;
-//extern byte screens[][SCREENWIDTH*SCREENHEIGHT];
+
@@ -301,9 +301,9 @@ V_MarkRect
int width,
int height );
-// 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
@@ -321,9 +321,9 @@ AM_getIslope
}
-//
-//
-//
+
+
+
void AM_activateNewScale(void)
{
m_x += m_w/2;
@@ -336,9 +336,9 @@ void AM_activateNewScale(void)
m_y2 = m_y + m_h;
}
-//
-//
-//
+
+
+
void AM_saveScaleAndLoc(void)
{
old_m_x = m_x;
@@ -347,9 +347,9 @@ void AM_saveScaleAndLoc(void)
old_m_h = m_h;
}
-//
-//
-//
+
+
+
void AM_restoreScaleAndLoc(void)
{
@@ -366,14 +366,14 @@ void AM_restoreScaleAndLoc(void)
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)
{
markpoints[markpointnum].x = m_x + m_w/2;
@@ -382,10 +382,10 @@ void AM_addMark(void)
}
-//
-// Determines bounding box of all vertices,
-// sets global variables controlling zoom range.
-//
+
+
+
+
void AM_findMinMaxBoundaries(void)
{
int i;
@@ -411,7 +411,7 @@ void AM_findMinMaxBoundaries(void)
max_w = max_x - min_x;
max_h = max_y - min_y;
- min_w = 2*PLAYERRADIUS; // const? never changed?
+ min_w = 2*PLAYERRADIUS;
min_h = 2*PLAYERRADIUS;
a = FixedDiv(f_w<<FRACBITS, max_w);
@@ -423,9 +423,9 @@ void AM_findMinMaxBoundaries(void)
}
-//
-//
-//
+
+
+
void AM_changeWindowLoc(void)
{
if (m_paninc.x || m_paninc.y)
@@ -452,9 +452,9 @@ void AM_changeWindowLoc(void)
}
-//
-//
-//
+
+
+
void AM_initVariables(void)
{
int pnum;
@@ -474,7 +474,7 @@ void AM_initVariables(void)
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])
@@ -485,20 +485,20 @@ void AM_initVariables(void)
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;
@@ -526,14 +526,14 @@ void AM_clearMarks(void)
int i;
for (i=0;i<AM_NUMMARKPOINTS;i++)
- markpoints[i].x = -1; // means empty
+ markpoints[i].x = -1;
markpointnum = 0;
}
-//
-// should be called at the start of every level
-// right now, i figure it out myself
-//
+
+
+
+
void AM_LevelInit(void)
{
leveljuststarted = 0;
@@ -554,9 +554,9 @@ void AM_LevelInit(void)
-//
-//
-//
+
+
+
void AM_Stop (void)
{
static event_t st_notify = { 0, ev_keyup, AM_MSGEXITED };
@@ -567,9 +567,9 @@ void AM_Stop (void)
stopped = true;
}
-//
-//
-//
+
+
+
void AM_Start (void)
{
static int lastlevel = -1, lastepisode = -1;
@@ -586,9 +586,9 @@ void AM_Start (void)
AM_loadPics();
}
-//
-// set the window scale to the maximum size
-//
+
+
+
void AM_minOutWindowScale(void)
{
scale_mtof = min_scale_mtof;
@@ -596,9 +596,9 @@ void AM_minOutWindowScale(void)
AM_activateNewScale();
}
-//
-// set the window scale to the minimum size
-//
+
+
+
void AM_maxOutWindowScale(void)
{
scale_mtof = max_scale_mtof;
@@ -607,9 +607,9 @@ void AM_maxOutWindowScale(void)
}
-//
-// Handle events (user inputs) in automap mode
-//
+
+
+
boolean
AM_Responder
( event_t* ev )
@@ -638,27 +638,27 @@ AM_Responder
rc = true;
switch(ev->data1)
{
- case AM_PANRIGHTKEY: // pan right
+ case AM_PANRIGHTKEY:
if (!followplayer) m_paninc.x = FTOM(F_PANINC);
else rc = false;
break;
- case AM_PANLEFTKEY: // pan left
+ case AM_PANLEFTKEY:
if (!followplayer) m_paninc.x = -FTOM(F_PANINC);
else rc = false;
break;
- case AM_PANUPKEY: // pan up
+ case AM_PANUPKEY:
if (!followplayer) m_paninc.y = FTOM(F_PANINC);
else rc = false;
break;
- case AM_PANDOWNKEY: // pan down
+ case AM_PANDOWNKEY:
if (!followplayer) m_paninc.y = -FTOM(F_PANINC);
else rc = false;
break;
- case AM_ZOOMOUTKEY: // zoom out
+ case AM_ZOOMOUTKEY:
mtof_zoommul = M_ZOOMOUT;
ftom_zoommul = M_ZOOMIN;
break;
- case AM_ZOOMINKEY: // zoom in
+ case AM_ZOOMINKEY:
mtof_zoommul = M_ZOOMIN;
ftom_zoommul = M_ZOOMOUT;
break;
@@ -735,13 +735,13 @@ AM_Responder
}
-//
-// Zooming
-//
+
+
+
void AM_changeWindowScale(void)
{
- // Change the scaling multipliers
+
scale_mtof = FixedMul(scale_mtof, mtof_zoommul);
scale_ftom = FixedDiv(FRACUNIT, scale_mtof);
@@ -754,9 +754,9 @@ void AM_changeWindowScale(void)
}
-//
-//
-//
+
+
+
void AM_doFollowPlayer(void)
{
@@ -769,26 +769,26 @@ void AM_doFollowPlayer(void)
f_oldloc.x = plr->mo->x;
f_oldloc.y = plr->mo->y;
- // m_x = FTOM(MTOF(plr->mo->x - m_w/2));
- // m_y = FTOM(MTOF(plr->mo->y - m_h/2));
- // m_x = plr->mo->x - m_w/2;
- // m_y = plr->mo->y - m_h/2;
+
+
+
+
}
}
-//
-//
-//
+
+
+
void AM_updateLightLev(void)
{
static nexttic = 0;
- //static int litelevels[] = { 0, 3, 5, 6, 6, 7, 7, 7 };
+
static int litelevels[] = { 0, 4, 7, 10, 12, 14, 15, 15 };
static int litelevelscnt = 0;
- // Change light level
+
if (amclock>nexttic)
{
lightlev = litelevels[litelevelscnt++];
@@ -799,9 +799,9 @@ void AM_updateLightLev(void)
}
-//
-// Updates on Game Tick
-//
+
+
+
void AM_Ticker (void)
{
@@ -813,36 +813,36 @@ void AM_Ticker (void)
if (followplayer)
AM_doFollowPlayer();
- // Change the zoom if necessary
+
if (ftom_zoommul != FRACUNIT)
AM_changeWindowScale();
- // Change x,y location
+
if (m_paninc.x || m_paninc.y)
AM_changeWindowLoc();
- // Update light level
- // AM_updateLightLev();
+
+
}
-//
-// Clear automap frame buffer.
-//
+
+
+
void AM_clearFB(int color)
{
memset(fb, color, f_w*f_h);
}
-//
-// Automap clipping of lines.
-//
-// Based on Cohen-Sutherland clipping algorithm but with a slightly
-// faster reject and precalculated slopes. If the speed is needed,
-// use a hash algorithm to handle the common cases.
-//
+
+
+
+
+
+
+
boolean
AM_clipMline
( mline_t* ml,
@@ -873,7 +873,7 @@ AM_clipMline
else if ((mx) >= f_w) (oc) |= RIGHT;
- // do trivial rejects and outcodes
+
if (ml->a.y > m_y2)
outcode1 = TOP;
else if (ml->a.y < m_y)
@@ -885,7 +885,7 @@ AM_clipMline
outcode2 = BOTTOM;
if (outcode1 & outcode2)
- return false; // trivially outside
+ return false;
if (ml->a.x < m_x)
outcode1 |= LEFT;
@@ -898,9 +898,9 @@ AM_clipMline
outcode2 |= RIGHT;
if (outcode1 & outcode2)
- return false; // trivially outside
+ return false;
- // transform to frame-buffer coordinates.
+
fl->a.x = CXMTOF(ml->a.x);
fl->a.y = CYMTOF(ml->a.y);
fl->b.x = CXMTOF(ml->b.x);
@@ -914,14 +914,14 @@ AM_clipMline
while (outcode1 | outcode2)
{
- // may be partially inside box
- // find an outside point
+
+
if (outcode1)
outside = outcode1;
else
outside = outcode2;
- // clip to each side
+
if (outside & TOP)
{
dy = fl->a.y - fl->b.y;
@@ -963,7 +963,7 @@ AM_clipMline
}
if (outcode1 & outcode2)
- return false; // trivially outside
+ return false;
}
return true;
@@ -971,9 +971,9 @@ AM_clipMline
#undef DOOUTCODE
-//
-// Classic Bresenham w/ whatever optimizations needed for speed
-//
+
+
+
void
AM_drawFline
( fline_t* fl,
@@ -991,7 +991,7 @@ AM_drawFline
static fuck = 0;
- // For debugging only
+
if ( fl->a.x < 0 || fl->a.x >= f_w
|| fl->a.y < 0 || fl->a.y >= f_h
|| fl->b.x < 0 || fl->b.x >= f_w
@@ -1049,9 +1049,9 @@ AM_drawFline
}
-//
-// Clip lines, draw visible part sof lines.
-//
+
+
+
void
AM_drawMline
( mline_t* ml,
@@ -1060,28 +1060,28 @@ AM_drawMline
static fline_t fl;
if (AM_clipMline(ml, &fl))
- AM_drawFline(&fl, color); // draws it on frame buffer using fb coords
+ AM_drawFline(&fl, color);
}
-//
-// Draws flat (floor/ceiling tile) aligned grid lines.
-//
+
+
+
void AM_drawGrid(int color)
{
fixed_t x, y;
fixed_t start, end;
mline_t ml;
- // Figure out start of vertical gridlines
+
start = m_x;
if ((start-bmaporgx)%(MAPBLOCKUNITS<<FRACBITS))
start += (MAPBLOCKUNITS<<FRACBITS)
- ((start-bmaporgx)%(MAPBLOCKUNITS<<FRACBITS));
end = m_x + m_w;
- // draw vertical gridlines
+
ml.a.y = m_y;
ml.b.y = m_y+m_h;
for (x=start; x<end; x+=(MAPBLOCKUNITS<<FRACBITS))
@@ -1091,14 +1091,14 @@ void AM_drawGrid(int color)
AM_drawMline(&ml, color);
}
- // Figure out start of horizontal gridlines
+
start = m_y;
if ((start-bmaporgy)%(MAPBLOCKUNITS<<FRACBITS))
start += (MAPBLOCKUNITS<<FRACBITS)
- ((start-bmaporgy)%(MAPBLOCKUNITS<<FRACBITS));
end = m_y + m_h;
- // draw horizontal gridlines
+
ml.a.x = m_x;
ml.b.x = m_x + m_w;
for (y=start; y<end; y+=(MAPBLOCKUNITS<<FRACBITS))
@@ -1110,10 +1110,10 @@ void AM_drawGrid(int color)
}
-//
-// Determines visible lines, draws them.
-// This is LineDef based, not LineSeg based.
-//
+
+
+
+
void AM_drawWalls(void)
{
int i;
@@ -1136,21 +1136,21 @@ void AM_drawWalls(void)
else
{
if (lines[i].special == 39)
- { // teleporters
+ {
AM_drawMline(&l, WALLCOLORS+WALLRANGE/2);
}
- else if (lines[i].flags & ML_SECRET) // secret door
+ else if (lines[i].flags & ML_SECRET)
{
if (cheating) AM_drawMline(&l, SECRETWALLCOLORS + lightlev);
else AM_drawMline(&l, WALLCOLORS+lightlev);
}
else if (lines[i].backsector->floorheight
!= lines[i].frontsector->floorheight) {
- AM_drawMline(&l, FDWALLCOLORS + lightlev); // floor level change
+ AM_drawMline(&l, FDWALLCOLORS + lightlev);
}
else if (lines[i].backsector->ceilingheight
!= lines[i].frontsector->ceilingheight) {
- AM_drawMline(&l, CDWALLCOLORS+lightlev); // ceiling level change
+ AM_drawMline(&l, CDWALLCOLORS+lightlev);
}
else if (cheating) {
AM_drawMline(&l, TSWALLCOLORS+lightlev);
@@ -1165,10 +1165,10 @@ void AM_drawWalls(void)
}
-//
-// Rotation in 2D.
-// Used to rotate player arrow line character.
-//
+
+
+
+
void
AM_rotate
( fixed_t* x,
@@ -1270,7 +1270,7 @@ void AM_drawPlayers(void)
continue;
if (p->powers[pw_invisibility])
- color = 246; // *close* to black
+ color = 246;
else
color = their_colors[their_color];
@@ -1310,10 +1310,10 @@ void AM_drawMarks(void)
{
if (markpoints[i].x != -1)
{
- // w = SHORT(marknums[i]->width);
- // h = SHORT(marknums[i]->height);
- w = 5; // because something's wrong with the wad, i guess
- h = 6; // because something's wrong with the wad, i guess
+
+
+ w = 5;
+ h = 6;
fx = CXMTOF(markpoints[i].x);
fy = CYMTOF(markpoints[i].y);
if (fx >= f_x && fx <= f_w - w && fy >= f_y && fy <= f_h - h)
@@ -1325,7 +1325,7 @@ void AM_drawMarks(void)
void AM_drawCrosshair(int color)
{
- fb[(f_w*(f_h+1))/2] = color; // single point for now
+ fb[(f_w*(f_h+1))/2] = color;
}
diff --git a/src/am_map.h b/src/am_map.h
@@ -1,52 +1,52 @@
-// 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.
-//
-// DESCRIPTION:
-// AutoMap module.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __AMMAP_H__
#define __AMMAP_H__
-// Used by ST StatusBar stuff.
+
#define AM_MSGHEADER (('a'<<24)+('m'<<16))
#define AM_MSGENTERED (AM_MSGHEADER | ('e'<<8))
#define AM_MSGEXITED (AM_MSGHEADER | ('x'<<8))
-// Called by main loop.
+
boolean AM_Responder (event_t* ev);
-// Called by main loop.
+
void AM_Ticker (void);
-// Called by main loop,
-// called instead of view drawer if automap active.
+
+
void AM_Drawer (void);
-// Called to force the automap to quit
-// if the level is completed while it is up.
+
+
void AM_Stop (void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_englsh.h b/src/d_englsh.h
@@ -1,41 +1,41 @@
-// 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.
-//
-// DESCRIPTION:
-// Printed strings for translation.
-// English language support (default).
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_ENGLSH__
#define __D_ENGLSH__
-//
-// Printed strings for translation
-//
-//
-// D_Main.C
-//
+
+
+
+
+
+
#define D_DEVSTR "Development mode ON.\n"
#define D_CDROM "CD-ROM Version: default.cfg from c:\\doomdata\n"
-//
-// M_Menu.C
-//
+
+
+
#define PRESSKEY "press a key."
#define PRESSYN "press y or n."
#define QUITMSG "are you sure you want to\nquit this great game?"
@@ -74,9 +74,9 @@
#define GAMMALVL4 "Gamma correction level 4"
#define EMPTYSTRING "empty slot"
-//
-// P_inter.C
-//
+
+
+
#define GOTARMOR "Picked up the armor."
#define GOTMEGA "Picked up the MegaArmor!"
#define GOTHTHBONUS "Picked up a health bonus."
@@ -119,9 +119,9 @@
#define GOTSHOTGUN "You got the shotgun!"
#define GOTSHOTGUN2 "You got the super shotgun!"
-//
-// P_Doors.C
-//
+
+
+
#define PD_BLUEO "You need a blue key to activate this object"
#define PD_REDO "You need a red key to activate this object"
#define PD_YELLOWO "You need a yellow key to activate this object"
@@ -129,14 +129,14 @@
#define PD_REDK "You need a red key to open this door"
#define PD_YELLOWK "You need a yellow key to open this door"
-//
-// G_game.C
-//
+
+
+
#define GGSAVED "game saved."
-//
-// HU_stuff.C
-//
+
+
+
#define HUSTR_MSGU "[Message unsent]"
#define HUSTR_E1M1 "E1M1: Hangar"
@@ -306,8 +306,8 @@
#define HUSTR_MESSAGESENT "[Message Sent]"
-// The following should NOT be changed unless it seems
-// just AWFULLY necessary
+
+
#define HUSTR_PLRGREEN "Green: "
#define HUSTR_PLRINDIGO "Indigo: "
@@ -319,9 +319,9 @@
#define HUSTR_KEYBROWN 'b'
#define HUSTR_KEYRED 'r'
-//
-// AM_map.C
-//
+
+
+
#define AMSTR_FOLLOWON "Follow Mode ON"
#define AMSTR_FOLLOWOFF "Follow Mode OFF"
@@ -332,9 +332,9 @@
#define AMSTR_MARKEDSPOT "Marked Spot"
#define AMSTR_MARKSCLEARED "All Marks Cleared"
-//
-// ST_stuff.C
-//
+
+
+
#define STSTR_MUS "Music Change"
#define STSTR_NOMUS "IMPOSSIBLE SELECTION"
@@ -353,9 +353,9 @@
#define STSTR_CHOPPERS "... doesn't suck - GM"
#define STSTR_CLEV "Changing Level..."
-//
-// F_Finale.C
-//
+
+
+
#define E1TEXT \
"Once you beat the big badasses and\n"\
"clean out the moon base you're supposed\n"\
@@ -433,7 +433,7 @@
"next stop, hell on earth!"
-// after level 6, put this:
+
#define C1TEXT \
"YOU HAVE ENTERED DEEPLY INTO THE INFESTED\n" \
@@ -449,7 +449,7 @@
"SWITCH WHICH HOLDS EARTH'S POPULATION\n" \
"HOSTAGE."
-// After level 11, put this:
+
#define C2TEXT \
"YOU HAVE WON! YOUR VICTORY HAS ENABLED\n" \
@@ -471,7 +471,7 @@
"UP AND RETURN TO THE FRAY."
-// After level 20, put this:
+
#define C3TEXT \
"YOU ARE AT THE CORRUPT HEART OF THE CITY,\n"\
@@ -485,7 +485,7 @@
"GOT TO GO THROUGH HELL TO GET TO IT?"
-// After level 29, put this:
+
#define C4TEXT \
"THE HORRENDOUS VISAGE OF THE BIGGEST\n"\
@@ -506,7 +506,7 @@
-// Before level 31, put this:
+
#define C5TEXT \
"CONGRATULATIONS, YOU'VE FOUND THE SECRET\n"\
@@ -516,7 +516,7 @@
"WILL BE."
-// Before level 32, put this:
+
#define C6TEXT \
"CONGRATULATIONS, YOU'VE FOUND THE\n"\
@@ -524,7 +524,7 @@
"BLAZE THROUGH THIS ONE!\n"
-// after map 06
+
#define P1TEXT \
"You gloat over the steaming carcass of the\n"\
@@ -541,7 +541,7 @@
"Oh yes, keep living, too."
-// after map 11
+
#define P2TEXT \
"Even the deadly Arch-Vile labyrinth could\n"\
@@ -552,7 +552,7 @@
"You're good at that kind of thing."
-// after map 20
+
#define P3TEXT \
"You've bashed and battered your way into\n"\
@@ -566,7 +566,7 @@
"get ready to give the bastard a little Hell\n"\
"of your own making!"
-// after map 30
+
#define P4TEXT \
"The Gatekeeper's evil face is splattered\n"\
@@ -582,7 +582,7 @@
"when you die, you'll need it for some\n"\
"final cleaning-up ..."
-// before map 31
+
#define P5TEXT \
"You've found the second-hardest level we\n"\
@@ -590,7 +590,7 @@
"two previous. If not, be prepared to die\n"\
"aplenty. For master marines only."
-// before map 32
+
#define P6TEXT \
"Betcha wondered just what WAS the hardest\n"\
@@ -671,9 +671,9 @@
-//
-// Character cast strings F_FINALE.C
-//
+
+
+
#define CC_ZOMBIE "ZOMBIEMAN"
#define CC_SHOTGUN "SHOTGUN GUY"
#define CC_HEAVY "HEAVY WEAPON DUDE"
@@ -694,8 +694,8 @@
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_event.h b/src/d_event.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-//
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_EVENT__
@@ -27,11 +27,11 @@
#include "doomtype.h"
-//
-// Event handling.
-//
-// Input event types.
+
+
+
+
typedef enum
{
ev_keydown,
@@ -40,13 +40,13 @@ typedef enum
ev_joystick
} evtype_t;
-// Event structure.
+
typedef struct
{
evtype_t type;
- int data1; // keys / mouse/joystick buttons
- int data2; // mouse/joystick x move
- int data3; // mouse/joystick y move
+ int data1;
+ int data2;
+ int data3;
} event_t;
@@ -66,34 +66,34 @@ typedef enum
-//
-// Button/action code definitions.
-//
+
+
+
typedef enum
{
- // Press "Fire".
+
BT_ATTACK = 1,
- // Use button, to open doors, activate switches.
+
BT_USE = 2,
- // Flag: game events, not really buttons.
+
BT_SPECIAL = 128,
BT_SPECIALMASK = 3,
- // Flag, weapon change pending.
- // If true, the next 3 bits hold weapon num.
+
+
BT_CHANGE = 4,
- // The 3bit weapon mask and shift, convenience.
+
BT_WEAPONMASK = (8+16+32),
BT_WEAPONSHIFT = 3,
- // Pause the game.
+
BTS_PAUSE = 1,
- // Save the game at each console.
+
BTS_SAVEGAME = 2,
- // Savegame slot numbers
- // occupy the second byte of buttons.
+
+
BTS_SAVEMASK = (4+8+16),
BTS_SAVESHIFT = 2,
@@ -102,9 +102,9 @@ typedef enum
-//
-// GLOBAL VARIABLES
-//
+
+
+
#define MAXEVENTS 64
extern event_t events[MAXEVENTS];
@@ -115,8 +115,8 @@ extern gameaction_t gameaction;
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_french.h b/src/d_french.h
@@ -1,37 +1,37 @@
-// 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.
-//
-// DESCRIPTION:
-// Printed strings, french translation.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_FRENCH__
#define __D_FRENCH__
-//
-// D_Main.C
-//
+
+
+
#define D_DEVSTR "MODE DEVELOPPEMENT ON.\n"
#define D_CDROM "VERSION CD-ROM: DEFAULT.CFG DANS C:\\DOOMDATA\n"
-//
-// M_Menu.C
-//
+
+
+
#define PRESSKEY "APPUYEZ SUR UNE TOUCHE."
#define PRESSYN "APPUYEZ SUR Y OU N"
#define QUITMSG "VOUS VOULEZ VRAIMENT\nQUITTER CE SUPER JEU?"
@@ -66,9 +66,9 @@
#define GAMMALVL4 "CORRECTION GAMMA NIVEAU 4"
#define EMPTYSTRING "EMPLACEMENT VIDE"
-//
-// P_inter.C
-//
+
+
+
#define GOTARMOR "ARMURE RECUPEREE."
#define GOTMEGA "MEGA-ARMURE RECUPEREE!"
#define GOTHTHBONUS "BONUS DE SANTE RECUPERE."
@@ -111,9 +111,9 @@
#define GOTSHOTGUN "VOUS AVEZ UN FUSIL!"
#define GOTSHOTGUN2 "VOUS AVEZ UN SUPER FUSIL!"
-//
-// P_Doors.C
-//
+
+
+
#define PD_BLUEO "IL VOUS FAUT UNE CLEF BLEUE"
#define PD_REDO "IL VOUS FAUT UNE CLEF ROUGE"
#define PD_YELLOWO "IL VOUS FAUT UNE CLEF JAUNE"
@@ -121,14 +121,14 @@
#define PD_REDK PD_REDO
#define PD_YELLOWK PD_YELLOWO
-//
-// G_game.C
-//
+
+
+
#define GGSAVED "JEU SAUVEGARDE."
-//
-// HU_stuff.C
-//
+
+
+
#define HUSTR_MSGU "[MESSAGE NON ENVOYE]"
#define HUSTR_E1M1 "E1M1: HANGAR"
@@ -217,22 +217,22 @@
#define HUSTR_MESSAGESENT "[MESSAGE ENVOYE]"
-// The following should NOT be changed unless it seems
-// just AWFULLY necessary
+
+
#define HUSTR_PLRGREEN "VERT: "
#define HUSTR_PLRINDIGO "INDIGO: "
#define HUSTR_PLRBROWN "BRUN: "
#define HUSTR_PLRRED "ROUGE: "
-#define HUSTR_KEYGREEN 'g' // french key should be "V"
+#define HUSTR_KEYGREEN 'g'
#define HUSTR_KEYINDIGO 'i'
#define HUSTR_KEYBROWN 'b'
#define HUSTR_KEYRED 'r'
-//
-// AM_map.C
-//
+
+
+
#define AMSTR_FOLLOWON "MODE POURSUITE ON"
#define AMSTR_FOLLOWOFF "MODE POURSUITE OFF"
@@ -243,9 +243,9 @@
#define AMSTR_MARKEDSPOT "REPERE MARQUE "
#define AMSTR_MARKSCLEARED "REPERES EFFACES "
-//
-// ST_stuff.C
-//
+
+
+
#define STSTR_MUS "CHANGEMENT DE MUSIQUE "
#define STSTR_NOMUS "IMPOSSIBLE SELECTION"
@@ -264,9 +264,9 @@
#define STSTR_CHOPPERS "... DOESN'T SUCK - GM"
#define STSTR_CLEV "CHANGEMENT DE NIVEAU..."
-//
-// F_Finale.C
-//
+
+
+
#define E1TEXT "APRES AVOIR VAINCU LES GROS MECHANTS\n"\
"ET NETTOYE LA BASE LUNAIRE, VOUS AVEZ\n"\
"GAGNE, NON? PAS VRAI? OU EST DONC VOTRE\n"\
@@ -321,7 +321,7 @@
-// after level 6, put this:
+
#define C1TEXT "VOUS ETES AU PLUS PROFOND DE L'ASTROPORT\n" \
"INFESTE DE MONSTRES, MAIS QUELQUE CHOSE\n" \
@@ -336,7 +336,7 @@
"L'INTERRUPTEUR DE CONTROLE QUI GARDE LA \n" \
"POPULATION DE LA TERRE EN OTAGE."
-// After level 11, put this:
+
#define C2TEXT "VOUS AVEZ GAGNE! VOTRE VICTOIRE A PERMIS\n" \
"A L'HUMANITE D'EVACUER LA TERRE ET \n"\
@@ -356,7 +356,7 @@
"VOUS VOUS RELEVEZ LENTEMENT ET PENIBLEMENT\n"\
"ET VOUS REPARTEZ POUR LE FRONT."
-// After level 20, put this:
+
#define C3TEXT "VOUS ETES AU COEUR DE LA CITE CORROMPUE,\n"\
"ENTOURE PAR LES CADAVRES DE VOS ENNEMIS.\n"\
@@ -368,7 +368,7 @@
"DE L'AUTRE COTE. VOUS ACCEPTEZ DE\n"\
"TRAVERSER L'ENFER POUR LE FAIRE?"
-// After level 29, put this:
+
#define C4TEXT "LE VISAGE HORRIBLE D'UN DEMON D'UNE\n"\
"TAILLE INCROYABLE S'EFFONDRE DEVANT\n"\
@@ -386,7 +386,7 @@
"VERS LA TERRE. SA RECONSTRUCTION SERA\n"\
"BEAUCOUP PLUS DROLE QUE SA DESTRUCTION.\n"
-// Before level 31, put this:
+
#define C5TEXT "FELICITATIONS! VOUS AVEZ TROUVE LE\n"\
"NIVEAU SECRET! IL SEMBLE AVOIR ETE\n"\
@@ -394,15 +394,15 @@
"DEMANDEZ QUELS PEUVENT ETRE LES\n"\
"HABITANTS DE CE COIN PERDU DE L'ENFER."
-// Before level 32, put this:
+
#define C6TEXT "FELICITATIONS! VOUS AVEZ DECOUVERT\n"\
"LE NIVEAU SUPER SECRET! VOUS FERIEZ\n"\
"MIEUX DE FONCER DANS CELUI-LA!\n"
-//
-// Character cast strings F_FINALE.C
-//
+
+
+
#define CC_ZOMBIE "ZOMBIE"
#define CC_SHOTGUN "TYPE AU FUSIL"
#define CC_HEAVY "MEC SUPER-ARME"
@@ -424,10 +424,10 @@
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_items.c b/src/d_items.c
@@ -1,29 +1,29 @@
-// 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:
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id:$";
-// We are referring to sprite numbers.
+
#include "info.h"
#ifdef __GNUG__
@@ -32,22 +32,22 @@ rcsid[] = "$Id:$";
#include "d_items.h"
-//
-// PSPRITE ACTIONS for waepons.
-// This struct controls the weapon animations.
-//
-// Each entry is:
-// ammo/amunition type
-// upstate
-// downstate
-// readystate
-// atkstate, i.e. attack/fire/hit frame
-// flashstate, muzzle flash
-//
+
+
+
+
+
+
+
+
+
+
+
+
weaponinfo_t weaponinfo[NUMWEAPONS] =
{
{
- // fist
+
am_noammo,
S_PUNCHUP,
S_PUNCHDOWN,
@@ -56,7 +56,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_NULL
},
{
- // pistol
+
am_clip,
S_PISTOLUP,
S_PISTOLDOWN,
@@ -65,7 +65,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_PISTOLFLASH
},
{
- // shotgun
+
am_shell,
S_SGUNUP,
S_SGUNDOWN,
@@ -74,7 +74,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_SGUNFLASH1
},
{
- // chaingun
+
am_clip,
S_CHAINUP,
S_CHAINDOWN,
@@ -83,7 +83,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_CHAINFLASH1
},
{
- // missile launcher
+
am_misl,
S_MISSILEUP,
S_MISSILEDOWN,
@@ -92,7 +92,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_MISSILEFLASH1
},
{
- // plasma rifle
+
am_cell,
S_PLASMAUP,
S_PLASMADOWN,
@@ -101,7 +101,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_PLASMAFLASH1
},
{
- // bfg 9000
+
am_cell,
S_BFGUP,
S_BFGDOWN,
@@ -110,7 +110,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_BFGFLASH1
},
{
- // chainsaw
+
am_noammo,
S_SAWUP,
S_SAWDOWN,
@@ -119,7 +119,7 @@ weaponinfo_t weaponinfo[NUMWEAPONS] =
S_NULL
},
{
- // super shotgun
+
am_shell,
S_DSGUNUP,
S_DSGUNDOWN,
diff --git a/src/d_items.h b/src/d_items.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// Items: key cards, artifacts, weapon, ammunition.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_ITEMS__
@@ -30,7 +30,7 @@
#endif
-// Weapon info: sprite frames, ammunition use.
+
typedef struct
{
ammotype_t ammo;
@@ -45,8 +45,8 @@ typedef struct
extern weaponinfo_t weaponinfo[NUMWEAPONS];
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_main.c b/src/d_main.c
@@ -1,28 +1,28 @@
-// 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 $";
@@ -77,35 +77,35 @@ static const char rcsid[] = "$Id: d_main.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
#include "d_main.h"
-//
-// 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 devparm;
+boolean nomonsters;
+boolean respawnparm;
+boolean fastparm;
boolean drone;
-boolean singletics = false; // debug flag to cancel adaptiveness
+boolean singletics = false;
+
+
+
-//extern int soundVolume;
-//extern int sfxVolume;
-//extern int musicVolume;
extern boolean inhelpscreens;
@@ -121,9 +121,9 @@ boolean advancedemo;
-char wadfile[1024]; // primary wad file
-char mapdir[1024]; // directory of development maps
-char basedefault[1024]; // default file
+char wadfile[1024];
+char mapdir[1024];
+char basedefault[1024];
void D_CheckNetGame (void);
@@ -132,21 +132,21 @@ 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;
@@ -154,15 +154,15 @@ void D_PostEvent (event_t* ev)
}
-//
-// 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;
@@ -171,7 +171,7 @@ void D_ProcessEvents (void)
{
ev = &events[eventtail];
if (M_Responder (ev))
- continue; // menu ate the event
+ continue;
G_Responder (ev);
}
}
@@ -179,12 +179,12 @@ void D_ProcessEvents (void)
-//
-// 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;
@@ -207,19 +207,19 @@ void D_Display (void)
boolean redrawsbar;
if (nodrawers)
- return; // for comparative timing / profiling
+ return;
redrawsbar = false;
- // change the view size if needed
+
if (setsizeneeded)
{
R_ExecuteSetViewSize ();
- oldgamestate = -1; // force background redraw
+ oldgamestate = -1;
borderdrawcount = 3;
}
- // save the current screen if about to wipe
+
if (gamestate != wipegamestate)
{
wipe = true;
@@ -231,7 +231,7 @@ void D_Display (void)
if (gamestate == GS_LEVEL && gametic)
HU_Erase();
- // do buffered drawing
+
switch (gamestate)
{
case GS_LEVEL:
@@ -242,7 +242,7 @@ void D_Display (void)
if (wipe || (viewheight != 200 && fullscreen) )
redrawsbar = true;
if (inhelpscreensstate && !inhelpscreens)
- redrawsbar = true; // just put away the help screen
+ redrawsbar = true;
ST_Drawer (viewheight == 200, redrawsbar );
fullscreen = viewheight == 200;
break;
@@ -260,35 +260,35 @@ void D_Display (void)
break;
}
- // draw buffered stuff to screen
+
I_UpdateNoBlit ();
- // draw the view directly
+
if (gamestate == GS_LEVEL && !automapactive && gametic)
R_RenderPlayerView (&players[displayplayer]);
if (gamestate == GS_LEVEL && gametic)
HU_Drawer ();
- // clean up border stuff
+
if (gamestate != oldgamestate && gamestate != GS_LEVEL)
I_SetPalette (W_CacheLumpName ("PLAYPAL",PU_CACHE));
- // see if the border needs to be initially drawn
+
if (gamestate == GS_LEVEL && oldgamestate != GS_LEVEL)
{
- viewactivestate = false; // view was not active
- R_FillBackScreen (); // draw the pattern into the back screen
+ viewactivestate = false;
+ R_FillBackScreen ();
}
- // see if the border needs to be updated to the screen
+
if (gamestate == GS_LEVEL && !automapactive && scaledviewwidth != 320)
{
if (menuactive || menuactivestate || !viewactivestate)
borderdrawcount = 3;
if (borderdrawcount)
{
- R_DrawViewBorder (); // erase old menu stuff
+ R_DrawViewBorder ();
borderdrawcount--;
}
@@ -299,7 +299,7 @@ void D_Display (void)
inhelpscreensstate = inhelpscreens;
oldgamestate = wipegamestate = gamestate;
- // draw pause pic
+
if (paused)
{
if (automapactive)
@@ -311,19 +311,19 @@ void D_Display (void)
}
- // menus go directly to the screen
- M_Drawer (); // menu is drawn even on top of everything
- NetUpdate (); // send out any new accumulation
+
+ M_Drawer ();
+ NetUpdate ();
- // normal update
+
if (!wipe)
{
- I_FinishUpdate (); // page flip or blit buffer
+ I_FinishUpdate ();
return;
}
- // wipe update
+
wipe_EndScreen(0, 0, SCREENWIDTH, SCREENHEIGHT);
wipestart = I_GetTime () - 1;
@@ -339,16 +339,16 @@ void D_Display (void)
done = wipe_ScreenWipe(wipe_Melt
, 0, 0, SCREENWIDTH, SCREENHEIGHT, tics);
I_UpdateNoBlit ();
- M_Drawer (); // menu is drawn even on top of wipes
- I_FinishUpdate (); // page flip or blit buffer
+ M_Drawer ();
+ I_FinishUpdate ();
} while (!done);
}
-//
-// D_DoomLoop
-//
+
+
+
extern boolean demorecording;
void D_DoomLoop (void)
@@ -368,10 +368,10 @@ void D_DoomLoop (void)
while (1)
{
- // frame syncronous IO operations
+
I_StartFrame ();
- // process one or more tics
+
if (singletics)
{
I_StartTic ();
@@ -386,21 +386,21 @@ void D_DoomLoop (void)
}
else
{
- TryRunTics (); // will run at least one tic
+ TryRunTics ();
}
- S_UpdateSounds (players[consoleplayer].mo);// move positional sounds
+ S_UpdateSounds (players[consoleplayer].mo);
- // Update display, next frame, with current state.
+
D_Display ();
#ifndef SNDSERV
- // Sound mixing for the buffer is snychronous.
+
I_UpdateSound();
#endif
- // Synchronous sound output is explicitly called.
+
#ifndef SNDINTR
- // Update sound output.
+
I_SubmitSound();
#endif
}
@@ -408,18 +408,18 @@ void D_DoomLoop (void)
-//
-// DEMO LOOP
-//
+
+
+
int demosequence;
int pagetic;
char *pagename;
-//
-// D_PageTicker
-// Handles timing for warped projection
-//
+
+
+
+
void D_PageTicker (void)
{
if (--pagetic < 0)
@@ -428,34 +428,34 @@ void D_PageTicker (void)
-//
-// 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
+ players[consoleplayer].playerstate = PST_LIVE;
advancedemo = false;
- usergame = false; // no save / end game here
+ usergame = false;
paused = false;
gameaction = ga_nothing;
@@ -510,7 +510,7 @@ void D_AdvanceDemo (void)
case 5:
G_DeferedPlayDemo ("demo3");
break;
- // THE DEFINITIVE DOOM Special Edition demo
+
case 6:
G_DeferedPlayDemo ("demo4");
break;
@@ -519,9 +519,9 @@ void D_AdvanceDemo (void)
-//
-// D_StartTitle
-//
+
+
+
void D_StartTitle (void)
{
gameaction = ga_nothing;
@@ -532,14 +532,14 @@ void D_StartTitle (void)
-// print title for every printed line
+
char title[128];
-//
-// D_AddFile
-//
+
+
+
void D_AddFile (char *file)
{
int numwadfiles;
@@ -554,12 +554,12 @@ void D_AddFile (char *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)
{
@@ -579,24 +579,24 @@ void IdentifyVersion (void)
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, "%s/plutonia.wad", doomwaddir);
@@ -604,7 +604,7 @@ void IdentifyVersion (void)
sprintf(tntwad, "%s/tnt.wad", doomwaddir);
- // French stuff.
+
doom2fwad = malloc(strlen(doomwaddir)+1+10+1);
sprintf(doom2fwad, "%s/doom2f.wad", doomwaddir);
@@ -658,8 +658,8 @@ void IdentifyVersion (void)
if ( !access (doom2fwad,R_OK) )
{
gamemode = commercial;
- // C'est ridicule!
- // Let's handle languages in config files, okay?
+
+
language = french;
printf("French version\n");
D_AddFile (doom2fwad);
@@ -711,14 +711,14 @@ void IdentifyVersion (void)
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;
@@ -737,7 +737,7 @@ void FindResponseFile (void)
char *moreargs[20];
char *firstargv;
- // READ THE RESPONSE FILE INTO MEMORY
+
handle = fopen (&myargv[i][1],"rb");
if (!handle)
{
@@ -752,7 +752,7 @@ void FindResponseFile (void)
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];
@@ -763,7 +763,7 @@ void FindResponseFile (void)
infile = file;
indexinfile = k = 0;
- indexinfile++; // SKIP PAST ARGV[0] (KEEP IT)
+ indexinfile++;
do
{
myargv[indexinfile++] = infile+k;
@@ -780,7 +780,7 @@ void FindResponseFile (void)
myargv[indexinfile++] = moreargs[k];
myargc = indexinfile;
- // DISPLAY ARGS
+
printf("%d command-line args:\n",myargc);
for (k=1;k<myargc;k++)
printf("%s\n",myargv[k]);
@@ -790,9 +790,9 @@ void FindResponseFile (void)
}
-//
-// D_DoomMain
-//
+
+
+
void D_DoomMain (void)
{
int p;
@@ -881,7 +881,7 @@ void D_DoomMain (void)
strcpy (basedefault,"c:/doomdata/default.cfg");
}
- // turbo option
+
if ( (p=M_CheckParm ("-turbo")) )
{
int scale = 200;
@@ -901,17 +901,17 @@ void D_DoomMain (void)
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
+ myargv[p][4] = 'p';
- // Map name handling.
+
switch (gamemode )
{
case shareware:
@@ -938,9 +938,9 @@ void D_DoomMain (void)
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
+
+
+ modifiedgame = true;
while (++p != myargc && myargv[p][0] != '-')
D_AddFile (myargv[p]);
}
@@ -957,7 +957,7 @@ void D_DoomMain (void)
printf("Playing demo %s.lmp.\n",myargv[p+1]);
}
- // get skill / episode / map from parms
+
startskill = sk_medium;
startepisode = 1;
startmap = 1;
@@ -1007,12 +1007,12 @@ void D_DoomMain (void)
autostart = true;
}
- // init subsystems
+
printf ("V_Init: allocate screens.\n");
V_Init ();
printf ("M_LoadDefaults: Load system defaults.\n");
- M_LoadDefaults (); // load before initing other systems
+ M_LoadDefaults ();
printf ("Z_Init: Init zone memory allocation daemon. \n");
Z_Init ();
@@ -1021,11 +1021,11 @@ void D_DoomMain (void)
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",
@@ -1038,15 +1038,15 @@ void D_DoomMain (void)
I_Error("\nYou 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("\nThis is not the registered version.");
}
- // Iff additonal PWAD files are used, print modified banner
+
if (modifiedgame)
{
/*m*/printf (
@@ -1061,7 +1061,7 @@ void D_DoomMain (void)
}
- // Check and print which version is executed.
+
switch ( gamemode )
{
case shareware:
@@ -1084,7 +1084,7 @@ void D_DoomMain (void)
break;
default:
- // Ouch.
+
break;
}
@@ -1112,18 +1112,18 @@ void D_DoomMain (void)
printf ("ST_Init: Init status bar.\n");
ST_Init ();
- // check for a driver that wants intermission stats
+
p = M_CheckParm ("-statcopy");
if (p && p<myargc-1)
{
- // for statistics driver
+
extern void* statcopy;
statcopy = (void*)atoi(myargv[p+1]);
printf ("External statistics registered.\n");
}
- // start the apropriate game based on parms
+
p = M_CheckParm ("-record");
if (p && p < myargc-1)
@@ -1135,16 +1135,16 @@ void D_DoomMain (void)
p = M_CheckParm ("-playdemo");
if (p && p < myargc-1)
{
- singledemo = true; // quit after one demo
+ singledemo = true;
G_DeferedPlayDemo (myargv[p+1]);
- D_DoomLoop (); // never returns
+ D_DoomLoop ();
}
p = M_CheckParm ("-timedemo");
if (p && p < myargc-1)
{
G_TimeDemo (myargv[p+1]);
- D_DoomLoop (); // never returns
+ D_DoomLoop ();
}
p = M_CheckParm ("-loadgame");
@@ -1163,9 +1163,9 @@ void D_DoomMain (void)
if (autostart || netgame)
G_InitNew (startskill, startepisode, startmap);
else
- D_StartTitle (); // start up intro loop
+ D_StartTitle ();
}
- D_DoomLoop (); // never returns
+ D_DoomLoop ();
}
diff --git a/src/d_main.h b/src/d_main.h
@@ -1,25 +1,25 @@
-// 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:
-// System specific interface stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_MAIN__
@@ -40,22 +40,22 @@ void D_AddFile (char *file);
-//
-// D_DoomMain()
-// Not a globally visible function, just included for source reference,
-// calls all startup code, parses command line options.
-// If not overrided by user input, calls N_AdvanceDemo.
-//
+
+
+
+
+
+
void D_DoomMain (void);
-// Called by IO functions when input is detected.
+
void D_PostEvent (event_t* ev);
-//
-// BASE LEVEL
-//
+
+
+
void D_PageTicker (void);
void D_PageDrawer (void);
void D_AdvanceDemo (void);
diff --git a/src/d_net.c b/src/d_net.c
@@ -1,26 +1,26 @@
-// 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 Network game communication and protocol,
-// all OS independend parts.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char rcsid[] = "$Id: d_net.c,v 1.3 1997/02/03 22:01:47 b1 Exp $";
@@ -37,33 +37,33 @@ static const char rcsid[] = "$Id: d_net.c,v 1.3 1997/02/03 22:01:47 b1 Exp $";
#define NCMD_EXIT 0x80000000
#define NCMD_RETRANSMIT 0x40000000
#define NCMD_SETUP 0x20000000
-#define NCMD_KILL 0x10000000 // kill game
+#define NCMD_KILL 0x10000000
#define NCMD_CHECKSUM 0x0fffffff
doomcom_t* doomcom;
-doomdata_t* netbuffer; // points inside doomcom
-
-
-//
-// NETWORKING
-//
-// gametic is the tic about to (or currently being) run
-// maketic is the tick that hasn't had control made for it yet
-// nettics[] has the maketics for all players
-//
-// a gametic cannot be run until nettics[] > gametic for all players
-//
+doomdata_t* netbuffer;
+
+
+
+
+
+
+
+
+
+
+
#define RESENDCOUNT 10
-#define PL_DRONE 0x80 // bit flag in doomdata->player
+#define PL_DRONE 0x80
ticcmd_t localcmds[BACKUPTICS];
ticcmd_t netcmds[MAXPLAYERS][BACKUPTICS];
int nettics[MAXNETNODES];
-boolean nodeingame[MAXNETNODES]; // set false as nodes leave game
-boolean remoteresend[MAXNETNODES]; // set when local needs tics
-int resendto[MAXNETNODES]; // set when remote needs tics
+boolean nodeingame[MAXNETNODES];
+boolean remoteresend[MAXNETNODES];
+int resendto[MAXNETNODES];
int resendcount[MAXNETNODES];
int nodeforplayer[MAXPLAYERS];
@@ -72,7 +72,7 @@ int maketic;
int lastnettic;
int skiptics;
int ticdup;
-int maxsend; // BACKUPTICS/(2*ticdup)-1
+int maxsend;
void D_ProcessEvents (void);
@@ -84,17 +84,17 @@ doomdata_t reboundstore;
-//
-//
-//
+
+
+
int NetbufferSize (void)
{
return (int)&(((doomdata_t *)0)->cmds[netbuffer->numtics]);
}
-//
-// Checksum
-//
+
+
+
unsigned NetbufferChecksum (void)
{
unsigned c;
@@ -102,9 +102,9 @@ unsigned NetbufferChecksum (void)
c = 0x1234567;
- // FIXME -endianess?
+
#ifdef NORMALUNIX
- return 0; // byte order problems
+ return 0;
#endif
l = (NetbufferSize () - (int)&(((doomdata_t *)0)->retransmitfrom))/4;
@@ -114,9 +114,9 @@ unsigned NetbufferChecksum (void)
return c & NCMD_CHECKSUM;
}
-//
-//
-//
+
+
+
int ExpandTics (int low)
{
int delta;
@@ -136,9 +136,9 @@ int ExpandTics (int low)
-//
-// HSendPacket
-//
+
+
+
void
HSendPacket
(int node,
@@ -185,10 +185,10 @@ HSendPacket
I_NetCmd ();
}
-//
-// HGetPacket
-// Returns false if no packet is waiting
-//
+
+
+
+
boolean HGetPacket (void)
{
if (reboundpacket)
@@ -253,9 +253,9 @@ boolean HGetPacket (void)
}
-//
-// GetPackets
-//
+
+
+
char exitmsg[80];
void GetPackets (void)
@@ -269,17 +269,17 @@ void GetPackets (void)
while ( HGetPacket() )
{
if (netbuffer->checksum & NCMD_SETUP)
- continue; // extra setup packet
+ continue;
netconsole = netbuffer->player & ~PL_DRONE;
netnode = doomcom->remotenode;
- // to save bytes, only the low byte of tic numbers are sent
- // Figure out what the rest of the bytes are
+
+
realstart = ExpandTics (netbuffer->starttic);
realend = (realstart+netbuffer->numtics);
- // check for exiting the game
+
if (netbuffer->checksum & NCMD_EXIT)
{
if (!nodeingame[netnode])
@@ -294,13 +294,13 @@ void GetPackets (void)
continue;
}
- // check for a remote game kill
+
if (netbuffer->checksum & NCMD_KILL)
I_Error ("Killed by network driver");
nodeforplayer[netconsole] = netnode;
- // check for retransmit request
+
if ( resendcount[netnode] <= 0
&& (netbuffer->checksum & NCMD_RETRANSMIT) )
{
@@ -312,7 +312,7 @@ void GetPackets (void)
else
resendcount[netnode]--;
- // check for out of order / duplicated packet
+
if (realend == nettics[netnode])
continue;
@@ -325,10 +325,10 @@ void GetPackets (void)
continue;
}
- // check for a missed packet
+
if (realstart > nettics[netnode])
{
- // stop processing until the other system resends the missed tics
+
if (debugfile)
fprintf (debugfile,
"missed tics from %i (%i - %i)\n",
@@ -337,7 +337,7 @@ void GetPackets (void)
continue;
}
- // update command store from the packet
+
{
int start;
@@ -358,11 +358,11 @@ void GetPackets (void)
}
-//
-// NetUpdate
-// Builds ticcmds for console player,
-// sends out a packet
-//
+
+
+
+
+
int gametime;
void NetUpdate (void)
@@ -373,12 +373,12 @@ void NetUpdate (void)
int realstart;
int gameticdiv;
- // check time
+
nowtime = I_GetTime ()/ticdup;
newtics = nowtime - gametime;
gametime = nowtime;
- if (newtics <= 0) // nothing new to update
+ if (newtics <= 0)
goto listen;
if (skiptics <= newtics)
@@ -395,25 +395,25 @@ void NetUpdate (void)
netbuffer->player = consoleplayer;
- // build new ticcmds for console player
+
gameticdiv = gametic/ticdup;
for (i=0 ; i<newtics ; i++)
{
I_StartTic ();
D_ProcessEvents ();
if (maketic - gameticdiv >= BACKUPTICS/2-1)
- break; // can't hold any more
+ break;
+
- //printf ("mk:%i ",maketic);
G_BuildTiccmd (&localcmds[maketic%BACKUPTICS]);
maketic++;
}
if (singletics)
- return; // singletic update is syncronous
+ return;
+
- // send the packet to the other nodes
for (i=0 ; i<doomcom->numnodes ; i++)
if (nodeingame[i])
{
@@ -440,16 +440,16 @@ void NetUpdate (void)
}
}
- // listen for other packets
+
listen:
GetPackets ();
}
-//
-// CheckAbort
-//
+
+
+
void CheckAbort (void)
{
event_t *ev;
@@ -470,9 +470,9 @@ void CheckAbort (void)
}
-//
-// D_ArbitrateNetStart
-//
+
+
+
void D_ArbitrateNetStart (void)
{
int i;
@@ -483,7 +483,7 @@ void D_ArbitrateNetStart (void)
if (doomcom->consoleplayer)
{
- // listen for setup info from key player
+
printf ("listening for network start info...\n");
while (1)
{
@@ -506,7 +506,7 @@ void D_ArbitrateNetStart (void)
}
else
{
- // key player, send the setup info
+
printf ("sending network start info...\n");
do
{
@@ -546,10 +546,10 @@ void D_ArbitrateNetStart (void)
}
}
-//
-// D_CheckNetGame
-// Works out player numbers among the net participants
-//
+
+
+
+
extern int viewangleoffset;
void D_CheckNetGame (void)
@@ -560,11 +560,11 @@ void D_CheckNetGame (void)
{
nodeingame[i] = false;
nettics[i] = 0;
- remoteresend[i] = false; // set when local needs tics
- resendto[i] = 0; // which tic to start sending
+ remoteresend[i] = false;
+ resendto[i] = 0;
}
- // I_InitNetwork sets doomcom and netgame
+
I_InitNetwork ();
if (doomcom->id != DOOMCOM_ID)
I_Error ("Doomcom buffer invalid!");
@@ -577,7 +577,7 @@ void D_CheckNetGame (void)
printf ("startskill %i deathmatch: %i startmap: %i startepisode: %i\n",
startskill, deathmatch, startmap, startepisode);
- // read values out of doomcom
+
ticdup = doomcom->ticdup;
maxsend = BACKUPTICS/(2*ticdup)-1;
if (maxsend<1)
@@ -594,11 +594,11 @@ void D_CheckNetGame (void)
}
-//
-// D_QuitNetGame
-// Called before quitting to leave a net game
-// without hanging the other players
-//
+
+
+
+
+
void D_QuitNetGame (void)
{
int i, j;
@@ -609,7 +609,7 @@ void D_QuitNetGame (void)
if (!netgame || !usergame || consoleplayer == -1 || demoplayback)
return;
- // send a bunch of packets for security
+
netbuffer->player = consoleplayer;
netbuffer->numtics = 0;
for (i=0 ; i<4 ; i++)
@@ -623,9 +623,9 @@ void D_QuitNetGame (void)
-//
-// TryRunTics
-//
+
+
+
int frametics[4];
int frameon;
int frameskip[4];
@@ -644,12 +644,12 @@ void TryRunTics (void)
int counts;
int numplaying;
- // get real tics
+
entertic = I_GetTime ()/ticdup;
realtics = entertic - oldentertics;
oldentertics = entertic;
- // get available tics
+
NetUpdate ();
lowtic = MAXINT;
@@ -665,7 +665,7 @@ void TryRunTics (void)
}
availabletics = lowtic - gametic/ticdup;
- // decide how many tics to run
+
if (realtics < availabletics-1)
counts = realtics+1;
else if (realtics < availabletics)
@@ -685,33 +685,33 @@ void TryRunTics (void)
if (!demoplayback)
{
- // ideally nettics[0] should be 1 - 3 tics above lowtic
- // if we are consistantly slower, speed up time
+
+
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i])
break;
if (consoleplayer == i)
{
- // the key player does not adapt
+
}
else
{
if (nettics[0] <= nettics[nodeforplayer[i]])
{
gametime--;
- // printf ("-");
+
}
frameskip[frameon&3] = (oldnettics > nettics[nodeforplayer[i]]);
oldnettics = nettics[0];
if (frameskip[0] && frameskip[1] && frameskip[2] && frameskip[3])
{
skiptics = 1;
- // printf ("+");
+
}
}
- }// demoplayback
+ }
- // wait for new tics if needed
+
while (lowtic < gametic/ticdup + counts)
{
NetUpdate ();
@@ -724,7 +724,7 @@ void TryRunTics (void)
if (lowtic < gametic/ticdup)
I_Error ("TryRunTics: lowtic < gametic");
- // don't stay in here forever -- give the menu a chance to work
+
if (I_GetTime ()/ticdup - entertic >= 20)
{
M_Ticker ();
@@ -732,7 +732,7 @@ void TryRunTics (void)
}
}
- // run the count * ticdup dics
+
while (counts--)
{
for (i=0 ; i<ticdup ; i++)
@@ -745,7 +745,7 @@ void TryRunTics (void)
G_Ticker ();
gametic++;
- // modify command for duplicated tics
+
if (i != ticdup-1)
{
ticcmd_t *cmd;
@@ -762,6 +762,6 @@ void TryRunTics (void)
}
}
}
- NetUpdate (); // check for new console commands
+ NetUpdate ();
}
}
diff --git a/src/d_net.h b/src/d_net.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// Networking stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_NET__
@@ -31,21 +31,21 @@
#endif
-//
-// Network play related stuff.
-// There is a data struct that stores network
-// communication related stuff, and another
-// one that defines the actual packets to
-// be transmitted.
-//
+
+
+
+
+
+
+
#define DOOMCOM_ID 0x12345678l
-// Max computers/players in a game.
+
#define MAXNETNODES 8
-// Networking and tick handling related.
+
#define BACKUPTICS 12
typedef enum
@@ -56,14 +56,14 @@ typedef enum
} command_t;
-//
-// Network packet data.
-//
+
+
+
typedef struct
{
- // High bit is retransmit request.
+
unsigned checksum;
- // Only valid if NCMD_RETRANSMIT.
+
byte retransmitfrom;
byte starttic;
@@ -78,72 +78,72 @@ typedef struct
typedef struct
{
- // Supposed to be DOOMCOM_ID?
+
long id;
- // DOOM executes an int to execute commands.
+
short intnum;
- // Communication between DOOM and the driver.
- // Is CMD_SEND or CMD_GET.
+
+
short command;
- // Is dest for send, set by get (-1 = no packet).
+
short remotenode;
- // Number of bytes in doomdata to be sent
+
short datalength;
- // Info common to all nodes.
- // Console is allways node 0.
+
+
short numnodes;
- // Flag: 1 = no duplication, 2-5 = dup for slow nets.
+
short ticdup;
- // Flag: 1 = send a backup tic in every packet.
+
short extratics;
- // Flag: 1 = deathmatch.
+
short deathmatch;
- // Flag: -1 = new game, 0-5 = load savegame
+
short savegame;
- short episode; // 1-3
- short map; // 1-9
- short skill; // 1-5
+ short episode;
+ short map;
+ short skill;
- // Info specific to this node.
+
short consoleplayer;
short numplayers;
- // These are related to the 3-display mode,
- // in which two drones looking left and right
- // were used to render two additional views
- // on two additional computers.
- // Probably not operational anymore.
- // 1 = left, 0 = center, -1 = right
+
+
+
+
+
+
short angleoffset;
- // 1 = drone
+
short drone;
- // The packet data to be sent.
+
doomdata_t data;
} doomcom_t;
-// Create any new ticcmds and broadcast to other players.
+
void NetUpdate (void);
-// Broadcasts special packets to other players
-// to notify of game exit
+
+
void D_QuitNetGame (void);
-//? how many ticks to run?
+
void TryRunTics (void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_player.h b/src/d_player.h
@@ -1,43 +1,43 @@
-// 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.
-//
-// DESCRIPTION:
-//
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_PLAYER__
#define __D_PLAYER__
-// The player data structure depends on a number
-// of other structs: items (internal inventory),
-// animation states (closely tied to the sprites
-// used to represent them, unfortunately).
+
+
+
+
#include "d_items.h"
#include "p_pspr.h"
-// In addition, the player is just a special
-// case of the generic moving object/actor.
+
+
#include "p_mobj.h"
-// Finally, for odd reasons, the player input
-// is buffered within the player data struct,
-// as commands per game tick.
+
+
+
#include "d_ticcmd.h"
#ifdef __GNUG__
@@ -47,151 +47,151 @@
-//
-// Player states.
-//
+
+
+
typedef enum
{
- // Playing or camping.
+
PST_LIVE,
- // Dead on the ground, view follows killer.
+
PST_DEAD,
- // Ready to restart/respawn???
+
PST_REBORN
} playerstate_t;
-//
-// Player internal flags, for cheats and debug.
-//
+
+
+
typedef enum
{
- // No clipping, walk through barriers.
+
CF_NOCLIP = 1,
- // No damage, no health loss.
+
CF_GODMODE = 2,
- // Not really a cheat, just a debug aid.
+
CF_NOMOMENTUM = 4
} cheat_t;
-//
-// Extended player object info: player_t
-//
+
+
+
typedef struct player_s
{
mobj_t* mo;
playerstate_t playerstate;
ticcmd_t cmd;
- // Determine POV,
- // including viewpoint bobbing during movement.
- // Focal origin above r.z
+
+
+
fixed_t viewz;
- // Base height above floor for viewz.
+
fixed_t viewheight;
- // Bob/squat speed.
+
fixed_t deltaviewheight;
- // bounded/scaled total momentum.
+
fixed_t bob;
- // This is only used between levels,
- // mo->health is used during levels.
+
+
int health;
int armorpoints;
- // Armor type is 0-2.
+
int armortype;
- // Power ups. invinc and invis are tic counters.
+
int powers[NUMPOWERS];
boolean cards[NUMCARDS];
boolean backpack;
- // Frags, kills of other players.
+
int frags[MAXPLAYERS];
weapontype_t readyweapon;
- // Is wp_nochange if not changing.
+
weapontype_t pendingweapon;
boolean weaponowned[NUMWEAPONS];
int ammo[NUMAMMO];
int maxammo[NUMAMMO];
- // True if button down last tic.
+
int attackdown;
int usedown;
- // Bit flags, for cheats and debug.
- // See cheat_t, above.
+
+
int cheats;
- // Refired shots are less accurate.
+
int refire;
- // For intermission stats.
+
int killcount;
int itemcount;
int secretcount;
- // Hint messages.
+
char* message;
- // For screen flashing (red or bright).
+
int damagecount;
int bonuscount;
- // Who did damage (NULL for floors/ceilings).
+
mobj_t* attacker;
- // So gun flashes light up areas.
+
int extralight;
- // Current PLAYPAL, ???
- // can be set to REDCOLORMAP for pain, etc.
+
+
int fixedcolormap;
- // Player skin colorshift,
- // 0-3 for which color to draw player.
+
+
int colormap;
- // Overlay view sprites (gun, etc).
+
pspdef_t psprites[NUMPSPRITES];
- // True if secret level has been done.
+
boolean didsecret;
} player_t;
-//
-// INTERMISSION
-// Structure passed e.g. to WI_Start(wb)
-//
+
+
+
+
typedef struct
{
- boolean in; // whether the player is in game
+ boolean in;
+
- // Player stats, kills, collected items etc.
int skills;
int sitems;
int ssecret;
int stime;
int frags[4];
- int score; // current score on entry, modified on return
+ int score;
} wbplayerstruct_t;
typedef struct
{
- int epsd; // episode # (0-2)
+ int epsd;
- // if true, splash the secret level
+
boolean didsecret;
- // previous and next levels, origin 0
+
int last;
int next;
@@ -200,10 +200,10 @@ typedef struct
int maxsecret;
int maxfrags;
- // the par time
+
int partime;
- // index of this player in game
+
int pnum;
wbplayerstruct_t plyr[MAXPLAYERS];
@@ -212,8 +212,8 @@ typedef struct
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_textur.h b/src/d_textur.h
@@ -1,24 +1,24 @@
-// 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.
-//
-// DESCRIPTION:
-// Typedefs related to to textures etc.,
-// isolated here to make it easier separating modules.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_TEXTUR__
@@ -29,10 +29,10 @@
-//
-// Flats?
-//
-// a pic is an unmasked block of pixels
+
+
+
+
typedef struct
{
byte width;
@@ -44,8 +44,8 @@ typedef struct
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_think.h b/src/d_think.h
@@ -1,25 +1,25 @@
-// 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.
-//
-// DESCRIPTION:
-// MapObj data. Map Objects or mobjs are actors, entities,
-// thinker, take-your-pick... anything that moves, acts, or
-// suffers state changes of more or less violent nature.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_THINK__
@@ -32,12 +32,12 @@
-//
-// Experimental stuff.
-// To compile this as "ANSI C with classes"
-// we will need to handle the various
-// action functions cleanly.
-//
+
+
+
+
+
+
typedef void (*actionf_v)();
typedef void (*actionf_p1)( void* );
typedef void (*actionf_p2)( void*, void* );
@@ -54,13 +54,13 @@ typedef union
-// Historically, "think_t" is yet another
-// function pointer to a routine to handle
-// an actor.
+
+
+
typedef actionf_t think_t;
-// Doubly linked list of actors.
+
typedef struct thinker_s
{
struct thinker_s* prev;
@@ -72,8 +72,8 @@ typedef struct thinker_s
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/d_ticcmd.h b/src/d_ticcmd.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// System specific interface stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_TICCMD__
@@ -29,16 +29,16 @@
#pragma interface
#endif
-// The data sampled per tick (single player)
-// and transmitted to other peers (multiplayer).
-// Mainly movements/button commands per game tick,
-// plus a checksum for internal state consistency.
+
+
+
+
typedef struct
{
- char forwardmove; // *2048 for move
- char sidemove; // *2048 for move
- short angleturn; // <<16 for angle delta
- short consistancy; // checks for net game
+ char forwardmove;
+ char sidemove;
+ short angleturn;
+ short consistancy;
byte chatchar;
byte buttons;
} ticcmd_t;
@@ -46,8 +46,8 @@ typedef struct
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/doomdata.h b/src/doomdata.h
@@ -1,62 +1,62 @@
-// 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.
-//
-// DESCRIPTION:
-// all external data is defined here
-// most of the data is loaded into different structures at run time
-// some internal structures shared by many modules are here
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __DOOMDATA__
#define __DOOMDATA__
-// The most basic types we use, portability.
+
#include "doomtype.h"
-// Some global defines, that configure the game.
+
#include "doomdef.h"
-//
-// Map level types.
-// The following data structures define the persistent format
-// used in the lumps of the WAD files.
-//
-// Lump order in a map WAD: each map needs a couple of lumps
-// to provide a complete scene geometry description.
+
+
+
+
+
+
+
enum
{
- ML_LABEL, // A separator, name, ExMx or MAPxx
- ML_THINGS, // Monsters, items..
- ML_LINEDEFS, // LineDefs, from editing
- ML_SIDEDEFS, // SideDefs, from editing
- ML_VERTEXES, // Vertices, edited and BSP splits generated
- ML_SEGS, // LineSegs, from LineDefs split by BSP
- ML_SSECTORS, // SubSectors, list of LineSegs
- ML_NODES, // BSP nodes
- ML_SECTORS, // Sectors, from editing
- ML_REJECT, // LUT, sector-sector visibility
- ML_BLOCKMAP // LUT, motion clipping, walls/grid element
+ ML_LABEL,
+ ML_THINGS,
+ ML_LINEDEFS,
+ ML_SIDEDEFS,
+ ML_VERTEXES,
+ ML_SEGS,
+ ML_SSECTORS,
+ ML_NODES,
+ ML_SECTORS,
+ ML_REJECT,
+ ML_BLOCKMAP
};
-// A single Vertex.
+
typedef struct
{
short x;
@@ -64,8 +64,8 @@ typedef struct
} mapvertex_t;
-// A SideDef, defining the visual appearance of a wall,
-// by setting textures and offsets.
+
+
typedef struct
{
short textureoffset;
@@ -73,14 +73,14 @@ typedef struct
char toptexture[8];
char bottomtexture[8];
char midtexture[8];
- // Front sector, towards viewer.
+
short sector;
} mapsidedef_t;
-// A LineDef, as used for editing, and as input
-// to the BSP builder.
+
+
typedef struct
{
short v1;
@@ -88,56 +88,56 @@ typedef struct
short flags;
short special;
short tag;
- // sidenum[1] will be -1 if one sided
+
short sidenum[2];
} maplinedef_t;
-//
-// LineDef attributes.
-//
-// Solid, is an obstacle.
+
+
+
+
#define ML_BLOCKING 1
-// Blocks monsters only.
+
#define ML_BLOCKMONSTERS 2
-// Backside will not be present at all
-// if not two sided.
+
+
#define ML_TWOSIDED 4
-// If a texture is pegged, the texture will have
-// the end exposed to air held constant at the
-// top or bottom of the texture (stairs or pulled
-// down things) and will move with a height change
-// of one of the neighbor sectors.
-// Unpegged textures allways have the first row of
-// the texture at the top pixel of the line for both
-// top and bottom textures (use next to windows).
-// upper texture unpegged
+
+
+
+
+
+
+
+
+
#define ML_DONTPEGTOP 8
-// lower texture unpegged
+
#define ML_DONTPEGBOTTOM 16
-// In AutoMap: don't map as two sided: IT'S A SECRET!
+
#define ML_SECRET 32
-// Sound rendering: don't let sound cross two of these.
+
#define ML_SOUNDBLOCK 64
-// Don't draw on the automap at all.
+
#define ML_DONTDRAW 128
-// Set if already seen, thus drawn in automap.
+
#define ML_MAPPED 256
-// Sector definition, from editing.
+
typedef struct
{
short floorheight;
@@ -149,17 +149,17 @@ typedef struct
short tag;
} mapsector_t;
-// SubSector, as generated by BSP.
+
typedef struct
{
short numsegs;
- // Index of first one, segs are stored sequentially.
+
short firstseg;
} mapsubsector_t;
-// LineSeg, generated by splitting LineDefs
-// using partition lines selected by BSP builder.
+
+
typedef struct
{
short v1;
@@ -172,25 +172,25 @@ typedef struct
-// BSP node structure.
-// Indicate a leaf.
+
+
#define NF_SUBSECTOR 0x8000
typedef struct
{
- // Partition line from (x,y) to x+dx,y+dy)
+
short x;
short y;
short dx;
short dy;
- // Bounding box for each child,
- // clip against view frustum.
+
+
short bbox[2][4];
- // If NF_SUBSECTOR its a subsector,
- // else it's a node of another subtree.
+
+
unsigned short children[2];
} mapnode_t;
@@ -198,8 +198,8 @@ typedef struct
-// Thing definition, position, orientation and type,
-// plus skill/visibility flags and attributes.
+
+
typedef struct
{
short x;
@@ -213,10 +213,10 @@ typedef struct
-#endif // __DOOMDATA__
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+#endif
+
+
+
+
+
diff --git a/src/doomdef.c b/src/doomdef.c
@@ -1,26 +1,26 @@
-// 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:
-// DoomDef - basic defines for DOOM, e.g. Version, game mode
-// and skill level, and display parameters.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
@@ -31,8 +31,8 @@ rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
#endif
#include "doomdef.h"
-// Location for any defines turned variables.
-// None.
+
+
diff --git a/src/doomdef.h b/src/doomdef.h
@@ -1,24 +1,24 @@
-// 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.
-//
-// DESCRIPTION:
-// Internally used data structures for virtually everything,
-// key definitions, lots of other stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __DOOMDEF__
#define __DOOMDEF__
@@ -26,40 +26,40 @@
#include <stdio.h>
#include <string.h>
-//
-// Global parameters/defines.
-//
-// DOOM version
+
+
+
+
enum { VERSION = 110 };
-// Game mode handling - identify IWAD version
-// to handle IWAD dependend animations etc.
+
+
typedef enum
{
- shareware, // DOOM 1 shareware, E1, M9
- registered, // DOOM 1 registered, E3, M27
- commercial, // DOOM 2 retail, E1 M34
- // DOOM 2 german edition not handled
- retail, // DOOM 1 retail, E4, M36
- indetermined // Well, no IWAD found.
+ shareware,
+ registered,
+ commercial,
+
+ retail,
+ indetermined
} GameMode_t;
-// Mission packs - might be useful for TC stuff?
+
typedef enum
{
- doom, // DOOM 1
- doom2, // DOOM 2
- pack_tnt, // TNT mission pack
- pack_plut, // Plutonia pack
+ doom,
+ doom2,
+ pack_tnt,
+ pack_plut,
none
} GameMission_t;
-// Identify language to use, software localization.
+
typedef enum
{
english,
@@ -70,60 +70,60 @@ typedef enum
} Language_t;
-// If rangecheck is undefined,
-// most parameter validation debugging code will not be compiled
+
+
#define RANGECHECK
-// Do or do not use external soundserver.
-// The sndserver binary to be run separately
-// has been introduced by Dave Taylor.
-// The integrated sound support is experimental,
-// and unfinished. Default is synchronous.
-// Experimental asynchronous timer based is
-// handled by SNDINTR.
+
+
+
+
+
+
+
#define SNDSERV 1
-//#define SNDINTR 1
-// This one switches between MIT SHM (no proper mouse)
-// and XFree86 DGA (mickey sampling). The original
-// linuxdoom used SHM, which is default.
-//#define X11_DGA 1
-//
-// For resize of screen, at start of game.
-// It will not work dynamically, see visplanes.
-//
+
+
+
+
+
+
+
+
+
#define BASE_WIDTH 320
-// It is educational but futile to change this
-// scaling e.g. to 2. Drawing of status bar,
-// menues etc. is tied to the scale implied
-// by the graphics.
+
+
+
+
#define SCREEN_MUL 1
-#define INV_ASPECT_RATIO 0.625 // 0.75, ideally
+#define INV_ASPECT_RATIO 0.625
+
+
+
-// Defines suck. C sucks.
-// C++ might sucks for OOP, but it sure is a better C.
-// So there.
#define SCREENWIDTH 320
-//SCREEN_MUL*BASE_WIDTH //320
+
#define SCREENHEIGHT 200
-//(int)(SCREEN_MUL*BASE_WIDTH*INV_ASPECT_RATIO) //200
-// The maximum number of players, multiplayer/networking.
+
+
#define MAXPLAYERS 4
-// State updates, number of tics / second.
+
#define TICRATE 35
-// The current state of the game: whether we are
-// playing, gazing at the intermission screen,
-// the game final animation, or a demo.
+
+
+
typedef enum
{
GS_LEVEL,
@@ -132,16 +132,16 @@ typedef enum
GS_DEMOSCREEN
} gamestate_t;
-//
-// Difficulty/skill settings/filters.
-//
-// Skill flags.
+
+
+
+
#define MTF_EASY 1
#define MTF_NORMAL 2
#define MTF_HARD 4
-// Deaf monsters/do not react to sound.
+
#define MTF_AMBUSH 8
typedef enum
@@ -156,9 +156,9 @@ typedef enum
-//
-// Key cards.
-//
+
+
+
typedef enum
{
it_bluecard,
@@ -174,9 +174,9 @@ typedef enum
-// The defined weapons,
-// including a marker indicating
-// user has not changed weapon.
+
+
+
typedef enum
{
wp_fist,
@@ -191,26 +191,26 @@ typedef enum
NUMWEAPONS,
- // No pending weapon change.
+
wp_nochange
} weapontype_t;
-// Ammunition types defined.
+
typedef enum
{
- am_clip, // Pistol / chaingun ammo.
- am_shell, // Shotgun / double barreled shotgun.
- am_cell, // Plasma rifle, BFG.
- am_misl, // Missile launcher.
+ am_clip,
+ am_shell,
+ am_cell,
+ am_misl,
NUMAMMO,
- am_noammo // Unlimited for chainsaw / fist.
+ am_noammo
} ammotype_t;
-// Power up artifacts.
+
typedef enum
{
pw_invulnerability,
@@ -225,11 +225,11 @@ typedef enum
-//
-// Power up durations,
-// how many seconds till expiration,
-// assuming TICRATE is 35 ticks/second.
-//
+
+
+
+
+
typedef enum
{
INVULNTICS = (30*TICRATE),
@@ -242,11 +242,11 @@ typedef enum
-//
-// DOOM keyboard definition.
-// This is the stuff configured by Setup.Exe.
-// Most key data are simple ascii (uppercased).
-//
+
+
+
+
+
#define KEY_RIGHTARROW 0xae
#define KEY_LEFTARROW 0xac
#define KEY_UPARROW 0xad
@@ -281,58 +281,58 @@ typedef enum
-// DOOM basic types (boolean),
-// and max/min values.
-//#include "doomtype.h"
-// Fixed point.
-//#include "m_fixed.h"
-// Endianess handling.
-//#include "m_swap.h"
-// Binary Angles, sine/cosine/atan lookups.
-//#include "tables.h"
-// Event type.
-//#include "d_event.h"
-// Game function, skills.
-//#include "g_game.h"
-// All external data is defined here.
-//#include "doomdata.h"
-// All important printed strings.
-// Language selection (message strings).
-//#include "dstrings.h"
-// Player is a special actor.
-//struct player_s;
-//#include "d_items.h"
-//#include "d_player.h"
-//#include "p_mobj.h"
-//#include "d_net.h"
-// PLAY
-//#include "p_tick.h"
-// Header, generated by sound utility.
-// The utility was written by Dave Taylor.
-//#include "sounds.h"
-#endif // __DOOMDEF__
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif
+
+
+
+
+
diff --git a/src/doomstat.c b/src/doomstat.c
@@ -1,25 +1,25 @@
-// 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:
-// Put all global tate variables here.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
@@ -31,14 +31,14 @@ rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
#include "doomstat.h"
-// Game Mode - identify IWAD as shareware, retail etc.
+
GameMode_t gamemode = indetermined;
GameMission_t gamemission = doom;
-// Language.
+
Language_t language = english;
-// Set if homebrew PWAD stuff has been added.
+
boolean modifiedgame;
diff --git a/src/doomstat.h b/src/doomstat.h
@@ -1,39 +1,39 @@
-// 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.
-//
-// DESCRIPTION:
-// All the global variables that store the internal state.
-// Theoretically speaking, the internal state of the engine
-// should be found by looking at the variables collected
-// here, and every relevant module will have to include
-// this header file.
-// In practice, things are a bit messy.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __D_STATE__
#define __D_STATE__
-// We need globally shared data structures,
-// for defining the global state variables.
+
+
#include "doomdata.h"
#include "d_net.h"
-// We need the playr data structure as well.
+
#include "d_player.h"
@@ -43,95 +43,95 @@
-// ------------------------
-// Command line parameters.
-//
-extern boolean nomonsters; // checkparm of -nomonsters
-extern boolean respawnparm; // checkparm of -respawn
-extern boolean fastparm; // checkparm of -fast
-extern boolean devparm; // DEBUG: launched with -devparm
+
+
+extern boolean nomonsters;
+extern boolean respawnparm;
+extern boolean fastparm;
+
+extern boolean devparm;
+
+
+
-// -----------------------------------------------------
-// Game Mode - identify IWAD as shareware, retail etc.
-//
extern GameMode_t gamemode;
extern GameMission_t gamemission;
-// Set if homebrew PWAD stuff has been added.
+
extern boolean modifiedgame;
-// -------------------------------------------
-// Language.
+
+
extern Language_t language;
-// -------------------------------------------
-// Selected skill type, map etc.
-//
-// Defaults for menu, methinks.
+
+
+
+
extern skill_t startskill;
extern int startepisode;
extern int startmap;
extern boolean autostart;
-// Selected by user.
+
extern skill_t gameskill;
extern int gameepisode;
extern int gamemap;
-// Nightmare mode flag, single player.
+
extern boolean respawnmonsters;
-// Netgame? Only true if >1 player.
+
extern boolean netgame;
-// Flag: true only if started as net deathmatch.
-// An enum might handle altdeath/cooperative better.
+
+
extern boolean deathmatch;
-// -------------------------
-// Internal parameters for sound rendering.
-// These have been taken from the DOS version,
-// but are not (yet) supported with Linux
-// (e.g. no sound volume adjustment with menu.
-
-// These are not used, but should be (menu).
-// From m_menu.c:
-// Sound FX volume has default, 0 - 15
-// Music volume has default, 0 - 15
-// These are multiplied by 8.
-extern int snd_SfxVolume; // maximum volume for sound
-extern int snd_MusicVolume; // maximum volume for music
-
-// Current music/sfx card - index useless
-// w/o a reference LUT in a sound module.
-// Ideally, this would use indices found
-// in: /usr/include/linux/soundcard.h
+
+
+
+
+
+
+
+
+
+
+
+extern int snd_SfxVolume;
+extern int snd_MusicVolume;
+
+
+
+
+
extern int snd_MusicDevice;
extern int snd_SfxDevice;
-// Config file? Same disclaimer as above.
+
extern int snd_DesiredMusicDevice;
extern int snd_DesiredSfxDevice;
-// -------------------------
-// Status flags for refresh.
-//
-// Depending on view size - no status bar?
-// Note that there is no way to disable the
-// status bar explicitely.
+
+
+
+
+
+
extern boolean statusbaractive;
-extern boolean automapactive; // In AutoMap mode?
-extern boolean menuactive; // Menu overlayed?
-extern boolean paused; // Game Pause?
+extern boolean automapactive;
+extern boolean menuactive;
+extern boolean paused;
extern boolean viewactive;
@@ -150,46 +150,46 @@ extern int scaledviewwidth;
-// This one is related to the 3-screen display mode.
-// ANG90 = left side, ANG270 = right
+
+
extern int viewangleoffset;
-// Player taking events, and displaying.
+
extern int consoleplayer;
extern int displayplayer;
-// -------------------------------------
-// Scores, rating.
-// Statistics on a given map, for intermission.
-//
+
+
+
+
extern int totalkills;
extern int totalitems;
extern int totalsecret;
-// Timer, for scores.
-extern int levelstarttic; // gametic at level start
-extern int leveltime; // tics in game play for par
+
+extern int levelstarttic;
+extern int leveltime;
+
+
+
+
-// --------------------------------------
-// DEMO playback/recording related stuff.
-// No demo, there is a human player in charge?
-// Disable save/end game?
extern boolean usergame;
-//?
+
extern boolean demoplayback;
extern boolean demorecording;
-// Quit after playing a demo from cmdline.
+
extern boolean singledemo;
-//?
+
extern gamestate_t gamestate;
@@ -197,83 +197,83 @@ extern gamestate_t gamestate;
-//-----------------------------
-// Internal parameters, fixed.
-// These are set by the engine, and not changed
-// according to user inputs. Partly load from
-// WAD, partly set at startup time.
+
+
+
+
+
extern int gametic;
-// Bookkeeping on players - state.
+
extern player_t players[MAXPLAYERS];
-// Alive? Disconnected?
+
extern boolean playeringame[MAXPLAYERS];
-// Player spawn spots for deathmatch.
+
#define MAX_DM_STARTS 10
extern mapthing_t deathmatchstarts[MAX_DM_STARTS];
extern mapthing_t* deathmatch_p;
-// Player spawn spots.
+
extern mapthing_t playerstarts[MAXPLAYERS];
-// Intermission stats.
-// Parameters for world map / intermission.
+
+
extern wbstartstruct_t wminfo;
-// LUT of ammunition limits for each kind.
-// This doubles with BackPack powerup item.
+
+
extern int maxammo[NUMAMMO];
-//-----------------------------------------
-// Internal parameters, used for engine.
-//
-// File handling stuff.
+
+
+
+
extern char basedefault[1024];
extern FILE* debugfile;
-// if true, load all graphics at level load
+
extern boolean precache;
-// wipegamestate can be set to -1
-// to force a wipe on the next draw
+
+
extern gamestate_t wipegamestate;
extern int mouseSensitivity;
-//?
-// debug flag to cancel adaptiveness
+
+
extern boolean singletics;
extern int bodyqueslot;
-// Needed to store the number of the dummy sky flat.
-// Used for rendering,
-// as well as tracking projectiles etc.
+
+
+
extern int skyflatnum;
-// Netgame stuff (buffers and pointers, i.e. indices).
-// This is ???
+
+
extern doomcom_t* doomcom;
-// This points inside doomcom.
+
extern doomdata_t* netbuffer;
@@ -289,8 +289,8 @@ extern int ticdup;
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/doomtype.h b/src/doomtype.h
@@ -1,24 +1,24 @@
-// 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.
-//
-// DESCRIPTION:
-// Simple basic typedefs, isolated here to make it easier
-// separating modules.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __DOOMTYPE__
@@ -27,7 +27,7 @@
#ifndef __BYTEBOOL__
#define __BYTEBOOL__
-// Fixed to use builtin bool type with C++.
+
#ifdef __cplusplus
typedef bool boolean;
#else
@@ -37,20 +37,20 @@ typedef unsigned char byte;
#endif
-// Predefined with some OS.
+
#ifdef LINUX
#include <values.h>
#else
#define MAXCHAR ((char)0x7f)
#define MAXSHORT ((short)0x7fff)
-// Max pos 32-bit int.
+
#define MAXINT ((int)0x7fffffff)
#define MAXLONG ((long)0x7fffffff)
#define MINCHAR ((char)0x80)
#define MINSHORT ((short)0x8000)
-// Max negative 32-bit integer.
+
#define MININT ((int)0x80000000)
#define MINLONG ((long)0x80000000)
#endif
@@ -59,8 +59,8 @@ typedef unsigned char byte;
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/dstrings.c b/src/dstrings.c
@@ -1,25 +1,25 @@
-// 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:
-// Globally defined strings.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
@@ -34,7 +34,7 @@ rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
char* endmsg[NUM_QUITMESSAGES+1]=
{
- // DOOM1
+
QUITMSG,
"please don't leave, there's more\ndemons to toast!",
"let's beat it -- this is turning\ninto a bloodbath!",
@@ -44,7 +44,7 @@ char* endmsg[NUM_QUITMESSAGES+1]=
"ya know, next time you come in here\ni'm gonna toast ya.",
"go ahead and leave. see if i care."
- // QuitDOOM II messages
+
"you want to quit?\nthen, thou hast lost an eighth!",
"don't go now, there's a \ndimensional shambler waiting\nat the dos prompt!",
"get outta here and go back\nto your boring programs.",
@@ -53,7 +53,7 @@ char* endmsg[NUM_QUITMESSAGES+1]=
"just leave. when you come\nback, i'll be waiting with a bat.",
"you're lucky i don't smack\nyou for thinking about leaving."
- // FinalDOOM?
+
"fuck you, pussy!\nget the fuck out!",
"you quit and i'll jizz\nin your cystholes!",
"if you leave, i'll make\nthe lord drink my jizz.",
@@ -62,7 +62,7 @@ char* endmsg[NUM_QUITMESSAGES+1]=
"suck it down, asshole!\nyou're a fucking wimp!",
"don't quit now! we're \nstill spending your money!",
- // Internal debug. Different style, too.
+
"THIS IS NO MESSAGE!\nPage intentionally left blank."
};
diff --git a/src/dstrings.h b/src/dstrings.h
@@ -1,35 +1,35 @@
-// 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 strings, by language.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __DSTRINGS__
#define __DSTRINGS__
-// All important printed strings.
-// Language selection (message strings).
-// Use -DFRENCH etc.
+
+
+
#ifdef FRENCH
#include "d_french.h"
@@ -37,30 +37,30 @@
#include "d_englsh.h"
#endif
-// Misc. other strings.
+
#define SAVEGAMENAME "doomsav"
-//
-// 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[];
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/f_finale.c b/src/f_finale.c
@@ -1,25 +1,25 @@
-// 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:
-// Game completion, final screen animation.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
@@ -27,7 +27,7 @@ rcsid[] = "$Id: f_finale.c,v 1.5 1997/02/03 21:26:34 b1 Exp $";
#include <ctype.h>
-// Functions.
+
#include "i_system.h"
#include "m_swap.h"
#include "z_zone.h"
@@ -35,20 +35,20 @@ rcsid[] = "$Id: f_finale.c,v 1.5 1997/02/03 21:26:34 b1 Exp $";
#include "w_wad.h"
#include "s_sound.h"
-// Data.
+
#include "dstrings.h"
#include "sounds.h"
#include "doomstat.h"
#include "r_state.h"
-// ?
-//#include "doomstat.h"
-//#include "r_local.h"
-//#include "f_finale.h"
-// Stage of animation:
-// 0 = text, 1 = art screen, 2 = character cast
+
+
+
+
+
+
int finalestage;
int finalecount;
@@ -90,9 +90,9 @@ void F_CastTicker (void);
boolean F_CastResponder (event_t *ev);
void F_CastDrawer (void);
-//
-// F_StartFinale
-//
+
+
+
void F_StartFinale (void)
{
gameaction = ga_nothing;
@@ -100,13 +100,13 @@ void F_StartFinale (void)
viewactive = false;
automapactive = false;
- // Okay - IWAD dependend stuff.
- // This has been changed severly, and
- // some stuff might have changed in the process.
+
+
+
switch ( gamemode )
{
- // DOOM 1 - E1, E3 or E4, but each nine missions
+
case shareware:
case registered:
case retail:
@@ -132,13 +132,13 @@ void F_StartFinale (void)
finaletext = e4text;
break;
default:
- // Ouch.
+
break;
}
break;
}
- // DOOM II and missions packs with E1, M34
+
case commercial:
{
S_ChangeMusic(mus_read_m, true);
@@ -170,18 +170,18 @@ void F_StartFinale (void)
finaletext = c6text;
break;
default:
- // Ouch.
+
break;
}
break;
}
- // Indeterminate.
+
default:
S_ChangeMusic(mus_read_m, true);
- finaleflat = "F_SKY1"; // Not used anywhere else.
- finaletext = c1text; // FIXME - other text, music?
+ finaleflat = "F_SKY1";
+ finaletext = c1text;
break;
}
@@ -201,18 +201,18 @@ boolean F_Responder (event_t *event)
}
-//
-// F_Ticker
-//
+
+
+
void F_Ticker (void)
{
int i;
- // check for skipping
+
if ( (gamemode == commercial)
&& ( finalecount > 50) )
{
- // go on to the next level
+
for (i=0 ; i<MAXPLAYERS ; i++)
if (players[i].cmd.buttons)
break;
@@ -226,7 +226,7 @@ void F_Ticker (void)
}
}
- // advance animation
+
finalecount++;
if (finalestage == 2)
@@ -242,7 +242,7 @@ void F_Ticker (void)
{
finalecount = 0;
finalestage = 1;
- wipegamestate = -1; // force a wipe
+ wipegamestate = -1;
if (gameepisode == 3)
S_StartMusic (mus_bunny);
}
@@ -250,9 +250,9 @@ void F_Ticker (void)
-//
-// F_TextWrite
-//
+
+
+
#include "hu_stuff.h"
extern patch_t *hu_font[HU_FONTSIZE];
@@ -270,7 +270,7 @@ void F_TextWrite (void)
int cx;
int cy;
- // erase the entire screen to a tiled background
+
src = W_CacheLumpName ( finaleflat , PU_CACHE);
dest = screens[0];
@@ -290,7 +290,7 @@ void F_TextWrite (void)
V_MarkRect (0, 0, SCREENWIDTH, SCREENHEIGHT);
- // draw some of the text onto the screen
+
cx = 10;
cy = 10;
ch = finaletext;
@@ -326,11 +326,11 @@ void F_TextWrite (void)
}
-//
-// Final DOOM 2 animation
-// Casting by id Software.
-// in order of appearance
-//
+
+
+
+
+
typedef struct
{
char *name;
@@ -368,15 +368,15 @@ int castonmelee;
boolean castattacking;
-//
-// F_StartCast
-//
+
+
+
extern gamestate_t wipegamestate;
void F_StartCast (void)
{
- wipegamestate = -1; // force a screen wipe
+ wipegamestate = -1;
castnum = 0;
caststate = &states[mobjinfo[castorder[castnum].type].seestate];
casttics = caststate->tics;
@@ -389,20 +389,20 @@ void F_StartCast (void)
}
-//
-// F_CastTicker
-//
+
+
+
void F_CastTicker (void)
{
int st;
int sfx;
if (--casttics > 0)
- return; // not time to change state yet
+ return;
if (caststate->tics == -1 || caststate->nextstate == S_NULL)
{
- // switch from deathstate to next monster
+
castnum++;
castdeath = false;
if (castorder[castnum].name == NULL)
@@ -414,14 +414,14 @@ void F_CastTicker (void)
}
else
{
- // just advance to next state in animation
+
if (caststate == &states[S_PLAY_ATK1])
- goto stopattack; // Oh, gross hack!
+ goto stopattack;
st = caststate->nextstate;
caststate = &states[st];
castframes++;
- // sound hacks....
+
switch (st)
{
case S_PLAY_ATK1: sfx = sfx_dshtgn; break;
@@ -459,7 +459,7 @@ void F_CastTicker (void)
if (castframes == 12)
{
- // go into attack frame
+
castattacking = true;
if (castonmelee)
caststate=&states[mobjinfo[castorder[castnum].type].meleestate];
@@ -495,9 +495,9 @@ void F_CastTicker (void)
}
-//
-// F_CastResponder
-//
+
+
+
boolean F_CastResponder (event_t* ev)
{
@@ -505,9 +505,9 @@ boolean F_CastResponder (event_t* ev)
return false;
if (castdeath)
- return true; // already in dying frames
+ return true;
- // go into death frame
+
castdeath = true;
caststate = &states[mobjinfo[castorder[castnum].type].deathstate];
casttics = caststate->tics;
@@ -528,7 +528,7 @@ void F_CastPrint (char* text)
int w;
int width;
- // find width
+
ch = text;
width = 0;
@@ -548,7 +548,7 @@ void F_CastPrint (char* text)
width += w;
}
- // draw it
+
cx = 160-width/2;
ch = text;
while (ch)
@@ -571,9 +571,9 @@ void F_CastPrint (char* text)
}
-//
-// F_CastDrawer
-//
+
+
+
void V_DrawPatchFlipped (int x, int y, int scrn, patch_t *patch);
void F_CastDrawer (void)
@@ -584,12 +584,12 @@ void F_CastDrawer (void)
boolean flip;
patch_t* patch;
- // erase the entire screen to a background
+
V_DrawPatch (0,0,0, W_CacheLumpName ("BOSSBACK", PU_CACHE));
F_CastPrint (castorder[castnum].name);
- // draw the current frame in the middle of the screen
+
sprdef = &sprites[caststate->sprite];
sprframe = &sprdef->spriteframes[ caststate->frame & FF_FRAMEMASK];
lump = sprframe->lump[0];
@@ -603,9 +603,9 @@ void F_CastDrawer (void)
}
-//
-// F_DrawPatchCol
-//
+
+
+
void
F_DrawPatchCol
( int x,
@@ -621,7 +621,7 @@ F_DrawPatchCol
column = (column_t *)((byte *)patch + LONG(patch->columnofs[col]));
desttop = screens[0]+x;
- // step through the posts in a column
+
while (column->topdelta != 0xff )
{
source = (byte *)column + 3;
@@ -638,9 +638,9 @@ F_DrawPatchCol
}
-//
-// F_BunnyScroll
-//
+
+
+
void F_BunnyScroll (void)
{
int scrolled;
@@ -694,9 +694,9 @@ void F_BunnyScroll (void)
}
-//
-// F_Drawer
-//
+
+
+
void F_Drawer (void)
{
if (finalestage == 2)
diff --git a/src/f_finale.h b/src/f_finale.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-//
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __F_FINALE__
@@ -26,17 +26,17 @@
#include "doomtype.h"
#include "d_event.h"
-//
-// FINALE
-//
-// Called by main loop.
+
+
+
+
boolean F_Responder (event_t* ev);
-// Called by main loop.
+
void F_Ticker (void);
-// Called by main loop.
+
void F_Drawer (void);
@@ -46,8 +46,8 @@ void F_StartFinale (void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/f_wipe.c b/src/f_wipe.c
@@ -1,25 +1,25 @@
-// 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:
-// Mission begin melt/wipe screen special effect.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char rcsid[] = "$Id: f_wipe.c,v 1.2 1997/02/03 22:45:09 b1 Exp $";
@@ -35,11 +35,11 @@ static const char rcsid[] = "$Id: f_wipe.c,v 1.2 1997/02/03 22:45:09 b1 Exp $";
#include "f_wipe.h"
-//
-// SCREEN WIPE PACKAGE
-//
-// when zero, stop the wipe
+
+
+
+
static boolean go = 0;
static byte* wipe_scr_start;
@@ -145,16 +145,16 @@ wipe_initMelt
{
int i, r;
- // copy start screen to main screen
+
memcpy(wipe_scr, wipe_scr_start, width*height);
- // makes this wipe faster (in theory)
- // to have stuff in column-major format
+
+
wipe_shittyColMajorXform((short*)wipe_scr_start, width/2, height);
wipe_shittyColMajorXform((short*)wipe_scr_end, width/2, height);
- // setup initial column positions
- // (y<0 => not ready to scroll yet)
+
+
y = (int *) Z_Malloc(width*sizeof(int), PU_STATIC, 0);
y[0] = -(M_Random()%16);
for (i=1;i<width;i++)
@@ -254,7 +254,7 @@ wipe_EndScreen
{
wipe_scr_end = screens[3];
I_ReadScreen(wipe_scr_end);
- V_DrawBlock(x, y, 0, width, height, wipe_scr_start); // restore start scr.
+ V_DrawBlock(x, y, 0, width, height, wipe_scr_start);
return 0;
}
@@ -276,21 +276,21 @@ wipe_ScreenWipe
void V_MarkRect(int, int, int, int);
- // initial stuff
+
if (!go)
{
go = 1;
- // wipe_scr = (byte *) Z_Malloc(width*height, PU_STATIC, 0); // DEBUG
+
wipe_scr = screens[0];
(*wipes[wipeno*3])(width, height, ticks);
}
- // do a piece of wipe-in
+
V_MarkRect(0, 0, width, height);
rc = (*wipes[wipeno*3+1])(width, height, ticks);
- // V_DrawBlock(x, y, 0, width, height, wipe_scr); // DEBUG
+
- // final stuff
+
if (rc)
{
go = 0;
diff --git a/src/f_wipe.h b/src/f_wipe.h
@@ -1,38 +1,38 @@
-// 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.
-//
-// DESCRIPTION:
-// Mission start screen wipe/melt, special effects.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __F_WIPE_H__
#define __F_WIPE_H__
-//
-// SCREEN WIPE PACKAGE
-//
+
+
+
enum
{
- // simple gradual pixel change for 8-bit only
+
wipe_ColorXForm,
- // weird screen melt
+
wipe_Melt,
wipe_NUMWIPES
@@ -64,8 +64,8 @@ wipe_ScreenWipe
int ticks );
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/g_game.c b/src/g_game.c
@@ -1,24 +1,24 @@
-// 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: none
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
@@ -49,7 +49,7 @@ rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
#include "st_stuff.h"
#include "am_map.h"
-// Needs access to LFB.
+
#include "v_video.h"
#include "w_wad.h"
@@ -58,11 +58,11 @@ rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
#include "s_sound.h"
-// Data.
+
#include "dstrings.h"
#include "sounds.h"
-// SKY handling - still the wrong place.
+
#include "r_data.h"
#include "r_sky.h"
@@ -102,27 +102,27 @@ int gameepisode;
int gamemap;
boolean paused;
-boolean sendpause; // send a pause event next tic
-boolean sendsave; // send a save event next tic
-boolean usergame; // ok to save / end game
+boolean sendpause;
+boolean sendsave;
+boolean usergame;
-boolean timingdemo; // if true, exit with report on completion
-boolean nodrawers; // for comparative timing purposes
-boolean noblit; // for comparative timing purposes
-int starttime; // for comparative timing purposes
+boolean timingdemo;
+boolean nodrawers;
+boolean noblit;
+int starttime;
boolean viewactive;
-boolean deathmatch; // only if started as net death
-boolean netgame; // only true if packets are broadcast
+boolean deathmatch;
+boolean netgame;
boolean playeringame[MAXPLAYERS];
player_t players[MAXPLAYERS];
-int consoleplayer; // player taking events and displaying
-int displayplayer; // view being displayed
+int consoleplayer;
+int displayplayer;
int gametic;
-int levelstarttic; // gametic at level start
-int totalkills, totalitems, totalsecret; // for intermission
+int levelstarttic;
+int totalkills, totalitems, totalsecret;
char demoname[32];
boolean demorecording;
@@ -131,20 +131,20 @@ boolean netdemo;
byte* demobuffer;
byte* demo_p;
byte* demoend;
-boolean singledemo; // quit after playing a demo from cmdline
+boolean singledemo;
-boolean precache = true; // if true, load all graphics at start
+boolean precache = true;
-wbstartstruct_t wminfo; // parms for world map / intermission
+wbstartstruct_t wminfo;
short consistancy[MAXPLAYERS][BACKUPTICS];
byte* savebuffer;
-//
-// controls (have defaults)
-//
+
+
+
int key_right;
int key_left;
@@ -174,19 +174,19 @@ int joybspeed;
fixed_t forwardmove[2] = {0x19, 0x32};
fixed_t sidemove[2] = {0x18, 0x28};
-fixed_t angleturn[3] = {640, 1280, 320}; // + slow turn
+fixed_t angleturn[3] = {640, 1280, 320};
#define SLOWTURNTICS 6
#define NUMKEYS 256
boolean gamekeydown[NUMKEYS];
-int turnheld; // for accelerative turning
+int turnheld;
boolean mousearray[4];
-boolean* mousebuttons = &mousearray[1]; // allow [-1]
+boolean* mousebuttons = &mousearray[1];
+
-// mouse values are used once
int mousex;
int mousey;
@@ -197,11 +197,11 @@ int dclicktime2;
int dclickstate2;
int dclicks2;
-// joystick values are repeated
+
int joyxmove;
int joyymove;
boolean joyarray[5];
-boolean* joybuttons = &joyarray[1]; // allow [-1]
+boolean* joybuttons = &joyarray[1];
int savegameslot;
char savedescription[32];
@@ -212,7 +212,7 @@ char savedescription[32];
mobj_t* bodyque[BODYQUESIZE];
int bodyqueslot;
-void* statcopy; // for statistics driver
+void* statcopy;
@@ -228,12 +228,12 @@ int G_CmdChecksum (ticcmd_t* cmd)
}
-//
-// G_BuildTiccmd
-// Builds a ticcmd from all of the available inputs
-// or reads it from the demo buffer.
-// If recording a demo, write it out
-//
+
+
+
+
+
+
void G_BuildTiccmd (ticcmd_t* cmd)
{
int i;
@@ -246,7 +246,7 @@ void G_BuildTiccmd (ticcmd_t* cmd)
ticcmd_t* base;
- base = I_BaseTiccmd (); // empty, or external driver
+ base = I_BaseTiccmd ();
memcpy (cmd,base,sizeof(*cmd));
cmd->consistancy =
@@ -259,8 +259,8 @@ void G_BuildTiccmd (ticcmd_t* cmd)
forward = side = 0;
- // use two stage accelerative turning
- // on the keyboard and joystick
+
+
if (joyxmove < 0
|| joyxmove > 0
|| gamekeydown[key_right]
@@ -270,21 +270,21 @@ void G_BuildTiccmd (ticcmd_t* cmd)
turnheld = 0;
if (turnheld < SLOWTURNTICS)
- tspeed = 2; // slow turn
+ tspeed = 2;
else
tspeed = speed;
- // let movement keys cancel each other out
+
if (strafe)
{
if (gamekeydown[key_right])
{
- // fprintf(stderr, "strafe right\n");
+
side += sidemove[speed];
}
if (gamekeydown[key_left])
{
- // fprintf(stderr, "strafe left\n");
+
side -= sidemove[speed];
}
if (joyxmove > 0)
@@ -307,12 +307,12 @@ void G_BuildTiccmd (ticcmd_t* cmd)
if (gamekeydown[key_up])
{
- // fprintf(stderr, "up\n");
+
forward += forwardmove[speed];
}
if (gamekeydown[key_down])
{
- // fprintf(stderr, "down\n");
+
forward -= forwardmove[speed];
}
if (joyymove < 0)
@@ -324,7 +324,7 @@ void G_BuildTiccmd (ticcmd_t* cmd)
if (gamekeydown[key_strafeleft])
side -= sidemove[speed];
- // buttons
+
cmd->chatchar = HU_dequeueChatChar();
if (gamekeydown[key_fire] || mousebuttons[mousebfire]
@@ -334,11 +334,11 @@ void G_BuildTiccmd (ticcmd_t* cmd)
if (gamekeydown[key_use] || joybuttons[joybuse] )
{
cmd->buttons |= BT_USE;
- // clear double clicks if hit use button
+
dclicks = 0;
}
- // chainsaw overrides
+
for (i=0 ; i<NUMWEAPONS-1 ; i++)
if (gamekeydown['1'+i])
{
@@ -347,11 +347,11 @@ void G_BuildTiccmd (ticcmd_t* cmd)
break;
}
- // mouse
+
if (mousebuttons[mousebforward])
forward += forwardmove[speed];
- // forward double click
+
if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 )
{
dclickstate = mousebuttons[mousebforward];
@@ -375,7 +375,7 @@ void G_BuildTiccmd (ticcmd_t* cmd)
}
}
- // strafe double click
+
bstrafe =
mousebuttons[mousebstrafe]
|| joybuttons[joybstrafe];
@@ -422,7 +422,7 @@ void G_BuildTiccmd (ticcmd_t* cmd)
cmd->forwardmove += forward;
cmd->sidemove += side;
- // special buttons
+
if (sendpause)
{
sendpause = false;
@@ -437,24 +437,24 @@ void G_BuildTiccmd (ticcmd_t* cmd)
}
-//
-// G_DoLoadLevel
-//
+
+
+
extern gamestate_t wipegamestate;
void G_DoLoadLevel (void)
{
int i;
- // Set the sky map.
- // First thing, we have a dummy sky texture name,
- // a flat. The data is in the WAD only because
- // we look for an actual index, instead of simply
- // setting one.
+
+
+
+
+
skyflatnum = R_FlatNumForName ( SKYFLATNAME );
- // DOOM determines the sky texture to be used
- // depending on the current episode, and the game version.
+
+
if ( (gamemode == commercial)
|| ( gamemode == pack_tnt )
|| ( gamemode == pack_plut ) )
@@ -467,10 +467,10 @@ void G_DoLoadLevel (void)
skytexture = R_TextureNumForName ("SKY2");
}
- levelstarttic = gametic; // for time calculation
+ levelstarttic = gametic;
if (wipegamestate == GS_LEVEL)
- wipegamestate = -1; // force a wipe
+ wipegamestate = -1;
gamestate = GS_LEVEL;
@@ -482,12 +482,12 @@ void G_DoLoadLevel (void)
}
P_SetupLevel (gameepisode, gamemap, 0, gameskill);
- displayplayer = consoleplayer; // view the guy you are playing
+ displayplayer = consoleplayer;
starttime = I_GetTime ();
gameaction = ga_nothing;
Z_CheckHeap ();
- // clear cmd building stuff
+
memset (gamekeydown, 0, sizeof(gamekeydown));
joyxmove = joyymove = 0;
mousex = mousey = 0;
@@ -497,17 +497,17 @@ void G_DoLoadLevel (void)
}
-//
-// G_Responder
-// Get info needed to make ticcmd_ts for the players.
-//
+
+
+
+
boolean G_Responder (event_t* ev)
{
- // allow spy mode changes even during the demo
+
if (gamestate == GS_LEVEL && ev->type == ev_keydown
&& ev->data1 == KEY_F12 && (singledemo || !deathmatch) )
{
- // spy mode
+
do
{
displayplayer++;
@@ -517,7 +517,7 @@ boolean G_Responder (event_t* ev)
return true;
}
- // any other key pops up menu if in demos
+
if (gameaction == ga_nothing && !singledemo &&
(demoplayback || gamestate == GS_DEMOSCREEN)
)
@@ -542,17 +542,17 @@ boolean G_Responder (event_t* ev)
}
#endif
if (HU_Responder (ev))
- return true; // chat ate the event
+ return true;
if (ST_Responder (ev))
- return true; // status window ate it
+ return true;
if (AM_Responder (ev))
- return true; // automap ate it
+ return true;
}
if (gamestate == GS_FINALE)
{
if (F_Responder (ev))
- return true; // finale ate the event
+ return true;
}
switch (ev->type)
@@ -565,12 +565,12 @@ boolean G_Responder (event_t* ev)
}
if (ev->data1 <NUMKEYS)
gamekeydown[ev->data1] = true;
- return true; // eat key down events
+ return true;
case ev_keyup:
if (ev->data1 <NUMKEYS)
gamekeydown[ev->data1] = false;
- return false; // always let key up events filter down
+ return false;
case ev_mouse:
mousebuttons[0] = ev->data1 & 1;
@@ -578,7 +578,7 @@ boolean G_Responder (event_t* ev)
mousebuttons[2] = ev->data1 & 4;
mousex = ev->data2*(mouseSensitivity+5)/10;
mousey = ev->data3*(mouseSensitivity+5)/10;
- return true; // eat events
+ return true;
case ev_joystick:
joybuttons[0] = ev->data1 & 1;
@@ -587,7 +587,7 @@ boolean G_Responder (event_t* ev)
joybuttons[3] = ev->data1 & 8;
joyxmove = ev->data2;
joyymove = ev->data3;
- return true; // eat events
+ return true;
default:
break;
@@ -598,22 +598,22 @@ boolean G_Responder (event_t* ev)
-//
-// G_Ticker
-// Make ticcmd_ts for the players.
-//
+
+
+
+
void G_Ticker (void)
{
int i;
int buf;
ticcmd_t* cmd;
- // do player reborns if needed
+
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i] && players[i].playerstate == PST_REBORN)
G_DoReborn (i);
- // do things to change the game state
+
while (gameaction != ga_nothing)
{
switch (gameaction)
@@ -651,8 +651,8 @@ void G_Ticker (void)
}
}
- // get commands, check consistancy,
- // and build new consistancy check
+
+
buf = (gametic/ticdup)%BACKUPTICS;
for (i=0 ; i<MAXPLAYERS ; i++)
@@ -668,7 +668,7 @@ void G_Ticker (void)
if (demorecording)
G_WriteDemoTiccmd (cmd);
- // check for turbo cheats
+
if (cmd->forwardmove > TURBOTHRESHOLD
&& !(gametic&31) && ((gametic>>5)&3) == i )
{
@@ -694,7 +694,7 @@ void G_Ticker (void)
}
}
- // check for special buttons
+
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (playeringame[i])
@@ -723,7 +723,7 @@ void G_Ticker (void)
}
}
- // do main actions
+
switch (gamestate)
{
case GS_LEVEL:
@@ -748,34 +748,34 @@ void G_Ticker (void)
}
-//
-// PLAYER STRUCTURE FUNCTIONS
-// also see P_SpawnPlayer in P_Things
-//
-//
-// G_InitPlayer
-// Called at the start.
-// Called by the game initialization functions.
-//
+
+
+
+
+
+
+
+
+
void G_InitPlayer (int player)
{
player_t* p;
- // set up the saved info
+
p = &players[player];
- // clear everything else to defaults
+
G_PlayerReborn (player);
}
-//
-// G_PlayerFinishLevel
-// Can when a player completes a level.
-//
+
+
+
+
void G_PlayerFinishLevel (int player)
{
player_t* p;
@@ -784,19 +784,19 @@ void G_PlayerFinishLevel (int player)
memset (p->powers, 0, sizeof (p->powers));
memset (p->cards, 0, sizeof (p->cards));
- p->mo->flags &= ~MF_SHADOW; // cancel invisibility
- p->extralight = 0; // cancel gun flashes
- p->fixedcolormap = 0; // cancel ir gogles
- p->damagecount = 0; // no palette changes
+ p->mo->flags &= ~MF_SHADOW;
+ p->extralight = 0;
+ p->fixedcolormap = 0;
+ p->damagecount = 0;
p->bonuscount = 0;
}
-//
-// G_PlayerReborn
-// Called after a player dies
-// almost everything is cleared and initialized
-//
+
+
+
+
+
void G_PlayerReborn (int player)
{
player_t* p;
@@ -819,7 +819,7 @@ void G_PlayerReborn (int player)
players[player].itemcount = itemcount;
players[player].secretcount = secretcount;
- p->usedown = p->attackdown = true; // don't do anything immediately
+ p->usedown = p->attackdown = true;
p->playerstate = PST_LIVE;
p->health = MAXHEALTH;
p->readyweapon = p->pendingweapon = wp_pistol;
@@ -832,12 +832,12 @@ void G_PlayerReborn (int player)
}
-//
-// G_CheckSpot
-// Returns false if the player cannot be respawned
-// at the given mapthing_t spot
-// because something is occupying it
-//
+
+
+
+
+
+
void P_SpawnPlayer (mapthing_t* mthing);
boolean
@@ -854,7 +854,7 @@ G_CheckSpot
if (!players[playernum].mo)
{
- // first spawn of level, before corpses
+
for (i=0 ; i<playernum ; i++)
if (players[i].mo->x == mthing->x << FRACBITS
&& players[i].mo->y == mthing->y << FRACBITS)
@@ -868,13 +868,13 @@ G_CheckSpot
if (!P_CheckPosition (players[playernum].mo, x, y) )
return false;
- // flush an old corpse if needed
+
if (bodyqueslot >= BODYQUESIZE)
P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]);
bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo;
bodyqueslot++;
- // spawn a teleport fog
+
ss = R_PointInSubsector (x,y);
an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT;
@@ -883,17 +883,17 @@ G_CheckSpot
, MT_TFOG);
if (players[consoleplayer].viewz != 1)
- S_StartSound (mo, sfx_telept); // don't start sound on first frame
+ S_StartSound (mo, sfx_telept);
return true;
}
-//
-// G_DeathMatchSpawnPlayer
-// Spawns a player at one of the random death match spots
-// called at level load and each death
-//
+
+
+
+
+
void G_DeathMatchSpawnPlayer (int playernum)
{
int i,j;
@@ -914,30 +914,30 @@ void G_DeathMatchSpawnPlayer (int playernum)
}
}
- // no good spot, so the player will probably get stuck
+
P_SpawnPlayer (&playerstarts[playernum]);
}
-//
-// G_DoReborn
-//
+
+
+
void G_DoReborn (int playernum)
{
int i;
if (!netgame)
{
- // reload the level from scratch
+
gameaction = ga_loadlevel;
}
else
{
- // respawn at the start
+
- // first dissasociate the corpse
+
players[playernum].mo->player = NULL;
- // spawn at random spot if in death match
+
if (deathmatch)
{
G_DeathMatchSpawnPlayer (playernum);
@@ -950,17 +950,17 @@ void G_DoReborn (int playernum)
return;
}
- // try to spawn at one of the other players spots
+
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (G_CheckSpot (playernum, &playerstarts[i]) )
{
- playerstarts[i].type = playernum+1; // fake as other player
+ playerstarts[i].type = playernum+1;
P_SpawnPlayer (&playerstarts[i]);
- playerstarts[i].type = i+1; // restore
+ playerstarts[i].type = i+1;
return;
}
- // he's going to be inside something. Too bad.
+
}
P_SpawnPlayer (&playerstarts[playernum]);
}
@@ -974,7 +974,7 @@ void G_ScreenShot (void)
-// DOOM Par Times
+
int pars[4][10] =
{
{0},
@@ -983,19 +983,19 @@ int pars[4][10] =
{0,90,45,90,150,90,90,165,30,135}
};
-// DOOM II Par Times
+
int cpars[32] =
{
- 30,90,120,120,90,150,120,120,270,90, // 1-10
- 210,150,150,150,210,150,420,150,210,150, // 11-20
- 240,150,180,150,150,300,330,420,300,180, // 21-30
- 120,30 // 31-32
+ 30,90,120,120,90,150,120,120,270,90,
+ 210,150,150,150,210,150,420,150,210,150,
+ 240,150,180,150,150,300,330,420,300,180,
+ 120,30
};
-//
-// G_DoCompleted
-//
+
+
+
boolean secretexit;
extern char* pagename;
@@ -1005,10 +1005,10 @@ void G_ExitLevel (void)
gameaction = ga_completed;
}
-// Here's for the german edition.
+
void G_SecretExitLevel (void)
{
- // IF NO WOLF3D LEVELS, NO SECRET EXIT!
+
if ( (gamemode == commercial)
&& (W_CheckNumForName("map31")<0))
secretexit = false;
@@ -1025,7 +1025,7 @@ void G_DoCompleted (void)
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i])
- G_PlayerFinishLevel (i); // take away cards and stuff
+ G_PlayerFinishLevel (i);
if (automapactive)
AM_Stop ();
@@ -1042,11 +1042,11 @@ void G_DoCompleted (void)
break;
}
-//#if 0 Hmmm - why?
+
if ( (gamemap == 8)
&& (gamemode != commercial) )
{
- // victory
+
gameaction = ga_victory;
return;
}
@@ -1054,18 +1054,18 @@ void G_DoCompleted (void)
if ( (gamemap == 9)
&& (gamemode != commercial) )
{
- // exit secret level
+
for (i=0 ; i<MAXPLAYERS ; i++)
players[i].didsecret = true;
}
-//#endif
+
wminfo.didsecret = players[consoleplayer].didsecret;
wminfo.epsd = gameepisode -1;
wminfo.last = gamemap -1;
- // wminfo.next is 0 biased, unlike gamemap
+
if ( gamemode == commercial)
{
if (secretexit)
@@ -1085,10 +1085,10 @@ void G_DoCompleted (void)
else
{
if (secretexit)
- wminfo.next = 8; // go to secret level
+ wminfo.next = 8;
else if (gamemap == 9)
{
- // returning from secret level
+
switch (gameepisode)
{
case 1:
@@ -1106,7 +1106,7 @@ void G_DoCompleted (void)
}
}
else
- wminfo.next = gamemap; // go to next level
+ wminfo.next = gamemap;
}
wminfo.maxkills = totalkills;
@@ -1141,9 +1141,9 @@ void G_DoCompleted (void)
}
-//
-// G_WorldDone
-//
+
+
+
void G_WorldDone (void)
{
gameaction = ga_worlddone;
@@ -1180,10 +1180,10 @@ void G_DoWorldDone (void)
-//
-// G_InitFromSavegame
-// Can be called by the startup code or the menu task.
-//
+
+
+
+
extern boolean setsizeneeded;
void R_ExecuteSetViewSize (void);
@@ -1210,11 +1210,11 @@ void G_DoLoadGame (void)
length = M_ReadFile (savename, &savebuffer);
save_p = savebuffer + SAVESTRINGSIZE;
- // skip the description field
+
memset (vcheck,0,sizeof(vcheck));
sprintf (vcheck,"version %i",VERSION);
if (strcmp (save_p, vcheck))
- return; // bad version
+ return;
save_p += VERSIONSIZE;
gameskill = *save_p++;
@@ -1223,16 +1223,16 @@ void G_DoLoadGame (void)
for (i=0 ; i<MAXPLAYERS ; i++)
playeringame[i] = *save_p++;
- // load a base level
+
G_InitNew (gameskill, gameepisode, gamemap);
- // get the times
+
a = *save_p++;
b = *save_p++;
c = *save_p++;
leveltime = (a<<16) + (b<<8) + c;
- // dearchive all the modifications
+
P_UnArchivePlayers ();
P_UnArchiveWorld ();
P_UnArchiveThinkers ();
@@ -1241,22 +1241,22 @@ void G_DoLoadGame (void)
if (*save_p != 0x1d)
I_Error ("Bad savegame");
- // done
+
Z_Free (savebuffer);
if (setsizeneeded)
R_ExecuteSetViewSize ();
- // draw the pattern into the back screen
+
R_FillBackScreen ();
}
-//
-// G_SaveGame
-// Called by the menu task.
-// Description is a 24 byte text string
-//
+
+
+
+
+
void
G_SaveGame
( int slot,
@@ -1304,7 +1304,7 @@ void G_DoSaveGame (void)
P_ArchiveThinkers ();
P_ArchiveSpecials ();
- *save_p++ = 0x1d; // consistancy marker
+ *save_p++ = 0x1d;
length = save_p - savebuffer;
if (length > SAVEGAMESIZE)
@@ -1315,16 +1315,16 @@ void G_DoSaveGame (void)
players[consoleplayer].message = GGSAVED;
- // draw the pattern into the back screen
+
R_FillBackScreen ();
}
-//
-// G_InitNew
-// Can be called by the startup code or the menu task,
-// consoleplayer, displayplayer, playeringame[] should be set.
-//
+
+
+
+
+
skill_t d_skill;
int d_episode;
int d_map;
@@ -1357,7 +1357,7 @@ void G_DoNewGame (void)
gameaction = ga_nothing;
}
-// The sky texture to be used instead of the F_SKY1 dummy.
+
extern int skytexture;
@@ -1380,9 +1380,9 @@ G_InitNew
skill = sk_nightmare;
- // This was quite messy with SPECIAL and commented parts.
- // Supposedly hacks to make the latest edition work.
- // It might not work properly.
+
+
+
if (episode < 1)
episode = 1;
@@ -1394,7 +1394,7 @@ G_InitNew
else if ( gamemode == shareware )
{
if (episode > 1)
- episode = 1; // only start episode 1 on shareware
+ episode = 1;
}
else
{
@@ -1436,11 +1436,11 @@ G_InitNew
}
- // force players to be initialized upon first level load
+
for (i=0 ; i<MAXPLAYERS ; i++)
players[i].playerstate = PST_REBORN;
- usergame = true; // will be set false if a demo
+ usergame = true;
paused = false;
demoplayback = false;
automapactive = false;
@@ -1451,7 +1451,7 @@ G_InitNew
viewactive = true;
- // set the sky map for the episode
+
if ( gamemode == commercial)
{
skytexture = R_TextureNumForName ("SKY3");
@@ -1473,7 +1473,7 @@ G_InitNew
case 3:
skytexture = R_TextureNumForName ("SKY3");
break;
- case 4: // Special Edition sky
+ case 4:
skytexture = R_TextureNumForName ("SKY4");
break;
}
@@ -1482,9 +1482,9 @@ G_InitNew
}
-//
-// DEMO RECORDING
-//
+
+
+
#define DEMOMARKER 0x80
@@ -1492,7 +1492,7 @@ void G_ReadDemoTiccmd (ticcmd_t* cmd)
{
if (*demo_p == DEMOMARKER)
{
- // end of demo data stream
+
G_CheckDemoStatus ();
return;
}
@@ -1505,7 +1505,7 @@ void G_ReadDemoTiccmd (ticcmd_t* cmd)
void G_WriteDemoTiccmd (ticcmd_t* cmd)
{
- if (gamekeydown['q']) // press q to end demo recording
+ if (gamekeydown['q'])
G_CheckDemoStatus ();
*demo_p++ = cmd->forwardmove;
*demo_p++ = cmd->sidemove;
@@ -1514,19 +1514,19 @@ void G_WriteDemoTiccmd (ticcmd_t* cmd)
demo_p -= 4;
if (demo_p > demoend - 16)
{
- // no more space
+
G_CheckDemoStatus ();
return;
}
- G_ReadDemoTiccmd (cmd); // make SURE it is exactly the same
+ G_ReadDemoTiccmd (cmd);
}
-//
-// G_RecordDemo
-//
+
+
+
void G_RecordDemo (char* name)
{
int i;
@@ -1567,9 +1567,9 @@ void G_BeginRecording (void)
}
-//
-// G_PlayDemo
-//
+
+
+
char* defdemoname;
@@ -1610,7 +1610,7 @@ void G_DoPlayDemo (void)
netdemo = true;
}
- // don't spend a lot of time in loadlevel
+
precache = false;
G_InitNew (skill, episode, map);
precache = true;
@@ -1619,9 +1619,9 @@ void G_DoPlayDemo (void)
demoplayback = true;
}
-//
-// G_TimeDemo
-//
+
+
+
void G_TimeDemo (char* name)
{
nodrawers = M_CheckParm ("-nodraw");
diff --git a/src/g_game.h b/src/g_game.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// Duh.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __G_GAME__
@@ -28,30 +28,30 @@
-//
-// GAME
-//
+
+
+
void G_DeathMatchSpawnPlayer (int playernum);
void G_InitNew (skill_t skill, int episode, int map);
-// Can be called by the startup code or M_Responder.
-// A normal game starts at map 1,
-// but a warp test can start elsewhere
+
+
+
void G_DeferedInitNew (skill_t skill, int episode, int map);
void G_DeferedPlayDemo (char* demo);
-// Can be called by the startup code or M_Responder,
-// calls P_SetupLevel or W_EnterWorld.
+
+
void G_LoadGame (char* name);
void G_DoLoadGame (void);
-// Called by M_Responder.
+
void G_SaveGame (int slot, char* description);
-// Only called by startup code.
+
void G_RecordDemo (char* name);
void G_BeginRecording (void);
@@ -72,8 +72,8 @@ void G_ScreenShot (void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/hu_lib.c b/src/hu_lib.c
@@ -1,24 +1,24 @@
-// 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: heads-up text and input code
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: hu_lib.c,v 1.3 1997/01/26 07:44:58 b1 Exp $";
@@ -34,10 +34,10 @@ rcsid[] = "$Id: hu_lib.c,v 1.3 1997/01/26 07:44:58 b1 Exp $";
#include "r_local.h"
#include "r_draw.h"
-// boolean : whether the screen is always erased
+
#define noterased viewwindowx
-extern boolean automapactive; // in AM_map.c
+extern boolean automapactive;
void HUlib_init(void)
{
@@ -107,7 +107,7 @@ HUlib_drawTextLine
int x;
unsigned char c;
- // draw the new stuff
+
x = l->x;
for (i=0;i<l->len;i++)
{
@@ -130,7 +130,7 @@ HUlib_drawTextLine
}
}
- // draw the cursor if requested
+
if (drawcursor
&& x + SHORT(l->f['_' - l->sc]->width) <= SCREENWIDTH)
{
@@ -139,7 +139,7 @@ HUlib_drawTextLine
}
-// sorta called by HU_Erase and just better darn get things straight
+
void HUlib_eraseTextLine(hu_textline_t* l)
{
int lh;
@@ -147,9 +147,9 @@ void HUlib_eraseTextLine(hu_textline_t* l)
int yoffset;
static boolean lastautomapactive = true;
- // Only erases when NOT in automap and the screen is reduced,
- // and the text must either need updating or refreshing
- // (because of a recent change back from the automap)
+
+
+
if (!automapactive &&
viewwindowx && l->needsupdate)
@@ -158,12 +158,12 @@ void HUlib_eraseTextLine(hu_textline_t* l)
for (y=l->y,yoffset=y*SCREENWIDTH ; y<l->y+lh ; y++,yoffset+=SCREENWIDTH)
{
if (y < viewwindowy || y >= viewwindowy + viewheight)
- R_VideoErase(yoffset, SCREENWIDTH); // erase entire line
+ R_VideoErase(yoffset, SCREENWIDTH);
else
{
- R_VideoErase(yoffset, viewwindowx); // erase left border
+ R_VideoErase(yoffset, viewwindowx);
R_VideoErase(yoffset + viewwindowx + viewwidth, viewwindowx);
- // erase right border
+
}
}
}
@@ -202,12 +202,12 @@ void HUlib_addLineToSText(hu_stext_t* s)
int i;
- // add a clear line
+
if (++s->cl == s->h)
s->cl = 0;
HUlib_clearTextLine(&s->l[s->cl]);
- // everything needs updating
+
for (i=0 ; i<s->h ; i++)
s->l[i].needsupdate = 4;
@@ -234,19 +234,19 @@ void HUlib_drawSText(hu_stext_t* s)
hu_textline_t *l;
if (!*s->on)
- return; // if not on, don't draw
+ return;
- // draw everything
+
for (i=0 ; i<s->h ; i++)
{
idx = s->cl - i;
if (idx < 0)
- idx += s->h; // handle queue of lines
+ idx += s->h;
l = &s->l[idx];
- // need a decision made here on whether to skip the draw
- HUlib_drawTextLine(l, false); // no cursor, please
+
+ HUlib_drawTextLine(l, false);
}
}
@@ -275,14 +275,14 @@ HUlib_initIText
int startchar,
boolean* on )
{
- it->lm = 0; // default left margin is start of text
+ it->lm = 0;
it->on = on;
it->laston = true;
HUlib_initTextLine(&it->l, x, y, font, startchar);
}
-// The following deletion routines adhere to the left margin restriction
+
void HUlib_delCharFromIText(hu_itext_t* it)
{
if (it->l.len != it->lm)
@@ -295,7 +295,7 @@ void HUlib_eraseLineFromIText(hu_itext_t* it)
HUlib_delCharFromTextLine(&it->l);
}
-// Resets left margin as well
+
void HUlib_resetIText(hu_itext_t* it)
{
it->lm = 0;
@@ -312,8 +312,8 @@ HUlib_addPrefixToIText
it->lm = it->l.len;
}
-// wrapper function for handling general keyed input.
-// returns true if it ate the key
+
+
boolean
HUlib_keyInIText
( hu_itext_t* it,
@@ -327,9 +327,9 @@ HUlib_keyInIText
HUlib_delCharFromIText(it);
else
if (ch != KEY_ENTER)
- return false; // did not eat key
+ return false;
- return true; // ate the key
+ return true;
}
@@ -340,7 +340,7 @@ void HUlib_drawIText(hu_itext_t* it)
if (!*it->on)
return;
- HUlib_drawTextLine(l, true); // draw the line w/ cursor
+ HUlib_drawTextLine(l, true);
}
diff --git a/src/hu_lib.h b/src/hu_lib.h
@@ -1,131 +1,131 @@
-// 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.
-//
-// DESCRIPTION: none
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __HULIB__
#define __HULIB__
-// We are referring to patches.
+
#include "r_defs.h"
-// background and foreground screen numbers
-// different from other modules.
+
+
#define BG 1
#define FG 0
-// font stuff
+
#define HU_CHARERASE KEY_BACKSPACE
#define HU_MAXLINES 4
#define HU_MAXLINELENGTH 80
-//
-// Typedefs of widgets
-//
-// Text Line widget
-// (parent of Scrolling Text and Input Text widgets)
+
+
+
+
+
typedef struct
{
- // left-justified position of scrolling text window
+
int x;
int y;
- patch_t** f; // font
- int sc; // start character
- char l[HU_MAXLINELENGTH+1]; // line of text
- int len; // current line length
+ patch_t** f;
+ int sc;
+ char l[HU_MAXLINELENGTH+1];
+ int len;
- // whether this line needs to be udpated
+
int needsupdate;
} hu_textline_t;
-// Scrolling Text window widget
-// (child of Text Line widget)
+
+
typedef struct
{
- hu_textline_t l[HU_MAXLINES]; // text lines to draw
- int h; // height in lines
- int cl; // current line number
+ hu_textline_t l[HU_MAXLINES];
+ int h;
+ int cl;
- // pointer to boolean stating whether to update window
+
boolean* on;
- boolean laston; // last value of *->on.
+ boolean laston;
} hu_stext_t;
-// Input Text Line widget
-// (child of Text Line widget)
+
+
typedef struct
{
- hu_textline_t l; // text line to input on
+ hu_textline_t l;
- // left margin past which I am not to delete characters
+
int lm;
- // pointer to boolean stating whether to update window
+
boolean* on;
- boolean laston; // last value of *->on;
+ boolean laston;
} hu_itext_t;
-//
-// Widget creation, access, and update routines
-//
-// initializes heads-up widget library
+
+
+
+
void HUlib_init(void);
-//
-// textline code
-//
-// clear a line of text
+
+
+
+
void HUlib_clearTextLine(hu_textline_t *t);
void HUlib_initTextLine(hu_textline_t *t, int x, int y, patch_t **f, int sc);
-// returns success
+
boolean HUlib_addCharToTextLine(hu_textline_t *t, char ch);
-// returns success
+
boolean HUlib_delCharFromTextLine(hu_textline_t *t);
-// draws tline
+
void HUlib_drawTextLine(hu_textline_t *l, boolean drawcursor);
-// erases text line
+
void HUlib_eraseTextLine(hu_textline_t *l);
-//
-// Scrolling Text window widget routines
-//
-// ?
+
+
+
+
void
HUlib_initSText
( hu_stext_t* s,
@@ -136,23 +136,23 @@ HUlib_initSText
int startchar,
boolean* on );
-// add a new line
+
void HUlib_addLineToSText(hu_stext_t* s);
-// ?
+
void
HUlib_addMessageToSText
( hu_stext_t* s,
char* prefix,
char* msg );
-// draws stext
+
void HUlib_drawSText(hu_stext_t* s);
-// erases all stext lines
+
void HUlib_eraseSText(hu_stext_t* s);
-// Input Text Line widget routines
+
void
HUlib_initIText
( hu_itext_t* it,
@@ -162,22 +162,22 @@ HUlib_initIText
int startchar,
boolean* on );
-// enforces left margin
+
void HUlib_delCharFromIText(hu_itext_t* it);
-// enforces left margin
+
void HUlib_eraseLineFromIText(hu_itext_t* it);
-// resets line and left margin
+
void HUlib_resetIText(hu_itext_t* it);
-// left of left-margin
+
void
HUlib_addPrefixToIText
( hu_itext_t* it,
char* str );
-// whether eaten
+
boolean
HUlib_keyInIText
( hu_itext_t* it,
@@ -185,12 +185,12 @@ HUlib_keyInIText
void HUlib_drawIText(hu_itext_t* it);
-// erases all itext lines
+
void HUlib_eraseIText(hu_itext_t* it);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
@@ -1,24 +1,24 @@
-// 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: Heads-up displays
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: hu_stuff.c,v 1.4 1997/02/03 16:47:52 b1 Exp $";
@@ -39,13 +39,13 @@ rcsid[] = "$Id: hu_stuff.c,v 1.4 1997/02/03 16:47:52 b1 Exp $";
#include "doomstat.h"
-// Data.
+
#include "dstrings.h"
#include "sounds.h"
-//
-// Locally used constants, shortcuts.
-//
+
+
+
#define HU_TITLE (mapnames[(gameepisode-1)*9+gamemap-1])
#define HU_TITLE2 (mapnames2[gamemap-1])
#define HU_TITLEP (mapnamesp[gamemap-1])
@@ -85,7 +85,7 @@ char* player_names[] =
};
-char chat_char; // remove later.
+char chat_char;
static player_t* plr;
patch_t* hu_font[HU_FONTSIZE];
static hu_textline_t w_title;
@@ -107,12 +107,12 @@ extern boolean automapactive;
static boolean headsupactive = false;
-//
-// Builtin map names.
-// The actual names can be found in DStrings.h.
-//
-char* mapnames[] = // DOOM shareware/registered/retail (Ultimate) names.
+
+
+
+
+char* mapnames[] =
{
HUSTR_E1M1,
@@ -166,7 +166,7 @@ char* mapnames[] = // DOOM shareware/registered/retail (Ultimate) names.
"NEWLEVEL"
};
-char* mapnames2[] = // DOOM 2 map names.
+char* mapnames2[] =
{
HUSTR_1,
HUSTR_2,
@@ -205,7 +205,7 @@ char* mapnames2[] = // DOOM 2 map names.
};
-char* mapnamesp[] = // Plutonia WAD map names.
+char* mapnamesp[] =
{
PHUSTR_1,
PHUSTR_2,
@@ -244,7 +244,7 @@ char* mapnamesp[] = // Plutonia WAD map names.
};
-char *mapnamest[] = // TNT WAD map names.
+char *mapnamest[] =
{
THUSTR_1,
THUSTR_2,
@@ -293,34 +293,34 @@ const char french_shiftxform[] =
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ', '!', '"', '#', '$', '%', '&',
- '"', // shift-'
+ '"',
'(', ')', '*', '+',
- '?', // shift-,
- '_', // shift--
- '>', // shift-.
- '?', // shift-/
- '0', // shift-0
- '1', // shift-1
- '2', // shift-2
- '3', // shift-3
- '4', // shift-4
- '5', // shift-5
- '6', // shift-6
- '7', // shift-7
- '8', // shift-8
- '9', // shift-9
+ '?',
+ '_',
+ '>',
+ '?',
+ '0',
+ '1',
+ '2',
+ '3',
+ '4',
+ '5',
+ '6',
+ '7',
+ '8',
+ '9',
'/',
- '.', // shift-;
+ '.',
'<',
- '+', // shift-=
+ '+',
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
- '[', // shift-[
- '!', // shift-backslash - OH MY GOD DOES WATCOM SUCK
- ']', // shift-]
+ '[',
+ '!',
+ ']',
'"', '_',
- '\'', // shift-`
+ '\'',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', '|', '}', '~', 127
@@ -336,34 +336,34 @@ const char english_shiftxform[] =
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31,
' ', '!', '"', '#', '$', '%', '&',
- '"', // shift-'
+ '"',
'(', ')', '*', '+',
- '<', // shift-,
- '_', // shift--
- '>', // shift-.
- '?', // shift-/
- ')', // shift-0
- '!', // shift-1
- '@', // shift-2
- '#', // shift-3
- '$', // shift-4
- '%', // shift-5
- '^', // shift-6
- '&', // shift-7
- '*', // shift-8
- '(', // shift-9
+ '<',
+ '_',
+ '>',
+ '?',
+ ')',
+ '!',
+ '@',
+ '#',
+ '$',
+ '%',
+ '^',
+ '&',
+ '*',
+ '(',
':',
- ':', // shift-;
+ ':',
'<',
- '+', // shift-=
+ '+',
'>', '?', '@',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
- '[', // shift-[
- '!', // shift-backslash - OH MY GOD DOES WATCOM SUCK
- ']', // shift-]
+ '[',
+ '!',
+ ']',
'"', '_',
- '\'', // shift-`
+ '\'',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'{', '|', '}', '~', 127
@@ -401,7 +401,7 @@ void HU_Init(void)
else
shiftxform = english_shiftxform;
- // load the heads-up font
+
j = HU_FONTSTART;
for (i=0;i<HU_FONTSIZE;i++)
{
@@ -431,13 +431,13 @@ void HU_Start(void)
message_nottobefuckedwith = false;
chat_on = false;
- // create the message widget
+
HUlib_initSText(&w_message,
HU_MSGX, HU_MSGY, HU_MSGHEIGHT,
hu_font,
HU_FONTSTART, &message_on);
- // create the map title widget
+
HUlib_initTextLine(&w_title,
HU_TITLEX, HU_TITLEY,
hu_font,
@@ -469,13 +469,13 @@ void HU_Start(void)
while (*s)
HUlib_addCharToTextLine(&w_title, *(s++));
- // create the chat widget
+
HUlib_initIText(&w_chat,
HU_INPUTX, HU_INPUTY,
hu_font,
HU_FONTSTART, &chat_on);
- // create the inputbuffer widgets
+
for (i=0 ; i<MAXPLAYERS ; i++)
HUlib_initIText(&w_inputbuffer[i], 0, 0, 0, 0, &always_off);
@@ -508,7 +508,7 @@ void HU_Ticker(void)
int i, rc;
char c;
- // tick down message counter if message is up
+
if (message_counter && !--message_counter)
{
message_on = false;
@@ -518,7 +518,7 @@ void HU_Ticker(void)
if (showMessages || message_dontfuckwithme)
{
- // display message if necessary
+
if ((plr->message && !message_nottobefuckedwith)
|| (plr->message && message_dontfuckwithme))
{
@@ -530,9 +530,9 @@ void HU_Ticker(void)
message_dontfuckwithme = 0;
}
- } // else message_on = false;
+ }
- // check for incoming chat characters
+
if (netgame)
{
for (i=0 ; i<MAXPLAYERS; i++)
@@ -702,24 +702,24 @@ boolean HU_Responder(event_t *ev)
else
{
c = ev->data1;
- // send a macro
+
if (altdown)
{
c = c - '0';
if (c > 9)
return false;
- // fprintf(stderr, "got here\n");
+
macromessage = chat_macros[c];
- // kill last message with a '\n'
- HU_queueChatChar(KEY_ENTER); // DEBUG!!!
- // send the macro message
+ HU_queueChatChar(KEY_ENTER);
+
+
while (*macromessage)
HU_queueChatChar(*macromessage++);
HU_queueChatChar(KEY_ENTER);
- // leave chat mode and notify that it was sent
+
chat_on = false;
strcpy(lastmessage, chat_macros[c]);
plr->message = lastmessage;
@@ -734,11 +734,11 @@ boolean HU_Responder(event_t *ev)
eatkey = HUlib_keyInIText(&w_chat, c);
if (eatkey)
{
- // static unsigned char buf[20]; // DEBUG
+
HU_queueChatChar(c);
- // sprintf(buf, "KEY: %d => %d", ev->data1, c);
- // plr->message = buf;
+
+
}
if (c == KEY_ENTER)
{
diff --git a/src/hu_stuff.h b/src/hu_stuff.h
@@ -1,22 +1,22 @@
-// 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.
-//
-// DESCRIPTION: Head up display
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __HU_STUFF_H__
#define __HU_STUFF_H__
@@ -24,13 +24,13 @@
#include "d_event.h"
-//
-// Globally visible constants.
-//
-#define HU_FONTSTART '!' // the first font characters
-#define HU_FONTEND '_' // the last font characters
-// Calculate # of glyphs in font.
+
+
+#define HU_FONTSTART '!'
+#define HU_FONTEND '_'
+
+
#define HU_FONTSIZE (HU_FONTEND - HU_FONTSTART + 1)
#define HU_BROADCAST 5
@@ -38,14 +38,14 @@
#define HU_MSGREFRESH KEY_ENTER
#define HU_MSGX 0
#define HU_MSGY 0
-#define HU_MSGWIDTH 64 // in characters
-#define HU_MSGHEIGHT 1 // in lines
+#define HU_MSGWIDTH 64
+#define HU_MSGHEIGHT 1
#define HU_MSGTIMEOUT (4*TICRATE)
-//
-// HEADS UP TEXT
-//
+
+
+
void HU_Init(void);
void HU_Start(void);
@@ -59,8 +59,8 @@ void HU_Erase(void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/i_main.c b/src/i_main.c
@@ -1,25 +1,25 @@
-// 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 program, simply calls D_DoomMain high level loop.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: i_main.c,v 1.4 1997/02/03 22:45:10 b1 Exp $";
diff --git a/src/i_net.c b/src/i_net.c
@@ -1,24 +1,24 @@
-// 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:
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
@@ -51,7 +51,7 @@ rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
-// For some odd reason...
+
#define ntohl(x) \
((unsigned long int)((((unsigned long int)(x) & 0x000000ffU) << 24) | \
(((unsigned long int)(x) & 0x0000ff00U) << 8) | \
@@ -69,9 +69,9 @@ void NetSend (void);
boolean NetListen (void);
-//
-// NETWORKING
-//
+
+
+
int DOOMPORT = (IPPORT_USERRESERVED +0x1d );
@@ -84,14 +84,14 @@ void (*netget) (void);
void (*netsend) (void);
-//
-// UDPsocket
-//
+
+
+
int UDPsocket (void)
{
int s;
- // allocate a socket
+
s = socket (PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (s<0)
I_Error ("can't create socket: %s",strerror(errno));
@@ -99,9 +99,9 @@ int UDPsocket (void)
return s;
}
-//
-// BindToLocalPort
-//
+
+
+
void
BindToLocalPort
( int s,
@@ -121,15 +121,15 @@ BindToLocalPort
}
-//
-// PacketSend
-//
+
+
+
void PacketSend (void)
{
int c;
doomdata_t sw;
- // byte swap
+
sw.checksum = htonl(netbuffer->checksum);
sw.player = netbuffer->player;
sw.retransmitfrom = netbuffer->retransmitfrom;
@@ -145,19 +145,19 @@ void PacketSend (void)
sw.cmds[c].buttons = netbuffer->cmds[c].buttons;
}
- //printf ("sending %i\n",gametic);
+
c = sendto (sendsocket , &sw, doomcom->datalength
,0,(void *)&sendaddress[doomcom->remotenode]
,sizeof(sendaddress[doomcom->remotenode]));
- // if (c == -1)
- // I_Error ("SendPacket error: %s",strerror(errno));
+
+
}
-//
-// PacketGet
-//
+
+
+
void PacketGet (void)
{
int i;
@@ -173,7 +173,7 @@ void PacketGet (void)
{
if (errno != EWOULDBLOCK)
I_Error ("GetPacket: %s",strerror(errno));
- doomcom->remotenode = -1; // no packet
+ doomcom->remotenode = -1;
return;
}
@@ -184,22 +184,22 @@ void PacketGet (void)
first = 0;
}
- // find remote node number
+
for (i=0 ; i<doomcom->numnodes ; i++)
if ( fromaddress.sin_addr.s_addr == sendaddress[i].sin_addr.s_addr )
break;
if (i == doomcom->numnodes)
{
- // packet is not from one of the players (new game broadcast)
- doomcom->remotenode = -1; // no packet
+
+ doomcom->remotenode = -1;
return;
}
- doomcom->remotenode = i; // good packet from a game player
+ doomcom->remotenode = i;
doomcom->datalength = c;
- // byte swap
+
netbuffer->checksum = ntohl(sw.checksum);
netbuffer->player = sw.player;
netbuffer->retransmitfrom = sw.retransmitfrom;
@@ -222,10 +222,10 @@ void PacketGet (void)
int GetLocalAddress (void)
{
char hostname[1024];
- struct hostent* hostentry; // host information entry
+ struct hostent* hostentry;
int v;
- // get local address
+
v = gethostname (hostname, sizeof(hostname));
if (v == -1)
I_Error ("GetLocalAddress : gethostname: errno %d",errno);
@@ -238,20 +238,20 @@ int GetLocalAddress (void)
}
-//
-// I_InitNetwork
-//
+
+
+
void I_InitNetwork (void)
{
boolean trueval = true;
int i;
int p;
- struct hostent* hostentry; // host information entry
+ struct hostent* hostentry;
doomcom = malloc (sizeof (*doomcom) );
memset (doomcom, 0, sizeof(*doomcom) );
- // set up for network
+
i = M_CheckParm ("-dup");
if (i && i< myargc-1)
{
@@ -276,12 +276,12 @@ void I_InitNetwork (void)
printf ("using alternate port %i\n",DOOMPORT);
}
- // parse network game options,
- // -net <consoleplayer> <host> <host> ...
+
+
i = M_CheckParm ("-net");
if (!i)
{
- // single player game
+
netgame = false;
doomcom->id = DOOMCOM_ID;
doomcom->numplayers = doomcom->numnodes = 1;
@@ -294,10 +294,10 @@ void I_InitNetwork (void)
netget = PacketGet;
netgame = true;
- // parse player number and host list
+
doomcom->consoleplayer = myargv[i+1][0]-'1';
- doomcom->numnodes = 1; // this node for sure
+ doomcom->numnodes = 1;
i++;
while (++i < myargc && myargv[i][0] != '-')
@@ -323,7 +323,7 @@ void I_InitNetwork (void)
doomcom->id = DOOMCOM_ID;
doomcom->numplayers = doomcom->numnodes;
- // build message to receive
+
insocket = UDPsocket ();
BindToLocalPort (insocket,htons(DOOMPORT));
ioctl (insocket, FIONBIO, &trueval);
diff --git a/src/i_net.h b/src/i_net.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// System specific network interface stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __I_NET__
@@ -30,7 +30,7 @@
-// Called by D_DoomMain.
+
void I_InitNetwork (void);
@@ -38,8 +38,8 @@ void I_NetCmd (void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/i_sound.c b/src/i_sound.c
@@ -1,25 +1,25 @@
-// 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:
-// System interface for sound.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: i_unix.c,v 1.5 1997/02/03 22:45:10 b1 Exp $";
@@ -41,10 +41,10 @@ rcsid[] = "$Id: i_unix.c,v 1.5 1997/02/03 22:45:10 b1 Exp $";
#include <unistd.h>
#include <sys/ioctl.h>
-// Linux voxware output.
+
#include <linux/soundcard.h>
-// Timer stuff. Experimental.
+
#include <time.h>
#include <signal.h>
@@ -58,104 +58,104 @@ rcsid[] = "$Id: i_unix.c,v 1.5 1997/02/03 22:45:10 b1 Exp $";
#include "doomdef.h"
-// UNIX hack, to be removed.
+
#ifdef SNDSERV
-// Separate sound server process.
+
FILE* sndserver=0;
char* sndserver_filename = "./sndserver ";
#elif SNDINTR
-// Update all 30 millisecs, approx. 30fps synchronized.
-// Linux resolution is allegedly 10 millisecs,
-// scale is microseconds.
+
+
+
#define SOUND_INTERVAL 500
-// Get the interrupt. Set duration in millisecs.
+
int I_SoundSetTimer( int duration_of_tick );
void I_SoundDelTimer( void );
#else
-// None?
+
#endif
-// A quick hack to establish a protocol between
-// synchronous mix buffer updates and asynchronous
-// audio writes. Probably redundant with gametic.
+
+
+
static int flag = 0;
-// The number of internal mixing channels,
-// the samples calculated for each mixing step,
-// the size of the 16bit, 2 hardware channel (stereo)
-// mixing buffer, and the samplerate of the raw data.
-// Needed for calling the actual sound output.
+
+
+
+
+
#define SAMPLECOUNT 512
#define NUM_CHANNELS 8
-// It is 2 for 16bit, and 2 for two channels.
+
#define BUFMUL 4
#define MIXBUFFERSIZE (SAMPLECOUNT*BUFMUL)
-#define SAMPLERATE 11025 // Hz
-#define SAMPLESIZE 2 // 16bit
+#define SAMPLERATE 11025
+#define SAMPLESIZE 2
+
-// The actual lengths of all sound effects.
int lengths[NUMSFX];
-// The actual output device.
+
int audio_fd;
-// The global mixing buffer.
-// Basically, samples from all active internal channels
-// are modifed and added, and stored in the buffer
-// that is submitted to the audio device.
+
+
+
+
signed short mixbuffer[MIXBUFFERSIZE];
-// The channel step amount...
+
unsigned int channelstep[NUM_CHANNELS];
-// ... and a 0.16 bit remainder of last step.
+
unsigned int channelstepremainder[NUM_CHANNELS];
-// The channel data pointers, start and end.
+
unsigned char* channels[NUM_CHANNELS];
unsigned char* channelsend[NUM_CHANNELS];
-// Time/gametic that the channel started playing,
-// used to determine oldest, which automatically
-// has lowest priority.
-// In case number of active sounds exceeds
-// available channels.
+
+
+
+
+
int channelstart[NUM_CHANNELS];
-// The sound in channel handles,
-// determined on registration,
-// might be used to unregister/stop/modify,
-// currently unused.
+
+
+
+
int channelhandles[NUM_CHANNELS];
-// SFX id of the playing sound effect.
-// Used to catch duplicates (like chainsaw).
+
+
int channelids[NUM_CHANNELS];
-// Pitch to stepping lookup, unused.
+
int steptable[256];
-// Volume lookups.
+
int vol_lookup[128*256];
-// Hardware left and right channel volume lookup.
+
int* channelleftvol_lookup[NUM_CHANNELS];
int* channelrightvol_lookup[NUM_CHANNELS];
-//
-// Safe ioctl, convenience.
-//
+
+
+
void
myioctl
( int fd,
@@ -177,10 +177,10 @@ myioctl
-//
-// This function loads the sound data from the WAD lump,
-// for single sound.
-//
+
+
+
+
void*
getsfx
( char* sfxname,
@@ -195,20 +195,20 @@ getsfx
int sfxlump;
- // Get the sound data from the WAD, allocate lump
- // in zone memory.
+
+
sprintf(name, "ds%s", sfxname);
- // Now, there is a severe problem with the
- // sound handling, in it is not (yet/anymore)
- // gamemode aware. That means, sounds from
- // DOOM II will be requested even with DOOM
- // shareware.
- // The sound list is wired into sounds.c,
- // which sets the external variable.
- // I do not do runtime patches to that
- // variable. Instead, we will use a
- // default sound for replacement.
+
+
+
+
+
+
+
+
+
+
if ( W_CheckNumForName(name) == -1 )
sfxlump = W_GetNumForName("dspistol");
else
@@ -216,36 +216,36 @@ getsfx
size = W_LumpLength( sfxlump );
- // Debug.
- // fprintf( stderr, "." );
- //fprintf( stderr, " -loading %s (lump %d, %d bytes)\n",
- // sfxname, sfxlump, size );
- //fflush( stderr );
+
+
+
+
+
sfx = (unsigned char*)W_CacheLumpNum( sfxlump, PU_STATIC );
- // Pads the sound effect out to the mixing buffer size.
- // The original realloc would interfere with zone memory.
+
+
paddedsize = ((size-8 + (SAMPLECOUNT-1)) / SAMPLECOUNT) * SAMPLECOUNT;
- // Allocate from zone memory.
+
paddedsfx = (unsigned char*)Z_Malloc( paddedsize+8, PU_STATIC, 0 );
- // ddt: (unsigned char *) realloc(sfx, paddedsize+8);
- // This should interfere with zone memory handling,
- // which does not kick in in the soundserver.
+
+
+
- // Now copy and pad.
+
memcpy( paddedsfx, sfx, size );
for (i=size ; i<paddedsize+8 ; i++)
paddedsfx[i] = 128;
- // Remove the cached lump.
+
Z_Free( sfx );
- // Preserve padded length.
+
*len = paddedsize;
- // Return allocated padded data.
+
return (void *) (paddedsfx + 8);
}
@@ -253,13 +253,13 @@ getsfx
-//
-// This function adds a sound to the
-// list of currently active sounds,
-// which is maintained as a given number
-// (eight, usually) of internal channels.
-// Returns a handle.
-//
+
+
+
+
+
+
+
int
addsfx
( int sfxid,
@@ -279,8 +279,8 @@ addsfx
int rightvol;
int leftvol;
- // Chainsaw troubles.
- // Play these sound effects only one at a time.
+
+
if ( sfxid == sfx_sawup
|| sfxid == sfx_sawidl
|| sfxid == sfx_sawful
@@ -288,23 +288,23 @@ addsfx
|| sfxid == sfx_stnmov
|| sfxid == sfx_pistol )
{
- // Loop all channels, check.
+
for (i=0 ; i<NUM_CHANNELS ; i++)
{
- // Active, and using the same SFX?
+
if ( (channels[i])
&& (channelids[i] == sfxid) )
{
- // Reset.
+
channels[i] = 0;
- // We are sure that iff,
- // there will only be one.
+
+
break;
}
}
}
- // Loop all channels to find oldest SFX.
+
for (i=0; (i<NUM_CHANNELS) && (channels[i]); i++)
{
if (channelstart[i] < oldest)
@@ -314,68 +314,68 @@ addsfx
}
}
- // Tales from the cryptic.
- // If we found a channel, fine.
- // If not, we simply overwrite the first one, 0.
- // Probably only happens at startup.
+
+
+
+
if (i == NUM_CHANNELS)
slot = oldestnum;
else
slot = i;
- // Okay, in the less recent channel,
- // we will handle the new SFX.
- // Set pointer to raw data.
+
+
+
channels[slot] = (unsigned char *) S_sfx[sfxid].data;
- // Set pointer to end of raw data.
+
channelsend[slot] = channels[slot] + lengths[sfxid];
- // Reset current handle number, limited to 0..100.
+
if (!handlenums)
handlenums = 100;
- // Assign current handle number.
- // Preserved so sounds could be stopped (unused).
+
+
channelhandles[slot] = rc = handlenums++;
- // Set stepping???
- // Kinda getting the impression this is never used.
+
+
channelstep[slot] = step;
- // ???
+
channelstepremainder[slot] = 0;
- // Should be gametic, I presume.
+
channelstart[slot] = gametic;
- // Separation, that is, orientation/stereo.
- // range is: 1 - 256
+
+
seperation += 1;
- // Per left/right channel.
- // x^2 seperation,
- // adjust volume properly.
+
+
+
leftvol =
- volume - ((volume*seperation*seperation) >> 16); ///(256*256);
+ volume - ((volume*seperation*seperation) >> 16);
seperation = seperation - 257;
rightvol =
volume - ((volume*seperation*seperation) >> 16);
- // Sanity check, clamp volume.
+
if (rightvol < 0 || rightvol > 127)
I_Error("rightvol out of bounds");
if (leftvol < 0 || leftvol > 127)
I_Error("leftvol out of bounds");
- // Get the proper lookup table piece
- // for this volume level???
+
+
channelleftvol_lookup[slot] = &vol_lookup[leftvol*256];
channelrightvol_lookup[slot] = &vol_lookup[rightvol*256];
- // Preserve sound SFX id,
- // e.g. for avoiding duplicates of chainsaw.
+
+
channelids[slot] = sfxid;
- // You tell me.
+
return rc;
}
@@ -383,40 +383,40 @@ addsfx
-//
-// SFX API
-// Note: this was called by S_Init.
-// However, whatever they did in the
-// old DPMS based DOS version, this
-// were simply dummies in the Linux
-// version.
-// See soundserver initdata().
-//
+
+
+
+
+
+
+
+
+
void I_SetChannels()
{
- // Init internal lookups (raw data, mixing buffer, channels).
- // This function sets up internal lookups used during
- // the mixing process.
+
+
+
int i;
int j;
int* steptablemid = steptable + 128;
- // Okay, reset internal mixing channels to zero.
+
/*for (i=0; i<NUM_CHANNELS; i++)
{
channels[i] = 0;
}*/
- // This table provides step widths for pitch parameters.
- // I fail to see that this is currently used.
+
+
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
- // into signed samples.
+
+
+
for (i=0 ; i<128 ; i++)
for (j=0 ; j<256 ; j++)
vol_lookup[i*256+j] = (i*(j-128)*256)/127;
@@ -425,28 +425,28 @@ void I_SetChannels()
void I_SetSfxVolume(int volume)
{
- // Identical to DOS.
- // Basically, this should propagate
- // the menu/config file setting
- // to the state variable used in
- // the mixing.
+
+
+
+
+
snd_SfxVolume = volume;
}
-// MUSIC API - dummy. Some code from DOS version.
+
void I_SetMusicVolume(int volume)
{
- // Internal state variable.
+
snd_MusicVolume = volume;
- // Now set volume on output device.
- // Whatever( snd_MusciVolume );
+
+
}
-//
-// Retrieve the raw data lump index
-// for a given SFX name.
-//
+
+
+
+
int I_GetSfxLumpNum(sfxinfo_t* sfx)
{
char namebuf[9];
@@ -454,18 +454,18 @@ int I_GetSfxLumpNum(sfxinfo_t* sfx)
return W_GetNumForName(namebuf);
}
-//
-// Starting a sound means adding it
-// to the current list of active sounds
-// in the internal channels.
-// As the SFX info struct contains
-// e.g. a pointer to the raw data,
-// it is ignored.
-// As our sound handling does not handle
-// priority, it is ignored.
-// Pitching (that is, increased speed of playback)
-// is set, but currently not used by mixing.
-//
+
+
+
+
+
+
+
+
+
+
+
+
int
I_StartSound
( int id,
@@ -475,7 +475,7 @@ I_StartSound
int priority )
{
- // UNUSED
+
priority = 0;
#ifdef SNDSERV
@@ -484,16 +484,16 @@ I_StartSound
fprintf(sndserver, "p%2.2x%2.2x%2.2x%2.2x\n", id, pitch, vol, sep);
fflush(sndserver);
}
- // warning: control reaches end of non-void function.
+
return id;
#else
- // Debug.
- //fprintf( stderr, "starting sound %d", id );
- // Returns a handle (not used).
+
+
+
id = addsfx( id, vol, steptable[pitch], sep );
- // fprintf( stderr, "/handle is %d\n", id );
+
return id;
#endif
@@ -503,115 +503,115 @@ I_StartSound
void I_StopSound (int handle)
{
- // You need the handle returned by StartSound.
- // Would be looping all channels,
- // tracking down the handle,
- // an setting the channel to zero.
- // UNUSED.
+
+
+
+
+
handle = 0;
}
int I_SoundIsPlaying(int handle)
{
- // Ouch.
+
return gametic < handle;
}
-//
-// This function loops all active (internal) sound
-// channels, retrieves a given number of samples
-// from the raw sound data, modifies it according
-// to the current (internal) channel parameters,
-// mixes the per channel samples into the global
-// mixbuffer, clamping it to the allowed range,
-// and sets up everything for transferring the
-// contents of the mixbuffer to the (two)
-// hardware channels (left and right, that is).
-//
-// This function currently supports only 16bit.
-//
+
+
+
+
+
+
+
+
+
+
+
+
+
void I_UpdateSound( void )
{
#ifdef SNDINTR
- // Debug. Count buffer misses with interrupt.
+
static int misses = 0;
#endif
- // Mix current sound data.
- // Data, from raw sound, for right and left.
+
+
register unsigned int sample;
register int dl;
register int dr;
- // Pointers in global mixbuffer, left, right, end.
+
signed short* leftout;
signed short* rightout;
signed short* leftend;
- // Step in mixbuffer, left and right, thus two.
+
int step;
- // Mixing channel index.
+
int chan;
- // Left and right channel
- // are in global mixbuffer, alternating.
+
+
leftout = mixbuffer;
rightout = mixbuffer+1;
step = 2;
- // Determine end, for left channel only
- // (right channel is implicit).
+
+
leftend = mixbuffer + SAMPLECOUNT*step;
- // Mix sounds into the mixing buffer.
- // Loop over step*SAMPLECOUNT,
- // that is 512 values for two channels.
+
+
+
while (leftout != leftend)
{
- // Reset left/right value.
+
dl = 0;
dr = 0;
- // Love thy L2 chache - made this a loop.
- // Now more channels could be set at compile time
- // as well. Thus loop those channels.
+
+
+
for ( chan = 0; chan < NUM_CHANNELS; chan++ )
{
- // Check channel, if active.
+
if (channels[ chan ])
{
- // Get the raw data from the channel.
+
sample = *channels[ chan ];
- // Add left and right part
- // for this channel (sound)
- // to the current data.
- // Adjust volume accordingly.
+
+
+
+
dl += channelleftvol_lookup[ chan ][sample];
dr += channelrightvol_lookup[ chan ][sample];
- // Increment index ???
+
channelstepremainder[ chan ] += channelstep[ chan ];
- // MSB is next sample???
+
channels[ chan ] += channelstepremainder[ chan ] >> 16;
- // Limit to LSB???
+
channelstepremainder[ chan ] &= 65536-1;
- // Check whether we are done.
+
if (channels[ chan ] >= channelsend[ chan ])
channels[ chan ] = 0;
}
}
- // Clamp to range. Left hardware channel.
- // Has been char instead of short.
- // if (dl > 127) *leftout = 127;
- // else if (dl < -128) *leftout = -128;
- // else *leftout = dl;
+
+
+
+
+
if (dl > 0x7fff)
*leftout = 0x7fff;
@@ -620,7 +620,7 @@ void I_UpdateSound( void )
else
*leftout = dl;
- // Same for right hardware channel.
+
if (dr > 0x7fff)
*rightout = 0x7fff;
else if (dr < -0x8000)
@@ -628,13 +628,13 @@ void I_UpdateSound( void )
else
*rightout = dr;
- // Increment current pointers in mixbuffer.
+
leftout += step;
rightout += step;
}
#ifdef SNDINTR
- // Debug check.
+
if ( flag )
{
misses += flag;
@@ -647,24 +647,24 @@ void I_UpdateSound( void )
misses = 0;
}
- // Increment flag for update.
+
flag++;
#endif
}
-//
-// This would be used to write out the mixbuffer
-// during each game loop update.
-// Updates sound buffer and audio device at runtime.
-// It is called during Timer interrupt with SNDINTR.
-// Mixing now done synchronous, and
-// only output be done asynchronous?
-//
+
+
+
+
+
+
+
+
void
I_SubmitSound(void)
{
- // Write it to DSP device.
+
write(audio_fd, mixbuffer, SAMPLECOUNT*BUFMUL);
}
@@ -677,12 +677,12 @@ I_UpdateSoundParams
int sep,
int pitch)
{
- // I fail too see that this is used.
- // Would be using the handle to identify
- // on which channel the sound might be active,
- // and resetting the channel parameters.
+
+
+
+
- // UNUSED.
+
handle = vol = sep = pitch = 0;
}
@@ -694,17 +694,17 @@ void I_ShutdownSound(void)
#ifdef SNDSERV
if (sndserver)
{
- // Send a "quit" command.
+
fprintf(sndserver, "q\n");
fflush(sndserver);
}
#else
- // Wait till all pending sounds are finished.
+
int done = 0;
int i;
- // FIXME (below).
+
fprintf( stderr, "I_ShutdownSound: NOT finishing pending sounds\n");
fflush( stderr );
@@ -712,19 +712,19 @@ void I_ShutdownSound(void)
{
for( i=0 ; i<8 && !channels[i] ; i++);
- // FIXME. No proper channel output.
- //if (i==8)
+
+
done=1;
}
#ifdef SNDINTR
I_SoundDelTimer();
#endif
- // Cleaning up -releasing the DSP device.
+
close ( audio_fd );
#endif
- // Done.
+
return;
}
@@ -746,7 +746,7 @@ I_InitSound()
else
sprintf(buffer, "%s", sndserver_filename);
- // start sound process
+
if ( !access(buffer, X_OK) )
{
strcat(buffer, " -quiet");
@@ -763,7 +763,7 @@ I_InitSound()
I_SoundSetTimer( SOUND_INTERVAL );
#endif
- // Secure and configure sound device first.
+
fprintf( stderr, "I_InitSound: ");
audio_fd = open("/dev/dsp", O_WRONLY);
@@ -792,20 +792,20 @@ I_InitSound()
fprintf(stderr, " configured audio device\n" );
- // Initialize external data (all sounds) at start, keep static.
+
fprintf( stderr, "I_InitSound: ");
for (i=1 ; i<NUMSFX ; i++)
{
- // Alias? Example is the chaingun sound linked to pistol.
+
if (!S_sfx[i].link)
{
- // Load data from WAD file.
+
S_sfx[i].data = getsfx( S_sfx[i].name, &lengths[i] );
}
else
{
- // Previously loaded already?
+
S_sfx[i].data = S_sfx[i].link->data;
lengths[i] = lengths[(S_sfx[i].link - S_sfx)/sizeof(sfxinfo_t)];
}
@@ -813,11 +813,11 @@ I_InitSound()
fprintf( stderr, " pre-cached all sound data\n");
- // Now initialize mixbuffer with zero.
+
for ( i = 0; i< MIXBUFFERSIZE; i++ )
mixbuffer[i] = 0;
- // Finished initialization.
+
fprintf(stderr, "I_InitSound: sound module ready\n");
#endif
@@ -826,11 +826,11 @@ I_InitSound()
-//
-// MUSIC API.
-// Still no music done.
-// Remains. Dummies.
-//
+
+
+
+
+
void I_InitMusic(void) { }
void I_ShutdownMusic(void) { }
@@ -839,26 +839,26 @@ static int musicdies=-1;
void I_PlaySong(int handle, int looping)
{
- // UNUSED.
+
handle = looping = 0;
musicdies = gametic + TICRATE*30;
}
void I_PauseSong (int handle)
{
- // UNUSED.
+
handle = 0;
}
void I_ResumeSong (int handle)
{
- // UNUSED.
+
handle = 0;
}
void I_StopSong(int handle)
{
- // UNUSED.
+
handle = 0;
looping = 0;
@@ -867,36 +867,36 @@ void I_StopSong(int handle)
void I_UnRegisterSong(int handle)
{
- // UNUSED.
+
handle = 0;
}
int I_RegisterSong(void* data)
{
- // UNUSED.
+
data = NULL;
return 1;
}
-// Is the song playing?
+
int I_QrySongPlaying(int handle)
{
- // UNUSED.
+
handle = 0;
return looping || musicdies > gametic;
}
-//
-// Experimental stuff.
-// A Linux timer interrupt, for asynchronous
-// sound output.
-// I ripped this out of the Timer class in
-// our Difference Engine, including a few
-// SUN remains...
-//
+
+
+
+
+
+
+
+
#ifdef sun
typedef sigset_t tSigSet;
#else
@@ -904,42 +904,42 @@ int I_QrySongPlaying(int handle)
#endif
-// We might use SIGVTALRM and ITIMER_VIRTUAL, if the process
-// time independend timer happens to get lost due to heavy load.
-// SIGALRM and ITIMER_REAL doesn't really work well.
-// There are issues with profiling as well.
+
+
+
+
static int /*__itimer_which*/ itimer = ITIMER_REAL;
static int sig = SIGALRM;
-// Interrupt handler.
+
void I_HandleSoundTimer( int ignore )
{
- // Debug.
- //fprintf( stderr, "%c", '+' ); fflush( stderr );
- // Feed sound device if necesary.
+
+
+
if ( flag )
{
- // See I_SubmitSound().
- // Write it to DSP device.
+
+
write(audio_fd, mixbuffer, SAMPLECOUNT*BUFMUL);
- // Reset flag counter.
+
flag = 0;
}
else
return;
- // UNUSED, but required.
+
ignore = 0;
return;
}
-// Get the interrupt. Set duration in millisecs.
+
int I_SoundSetTimer( int duration_of_tick )
{
- // Needed for gametick clockwork.
+
struct itimerval value;
struct itimerval ovalue;
struct sigaction act;
@@ -947,13 +947,13 @@ int I_SoundSetTimer( int duration_of_tick )
int res;
- // This sets to SA_ONESHOT and SA_NOMASK, thus we can not use it.
- // signal( _sig, handle_SIG_TICK );
- // Now we have to change this attribute for repeated calls.
+
+
+
act.sa_handler = I_HandleSoundTimer;
#ifndef sun
- //ac t.sa_mask = _sig;
+
#endif
act.sa_flags = SA_RESTART;
@@ -964,10 +964,10 @@ int I_SoundSetTimer( int duration_of_tick )
value.it_value.tv_sec = 0;
value.it_value.tv_usec = duration_of_tick;
- // Error is -1.
+
res = setitimer( itimer, &value, &ovalue );
- // Debug.
+
if ( res == -1 )
fprintf( stderr, "I_SoundSetTimer: interrupt n.a.\n");
@@ -975,10 +975,10 @@ int I_SoundSetTimer( int duration_of_tick )
}
-// Remove the interrupt. Set duration to zero.
+
void I_SoundDelTimer()
{
- // Debug.
+
if ( I_SoundSetTimer( 0 ) == -1)
fprintf( stderr, "I_SoundDelTimer: failed to remove interrupt. Doh!\n");
}
diff --git a/src/i_sound.h b/src/i_sound.h
@@ -1,31 +1,31 @@
-// 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.
-//
-//
-// DESCRIPTION:
-// System interface, sound.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __I_SOUND__
#define __I_SOUND__
#include "doomdef.h"
-// UNIX hack, to be removed.
+
#ifdef SNDSERV
#include <stdio.h>
extern FILE* sndserver;
@@ -37,29 +37,29 @@ extern char* sndserver_filename;
-// Init at program start...
+
void I_InitSound();
-// ... update sound buffer and audio device at runtime...
+
void I_UpdateSound(void);
void I_SubmitSound(void);
-// ... shut down and relase at program termination.
+
void I_ShutdownSound(void);
-//
-// SFX I/O
-//
-// Initialize channels?
+
+
+
+
void I_SetChannels();
-// Get raw data lump index for sound descriptor.
+
int I_GetSfxLumpNum (sfxinfo_t* sfxinfo );
-// Starts a sound in a particular sound channel.
+
int
I_StartSound
( int id,
@@ -69,16 +69,16 @@ I_StartSound
int priority );
-// Stops a sound channel.
+
void I_StopSound(int handle);
-// Called by S_*() functions
-// to see if a channel is still playing.
-// Returns 0 if no longer playing, 1 if playing.
+
+
+
int I_SoundIsPlaying(int handle);
-// Updates the volume, separation,
-// and pitch of a sound channel.
+
+
void
I_UpdateSoundParams
( int handle,
@@ -87,36 +87,36 @@ I_UpdateSoundParams
int pitch );
-//
-// MUSIC I/O
-//
+
+
+
void I_InitMusic(void);
void I_ShutdownMusic(void);
-// Volume.
+
void I_SetMusicVolume(int volume);
-// PAUSE game handling.
+
void I_PauseSong(int handle);
void I_ResumeSong(int handle);
-// Registers a song handle to song data.
+
int I_RegisterSong(void *data);
-// Called by anything that wishes to start music.
-// plays a song, and when the song is done,
-// starts playing it again in an endless loop.
-// Horrible thing to do, considering.
+
+
+
+
void
I_PlaySong
( int handle,
int looping );
-// Stops a song over 3 seconds.
+
void I_StopSong(int handle);
-// See above (register), then think backwards
+
void I_UnRegisterSong(int handle);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/i_system.c b/src/i_system.c
@@ -1,24 +1,24 @@
-// 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:
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: m_bbox.c,v 1.1 1997/02/03 22:45:10 b1 Exp $";
@@ -57,7 +57,7 @@ I_Tactile
int off,
int total )
{
- // UNUSED.
+
on = off = total = 0;
}
@@ -81,10 +81,10 @@ byte* I_ZoneBase (int* size)
-//
-// I_GetTime
-// returns time in 1/70th second tics
-//
+
+
+
+
int I_GetTime (void)
{
struct timeval tp;
@@ -101,18 +101,18 @@ int I_GetTime (void)
-//
-// I_Init
-//
+
+
+
void I_Init (void)
{
I_InitSound();
- // I_InitGraphics();
+
}
-//
-// I_Quit
-//
+
+
+
void I_Quit (void)
{
D_QuitNetGame ();
@@ -154,16 +154,16 @@ byte* I_AllocLow(int length)
}
-//
-// I_Error
-//
+
+
+
extern boolean demorecording;
void I_Error (char *error, ...)
{
va_list argptr;
- // Message first.
+
va_start (argptr,error);
fprintf (stderr, "Error: ");
vfprintf (stderr,error,argptr);
@@ -172,7 +172,7 @@ void I_Error (char *error, ...)
fflush( stderr );
- // Shutdown. Here might be other errors.
+
if (demorecording)
G_CheckDemoStatus();
diff --git a/src/i_system.h b/src/i_system.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// System specific interface stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __I_SYSTEM__
@@ -31,56 +31,56 @@
#endif
-// Called by DoomMain.
+
void I_Init (void);
-// Called by startup code
-// to get the ammount of memory to malloc
-// for the zone management.
+
+
+
byte* I_ZoneBase (int *size);
-// Called by D_DoomLoop,
-// returns current time in tics.
+
+
int I_GetTime (void);
-//
-// Called by D_DoomLoop,
-// called before processing any tics in a frame
-// (just after displaying a frame).
-// Time consuming syncronous operations
-// are performed here (joystick reading).
-// Can call D_PostEvent.
-//
+
+
+
+
+
+
+
+
void I_StartFrame (void);
-//
-// Called by D_DoomLoop,
-// called before processing each tic in a frame.
-// Quick syncronous operations are performed here.
-// Can call D_PostEvent.
+
+
+
+
+
void I_StartTic (void);
-// Asynchronous interrupt functions should maintain private queues
-// that are read by the synchronous functions
-// to be converted into events.
-// Either returns a null ticcmd,
-// or calls a loadable driver to build it.
-// This ticcmd will then be modified by the gameloop
-// for normal input.
+
+
+
+
+
+
+
ticcmd_t* I_BaseTiccmd (void);
-// Called by M_Responder when quit is selected.
-// Clean exit, displays sell blurb.
+
+
void I_Quit (void);
-// Allocates from low memory under dos,
-// just mallocs under unix
+
+
byte* I_AllocLow (int length);
void I_Tactile (int on, int off, int total);
@@ -90,8 +90,8 @@ void I_Error (char *error, ...);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/i_video.c b/src/i_video.c
@@ -1,25 +1,25 @@
-// 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 graphics stuff for X11, UNIX.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: i_x.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";
@@ -34,10 +34,10 @@ rcsid[] = "$Id: i_x.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";
#include <X11/keysym.h>
#include <X11/extensions/XShm.h>
-// Had to dig up XShm.c for this one.
-// It is in the libXext, but not in the XFree86 headers.
+
+
#ifdef LINUX
-int XShmGetEventBase( Display* dpy ); // problems with g++?
+int XShmGetEventBase( Display* dpy );
#endif
#include <stdarg.h>
@@ -71,28 +71,28 @@ XImage* image;
int X_width;
int X_height;
-// MIT SHared Memory extension.
+
boolean doShm;
XShmSegmentInfo X_shminfo;
int X_shmeventtype;
-// Fake mouse handling.
-// This cannot work properly w/o DGA.
-// Needs an invisible mouse cursor at least.
+
+
+
boolean grabMouse;
int doPointerWarp = POINTER_WARP_COUNTDOWN;
-// Blocky mode,
-// replace each 320x200 pixel with multiply*multiply pixels.
-// According to Dave Taylor, it still is a bonehead thing
-// to use ....
+
+
+
+
static int multiply=1;
-//
-// Translates the key currently in X_event
-//
+
+
+
int xlatekey(void)
{
@@ -163,26 +163,26 @@ int xlatekey(void)
void I_ShutdownGraphics(void)
{
- // Detach from X server
+
if (!XShmDetach(X_display, &X_shminfo))
I_Error("XShmDetach() failed in I_ShutdownGraphics()");
- // Release shared memory.
+
shmdt(X_shminfo.shmaddr);
shmctl(X_shminfo.shmid, IPC_RMID, 0);
- // Paranoia.
+
image->data = NULL;
}
-//
-// I_StartFrame
-//
+
+
+
void I_StartFrame (void)
{
- // er?
+
}
@@ -196,7 +196,7 @@ void I_GetEvent(void)
event_t event;
- // put event-grabbing stuff in here
+
XNextEvent(X_display, &X_event);
switch (X_event.type)
{
@@ -204,13 +204,13 @@ void I_GetEvent(void)
event.type = ev_keydown;
event.data1 = xlatekey();
D_PostEvent(&event);
- // fprintf(stderr, "k");
+
break;
case KeyRelease:
event.type = ev_keyup;
event.data1 = xlatekey();
D_PostEvent(&event);
- // fprintf(stderr, "ku");
+
break;
case ButtonPress:
event.type = ev_mouse;
@@ -223,7 +223,7 @@ void I_GetEvent(void)
| (X_event.xbutton.button == Button3 ? 4 : 0);
event.data2 = event.data3 = 0;
D_PostEvent(&event);
- // fprintf(stderr, "b");
+
break;
case ButtonRelease:
event.type = ev_mouse;
@@ -231,7 +231,7 @@ void I_GetEvent(void)
(X_event.xbutton.state & Button1Mask)
| (X_event.xbutton.state & Button2Mask ? 2 : 0)
| (X_event.xbutton.state & Button3Mask ? 4 : 0);
- // suggest parentheses around arithmetic in operand of |
+
event.data1 =
event.data1
^ (X_event.xbutton.button == Button1 ? 1 : 0)
@@ -239,7 +239,7 @@ void I_GetEvent(void)
^ (X_event.xbutton.button == Button3 ? 4 : 0);
event.data2 = event.data3 = 0;
D_PostEvent(&event);
- // fprintf(stderr, "bu");
+
break;
case MotionNotify:
event.type = ev_mouse;
@@ -258,7 +258,7 @@ void I_GetEvent(void)
X_event.xmotion.y != X_height/2)
{
D_PostEvent(&event);
- // fprintf(stderr, "m");
+
mousemoved = false;
} else
{
@@ -303,9 +303,9 @@ createnullcursor
return cursor;
}
-//
-// I_StartTic
-//
+
+
+
void I_StartTic (void)
{
@@ -315,9 +315,9 @@ void I_StartTic (void)
while (XPending(X_display))
I_GetEvent();
- // Warp the pointer back to the middle of the window
- // or it will wander off - that is, the game will
- // loose input focus within X11.
+
+
+
if (grabMouse)
{
if (!--doPointerWarp)
@@ -338,26 +338,26 @@ void I_StartTic (void)
}
-//
-// I_UpdateNoBlit
-//
+
+
+
void I_UpdateNoBlit (void)
{
- // what is this?
+
}
-//
-// I_FinishUpdate
-//
+
+
+
void I_FinishUpdate (void)
{
static int lasttic;
int tics;
int i;
- // UNUSED static unsigned char *bigscreen=0;
+
- // draws little dots on the bottom of the screen
+
if (devparm)
{
@@ -373,7 +373,7 @@ void I_FinishUpdate (void)
}
- // scales the screen size before blitting it
+
if (multiply == 2)
{
unsigned int *olineptrs[2];
@@ -475,7 +475,7 @@ void I_FinishUpdate (void)
}
else if (multiply == 4)
{
- // Broken. Gotta fix this some day.
+
void Expand4(unsigned *, double *);
Expand4 ((unsigned *)(screens[0]), (double *) (image->data));
}
@@ -493,7 +493,7 @@ void I_FinishUpdate (void)
True ))
I_Error("XShmPutImage() failed\n");
- // wait for it to finish and processes all input events
+
shmFinished = false;
do
{
@@ -504,7 +504,7 @@ void I_FinishUpdate (void)
else
{
- // draw the image
+
XPutImage( X_display,
X_mainWindow,
X_gc,
@@ -513,7 +513,7 @@ void I_FinishUpdate (void)
0, 0,
X_width, X_height );
- // sync up with server
+
XSync(X_display, False);
}
@@ -521,18 +521,18 @@ void I_FinishUpdate (void)
}
-//
-// I_ReadScreen
-//
+
+
+
void I_ReadScreen (byte* scr)
{
memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
}
-//
-// Palette stuff.
-//
+
+
+
static XColor colors[256];
void UploadNewPalette(Colormap cmap, byte *palette)
@@ -548,7 +548,7 @@ void UploadNewPalette(Colormap cmap, byte *palette)
if (X_visualinfo.class == PseudoColor && X_visualinfo.depth == 8)
#endif
{
- // initialize the colormap
+
if (firstcall)
{
firstcall = false;
@@ -559,7 +559,7 @@ void UploadNewPalette(Colormap cmap, byte *palette)
}
}
- // set the X colormap entries
+
for (i=0 ; i<256 ; i++)
{
c = gammatable[usegamma][*palette++];
@@ -570,28 +570,28 @@ void UploadNewPalette(Colormap cmap, byte *palette)
colors[i].blue = (c<<8) + c;
}
- // store the colors to the current colormap
+
XStoreColors(X_display, cmap, colors, 256);
}
}
-//
-// I_SetPalette
-//
+
+
+
void I_SetPalette (byte* palette)
{
UploadNewPalette(X_cmap, palette);
}
-//
-// This function is probably redundant,
-// if XShmDetach works properly.
-// ddt never detached the XShm memory,
-// thus there might have been stale
-// handles accumulating.
-//
+
+
+
+
+
+
+
void grabsharedmemory(int size)
{
@@ -600,16 +600,16 @@ void grabsharedmemory(int size)
int minsize = 320*200;
int id;
int rc;
- // UNUSED int done=0;
+
int pollution=5;
- // try to use what was here before
+
do
{
- id = shmget((key_t) key, minsize, 0777); // just get the id
+ id = shmget((key_t) key, minsize, 0777);
if (id != -1)
{
- rc=shmctl(id, IPC_STAT, &shminfo); // get stats on it
+ rc=shmctl(id, IPC_STAT, &shminfo);
if (!rc)
{
if (shminfo.shm_nattch)
@@ -682,7 +682,7 @@ void grabsharedmemory(int size)
X_shminfo.shmid = id;
- // attach to the shared memory segment
+
image->data = X_shminfo.shmaddr = shmat(id, 0, 0);
fprintf(stderr, "shared memory id=%d, addr=0x%x\n", id,
@@ -699,7 +699,7 @@ void I_InitGraphics(void)
int x=0;
int y=0;
- // warning: char format, different type arg
+
char xsign=' ';
char ysign=' ';
@@ -728,19 +728,19 @@ void I_InitGraphics(void)
X_width = SCREENWIDTH * multiply;
X_height = SCREENHEIGHT * multiply;
- // check for command-line display name
- if ( (pnum=M_CheckParm("-disp")) ) // suggest parentheses around assignment
+
+ if ( (pnum=M_CheckParm("-disp")) )
displayname = myargv[pnum+1];
else
displayname = 0;
- // check if the user wants to grab the mouse (quite unnice)
+
grabMouse = !!M_CheckParm("-grabmouse");
- // check for command-line geometry
- if ( (pnum=M_CheckParm("-geom")) ) // suggest parentheses around assignment
+
+ if ( (pnum=M_CheckParm("-geom")) )
{
- // warning: char format, different type arg 3,5
+
n = sscanf(myargv[pnum+1], "%c%d%c%d", &xsign, &x, &ysign, &y);
if (n==2)
@@ -756,7 +756,7 @@ void I_InitGraphics(void)
I_Error("bad -geom parameter");
}
- // open the display
+
X_display = XOpenDisplay(displayname);
if (!X_display)
{
@@ -766,16 +766,16 @@ void I_InitGraphics(void)
I_Error("Could not open display (DISPLAY=[%s])", getenv("DISPLAY"));
}
- // use the default visual
+
X_screen = DefaultScreen(X_display);
if (!XMatchVisualInfo(X_display, X_screen, 8, PseudoColor, &X_visualinfo))
I_Error("xdoom currently only supports 256-color PseudoColor screens");
X_visual = X_visualinfo.visual;
- // check for the MITSHM extension
+
doShm = XShmQueryExtension(X_display);
- // even if it's available, make sure it's a local connection
+
if (doShm)
{
if (!displayname) displayname = (char *) getenv("DISPLAY");
@@ -790,28 +790,28 @@ void I_InitGraphics(void)
fprintf(stderr, "Using MITSHM extension\n");
- // create the colormap
+
X_cmap = XCreateColormap(X_display, RootWindow(X_display,
X_screen), X_visual, AllocAll);
- // setup attributes for main window
+
attribmask = CWEventMask | CWColormap | CWBorderPixel;
attribs.event_mask =
KeyPressMask
| KeyReleaseMask
- // | PointerMotionMask | ButtonPressMask | ButtonReleaseMask
+
| ExposureMask;
attribs.colormap = X_cmap;
attribs.border_pixel = 0;
- // create the main window
+
X_mainWindow = XCreateWindow( X_display,
RootWindow(X_display, X_screen),
x, y,
X_width, X_height,
- 0, // borderwidth
- 8, // depth
+ 0,
+ 8,
InputOutput,
X_visual,
attribmask,
@@ -820,7 +820,7 @@ void I_InitGraphics(void)
XDefineCursor(X_display, X_mainWindow,
createnullcursor( X_display, X_mainWindow ) );
- // create the GC
+
valuemask = GCGraphicsExposures;
xgcvalues.graphics_exposures = False;
X_gc = XCreateGC( X_display,
@@ -828,10 +828,10 @@ void I_InitGraphics(void)
valuemask,
&xgcvalues );
- // map the window
+
XMapWindow(X_display, X_mainWindow);
- // wait until it is OK to draw
+
oktodraw = 0;
while (!oktodraw)
{
@@ -843,7 +843,7 @@ void I_InitGraphics(void)
}
}
- // grabs the pointer so it is restricted to this window
+
if (grabMouse)
XGrabPointer(X_display, X_mainWindow, True,
ButtonPressMask|ButtonReleaseMask|PointerMotionMask,
@@ -855,7 +855,7 @@ void I_InitGraphics(void)
X_shmeventtype = XShmGetEventBase(X_display) + ShmCompletion;
- // create the image
+
image = XShmCreateImage( X_display,
X_visual,
8,
@@ -868,18 +868,18 @@ void I_InitGraphics(void)
grabsharedmemory(image->bytes_per_line * image->height);
- // UNUSED
- // create the shared memory segment
- // X_shminfo.shmid = shmget (IPC_PRIVATE,
- // image->bytes_per_line * image->height, IPC_CREAT | 0777);
- // if (X_shminfo.shmid < 0)
- // {
- // perror("");
- // I_Error("shmget() failed in InitGraphics()");
- // }
- // fprintf(stderr, "shared memory id=%d\n", X_shminfo.shmid);
- // attach to the shared memory segment
- // image->data = X_shminfo.shmaddr = shmat(X_shminfo.shmid, 0, 0);
+
+
+
+
+
+
+
+
+
+
+
+
if (!image->data)
@@ -888,7 +888,7 @@ void I_InitGraphics(void)
I_Error("shmat() failed in InitGraphics()");
}
- // get the X server to attach to it
+
if (!XShmAttach(X_display, &X_shminfo))
I_Error("XShmAttach() failed in InitGraphics()");
@@ -931,7 +931,7 @@ void InitExpand2 (void)
{
int i;
int j;
- // UNUSED unsigned iexp, jexp;
+
double* exp;
union
{
diff --git a/src/i_video.h b/src/i_video.h
@@ -1,23 +1,23 @@
-// 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.
-//
-// DESCRIPTION:
-// System specific interface stuff.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#ifndef __I_VIDEO__
@@ -31,21 +31,21 @@
#endif
-// Called by D_DoomMain,
-// determines the hardware configuration
-// and sets up the video mode
+
+
+
void I_InitGraphics (void);
void I_ShutdownGraphics(void);
-// Takes full 8 bit values.
+
void I_SetPalette (byte* palette);
void I_UpdateNoBlit (void);
void I_FinishUpdate (void);
-// Wait for vertical retrace or pause a bit.
+
void I_WaitVBL(int count);
void I_ReadScreen (byte* scr);
@@ -56,8 +56,8 @@ void I_EndRead (void);
#endif
-//-----------------------------------------------------------------------------
-//
-// $Log:$
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
diff --git a/src/info.c b/src/info.c
@@ -1,32 +1,32 @@
-// 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:
-// Thing frame/state LUT,
-// generated by multigen utilitiy.
-// This one is the original DOOM version, preserved.
-//
-//-----------------------------------------------------------------------------
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
static const char
rcsid[] = "$Id: info.c,v 1.3 1997/01/26 07:45:00 b1 Exp $";
-// Data.
+
#include "sounds.h"
#include "m_fixed.h"
@@ -55,7 +55,7 @@ char *sprnames[NUMSPRITES] = {
};
-// Doesn't work with g++, needs actionf_p1
+
void A_Light0();
void A_WeaponReady();
void A_Lower();
@@ -133,4538 +133,4538 @@ void A_BrainExplode();
state_t states[NUMSTATES] = {
- {SPR_TROO,0,-1,{NULL},S_NULL,0,0}, // S_NULL
- {SPR_SHTG,4,0,{A_Light0},S_NULL,0,0}, // S_LIGHTDONE
- {SPR_PUNG,0,1,{A_WeaponReady},S_PUNCH,0,0}, // S_PUNCH
- {SPR_PUNG,0,1,{A_Lower},S_PUNCHDOWN,0,0}, // S_PUNCHDOWN
- {SPR_PUNG,0,1,{A_Raise},S_PUNCHUP,0,0}, // S_PUNCHUP
- {SPR_PUNG,1,4,{NULL},S_PUNCH2,0,0}, // S_PUNCH1
- {SPR_PUNG,2,4,{A_Punch},S_PUNCH3,0,0}, // S_PUNCH2
- {SPR_PUNG,3,5,{NULL},S_PUNCH4,0,0}, // S_PUNCH3
- {SPR_PUNG,2,4,{NULL},S_PUNCH5,0,0}, // S_PUNCH4
- {SPR_PUNG,1,5,{A_ReFire},S_PUNCH,0,0}, // S_PUNCH5
- {SPR_PISG,0,1,{A_WeaponReady},S_PISTOL,0,0},// S_PISTOL
- {SPR_PISG,0,1,{A_Lower},S_PISTOLDOWN,0,0}, // S_PISTOLDOWN
- {SPR_PISG,0,1,{A_Raise},S_PISTOLUP,0,0}, // S_PISTOLUP
- {SPR_PISG,0,4,{NULL},S_PISTOL2,0,0}, // S_PISTOL1
- {SPR_PISG,1,6,{A_FirePistol},S_PISTOL3,0,0},// S_PISTOL2
- {SPR_PISG,2,4,{NULL},S_PISTOL4,0,0}, // S_PISTOL3
- {SPR_PISG,1,5,{A_ReFire},S_PISTOL,0,0}, // S_PISTOL4
- {SPR_PISF,32768,7,{A_Light1},S_LIGHTDONE,0,0}, // S_PISTOLFLASH
- {SPR_SHTG,0,1,{A_WeaponReady},S_SGUN,0,0}, // S_SGUN
- {SPR_SHTG,0,1,{A_Lower},S_SGUNDOWN,0,0}, // S_SGUNDOWN
- {SPR_SHTG,0,1,{A_Raise},S_SGUNUP,0,0}, // S_SGUNUP
- {SPR_SHTG,0,3,{NULL},S_SGUN2,0,0}, // S_SGUN1
- {SPR_SHTG,0,7,{A_FireShotgun},S_SGUN3,0,0}, // S_SGUN2
- {SPR_SHTG,1,5,{NULL},S_SGUN4,0,0}, // S_SGUN3
- {SPR_SHTG,2,5,{NULL},S_SGUN5,0,0}, // S_SGUN4
- {SPR_SHTG,3,4,{NULL},S_SGUN6,0,0}, // S_SGUN5
- {SPR_SHTG,2,5,{NULL},S_SGUN7,0,0}, // S_SGUN6
- {SPR_SHTG,1,5,{NULL},S_SGUN8,0,0}, // S_SGUN7
- {SPR_SHTG,0,3,{NULL},S_SGUN9,0,0}, // S_SGUN8
- {SPR_SHTG,0,7,{A_ReFire},S_SGUN,0,0}, // S_SGUN9
- {SPR_SHTF,32768,4,{A_Light1},S_SGUNFLASH2,0,0}, // S_SGUNFLASH1
- {SPR_SHTF,32769,3,{A_Light2},S_LIGHTDONE,0,0}, // S_SGUNFLASH2
- {SPR_SHT2,0,1,{A_WeaponReady},S_DSGUN,0,0}, // S_DSGUN
- {SPR_SHT2,0,1,{A_Lower},S_DSGUNDOWN,0,0}, // S_DSGUNDOWN
- {SPR_SHT2,0,1,{A_Raise},S_DSGUNUP,0,0}, // S_DSGUNUP
- {SPR_SHT2,0,3,{NULL},S_DSGUN2,0,0}, // S_DSGUN1
- {SPR_SHT2,0,7,{A_FireShotgun2},S_DSGUN3,0,0}, // S_DSGUN2
- {SPR_SHT2,1,7,{NULL},S_DSGUN4,0,0}, // S_DSGUN3
- {SPR_SHT2,2,7,{A_CheckReload},S_DSGUN5,0,0}, // S_DSGUN4
- {SPR_SHT2,3,7,{A_OpenShotgun2},S_DSGUN6,0,0}, // S_DSGUN5
- {SPR_SHT2,4,7,{NULL},S_DSGUN7,0,0}, // S_DSGUN6
- {SPR_SHT2,5,7,{A_LoadShotgun2},S_DSGUN8,0,0}, // S_DSGUN7
- {SPR_SHT2,6,6,{NULL},S_DSGUN9,0,0}, // S_DSGUN8
- {SPR_SHT2,7,6,{A_CloseShotgun2},S_DSGUN10,0,0}, // S_DSGUN9
- {SPR_SHT2,0,5,{A_ReFire},S_DSGUN,0,0}, // S_DSGUN10
- {SPR_SHT2,1,7,{NULL},S_DSNR2,0,0}, // S_DSNR1
- {SPR_SHT2,0,3,{NULL},S_DSGUNDOWN,0,0}, // S_DSNR2
- {SPR_SHT2,32776,5,{A_Light1},S_DSGUNFLASH2,0,0}, // S_DSGUNFLASH1
- {SPR_SHT2,32777,4,{A_Light2},S_LIGHTDONE,0,0}, // S_DSGUNFLASH2
- {SPR_CHGG,0,1,{A_WeaponReady},S_CHAIN,0,0}, // S_CHAIN
- {SPR_CHGG,0,1,{A_Lower},S_CHAINDOWN,0,0}, // S_CHAINDOWN
- {SPR_CHGG,0,1,{A_Raise},S_CHAINUP,0,0}, // S_CHAINUP
- {SPR_CHGG,0,4,{A_FireCGun},S_CHAIN2,0,0}, // S_CHAIN1
- {SPR_CHGG,1,4,{A_FireCGun},S_CHAIN3,0,0}, // S_CHAIN2
- {SPR_CHGG,1,0,{A_ReFire},S_CHAIN,0,0}, // S_CHAIN3
- {SPR_CHGF,32768,5,{A_Light1},S_LIGHTDONE,0,0}, // S_CHAINFLASH1
- {SPR_CHGF,32769,5,{A_Light2},S_LIGHTDONE,0,0}, // S_CHAINFLASH2
- {SPR_MISG,0,1,{A_WeaponReady},S_MISSILE,0,0}, // S_MISSILE
- {SPR_MISG,0,1,{A_Lower},S_MISSILEDOWN,0,0}, // S_MISSILEDOWN
- {SPR_MISG,0,1,{A_Raise},S_MISSILEUP,0,0}, // S_MISSILEUP
- {SPR_MISG,1,8,{A_GunFlash},S_MISSILE2,0,0}, // S_MISSILE1
- {SPR_MISG,1,12,{A_FireMissile},S_MISSILE3,0,0}, // S_MISSILE2
- {SPR_MISG,1,0,{A_ReFire},S_MISSILE,0,0}, // S_MISSILE3
- {SPR_MISF,32768,3,{A_Light1},S_MISSILEFLASH2,0,0}, // S_MISSILEFLASH1
- {SPR_MISF,32769,4,{NULL},S_MISSILEFLASH3,0,0}, // S_MISSILEFLASH2
- {SPR_MISF,32770,4,{A_Light2},S_MISSILEFLASH4,0,0}, // S_MISSILEFLASH3
- {SPR_MISF,32771,4,{A_Light2},S_LIGHTDONE,0,0}, // S_MISSILEFLASH4
- {SPR_SAWG,2,4,{A_WeaponReady},S_SAWB,0,0}, // S_SAW
- {SPR_SAWG,3,4,{A_WeaponReady},S_SAW,0,0}, // S_SAWB
- {SPR_SAWG,2,1,{A_Lower},S_SAWDOWN,0,0}, // S_SAWDOWN
- {SPR_SAWG,2,1,{A_Raise},S_SAWUP,0,0}, // S_SAWUP
- {SPR_SAWG,0,4,{A_Saw},S_SAW2,0,0}, // S_SAW1
- {SPR_SAWG,1,4,{A_Saw},S_SAW3,0,0}, // S_SAW2
- {SPR_SAWG,1,0,{A_ReFire},S_SAW,0,0}, // S_SAW3
- {SPR_PLSG,0,1,{A_WeaponReady},S_PLASMA,0,0}, // S_PLASMA
- {SPR_PLSG,0,1,{A_Lower},S_PLASMADOWN,0,0}, // S_PLASMADOWN
- {SPR_PLSG,0,1,{A_Raise},S_PLASMAUP,0,0}, // S_PLASMAUP
- {SPR_PLSG,0,3,{A_FirePlasma},S_PLASMA2,0,0}, // S_PLASMA1
- {SPR_PLSG,1,20,{A_ReFire},S_PLASMA,0,0}, // S_PLASMA2
- {SPR_PLSF,32768,4,{A_Light1},S_LIGHTDONE,0,0}, // S_PLASMAFLASH1
- {SPR_PLSF,32769,4,{A_Light1},S_LIGHTDONE,0,0}, // S_PLASMAFLASH2
- {SPR_BFGG,0,1,{A_WeaponReady},S_BFG,0,0}, // S_BFG
- {SPR_BFGG,0,1,{A_Lower},S_BFGDOWN,0,0}, // S_BFGDOWN
- {SPR_BFGG,0,1,{A_Raise},S_BFGUP,0,0}, // S_BFGUP
- {SPR_BFGG,0,20,{A_BFGsound},S_BFG2,0,0}, // S_BFG1
- {SPR_BFGG,1,10,{A_GunFlash},S_BFG3,0,0}, // S_BFG2
- {SPR_BFGG,1,10,{A_FireBFG},S_BFG4,0,0}, // S_BFG3
- {SPR_BFGG,1,20,{A_ReFire},S_BFG,0,0}, // S_BFG4
- {SPR_BFGF,32768,11,{A_Light1},S_BFGFLASH2,0,0}, // S_BFGFLASH1
- {SPR_BFGF,32769,6,{A_Light2},S_LIGHTDONE,0,0}, // S_BFGFLASH2
- {SPR_BLUD,2,8,{NULL},S_BLOOD2,0,0}, // S_BLOOD1
- {SPR_BLUD,1,8,{NULL},S_BLOOD3,0,0}, // S_BLOOD2
- {SPR_BLUD,0,8,{NULL},S_NULL,0,0}, // S_BLOOD3
- {SPR_PUFF,32768,4,{NULL},S_PUFF2,0,0}, // S_PUFF1
- {SPR_PUFF,1,4,{NULL},S_PUFF3,0,0}, // S_PUFF2
- {SPR_PUFF,2,4,{NULL},S_PUFF4,0,0}, // S_PUFF3
- {SPR_PUFF,3,4,{NULL},S_NULL,0,0}, // S_PUFF4
- {SPR_BAL1,32768,4,{NULL},S_TBALL2,0,0}, // S_TBALL1
- {SPR_BAL1,32769,4,{NULL},S_TBALL1,0,0}, // S_TBALL2
- {SPR_BAL1,32770,6,{NULL},S_TBALLX2,0,0}, // S_TBALLX1
- {SPR_BAL1,32771,6,{NULL},S_TBALLX3,0,0}, // S_TBALLX2
- {SPR_BAL1,32772,6,{NULL},S_NULL,0,0}, // S_TBALLX3
- {SPR_BAL2,32768,4,{NULL},S_RBALL2,0,0}, // S_RBALL1
- {SPR_BAL2,32769,4,{NULL},S_RBALL1,0,0}, // S_RBALL2
- {SPR_BAL2,32770,6,{NULL},S_RBALLX2,0,0}, // S_RBALLX1
- {SPR_BAL2,32771,6,{NULL},S_RBALLX3,0,0}, // S_RBALLX2
- {SPR_BAL2,32772,6,{NULL},S_NULL,0,0}, // S_RBALLX3
- {SPR_PLSS,32768,6,{NULL},S_PLASBALL2,0,0}, // S_PLASBALL
- {SPR_PLSS,32769,6,{NULL},S_PLASBALL,0,0}, // S_PLASBALL2
- {SPR_PLSE,32768,4,{NULL},S_PLASEXP2,0,0}, // S_PLASEXP
- {SPR_PLSE,32769,4,{NULL},S_PLASEXP3,0,0}, // S_PLASEXP2
- {SPR_PLSE,32770,4,{NULL},S_PLASEXP4,0,0}, // S_PLASEXP3
- {SPR_PLSE,32771,4,{NULL},S_PLASEXP5,0,0}, // S_PLASEXP4
- {SPR_PLSE,32772,4,{NULL},S_NULL,0,0}, // S_PLASEXP5
- {SPR_MISL,32768,1,{NULL},S_ROCKET,0,0}, // S_ROCKET
- {SPR_BFS1,32768,4,{NULL},S_BFGSHOT2,0,0}, // S_BFGSHOT
- {SPR_BFS1,32769,4,{NULL},S_BFGSHOT,0,0}, // S_BFGSHOT2
- {SPR_BFE1,32768,8,{NULL},S_BFGLAND2,0,0}, // S_BFGLAND
- {SPR_BFE1,32769,8,{NULL},S_BFGLAND3,0,0}, // S_BFGLAND2
- {SPR_BFE1,32770,8,{A_BFGSpray},S_BFGLAND4,0,0}, // S_BFGLAND3
- {SPR_BFE1,32771,8,{NULL},S_BFGLAND5,0,0}, // S_BFGLAND4
- {SPR_BFE1,32772,8,{NULL},S_BFGLAND6,0,0}, // S_BFGLAND5
- {SPR_BFE1,32773,8,{NULL},S_NULL,0,0}, // S_BFGLAND6
- {SPR_BFE2,32768,8,{NULL},S_BFGEXP2,0,0}, // S_BFGEXP
- {SPR_BFE2,32769,8,{NULL},S_BFGEXP3,0,0}, // S_BFGEXP2
- {SPR_BFE2,32770,8,{NULL},S_BFGEXP4,0,0}, // S_BFGEXP3
- {SPR_BFE2,32771,8,{NULL},S_NULL,0,0}, // S_BFGEXP4
- {SPR_MISL,32769,8,{A_Explode},S_EXPLODE2,0,0}, // S_EXPLODE1
- {SPR_MISL,32770,6,{NULL},S_EXPLODE3,0,0}, // S_EXPLODE2
- {SPR_MISL,32771,4,{NULL},S_NULL,0,0}, // S_EXPLODE3
- {SPR_TFOG,32768,6,{NULL},S_TFOG01,0,0}, // S_TFOG
- {SPR_TFOG,32769,6,{NULL},S_TFOG02,0,0}, // S_TFOG01
- {SPR_TFOG,32768,6,{NULL},S_TFOG2,0,0}, // S_TFOG02
- {SPR_TFOG,32769,6,{NULL},S_TFOG3,0,0}, // S_TFOG2
- {SPR_TFOG,32770,6,{NULL},S_TFOG4,0,0}, // S_TFOG3
- {SPR_TFOG,32771,6,{NULL},S_TFOG5,0,0}, // S_TFOG4
- {SPR_TFOG,32772,6,{NULL},S_TFOG6,0,0}, // S_TFOG5
- {SPR_TFOG,32773,6,{NULL},S_TFOG7,0,0}, // S_TFOG6
- {SPR_TFOG,32774,6,{NULL},S_TFOG8,0,0}, // S_TFOG7
- {SPR_TFOG,32775,6,{NULL},S_TFOG9,0,0}, // S_TFOG8
- {SPR_TFOG,32776,6,{NULL},S_TFOG10,0,0}, // S_TFOG9
- {SPR_TFOG,32777,6,{NULL},S_NULL,0,0}, // S_TFOG10
- {SPR_IFOG,32768,6,{NULL},S_IFOG01,0,0}, // S_IFOG
- {SPR_IFOG,32769,6,{NULL},S_IFOG02,0,0}, // S_IFOG01
- {SPR_IFOG,32768,6,{NULL},S_IFOG2,0,0}, // S_IFOG02
- {SPR_IFOG,32769,6,{NULL},S_IFOG3,0,0}, // S_IFOG2
- {SPR_IFOG,32770,6,{NULL},S_IFOG4,0,0}, // S_IFOG3
- {SPR_IFOG,32771,6,{NULL},S_IFOG5,0,0}, // S_IFOG4
- {SPR_IFOG,32772,6,{NULL},S_NULL,0,0}, // S_IFOG5
- {SPR_PLAY,0,-1,{NULL},S_NULL,0,0}, // S_PLAY
- {SPR_PLAY,0,4,{NULL},S_PLAY_RUN2,0,0}, // S_PLAY_RUN1
- {SPR_PLAY,1,4,{NULL},S_PLAY_RUN3,0,0}, // S_PLAY_RUN2
- {SPR_PLAY,2,4,{NULL},S_PLAY_RUN4,0,0}, // S_PLAY_RUN3
- {SPR_PLAY,3,4,{NULL},S_PLAY_RUN1,0,0}, // S_PLAY_RUN4
- {SPR_PLAY,4,12,{NULL},S_PLAY,0,0}, // S_PLAY_ATK1
- {SPR_PLAY,32773,6,{NULL},S_PLAY_ATK1,0,0}, // S_PLAY_ATK2
- {SPR_PLAY,6,4,{NULL},S_PLAY_PAIN2,0,0}, // S_PLAY_PAIN
- {SPR_PLAY,6,4,{A_Pain},S_PLAY,0,0}, // S_PLAY_PAIN2
- {SPR_PLAY,7,10,{NULL},S_PLAY_DIE2,0,0}, // S_PLAY_DIE1
- {SPR_PLAY,8,10,{A_PlayerScream},S_PLAY_DIE3,0,0}, // S_PLAY_DIE2
- {SPR_PLAY,9,10,{A_Fall},S_PLAY_DIE4,0,0}, // S_PLAY_DIE3
- {SPR_PLAY,10,10,{NULL},S_PLAY_DIE5,0,0}, // S_PLAY_DIE4
- {SPR_PLAY,11,10,{NULL},S_PLAY_DIE6,0,0}, // S_PLAY_DIE5
- {SPR_PLAY,12,10,{NULL},S_PLAY_DIE7,0,0}, // S_PLAY_DIE6
- {SPR_PLAY,13,-1,{NULL},S_NULL,0,0}, // S_PLAY_DIE7
- {SPR_PLAY,14,5,{NULL},S_PLAY_XDIE2,0,0}, // S_PLAY_XDIE1
- {SPR_PLAY,15,5,{A_XScream},S_PLAY_XDIE3,0,0}, // S_PLAY_XDIE2
- {SPR_PLAY,16,5,{A_Fall},S_PLAY_XDIE4,0,0}, // S_PLAY_XDIE3
- {SPR_PLAY,17,5,{NULL},S_PLAY_XDIE5,0,0}, // S_PLAY_XDIE4
- {SPR_PLAY,18,5,{NULL},S_PLAY_XDIE6,0,0}, // S_PLAY_XDIE5
- {SPR_PLAY,19,5,{NULL},S_PLAY_XDIE7,0,0}, // S_PLAY_XDIE6
- {SPR_PLAY,20,5,{NULL},S_PLAY_XDIE8,0,0}, // S_PLAY_XDIE7
- {SPR_PLAY,21,5,{NULL},S_PLAY_XDIE9,0,0}, // S_PLAY_XDIE8
- {SPR_PLAY,22,-1,{NULL},S_NULL,0,0}, // S_PLAY_XDIE9
- {SPR_POSS,0,10,{A_Look},S_POSS_STND2,0,0}, // S_POSS_STND
- {SPR_POSS,1,10,{A_Look},S_POSS_STND,0,0}, // S_POSS_STND2
- {SPR_POSS,0,4,{A_Chase},S_POSS_RUN2,0,0}, // S_POSS_RUN1
- {SPR_POSS,0,4,{A_Chase},S_POSS_RUN3,0,0}, // S_POSS_RUN2
- {SPR_POSS,1,4,{A_Chase},S_POSS_RUN4,0,0}, // S_POSS_RUN3
- {SPR_POSS,1,4,{A_Chase},S_POSS_RUN5,0,0}, // S_POSS_RUN4
- {SPR_POSS,2,4,{A_Chase},S_POSS_RUN6,0,0}, // S_POSS_RUN5
- {SPR_POSS,2,4,{A_Chase},S_POSS_RUN7,0,0}, // S_POSS_RUN6
- {SPR_POSS,3,4,{A_Chase},S_POSS_RUN8,0,0}, // S_POSS_RUN7
- {SPR_POSS,3,4,{A_Chase},S_POSS_RUN1,0,0}, // S_POSS_RUN8
- {SPR_POSS,4,10,{A_FaceTarget},S_POSS_ATK2,0,0}, // S_POSS_ATK1
- {SPR_POSS,5,8,{A_PosAttack},S_POSS_ATK3,0,0}, // S_POSS_ATK2
- {SPR_POSS,4,8,{NULL},S_POSS_RUN1,0,0}, // S_POSS_ATK3
- {SPR_POSS,6,3,{NULL},S_POSS_PAIN2,0,0}, // S_POSS_PAIN
- {SPR_POSS,6,3,{A_Pain},S_POSS_RUN1,0,0}, // S_POSS_PAIN2
- {SPR_POSS,7,5,{NULL},S_POSS_DIE2,0,0}, // S_POSS_DIE1
- {SPR_POSS,8,5,{A_Scream},S_POSS_DIE3,0,0}, // S_POSS_DIE2
- {SPR_POSS,9,5,{A_Fall},S_POSS_DIE4,0,0}, // S_POSS_DIE3
- {SPR_POSS,10,5,{NULL},S_POSS_DIE5,0,0}, // S_POSS_DIE4
- {SPR_POSS,11,-1,{NULL},S_NULL,0,0}, // S_POSS_DIE5
- {SPR_POSS,12,5,{NULL},S_POSS_XDIE2,0,0}, // S_POSS_XDIE1
- {SPR_POSS,13,5,{A_XScream},S_POSS_XDIE3,0,0}, // S_POSS_XDIE2
- {SPR_POSS,14,5,{A_Fall},S_POSS_XDIE4,0,0}, // S_POSS_XDIE3
- {SPR_POSS,15,5,{NULL},S_POSS_XDIE5,0,0}, // S_POSS_XDIE4
- {SPR_POSS,16,5,{NULL},S_POSS_XDIE6,0,0}, // S_POSS_XDIE5
- {SPR_POSS,17,5,{NULL},S_POSS_XDIE7,0,0}, // S_POSS_XDIE6
- {SPR_POSS,18,5,{NULL},S_POSS_XDIE8,0,0}, // S_POSS_XDIE7
- {SPR_POSS,19,5,{NULL},S_POSS_XDIE9,0,0}, // S_POSS_XDIE8
- {SPR_POSS,20,-1,{NULL},S_NULL,0,0}, // S_POSS_XDIE9
- {SPR_POSS,10,5,{NULL},S_POSS_RAISE2,0,0}, // S_POSS_RAISE1
- {SPR_POSS,9,5,{NULL},S_POSS_RAISE3,0,0}, // S_POSS_RAISE2
- {SPR_POSS,8,5,{NULL},S_POSS_RAISE4,0,0}, // S_POSS_RAISE3
- {SPR_POSS,7,5,{NULL},S_POSS_RUN1,0,0}, // S_POSS_RAISE4
- {SPR_SPOS,0,10,{A_Look},S_SPOS_STND2,0,0}, // S_SPOS_STND
- {SPR_SPOS,1,10,{A_Look},S_SPOS_STND,0,0}, // S_SPOS_STND2
- {SPR_SPOS,0,3,{A_Chase},S_SPOS_RUN2,0,0}, // S_SPOS_RUN1
- {SPR_SPOS,0,3,{A_Chase},S_SPOS_RUN3,0,0}, // S_SPOS_RUN2
- {SPR_SPOS,1,3,{A_Chase},S_SPOS_RUN4,0,0}, // S_SPOS_RUN3
- {SPR_SPOS,1,3,{A_Chase},S_SPOS_RUN5,0,0}, // S_SPOS_RUN4
- {SPR_SPOS,2,3,{A_Chase},S_SPOS_RUN6,0,0}, // S_SPOS_RUN5
- {SPR_SPOS,2,3,{A_Chase},S_SPOS_RUN7,0,0}, // S_SPOS_RUN6
- {SPR_SPOS,3,3,{A_Chase},S_SPOS_RUN8,0,0}, // S_SPOS_RUN7
- {SPR_SPOS,3,3,{A_Chase},S_SPOS_RUN1,0,0}, // S_SPOS_RUN8
- {SPR_SPOS,4,10,{A_FaceTarget},S_SPOS_ATK2,0,0}, // S_SPOS_ATK1
- {SPR_SPOS,32773,10,{A_SPosAttack},S_SPOS_ATK3,0,0}, // S_SPOS_ATK2
- {SPR_SPOS,4,10,{NULL},S_SPOS_RUN1,0,0}, // S_SPOS_ATK3
- {SPR_SPOS,6,3,{NULL},S_SPOS_PAIN2,0,0}, // S_SPOS_PAIN
- {SPR_SPOS,6,3,{A_Pain},S_SPOS_RUN1,0,0}, // S_SPOS_PAIN2
- {SPR_SPOS,7,5,{NULL},S_SPOS_DIE2,0,0}, // S_SPOS_DIE1
- {SPR_SPOS,8,5,{A_Scream},S_SPOS_DIE3,0,0}, // S_SPOS_DIE2
- {SPR_SPOS,9,5,{A_Fall},S_SPOS_DIE4,0,0}, // S_SPOS_DIE3
- {SPR_SPOS,10,5,{NULL},S_SPOS_DIE5,0,0}, // S_SPOS_DIE4
- {SPR_SPOS,11,-1,{NULL},S_NULL,0,0}, // S_SPOS_DIE5
- {SPR_SPOS,12,5,{NULL},S_SPOS_XDIE2,0,0}, // S_SPOS_XDIE1
- {SPR_SPOS,13,5,{A_XScream},S_SPOS_XDIE3,0,0}, // S_SPOS_XDIE2
- {SPR_SPOS,14,5,{A_Fall},S_SPOS_XDIE4,0,0}, // S_SPOS_XDIE3
- {SPR_SPOS,15,5,{NULL},S_SPOS_XDIE5,0,0}, // S_SPOS_XDIE4
- {SPR_SPOS,16,5,{NULL},S_SPOS_XDIE6,0,0}, // S_SPOS_XDIE5
- {SPR_SPOS,17,5,{NULL},S_SPOS_XDIE7,0,0}, // S_SPOS_XDIE6
- {SPR_SPOS,18,5,{NULL},S_SPOS_XDIE8,0,0}, // S_SPOS_XDIE7
- {SPR_SPOS,19,5,{NULL},S_SPOS_XDIE9,0,0}, // S_SPOS_XDIE8
- {SPR_SPOS,20,-1,{NULL},S_NULL,0,0}, // S_SPOS_XDIE9
- {SPR_SPOS,11,5,{NULL},S_SPOS_RAISE2,0,0}, // S_SPOS_RAISE1
- {SPR_SPOS,10,5,{NULL},S_SPOS_RAISE3,0,0}, // S_SPOS_RAISE2
- {SPR_SPOS,9,5,{NULL},S_SPOS_RAISE4,0,0}, // S_SPOS_RAISE3
- {SPR_SPOS,8,5,{NULL},S_SPOS_RAISE5,0,0}, // S_SPOS_RAISE4
- {SPR_SPOS,7,5,{NULL},S_SPOS_RUN1,0,0}, // S_SPOS_RAISE5
- {SPR_VILE,0,10,{A_Look},S_VILE_STND2,0,0}, // S_VILE_STND
- {SPR_VILE,1,10,{A_Look},S_VILE_STND,0,0}, // S_VILE_STND2
- {SPR_VILE,0,2,{A_VileChase},S_VILE_RUN2,0,0}, // S_VILE_RUN1
- {SPR_VILE,0,2,{A_VileChase},S_VILE_RUN3,0,0}, // S_VILE_RUN2
- {SPR_VILE,1,2,{A_VileChase},S_VILE_RUN4,0,0}, // S_VILE_RUN3
- {SPR_VILE,1,2,{A_VileChase},S_VILE_RUN5,0,0}, // S_VILE_RUN4
- {SPR_VILE,2,2,{A_VileChase},S_VILE_RUN6,0,0}, // S_VILE_RUN5
- {SPR_VILE,2,2,{A_VileChase},S_VILE_RUN7,0,0}, // S_VILE_RUN6
- {SPR_VILE,3,2,{A_VileChase},S_VILE_RUN8,0,0}, // S_VILE_RUN7
- {SPR_VILE,3,2,{A_VileChase},S_VILE_RUN9,0,0}, // S_VILE_RUN8
- {SPR_VILE,4,2,{A_VileChase},S_VILE_RUN10,0,0}, // S_VILE_RUN9
- {SPR_VILE,4,2,{A_VileChase},S_VILE_RUN11,0,0}, // S_VILE_RUN10
- {SPR_VILE,5,2,{A_VileChase},S_VILE_RUN12,0,0}, // S_VILE_RUN11
- {SPR_VILE,5,2,{A_VileChase},S_VILE_RUN1,0,0}, // S_VILE_RUN12
- {SPR_VILE,32774,0,{A_VileStart},S_VILE_ATK2,0,0}, // S_VILE_ATK1
- {SPR_VILE,32774,10,{A_FaceTarget},S_VILE_ATK3,0,0}, // S_VILE_ATK2
- {SPR_VILE,32775,8,{A_VileTarget},S_VILE_ATK4,0,0}, // S_VILE_ATK3
- {SPR_VILE,32776,8,{A_FaceTarget},S_VILE_ATK5,0,0}, // S_VILE_ATK4
- {SPR_VILE,32777,8,{A_FaceTarget},S_VILE_ATK6,0,0}, // S_VILE_ATK5
- {SPR_VILE,32778,8,{A_FaceTarget},S_VILE_ATK7,0,0}, // S_VILE_ATK6
- {SPR_VILE,32779,8,{A_FaceTarget},S_VILE_ATK8,0,0}, // S_VILE_ATK7
- {SPR_VILE,32780,8,{A_FaceTarget},S_VILE_ATK9,0,0}, // S_VILE_ATK8
- {SPR_VILE,32781,8,{A_FaceTarget},S_VILE_ATK10,0,0}, // S_VILE_ATK9
- {SPR_VILE,32782,8,{A_VileAttack},S_VILE_ATK11,0,0}, // S_VILE_ATK10
- {SPR_VILE,32783,20,{NULL},S_VILE_RUN1,0,0}, // S_VILE_ATK11
- {SPR_VILE,32794,10,{NULL},S_VILE_HEAL2,0,0}, // S_VILE_HEAL1
- {SPR_VILE,32795,10,{NULL},S_VILE_HEAL3,0,0}, // S_VILE_HEAL2
- {SPR_VILE,32796,10,{NULL},S_VILE_RUN1,0,0}, // S_VILE_HEAL3
- {SPR_VILE,16,5,{NULL},S_VILE_PAIN2,0,0}, // S_VILE_PAIN
- {SPR_VILE,16,5,{A_Pain},S_VILE_RUN1,0,0}, // S_VILE_PAIN2
- {SPR_VILE,16,7,{NULL},S_VILE_DIE2,0,0}, // S_VILE_DIE1
- {SPR_VILE,17,7,{A_Scream},S_VILE_DIE3,0,0}, // S_VILE_DIE2
- {SPR_VILE,18,7,{A_Fall},S_VILE_DIE4,0,0}, // S_VILE_DIE3
- {SPR_VILE,19,7,{NULL},S_VILE_DIE5,0,0}, // S_VILE_DIE4
- {SPR_VILE,20,7,{NULL},S_VILE_DIE6,0,0}, // S_VILE_DIE5
- {SPR_VILE,21,7,{NULL},S_VILE_DIE7,0,0}, // S_VILE_DIE6
- {SPR_VILE,22,7,{NULL},S_VILE_DIE8,0,0}, // S_VILE_DIE7
- {SPR_VILE,23,5,{NULL},S_VILE_DIE9,0,0}, // S_VILE_DIE8
- {SPR_VILE,24,5,{NULL},S_VILE_DIE10,0,0}, // S_VILE_DIE9
- {SPR_VILE,25,-1,{NULL},S_NULL,0,0}, // S_VILE_DIE10
- {SPR_FIRE,32768,2,{A_StartFire},S_FIRE2,0,0}, // S_FIRE1
- {SPR_FIRE,32769,2,{A_Fire},S_FIRE3,0,0}, // S_FIRE2
- {SPR_FIRE,32768,2,{A_Fire},S_FIRE4,0,0}, // S_FIRE3
- {SPR_FIRE,32769,2,{A_Fire},S_FIRE5,0,0}, // S_FIRE4
- {SPR_FIRE,32770,2,{A_FireCrackle},S_FIRE6,0,0}, // S_FIRE5
- {SPR_FIRE,32769,2,{A_Fire},S_FIRE7,0,0}, // S_FIRE6
- {SPR_FIRE,32770,2,{A_Fire},S_FIRE8,0,0}, // S_FIRE7
- {SPR_FIRE,32769,2,{A_Fire},S_FIRE9,0,0}, // S_FIRE8
- {SPR_FIRE,32770,2,{A_Fire},S_FIRE10,0,0}, // S_FIRE9
- {SPR_FIRE,32771,2,{A_Fire},S_FIRE11,0,0}, // S_FIRE10
- {SPR_FIRE,32770,2,{A_Fire},S_FIRE12,0,0}, // S_FIRE11
- {SPR_FIRE,32771,2,{A_Fire},S_FIRE13,0,0}, // S_FIRE12
- {SPR_FIRE,32770,2,{A_Fire},S_FIRE14,0,0}, // S_FIRE13
- {SPR_FIRE,32771,2,{A_Fire},S_FIRE15,0,0}, // S_FIRE14
- {SPR_FIRE,32772,2,{A_Fire},S_FIRE16,0,0}, // S_FIRE15
- {SPR_FIRE,32771,2,{A_Fire},S_FIRE17,0,0}, // S_FIRE16
- {SPR_FIRE,32772,2,{A_Fire},S_FIRE18,0,0}, // S_FIRE17
- {SPR_FIRE,32771,2,{A_Fire},S_FIRE19,0,0}, // S_FIRE18
- {SPR_FIRE,32772,2,{A_FireCrackle},S_FIRE20,0,0}, // S_FIRE19
- {SPR_FIRE,32773,2,{A_Fire},S_FIRE21,0,0}, // S_FIRE20
- {SPR_FIRE,32772,2,{A_Fire},S_FIRE22,0,0}, // S_FIRE21
- {SPR_FIRE,32773,2,{A_Fire},S_FIRE23,0,0}, // S_FIRE22
- {SPR_FIRE,32772,2,{A_Fire},S_FIRE24,0,0}, // S_FIRE23
- {SPR_FIRE,32773,2,{A_Fire},S_FIRE25,0,0}, // S_FIRE24
- {SPR_FIRE,32774,2,{A_Fire},S_FIRE26,0,0}, // S_FIRE25
- {SPR_FIRE,32775,2,{A_Fire},S_FIRE27,0,0}, // S_FIRE26
- {SPR_FIRE,32774,2,{A_Fire},S_FIRE28,0,0}, // S_FIRE27
- {SPR_FIRE,32775,2,{A_Fire},S_FIRE29,0,0}, // S_FIRE28
- {SPR_FIRE,32774,2,{A_Fire},S_FIRE30,0,0}, // S_FIRE29
- {SPR_FIRE,32775,2,{A_Fire},S_NULL,0,0}, // S_FIRE30
- {SPR_PUFF,1,4,{NULL},S_SMOKE2,0,0}, // S_SMOKE1
- {SPR_PUFF,2,4,{NULL},S_SMOKE3,0,0}, // S_SMOKE2
- {SPR_PUFF,1,4,{NULL},S_SMOKE4,0,0}, // S_SMOKE3
- {SPR_PUFF,2,4,{NULL},S_SMOKE5,0,0}, // S_SMOKE4
- {SPR_PUFF,3,4,{NULL},S_NULL,0,0}, // S_SMOKE5
- {SPR_FATB,32768,2,{A_Tracer},S_TRACER2,0,0}, // S_TRACER
- {SPR_FATB,32769,2,{A_Tracer},S_TRACER,0,0}, // S_TRACER2
- {SPR_FBXP,32768,8,{NULL},S_TRACEEXP2,0,0}, // S_TRACEEXP1
- {SPR_FBXP,32769,6,{NULL},S_TRACEEXP3,0,0}, // S_TRACEEXP2
- {SPR_FBXP,32770,4,{NULL},S_NULL,0,0}, // S_TRACEEXP3
- {SPR_SKEL,0,10,{A_Look},S_SKEL_STND2,0,0}, // S_SKEL_STND
- {SPR_SKEL,1,10,{A_Look},S_SKEL_STND,0,0}, // S_SKEL_STND2
- {SPR_SKEL,0,2,{A_Chase},S_SKEL_RUN2,0,0}, // S_SKEL_RUN1
- {SPR_SKEL,0,2,{A_Chase},S_SKEL_RUN3,0,0}, // S_SKEL_RUN2
- {SPR_SKEL,1,2,{A_Chase},S_SKEL_RUN4,0,0}, // S_SKEL_RUN3
- {SPR_SKEL,1,2,{A_Chase},S_SKEL_RUN5,0,0}, // S_SKEL_RUN4
- {SPR_SKEL,2,2,{A_Chase},S_SKEL_RUN6,0,0}, // S_SKEL_RUN5
- {SPR_SKEL,2,2,{A_Chase},S_SKEL_RUN7,0,0}, // S_SKEL_RUN6
- {SPR_SKEL,3,2,{A_Chase},S_SKEL_RUN8,0,0}, // S_SKEL_RUN7
- {SPR_SKEL,3,2,{A_Chase},S_SKEL_RUN9,0,0}, // S_SKEL_RUN8
- {SPR_SKEL,4,2,{A_Chase},S_SKEL_RUN10,0,0}, // S_SKEL_RUN9
- {SPR_SKEL,4,2,{A_Chase},S_SKEL_RUN11,0,0}, // S_SKEL_RUN10
- {SPR_SKEL,5,2,{A_Chase},S_SKEL_RUN12,0,0}, // S_SKEL_RUN11
- {SPR_SKEL,5,2,{A_Chase},S_SKEL_RUN1,0,0}, // S_SKEL_RUN12
- {SPR_SKEL,6,0,{A_FaceTarget},S_SKEL_FIST2,0,0}, // S_SKEL_FIST1
- {SPR_SKEL,6,6,{A_SkelWhoosh},S_SKEL_FIST3,0,0}, // S_SKEL_FIST2
- {SPR_SKEL,7,6,{A_FaceTarget},S_SKEL_FIST4,0,0}, // S_SKEL_FIST3
- {SPR_SKEL,8,6,{A_SkelFist},S_SKEL_RUN1,0,0}, // S_SKEL_FIST4
- {SPR_SKEL,32777,0,{A_FaceTarget},S_SKEL_MISS2,0,0}, // S_SKEL_MISS1
- {SPR_SKEL,32777,10,{A_FaceTarget},S_SKEL_MISS3,0,0}, // S_SKEL_MISS2
- {SPR_SKEL,10,10,{A_SkelMissile},S_SKEL_MISS4,0,0}, // S_SKEL_MISS3
- {SPR_SKEL,10,10,{A_FaceTarget},S_SKEL_RUN1,0,0}, // S_SKEL_MISS4
- {SPR_SKEL,11,5,{NULL},S_SKEL_PAIN2,0,0}, // S_SKEL_PAIN
- {SPR_SKEL,11,5,{A_Pain},S_SKEL_RUN1,0,0}, // S_SKEL_PAIN2
- {SPR_SKEL,11,7,{NULL},S_SKEL_DIE2,0,0}, // S_SKEL_DIE1
- {SPR_SKEL,12,7,{NULL},S_SKEL_DIE3,0,0}, // S_SKEL_DIE2
- {SPR_SKEL,13,7,{A_Scream},S_SKEL_DIE4,0,0}, // S_SKEL_DIE3
- {SPR_SKEL,14,7,{A_Fall},S_SKEL_DIE5,0,0}, // S_SKEL_DIE4
- {SPR_SKEL,15,7,{NULL},S_SKEL_DIE6,0,0}, // S_SKEL_DIE5
- {SPR_SKEL,16,-1,{NULL},S_NULL,0,0}, // S_SKEL_DIE6
- {SPR_SKEL,16,5,{NULL},S_SKEL_RAISE2,0,0}, // S_SKEL_RAISE1
- {SPR_SKEL,15,5,{NULL},S_SKEL_RAISE3,0,0}, // S_SKEL_RAISE2
- {SPR_SKEL,14,5,{NULL},S_SKEL_RAISE4,0,0}, // S_SKEL_RAISE3
- {SPR_SKEL,13,5,{NULL},S_SKEL_RAISE5,0,0}, // S_SKEL_RAISE4
- {SPR_SKEL,12,5,{NULL},S_SKEL_RAISE6,0,0}, // S_SKEL_RAISE5
- {SPR_SKEL,11,5,{NULL},S_SKEL_RUN1,0,0}, // S_SKEL_RAISE6
- {SPR_MANF,32768,4,{NULL},S_FATSHOT2,0,0}, // S_FATSHOT1
- {SPR_MANF,32769,4,{NULL},S_FATSHOT1,0,0}, // S_FATSHOT2
- {SPR_MISL,32769,8,{NULL},S_FATSHOTX2,0,0}, // S_FATSHOTX1
- {SPR_MISL,32770,6,{NULL},S_FATSHOTX3,0,0}, // S_FATSHOTX2
- {SPR_MISL,32771,4,{NULL},S_NULL,0,0}, // S_FATSHOTX3
- {SPR_FATT,0,15,{A_Look},S_FATT_STND2,0,0}, // S_FATT_STND
- {SPR_FATT,1,15,{A_Look},S_FATT_STND,0,0}, // S_FATT_STND2
- {SPR_FATT,0,4,{A_Chase},S_FATT_RUN2,0,0}, // S_FATT_RUN1
- {SPR_FATT,0,4,{A_Chase},S_FATT_RUN3,0,0}, // S_FATT_RUN2
- {SPR_FATT,1,4,{A_Chase},S_FATT_RUN4,0,0}, // S_FATT_RUN3
- {SPR_FATT,1,4,{A_Chase},S_FATT_RUN5,0,0}, // S_FATT_RUN4
- {SPR_FATT,2,4,{A_Chase},S_FATT_RUN6,0,0}, // S_FATT_RUN5
- {SPR_FATT,2,4,{A_Chase},S_FATT_RUN7,0,0}, // S_FATT_RUN6
- {SPR_FATT,3,4,{A_Chase},S_FATT_RUN8,0,0}, // S_FATT_RUN7
- {SPR_FATT,3,4,{A_Chase},S_FATT_RUN9,0,0}, // S_FATT_RUN8
- {SPR_FATT,4,4,{A_Chase},S_FATT_RUN10,0,0}, // S_FATT_RUN9
- {SPR_FATT,4,4,{A_Chase},S_FATT_RUN11,0,0}, // S_FATT_RUN10
- {SPR_FATT,5,4,{A_Chase},S_FATT_RUN12,0,0}, // S_FATT_RUN11
- {SPR_FATT,5,4,{A_Chase},S_FATT_RUN1,0,0}, // S_FATT_RUN12
- {SPR_FATT,6,20,{A_FatRaise},S_FATT_ATK2,0,0}, // S_FATT_ATK1
- {SPR_FATT,32775,10,{A_FatAttack1},S_FATT_ATK3,0,0}, // S_FATT_ATK2
- {SPR_FATT,8,5,{A_FaceTarget},S_FATT_ATK4,0,0}, // S_FATT_ATK3
- {SPR_FATT,6,5,{A_FaceTarget},S_FATT_ATK5,0,0}, // S_FATT_ATK4
- {SPR_FATT,32775,10,{A_FatAttack2},S_FATT_ATK6,0,0}, // S_FATT_ATK5
- {SPR_FATT,8,5,{A_FaceTarget},S_FATT_ATK7,0,0}, // S_FATT_ATK6
- {SPR_FATT,6,5,{A_FaceTarget},S_FATT_ATK8,0,0}, // S_FATT_ATK7
- {SPR_FATT,32775,10,{A_FatAttack3},S_FATT_ATK9,0,0}, // S_FATT_ATK8
- {SPR_FATT,8,5,{A_FaceTarget},S_FATT_ATK10,0,0}, // S_FATT_ATK9
- {SPR_FATT,6,5,{A_FaceTarget},S_FATT_RUN1,0,0}, // S_FATT_ATK10
- {SPR_FATT,9,3,{NULL},S_FATT_PAIN2,0,0}, // S_FATT_PAIN
- {SPR_FATT,9,3,{A_Pain},S_FATT_RUN1,0,0}, // S_FATT_PAIN2
- {SPR_FATT,10,6,{NULL},S_FATT_DIE2,0,0}, // S_FATT_DIE1
- {SPR_FATT,11,6,{A_Scream},S_FATT_DIE3,0,0}, // S_FATT_DIE2
- {SPR_FATT,12,6,{A_Fall},S_FATT_DIE4,0,0}, // S_FATT_DIE3
- {SPR_FATT,13,6,{NULL},S_FATT_DIE5,0,0}, // S_FATT_DIE4
- {SPR_FATT,14,6,{NULL},S_FATT_DIE6,0,0}, // S_FATT_DIE5
- {SPR_FATT,15,6,{NULL},S_FATT_DIE7,0,0}, // S_FATT_DIE6
- {SPR_FATT,16,6,{NULL},S_FATT_DIE8,0,0}, // S_FATT_DIE7
- {SPR_FATT,17,6,{NULL},S_FATT_DIE9,0,0}, // S_FATT_DIE8
- {SPR_FATT,18,6,{NULL},S_FATT_DIE10,0,0}, // S_FATT_DIE9
- {SPR_FATT,19,-1,{A_BossDeath},S_NULL,0,0}, // S_FATT_DIE10
- {SPR_FATT,17,5,{NULL},S_FATT_RAISE2,0,0}, // S_FATT_RAISE1
- {SPR_FATT,16,5,{NULL},S_FATT_RAISE3,0,0}, // S_FATT_RAISE2
- {SPR_FATT,15,5,{NULL},S_FATT_RAISE4,0,0}, // S_FATT_RAISE3
- {SPR_FATT,14,5,{NULL},S_FATT_RAISE5,0,0}, // S_FATT_RAISE4
- {SPR_FATT,13,5,{NULL},S_FATT_RAISE6,0,0}, // S_FATT_RAISE5
- {SPR_FATT,12,5,{NULL},S_FATT_RAISE7,0,0}, // S_FATT_RAISE6
- {SPR_FATT,11,5,{NULL},S_FATT_RAISE8,0,0}, // S_FATT_RAISE7
- {SPR_FATT,10,5,{NULL},S_FATT_RUN1,0,0}, // S_FATT_RAISE8
- {SPR_CPOS,0,10,{A_Look},S_CPOS_STND2,0,0}, // S_CPOS_STND
- {SPR_CPOS,1,10,{A_Look},S_CPOS_STND,0,0}, // S_CPOS_STND2
- {SPR_CPOS,0,3,{A_Chase},S_CPOS_RUN2,0,0}, // S_CPOS_RUN1
- {SPR_CPOS,0,3,{A_Chase},S_CPOS_RUN3,0,0}, // S_CPOS_RUN2
- {SPR_CPOS,1,3,{A_Chase},S_CPOS_RUN4,0,0}, // S_CPOS_RUN3
- {SPR_CPOS,1,3,{A_Chase},S_CPOS_RUN5,0,0}, // S_CPOS_RUN4
- {SPR_CPOS,2,3,{A_Chase},S_CPOS_RUN6,0,0}, // S_CPOS_RUN5
- {SPR_CPOS,2,3,{A_Chase},S_CPOS_RUN7,0,0}, // S_CPOS_RUN6
- {SPR_CPOS,3,3,{A_Chase},S_CPOS_RUN8,0,0}, // S_CPOS_RUN7
- {SPR_CPOS,3,3,{A_Chase},S_CPOS_RUN1,0,0}, // S_CPOS_RUN8
- {SPR_CPOS,4,10,{A_FaceTarget},S_CPOS_ATK2,0,0}, // S_CPOS_ATK1
- {SPR_CPOS,32773,4,{A_CPosAttack},S_CPOS_ATK3,0,0}, // S_CPOS_ATK2
- {SPR_CPOS,32772,4,{A_CPosAttack},S_CPOS_ATK4,0,0}, // S_CPOS_ATK3
- {SPR_CPOS,5,1,{A_CPosRefire},S_CPOS_ATK2,0,0}, // S_CPOS_ATK4
- {SPR_CPOS,6,3,{NULL},S_CPOS_PAIN2,0,0}, // S_CPOS_PAIN
- {SPR_CPOS,6,3,{A_Pain},S_CPOS_RUN1,0,0}, // S_CPOS_PAIN2
- {SPR_CPOS,7,5,{NULL},S_CPOS_DIE2,0,0}, // S_CPOS_DIE1
- {SPR_CPOS,8,5,{A_Scream},S_CPOS_DIE3,0,0}, // S_CPOS_DIE2
- {SPR_CPOS,9,5,{A_Fall},S_CPOS_DIE4,0,0}, // S_CPOS_DIE3
- {SPR_CPOS,10,5,{NULL},S_CPOS_DIE5,0,0}, // S_CPOS_DIE4
- {SPR_CPOS,11,5,{NULL},S_CPOS_DIE6,0,0}, // S_CPOS_DIE5
- {SPR_CPOS,12,5,{NULL},S_CPOS_DIE7,0,0}, // S_CPOS_DIE6
- {SPR_CPOS,13,-1,{NULL},S_NULL,0,0}, // S_CPOS_DIE7
- {SPR_CPOS,14,5,{NULL},S_CPOS_XDIE2,0,0}, // S_CPOS_XDIE1
- {SPR_CPOS,15,5,{A_XScream},S_CPOS_XDIE3,0,0}, // S_CPOS_XDIE2
- {SPR_CPOS,16,5,{A_Fall},S_CPOS_XDIE4,0,0}, // S_CPOS_XDIE3
- {SPR_CPOS,17,5,{NULL},S_CPOS_XDIE5,0,0}, // S_CPOS_XDIE4
- {SPR_CPOS,18,5,{NULL},S_CPOS_XDIE6,0,0}, // S_CPOS_XDIE5
- {SPR_CPOS,19,-1,{NULL},S_NULL,0,0}, // S_CPOS_XDIE6
- {SPR_CPOS,13,5,{NULL},S_CPOS_RAISE2,0,0}, // S_CPOS_RAISE1
- {SPR_CPOS,12,5,{NULL},S_CPOS_RAISE3,0,0}, // S_CPOS_RAISE2
- {SPR_CPOS,11,5,{NULL},S_CPOS_RAISE4,0,0}, // S_CPOS_RAISE3
- {SPR_CPOS,10,5,{NULL},S_CPOS_RAISE5,0,0}, // S_CPOS_RAISE4
- {SPR_CPOS,9,5,{NULL},S_CPOS_RAISE6,0,0}, // S_CPOS_RAISE5
- {SPR_CPOS,8,5,{NULL},S_CPOS_RAISE7,0,0}, // S_CPOS_RAISE6
- {SPR_CPOS,7,5,{NULL},S_CPOS_RUN1,0,0}, // S_CPOS_RAISE7
- {SPR_TROO,0,10,{A_Look},S_TROO_STND2,0,0}, // S_TROO_STND
- {SPR_TROO,1,10,{A_Look},S_TROO_STND,0,0}, // S_TROO_STND2
- {SPR_TROO,0,3,{A_Chase},S_TROO_RUN2,0,0}, // S_TROO_RUN1
- {SPR_TROO,0,3,{A_Chase},S_TROO_RUN3,0,0}, // S_TROO_RUN2
- {SPR_TROO,1,3,{A_Chase},S_TROO_RUN4,0,0}, // S_TROO_RUN3
- {SPR_TROO,1,3,{A_Chase},S_TROO_RUN5,0,0}, // S_TROO_RUN4
- {SPR_TROO,2,3,{A_Chase},S_TROO_RUN6,0,0}, // S_TROO_RUN5
- {SPR_TROO,2,3,{A_Chase},S_TROO_RUN7,0,0}, // S_TROO_RUN6
- {SPR_TROO,3,3,{A_Chase},S_TROO_RUN8,0,0}, // S_TROO_RUN7
- {SPR_TROO,3,3,{A_Chase},S_TROO_RUN1,0,0}, // S_TROO_RUN8
- {SPR_TROO,4,8,{A_FaceTarget},S_TROO_ATK2,0,0}, // S_TROO_ATK1
- {SPR_TROO,5,8,{A_FaceTarget},S_TROO_ATK3,0,0}, // S_TROO_ATK2
- {SPR_TROO,6,6,{A_TroopAttack},S_TROO_RUN1,0,0}, // S_TROO_ATK3
- {SPR_TROO,7,2,{NULL},S_TROO_PAIN2,0,0}, // S_TROO_PAIN
- {SPR_TROO,7,2,{A_Pain},S_TROO_RUN1,0,0}, // S_TROO_PAIN2
- {SPR_TROO,8,8,{NULL},S_TROO_DIE2,0,0}, // S_TROO_DIE1
- {SPR_TROO,9,8,{A_Scream},S_TROO_DIE3,0,0}, // S_TROO_DIE2
- {SPR_TROO,10,6,{NULL},S_TROO_DIE4,0,0}, // S_TROO_DIE3
- {SPR_TROO,11,6,{A_Fall},S_TROO_DIE5,0,0}, // S_TROO_DIE4
- {SPR_TROO,12,-1,{NULL},S_NULL,0,0}, // S_TROO_DIE5
- {SPR_TROO,13,5,{NULL},S_TROO_XDIE2,0,0}, // S_TROO_XDIE1
- {SPR_TROO,14,5,{A_XScream},S_TROO_XDIE3,0,0}, // S_TROO_XDIE2
- {SPR_TROO,15,5,{NULL},S_TROO_XDIE4,0,0}, // S_TROO_XDIE3
- {SPR_TROO,16,5,{A_Fall},S_TROO_XDIE5,0,0}, // S_TROO_XDIE4
- {SPR_TROO,17,5,{NULL},S_TROO_XDIE6,0,0}, // S_TROO_XDIE5
- {SPR_TROO,18,5,{NULL},S_TROO_XDIE7,0,0}, // S_TROO_XDIE6
- {SPR_TROO,19,5,{NULL},S_TROO_XDIE8,0,0}, // S_TROO_XDIE7
- {SPR_TROO,20,-1,{NULL},S_NULL,0,0}, // S_TROO_XDIE8
- {SPR_TROO,12,8,{NULL},S_TROO_RAISE2,0,0}, // S_TROO_RAISE1
- {SPR_TROO,11,8,{NULL},S_TROO_RAISE3,0,0}, // S_TROO_RAISE2
- {SPR_TROO,10,6,{NULL},S_TROO_RAISE4,0,0}, // S_TROO_RAISE3
- {SPR_TROO,9,6,{NULL},S_TROO_RAISE5,0,0}, // S_TROO_RAISE4
- {SPR_TROO,8,6,{NULL},S_TROO_RUN1,0,0}, // S_TROO_RAISE5
- {SPR_SARG,0,10,{A_Look},S_SARG_STND2,0,0}, // S_SARG_STND
- {SPR_SARG,1,10,{A_Look},S_SARG_STND,0,0}, // S_SARG_STND2
- {SPR_SARG,0,2,{A_Chase},S_SARG_RUN2,0,0}, // S_SARG_RUN1
- {SPR_SARG,0,2,{A_Chase},S_SARG_RUN3,0,0}, // S_SARG_RUN2
- {SPR_SARG,1,2,{A_Chase},S_SARG_RUN4,0,0}, // S_SARG_RUN3
- {SPR_SARG,1,2,{A_Chase},S_SARG_RUN5,0,0}, // S_SARG_RUN4
- {SPR_SARG,2,2,{A_Chase},S_SARG_RUN6,0,0}, // S_SARG_RUN5
- {SPR_SARG,2,2,{A_Chase},S_SARG_RUN7,0,0}, // S_SARG_RUN6
- {SPR_SARG,3,2,{A_Chase},S_SARG_RUN8,0,0}, // S_SARG_RUN7
- {SPR_SARG,3,2,{A_Chase},S_SARG_RUN1,0,0}, // S_SARG_RUN8
- {SPR_SARG,4,8,{A_FaceTarget},S_SARG_ATK2,0,0}, // S_SARG_ATK1
- {SPR_SARG,5,8,{A_FaceTarget},S_SARG_ATK3,0,0}, // S_SARG_ATK2
- {SPR_SARG,6,8,{A_SargAttack},S_SARG_RUN1,0,0}, // S_SARG_ATK3
- {SPR_SARG,7,2,{NULL},S_SARG_PAIN2,0,0}, // S_SARG_PAIN
- {SPR_SARG,7,2,{A_Pain},S_SARG_RUN1,0,0}, // S_SARG_PAIN2
- {SPR_SARG,8,8,{NULL},S_SARG_DIE2,0,0}, // S_SARG_DIE1
- {SPR_SARG,9,8,{A_Scream},S_SARG_DIE3,0,0}, // S_SARG_DIE2
- {SPR_SARG,10,4,{NULL},S_SARG_DIE4,0,0}, // S_SARG_DIE3
- {SPR_SARG,11,4,{A_Fall},S_SARG_DIE5,0,0}, // S_SARG_DIE4
- {SPR_SARG,12,4,{NULL},S_SARG_DIE6,0,0}, // S_SARG_DIE5
- {SPR_SARG,13,-1,{NULL},S_NULL,0,0}, // S_SARG_DIE6
- {SPR_SARG,13,5,{NULL},S_SARG_RAISE2,0,0}, // S_SARG_RAISE1
- {SPR_SARG,12,5,{NULL},S_SARG_RAISE3,0,0}, // S_SARG_RAISE2
- {SPR_SARG,11,5,{NULL},S_SARG_RAISE4,0,0}, // S_SARG_RAISE3
- {SPR_SARG,10,5,{NULL},S_SARG_RAISE5,0,0}, // S_SARG_RAISE4
- {SPR_SARG,9,5,{NULL},S_SARG_RAISE6,0,0}, // S_SARG_RAISE5
- {SPR_SARG,8,5,{NULL},S_SARG_RUN1,0,0}, // S_SARG_RAISE6
- {SPR_HEAD,0,10,{A_Look},S_HEAD_STND,0,0}, // S_HEAD_STND
- {SPR_HEAD,0,3,{A_Chase},S_HEAD_RUN1,0,0}, // S_HEAD_RUN1
- {SPR_HEAD,1,5,{A_FaceTarget},S_HEAD_ATK2,0,0}, // S_HEAD_ATK1
- {SPR_HEAD,2,5,{A_FaceTarget},S_HEAD_ATK3,0,0}, // S_HEAD_ATK2
- {SPR_HEAD,32771,5,{A_HeadAttack},S_HEAD_RUN1,0,0}, // S_HEAD_ATK3
- {SPR_HEAD,4,3,{NULL},S_HEAD_PAIN2,0,0}, // S_HEAD_PAIN
- {SPR_HEAD,4,3,{A_Pain},S_HEAD_PAIN3,0,0}, // S_HEAD_PAIN2
- {SPR_HEAD,5,6,{NULL},S_HEAD_RUN1,0,0}, // S_HEAD_PAIN3
- {SPR_HEAD,6,8,{NULL},S_HEAD_DIE2,0,0}, // S_HEAD_DIE1
- {SPR_HEAD,7,8,{A_Scream},S_HEAD_DIE3,0,0}, // S_HEAD_DIE2
- {SPR_HEAD,8,8,{NULL},S_HEAD_DIE4,0,0}, // S_HEAD_DIE3
- {SPR_HEAD,9,8,{NULL},S_HEAD_DIE5,0,0}, // S_HEAD_DIE4
- {SPR_HEAD,10,8,{A_Fall},S_HEAD_DIE6,0,0}, // S_HEAD_DIE5
- {SPR_HEAD,11,-1,{NULL},S_NULL,0,0}, // S_HEAD_DIE6
- {SPR_HEAD,11,8,{NULL},S_HEAD_RAISE2,0,0}, // S_HEAD_RAISE1
- {SPR_HEAD,10,8,{NULL},S_HEAD_RAISE3,0,0}, // S_HEAD_RAISE2
- {SPR_HEAD,9,8,{NULL},S_HEAD_RAISE4,0,0}, // S_HEAD_RAISE3
- {SPR_HEAD,8,8,{NULL},S_HEAD_RAISE5,0,0}, // S_HEAD_RAISE4
- {SPR_HEAD,7,8,{NULL},S_HEAD_RAISE6,0,0}, // S_HEAD_RAISE5
- {SPR_HEAD,6,8,{NULL},S_HEAD_RUN1,0,0}, // S_HEAD_RAISE6
- {SPR_BAL7,32768,4,{NULL},S_BRBALL2,0,0}, // S_BRBALL1
- {SPR_BAL7,32769,4,{NULL},S_BRBALL1,0,0}, // S_BRBALL2
- {SPR_BAL7,32770,6,{NULL},S_BRBALLX2,0,0}, // S_BRBALLX1
- {SPR_BAL7,32771,6,{NULL},S_BRBALLX3,0,0}, // S_BRBALLX2
- {SPR_BAL7,32772,6,{NULL},S_NULL,0,0}, // S_BRBALLX3
- {SPR_BOSS,0,10,{A_Look},S_BOSS_STND2,0,0}, // S_BOSS_STND
- {SPR_BOSS,1,10,{A_Look},S_BOSS_STND,0,0}, // S_BOSS_STND2
- {SPR_BOSS,0,3,{A_Chase},S_BOSS_RUN2,0,0}, // S_BOSS_RUN1
- {SPR_BOSS,0,3,{A_Chase},S_BOSS_RUN3,0,0}, // S_BOSS_RUN2
- {SPR_BOSS,1,3,{A_Chase},S_BOSS_RUN4,0,0}, // S_BOSS_RUN3
- {SPR_BOSS,1,3,{A_Chase},S_BOSS_RUN5,0,0}, // S_BOSS_RUN4
- {SPR_BOSS,2,3,{A_Chase},S_BOSS_RUN6,0,0}, // S_BOSS_RUN5
- {SPR_BOSS,2,3,{A_Chase},S_BOSS_RUN7,0,0}, // S_BOSS_RUN6
- {SPR_BOSS,3,3,{A_Chase},S_BOSS_RUN8,0,0}, // S_BOSS_RUN7
- {SPR_BOSS,3,3,{A_Chase},S_BOSS_RUN1,0,0}, // S_BOSS_RUN8
- {SPR_BOSS,4,8,{A_FaceTarget},S_BOSS_ATK2,0,0}, // S_BOSS_ATK1
- {SPR_BOSS,5,8,{A_FaceTarget},S_BOSS_ATK3,0,0}, // S_BOSS_ATK2
- {SPR_BOSS,6,8,{A_BruisAttack},S_BOSS_RUN1,0,0}, // S_BOSS_ATK3
- {SPR_BOSS,7,2,{NULL},S_BOSS_PAIN2,0,0}, // S_BOSS_PAIN
- {SPR_BOSS,7,2,{A_Pain},S_BOSS_RUN1,0,0}, // S_BOSS_PAIN2
- {SPR_BOSS,8,8,{NULL},S_BOSS_DIE2,0,0}, // S_BOSS_DIE1
- {SPR_BOSS,9,8,{A_Scream},S_BOSS_DIE3,0,0}, // S_BOSS_DIE2
- {SPR_BOSS,10,8,{NULL},S_BOSS_DIE4,0,0}, // S_BOSS_DIE3
- {SPR_BOSS,11,8,{A_Fall},S_BOSS_DIE5,0,0}, // S_BOSS_DIE4
- {SPR_BOSS,12,8,{NULL},S_BOSS_DIE6,0,0}, // S_BOSS_DIE5
- {SPR_BOSS,13,8,{NULL},S_BOSS_DIE7,0,0}, // S_BOSS_DIE6
- {SPR_BOSS,14,-1,{A_BossDeath},S_NULL,0,0}, // S_BOSS_DIE7
- {SPR_BOSS,14,8,{NULL},S_BOSS_RAISE2,0,0}, // S_BOSS_RAISE1
- {SPR_BOSS,13,8,{NULL},S_BOSS_RAISE3,0,0}, // S_BOSS_RAISE2
- {SPR_BOSS,12,8,{NULL},S_BOSS_RAISE4,0,0}, // S_BOSS_RAISE3
- {SPR_BOSS,11,8,{NULL},S_BOSS_RAISE5,0,0}, // S_BOSS_RAISE4
- {SPR_BOSS,10,8,{NULL},S_BOSS_RAISE6,0,0}, // S_BOSS_RAISE5
- {SPR_BOSS,9,8,{NULL},S_BOSS_RAISE7,0,0}, // S_BOSS_RAISE6
- {SPR_BOSS,8,8,{NULL},S_BOSS_RUN1,0,0}, // S_BOSS_RAISE7
- {SPR_BOS2,0,10,{A_Look},S_BOS2_STND2,0,0}, // S_BOS2_STND
- {SPR_BOS2,1,10,{A_Look},S_BOS2_STND,0,0}, // S_BOS2_STND2
- {SPR_BOS2,0,3,{A_Chase},S_BOS2_RUN2,0,0}, // S_BOS2_RUN1
- {SPR_BOS2,0,3,{A_Chase},S_BOS2_RUN3,0,0}, // S_BOS2_RUN2
- {SPR_BOS2,1,3,{A_Chase},S_BOS2_RUN4,0,0}, // S_BOS2_RUN3
- {SPR_BOS2,1,3,{A_Chase},S_BOS2_RUN5,0,0}, // S_BOS2_RUN4
- {SPR_BOS2,2,3,{A_Chase},S_BOS2_RUN6,0,0}, // S_BOS2_RUN5
- {SPR_BOS2,2,3,{A_Chase},S_BOS2_RUN7,0,0}, // S_BOS2_RUN6
- {SPR_BOS2,3,3,{A_Chase},S_BOS2_RUN8,0,0}, // S_BOS2_RUN7
- {SPR_BOS2,3,3,{A_Chase},S_BOS2_RUN1,0,0}, // S_BOS2_RUN8
- {SPR_BOS2,4,8,{A_FaceTarget},S_BOS2_ATK2,0,0}, // S_BOS2_ATK1
- {SPR_BOS2,5,8,{A_FaceTarget},S_BOS2_ATK3,0,0}, // S_BOS2_ATK2
- {SPR_BOS2,6,8,{A_BruisAttack},S_BOS2_RUN1,0,0}, // S_BOS2_ATK3
- {SPR_BOS2,7,2,{NULL},S_BOS2_PAIN2,0,0}, // S_BOS2_PAIN
- {SPR_BOS2,7,2,{A_Pain},S_BOS2_RUN1,0,0}, // S_BOS2_PAIN2
- {SPR_BOS2,8,8,{NULL},S_BOS2_DIE2,0,0}, // S_BOS2_DIE1
- {SPR_BOS2,9,8,{A_Scream},S_BOS2_DIE3,0,0}, // S_BOS2_DIE2
- {SPR_BOS2,10,8,{NULL},S_BOS2_DIE4,0,0}, // S_BOS2_DIE3
- {SPR_BOS2,11,8,{A_Fall},S_BOS2_DIE5,0,0}, // S_BOS2_DIE4
- {SPR_BOS2,12,8,{NULL},S_BOS2_DIE6,0,0}, // S_BOS2_DIE5
- {SPR_BOS2,13,8,{NULL},S_BOS2_DIE7,0,0}, // S_BOS2_DIE6
- {SPR_BOS2,14,-1,{NULL},S_NULL,0,0}, // S_BOS2_DIE7
- {SPR_BOS2,14,8,{NULL},S_BOS2_RAISE2,0,0}, // S_BOS2_RAISE1
- {SPR_BOS2,13,8,{NULL},S_BOS2_RAISE3,0,0}, // S_BOS2_RAISE2
- {SPR_BOS2,12,8,{NULL},S_BOS2_RAISE4,0,0}, // S_BOS2_RAISE3
- {SPR_BOS2,11,8,{NULL},S_BOS2_RAISE5,0,0}, // S_BOS2_RAISE4
- {SPR_BOS2,10,8,{NULL},S_BOS2_RAISE6,0,0}, // S_BOS2_RAISE5
- {SPR_BOS2,9,8,{NULL},S_BOS2_RAISE7,0,0}, // S_BOS2_RAISE6
- {SPR_BOS2,8,8,{NULL},S_BOS2_RUN1,0,0}, // S_BOS2_RAISE7
- {SPR_SKUL,32768,10,{A_Look},S_SKULL_STND2,0,0}, // S_SKULL_STND
- {SPR_SKUL,32769,10,{A_Look},S_SKULL_STND,0,0}, // S_SKULL_STND2
- {SPR_SKUL,32768,6,{A_Chase},S_SKULL_RUN2,0,0}, // S_SKULL_RUN1
- {SPR_SKUL,32769,6,{A_Chase},S_SKULL_RUN1,0,0}, // S_SKULL_RUN2
- {SPR_SKUL,32770,10,{A_FaceTarget},S_SKULL_ATK2,0,0}, // S_SKULL_ATK1
- {SPR_SKUL,32771,4,{A_SkullAttack},S_SKULL_ATK3,0,0}, // S_SKULL_ATK2
- {SPR_SKUL,32770,4,{NULL},S_SKULL_ATK4,0,0}, // S_SKULL_ATK3
- {SPR_SKUL,32771,4,{NULL},S_SKULL_ATK3,0,0}, // S_SKULL_ATK4
- {SPR_SKUL,32772,3,{NULL},S_SKULL_PAIN2,0,0}, // S_SKULL_PAIN
- {SPR_SKUL,32772,3,{A_Pain},S_SKULL_RUN1,0,0}, // S_SKULL_PAIN2
- {SPR_SKUL,32773,6,{NULL},S_SKULL_DIE2,0,0}, // S_SKULL_DIE1
- {SPR_SKUL,32774,6,{A_Scream},S_SKULL_DIE3,0,0}, // S_SKULL_DIE2
- {SPR_SKUL,32775,6,{NULL},S_SKULL_DIE4,0,0}, // S_SKULL_DIE3
- {SPR_SKUL,32776,6,{A_Fall},S_SKULL_DIE5,0,0}, // S_SKULL_DIE4
- {SPR_SKUL,9,6,{NULL},S_SKULL_DIE6,0,0}, // S_SKULL_DIE5
- {SPR_SKUL,10,6,{NULL},S_NULL,0,0}, // S_SKULL_DIE6
- {SPR_SPID,0,10,{A_Look},S_SPID_STND2,0,0}, // S_SPID_STND
- {SPR_SPID,1,10,{A_Look},S_SPID_STND,0,0}, // S_SPID_STND2
- {SPR_SPID,0,3,{A_Metal},S_SPID_RUN2,0,0}, // S_SPID_RUN1
- {SPR_SPID,0,3,{A_Chase},S_SPID_RUN3,0,0}, // S_SPID_RUN2
- {SPR_SPID,1,3,{A_Chase},S_SPID_RUN4,0,0}, // S_SPID_RUN3
- {SPR_SPID,1,3,{A_Chase},S_SPID_RUN5,0,0}, // S_SPID_RUN4
- {SPR_SPID,2,3,{A_Metal},S_SPID_RUN6,0,0}, // S_SPID_RUN5
- {SPR_SPID,2,3,{A_Chase},S_SPID_RUN7,0,0}, // S_SPID_RUN6
- {SPR_SPID,3,3,{A_Chase},S_SPID_RUN8,0,0}, // S_SPID_RUN7
- {SPR_SPID,3,3,{A_Chase},S_SPID_RUN9,0,0}, // S_SPID_RUN8
- {SPR_SPID,4,3,{A_Metal},S_SPID_RUN10,0,0}, // S_SPID_RUN9
- {SPR_SPID,4,3,{A_Chase},S_SPID_RUN11,0,0}, // S_SPID_RUN10
- {SPR_SPID,5,3,{A_Chase},S_SPID_RUN12,0,0}, // S_SPID_RUN11
- {SPR_SPID,5,3,{A_Chase},S_SPID_RUN1,0,0}, // S_SPID_RUN12
- {SPR_SPID,32768,20,{A_FaceTarget},S_SPID_ATK2,0,0}, // S_SPID_ATK1
- {SPR_SPID,32774,4,{A_SPosAttack},S_SPID_ATK3,0,0}, // S_SPID_ATK2
- {SPR_SPID,32775,4,{A_SPosAttack},S_SPID_ATK4,0,0}, // S_SPID_ATK3
- {SPR_SPID,32775,1,{A_SpidRefire},S_SPID_ATK2,0,0}, // S_SPID_ATK4
- {SPR_SPID,8,3,{NULL},S_SPID_PAIN2,0,0}, // S_SPID_PAIN
- {SPR_SPID,8,3,{A_Pain},S_SPID_RUN1,0,0}, // S_SPID_PAIN2
- {SPR_SPID,9,20,{A_Scream},S_SPID_DIE2,0,0}, // S_SPID_DIE1
- {SPR_SPID,10,10,{A_Fall},S_SPID_DIE3,0,0}, // S_SPID_DIE2
- {SPR_SPID,11,10,{NULL},S_SPID_DIE4,0,0}, // S_SPID_DIE3
- {SPR_SPID,12,10,{NULL},S_SPID_DIE5,0,0}, // S_SPID_DIE4
- {SPR_SPID,13,10,{NULL},S_SPID_DIE6,0,0}, // S_SPID_DIE5
- {SPR_SPID,14,10,{NULL},S_SPID_DIE7,0,0}, // S_SPID_DIE6
- {SPR_SPID,15,10,{NULL},S_SPID_DIE8,0,0}, // S_SPID_DIE7
- {SPR_SPID,16,10,{NULL},S_SPID_DIE9,0,0}, // S_SPID_DIE8
- {SPR_SPID,17,10,{NULL},S_SPID_DIE10,0,0}, // S_SPID_DIE9
- {SPR_SPID,18,30,{NULL},S_SPID_DIE11,0,0}, // S_SPID_DIE10
- {SPR_SPID,18,-1,{A_BossDeath},S_NULL,0,0}, // S_SPID_DIE11
- {SPR_BSPI,0,10,{A_Look},S_BSPI_STND2,0,0}, // S_BSPI_STND
- {SPR_BSPI,1,10,{A_Look},S_BSPI_STND,0,0}, // S_BSPI_STND2
- {SPR_BSPI,0,20,{NULL},S_BSPI_RUN1,0,0}, // S_BSPI_SIGHT
- {SPR_BSPI,0,3,{A_BabyMetal},S_BSPI_RUN2,0,0}, // S_BSPI_RUN1
- {SPR_BSPI,0,3,{A_Chase},S_BSPI_RUN3,0,0}, // S_BSPI_RUN2
- {SPR_BSPI,1,3,{A_Chase},S_BSPI_RUN4,0,0}, // S_BSPI_RUN3
- {SPR_BSPI,1,3,{A_Chase},S_BSPI_RUN5,0,0}, // S_BSPI_RUN4
- {SPR_BSPI,2,3,{A_Chase},S_BSPI_RUN6,0,0}, // S_BSPI_RUN5
- {SPR_BSPI,2,3,{A_Chase},S_BSPI_RUN7,0,0}, // S_BSPI_RUN6
- {SPR_BSPI,3,3,{A_BabyMetal},S_BSPI_RUN8,0,0}, // S_BSPI_RUN7
- {SPR_BSPI,3,3,{A_Chase},S_BSPI_RUN9,0,0}, // S_BSPI_RUN8
- {SPR_BSPI,4,3,{A_Chase},S_BSPI_RUN10,0,0}, // S_BSPI_RUN9
- {SPR_BSPI,4,3,{A_Chase},S_BSPI_RUN11,0,0}, // S_BSPI_RUN10
- {SPR_BSPI,5,3,{A_Chase},S_BSPI_RUN12,0,0}, // S_BSPI_RUN11
- {SPR_BSPI,5,3,{A_Chase},S_BSPI_RUN1,0,0}, // S_BSPI_RUN12
- {SPR_BSPI,32768,20,{A_FaceTarget},S_BSPI_ATK2,0,0}, // S_BSPI_ATK1
- {SPR_BSPI,32774,4,{A_BspiAttack},S_BSPI_ATK3,0,0}, // S_BSPI_ATK2
- {SPR_BSPI,32775,4,{NULL},S_BSPI_ATK4,0,0}, // S_BSPI_ATK3
- {SPR_BSPI,32775,1,{A_SpidRefire},S_BSPI_ATK2,0,0}, // S_BSPI_ATK4
- {SPR_BSPI,8,3,{NULL},S_BSPI_PAIN2,0,0}, // S_BSPI_PAIN
- {SPR_BSPI,8,3,{A_Pain},S_BSPI_RUN1,0,0}, // S_BSPI_PAIN2
- {SPR_BSPI,9,20,{A_Scream},S_BSPI_DIE2,0,0}, // S_BSPI_DIE1
- {SPR_BSPI,10,7,{A_Fall},S_BSPI_DIE3,0,0}, // S_BSPI_DIE2
- {SPR_BSPI,11,7,{NULL},S_BSPI_DIE4,0,0}, // S_BSPI_DIE3
- {SPR_BSPI,12,7,{NULL},S_BSPI_DIE5,0,0}, // S_BSPI_DIE4
- {SPR_BSPI,13,7,{NULL},S_BSPI_DIE6,0,0}, // S_BSPI_DIE5
- {SPR_BSPI,14,7,{NULL},S_BSPI_DIE7,0,0}, // S_BSPI_DIE6
- {SPR_BSPI,15,-1,{A_BossDeath},S_NULL,0,0}, // S_BSPI_DIE7
- {SPR_BSPI,15,5,{NULL},S_BSPI_RAISE2,0,0}, // S_BSPI_RAISE1
- {SPR_BSPI,14,5,{NULL},S_BSPI_RAISE3,0,0}, // S_BSPI_RAISE2
- {SPR_BSPI,13,5,{NULL},S_BSPI_RAISE4,0,0}, // S_BSPI_RAISE3
- {SPR_BSPI,12,5,{NULL},S_BSPI_RAISE5,0,0}, // S_BSPI_RAISE4
- {SPR_BSPI,11,5,{NULL},S_BSPI_RAISE6,0,0}, // S_BSPI_RAISE5
- {SPR_BSPI,10,5,{NULL},S_BSPI_RAISE7,0,0}, // S_BSPI_RAISE6
- {SPR_BSPI,9,5,{NULL},S_BSPI_RUN1,0,0}, // S_BSPI_RAISE7
- {SPR_APLS,32768,5,{NULL},S_ARACH_PLAZ2,0,0}, // S_ARACH_PLAZ
- {SPR_APLS,32769,5,{NULL},S_ARACH_PLAZ,0,0}, // S_ARACH_PLAZ2
- {SPR_APBX,32768,5,{NULL},S_ARACH_PLEX2,0,0}, // S_ARACH_PLEX
- {SPR_APBX,32769,5,{NULL},S_ARACH_PLEX3,0,0}, // S_ARACH_PLEX2
- {SPR_APBX,32770,5,{NULL},S_ARACH_PLEX4,0,0}, // S_ARACH_PLEX3
- {SPR_APBX,32771,5,{NULL},S_ARACH_PLEX5,0,0}, // S_ARACH_PLEX4
- {SPR_APBX,32772,5,{NULL},S_NULL,0,0}, // S_ARACH_PLEX5
- {SPR_CYBR,0,10,{A_Look},S_CYBER_STND2,0,0}, // S_CYBER_STND
- {SPR_CYBR,1,10,{A_Look},S_CYBER_STND,0,0}, // S_CYBER_STND2
- {SPR_CYBR,0,3,{A_Hoof},S_CYBER_RUN2,0,0}, // S_CYBER_RUN1
- {SPR_CYBR,0,3,{A_Chase},S_CYBER_RUN3,0,0}, // S_CYBER_RUN2
- {SPR_CYBR,1,3,{A_Chase},S_CYBER_RUN4,0,0}, // S_CYBER_RUN3
- {SPR_CYBR,1,3,{A_Chase},S_CYBER_RUN5,0,0}, // S_CYBER_RUN4
- {SPR_CYBR,2,3,{A_Chase},S_CYBER_RUN6,0,0}, // S_CYBER_RUN5
- {SPR_CYBR,2,3,{A_Chase},S_CYBER_RUN7,0,0}, // S_CYBER_RUN6
- {SPR_CYBR,3,3,{A_Metal},S_CYBER_RUN8,0,0}, // S_CYBER_RUN7
- {SPR_CYBR,3,3,{A_Chase},S_CYBER_RUN1,0,0}, // S_CYBER_RUN8
- {SPR_CYBR,4,6,{A_FaceTarget},S_CYBER_ATK2,0,0}, // S_CYBER_ATK1
- {SPR_CYBR,5,12,{A_CyberAttack},S_CYBER_ATK3,0,0}, // S_CYBER_ATK2
- {SPR_CYBR,4,12,{A_FaceTarget},S_CYBER_ATK4,0,0}, // S_CYBER_ATK3
- {SPR_CYBR,5,12,{A_CyberAttack},S_CYBER_ATK5,0,0}, // S_CYBER_ATK4
- {SPR_CYBR,4,12,{A_FaceTarget},S_CYBER_ATK6,0,0}, // S_CYBER_ATK5
- {SPR_CYBR,5,12,{A_CyberAttack},S_CYBER_RUN1,0,0}, // S_CYBER_ATK6
- {SPR_CYBR,6,10,{A_Pain},S_CYBER_RUN1,0,0}, // S_CYBER_PAIN
- {SPR_CYBR,7,10,{NULL},S_CYBER_DIE2,0,0}, // S_CYBER_DIE1
- {SPR_CYBR,8,10,{A_Scream},S_CYBER_DIE3,0,0}, // S_CYBER_DIE2
- {SPR_CYBR,9,10,{NULL},S_CYBER_DIE4,0,0}, // S_CYBER_DIE3
- {SPR_CYBR,10,10,{NULL},S_CYBER_DIE5,0,0}, // S_CYBER_DIE4
- {SPR_CYBR,11,10,{NULL},S_CYBER_DIE6,0,0}, // S_CYBER_DIE5
- {SPR_CYBR,12,10,{A_Fall},S_CYBER_DIE7,0,0}, // S_CYBER_DIE6
- {SPR_CYBR,13,10,{NULL},S_CYBER_DIE8,0,0}, // S_CYBER_DIE7
- {SPR_CYBR,14,10,{NULL},S_CYBER_DIE9,0,0}, // S_CYBER_DIE8
- {SPR_CYBR,15,30,{NULL},S_CYBER_DIE10,0,0}, // S_CYBER_DIE9
- {SPR_CYBR,15,-1,{A_BossDeath},S_NULL,0,0}, // S_CYBER_DIE10
- {SPR_PAIN,0,10,{A_Look},S_PAIN_STND,0,0}, // S_PAIN_STND
- {SPR_PAIN,0,3,{A_Chase},S_PAIN_RUN2,0,0}, // S_PAIN_RUN1
- {SPR_PAIN,0,3,{A_Chase},S_PAIN_RUN3,0,0}, // S_PAIN_RUN2
- {SPR_PAIN,1,3,{A_Chase},S_PAIN_RUN4,0,0}, // S_PAIN_RUN3
- {SPR_PAIN,1,3,{A_Chase},S_PAIN_RUN5,0,0}, // S_PAIN_RUN4
- {SPR_PAIN,2,3,{A_Chase},S_PAIN_RUN6,0,0}, // S_PAIN_RUN5
- {SPR_PAIN,2,3,{A_Chase},S_PAIN_RUN1,0,0}, // S_PAIN_RUN6
- {SPR_PAIN,3,5,{A_FaceTarget},S_PAIN_ATK2,0,0}, // S_PAIN_ATK1
- {SPR_PAIN,4,5,{A_FaceTarget},S_PAIN_ATK3,0,0}, // S_PAIN_ATK2
- {SPR_PAIN,32773,5,{A_FaceTarget},S_PAIN_ATK4,0,0}, // S_PAIN_ATK3
- {SPR_PAIN,32773,0,{A_PainAttack},S_PAIN_RUN1,0,0}, // S_PAIN_ATK4
- {SPR_PAIN,6,6,{NULL},S_PAIN_PAIN2,0,0}, // S_PAIN_PAIN
- {SPR_PAIN,6,6,{A_Pain},S_PAIN_RUN1,0,0}, // S_PAIN_PAIN2
- {SPR_PAIN,32775,8,{NULL},S_PAIN_DIE2,0,0}, // S_PAIN_DIE1
- {SPR_PAIN,32776,8,{A_Scream},S_PAIN_DIE3,0,0}, // S_PAIN_DIE2
- {SPR_PAIN,32777,8,{NULL},S_PAIN_DIE4,0,0}, // S_PAIN_DIE3
- {SPR_PAIN,32778,8,{NULL},S_PAIN_DIE5,0,0}, // S_PAIN_DIE4
- {SPR_PAIN,32779,8,{A_PainDie},S_PAIN_DIE6,0,0}, // S_PAIN_DIE5
- {SPR_PAIN,32780,8,{NULL},S_NULL,0,0}, // S_PAIN_DIE6
- {SPR_PAIN,12,8,{NULL},S_PAIN_RAISE2,0,0}, // S_PAIN_RAISE1
- {SPR_PAIN,11,8,{NULL},S_PAIN_RAISE3,0,0}, // S_PAIN_RAISE2
- {SPR_PAIN,10,8,{NULL},S_PAIN_RAISE4,0,0}, // S_PAIN_RAISE3
- {SPR_PAIN,9,8,{NULL},S_PAIN_RAISE5,0,0}, // S_PAIN_RAISE4
- {SPR_PAIN,8,8,{NULL},S_PAIN_RAISE6,0,0}, // S_PAIN_RAISE5
- {SPR_PAIN,7,8,{NULL},S_PAIN_RUN1,0,0}, // S_PAIN_RAISE6
- {SPR_SSWV,0,10,{A_Look},S_SSWV_STND2,0,0}, // S_SSWV_STND
- {SPR_SSWV,1,10,{A_Look},S_SSWV_STND,0,0}, // S_SSWV_STND2
- {SPR_SSWV,0,3,{A_Chase},S_SSWV_RUN2,0,0}, // S_SSWV_RUN1
- {SPR_SSWV,0,3,{A_Chase},S_SSWV_RUN3,0,0}, // S_SSWV_RUN2
- {SPR_SSWV,1,3,{A_Chase},S_SSWV_RUN4,0,0}, // S_SSWV_RUN3
- {SPR_SSWV,1,3,{A_Chase},S_SSWV_RUN5,0,0}, // S_SSWV_RUN4
- {SPR_SSWV,2,3,{A_Chase},S_SSWV_RUN6,0,0}, // S_SSWV_RUN5
- {SPR_SSWV,2,3,{A_Chase},S_SSWV_RUN7,0,0}, // S_SSWV_RUN6
- {SPR_SSWV,3,3,{A_Chase},S_SSWV_RUN8,0,0}, // S_SSWV_RUN7
- {SPR_SSWV,3,3,{A_Chase},S_SSWV_RUN1,0,0}, // S_SSWV_RUN8
- {SPR_SSWV,4,10,{A_FaceTarget},S_SSWV_ATK2,0,0}, // S_SSWV_ATK1
- {SPR_SSWV,5,10,{A_FaceTarget},S_SSWV_ATK3,0,0}, // S_SSWV_ATK2
- {SPR_SSWV,32774,4,{A_CPosAttack},S_SSWV_ATK4,0,0}, // S_SSWV_ATK3
- {SPR_SSWV,5,6,{A_FaceTarget},S_SSWV_ATK5,0,0}, // S_SSWV_ATK4
- {SPR_SSWV,32774,4,{A_CPosAttack},S_SSWV_ATK6,0,0}, // S_SSWV_ATK5
- {SPR_SSWV,5,1,{A_CPosRefire},S_SSWV_ATK2,0,0}, // S_SSWV_ATK6
- {SPR_SSWV,7,3,{NULL},S_SSWV_PAIN2,0,0}, // S_SSWV_PAIN
- {SPR_SSWV,7,3,{A_Pain},S_SSWV_RUN1,0,0}, // S_SSWV_PAIN2
- {SPR_SSWV,8,5,{NULL},S_SSWV_DIE2,0,0}, // S_SSWV_DIE1
- {SPR_SSWV,9,5,{A_Scream},S_SSWV_DIE3,0,0}, // S_SSWV_DIE2
- {SPR_SSWV,10,5,{A_Fall},S_SSWV_DIE4,0,0}, // S_SSWV_DIE3
- {SPR_SSWV,11,5,{NULL},S_SSWV_DIE5,0,0}, // S_SSWV_DIE4
- {SPR_SSWV,12,-1,{NULL},S_NULL,0,0}, // S_SSWV_DIE5
- {SPR_SSWV,13,5,{NULL},S_SSWV_XDIE2,0,0}, // S_SSWV_XDIE1
- {SPR_SSWV,14,5,{A_XScream},S_SSWV_XDIE3,0,0}, // S_SSWV_XDIE2
- {SPR_SSWV,15,5,{A_Fall},S_SSWV_XDIE4,0,0}, // S_SSWV_XDIE3
- {SPR_SSWV,16,5,{NULL},S_SSWV_XDIE5,0,0}, // S_SSWV_XDIE4
- {SPR_SSWV,17,5,{NULL},S_SSWV_XDIE6,0,0}, // S_SSWV_XDIE5
- {SPR_SSWV,18,5,{NULL},S_SSWV_XDIE7,0,0}, // S_SSWV_XDIE6
- {SPR_SSWV,19,5,{NULL},S_SSWV_XDIE8,0,0}, // S_SSWV_XDIE7
- {SPR_SSWV,20,5,{NULL},S_SSWV_XDIE9,0,0}, // S_SSWV_XDIE8
- {SPR_SSWV,21,-1,{NULL},S_NULL,0,0}, // S_SSWV_XDIE9
- {SPR_SSWV,12,5,{NULL},S_SSWV_RAISE2,0,0}, // S_SSWV_RAISE1
- {SPR_SSWV,11,5,{NULL},S_SSWV_RAISE3,0,0}, // S_SSWV_RAISE2
- {SPR_SSWV,10,5,{NULL},S_SSWV_RAISE4,0,0}, // S_SSWV_RAISE3
- {SPR_SSWV,9,5,{NULL},S_SSWV_RAISE5,0,0}, // S_SSWV_RAISE4
- {SPR_SSWV,8,5,{NULL},S_SSWV_RUN1,0,0}, // S_SSWV_RAISE5
- {SPR_KEEN,0,-1,{NULL},S_KEENSTND,0,0}, // S_KEENSTND
- {SPR_KEEN,0,6,{NULL},S_COMMKEEN2,0,0}, // S_COMMKEEN
- {SPR_KEEN,1,6,{NULL},S_COMMKEEN3,0,0}, // S_COMMKEEN2
- {SPR_KEEN,2,6,{A_Scream},S_COMMKEEN4,0,0}, // S_COMMKEEN3
- {SPR_KEEN,3,6,{NULL},S_COMMKEEN5,0,0}, // S_COMMKEEN4
- {SPR_KEEN,4,6,{NULL},S_COMMKEEN6,0,0}, // S_COMMKEEN5
- {SPR_KEEN,5,6,{NULL},S_COMMKEEN7,0,0}, // S_COMMKEEN6
- {SPR_KEEN,6,6,{NULL},S_COMMKEEN8,0,0}, // S_COMMKEEN7
- {SPR_KEEN,7,6,{NULL},S_COMMKEEN9,0,0}, // S_COMMKEEN8
- {SPR_KEEN,8,6,{NULL},S_COMMKEEN10,0,0}, // S_COMMKEEN9
- {SPR_KEEN,9,6,{NULL},S_COMMKEEN11,0,0}, // S_COMMKEEN10
- {SPR_KEEN,10,6,{A_KeenDie},S_COMMKEEN12,0,0},// S_COMMKEEN11
- {SPR_KEEN,11,-1,{NULL},S_NULL,0,0}, // S_COMMKEEN12
- {SPR_KEEN,12,4,{NULL},S_KEENPAIN2,0,0}, // S_KEENPAIN
- {SPR_KEEN,12,8,{A_Pain},S_KEENSTND,0,0}, // S_KEENPAIN2
- {SPR_BBRN,0,-1,{NULL},S_NULL,0,0}, // S_BRAIN
- {SPR_BBRN,1,36,{A_BrainPain},S_BRAIN,0,0}, // S_BRAIN_PAIN
- {SPR_BBRN,0,100,{A_BrainScream},S_BRAIN_DIE2,0,0}, // S_BRAIN_DIE1
- {SPR_BBRN,0,10,{NULL},S_BRAIN_DIE3,0,0}, // S_BRAIN_DIE2
- {SPR_BBRN,0,10,{NULL},S_BRAIN_DIE4,0,0}, // S_BRAIN_DIE3
- {SPR_BBRN,0,-1,{A_BrainDie},S_NULL,0,0}, // S_BRAIN_DIE4
- {SPR_SSWV,0,10,{A_Look},S_BRAINEYE,0,0}, // S_BRAINEYE
- {SPR_SSWV,0,181,{A_BrainAwake},S_BRAINEYE1,0,0}, // S_BRAINEYESEE
- {SPR_SSWV,0,150,{A_BrainSpit},S_BRAINEYE1,0,0}, // S_BRAINEYE1
- {SPR_BOSF,32768,3,{A_SpawnSound},S_SPAWN2,0,0}, // S_SPAWN1
- {SPR_BOSF,32769,3,{A_SpawnFly},S_SPAWN3,0,0}, // S_SPAWN2
- {SPR_BOSF,32770,3,{A_SpawnFly},S_SPAWN4,0,0}, // S_SPAWN3
- {SPR_BOSF,32771,3,{A_SpawnFly},S_SPAWN1,0,0}, // S_SPAWN4
- {SPR_FIRE,32768,4,{A_Fire},S_SPAWNFIRE2,0,0}, // S_SPAWNFIRE1
- {SPR_FIRE,32769,4,{A_Fire},S_SPAWNFIRE3,0,0}, // S_SPAWNFIRE2
- {SPR_FIRE,32770,4,{A_Fire},S_SPAWNFIRE4,0,0}, // S_SPAWNFIRE3
- {SPR_FIRE,32771,4,{A_Fire},S_SPAWNFIRE5,0,0}, // S_SPAWNFIRE4
- {SPR_FIRE,32772,4,{A_Fire},S_SPAWNFIRE6,0,0}, // S_SPAWNFIRE5
- {SPR_FIRE,32773,4,{A_Fire},S_SPAWNFIRE7,0,0}, // S_SPAWNFIRE6
- {SPR_FIRE,32774,4,{A_Fire},S_SPAWNFIRE8,0,0}, // S_SPAWNFIRE7
- {SPR_FIRE,32775,4,{A_Fire},S_NULL,0,0}, // S_SPAWNFIRE8
- {SPR_MISL,32769,10,{NULL},S_BRAINEXPLODE2,0,0}, // S_BRAINEXPLODE1
- {SPR_MISL,32770,10,{NULL},S_BRAINEXPLODE3,0,0}, // S_BRAINEXPLODE2
- {SPR_MISL,32771,10,{A_BrainExplode},S_NULL,0,0}, // S_BRAINEXPLODE3
- {SPR_ARM1,0,6,{NULL},S_ARM1A,0,0}, // S_ARM1
- {SPR_ARM1,32769,7,{NULL},S_ARM1,0,0}, // S_ARM1A
- {SPR_ARM2,0,6,{NULL},S_ARM2A,0,0}, // S_ARM2
- {SPR_ARM2,32769,6,{NULL},S_ARM2,0,0}, // S_ARM2A
- {SPR_BAR1,0,6,{NULL},S_BAR2,0,0}, // S_BAR1
- {SPR_BAR1,1,6,{NULL},S_BAR1,0,0}, // S_BAR2
- {SPR_BEXP,32768,5,{NULL},S_BEXP2,0,0}, // S_BEXP
- {SPR_BEXP,32769,5,{A_Scream},S_BEXP3,0,0}, // S_BEXP2
- {SPR_BEXP,32770,5,{NULL},S_BEXP4,0,0}, // S_BEXP3
- {SPR_BEXP,32771,10,{A_Explode},S_BEXP5,0,0}, // S_BEXP4
- {SPR_BEXP,32772,10,{NULL},S_NULL,0,0}, // S_BEXP5
- {SPR_FCAN,32768,4,{NULL},S_BBAR2,0,0}, // S_BBAR1
- {SPR_FCAN,32769,4,{NULL},S_BBAR3,0,0}, // S_BBAR2
- {SPR_FCAN,32770,4,{NULL},S_BBAR1,0,0}, // S_BBAR3
- {SPR_BON1,0,6,{NULL},S_BON1A,0,0}, // S_BON1
- {SPR_BON1,1,6,{NULL},S_BON1B,0,0}, // S_BON1A
- {SPR_BON1,2,6,{NULL},S_BON1C,0,0}, // S_BON1B
- {SPR_BON1,3,6,{NULL},S_BON1D,0,0}, // S_BON1C
- {SPR_BON1,2,6,{NULL},S_BON1E,0,0}, // S_BON1D
- {SPR_BON1,1,6,{NULL},S_BON1,0,0}, // S_BON1E
- {SPR_BON2,0,6,{NULL},S_BON2A,0,0}, // S_BON2
- {SPR_BON2,1,6,{NULL},S_BON2B,0,0}, // S_BON2A
- {SPR_BON2,2,6,{NULL},S_BON2C,0,0}, // S_BON2B
- {SPR_BON2,3,6,{NULL},S_BON2D,0,0}, // S_BON2C
- {SPR_BON2,2,6,{NULL},S_BON2E,0,0}, // S_BON2D
- {SPR_BON2,1,6,{NULL},S_BON2,0,0}, // S_BON2E
- {SPR_BKEY,0,10,{NULL},S_BKEY2,0,0}, // S_BKEY
- {SPR_BKEY,32769,10,{NULL},S_BKEY,0,0}, // S_BKEY2
- {SPR_RKEY,0,10,{NULL},S_RKEY2,0,0}, // S_RKEY
- {SPR_RKEY,32769,10,{NULL},S_RKEY,0,0}, // S_RKEY2
- {SPR_YKEY,0,10,{NULL},S_YKEY2,0,0}, // S_YKEY
- {SPR_YKEY,32769,10,{NULL},S_YKEY,0,0}, // S_YKEY2
- {SPR_BSKU,0,10,{NULL},S_BSKULL2,0,0}, // S_BSKULL
- {SPR_BSKU,32769,10,{NULL},S_BSKULL,0,0}, // S_BSKULL2
- {SPR_RSKU,0,10,{NULL},S_RSKULL2,0,0}, // S_RSKULL
- {SPR_RSKU,32769,10,{NULL},S_RSKULL,0,0}, // S_RSKULL2
- {SPR_YSKU,0,10,{NULL},S_YSKULL2,0,0}, // S_YSKULL
- {SPR_YSKU,32769,10,{NULL},S_YSKULL,0,0}, // S_YSKULL2
- {SPR_STIM,0,-1,{NULL},S_NULL,0,0}, // S_STIM
- {SPR_MEDI,0,-1,{NULL},S_NULL,0,0}, // S_MEDI
- {SPR_SOUL,32768,6,{NULL},S_SOUL2,0,0}, // S_SOUL
- {SPR_SOUL,32769,6,{NULL},S_SOUL3,0,0}, // S_SOUL2
- {SPR_SOUL,32770,6,{NULL},S_SOUL4,0,0}, // S_SOUL3
- {SPR_SOUL,32771,6,{NULL},S_SOUL5,0,0}, // S_SOUL4
- {SPR_SOUL,32770,6,{NULL},S_SOUL6,0,0}, // S_SOUL5
- {SPR_SOUL,32769,6,{NULL},S_SOUL,0,0}, // S_SOUL6
- {SPR_PINV,32768,6,{NULL},S_PINV2,0,0}, // S_PINV
- {SPR_PINV,32769,6,{NULL},S_PINV3,0,0}, // S_PINV2
- {SPR_PINV,32770,6,{NULL},S_PINV4,0,0}, // S_PINV3
- {SPR_PINV,32771,6,{NULL},S_PINV,0,0}, // S_PINV4
- {SPR_PSTR,32768,-1,{NULL},S_NULL,0,0}, // S_PSTR
- {SPR_PINS,32768,6,{NULL},S_PINS2,0,0}, // S_PINS
- {SPR_PINS,32769,6,{NULL},S_PINS3,0,0}, // S_PINS2
- {SPR_PINS,32770,6,{NULL},S_PINS4,0,0}, // S_PINS3
- {SPR_PINS,32771,6,{NULL},S_PINS,0,0}, // S_PINS4
- {SPR_MEGA,32768,6,{NULL},S_MEGA2,0,0}, // S_MEGA
- {SPR_MEGA,32769,6,{NULL},S_MEGA3,0,0}, // S_MEGA2
- {SPR_MEGA,32770,6,{NULL},S_MEGA4,0,0}, // S_MEGA3
- {SPR_MEGA,32771,6,{NULL},S_MEGA,0,0}, // S_MEGA4
- {SPR_SUIT,32768,-1,{NULL},S_NULL,0,0}, // S_SUIT
- {SPR_PMAP,32768,6,{NULL},S_PMAP2,0,0}, // S_PMAP
- {SPR_PMAP,32769,6,{NULL},S_PMAP3,0,0}, // S_PMAP2
- {SPR_PMAP,32770,6,{NULL},S_PMAP4,0,0}, // S_PMAP3
- {SPR_PMAP,32771,6,{NULL},S_PMAP5,0,0}, // S_PMAP4
- {SPR_PMAP,32770,6,{NULL},S_PMAP6,0,0}, // S_PMAP5
- {SPR_PMAP,32769,6,{NULL},S_PMAP,0,0}, // S_PMAP6
- {SPR_PVIS,32768,6,{NULL},S_PVIS2,0,0}, // S_PVIS
- {SPR_PVIS,1,6,{NULL},S_PVIS,0,0}, // S_PVIS2
- {SPR_CLIP,0,-1,{NULL},S_NULL,0,0}, // S_CLIP
- {SPR_AMMO,0,-1,{NULL},S_NULL,0,0}, // S_AMMO
- {SPR_ROCK,0,-1,{NULL},S_NULL,0,0}, // S_ROCK
- {SPR_BROK,0,-1,{NULL},S_NULL,0,0}, // S_BROK
- {SPR_CELL,0,-1,{NULL},S_NULL,0,0}, // S_CELL
- {SPR_CELP,0,-1,{NULL},S_NULL,0,0}, // S_CELP
- {SPR_SHEL,0,-1,{NULL},S_NULL,0,0}, // S_SHEL
- {SPR_SBOX,0,-1,{NULL},S_NULL,0,0}, // S_SBOX
- {SPR_BPAK,0,-1,{NULL},S_NULL,0,0}, // S_BPAK
- {SPR_BFUG,0,-1,{NULL},S_NULL,0,0}, // S_BFUG
- {SPR_MGUN,0,-1,{NULL},S_NULL,0,0}, // S_MGUN
- {SPR_CSAW,0,-1,{NULL},S_NULL,0,0}, // S_CSAW
- {SPR_LAUN,0,-1,{NULL},S_NULL,0,0}, // S_LAUN
- {SPR_PLAS,0,-1,{NULL},S_NULL,0,0}, // S_PLAS
- {SPR_SHOT,0,-1,{NULL},S_NULL,0,0}, // S_SHOT
- {SPR_SGN2,0,-1,{NULL},S_NULL,0,0}, // S_SHOT2
- {SPR_COLU,32768,-1,{NULL},S_NULL,0,0}, // S_COLU
- {SPR_SMT2,0,-1,{NULL},S_NULL,0,0}, // S_STALAG
- {SPR_GOR1,0,10,{NULL},S_BLOODYTWITCH2,0,0}, // S_BLOODYTWITCH
- {SPR_GOR1,1,15,{NULL},S_BLOODYTWITCH3,0,0}, // S_BLOODYTWITCH2
- {SPR_GOR1,2,8,{NULL},S_BLOODYTWITCH4,0,0}, // S_BLOODYTWITCH3
- {SPR_GOR1,1,6,{NULL},S_BLOODYTWITCH,0,0}, // S_BLOODYTWITCH4
- {SPR_PLAY,13,-1,{NULL},S_NULL,0,0}, // S_DEADTORSO
- {SPR_PLAY,18,-1,{NULL},S_NULL,0,0}, // S_DEADBOTTOM
- {SPR_POL2,0,-1,{NULL},S_NULL,0,0}, // S_HEADSONSTICK
- {SPR_POL5,0,-1,{NULL},S_NULL,0,0}, // S_GIBS
- {SPR_POL4,0,-1,{NULL},S_NULL,0,0}, // S_HEADONASTICK
- {SPR_POL3,32768,6,{NULL},S_HEADCANDLES2,0,0}, // S_HEADCANDLES
- {SPR_POL3,32769,6,{NULL},S_HEADCANDLES,0,0}, // S_HEADCANDLES2
- {SPR_POL1,0,-1,{NULL},S_NULL,0,0}, // S_DEADSTICK
- {SPR_POL6,0,6,{NULL},S_LIVESTICK2,0,0}, // S_LIVESTICK
- {SPR_POL6,1,8,{NULL},S_LIVESTICK,0,0}, // S_LIVESTICK2
- {SPR_GOR2,0,-1,{NULL},S_NULL,0,0}, // S_MEAT2
- {SPR_GOR3,0,-1,{NULL},S_NULL,0,0}, // S_MEAT3
- {SPR_GOR4,0,-1,{NULL},S_NULL,0,0}, // S_MEAT4
- {SPR_GOR5,0,-1,{NULL},S_NULL,0,0}, // S_MEAT5
- {SPR_SMIT,0,-1,{NULL},S_NULL,0,0}, // S_STALAGTITE
- {SPR_COL1,0,-1,{NULL},S_NULL,0,0}, // S_TALLGRNCOL
- {SPR_COL2,0,-1,{NULL},S_NULL,0,0}, // S_SHRTGRNCOL
- {SPR_COL3,0,-1,{NULL},S_NULL,0,0}, // S_TALLREDCOL
- {SPR_COL4,0,-1,{NULL},S_NULL,0,0}, // S_SHRTREDCOL
- {SPR_CAND,32768,-1,{NULL},S_NULL,0,0}, // S_CANDLESTIK
- {SPR_CBRA,32768,-1,{NULL},S_NULL,0,0}, // S_CANDELABRA
- {SPR_COL6,0,-1,{NULL},S_NULL,0,0}, // S_SKULLCOL
- {SPR_TRE1,0,-1,{NULL},S_NULL,0,0}, // S_TORCHTREE
- {SPR_TRE2,0,-1,{NULL},S_NULL,0,0}, // S_BIGTREE
- {SPR_ELEC,0,-1,{NULL},S_NULL,0,0}, // S_TECHPILLAR
- {SPR_CEYE,32768,6,{NULL},S_EVILEYE2,0,0}, // S_EVILEYE
- {SPR_CEYE,32769,6,{NULL},S_EVILEYE3,0,0}, // S_EVILEYE2
- {SPR_CEYE,32770,6,{NULL},S_EVILEYE4,0,0}, // S_EVILEYE3
- {SPR_CEYE,32769,6,{NULL},S_EVILEYE,0,0}, // S_EVILEYE4
- {SPR_FSKU,32768,6,{NULL},S_FLOATSKULL2,0,0}, // S_FLOATSKULL
- {SPR_FSKU,32769,6,{NULL},S_FLOATSKULL3,0,0}, // S_FLOATSKULL2
- {SPR_FSKU,32770,6,{NULL},S_FLOATSKULL,0,0}, // S_FLOATSKULL3
- {SPR_COL5,0,14,{NULL},S_HEARTCOL2,0,0}, // S_HEARTCOL
- {SPR_COL5,1,14,{NULL},S_HEARTCOL,0,0}, // S_HEARTCOL2
- {SPR_TBLU,32768,4,{NULL},S_BLUETORCH2,0,0}, // S_BLUETORCH
- {SPR_TBLU,32769,4,{NULL},S_BLUETORCH3,0,0}, // S_BLUETORCH2
- {SPR_TBLU,32770,4,{NULL},S_BLUETORCH4,0,0}, // S_BLUETORCH3
- {SPR_TBLU,32771,4,{NULL},S_BLUETORCH,0,0}, // S_BLUETORCH4
- {SPR_TGRN,32768,4,{NULL},S_GREENTORCH2,0,0}, // S_GREENTORCH
- {SPR_TGRN,32769,4,{NULL},S_GREENTORCH3,0,0}, // S_GREENTORCH2
- {SPR_TGRN,32770,4,{NULL},S_GREENTORCH4,0,0}, // S_GREENTORCH3
- {SPR_TGRN,32771,4,{NULL},S_GREENTORCH,0,0}, // S_GREENTORCH4
- {SPR_TRED,32768,4,{NULL},S_REDTORCH2,0,0}, // S_REDTORCH
- {SPR_TRED,32769,4,{NULL},S_REDTORCH3,0,0}, // S_REDTORCH2
- {SPR_TRED,32770,4,{NULL},S_REDTORCH4,0,0}, // S_REDTORCH3
- {SPR_TRED,32771,4,{NULL},S_REDTORCH,0,0}, // S_REDTORCH4
- {SPR_SMBT,32768,4,{NULL},S_BTORCHSHRT2,0,0}, // S_BTORCHSHRT
- {SPR_SMBT,32769,4,{NULL},S_BTORCHSHRT3,0,0}, // S_BTORCHSHRT2
- {SPR_SMBT,32770,4,{NULL},S_BTORCHSHRT4,0,0}, // S_BTORCHSHRT3
- {SPR_SMBT,32771,4,{NULL},S_BTORCHSHRT,0,0}, // S_BTORCHSHRT4
- {SPR_SMGT,32768,4,{NULL},S_GTORCHSHRT2,0,0}, // S_GTORCHSHRT
- {SPR_SMGT,32769,4,{NULL},S_GTORCHSHRT3,0,0}, // S_GTORCHSHRT2
- {SPR_SMGT,32770,4,{NULL},S_GTORCHSHRT4,0,0}, // S_GTORCHSHRT3
- {SPR_SMGT,32771,4,{NULL},S_GTORCHSHRT,0,0}, // S_GTORCHSHRT4
- {SPR_SMRT,32768,4,{NULL},S_RTORCHSHRT2,0,0}, // S_RTORCHSHRT
- {SPR_SMRT,32769,4,{NULL},S_RTORCHSHRT3,0,0}, // S_RTORCHSHRT2
- {SPR_SMRT,32770,4,{NULL},S_RTORCHSHRT4,0,0}, // S_RTORCHSHRT3
- {SPR_SMRT,32771,4,{NULL},S_RTORCHSHRT,0,0}, // S_RTORCHSHRT4
- {SPR_HDB1,0,-1,{NULL},S_NULL,0,0}, // S_HANGNOGUTS
- {SPR_HDB2,0,-1,{NULL},S_NULL,0,0}, // S_HANGBNOBRAIN
- {SPR_HDB3,0,-1,{NULL},S_NULL,0,0}, // S_HANGTLOOKDN
- {SPR_HDB4,0,-1,{NULL},S_NULL,0,0}, // S_HANGTSKULL
- {SPR_HDB5,0,-1,{NULL},S_NULL,0,0}, // S_HANGTLOOKUP
- {SPR_HDB6,0,-1,{NULL},S_NULL,0,0}, // S_HANGTNOBRAIN
- {SPR_POB1,0,-1,{NULL},S_NULL,0,0}, // S_COLONGIBS
- {SPR_POB2,0,-1,{NULL},S_NULL,0,0}, // S_SMALLPOOL
- {SPR_BRS1,0,-1,{NULL},S_NULL,0,0}, // S_BRAINSTEM
- {SPR_TLMP,32768,4,{NULL},S_TECHLAMP2,0,0}, // S_TECHLAMP
- {SPR_TLMP,32769,4,{NULL},S_TECHLAMP3,0,0}, // S_TECHLAMP2
- {SPR_TLMP,32770,4,{NULL},S_TECHLAMP4,0,0}, // S_TECHLAMP3
- {SPR_TLMP,32771,4,{NULL},S_TECHLAMP,0,0}, // S_TECHLAMP4
- {SPR_TLP2,32768,4,{NULL},S_TECH2LAMP2,0,0}, // S_TECH2LAMP
- {SPR_TLP2,32769,4,{NULL},S_TECH2LAMP3,0,0}, // S_TECH2LAMP2
- {SPR_TLP2,32770,4,{NULL},S_TECH2LAMP4,0,0}, // S_TECH2LAMP3
- {SPR_TLP2,32771,4,{NULL},S_TECH2LAMP,0,0} // S_TECH2LAMP4
+ {SPR_TROO,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SHTG,4,0,{A_Light0},S_NULL,0,0},
+ {SPR_PUNG,0,1,{A_WeaponReady},S_PUNCH,0,0},
+ {SPR_PUNG,0,1,{A_Lower},S_PUNCHDOWN,0,0},
+ {SPR_PUNG,0,1,{A_Raise},S_PUNCHUP,0,0},
+ {SPR_PUNG,1,4,{NULL},S_PUNCH2,0,0},
+ {SPR_PUNG,2,4,{A_Punch},S_PUNCH3,0,0},
+ {SPR_PUNG,3,5,{NULL},S_PUNCH4,0,0},
+ {SPR_PUNG,2,4,{NULL},S_PUNCH5,0,0},
+ {SPR_PUNG,1,5,{A_ReFire},S_PUNCH,0,0},
+ {SPR_PISG,0,1,{A_WeaponReady},S_PISTOL,0,0},
+ {SPR_PISG,0,1,{A_Lower},S_PISTOLDOWN,0,0},
+ {SPR_PISG,0,1,{A_Raise},S_PISTOLUP,0,0},
+ {SPR_PISG,0,4,{NULL},S_PISTOL2,0,0},
+ {SPR_PISG,1,6,{A_FirePistol},S_PISTOL3,0,0},
+ {SPR_PISG,2,4,{NULL},S_PISTOL4,0,0},
+ {SPR_PISG,1,5,{A_ReFire},S_PISTOL,0,0},
+ {SPR_PISF,32768,7,{A_Light1},S_LIGHTDONE,0,0},
+ {SPR_SHTG,0,1,{A_WeaponReady},S_SGUN,0,0},
+ {SPR_SHTG,0,1,{A_Lower},S_SGUNDOWN,0,0},
+ {SPR_SHTG,0,1,{A_Raise},S_SGUNUP,0,0},
+ {SPR_SHTG,0,3,{NULL},S_SGUN2,0,0},
+ {SPR_SHTG,0,7,{A_FireShotgun},S_SGUN3,0,0},
+ {SPR_SHTG,1,5,{NULL},S_SGUN4,0,0},
+ {SPR_SHTG,2,5,{NULL},S_SGUN5,0,0},
+ {SPR_SHTG,3,4,{NULL},S_SGUN6,0,0},
+ {SPR_SHTG,2,5,{NULL},S_SGUN7,0,0},
+ {SPR_SHTG,1,5,{NULL},S_SGUN8,0,0},
+ {SPR_SHTG,0,3,{NULL},S_SGUN9,0,0},
+ {SPR_SHTG,0,7,{A_ReFire},S_SGUN,0,0},
+ {SPR_SHTF,32768,4,{A_Light1},S_SGUNFLASH2,0,0},
+ {SPR_SHTF,32769,3,{A_Light2},S_LIGHTDONE,0,0},
+ {SPR_SHT2,0,1,{A_WeaponReady},S_DSGUN,0,0},
+ {SPR_SHT2,0,1,{A_Lower},S_DSGUNDOWN,0,0},
+ {SPR_SHT2,0,1,{A_Raise},S_DSGUNUP,0,0},
+ {SPR_SHT2,0,3,{NULL},S_DSGUN2,0,0},
+ {SPR_SHT2,0,7,{A_FireShotgun2},S_DSGUN3,0,0},
+ {SPR_SHT2,1,7,{NULL},S_DSGUN4,0,0},
+ {SPR_SHT2,2,7,{A_CheckReload},S_DSGUN5,0,0},
+ {SPR_SHT2,3,7,{A_OpenShotgun2},S_DSGUN6,0,0},
+ {SPR_SHT2,4,7,{NULL},S_DSGUN7,0,0},
+ {SPR_SHT2,5,7,{A_LoadShotgun2},S_DSGUN8,0,0},
+ {SPR_SHT2,6,6,{NULL},S_DSGUN9,0,0},
+ {SPR_SHT2,7,6,{A_CloseShotgun2},S_DSGUN10,0,0},
+ {SPR_SHT2,0,5,{A_ReFire},S_DSGUN,0,0},
+ {SPR_SHT2,1,7,{NULL},S_DSNR2,0,0},
+ {SPR_SHT2,0,3,{NULL},S_DSGUNDOWN,0,0},
+ {SPR_SHT2,32776,5,{A_Light1},S_DSGUNFLASH2,0,0},
+ {SPR_SHT2,32777,4,{A_Light2},S_LIGHTDONE,0,0},
+ {SPR_CHGG,0,1,{A_WeaponReady},S_CHAIN,0,0},
+ {SPR_CHGG,0,1,{A_Lower},S_CHAINDOWN,0,0},
+ {SPR_CHGG,0,1,{A_Raise},S_CHAINUP,0,0},
+ {SPR_CHGG,0,4,{A_FireCGun},S_CHAIN2,0,0},
+ {SPR_CHGG,1,4,{A_FireCGun},S_CHAIN3,0,0},
+ {SPR_CHGG,1,0,{A_ReFire},S_CHAIN,0,0},
+ {SPR_CHGF,32768,5,{A_Light1},S_LIGHTDONE,0,0},
+ {SPR_CHGF,32769,5,{A_Light2},S_LIGHTDONE,0,0},
+ {SPR_MISG,0,1,{A_WeaponReady},S_MISSILE,0,0},
+ {SPR_MISG,0,1,{A_Lower},S_MISSILEDOWN,0,0},
+ {SPR_MISG,0,1,{A_Raise},S_MISSILEUP,0,0},
+ {SPR_MISG,1,8,{A_GunFlash},S_MISSILE2,0,0},
+ {SPR_MISG,1,12,{A_FireMissile},S_MISSILE3,0,0},
+ {SPR_MISG,1,0,{A_ReFire},S_MISSILE,0,0},
+ {SPR_MISF,32768,3,{A_Light1},S_MISSILEFLASH2,0,0},
+ {SPR_MISF,32769,4,{NULL},S_MISSILEFLASH3,0,0},
+ {SPR_MISF,32770,4,{A_Light2},S_MISSILEFLASH4,0,0},
+ {SPR_MISF,32771,4,{A_Light2},S_LIGHTDONE,0,0},
+ {SPR_SAWG,2,4,{A_WeaponReady},S_SAWB,0,0},
+ {SPR_SAWG,3,4,{A_WeaponReady},S_SAW,0,0},
+ {SPR_SAWG,2,1,{A_Lower},S_SAWDOWN,0,0},
+ {SPR_SAWG,2,1,{A_Raise},S_SAWUP,0,0},
+ {SPR_SAWG,0,4,{A_Saw},S_SAW2,0,0},
+ {SPR_SAWG,1,4,{A_Saw},S_SAW3,0,0},
+ {SPR_SAWG,1,0,{A_ReFire},S_SAW,0,0},
+ {SPR_PLSG,0,1,{A_WeaponReady},S_PLASMA,0,0},
+ {SPR_PLSG,0,1,{A_Lower},S_PLASMADOWN,0,0},
+ {SPR_PLSG,0,1,{A_Raise},S_PLASMAUP,0,0},
+ {SPR_PLSG,0,3,{A_FirePlasma},S_PLASMA2,0,0},
+ {SPR_PLSG,1,20,{A_ReFire},S_PLASMA,0,0},
+ {SPR_PLSF,32768,4,{A_Light1},S_LIGHTDONE,0,0},
+ {SPR_PLSF,32769,4,{A_Light1},S_LIGHTDONE,0,0},
+ {SPR_BFGG,0,1,{A_WeaponReady},S_BFG,0,0},
+ {SPR_BFGG,0,1,{A_Lower},S_BFGDOWN,0,0},
+ {SPR_BFGG,0,1,{A_Raise},S_BFGUP,0,0},
+ {SPR_BFGG,0,20,{A_BFGsound},S_BFG2,0,0},
+ {SPR_BFGG,1,10,{A_GunFlash},S_BFG3,0,0},
+ {SPR_BFGG,1,10,{A_FireBFG},S_BFG4,0,0},
+ {SPR_BFGG,1,20,{A_ReFire},S_BFG,0,0},
+ {SPR_BFGF,32768,11,{A_Light1},S_BFGFLASH2,0,0},
+ {SPR_BFGF,32769,6,{A_Light2},S_LIGHTDONE,0,0},
+ {SPR_BLUD,2,8,{NULL},S_BLOOD2,0,0},
+ {SPR_BLUD,1,8,{NULL},S_BLOOD3,0,0},
+ {SPR_BLUD,0,8,{NULL},S_NULL,0,0},
+ {SPR_PUFF,32768,4,{NULL},S_PUFF2,0,0},
+ {SPR_PUFF,1,4,{NULL},S_PUFF3,0,0},
+ {SPR_PUFF,2,4,{NULL},S_PUFF4,0,0},
+ {SPR_PUFF,3,4,{NULL},S_NULL,0,0},
+ {SPR_BAL1,32768,4,{NULL},S_TBALL2,0,0},
+ {SPR_BAL1,32769,4,{NULL},S_TBALL1,0,0},
+ {SPR_BAL1,32770,6,{NULL},S_TBALLX2,0,0},
+ {SPR_BAL1,32771,6,{NULL},S_TBALLX3,0,0},
+ {SPR_BAL1,32772,6,{NULL},S_NULL,0,0},
+ {SPR_BAL2,32768,4,{NULL},S_RBALL2,0,0},
+ {SPR_BAL2,32769,4,{NULL},S_RBALL1,0,0},
+ {SPR_BAL2,32770,6,{NULL},S_RBALLX2,0,0},
+ {SPR_BAL2,32771,6,{NULL},S_RBALLX3,0,0},
+ {SPR_BAL2,32772,6,{NULL},S_NULL,0,0},
+ {SPR_PLSS,32768,6,{NULL},S_PLASBALL2,0,0},
+ {SPR_PLSS,32769,6,{NULL},S_PLASBALL,0,0},
+ {SPR_PLSE,32768,4,{NULL},S_PLASEXP2,0,0},
+ {SPR_PLSE,32769,4,{NULL},S_PLASEXP3,0,0},
+ {SPR_PLSE,32770,4,{NULL},S_PLASEXP4,0,0},
+ {SPR_PLSE,32771,4,{NULL},S_PLASEXP5,0,0},
+ {SPR_PLSE,32772,4,{NULL},S_NULL,0,0},
+ {SPR_MISL,32768,1,{NULL},S_ROCKET,0,0},
+ {SPR_BFS1,32768,4,{NULL},S_BFGSHOT2,0,0},
+ {SPR_BFS1,32769,4,{NULL},S_BFGSHOT,0,0},
+ {SPR_BFE1,32768,8,{NULL},S_BFGLAND2,0,0},
+ {SPR_BFE1,32769,8,{NULL},S_BFGLAND3,0,0},
+ {SPR_BFE1,32770,8,{A_BFGSpray},S_BFGLAND4,0,0},
+ {SPR_BFE1,32771,8,{NULL},S_BFGLAND5,0,0},
+ {SPR_BFE1,32772,8,{NULL},S_BFGLAND6,0,0},
+ {SPR_BFE1,32773,8,{NULL},S_NULL,0,0},
+ {SPR_BFE2,32768,8,{NULL},S_BFGEXP2,0,0},
+ {SPR_BFE2,32769,8,{NULL},S_BFGEXP3,0,0},
+ {SPR_BFE2,32770,8,{NULL},S_BFGEXP4,0,0},
+ {SPR_BFE2,32771,8,{NULL},S_NULL,0,0},
+ {SPR_MISL,32769,8,{A_Explode},S_EXPLODE2,0,0},
+ {SPR_MISL,32770,6,{NULL},S_EXPLODE3,0,0},
+ {SPR_MISL,32771,4,{NULL},S_NULL,0,0},
+ {SPR_TFOG,32768,6,{NULL},S_TFOG01,0,0},
+ {SPR_TFOG,32769,6,{NULL},S_TFOG02,0,0},
+ {SPR_TFOG,32768,6,{NULL},S_TFOG2,0,0},
+ {SPR_TFOG,32769,6,{NULL},S_TFOG3,0,0},
+ {SPR_TFOG,32770,6,{NULL},S_TFOG4,0,0},
+ {SPR_TFOG,32771,6,{NULL},S_TFOG5,0,0},
+ {SPR_TFOG,32772,6,{NULL},S_TFOG6,0,0},
+ {SPR_TFOG,32773,6,{NULL},S_TFOG7,0,0},
+ {SPR_TFOG,32774,6,{NULL},S_TFOG8,0,0},
+ {SPR_TFOG,32775,6,{NULL},S_TFOG9,0,0},
+ {SPR_TFOG,32776,6,{NULL},S_TFOG10,0,0},
+ {SPR_TFOG,32777,6,{NULL},S_NULL,0,0},
+ {SPR_IFOG,32768,6,{NULL},S_IFOG01,0,0},
+ {SPR_IFOG,32769,6,{NULL},S_IFOG02,0,0},
+ {SPR_IFOG,32768,6,{NULL},S_IFOG2,0,0},
+ {SPR_IFOG,32769,6,{NULL},S_IFOG3,0,0},
+ {SPR_IFOG,32770,6,{NULL},S_IFOG4,0,0},
+ {SPR_IFOG,32771,6,{NULL},S_IFOG5,0,0},
+ {SPR_IFOG,32772,6,{NULL},S_NULL,0,0},
+ {SPR_PLAY,0,-1,{NULL},S_NULL,0,0},
+ {SPR_PLAY,0,4,{NULL},S_PLAY_RUN2,0,0},
+ {SPR_PLAY,1,4,{NULL},S_PLAY_RUN3,0,0},
+ {SPR_PLAY,2,4,{NULL},S_PLAY_RUN4,0,0},
+ {SPR_PLAY,3,4,{NULL},S_PLAY_RUN1,0,0},
+ {SPR_PLAY,4,12,{NULL},S_PLAY,0,0},
+ {SPR_PLAY,32773,6,{NULL},S_PLAY_ATK1,0,0},
+ {SPR_PLAY,6,4,{NULL},S_PLAY_PAIN2,0,0},
+ {SPR_PLAY,6,4,{A_Pain},S_PLAY,0,0},
+ {SPR_PLAY,7,10,{NULL},S_PLAY_DIE2,0,0},
+ {SPR_PLAY,8,10,{A_PlayerScream},S_PLAY_DIE3,0,0},
+ {SPR_PLAY,9,10,{A_Fall},S_PLAY_DIE4,0,0},
+ {SPR_PLAY,10,10,{NULL},S_PLAY_DIE5,0,0},
+ {SPR_PLAY,11,10,{NULL},S_PLAY_DIE6,0,0},
+ {SPR_PLAY,12,10,{NULL},S_PLAY_DIE7,0,0},
+ {SPR_PLAY,13,-1,{NULL},S_NULL,0,0},
+ {SPR_PLAY,14,5,{NULL},S_PLAY_XDIE2,0,0},
+ {SPR_PLAY,15,5,{A_XScream},S_PLAY_XDIE3,0,0},
+ {SPR_PLAY,16,5,{A_Fall},S_PLAY_XDIE4,0,0},
+ {SPR_PLAY,17,5,{NULL},S_PLAY_XDIE5,0,0},
+ {SPR_PLAY,18,5,{NULL},S_PLAY_XDIE6,0,0},
+ {SPR_PLAY,19,5,{NULL},S_PLAY_XDIE7,0,0},
+ {SPR_PLAY,20,5,{NULL},S_PLAY_XDIE8,0,0},
+ {SPR_PLAY,21,5,{NULL},S_PLAY_XDIE9,0,0},
+ {SPR_PLAY,22,-1,{NULL},S_NULL,0,0},
+ {SPR_POSS,0,10,{A_Look},S_POSS_STND2,0,0},
+ {SPR_POSS,1,10,{A_Look},S_POSS_STND,0,0},
+ {SPR_POSS,0,4,{A_Chase},S_POSS_RUN2,0,0},
+ {SPR_POSS,0,4,{A_Chase},S_POSS_RUN3,0,0},
+ {SPR_POSS,1,4,{A_Chase},S_POSS_RUN4,0,0},
+ {SPR_POSS,1,4,{A_Chase},S_POSS_RUN5,0,0},
+ {SPR_POSS,2,4,{A_Chase},S_POSS_RUN6,0,0},
+ {SPR_POSS,2,4,{A_Chase},S_POSS_RUN7,0,0},
+ {SPR_POSS,3,4,{A_Chase},S_POSS_RUN8,0,0},
+ {SPR_POSS,3,4,{A_Chase},S_POSS_RUN1,0,0},
+ {SPR_POSS,4,10,{A_FaceTarget},S_POSS_ATK2,0,0},
+ {SPR_POSS,5,8,{A_PosAttack},S_POSS_ATK3,0,0},
+ {SPR_POSS,4,8,{NULL},S_POSS_RUN1,0,0},
+ {SPR_POSS,6,3,{NULL},S_POSS_PAIN2,0,0},
+ {SPR_POSS,6,3,{A_Pain},S_POSS_RUN1,0,0},
+ {SPR_POSS,7,5,{NULL},S_POSS_DIE2,0,0},
+ {SPR_POSS,8,5,{A_Scream},S_POSS_DIE3,0,0},
+ {SPR_POSS,9,5,{A_Fall},S_POSS_DIE4,0,0},
+ {SPR_POSS,10,5,{NULL},S_POSS_DIE5,0,0},
+ {SPR_POSS,11,-1,{NULL},S_NULL,0,0},
+ {SPR_POSS,12,5,{NULL},S_POSS_XDIE2,0,0},
+ {SPR_POSS,13,5,{A_XScream},S_POSS_XDIE3,0,0},
+ {SPR_POSS,14,5,{A_Fall},S_POSS_XDIE4,0,0},
+ {SPR_POSS,15,5,{NULL},S_POSS_XDIE5,0,0},
+ {SPR_POSS,16,5,{NULL},S_POSS_XDIE6,0,0},
+ {SPR_POSS,17,5,{NULL},S_POSS_XDIE7,0,0},
+ {SPR_POSS,18,5,{NULL},S_POSS_XDIE8,0,0},
+ {SPR_POSS,19,5,{NULL},S_POSS_XDIE9,0,0},
+ {SPR_POSS,20,-1,{NULL},S_NULL,0,0},
+ {SPR_POSS,10,5,{NULL},S_POSS_RAISE2,0,0},
+ {SPR_POSS,9,5,{NULL},S_POSS_RAISE3,0,0},
+ {SPR_POSS,8,5,{NULL},S_POSS_RAISE4,0,0},
+ {SPR_POSS,7,5,{NULL},S_POSS_RUN1,0,0},
+ {SPR_SPOS,0,10,{A_Look},S_SPOS_STND2,0,0},
+ {SPR_SPOS,1,10,{A_Look},S_SPOS_STND,0,0},
+ {SPR_SPOS,0,3,{A_Chase},S_SPOS_RUN2,0,0},
+ {SPR_SPOS,0,3,{A_Chase},S_SPOS_RUN3,0,0},
+ {SPR_SPOS,1,3,{A_Chase},S_SPOS_RUN4,0,0},
+ {SPR_SPOS,1,3,{A_Chase},S_SPOS_RUN5,0,0},
+ {SPR_SPOS,2,3,{A_Chase},S_SPOS_RUN6,0,0},
+ {SPR_SPOS,2,3,{A_Chase},S_SPOS_RUN7,0,0},
+ {SPR_SPOS,3,3,{A_Chase},S_SPOS_RUN8,0,0},
+ {SPR_SPOS,3,3,{A_Chase},S_SPOS_RUN1,0,0},
+ {SPR_SPOS,4,10,{A_FaceTarget},S_SPOS_ATK2,0,0},
+ {SPR_SPOS,32773,10,{A_SPosAttack},S_SPOS_ATK3,0,0},
+ {SPR_SPOS,4,10,{NULL},S_SPOS_RUN1,0,0},
+ {SPR_SPOS,6,3,{NULL},S_SPOS_PAIN2,0,0},
+ {SPR_SPOS,6,3,{A_Pain},S_SPOS_RUN1,0,0},
+ {SPR_SPOS,7,5,{NULL},S_SPOS_DIE2,0,0},
+ {SPR_SPOS,8,5,{A_Scream},S_SPOS_DIE3,0,0},
+ {SPR_SPOS,9,5,{A_Fall},S_SPOS_DIE4,0,0},
+ {SPR_SPOS,10,5,{NULL},S_SPOS_DIE5,0,0},
+ {SPR_SPOS,11,-1,{NULL},S_NULL,0,0},
+ {SPR_SPOS,12,5,{NULL},S_SPOS_XDIE2,0,0},
+ {SPR_SPOS,13,5,{A_XScream},S_SPOS_XDIE3,0,0},
+ {SPR_SPOS,14,5,{A_Fall},S_SPOS_XDIE4,0,0},
+ {SPR_SPOS,15,5,{NULL},S_SPOS_XDIE5,0,0},
+ {SPR_SPOS,16,5,{NULL},S_SPOS_XDIE6,0,0},
+ {SPR_SPOS,17,5,{NULL},S_SPOS_XDIE7,0,0},
+ {SPR_SPOS,18,5,{NULL},S_SPOS_XDIE8,0,0},
+ {SPR_SPOS,19,5,{NULL},S_SPOS_XDIE9,0,0},
+ {SPR_SPOS,20,-1,{NULL},S_NULL,0,0},
+ {SPR_SPOS,11,5,{NULL},S_SPOS_RAISE2,0,0},
+ {SPR_SPOS,10,5,{NULL},S_SPOS_RAISE3,0,0},
+ {SPR_SPOS,9,5,{NULL},S_SPOS_RAISE4,0,0},
+ {SPR_SPOS,8,5,{NULL},S_SPOS_RAISE5,0,0},
+ {SPR_SPOS,7,5,{NULL},S_SPOS_RUN1,0,0},
+ {SPR_VILE,0,10,{A_Look},S_VILE_STND2,0,0},
+ {SPR_VILE,1,10,{A_Look},S_VILE_STND,0,0},
+ {SPR_VILE,0,2,{A_VileChase},S_VILE_RUN2,0,0},
+ {SPR_VILE,0,2,{A_VileChase},S_VILE_RUN3,0,0},
+ {SPR_VILE,1,2,{A_VileChase},S_VILE_RUN4,0,0},
+ {SPR_VILE,1,2,{A_VileChase},S_VILE_RUN5,0,0},
+ {SPR_VILE,2,2,{A_VileChase},S_VILE_RUN6,0,0},
+ {SPR_VILE,2,2,{A_VileChase},S_VILE_RUN7,0,0},
+ {SPR_VILE,3,2,{A_VileChase},S_VILE_RUN8,0,0},
+ {SPR_VILE,3,2,{A_VileChase},S_VILE_RUN9,0,0},
+ {SPR_VILE,4,2,{A_VileChase},S_VILE_RUN10,0,0},
+ {SPR_VILE,4,2,{A_VileChase},S_VILE_RUN11,0,0},
+ {SPR_VILE,5,2,{A_VileChase},S_VILE_RUN12,0,0},
+ {SPR_VILE,5,2,{A_VileChase},S_VILE_RUN1,0,0},
+ {SPR_VILE,32774,0,{A_VileStart},S_VILE_ATK2,0,0},
+ {SPR_VILE,32774,10,{A_FaceTarget},S_VILE_ATK3,0,0},
+ {SPR_VILE,32775,8,{A_VileTarget},S_VILE_ATK4,0,0},
+ {SPR_VILE,32776,8,{A_FaceTarget},S_VILE_ATK5,0,0},
+ {SPR_VILE,32777,8,{A_FaceTarget},S_VILE_ATK6,0,0},
+ {SPR_VILE,32778,8,{A_FaceTarget},S_VILE_ATK7,0,0},
+ {SPR_VILE,32779,8,{A_FaceTarget},S_VILE_ATK8,0,0},
+ {SPR_VILE,32780,8,{A_FaceTarget},S_VILE_ATK9,0,0},
+ {SPR_VILE,32781,8,{A_FaceTarget},S_VILE_ATK10,0,0},
+ {SPR_VILE,32782,8,{A_VileAttack},S_VILE_ATK11,0,0},
+ {SPR_VILE,32783,20,{NULL},S_VILE_RUN1,0,0},
+ {SPR_VILE,32794,10,{NULL},S_VILE_HEAL2,0,0},
+ {SPR_VILE,32795,10,{NULL},S_VILE_HEAL3,0,0},
+ {SPR_VILE,32796,10,{NULL},S_VILE_RUN1,0,0},
+ {SPR_VILE,16,5,{NULL},S_VILE_PAIN2,0,0},
+ {SPR_VILE,16,5,{A_Pain},S_VILE_RUN1,0,0},
+ {SPR_VILE,16,7,{NULL},S_VILE_DIE2,0,0},
+ {SPR_VILE,17,7,{A_Scream},S_VILE_DIE3,0,0},
+ {SPR_VILE,18,7,{A_Fall},S_VILE_DIE4,0,0},
+ {SPR_VILE,19,7,{NULL},S_VILE_DIE5,0,0},
+ {SPR_VILE,20,7,{NULL},S_VILE_DIE6,0,0},
+ {SPR_VILE,21,7,{NULL},S_VILE_DIE7,0,0},
+ {SPR_VILE,22,7,{NULL},S_VILE_DIE8,0,0},
+ {SPR_VILE,23,5,{NULL},S_VILE_DIE9,0,0},
+ {SPR_VILE,24,5,{NULL},S_VILE_DIE10,0,0},
+ {SPR_VILE,25,-1,{NULL},S_NULL,0,0},
+ {SPR_FIRE,32768,2,{A_StartFire},S_FIRE2,0,0},
+ {SPR_FIRE,32769,2,{A_Fire},S_FIRE3,0,0},
+ {SPR_FIRE,32768,2,{A_Fire},S_FIRE4,0,0},
+ {SPR_FIRE,32769,2,{A_Fire},S_FIRE5,0,0},
+ {SPR_FIRE,32770,2,{A_FireCrackle},S_FIRE6,0,0},
+ {SPR_FIRE,32769,2,{A_Fire},S_FIRE7,0,0},
+ {SPR_FIRE,32770,2,{A_Fire},S_FIRE8,0,0},
+ {SPR_FIRE,32769,2,{A_Fire},S_FIRE9,0,0},
+ {SPR_FIRE,32770,2,{A_Fire},S_FIRE10,0,0},
+ {SPR_FIRE,32771,2,{A_Fire},S_FIRE11,0,0},
+ {SPR_FIRE,32770,2,{A_Fire},S_FIRE12,0,0},
+ {SPR_FIRE,32771,2,{A_Fire},S_FIRE13,0,0},
+ {SPR_FIRE,32770,2,{A_Fire},S_FIRE14,0,0},
+ {SPR_FIRE,32771,2,{A_Fire},S_FIRE15,0,0},
+ {SPR_FIRE,32772,2,{A_Fire},S_FIRE16,0,0},
+ {SPR_FIRE,32771,2,{A_Fire},S_FIRE17,0,0},
+ {SPR_FIRE,32772,2,{A_Fire},S_FIRE18,0,0},
+ {SPR_FIRE,32771,2,{A_Fire},S_FIRE19,0,0},
+ {SPR_FIRE,32772,2,{A_FireCrackle},S_FIRE20,0,0},
+ {SPR_FIRE,32773,2,{A_Fire},S_FIRE21,0,0},
+ {SPR_FIRE,32772,2,{A_Fire},S_FIRE22,0,0},
+ {SPR_FIRE,32773,2,{A_Fire},S_FIRE23,0,0},
+ {SPR_FIRE,32772,2,{A_Fire},S_FIRE24,0,0},
+ {SPR_FIRE,32773,2,{A_Fire},S_FIRE25,0,0},
+ {SPR_FIRE,32774,2,{A_Fire},S_FIRE26,0,0},
+ {SPR_FIRE,32775,2,{A_Fire},S_FIRE27,0,0},
+ {SPR_FIRE,32774,2,{A_Fire},S_FIRE28,0,0},
+ {SPR_FIRE,32775,2,{A_Fire},S_FIRE29,0,0},
+ {SPR_FIRE,32774,2,{A_Fire},S_FIRE30,0,0},
+ {SPR_FIRE,32775,2,{A_Fire},S_NULL,0,0},
+ {SPR_PUFF,1,4,{NULL},S_SMOKE2,0,0},
+ {SPR_PUFF,2,4,{NULL},S_SMOKE3,0,0},
+ {SPR_PUFF,1,4,{NULL},S_SMOKE4,0,0},
+ {SPR_PUFF,2,4,{NULL},S_SMOKE5,0,0},
+ {SPR_PUFF,3,4,{NULL},S_NULL,0,0},
+ {SPR_FATB,32768,2,{A_Tracer},S_TRACER2,0,0},
+ {SPR_FATB,32769,2,{A_Tracer},S_TRACER,0,0},
+ {SPR_FBXP,32768,8,{NULL},S_TRACEEXP2,0,0},
+ {SPR_FBXP,32769,6,{NULL},S_TRACEEXP3,0,0},
+ {SPR_FBXP,32770,4,{NULL},S_NULL,0,0},
+ {SPR_SKEL,0,10,{A_Look},S_SKEL_STND2,0,0},
+ {SPR_SKEL,1,10,{A_Look},S_SKEL_STND,0,0},
+ {SPR_SKEL,0,2,{A_Chase},S_SKEL_RUN2,0,0},
+ {SPR_SKEL,0,2,{A_Chase},S_SKEL_RUN3,0,0},
+ {SPR_SKEL,1,2,{A_Chase},S_SKEL_RUN4,0,0},
+ {SPR_SKEL,1,2,{A_Chase},S_SKEL_RUN5,0,0},
+ {SPR_SKEL,2,2,{A_Chase},S_SKEL_RUN6,0,0},
+ {SPR_SKEL,2,2,{A_Chase},S_SKEL_RUN7,0,0},
+ {SPR_SKEL,3,2,{A_Chase},S_SKEL_RUN8,0,0},
+ {SPR_SKEL,3,2,{A_Chase},S_SKEL_RUN9,0,0},
+ {SPR_SKEL,4,2,{A_Chase},S_SKEL_RUN10,0,0},
+ {SPR_SKEL,4,2,{A_Chase},S_SKEL_RUN11,0,0},
+ {SPR_SKEL,5,2,{A_Chase},S_SKEL_RUN12,0,0},
+ {SPR_SKEL,5,2,{A_Chase},S_SKEL_RUN1,0,0},
+ {SPR_SKEL,6,0,{A_FaceTarget},S_SKEL_FIST2,0,0},
+ {SPR_SKEL,6,6,{A_SkelWhoosh},S_SKEL_FIST3,0,0},
+ {SPR_SKEL,7,6,{A_FaceTarget},S_SKEL_FIST4,0,0},
+ {SPR_SKEL,8,6,{A_SkelFist},S_SKEL_RUN1,0,0},
+ {SPR_SKEL,32777,0,{A_FaceTarget},S_SKEL_MISS2,0,0},
+ {SPR_SKEL,32777,10,{A_FaceTarget},S_SKEL_MISS3,0,0},
+ {SPR_SKEL,10,10,{A_SkelMissile},S_SKEL_MISS4,0,0},
+ {SPR_SKEL,10,10,{A_FaceTarget},S_SKEL_RUN1,0,0},
+ {SPR_SKEL,11,5,{NULL},S_SKEL_PAIN2,0,0},
+ {SPR_SKEL,11,5,{A_Pain},S_SKEL_RUN1,0,0},
+ {SPR_SKEL,11,7,{NULL},S_SKEL_DIE2,0,0},
+ {SPR_SKEL,12,7,{NULL},S_SKEL_DIE3,0,0},
+ {SPR_SKEL,13,7,{A_Scream},S_SKEL_DIE4,0,0},
+ {SPR_SKEL,14,7,{A_Fall},S_SKEL_DIE5,0,0},
+ {SPR_SKEL,15,7,{NULL},S_SKEL_DIE6,0,0},
+ {SPR_SKEL,16,-1,{NULL},S_NULL,0,0},
+ {SPR_SKEL,16,5,{NULL},S_SKEL_RAISE2,0,0},
+ {SPR_SKEL,15,5,{NULL},S_SKEL_RAISE3,0,0},
+ {SPR_SKEL,14,5,{NULL},S_SKEL_RAISE4,0,0},
+ {SPR_SKEL,13,5,{NULL},S_SKEL_RAISE5,0,0},
+ {SPR_SKEL,12,5,{NULL},S_SKEL_RAISE6,0,0},
+ {SPR_SKEL,11,5,{NULL},S_SKEL_RUN1,0,0},
+ {SPR_MANF,32768,4,{NULL},S_FATSHOT2,0,0},
+ {SPR_MANF,32769,4,{NULL},S_FATSHOT1,0,0},
+ {SPR_MISL,32769,8,{NULL},S_FATSHOTX2,0,0},
+ {SPR_MISL,32770,6,{NULL},S_FATSHOTX3,0,0},
+ {SPR_MISL,32771,4,{NULL},S_NULL,0,0},
+ {SPR_FATT,0,15,{A_Look},S_FATT_STND2,0,0},
+ {SPR_FATT,1,15,{A_Look},S_FATT_STND,0,0},
+ {SPR_FATT,0,4,{A_Chase},S_FATT_RUN2,0,0},
+ {SPR_FATT,0,4,{A_Chase},S_FATT_RUN3,0,0},
+ {SPR_FATT,1,4,{A_Chase},S_FATT_RUN4,0,0},
+ {SPR_FATT,1,4,{A_Chase},S_FATT_RUN5,0,0},
+ {SPR_FATT,2,4,{A_Chase},S_FATT_RUN6,0,0},
+ {SPR_FATT,2,4,{A_Chase},S_FATT_RUN7,0,0},
+ {SPR_FATT,3,4,{A_Chase},S_FATT_RUN8,0,0},
+ {SPR_FATT,3,4,{A_Chase},S_FATT_RUN9,0,0},
+ {SPR_FATT,4,4,{A_Chase},S_FATT_RUN10,0,0},
+ {SPR_FATT,4,4,{A_Chase},S_FATT_RUN11,0,0},
+ {SPR_FATT,5,4,{A_Chase},S_FATT_RUN12,0,0},
+ {SPR_FATT,5,4,{A_Chase},S_FATT_RUN1,0,0},
+ {SPR_FATT,6,20,{A_FatRaise},S_FATT_ATK2,0,0},
+ {SPR_FATT,32775,10,{A_FatAttack1},S_FATT_ATK3,0,0},
+ {SPR_FATT,8,5,{A_FaceTarget},S_FATT_ATK4,0,0},
+ {SPR_FATT,6,5,{A_FaceTarget},S_FATT_ATK5,0,0},
+ {SPR_FATT,32775,10,{A_FatAttack2},S_FATT_ATK6,0,0},
+ {SPR_FATT,8,5,{A_FaceTarget},S_FATT_ATK7,0,0},
+ {SPR_FATT,6,5,{A_FaceTarget},S_FATT_ATK8,0,0},
+ {SPR_FATT,32775,10,{A_FatAttack3},S_FATT_ATK9,0,0},
+ {SPR_FATT,8,5,{A_FaceTarget},S_FATT_ATK10,0,0},
+ {SPR_FATT,6,5,{A_FaceTarget},S_FATT_RUN1,0,0},
+ {SPR_FATT,9,3,{NULL},S_FATT_PAIN2,0,0},
+ {SPR_FATT,9,3,{A_Pain},S_FATT_RUN1,0,0},
+ {SPR_FATT,10,6,{NULL},S_FATT_DIE2,0,0},
+ {SPR_FATT,11,6,{A_Scream},S_FATT_DIE3,0,0},
+ {SPR_FATT,12,6,{A_Fall},S_FATT_DIE4,0,0},
+ {SPR_FATT,13,6,{NULL},S_FATT_DIE5,0,0},
+ {SPR_FATT,14,6,{NULL},S_FATT_DIE6,0,0},
+ {SPR_FATT,15,6,{NULL},S_FATT_DIE7,0,0},
+ {SPR_FATT,16,6,{NULL},S_FATT_DIE8,0,0},
+ {SPR_FATT,17,6,{NULL},S_FATT_DIE9,0,0},
+ {SPR_FATT,18,6,{NULL},S_FATT_DIE10,0,0},
+ {SPR_FATT,19,-1,{A_BossDeath},S_NULL,0,0},
+ {SPR_FATT,17,5,{NULL},S_FATT_RAISE2,0,0},
+ {SPR_FATT,16,5,{NULL},S_FATT_RAISE3,0,0},
+ {SPR_FATT,15,5,{NULL},S_FATT_RAISE4,0,0},
+ {SPR_FATT,14,5,{NULL},S_FATT_RAISE5,0,0},
+ {SPR_FATT,13,5,{NULL},S_FATT_RAISE6,0,0},
+ {SPR_FATT,12,5,{NULL},S_FATT_RAISE7,0,0},
+ {SPR_FATT,11,5,{NULL},S_FATT_RAISE8,0,0},
+ {SPR_FATT,10,5,{NULL},S_FATT_RUN1,0,0},
+ {SPR_CPOS,0,10,{A_Look},S_CPOS_STND2,0,0},
+ {SPR_CPOS,1,10,{A_Look},S_CPOS_STND,0,0},
+ {SPR_CPOS,0,3,{A_Chase},S_CPOS_RUN2,0,0},
+ {SPR_CPOS,0,3,{A_Chase},S_CPOS_RUN3,0,0},
+ {SPR_CPOS,1,3,{A_Chase},S_CPOS_RUN4,0,0},
+ {SPR_CPOS,1,3,{A_Chase},S_CPOS_RUN5,0,0},
+ {SPR_CPOS,2,3,{A_Chase},S_CPOS_RUN6,0,0},
+ {SPR_CPOS,2,3,{A_Chase},S_CPOS_RUN7,0,0},
+ {SPR_CPOS,3,3,{A_Chase},S_CPOS_RUN8,0,0},
+ {SPR_CPOS,3,3,{A_Chase},S_CPOS_RUN1,0,0},
+ {SPR_CPOS,4,10,{A_FaceTarget},S_CPOS_ATK2,0,0},
+ {SPR_CPOS,32773,4,{A_CPosAttack},S_CPOS_ATK3,0,0},
+ {SPR_CPOS,32772,4,{A_CPosAttack},S_CPOS_ATK4,0,0},
+ {SPR_CPOS,5,1,{A_CPosRefire},S_CPOS_ATK2,0,0},
+ {SPR_CPOS,6,3,{NULL},S_CPOS_PAIN2,0,0},
+ {SPR_CPOS,6,3,{A_Pain},S_CPOS_RUN1,0,0},
+ {SPR_CPOS,7,5,{NULL},S_CPOS_DIE2,0,0},
+ {SPR_CPOS,8,5,{A_Scream},S_CPOS_DIE3,0,0},
+ {SPR_CPOS,9,5,{A_Fall},S_CPOS_DIE4,0,0},
+ {SPR_CPOS,10,5,{NULL},S_CPOS_DIE5,0,0},
+ {SPR_CPOS,11,5,{NULL},S_CPOS_DIE6,0,0},
+ {SPR_CPOS,12,5,{NULL},S_CPOS_DIE7,0,0},
+ {SPR_CPOS,13,-1,{NULL},S_NULL,0,0},
+ {SPR_CPOS,14,5,{NULL},S_CPOS_XDIE2,0,0},
+ {SPR_CPOS,15,5,{A_XScream},S_CPOS_XDIE3,0,0},
+ {SPR_CPOS,16,5,{A_Fall},S_CPOS_XDIE4,0,0},
+ {SPR_CPOS,17,5,{NULL},S_CPOS_XDIE5,0,0},
+ {SPR_CPOS,18,5,{NULL},S_CPOS_XDIE6,0,0},
+ {SPR_CPOS,19,-1,{NULL},S_NULL,0,0},
+ {SPR_CPOS,13,5,{NULL},S_CPOS_RAISE2,0,0},
+ {SPR_CPOS,12,5,{NULL},S_CPOS_RAISE3,0,0},
+ {SPR_CPOS,11,5,{NULL},S_CPOS_RAISE4,0,0},
+ {SPR_CPOS,10,5,{NULL},S_CPOS_RAISE5,0,0},
+ {SPR_CPOS,9,5,{NULL},S_CPOS_RAISE6,0,0},
+ {SPR_CPOS,8,5,{NULL},S_CPOS_RAISE7,0,0},
+ {SPR_CPOS,7,5,{NULL},S_CPOS_RUN1,0,0},
+ {SPR_TROO,0,10,{A_Look},S_TROO_STND2,0,0},
+ {SPR_TROO,1,10,{A_Look},S_TROO_STND,0,0},
+ {SPR_TROO,0,3,{A_Chase},S_TROO_RUN2,0,0},
+ {SPR_TROO,0,3,{A_Chase},S_TROO_RUN3,0,0},
+ {SPR_TROO,1,3,{A_Chase},S_TROO_RUN4,0,0},
+ {SPR_TROO,1,3,{A_Chase},S_TROO_RUN5,0,0},
+ {SPR_TROO,2,3,{A_Chase},S_TROO_RUN6,0,0},
+ {SPR_TROO,2,3,{A_Chase},S_TROO_RUN7,0,0},
+ {SPR_TROO,3,3,{A_Chase},S_TROO_RUN8,0,0},
+ {SPR_TROO,3,3,{A_Chase},S_TROO_RUN1,0,0},
+ {SPR_TROO,4,8,{A_FaceTarget},S_TROO_ATK2,0,0},
+ {SPR_TROO,5,8,{A_FaceTarget},S_TROO_ATK3,0,0},
+ {SPR_TROO,6,6,{A_TroopAttack},S_TROO_RUN1,0,0},
+ {SPR_TROO,7,2,{NULL},S_TROO_PAIN2,0,0},
+ {SPR_TROO,7,2,{A_Pain},S_TROO_RUN1,0,0},
+ {SPR_TROO,8,8,{NULL},S_TROO_DIE2,0,0},
+ {SPR_TROO,9,8,{A_Scream},S_TROO_DIE3,0,0},
+ {SPR_TROO,10,6,{NULL},S_TROO_DIE4,0,0},
+ {SPR_TROO,11,6,{A_Fall},S_TROO_DIE5,0,0},
+ {SPR_TROO,12,-1,{NULL},S_NULL,0,0},
+ {SPR_TROO,13,5,{NULL},S_TROO_XDIE2,0,0},
+ {SPR_TROO,14,5,{A_XScream},S_TROO_XDIE3,0,0},
+ {SPR_TROO,15,5,{NULL},S_TROO_XDIE4,0,0},
+ {SPR_TROO,16,5,{A_Fall},S_TROO_XDIE5,0,0},
+ {SPR_TROO,17,5,{NULL},S_TROO_XDIE6,0,0},
+ {SPR_TROO,18,5,{NULL},S_TROO_XDIE7,0,0},
+ {SPR_TROO,19,5,{NULL},S_TROO_XDIE8,0,0},
+ {SPR_TROO,20,-1,{NULL},S_NULL,0,0},
+ {SPR_TROO,12,8,{NULL},S_TROO_RAISE2,0,0},
+ {SPR_TROO,11,8,{NULL},S_TROO_RAISE3,0,0},
+ {SPR_TROO,10,6,{NULL},S_TROO_RAISE4,0,0},
+ {SPR_TROO,9,6,{NULL},S_TROO_RAISE5,0,0},
+ {SPR_TROO,8,6,{NULL},S_TROO_RUN1,0,0},
+ {SPR_SARG,0,10,{A_Look},S_SARG_STND2,0,0},
+ {SPR_SARG,1,10,{A_Look},S_SARG_STND,0,0},
+ {SPR_SARG,0,2,{A_Chase},S_SARG_RUN2,0,0},
+ {SPR_SARG,0,2,{A_Chase},S_SARG_RUN3,0,0},
+ {SPR_SARG,1,2,{A_Chase},S_SARG_RUN4,0,0},
+ {SPR_SARG,1,2,{A_Chase},S_SARG_RUN5,0,0},
+ {SPR_SARG,2,2,{A_Chase},S_SARG_RUN6,0,0},
+ {SPR_SARG,2,2,{A_Chase},S_SARG_RUN7,0,0},
+ {SPR_SARG,3,2,{A_Chase},S_SARG_RUN8,0,0},
+ {SPR_SARG,3,2,{A_Chase},S_SARG_RUN1,0,0},
+ {SPR_SARG,4,8,{A_FaceTarget},S_SARG_ATK2,0,0},
+ {SPR_SARG,5,8,{A_FaceTarget},S_SARG_ATK3,0,0},
+ {SPR_SARG,6,8,{A_SargAttack},S_SARG_RUN1,0,0},
+ {SPR_SARG,7,2,{NULL},S_SARG_PAIN2,0,0},
+ {SPR_SARG,7,2,{A_Pain},S_SARG_RUN1,0,0},
+ {SPR_SARG,8,8,{NULL},S_SARG_DIE2,0,0},
+ {SPR_SARG,9,8,{A_Scream},S_SARG_DIE3,0,0},
+ {SPR_SARG,10,4,{NULL},S_SARG_DIE4,0,0},
+ {SPR_SARG,11,4,{A_Fall},S_SARG_DIE5,0,0},
+ {SPR_SARG,12,4,{NULL},S_SARG_DIE6,0,0},
+ {SPR_SARG,13,-1,{NULL},S_NULL,0,0},
+ {SPR_SARG,13,5,{NULL},S_SARG_RAISE2,0,0},
+ {SPR_SARG,12,5,{NULL},S_SARG_RAISE3,0,0},
+ {SPR_SARG,11,5,{NULL},S_SARG_RAISE4,0,0},
+ {SPR_SARG,10,5,{NULL},S_SARG_RAISE5,0,0},
+ {SPR_SARG,9,5,{NULL},S_SARG_RAISE6,0,0},
+ {SPR_SARG,8,5,{NULL},S_SARG_RUN1,0,0},
+ {SPR_HEAD,0,10,{A_Look},S_HEAD_STND,0,0},
+ {SPR_HEAD,0,3,{A_Chase},S_HEAD_RUN1,0,0},
+ {SPR_HEAD,1,5,{A_FaceTarget},S_HEAD_ATK2,0,0},
+ {SPR_HEAD,2,5,{A_FaceTarget},S_HEAD_ATK3,0,0},
+ {SPR_HEAD,32771,5,{A_HeadAttack},S_HEAD_RUN1,0,0},
+ {SPR_HEAD,4,3,{NULL},S_HEAD_PAIN2,0,0},
+ {SPR_HEAD,4,3,{A_Pain},S_HEAD_PAIN3,0,0},
+ {SPR_HEAD,5,6,{NULL},S_HEAD_RUN1,0,0},
+ {SPR_HEAD,6,8,{NULL},S_HEAD_DIE2,0,0},
+ {SPR_HEAD,7,8,{A_Scream},S_HEAD_DIE3,0,0},
+ {SPR_HEAD,8,8,{NULL},S_HEAD_DIE4,0,0},
+ {SPR_HEAD,9,8,{NULL},S_HEAD_DIE5,0,0},
+ {SPR_HEAD,10,8,{A_Fall},S_HEAD_DIE6,0,0},
+ {SPR_HEAD,11,-1,{NULL},S_NULL,0,0},
+ {SPR_HEAD,11,8,{NULL},S_HEAD_RAISE2,0,0},
+ {SPR_HEAD,10,8,{NULL},S_HEAD_RAISE3,0,0},
+ {SPR_HEAD,9,8,{NULL},S_HEAD_RAISE4,0,0},
+ {SPR_HEAD,8,8,{NULL},S_HEAD_RAISE5,0,0},
+ {SPR_HEAD,7,8,{NULL},S_HEAD_RAISE6,0,0},
+ {SPR_HEAD,6,8,{NULL},S_HEAD_RUN1,0,0},
+ {SPR_BAL7,32768,4,{NULL},S_BRBALL2,0,0},
+ {SPR_BAL7,32769,4,{NULL},S_BRBALL1,0,0},
+ {SPR_BAL7,32770,6,{NULL},S_BRBALLX2,0,0},
+ {SPR_BAL7,32771,6,{NULL},S_BRBALLX3,0,0},
+ {SPR_BAL7,32772,6,{NULL},S_NULL,0,0},
+ {SPR_BOSS,0,10,{A_Look},S_BOSS_STND2,0,0},
+ {SPR_BOSS,1,10,{A_Look},S_BOSS_STND,0,0},
+ {SPR_BOSS,0,3,{A_Chase},S_BOSS_RUN2,0,0},
+ {SPR_BOSS,0,3,{A_Chase},S_BOSS_RUN3,0,0},
+ {SPR_BOSS,1,3,{A_Chase},S_BOSS_RUN4,0,0},
+ {SPR_BOSS,1,3,{A_Chase},S_BOSS_RUN5,0,0},
+ {SPR_BOSS,2,3,{A_Chase},S_BOSS_RUN6,0,0},
+ {SPR_BOSS,2,3,{A_Chase},S_BOSS_RUN7,0,0},
+ {SPR_BOSS,3,3,{A_Chase},S_BOSS_RUN8,0,0},
+ {SPR_BOSS,3,3,{A_Chase},S_BOSS_RUN1,0,0},
+ {SPR_BOSS,4,8,{A_FaceTarget},S_BOSS_ATK2,0,0},
+ {SPR_BOSS,5,8,{A_FaceTarget},S_BOSS_ATK3,0,0},
+ {SPR_BOSS,6,8,{A_BruisAttack},S_BOSS_RUN1,0,0},
+ {SPR_BOSS,7,2,{NULL},S_BOSS_PAIN2,0,0},
+ {SPR_BOSS,7,2,{A_Pain},S_BOSS_RUN1,0,0},
+ {SPR_BOSS,8,8,{NULL},S_BOSS_DIE2,0,0},
+ {SPR_BOSS,9,8,{A_Scream},S_BOSS_DIE3,0,0},
+ {SPR_BOSS,10,8,{NULL},S_BOSS_DIE4,0,0},
+ {SPR_BOSS,11,8,{A_Fall},S_BOSS_DIE5,0,0},
+ {SPR_BOSS,12,8,{NULL},S_BOSS_DIE6,0,0},
+ {SPR_BOSS,13,8,{NULL},S_BOSS_DIE7,0,0},
+ {SPR_BOSS,14,-1,{A_BossDeath},S_NULL,0,0},
+ {SPR_BOSS,14,8,{NULL},S_BOSS_RAISE2,0,0},
+ {SPR_BOSS,13,8,{NULL},S_BOSS_RAISE3,0,0},
+ {SPR_BOSS,12,8,{NULL},S_BOSS_RAISE4,0,0},
+ {SPR_BOSS,11,8,{NULL},S_BOSS_RAISE5,0,0},
+ {SPR_BOSS,10,8,{NULL},S_BOSS_RAISE6,0,0},
+ {SPR_BOSS,9,8,{NULL},S_BOSS_RAISE7,0,0},
+ {SPR_BOSS,8,8,{NULL},S_BOSS_RUN1,0,0},
+ {SPR_BOS2,0,10,{A_Look},S_BOS2_STND2,0,0},
+ {SPR_BOS2,1,10,{A_Look},S_BOS2_STND,0,0},
+ {SPR_BOS2,0,3,{A_Chase},S_BOS2_RUN2,0,0},
+ {SPR_BOS2,0,3,{A_Chase},S_BOS2_RUN3,0,0},
+ {SPR_BOS2,1,3,{A_Chase},S_BOS2_RUN4,0,0},
+ {SPR_BOS2,1,3,{A_Chase},S_BOS2_RUN5,0,0},
+ {SPR_BOS2,2,3,{A_Chase},S_BOS2_RUN6,0,0},
+ {SPR_BOS2,2,3,{A_Chase},S_BOS2_RUN7,0,0},
+ {SPR_BOS2,3,3,{A_Chase},S_BOS2_RUN8,0,0},
+ {SPR_BOS2,3,3,{A_Chase},S_BOS2_RUN1,0,0},
+ {SPR_BOS2,4,8,{A_FaceTarget},S_BOS2_ATK2,0,0},
+ {SPR_BOS2,5,8,{A_FaceTarget},S_BOS2_ATK3,0,0},
+ {SPR_BOS2,6,8,{A_BruisAttack},S_BOS2_RUN1,0,0},
+ {SPR_BOS2,7,2,{NULL},S_BOS2_PAIN2,0,0},
+ {SPR_BOS2,7,2,{A_Pain},S_BOS2_RUN1,0,0},
+ {SPR_BOS2,8,8,{NULL},S_BOS2_DIE2,0,0},
+ {SPR_BOS2,9,8,{A_Scream},S_BOS2_DIE3,0,0},
+ {SPR_BOS2,10,8,{NULL},S_BOS2_DIE4,0,0},
+ {SPR_BOS2,11,8,{A_Fall},S_BOS2_DIE5,0,0},
+ {SPR_BOS2,12,8,{NULL},S_BOS2_DIE6,0,0},
+ {SPR_BOS2,13,8,{NULL},S_BOS2_DIE7,0,0},
+ {SPR_BOS2,14,-1,{NULL},S_NULL,0,0},
+ {SPR_BOS2,14,8,{NULL},S_BOS2_RAISE2,0,0},
+ {SPR_BOS2,13,8,{NULL},S_BOS2_RAISE3,0,0},
+ {SPR_BOS2,12,8,{NULL},S_BOS2_RAISE4,0,0},
+ {SPR_BOS2,11,8,{NULL},S_BOS2_RAISE5,0,0},
+ {SPR_BOS2,10,8,{NULL},S_BOS2_RAISE6,0,0},
+ {SPR_BOS2,9,8,{NULL},S_BOS2_RAISE7,0,0},
+ {SPR_BOS2,8,8,{NULL},S_BOS2_RUN1,0,0},
+ {SPR_SKUL,32768,10,{A_Look},S_SKULL_STND2,0,0},
+ {SPR_SKUL,32769,10,{A_Look},S_SKULL_STND,0,0},
+ {SPR_SKUL,32768,6,{A_Chase},S_SKULL_RUN2,0,0},
+ {SPR_SKUL,32769,6,{A_Chase},S_SKULL_RUN1,0,0},
+ {SPR_SKUL,32770,10,{A_FaceTarget},S_SKULL_ATK2,0,0},
+ {SPR_SKUL,32771,4,{A_SkullAttack},S_SKULL_ATK3,0,0},
+ {SPR_SKUL,32770,4,{NULL},S_SKULL_ATK4,0,0},
+ {SPR_SKUL,32771,4,{NULL},S_SKULL_ATK3,0,0},
+ {SPR_SKUL,32772,3,{NULL},S_SKULL_PAIN2,0,0},
+ {SPR_SKUL,32772,3,{A_Pain},S_SKULL_RUN1,0,0},
+ {SPR_SKUL,32773,6,{NULL},S_SKULL_DIE2,0,0},
+ {SPR_SKUL,32774,6,{A_Scream},S_SKULL_DIE3,0,0},
+ {SPR_SKUL,32775,6,{NULL},S_SKULL_DIE4,0,0},
+ {SPR_SKUL,32776,6,{A_Fall},S_SKULL_DIE5,0,0},
+ {SPR_SKUL,9,6,{NULL},S_SKULL_DIE6,0,0},
+ {SPR_SKUL,10,6,{NULL},S_NULL,0,0},
+ {SPR_SPID,0,10,{A_Look},S_SPID_STND2,0,0},
+ {SPR_SPID,1,10,{A_Look},S_SPID_STND,0,0},
+ {SPR_SPID,0,3,{A_Metal},S_SPID_RUN2,0,0},
+ {SPR_SPID,0,3,{A_Chase},S_SPID_RUN3,0,0},
+ {SPR_SPID,1,3,{A_Chase},S_SPID_RUN4,0,0},
+ {SPR_SPID,1,3,{A_Chase},S_SPID_RUN5,0,0},
+ {SPR_SPID,2,3,{A_Metal},S_SPID_RUN6,0,0},
+ {SPR_SPID,2,3,{A_Chase},S_SPID_RUN7,0,0},
+ {SPR_SPID,3,3,{A_Chase},S_SPID_RUN8,0,0},
+ {SPR_SPID,3,3,{A_Chase},S_SPID_RUN9,0,0},
+ {SPR_SPID,4,3,{A_Metal},S_SPID_RUN10,0,0},
+ {SPR_SPID,4,3,{A_Chase},S_SPID_RUN11,0,0},
+ {SPR_SPID,5,3,{A_Chase},S_SPID_RUN12,0,0},
+ {SPR_SPID,5,3,{A_Chase},S_SPID_RUN1,0,0},
+ {SPR_SPID,32768,20,{A_FaceTarget},S_SPID_ATK2,0,0},
+ {SPR_SPID,32774,4,{A_SPosAttack},S_SPID_ATK3,0,0},
+ {SPR_SPID,32775,4,{A_SPosAttack},S_SPID_ATK4,0,0},
+ {SPR_SPID,32775,1,{A_SpidRefire},S_SPID_ATK2,0,0},
+ {SPR_SPID,8,3,{NULL},S_SPID_PAIN2,0,0},
+ {SPR_SPID,8,3,{A_Pain},S_SPID_RUN1,0,0},
+ {SPR_SPID,9,20,{A_Scream},S_SPID_DIE2,0,0},
+ {SPR_SPID,10,10,{A_Fall},S_SPID_DIE3,0,0},
+ {SPR_SPID,11,10,{NULL},S_SPID_DIE4,0,0},
+ {SPR_SPID,12,10,{NULL},S_SPID_DIE5,0,0},
+ {SPR_SPID,13,10,{NULL},S_SPID_DIE6,0,0},
+ {SPR_SPID,14,10,{NULL},S_SPID_DIE7,0,0},
+ {SPR_SPID,15,10,{NULL},S_SPID_DIE8,0,0},
+ {SPR_SPID,16,10,{NULL},S_SPID_DIE9,0,0},
+ {SPR_SPID,17,10,{NULL},S_SPID_DIE10,0,0},
+ {SPR_SPID,18,30,{NULL},S_SPID_DIE11,0,0},
+ {SPR_SPID,18,-1,{A_BossDeath},S_NULL,0,0},
+ {SPR_BSPI,0,10,{A_Look},S_BSPI_STND2,0,0},
+ {SPR_BSPI,1,10,{A_Look},S_BSPI_STND,0,0},
+ {SPR_BSPI,0,20,{NULL},S_BSPI_RUN1,0,0},
+ {SPR_BSPI,0,3,{A_BabyMetal},S_BSPI_RUN2,0,0},
+ {SPR_BSPI,0,3,{A_Chase},S_BSPI_RUN3,0,0},
+ {SPR_BSPI,1,3,{A_Chase},S_BSPI_RUN4,0,0},
+ {SPR_BSPI,1,3,{A_Chase},S_BSPI_RUN5,0,0},
+ {SPR_BSPI,2,3,{A_Chase},S_BSPI_RUN6,0,0},
+ {SPR_BSPI,2,3,{A_Chase},S_BSPI_RUN7,0,0},
+ {SPR_BSPI,3,3,{A_BabyMetal},S_BSPI_RUN8,0,0},
+ {SPR_BSPI,3,3,{A_Chase},S_BSPI_RUN9,0,0},
+ {SPR_BSPI,4,3,{A_Chase},S_BSPI_RUN10,0,0},
+ {SPR_BSPI,4,3,{A_Chase},S_BSPI_RUN11,0,0},
+ {SPR_BSPI,5,3,{A_Chase},S_BSPI_RUN12,0,0},
+ {SPR_BSPI,5,3,{A_Chase},S_BSPI_RUN1,0,0},
+ {SPR_BSPI,32768,20,{A_FaceTarget},S_BSPI_ATK2,0,0},
+ {SPR_BSPI,32774,4,{A_BspiAttack},S_BSPI_ATK3,0,0},
+ {SPR_BSPI,32775,4,{NULL},S_BSPI_ATK4,0,0},
+ {SPR_BSPI,32775,1,{A_SpidRefire},S_BSPI_ATK2,0,0},
+ {SPR_BSPI,8,3,{NULL},S_BSPI_PAIN2,0,0},
+ {SPR_BSPI,8,3,{A_Pain},S_BSPI_RUN1,0,0},
+ {SPR_BSPI,9,20,{A_Scream},S_BSPI_DIE2,0,0},
+ {SPR_BSPI,10,7,{A_Fall},S_BSPI_DIE3,0,0},
+ {SPR_BSPI,11,7,{NULL},S_BSPI_DIE4,0,0},
+ {SPR_BSPI,12,7,{NULL},S_BSPI_DIE5,0,0},
+ {SPR_BSPI,13,7,{NULL},S_BSPI_DIE6,0,0},
+ {SPR_BSPI,14,7,{NULL},S_BSPI_DIE7,0,0},
+ {SPR_BSPI,15,-1,{A_BossDeath},S_NULL,0,0},
+ {SPR_BSPI,15,5,{NULL},S_BSPI_RAISE2,0,0},
+ {SPR_BSPI,14,5,{NULL},S_BSPI_RAISE3,0,0},
+ {SPR_BSPI,13,5,{NULL},S_BSPI_RAISE4,0,0},
+ {SPR_BSPI,12,5,{NULL},S_BSPI_RAISE5,0,0},
+ {SPR_BSPI,11,5,{NULL},S_BSPI_RAISE6,0,0},
+ {SPR_BSPI,10,5,{NULL},S_BSPI_RAISE7,0,0},
+ {SPR_BSPI,9,5,{NULL},S_BSPI_RUN1,0,0},
+ {SPR_APLS,32768,5,{NULL},S_ARACH_PLAZ2,0,0},
+ {SPR_APLS,32769,5,{NULL},S_ARACH_PLAZ,0,0},
+ {SPR_APBX,32768,5,{NULL},S_ARACH_PLEX2,0,0},
+ {SPR_APBX,32769,5,{NULL},S_ARACH_PLEX3,0,0},
+ {SPR_APBX,32770,5,{NULL},S_ARACH_PLEX4,0,0},
+ {SPR_APBX,32771,5,{NULL},S_ARACH_PLEX5,0,0},
+ {SPR_APBX,32772,5,{NULL},S_NULL,0,0},
+ {SPR_CYBR,0,10,{A_Look},S_CYBER_STND2,0,0},
+ {SPR_CYBR,1,10,{A_Look},S_CYBER_STND,0,0},
+ {SPR_CYBR,0,3,{A_Hoof},S_CYBER_RUN2,0,0},
+ {SPR_CYBR,0,3,{A_Chase},S_CYBER_RUN3,0,0},
+ {SPR_CYBR,1,3,{A_Chase},S_CYBER_RUN4,0,0},
+ {SPR_CYBR,1,3,{A_Chase},S_CYBER_RUN5,0,0},
+ {SPR_CYBR,2,3,{A_Chase},S_CYBER_RUN6,0,0},
+ {SPR_CYBR,2,3,{A_Chase},S_CYBER_RUN7,0,0},
+ {SPR_CYBR,3,3,{A_Metal},S_CYBER_RUN8,0,0},
+ {SPR_CYBR,3,3,{A_Chase},S_CYBER_RUN1,0,0},
+ {SPR_CYBR,4,6,{A_FaceTarget},S_CYBER_ATK2,0,0},
+ {SPR_CYBR,5,12,{A_CyberAttack},S_CYBER_ATK3,0,0},
+ {SPR_CYBR,4,12,{A_FaceTarget},S_CYBER_ATK4,0,0},
+ {SPR_CYBR,5,12,{A_CyberAttack},S_CYBER_ATK5,0,0},
+ {SPR_CYBR,4,12,{A_FaceTarget},S_CYBER_ATK6,0,0},
+ {SPR_CYBR,5,12,{A_CyberAttack},S_CYBER_RUN1,0,0},
+ {SPR_CYBR,6,10,{A_Pain},S_CYBER_RUN1,0,0},
+ {SPR_CYBR,7,10,{NULL},S_CYBER_DIE2,0,0},
+ {SPR_CYBR,8,10,{A_Scream},S_CYBER_DIE3,0,0},
+ {SPR_CYBR,9,10,{NULL},S_CYBER_DIE4,0,0},
+ {SPR_CYBR,10,10,{NULL},S_CYBER_DIE5,0,0},
+ {SPR_CYBR,11,10,{NULL},S_CYBER_DIE6,0,0},
+ {SPR_CYBR,12,10,{A_Fall},S_CYBER_DIE7,0,0},
+ {SPR_CYBR,13,10,{NULL},S_CYBER_DIE8,0,0},
+ {SPR_CYBR,14,10,{NULL},S_CYBER_DIE9,0,0},
+ {SPR_CYBR,15,30,{NULL},S_CYBER_DIE10,0,0},
+ {SPR_CYBR,15,-1,{A_BossDeath},S_NULL,0,0},
+ {SPR_PAIN,0,10,{A_Look},S_PAIN_STND,0,0},
+ {SPR_PAIN,0,3,{A_Chase},S_PAIN_RUN2,0,0},
+ {SPR_PAIN,0,3,{A_Chase},S_PAIN_RUN3,0,0},
+ {SPR_PAIN,1,3,{A_Chase},S_PAIN_RUN4,0,0},
+ {SPR_PAIN,1,3,{A_Chase},S_PAIN_RUN5,0,0},
+ {SPR_PAIN,2,3,{A_Chase},S_PAIN_RUN6,0,0},
+ {SPR_PAIN,2,3,{A_Chase},S_PAIN_RUN1,0,0},
+ {SPR_PAIN,3,5,{A_FaceTarget},S_PAIN_ATK2,0,0},
+ {SPR_PAIN,4,5,{A_FaceTarget},S_PAIN_ATK3,0,0},
+ {SPR_PAIN,32773,5,{A_FaceTarget},S_PAIN_ATK4,0,0},
+ {SPR_PAIN,32773,0,{A_PainAttack},S_PAIN_RUN1,0,0},
+ {SPR_PAIN,6,6,{NULL},S_PAIN_PAIN2,0,0},
+ {SPR_PAIN,6,6,{A_Pain},S_PAIN_RUN1,0,0},
+ {SPR_PAIN,32775,8,{NULL},S_PAIN_DIE2,0,0},
+ {SPR_PAIN,32776,8,{A_Scream},S_PAIN_DIE3,0,0},
+ {SPR_PAIN,32777,8,{NULL},S_PAIN_DIE4,0,0},
+ {SPR_PAIN,32778,8,{NULL},S_PAIN_DIE5,0,0},
+ {SPR_PAIN,32779,8,{A_PainDie},S_PAIN_DIE6,0,0},
+ {SPR_PAIN,32780,8,{NULL},S_NULL,0,0},
+ {SPR_PAIN,12,8,{NULL},S_PAIN_RAISE2,0,0},
+ {SPR_PAIN,11,8,{NULL},S_PAIN_RAISE3,0,0},
+ {SPR_PAIN,10,8,{NULL},S_PAIN_RAISE4,0,0},
+ {SPR_PAIN,9,8,{NULL},S_PAIN_RAISE5,0,0},
+ {SPR_PAIN,8,8,{NULL},S_PAIN_RAISE6,0,0},
+ {SPR_PAIN,7,8,{NULL},S_PAIN_RUN1,0,0},
+ {SPR_SSWV,0,10,{A_Look},S_SSWV_STND2,0,0},
+ {SPR_SSWV,1,10,{A_Look},S_SSWV_STND,0,0},
+ {SPR_SSWV,0,3,{A_Chase},S_SSWV_RUN2,0,0},
+ {SPR_SSWV,0,3,{A_Chase},S_SSWV_RUN3,0,0},
+ {SPR_SSWV,1,3,{A_Chase},S_SSWV_RUN4,0,0},
+ {SPR_SSWV,1,3,{A_Chase},S_SSWV_RUN5,0,0},
+ {SPR_SSWV,2,3,{A_Chase},S_SSWV_RUN6,0,0},
+ {SPR_SSWV,2,3,{A_Chase},S_SSWV_RUN7,0,0},
+ {SPR_SSWV,3,3,{A_Chase},S_SSWV_RUN8,0,0},
+ {SPR_SSWV,3,3,{A_Chase},S_SSWV_RUN1,0,0},
+ {SPR_SSWV,4,10,{A_FaceTarget},S_SSWV_ATK2,0,0},
+ {SPR_SSWV,5,10,{A_FaceTarget},S_SSWV_ATK3,0,0},
+ {SPR_SSWV,32774,4,{A_CPosAttack},S_SSWV_ATK4,0,0},
+ {SPR_SSWV,5,6,{A_FaceTarget},S_SSWV_ATK5,0,0},
+ {SPR_SSWV,32774,4,{A_CPosAttack},S_SSWV_ATK6,0,0},
+ {SPR_SSWV,5,1,{A_CPosRefire},S_SSWV_ATK2,0,0},
+ {SPR_SSWV,7,3,{NULL},S_SSWV_PAIN2,0,0},
+ {SPR_SSWV,7,3,{A_Pain},S_SSWV_RUN1,0,0},
+ {SPR_SSWV,8,5,{NULL},S_SSWV_DIE2,0,0},
+ {SPR_SSWV,9,5,{A_Scream},S_SSWV_DIE3,0,0},
+ {SPR_SSWV,10,5,{A_Fall},S_SSWV_DIE4,0,0},
+ {SPR_SSWV,11,5,{NULL},S_SSWV_DIE5,0,0},
+ {SPR_SSWV,12,-1,{NULL},S_NULL,0,0},
+ {SPR_SSWV,13,5,{NULL},S_SSWV_XDIE2,0,0},
+ {SPR_SSWV,14,5,{A_XScream},S_SSWV_XDIE3,0,0},
+ {SPR_SSWV,15,5,{A_Fall},S_SSWV_XDIE4,0,0},
+ {SPR_SSWV,16,5,{NULL},S_SSWV_XDIE5,0,0},
+ {SPR_SSWV,17,5,{NULL},S_SSWV_XDIE6,0,0},
+ {SPR_SSWV,18,5,{NULL},S_SSWV_XDIE7,0,0},
+ {SPR_SSWV,19,5,{NULL},S_SSWV_XDIE8,0,0},
+ {SPR_SSWV,20,5,{NULL},S_SSWV_XDIE9,0,0},
+ {SPR_SSWV,21,-1,{NULL},S_NULL,0,0},
+ {SPR_SSWV,12,5,{NULL},S_SSWV_RAISE2,0,0},
+ {SPR_SSWV,11,5,{NULL},S_SSWV_RAISE3,0,0},
+ {SPR_SSWV,10,5,{NULL},S_SSWV_RAISE4,0,0},
+ {SPR_SSWV,9,5,{NULL},S_SSWV_RAISE5,0,0},
+ {SPR_SSWV,8,5,{NULL},S_SSWV_RUN1,0,0},
+ {SPR_KEEN,0,-1,{NULL},S_KEENSTND,0,0},
+ {SPR_KEEN,0,6,{NULL},S_COMMKEEN2,0,0},
+ {SPR_KEEN,1,6,{NULL},S_COMMKEEN3,0,0},
+ {SPR_KEEN,2,6,{A_Scream},S_COMMKEEN4,0,0},
+ {SPR_KEEN,3,6,{NULL},S_COMMKEEN5,0,0},
+ {SPR_KEEN,4,6,{NULL},S_COMMKEEN6,0,0},
+ {SPR_KEEN,5,6,{NULL},S_COMMKEEN7,0,0},
+ {SPR_KEEN,6,6,{NULL},S_COMMKEEN8,0,0},
+ {SPR_KEEN,7,6,{NULL},S_COMMKEEN9,0,0},
+ {SPR_KEEN,8,6,{NULL},S_COMMKEEN10,0,0},
+ {SPR_KEEN,9,6,{NULL},S_COMMKEEN11,0,0},
+ {SPR_KEEN,10,6,{A_KeenDie},S_COMMKEEN12,0,0},
+ {SPR_KEEN,11,-1,{NULL},S_NULL,0,0},
+ {SPR_KEEN,12,4,{NULL},S_KEENPAIN2,0,0},
+ {SPR_KEEN,12,8,{A_Pain},S_KEENSTND,0,0},
+ {SPR_BBRN,0,-1,{NULL},S_NULL,0,0},
+ {SPR_BBRN,1,36,{A_BrainPain},S_BRAIN,0,0},
+ {SPR_BBRN,0,100,{A_BrainScream},S_BRAIN_DIE2,0,0},
+ {SPR_BBRN,0,10,{NULL},S_BRAIN_DIE3,0,0},
+ {SPR_BBRN,0,10,{NULL},S_BRAIN_DIE4,0,0},
+ {SPR_BBRN,0,-1,{A_BrainDie},S_NULL,0,0},
+ {SPR_SSWV,0,10,{A_Look},S_BRAINEYE,0,0},
+ {SPR_SSWV,0,181,{A_BrainAwake},S_BRAINEYE1,0,0},
+ {SPR_SSWV,0,150,{A_BrainSpit},S_BRAINEYE1,0,0},
+ {SPR_BOSF,32768,3,{A_SpawnSound},S_SPAWN2,0,0},
+ {SPR_BOSF,32769,3,{A_SpawnFly},S_SPAWN3,0,0},
+ {SPR_BOSF,32770,3,{A_SpawnFly},S_SPAWN4,0,0},
+ {SPR_BOSF,32771,3,{A_SpawnFly},S_SPAWN1,0,0},
+ {SPR_FIRE,32768,4,{A_Fire},S_SPAWNFIRE2,0,0},
+ {SPR_FIRE,32769,4,{A_Fire},S_SPAWNFIRE3,0,0},
+ {SPR_FIRE,32770,4,{A_Fire},S_SPAWNFIRE4,0,0},
+ {SPR_FIRE,32771,4,{A_Fire},S_SPAWNFIRE5,0,0},
+ {SPR_FIRE,32772,4,{A_Fire},S_SPAWNFIRE6,0,0},
+ {SPR_FIRE,32773,4,{A_Fire},S_SPAWNFIRE7,0,0},
+ {SPR_FIRE,32774,4,{A_Fire},S_SPAWNFIRE8,0,0},
+ {SPR_FIRE,32775,4,{A_Fire},S_NULL,0,0},
+ {SPR_MISL,32769,10,{NULL},S_BRAINEXPLODE2,0,0},
+ {SPR_MISL,32770,10,{NULL},S_BRAINEXPLODE3,0,0},
+ {SPR_MISL,32771,10,{A_BrainExplode},S_NULL,0,0},
+ {SPR_ARM1,0,6,{NULL},S_ARM1A,0,0},
+ {SPR_ARM1,32769,7,{NULL},S_ARM1,0,0},
+ {SPR_ARM2,0,6,{NULL},S_ARM2A,0,0},
+ {SPR_ARM2,32769,6,{NULL},S_ARM2,0,0},
+ {SPR_BAR1,0,6,{NULL},S_BAR2,0,0},
+ {SPR_BAR1,1,6,{NULL},S_BAR1,0,0},
+ {SPR_BEXP,32768,5,{NULL},S_BEXP2,0,0},
+ {SPR_BEXP,32769,5,{A_Scream},S_BEXP3,0,0},
+ {SPR_BEXP,32770,5,{NULL},S_BEXP4,0,0},
+ {SPR_BEXP,32771,10,{A_Explode},S_BEXP5,0,0},
+ {SPR_BEXP,32772,10,{NULL},S_NULL,0,0},
+ {SPR_FCAN,32768,4,{NULL},S_BBAR2,0,0},
+ {SPR_FCAN,32769,4,{NULL},S_BBAR3,0,0},
+ {SPR_FCAN,32770,4,{NULL},S_BBAR1,0,0},
+ {SPR_BON1,0,6,{NULL},S_BON1A,0,0},
+ {SPR_BON1,1,6,{NULL},S_BON1B,0,0},
+ {SPR_BON1,2,6,{NULL},S_BON1C,0,0},
+ {SPR_BON1,3,6,{NULL},S_BON1D,0,0},
+ {SPR_BON1,2,6,{NULL},S_BON1E,0,0},
+ {SPR_BON1,1,6,{NULL},S_BON1,0,0},
+ {SPR_BON2,0,6,{NULL},S_BON2A,0,0},
+ {SPR_BON2,1,6,{NULL},S_BON2B,0,0},
+ {SPR_BON2,2,6,{NULL},S_BON2C,0,0},
+ {SPR_BON2,3,6,{NULL},S_BON2D,0,0},
+ {SPR_BON2,2,6,{NULL},S_BON2E,0,0},
+ {SPR_BON2,1,6,{NULL},S_BON2,0,0},
+ {SPR_BKEY,0,10,{NULL},S_BKEY2,0,0},
+ {SPR_BKEY,32769,10,{NULL},S_BKEY,0,0},
+ {SPR_RKEY,0,10,{NULL},S_RKEY2,0,0},
+ {SPR_RKEY,32769,10,{NULL},S_RKEY,0,0},
+ {SPR_YKEY,0,10,{NULL},S_YKEY2,0,0},
+ {SPR_YKEY,32769,10,{NULL},S_YKEY,0,0},
+ {SPR_BSKU,0,10,{NULL},S_BSKULL2,0,0},
+ {SPR_BSKU,32769,10,{NULL},S_BSKULL,0,0},
+ {SPR_RSKU,0,10,{NULL},S_RSKULL2,0,0},
+ {SPR_RSKU,32769,10,{NULL},S_RSKULL,0,0},
+ {SPR_YSKU,0,10,{NULL},S_YSKULL2,0,0},
+ {SPR_YSKU,32769,10,{NULL},S_YSKULL,0,0},
+ {SPR_STIM,0,-1,{NULL},S_NULL,0,0},
+ {SPR_MEDI,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SOUL,32768,6,{NULL},S_SOUL2,0,0},
+ {SPR_SOUL,32769,6,{NULL},S_SOUL3,0,0},
+ {SPR_SOUL,32770,6,{NULL},S_SOUL4,0,0},
+ {SPR_SOUL,32771,6,{NULL},S_SOUL5,0,0},
+ {SPR_SOUL,32770,6,{NULL},S_SOUL6,0,0},
+ {SPR_SOUL,32769,6,{NULL},S_SOUL,0,0},
+ {SPR_PINV,32768,6,{NULL},S_PINV2,0,0},
+ {SPR_PINV,32769,6,{NULL},S_PINV3,0,0},
+ {SPR_PINV,32770,6,{NULL},S_PINV4,0,0},
+ {SPR_PINV,32771,6,{NULL},S_PINV,0,0},
+ {SPR_PSTR,32768,-1,{NULL},S_NULL,0,0},
+ {SPR_PINS,32768,6,{NULL},S_PINS2,0,0},
+ {SPR_PINS,32769,6,{NULL},S_PINS3,0,0},
+ {SPR_PINS,32770,6,{NULL},S_PINS4,0,0},
+ {SPR_PINS,32771,6,{NULL},S_PINS,0,0},
+ {SPR_MEGA,32768,6,{NULL},S_MEGA2,0,0},
+ {SPR_MEGA,32769,6,{NULL},S_MEGA3,0,0},
+ {SPR_MEGA,32770,6,{NULL},S_MEGA4,0,0},
+ {SPR_MEGA,32771,6,{NULL},S_MEGA,0,0},
+ {SPR_SUIT,32768,-1,{NULL},S_NULL,0,0},
+ {SPR_PMAP,32768,6,{NULL},S_PMAP2,0,0},
+ {SPR_PMAP,32769,6,{NULL},S_PMAP3,0,0},
+ {SPR_PMAP,32770,6,{NULL},S_PMAP4,0,0},
+ {SPR_PMAP,32771,6,{NULL},S_PMAP5,0,0},
+ {SPR_PMAP,32770,6,{NULL},S_PMAP6,0,0},
+ {SPR_PMAP,32769,6,{NULL},S_PMAP,0,0},
+ {SPR_PVIS,32768,6,{NULL},S_PVIS2,0,0},
+ {SPR_PVIS,1,6,{NULL},S_PVIS,0,0},
+ {SPR_CLIP,0,-1,{NULL},S_NULL,0,0},
+ {SPR_AMMO,0,-1,{NULL},S_NULL,0,0},
+ {SPR_ROCK,0,-1,{NULL},S_NULL,0,0},
+ {SPR_BROK,0,-1,{NULL},S_NULL,0,0},
+ {SPR_CELL,0,-1,{NULL},S_NULL,0,0},
+ {SPR_CELP,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SHEL,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SBOX,0,-1,{NULL},S_NULL,0,0},
+ {SPR_BPAK,0,-1,{NULL},S_NULL,0,0},
+ {SPR_BFUG,0,-1,{NULL},S_NULL,0,0},
+ {SPR_MGUN,0,-1,{NULL},S_NULL,0,0},
+ {SPR_CSAW,0,-1,{NULL},S_NULL,0,0},
+ {SPR_LAUN,0,-1,{NULL},S_NULL,0,0},
+ {SPR_PLAS,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SHOT,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SGN2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_COLU,32768,-1,{NULL},S_NULL,0,0},
+ {SPR_SMT2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_GOR1,0,10,{NULL},S_BLOODYTWITCH2,0,0},
+ {SPR_GOR1,1,15,{NULL},S_BLOODYTWITCH3,0,0},
+ {SPR_GOR1,2,8,{NULL},S_BLOODYTWITCH4,0,0},
+ {SPR_GOR1,1,6,{NULL},S_BLOODYTWITCH,0,0},
+ {SPR_PLAY,13,-1,{NULL},S_NULL,0,0},
+ {SPR_PLAY,18,-1,{NULL},S_NULL,0,0},
+ {SPR_POL2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_POL5,0,-1,{NULL},S_NULL,0,0},
+ {SPR_POL4,0,-1,{NULL},S_NULL,0,0},
+ {SPR_POL3,32768,6,{NULL},S_HEADCANDLES2,0,0},
+ {SPR_POL3,32769,6,{NULL},S_HEADCANDLES,0,0},
+ {SPR_POL1,0,-1,{NULL},S_NULL,0,0},
+ {SPR_POL6,0,6,{NULL},S_LIVESTICK2,0,0},
+ {SPR_POL6,1,8,{NULL},S_LIVESTICK,0,0},
+ {SPR_GOR2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_GOR3,0,-1,{NULL},S_NULL,0,0},
+ {SPR_GOR4,0,-1,{NULL},S_NULL,0,0},
+ {SPR_GOR5,0,-1,{NULL},S_NULL,0,0},
+ {SPR_SMIT,0,-1,{NULL},S_NULL,0,0},
+ {SPR_COL1,0,-1,{NULL},S_NULL,0,0},
+ {SPR_COL2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_COL3,0,-1,{NULL},S_NULL,0,0},
+ {SPR_COL4,0,-1,{NULL},S_NULL,0,0},
+ {SPR_CAND,32768,-1,{NULL},S_NULL,0,0},
+ {SPR_CBRA,32768,-1,{NULL},S_NULL,0,0},
+ {SPR_COL6,0,-1,{NULL},S_NULL,0,0},
+ {SPR_TRE1,0,-1,{NULL},S_NULL,0,0},
+ {SPR_TRE2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_ELEC,0,-1,{NULL},S_NULL,0,0},
+ {SPR_CEYE,32768,6,{NULL},S_EVILEYE2,0,0},
+ {SPR_CEYE,32769,6,{NULL},S_EVILEYE3,0,0},
+ {SPR_CEYE,32770,6,{NULL},S_EVILEYE4,0,0},
+ {SPR_CEYE,32769,6,{NULL},S_EVILEYE,0,0},
+ {SPR_FSKU,32768,6,{NULL},S_FLOATSKULL2,0,0},
+ {SPR_FSKU,32769,6,{NULL},S_FLOATSKULL3,0,0},
+ {SPR_FSKU,32770,6,{NULL},S_FLOATSKULL,0,0},
+ {SPR_COL5,0,14,{NULL},S_HEARTCOL2,0,0},
+ {SPR_COL5,1,14,{NULL},S_HEARTCOL,0,0},
+ {SPR_TBLU,32768,4,{NULL},S_BLUETORCH2,0,0},
+ {SPR_TBLU,32769,4,{NULL},S_BLUETORCH3,0,0},
+ {SPR_TBLU,32770,4,{NULL},S_BLUETORCH4,0,0},
+ {SPR_TBLU,32771,4,{NULL},S_BLUETORCH,0,0},
+ {SPR_TGRN,32768,4,{NULL},S_GREENTORCH2,0,0},
+ {SPR_TGRN,32769,4,{NULL},S_GREENTORCH3,0,0},
+ {SPR_TGRN,32770,4,{NULL},S_GREENTORCH4,0,0},
+ {SPR_TGRN,32771,4,{NULL},S_GREENTORCH,0,0},
+ {SPR_TRED,32768,4,{NULL},S_REDTORCH2,0,0},
+ {SPR_TRED,32769,4,{NULL},S_REDTORCH3,0,0},
+ {SPR_TRED,32770,4,{NULL},S_REDTORCH4,0,0},
+ {SPR_TRED,32771,4,{NULL},S_REDTORCH,0,0},
+ {SPR_SMBT,32768,4,{NULL},S_BTORCHSHRT2,0,0},
+ {SPR_SMBT,32769,4,{NULL},S_BTORCHSHRT3,0,0},
+ {SPR_SMBT,32770,4,{NULL},S_BTORCHSHRT4,0,0},
+ {SPR_SMBT,32771,4,{NULL},S_BTORCHSHRT,0,0},
+ {SPR_SMGT,32768,4,{NULL},S_GTORCHSHRT2,0,0},
+ {SPR_SMGT,32769,4,{NULL},S_GTORCHSHRT3,0,0},
+ {SPR_SMGT,32770,4,{NULL},S_GTORCHSHRT4,0,0},
+ {SPR_SMGT,32771,4,{NULL},S_GTORCHSHRT,0,0},
+ {SPR_SMRT,32768,4,{NULL},S_RTORCHSHRT2,0,0},
+ {SPR_SMRT,32769,4,{NULL},S_RTORCHSHRT3,0,0},
+ {SPR_SMRT,32770,4,{NULL},S_RTORCHSHRT4,0,0},
+ {SPR_SMRT,32771,4,{NULL},S_RTORCHSHRT,0,0},
+ {SPR_HDB1,0,-1,{NULL},S_NULL,0,0},
+ {SPR_HDB2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_HDB3,0,-1,{NULL},S_NULL,0,0},
+ {SPR_HDB4,0,-1,{NULL},S_NULL,0,0},
+ {SPR_HDB5,0,-1,{NULL},S_NULL,0,0},
+ {SPR_HDB6,0,-1,{NULL},S_NULL,0,0},
+ {SPR_POB1,0,-1,{NULL},S_NULL,0,0},
+ {SPR_POB2,0,-1,{NULL},S_NULL,0,0},
+ {SPR_BRS1,0,-1,{NULL},S_NULL,0,0},
+ {SPR_TLMP,32768,4,{NULL},S_TECHLAMP2,0,0},
+ {SPR_TLMP,32769,4,{NULL},S_TECHLAMP3,0,0},
+ {SPR_TLMP,32770,4,{NULL},S_TECHLAMP4,0,0},
+ {SPR_TLMP,32771,4,{NULL},S_TECHLAMP,0,0},
+ {SPR_TLP2,32768,4,{NULL},S_TECH2LAMP2,0,0},
+ {SPR_TLP2,32769,4,{NULL},S_TECH2LAMP3,0,0},
+ {SPR_TLP2,32770,4,{NULL},S_TECH2LAMP4,0,0},
+ {SPR_TLP2,32771,4,{NULL},S_TECH2LAMP,0,0}
};
mobjinfo_t mobjinfo[NUMMOBJTYPES] = {
- { // MT_PLAYER
- -1, // doomednum
- S_PLAY, // spawnstate
- 100, // spawnhealth
- S_PLAY_RUN1, // seestate
- sfx_None, // seesound
- 0, // reactiontime
- sfx_None, // attacksound
- S_PLAY_PAIN, // painstate
- 255, // painchance
- sfx_plpain, // painsound
- S_NULL, // meleestate
- S_PLAY_ATK1, // missilestate
- S_PLAY_DIE1, // deathstate
- S_PLAY_XDIE1, // xdeathstate
- sfx_pldeth, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_DROPOFF|MF_PICKUP|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_POSSESSED
- 3004, // doomednum
- S_POSS_STND, // spawnstate
- 20, // spawnhealth
- S_POSS_RUN1, // seestate
- sfx_posit1, // seesound
- 8, // reactiontime
- sfx_pistol, // attacksound
- S_POSS_PAIN, // painstate
- 200, // painchance
- sfx_popain, // painsound
- 0, // meleestate
- S_POSS_ATK1, // missilestate
- S_POSS_DIE1, // deathstate
- S_POSS_XDIE1, // xdeathstate
- sfx_podth1, // deathsound
- 8, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_posact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_POSS_RAISE1 // raisestate
- },
-
- { // MT_SHOTGUY
- 9, // doomednum
- S_SPOS_STND, // spawnstate
- 30, // spawnhealth
- S_SPOS_RUN1, // seestate
- sfx_posit2, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_SPOS_PAIN, // painstate
- 170, // painchance
- sfx_popain, // painsound
- 0, // meleestate
- S_SPOS_ATK1, // missilestate
- S_SPOS_DIE1, // deathstate
- S_SPOS_XDIE1, // xdeathstate
- sfx_podth2, // deathsound
- 8, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_posact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_SPOS_RAISE1 // raisestate
- },
-
- { // MT_VILE
- 64, // doomednum
- S_VILE_STND, // spawnstate
- 700, // spawnhealth
- S_VILE_RUN1, // seestate
- sfx_vilsit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_VILE_PAIN, // painstate
- 10, // painchance
- sfx_vipain, // painsound
- 0, // meleestate
- S_VILE_ATK1, // missilestate
- S_VILE_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_vildth, // deathsound
- 15, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 500, // mass
- 0, // damage
- sfx_vilact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_NULL // raisestate
- },
-
- { // MT_FIRE
- -1, // doomednum
- S_FIRE1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_UNDEAD
- 66, // doomednum
- S_SKEL_STND, // spawnstate
- 300, // spawnhealth
- S_SKEL_RUN1, // seestate
- sfx_skesit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_SKEL_PAIN, // painstate
- 100, // painchance
- sfx_popain, // painsound
- S_SKEL_FIST1, // meleestate
- S_SKEL_MISS1, // missilestate
- S_SKEL_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_skedth, // deathsound
- 10, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 500, // mass
- 0, // damage
- sfx_skeact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_SKEL_RAISE1 // raisestate
- },
-
- { // MT_TRACER
- -1, // doomednum
- S_TRACER, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_skeatk, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_TRACEEXP1, // deathstate
- S_NULL, // xdeathstate
- sfx_barexp, // deathsound
- 10*FRACUNIT, // speed
- 11*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 10, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_SMOKE
- -1, // doomednum
- S_SMOKE1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_FATSO
- 67, // doomednum
- S_FATT_STND, // spawnstate
- 600, // spawnhealth
- S_FATT_RUN1, // seestate
- sfx_mansit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_FATT_PAIN, // painstate
- 80, // painchance
- sfx_mnpain, // painsound
- 0, // meleestate
- S_FATT_ATK1, // missilestate
- S_FATT_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_mandth, // deathsound
- 8, // speed
- 48*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 1000, // mass
- 0, // damage
- sfx_posact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_FATT_RAISE1 // raisestate
- },
-
- { // MT_FATSHOT
- -1, // doomednum
- S_FATSHOT1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_firsht, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_FATSHOTX1, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 20*FRACUNIT, // speed
- 6*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 8, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_CHAINGUY
- 65, // doomednum
- S_CPOS_STND, // spawnstate
- 70, // spawnhealth
- S_CPOS_RUN1, // seestate
- sfx_posit2, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_CPOS_PAIN, // painstate
- 170, // painchance
- sfx_popain, // painsound
- 0, // meleestate
- S_CPOS_ATK1, // missilestate
- S_CPOS_DIE1, // deathstate
- S_CPOS_XDIE1, // xdeathstate
- sfx_podth2, // deathsound
- 8, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_posact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_CPOS_RAISE1 // raisestate
- },
-
- { // MT_TROOP
- 3001, // doomednum
- S_TROO_STND, // spawnstate
- 60, // spawnhealth
- S_TROO_RUN1, // seestate
- sfx_bgsit1, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_TROO_PAIN, // painstate
- 200, // painchance
- sfx_popain, // painsound
- S_TROO_ATK1, // meleestate
- S_TROO_ATK1, // missilestate
- S_TROO_DIE1, // deathstate
- S_TROO_XDIE1, // xdeathstate
- sfx_bgdth1, // deathsound
- 8, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_bgact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_TROO_RAISE1 // raisestate
- },
-
- { // MT_SERGEANT
- 3002, // doomednum
- S_SARG_STND, // spawnstate
- 150, // spawnhealth
- S_SARG_RUN1, // seestate
- sfx_sgtsit, // seesound
- 8, // reactiontime
- sfx_sgtatk, // attacksound
- S_SARG_PAIN, // painstate
- 180, // painchance
- sfx_dmpain, // painsound
- S_SARG_ATK1, // meleestate
- 0, // missilestate
- S_SARG_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_sgtdth, // deathsound
- 10, // speed
- 30*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 400, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_SARG_RAISE1 // raisestate
- },
-
- { // MT_SHADOWS
- 58, // doomednum
- S_SARG_STND, // spawnstate
- 150, // spawnhealth
- S_SARG_RUN1, // seestate
- sfx_sgtsit, // seesound
- 8, // reactiontime
- sfx_sgtatk, // attacksound
- S_SARG_PAIN, // painstate
- 180, // painchance
- sfx_dmpain, // painsound
- S_SARG_ATK1, // meleestate
- 0, // missilestate
- S_SARG_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_sgtdth, // deathsound
- 10, // speed
- 30*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 400, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_SHADOW|MF_COUNTKILL, // flags
- S_SARG_RAISE1 // raisestate
- },
-
- { // MT_HEAD
- 3005, // doomednum
- S_HEAD_STND, // spawnstate
- 400, // spawnhealth
- S_HEAD_RUN1, // seestate
- sfx_cacsit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_HEAD_PAIN, // painstate
- 128, // painchance
- sfx_dmpain, // painsound
- 0, // meleestate
- S_HEAD_ATK1, // missilestate
- S_HEAD_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_cacdth, // deathsound
- 8, // speed
- 31*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 400, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_FLOAT|MF_NOGRAVITY|MF_COUNTKILL, // flags
- S_HEAD_RAISE1 // raisestate
- },
-
- { // MT_BRUISER
- 3003, // doomednum
- S_BOSS_STND, // spawnstate
- 1000, // spawnhealth
- S_BOSS_RUN1, // seestate
- sfx_brssit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_BOSS_PAIN, // painstate
- 50, // painchance
- sfx_dmpain, // painsound
- S_BOSS_ATK1, // meleestate
- S_BOSS_ATK1, // missilestate
- S_BOSS_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_brsdth, // deathsound
- 8, // speed
- 24*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 1000, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_BOSS_RAISE1 // raisestate
- },
-
- { // MT_BRUISERSHOT
- -1, // doomednum
- S_BRBALL1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_firsht, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_BRBALLX1, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 15*FRACUNIT, // speed
- 6*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 8, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_KNIGHT
- 69, // doomednum
- S_BOS2_STND, // spawnstate
- 500, // spawnhealth
- S_BOS2_RUN1, // seestate
- sfx_kntsit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_BOS2_PAIN, // painstate
- 50, // painchance
- sfx_dmpain, // painsound
- S_BOS2_ATK1, // meleestate
- S_BOS2_ATK1, // missilestate
- S_BOS2_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_kntdth, // deathsound
- 8, // speed
- 24*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 1000, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_BOS2_RAISE1 // raisestate
- },
-
- { // MT_SKULL
- 3006, // doomednum
- S_SKULL_STND, // spawnstate
- 100, // spawnhealth
- S_SKULL_RUN1, // seestate
- 0, // seesound
- 8, // reactiontime
- sfx_sklatk, // attacksound
- S_SKULL_PAIN, // painstate
- 256, // painchance
- sfx_dmpain, // painsound
- 0, // meleestate
- S_SKULL_ATK1, // missilestate
- S_SKULL_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 8, // speed
- 16*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 50, // mass
- 3, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_FLOAT|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_SPIDER
- 7, // doomednum
- S_SPID_STND, // spawnstate
- 3000, // spawnhealth
- S_SPID_RUN1, // seestate
- sfx_spisit, // seesound
- 8, // reactiontime
- sfx_shotgn, // attacksound
- S_SPID_PAIN, // painstate
- 40, // painchance
- sfx_dmpain, // painsound
- 0, // meleestate
- S_SPID_ATK1, // missilestate
- S_SPID_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_spidth, // deathsound
- 12, // speed
- 128*FRACUNIT, // radius
- 100*FRACUNIT, // height
- 1000, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_NULL // raisestate
- },
-
- { // MT_BABY
- 68, // doomednum
- S_BSPI_STND, // spawnstate
- 500, // spawnhealth
- S_BSPI_SIGHT, // seestate
- sfx_bspsit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_BSPI_PAIN, // painstate
- 128, // painchance
- sfx_dmpain, // painsound
- 0, // meleestate
- S_BSPI_ATK1, // missilestate
- S_BSPI_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_bspdth, // deathsound
- 12, // speed
- 64*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 600, // mass
- 0, // damage
- sfx_bspact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_BSPI_RAISE1 // raisestate
- },
-
- { // MT_CYBORG
- 16, // doomednum
- S_CYBER_STND, // spawnstate
- 4000, // spawnhealth
- S_CYBER_RUN1, // seestate
- sfx_cybsit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_CYBER_PAIN, // painstate
- 20, // painchance
- sfx_dmpain, // painsound
- 0, // meleestate
- S_CYBER_ATK1, // missilestate
- S_CYBER_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_cybdth, // deathsound
- 16, // speed
- 40*FRACUNIT, // radius
- 110*FRACUNIT, // height
- 1000, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_NULL // raisestate
- },
-
- { // MT_PAIN
- 71, // doomednum
- S_PAIN_STND, // spawnstate
- 400, // spawnhealth
- S_PAIN_RUN1, // seestate
- sfx_pesit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_PAIN_PAIN, // painstate
- 128, // painchance
- sfx_pepain, // painsound
- 0, // meleestate
- S_PAIN_ATK1, // missilestate
- S_PAIN_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_pedth, // deathsound
- 8, // speed
- 31*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 400, // mass
- 0, // damage
- sfx_dmact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_FLOAT|MF_NOGRAVITY|MF_COUNTKILL, // flags
- S_PAIN_RAISE1 // raisestate
- },
-
- { // MT_WOLFSS
- 84, // doomednum
- S_SSWV_STND, // spawnstate
- 50, // spawnhealth
- S_SSWV_RUN1, // seestate
- sfx_sssit, // seesound
- 8, // reactiontime
- 0, // attacksound
- S_SSWV_PAIN, // painstate
- 170, // painchance
- sfx_popain, // painsound
- 0, // meleestate
- S_SSWV_ATK1, // missilestate
- S_SSWV_DIE1, // deathstate
- S_SSWV_XDIE1, // xdeathstate
- sfx_ssdth, // deathsound
- 8, // speed
- 20*FRACUNIT, // radius
- 56*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_posact, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_SSWV_RAISE1 // raisestate
- },
-
- { // MT_KEEN
- 72, // doomednum
- S_KEENSTND, // spawnstate
- 100, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_KEENPAIN, // painstate
- 256, // painchance
- sfx_keenpn, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_COMMKEEN, // deathstate
- S_NULL, // xdeathstate
- sfx_keendt, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 72*FRACUNIT, // height
- 10000000, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY|MF_SHOOTABLE|MF_COUNTKILL, // flags
- S_NULL // raisestate
- },
-
- { // MT_BOSSBRAIN
- 88, // doomednum
- S_BRAIN, // spawnstate
- 250, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_BRAIN_PAIN, // painstate
- 255, // painchance
- sfx_bospn, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_BRAIN_DIE1, // deathstate
- S_NULL, // xdeathstate
- sfx_bosdth, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 10000000, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SHOOTABLE, // flags
- S_NULL // raisestate
- },
-
- { // MT_BOSSSPIT
- 89, // doomednum
- S_BRAINEYE, // spawnstate
- 1000, // spawnhealth
- S_BRAINEYESEE, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 32*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOSECTOR, // flags
- S_NULL // raisestate
- },
-
- { // MT_BOSSTARGET
- 87, // doomednum
- S_NULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 32*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOSECTOR, // flags
- S_NULL // raisestate
- },
-
- { // MT_SPAWNSHOT
- -1, // doomednum
- S_SPAWN1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_bospit, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 10*FRACUNIT, // speed
- 6*FRACUNIT, // radius
- 32*FRACUNIT, // height
- 100, // mass
- 3, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY|MF_NOCLIP, // flags
- S_NULL // raisestate
- },
-
- { // MT_SPAWNFIRE
- -1, // doomednum
- S_SPAWNFIRE1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_BARREL
- 2035, // doomednum
- S_BAR1, // spawnstate
- 20, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_BEXP, // deathstate
- S_NULL, // xdeathstate
- sfx_barexp, // deathsound
- 0, // speed
- 10*FRACUNIT, // radius
- 42*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_NOBLOOD, // flags
- S_NULL // raisestate
- },
-
- { // MT_TROOPSHOT
- -1, // doomednum
- S_TBALL1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_firsht, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_TBALLX1, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 10*FRACUNIT, // speed
- 6*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 3, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_HEADSHOT
- -1, // doomednum
- S_RBALL1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_firsht, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_RBALLX1, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 10*FRACUNIT, // speed
- 6*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 5, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_ROCKET
- -1, // doomednum
- S_ROCKET, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_rlaunc, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_EXPLODE1, // deathstate
- S_NULL, // xdeathstate
- sfx_barexp, // deathsound
- 20*FRACUNIT, // speed
- 11*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 20, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_PLASMA
- -1, // doomednum
- S_PLASBALL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_plasma, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_PLASEXP, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 25*FRACUNIT, // speed
- 13*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 5, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_BFG
- -1, // doomednum
- S_BFGSHOT, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- 0, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_BFGLAND, // deathstate
- S_NULL, // xdeathstate
- sfx_rxplod, // deathsound
- 25*FRACUNIT, // speed
- 13*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 100, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_ARACHPLAZ
- -1, // doomednum
- S_ARACH_PLAZ, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_plasma, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_ARACH_PLEX, // deathstate
- S_NULL, // xdeathstate
- sfx_firxpl, // deathsound
- 25*FRACUNIT, // speed
- 13*FRACUNIT, // radius
- 8*FRACUNIT, // height
- 100, // mass
- 5, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_MISSILE|MF_DROPOFF|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_PUFF
- -1, // doomednum
- S_PUFF1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_BLOOD
- -1, // doomednum
- S_BLOOD1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP, // flags
- S_NULL // raisestate
- },
-
- { // MT_TFOG
- -1, // doomednum
- S_TFOG, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_IFOG
- -1, // doomednum
- S_IFOG, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_TELEPORTMAN
- 14, // doomednum
- S_NULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOSECTOR, // flags
- S_NULL // raisestate
- },
-
- { // MT_EXTRABFG
- -1, // doomednum
- S_BFGEXP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC0
- 2018, // doomednum
- S_ARM1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC1
- 2019, // doomednum
- S_ARM2, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC2
- 2014, // doomednum
- S_BON1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC3
- 2015, // doomednum
- S_BON2, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC4
- 5, // doomednum
- S_BKEY, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC5
- 13, // doomednum
- S_RKEY, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC6
- 6, // doomednum
- S_YKEY, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC7
- 39, // doomednum
- S_YSKULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC8
- 38, // doomednum
- S_RSKULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC9
- 40, // doomednum
- S_BSKULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_NOTDMATCH, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC10
- 2011, // doomednum
- S_STIM, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC11
- 2012, // doomednum
- S_MEDI, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC12
- 2013, // doomednum
- S_SOUL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_INV
- 2022, // doomednum
- S_PINV, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC13
- 2023, // doomednum
- S_PSTR, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_INS
- 2024, // doomednum
- S_PINS, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC14
- 2025, // doomednum
- S_SUIT, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC15
- 2026, // doomednum
- S_PMAP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC16
- 2045, // doomednum
- S_PVIS, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_MEGA
- 83, // doomednum
- S_MEGA, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL|MF_COUNTITEM, // flags
- S_NULL // raisestate
- },
-
- { // MT_CLIP
- 2007, // doomednum
- S_CLIP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC17
- 2048, // doomednum
- S_AMMO, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC18
- 2010, // doomednum
- S_ROCK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC19
- 2046, // doomednum
- S_BROK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC20
- 2047, // doomednum
- S_CELL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC21
- 17, // doomednum
- S_CELP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC22
- 2008, // doomednum
- S_SHEL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC23
- 2049, // doomednum
- S_SBOX, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC24
- 8, // doomednum
- S_BPAK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC25
- 2006, // doomednum
- S_BFUG, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_CHAINGUN
- 2002, // doomednum
- S_MGUN, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC26
- 2005, // doomednum
- S_CSAW, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC27
- 2003, // doomednum
- S_LAUN, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC28
- 2004, // doomednum
- S_PLAS, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_SHOTGUN
- 2001, // doomednum
- S_SHOT, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_SUPERSHOTGUN
- 82, // doomednum
- S_SHOT2, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPECIAL, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC29
- 85, // doomednum
- S_TECHLAMP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC30
- 86, // doomednum
- S_TECH2LAMP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC31
- 2028, // doomednum
- S_COLU, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC32
- 30, // doomednum
- S_TALLGRNCOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC33
- 31, // doomednum
- S_SHRTGRNCOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC34
- 32, // doomednum
- S_TALLREDCOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC35
- 33, // doomednum
- S_SHRTREDCOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC36
- 37, // doomednum
- S_SKULLCOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC37
- 36, // doomednum
- S_HEARTCOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC38
- 41, // doomednum
- S_EVILEYE, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC39
- 42, // doomednum
- S_FLOATSKULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC40
- 43, // doomednum
- S_TORCHTREE, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC41
- 44, // doomednum
- S_BLUETORCH, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC42
- 45, // doomednum
- S_GREENTORCH, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC43
- 46, // doomednum
- S_REDTORCH, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC44
- 55, // doomednum
- S_BTORCHSHRT, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC45
- 56, // doomednum
- S_GTORCHSHRT, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC46
- 57, // doomednum
- S_RTORCHSHRT, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC47
- 47, // doomednum
- S_STALAGTITE, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC48
- 48, // doomednum
- S_TECHPILLAR, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC49
- 34, // doomednum
- S_CANDLESTIK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC50
- 35, // doomednum
- S_CANDELABRA, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC51
- 49, // doomednum
- S_BLOODYTWITCH, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 68*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC52
- 50, // doomednum
- S_MEAT2, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 84*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC53
- 51, // doomednum
- S_MEAT3, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 84*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC54
- 52, // doomednum
- S_MEAT4, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 68*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC55
- 53, // doomednum
- S_MEAT5, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 52*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC56
- 59, // doomednum
- S_MEAT2, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 84*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC57
- 60, // doomednum
- S_MEAT4, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 68*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC58
- 61, // doomednum
- S_MEAT3, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 52*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC59
- 62, // doomednum
- S_MEAT5, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 52*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC60
- 63, // doomednum
- S_BLOODYTWITCH, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 68*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC61
- 22, // doomednum
- S_HEAD_DIE6, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC62
- 15, // doomednum
- S_PLAY_DIE7, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC63
- 18, // doomednum
- S_POSS_DIE5, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC64
- 21, // doomednum
- S_SARG_DIE6, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC65
- 23, // doomednum
- S_SKULL_DIE6, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC66
- 20, // doomednum
- S_TROO_DIE5, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC67
- 19, // doomednum
- S_SPOS_DIE5, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC68
- 10, // doomednum
- S_PLAY_XDIE9, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC69
- 12, // doomednum
- S_PLAY_XDIE9, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC70
- 28, // doomednum
- S_HEADSONSTICK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC71
- 24, // doomednum
- S_GIBS, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- 0, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC72
- 27, // doomednum
- S_HEADONASTICK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC73
- 29, // doomednum
- S_HEADCANDLES, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC74
- 25, // doomednum
- S_DEADSTICK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC75
- 26, // doomednum
- S_LIVESTICK, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC76
- 54, // doomednum
- S_BIGTREE, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 32*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC77
- 70, // doomednum
- S_BBAR1, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC78
- 73, // doomednum
- S_HANGNOGUTS, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 88*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC79
- 74, // doomednum
- S_HANGBNOBRAIN, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 88*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC80
- 75, // doomednum
- S_HANGTLOOKDN, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC81
- 76, // doomednum
- S_HANGTSKULL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC82
- 77, // doomednum
- S_HANGTLOOKUP, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC83
- 78, // doomednum
- S_HANGTNOBRAIN, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 16*FRACUNIT, // radius
- 64*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_SOLID|MF_SPAWNCEILING|MF_NOGRAVITY, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC84
- 79, // doomednum
- S_COLONGIBS, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC85
- 80, // doomednum
- S_SMALLPOOL, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP, // flags
- S_NULL // raisestate
- },
-
- { // MT_MISC86
- 81, // doomednum
- S_BRAINSTEM, // spawnstate
- 1000, // spawnhealth
- S_NULL, // seestate
- sfx_None, // seesound
- 8, // reactiontime
- sfx_None, // attacksound
- S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
- S_NULL, // meleestate
- S_NULL, // missilestate
- S_NULL, // deathstate
- S_NULL, // xdeathstate
- sfx_None, // deathsound
- 0, // speed
- 20*FRACUNIT, // radius
- 16*FRACUNIT, // height
- 100, // mass
- 0, // damage
- sfx_None, // activesound
- MF_NOBLOCKMAP, // flags
- S_NULL // raisestate
+ {
+ -1,
+ S_PLAY,
+ 100,
+ S_PLAY_RUN1,
+ sfx_None,
+ 0,
+ sfx_None,
+ S_PLAY_PAIN,
+ 255,
+ sfx_plpain,
+ S_NULL,
+ S_PLAY_ATK1,
+ S_PLAY_DIE1,
+ S_PLAY_XDIE1,
+ sfx_pldeth,
+ 0,
+ 16*FRACUNIT,
+ 56*FRACUNIT,
+ 100,
+ 0,
+ sfx_None,
+ MF_SOLID|MF_SHOOTABLE|MF_DROPOFF|MF_PICKUP|MF_NOTDMATCH,
+ S_NULL
+ },
+
+ {
+ 3004,
+ S_POSS_STND,
+ 20,
+ S_POSS_RUN1,
+ sfx_posit1,
+ 8,
+ sfx_pistol,
+ S_POSS_PAIN,
+ 200,
