I documented the REQ* opcodes on
the wiki, though it might not make a terrible amount of sense if you don't already understand how FF7's scripts are run.
Essentially in a given field file you have a number of
entities. Some of these entities are connected with a physical object on the screen, while others are simply abstract (I believe earlier documentation referred to these as "entities" and "characters"; the number of each are defined in the field file header). Each entity has up to 32 "member functions", or scripts (the offsets of these are stored in the large arrays of shorts early in the field file). Only the entity itself is allowed to execute these scripts, so no entity can directly "call" someone else's scripts.
Now, all entities run their scripts in parallel. In separate "threads", if you will. Unless specified, each entity will just execute their "init" function (script 0), at base priority. "Triggers" can be set up in the field to activate other member scripts, i.e. "ontouch", "onactivate" etc. Also, one entity can
request that another entity runs one of its member scripts. This is done with the REQ* commands. A target of a REQ* command will pause his current execution and instead begin executing the requested script at a specified priority. If the target entity is already executing something else at a higher priority, the requested script will be queued at its specified priority slot. If the target entity is already executing or waiting to execute something at the specified priority, the requesting entity will either block (wait) or silently fail the request.
The different variations of the REQ* commands specify how the requesting entity should behave while the target entity is running the code. The
REQ command simply requests that the target entity starts running the script, but does not care if the request is successfully completed or not, or when the script is actually started. The requesting entity will immediately continue its own execution, regardless of what the target entity is executing. The
REQSW (request-start-wait) command behaves similarly, but will block (wait) until the target entity actually begins to execute the script, then continue executing in parallel. This version will not fail silently like REQ, since it always succeeds (sooner or later). The
REQEW (request-end-wait) command does all this but blocks until (surprise) the target entity has
finished executing the script (indicated by the RET command, which btw tells the target entity to resume execution at whatever lower priority it was executing on before, or simply halt at base priority). Finally, the PRQ* commands simply means that instead of referring to a specific entity, you refer to the entity associated with a character in the current party (0, 1 or 2).
This kind of multithreading makes it relatively easy to make characters perform things on-screen, regardless if they're controlled from a central "story script" entity or triggered by some event in a character or object entity. To get the characters to do something simultaneously, all you would have to do is issue the REQSW command to the relevant script in their entities. To make Cloud walk across the screen and only once he's arrived have the door open, you first request Cloud's entity's "walk over there" script with REQEW, followed the door's "open" script.
Piece of cake?
