[SOLVED] A few questions about A_(Generic)FreezeDeath

[Void Weaver]

I tried to make missile with non-lethal temporary "freezing" effect via A_GenericFreezeDeath f-tion, something like as:

Code: Select all

Actor VPlasmaBall : PlasmaBall
{
States
{
Spawn:
    PLSS AB 6 A_RadiusGive("Freezer",65,RGF_MONSTERS|RGF_EXFILTER,1,"RShield")
    Loop
Death:
    PLSE ABCDE 4 A_RadiusGive("Freezer",65,RGF_MONSTERS|RGF_EXFILTER,1,"RShield")
    Stop
}
} 

Actor Freezer : CustomInventory
{
+INVENTORY.ALWAYSPICKUP
Inventory.MaxAmount 0
States
{
Pickup:
"####" "#" 0 A_GenericFreezeDeath
Stop
}
}

In general it works as I expected, but duration of fake freezing seems to be odd randomized and original translation doesn't restores.

So questions itself:
1. What determines the duration of A_GenericFreezeDeath f-tion? And how it can be controlled?
2. In case if duration hardcoded and there no levers to directly control function duration, then how it can be terminated (via another custominventory "unfreezer" for ex.) outside? With exception of calling foe's Pain state ofc.
3. How to restore foe's source translation? I mean I know about A_SetTranslation and Thing_SetTranslation functions, but I dunno values\stringname of default translation vanilla's actors.
Or maybe I should use another methods of translation restoring?

[Graf Zahl]

One word: Ouch!

That won't work because A_FreezeDeath expects to operate on something dead. This functions sets many flags to values that only make sense for a corpse and since it assumes that this corpse will shatter there is no attempt to make it restorable. It also sets a delay counter.

It's A_FreezeDeathChunks that performs the waiting on this timer and that gets immediately disqualified when you want to freeze something alive. And this needs to be operated by the actor itself, you cannot do this from a powerup.

This all means that the actor you want to freeze has to know about this feature and deal with the delay, you cannot enforce it from the outside.

[Void Weaver]

Well, I know that's function supposed to be used in Death state(s), but I would to use it as external custom status modifier...
Sooo, does mean yours "Ouch!" that current "feature" will be considered as bug and will be fixed in the next releases and therefore I shouldn't use it anyway? I need know this beforehand.

This functions sets many flags to values that only make sense for a corpse and since it assumes that this corpse will shatter there is no attempt to make it restorable. It also sets a delay counter.

Um, maybe I understand something wrong or maybe you don't understand me, but in my case A_FreezeDeath externally called by alive actor do restore its normal activity... a little while later.

It's A_FreezeDeathChunks that performs the waiting on this timer and that gets immediately disqualified when you want to freeze something alive. And this needs to be operated by the actor itself, you cannot do this from a powerup.

So this is mean that only A_FreezeDeathChunks handle A_FreezeDeath actual timer, right? Then why "unfreezing" takes a some a bit random duration?

[Graf Zahl]

Um, maybe I understand something wrong or maybe you don't understand me, but in my case A_FreezeDeath externally called by alive actor do restore its normal activity... a little while later.

Careful! You are deeply wading in "undefined behavior" territory here!

So this is mean that only A_FreezeDeathChunks handle A_FreezeDeath actual timer, right?

Correctly. Of course you can write your own timing function, but the setup you are using can not call it.

Then why "unfreezing" takes a some a bit random duration?

Because the duration is randomized.

[Void Weaver]

Got it. Thank you for clarifying! ^_^

EDIT:
In case if a somebody will looking for A_(Generic)FreezeDeath and A_FreezeDeathChunks source code, it placed here "\zscript\shared\ice.txt":

---

Code: Select all

extend class Actor
{

	//============================================================================
	//
	// A_FreezeDeath
	//
	//============================================================================

	void A_FreezeDeath()
	{

		int t = random[freezedeath]();
		tics = 75+t+random[freezedeath]();
		bSolid = bShootable = bNoBlood = bIceCorpse = bPushable = bTelestomp = bCanPass = bSlidesOnWalls = bCrashed = true;
		Height = Default.Height;
		A_SetRenderStyle(1, STYLE_Normal);

		A_PlaySound ("misc/freeze", CHAN_BODY);

		// [RH] Andy Baker's stealth monsters
		if (bStealth)
		{
			Alpha = 1;
			visdir = 0;
		}

		if (player)
		{
			player.damagecount = 0;
			player.poisoncount = 0;
			player.bonuscount = 0;
		}
		else if (bIsMonster && special)
		{ // Initiate monster death actions
			A_CallSpecial(special, args[0],	args[1], args[2], args[3], args[4]);
			special = 0;
		}
	}

	//============================================================================
	//
	// A_FreezeDeathChunks
	//
	//============================================================================

	void A_FreezeDeathChunks()
	{
		if (Vel != (0,0,0) && !bShattering)
		{
			tics = 3*TICRATE;
			return;
		}
		Vel = (0,0,0);
		A_PlaySound ("misc/icebreak", CHAN_BODY);

		// [RH] In Hexen, this creates a random number of shards (range [24,56])
		// with no relation to the size of the self shattering. I think it should
		// base the number of shards on the size of the dead thing, so bigger
		// things break up into more shards than smaller things.
		// An actor with radius 20 and height 64 creates ~40 chunks.
		int numChunks = max(4, int(radius * Height)/32);
		int i = Random[FreezeDeathChunks](0, numChunks/4 - 1);
		for (i = max(24, numChunks + i); i >= 0; i--)
		{
			double xo = (random[FreezeDeathChunks]() - 128)*radius / 128;
			double yo = (random[FreezeDeathChunks]() - 128)*radius / 128;
			double zo = (random[FreezeDeathChunks]() * Height / 255);

			Actor mo = Spawn("IceChunk", Vec3Offset(xo, yo, zo), ALLOW_REPLACE);
			if (mo)
			{
				mo.SetState (mo.SpawnState + random[FreezeDeathChunks](0, 2));
				mo.Vel.X = random2[FreezeDeathChunks]() / 128.;
				mo.Vel.Y = random2[FreezeDeathChunks]() / 128.;
				mo.Vel.Z = (mo.pos.Z - pos.Z) / Height * 4;
			}
		}
		if (player)
		{ // attach the player's view to a chunk of ice
			Actor head = Spawn("IceChunkHead", pos + (0, 0, player.mo.ViewHeight), ALLOW_REPLACE);
			if (head != null)
			{
				head.Vel.X = random2[FreezeDeathChunks]() / 128.;
				head.Vel.Y = random2[FreezeDeathChunks]() / 128.;
				head.Vel.Z = (head.pos.Z - pos.Z) / Height * 4;

				head.health = health;
				head.Angle = Angle;
				if (head is "PlayerPawn")
				{
					head.player = player;
					head.player.mo = PlayerPawn(head);
					player = null;
					head.ObtainInventory (self);
				}
				head.Pitch = 0.;
				if (head.player.camera == self)
				{
					head.player.camera = head;
				}
			}
		}

		// [RH] Do some stuff to make this more useful outside Hexen
		if (bBossDeath)
		{
			A_BossDeath();
		}
		A_NoBlocking();

		SetStateLabel('null');
	}

	void A_GenericFreezeDeath()
	{
		A_SetTranslation('Ice');
		A_FreezeDeath();
	}
	

}