mirror of
https://github.com/scp-fs2open/fs2open.github.com.git
synced 2026-11-08 07:28:22 -10:00
asarium
a13b503b83
The largest new feature is that it is now possible to include other files into the RML by using the "include" tag. This is useful for making markup files more modular. Also added some more options for existing things (e.g. built-in detail options).
572 lines
6.6 KiB
C++
572 lines
6.6 KiB
C++
|
|
#include "enums.h"
|
|
|
|
#include "scripting/ade.h"
|
|
|
|
namespace scripting {
|
|
namespace api {
|
|
|
|
//**********OBJECT: constant class
|
|
//WMC NOTE -
|
|
//While you can have enumeration indexes in any order, make sure
|
|
//that any new enumerations have indexes of NEXT INDEX (see below)
|
|
//or after. Don't forget to increment NEXT INDEX after you're done.
|
|
//=====================================
|
|
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
|
flag_def_list Enumerations[] = {
|
|
{
|
|
"ALPHABLEND_FILTER",
|
|
LE_ALPHABLEND_FILTER,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ALPHABLEND_NONE",
|
|
LE_ALPHABLEND_NONE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"CFILE_TYPE_NORMAL",
|
|
LE_CFILE_TYPE_NORMAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"CFILE_TYPE_MEMORY_MAPPED",
|
|
LE_CFILE_TYPE_MEMORY_MAPPED,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MOUSE_LEFT_BUTTON",
|
|
LE_MOUSE_LEFT_BUTTON,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MOUSE_RIGHT_BUTTON",
|
|
LE_MOUSE_RIGHT_BUTTON,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MOUSE_MIDDLE_BUTTON",
|
|
LE_MOUSE_MIDDLE_BUTTON,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK",
|
|
LE_ORDER_ATTACK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK_ANY",
|
|
LE_ORDER_ATTACK_ANY,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DEPART",
|
|
LE_ORDER_DEPART,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DISABLE",
|
|
LE_ORDER_DISABLE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DISARM",
|
|
LE_ORDER_DISARM,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_DOCK",
|
|
LE_ORDER_DOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_EVADE",
|
|
LE_ORDER_EVADE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_FLY_TO",
|
|
LE_ORDER_FLY_TO,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_FORM_ON_WING",
|
|
LE_ORDER_FORM_ON_WING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_GUARD",
|
|
LE_ORDER_GUARD,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_IGNORE_SHIP",
|
|
LE_ORDER_IGNORE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_KEEP_SAFE_DISTANCE",
|
|
LE_ORDER_KEEP_SAFE_DISTANCE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_PLAY_DEAD",
|
|
LE_ORDER_PLAY_DEAD,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_PLAY_DEAD_PERSISTENT",
|
|
LE_ORDER_PLAY_DEAD_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_REARM",
|
|
LE_ORDER_REARM,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_STAY_NEAR",
|
|
LE_ORDER_STAY_NEAR,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_STAY_STILL",
|
|
LE_ORDER_STAY_STILL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_UNDOCK",
|
|
LE_ORDER_UNDOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_WAYPOINTS",
|
|
LE_ORDER_WAYPOINTS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_WAYPOINTS_ONCE",
|
|
LE_ORDER_WAYPOINTS_ONCE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK_WING",
|
|
LE_ORDER_ATTACK_WING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_GUARD_WING",
|
|
LE_ORDER_GUARD_WING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"ORDER_ATTACK_SHIP_CLASS",
|
|
LE_ORDER_ATTACK_SHIP_CLASS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_DEBUG",
|
|
LE_PARTICLE_DEBUG,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_BITMAP",
|
|
LE_PARTICLE_BITMAP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_FIRE",
|
|
LE_PARTICLE_FIRE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_SMOKE",
|
|
LE_PARTICLE_SMOKE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_SMOKE2",
|
|
LE_PARTICLE_SMOKE2,
|
|
0
|
|
},
|
|
|
|
{
|
|
"PARTICLE_PERSISTENT_BITMAP",
|
|
LE_PARTICLE_PERSISTENT_BITMAP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_CAMPAIGN_PERSISTENT",
|
|
LE_SEXPVAR_CAMPAIGN_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_NOT_PERSISTENT",
|
|
LE_SEXPVAR_NOT_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_PLAYER_PERSISTENT",
|
|
LE_SEXPVAR_PLAYER_PERSISTENT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_TYPE_NUMBER",
|
|
LE_SEXPVAR_TYPE_NUMBER,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SEXPVAR_TYPE_STRING",
|
|
LE_SEXPVAR_TYPE_STRING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"TEXTURE_STATIC",
|
|
LE_TEXTURE_STATIC,
|
|
0
|
|
},
|
|
|
|
{
|
|
"TEXTURE_DYNAMIC",
|
|
LE_TEXTURE_DYNAMIC,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LOCK",
|
|
LE_LOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"UNLOCK",
|
|
LE_UNLOCK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"NONE",
|
|
LE_NONE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_FRONT",
|
|
LE_SHIELD_FRONT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_LEFT",
|
|
LE_SHIELD_LEFT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_RIGHT",
|
|
LE_SHIELD_RIGHT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"SHIELD_BACK",
|
|
LE_SHIELD_BACK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MISSION_REPEAT",
|
|
LE_MISSION_REPEAT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"NORMAL_CONTROLS",
|
|
LE_NORMAL_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_STEERING_CONTROLS",
|
|
LE_LUA_STEERING_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_FULL_CONTROLS",
|
|
LE_LUA_FULL_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"NORMAL_BUTTON_CONTROLS",
|
|
LE_NORMAL_BUTTON_CONTROLS,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_ADDITIVE_BUTTON_CONTROL",
|
|
LE_LUA_ADDITIVE_BUTTON_CONTROL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"LUA_OVERRIDE_BUTTON_CONTROL",
|
|
LE_LUA_OVERRIDE_BUTTON_CONTROL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_INTERNAL",
|
|
LE_VM_INTERNAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_EXTERNAL",
|
|
LE_VM_EXTERNAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_TRACK",
|
|
LE_VM_TRACK,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_DEAD_VIEW",
|
|
LE_VM_DEAD_VIEW,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_CHASE",
|
|
LE_VM_CHASE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_OTHER_SHIP",
|
|
LE_VM_OTHER_SHIP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_EXTERNAL_CAMERA_LOCKED",
|
|
LE_VM_EXTERNAL_CAMERA_LOCKED,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_CAMERA_LOCKED",
|
|
LE_VM_CAMERA_LOCKED,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_WARP_CHASE",
|
|
LE_VM_WARP_CHASE,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_UP",
|
|
LE_VM_PADLOCK_UP,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_REAR",
|
|
LE_VM_PADLOCK_REAR,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_LEFT",
|
|
LE_VM_PADLOCK_LEFT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_PADLOCK_RIGHT",
|
|
LE_VM_PADLOCK_RIGHT,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_WARPIN_ANCHOR",
|
|
LE_VM_WARPIN_ANCHOR,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_TOPDOWN",
|
|
LE_VM_TOPDOWN,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_FREECAMERA",
|
|
LE_VM_FREECAMERA,
|
|
0
|
|
},
|
|
|
|
{
|
|
"VM_CENTERING",
|
|
LE_VM_CENTERING,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MESSAGE_PRIORITY_LOW",
|
|
LE_MESSAGE_PRIORITY_LOW,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MESSAGE_PRIORITY_NORMAL",
|
|
LE_MESSAGE_PRIORITY_NORMAL,
|
|
0
|
|
},
|
|
|
|
{
|
|
"MESSAGE_PRIORITY_HIGH",
|
|
LE_MESSAGE_PRIORITY_HIGH,
|
|
0
|
|
},
|
|
{
|
|
"OPTION_TYPE_SELECTION",
|
|
LE_OPTION_TYPE_SELECTION,
|
|
0
|
|
},
|
|
{
|
|
"OPTION_TYPE_RANGE",
|
|
LE_OPTION_TYPE_RANGE,
|
|
0
|
|
},
|
|
};
|
|
|
|
//DO NOT FORGET to increment NEXT INDEX: !!!!!!!!!!!!!
|
|
|
|
size_t Num_enumerations = sizeof(Enumerations) / sizeof(flag_def_list);
|
|
|
|
|
|
enum_h::enum_h() {
|
|
index = -1;
|
|
is_constant = false;
|
|
}
|
|
enum_h::enum_h(int n_index) {
|
|
index = n_index;
|
|
is_constant = false;
|
|
}
|
|
bool enum_h::IsValid() const { return (index > -1 && index < ENUM_NEXT_INDEX); }
|
|
|
|
ADE_OBJ(l_Enum, enum_h, "enumeration", "Enumeration object");
|
|
|
|
ADE_FUNC(__newindex,
|
|
l_Enum,
|
|
"enumeration",
|
|
"Sets enumeration to specified value (if it is not a global",
|
|
"enumeration",
|
|
"enumeration") {
|
|
enum_h* e1 = NULL, * e2 = NULL;
|
|
if (!ade_get_args(L, "oo", l_Enum.GetPtr(&e1), l_Enum.GetPtr(&e2))) {
|
|
return ade_set_error(L, "o", l_Enum.Set(enum_h()));
|
|
}
|
|
|
|
if (!e1->is_constant) {
|
|
e1->index = e2->index;
|
|
}
|
|
|
|
return ade_set_args(L, "o", l_Enum.Set(*e1));
|
|
}
|
|
|
|
ADE_FUNC(__tostring,
|
|
l_Enum,
|
|
NULL,
|
|
"Returns enumeration name",
|
|
"string",
|
|
"Enumeration name, or \"<INVALID>\" if invalid") {
|
|
enum_h* e = NULL;
|
|
if (!ade_get_args(L, "o", l_Enum.GetPtr(&e))) {
|
|
return ade_set_args(L, "s", "<INVALID>");
|
|
}
|
|
|
|
if (e->index < 1 || e->index >= ENUM_NEXT_INDEX) {
|
|
return ade_set_args(L, "s", "<INVALID>");
|
|
}
|
|
|
|
uint i;
|
|
for (i = 0; i < Num_enumerations; i++) {
|
|
if (Enumerations[i].def == e->index) {
|
|
return ade_set_args(L, "s", Enumerations[i].name);
|
|
}
|
|
}
|
|
|
|
return ade_set_args(L, "s", "<INVALID>");
|
|
}
|
|
|
|
ADE_FUNC(__eq,
|
|
l_Enum,
|
|
"enumeration",
|
|
"Compares the two enumerations for equality",
|
|
"boolean",
|
|
"true if equal, false otherwise") {
|
|
enum_h* e1 = NULL;
|
|
enum_h* e2 = NULL;
|
|
|
|
if (!ade_get_args(L, "oo", l_Enum.GetPtr(&e1), l_Enum.GetPtr(&e2))) {
|
|
return ade_set_error(L, "o", l_Enum.Set(enum_h()));
|
|
}
|
|
|
|
if (e1 == NULL || e2 == NULL) {
|
|
return ADE_RETURN_FALSE;
|
|
}
|
|
|
|
return ade_set_args(L, "b", e1->index == e2->index);
|
|
}
|
|
|
|
}
|
|
}
|