Example #1
0
DEFINE_ACTION_FUNCTION(AActor, A_SargAttack)
{
	PARAM_ACTION_PROLOGUE;

	if (!self->target)
		return 0;
				
	A_FaceTarget (self);
	if (self->CheckMeleeRange ())
	{
		int damage = ((pr_sargattack()%10)+1)*4;
		int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
		P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
	}
	return 0;
}
DEFINE_ACTION_FUNCTION(AActor, A_FireMauler2)
{
	if (self->player != NULL)
	{
		AWeapon *weapon = self->player->ReadyWeapon;
		if (weapon != NULL)
		{
			if (!weapon->DepleteAmmo (weapon->bAltFire))
				return;
		}
		self->player->mo->PlayAttacking2 ();
	}
	P_SpawnPlayerMissile (self, PClass::FindClass("MaulerTorpedo"));
	P_DamageMobj (self, self, NULL, 20, self->DamageType);
	P_ThrustMobj (self, self->angle + ANGLE_180, 0x7D000);
}
Example #3
0
DEFINE_ACTION_FUNCTION(AActor, A_ChicAttack)
{
	PARAM_ACTION_PROLOGUE;

	if (!self->target)
	{
		return 0;
	}
	if (self->CheckMeleeRange())
	{
		int damage = 1 + (pr_chicattack() & 1);
		int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
		P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
	}
	return 0;
}
Example #4
0
void A_PigAttack (AActor *actor)
{
    if (P_UpdateMorphedMonster (actor, 18))
    {
        return;
    }
    if (!actor->target)
    {
        return;
    }
    if (actor->CheckMeleeRange ())
    {
        P_DamageMobj(actor->target, actor, actor, 2+(pr_pigattack()&1), MOD_HIT);
        S_Sound(actor, CHAN_WEAPON, "PigAttack", 1, ATTN_NORM);
    }
}
Example #5
0
//
// ACS_funcThingDamage
//
static void ACS_funcThingDamage(ACS_FUNCARG)
{
   int32_t tid    = args[0];
   int32_t damage = args[1];
   int     mod    = E_DamageTypeNumForName(ACSVM::GetString(args[2]));
   Mobj   *mo     = NULL;
   int32_t count  = 0;

   while((mo = P_FindMobjFromTID(tid, mo, thread->trigger)))
   {
      P_DamageMobj(mo, NULL, NULL, damage, mod);
      ++count;
   }

   *retn++ = count;
}
Example #6
0
DEFINE_ACTION_FUNCTION(AActor, A_BishopAttack)
{
	if (!self->target)
	{
		return;
	}
	S_Sound (self, CHAN_BODY, self->AttackSound, 1, ATTN_NORM);
	if (self->CheckMeleeRange())
	{
		int damage = pr_atk.HitDice (4);
		int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
		P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
		return;
	}
	self->special1 = (pr_atk() & 3) + 5;
}
Example #7
0
//
// A_SkelFist
//
// Revenant punch attack.
//
void A_SkelFist(actionargs_t *actionargs)
{
   Mobj *actor = actionargs->actor;
   
   if(!actor->target)
      return;
   
   A_FaceTarget(actionargs);
   
   if(P_CheckMeleeRange(actor))
   {
      int damage = ((P_Random(pr_skelfist) % 10) + 1) * 6;
      S_StartSound(actor, sfx_skepch);
      P_DamageMobj(actor->target, actor, actor, damage, MOD_HIT);
   }
}
Example #8
0
static int suicideResponse(msgresponse_t response, int /*userValue*/, void * /*userPointer*/)
{
    if(response == MSG_YES)
    {
        if(IS_NETGAME && IS_CLIENT)
        {
            NetCl_CheatRequest("suicide");
        }
        else
        {
            player_t *plr = &players[CONSOLEPLAYER];
            P_DamageMobj(plr->plr->mo, NULL, NULL, 10000, false);
        }
    }
    return true;
}
Example #9
0
void DEarthquake::Tick ()
{
	int i;

	if (m_Spot == NULL)
	{
		Destroy ();
		return;
	}

	if (!S_IsActorPlayingSomething (m_Spot, CHAN_BODY, m_QuakeSFX))
	{
		S_Sound (m_Spot, CHAN_BODY | CHAN_LOOP, m_QuakeSFX, 1, ATTN_NORM);
	}
	if (m_DamageRadius > 0)
	{
		for (i = 0; i < MAXPLAYERS; i++)
		{
			if (playeringame[i] && !(players[i].cheats & CF_NOCLIP))
			{
				AActor *victim = players[i].mo;
				fixed_t dist;

				dist = P_AproxDistance (victim->x - m_Spot->x, victim->y - m_Spot->y);
				// Check if in damage radius
				if (dist < m_DamageRadius && victim->z <= victim->floorz)
				{
					if (pr_quake() < 50)
					{
						P_DamageMobj (victim, NULL, NULL, pr_quake.HitDice (1), NAME_None);
					}
					// Thrust player around
					angle_t an = victim->angle + ANGLE_1*pr_quake();
					P_ThrustMobj (victim, an, m_Intensity << (FRACBITS-1));
				}
			}
		}
	}
	if (--m_Countdown == 0)
	{
		if (S_IsActorPlayingSomething(m_Spot, CHAN_BODY, m_QuakeSFX))
		{
			S_StopSound(m_Spot, CHAN_BODY);
		}
		Destroy();
	}
}
Example #10
0
void P_MinotaurSlam (AActor *source, AActor *target)
{
    DAngle angle;
    double thrust;
    int damage;

    angle = source->AngleTo(target);
    thrust = 16 + pr_minotaurslam() / 64.;
    target->VelFromAngle(angle, thrust);
    damage = pr_minotaurslam.HitDice (static_cast<AMinotaur *>(source) ? 4 : 6);
    int newdam = P_DamageMobj (target, NULL, NULL, damage, NAME_Melee);
    P_TraceBleed (newdam > 0 ? newdam : damage, target, angle, 0.);
    if (target->player)
    {
        target->reactiontime = 14+(pr_minotaurslam()&7);
    }
}
Example #11
0
void A_Srcr1Attack (AActor *actor)
{
	AActor *mo;
	fixed_t momz;
	angle_t angle;

	if (!actor->target)
	{
		return;
	}
	S_SoundID (actor, CHAN_BODY, actor->AttackSound, 1, ATTN_NORM);
	if (actor->CheckMeleeRange ())
	{
		int damage = pr_scrc1atk.HitDice (8);
		P_DamageMobj (actor->target, actor, actor, damage, NAME_Melee);
		P_TraceBleed (damage, actor->target, actor);
		return;
	}
	if (actor->health > (actor->GetDefault()->health/3)*2)
	{ // Spit one fireball
		P_SpawnMissileZ (actor, actor->z + 48*FRACUNIT, actor->target, RUNTIME_CLASS(ASorcererFX1));
	}
	else
	{ // Spit three fireballs
		mo = P_SpawnMissileZ (actor, actor->z + 48*FRACUNIT, actor->target, RUNTIME_CLASS(ASorcererFX1));
		if (mo != NULL)
		{
			momz = mo->momz;
			angle = mo->angle;
			P_SpawnMissileAngleZ (actor, actor->z + 48*FRACUNIT, RUNTIME_CLASS(ASorcererFX1), angle-ANGLE_1*3, momz);
			P_SpawnMissileAngleZ (actor, actor->z + 48*FRACUNIT, RUNTIME_CLASS(ASorcererFX1), angle+ANGLE_1*3, momz);
		}
		if (actor->health < actor->GetDefault()->health/3)
		{ // Maybe attack again
			if (actor->special1)
			{ // Just attacked, so don't attack again
				actor->special1 = 0;
			}
			else
			{ // Set state to attack again
				actor->special1 = 1;
				actor->SetState (&ASorcerer1::States[S_SRCR1_ATK+3]);
			}
		}
	}
}
DEFINE_ACTION_FUNCTION(AActor, A_ProgrammerMelee)
{
	int damage;

	if (self->target == NULL)
		return;

	A_FaceTarget (self);

	if (!self->CheckMeleeRange ())
		return;

	S_Sound (self, CHAN_WEAPON, "programmer/clank", 1, ATTN_NORM);

	damage = ((pr_prog() % 10) + 1) * 6;
	int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
	P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
}
Example #13
0
DEFINE_ACTION_FUNCTION(AActor, A_HeadAttack)
{
	if (!self->target)
		return;
				
	A_FaceTarget (self);
	if (self->CheckMeleeRange ())
	{
		int damage = (pr_headattack()%6+1)*10;
		S_Sound (self, CHAN_WEAPON, self->AttackSound, 1, ATTN_NORM);
		int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
		P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
		return;
	}
	
	// launch a missile
	P_SpawnMissile (self, self->target, PClass::FindClass("CacodemonBall"));
}
Example #14
0
DEFINE_ACTION_FUNCTION(AActor, A_SerpentMeleeAttack)
{
    if (!self->target)
    {
        return;
    }
    if (self->CheckMeleeRange ())
    {
        int damage = pr_serpentmeattack.HitDice (5);
        int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
        P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
        S_Sound (self, CHAN_BODY, "SerpentMeleeHit", 1, ATTN_NORM);
    }
    if (pr_serpentmeattack() < 96)
    {
        CALL_ACTION(A_SerpentCheckForAttack, self);
    }
}
Example #15
0
dd_bool EV_ThingDestroy(int tid)
{
    mobj_t      *mobj;
    int         searcher;
    dd_bool     success;

    success = false;
    searcher = -1;
    while((mobj = P_FindMobjFromTID(tid, &searcher)) != NULL)
    {
        if(mobj->flags & MF_SHOOTABLE)
        {
            P_DamageMobj(mobj, NULL, NULL, 10000, false);
            success = true;
        }
    }
    return success;
}
Example #16
0
DEFINE_ACTION_FUNCTION(AActor, A_StalkerAttack)
{
	if (self->flags & MF_NOGRAVITY)
	{
		self->SetState (self->FindState("Drop"));
	}
	else if (self->target != NULL)
	{
		A_FaceTarget (self);
		if (self->CheckMeleeRange ())
		{
			int damage = (pr_stalker() & 7) * 2 + 2;

			int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
			P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
		}
	}
}
Example #17
0
//
// A_TroopAttack
//
DEFINE_ACTION_FUNCTION(AActor, A_TroopAttack)
{
    if (!self->target)
        return;

    A_FaceTarget (self);
    if (self->CheckMeleeRange ())
    {
        int damage = (pr_troopattack()%8+1)*3;
        S_Sound (self, CHAN_WEAPON, "imp/melee", 1, ATTN_NORM);
        int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
        P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
        return;
    }

    // launch a missile
    P_SpawnMissile (self, self->target, PClass::FindClass("DoomImpBall"));
}
Example #18
0
DEFINE_ACTION_FUNCTION(AActor, A_WraithMelee)
{
	int amount;

	// [BB] This is server-side.
	if ( NETWORK_InClientMode() )
	{
		return;
	}

	// Steal health from target and give to self
	if (self->CheckMeleeRange() && (pr_stealhealth()<220))
	{
		amount = pr_stealhealth.HitDice (2);
		P_DamageMobj (self->target, self, self, amount, NAME_Melee);
		self->health += amount;
	}
}
Example #19
0
DEFINE_ACTION_FUNCTION(AActor, A_FireMauler2)
{
	PARAM_ACTION_PROLOGUE;

	if (self->player != NULL)
	{
		AWeapon *weapon = self->player->ReadyWeapon;
		if (weapon != NULL)
		{
			if (!weapon->DepleteAmmo (weapon->bAltFire))
				return 0;
		}
		self->player->mo->PlayAttacking2 ();
	}
	P_SpawnPlayerMissile (self, PClass::FindActor("MaulerTorpedo"));
	P_DamageMobj (self, self, NULL, 20, self->DamageType);
	self->Thrust(self->Angles.Yaw+180., 7.8125);
	return 0;
}
Example #20
0
//
// PIT_StompThing
//
boolean PIT_StompThing (mobj_t* thing)
{
    int		damage;
    int		gibhealth;
    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;

    if (telefrag == false)
    {
      if (tmthing->flags2 & MF2_PASSMOBJ)
      {
	if (tmz > thing->z + thing->height)
	  return true; // overhead
	if (tmz + tmthing->height < thing->z)
	  return true; // underneath
      }
      return false;
    }

    gibhealth = thing->info->gibhealth;
    if (gibhealth < 0)
      damage = (thing->health - gibhealth) + 1;
    else
      damage = (thing->health + thing->info->spawnhealth) + 1;
    P_DamageMobj (thing, tmthing, tmthing, damage);
    return true;
}
Example #21
0
void P_PlayerOnSpecialFlat(player_t *player, int floorType)
{
	if(player->plr->mo->z		/*!= player->plr->mo->floorz */
	   > player->plr->mo->subsector->sector->floorheight)
	{							// Player is not touching the floor
		return;
	}
	switch (floorType)
	{
	case FLOOR_LAVA:
		if(!(leveltime & 31))
		{
			P_DamageMobj(player->plr->mo, &LavaInflictor, NULL, 10);
			S_StartSound(SFX_LAVA_SIZZLE, player->plr->mo);
		}
		break;
	default:
		break;
	}
}
Example #22
0
int ALightning::SpecialMissileHit (AActor *thing)
{
	if (thing->flags&MF_SHOOTABLE && thing != target)
	{
		if (thing->Mass != INT_MAX)
		{
			thing->Vel.X += Vel.X / 16;
			thing->Vel.Y += Vel.Y / 16;
		}
		if ((!thing->player && !(thing->flags2&MF2_BOSS))
			|| !(level.time&1))
		{
			P_DamageMobj(thing, this, target, 3, NAME_Electric);
			if (!(S_IsActorPlayingSomething (this, CHAN_WEAPON, -1)))
			{
				S_Sound (this, CHAN_WEAPON, this->AttackSound, 1, ATTN_NORM);
			}
			if (thing->flags3&MF3_ISMONSTER && pr_hit() < 64)
			{
				thing->Howl ();
			}
		}
		health--;
		if (health <= 0 || thing->health <= 0)
		{
			return 0;
		}
		if (flags3 & MF3_FLOORHUGGER)
		{
			if (lastenemy && ! lastenemy->tracer)
			{
				lastenemy->tracer = thing;
			}
		}
		else if (!tracer)
		{
			tracer = thing;
		}
	}
	return 1; // lightning zaps through all sprites
}
Example #23
0
DEFINE_ACTION_FUNCTION(AActor, A_MinotaurAtk2)
{
    PARAM_ACTION_PROLOGUE;

    AActor *mo;
    DAngle angle;
    double vz;
    double z;
    bool friendly = !!(self->flags5 & MF5_SUMMONEDMONSTER);

    if (self->target == NULL)
    {
        return 0;
    }
    S_Sound (self, CHAN_WEAPON, "minotaur/attack2", 1, ATTN_NORM);
    if (self->CheckMeleeRange())
    {
        int damage;
        damage = pr_atk.HitDice (friendly ? 3 : 5);
        int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
        P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
        return 0;
    }
    z = self->Z() + 40;
    PClassActor *fx = PClass::FindActor("MinotaurFX1");
    if (fx)
    {
        mo = P_SpawnMissileZ (self, z, self->target, fx);
        if (mo != NULL)
        {
//			S_Sound (mo, CHAN_WEAPON, "minotaur/attack2", 1, ATTN_NORM);
            vz = mo->Vel.Z;
            angle = mo->Angles.Yaw;
            P_SpawnMissileAngleZ (self, z, fx, angle-(45./8), vz);
            P_SpawnMissileAngleZ (self, z, fx, angle+(45./8), vz);
            P_SpawnMissileAngleZ (self, z, fx, angle-(45./16), vz);
            P_SpawnMissileAngleZ (self, z, fx, angle+(45./16), vz);
        }
    }
    return 0;
}
Example #24
0
//
// A_BruisAttack
//
// Baron of Hell attack.
//
void A_BruisAttack(actionargs_t *actionargs)
{
   Mobj *actor = actionargs->actor;

   if(!actor->target)
      return;
   
   if(P_CheckMeleeRange(actor))
   {
      int damage;
      S_StartSound(actor, sfx_claw);
      damage = (P_Random(pr_bruisattack)%8+1)*10;
      P_DamageMobj(actor->target, actor, actor, damage, MOD_HIT);
   }
   else
   {
      // launch a missile
      P_SpawnMissile(actor, actor->target, E_SafeThingType(MT_BRUISERSHOT),
                     actor->z + DEFAULTMISSILEZ);  
   }
}
Example #25
0
//
// A_HeadAttack
//
// Cacodemon attack.
//
void A_HeadAttack(actionargs_t *actionargs)
{
   Mobj *actor = actionargs->actor;

   if(!actor->target)
      return;
   
   A_FaceTarget(actionargs);
   
   if(P_CheckMeleeRange(actor))
   {
      int damage = (P_Random(pr_headattack)%6+1)*10;
      P_DamageMobj(actor->target, actor, actor, damage, MOD_HIT);
   }
   else
   {
      // launch a missile
      P_SpawnMissile(actor, actor->target, E_SafeThingType(MT_HEADSHOT),
                     actor->z + DEFAULTMISSILEZ);
   }
}
Example #26
0
DEFINE_ACTION_FUNCTION(AActor, A_MinotaurAtk1)
{
	player_t *player;

	if (!self->target)
	{
		return;
	}
	S_Sound (self, CHAN_WEAPON, "minotaur/melee", 1, ATTN_NORM);
	if (self->CheckMeleeRange())
	{
		int damage = pr_minotauratk1.HitDice (4);
		int newdam = P_DamageMobj (self->target, self, self, damage, NAME_Melee);
		P_TraceBleed (newdam > 0 ? newdam : damage, self->target, self);
		if ((player = self->target->player) != NULL &&
			player->mo == self->target)
		{ // Squish the player
			player->deltaviewheight = -16*FRACUNIT;
		}
	}
}
Example #27
0
bool AArtiTomeOfPower::Use (bool pickup)
{
	if (Owner->player->morphTics && (Owner->player->MorphStyle & MORPH_UNDOBYTOMEOFPOWER))
	{ // Attempt to undo chicken
		if (!P_UndoPlayerMorph (Owner->player, Owner->player, MORPH_UNDOBYTOMEOFPOWER))
		{ // Failed
			if (!(Owner->player->MorphStyle & MORPH_FAILNOTELEFRAG))
			{
				P_DamageMobj (Owner, NULL, NULL, TELEFRAG_DAMAGE, NAME_Telefrag);
			}
		}
		else
		{ // Succeeded
			S_Sound (Owner, CHAN_VOICE, "*evillaugh", 1, ATTN_IDLE);
		}
		return true;
	}
	else
	{
		return Super::Use (pickup);
	}
}
Example #28
0
static void DoSectorDamage(AActor *actor, sector_t *sec, int amount, FName type, PClassActor *protectClass, int flags)
{
	if (!(actor->flags & MF_SHOOTABLE))
		return;

	if (!(flags & DAMAGE_NONPLAYERS) && actor->player == NULL)
		return;

	if (!(flags & DAMAGE_PLAYERS) && actor->player != NULL)
		return;

	if (!(flags & DAMAGE_IN_AIR) && !actor->isAtZ(sec->floorplane.ZatPoint(actor)) && !actor->waterlevel)
		return;

	if (protectClass != NULL)
	{
		if (actor->FindInventory(protectClass, !!(flags & DAMAGE_SUBCLASSES_PROTECT)))
			return;
	}

	P_DamageMobj (actor, NULL, NULL, amount, type);
}
//
// A_VileAttack
//
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_VileAttack)
{		
	ACTION_PARAM_START(6);
	ACTION_PARAM_SOUND(snd,0);
	ACTION_PARAM_INT(dmg,1);
	ACTION_PARAM_INT(blastdmg,2);
	ACTION_PARAM_INT(blastrad,3);
	ACTION_PARAM_FIXED(thrust,4);
	ACTION_PARAM_NAME(dmgtype,5);

	AActor *fire, *target;
	angle_t an;
		
	if (NULL == (target = self->target))
		return;
	
	A_FaceTarget (self);

	if (!P_CheckSight (self, target, 0) )
		return;

	S_Sound (self, CHAN_WEAPON, snd, 1, ATTN_NORM);
	P_TraceBleed (dmg, target);
	P_DamageMobj (target, self, self, dmg, NAME_None);
		
	an = self->angle >> ANGLETOFINESHIFT;
	fire = self->tracer;

	if (fire != NULL)
	{
		// move the fire between the vile and the player
		fire->SetOrigin (target->x - FixedMul (24*FRACUNIT, finecosine[an]),
						 target->y - FixedMul (24*FRACUNIT, finesine[an]),
						 target->z);
		
		P_RadiusAttack (fire, self, blastdmg, blastrad, dmgtype, false);
	}
	target->velz = Scale(thrust, 1000, target->Mass);
}
Example #30
0
DEFINE_ACTION_FUNCTION(AActor, A_MinotaurRoam)
{
    PARAM_ACTION_PROLOGUE;

    // In case pain caused him to skip his fade in.
    self->RenderStyle = STYLE_Normal;

    if (self->IsKindOf(RUNTIME_CLASS(AMinotaurFriend)))
    {
        AMinotaurFriend *self1 = static_cast<AMinotaurFriend *> (self);

        if (self1->StartTime >= 0 && (level.maptime - self1->StartTime) >= MAULATORTICS)
        {
            P_DamageMobj (self1, NULL, NULL, TELEFRAG_DAMAGE, NAME_None);
            return 0;
        }
    }

    if (pr_minotaurroam() < 30)
        CALL_ACTION(A_MinotaurLook, self);		// adjust to closest target

    if (pr_minotaurroam() < 6)
    {
        //Choose new direction
        self->movedir = pr_minotaurroam() % 8;
        FaceMovementDirection (self);
    }
    if (!P_Move(self))
    {
        // Turn
        if (pr_minotaurroam() & 1)
            self->movedir = (self->movedir + 1) % 8;
        else
            self->movedir = (self->movedir + 7) % 8;
        FaceMovementDirection (self);
    }
    return 0;
}