macros.h

Go to the documentation of this file.

#ifndef _SCRIPT_API_MACROS_H_
#define _SCRIPT_API_MACROS_H_
 
#include "evt.h"
#include "stdlib/stdarg.h"
 
#ifdef _LANGUAGE_C_PLUS_PLUS
extern "C" {
#endif
 
/****** EXPRESSIONS ***************************************************************************************************/
 
 
 
#define EVT_LOCAL_VAR_CUTOFF     -20000000
#define EVT_LOCAL_VAR_OFFSET      30000000
#define EVT_MAP_VAR_CUTOFF       -40000000
#define EVT_MAP_VAR_OFFSET        50000000
#define EVT_LOCAL_FLAG_CUTOFF    -60000000
#define EVT_LOCAL_FLAG_OFFSET     70000000
#define EVT_MAP_FLAG_CUTOFF      -80000000
#define EVT_MAP_FLAG_OFFSET       90000000
#define EVT_AREA_FLAG_CUTOFF    -100000000
#define EVT_AREA_FLAG_OFFSET     110000000
#define EVT_GAME_FLAG_CUTOFF    -120000000
#define EVT_GAME_FLAG_OFFSET     130000000
#define EVT_AREA_BYTE_CUTOFF    -140000000
#define EVT_AREA_BYTE_OFFSET     150000000
#define EVT_GAME_BYTE_CUTOFF    -160000000
#define EVT_GAME_BYTE_OFFSET     170000000
#define EVT_ARRAY_VAR_CUTOFF    -180000000
#define EVT_ARRAY_VAR_OFFSET     190000000
#define EVT_ARRAY_FLAG_CUTOFF   -200000000
#define EVT_ARRAY_FLAG_OFFSET    210000000
#define EVT_FIXED_CUTOFF        -220000000
#define EVT_FIXED_OFFSET         230000000
#define EVT_IGNORE_ARG          -250000000 // used by a couple functions to selectively ignore args
#define EVT_LIMIT               -270000000 // TODO better name
 
 // This fixes an issue with fixed point numbers not being correct. Potentially a truncation vs round difference.
#define FLOAT_ROUND(x) ((x) >=0 ? (f64)((x) + 0.9) : (f64)(x))
#define Float(DOUBLE)  ((Bytecode)FLOAT_ROUND(((DOUBLE) * 1024.0f)) - EVT_FIXED_OFFSET)
 
#define EVT_FIXED_TO_FLOAT(x) ({f32 var = (x) + EVT_FIXED_OFFSET; var /= 1024.0f; var;})
 
#define FLOAT_TO_FIXED(x) (((x) * 1024.0f) + -EVT_FIXED_OFFSET)
 
#define Ref(sym) ((Bytecode) &(sym))
 
#define LocalVar(INDEX) ((INDEX) - EVT_LOCAL_VAR_OFFSET)
 
#define MapVar(INDEX) ((INDEX) - EVT_MAP_VAR_OFFSET)
 
#define LocalFlag(INDEX) ((INDEX) - EVT_LOCAL_FLAG_OFFSET)
 
#define MapFlag(INDEX) ((INDEX) - EVT_MAP_FLAG_OFFSET)
 
#define AreaFlag(INDEX) ((INDEX) - EVT_AREA_FLAG_OFFSET)
 
#define GameFlag(INDEX) ((INDEX) - EVT_GAME_FLAG_OFFSET)
 
#define AreaByte(INDEX) ((INDEX) - EVT_AREA_BYTE_OFFSET)
 
#define GameByte(INDEX) ((INDEX) - EVT_GAME_BYTE_OFFSET)
 
#define ArrayVar(INDEX) ((INDEX) - EVT_ARRAY_VAR_OFFSET)
 
#define ArrayFlag(INDEX) ((INDEX) - EVT_ARRAY_FLAG_OFFSET)
 
#define EVT_ENTITY_ID_BIT 0x4000
#define EVT_ENTITY_INDEX(entityIndex) ((entityIndex) + EVT_ENTITY_ID_BIT)
 
// inverse macros for obtaining the index of a variable from its encoded form
#define EVT_INDEX_OF_LOCAL_VAR(v)   ((v) + EVT_LOCAL_VAR_OFFSET)
#define EVT_INDEX_OF_LOCAL_FLAG(v)  ((v) + EVT_LOCAL_FLAG_OFFSET)
#define EVT_INDEX_OF_MAP_VAR(v)     ((v) + EVT_MAP_VAR_OFFSET)
#define EVT_INDEX_OF_MAP_FLAG(v)    ((v) + EVT_MAP_FLAG_OFFSET)
#define EVT_INDEX_OF_AREA_FLAG(v)   ((v) + EVT_AREA_FLAG_OFFSET)
#define EVT_INDEX_OF_AREA_BYTE(v)   ((v) + EVT_AREA_BYTE_OFFSET)
#define EVT_INDEX_OF_GAME_FLAG(v)   ((v) + EVT_GAME_FLAG_OFFSET)
#define EVT_INDEX_OF_GAME_BYTE(v)   ((v) + EVT_GAME_BYTE_OFFSET)
#define EVT_INDEX_OF_ARRAY_FLAG(v)  ((v) + EVT_ARRAY_FLAG_OFFSET)
#define EVT_INDEX_OF_ARRAY_VAR(v)   ((v) + EVT_ARRAY_VAR_OFFSET)
 
// shorthand names for LocalVar
#define LVar0 LocalVar(0)
#define LVar1 LocalVar(1)
#define LVar2 LocalVar(2)
#define LVar3 LocalVar(3)
#define LVar4 LocalVar(4)
#define LVar5 LocalVar(5)
#define LVar6 LocalVar(6)
#define LVar7 LocalVar(7)
#define LVar8 LocalVar(8)
#define LVar9 LocalVar(9)
#define LVarA LocalVar(10)
#define LVarB LocalVar(11)
#define LVarC LocalVar(12)
#define LVarD LocalVar(13)
#define LVarE LocalVar(14)
#define LVarF LocalVar(15)
 
// shorthand names for common LocalFlags
// these actually run all the way up to LocalFlag(96), but nothing past 15 is ever used
#define LFlag0 LocalFlag(0)
#define LFlag1 LocalFlag(1)
#define LFlag2 LocalFlag(2)
#define LFlag3 LocalFlag(3)
#define LFlag4 LocalFlag(4)
#define LFlag5 LocalFlag(5)
#define LFlag6 LocalFlag(6)
#define LFlag7 LocalFlag(7)
#define LFlag8 LocalFlag(8)
#define LFlag9 LocalFlag(9)
#define LFlagA LocalFlag(10)
#define LFlagB LocalFlag(11)
#define LFlagC LocalFlag(12)
#define LFlagD LocalFlag(13)
#define LFlagE LocalFlag(14)
#define LFlagF LocalFlag(15)
 
/****** INSTRUCTIONS **************************************************************************************************/
 
 
 
#define EVT_CMD(opcode, argv...) \
    opcode, \
    (sizeof((Bytecode[]){argv})/sizeof(Bytecode)), \
    ##argv
 
#define End                                 EVT_CMD(EVT_OP_END),
 
#define Return                              EVT_CMD(EVT_OP_RETURN),
 
#define Jump(EVT_SOURCE)                    EVT_CMD(EVT_OP_JUMP, (Bytecode) EVT_SOURCE),
 
#define Label(LABEL_ID)                     EVT_CMD(EVT_OP_LABEL, LABEL_ID),
 
#define Goto(LABEL_ID)                      EVT_CMD(EVT_OP_GOTO, LABEL_ID),
 
#define Loop(TIMES)                         EVT_CMD(EVT_OP_LOOP, TIMES),
 
#define EndLoop                            EVT_CMD(EVT_OP_END_LOOP),
 
#define BreakLoop                          EVT_CMD(EVT_OP_BREAK_LOOP),
 
#define Wait(NUM_FRAMES)                    EVT_CMD(EVT_OP_WAIT_FRAMES, NUM_FRAMES),
 
 
#define WaitSecs(NUM_SECONDS)              EVT_CMD(EVT_OP_WAIT_SECS, NUM_SECONDS),
 
#define IfEq(LVAR, RVAR)                   EVT_CMD(EVT_OP_IF_EQ, LVAR, RVAR),
 
#define IfNe(LVAR, RVAR)                   EVT_CMD(EVT_OP_IF_NE, LVAR, RVAR),
 
#define IfLt(LVAR, RVAR)                   EVT_CMD(EVT_OP_IF_LT, LVAR, RVAR),
 
#define IfGt(LVAR, RVAR)                   EVT_CMD(EVT_OP_IF_GT, LVAR, RVAR),
 
#define IfLe(LVAR, RVAR)                   EVT_CMD(EVT_OP_IF_LE, LVAR, RVAR),
 
#define IfGe(LVAR, RVAR)                   EVT_CMD(EVT_OP_IF_GE, LVAR, RVAR),
 
#define IfFlag(LVAR, RVAR)                 EVT_CMD(EVT_OP_IF_FLAG, LVAR, RVAR),
 
#define IfNotFlag(LVAR, RVAR)             EVT_CMD(EVT_OP_IF_NOT_FLAG, LVAR, RVAR),
 
#define Else                                EVT_CMD(EVT_OP_ELSE),
 
#define EndIf                              EVT_CMD(EVT_OP_END_IF),
 
#define Switch(LVAR)                        EVT_CMD(EVT_OP_SWITCH, LVAR),
 
#define SwitchConst(LCONST)                EVT_CMD(EVT_OP_SWITCH_CONST, LCONST),
 
#define CaseEq(RVAR)                       EVT_CMD(EVT_OP_CASE_EQ, RVAR),
 
#define CaseNe(RVAR)                       EVT_CMD(EVT_OP_CASE_NE, RVAR),
 
#define CaseLt(RVAR)                       EVT_CMD(EVT_OP_CASE_LT, RVAR),
 
#define CaseGt(RVAR)                       EVT_CMD(EVT_OP_CASE_GT, RVAR),
 
#define CaseLe(RVAR)                       EVT_CMD(EVT_OP_CASE_LE, RVAR),
 
#define CaseGe(RVAR)                       EVT_CMD(EVT_OP_CASE_GE, RVAR),
 
#define CaseDefault                        EVT_CMD(EVT_OP_CASE_DEFAULT),
 
#define CaseOrEq(RVAR)                    EVT_CMD(EVT_OP_CASE_OR_EQ, RVAR),
 
#define CaseAndEq(RVAR)                   EVT_CMD(EVT_OP_CASE_AND_EQ, RVAR),
 
#define CaseFlag(RVAR)                     EVT_CMD(EVT_OP_CASE_FLAG, RVAR),
 
#define EndCaseGroup                      EVT_CMD(EVT_OP_END_CASE_GROUP),
 
#define CaseRange(MIN, MAX)                EVT_CMD(EVT_OP_CASE_RANGE, MIN, MAX),
 
#define BreakSwitch                        EVT_CMD(EVT_OP_BREAK_SWITCH),
 
#define EndSwitch                          EVT_CMD(EVT_OP_END_SWITCH),
 
#define Set(VAR, INT_VALUE)                 EVT_CMD(EVT_OP_SET, VAR, (Bytecode) INT_VALUE),
 
#define SetConst(VAR, CONST)               EVT_CMD(EVT_OP_SET_CONST, VAR, (Bytecode) CONST),
 
#define SetF(VAR, FLOAT_VALUE)              EVT_CMD(EVT_OP_SETF, VAR, FLOAT_VALUE),
 
// Basic arithmetic operations.
#define Add(VAR, INT_VALUE)                 EVT_CMD(EVT_OP_ADD, VAR, INT_VALUE),
#define Sub(VAR, INT_VALUE)                 EVT_CMD(EVT_OP_SUB, VAR, INT_VALUE),
#define Mul(VAR, INT_VALUE)                 EVT_CMD(EVT_OP_MUL, VAR, INT_VALUE),
#define Div(VAR, INT_VALUE)                 EVT_CMD(EVT_OP_DIV, VAR, INT_VALUE),
#define Mod(VAR, INT_VALUE)                 EVT_CMD(EVT_OP_MOD, VAR, INT_VALUE),
 
// Basic floating-point arithmetic operations.
#define AddF(VAR, FLOAT_VALUE)              EVT_CMD(EVT_OP_ADDF, VAR, FLOAT_VALUE),
#define SubF(VAR, FLOAT_VALUE)              EVT_CMD(EVT_OP_SUBF, VAR, FLOAT_VALUE),
#define MulF(VAR, FLOAT_VALUE)              EVT_CMD(EVT_OP_MULF, VAR, FLOAT_VALUE),
#define DivF(VAR, FLOAT_VALUE)              EVT_CMD(EVT_OP_DIVF, VAR, FLOAT_VALUE),
 
#define UseBuf(INT_PTR)                    EVT_CMD(EVT_OP_USE_BUF, (Bytecode) INT_PTR),
 
#define BufRead1(VAR)                      EVT_CMD(EVT_OP_BUF_READ1, VAR),
 
#define BufRead2(VAR1, VAR2)               EVT_CMD(EVT_OP_BUF_READ2, VAR1, VAR2),
 
#define BufRead3(VAR1, VAR2, VAR3)         EVT_CMD(EVT_OP_BUF_READ3, VAR1, VAR2, VAR3),
 
#define BufRead4(VAR1, VAR2, VAR3, VAR4)   EVT_CMD(EVT_OP_BUF_READ4, VAR1, VAR2, VAR3, VAR4),
 
#define BufPeek(OFFSET, VAR)               EVT_CMD(EVT_OP_BUF_PEEK, OFFSET, VAR),
 
#define UseFBuf(FLOAT_PTR)                 EVT_CMD(EVT_OP_USE_FBUF, (Bytecode) FLOAT_PTR),
 
#define FBufRead1(VAR)                     EVT_CMD(EVT_OP_FBUF_READ1, VAR),
 
#define FBufRead2(VAR1, VAR2)              EVT_CMD(EVT_OP_FBUF_READ2, VAR1, VAR2),
 
#define FBufRead3(VAR1, VAR2, VAR3)        EVT_CMD(EVT_OP_FBUF_READ3, VAR1, VAR2, VAR3),
 
#define FBufRead4(VAR1, VAR2, VAR3, VAR4)  EVT_CMD(EVT_OP_FBUF_READ4, VAR1, VAR2, VAR3, VAR4),
 
#define FBufPeek(OFFSET, VAR)              EVT_CMD(EVT_OP_FBUF_PEEK, OFFSET, VAR),
 
#define UseArray(INT_PTR)                  EVT_CMD(EVT_OP_USE_ARRAY, (Bytecode) INT_PTR),
 
#define UseFlagArray(PACKED_FLAGS_PTR)    EVT_CMD(EVT_OP_USE_FLAG_ARRAY, (Bytecode) PACKED_FLAGS_PTR),
 
#define MallocArray(SIZE, OUT_PTR_VAR)     EVT_CMD(EVT_OP_MALLOC_ARRAY, SIZE, OUT_PTR_VAR),
 
#define BitwiseAnd(VAR, VALUE)             EVT_CMD(EVT_OP_BITWISE_AND, VAR, VALUE),
 
#define BitwiseAndConst(VAR, CONST)       EVT_CMD(EVT_OP_BITWISE_AND_CONST, VAR, CONST),
 
#define BitwiseOr(VAR, VALUE)              EVT_CMD(EVT_OP_BITWISE_OR, VAR, VALUE),
 
#define BitwiseOrConst(VAR, CONST)        EVT_CMD(EVT_OP_BITWISE_OR_CONST, VAR, CONST),
 
#define Exec(EVT_SOURCE)                    EVT_CMD(EVT_OP_EXEC, (Bytecode) EVT_SOURCE),
 
#define ExecGetTID(EVT_SOURCE, OUTVAR)    EVT_CMD(EVT_OP_EXEC_GET_TID, (Bytecode) EVT_SOURCE, OUTVAR),
 
#define ExecWait(EVT_SOURCE)               EVT_CMD(EVT_OP_EXEC_WAIT, (Bytecode) EVT_SOURCE),
 
#define BindTrigger(EVT_SOURCE, TRIGGER, COLLIDER_ID, UNK_A3, TRIGGER_PTR_OUTVAR) \
    EVT_CMD(EVT_OP_BIND_TRIGGER, (Bytecode) EVT_SOURCE, TRIGGER, (Bytecode) COLLIDER_ID, UNK_A3, TRIGGER_PTR_OUTVAR),
 
#define BindPadlock(EVT_SOURCE, TRIGGER, COLLIDER_ID, ITEM_LIST, UNK_A3, TRIGGER_PTR_OUTVAR) \
    EVT_CMD(EVT_OP_BIND_PADLOCK, (Bytecode) EVT_SOURCE, TRIGGER, COLLIDER_ID, (Bytecode) ITEM_LIST, UNK_A3, TRIGGER_PTR_OUTVAR),
 
#define Unbind                              EVT_CMD(EVT_OP_UNBIND),
 
#define KillThread(TID)                    EVT_CMD(EVT_OP_KILL_THREAD, TID),
 
#define SetPriority(PRIORITY)              EVT_CMD(EVT_OP_SET_PRIORITY, PRIORITY),
 
#define SetTimescale(TIMESCALE)            EVT_CMD(EVT_OP_SET_TIMESCALE, TIMESCALE),
 
#define SetGroup(GROUP)                    EVT_CMD(EVT_OP_SET_GROUP, GROUP),
 
#define SuspendGroup(GROUP)                EVT_CMD(EVT_OP_SUSPEND_GROUP, GROUP),
 
#define ResumeGroup(GROUP)                 EVT_CMD(EVT_OP_RESUME_GROUP, GROUP),
 
#define SuspendOthers(GROUP)               EVT_CMD(EVT_OP_SUSPEND_OTHERS, GROUP),
 
#define ResumeOthers(GROUP)                EVT_CMD(EVT_OP_RESUME_OTHERS, GROUP),
 
#define SuspendThread(TID)                 EVT_CMD(EVT_OP_SUSPEND_THREAD, TID),
 
#define ResumeThread(TID)                  EVT_CMD(EVT_OP_RESUME_THREAD, TID),
 
#define IsThreadRunning(TID, OUTVAR)      EVT_CMD(EVT_OP_IS_THREAD_RUNNING, TID, OUTVAR),
 
#define Thread                              EVT_CMD(EVT_OP_THREAD),
 
#define EndThread                          EVT_CMD(EVT_OP_END_THREAD),
 
#define ChildThread                        EVT_CMD(EVT_OP_CHILD_THREAD),
 
#define EndChildThread                    EVT_CMD(EVT_OP_END_CHILD_THREAD),
 
#define Call(FUNC, ARGS...)                     EVT_CMD(EVT_OP_CALL, (Bytecode) FUNC, ##ARGS),
 
#define EVT_DEBUG_LOG(STRING)                   EVT_CMD(EVT_OP_DEBUG_LOG, STRING),
 
#define DebugPrintVar(VAR)                EVT_CMD(EVT_OP_DEBUG_PRINT_VAR, VAR),
 
/****** VECTOR OPERATIONS *********************************************************************************************/
 
// expand vector components
#define EVT_AS_VEC2(baseVar) (baseVar), (baseVar + 1)
#define EVT_AS_VEC3(baseVar) (baseVar), (baseVar + 1), (baseVar + 2)
 
// extract components from vector
#define EVT_VEC_X(baseVar) (baseVar)
#define EVT_VEC_Y(baseVar) (baseVar + 1)
#define EVT_VEC_Z(baseVar) (baseVar + 2)
 
#define EVT_VEC2_OP(OPERATION, MUT_BASE, x, y) \
    OPERATION(MUT_BASE + 0, x) \
    OPERATION(MUT_BASE + 1, y)
 
#define EVT_VEC3_OP(OPERATION, MUT_BASE, x, y, z) \
    OPERATION(MUT_BASE + 0, x) \
    OPERATION(MUT_BASE + 1, y) \
    OPERATION(MUT_BASE + 2, z)
 
#define EVT_VEC2_VOP(OPERATION, MUT_BASE, AMT_BASE) \
    OPERATION(MUT_BASE + 0, AMT_BASE + 0) \
    OPERATION(MUT_BASE + 1, AMT_BASE + 1)
 
#define EVT_VEC3_VOP(OPERATION, MUT_BASE, AMT_BASE) \
    OPERATION(MUT_BASE + 0, AMT_BASE + 0) \
    OPERATION(MUT_BASE + 1, AMT_BASE + 1) \
    OPERATION(MUT_BASE + 2, AMT_BASE + 2)
 
#define EVT_VEC2I_SET(baseVar, x, y)    EVT_VEC2_OP(Set, baseVar, x, y)
#define EVT_VEC2F_SET(baseVar, x, y)    EVT_VEC2_OP(SetF, baseVar, x, y)
#define EVT_VEC3I_SET(baseVar, x, y, z) EVT_VEC3_OP(Set, baseVar, x, y, z)
#define EVT_VEC3F_SET(baseVar, x, y, z) EVT_VEC3_OP(SetF, baseVar, x, y, z)
 
#define EVT_VEC2I_VSET(baseVar, baseSrc) EVT_VEC2_VOP(Set, baseVar, baseSrc)
#define EVT_VEC2F_VSET(baseVar, baseSrc) EVT_VEC2_VOP(SetF, baseVar, baseSrc)
#define EVT_VEC3I_VSET(baseVar, baseSrc) EVT_VEC3_VOP(Set, baseVar, baseSrc)
#define EVT_VEC3F_VSET(baseVar, baseSrc) EVT_VEC3_VOP(SetF, baseVar, baseSrc)
 
#define EVT_VEC2I_ADD(baseVar, x, y)    EVT_VEC2_OP(Add, baseVar, x, y)
#define EVT_VEC2F_ADD(baseVar, x, y)    EVT_VEC2_OP(AddF, baseVar, x, y)
#define EVT_VEC3I_ADD(baseVar, x, y, z) EVT_VEC3_OP(Add, baseVar, x, y, z)
#define EVT_VEC3F_ADD(baseVar, x, y, z) EVT_VEC3_OP(AddF, baseVar, x, y, z)
 
#define EVT_VEC2I_VADD(baseVar, baseAmt) EVT_VEC2_VOP(Add, baseVar, baseAmt)
#define EVT_VEC2F_VADD(baseVar, baseAmt) EVT_VEC2_VOP(AddF, baseVar, baseAmt)
#define EVT_VEC3I_VADD(baseVar, baseAmt) EVT_VEC3_VOP(Add, baseVar, baseAmt)
#define EVT_VEC3F_VADD(baseVar, baseAmt) EVT_VEC3_VOP(AddF, baseVar, baseAmt)
 
#define EVT_VEC2I_SUB(baseVar, x, y)    EVT_VEC2_OP(Sub, baseVar, x, y)
#define EVT_VEC2F_SUB(baseVar, x, y)    EVT_VEC2_OP(SubF, baseVar, x, y)
#define EVT_VEC3I_SUB(baseVar, x, y, z) EVT_VEC3_OP(Sub, baseVar, x, y, z)
#define EVT_VEC3F_SUB(baseVar, x, y, z) EVT_VEC3_OP(SubF, baseVar, x, y, z)
 
#define EVT_VEC2I_VSUB(baseVar, baseAmt) EVT_VEC2_VOP(Sub, baseVar, baseAmt)
#define EVT_VEC2F_VSUB(baseVar, baseAmt) EVT_VEC2_VOP(SubF, baseVar, baseAmt)
#define EVT_VEC3I_VSUB(baseVar, baseAmt) EVT_VEC3_VOP(Sub, baseVar, baseAmt)
#define EVT_VEC3F_VSUB(baseVar, baseAmt) EVT_VEC3_VOP(SubF, baseVar, baseAmt)
 
/****** COMMON SCRIPTS ************************************************************************************************/
 
#define IfTrue(b)  IfNe(b, 0)
#define IfFalse(b) IfEq(b, 0)
 
#define EVT_EXIT_WALK(walkDistance, exitIdx, map, entryIdx) \
    { \
        SetGroup(EVT_GROUP_EXIT_MAP) \
        Call(DisablePlayerInput, TRUE) \
        Call(UseExitHeading, walkDistance, exitIdx) \
        Exec(ExitWalk) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
// alternate version of EVT_EXIT_WALK used on Pleasant Path which does not join EVT_GROUP_EXIT_MAP
#define EVT_EXIT_WALK_NOK(walkDistance, exitIdx, map, entryIdx) \
    { \
        Call(UseExitHeading, walkDistance, exitIdx) \
        Exec(ExitWalk) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
#define EVT_EXIT_SINGLE_DOOR(exitIdx, map, entryIdx, colliderID, modelID, swingDir) \
    { \
        SetGroup(EVT_GROUP_EXIT_MAP) \
        Call(DisablePlayerInput, TRUE) \
        Set(LVar0, exitIdx) \
        Set(LVar1, colliderID) \
        Set(LVar2, modelID) \
        Set(LVar3, swingDir) \
        Exec(ExitSingleDoor) \
        Wait(17) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
#define EVT_EXIT_SINGLE_DOOR_SET_SOUNDS(exitIdx, map, entryIdx, colliderID, modelID, swingDir, sounds) \
    { \
        SetGroup(EVT_GROUP_EXIT_MAP) \
        Call(DisablePlayerInput, TRUE) \
        Call(UseDoorSounds, sounds) \
        Set(LVar0, exitIdx) \
        Set(LVar1, colliderID) \
        Set(LVar2, modelID) \
        Set(LVar3, swingDir) \
        Exec(ExitSingleDoor) \
        Wait(17) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
#define EVT_EXIT_SPLIT_SINGLE_DOOR(exitIdx, map, entryIdx, colliderID, topModelID, bottomModelID, swingDir) \
    { \
        SetGroup(EVT_GROUP_EXIT_MAP) \
        Call(DisablePlayerInput, TRUE) \
        Set(LVar0, exitIdx) \
        Set(LVar1, colliderID) \
        Set(LVar2, topModelID) \
        Set(LVar4, bottomModelID) \
        Set(LVar3, swingDir) \
        Exec(ExitSplitSingleDoor) \
        Wait(17) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
#define EVT_EXIT_DOUBLE_DOOR(exitIdx, map, entryIdx, colliderID, leftDoorModelID, rightDoorModelID) \
    { \
        SetGroup(EVT_GROUP_EXIT_MAP) \
        Call(DisablePlayerInput, TRUE) \
        Set(LVar0, exitIdx) \
        Set(LVar1, colliderID) \
        Set(LVar2, leftDoorModelID) \
        Set(LVar3, rightDoorModelID) \
        Exec(ExitDoubleDoor) \
        Wait(17) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
#define EVT_EXIT_DOUBLE_DOOR_SET_SOUNDS(exitIdx, map, entryIdx, colliderID, leftDoorModelID, rightDoorModelID, sounds) \
    { \
        SetGroup(EVT_GROUP_EXIT_MAP) \
        Call(DisablePlayerInput, TRUE) \
        Call(UseDoorSounds, sounds) \
        Set(LVar0, exitIdx) \
        Set(LVar1, colliderID) \
        Set(LVar2, leftDoorModelID) \
        Set(LVar3, rightDoorModelID) \
        Exec(ExitDoubleDoor) \
        Wait(17) \
        Call(GotoMap, Ref(map), entryIdx) \
        Wait(100) \
        Return \
        End \
    }
 
#define EVT_SETUP_CAMERA_DEFAULT(r, g, b) \
    Call(SetCamPerspective, CAM_DEFAULT, CAM_UPDATE_FROM_ZONE, 25, 16, 4096) \
    Call(SetCamBGColor, CAM_DEFAULT, r, g, b) \
    Call(SetCamEnabled, CAM_DEFAULT, TRUE)
 
#define EVT_SETUP_CAMERA_NO_LEAD(r, g, b) \
    Call(SetCamPerspective, CAM_DEFAULT, CAM_UPDATE_FROM_ZONE, 25, 16, 4096) \
    Call(SetCamBGColor, CAM_DEFAULT, r, g, b) \
    Call(SetCamLeadPlayer, CAM_DEFAULT, FALSE) \
    Call(SetCamEnabled, CAM_DEFAULT, TRUE)
 
#define EVT_SETUP_CAMERA_MIM() \
    Call(SetCamPerspective, CAM_DEFAULT, CAM_UPDATE_FROM_ZONE, 25, 16, 650) \
    Call(SetCamBGColor, CAM_DEFAULT, 0, 0, 0) \
    Call(SetCamLeadPlayer, CAM_DEFAULT, FALSE) \
    Call(SetCamEnabled, CAM_DEFAULT, TRUE)
 
// allow macros with variable number of arguments
// see https://stackoverflow.com/questions/11761703/overloading-macro-on-number-of-arguments
// solution provided by R1tschY and edited by Gabriel Staples
#define __NARG__(args...) \
    __NARG_I_(args,__RSEQ_N())
#define __NARG_I_(args...) \
    __ARG_N(args)
#define __ARG_N( \
      _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
     _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
     _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
     _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
     _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
     _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
     _61,_62,_63,N,...) N
#define __RSEQ_N() \
     63,62,61,60,                   \
     59,58,57,56,55,54,53,52,51,50, \
     49,48,47,46,45,44,43,42,41,40, \
     39,38,37,36,35,34,33,32,31,30, \
     29,28,27,26,25,24,23,22,21,20, \
     19,18,17,16,15,14,13,12,11,10, \
     9,8,7,6,5,4,3,2,1,0
#define _VFUNC_(name, n) name##n
#define _VFUNC(name, n) _VFUNC_(name, n)
#define VFUNC(func, args...) _VFUNC(func, __NARG__(args)) (args)
 
#define PlayEffect(args...) VFUNC(PlayEffect, args)
#define PlayEffect1(effect) \
    Call(PlayEffect_impl, effect, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect2(effect, subtype) \
    Call(PlayEffect_impl, effect, subtype, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect3(effect, subtype, a) \
    Call(PlayEffect_impl, effect, subtype, a, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect4(effect, subtype, a, b) \
    Call(PlayEffect_impl, effect, subtype, a, b, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect5(effect, subtype, a, b, c) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, 0, 0, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect6(effect, subtype, a, b, c, d) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, 0, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect7(effect, subtype, a, b, c, d, e) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, 0, 0, 0, 0, 0, 0, 0)
#define PlayEffect8(effect, subtype, a, b, c, d, e, f) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, 0, 0, 0, 0, 0, 0)
#define PlayEffect9(effect, subtype, a, b, c, d, e, f, g) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, g, 0, 0, 0, 0, 0)
#define PlayEffect10(effect, subtype, a, b, c, d, e, f, g, h) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, g, h, 0, 0, 0, 0)
#define PlayEffect11(effect, subtype, a, b, c, d, e, f, g, h, i) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, g, h, i, 0, 0, 0)
#define PlayEffect12(effect, subtype, a, b, c, d, e, f, g, h, i, j) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, g, h, i, j, 0, 0)
#define PlayEffect13(effect, subtype, a, b, c, d, e, f, g, h, i, j, k) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, g, h, i, j, k, 0)
#define PlayEffect14(effect, subtype, a, b, c, d, e, f, g, h, i, j, k, l) \
    Call(PlayEffect_impl, effect, subtype, a, b, c, d, e, f, g, h, i, j, k, l)
 
#ifdef _LANGUAGE_C_PLUS_PLUS
}
#endif
 
#endif