Subversion Repositories Kolibri OS

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

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

//

// $Id:$

//

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

//

// This source is available for distribution and/or modification

// only under the terms of the DOOM Source Code License as

// published by id Software. All rights reserved.

//

// The source is distributed in the hope that it will be useful,

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

// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License

// for more details.

//

// $Log:$

//

// DESCRIPTION:

//      Movement, collision handling.

//      Shooting and aiming.

//

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

static const char

rcsid[] = "$Id: p_map.c,v 1.5 1997/02/03 22:45:11 b1 Exp $";

#include 

#include "doomtype.h"

#include "m_bbox.h"

#include "m_random.h"

#include "i_system.h"

#include "doomdef.h"

#include "p_local.h"

#include "s_sound.h"

// State.

#include "doomstat.h"

#include "r_state.h"

// Data.

#include "sounds.h"

fixed_t         tmbbox[4];

mobj_t*         tmthing;

int             tmflags;

fixed_t         tmx;

fixed_t         tmy;

// If "floatok" true, move would be ok

// if within "tmfloorz - tmceilingz".

boolean         floatok;

fixed_t         tmfloorz;

fixed_t         tmceilingz;

fixed_t         tmdropoffz;

// keep track of the line that lowers the ceiling,

// so missiles don't explode against sky hack walls

line_t*         ceilingline;

// keep track of special lines as they are hit,

// but don't process them until the move is proven valid

#define MAXSPECIALCROSS         8

line_t*         spechit[MAXSPECIALCROSS];

int             numspechit;

//

// TELEPORT MOVE

//

//

// PIT_StompThing

//

boolean PIT_StompThing (mobj_t* thing)

{

    fixed_t     blockdist;

    if (!(thing->flags & MF_SHOOTABLE) )

        return true;

    blockdist = thing->radius + tmthing->radius;

    if ( abs(thing->x - tmx) >= blockdist

         || abs(thing->y - tmy) >= blockdist )

    {

        // didn't hit it

        return true;

    }

    // don't clip against self

    if (thing == tmthing)

        return true;

    // monsters don't stomp things except on boss level

    if ( !tmthing->player && gamemap != 30)

        return false;

    P_DamageMobj (thing, tmthing, tmthing, 10000);

    return true;

}

//

// P_TeleportMove

//

boolean

P_TeleportMove

( mobj_t*       thing,

  fixed_t       x,

  fixed_t       y )

{

    int                 xl;

    int                 xh;

    int                 yl;

    int                 yh;

    int                 bx;

    int                 by;

    subsector_t*        newsubsec;

    // kill anything occupying the position

    tmthing = thing;

    tmflags = thing->flags;

    tmx = x;

    tmy = y;

    tmbbox[BOXTOP] = y + tmthing->radius;

    tmbbox[BOXBOTTOM] = y - tmthing->radius;

    tmbbox[BOXRIGHT] = x + tmthing->radius;

    tmbbox[BOXLEFT] = x - tmthing->radius;

    newsubsec = R_PointInSubsector (x,y);

    ceilingline = NULL;

    // The base floor/ceiling is from the subsector

    // that contains the point.

    // Any contacted lines the step closer together

    // will adjust them.

    tmfloorz = tmdropoffz = newsubsec->sector->floorheight;

    tmceilingz = newsubsec->sector->ceilingheight;

    validcount++;

    numspechit = 0;

    // stomp on any things contacted

    xl = (tmbbox[BOXLEFT] - bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT;

    xh = (tmbbox[BOXRIGHT] - bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT;

    yl = (tmbbox[BOXBOTTOM] - bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT;

    yh = (tmbbox[BOXTOP] - bmaporgy + MAXRADIUS)>>MAPBLOCKSHIFT;

    for (bx=xl ; bx<=xh ; bx++)

        for (by=yl ; by<=yh ; by++)

            if (!P_BlockThingsIterator(bx,by,PIT_StompThing))

                return false;

    // the move is ok,

    // so link the thing into its new position

    P_UnsetThingPosition (thing);

    thing->floorz = tmfloorz;

    thing->ceilingz = tmceilingz;

    thing->x = x;

    thing->y = y;

    P_SetThingPosition (thing);

    return true;

}

//

// MOVEMENT ITERATOR FUNCTIONS

//

//

// PIT_CheckLine

// Adjusts tmfloorz and tmceilingz as lines are contacted

//

boolean PIT_CheckLine (line_t* ld)

{

    if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT]

        || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT]

        || tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM]

        || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP] )

        return true;

    if (P_BoxOnLineSide (tmbbox, ld) != -1)

        return true;

    // A line has been hit

    // The moving thing's destination position will cross

    // the given line.

    // If this should not be allowed, return false.

    // If the line is special, keep track of it

    // to process later if the move is proven ok.

    // NOTE: specials are NOT sorted by order,

    // so two special lines that are only 8 pixels apart

    // could be crossed in either order.

    if (!ld->backsector)

        return false;           // one sided line

    if (!(tmthing->flags & MF_MISSILE) )

    {

        if ( ld->flags & ML_BLOCKING )

            return false;       // explicitly blocking everything

        if ( !tmthing->player && ld->flags & ML_BLOCKMONSTERS )

            return false;       // block monsters only

    }

    // set openrange, opentop, openbottom

    P_LineOpening (ld);

    // adjust floor / ceiling heights

    if (opentop < tmceilingz)

    {

        tmceilingz = opentop;

        ceilingline = ld;

    }

    if (openbottom > tmfloorz)

        tmfloorz = openbottom;

    if (lowfloor < tmdropoffz)

        tmdropoffz = lowfloor;

    // if contacted a special line, add it to the list

    if (ld->special)

    {

        spechit[numspechit] = ld;

        numspechit++;

    }

    return true;

}

//

// PIT_CheckThing

//

boolean PIT_CheckThing (mobj_t* thing)

{

    fixed_t             blockdist;

    boolean             solid;

    int                 damage;

    if (!(thing->flags & (MF_SOLID|MF_SPECIAL|MF_SHOOTABLE) ))

        return true;

    blockdist = thing->radius + tmthing->radius;

    if ( abs(thing->x - tmx) >= blockdist

         || abs(thing->y - tmy) >= blockdist )

    {

        // didn't hit it

        return true;

    }

    // don't clip against self

    if (thing == tmthing)

        return true;

    // check for skulls slamming into things

    if (tmthing->flags & MF_SKULLFLY)

    {

        damage = ((P_Random()%8)+1)*tmthing->info->damage;

        P_DamageMobj (thing, tmthing, tmthing, damage);

        tmthing->flags &= ~MF_SKULLFLY;

        tmthing->momx = tmthing->momy = tmthing->momz = 0;

        P_SetMobjState (tmthing, tmthing->info->spawnstate);

        return false;           // stop moving

    }

    // missiles can hit other things

    if (tmthing->flags & MF_MISSILE)

    {

        // see if it went over / under

        if (tmthing->z > thing->z + thing->height)

            return true;                // overhead

        if (tmthing->z+tmthing->height < thing->z)

            return true;                // underneath

        if (tmthing->target && (

            tmthing->target->type == thing->type ||

            (tmthing->target->type == MT_KNIGHT && thing->type == MT_BRUISER)||

            (tmthing->target->type == MT_BRUISER && thing->type == MT_KNIGHT) ) )

        {

            // Don't hit same species as originator.

            if (thing == tmthing->target)

                return true;

            if (thing->type != MT_PLAYER)

            {

                // Explode, but do no damage.

                // Let players missile other players.

                return false;

            }

        }

        if (! (thing->flags & MF_SHOOTABLE) )

        {

            // didn't do any damage

            return !(thing->flags & MF_SOLID);

        }

        // damage / explode

        damage = ((P_Random()%8)+1)*tmthing->info->damage;

        P_DamageMobj (thing, tmthing, tmthing->target, damage);

        // don't traverse any more

        return false;

    }

    // check for special pickup

    if (thing->flags & MF_SPECIAL)

    {

        solid = thing->flags&MF_SOLID;

        if (tmflags&MF_PICKUP)

        {

            // can remove thing

            P_TouchSpecialThing (thing, tmthing);

        }

        return !solid;

    }

    return !(thing->flags & MF_SOLID);

}

//

// MOVEMENT CLIPPING

//

//

// P_CheckPosition

// This is purely informative, nothing is modified

// (except things picked up).

//

// in:

//  a mobj_t (can be valid or invalid)

//  a position to be checked

//   (doesn't need to be related to the mobj_t->x,y)

//

// during:

//  special things are touched if MF_PICKUP

//  early out on solid lines?

//

// out:

//  newsubsec

//  floorz

//  ceilingz

//  tmdropoffz

//   the lowest point contacted

//   (monsters won't move to a dropoff)

//  speciallines[]

//  numspeciallines

//

boolean

P_CheckPosition

( mobj_t*       thing,

  fixed_t       x,

  fixed_t       y )

{

    int                 xl;

    int                 xh;

    int                 yl;

    int                 yh;

    int                 bx;

    int                 by;

    subsector_t*        newsubsec;

    tmthing = thing;

    tmflags = thing->flags;

    tmx = x;

    tmy = y;

    tmbbox[BOXTOP] = y + tmthing->radius;

    tmbbox[BOXBOTTOM] = y - tmthing->radius;

    tmbbox[BOXRIGHT] = x + tmthing->radius;

    tmbbox[BOXLEFT] = x - tmthing->radius;

    newsubsec = R_PointInSubsector (x,y);

    ceilingline = NULL;

    // The base floor / ceiling is from the subsector

    // that contains the point.

    // Any contacted lines the step closer together

    // will adjust them.

    tmfloorz = tmdropoffz = newsubsec->sector->floorheight;

    tmceilingz = newsubsec->sector->ceilingheight;

    validcount++;

    numspechit = 0;

    if ( tmflags & MF_NOCLIP )

        return true;

    // Check things first, possibly picking things up.

    // The bounding box is extended by MAXRADIUS

    // because mobj_ts are grouped into mapblocks

    // based on their origin point, and can overlap

    // into adjacent blocks by up to MAXRADIUS units.

    xl = (tmbbox[BOXLEFT] - bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT;

    xh = (tmbbox[BOXRIGHT] - bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT;

    yl = (tmbbox[BOXBOTTOM] - bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT;

    yh = (tmbbox[BOXTOP] - bmaporgy + MAXRADIUS)>>MAPBLOCKSHIFT;

    for (bx=xl ; bx<=xh ; bx++)

        for (by=yl ; by<=yh ; by++)

            if (!P_BlockThingsIterator(bx,by,PIT_CheckThing))

                return false;

    // check lines

    xl = (tmbbox[BOXLEFT] - bmaporgx)>>MAPBLOCKSHIFT;

    xh = (tmbbox[BOXRIGHT] - bmaporgx)>>MAPBLOCKSHIFT;

    yl = (tmbbox[BOXBOTTOM] - bmaporgy)>>MAPBLOCKSHIFT;

    yh = (tmbbox[BOXTOP] - bmaporgy)>>MAPBLOCKSHIFT;

    for (bx=xl ; bx<=xh ; bx++)

        for (by=yl ; by<=yh ; by++)

            if (!P_BlockLinesIterator (bx,by,PIT_CheckLine))

                return false;

    return true;

}

//

// P_TryMove

// Attempt to move to a new position,

// crossing special lines unless MF_TELEPORT is set.

//

boolean

P_TryMove

( mobj_t*       thing,

  fixed_t       x,

  fixed_t       y )

{

    fixed_t     oldx;

    fixed_t     oldy;

    int         side;

    int         oldside;

    line_t*     ld;

    floatok = false;

    if (!P_CheckPosition (thing, x, y))

        return false;           // solid wall or thing

    if ( !(thing->flags & MF_NOCLIP) )

    {

        if (tmceilingz - tmfloorz < thing->height)

            return false;       // doesn't fit

        floatok = true;

        if ( !(thing->flags&MF_TELEPORT)

             &&tmceilingz - thing->z < thing->height)

            return false;       // mobj must lower itself to fit

        if ( !(thing->flags&MF_TELEPORT)

             && tmfloorz - thing->z > 24*FRACUNIT )

            return false;       // too big a step up

        if ( !(thing->flags&(MF_DROPOFF|MF_FLOAT))

             && tmfloorz - tmdropoffz > 24*FRACUNIT )

            return false;       // don't stand over a dropoff

    }

    // the move is ok,

    // so link the thing into its new position

    P_UnsetThingPosition (thing);

    oldx = thing->x;

    oldy = thing->y;

    thing->floorz = tmfloorz;

    thing->ceilingz = tmceilingz;

    thing->x = x;

    thing->y = y;

    P_SetThingPosition (thing);

    // if any special lines were hit, do the effect

    if (! (thing->flags&(MF_TELEPORT|MF_NOCLIP)) )

    {

        while (numspechit--)

        {

            // see if the line was crossed

            ld = spechit[numspechit];

            side = P_PointOnLineSide (thing->x, thing->y, ld);

            oldside = P_PointOnLineSide (oldx, oldy, ld);

            if (side != oldside)

            {

                if (ld->special)

                    P_CrossSpecialLine (ld-lines, oldside, thing);

            }

        }

    }

    return true;

}

//

// P_ThingHeightClip

// Takes a valid thing and adjusts the thing->floorz,

// thing->ceilingz, and possibly thing->z.

// This is called for all nearby monsters

// whenever a sector changes height.

// If the thing doesn't fit,

// the z will be set to the lowest value

// and false will be returned.

//

boolean P_ThingHeightClip (mobj_t* thing)

{

    boolean             onfloor;

    onfloor = (thing->z == thing->floorz);

    P_CheckPosition (thing, thing->x, thing->y);

    // what about stranding a monster partially off an edge?

    thing->floorz = tmfloorz;

    thing->ceilingz = tmceilingz;

    if (onfloor)

    {

        // walking monsters rise and fall with the floor

        thing->z = thing->floorz;

    }

    else

    {

        // don't adjust a floating monster unless forced to

        if (thing->z+thing->height > thing->ceilingz)

            thing->z = thing->ceilingz - thing->height;

    }

    if (thing->ceilingz - thing->floorz < thing->height)

        return false;

    return true;

}

//

// SLIDE MOVE

// Allows the player to slide along any angled walls.

//

fixed_t         bestslidefrac;

fixed_t         secondslidefrac;

line_t*         bestslideline;

line_t*         secondslideline;

mobj_t*         slidemo;

fixed_t         tmxmove;

fixed_t         tmymove;

//

// P_HitSlideLine

// Adjusts the xmove / ymove

// so that the next move will slide along the wall.

//

void P_HitSlideLine (line_t* ld)

{

    int                 side;

    angle_t             lineangle;

    angle_t             moveangle;

    angle_t             deltaangle;

    fixed_t             movelen;

    fixed_t             newlen;

    if (ld->slopetype == ST_HORIZONTAL)

    {

        tmymove = 0;

        return;

    }

    if (ld->slopetype == ST_VERTICAL)

    {

        tmxmove = 0;

        return;

    }

    side = P_PointOnLineSide (slidemo->x, slidemo->y, ld);

    lineangle = R_PointToAngle2 (0,0, ld->dx, ld->dy);

    if (side == 1)

        lineangle += ANG180;

    moveangle = R_PointToAngle2 (0,0, tmxmove, tmymove);

    deltaangle = moveangle-lineangle;

    if (deltaangle > ANG180)

        deltaangle += ANG180;

    //  I_Error ("SlideLine: ang>ANG180");

    lineangle >>= ANGLETOFINESHIFT;

    deltaangle >>= ANGLETOFINESHIFT;

    movelen = P_AproxDistance (tmxmove, tmymove);

    newlen = FixedMul (movelen, finecosine[deltaangle]);

    tmxmove = FixedMul (newlen, finecosine[lineangle]);

    tmymove = FixedMul (newlen, finesine[lineangle]);

}

//

// PTR_SlideTraverse

//

boolean PTR_SlideTraverse (intercept_t* in)

{

    line_t*     li;

    if (!in->isaline)

        I_Error ("PTR_SlideTraverse: not a line?");

    li = in->d.line;

    if ( ! (li->flags & ML_TWOSIDED) )

    {

        if (P_PointOnLineSide (slidemo->x, slidemo->y, li))

        {

            // don't hit the back side

            return true;

        }

        goto isblocking;

    }

    // set openrange, opentop, openbottom

    P_LineOpening (li);

    if (openrange < slidemo->height)

        goto isblocking;                // doesn't fit

    if (opentop - slidemo->z < slidemo->height)

        goto isblocking;                // mobj is too high

    if (openbottom - slidemo->z > 24*FRACUNIT )

        goto isblocking;                // too big a step up

    // this line doesn't block movement

    return true;

    // the line does block movement,

    // see if it is closer than best so far

  isblocking:

    if (in->frac < bestslidefrac)

    {

        secondslidefrac = bestslidefrac;

        secondslideline = bestslideline;

        bestslidefrac = in->frac;

        bestslideline = li;

    }

    return false;       // stop

}

//

// P_SlideMove

// The momx / momy move is bad, so try to slide

// along a wall.

// Find the first line hit, move flush to it,

// and slide along it

//

// This is a kludgy mess.

//

void P_SlideMove (mobj_t* mo)

{

    fixed_t             leadx;

    fixed_t             leady;

    fixed_t             trailx;

    fixed_t             traily;

    fixed_t             newx;

    fixed_t             newy;

    int                 hitcount;

    slidemo = mo;

    hitcount = 0;

  retry:

    if (++hitcount == 3)

        goto stairstep;         // don't loop forever

    // trace along the three leading corners

    if (mo->momx > 0)

    {

        leadx = mo->x + mo->radius;

        trailx = mo->x - mo->radius;

    }

    else

    {

        leadx = mo->x - mo->radius;

        trailx = mo->x + mo->radius;

    }

    if (mo->momy > 0)

    {

        leady = mo->y + mo->radius;

        traily = mo->y - mo->radius;

    }

    else

    {

        leady = mo->y - mo->radius;

        traily = mo->y + mo->radius;

    }

    bestslidefrac = FRACUNIT+1;

    P_PathTraverse ( leadx, leady, leadx+mo->momx, leady+mo->momy,

                     PT_ADDLINES, PTR_SlideTraverse );

    P_PathTraverse ( trailx, leady, trailx+mo->momx, leady+mo->momy,

                     PT_ADDLINES, PTR_SlideTraverse );

    P_PathTraverse ( leadx, traily, leadx+mo->momx, traily+mo->momy,

                     PT_ADDLINES, PTR_SlideTraverse );

    // move up to the wall

    if (bestslidefrac == FRACUNIT+1)

    {

        // the move most have hit the middle, so stairstep

      stairstep:

        if (!P_TryMove (mo, mo->x, mo->y + mo->momy))

            P_TryMove (mo, mo->x + mo->momx, mo->y);

        return;

    }

    // fudge a bit to make sure it doesn't hit

    bestslidefrac -= 0x800;

    if (bestslidefrac > 0)

    {

        newx = FixedMul (mo->momx, bestslidefrac);

        newy = FixedMul (mo->momy, bestslidefrac);

        if (!P_TryMove (mo, mo->x+newx, mo->y+newy))

            goto stairstep;

    }

    // Now continue along the wall.

    // First calculate remainder.

    bestslidefrac = FRACUNIT-(bestslidefrac+0x800);

    if (bestslidefrac > FRACUNIT)

        bestslidefrac = FRACUNIT;

    if (bestslidefrac <= 0)

        return;

    tmxmove = FixedMul (mo->momx, bestslidefrac);

    tmymove = FixedMul (mo->momy, bestslidefrac);

    P_HitSlideLine (bestslideline);     // clip the moves

    mo->momx = tmxmove;

    mo->momy = tmymove;

    if (!P_TryMove (mo, mo->x+tmxmove, mo->y+tmymove))

    {

        goto retry;

    }

}

//

// P_LineAttack

//

mobj_t*         linetarget;     // who got hit (or NULL)

mobj_t*         shootthing;

// Height if not aiming up or down

// ???: use slope for monsters?

fixed_t         shootz;

int             la_damage;

fixed_t         attackrange;

fixed_t         aimslope;

// slopes to top and bottom of target

extern fixed_t  topslope;

extern fixed_t  bottomslope;

//

// PTR_AimTraverse

// Sets linetaget and aimslope when a target is aimed at.

//

boolean

PTR_AimTraverse (intercept_t* in)

{

    line_t*             li;

    mobj_t*             th;

    fixed_t             slope;

    fixed_t             thingtopslope;

    fixed_t             thingbottomslope;

    fixed_t             dist;

    if (in->isaline)

    {

        li = in->d.line;

        if ( !(li->flags & ML_TWOSIDED) )

            return false;               // stop

        // Crosses a two sided line.

        // A two sided line will restrict

        // the possible target ranges.

        P_LineOpening (li);

        if (openbottom >= opentop)

            return false;               // stop

        dist = FixedMul (attackrange, in->frac);

        if (li->frontsector->floorheight != li->backsector->floorheight)

        {

            slope = FixedDiv (openbottom - shootz , dist);

            if (slope > bottomslope)

                bottomslope = slope;

        }

        if (li->frontsector->ceilingheight != li->backsector->ceilingheight)

        {

            slope = FixedDiv (opentop - shootz , dist);

            if (slope < topslope)

                topslope = slope;

        }

        if (topslope <= bottomslope)

            return false;               // stop

        return true;                    // shot continues

    }

    // shoot a thing

    th = in->d.thing;

    if (th == shootthing)

        return true;                    // can't shoot self

    if (!(th->flags&MF_SHOOTABLE))

        return true;                    // corpse or something

    // check angles to see if the thing can be aimed at

    dist = FixedMul (attackrange, in->frac);

    thingtopslope = FixedDiv (th->z+th->height - shootz , dist);

    if (thingtopslope < bottomslope)

        return true;                    // shot over the thing

    thingbottomslope = FixedDiv (th->z - shootz, dist);

    if (thingbottomslope > topslope)

        return true;                    // shot under the thing

    // this thing can be hit!

    if (thingtopslope > topslope)

        thingtopslope = topslope;

    if (thingbottomslope < bottomslope)

        thingbottomslope = bottomslope;

    aimslope = (thingtopslope+thingbottomslope)/2;

    linetarget = th;

    return false;                       // don't go any farther

}

//

// PTR_ShootTraverse

//

boolean PTR_ShootTraverse (intercept_t* in)

{

    fixed_t             x;

    fixed_t             y;

    fixed_t             z;

    fixed_t             frac;

    line_t*             li;

    mobj_t*             th;

    fixed_t             slope;

    fixed_t             dist;

    fixed_t             thingtopslope;

    fixed_t             thingbottomslope;

    if (in->isaline)

    {

        li = in->d.line;

        if (li->special)

            P_ShootSpecialLine (shootthing, li);

        if ( !(li->flags & ML_TWOSIDED) )

            goto hitline;

        // crosses a two sided line

        P_LineOpening (li);

        dist = FixedMul (attackrange, in->frac);

        if (li->frontsector->floorheight != li->backsector->floorheight)

        {

            slope = FixedDiv (openbottom - shootz , dist);

            if (slope > aimslope)

                goto hitline;

        }

        if (li->frontsector->ceilingheight != li->backsector->ceilingheight)

        {

            slope = FixedDiv (opentop - shootz , dist);

            if (slope < aimslope)

                goto hitline;

        }

        // shot continues

        return true;

        // hit line

      hitline:

        // position a bit closer

        frac = in->frac - FixedDiv (4*FRACUNIT,attackrange);

        x = trace.x + FixedMul (trace.dx, frac);

        y = trace.y + FixedMul (trace.dy, frac);

        z = shootz + FixedMul (aimslope, FixedMul(frac, attackrange));

        if (li->frontsector->ceilingpic == skyflatnum)

        {

            // don't shoot the sky!

            if (z > li->frontsector->ceilingheight)

                return false;

            // it's a sky hack wall

            if  (li->backsector && li->backsector->ceilingpic == skyflatnum)

                return false;

        }

        // Spawn bullet puffs.

        P_SpawnPuff (x,y,z);

        // don't go any farther

        return false;

    }

    // shoot a thing

    th = in->d.thing;

    if (th == shootthing)

        return true;            // can't shoot self

    if (!(th->flags&MF_SHOOTABLE))

        return true;            // corpse or something

    // check angles to see if the thing can be aimed at

    dist = FixedMul (attackrange, in->frac);

    thingtopslope = FixedDiv (th->z+th->height - shootz , dist);

    if (thingtopslope < aimslope)

        return true;            // shot over the thing

    thingbottomslope = FixedDiv (th->z - shootz, dist);

    if (thingbottomslope > aimslope)

        return true;            // shot under the thing

    // hit thing

    // position a bit closer

    frac = in->frac - FixedDiv (10*FRACUNIT,attackrange);

    x = trace.x + FixedMul (trace.dx, frac);

    y = trace.y + FixedMul (trace.dy, frac);

    z = shootz + FixedMul (aimslope, FixedMul(frac, attackrange));

    // Spawn bullet puffs or blod spots,

    // depending on target type.

    if (in->d.thing->flags & MF_NOBLOOD)

        P_SpawnPuff (x,y,z);

    else

        P_SpawnBlood (x,y,z, la_damage);

    if (la_damage)

        P_DamageMobj (th, shootthing, shootthing, la_damage);

    // don't go any farther

    return false;

}

//

// P_AimLineAttack

//

fixed_t

P_AimLineAttack

( mobj_t*       t1,

  angle_t       angle,

  fixed_t       distance )

{

    fixed_t     x2;

    fixed_t     y2;

    angle >>= ANGLETOFINESHIFT;

    shootthing = t1;

    x2 = t1->x + (distance>>FRACBITS)*finecosine[angle];

    y2 = t1->y + (distance>>FRACBITS)*finesine[angle];

    shootz = t1->z + (t1->height>>1) + 8*FRACUNIT;

    // can't shoot outside view angles

    topslope = 100*FRACUNIT/160;

    bottomslope = -100*FRACUNIT/160;

    attackrange = distance;

    linetarget = NULL;

    P_PathTraverse ( t1->x, t1->y,

                     x2, y2,

                     PT_ADDLINES|PT_ADDTHINGS,

                     PTR_AimTraverse );

    if (linetarget)

        return aimslope;

    return 0;

}

//

// P_LineAttack

// If damage == 0, it is just a test trace

// that will leave linetarget set.

//

void

P_LineAttack

( mobj_t*       t1,

  angle_t       angle,

  fixed_t       distance,

  fixed_t       slope,

  int           damage )

{

    fixed_t     x2;

    fixed_t     y2;

    angle >>= ANGLETOFINESHIFT;

    shootthing = t1;

    la_damage = damage;

    x2 = t1->x + (distance>>FRACBITS)*finecosine[angle];

    y2 = t1->y + (distance>>FRACBITS)*finesine[angle];

    shootz = t1->z + (t1->height>>1) + 8*FRACUNIT;

    attackrange = distance;

    aimslope = slope;

    P_PathTraverse ( t1->x, t1->y,

                     x2, y2,