ZDoom

Superseded by alternate implementation.
Pull requested.

https://github.com/rheit/zdoom/pull/112
https://github.com/rheit/acc/pull/9

Say, FDARI, would you be capable of updating this to the current version of Zdoom's revision? I sincerely think this would be extremely useful.

Yeah. I'm only looking at it for player 1, but I'll keep this in mind.

That's not good in concept, although it could work out. Conceptual problems: You depend on a specific player to be in the game, and you depend on that player to be of the appropriate class. If player 1 is guaranteed to be present and of the WhateverPlayer class, it will work.

A few portable utility functions for decorate can be designed in ACS.[spoiler=Excerpt of my ACS/Decorate interop][code]#LIBDEFINE SCRIPT_ACSMISC 1
#LIBDEFINE MISC_TASK_CHECKACTOR 1
#LIBDEFINE MISC_TASK_PLAYERNUM 2

script SCRIPT_ACSMISC (int task, int p1, int p2)
{
switch (task)
{
case MISC_TASK_CHECKACTOR:
// p1 = tid
// p2 = ptr
// tid 0 ptr 0/default: Never exists
SetResultValue(SetActivator(p1, p2));
terminate;
case MISC_TASK_PLAYERNUM:
// p1 = tid
// p2 = ptr
// tid 0 ptr 0/default: caller
if (p1 || p2)
{
SetActivator(p1, p2);
}
SetResultValue(playerNumber());
terminate;
}
}[/code][code]// decorate ACS constants
enum
{
SCRIPT_ACSMISC = 1
};

enum
{
MISC_TASK_CHECKACTOR = 1,
MISC_TASK_PLAYERNUM = 2
};[/code]Sample use: A_JumpIf(ACS_ExecuteWithResult(SCRIPT_ACSMISC, MISC_TASK_PLAYERNUM, 0, AAPTR_TARGET) > -1, "targetIsAPlayer")[/spoiler]

Out of curiousity, would it be possible to do A_JumpIf(ClassID(AAPTR_TARGET) == ClassID(AAPTR_PLAYER1),"ItsAPlayer")? I'm guessing that it is, though I haven't tried doing that yet, as I'm currently hog-tied with a bunch of experiments. Still, I just wanted to ensure that it's possible to do a comparison to check and see if the player is it's target.

If an actor that has no target or tracer compares AAPTR_TARGET and AAPTR_TRACER with this function, they will be treated as equal, because they are both null references. Is that the best behaviour? In most situations, you will want to "act" only if they are the same [i]and[/i] non-null. If you'd end up adding [i]&& !ComparePointer(AAPTR_TARGET, AAPTR_NULL)[/i] a lot, you might be happier with a function that returns false/does not jump, if an actor is NULL. I could rewrite it that way, but you'd have to go a little further to check specifically for null, and to allow two null-pointers to be equal.

Current methods:
Pointer equality: ComparePointers(AAPTR_SOMETHING, AAPTR_ELSE)
Pointer is null: ComparePointers(AAPTR_SOMETHING, AAPTR_NULL)
Non-null pointer equality: ComparePointers(AAPTR_SOMETHING, AAPTR_ELSE) && !ComparePointers(AAPTR_SOMETHING, AAPTR_NULL)

Alternative methods:
Pointer equality: Not built in
Pointer is null: Not built in
Non-null pointer equality: ComparePointers(AAPTR_SOMETHING, AAPTR_ELSE)

For specific needs you could complement the alternative method (non-null pointer equality only) with an ACS library / function:[spoiler=Pointer existence tests][code]#define script_ptrtest 1
function int ActorExists(int tid, int ptr)
{
return ACS_ExecuteWithResult(script_ptrtest, tid, ptr);
}


script script_ptrtest (int tid, int ptr)
{
SetResultValue(SetActivator(tid, ptr));
}[/code]Pointer equality: ComparePointers(AAPTR_SOMETHING, AAPTR_ELSE) || !(ActorExists(0, AAPTR_SOMETHING) || ActorExists(0, AAPTR_ELSE)) // They're non-null equal or both null
Pointer is null: !ActorExists(0, AAPTR_SOMETHING)
Non-null pointer equality: ComparePointers(AAPTR_SOMETHING, AAPTR_ELSE)

There are many ways to set up that script and function, or just a script. I ran the SetActivator() in a separate script instance so that it won't affect the calling script.[/spoiler]

Okay, that definitely gave me a wave of relief. Thank you.

I would say, this feature is picture perfect! That is, aside from any other code maintenance you might do to it, if any, but that's for you to decide.

That one contains syntax constraint checks, and are purely for testing purposes on my end, not really a demo of any sort. Checks that cos() and sin() require exactly 1 parameter, and that ClassID() accepts 0 or 1 parameters.

VerifyInvalidityOfSyntaxes:
			TNT1 A 0 ACS_ExecuteWithResult( cos(1) )
			TNT1 A 0 ACS_ExecuteWithResult( sin(1) )
			TNT1 A 0 ACS_ExecuteWithResult( ClassID() )
			TNT1 A 0 ACS_ExecuteWithResult( ClassID(AAPTR_DEFAULT) )
			stop

Okay, out of curiousity, what's this part doing?

[code]VerifyInvalidityOfSyntaxes:
TNT1 A 0 ACS_ExecuteWithResult( cos(1) )
TNT1 A 0 ACS_ExecuteWithResult( sin(1) )
TNT1 A 0 ACS_ExecuteWithResult( ClassID() )
TNT1 A 0 ACS_ExecuteWithResult( ClassID(AAPTR_DEFAULT) )
stop[/code]

I have a feeling it's just there to debug some ACS, or something. That part is the only thing I'm slightly confused on.

Check the update. Summary:

ACS bool ComparePointers(int ptr_selector, int ptr_compare)

Decorate A_ComparePointers(state jumpto, int ptr_selector, int ptr_compare)

Decorate constant int StringID(str stringLiteral) -- int is a stringID-entry, unique to that string

Decorate int ClassID([int ptr_selector]) -- int is a StringID-entry, unique to that string

ACS print syntax g:x converts a stringID to a string.

I borrowed a trick from here: http://forum.zdoom.org/viewtopic.php?f=34&t=30806
Purpose: Make class checking a bit more flexible. (Compare with a string constant, or with the class name of another actor, and use the comparison in other things than jump function, and use non-equality as well as equality.)

So is it feasible? Think it could be done? It would be one hell of a compliment to A_ComparePointers, I know this much.

That one I can see. Yes, that is something I'd need inventory tokens or trickier methods for today. (Trickier methods involve strparam(n:0) and char-by-char comparison against an acs table.)

Hm, okay... I think I may indeed have been confusing myself.

What I really think would help is a function like this:

A_CheckActor(state jump, selector, str classname)

It checks to see if an actor in it's code pointer of choice is "classname". In a way, this can be used to replicate A_JumpIfInventory, only without the need of inventory tokens made strictly for identification so we can finally have a good reason to stop making those, and that's just one example.

I personally see that as something that can go hand in hand with A_ComparePointers, to do a lot of things together.

I'm not sure what it would be. If I get it, I think it isn't going to be such a good function. It might be better to execute a purpose specific ACS script from a library for such a complex and specific piece of logic.

Would the above be better as another suggestion in the suggested features section?