Skip to content

Instantly share code, notes, and snippets.

@nitrocaster

nitrocaster/lua_help.hpp

Created November 26, 2015 20:25
Show Gist options
  • Save nitrocaster/2c39ac5c404a21ab0052 to your computer and use it in GitHub Desktop.
Save nitrocaster/2c39ac5c404a21ab0052 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
lua_help.hpp
CGameFont* GetFontGraffiti19Russian();
unsigned int render_get_dx_level();
char const* command_line();
CGameFont* GetFontLetterica16Russian();
CGameFont* GetFontLetterica18Russian();
CGameFont* GetFontGraffiti50Russian();
CGameGraph const* game_graph();
bool IsImportantSave();
CGameFont* GetFontGraffiti32Russian();
int GetARGB(unsigned short,unsigned short,unsigned short,unsigned short);
action_planner* cast_planner(action_base*);
CUIGameCustom* get_hud();
FS* getFS();
bool IsDynamicMusic();
void show_condition(ini_file*,char const*);
CGameFont* GetFontSmall();
cef_storage* ef_storage();
bool IsGameTypeSingle();
CConsole* get_console();
int bit_and(int,int);
unsigned short script_server_object_version();
ini_file* create_ini_file(char const*);
ini_file* system_ini();
CGameFont* GetFontDI();
unsigned int time_global();
bool is_enough_address_space_available();
void log(char const*);
void error_log(char const*);
void prefetch(char const*);
bool editor();
int bit_or(int,int);
unsigned int time_global_async();
int bit_not(int);
render_device* device();
bool app_ready();
char const* user_name();
int dik_to_bind(int);
alife_simulator* alife();
CGameFont* GetFontLetterica25();
bool valid_saved_game(char const*);
CGameFont* GetFontGraffiti22Russian();
void buy_condition(custom [float],custom [float]);
int bit_xor(int,int);
void sell_condition(custom [float],custom [float]);
CGameFont* GetFontMedium();
ini_file* game_ini();
void verify_if_thread_is_running();
void flush();
[cpp]
class best_scores_pair_t
{
int second { get; set; }
custom [enum gamespy_profile::enum_best_score_type] first { get; set; }
}
[cpp]
class CWeaponBM16 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class holder
{
void Action(holder&,unsigned short,unsigned int);
bool engaged(holder&);
void SetParam(holder&,int,vector);
}
[cpp]
class CPoltergeist : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class color
{
custom [float] b { get; set; }
color& set(color&,custom [float],custom [float],custom [float]);
custom [float] r { get; set; }
custom [float] g { get; set; }
void __init(luabind::argument const&,custom [float],custom [float],custom [float]);
}
[cpp]
class CALifeMonsterMovementManager
{
CALifeMonsterDetailPathManager* detail(CALifeMonsterMovementManager const*);
custom [enum MovementManager::EPathType] const& path_type(CALifeMonsterMovementManager const&);
bool completed(CALifeMonsterMovementManager const&);
bool actual(CALifeMonsterMovementManager const&);
CALifeMonsterPatrolPathManager* patrol(CALifeMonsterMovementManager const*);
}
[cpp]
class CAI_PseudoDog : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class fs_file
{
unsigned int ptr { get; set; }
unsigned int size_real { get; set; }
unsigned int vfs { get; set; }
unsigned int size_compressed { get; set; }
char const* name { get; set; }
unsigned int modif { get; set; }
}
[cpp]
class cond
{
const act_end = 128;
const anim_end = 4;
const look_end = 2;
const move_end = 1;
const object_end = 32;
const sound_end = 8;
const time_end = 64;
void __init(luabind::argument const&,unsigned int,custom [double]);
}
[cpp]
class cse_alife_item_weapon_auto_shotgun : cse_alife_item_weapon
{
void on_unregister(cse_alife_item_weapon_auto_shotgun&);
void use_ai_locations(cse_alife_object&,bool);
void UPDATE_Write(cse_abstract&,net_packet&);
bool can_switch_offline(cse_alife_item_weapon_auto_shotgun const&);
void switch_online(cse_alife_item_weapon_auto_shotgun&);
cse_abstract* init(cse_alife_item_weapon_auto_shotgun&);
bool interactive(cse_alife_item_weapon_auto_shotgun const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_weapon_auto_shotgun&);
void STATE_Read(cse_alife_item_weapon_auto_shotgun&,net_packet&,unsigned short);
void on_register(cse_alife_item_weapon_auto_shotgun&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
void clone_addons(cse_alife_item_weapon&,cse_alife_item_weapon*);
bool keep_saved_data_anyway(cse_alife_item_weapon_auto_shotgun const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_weapon_auto_shotgun const&);
vector& angle { get; set; }
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
void on_spawn(cse_alife_item_weapon_auto_shotgun&);
unsigned int m_level_vertex_id { get; set; }
bool used_ai_locations(cse_alife_item_weapon_auto_shotgun const&);
bool can_save(cse_alife_item_weapon_auto_shotgun const&);
bool bfUseful(cse_alife_item_weapon_auto_shotgun&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_weapon_auto_shotgun&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void STATE_Write(cse_alife_item_weapon_auto_shotgun&,net_packet&);
char const* name(cse_abstract const*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class story_ids
{
const INVALID_STORY_ID = -1;
const Invalid = 65535;
const test_01 = 65000;
const test_02 = 65001;
const test_03 = 65002;
const test_04 = 65003;
const test_05 = 65004;
}
[cpp]
class danger_object
{
const attack_sound = 1;
const attacked = 5;
const bullet_ricochet = 0;
const enemy_sound = 7;
const entity_attacked = 2;
const entity_corpse = 4;
const entity_death = 3;
const grenade = 6;
const hit = 2;
const sound = 1;
const visual = 0;
game_object* object(danger_object const*);
vector position(danger_object const*);
void __eq(lua_State*,danger_object const&,danger_object);
custom [enum CDangerObject::EDangerType] type(danger_object const&);
unsigned int time(danger_object const&);
game_object* dependent_object(danger_object const*);
custom [enum CDangerObject::EDangerPerceiveType] perceive_type(danger_object const&);
}
[cpp]
class DIK_keys
{
const DIK_0 = 11;
const DIK_1 = 2;
const DIK_2 = 3;
const DIK_3 = 4;
const DIK_4 = 5;
const DIK_5 = 6;
const DIK_6 = 7;
const DIK_7 = 8;
const DIK_8 = 9;
const DIK_9 = 10;
const DIK_A = 30;
const DIK_ADD = 78;
const DIK_APOSTROPHE = 40;
const DIK_APPS = 221;
const DIK_AT = 145;
const DIK_AX = 150;
const DIK_B = 48;
const DIK_BACK = 14;
const DIK_BACKSLASH = 43;
const DIK_C = 46;
const DIK_CAPITAL = 58;
const DIK_CIRCUMFLEX = 144;
const DIK_COLON = 146;
const DIK_COMMA = 51;
const DIK_CONVERT = 121;
const DIK_D = 32;
const DIK_DECIMAL = 83;
const DIK_DELETE = 211;
const DIK_DIVIDE = 181;
const DIK_DOWN = 208;
const DIK_E = 18;
const DIK_END = 207;
const DIK_EQUALS = 13;
const DIK_ESCAPE = 1;
const DIK_F = 33;
const DIK_F1 = 59;
const DIK_F10 = 68;
const DIK_F11 = 87;
const DIK_F12 = 88;
const DIK_F13 = 100;
const DIK_F14 = 101;
const DIK_F15 = 102;
const DIK_F2 = 60;
const DIK_F3 = 61;
const DIK_F4 = 62;
const DIK_F5 = 63;
const DIK_F6 = 64;
const DIK_F7 = 65;
const DIK_F8 = 66;
const DIK_F9 = 67;
const DIK_G = 34;
const DIK_GRAVE = 41;
const DIK_H = 35;
const DIK_HOME = 199;
const DIK_I = 23;
const DIK_INSERT = 210;
const DIK_J = 36;
const DIK_K = 37;
const DIK_KANA = 112;
const DIK_KANJI = 148;
const DIK_L = 38;
const DIK_LBRACKET = 26;
const DIK_LCONTROL = 29;
const DIK_LEFT = 203;
const DIK_LMENU = 56;
const DIK_LSHIFT = 42;
const DIK_LWIN = 219;
const DIK_M = 50;
const DIK_MINUS = 12;
const DIK_MULTIPLY = 55;
const DIK_N = 49;
const DIK_NEXT = 209;
const DIK_NOCONVERT = 123;
const DIK_NUMLOCK = 69;
const DIK_NUMPAD0 = 82;
const DIK_NUMPAD1 = 79;
const DIK_NUMPAD2 = 80;
const DIK_NUMPAD3 = 81;
const DIK_NUMPAD4 = 75;
const DIK_NUMPAD5 = 76;
const DIK_NUMPAD6 = 77;
const DIK_NUMPAD7 = 71;
const DIK_NUMPAD8 = 72;
const DIK_NUMPAD9 = 73;
const DIK_NUMPADCOMMA = 179;
const DIK_NUMPADENTER = 156;
const DIK_NUMPADEQUALS = 141;
const DIK_O = 24;
const DIK_P = 25;
const DIK_PAUSE = 197;
const DIK_PERIOD = 52;
const DIK_PRIOR = 201;
const DIK_Q = 16;
const DIK_R = 19;
const DIK_RBRACKET = 27;
const DIK_RCONTROL = 157;
const DIK_RETURN = 28;
const DIK_RIGHT = 205;
const DIK_RMENU = 184;
const DIK_RSHIFT = 54;
const DIK_RWIN = 220;
const DIK_S = 31;
const DIK_SCROLL = 70;
const DIK_SEMICOLON = 39;
const DIK_SLASH = 53;
const DIK_SPACE = 57;
const DIK_STOP = 149;
const DIK_SUBTRACT = 74;
const DIK_SYSRQ = 183;
const DIK_T = 20;
const DIK_TAB = 15;
const DIK_U = 22;
const DIK_UNDERLINE = 147;
const DIK_UNLABELED = 151;
const DIK_UP = 200;
const DIK_V = 47;
const DIK_W = 17;
const DIK_X = 45;
const DIK_Y = 21;
const DIK_YEN = 125;
const DIK_Z = 44;
const MOUSE_1 = 337;
const MOUSE_2 = 338;
const MOUSE_3 = 339;
}
[cpp]
class CUIListBoxItem : CUIFrameLineWnd
{
void AttachChild(CUIWindow&,CUIWindow*);
void SetWidth(CUIFrameLineWnd&,custom [float]);
CUIStatic* AddIconField(CUIListBoxItem&,custom [float]);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
void SetHeight(CUIFrameLineWnd&,custom [float]);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void __init(luabind::argument const&,custom [float]);
custom [float] GetWidth(CUIWindow const&);
void SetPPMode(CUIWindow&);
void SetColor(CUIFrameLineWnd&,unsigned int);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetTextColor(CUIListBoxItem&,unsigned int);
void SetWndRect(CUIWindow&,Frect);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void Enable(CUIWindow&,bool);
CUITextWnd* AddTextField(CUIListBoxItem&,char const*,custom [float]);
CUITextWnd* GetTextItem(CUIListBoxItem&);
void DetachChild(CUIWindow&,CUIWindow*);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CUITextWnd : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void SetTextComplexMode(CUITextWnd&,bool);
void __init(luabind::argument const&);
void AdjustWidthToText(CUITextWnd&);
bool IsShown(CUIWindow&);
void SetFont(CUITextWnd&,CGameFont*);
custom [float] GetWidth(CUIWindow const&);
void SetWindowName(CUIWindow&,char const*);
void SetVTextAlignment(CUITextWnd&,custom [enum EVTextAlignment]);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetTextColor(CUITextWnd&,unsigned int);
void SetWndRect(CUIWindow&,Frect);
void SetEllipsis(CUITextWnd&,bool);
void AdjustHeightToText(CUITextWnd&);
void SetTextST(CUITextWnd&,char const*);
void SetTextOffset(CUITextWnd&,custom [float],custom [float]);
CGameFont* GetFont(CUITextWnd&);
unsigned int GetTextColor(CUITextWnd&);
void SetWndSize(CUIWindow&,vector2);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
void Enable(CUIWindow&,bool);
void SetWndPos(CUIWindow&,vector2);
char const* GetText(CUITextWnd&);
void Show(CUIWindow&,bool);
void SetPPMode(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
bool IsEnabled(CUIWindow&);
char const* WindowName(CUIWindow&);
void SetTextAlignment(CUITextWnd&,custom [enum IGameFont::EAligment]);
void SetText(CUITextWnd&,char const*);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CChimera : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class ce_script_zone : DLL_Pure
{
DLL_Pure* _construct(DLL_Pure&);
void __init(luabind::argument const&);
}
[cpp]
class CWeaponWalther : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class ce_smart_zone : DLL_Pure
{
DLL_Pure* _construct(DLL_Pure&);
void __init(luabind::argument const&);
}
[cpp]
class CAI_Trader : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CWeaponAK74 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CF1 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class not_yet_visible_object
{
game_object* object(not_yet_visible_object const&);
custom [float] value { get; set; }
}
[cpp]
class CUIStatic : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
custom [float] GetHeight(CUIWindow const&);
void Enable(CUIWindow&,bool);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetTextureRect(CUIStatic&,Frect*);
void SetStretchTexture(CUIStatic&,bool);
Frect const* GetTextureRect(CUIStatic&);
}
[cpp]
class cse_alife_object_climable : , cse_shapecse_abstract
{
vector& angle { get; set; }
vector& position { get; set; }
unsigned short id { get; set; }
char const* section_name(cse_abstract const*);
char const* name(cse_abstract const*);
void STATE_Read(cse_alife_object_climable&,net_packet&,unsigned short);
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_object_climable&,net_packet&);
unsigned short parent_id { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short script_version { get; set; }
int clsid(cse_abstract const&);
cse_abstract* init(cse_alife_object_climable&);
ini_file* spawn_ini(cse_abstract*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class patrol
{
const continue = 1;
const custom = 3;
const dummy = -1;
const nearest = 2;
const next = 4;
const start = 0;
const stop = 0;
bool flag(patrol const&,unsigned int,unsigned char);
unsigned short game_vertex_id(patrol const&,unsigned int);
vector point(patrol const*,unsigned int);
unsigned int get_nearest(patrol const&,vector const&);
bool terminal(patrol const&,unsigned int);
flags32 flags(patrol const&,unsigned int);
unsigned int index(patrol const&,char const*);
void __init(luabind::argument const&,char const*,custom [enum PatrolPathManager::EPatrolStartType] const,custom [enum PatrolPathManager::EPatrolRouteType] const,bool,unsigned int);
unsigned int count(patrol const&);
char const* name(patrol const&,unsigned int);
unsigned int level_vertex_id(patrol const&,unsigned int);
}
[cpp]
class CPhrase
{
CPhraseScript* GetPhraseScript(CPhrase&);
}
[cpp]
class Patch_Dawnload_Progress
{
char const* GetStatus(Patch_Dawnload_Progress&);
custom [float] GetProgress(Patch_Dawnload_Progress&);
char const* GetFlieName(Patch_Dawnload_Progress&);
bool GetInProgress(Patch_Dawnload_Progress&);
}
[cpp]
class CUIScriptWnd : , CUIDialogWndDLL_Pure
{
void AttachChild(CUIWindow&,CUIWindow*);
CDialogHolder* GetHolder(CUIDialogWnd&);
DLL_Pure* _construct(DLL_Pure&);
bool Dispatch(CUIScriptWnd&,int,int);
void __init(luabind::argument const&);
bool OnKeyboard(CUIScriptWnd&,int,custom [enum EUIMessages]);
void ShowDialog(CUIDialogWnd&,bool);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void Register(CUIScriptWnd&,CUIWindow*,char const*);
void SetWindowName(CUIWindow&,char const*);
void Show(CUIWindow&,bool);
void AddCallback(CUIScriptWnd&,char const*,short,function<void> const&,luabind::object const&);
bool Load(CUIScriptWnd&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
bool IsShown(CUIWindow&);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void Enable(CUIWindow&,bool);
void SetWndRect(CUIWindow&,Frect);
void Update(CUIScriptWnd&);
void HideDialog(CUIDialogWnd&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CUIEditBox : CUICustomEdit
{
void AttachChild(CUIWindow&,CUIWindow*);
void InitTexture(CUIEditBox&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
void SetText(CUICustomEdit&,char const*);
void SetWindowName(CUIWindow&,char const*);
void SetNextFocusCapturer(CUICustomEdit&,CUICustomEdit*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
char const* WindowName(CUIWindow&);
char const* GetText(CUICustomEdit const&);
bool IsEnabled(CUIWindow&);
void CaptureFocus(CUICustomEdit&,bool);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void Enable(CUIWindow&,bool);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CSnork : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CRGD5 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CSavedGameWrapper
{
custom [float] const& actor_health(CSavedGameWrapper const&);
CTime game_time(CSavedGameWrapper const*);
unsigned char const& level_id(CSavedGameWrapper const&);
char const* level_name(CSavedGameWrapper const&);
void __init(luabind::argument const&,char const*);
}
[cpp]
class cse_alife_helicopter : , cse_alife_dynamic_object_visual, cse_motioncse_ph_skeleton
{
void on_unregister(cse_alife_helicopter&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_helicopter const&);
void switch_online(cse_alife_helicopter&);
cse_abstract* init(cse_alife_helicopter&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_helicopter&);
void STATE_Read(cse_alife_helicopter&,net_packet&,unsigned short);
void on_register(cse_alife_helicopter&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_helicopter const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_helicopter const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_helicopter&);
bool can_save(cse_alife_helicopter const&);
bool used_ai_locations(cse_alife_helicopter const&);
void STATE_Write(cse_alife_helicopter&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_helicopter&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_helicopter const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class CScriptXmlInit
{
CUIMMShniaga* InitMMShniaga(CScriptXmlInit&,char const*,CUIWindow*);
CUIEditBox* InitMPPlayerName(CScriptXmlInit&,char const*,CUIWindow*);
CServerList* InitServerList(CScriptXmlInit&,char const*,CUIWindow*);
CUIStatic* InitSleepStatic(CScriptXmlInit&,char const*,CUIWindow*);
void __init(luabind::argument const&);
CUIEditBox* InitEditBox(CScriptXmlInit&,char const*,CUIWindow*);
CUIFrameLineWnd* InitFrameLine(CScriptXmlInit&,char const*,CUIWindow*);
CUITabControl* InitTab(CScriptXmlInit&,char const*,CUIWindow*);
CUIProgressBar* InitProgressBar(CScriptXmlInit&,char const*,CUIWindow*);
CUISpinText* InitSpinText(CScriptXmlInit&,char const*,CUIWindow*);
void InitWindow(CScriptXmlInit&,char const*,int,CUIWindow*);
void ParseFile(CScriptXmlInit&,char const*);
CUIMapList* InitMapList(CScriptXmlInit&,char const*,CUIWindow*);
CUITextWnd* InitTextWnd(CScriptXmlInit&,char const*,CUIWindow*);
CUIScrollView* InitScrollView(CScriptXmlInit&,char const*,CUIWindow*);
CUIWindow* InitKeyBinding(CScriptXmlInit&,char const*,CUIWindow*);
CUIEditBox* InitCDkey(CScriptXmlInit&,char const*,CUIWindow*);
CUI3tButton* Init3tButton(CScriptXmlInit&,char const*,CUIWindow*);
CUIComboBox* InitComboBox(CScriptXmlInit&,char const*,CUIWindow*);
CUITrackBar* InitTrackBar(CScriptXmlInit&,char const*,CUIWindow*);
CUIMapInfo* InitMapInfo(CScriptXmlInit&,char const*,CUIWindow*);
CUISpinFlt* InitSpinFlt(CScriptXmlInit&,char const*,CUIWindow*);
CUIStatic* InitStatic(CScriptXmlInit&,char const*,CUIWindow*);
CUISpinNum* InitSpinNum(CScriptXmlInit&,char const*,CUIWindow*);
CUIListBox* InitListBox(CScriptXmlInit&,char const*,CUIWindow*);
CUIStatic* InitAnimStatic(CScriptXmlInit&,char const*,CUIWindow*);
CUIFrameWindow* InitFrame(CScriptXmlInit&,char const*,CUIWindow*);
CUICheckButton* InitCheck(CScriptXmlInit&,char const*,CUIWindow*);
}
[cpp]
class CUISpinNum : CUICustomSpin
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* GetText(CUICustomSpin&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
char const* WindowName(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class sound_params
{
custom [float] min_distance { get; set; }
vector& position { get; set; }
custom [float] max_distance { get; set; }
custom [float] volume { get; set; }
custom [float] frequency { get; set; }
}
[cpp]
class object
{
const activate = 16;
const aim1 = 4;
const aim2 = 5;
const deactivate = 17;
const drop = 11;
const dummy = -1;
const fire1 = 6;
const fire2 = 8;
const hide = 22;
const idle = 9;
const reload = 2;
const reload1 = 2;
const reload2 = 3;
const show = 21;
const strap = 10;
const switch1 = 0;
const switch2 = 1;
const take = 23;
const turn_off = 20;
const turn_on = 19;
const use = 18;
void object(object&,game_object*);
void action(object&,custom [enum MonsterSpace::EObjectAction]);
bool completed(object&);
void __init(luabind::argument const&,char const*,custom [enum MonsterSpace::EObjectAction]);
}
[cpp]
class CWeaponRG6 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class game_memory_object : memory_object
{
game_object* object(game_memory_object const&);
custom [struct MemorySpace::CObjectParams<class CGameObject>]& self_info { get; set; }
unsigned int level_time { get; set; }
unsigned int last_level_time { get; set; }
custom [struct MemorySpace::CObjectParams<class CGameObject>]& object_info { get; set; }
}
[cpp]
class CMainMenu
{
char const* GetCDKey(CMainMenu&);
login_manager* GetLoginMngr(CMainMenu&);
account_manager* GetAccountMngr(CMainMenu&);
char const* GetGSVer(CMainMenu&);
bool ValidateCDKey(CMainMenu&);
Patch_Dawnload_Progress* GetPatchProgress(CMainMenu&);
profile_store* GetProfileStore(CMainMenu&);
char const* GetPlayerName(CMainMenu&);
void CancelDownload(CMainMenu&);
demo_info const* GetDemoInfo(CMainMenu&,char const*);
}
[cpp]
class profile_store
{
const at_award_massacre = 0;
const at_awards_count = 30;
const bst_backstabs_in_row = 2;
const bst_bleed_kills_in_row = 2;
const bst_explosive_kills_in_row = 3;
const bst_eye_kills_in_row = 4;
const bst_head_shots_in_row = 3;
const bst_kills_in_row = 0;
const bst_kinife_kills_in_row = 1;
const bst_score_types_count = 7;
void load_current_profile(profile_store&,store_operation_cb,store_operation_cb);
void stop_loading(profile_store&);
custom [class AssociativeVector<enum gamespy_profile::enum_best_score_type,int,struct std::less<enum gamespy_profile::enum_best_score_type> >] const& get_best_scores(profile_store&);
custom [class AssociativeVector<enum gamespy_profile::enum_awards_t,struct gamespy_profile::award_data,struct std::less<enum gamespy_profile::enum_awards_t> >] const& get_awards(profile_store&);
}
[cpp]
class property_evaluator_const : property_evaluator
{
game_object* object { get; set; }
bool evaluate(property_evaluator&);
property_storage* storage { get; set; }
void setup(property_evaluator&,game_object*,property_storage*);
void __init(luabind::argument const&,bool);
}
[cpp]
class award_pair_t
{
award_data& second { get; set; }
custom [enum gamespy_profile::enum_awards_t] first { get; set; }
}
[cpp]
class CUITrackBar : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void SetOptIBounds(CUITrackBar&,int,int);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void SetCheck(CUITrackBar&,bool);
bool GetCheck(CUITrackBar&);
void Enable(CUIWindow&,bool);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
custom [float] GetFValue(CUITrackBar&);
int GetIValue(CUITrackBar&);
void SetWndPos(CUIWindow&,vector2);
void SetWndSize(CUIWindow&,vector2);
void SetWndRect(CUIWindow&,Frect);
bool IsEnabled(CUIWindow&);
void SetPPMode(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetOptFBounds(CUITrackBar&,custom [float],custom [float]);
void SetCurrentValue(CUITrackBar&);
bool IsAutoDelete(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CPhysicObject : CGameObject
{
void play_bones_sound(CPhysicObject&);
void stop_bones_sound(CPhysicObject&);
int getVisible(CGameObject const&);
void stop_anim(CPhysicObject&);
void __init(luabind::argument const&);
custom [float] anim_time_get(CPhysicObject&);
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void anim_time_set(CPhysicObject&,custom [float]);
void run_anim_back(CPhysicObject&);
int net_Spawn(CGameObject&,cse_abstract*);
int getEnabled(CGameObject const&);
void unset_door_ignore_dynamics(CPhysicObject&);
DLL_Pure* _construct(CGameObject&);
void set_door_ignore_dynamics(CPhysicObject&);
void net_Export(CGameObject&,net_packet&);
void run_anim_forward(CPhysicObject&);
}
[cpp]
class CFadedBall : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_item_ammo : cse_alife_item
{
void on_unregister(cse_alife_item_ammo&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_ammo const&);
void switch_online(cse_alife_item_ammo&);
cse_abstract* init(cse_alife_item_ammo&);
bool interactive(cse_alife_item_ammo const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_ammo&);
void STATE_Read(cse_alife_item_ammo&,net_packet&,unsigned short);
void on_register(cse_alife_item_ammo&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_ammo const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_ammo const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_ammo&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_ammo&,net_packet&);
bool can_save(cse_alife_item_ammo const&);
bool used_ai_locations(cse_alife_item_ammo const&);
bool bfUseful(cse_alife_item_ammo&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_ammo&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class CWeaponFORT : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CDialogHolder
{
void RemoveDialogToRender(CDialogHolder&,CUIWindow*);
void AddDialogToRender(CDialogHolder&,CUIWindow*);
}
[cpp]
class CWeaponBinoculars : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUIPropertiesBox : CUIFrameWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void RemoveItem(CUIPropertiesBox&,unsigned int);
void SetWidth(CUIFrameWindow&,custom [float]);
void __init(luabind::argument const&);
void Show(CUIPropertiesBox&,int,int);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
void SetHeight(CUIFrameWindow&,custom [float]);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void RemoveAll(CUIPropertiesBox&);
custom [float] GetWidth(CUIWindow const&);
void SetPPMode(CUIWindow&);
void SetColor(CUIFrameWindow&,unsigned int);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void Hide(CUIPropertiesBox&);
bool AddItem(CUIPropertiesBox&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetWndSize(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
void AutoUpdateSize(CUIPropertiesBox&);
void SetWndRect(CUIWindow&,Frect);
void SetWndPos(CUIWindow&,vector2);
void ResetPPMode(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class object_factory
{
void register(object_factory&,char const*,char const*,char const*);
}
[cpp]
class CUIFrameWindow : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void SetWidth(CUIFrameWindow&,custom [float]);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
void SetHeight(CUIFrameWindow&,custom [float]);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void SetColor(CUIFrameWindow&,unsigned int);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void DetachChild(CUIWindow&,CUIWindow*);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void SetWndRect(CUIWindow&,Frect);
void SetPPMode(CUIWindow&);
custom [float] GetWidth(CUIWindow const&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class ICollidable
{
}
[cpp]
class cse_anomalous_zone : cse_custom_zone
{
void on_unregister(cse_anomalous_zone&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_anomalous_zone const&);
void switch_online(cse_anomalous_zone&);
cse_abstract* init(cse_anomalous_zone&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_anomalous_zone&);
void STATE_Read(cse_anomalous_zone&,net_packet&,unsigned short);
void on_register(cse_anomalous_zone&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_anomalous_zone const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_anomalous_zone const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_anomalous_zone&);
bool can_save(cse_anomalous_zone const&);
bool used_ai_locations(cse_anomalous_zone const&);
void STATE_Write(cse_anomalous_zone&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_anomalous_zone&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_anomalous_zone const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class CUIListBox : CUIScrollView
{
void AttachChild(CUIWindow&,CUIWindow*);
void AddExistingItem(CUIListBox&,CUIListBoxItem*);
void RemoveItem(CUIListBox&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
void ShowSelectedItem(CUIListBox&,bool);
custom [float] GetWidth(CUIWindow const&);
CUIWindow* GetItem(CUIListBox&,unsigned int);
void SetWindowName(CUIWindow&,char const*);
unsigned int GetSelectedIndex(CUIListBox&);
void RemoveWindow(CUIScrollView&,CUIWindow*);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void AddWindow(CUIScrollView&,CUIWindow*,bool);
CUIListBoxItem* GetSelectedItem(CUIListBox&);
void Clear(CUIScrollView&);
void ScrollToEnd(CUIScrollView&);
CUIListBoxItem* AddTextItem(CUIListBox&,char const*);
unsigned int GetSize(CUIListBox&);
void SetWndSize(CUIWindow&,vector2);
void ScrollToBegin(CUIScrollView&);
int GetCurrentScrollPos(CUIScrollView&);
void DetachChild(CUIWindow&,CUIWindow*);
void RemoveAll(CUIListBox&);
void SetAutoDelete(CUIWindow&,bool);
char const* WindowName(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
CUIListBoxItem* GetItemByIndex(CUIListBox&,int);
void SetScrollPos(CUIScrollView&,int);
vector2 const* GetWndPos(CUIWindow*);
int GetMaxScrollPos(CUIScrollView&);
void SetPPMode(CUIWindow&);
void Enable(CUIWindow&,bool);
int GetMinScrollPos(CUIScrollView&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class cse_alife_item_custom_outfit : cse_alife_item
{
void on_unregister(cse_alife_item_custom_outfit&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_custom_outfit const&);
void switch_online(cse_alife_item_custom_outfit&);
cse_abstract* init(cse_alife_item_custom_outfit&);
bool interactive(cse_alife_item_custom_outfit const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_custom_outfit&);
void STATE_Read(cse_alife_item_custom_outfit&,net_packet&,unsigned short);
void on_register(cse_alife_item_custom_outfit&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_custom_outfit const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_custom_outfit const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_custom_outfit&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_custom_outfit&,net_packet&);
bool can_save(cse_alife_item_custom_outfit const&);
bool used_ai_locations(cse_alife_item_custom_outfit const&);
bool bfUseful(cse_alife_item_custom_outfit&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_custom_outfit&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class SServerFilters
{
bool full { get; set; }
bool with_pass { get; set; }
bool empty { get; set; }
bool without_pass { get; set; }
bool listen_servers { get; set; }
bool without_ff { get; set; }
void __init(luabind::argument const&);
}
[cpp]
class act
{
const attack = 2;
const eat = 1;
const panic = 3;
const rest = 0;
void __init(luabind::argument const&,custom [enum MonsterSpace::EScriptMonsterGlobalAction],game_object*);
}
[cpp]
class CGameTask
{
void add_complete_func(CGameTask&,char const*);
void set_id(CGameTask&,char const*);
void set_title(CGameTask&,char const*);
void set_map_location(CGameTask&,char const*);
void __init(luabind::argument const&);
void add_fail_info(CGameTask&,char const*);
void add_on_complete_func(CGameTask&,char const*);
void add_complete_info(CGameTask&,char const*);
void change_map_location(CGameTask&,char const*,unsigned short);
void remove_map_locations(CGameTask&,bool);
void add_on_fail_func(CGameTask&,char const*);
void set_type(CGameTask&,int);
void set_icon_name(CGameTask&,char const*);
void add_on_fail_info(CGameTask&,char const*);
void set_description(CGameTask&,char const*);
void add_fail_func(CGameTask&,char const*);
void add_on_complete_info(CGameTask&,char const*);
char const* get_icon_name(CGameTask&);
int get_priority(CGameTask&);
char const* get_id(CGameTask&);
char const* get_title(CGameTask&);
void set_map_hint(CGameTask&,char const*);
void set_priority(CGameTask&,int);
void set_map_object_id(CGameTask&,int);
}
[cpp]
class CAI_Boar : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class entity_action
{
bool object(entity_action const&);
bool anim(entity_action const&);
void __init(luabind::argument const&,entity_action const*);
void set_action(entity_action&,act&);
bool look(entity_action const&);
bool all(entity_action&);
bool completed(entity_action&);
bool sound(entity_action const&);
bool time(entity_action&);
bool move(entity_action const&);
bool particle(entity_action const&);
}
[cpp]
class CUIMMShniaga : CUIWindow
{
const epi_main = 0;
const epi_new_game = 1;
const epi_new_network_game = 2;
void AttachChild(CUIWindow&,CUIWindow*);
void SetPage(CUIMMShniaga&,custom [enum CUIMMShniaga::enum_page_id],char const*,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
void ShowPage(CUIMMShniaga&,custom [enum CUIMMShniaga::enum_page_id]);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
vector2 const* GetWndPos(CUIWindow*);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void SetVisibleMagnifier(CUIMMShniaga&,bool);
void SetWndRect(CUIWindow&,Frect);
void SetPPMode(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CSimpleDetector : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CWeaponPM : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_team_base_zone : cse_alife_space_restrictor
{
void on_unregister(cse_alife_team_base_zone&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_team_base_zone const&);
void switch_online(cse_alife_team_base_zone&);
cse_abstract* init(cse_alife_team_base_zone&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_team_base_zone&);
void STATE_Read(cse_alife_team_base_zone&,net_packet&,unsigned short);
void on_register(cse_alife_team_base_zone&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_team_base_zone const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_team_base_zone const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_team_base_zone&);
bool can_save(cse_alife_team_base_zone const&);
bool used_ai_locations(cse_alife_team_base_zone const&);
void STATE_Write(cse_alife_team_base_zone&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_team_base_zone&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_team_base_zone const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class CPhraseDialog
{
CPhrase* AddPhrase(CPhraseDialog&,char const*,char const*,char const*,int);
}
[cpp]
class CGameObject : , DLL_Pure, ISheduled, ICollidableIRenderable
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int net_Spawn(CGameObject&,cse_abstract*);
int getVisible(CGameObject const&);
}
[cpp]
class FS_file_list_ex
{
void Sort(FS_file_list_ex&,unsigned int);
unsigned int Size(FS_file_list_ex&);
FS_item GetAt(FS_file_list_ex&,unsigned int);
}
[cpp]
class CHelicopter : CGameObject
{
const eAlive = 0;
const eBodyByPath = 0;
const eBodyToPoint = 1;
const eDead = 1;
const eEnemyEntity = 2;
const eEnemyNone = 0;
const eEnemyPoint = 1;
const eMovLanding = 4;
const eMovNone = 0;
const eMovPatrolPath = 2;
const eMovRoundPath = 3;
const eMovTakeOff = 5;
const eMovToPoint = 1;
void SetEnemy(CHelicopter&,vector*);
void SetLinearAcc(CHelicopter&,custom [float],custom [float]);
void UseFireTrail(CHelicopter&,bool);
bool m_light_started { get; set; }
void __init(luabind::argument const&);
void ClearEnemy(CHelicopter&);
custom [float] GetfHealth(CHelicopter const&);
custom [float] GetDistanceToDestPosition(CHelicopter&);
vector GetCurrVelocityVec(CHelicopter&);
void net_Import(CGameObject&,net_packet&);
bool m_use_mgun_on_attack { get; set; }
int GetState(CHelicopter&);
custom [float] SetfHealth(CHelicopter&,custom [float]);
bool use(CGameObject&,CGameObject*);
void SetBarrelDirTolerance(CHelicopter&,custom [float]);
void GoPatrolByRoundPath(CHelicopter&,vector,custom [float],bool);
bool m_use_rocket_on_attack { get; set; }
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int GetBodyState(CHelicopter&);
custom [float] m_min_rocket_dist { get; set; }
void LookAtPoint(CHelicopter&,vector,bool);
int net_Spawn(CGameObject&,cse_abstract*);
void SetOnPointRangeDist(CHelicopter&,custom [float]);
void StartFlame(CHelicopter&);
int getVisible(CGameObject const&);
custom [float] GetSpeedInDestPoint(CHelicopter&,custom [float]);
custom [float] GetOnPointRangeDist(CHelicopter&);
bool m_exploded { get; set; }
custom [float] m_min_mgun_dist { get; set; }
bool isVisible(CHelicopter&,game_object*);
void GoPatrolByPatrolPath(CHelicopter&,char const*,int);
void TurnEngineSound(CHelicopter&,bool);
custom [float] GetSafeAltitude(CHelicopter&);
int GetHuntState(CHelicopter&);
bool m_flame_started { get; set; }
bool m_syncronize_rocket { get; set; }
unsigned int m_time_between_rocket_attack { get; set; }
custom [float] m_max_mgun_dist { get; set; }
custom [float] m_max_rocket_dist { get; set; }
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void SetFireTrailLength(CHelicopter&,custom [float]);
void TurnLighting(CHelicopter&,bool);
custom [float] GetRealAltitude(CHelicopter&);
custom [float] GetCurrVelocity(CHelicopter&);
bool m_dead { get; set; }
int GetMovementState(CHelicopter&);
void Explode(CHelicopter&);
custom [float] GetMaxVelocity(CHelicopter&);
void SetMaxVelocity(CHelicopter&,custom [float]);
void SetDestPosition(CHelicopter&,vector*);
void Die(CHelicopter&);
void SetSpeedInDestPoint(CHelicopter&,custom [float]);
}
[cpp]
class CUICheckButton : CUI3tButton
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
void SetCheck(CUICheckButton&,bool);
void SetWindowName(CUIWindow&,char const*);
Frect const* GetTextureRect(CUIStatic&);
bool GetCheck(CUICheckButton const&);
void SetStretchTexture(CUIStatic&,bool);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetTextureRect(CUIStatic&,Frect*);
void Enable(CUIWindow&,bool);
bool IsEnabled(CUIWindow&);
void SetPPMode(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void SetWndRect(CUIWindow&,Frect);
custom [float] GetHeight(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetDependControl(CUICheckButton&,CUIWindow*);
}
[cpp]
class stalker_ids
{
const action_accomplish_task = 7;
const action_aim_enemy = 16;
const action_alife_planner = 88;
const action_anomaly_planner = 90;
const action_combat_planner = 89;
const action_communicate_with_customer = 9;
const action_critically_wounded = 36;
const action_danger_by_sound_planner = 73;
const action_danger_grenade_look_around = 85;
const action_danger_grenade_planner = 72;
const action_danger_grenade_search = 86;
const action_danger_grenade_take_cover = 82;
const action_danger_grenade_take_cover_after_explosion = 84;
const action_danger_grenade_wait_for_explosion = 83;
const action_danger_in_direction_detour = 80;
const action_danger_in_direction_hold_position = 79;
const action_danger_in_direction_look_out = 78;
const action_danger_in_direction_planner = 71;
const action_danger_in_direction_search = 81;
const action_danger_in_direction_take_cover = 77;
const action_danger_planner = 91;
const action_danger_unknown_look_around = 75;
const action_danger_unknown_planner = 70;
const action_danger_unknown_search = 76;
const action_danger_unknown_take_cover = 74;
const action_dead = 0;
const action_death_planner = 87;
const action_detour_enemy = 25;
const action_dying = 1;
const action_find_ammo = 15;
const action_find_item_to_kill = 13;
const action_gather_items = 2;
const action_get_distance = 24;
const action_get_item_to_kill = 12;
const action_get_ready_to_kill = 17;
const action_hold_position = 23;
const action_kill_enemy = 19;
const action_kill_enemy_if_not_visible = 29;
const action_kill_if_enemy_critically_wounded = 37;
const action_kill_if_player_on_the_path = 35;
const action_kill_wounded_enemy = 33;
const action_look_out = 22;
const action_make_item_killing = 14;
const action_no_alife = 3;
const action_post_combat_wait = 34;
const action_prepare_wounded_enemy = 32;
const action_reach_customer_location = 8;
const action_reach_task_location = 6;
const action_reach_wounded_enemy = 30;
const action_retreat_from_enemy = 20;
const action_script = 92;
const action_search_enemy = 26;
const action_smart_terrain_task = 4;
const action_solve_zone_puzzle = 5;
const action_sudden_attack = 28;
const action_take_cover = 21;
const detect_anomaly = 11;
const get_out_of_anomaly = 10;
const property_alife = 3;
const property_alive = 0;
const property_already_dead = 2;
const property_anomaly = 46;
const property_cover_actual = 42;
const property_cover_reached = 43;
const property_critically_wounded = 29;
const property_danger = 8;
const property_danger_by_sound = 41;
const property_danger_grenade = 40;
const property_danger_in_direction = 39;
const property_danger_unknown = 38;
const property_dead = 1;
const property_enemy = 7;
const property_enemy_critically_wounded = 30;
const property_enemy_detoured = 21;
const property_found_ammo = 12;
const property_found_item_to_kill = 10;
const property_grenade_exploded = 45;
const property_in_cover = 18;
const property_inside_anomaly = 47;
const property_item_can_kill = 11;
const property_item_to_kill = 9;
const property_items = 6;
const property_looked_around = 44;
const property_looked_out = 19;
const property_panic = 17;
const property_position_holded = 20;
const property_pure_enemy = 23;
const property_puzzle_solved = 4;
const property_ready_to_detour = 14;
const property_ready_to_kill = 13;
const property_script = 74;
const property_see_enemy = 15;
const property_smart_terrain_task = 5;
const property_use_crouch_to_look_out = 24;
const property_use_suddenness = 22;
const sound_alarm = 4;
const sound_attack_allies_several_enemies = 7;
const sound_attack_allies_single_enemy = 6;
const sound_attack_no_allies = 5;
const sound_backup = 8;
const sound_detour = 9;
const sound_die = 0;
const sound_die_in_anomaly = 1;
const sound_enemy_critically_wounded = 24;
const sound_enemy_killed_or_wounded = -805289984;
const sound_enemy_lost_no_allies = 12;
const sound_enemy_lost_with_allies = 13;
const sound_friendly_grenade_alarm = 20;
const sound_grenade_alarm = 19;
const sound_humming = 3;
const sound_injuring = 2;
const sound_injuring_by_friend = 14;
const sound_kill_wounded = 23;
const sound_need_backup = 21;
const sound_panic_human = 15;
const sound_panic_monster = 16;
const sound_running_in_danger = 22;
const sound_script = 27;
const sound_search1_no_allies = 11;
const sound_search1_with_allies = 10;
const sound_tolls = 17;
const sound_wounded = 18;
}
[cpp]
class cse_alife_trader : , cse_alife_dynamic_object_visualcse_alife_trader_abstract
{
void on_unregister(cse_alife_trader&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_trader const&);
void switch_online(cse_alife_trader&);
cse_abstract* init(cse_alife_trader&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_trader&);
void STATE_Read(cse_alife_trader&,net_packet&,unsigned short);
void on_register(cse_alife_trader&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
int reputation(cse_alife_trader_abstract&);
bool keep_saved_data_anyway(cse_alife_trader const&);
unsigned short script_version { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_trader const&);
char const* community(cse_alife_trader_abstract const&);
vector& angle { get; set; }
int rank(cse_alife_trader_abstract&);
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_trader&);
bool can_save(cse_alife_trader const&);
bool used_ai_locations(cse_alife_trader const&);
void STATE_Write(cse_alife_trader&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_trader&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_trader const&);
char const* name(cse_abstract const*);
char const* profile_name(cse_alife_trader_abstract*);
}
[cpp]
class sound
{
const attack = 3;
const attack_hit = 4;
const die = 7;
const eat = 2;
const idle = 1;
const panic = 11;
const steal = 10;
const take_damage = 5;
const threaten = 9;
void set_sound(sound&,sound_object const&);
void set_sound_type(sound&,custom [enum ESoundTypes]);
bool completed(sound&);
void set_position(sound&,vector const&);
void set_bone(sound&,char const*);
void set_angles(sound&,vector const&);
void __init(luabind::argument const&,char const*,char const*,custom [enum MonsterSpace::EMonsterHeadAnimType]);
}
[cpp]
class cse_abstract : cpure_server_object
{
vector& angle { get; set; }
vector& position { get; set; }
unsigned short id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short parent_id { get; set; }
ini_file* spawn_ini(cse_abstract*);
void STATE_Read(cse_abstract&,net_packet&,unsigned short);
int clsid(cse_abstract const&);
void STATE_Write(cse_abstract&,net_packet&);
char const* name(cse_abstract const*);
char const* section_name(cse_abstract const*);
}
[cpp]
class look
{
const cur_dir = 0;
const danger = 5;
const direction = 2;
const fire_point = 10;
const path_dir = 1;
const point = 3;
const search = 6;
void object(look&,game_object*);
bool completed(look&);
void type(look&,custom [enum SightManager::ESightType]);
void bone(look&,char const*);
void direct(look&,vector const&);
void __init(luabind::argument const&,game_object*,custom [float],custom [float]);
}
[cpp]
class vector
{
vector& slide(vector&,vector const&,vector const&);
vector& invert(vector&,vector const&);
custom [float] getH(vector const&);
vector& lerp(vector&,vector const&,vector const&,custom [float]);
void __init(luabind::argument const&);
vector& reflect(vector&,vector const&,vector const&);
custom [float] distance_to_sqr(vector const&,vector const&);
custom [float] distance_to_xz(vector const&,vector const&);
vector& set(vector&,vector const&);
vector& min(vector&,vector const&,vector const&);
vector& mad(vector&,vector const&,vector const&,vector const&);
vector& mul(vector&,vector const&,custom [float]);
custom [float] dotproduct(vector const&,vector const&);
vector& average(vector&,vector const&,vector const&);
vector& normalize(vector&,vector const&);
custom [float] x { get; set; }
custom [float] y { get; set; }
custom [float] magnitude(vector const&);
vector& clamp(vector&,vector const&,vector const&);
vector& sub(vector&,vector const&,custom [float]);
vector& add(vector&,vector const&,custom [float]);
custom [float] z { get; set; }
custom [float] getP(vector const&);
vector& setHP(vector&,custom [float],custom [float]);
vector& normalize_safe(vector&,vector const&);
custom [float] distance_to(vector const&,vector const&);
vector& abs(vector&,vector const&);
int similar(vector const&,vector const&,custom [float]);
vector& set_length(vector&,custom [float]);
vector& div(vector&,vector const&,custom [float]);
vector& inertion(vector&,vector const&,custom [float]);
vector& align(vector&);
vector& max(vector&,vector const&,vector const&);
vector& crossproduct(vector&,vector const&,vector const&);
}
[cpp]
class GameGraph__CVertex
{
unsigned char level_id(GameGraph__CVertex const&);
unsigned int level_vertex_id(GameGraph__CVertex const&);
vector level_point(GameGraph__CVertex const*);
vector game_point(GameGraph__CVertex const*);
}
[cpp]
class cse_alife_item_torch : cse_alife_item
{
void on_unregister(cse_alife_item_torch&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_torch const&);
void switch_online(cse_alife_item_torch&);
cse_abstract* init(cse_alife_item_torch&);
bool interactive(cse_alife_item_torch const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_torch&);
void STATE_Read(cse_alife_item_torch&,net_packet&,unsigned short);
void on_register(cse_alife_item_torch&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_torch const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_torch const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_torch&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_torch&,net_packet&);
bool can_save(cse_alife_item_torch const&);
bool used_ai_locations(cse_alife_item_torch const&);
bool bfUseful(cse_alife_item_torch&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_torch&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class game_difficulty
{
const master = 3;
const novice = 0;
const stalker = 1;
const veteran = 2;
}
[cpp]
class CFracture : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class rotation
{
custom [float] yaw { get; set; }
custom [float] pitch { get; set; }
}
[cpp]
class CAI_Flesh : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class visible_memory_object : game_memory_object
{
game_object* object(game_memory_object const&);
custom [struct MemorySpace::CObjectParams<class CGameObject>]& self_info { get; set; }
unsigned int level_time { get; set; }
unsigned int last_level_time { get; set; }
custom [struct MemorySpace::CObjectParams<class CGameObject>]& object_info { get; set; }
}
[cpp]
class CController : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CALifeMonsterBrain
{
CALifeMonsterMovementManager* movement(CALifeMonsterBrain const*);
void update(CALifeMonsterBrain&);
void can_choose_alife_tasks(CALifeMonsterBrain&,bool);
}
[cpp]
class smart_cover_object : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_item_weapon_magazined : cse_alife_item_weapon
{
void on_unregister(cse_alife_item_weapon_magazined&);
void use_ai_locations(cse_alife_object&,bool);
void UPDATE_Write(cse_abstract&,net_packet&);
bool can_switch_offline(cse_alife_item_weapon_magazined const&);
void switch_online(cse_alife_item_weapon_magazined&);
cse_abstract* init(cse_alife_item_weapon_magazined&);
bool interactive(cse_alife_item_weapon_magazined const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_weapon_magazined&);
void STATE_Read(cse_alife_item_weapon_magazined&,net_packet&,unsigned short);
void on_register(cse_alife_item_weapon_magazined&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
void clone_addons(cse_alife_item_weapon&,cse_alife_item_weapon*);
bool keep_saved_data_anyway(cse_alife_item_weapon_magazined const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_weapon_magazined const&);
vector& angle { get; set; }
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
void on_spawn(cse_alife_item_weapon_magazined&);
unsigned int m_level_vertex_id { get; set; }
bool used_ai_locations(cse_alife_item_weapon_magazined const&);
bool can_save(cse_alife_item_weapon_magazined const&);
bool bfUseful(cse_alife_item_weapon_magazined&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_weapon_magazined&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void STATE_Write(cse_alife_item_weapon_magazined&,net_packet&);
char const* name(cse_abstract const*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class CCat : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CPda : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CTorridZone : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CAI_Bloodsucker : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void force_visibility_state(CAI_Bloodsucker&,int);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CActor : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CLevelChanger : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class action_base
{
game_object* object { get; set; }
void execute(action_base&);
void finalize(action_base&);
void set_weight(action_base&,unsigned short const&);
void remove_effect(action_base&,unsigned int const&);
void setup(action_base&,game_object*,property_storage*);
void add_effect(action_base&,world_property const&);
void show(action_base&,char const*);
property_storage* storage { get; set; }
void initialize(action_base&);
void add_precondition(action_base&,world_property const&);
void remove_precondition(action_base&,unsigned int const&);
void __init(luabind::argument const&,game_object*,char const*);
}
[cpp]
class CALifeSmartTerrainTask
{
unsigned short game_vertex_id(CALifeSmartTerrainTask const&);
unsigned int level_vertex_id(CALifeSmartTerrainTask const&);
vector position(CALifeSmartTerrainTask const&);
void __init(luabind::argument const&,unsigned short,unsigned int);
}
[cpp]
class account_operation_cb
{
void bind(account_operation_cb&,luabind::object,function<void>);
void clear(account_operation_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class cse_visual
{
}
[cpp]
class explosive
{
void explode(explosive&);
}
[cpp]
class ipure_server_object : iserializable
{
}
[cpp]
class CZoneCampfire : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void turn_on(CZoneCampfire&);
void turn_off(CZoneCampfire&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
bool is_on(CZoneCampfire&);
}
[cpp]
class CPsyDog : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUIProgressBar : CUIWindow
{
void SetProgressPos(CUIProgressBar&,custom [float]);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
custom [float] GetRange_min(CUIProgressBar&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
custom [float] GetProgressPos(CUIProgressBar&);
void Enable(CUIWindow&,bool);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void AttachChild(CUIWindow&,CUIWindow*);
custom [float] GetRange_max(CUIProgressBar&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class world_property
{
unsigned int const& condition(world_property const&);
bool const& value(world_property const&);
void __eq(lua_State*,world_property const&,world_property);
void __init(luabind::argument const&,unsigned int,bool);
void __lt(lua_State*,world_property const&,world_property);
}
[cpp]
class CBottleItem : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CSE_AbstractVisual : , cse_visualcse_abstract
{
char const* section_name(cse_abstract const*);
vector& angle { get; set; }
vector& position { get; set; }
unsigned short id { get; set; }
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Read(CSE_AbstractVisual&,net_packet&,unsigned short);
void __init(luabind::argument const&,char const*);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short parent_id { get; set; }
char const* getStartupAnimation(CSE_AbstractVisual&);
unsigned short script_version { get; set; }
int clsid(cse_abstract const&);
cse_abstract* init(CSE_AbstractVisual&);
ini_file* spawn_ini(cse_abstract*);
void STATE_Write(CSE_AbstractVisual&,net_packet&);
}
[cpp]
class cse_temporary : cse_abstract
{
vector& angle { get; set; }
vector& position { get; set; }
unsigned short id { get; set; }
char const* section_name(cse_abstract const*);
char const* name(cse_abstract const*);
void STATE_Read(cse_temporary&,net_packet&,unsigned short);
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_temporary&,net_packet&);
unsigned short parent_id { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short script_version { get; set; }
int clsid(cse_abstract const&);
cse_abstract* init(cse_temporary&);
ini_file* spawn_ini(cse_abstract*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class cse_spectator : cse_abstract
{
vector& angle { get; set; }
vector& position { get; set; }
unsigned short id { get; set; }
char const* section_name(cse_abstract const*);
char const* name(cse_abstract const*);
void STATE_Read(cse_spectator&,net_packet&,unsigned short);
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_spectator&,net_packet&);
unsigned short parent_id { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short script_version { get; set; }
int clsid(cse_abstract const&);
cse_abstract* init(cse_spectator&);
ini_file* spawn_ini(cse_abstract*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class property_evaluator
{
game_object* object { get; set; }
bool evaluate(property_evaluator&);
property_storage* storage { get; set; }
void __init(luabind::argument const&,game_object*,char const*);
void setup(property_evaluator&,game_object*,property_storage*);
}
[cpp]
class cse_shape
{
}
[cpp]
class FS_item
{
char const* NameShort(FS_item&);
char const* ModifDigitOnly(FS_item&);
unsigned int Size(FS_item&);
char const* Modif(FS_item&);
char const* NameFull(FS_item&);
}
[cpp]
class ipure_schedulable_object
{
}
[cpp]
class CConsole
{
void show(CConsole&);
void execute(CConsole&,char const*);
bool get_bool(CConsole*,char const*);
char const* get_string(CConsole const&,char const*);
void execute_deferred(CConsole*,char const*);
void execute_script(CConsole&,char const*);
int get_integer(CConsole*,char const*);
void hide(CConsole&);
custom [float] get_float(CConsole*,char const*);
char const* get_token(CConsole const&,char const*);
}
[cpp]
class MonsterHitInfo
{
vector& direction { get; set; }
game_object* who { get; set; }
int time { get; set; }
}
[cpp]
class render_device
{
vector& cam_dir { get; set; }
unsigned int width { get; set; }
void pause(render_device*,bool);
vector& cam_pos { get; set; }
bool is_paused(render_device*);
vector& cam_right { get; set; }
unsigned int time_delta { get; set; }
custom [float] fov { get; set; }
vector& cam_top { get; set; }
unsigned int precache_frame { get; set; }
unsigned int frame { get; set; }
custom [float] aspect_ratio { get; set; }
unsigned int time_global(render_device const*);
unsigned int height { get; set; }
custom [float] f_time_delta { get; set; }
}
[cpp]
class cse_alife_monster_base : , cse_alife_monster_abstractcse_ph_skeleton
{
void on_unregister(cse_alife_monster_base&);
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_monster_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_monster_base const&);
void switch_online(cse_alife_monster_base&);
unsigned char group { get; set; }
bool used_ai_locations(cse_alife_monster_base const&);
void update(cse_alife_monster_base&);
bool interactive(cse_alife_monster_base const&);
cse_abstract* init(cse_alife_monster_base&);
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
void on_death(cse_alife_monster_base&,cse_abstract*);
void switch_offline(cse_alife_monster_base&);
void STATE_Read(cse_alife_monster_base&,net_packet&,unsigned short);
void smart_terrain_task_activate(cse_alife_monster_abstract*);
unsigned char g_group(cse_alife_monster_base&);
void on_register(cse_alife_monster_base&);
void STATE_Write(cse_alife_monster_base&,net_packet&);
bool can_save(cse_alife_monster_base const&);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_monster_base&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
unsigned short m_game_vertex_id { get; set; }
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
void UPDATE_Write(cse_abstract&,net_packet&);
bool keep_saved_data_anyway(cse_alife_monster_base const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
void use_ai_locations(cse_alife_object&,bool);
bool alive(cse_alife_creature_abstract const&);
vector& position { get; set; }
void move_offline(cse_alife_object&,bool);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_monster_base&);
bool can_switch_online(cse_alife_monster_base const&);
char const* section_name(cse_abstract const*);
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_monster_base&);
CALifeMonsterBrain* brain(cse_alife_monster_abstract*);
bool has_detector(cse_alife_monster_abstract&);
ini_file* spawn_ini(cse_abstract*);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_monster_base&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
unsigned char team { get; set; }
}
[cpp]
class CWeaponUSP45 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_object_breakable : cse_alife_dynamic_object_visual
{
void on_unregister(cse_alife_object_breakable&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_object_breakable const&);
void switch_online(cse_alife_object_breakable&);
cse_abstract* init(cse_alife_object_breakable&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_object_breakable&);
void STATE_Read(cse_alife_object_breakable&,net_packet&,unsigned short);
void on_register(cse_alife_object_breakable&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_object_breakable const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_object_breakable const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_object_breakable&);
bool can_save(cse_alife_object_breakable const&);
bool used_ai_locations(cse_alife_object_breakable const&);
void STATE_Write(cse_alife_object_breakable&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_object_breakable&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_object_breakable const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class cse_alife_item_explosive : cse_alife_item
{
void on_unregister(cse_alife_item_explosive&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_explosive const&);
void switch_online(cse_alife_item_explosive&);
cse_abstract* init(cse_alife_item_explosive&);
bool interactive(cse_alife_item_explosive const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_explosive&);
void STATE_Read(cse_alife_item_explosive&,net_packet&,unsigned short);
void on_register(cse_alife_item_explosive&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_explosive const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_explosive const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_explosive&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_explosive&,net_packet&);
bool can_save(cse_alife_item_explosive const&);
bool used_ai_locations(cse_alife_item_explosive const&);
bool bfUseful(cse_alife_item_explosive&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_explosive&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class cse_alife_object_projector : cse_alife_dynamic_object_visual
{
void on_unregister(cse_alife_object_projector&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_object_projector const&);
void switch_online(cse_alife_object_projector&);
cse_abstract* init(cse_alife_object_projector&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_object_projector&);
void STATE_Read(cse_alife_object_projector&,net_packet&,unsigned short);
void on_register(cse_alife_object_projector&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_object_projector const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_object_projector const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_object_projector&);
bool can_save(cse_alife_object_projector const&);
bool used_ai_locations(cse_alife_object_projector const&);
void STATE_Write(cse_alife_object_projector&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_object_projector&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_object_projector const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class StaticDrawableWrapper
{
CUIStatic* wnd(StaticDrawableWrapper&);
custom [float] m_endTime { get; set; }
}
[cpp]
class task
{
const additional = 1;
const completed = 2;
const fail = 0;
const in_progress = 1;
const storyline = 0;
const task_dummy = 65535;
}
[cpp]
class cse_alife_inventory_box : cse_alife_dynamic_object_visual
{
void on_unregister(cse_alife_inventory_box&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_inventory_box const&);
void switch_online(cse_alife_inventory_box&);
cse_abstract* init(cse_alife_inventory_box&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_inventory_box&);
void STATE_Read(cse_alife_inventory_box&,net_packet&,unsigned short);
void on_register(cse_alife_inventory_box&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_inventory_box const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_inventory_box const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_inventory_box&);
bool can_save(cse_alife_inventory_box const&);
bool used_ai_locations(cse_alife_inventory_box const&);
void STATE_Write(cse_alife_inventory_box&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_inventory_box&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_inventory_box const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class callback
{
const action_animation = 21;
const action_movement = 18;
const action_object = 24;
const action_particle = 23;
const action_removed = 20;
const action_sound = 22;
const action_watch = 19;
const actor_sleep = 25;
const article_info = 12;
const death = 8;
const helicopter_on_hit = 27;
const helicopter_on_point = 26;
const hit = 16;
const inventory_info = 11;
const inventory_pda = 10;
const level_border_enter = 7;
const level_border_exit = 6;
const map_location_added = 14;
const on_item_drop = 29;
const on_item_take = 28;
const patrol_path_in_point = 9;
const script_animation = 30;
const sound = 17;
const take_item_from_box = 34;
const task_state = 13;
const trade_perform_operation = 3;
const trade_sell_buy_item = 2;
const trade_start = 0;
const trade_stop = 1;
const trader_global_anim_request = 31;
const trader_head_anim_request = 32;
const trader_sound_end = 33;
const use_object = 15;
const weapon_no_ammo = 35;
const zone_enter = 4;
const zone_exit = 5;
}
[cpp]
class cse_alife_ph_skeleton_object : , cse_alife_dynamic_object_visualcse_ph_skeleton
{
void on_unregister(cse_alife_ph_skeleton_object&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_ph_skeleton_object const&);
void switch_online(cse_alife_ph_skeleton_object&);
cse_abstract* init(cse_alife_ph_skeleton_object&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_ph_skeleton_object&);
void STATE_Read(cse_alife_ph_skeleton_object&,net_packet&,unsigned short);
void on_register(cse_alife_ph_skeleton_object&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_ph_skeleton_object const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_ph_skeleton_object const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_ph_skeleton_object&);
bool can_save(cse_alife_ph_skeleton_object const&);
bool used_ai_locations(cse_alife_ph_skeleton_object const&);
void STATE_Write(cse_alife_ph_skeleton_object&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_ph_skeleton_object&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_ph_skeleton_object const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class cse_alife_graph_point : cse_abstract
{
vector& angle { get; set; }
vector& position { get; set; }
unsigned short id { get; set; }
char const* section_name(cse_abstract const*);
char const* name(cse_abstract const*);
void STATE_Read(cse_alife_graph_point&,net_packet&,unsigned short);
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_graph_point&,net_packet&);
unsigned short parent_id { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short script_version { get; set; }
int clsid(cse_abstract const&);
cse_abstract* init(cse_alife_graph_point&);
ini_file* spawn_ini(cse_abstract*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class cse_alife_creature_abstract : cse_alife_dynamic_object_visual
{
void on_unregister(cse_alife_creature_abstract&);
custom [float] health(cse_alife_creature_abstract const&);
void use_ai_locations(cse_alife_object&,bool);
unsigned char g_group(cse_alife_creature_abstract&);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_creature_abstract const&);
void switch_online(cse_alife_creature_abstract&);
unsigned char team { get; set; }
bool used_ai_locations(cse_alife_creature_abstract const&);
bool interactive(cse_alife_creature_abstract const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_creature_abstract&);
void on_death(cse_alife_creature_abstract&,cse_abstract*);
bool alive(cse_alife_creature_abstract const&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned char squad { get; set; }
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
bool keep_saved_data_anyway(cse_alife_creature_abstract const&);
unsigned short script_version { get; set; }
char const* section_name(cse_abstract const*);
cse_abstract* init(cse_alife_creature_abstract&);
void STATE_Read(cse_alife_creature_abstract&,net_packet&,unsigned short);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_creature_abstract&);
bool can_switch_online(cse_alife_creature_abstract const&);
void on_register(cse_alife_creature_abstract&);
vector& angle { get; set; }
unsigned char g_squad(cse_alife_creature_abstract&);
void on_spawn(cse_alife_creature_abstract&);
void UPDATE_Write(cse_abstract&,net_packet&);
unsigned short m_game_vertex_id { get; set; }
ini_file* spawn_ini(cse_abstract*);
bool can_save(cse_alife_creature_abstract const&);
void STATE_Write(cse_alife_creature_abstract&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_creature_abstract&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned char group { get; set; }
char const* name(cse_abstract const*);
unsigned int m_level_vertex_id { get; set; }
}
[cpp]
class CUICustomEdit : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void SetNextFocusCapturer(CUICustomEdit&,CUICustomEdit*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetText(CUICustomEdit&,char const*);
void Enable(CUIWindow&,bool);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void CaptureFocus(CUICustomEdit&,bool);
char const* GetText(CUICustomEdit const&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class MEMBERS__value_type
{
cse_alife_monster_abstract* object { get; set; }
unsigned short id { get; set; }
}
[cpp]
class CPsyDogPhantom : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_online_offline_group : , cse_alife_dynamic_objectcse_alife_schedulable
{
void on_unregister(cse_alife_online_offline_group&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_online_offline_group const&);
unsigned int npc_count(cse_alife_online_offline_group const&);
void switch_online(cse_alife_online_offline_group&);
CALifeSmartTerrainTask* get_current_task(cse_alife_online_offline_group&);
cse_abstract* init(cse_alife_online_offline_group&);
void update(cse_alife_online_offline_group&);
bool interactive(cse_alife_online_offline_group const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_online_offline_group&);
void STATE_Read(cse_alife_online_offline_group&,net_packet&,unsigned short);
void unregister_member(cse_alife_online_offline_group&,unsigned short);
unsigned short commander_id(cse_alife_online_offline_group&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
void add_location_type(cse_alife_online_offline_group&,char const*);
custom [class AssociativeVector<unsigned short,class CSE_ALifeMonsterAbstract *,struct std::less<unsigned short> >] const& squad_members(cse_alife_online_offline_group const&);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_online_offline_group const&);
unsigned short script_version { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void on_register(cse_alife_online_offline_group&);
void force_change_position(cse_alife_online_offline_group&,vector);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_online_offline_group const&);
ini_file* spawn_ini(cse_abstract*);
vector& angle { get; set; }
void STATE_Write(cse_alife_online_offline_group&,net_packet&);
void on_spawn(cse_alife_online_offline_group&);
bool used_ai_locations(cse_alife_online_offline_group const&);
bool can_save(cse_alife_online_offline_group const&);
unsigned int m_level_vertex_id { get; set; }
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_online_offline_group&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void register_member(cse_alife_online_offline_group&,unsigned short);
char const* name(cse_abstract const*);
void clear_location_types(cse_alife_online_offline_group&);
}
[cpp]
class cse_custom_zone : , cse_alife_dynamic_objectcse_shape
{
void on_unregister(cse_custom_zone&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_custom_zone const&);
void switch_online(cse_custom_zone&);
cse_abstract* init(cse_custom_zone&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_custom_zone&);
void STATE_Read(cse_custom_zone&,net_packet&,unsigned short);
void on_register(cse_custom_zone&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_custom_zone const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_custom_zone const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void on_spawn(cse_custom_zone&);
bool can_save(cse_custom_zone const&);
bool used_ai_locations(cse_custom_zone const&);
void STATE_Write(cse_custom_zone&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_custom_zone&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_custom_zone const&);
char const* name(cse_abstract const*);
char const* section_name(cse_abstract const*);
}
[cpp]
class CWeaponShotgun : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CBastArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class ISheduled
{
}
[cpp]
class cse_torrid_zone : , cse_custom_zonecse_motion
{
void on_unregister(cse_torrid_zone&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_torrid_zone const&);
void switch_online(cse_torrid_zone&);
cse_abstract* init(cse_torrid_zone&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_torrid_zone&);
void STATE_Read(cse_torrid_zone&,net_packet&,unsigned short);
void on_register(cse_torrid_zone&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_torrid_zone const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_torrid_zone const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_torrid_zone&);
bool can_save(cse_torrid_zone const&);
bool used_ai_locations(cse_torrid_zone const&);
void STATE_Write(cse_torrid_zone&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_torrid_zone&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_torrid_zone const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class cse_alife_creature_actor : , cse_alife_creature_abstract, cse_alife_trader_abstractcse_ph_skeleton
{
void on_unregister(cse_alife_creature_actor&);
custom [float] health(cse_alife_creature_abstract const&);
void use_ai_locations(cse_alife_object&,bool);
unsigned char g_group(cse_alife_creature_actor&);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_creature_actor const&);
void switch_online(cse_alife_creature_actor&);
unsigned char team { get; set; }
bool used_ai_locations(cse_alife_creature_actor const&);
bool interactive(cse_alife_creature_actor const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_creature_actor&);
void on_death(cse_alife_creature_actor&,cse_abstract*);
bool alive(cse_alife_creature_abstract const&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned char squad { get; set; }
cse_abstract* init(cse_alife_creature_actor&);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
char const* community(cse_alife_trader_abstract const&);
bool keep_saved_data_anyway(cse_alife_creature_actor const&);
unsigned short script_version { get; set; }
int rank(cse_alife_trader_abstract&);
int reputation(cse_alife_trader_abstract&);
unsigned int m_level_vertex_id { get; set; }
void STATE_Read(cse_alife_creature_actor&,net_packet&,unsigned short);
unsigned char group { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_creature_actor&);
bool can_switch_online(cse_alife_creature_actor const&);
unsigned char g_squad(cse_alife_creature_actor&);
vector& angle { get; set; }
void STATE_Write(cse_alife_creature_actor&,net_packet&);
void on_spawn(cse_alife_creature_actor&);
bool can_save(cse_alife_creature_actor const&);
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_creature_actor&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void on_register(cse_alife_creature_actor&);
char const* name(cse_abstract const*);
char const* profile_name(cse_alife_trader_abstract*);
}
[cpp]
class cse_alife_human_stalker : , cse_alife_human_abstractcse_ph_skeleton
{
void on_unregister(cse_alife_human_stalker&);
unsigned char team { get; set; }
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_human_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_human_stalker const&);
cse_abstract* init(cse_alife_human_stalker&);
void switch_online(cse_alife_human_stalker&);
unsigned char group { get; set; }
void STATE_Read(cse_alife_human_stalker&,net_packet&,unsigned short);
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
void update(cse_alife_human_stalker&);
unsigned int m_level_vertex_id { get; set; }
unsigned char g_group(cse_alife_human_stalker&);
void on_register(cse_alife_human_stalker&);
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
bool interactive(cse_alife_human_stalker const&);
void switch_offline(cse_alife_human_stalker&);
void STATE_Write(cse_alife_human_stalker&,net_packet&);
void smart_terrain_task_activate(cse_alife_monster_abstract*);
char const* community(cse_alife_trader_abstract const&);
void set_rank(cse_alife_human_abstract&,int);
bool can_save(cse_alife_human_stalker const&);
ini_file* spawn_ini(cse_abstract*);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_human_stalker&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
vector& position { get; set; }
int reputation(cse_alife_trader_abstract&);
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
unsigned short m_game_vertex_id { get; set; }
bool keep_saved_data_anyway(cse_alife_human_stalker const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
char const* section_name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
void use_ai_locations(cse_alife_object&,bool);
bool alive(cse_alife_creature_abstract const&);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_human_stalker&);
bool can_switch_online(cse_alife_human_stalker const&);
void move_offline(cse_alife_object&,bool);
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_human_stalker&);
CALifeHumanBrain* brain(cse_alife_human_abstract*);
bool has_detector(cse_alife_monster_abstract&);
bool used_ai_locations(cse_alife_human_stalker const&);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_human_stalker&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void on_death(cse_alife_human_stalker&,cse_abstract*);
char const* name(cse_abstract const*);
char const* profile_name(cse_alife_trader_abstract*);
}
[cpp]
class CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void Enable(CUIWindow&,bool);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class cse_alife_monster_zombie : cse_alife_monster_abstract
{
void on_unregister(cse_alife_monster_zombie&);
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_monster_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_monster_zombie const&);
void switch_online(cse_alife_monster_zombie&);
unsigned char group { get; set; }
bool used_ai_locations(cse_alife_monster_zombie const&);
void update(cse_alife_monster_zombie&);
bool interactive(cse_alife_monster_zombie const&);
cse_abstract* init(cse_alife_monster_zombie&);
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
void on_death(cse_alife_monster_zombie&,cse_abstract*);
void switch_offline(cse_alife_monster_zombie&);
void STATE_Read(cse_alife_monster_zombie&,net_packet&,unsigned short);
void smart_terrain_task_activate(cse_alife_monster_abstract*);
unsigned char g_group(cse_alife_monster_zombie&);
void on_register(cse_alife_monster_zombie&);
void STATE_Write(cse_alife_monster_zombie&,net_packet&);
bool can_save(cse_alife_monster_zombie const&);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_monster_zombie&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
unsigned short m_game_vertex_id { get; set; }
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
void UPDATE_Write(cse_abstract&,net_packet&);
bool keep_saved_data_anyway(cse_alife_monster_zombie const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
void use_ai_locations(cse_alife_object&,bool);
bool alive(cse_alife_creature_abstract const&);
vector& position { get; set; }
void move_offline(cse_alife_object&,bool);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_monster_zombie&);
bool can_switch_online(cse_alife_monster_zombie const&);
char const* section_name(cse_abstract const*);
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_monster_zombie&);
CALifeMonsterBrain* brain(cse_alife_monster_abstract*);
bool has_detector(cse_alife_monster_abstract&);
ini_file* spawn_ini(cse_abstract*);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_monster_zombie&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
unsigned char team { get; set; }
}
[cpp]
class cse_alife_creature_crow : cse_alife_creature_abstract
{
void on_unregister(cse_alife_creature_crow&);
custom [float] health(cse_alife_creature_abstract const&);
void use_ai_locations(cse_alife_object&,bool);
unsigned char g_group(cse_alife_creature_crow&);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_creature_crow const&);
void switch_online(cse_alife_creature_crow&);
unsigned char team { get; set; }
bool used_ai_locations(cse_alife_creature_crow const&);
bool interactive(cse_alife_creature_crow const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_creature_crow&);
void on_death(cse_alife_creature_crow&,cse_abstract*);
bool alive(cse_alife_creature_abstract const&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned char squad { get; set; }
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
bool keep_saved_data_anyway(cse_alife_creature_crow const&);
unsigned short script_version { get; set; }
unsigned int m_level_vertex_id { get; set; }
void STATE_Read(cse_alife_creature_crow&,net_packet&,unsigned short);
unsigned char group { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_creature_crow&);
bool can_switch_online(cse_alife_creature_crow const&);
unsigned char g_squad(cse_alife_creature_crow&);
vector& angle { get; set; }
void STATE_Write(cse_alife_creature_crow&,net_packet&);
void on_spawn(cse_alife_creature_crow&);
bool can_save(cse_alife_creature_crow const&);
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_creature_crow&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void on_register(cse_alife_creature_crow&);
char const* name(cse_abstract const*);
cse_abstract* init(cse_alife_creature_crow&);
}
[cpp]
class suggest_nicks_cb
{
void bind(suggest_nicks_cb&,luabind::object,function<void>);
void clear(suggest_nicks_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class cse_alife_monster_rat : , cse_alife_monster_abstractcse_alife_inventory_item
{
void on_unregister(cse_alife_monster_rat&);
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_monster_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_monster_rat const&);
void switch_online(cse_alife_monster_rat&);
unsigned char group { get; set; }
bool used_ai_locations(cse_alife_monster_rat const&);
void update(cse_alife_monster_rat&);
bool interactive(cse_alife_monster_rat const&);
cse_abstract* init(cse_alife_monster_rat&);
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
void on_death(cse_alife_monster_rat&,cse_abstract*);
void switch_offline(cse_alife_monster_rat&);
void STATE_Read(cse_alife_monster_rat&,net_packet&,unsigned short);
void smart_terrain_task_activate(cse_alife_monster_abstract*);
unsigned char g_group(cse_alife_monster_rat&);
void on_register(cse_alife_monster_rat&);
void STATE_Write(cse_alife_monster_rat&,net_packet&);
bool can_save(cse_alife_monster_rat const&);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_monster_rat&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
unsigned short m_game_vertex_id { get; set; }
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
void UPDATE_Write(cse_abstract&,net_packet&);
bool keep_saved_data_anyway(cse_alife_monster_rat const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
void use_ai_locations(cse_alife_object&,bool);
bool alive(cse_alife_creature_abstract const&);
vector& position { get; set; }
void move_offline(cse_alife_object&,bool);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_monster_rat&);
bool can_switch_online(cse_alife_monster_rat const&);
char const* section_name(cse_abstract const*);
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_monster_rat&);
CALifeMonsterBrain* brain(cse_alife_monster_abstract*);
bool has_detector(cse_alife_monster_abstract&);
ini_file* spawn_ini(cse_abstract*);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_monster_rat&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
unsigned char team { get; set; }
}
[cpp]
class CAI_Stalker : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class physics_world
{
void set_gravity(physics_world&,custom [float]);
void add_call(physics_world&,custom [class CPHCondition]*,custom [class CPHAction]*);
custom [float] gravity(physics_world&);
}
[cpp]
class CTushkano : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_item : , cse_alife_dynamic_object_visualcse_alife_inventory_item
{
void on_unregister(cse_alife_item&);
void use_ai_locations(cse_alife_object&,bool);
void UPDATE_Write(cse_abstract&,net_packet&);
bool can_switch_offline(cse_alife_item const&);
void switch_online(cse_alife_item&);
cse_abstract* init(cse_alife_item&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item&);
void STATE_Read(cse_alife_item&,net_packet&,unsigned short);
void on_register(cse_alife_item&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_item const&);
vector& angle { get; set; }
char const* section_name(cse_abstract const*);
unsigned short m_game_vertex_id { get; set; }
void on_spawn(cse_alife_item&);
void STATE_Write(cse_alife_item&,net_packet&);
bool can_save(cse_alife_item const&);
bool used_ai_locations(cse_alife_item const&);
bool bfUseful(cse_alife_item&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_item const&);
char const* name(cse_abstract const*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class CUI3tButton : CUIButton
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
custom [float] GetHeight(CUIWindow const&);
void Enable(CUIWindow&,bool);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetTextureRect(CUIStatic&,Frect*);
void SetStretchTexture(CUIStatic&,bool);
Frect const* GetTextureRect(CUIStatic&);
}
[cpp]
class cse_alife_item_weapon : cse_alife_item
{
void on_unregister(cse_alife_item_weapon&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_weapon const&);
void switch_online(cse_alife_item_weapon&);
cse_abstract* init(cse_alife_item_weapon&);
bool interactive(cse_alife_item_weapon const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_weapon&);
void STATE_Read(cse_alife_item_weapon&,net_packet&,unsigned short);
void on_register(cse_alife_item_weapon&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
void clone_addons(cse_alife_item_weapon&,cse_alife_item_weapon*);
bool keep_saved_data_anyway(cse_alife_item_weapon const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_weapon const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_weapon&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_weapon&,net_packet&);
bool used_ai_locations(cse_alife_item_weapon const&);
bool can_save(cse_alife_item_weapon const&);
bool bfUseful(cse_alife_item_weapon&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_weapon&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class cse_alife_item_weapon_magazined_w_gl : cse_alife_item_weapon_magazined
{
void on_unregister(cse_alife_item_weapon_magazined_w_gl&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_weapon_magazined_w_gl const&);
void switch_online(cse_alife_item_weapon_magazined_w_gl&);
cse_abstract* init(cse_alife_item_weapon_magazined_w_gl&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_weapon_magazined_w_gl&);
void STATE_Read(cse_alife_item_weapon_magazined_w_gl&,net_packet&,unsigned short);
void on_register(cse_alife_item_weapon_magazined_w_gl&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
void clone_addons(cse_alife_item_weapon&,cse_alife_item_weapon*);
bool keep_saved_data_anyway(cse_alife_item_weapon_magazined_w_gl const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_item_weapon_magazined_w_gl const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_weapon_magazined_w_gl&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_weapon_magazined_w_gl&,net_packet&);
bool used_ai_locations(cse_alife_item_weapon_magazined_w_gl const&);
bool can_save(cse_alife_item_weapon_magazined_w_gl const&);
bool bfUseful(cse_alife_item_weapon_magazined_w_gl&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_weapon_magazined_w_gl&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_item_weapon_magazined_w_gl const&);
char const* name(cse_abstract const*);
char const* section_name(cse_abstract const*);
}
[cpp]
class DLL_Pure
{
DLL_Pure* _construct(DLL_Pure&);
void __init(luabind::argument const&);
}
[cpp]
class CRustyHairArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cpure_server_object : ipure_server_object
{
}
[cpp]
class CGrenadeLauncher : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_item_grenade : cse_alife_item
{
void on_unregister(cse_alife_item_grenade&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_grenade const&);
void switch_online(cse_alife_item_grenade&);
cse_abstract* init(cse_alife_item_grenade&);
bool interactive(cse_alife_item_grenade const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_grenade&);
void STATE_Read(cse_alife_item_grenade&,net_packet&,unsigned short);
void on_register(cse_alife_item_grenade&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_grenade const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_grenade const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_grenade&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_grenade&,net_packet&);
bool can_save(cse_alife_item_grenade const&);
bool used_ai_locations(cse_alife_item_grenade const&);
bool bfUseful(cse_alife_item_grenade&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_grenade&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class GAME_TYPE
{
const GAME_UNKNOWN = -1;
const eGameIDArtefactHunt = 8;
const eGameIDCaptureTheArtefact = 16;
const eGameIDDeathmatch = 2;
const eGameIDTeamDeathmatch = 4;
}
[cpp]
class cse_alife_item_document : cse_alife_item
{
void on_unregister(cse_alife_item_document&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_document const&);
void switch_online(cse_alife_item_document&);
cse_abstract* init(cse_alife_item_document&);
bool interactive(cse_alife_item_document const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_document&);
void STATE_Read(cse_alife_item_document&,net_packet&,unsigned short);
void on_register(cse_alife_item_document&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_document const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_document const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_document&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_document&,net_packet&);
bool can_save(cse_alife_item_document const&);
bool used_ai_locations(cse_alife_item_document const&);
bool bfUseful(cse_alife_item_document&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_document&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class cse_alife_item_pda : cse_alife_item
{
void on_unregister(cse_alife_item_pda&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_pda const&);
void switch_online(cse_alife_item_pda&);
cse_abstract* init(cse_alife_item_pda&);
bool interactive(cse_alife_item_pda const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_pda&);
void STATE_Read(cse_alife_item_pda&,net_packet&,unsigned short);
void on_register(cse_alife_item_pda&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_pda const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_pda const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_pda&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_pda&,net_packet&);
bool can_save(cse_alife_item_pda const&);
bool used_ai_locations(cse_alife_item_pda const&);
bool bfUseful(cse_alife_item_pda&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_pda&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class action_planner
{
property_evaluator& evaluator(action_planner&,unsigned int const&);
void setup(action_planner&,game_object*);
bool initialized(action_planner const&);
property_storage& storage { get; set; }
action_base& action(action_planner&,unsigned int const&);
void update(action_planner&);
void set_goal_world_state(action_planner*,world_state*);
game_object* object { get; set; }
bool actual(action_planner const*);
action_base& current_action(action_planner&);
unsigned int current_action_id(action_planner const&);
void show(action_planner&,char const*);
void clear(action_planner&);
void __init(luabind::argument const&);
void add_action(action_planner&,unsigned int const&,action_base*);
void remove_evaluator(action_planner&,unsigned int const&);
void add_evaluator(action_planner&,unsigned int const&,property_evaluator*);
void remove_action(action_planner&,unsigned int const&);
}
[cpp]
class cse_alife_item_artefact : cse_alife_item
{
void on_unregister(cse_alife_item_artefact&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_artefact const&);
void switch_online(cse_alife_item_artefact&);
cse_abstract* init(cse_alife_item_artefact&);
bool interactive(cse_alife_item_artefact const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_artefact&);
void STATE_Read(cse_alife_item_artefact&,net_packet&,unsigned short);
void on_register(cse_alife_item_artefact&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_artefact const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_artefact const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_artefact&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_artefact&,net_packet&);
bool can_save(cse_alife_item_artefact const&);
bool used_ai_locations(cse_alife_item_artefact const&);
bool bfUseful(cse_alife_item_artefact&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_artefact&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class cse_alife_item_detector : cse_alife_item
{
void on_unregister(cse_alife_item_detector&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_detector const&);
void switch_online(cse_alife_item_detector&);
cse_abstract* init(cse_alife_item_detector&);
bool interactive(cse_alife_item_detector const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_detector&);
void STATE_Read(cse_alife_item_detector&,net_packet&,unsigned short);
void on_register(cse_alife_item_detector&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_detector const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_detector const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_detector&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_detector&,net_packet&);
bool can_save(cse_alife_item_detector const&);
bool used_ai_locations(cse_alife_item_detector const&);
bool bfUseful(cse_alife_item_detector&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_detector&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class CTorch : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CWeaponRPG7 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class token
{
int id { get; set; }
char const* name { get; set; }
void __init(luabind::argument const&);
}
[cpp]
class token_list
{
void remove(token_list&,char const*);
int id(token_list&,char const*);
char const* name(token_list&,int);
void add(token_list&,char const*,int);
void clear(token_list&);
void __init(luabind::argument const&);
}
[cpp]
class rtoken_list
{
void remove(rtoken_list&,unsigned int);
char const* get(rtoken_list&,unsigned int);
unsigned int count(rtoken_list&);
void add(rtoken_list&,char const*);
void clear(rtoken_list&);
void __init(luabind::argument const&);
}
[cpp]
class memory_object
{
unsigned int level_time { get; set; }
unsigned int last_level_time { get; set; }
}
[cpp]
class net_packet
{
void r_float_q16(net_packet&,custom [float]&,custom [float],custom [float]);
void w_dir(net_packet&,vector const&);
void w_float(net_packet&,custom [float]);
void w_sdir(net_packet&,vector const&);
custom [unsigned __int64] r_u64(net_packet&);
short r_s16(net_packet&);
void r_float_q8(net_packet&,custom [float]&,custom [float],custom [float]);
unsigned int r_u32(net_packet&);
void w_u64(net_packet&,custom [unsigned __int64]);
unsigned short r_u16(net_packet&);
custom [float] r_float(net_packet&);
void w_float_q8(net_packet&,custom [float],custom [float],custom [float]);
void w_angle16(net_packet&,custom [float]);
void w_vec3(net_packet&,vector const&);
void w_chunk_open8(net_packet&,unsigned int&);
bool r_eof(net_packet*);
void r_matrix(net_packet&,matrix&);
void w_matrix(net_packet&,matrix&);
void w_float_q16(net_packet&,custom [float],custom [float],custom [float]);
void w_angle8(net_packet&,custom [float]);
void w_u16(net_packet&,unsigned short);
void w_chunk_close16(net_packet&,unsigned int);
void r_seek(net_packet&,unsigned int);
void r_vec3(net_packet&,vector&);
void r_advance(net_packet&,unsigned int);
char const* r_stringZ(net_packet*);
void w_s64(net_packet&,custom [__int64]);
unsigned char r_u8(net_packet&);
void r_sdir(net_packet&,vector&);
void r_dir(net_packet&,vector&);
void r_angle8(net_packet&,custom [float]&);
void r_angle16(net_packet&,custom [float]&);
unsigned int r_begin(net_packet&,unsigned short&);
void w_chunk_close8(net_packet&,unsigned int);
bool r_bool(net_packet*);
custom [__int64] r_s64(net_packet&);
custom [signed char] r_s8(net_packet&);
unsigned int r_tell(net_packet&);
void w_bool(net_packet*,bool);
void w_chunk_open16(net_packet&,unsigned int&);
void w_u8(net_packet&,unsigned char);
unsigned int w_tell(net_packet&);
int r_s32(net_packet&);
void w_s32(net_packet&,int);
void w_begin(net_packet&,unsigned short);
void __init(luabind::argument const&);
void w_s16(net_packet&,short);
ClientID r_clientID(net_packet*);
void w_stringZ(net_packet&,char const*);
unsigned int r_elapsed(net_packet&);
void w_clientID(net_packet&,ClientID&);
void w_u32(net_packet&,unsigned int);
}
[cpp]
class ini_file
{
int r_clsid(ini_file&,char const*,char const*);
custom [float] r_float(ini_file&,char const*,char const*);
vector r_vector(ini_file&,char const*,char const*);
int r_token(ini_file&,char const*,char const*,token_list const&);
char const* r_string_wq(ini_file&,char const*,char const*);
void __init(luabind::argument const&,char const*);
bool r_line(ini_file*,char const*,int,string_class&,string_class&);
int r_s32(ini_file&,char const*,char const*);
bool section_exist(ini_file&,char const*);
char const* r_string(ini_file&,char const*,char const*);
unsigned int r_u32(ini_file&,char const*,char const*);
bool line_exist(ini_file&,char const*,char const*);
bool r_bool(ini_file&,char const*,char const*);
unsigned int line_count(ini_file&,char const*);
}
[cpp]
class sound_object
{
const looped = 1;
const s2d = 2;
const s3d = 0;
void stop(sound_object&);
custom [float] const frequency { get; set; }
void attach_tail(sound_object&,char const*);
custom [float] const max_distance { get; set; }
unsigned int length(sound_object&);
void stop_deffered(sound_object&);
void set_position(sound_object&,vector const&);
custom [float] const min_distance { get; set; }
bool playing(sound_object const&);
void play_no_feedback(sound_object&,game_object*,unsigned int,custom [float],vector,custom [float]);
void play_at_pos(sound_object&,game_object*,vector const&,custom [float],int);
vector get_position(sound_object const&);
void play(sound_object&,game_object*,custom [float],int);
void __init(luabind::argument const&,char const*,custom [enum ESoundTypes]);
custom [float] const volume { get; set; }
}
[cpp]
class Frect
{
custom [float] x2 { get; set; }
custom [float] x1 { get; set; }
vector2& rb { get; set; }
Frect& set(Frect&,custom [float],custom [float],custom [float],custom [float]);
custom [float] y2 { get; set; }
custom [float] y1 { get; set; }
vector2& lt { get; set; }
void __init(luabind::argument const&);
}
[cpp]
class Fbox
{
vector& max { get; set; }
vector& min { get; set; }
void __init(luabind::argument const&);
}
[cpp]
class CMedkit : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class vector2
{
custom [float] y { get; set; }
custom [float] x { get; set; }
vector2& set(vector2&,vector2 const&);
void __init(luabind::argument const&);
}
[cpp]
class cse_alife_object : cse_abstract
{
unsigned short id { get; set; }
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
void can_switch_offline(cse_alife_object&,bool);
char const* section_name(cse_abstract const*);
void STATE_Write(cse_alife_object&,net_packet&);
int clsid(cse_abstract const&);
bool used_ai_locations(cse_alife_object const&);
cse_abstract* init(cse_alife_object&);
ini_file* spawn_ini(cse_abstract*);
unsigned int m_level_vertex_id { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
vector& angle { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
unsigned short script_version { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
bool interactive(cse_alife_object const&);
void STATE_Read(cse_alife_object&,net_packet&,unsigned short);
void can_switch_online(cse_alife_object&,bool);
unsigned short parent_id { get; set; }
bool can_save(cse_alife_object const&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void move_offline(cse_alife_object&,bool);
char const* name(cse_abstract const*);
unsigned short m_game_vertex_id { get; set; }
}
[cpp]
class CWeaponSVD : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class flags32
{
flags32& and(flags32&,flags32 const&,unsigned int);
flags32& or(flags32&,flags32 const&,unsigned int);
bool is_any(flags32*,unsigned int);
bool is(flags32*,unsigned int);
void __init(luabind::argument const&);
bool test(flags32*,unsigned int);
bool equal(flags32*,flags32 const&,unsigned int);
flags32& set(flags32*,unsigned int,bool);
flags32& invert(flags32&,unsigned int);
flags32& assign(flags32&,unsigned int);
flags32& zero(flags32&);
flags32& one(flags32&);
unsigned int get(flags32 const&);
}
[cpp]
class CRadioactiveZone : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class noise
{
custom [float] fps { get; set; }
noise& set(noise&,custom [float],custom [float],custom [float]);
custom [float] grain { get; set; }
custom [float] intensity { get; set; }
void __init(luabind::argument const&,custom [float],custom [float],custom [float]);
}
[cpp]
class flags16
{
flags16& and(flags16&,flags16 const&,unsigned short);
flags16& or(flags16&,flags16 const&,unsigned short);
bool is_any(flags16*,unsigned short);
bool is(flags16*,unsigned short);
void __init(luabind::argument const&);
bool test(flags16*,unsigned short);
bool equal(flags16*,flags16 const&,unsigned short);
flags16& set(flags16*,unsigned short,bool);
flags16& invert(flags16&,unsigned short);
flags16& assign(flags16&,unsigned short);
flags16& zero(flags16&);
void one(flags16*);
unsigned short get(flags16 const&);
}
[cpp]
class CSightParams
{
const eSightTypeAnimationDirection = 11;
const eSightTypeCover = 5;
const eSightTypeCoverLookOver = 8;
const eSightTypeCurrentDirection = 0;
const eSightTypeDirection = 2;
const eSightTypeDummy = -1;
const eSightTypeFireObject = 9;
const eSightTypeFirePosition = 10;
const eSightTypeLookOver = 7;
const eSightTypeObject = 4;
const eSightTypePathDirection = 1;
const eSightTypePosition = 3;
const eSightTypeSearch = 6;
custom [enum SightManager::ESightType] m_sight_type { get; set; }
vector& m_vector { get; set; }
game_object* m_object { get; set; }
void __init(luabind::argument const&);
}
[cpp]
class CCar : , CGameObjectholder
{
const eWpnActivate = 3;
const eWpnAutoFire = 5;
const eWpnDesiredDir = 1;
const eWpnDesiredPos = 2;
const eWpnFire = 4;
const eWpnToDefaultDir = 6;
int net_Spawn(CGameObject&,cse_abstract*);
vector CurrentVel(CCar&);
unsigned int ExplodeTime(CCar&);
void __init(luabind::argument const&);
custom [float] GetfHealth(CCar const&);
void Action(CCar&,unsigned short,unsigned int);
void net_Import(CGameObject&,net_packet&);
void SetParam(CCar&,int,vector);
void SetExplodeTime(CCar&,unsigned int);
bool HasWeapon(CCar&);
void CarExplode(CCar&);
bool use(CGameObject&,CGameObject*);
int getVisible(CGameObject const&);
IRender_Visual* Visual(CGameObject const&);
bool IsObjectVisible(CCar&,game_object*);
bool CanHit(CCar&);
int getEnabled(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
DLL_Pure* _construct(CGameObject&);
custom [float] SetfHealth(CCar&,custom [float]);
bool engaged(holder&);
custom [float] FireDirDiff(CCar&);
}
[cpp]
class flags8
{
flags8& and(flags8&,flags8 const&,unsigned char);
flags8& or(flags8&,flags8 const&,unsigned char);
bool is_any(flags8*,unsigned char);
bool is(flags8*,unsigned char);
void __init(luabind::argument const&);
bool test(flags8*,unsigned char);
bool equal(flags8*,flags8 const&,unsigned char);
flags8& set(flags8*,unsigned char,bool);
flags8& invert(flags8&,unsigned char);
flags8& assign(flags8&,unsigned char);
flags8& zero(flags8&);
void one(flags8*);
unsigned char get(flags8 const&);
}
[cpp]
class IKinematicsAnimated
{
void PlayCycle(IKinematicsAnimated*,char const*);
}
[cpp]
class cse_alife_trader_abstract
{
int reputation(cse_alife_trader_abstract&);
int rank(cse_alife_trader_abstract&);
char const* community(cse_alife_trader_abstract const&);
char const* profile_name(cse_alife_trader_abstract*);
}
[cpp]
class CMercuryBall : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class FS
{
const FSType_Any = 3;
const FSType_External = 2;
const FSType_Virtual = 1;
const FS_ClampExt = 4;
const FS_ListFiles = 1;
const FS_ListFolders = 2;
const FS_RootOnly = 8;
const FS_sort_by_modif_down = 5;
const FS_sort_by_modif_up = 4;
const FS_sort_by_name_down = 1;
const FS_sort_by_name_up = 0;
const FS_sort_by_size_down = 3;
const FS_sort_by_size_up = 2;
void r_close(FS&,reader*&);
void w_close(FS&,custom [class IWriter]*&);
void file_rename(FS&,char const*,char const*,bool);
int file_length(FS&,char const*);
FS_file_list_ex file_list_open_ex(FS*,char const*,unsigned int,char const*);
char const* update_path(FS*,char const*,char const*);
void dir_delete(FS*,char const*,char const*,int);
char const* get_file_age_str(FS*,char const*);
void file_copy(FS&,char const*,char const*);
reader* r_open(FS&,char const*);
custom [class FS_Path]* append_path(FS&,char const*,char const*,char const*,int);
void file_delete(FS&,char const*);
custom [class IWriter]* w_open(FS&,char const*);
bool path_exist(FS&,char const*);
FS_file_list file_list_open(FS*,char const*,char const*,unsigned int);
unsigned int get_file_age(FS&,char const*);
custom [class FS_Path]* get_path(FS&,char const*);
FileStatus exist(FS&,char const*,char const*,custom [enum FSType]);
}
[cpp]
class CEliteDetector : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CInventoryBox : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_dynamic_object : cse_alife_object
{
void on_unregister(cse_alife_dynamic_object&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_dynamic_object const&);
void switch_online(cse_alife_dynamic_object&);
cse_abstract* init(cse_alife_dynamic_object&);
bool interactive(cse_alife_dynamic_object const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_dynamic_object&);
void STATE_Read(cse_alife_dynamic_object&,net_packet&,unsigned short);
void on_register(cse_alife_dynamic_object&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_dynamic_object const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_dynamic_object const&);
vector& angle { get; set; }
void on_spawn(cse_alife_dynamic_object&);
unsigned short m_game_vertex_id { get; set; }
unsigned int m_level_vertex_id { get; set; }
bool can_save(cse_alife_dynamic_object const&);
bool used_ai_locations(cse_alife_dynamic_object const&);
void STATE_Write(cse_alife_dynamic_object&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_dynamic_object&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
ini_file* spawn_ini(cse_abstract*);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class CScientificDetector : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CALifeMonsterDetailPathManager
{
void target(CALifeMonsterDetailPathManager&,CALifeSmartTerrainTask const*);
bool completed(CALifeMonsterDetailPathManager const&);
bool actual(CALifeMonsterDetailPathManager const&);
bool failed(CALifeMonsterDetailPathManager const&);
custom [float] const& speed(CALifeMonsterDetailPathManager const&);
}
[cpp]
class CAdvancedDetector : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CWeaponAmmo : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUIMapInfo : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void Init(CUIMapInfo&,vector2,vector2);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void InitMap(CUIMapInfo&,char const*,char const*);
void Enable(CUIWindow&,bool);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class cse_ph_skeleton
{
}
[cpp]
class CGameFont
{
const alCenter = 2;
const alLeft = 0;
const alRight = 1;
}
[cpp]
class CUISpinText : CUICustomSpin
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* GetText(CUICustomSpin&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
char const* WindowName(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class game_object
{
const action_type_count = 6;
const alifeMovementTypeMask = 0;
const alifeMovementTypeRandom = 1;
const animation = 2;
const dialog_pda_msg = 0;
const dummy = -1;
const enemy = 2;
const friend = 0;
const game_path = 0;
const info_pda_msg = 1;
const level_path = 1;
const movement = 0;
const neutral = 1;
const no_path = 3;
const no_pda_msg = 2;
const object = 5;
const particle = 4;
const patrol_path = 2;
const relation_attack = 1;
const relation_fight_help_human = 2;
const relation_fight_help_monster = 4;
const relation_kill = 0;
const sound = 3;
const watch = 1;
void set_queue_size(game_object&,unsigned int);
void enable_attachable_item(game_object&,bool);
bool can_script_capture(game_object const&);
game_object* parent(game_object const&);
char const* who_hit_name(game_object&);
game_object* item_in_slot(game_object const&,unsigned int);
void change_character_reputation(game_object&,int);
custom [float] apply_loophole_direction_distance(game_object const&);
bool night_vision_enabled(game_object const&);
void set_invisible(game_object&,bool);
custom [float] visibility_threshold(game_object const&);
void enable_torch(game_object&,bool);
vector bone_position(game_object const&,char const*);
int community_goodwill(game_object&,char const*);
bool deadbody_closed_status(game_object&);
int goodwill(game_object&,game_object*);
void set_trader_head_anim(game_object&,char const*);
char const* aim_bone_id(game_object const&);
void set_callback(game_object&,callback);
danger_object const* best_danger(game_object&);
void transfer_money(game_object&,int,game_object*);
void set_enemy_callback(game_object&,function<bool> const&,luabind::object const&);
int weapon_scope_status(game_object&);
void give_task(game_object&,CGameTask*,unsigned int,bool,unsigned int);
char const* out_restrictions(game_object&);
custom [float] range(game_object const&);
void run_talk_dialog(game_object&,game_object*,bool);
void remove_home(game_object&);
bool in_current_loophole_fov(game_object const&,vector);
void set_smart_cover_target_default(game_object&,bool);
void deadbody_can_take(game_object&,bool);
bool is_inv_upgrade_enabled(game_object&);
void set_relation(game_object&,custom [enum ALife::ERelationType],game_object*);
char const* name(game_object const&);
char const* get_dest_smart_cover_name(game_object&);
holder* get_current_holder(game_object&);
game_object* best_item(game_object&);
char const* character_community(game_object&);
void set_patrol_path(game_object&,char const*,custom [enum PatrolPathManager::EPatrolStartType],custom [enum PatrolPathManager::EPatrolRouteType],bool);
void set_fov(game_object&,custom [float]);
custom [enum MonsterSpace::EBodyState] target_body_state(game_object const&);
void set_capture_anim(game_object&,game_object*,char const*,vector const&,custom [float]);
void remove_restrictions(game_object&,char const*,char const*);
void hit(game_object&,hit*);
unsigned int aim_time(game_object&,game_object*);
void actor_look_at_point(game_object&,vector);
cover_point const* safe_cover(game_object&,vector const&,custom [float],custom [float]);
void skip_transfer_enemy(game_object&,bool);
custom [enum MonsterSpace::EMentalState] target_mental_state(game_object const&);
int squad(game_object const&);
void mark_item_dropped(game_object&,game_object*);
void set_dest_loophole(game_object&);
custom [enum DetailPathManager::EDetailPathType] detail_path_type(game_object const&);
void set_visual_memory_enabled(game_object&,bool);
custom [enum MonsterSpace::EMovementType] movement_type(game_object const&);
object_binder* binded_object(game_object&);
void can_throw_grenades(game_object&,bool);
bool inside(game_object const&,vector const&);
custom [float] satiety { get; set; }
void remove_all_restrictions(game_object&);
void buy_condition(game_object&,custom [float],custom [float]);
char const* patrol(game_object&);
custom [float] bleeding { get; set; }
void switch_to_trade(game_object&);
void set_sight(game_object&,game_object*,bool,bool,bool);
unsigned int memory_time(game_object&,game_object const&);
void give_talk_message(game_object&,char const*,char const*,char const*);
char const* base_out_restrictions(game_object&);
bool see(game_object&,char const*);
void set_condition(game_object&,custom [float]);
void enable_trade(game_object&);
void lock_door_for_npc(game_object&);
void force_set_goodwill(game_object&,int,game_object*);
void set_sound_mask(game_object&,unsigned int);
void enable_inv_upgrade(game_object&);
void set_movement_selection_type(game_object&,custom [enum ESelectionType]);
int active_sound_count(game_object&,bool);
custom [float] psy_health { get; set; }
custom [float] idle_max_time(game_object const&);
custom [class xr_vector<struct MemorySpace::CNotYetVisibleObject,class xalloc<struct MemorySpace::CNotYetVisibleObject> >] const& not_yet_visible_objects(game_object const&);
custom [enum MonsterSpace::EBodyState] body_state(game_object const&);
game_object* get_corpse(game_object const&);
void disable_show_hide_sounds(game_object&,bool);
unsigned int get_current_point_index(game_object&);
void set_body_state(game_object&,custom [enum MonsterSpace::EBodyState]);
void set_character_community(game_object&,char const*,int,int);
void set_smart_cover_target_selector(game_object&);
void external_sound_stop(game_object&);
void set_actor_position(game_object&,vector);
bool in_smart_cover(game_object const&);
ini_file* spawn_ini(game_object const&);
void external_sound_start(game_object&,char const*);
void use_smart_covers_only(game_object&,bool);
void kill(game_object&,game_object*);
bool has_info(game_object&,char const*);
void reset_action_queue(game_object&);
physics_shell* get_physics_shell(game_object const&);
custom [float] health { get; set; }
bool give_info_portion(game_object&,char const*);
void unregister_in_combat(game_object&);
void remove_sound(game_object&,unsigned int);
game_object* active_detector(game_object const&);
custom [float] get_current_outfit_protection(game_object&,int);
bool accessible(game_object&,unsigned int);
unsigned int cost(game_object const&);
void info_add(game_object&,char const*);
void script(game_object&,bool,char const*);
void restore_max_ignore_monster_distance(game_object&);
void set_movement_type(game_object&,custom [enum MonsterSpace::EMovementType]);
char const* base_in_restrictions(game_object&);
unsigned int active_slot(game_object&);
void give_talk_message2(game_object&,char const*,char const*,char const*,char const*);
void set_start_point(game_object&,int);
unsigned int add_combat_sound(game_object&,char const*,unsigned int,custom [enum ESoundTypes],unsigned int,unsigned int,unsigned int,char const*);
void set_anomaly_power(game_object&,custom [float]);
custom [enum ALife::ERelationType] relation(game_object&,game_object*);
bool is_level_changer_enabled(game_object&);
unsigned int get_ammo_total(game_object const&);
custom [class xr_vector<struct MemorySpace::CHitObject,class xalloc<struct MemorySpace::CHitObject> >] const& memory_hit_objects(game_object const&);
bool in_current_loophole_range(game_object const&,vector);
void attachable_item_load_attach(game_object&,char const*);
bool take_items_enabled(game_object const&);
vector direction(game_object const&);
void restore_sound_threshold(game_object&);
void explode(game_object&,unsigned int);
bool in_loophole_fov(game_object const&,char const*,char const*,vector);
custom [float] mass(game_object const&);
void stop_particles(game_object&,char const*,char const*);
void start_particles(game_object&,char const*,char const*);
bool is_weapon_going_to_be_strapped(game_object const&,game_object const*);
bool sniper_update_rate(game_object const&);
void enable_level_changer(game_object&,bool);
bool sniper_fire_mode(game_object const&);
void set_level_changer_invitation(game_object&,char const*);
void buy_item_condition_factor(game_object&,custom [float]);
vector get_movement_speed(game_object const&);
CPhysicObject* get_physics_object(game_object&);
void set_ammo_elapsed(game_object&,int);
void debug_planner(game_object&,action_planner const*);
CArtefact* get_artefact(game_object&);
CZoneCampfire* get_campfire(game_object&);
unsigned int object_count(game_object const&);
void unregister_door_for_npc(game_object&);
void set_const_force(game_object&,vector const&,custom [float],unsigned int);
bool disable_hit_marks(game_object const&);
CSightParams sight_params(game_object&);
void unload_magazine(game_object&);
void disable_trade(game_object&);
void play_sound(game_object&,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int);
void can_select_weapon(game_object&,bool);
void poltergeist_set_actor_ignore(game_object&,bool);
void deadbody_closed(game_object&,bool);
int clsid(game_object const&);
void iterate_inventory_box(game_object&,function<void>,luabind::object);
void stop_talk(game_object&);
void iterate_inventory(game_object&,function<void>,luabind::object);
void wounded(game_object&,bool);
int get_visibility_state(game_object&);
unsigned int location_on_path(game_object&,custom [float],vector*);
bool fake_death_fall_down(game_object&);
custom [enum ETaskState] get_task_state(game_object&,char const*);
void buy_supplies(game_object&,ini_file*,char const*);
void sell_condition(game_object&,custom [float],custom [float]);
void show_condition(game_object&,ini_file*,char const*);
void set_path_type(game_object&,custom [enum MovementManager::EPathType]);
void command(game_object&,entity_action const*,bool);
void make_object_visible_somewhen(game_object&,game_object*);
void disable_inv_upgrade(game_object&);
bool dont_has_info(game_object&,char const*);
bool inv_box_can_take_status(game_object&);
bool inv_box_can_take(game_object&,bool);
bool inv_box_closed_status(game_object&);
game_object* object(game_object&,int);
custom [float] fov(game_object const&);
vector memory_position(game_object&,game_object const&);
bool inv_box_closed(game_object&,bool,char const*);
void set_smart_cover_target_fire(game_object&);
bool movement_enabled(game_object&);
game_object* active_item(game_object&);
void info_clear(game_object&);
bool is_inv_box_empty(game_object&);
void set_fastcall(game_object&,function<bool> const&,luabind::object const&);
bool in_loophole_range(game_object const&,char const*,char const*,vector);
unsigned int level_vertex_id(game_object const&);
unsigned int vertex_in_direction(game_object const&,unsigned int,vector,custom [float]);
void set_nonscript_usable(game_object&,bool);
void set_tip_text_default(game_object&);
void set_vis_state(game_object&,custom [float]);
void set_tip_text(game_object&,char const*);
holder* get_holder_class(game_object&);
custom [float] ignore_monster_threshold(game_object const&);
bool movement_target_reached(game_object&);
void sound_prefix(game_object&,char const*);
hanging_lamp* get_hanging_lamp(game_object&);
bool weapon_strapped(game_object const&);
custom [class xr_vector<struct MemorySpace::CVisibleObject,class xalloc<struct MemorySpace::CVisibleObject> >] const& memory_visible_objects(game_object const&);
bool burer_get_force_gravi_attack(game_object&);
custom [float] lookout_max_time(game_object const&);
CCar* get_car(game_object&);
void patrol_path_make_inactual(game_object&);
custom [float] get_anomaly_power(game_object&);
void unlock_door_for_npc(game_object&);
char const* get_script_name(game_object const&);
unsigned int get_ammo_in_magazine(game_object&);
void allow_break_talk_dialog(game_object&,bool);
void enable_anomaly(game_object&);
game_object* get_enemy(game_object const&);
void set_actor_relation_flags(game_object&,flags32);
int animation_count(game_object const&);
custom [float] power { get; set; }
custom [float] morale { get; set; }
int character_reputation(game_object&);
void fake_death_stand_up(game_object&);
void restore_default_start_dialog(game_object&);
char const* character_icon(game_object&);
void set_dest_level_vertex_id(game_object&,unsigned int);
void set_smart_cover_target_idle(game_object&);
void register_door_for_npc(game_object&);
char const* get_visual_name(game_object const&);
char const* profile_name(game_object&);
void set_sympathy(game_object&,custom [float]);
unsigned int accessible_nearest(game_object&,vector const&,vector&);
bool disable_info_portion(game_object&,char const*);
unsigned int add_sound(game_object&,char const*,unsigned int,custom [enum ESoundTypes],unsigned int,unsigned int,unsigned int,char const*);
game_object* best_enemy(game_object&);
void set_enemy(game_object&,game_object*);
void enable_night_vision(game_object&,bool);
MonsterHitInfo get_monster_hit_info(game_object&);
custom [float] max_health(game_object const&);
void set_trader_sound(game_object&,char const*,char const*);
void set_community_goodwill(game_object&,char const*,int);
void play_cycle(game_object&,char const*,bool);
bool is_door_locked_for_npc(game_object const&);
int general_goodwill(game_object&,game_object*);
void change_goodwill(game_object&,int,game_object*);
void set_goodwill(game_object&,int,game_object*);
int character_rank(game_object&);
void get_start_dialog(game_object&);
void invulnerable(game_object&,bool);
void set_start_dialog(game_object&,char const*);
void allow_sprint(game_object&,bool);
int weapon_silencer_status(game_object&);
void set_dest_game_vertex_id(game_object&,unsigned short);
int weapon_grenadelauncher_status(game_object&);
bool weapon_is_silencer(game_object&);
custom [float] idle_min_time(game_object const&);
bool weapon_is_scope(game_object&);
void set_default_panic_threshold(game_object&);
void set_smart_cover_target(game_object&);
void disable_talk(game_object&);
void restore_weapon(game_object&);
void hide_weapon(game_object&);
void disable_anomaly(game_object&);
bool marked_dropped(game_object&,game_object*);
void switch_to_upgrade(game_object&);
bool path_completed(game_object const&);
unsigned int money(game_object&);
void bind_object(game_object&,object_binder*);
void inventory_for_each(game_object&,function<void> const&);
void clear_animations(game_object&);
void add_restrictions(game_object&,char const*,char const*);
int animation_slot(game_object const&);
custom [enum MovementManager::EPathType] path_type(game_object const&);
void drop_item_and_teleport(game_object&,game_object*,vector);
bool vision_enabled(game_object const&);
entity_action* action(game_object const&);
void set_task_state(game_object&,custom [enum ETaskState],char const*);
void drop_item(game_object&,game_object*);
void change_team(game_object&,unsigned char,unsigned char,unsigned char);
unsigned int death_time(game_object const&);
void set_item(game_object&,custom [enum MonsterSpace::EObjectAction],game_object*,unsigned int,unsigned int);
bool is_talk_enabled(game_object&);
void enable_talk(game_object&);
custom [enum MonsterSpace::EMovementType] target_movement_type(game_object const&);
void set_patrol_extrapolate_callback(game_object&,function<bool> const&,luabind::object const&);
bool is_talking(game_object&);
CGameTask* get_task(game_object&,char const*,bool);
void switch_to_talk(game_object&);
void set_active_task(game_object&,CGameTask*);
vector head_orientation(game_object const&);
void set_previous_point(game_object&,int);
unsigned short get_bone_id(game_object const&,char const*);
void set_desired_direction(game_object&,vector const*);
void jump(game_object&,vector const&,custom [float]);
bool torch_enabled(game_object const&);
flags32 get_actor_relation_flags(game_object const&);
void set_sound_threshold(game_object&,custom [float]);
bool weapon_is_grenadelauncher(game_object&);
CHelicopter* get_helicopter(game_object&);
char const* get_smart_cover_description(game_object const&);
unsigned int story_id(game_object const&);
void set_character_rank(game_object&,int);
void set_trader_global_anim(game_object&,char const*);
void transfer_item(game_object&,game_object*,game_object*);
vector center(game_object&);
char const* in_restrictions(game_object&);
int group(game_object const&);
void clear_override_animation(game_object&);
void set_npc_position(game_object&,vector);
bool deadbody_can_take_status(game_object&);
void eat(game_object&,game_object*);
void activate_slot(game_object&,unsigned int);
entity_action const* action_by_index(game_object&,unsigned int);
void register_in_combat(game_object&);
unsigned int game_vertex_id(game_object const&);
void set_visual_name(game_object&,char const*);
unsigned int action_count(game_object const&);
custom [float] radiation { get; set; }
void force_visibility_state(game_object&,int);
void release_stand_sleep_animation(game_object&);
bool active_zone_contact(game_object&,unsigned short);
bool is_door_blocked_by_npc(game_object const&);
void restore_ignore_monster_threshold(game_object&);
void on_door_is_closed(game_object&);
void burer_set_force_gravi_attack(game_object&,bool);
bool is_there_items_to_pickup(game_object const&);
void set_manual_invisibility(game_object&,bool);
unsigned short id(game_object const&);
bool is_active_task(game_object&,CGameTask*);
void enable_vision(game_object&,bool);
action_planner* motivation_action_manager(game_object*);
void set_override_animation(game_object&,char const*);
custom [float] accuracy(game_object const&);
void add_animation(game_object&,char const*,bool,vector,vector,bool);
bool critically_wounded(game_object&);
SoundInfo get_sound_info(game_object&);
bool alive(game_object const&);
int team(game_object const&);
char const* who_hit_section_name(game_object&);
void set_collision_off(game_object&,bool);
void berserk(game_object&);
bool is_trade_enabled(game_object&);
bool suitable_smart_cover(game_object&,game_object*);
void set_alien_control(game_object&,bool);
vector position(game_object const&);
bool weapon_unstrapped(game_object const&);
bool death_sound_enabled(game_object const&);
void set_custom_panic_threshold(game_object&,custom [float]);
void make_item_active(game_object&,game_object*);
custom [enum MonsterSpace::EMentalState] mental_state(game_object const&);
void inactualize_patrol_path(game_object&);
char const* sound_voice_prefix(game_object const&);
char const* section(game_object const&);
bool attachable_item_enabled(game_object const&);
bool is_body_turning(game_object const&);
cover_point const* find_best_cover(game_object&,vector);
void force_stand_sleep_animation(game_object&,unsigned int);
bool poltergeist_get_actor_ignore(game_object&);
bool get_script(game_object const&);
void set_desired_position(game_object&,vector const*);
bool special_danger_move(game_object&);
void set_actor_direction(game_object&,custom [float]);
custom [float] max_ignore_monster_distance(game_object const&);
void set_range(game_object&,custom [float]);
void enable_memory_object(game_object&,game_object*,bool);
void extrapolate_length(game_object&,custom [float]);
custom [class xr_vector<struct MemorySpace::CSoundObject,class xalloc<struct MemorySpace::CSoundObject> >] const& memory_sound_objects(game_object const&);
custom [float] condition(game_object const&);
void set_mental_state(game_object&,custom [enum MonsterSpace::EMentalState]);
void set_dest_smart_cover(game_object&);
void give_game_news(game_object&,char const*,char const*,char const*,int,int,int);
custom [float] lookout_min_time(game_object const&);
void set_smart_cover_target_lookout(game_object&);
int get_enemy_strength(game_object const&);
void set_detail_path_type(game_object&,custom [enum DetailPathManager::EDetailPathType]);
void set_smart_cover_target_fire_no_lookout(game_object&);
void on_door_is_open(game_object&);
void give_money(game_object&,int);
custom [float] sympathy(game_object&);
void set_home(game_object&,unsigned int,custom [float],custom [float],bool,custom [float]);
game_object* get_current_outfit(game_object const&);
cover_point const* get_dest_smart_cover(game_object&);
char const* character_name(game_object&);
int rank(game_object&);
void set_force_anti_aim(game_object&,bool);
game_object* best_weapon(game_object&);
cover_point const* best_cover(game_object&,vector const&,vector const&,custom [float],custom [float],custom [float]);
void group_throw_time_interval(game_object&,unsigned int);
bool get_force_anti_aim(game_object&);
vector get_current_direction(game_object&);
}
[cpp]
class phaction_constforce
{
void __init(luabind::argument const&,custom [class CPhysicsShell]*,vector const&);
}
[cpp]
class cse_alife_item_helmet : cse_alife_item
{
void on_unregister(cse_alife_item_helmet&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_helmet const&);
void switch_online(cse_alife_item_helmet&);
cse_abstract* init(cse_alife_item_helmet&);
bool interactive(cse_alife_item_helmet const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_helmet&);
void STATE_Read(cse_alife_item_helmet&,net_packet&,unsigned short);
void on_register(cse_alife_item_helmet&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_helmet const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_helmet const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_helmet&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_helmet&,net_packet&);
bool can_save(cse_alife_item_helmet const&);
bool used_ai_locations(cse_alife_item_helmet const&);
bool bfUseful(cse_alife_item_helmet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_helmet&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class FS_file_list
{
void Free(FS_file_list&);
unsigned int Size(FS_file_list&);
char const* GetAt(FS_file_list&,unsigned int);
}
[cpp]
class cse_alife_human_abstract : , cse_alife_trader_abstractcse_alife_monster_abstract
{
void on_unregister(cse_alife_human_abstract&);
void STATE_Read(cse_alife_human_abstract&,net_packet&,unsigned short);
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_human_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_human_abstract const&);
void on_register(cse_alife_human_abstract&);
void switch_online(cse_alife_human_abstract&);
unsigned char team { get; set; }
void on_before_register(cse_alife_human_abstract&);
cse_abstract* init(cse_alife_human_abstract&);
void update(cse_alife_human_abstract&);
unsigned int m_level_vertex_id { get; set; }
bool interactive(cse_alife_human_abstract const&);
void STATE_Write(cse_alife_human_abstract&,net_packet&);
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
bool used_ai_locations(cse_alife_human_abstract const&);
void switch_offline(cse_alife_human_abstract&);
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
void on_death(cse_alife_human_abstract&,cse_abstract*);
unsigned char group { get; set; }
void set_rank(cse_alife_human_abstract&,int);
void smart_terrain_task_activate(cse_alife_monster_abstract*);
ini_file* spawn_ini(cse_abstract*);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_human_abstract&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
vector& position { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
int reputation(cse_alife_trader_abstract&);
void move_offline(cse_alife_object&,bool);
bool keep_saved_data_anyway(cse_alife_human_abstract const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
char const* section_name(cse_abstract const*);
bool alive(cse_alife_creature_abstract const&);
void use_ai_locations(cse_alife_object&,bool);
void UPDATE_Write(cse_abstract&,net_packet&);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_human_abstract&);
bool can_switch_online(cse_alife_human_abstract const&);
unsigned short m_game_vertex_id { get; set; }
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_human_abstract&);
CALifeHumanBrain* brain(cse_alife_human_abstract*);
bool has_detector(cse_alife_monster_abstract&);
char const* community(cse_alife_trader_abstract const&);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
bool can_save(cse_alife_human_abstract const&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned char g_group(cse_alife_human_abstract&);
char const* name(cse_abstract const*);
char const* profile_name(cse_alife_trader_abstract*);
}
[cpp]
class physics_joint
{
void set_axis_dir_vs_second_element(physics_joint&,custom [float],custom [float],custom [float],int);
void get_limits(physics_joint&,custom [float]&,custom [float]&,int);
custom [float] get_axis_angle(physics_joint&,int);
void set_anchor_vs_second_element(physics_joint&,custom [float],custom [float],custom [float]);
void set_max_force_and_velocity(physics_joint&,custom [float],custom [float],int);
bool is_breakable(physics_joint&);
void set_joint_spring_dumping_factors(physics_joint&,custom [float],custom [float]);
void get_anchor(physics_joint&,vector&);
physics_element* get_first_element(physics_joint&);
void set_axis_dir_vs_first_element(physics_joint&,custom [float],custom [float],custom [float],int);
void set_limits(physics_joint&,custom [float],custom [float],int);
void get_axis_dir(physics_joint&,int,vector&);
void set_anchor_vs_first_element(physics_joint&,custom [float],custom [float],custom [float]);
unsigned short get_axes_number(physics_joint&);
void set_axis_spring_dumping_factors(physics_joint&,custom [float],custom [float],int);
physics_element* get_stcond_element(physics_joint&);
void get_max_force_and_velocity(physics_joint&,custom [float]&,custom [float]&,int);
unsigned short get_bone_id(physics_joint&);
void set_axis_dir_global(physics_joint&,custom [float],custom [float],custom [float],int);
void set_anchor_global(physics_joint&,custom [float],custom [float],custom [float]);
}
[cpp]
class color_animator
{
unsigned int length(color_animator&);
void load(color_animator&,char const*);
fcolor calculate(color_animator&,custom [float]);
void __init(luabind::argument const&,char const*);
}
[cpp]
class CUIMapList : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void StartDedicatedServer(CUIMapList&);
void SetMapInfo(CUIMapList&,CUIMapInfo*);
void SetModeSelector(CUIMapList&,CUIWindow*);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
char const* GetCommandLine(CUIMapList&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetPPMode(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void SetAutoDelete(CUIWindow&,bool);
void ClearList(CUIMapList&);
void LoadMapList(CUIMapList&);
bool IsEmpty(CUIMapList&);
void SetWeatherSelector(CUIMapList&,CUIComboBox*);
bool IsAutoDelete(CUIWindow&);
void SetServerParams(CUIMapList&,char const*);
void SetWndPos(CUIWindow&,vector2);
void ResetPPMode(CUIWindow&);
void OnModeChange(CUIMapList&);
bool IsEnabled(CUIWindow&);
void DetachChild(CUIWindow&,CUIWindow*);
void SaveMapList(CUIMapList&);
void SetWndRect(CUIWindow&,Frect);
custom [enum EGameIDs] GetCurGameType(CUIMapList&);
void SetMapPic(CUIMapList&,CUIStatic*);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CWeaponSVU : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class entity_memory_object : memory_object
{
game_object* object(entity_memory_object const&);
custom [struct MemorySpace::CObjectParams<class CEntityAlive>]& self_info { get; set; }
unsigned int level_time { get; set; }
unsigned int last_level_time { get; set; }
custom [struct MemorySpace::CObjectParams<class CEntityAlive>]& object_info { get; set; }
}
[cpp]
class CElectricBall : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class ClientID
{
void __eq(lua_State*,ClientID&,ClientID);
void set(ClientID&,unsigned int);
void __init(luabind::argument const&);
unsigned int value(ClientID const&);
}
[cpp]
class cef_storage
{
custom [float] evaluate(cef_storage*,char const*,cse_alife_object*,cse_alife_object*,cse_alife_object*,cse_alife_object*);
}
[cpp]
class duality
{
duality& set(duality&,custom [float],custom [float]);
custom [float] v { get; set; }
custom [float] h { get; set; }
void __init(luabind::argument const&,custom [float],custom [float]);
}
[cpp]
class cse_alife_dynamic_object_visual : , cse_alife_dynamic_objectcse_visual
{
void on_unregister(cse_alife_dynamic_object_visual&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_dynamic_object_visual const&);
void switch_online(cse_alife_dynamic_object_visual&);
cse_abstract* init(cse_alife_dynamic_object_visual&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_dynamic_object_visual&);
void STATE_Read(cse_alife_dynamic_object_visual&,net_packet&,unsigned short);
void on_register(cse_alife_dynamic_object_visual&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_dynamic_object_visual const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_dynamic_object_visual const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void on_spawn(cse_alife_dynamic_object_visual&);
bool can_save(cse_alife_dynamic_object_visual const&);
bool used_ai_locations(cse_alife_dynamic_object_visual const&);
void STATE_Write(cse_alife_dynamic_object_visual&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_dynamic_object_visual&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_dynamic_object_visual const&);
char const* name(cse_abstract const*);
char const* section_name(cse_abstract const*);
}
[cpp]
class hit_memory_object : entity_memory_object
{
custom [float] amount { get; set; }
custom [struct MemorySpace::CObjectParams<class CEntityAlive>]& self_info { get; set; }
unsigned int level_time { get; set; }
unsigned int last_level_time { get; set; }
vector& direction { get; set; }
unsigned short bone_index { get; set; }
custom [struct MemorySpace::CObjectParams<class CEntityAlive>]& object_info { get; set; }
game_object* object(entity_memory_object const&);
}
[cpp]
class CGalantineArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUIGameCustom
{
void enable_fake_indicators(CUIGameCustom&,bool);
void hide_messages(CUIGameCustom&);
void RemoveCustomStatic(CUIGameCustom&,char const*);
void HidePdaMenu(CUIGameCustom&);
void AddDialogToRender(CUIGameCustom&,CUIWindow*);
void HideActorMenu(CUIGameCustom&);
void update_fake_indicators(CUIGameCustom&,unsigned char,custom [float]);
void RemoveDialogToRender(CUIGameCustom&,CUIWindow*);
void show_messages(CUIGameCustom&);
StaticDrawableWrapper* AddCustomStatic(CUIGameCustom&,char const*,bool);
StaticDrawableWrapper* GetCustomStatic(CUIGameCustom&,char const*);
}
[cpp]
class GameGraph__LEVEL_MAP__value_type
{
custom [class GameGraph::SLevel]& level { get; set; }
unsigned char id { get; set; }
}
[cpp]
class demo_player_info
{
short const get_frags(demo_player_info const&);
unsigned short const get_artefacts(demo_player_info const&);
unsigned char const get_rank(demo_player_info const&);
short const get_deaths(demo_player_info const&);
unsigned char const get_team(demo_player_info const&);
char const* get_name(demo_player_info const&);
short const get_spots(demo_player_info const&);
}
[cpp]
class cse_alife_smart_zone : , cse_alife_space_restrictorcse_alife_schedulable
{
void on_unregister(cse_alife_smart_zone&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_smart_zone const&);
void switch_online(cse_alife_smart_zone&);
cse_abstract* init(cse_alife_smart_zone&);
void update(cse_alife_smart_zone&);
bool interactive(cse_alife_smart_zone const&);
custom [float] suitable(cse_alife_smart_zone const&,cse_alife_monster_abstract*);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_smart_zone&);
custom [float] detect_probability(cse_alife_smart_zone&);
void STATE_Read(cse_alife_smart_zone&,net_packet&,unsigned short);
void on_register(cse_alife_smart_zone&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_smart_zone const&);
unsigned short script_version { get; set; }
char const* section_name(cse_abstract const*);
void unregister_npc(cse_alife_smart_zone&,cse_alife_monster_abstract*);
bool enabled(cse_alife_smart_zone const&,cse_alife_monster_abstract*);
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_smart_zone const&);
void STATE_Write(cse_alife_smart_zone&,net_packet&);
vector& angle { get; set; }
void smart_touch(cse_alife_smart_zone&,cse_alife_monster_abstract*);
void on_spawn(cse_alife_smart_zone&);
bool used_ai_locations(cse_alife_smart_zone const&);
void UPDATE_Write(cse_abstract&,net_packet&);
CALifeSmartTerrainTask* task(cse_alife_smart_zone&,cse_alife_monster_abstract*);
unsigned short m_game_vertex_id { get; set; }
bool can_save(cse_alife_smart_zone const&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_smart_zone&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void register_npc(cse_alife_smart_zone&,cse_alife_monster_abstract*);
char const* name(cse_abstract const*);
unsigned int m_level_vertex_id { get; set; }
}
[cpp]
class planner_action : , action_planneraction_base
{
unsigned short weight(planner_action const&,world_state const&,world_state const&);
void set_weight(action_base&,unsigned short const&);
property_evaluator& evaluator(action_planner&,unsigned int const&);
void initialize(planner_action&);
void setup(planner_action&,game_object*,property_storage*);
bool initialized(action_planner const&);
property_storage& storage { get; set; }
void remove_precondition(action_base&,unsigned int const&);
action_base& action(action_planner&,unsigned int const&);
void update(action_planner&);
void set_goal_world_state(action_planner*,world_state*);
void show(planner_action&,char const*);
void execute(planner_action&);
void finalize(planner_action&);
void add_precondition(action_base&,world_property const&);
void remove_action(action_planner&,unsigned int const&);
bool actual(action_planner const*);
action_base& current_action(action_planner&);
unsigned int current_action_id(action_planner const&);
void remove_effect(action_base&,unsigned int const&);
void add_effect(action_base&,world_property const&);
void add_evaluator(action_planner&,unsigned int const&,property_evaluator*);
void remove_evaluator(action_planner&,unsigned int const&);
void add_action(action_planner&,unsigned int const&,action_base*);
void __init(luabind::argument const&,game_object*,char const*);
void clear(action_planner&);
game_object* object { get; set; }
}
[cpp]
class CALifeHumanBrain : CALifeMonsterBrain
{
CALifeMonsterMovementManager* movement(CALifeMonsterBrain const*);
void update(CALifeMonsterBrain&);
void can_choose_alife_tasks(CALifeMonsterBrain&,bool);
}
[cpp]
class CBlend
{
}
[cpp]
class found_email_cb
{
void bind(found_email_cb&,luabind::object,function<void>);
void clear(found_email_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class COptionsManager
{
void SaveValues(COptionsManager&,char const*);
bool NeedSystemRestart(COptionsManager&);
void __init(luabind::argument const&);
void SendMessage2Group(COptionsManager&,char const*,char const*);
void UndoGroup(COptionsManager&,char const*);
bool NeedVidRestart(COptionsManager&);
void OptionsPostAccept(COptionsManager&);
void SetCurrentValues(COptionsManager&,char const*);
void SaveBackupValues(COptionsManager&,char const*);
}
[cpp]
class CBlackGraviArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class SoundInfo
{
int danger { get; set; }
vector& position { get; set; }
custom [float] power { get; set; }
int time { get; set; }
game_object* who { get; set; }
}
[cpp]
class CUIButton : CUIStatic
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
Frect const* GetTextureRect(CUIStatic&);
void SetStretchTexture(CUIStatic&,bool);
bool IsEnabled(CUIWindow&);
void SetTextureRect(CUIStatic&,Frect*);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void Enable(CUIWindow&,bool);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class cse_alife_schedulable : ipure_schedulable_object
{
}
[cpp]
class CUISleepStatic : CUIStatic
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
Frect const* GetTextureRect(CUIStatic&);
void SetStretchTexture(CUIStatic&,bool);
bool IsEnabled(CUIWindow&);
void SetTextureRect(CUIStatic&,Frect*);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void Enable(CUIWindow&,bool);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CMosquitoBald : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class particle
{
void set_velocity(particle&,vector const&);
void set_angles(particle&,vector const&);
bool completed(particle&);
void __init(luabind::argument const&,char const*,particle_params const&,bool);
void set_bone(particle&,char const*);
void set_particle(particle&,char const*,bool);
void set_position(particle&,vector const&);
}
[cpp]
class ui_events
{
const BUTTON_CLICKED = 17;
const BUTTON_DOWN = 18;
const CHECK_BUTTON_RESET = 21;
const CHECK_BUTTON_SET = 20;
const EDIT_TEXT_COMMIT = 71;
const LIST_ITEM_CLICKED = 35;
const LIST_ITEM_SELECT = 36;
const MAIN_MENU_RELOADED = 76;
const MESSAGE_BOX_CANCEL_CLICKED = 44;
const MESSAGE_BOX_COPY_CLICKED = 45;
const MESSAGE_BOX_NO_CLICKED = 43;
const MESSAGE_BOX_OK_CLICKED = 39;
const MESSAGE_BOX_QUIT_GAME_CLICKED = 42;
const MESSAGE_BOX_QUIT_WIN_CLICKED = 41;
const MESSAGE_BOX_YES_CLICKED = 40;
const PROPERTY_CLICKED = 38;
const RADIOBUTTON_SET = 22;
const SCROLLBAR_HSCROLL = 32;
const SCROLLBAR_VSCROLL = 31;
const SCROLLBOX_MOVE = 30;
const TAB_CHANGED = 19;
const WINDOW_KEYBOARD_CAPTURE_LOST = 14;
const WINDOW_KEY_PRESSED = 10;
const WINDOW_KEY_RELEASED = 11;
const WINDOW_LBUTTON_DB_CLICK = 9;
const WINDOW_LBUTTON_DOWN = 0;
const WINDOW_LBUTTON_UP = 3;
const WINDOW_MOUSE_MOVE = 6;
const WINDOW_RBUTTON_DOWN = 1;
const WINDOW_RBUTTON_UP = 4;
}
[cpp]
class CUILines
{
void SetElipsis(CUILines&,bool);
void SetTextST(CUILines&,char const*);
void SetFont(CUILines&,CGameFont*);
void SetText(CUILines&,char const*);
char const* GetText(CUILines&);
void SetTextColor(CUILines&,unsigned int);
}
[cpp]
class alife_simulator
{
void remove_out_restriction(alife_simulator*,cse_alife_monster_abstract*,unsigned short);
cse_abstract* create_ammo(alife_simulator*,char const*,vector const&,unsigned int,unsigned short,unsigned short,int);
cse_alife_creature_actor* actor(alife_simulator const*);
void switch_distance(alife_simulator&,custom [float]);
unsigned int level_id(alife_simulator*);
bool dont_has_info(alife_simulator const*,unsigned short const&,char const*);
cse_alife_dynamic_object* object(alife_simulator const*,unsigned short,bool);
void set_switch_online(alife_simulator&,unsigned short,bool);
char const* level_name(alife_simulator const*,int);
void add_in_restriction(alife_simulator*,cse_alife_monster_abstract*,unsigned short);
void set_interactive(alife_simulator&,unsigned short,bool);
void set_switch_offline(alife_simulator&,unsigned short,bool);
void remove_all_restrictions(alife_simulator&,unsigned short,custom [enum RestrictionSpace::ERestrictorTypes] const&);
void kill_entity(alife_simulator*,cse_alife_monster_abstract*);
bool has_info(alife_simulator const*,unsigned short const&,char const*);
unsigned short spawn_id(alife_simulator*,unsigned int);
bool valid_object_id(alife_simulator const*,unsigned short);
void add_out_restriction(alife_simulator*,cse_alife_monster_abstract*,unsigned short);
void remove_in_restriction(alife_simulator*,cse_alife_monster_abstract*,unsigned short);
void release(alife_simulator*,cse_abstract*,bool);
cse_alife_dynamic_object* story_object(alife_simulator const*,unsigned int);
cse_abstract* create(alife_simulator*,char const*,vector const&,unsigned int,unsigned short);
}
[cpp]
class profile
{
char const* unique_nick(profile const&);
bool const online(profile const&);
}
[cpp]
class cse_alife_object_physic : , cse_alife_dynamic_object_visualcse_ph_skeleton
{
void on_unregister(cse_alife_object_physic&);
void use_ai_locations(cse_alife_object&,bool);
void UPDATE_Write(cse_abstract&,net_packet&);
bool can_switch_offline(cse_alife_object_physic const&);
void switch_online(cse_alife_object_physic&);
cse_abstract* init(cse_alife_object_physic&);
void set_yaw(cse_alife_object_physic*,custom [float]);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_object_physic&);
void STATE_Read(cse_alife_object_physic&,net_packet&,unsigned short);
void on_register(cse_alife_object_physic&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_object_physic const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_object_physic const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_object_physic&);
void STATE_Write(cse_alife_object_physic&,net_packet&);
bool can_save(cse_alife_object_physic const&);
bool used_ai_locations(cse_alife_object_physic const&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_object_physic&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_object_physic const&);
char const* name(cse_abstract const*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class hanging_lamp : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void turn_on(hanging_lamp&);
void turn_off(hanging_lamp&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CStalkerOutfit : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class FileStatus
{
bool Exists { get; set; }
bool External { get; set; }
}
[cpp]
class cse_alife_psydog_phantom : cse_alife_monster_base
{
void on_unregister(cse_alife_psydog_phantom&);
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_monster_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_psydog_phantom const&);
void switch_online(cse_alife_psydog_phantom&);
unsigned char group { get; set; }
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
void update(cse_alife_psydog_phantom&);
bool interactive(cse_alife_psydog_phantom const&);
unsigned char team { get; set; }
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
cse_abstract* init(cse_alife_psydog_phantom&);
void switch_offline(cse_alife_psydog_phantom&);
unsigned int m_level_vertex_id { get; set; }
void smart_terrain_task_activate(cse_alife_monster_abstract*);
void STATE_Read(cse_alife_psydog_phantom&,net_packet&,unsigned short);
void on_register(cse_alife_psydog_phantom&);
unsigned char g_group(cse_alife_psydog_phantom&);
void on_before_register(cse_alife_psydog_phantom&);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_psydog_phantom&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
void STATE_Write(cse_alife_psydog_phantom&,net_packet&);
unsigned short m_game_vertex_id { get; set; }
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
ini_file* spawn_ini(cse_abstract*);
bool keep_saved_data_anyway(cse_alife_psydog_phantom const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
void use_ai_locations(cse_alife_object&,bool);
bool alive(cse_alife_creature_abstract const&);
vector& position { get; set; }
void move_offline(cse_alife_object&,bool);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_psydog_phantom&);
bool can_switch_online(cse_alife_psydog_phantom const&);
char const* section_name(cse_abstract const*);
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_psydog_phantom&);
CALifeMonsterBrain* brain(cse_alife_monster_abstract*);
bool has_detector(cse_alife_monster_abstract&);
void UPDATE_Write(cse_abstract&,net_packet&);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
bool can_save(cse_alife_psydog_phantom const&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void on_death(cse_alife_psydog_phantom&,cse_abstract*);
char const* name(cse_abstract const*);
bool used_ai_locations(cse_alife_psydog_phantom const&);
}
[cpp]
class CZombie : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUITabControl : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void RemoveAll(CUITabControl&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
bool AddItem(CUITabControl&,char const*,char const*,vector2,vector2);
void SetWndRect(CUIWindow&,Frect);
void SetPPMode(CUIWindow&);
void SetActiveTab(CUITabControl&,char const*);
bool IsEnabled(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
CUITabButton* GetButtonById(CUITabControl&,char const*);
char const* GetActiveId(CUITabControl&);
unsigned int const GetTabsCount(CUITabControl const&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CWeaponGroza : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class move
{
const back = 4;
const criteria = 2;
const crouch = 0;
const curve = 0;
const curve_criteria = 2;
const default = 0;
const dodge = 1;
const down = 64;
const drag = 3;
const force = 1;
const fwd = 2;
const handbrake = 128;
const jump = 4;
const left = 8;
const line = 0;
const none = 1;
const off = 512;
const on = 256;
const right = 16;
const run = 1;
const run_fwd = 2;
const run_with_leader = 7;
const stand = 2;
const standing = 1;
const steal = 5;
const up = 32;
const walk = 0;
const walk_bkwd = 1;
const walk_fwd = 0;
const walk_with_leader = 6;
void input(move&,custom [enum CScriptMovementAction::EInputKeys]);
void position(move&,vector const&);
void patrol(move&,custom [class CPatrolPath] const*,custom [class shared_str]);
void __init(luabind::argument const&,custom [enum MonsterSpace::EScriptMonsterMoveAction],game_object*,custom [float],custom [enum MonsterSpace::EScriptMonsterSpeedParam]);
void move(move&,custom [enum MonsterSpace::EMovementType]);
bool completed(move&);
void body(move&,custom [enum MonsterSpace::EBodyState]);
void object(move&,game_object*);
void path(move&,custom [enum DetailPathManager::EDetailPathType]);
}
[cpp]
class cse_alife_group_abstract
{
}
[cpp]
class profile_timer
{
void stop(profile_timer&);
void __tostring(lua_State*,profile_timer&);
void __init(luabind::argument const&,profile_timer&);
void __add(lua_State*,profile_timer const&,profile_timer);
custom [float] time(profile_timer const&);
void start(profile_timer&);
void __lt(lua_State*,profile_timer const&,profile_timer);
}
[cpp]
class CSpaceRestrictor : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class anim
{
const attack = 7;
const capture_prepare = 1;
const danger = 0;
const eat = 4;
const free = 1;
const lie_idle = 3;
const look_around = 8;
const panic = 2;
const rest = 6;
const sit_idle = 2;
const sleep = 5;
const stand_idle = 0;
const turn = 9;
void type(anim&,custom [enum MonsterSpace::EMentalState]);
bool completed(anim&);
void anim(anim&,char const*);
void __init(luabind::argument const&,custom [enum MonsterSpace::EScriptMonsterAnimAction],int);
}
[cpp]
class reader
{
void r_vec3(reader*,vector*);
custom [float] r_float_q16(reader&,custom [float],custom [float]);
void r_advance(reader&,int);
void r_sdir(reader&,vector&);
void r_seek(reader&,int);
short r_s16(reader&);
custom [float] r_angle8(reader&);
custom [float] r_float_q8(reader&,custom [float],custom [float]);
unsigned int r_u32(reader&);
bool r_bool(reader*);
custom [float] r_angle16(reader&);
int r_tell(reader const&);
bool r_eof(reader*);
custom [unsigned __int64] r_u64(reader&);
int r_s32(reader&);
void r_dir(reader&,vector&);
custom [__int64] r_s64(reader&);
custom [float] r_float(reader&);
unsigned short r_u16(reader&);
unsigned char r_u8(reader&);
int r_elapsed(reader const&);
custom [signed char] r_s8(reader&);
char const* r_stringZ(reader*);
}
[cpp]
class login_manager
{
void logout(login_manager&);
void stop_login(login_manager&);
void forgot_password(login_manager&,char const*);
void login(login_manager&,char const*,char const*,char const*,login_operation_cb);
void save_nick_to_registry(login_manager&,char const*);
char const* get_email_from_registry(login_manager&);
void save_email_to_registry(login_manager&,char const*);
void save_remember_me_to_registry(login_manager&,bool);
bool get_remember_me_from_registry(login_manager&);
void save_password_to_registry(login_manager&,char const*);
char const* get_nick_from_registry(login_manager&);
char const* get_password_from_registry(login_manager&);
void login_offline(login_manager&,char const*,login_operation_cb);
profile const* get_current_profile(login_manager const&);
void stop_setting_unique_nick(login_manager&);
void set_unique_nick(login_manager&,char const*,login_operation_cb);
}
[cpp]
class login_operation_cb
{
void bind(login_operation_cb&,luabind::object,function<void>);
void clear(login_operation_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class CThornArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CPhraseScript
{
void AddAction(CPhraseScript&,char const*);
void AddGiveInfo(CPhraseScript&,char const*);
void AddDontHasInfo(CPhraseScript&,char const*);
void SetScriptText(CPhraseScript&,char const*);
void AddDisableInfo(CPhraseScript&,char const*);
void AddPrecondition(CPhraseScript&,char const*);
void AddHasInfo(CPhraseScript&,char const*);
}
[cpp]
class CBurer : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CAntirad : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CFoodItem : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CWeaponHPSA : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class phcondition_callonstep
{
void set_global_time_ms(phcondition_callonstep&,unsigned int);
void set_time_interval_ms(phcondition_callonstep&,unsigned int);
void set_step(phcondition_callonstep&,custom [unsigned __int64]);
void set_global_time_s(phcondition_callonstep&,custom [float]);
void set_time_interval_s(phcondition_callonstep&,custom [float]);
void set_steps_interval(phcondition_callonstep&,custom [unsigned __int64]);
void __init(luabind::argument const&);
}
[cpp]
class CZudaArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class key_bindings
{
const kACCEL = 6;
const kBACK = 9;
const kBUY = 48;
const kCAM_1 = 14;
const kCAM_2 = 15;
const kCAM_3 = 16;
const kCAM_ZOOM_IN = 17;
const kCAM_ZOOM_OUT = 18;
const kCHAT = 42;
const kCONSOLE = 46;
const kCROUCH = 5;
const kDOWN = 3;
const kDROP = 39;
const kFWD = 8;
const kINVENTORY = 47;
const kJUMP = 4;
const kLEFT = 0;
const kL_LOOKOUT = 12;
const kL_STRAFE = 10;
const kNIGHT_VISION = 20;
const kQUIT = 45;
const kRIGHT = 1;
const kR_LOOKOUT = 13;
const kR_STRAFE = 11;
const kSCORES = 41;
const kSCREENSHOT = 44;
const kSKIN = 49;
const kTEAM = 50;
const kTORCH = 19;
const kUP = 2;
const kUSE = 40;
const kWPN_1 = 22;
const kWPN_2 = 23;
const kWPN_3 = 24;
const kWPN_4 = 25;
const kWPN_5 = 26;
const kWPN_6 = 27;
const kWPN_FIRE = 30;
const kWPN_FUNC = 35;
const kWPN_NEXT = 29;
const kWPN_RELOAD = 34;
const kWPN_ZOOM = 31;
}
[cpp]
class CUICustomSpin : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* GetText(CUICustomSpin&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
char const* WindowName(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class cse_alife_creature_phantom : cse_alife_creature_abstract
{
void on_unregister(cse_alife_creature_phantom&);
custom [float] health(cse_alife_creature_abstract const&);
void use_ai_locations(cse_alife_object&,bool);
unsigned char g_group(cse_alife_creature_phantom&);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_creature_phantom const&);
void switch_online(cse_alife_creature_phantom&);
unsigned char team { get; set; }
bool used_ai_locations(cse_alife_creature_phantom const&);
bool interactive(cse_alife_creature_phantom const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_creature_phantom&);
void on_death(cse_alife_creature_phantom&,cse_abstract*);
bool alive(cse_alife_creature_abstract const&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned char squad { get; set; }
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
bool keep_saved_data_anyway(cse_alife_creature_phantom const&);
unsigned short script_version { get; set; }
unsigned int m_level_vertex_id { get; set; }
void STATE_Read(cse_alife_creature_phantom&,net_packet&,unsigned short);
unsigned char group { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_creature_phantom&);
bool can_switch_online(cse_alife_creature_phantom const&);
unsigned char g_squad(cse_alife_creature_phantom&);
vector& angle { get; set; }
void STATE_Write(cse_alife_creature_phantom&,net_packet&);
void on_spawn(cse_alife_creature_phantom&);
bool can_save(cse_alife_creature_phantom const&);
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_creature_phantom&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void on_register(cse_alife_creature_phantom&);
char const* name(cse_abstract const*);
cse_abstract* init(cse_alife_creature_phantom&);
}
[cpp]
class particle_params
{
void __init(luabind::argument const&,vector const&,vector const&,vector const&);
}
[cpp]
class physics_element
{
custom [float] get_mass(physics_element&);
void release_fixed(physics_element&);
void get_linear_vel(physics_element const&,vector&);
matrix global_transform(physics_element*);
bool is_fixed(physics_element&);
bool is_breakable(physics_element&);
void apply_force(physics_element&,custom [float],custom [float],custom [float]);
void get_angular_vel(physics_element const&,vector&);
void fix(physics_element&);
custom [float] get_density(physics_element&);
custom [float] get_volume(physics_element&);
}
[cpp]
class cse_alife_level_changer : cse_alife_space_restrictor
{
void on_unregister(cse_alife_level_changer&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_level_changer const&);
void switch_online(cse_alife_level_changer&);
cse_abstract* init(cse_alife_level_changer&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_level_changer&);
void STATE_Read(cse_alife_level_changer&,net_packet&,unsigned short);
void on_register(cse_alife_level_changer&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_level_changer const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_level_changer const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_level_changer&);
bool can_save(cse_alife_level_changer const&);
bool used_ai_locations(cse_alife_level_changer const&);
void STATE_Write(cse_alife_level_changer&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_level_changer&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_level_changer const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class account_manager
{
void stop_searching_email(account_manager&);
custom [class xr_vector<char const *,class xalloc<char const *> >] const& get_suggested_unicks(account_manager const&);
void delete_profile(account_manager&,account_operation_cb);
void create_profile(account_manager&,char const*,char const*,char const*,char const*,account_operation_cb);
bool is_get_account_profiles_active(account_manager const&);
void suggest_unique_nicks(account_manager&,char const*,suggest_nicks_cb);
bool verify_email(account_manager&,char const*);
bool verify_password(account_manager&,char const*);
void stop_suggest_unique_nicks(account_manager&);
bool is_email_searching_active(account_manager const&);
void stop_fetching_account_profiles(account_manager&);
void get_account_profiles(account_manager&,char const*,char const*,account_profiles_cb);
char const* get_verify_error_descr(account_manager const&);
bool verify_unique_nick(account_manager&,char const*);
custom [class xr_vector<char const *,class xalloc<char const *> >] const& get_found_profiles(account_manager const&);
void search_for_email(account_manager&,char const*,found_email_cb);
}
[cpp]
class CHelmet : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CALifeMonsterPatrolPathManager
{
bool actual(CALifeMonsterPatrolPathManager const&);
unsigned short const& target_game_vertex_id(CALifeMonsterPatrolPathManager const&);
vector target_position(CALifeMonsterPatrolPathManager*);
void path(CALifeMonsterPatrolPathManager&,char const*);
unsigned int const& target_level_vertex_id(CALifeMonsterPatrolPathManager const&);
bool use_randomness(CALifeMonsterPatrolPathManager const&);
void start_vertex_index(CALifeMonsterPatrolPathManager&,unsigned int const&);
bool completed(CALifeMonsterPatrolPathManager const&);
custom [enum PatrolPathManager::EPatrolStartType] const& start_type(CALifeMonsterPatrolPathManager const&);
custom [enum PatrolPathManager::EPatrolRouteType] const& route_type(CALifeMonsterPatrolPathManager const&);
}
[cpp]
class account_profiles_cb
{
void bind(account_profiles_cb&,luabind::object,function<void>);
void clear(account_profiles_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class cse_alife_item_bolt : cse_alife_item
{
void on_unregister(cse_alife_item_bolt&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_item_bolt const&);
void switch_online(cse_alife_item_bolt&);
cse_abstract* init(cse_alife_item_bolt&);
bool interactive(cse_alife_item_bolt const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_bolt&);
void STATE_Read(cse_alife_item_bolt&,net_packet&,unsigned short);
void on_register(cse_alife_item_bolt&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_item_bolt const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_bolt const&);
vector& angle { get; set; }
void on_spawn(cse_alife_item_bolt&);
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void STATE_Write(cse_alife_item_bolt&,net_packet&);
bool can_save(cse_alife_item_bolt const&);
bool used_ai_locations(cse_alife_item_bolt const&);
bool bfUseful(cse_alife_item_bolt&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_bolt&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
unsigned int m_level_vertex_id { get; set; }
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class particles_object
{
void stop(particles_object&);
bool looped(particles_object const&);
void move_to(particles_object&,vector const&,vector const&);
void __init(luabind::argument const&,char const*);
void play_at_pos(particles_object&,vector const&);
void pause_path(particles_object&,bool);
void stop_path(particles_object&);
void start_path(particles_object&,bool);
bool playing(particles_object const&);
void play(particles_object&);
void load_path(particles_object&,char const*);
void stop_deffered(particles_object&);
}
[cpp]
class CWeaponVintorez : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CArtefact : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getVisible(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
int net_Spawn(CGameObject&,cse_abstract*);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
void SwitchVisibility(CArtefact&,bool);
IRender_Visual* Visual(CGameObject const&);
}
[cpp]
class CAI_Dog : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CDestroyablePhysicsObject : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class effector
{
bool process(effector&,effector_params*);
void finish(effector*);
void start(effector*);
void __init(luabind::argument const&,int,custom [float]);
}
[cpp]
class CServerList : CUIWindow
{
const ece_unique_nick_expired = 2;
const ece_unique_nick_not_registred = 1;
void AttachChild(CUIWindow&,CUIWindow*);
void ShowServerInfo(CServerList&);
void ConnectToSelected(CServerList&);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void RefreshQuick(CServerList&);
void SetWindowName(CUIWindow&,char const*);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
bool IsAutoDelete(CUIWindow&);
void SetConnectionErrCb(CServerList&,connect_error_cb);
void SetSortFunc(CServerList&,char const*,bool);
void SetFilters(CServerList&,SServerFilters&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void RefreshList(CServerList&,bool);
void NetRadioChanged(CServerList&,bool);
void SetPlayerName(CServerList&,char const*);
void SetPPMode(CUIWindow&);
bool IsEnabled(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetAutoDelete(CUIWindow&,bool);
void DetachChild(CUIWindow&,CUIWindow*);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CWeaponFN2000 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class phcondition_expireonstep : phcondition_callonstep
{
void set_global_time_ms(phcondition_callonstep&,unsigned int);
void set_time_interval_ms(phcondition_callonstep&,unsigned int);
void set_step(phcondition_callonstep&,custom [unsigned __int64]);
void set_global_time_s(phcondition_callonstep&,custom [float]);
void set_time_interval_s(phcondition_callonstep&,custom [float]);
void set_steps_interval(phcondition_callonstep&,custom [unsigned __int64]);
void __init(luabind::argument const&);
}
[cpp]
class MonsterSpace
{
const head_anim_angry = 1;
const head_anim_glad = 2;
const head_anim_kind = 3;
const head_anim_normal = 0;
const sound_script = 128;
}
[cpp]
class cse_alife_monster_abstract : , cse_alife_creature_abstractcse_alife_schedulable
{
void on_unregister(cse_alife_monster_abstract&);
custom [float] health(cse_alife_creature_abstract const&);
int rank(cse_alife_monster_abstract&);
void current_level_travel_speed(cse_alife_monster_abstract*,custom [float]);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_monster_abstract const&);
void switch_online(cse_alife_monster_abstract&);
unsigned char team { get; set; }
cse_abstract* init(cse_alife_monster_abstract&);
void update(cse_alife_monster_abstract&);
bool interactive(cse_alife_monster_abstract const&);
unsigned int m_level_vertex_id { get; set; }
unsigned short group_id { get; set; }
unsigned int m_story_id { get; set; }
void on_death(cse_alife_monster_abstract&,cse_abstract*);
void switch_offline(cse_alife_monster_abstract&);
unsigned char group { get; set; }
void smart_terrain_task_activate(cse_alife_monster_abstract*);
void on_before_register(cse_alife_monster_abstract&);
void on_register(cse_alife_monster_abstract&);
void STATE_Write(cse_alife_monster_abstract&,net_packet&);
bool used_ai_locations(cse_alife_monster_abstract const&);
int clsid(cse_abstract const&);
unsigned char g_squad(cse_alife_monster_abstract&);
unsigned char squad { get; set; }
unsigned short m_smart_terrain_id { get; set; }
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
unsigned short smart_terrain_id(cse_alife_monster_abstract*);
unsigned short id { get; set; }
rotation* o_torso(cse_alife_creature_abstract*);
void UPDATE_Write(cse_abstract&,net_packet&);
bool keep_saved_data_anyway(cse_alife_monster_abstract const&);
unsigned short script_version { get; set; }
void travel_speed(cse_alife_monster_abstract*,custom [float]);
void use_ai_locations(cse_alife_object&,bool);
bool alive(cse_alife_creature_abstract const&);
char const* section_name(cse_abstract const*);
void move_offline(cse_alife_object&,bool);
void UPDATE_Read(cse_abstract&,net_packet&);
unsigned char g_team(cse_alife_monster_abstract&);
bool can_switch_online(cse_alife_monster_abstract const&);
vector& position { get; set; }
vector& angle { get; set; }
void smart_terrain_task_deactivate(cse_alife_monster_abstract*);
void on_spawn(cse_alife_monster_abstract&);
CALifeMonsterBrain* brain(cse_alife_monster_abstract*);
bool has_detector(cse_alife_monster_abstract&);
void force_set_goodwill(cse_alife_monster_abstract*,int,unsigned short);
void kill(cse_alife_monster_abstract&);
void clear_smart_terrain(cse_alife_monster_abstract*);
unsigned short parent_id { get; set; }
bool can_save(cse_alife_monster_abstract const&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void STATE_Read(cse_alife_monster_abstract&,net_packet&,unsigned short);
char const* name(cse_abstract const*);
unsigned char g_group(cse_alife_monster_abstract&);
}
[cpp]
class CMincer : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CScope : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUIMessageBoxEx : CUIDialogWnd
{
void AttachChild(CUIWindow&,CUIWindow*);
CDialogHolder* GetHolder(CUIDialogWnd&);
char const* GetPassword(CUIMessageBoxEx&);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
void ShowDialog(CUIDialogWnd&,bool);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
void SetText(CUIMessageBoxEx&,char const*);
void SetWindowName(CUIWindow&,char const*);
char const* GetHost(CUIMessageBoxEx&);
char const* WindowName(CUIWindow&);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsShown(CUIWindow&);
void SetPPMode(CUIWindow&);
bool IsEnabled(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void InitMessageBox(CUIMessageBoxEx&,char const*);
void Enable(CUIWindow&,bool);
void HideDialog(CUIDialogWnd&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class cse_alife_inventory_item
{
}
[cpp]
class CBlackDrops : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_mounted_weapon : cse_alife_dynamic_object_visual
{
void on_unregister(cse_alife_mounted_weapon&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_mounted_weapon const&);
void switch_online(cse_alife_mounted_weapon&);
cse_abstract* init(cse_alife_mounted_weapon&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_mounted_weapon&);
void STATE_Read(cse_alife_mounted_weapon&,net_packet&,unsigned short);
void on_register(cse_alife_mounted_weapon&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_mounted_weapon const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_mounted_weapon const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_mounted_weapon&);
bool can_save(cse_alife_mounted_weapon const&);
bool used_ai_locations(cse_alife_mounted_weapon const&);
void STATE_Write(cse_alife_mounted_weapon&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_mounted_weapon&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_mounted_weapon const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class cse_alife_car : , cse_alife_dynamic_object_visualcse_ph_skeleton
{
void on_unregister(cse_alife_car&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_car const&);
void switch_online(cse_alife_car&);
cse_abstract* init(cse_alife_car&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_car&);
void STATE_Read(cse_alife_car&,net_packet&,unsigned short);
void on_register(cse_alife_car&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_car const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_car const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_car&);
bool can_save(cse_alife_car const&);
bool used_ai_locations(cse_alife_car const&);
void STATE_Write(cse_alife_car&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_car&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_car const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class CAI_Crow : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_alife_space_restrictor : , cse_alife_dynamic_objectcse_shape
{
void on_unregister(cse_alife_space_restrictor&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_space_restrictor const&);
void switch_online(cse_alife_space_restrictor&);
cse_abstract* init(cse_alife_space_restrictor&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_space_restrictor&);
void STATE_Read(cse_alife_space_restrictor&,net_packet&,unsigned short);
void on_register(cse_alife_space_restrictor&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_space_restrictor const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_space_restrictor const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void on_spawn(cse_alife_space_restrictor&);
bool can_save(cse_alife_space_restrictor const&);
bool used_ai_locations(cse_alife_space_restrictor const&);
void STATE_Write(cse_alife_space_restrictor&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_space_restrictor&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_space_restrictor const&);
char const* name(cse_abstract const*);
char const* section_name(cse_abstract const*);
}
[cpp]
class CGameGraph
{
custom [class AssociativeVector<unsigned char,class GameGraph::SLevel,struct std::less<unsigned char> >] const& levels(CGameGraph const*);
void accessible(CGameGraph const*,unsigned int const&,bool);
GameGraph__CVertex const* vertex(CGameGraph const&,unsigned int);
bool valid_vertex_id(CGameGraph const&,unsigned int);
unsigned short vertex_id(CGameGraph const&,GameGraph__CVertex const*);
}
[cpp]
class client_spawn_manager
{
void remove(client_spawn_manager&,unsigned short,unsigned short);
void add(client_spawn_manager&,unsigned short,unsigned short,function<void> const&);
}
[cpp]
class hit
{
const burn = 0;
const chemical_burn = 2;
const dummy = 11;
const explosion = 8;
const fire_wound = 6;
const light_burn = 10;
const radiation = 3;
const shock = 1;
const strike = 7;
const telepatic = 4;
const wound = 5;
game_object* draftsman { get; set; }
void bone(hit&,char const*);
custom [float] power { get; set; }
int type { get; set; }
vector& direction { get; set; }
custom [float] impulse { get; set; }
void __init(luabind::argument const&,hit const*);
}
[cpp]
class cover_point
{
bool is_smart_cover(cover_point const*);
vector const& position(cover_point const&);
unsigned int level_vertex_id(cover_point const&);
}
[cpp]
class CUIScrollView : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void ScrollToEnd(CUIScrollView&);
custom [float] GetHeight(CUIWindow const&);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void ScrollToBegin(CUIScrollView&);
void SetWindowName(CUIWindow&,char const*);
void Enable(CUIWindow&,bool);
int GetCurrentScrollPos(CUIScrollView&);
void SetWndSize(CUIWindow&,vector2);
void DetachChild(CUIWindow&,CUIWindow*);
void RemoveWindow(CUIScrollView&,CUIWindow*);
bool IsAutoDelete(CUIWindow&);
int GetMinScrollPos(CUIScrollView&);
void SetWndPos(CUIWindow&,vector2);
void ResetPPMode(CUIWindow&);
void SetPPMode(CUIWindow&);
void SetScrollPos(CUIScrollView&,int);
bool IsEnabled(CUIWindow&);
int GetMaxScrollPos(CUIScrollView&);
void SetWndRect(CUIWindow&,Frect);
void AddWindow(CUIScrollView&,CUIWindow*,bool);
void SetAutoDelete(CUIWindow&,bool);
void Clear(CUIScrollView&);
}
[cpp]
class cse_smart_cover : cse_alife_dynamic_object
{
void on_unregister(cse_smart_cover&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_smart_cover const&);
void switch_online(cse_smart_cover&);
cse_abstract* init(cse_smart_cover&);
char const* description(cse_smart_cover const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_smart_cover&);
void STATE_Read(cse_smart_cover&,net_packet&,unsigned short);
void on_register(cse_smart_cover&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_smart_cover const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_smart_cover const&);
void UPDATE_Write(cse_abstract&,net_packet&);
vector& angle { get; set; }
void on_spawn(cse_smart_cover&);
unsigned short m_game_vertex_id { get; set; }
ini_file* spawn_ini(cse_abstract*);
void set_available_loopholes(cse_smart_cover&,luabind::object);
bool can_save(cse_smart_cover const&);
bool used_ai_locations(cse_smart_cover const&);
void STATE_Write(cse_smart_cover&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_smart_cover&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_smart_cover const&);
char const* name(cse_abstract const*);
unsigned int m_level_vertex_id { get; set; }
}
[cpp]
class CGraviArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class fcolor
{
custom [float] b { get; set; }
fcolor& set(fcolor&,unsigned int);
custom [float] r { get; set; }
void __init(luabind::argument const&);
custom [float] a { get; set; }
custom [float] g { get; set; }
}
[cpp]
class iserializable
{
}
[cpp]
class matrix
{
vector& i { get; set; }
vector& c { get; set; }
void __init(luabind::argument const&);
vector& k { get; set; }
custom [float] _44_ { get; set; }
vector& j { get; set; }
custom [float] _24_ { get; set; }
matrix& setXYZ(matrix&,custom [float],custom [float],custom [float]);
matrix& identity(matrix&);
custom [float] _34_ { get; set; }
matrix& set(matrix&,vector const&,vector const&,vector const&,vector const&);
matrix& setXYZi(matrix&,custom [float],custom [float],custom [float]);
matrix& mk_xform(matrix&,custom [struct _quaternion<float>] const&,vector const&);
matrix& mul(matrix&,custom [float]);
custom [float] _14_ { get; set; }
matrix& div(matrix&,custom [float]);
void getHPB(matrix*,custom [float]*,custom [float]*,custom [float]*);
matrix& setHPB(matrix&,custom [float],custom [float],custom [float]);
}
[cpp]
class cse_alife_object_hanging_lamp : , cse_alife_dynamic_object_visualcse_ph_skeleton
{
void on_unregister(cse_alife_object_hanging_lamp&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_alife_object_hanging_lamp const&);
void switch_online(cse_alife_object_hanging_lamp&);
cse_abstract* init(cse_alife_object_hanging_lamp&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_object_hanging_lamp&);
void STATE_Read(cse_alife_object_hanging_lamp&,net_packet&,unsigned short);
void on_register(cse_alife_object_hanging_lamp&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_alife_object_hanging_lamp const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
ini_file* spawn_ini(cse_abstract*);
bool can_switch_online(cse_alife_object_hanging_lamp const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
char const* section_name(cse_abstract const*);
void on_spawn(cse_alife_object_hanging_lamp&);
bool can_save(cse_alife_object_hanging_lamp const&);
bool used_ai_locations(cse_alife_object_hanging_lamp const&);
void STATE_Write(cse_alife_object_hanging_lamp&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_object_hanging_lamp&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_alife_object_hanging_lamp const&);
char const* name(cse_abstract const*);
void UPDATE_Write(cse_abstract&,net_packet&);
}
[cpp]
class CPseudoGigant : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class property_storage
{
void set_property(property_storage&,unsigned int const&,bool const&);
bool const& property(property_storage const&,unsigned int const&);
void __init(luabind::argument const&);
}
[cpp]
class cse_motion
{
}
[cpp]
class CDummyArtefact : CArtefact
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
unsigned char GetAfRank(CArtefact const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
IRender_Visual* Visual(CGameObject const&);
void FollowByPath(CArtefact&,char const*,int,vector);
void SwitchVisibility(CArtefact&,bool);
DLL_Pure* _construct(CGameObject&);
int getEnabled(CGameObject const&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class connect_error_cb
{
void bind(connect_error_cb&,luabind::object,function<void>);
void clear(connect_error_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class CSilencer : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class spawn_story_ids
{
const INVALID_SPAWN_STORY_ID = -1;
}
[cpp]
class IRenderable
{
}
[cpp]
class cse_alife_item_weapon_shotgun : cse_alife_item_weapon
{
void on_unregister(cse_alife_item_weapon_shotgun&);
void use_ai_locations(cse_alife_object&,bool);
void UPDATE_Write(cse_abstract&,net_packet&);
bool can_switch_offline(cse_alife_item_weapon_shotgun const&);
void switch_online(cse_alife_item_weapon_shotgun&);
cse_abstract* init(cse_alife_item_weapon_shotgun&);
bool interactive(cse_alife_item_weapon_shotgun const&);
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_alife_item_weapon_shotgun&);
void STATE_Read(cse_alife_item_weapon_shotgun&,net_packet&,unsigned short);
void on_register(cse_alife_item_weapon_shotgun&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
void clone_addons(cse_alife_item_weapon&,cse_alife_item_weapon*);
bool keep_saved_data_anyway(cse_alife_item_weapon_shotgun const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_alife_item_weapon_shotgun const&);
vector& angle { get; set; }
ini_file* spawn_ini(cse_abstract*);
unsigned short m_game_vertex_id { get; set; }
void on_spawn(cse_alife_item_weapon_shotgun&);
unsigned int m_level_vertex_id { get; set; }
bool used_ai_locations(cse_alife_item_weapon_shotgun const&);
bool can_save(cse_alife_item_weapon_shotgun const&);
bool bfUseful(cse_alife_item_weapon_shotgun&);
unsigned short parent_id { get; set; }
void on_before_register(cse_alife_item_weapon_shotgun&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
void STATE_Write(cse_alife_item_weapon_shotgun&,net_packet&);
char const* name(cse_abstract const*);
void __init(luabind::argument const&,char const*);
}
[cpp]
class CUIFrameLineWnd : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void SetWidth(CUIFrameLineWnd&,custom [float]);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
void SetHeight(CUIFrameLineWnd&,custom [float]);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void SetColor(CUIFrameLineWnd&,unsigned int);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void DetachChild(CUIWindow&,CUIWindow*);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void SetWndRect(CUIWindow&,Frect);
void SetPPMode(CUIWindow&);
custom [float] GetWidth(CUIWindow const&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class physics_shell
{
physics_joint* get_joint_by_bone_name(physics_shell&,char const*);
physics_element* get_element_by_bone_id(physics_shell&,unsigned short);
physics_joint* get_joint_by_bone_id(physics_shell&,unsigned short);
physics_element* get_element_by_bone_name(physics_shell&,char const*);
physics_joint* get_joint_by_order(physics_shell&,unsigned short);
void block_breaking(physics_shell&);
void get_linear_vel(physics_shell const&,vector&);
bool is_breakable(physics_shell&);
bool is_breaking_blocked(physics_shell&);
void apply_force(physics_shell&,custom [float],custom [float],custom [float]);
void unblock_breaking(physics_shell&);
void get_angular_vel(physics_shell const&,vector&);
unsigned short get_joints_number(physics_shell&);
unsigned short get_elements_number(physics_shell&);
physics_element* get_element_by_order(physics_shell&,unsigned short);
}
[cpp]
class snd_type
{
const ambient = 128;
const anomaly = 268435456;
const anomaly_idle = 268437504;
const attack = 8192;
const bullet_hit = 524288;
const die = 131072;
const drop = 33554432;
const eat = 4096;
const empty = 1048576;
const hide = 16777216;
const idle = 2048;
const injure = 65536;
const item = 1073741824;
const item_drop = 1107296256;
const item_hide = 1090519040;
const item_pick_up = 1140850688;
const item_take = 1082130432;
const item_use = 1077936128;
const monster = 536870912;
const monster_attack = 536879104;
const monster_die = 537001984;
const monster_eat = 536875008;
const monster_injure = 536936448;
const monster_step = 536903680;
const monster_talk = 536887296;
const no_sound = 0;
const object_break = 1024;
const object_collide = 512;
const object_explode = 256;
const pick_up = 67108864;
const reload = 262144;
const shoot = 2097152;
const step = 32768;
const take = 8388608;
const talk = 16384;
const use = 4194304;
const weapon = -2147483648;
const weapon_bullet_hit = -2146959360;
const weapon_empty = -2146435072;
const weapon_reload = -2147221504;
const weapon_shoot = -2145386496;
const world = 134217728;
const world_ambient = 134217856;
const world_object_break = 134218752;
const world_object_collide = 134218240;
const world_object_explode = 134217984;
}
[cpp]
class CExplosiveItem : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class object_binder
{
game_object* object { get; set; }
void net_destroy(object_binder&);
void reinit(object_binder&);
bool net_save_relevant(object_binder&);
void net_export(object_binder&,net_packet*);
void __init(luabind::argument const&,game_object*);
void net_Relcase(object_binder&,game_object*);
void load(object_binder&,reader*);
void reload(object_binder&,char const*);
void save(object_binder&,net_packet*);
bool net_spawn(object_binder&,cse_alife_object*);
void update(object_binder&,unsigned int);
void net_import(object_binder&,net_packet*);
}
[cpp]
class CWeaponLR300 : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class memory_info : visible_memory_object
{
game_object* object(game_memory_object const&);
custom [struct MemorySpace::CObjectParams<class CGameObject>]& self_info { get; set; }
bool hit_info { get; set; }
bool visual_info { get; set; }
unsigned int last_level_time { get; set; }
bool sound_info { get; set; }
custom [struct MemorySpace::CObjectParams<class CGameObject>]& object_info { get; set; }
unsigned int level_time { get; set; }
}
[cpp]
class CHairsZone : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUIDialogWnd : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
CDialogHolder* GetHolder(CUIDialogWnd&);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
void ShowDialog(CUIDialogWnd&,bool);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsShown(CUIWindow&);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void SetWndRect(CUIWindow&,Frect);
void SetPPMode(CUIWindow&);
void HideDialog(CUIDialogWnd&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class object_params
{
unsigned int level_vertex { get; set; }
vector& position { get; set; }
}
[cpp]
class effector_params
{
noise& noise { get; set; }
custom [float] gray { get; set; }
color& color_gray { get; set; }
void __init(luabind::argument const&);
color& color_add { get; set; }
custom [float] blur { get; set; }
duality& dual { get; set; }
color& color_base { get; set; }
void assign(effector_params*,effector_params*);
}
[cpp]
class CUIMessageBox : CUIStatic
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
char const* GetPassword(CUIMessageBox&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
void SetText(CUIMessageBox&,char const*);
void SetWindowName(CUIWindow&,char const*);
char const* GetHost(CUIMessageBox&);
Frect const* GetTextureRect(CUIStatic&);
void SetStretchTexture(CUIStatic&,bool);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetTextureRect(CUIStatic&,Frect*);
void SetWndRect(CUIWindow&,Frect);
bool IsEnabled(CUIWindow&);
void SetPPMode(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void InitMessageBox(CUIMessageBox&,char const*);
void Enable(CUIWindow&,bool);
char const* WindowName(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class CWeaponAutomaticShotgun : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class CUISpinFlt : CUICustomSpin
{
void AttachChild(CUIWindow&,CUIWindow*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* GetText(CUICustomSpin&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void Enable(CUIWindow&,bool);
char const* WindowName(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class demo_info
{
demo_player_info const* get_player(demo_info const&,unsigned int);
char const* get_game_type(demo_info const&);
unsigned int const get_players_count(demo_info const&);
char const* get_map_version(demo_info const&);
char const* get_map_name(demo_info const&);
char const* get_author_name(demo_info const&);
char const* get_game_score(demo_info const&);
}
[cpp]
class CUIListBoxItemMsgChain : CUIListBoxItem
{
void AttachChild(CUIWindow&,CUIWindow*);
void SetWidth(CUIFrameLineWnd&,custom [float]);
void __init(luabind::argument const&,custom [float]);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
void SetHeight(CUIFrameLineWnd&,custom [float]);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
custom [float] GetWidth(CUIWindow const&);
void DetachChild(CUIWindow&,CUIWindow*);
bool IsEnabled(CUIWindow&);
void SetColor(CUIFrameLineWnd&,unsigned int);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
void SetTextColor(CUIListBoxItem&,unsigned int);
CUITextWnd* AddTextField(CUIListBoxItem&,char const*,custom [float]);
void SetPPMode(CUIWindow&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void SetWndRect(CUIWindow&,Frect);
CUITextWnd* GetTextItem(CUIListBoxItem&);
CUIStatic* AddIconField(CUIListBoxItem&,custom [float]);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class sound_memory_object : game_memory_object
{
game_object* object(game_memory_object const&);
custom [struct MemorySpace::CObjectParams<class CGameObject>]& self_info { get; set; }
unsigned int level_time { get; set; }
custom [float] power { get; set; }
int type(sound_memory_object const&);
custom [struct MemorySpace::CObjectParams<class CGameObject>]& object_info { get; set; }
unsigned int last_level_time { get; set; }
}
[cpp]
class CWeaponKnife : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
[cpp]
class cse_zone_visual : , cse_anomalous_zonecse_visual
{
void on_unregister(cse_zone_visual&);
void use_ai_locations(cse_alife_object&,bool);
void __init(luabind::argument const&,char const*);
bool can_switch_offline(cse_zone_visual const&);
void switch_online(cse_zone_visual&);
cse_abstract* init(cse_zone_visual&);
unsigned int m_level_vertex_id { get; set; }
vector& position { get; set; }
unsigned int m_story_id { get; set; }
void switch_offline(cse_zone_visual&);
void STATE_Read(cse_zone_visual&,net_packet&,unsigned short);
void on_register(cse_zone_visual&);
int clsid(cse_abstract const&);
void move_offline(cse_alife_object&,bool);
unsigned short id { get; set; }
bool keep_saved_data_anyway(cse_zone_visual const&);
unsigned short script_version { get; set; }
void UPDATE_Read(cse_abstract&,net_packet&);
char const* section_name(cse_abstract const*);
bool can_switch_online(cse_zone_visual const&);
vector& angle { get; set; }
unsigned short m_game_vertex_id { get; set; }
void UPDATE_Write(cse_abstract&,net_packet&);
void on_spawn(cse_zone_visual&);
bool can_save(cse_zone_visual const&);
bool used_ai_locations(cse_zone_visual const&);
void STATE_Write(cse_zone_visual&,net_packet&);
unsigned short parent_id { get; set; }
void on_before_register(cse_zone_visual&);
bool online { get; set; }
void visible_for_map(cse_alife_object&,bool);
bool interactive(cse_zone_visual const&);
char const* name(cse_abstract const*);
ini_file* spawn_ini(cse_abstract*);
}
[cpp]
class store_operation_cb
{
void bind(store_operation_cb&,luabind::object,function<void>);
void clear(store_operation_cb&);
void __init(luabind::argument const&,luabind::object,function<void>);
}
[cpp]
class IRender_Visual
{
IKinematicsAnimated* dcast_PKinematicsAnimated(IRender_Visual&);
}
[cpp]
class world_state
{
bool includes(world_state const&,world_state const&);
void __lt(lua_State*,world_state const&,world_state);
world_property const* property(world_state const&,unsigned int const&);
void __eq(lua_State*,world_state const&,world_state);
void remove_property(world_state&,unsigned int const&);
void add_property(world_state&,world_property const&);
void clear(world_state&);
void __init(luabind::argument const&,world_state);
}
[cpp]
class CUIComboBox : CUIWindow
{
void AttachChild(CUIWindow&,CUIWindow*);
void enable_id(CUIComboBox&,int);
int CurrentID(CUIComboBox&);
void Enable(CUIWindow&,bool);
void SetWndSize(CUIWindow&,vector2);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
void SetText(CUIComboBox&,char const*);
char const* GetTextOf(CUIComboBox&,int);
void SetWindowName(CUIWindow&,char const*);
void disable_id(CUIComboBox&,int);
void ClearList(CUIComboBox&);
void SetPPMode(CUIWindow&);
void SetVertScroll(CUIComboBox&,bool);
void SetAutoDelete(CUIWindow&,bool);
void SetListLength(CUIComboBox&,int);
void ResetPPMode(CUIWindow&);
CUIListBoxItem* AddItem(CUIComboBox&,char const*,int);
bool IsAutoDelete(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
bool IsEnabled(CUIWindow&);
void DetachChild(CUIWindow&,CUIWindow*);
char const* WindowName(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
char const* GetText(CUIComboBox&);
void SetCurrentOptValue(CUIComboBox&);
custom [float] GetHeight(CUIWindow const&);
}
[cpp]
class award_data
{
unsigned short m_count { get; set; }
unsigned int m_last_reward_date { get; set; }
}
[cpp]
class CUITabButton : CUIButton
{
void AttachChild(CUIWindow&,CUIWindow*);
CUILines* TextControl(CUIStatic&);
void InitTexture(CUIStatic&,char const*);
void __init(luabind::argument const&);
void Show(CUIWindow&,bool);
bool IsShown(CUIWindow&);
vector2 const* GetWndPos(CUIWindow*);
custom [float] GetWidth(CUIWindow const&);
char const* WindowName(CUIWindow&);
void SetWindowName(CUIWindow&,char const*);
void DetachChild(CUIWindow&,CUIWindow*);
void SetAutoDelete(CUIWindow&,bool);
bool IsAutoDelete(CUIWindow&);
void ResetPPMode(CUIWindow&);
void SetWndPos(CUIWindow&,vector2);
custom [float] GetHeight(CUIWindow const&);
void Enable(CUIWindow&,bool);
bool IsEnabled(CUIWindow&);
void SetWndSize(CUIWindow&,vector2);
void SetPPMode(CUIWindow&);
void SetWndRect(CUIWindow&,Frect);
void SetTextureRect(CUIStatic&,Frect*);
void SetStretchTexture(CUIStatic&,bool);
Frect const* GetTextureRect(CUIStatic&);
}
[cpp]
class CWeaponVal : CGameObject
{
void net_Import(CGameObject&,net_packet&);
bool use(CGameObject&,CGameObject*);
IRender_Visual* Visual(CGameObject const&);
void net_Export(CGameObject&,net_packet&);
void __init(luabind::argument const&);
int getEnabled(CGameObject const&);
DLL_Pure* _construct(CGameObject&);
int getVisible(CGameObject const&);
int net_Spawn(CGameObject&,cse_abstract*);
}
namespace main_menu
{
CMainMenu* get_main_menu();
}
namespace level
{
custom [enum ESingleGameDifficulty] get_game_difficulty();
char const* name();
unsigned int vertex_in_direction(unsigned int,vector,custom [float]);
vector vertex_position(unsigned int);
custom [float] get_time_factor();
void spawn_phantom(vector const&);
void stop_weather_fx();
void change_game_time(unsigned int,unsigned int,unsigned int);
bool start_weather_fx_from_time(char const*,custom [float]);
void set_time_factor(custom [float]);
unsigned int get_time_minutes();
void set_weather(char const*,bool);
unsigned int get_time_hours();
void map_change_spot_hint(unsigned short,char const*,char const*);
game_object* debug_object(char const*);
void map_add_object_spot_ser(unsigned short,char const*,char const*);
void hide_indicators();
bool set_weather_fx(char const*);
void iterate_sounds(char const*,unsigned int,luabind::object,function<void>);
void add_call(luabind::object const&,char const*,char const*);
custom [float] rain_factor();
void add_dialog_to_render(CUIDialogWnd*);
void prefetch_sound(char const*);
void remove_call(luabind::object const&,char const*,char const*);
void show_weapon(bool);
bool is_wfx_playing();
void remove_calls_for_object(luabind::object const&);
unsigned int get_time_days();
void set_game_difficulty(custom [enum ESingleGameDifficulty]);
bool present();
void map_add_object_spot(unsigned short,char const*,char const*);
void add_pp_effector(char const*,int,bool);
char const* get_weather();
unsigned short map_has_object_spot(unsigned short,char const*);
void enable_input();
custom [float] add_cam_effector(char const*,int,bool,char const*);
physics_world* physics_world();
bool patrol_path_exists(char const*);
void map_remove_object_spot(unsigned short,char const*);
void remove_dialog_to_render(CUIDialogWnd*);
custom [float] low_cover_in_direction(unsigned int,vector const&);
custom [float] high_cover_in_direction(unsigned int,vector const&);
void show_indicators();
Fbox get_bounding_volume();
unsigned int game_id();
void hide_indicators_safe();
client_spawn_manager& client_spawn_manager();
custom [float] get_wfx_time();
custom [float] add_cam_effector2(char const*,int,bool,char const*,custom [float]);
custom [class CEnvironment]* environment();
void disable_input();
custom [float] get_snd_volume();
void remove_complex_effector(int);
void add_complex_effector(char const*,int);
game_object* object_by_id(unsigned short);
void remove_cam_effector(int);
void set_pp_effector_factor(int,custom [float]);
void remove_pp_effector(int);
unsigned int vertex_id(vector);
void set_snd_volume(custom [float]);
void check_object(game_object*);
game_object* debug_actor();
}
namespace relation_registry
{
void set_community_relation(char const*,char const*,int);
int get_general_goodwill_between(unsigned short,unsigned short);
void change_community_goodwill(char const*,int,int);
int community_goodwill(char const*,int);
int community_relation(char const*,char const*);
void set_community_goodwill(char const*,int,int);
}
namespace actor_stats
{
void add_points_str(char const*,char const*,char const*);
void add_points(char const*,char const*,int,int);
int get_points(char const*);
}
namespace game
{
char const* translate_string(char const*);
bool has_active_tutorial();
unsigned int time();
void stop_tutorial();
CTime get_game_time();
void start_tutorial(char const*);
[cpp]
class CTime
{
const DateToDay = 0;
const DateToMonth = 1;
const DateToYear = 2;
const TimeToHours = 0;
const TimeToMilisecs = 3;
const TimeToMinutes = 1;
const TimeToSeconds = 2;
void __le(lua_State*,CTime const&,CTime);
custom [float] diffSec(CTime&,CTime*);
void __lt(lua_State*,CTime const&,CTime);
void __ge(lua_State*,CTime const&,CTime);
void __sub(lua_State*,CTime&,CTime);
void add(CTime&,CTime*);
void __gt(lua_State*,CTime const&,CTime);
void set(CTime&,int,int,int,int,int,int,int);
void setHMS(CTime&,int,int,int);
char const* timeToString(CTime&,int);
void setHMSms(CTime&,int,int,int,int);
void __add(lua_State*,CTime&,CTime);
void __eq(lua_State*,CTime const&,CTime);
void __init(luabind::argument const&,CTime const&);
char const* dateToString(CTime&,int);
void sub(CTime&,CTime*);
void get(CTime&,unsigned int&,unsigned int&,unsigned int&,unsigned int&,unsigned int&,unsigned int&,unsigned int&);
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment