The way this was done was a major headache inducer, requiring reconstruction of the function each time the value was changed and in general made actor damage a major hassle.
There was a DECORATE wrapper to mimic the original behavior but this looked quite broken because it completely ignored the different semantics of both damage calculation types.
It also made it impossible to determine if damage was a function or a value.
This accessor has been reverted to what it should be, only returning the constant, which now is -1 for a damage function. I am sorry if this may break the odd mod out but a quick look over some DECORATE-heavy stuff showed that this was never combined in any of them so that accessing 'damage' in DECORATE code depended on an actual damage function.
To get proper damage, a future commit will add a DECORATE function which calls AActor::GetMissileDamage.
So something like 'return ++user_x;' is now possible
Admittedly this needed quite a bit of refactoring mainly due to the fact that return types now have to be checked after resolving the function rather than before
break and continue were added but are not yet useable anywhere
This was made general enough so that loops and switch statements that accept breaks/continues can be done without much difficulty as well as goto statements with explicit labels if those are ever wanted
- fixed: DECORATE allowed a silent conversion from names to integers.
In old versions the name was converted to 0, since the scripting branch to the name index. Reverted to the old behavior but added a warning message.
- This reverts commit 06216d733e.
- I don't know what I was thinking. Since stateowner is always available
to the wrapper function, and this code is only generated for the wrapper
function, it's a nonissue. The state is already located before calling
any function that uses it.
- This reverts commit 39df62b20e.
- Anything that needs to lookup a state also needs stateowner. See
FxMultiNameState::Emit(). I will need to be more selective when
de-actionifying functions.
- An actor function really only needs to be an action function if:
1. It can be called with no parameters specified, either because it takes
none or because all its parameters are optional. This lets SetState()
call it directly without creating a wrapper function for it.
2. It wants access to the callingstate or stateowner parameters. Most
functions don't care about them, so passing them is superfluous.
- DECORATE now has atan2(y,x) and VectorAngle(x,y) functions. They are
identical except for the order of their parameters. The returned angle
is in degrees (not radians).
- Split specific parsing for each intrinsic out of ParseExpression0 and
into their own functions.
- Instead of reserving keywords for intrinsics, identify them by name
within TK_Identifier's handling.
- This is so that you can call an A_Jump-type function from inside an if
statement and do something other than jump if the jump condition was
met. e.g.
{
if (A_Jump(128, "Foo"))
{
A_Log("The function would have jumped");
}
else
{
A_Log("The function would not have jumped");
}
}
- The A_Jump family of action functions now return the state to jump
to (NULL if no jump is to be taken) instead of jumping directly.
It is the caller's responsibility to handle the jump. This will
make it possible to use their results in if statements and
do something other than jump.
- DECORATE return statements can now return the result of a function
(but not any random expression--it must be a function call). To
make a jump happen from inside a multi-action block, you must
return the value of an A_Jump function. e.g.:
{ return A_Jump(128, "SomeState"); }
- The VMFunction class now contains its prototype instead of storing
it at a higher level in PFunction. This is so that
FState::CallAction can easily tell if a function returns a state.
- Removed the FxTailable class because with explicit return
statements, it's not useful anymore.
If done as before, forward-declared classes cannot be found, and the immediate resolving is only needed for constant expressions, so explicitly enabling it in the 4 places where it is needed ensures that those unresolvable expressions remain intact until the final processing pass righr before the code generator is started.
This reverts commit e9cbb0b223, reversing
changes made to d6e3fc0567.
The merge just copied the obsolete FxFloatCast from master without any conflict so it all had to be removed again.
- This is RandomPick but for floats. Considering what RandomPick
translates into in the scripting branch, I hope I don't regret not using
type inference on RandomPick instead of creating a new keyword.
- "If it ain't broke, don't fix it."
- Some of the changes were downright wrong and some were pointless, so undo
everything that doesn't look like an actual improvement.
- So now you can do something like this for an action:
{
if (health > 1000)
{
A_Scream;
}
else
{
A_XScream;
}
}
Yes, the braces are required. Because I see too many instances where
somebody writes an if statement in ACS and doesn't understand why it
doesn't work right because they forgot braces.
- Fixed: Not actually putting an action between { and } would crash.
- You can now call several actions from one frame by grouping them between
curly braces. i.e. :
POSS G 3 { A_Pain; A_Log("Ow! That hurt!"); }
I will probably add an `if (something) { blah; blah; } else { wah; wah; }`
construct later, but that's the extent of the munging I plan for DECORATE. The
real work goes to the scripting language, not here. But if this branch is
getting merged to master sooner than later, here's an immediate benefit
from it right now.
- This replaces the general extensibility that had existed formerly
in thingdef_function.cpp. Parameter parsing for function calls is
shared with state parameter parsing. Functions are defined exactly in
the same way as action functions, but without the 'action' keyword.
Conflicts:
src/CMakeLists.txt
src/b_think.cpp
src/g_doom/a_doomweaps.cpp
src/g_hexen/a_clericstaff.cpp
src/g_hexen/a_fighterplayer.cpp
src/namedef.h
src/p_enemy.cpp
src/p_local.h
src/p_mobj.cpp
src/p_teleport.cpp
src/sc_man_tokens.h
src/thingdef/thingdef_codeptr.cpp
src/thingdef/thingdef_function.cpp
src/thingdef/thingdef_parse.cpp
wadsrc/static/actors/actor.txt
wadsrc/static/actors/constants.txt
wadsrc/static/actors/shared/inventory.txt
- Added register reuse to VMFunctionBuilder for FxPick's code emitter.
- Note to self: Need to reimplement IsPointerEqual and CheckClass, which
were added to thingdef_function.cpp over the past year, as this file no
longer exists in this branch.
