a_action.c

制作游戏 魔法师传奇 源代码设计 MOFASHICHUANQI 经典老游戏

void A_BridgeRemove(mobj_t *actor)
{
	actor->special1 = true;		// Removing the bridge
	actor->flags &= ~MF_SOLID;
	P_SetMobjState(actor, S_FREE_BRIDGE1);
}


//==========================================================================
//
// A_GhostOn
//
//==========================================================================

/*
void A_GhostOn(mobj_t *actor)
{
	actor->flags |= MF_SHADOW;
}
*/

//==========================================================================
//
// A_GhostOff
//
//==========================================================================

/*
void A_GhostOff(mobj_t *actor)
{
	actor->flags &= ~MF_SHADOW;
}
*/

//==========================================================================
//
// A_HideThing
//
//==========================================================================

void A_HideThing(mobj_t *actor)
{
	actor->flags2 |= MF2_DONTDRAW;
}

//==========================================================================
//
// A_UnHideThing
//
//==========================================================================

void A_UnHideThing(mobj_t *actor)
{
	actor->flags2 &= ~MF2_DONTDRAW;
}

//==========================================================================
//
// A_SetShootable
//
//==========================================================================

void A_SetShootable(mobj_t *actor)
{
	actor->flags2 &= ~MF2_NONSHOOTABLE;
	actor->flags |= MF_SHOOTABLE;
}

//==========================================================================
//
// A_UnSetShootable
//
//==========================================================================

void A_UnSetShootable(mobj_t *actor)
{
	actor->flags2 |= MF2_NONSHOOTABLE;
	actor->flags &= ~MF_SHOOTABLE;
}

//==========================================================================
//
// A_SetAltShadow
//
//==========================================================================

void A_SetAltShadow(mobj_t *actor)
{
	actor->flags &= ~MF_SHADOW;
	actor->flags |= MF_ALTSHADOW;
}

//==========================================================================
//
// A_UnSetAltShadow
//
//==========================================================================

/*
void A_UnSetAltShadow(mobj_t *actor)
{
	actor->flags &= ~MF_ALTSHADOW;
}
*/

//--------------------------------------------------------------------------
//
// Sound Action Routines
//
//--------------------------------------------------------------------------

//==========================================================================
//
// A_ContMobjSound
//
//==========================================================================

void A_ContMobjSound(mobj_t *actor)
{
	switch(actor->type)
	{
		case MT_SERPENTFX:
			S_StartSound(actor, SFX_SERPENTFX_CONTINUOUS);
			break;
		case MT_HAMMER_MISSILE:
			S_StartSound(actor, SFX_FIGHTER_HAMMER_CONTINUOUS);
			break;
		case MT_QUAKE_FOCUS:
			S_StartSound(actor, SFX_EARTHQUAKE);
			break;
		default:
			break;
	}
}

//==========================================================================
//
// PROC A_ESound
//
//==========================================================================

void A_ESound(mobj_t *mo)
{
	int sound;

	switch(mo->type)
	{
		case MT_SOUNDWIND:
			sound = SFX_WIND;
			break;
		default:
			sound = SFX_NONE;
			break;
	}
	S_StartSound(mo, sound);	
}



//==========================================================================
// Summon Minotaur -- see p_enemy for variable descriptions
//==========================================================================


void A_Summon(mobj_t *actor)
{
	mobj_t *mo;
	mobj_t *master;

	mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_MINOTAUR);
	if (mo)
	{
		if(P_TestMobjLocation(mo) == false || !actor->special1)
		{ // Didn't fit - change back to artifact
			P_SetMobjState(mo, S_NULL);
			mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_SUMMONMAULATOR);
			if (mo) mo->flags2 |= MF2_DROPPED;
			return;
		}

		memcpy((void *)mo->args, &leveltime, sizeof(leveltime));
		master = (mobj_t *)actor->special1;
		if (master->flags&MF_CORPSE)
		{	// Master dead
			mo->special1 = 0;		// No master
		}
		else
		{
			mo->special1 = actor->special1;		// Pointer to master (mobj_t *)
			P_GivePower(master->player, pw_minotaur);
		}

		// Make smoke puff
		P_SpawnMobj(actor->x, actor->y, actor->z, MT_MNTRSMOKE);
		S_StartSound(actor, SFX_MAULATOR_ACTIVE);
	}
}



//==========================================================================
// Fog Variables:
//
//		args[0]		Speed (0..10) of fog
//		args[1]		Angle of spread (0..128)
// 		args[2]		Frequency of spawn (1..10)
//		args[3]		Lifetime countdown
//		args[4]		Boolean: fog moving?
//		special1		Internal:  Counter for spawn frequency
//		special2		Internal:  Index into floatbob table
//
//==========================================================================

void A_FogSpawn(mobj_t *actor)
{
	mobj_t *mo=NULL;
	angle_t delta;

	if (actor->special1-- > 0) return;

	actor->special1 = actor->args[2];		// Reset frequency count

	switch(P_Random()%3)
	{
		case 0:
			mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_FOGPATCHS);
			break;
		case 1:
			mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_FOGPATCHM);
			break;
		case 2:
			mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_FOGPATCHL);
			break;
	}

	if (mo)
	{
		delta = actor->args[1];
		if (delta==0) delta=1;
		mo->angle = actor->angle + (((P_Random()%delta)-(delta>>1))<<24);
		mo->target = actor;
		if (actor->args[0] < 1) actor->args[0] = 1;
		mo->args[0] = (P_Random() % (actor->args[0]))+1;	// Random speed
		mo->args[3] = actor->args[3];						// Set lifetime
		mo->args[4] = 1;									// Set to moving
		mo->special2 = P_Random()&63;
	}
}


void A_FogMove(mobj_t *actor)
{
	int speed = actor->args[0]<<FRACBITS;
	angle_t angle;
	int weaveindex;

	if (!(actor->args[4])) return;

	if (actor->args[3]-- <= 0)
	{
		P_SetMobjStateNF(actor, actor->info->deathstate);
		return;
	}

	if ((actor->args[3] % 4) == 0)
	{
		weaveindex = actor->special2;
		actor->z += FloatBobOffsets[weaveindex]>>1;
		actor->special2 = (weaveindex+1)&63;
	}

	angle = actor->angle>>ANGLETOFINESHIFT;
	actor->momx = FixedMul(speed, finecosine[angle]);
	actor->momy = FixedMul(speed, finesine[angle]);
}

//===========================================================================
//
// A_PoisonBagInit
//
//===========================================================================

void A_PoisonBagInit(mobj_t *actor)
{
	mobj_t *mo;

	mo = P_SpawnMobj(actor->x, actor->y, actor->z+28*FRACUNIT,
		MT_POISONCLOUD);
	if(!mo)
	{
		return;
	}
	mo->momx = 1; // missile objects must move to impact other objects
	mo->special1 = 24+(P_Random()&7);
	mo->special2 = 0;
	mo->target = actor->target;
	mo->radius = 20*FRACUNIT;
	mo->height = 30*FRACUNIT;
	mo->flags &= ~MF_NOCLIP;
}

//===========================================================================
//
// A_PoisonBagCheck
//
//===========================================================================

void A_PoisonBagCheck(mobj_t *actor)
{
	if(!--actor->special1)
	{
		P_SetMobjState(actor, S_POISONCLOUD_X1);
	}
	else
	{
		return;
	}
}

//===========================================================================
//
// A_PoisonBagDamage
//
//===========================================================================

void A_PoisonBagDamage(mobj_t *actor)
{
	int bobIndex;
	
	extern void A_Explode(mobj_t *actor);

	A_Explode(actor);	

	bobIndex = actor->special2;
	actor->z += FloatBobOffsets[bobIndex]>>4;
	actor->special2 = (bobIndex+1)&63;
}

//===========================================================================
//
// A_PoisonShroom
//
//===========================================================================

void A_PoisonShroom(mobj_t *actor)
{
	actor->tics = 128+(P_Random()<<1);
}

//===========================================================================
//
// A_CheckThrowBomb
//
//===========================================================================

void A_CheckThrowBomb(mobj_t *actor)
{
	if(abs(actor->momx) < 1.5*FRACUNIT && abs(actor->momy) < 1.5*FRACUNIT
		&& actor->momz < 2*FRACUNIT
		&& actor->state == &states[S_THROWINGBOMB6])
	{
		P_SetMobjState(actor, S_THROWINGBOMB7);
		actor->z = actor->floorz;
		actor->momz = 0;
		actor->flags2 &= ~MF2_FLOORBOUNCE;
		actor->flags &= ~MF_MISSILE;
	}
	if(!--actor->health)
	{
		P_SetMobjState(actor, actor->info->deathstate);
	}
}

//===========================================================================
// Quake variables
//
//		args[0]		Intensity on richter scale (2..9)
//		args[1]		Duration in tics
//		args[2]		Radius for damage
//		args[3]		Radius for tremor
//		args[4]		TID of map thing for focus of quake
//
//===========================================================================

//===========================================================================
//
// A_LocalQuake
//
//===========================================================================

boolean A_LocalQuake(byte *args, mobj_t *actor)
{
	mobj_t *focus, *target;
	int lastfound=0;
	int success=false;

	actor=actor;	// suppress warning

	// Find all quake foci
	do
	{
		target = P_FindMobjFromTID(args[4], &lastfound);
		if (target)
		{
			focus = P_SpawnMobj(target->x,
								target->y,
								target->z, MT_QUAKE_FOCUS);
			if (focus)
			{
				focus->args[0] = args[0];
				focus->args[1] = args[1]>>1;	// decremented every 2 tics
				focus->args[2] = args[2];
				focus->args[3] = args[3];
				focus->args[4] = args[4];
				success = true;
			}
		}
	}while(target != NULL);

	return(success);
}


//===========================================================================
//
// A_Quake
//
//===========================================================================
int	localQuakeHappening[MAXPLAYERS];

void A_Quake(mobj_t *actor)
{
	angle_t an;
	player_t *player;
	mobj_t *victim;
	int richters = actor->args[0];
	int playnum;
	fixed_t dist;

	if (actor->args[1]-- > 0)