p_inter.c

The source code of Doom legacy for windows

    if (!target || !target->player)
        return;

    if (source && source->player)
    {
        if (source->player==target->player)
            CONS_Printf("%s suicides\n", player_names[target->player-players]);
        else
        {
            if (target->health < -9000) // telefrag !
                str = "%s was telefraged by %s\n";
            else
            {
                w = source->player->readyweapon;
                if( inflictor && inflictor!=source && (inflictor->flags&MF_MISSILE) )
                {
                    switch(inflictor->type) {
                    case MT_ROCKET : w = wp_missile; break;
                    case MT_PLASMA : w = wp_plasma;  break;
                    case MT_BFG    : w = wp_bfg;     break;
                    default : break;
                    }
                }

                switch(w)
                {
                case wp_fist:
                    str = "%s was beaten to a pulp by %s\n";
                    break;
                case wp_pistol:
                    str = "%s was gunned by %s\n";
                    break;
                case wp_shotgun:
                    str = "%s was shot down by %s\n";
                    break;
                case wp_chaingun:
                    str = "%s was machine-gunned by %s\n";
                    break;
                case wp_missile:
                    str = "%s was catched up by %s's rocket\n";
                    if (target->health < -target->info->spawnhealth &&
                        target->info->xdeathstate)
                        str = "%s was gibbed by %s's rocket\n";
                    break;
                case wp_plasma:
                    str = "%s eats %s's toaster\n";
                    break;
                case wp_bfg:
                    str = "%s enjoy %s's big fraggin' gun\n";
                    break;
                case wp_chainsaw:
                    str = "%s was divided up into little pieces by %s's chainsaw\n";
                    break;
                case wp_supershotgun:
                    str = "%s ate 2 loads of %s's buckshot\n";
                    break;
                default:
                    str = "%s was killed by %s\n";
                    break;
                }
            }
            CONS_Printf(str,player_names[target->player-players],
                            player_names[source->player-players]);
        }
    }
    else
    {
        CONS_Printf(player_names[target->player-players]);

        if (!source)
        {
            // environment kills
            w = target->player->specialsector;      //see p_spec.c

            if (w==5)
                CONS_Printf(" dies in hellslime\n");
            else if (w==7)
                CONS_Printf(" gulped a load of nukage\n");
            else if (w==16 || w==4)
                CONS_Printf(" dies in super hellslime/strobe hurt\n");
            else
                CONS_Printf(" dies in special sector\n");
        }
        else
        {
            // check for lava,slime,water,crush,fall,monsters..
            if (source->type == MT_BARREL)
            {
                if (source->target->player)
                    CONS_Printf(" was barrel-fragged by %s\n",
                                player_names[source->target->player-players]);
                else
                    CONS_Printf(" dies from a barrel explosion\n");
            }
            else
            switch (source->type)
            {
              case MT_POSSESSED:
                CONS_Printf(" was shot by a possessed\n"); break;
              case MT_SHOTGUY:
                CONS_Printf(" was shot down by a shotguy\n"); break;
              case MT_VILE:
                CONS_Printf(" was blasted by an Arch-vile\n"); break;
              case MT_FATSO:
                CONS_Printf(" was exploded by a Mancubus\n"); break;
              case MT_CHAINGUY:
                CONS_Printf(" was punctured by a Chainguy\n"); break;
              case MT_TROOP:
                CONS_Printf(" was fried by an Imp\n"); break;
              case MT_SERGEANT:
                CONS_Printf(" was eviscerated by a Demon\n"); break;
              case MT_SHADOWS:
                CONS_Printf(" was mauled by a Shadow Demon\n"); break;
              case MT_HEAD:
                CONS_Printf(" was fried by a Caco-demon\n"); break;
              case MT_BRUISER:
                  CONS_Printf(" was slain by a Baron of Hell\n"); break;
              case MT_UNDEAD:
                CONS_Printf(" was smashed by a Revenant\n"); break;
              case MT_KNIGHT:
                CONS_Printf(" was slain by a Hell-Knight\n"); break;
              case MT_SKULL:
                CONS_Printf(" was killed by a Skull\n"); break;
              case MT_SPIDER:
                CONS_Printf(" was killed by a Spider\n"); break;
              case MT_BABY:
                CONS_Printf(" was killed by a Baby Spider\n"); break;
              case MT_CYBORG:
                CONS_Printf(" was crushed by the Cyber-demon\n"); break;
              case MT_PAIN:
                CONS_Printf(" was killed by a Pain Elemental\n"); break;
              case MT_WOLFSS:
                CONS_Printf(" was killed by a WolfSS\n"); break;
              default:
                CONS_Printf(" died\n");
            }
        }
    }
}

// WARNING : check cv_fraglimit>0 before call this function !
void P_CheckFragLimit(player_t *p)
{
    if(cv_teamplay.value)
    {
        int fragteam=0,i;

        for(i=0;i<MAXPLAYERS;i++)
            if(ST_SameTeam(p,&players[i]))
                fragteam += ST_PlayerFrags(i);

        if(cv_fraglimit.value<=fragteam)
            G_ExitLevel();
    }
    else
    {
        if(cv_fraglimit.value<=ST_PlayerFrags(p-players))
            G_ExitLevel();
    }
}


// P_KillMobj
//
//      source is the attacker,
//      target is the 'target' of the attack, target dies...
//                                          113
void P_KillMobj ( mobj_t*       target,
                  mobj_t*       inflictor,
                  mobj_t*       source )
{
    mobjtype_t  item;
    mobj_t*     mo;
extern consvar_t cv_solidcorpse;
    // dead target is no more shootable
    if( !cv_solidcorpse.value )
        target->flags &= ~MF_SHOOTABLE;

    target->flags &= ~(MF_FLOAT|MF_SKULLFLY);

    if (target->type != MT_SKULL)
        target->flags &= ~MF_NOGRAVITY;

    // scream a corpse :)
    if( target->flags & MF_CORPSE )
    {
        // turn it to gibs
        P_SetMobjState (target, S_GIBS);

        target->flags &= ~MF_SOLID;
        target->height = 0;
        target->radius<<= 1;
        target->skin = 0;

        //added:22-02-98: lets have a neat 'crunch' sound!
        S_StartSound (target, sfx_slop);
        return;
    }

    //added:22-02-98: remember who exploded the barrel, so that the guy who
    //                shot the barrel which killed another guy, gets the frag!
    //                (source is passed from barrel to barrel also!)
    //                (only for multiplayer fun, does not remember monsters)
    if ((target->type == MT_BARREL || target->type == MT_POD) &&
        source &&
        source->player)
        target->target = source;

    if( demoversion < 131 )
    {
        target->flags   |= MF_CORPSE|MF_DROPOFF;
        target->height >>= 2;
        if( demoversion>=112 )
            target->radius -= (target->radius>>4);      //for solid corpses
    }
    // show death messages, only if it concern the console player
    // (be it an attacker or a target)
    if (target->player && (target->player == &players[consoleplayer]) )
        P_DeathMessages (target, inflictor, source);
    else
    if (source && source->player && (source->player == &players[consoleplayer]) )
        P_DeathMessages (target, inflictor, source);


    // if killed by a player
    if (source && source->player)
    {
        // count for intermission
        if (target->flags & MF_COUNTKILL)
            source->player->killcount++;

        // count frags if player killed player
        if (target->player)
        {
            source->player->frags[target->player-players]++;
            if( gamemode == heretic )
            {
                if(source->player == &players[displayplayer] 
                || source->player == &players[secondarydisplayplayer] )
                    S_StartSound(NULL, sfx_gfrag);

                // Make a super chicken
                if(source->player->chickenTics)
                    P_GivePower(source->player, pw_weaponlevel2);
            }
            // check fraglimit cvar
            if (cv_fraglimit.value)
                P_CheckFragLimit(source->player);
        }
    }
    else if (!multiplayer && (target->flags & MF_COUNTKILL))
    {
        // count all monster deaths,
        // even those caused by other monsters
        players[0].killcount++;
    }

    // if a player avatar dies...
    if (target->player)
    {
        // count environment kills against you (you fragged yourself!)
        if (!source)
            target->player->frags[target->player-players]++;

        target->flags &= ~MF_SOLID;                     // does not block
        target->flags2 &= ~MF2_FLY;
        target->player->powers[pw_flight] = 0;
        target->player->powers[pw_weaponlevel2] = 0;
        target->player->playerstate = PST_DEAD;
        P_DropWeapon (target->player);                  // put weapon away
        if (target->player == &players[consoleplayer])
        {
            // don't die in auto map,
            // switch view prior to dying
            if (automapactive)
                AM_Stop ();

            //added:22-02-98: recenter view for next live...
            localaiming = 0;
        }
        if (target->player == &players[secondarydisplayplayer])
        {
            //added:22-02-98: recenter view for next live...
            localaiming2 = 0;
        }
/* HERETODO
        if(target->flags2&MF2_FIREDAMAGE)
        { // Player flame death
            P_SetMobjState(target, S_PLAY_FDTH1);
            //S_StartSound(target, sfx_hedat1); // Burn sound
            return;
        }
*/
    }

    if (( (gamemode != heretic && target->health < -target->info->spawnhealth)
        ||(gamemode == heretic && target->health < -(target->info->spawnhealth>>1)))
        && target->info->xdeathstate)
    {
        P_SetMobjState (target, target->info->xdeathstate);
    }
    else
        P_SetMobjState (target, target->info->deathstate);

    target->tics -= P_Random()&3;

    if (target->tics < 1)
        target->tics = 1;

    // Drop stuff.
    // This determines the kind of object spawned
    // during the death frame of a thing.
    switch (target->type)
    {
      case MT_WOLFSS:
      case MT_POSSESSED:
        item = MT_CLIP;
        break;

      case MT_SHOTGUY:
        item = MT_SHOTGUN;
        break;

      case MT_CHAINGUY:
        item = MT_CHAINGUN;
        break;

      default:
        return;
    }

    // SoM: Damnit! Why not use the target's floorz?
    mo = P_SpawnMobj (target->x, target->y, demoversion<132 ? ONFLOORZ : target->floorz, item);
    mo->flags |= MF_DROPPED;    // special versions of items
}


//---------------------------------------------------------------------------
//
// FUNC P_MinotaurSlam
//
//---------------------------------------------------------------------------

void P_MinotaurSlam(mobj_t *source, mobj_t *target)
{
    angle_t angle;
    fixed_t thrust;
    
    angle = R_PointToAngle2(source->x, source->y, target->x, target->y);
    angle >>= ANGLETOFINESHIFT;
    thrust = 16*FRACUNIT+(P_Random()<<10);
    target->momx += FixedMul(thrust, finecosine[angle]);
    target->momy += FixedMul(thrust, finesine[angle]);
    P_DamageMobj(target, NULL, NULL, HITDICE(6));
    if(target->player)
    {
        target->reactiontime = 14+(P_Random()&7);
    }
}

//---------------------------------------------------------------------------
//
// FUNC P_TouchWhirlwind
//
//---------------------------------------------------------------------------

boolean P_TouchWhirlwind(mobj_t *target)
{
    int randVal;
    
    target->angle += P_SignedRandom()<<20;
    target->momx += P_SignedRandom()<<10;
    target->momy += P_SignedRandom()<<10;
    if(leveltime&16 && !(target->flags2&MF2_BOSS))
    {
        randVal = P_Random();
        if(randVal > 160)
        {
            randVal = 160;
        }
        target->momz += randVal<<10;
        if(target->momz > 12*FRACUNIT)
        {
            target->momz = 12*FRACUNIT;
        }
    }
    if(!(leveltime&7))
    {
        return P_DamageMobj(target, NULL, NULL, 3);
    }
    return false;
}

//---------------------------------------------------------------------------
//
// FUNC P_ChickenMorphPlayer
//
// Returns true if the player gets turned into a chicken.
//
//---------------------------------------------------------------------------

boolean P_ChickenMorphPlayer(player_t *player)
{
    mobj_t *pmo;
    mobj_t *fog;
    mobj_t *chicken;
    fixed_t x;
    fixed_t y;
    fixed_t z;
    angle_t angle;
    int oldFlags2;
    
    if(player->chickenTics)
    {
        if((player->chickenTics < CHICKENTICS-TICRATE)
            && !player->powers[pw_weaponlevel2])
        { // Make a super chicken
            P_GivePower(player, pw_weaponlevel2);
        }
        return(false);
    }
    if(player->powers[pw_invulnerability])
    { // Immune when invulnerable
        return(false);
    }
    pmo = player->mo;
    x = pmo->x;
    y = pmo->y;
    z = pmo->z;
    angle = pmo->angle;
    oldFlags2 = pmo->flags2;
    P_SetMobjState(pmo, S_FREETARGMOBJ);
    fog = P_SpawnMobj(x, y, z+TELEFOGHEIGHT, MT_TFOG);
    S_StartSound(fog, sfx_telept);
    chicken = P_SpawnMobj(x, y, z, MT_CHICPLAYER);
    chicken->special1 = player->readyweapon;
    chicken->angle = angle;
    chicken->player = player;
    player->health = chicken->health = MAXCHICKENHEALTH;
    player->mo = chicken;
    player->armorpoints = player->armortype = 0;
    player->powers[pw_invisibility] = 0;
    player->powers[pw_weaponlevel2] = 0;
    player->weaponinfo = wpnlev1info;
    if(oldFlags2&MF2_FLY)
    {
        chicken->flags2 |= MF2_FLY;
    }
    player->chickenTics = CHICKENTICS;
    P_ActivateBeak(player);
    return(true);
}

//---------------------------------------------------------------------------
//
// FUNC P_ChickenMorph
//
//---------------------------------------------------------------------------