Amnesia Engine Scripts+

float Math_RandFloat(float afMin, float afMax) {
    return RandFloat(afMin, afMax);
}

int Math_RandInt(int alMin, int alMax) {
    return RandInt(alMin, alMax);
}

float Math_Sin(float afX) {
    return MathSin(afX);
}

float Math_Cos(float afX) {
    return MathCos(afX);
}

float Math_Tan(float afX) {
    return MathTan(afX);
}

float Math_Asin(float afX) {
    return MathAsin(afX);
}

float Math_Acos(float afX) {
    return MathAcos(afX);
}

float Math_Atan(float afX) {
    return MathAtan(afX);
}

float Math_Atan2(float afX, float afY) {
    return MathAtan2(afX, afY);
}

float Math_Sqrt(float afX) {
    return MathSqrt(afX);
}

float Math_Pow(float afBase, float afExp) {
    return MathPow(afBase, afExp);
}

float Math_Min(float afA, float afB) {
    return MathMin(afA, afB);
}

float Math_Max(float afA, float afB) {
    return MathMax(afA, afB);
}

float Math_Clamp(float afX, float afMin, float afMax) {
    return MathClamp(afX, afMin, afMax);
}

float Math_Abs(float afX) {
    return MathAbs(afX);
}

bool String_Contains(string& asString, string& asSubString) {
    return StringContains(asString, asSubString);
}

string String_Sub(string& asString, int alStart, int alCount) {
    return StringSub(asString, alStart, alCount);
}

int String_ToInt(string&in asString) {
    return StringToInt(asString);
}

float String_ToFloat(string&in asString) {
    return StringToFloat(asString);
}

bool String_ToBool(string&in asString) {
    return StringToBool(asString);
}

void Debug_Print(string& asString) {
    Print(asString);
}

void Debug_AddMessage(string& asString, bool abCheckForDuplicates) {
    AddDebugMessage(asString, abCheckForDuplicates);
}

void Debug_ProgLog(string& asLevel, string& asMessage) {
    ProgLog(asLevel, asMessage);
}

bool Debug_GetEnabled() {
    return ScriptDebugOn();
}

void Script_SetLocalVarInt(string& asName, int alVal) {
    SetLocalVarInt(asName, alVal);
}

void Script_AddLocalVarInt(string& asName, int alVal) {
    AddLocalVarInt(asName, alVal);
}

int Script_GetLocalVarInt(string& asName) {
    return GetLocalVarInt(asName);
}

void Script_SetLocalVarFloat(string& asName, float afVal) {
    SetLocalVarFloat(asName, afVal);
}

void Script_AddLocalVarFloat(string& asName, float afVal) {
    AddLocalVarFloat(asName, afVal);
}

float Script_GetLocalVarFloat(string& asName) {
    return GetLocalVarFloat(asName);
}

void Script_SetLocalVarString(string& asName, const string& asVal) {
    SetLocalVarString(asName, asVal);
}

void Script_AddLocalVarString(string& asName, string& asVal) {
    AddLocalVarString(asName, asVal);
}

string Script_GetLocalVarString(string& asName) {
    return GetLocalVarString(asName);
}

void Script_SetGlobalVarInt(string& asName, int alVal) {
    SetGlobalVarInt(asName, alVal);
}

void Script_AddGlobalVarInt(string& asName, int alVal) {
    AddGlobalVarInt(asName, alVal);
}

int Script_GetGlobalVarInt(string& asName) {
    return GetGlobalVarInt(asName);
}

void Script_SetGlobalVarFloat(string& asName, float afVal) {
    SetGlobalVarFloat(asName, afVal);
}

void Script_AddGlobalVarFloat(string& asName, float afVal) {
    AddGlobalVarFloat(asName, afVal);
}

float Script_GetGlobalVarFloat(string& asName) {
    return GetGlobalVarFloat(asName);
}

void Script_SetGlobalVarString(string& asName, const string& asVal) {
    SetGlobalVarString(asName, asVal);
}

void Script_AddGlobalVarString(string& asName, string& asVal) {
    AddGlobalVarString(asName, asVal);
}

string Script_GetGlobalVarString(string& asName) {
    return GetGlobalVarString(asName);
}

void ParticleSystem_Preload(string& asPSFile) {
    PreloadParticleSystem(asPSFile);
}

void ParticleSystem_CreateAtEntity(string& asPSName, string& asPSFile, string& asEntity, bool abSavePS) {
    CreateParticleSystemAtEntity(asPSName, asPSFile, asEntity, abSavePS);
}

void ParticleSystem_CreateAtEntityExt(string& asPSName, string& asPSFile, string& asEntity, bool abSavePS, float afR, float afG, float afB, float afA, bool abFadeAtDistance, float afFadeMinEnd, float afFadeMinStart, float afFadeMaxStart, float afFadeMaxEnd) {
    CreateParticleSystemAtEntityExt(asPSName, asPSFile, asEntity, abSavePS, afR, afG, afB, afA, abFadeAtDistance, afFadeMinEnd, afFadeMinStart, afFadeMaxStart, afFadeMaxEnd);
}

void ParticleSystem_Destroy(string& asName) {
    DestroyParticleSystem(asName);
}

void ParticleSystem_StartPlayerSpawnPS(string& asPSFile) {
    StartPlayerSpawnPS(asPSFile);
}

void ParticleSystem_StopPlayerSpawnPS() {
    StopPlayerSpawnPS();
}

void Sound_Preload(string& a) {
    PreloadSound(a);
}

void Sound_PlayAtEntity(string& a, string& b, string& c, float d, bool e) {
    PlaySoundAtEntity(a, b, c, d, e);
}

void Sound_FadeIn(string& a, float b, bool c) {
    FadeInSound(a, b, c);
}

void Sound_Stop(string& a, float b) {
    StopSound(a, b);
}

void Sound_PlayMusic(string& a, bool b, float c, float d, int e, bool f) {
    PlayMusic(a, b, c, d, e, f);
}

void Sound_StopMusic(float a, int b) {
    StopMusic(a, b);
}

void Sound_FadeGlobalVolume(float a, float b) {
    FadeGlobalSoundVolume(a, b);
}

void Sound_FadeGlobalSpeed(float a, float b) {
    FadeGlobalSoundSpeed(a, b);
}

void Sound_AddEffectVoice(string& asVoiceFile, string& asEffectFile, string& asTextCat, string& asTextEntry, bool abUsePosition, string& asPosEntity, float afMinDistance, float afMaxDistance) {
    AddEffectVoice(asVoiceFile, asEffectFile, asTextCat, asTextEntry, abUsePosition, asPosEntity, afMinDistance, afMaxDistance);
}

void Sound_StopAllEffectVoices(float afFadeOutTime) {
    StopAllEffectVoices(afFadeOutTime);
}

bool Sound_GetEffectVoiceActive() {
    return GetEffectVoiceActive();
}

void Sound_SetEffectVoiceOverCallback(string& asFunc) {
    SetEffectVoiceOverCallback(asFunc);
}

void Sound_PlayGuiSound(string& asSoundFile, float afVolume) {
    PlayGuiSound(asSoundFile, afVolume);
}

void Light_SetVisible(string& a, bool b) {
    SetLightVisible(a, b);
}

void Light_FadeTo(string& asLightName, float afR, float afG, float afB, float afA, float afRadius, float afTime) {
    FadeLightTo(asLightName, afR, afG, afB, afA, afRadius, afTime);
}

void Light_SetFlickerActive(string& asLightName, bool abActive) {
    SetLightFlickerActive(asLightName, abActive);
}

void Game_StartCredits(string& asMusic, bool abLoopMusic, string& asTextCat, string& asTextEntry, int alEndNum) {
    StartCredits(asMusic, abLoopMusic, asTextCat, asTextEntry, alEndNum);
}

void Game_StartDemoEnd() {
    StartDemoEnd();
}

void Game_AutoSave() {
    AutoSave();
}

void Game_SetupLoadScreen(string&asTextCat, string&asTextEntry, int alRandomNum, string&asImageFile) {
    SetupLoadScreen(asTextCat, asTextEntry, alRandomNum, asImageFile);
}

void Game_SetDeathHint(string& asTextCategory, string& asTextEntry) {
    SetDeathHint(asTextCategory, asTextEntry);
}

void Game_DisableDeathStartSound() {
    DisableDeathStartSound();
}

void Game_GiveHint(string& asName, string& asMessageCat, string& asMessageEntry, float afTimeShown) {
    GiveHint(asName, asMessageCat, asMessageEntry, afTimeShown);
}

void Game_RemoveHint(string& asName) {
    RemoveHint(asName);
}

void Game_BlockHint(string& asName) {
    BlockHint(asName);
}

void Game_UnblockHint(string& asName) {
    UnBlockHint(asName);
}

void Game_CreateDataCache() {
    CreateDataCache();
}

void Game_DestroyDataCache() {
    DestroyDataCache();
}

void Map_CheckPoint(string& asName, string& asStartPos, string& asCallback, string& asDeathHintCat, string& asDeathHintEntry) {
    CheckPoint(asName, asStartPos, asCallback, asDeathHintCat, asDeathHintEntry);
}

void Map_Change(string& asMapName, string& asStartPos, string& asStartSound, string& asEndSound) {
    ChangeMap(asMapName, asStartPos, asStartSound, asEndSound);
}

void Map_ClearSavedMaps() {
    ClearSavedMaps();
}

void Map_SetDisplayNameEntry(string& asNameEntry) {
    SetMapDisplayNameEntry(asNameEntry);
}

void Map_SetSkyboxActive(bool abActive) {
    SetSkyBoxActive(abActive);
}

void Map_SetSkyboxTexture(string & asTexture) {
    SetSkyBoxTexture(asTexture);
}

void Map_SetSkyboxColor(float afR, float afG, float afB, float afA) {
    SetSkyBoxColor(afR, afG, afB, afA);
}

void Map_SetFogActive(bool abActive) {
    SetFogActive(abActive);
}

void Map_SetFogColor(float afR, float afG, float afB, float afA) {
    SetFogColor(afR, afG, afB, afA);
}

void Map_SetFogProperties(float afStart, float afEnd, float afFalloffExp, bool abCulling) {
    SetFogProperties(afStart, afEnd, afFalloffExp, abCulling);
}

void Timer_Add(string& asName, float afTime, string& asFunction) {
    AddTimer(asName, afTime, asFunction);
}

void Timer_Remove(string& asName) {
    RemoveTimer(asName);
}

float Timer_GetTimeLeft(string& asName) {
    return GetTimerTimeLeft(asName);
}

void Effect_FadeOut(float afTime) {
    FadeOut(afTime);
}

void Effect_FadeIn(float afTime) {
    FadeIn(afTime);
}

void Effect_FadeImageTrailTo(float afAmount, float afSpeed) {
    FadeImageTrailTo(afAmount, afSpeed);
}

void Effect_FadeSepiaColorTo(float afAmount, float afSpeed) {
    FadeSepiaColorTo(afAmount, afSpeed);
}

void Effect_FadeRadialBlurTo(float afSize, float afSpeed) {
    FadeRadialBlurTo(afSize, afSpeed);
}

void Effect_SetRadialBlurStartDist(float afStartDist) {
    SetRadialBlurStartDist(afStartDist);
}

void Effect_StartFlash(float afFadeIn, float afWhite, float afFadeOut) {
    StartEffectFlash(afFadeIn, afWhite, afFadeOut);
}

void Effect_StartEmotionFlash(string& asTextCat, string& asTextEntry, string& asSound) {
    StartEffectEmotionFlash(asTextCat, asTextEntry, asSound);
}

bool Effect_GetFlashbackIsActive() {
    return GetFlashbackIsActive();
}

void Effect_StartScreenShake(float afAmount, float afTime, float afFadeInTime, float afFadeOutTime) {
    StartScreenShake(afAmount, afTime, afFadeInTime, afFadeOutTime);
}

void Effect_SetInDarknessEffectsActive(bool abX) {
    SetInDarknessEffectsActive(abX);
}

void Effect_SetInsanitySetEnabled(string& asSet, bool abX) {
    SetInsanitySetEnabled(asSet, abX);
}

void Effect_StartInsanityEvent(string &in asEventName) {
    StartInsanityEvent(asEventName);
}

void Effect_StartRandomInsanityEvent() {
    StartRandomInsanityEvent();
}

void Effect_StopCurrentInsanityEvent() {
    StopCurrentInsanityEvent();
}

void Effect_FadeFOVMulTo(float afX, float afSpeed) {
    FadePlayerFOVMulTo(afX, afSpeed);
}

void Effect_FadeAspectMulTo(float afX, float afSpeed) {
    FadePlayerAspectMulTo(afX, afSpeed);
}

void Effect_FadePlayerRollTo(float afX, float afSpeedMul, float afMaxSpeed) {
    FadePlayerRollTo(afX, afSpeedMul, afMaxSpeed);
}

void Effect_MovePlayerHeadPos(float afX, float afY, float afZ, float afSpeed, float afSlowDownDist) {
    MovePlayerHeadPos(afX, afY, afZ, afSpeed, afSlowDownDist);
}

void Effect_SetMessage(string& asTextCategory, string& asTextEntry, float afTime) {
    SetMessage(asTextCategory, asTextEntry, afTime);
}

void Player_SetActive(bool abActive) {
    SetPlayerActive(abActive);
}

void Player_ChangeStateToNormal() {
    ChangePlayerStateToNormal();
}

void Player_SetCrouching(bool abCrouch) {
    SetPlayerCrouching(abCrouch);
}

void Player_AddPlayerBodyForce(float afX, float afY, float afZ, bool abUseLocalCoords) {
    AddPlayerBodyForce(afX, afY, afZ, abUseLocalCoords);
}

void Player_ShowCrossHairIcons(bool abX) {
    ShowPlayerCrossHairIcons(abX);
}

void Player_SetSanity(float afSanity) {
    SetPlayerSanity(afSanity);
}

void Player_AddSanity(float afSanity) {
    AddPlayerSanity(afSanity);
}

float Player_GetSanity() {
    return GetPlayerSanity();
}

void Player_SetHealth(float afHealth) {
    SetPlayerHealth(afHealth);
}

void Player_AddPlayerHealth(float afHealth) {
    AddPlayerHealth(afHealth);
}

float Player_GetHealth() {
    return GetPlayerHealth();
}

void Player_SetLampOil(float afOil) {
    SetPlayerLampOil(afOil);
}

void Player_AddLampOil(float afOil) {
    AddPlayerLampOil(afOil);
}

float Player_GetLampOil() {
    return GetPlayerLampOil();
}

float Player_GetSpeed() {
    return GetPlayerSpeed();
}

float Player_GetYSpeed() {
    return GetPlayerYSpeed();
}

void Player_SetSanityDrainDisabled(bool abX) {
    SetSanityDrainDisabled(abX);
}

void Player_GiveSanityBoost() {
    GiveSanityBoost();
}

void Player_GiveSanityBoostSmall() {
    GiveSanityBoostSmall();
}

void Player_GiveSanityDamage(float afAmount, bool abUseEffect) {
    GiveSanityDamage(afAmount, abUseEffect);
}

void Player_GiveDamage(float afAmount, string& asType, bool abSpinHead, bool abLethal) {
    GivePlayerDamage(afAmount, asType, abSpinHead, abLethal);
}

void Player_StartLookAt(string& asEntityName, float afSpeedMul, float afMaxSpeed, string& asAtTargetCallback) {
    StartPlayerLookAt(asEntityName, afSpeedMul, afMaxSpeed, asAtTargetCallback);
}

void Player_StopLookAt() {
    StopPlayerLookAt();
}

void Player_SetMoveSpeedMul(float afMul) {
    SetPlayerMoveSpeedMul(afMul);
}

void Player_SetRunSpeedMul(float afMul) {
    SetPlayerRunSpeedMul(afMul);
}

void Player_SetLookSpeedMul(float afMul) {
    SetPlayerLookSpeedMul(afMul);
}

void Player_SetJumpForceMul(float afMul) {
    SetPlayerJumpForceMul(afMul);
}

void Player_SetJumpDisabled(bool abX) {
    SetPlayerJumpDisabled(abX);
}

void Player_SetCrouchDisabled(bool abX) {
    SetPlayerCrouchDisabled(abX);
}

void Player_Teleport(string& asStartPosName) {
    TeleportPlayer(asStartPosName);
}

void Player_SetLanternActive(bool abX, bool abUseEffects) {
    SetLanternActive(abX, abUseEffects);
}

void Player_SetLanternDisabled(bool abX) {
    SetLanternDisabled(abX);
}

bool Player_GetLanternActive() {
    return GetLanternActive();
}

void Player_SetLanternLitCallback(string& asCallback) {
    SetLanternLitCallback(asCallback);
}

void Player_MoveForward(float afAmount) {
    MovePlayerForward(afAmount);
}

void Player_SetFallDamageDisabled(bool abX) {
    SetPlayerFallDamageDisabled(abX);
}

void Player_SetPos(float afX, float afY, float afZ) {
    SetPlayerPos(afX, afY, afZ);
}

float Player_GetPosX() {
    return GetPlayerPosX();
}

float Player_GetPosY() {
    return GetPlayerPosY();
}

float Player_GetPosZ() {
    return GetPlayerPosZ();
}

void Journal_AddNote(string& asNameAndTextEntry, string& asImage) {
    AddNote(asNameAndTextEntry, asImage);
}

void Journal_AddDiary(string& asNameAndTextEntry, string& asImage) {
    AddDiary(asNameAndTextEntry, asImage);
}

void Journal_ReturnOpen(bool abOpenJournal) {
    ReturnOpenJournal(abOpenJournal);
}

void Journal_AddQuest(string& asName, string& asNameAndTextEntry) {
    AddQuest(asName, asNameAndTextEntry);
}

void Journal_CompleteQuest(string& asName, string& asNameAndTextEntry) {
    CompleteQuest(asName, asNameAndTextEntry);
}

bool Journal_GetQuestIsCompleted(string& asName) {
    return QuestIsCompleted(asName);
}

bool Journal_GetQuestIsAdded(string& asName) {
    return QuestIsAdded(asName);
}

void Journal_SetNumberOfQuestsInMap(int alNumberOfQuests) {
    SetNumberOfQuestsInMap(alNumberOfQuests);
}

void Inventory_Exit() {
    ExitInventory();
}

void Inventory_SetDisabled(bool abX) {
    SetInventoryDisabled(abX);
}

void Inventory_SetMessage(string& asTextCategory, string& asTextEntry, float afTime) {
    SetInventoryMessage(asTextCategory, asTextEntry, afTime);
}

void Inventory_GiveItem(string& asName, string& asType, string& asSubTypeName, string& asImageName, float afAmount) {
    GiveItem(asName, asType, asSubTypeName, asImageName, afAmount);
}

void Inventory_GiveItemFromFile(string& asName, string& asFileName) {
    GiveItemFromFile(asName, asFileName);
}

void Inventory_RemoveItem(string& asName) {
    RemoveItem(asName);
}

bool Inventory_HasItem(string& asName) {
    return HasItem(asName);
}

void Inventory_AddCombineCallback(string& asName, string& asItemA, string& asItemB, string& asFunction, bool abAutoRemove) {
    AddCombineCallback(asName, asItemA, asItemB, asFunction, abAutoRemove);
}

void Inventory_RemoveCombineCallback(string& asName) {
    RemoveCombineCallback(asName);
}

void Inventory_AddUseItemCallback(string& asName, string& asItem, string& asEntity, string& asFunction, bool abAutoDestroy) {
    AddUseItemCallback(asName, asItem, asEntity, asFunction, abAutoDestroy);
}

void Inventory_RemoveUseItemCallback(string& asName) {
    RemoveUseItemCallback(asName);
}

void Entity_SetActive(string& asName, bool abActive) {
    SetEntityActive(asName, abActive);
}

void Entity_SetVisible(string& asName, bool abVisible) {
    SetEntityVisible(asName, abVisible);
}

bool Entity_GetExists(string& asName) {
    return GetEntityExists(asName);
}

void Entity_SetCustomFocusCrossHair(string& asName, string& asCrossHair) {
    SetEntityCustomFocusCrossHair(asName, asCrossHair);
}

void Entity_CreateAtArea(string& asEntityName, string& asEntityFile, string& asAreaName, bool abFullGameSave) {
    CreateEntityAtArea(asEntityName, asEntityFile, asAreaName, abFullGameSave);
}

void Entity_Replace(string &in asName, string &in asBodyName, string &in asNewEntityName, string &in asNewEntityFile, bool abFullGameSave) {
    ReplaceEntity(asName, asBodyName, asNewEntityName, asNewEntityFile, abFullGameSave);
}

void Entity_PlaceAtEntity(string &in asName, string &in asTargetEntity, string &in asTargetBodyName, bool abUseRotation) {
    PlaceEntityAtEntity(asName, asTargetEntity, asTargetBodyName, abUseRotation);
}

void Entity_SetPos(string &in asName, float afX, float afY, float afZ) {
    SetEntityPos(asName, afX, afY, afZ);
}

float Entity_GetPosX(string &in asName) {
    return GetEntityPosX(asName);
}

float Entity_GetPosY(string &in asName) {
    return GetEntityPosY(asName);
}

float Entity_GetPosZ(string &in asName) {
    return GetEntityPosZ(asName);
}

void Entity_SetPlayerLookAtCallback(string& asName, string& asCallback, bool abRemoveWhenLookedAt) {
    SetEntityPlayerLookAtCallback(asName, asCallback, abRemoveWhenLookedAt);
}

void Entity_SetPlayerInteractCallback(string& asName, string& asCallback, bool abRemoveOnInteraction) {
    SetEntityPlayerInteractCallback(asName, asCallback, abRemoveOnInteraction);
}

void Entity_SetCallbackFunc(string& asName, string& asCallback) {
    SetEntityCallbackFunc(asName, asCallback);
}

void Entity_SetConnectionStateChangeCallback(string& asName, string& asCallback) {
    SetEntityConnectionStateChangeCallback(asName, asCallback);
}

void Entity_SetInteractionDisabled(string& asName, bool abDisabled) {
    SetEntityInteractionDisabled(asName, abDisabled);
}

void Entity_BreakJoint(string& asName) {
    BreakJoint(asName);
}

void Entity_AddCollideCallback(string& asParentName, string& asChildName, string& asFunction, bool abDeleteOnCollide, int alStates) {
    AddEntityCollideCallback(asParentName, asChildName, asFunction, abDeleteOnCollide, alStates);
}

void Entity_RemoveCollideCallback(string& asParentName, string& asChildName) {
    RemoveEntityCollideCallback(asParentName, asChildName);
}

bool Entity_GetCollide(string& asEntityA, string& asEntityB) {
    return GetEntitiesCollide(asEntityA, asEntityB);
}

void Entity_SetBodyMass(string &in asName, float afMass) {
    SetBodyMass(asName, afMass);
}

float Entity_GetBodyMass(string &in asName) {
    return GetBodyMass(asName);
}

void Entity_SetEffectActive(string& asName, bool abActive, bool abFadeAndPlaySounds) {
    SetPropEffectActive(asName, abActive, abFadeAndPlaySounds);
}

void Entity_SetActiveAndFade(string& asName, bool abActive, float afFadeTime) {
    SetPropActiveAndFade(asName, abActive, afFadeTime);
}

void Entity_SetStaticPhysics(string& asName, bool abX) {
    SetPropStaticPhysics(asName, abX);
}

bool Entity_GetInteractedWith(string& asName) {
    return GetPropIsInteractedWith(asName);
}

void Entity_RotateToSpeed(string& asName, float afAcc, float afGoalSpeed, float afAxisX, float afAxisY, float afAxisZ, bool abResetSpeed, string& asOffsetArea) {
    RotatePropToSpeed(asName, afAcc, afGoalSpeed, afAxisX, afAxisY, afAxisZ, abResetSpeed, asOffsetArea);
}

void Entity_StopMovement(string& asName) {
    StopPropMovement(asName);
}

void Entity_AttachEntity(string& asPropName, string& asAttachName, string& asAttachFile, float afPosX, float afPosY, float afPosZ, float afRotX, float afRotY, float afRotZ) {
    AttachPropToProp(asPropName, asAttachName, asAttachFile, afPosX, afPosY, afPosZ, afRotX, afRotY, afRotZ);
}

void Entity_RemoveAttachedEntity(string& asPropName, string& asAttachName) {
    RemoveAttachedPropFromProp(asPropName, asAttachName);
}

void Entity_SetHealth(string& asName, float afHealth) {
    SetPropHealth(asName, afHealth);
}

void Entity_AddHealth(string& asName, float afHealth) {
    AddPropHealth(asName, afHealth);
}

float Entity_GetHealth(string& asName) {
    return GetPropHealth(asName);
}

void Entity_Reset(string& asName) {
    ResetProp(asName);
}

void Entity_PlayAnimation(string& asProp, string& asAnimation, float afFadeTime, bool abLoop, string& asCallback) {
    PlayPropAnimation(asProp, asAnimation, afFadeTime, abLoop, asCallback);
}

void Entity_AddForce(string& asName, float afX, float afY, float afZ, string& asCoordSystem) {
    AddPropForce(asName, afX, afY, afZ, asCoordSystem);
}

void Entity_AddImpulse(string& asName, float afX, float afY, float afZ, string& asCoordSystem) {
    AddPropImpulse(asName, afX, afY, afZ, asCoordSystem);
}

void Entity_AddBodyForce(string& asName, float afX, float afY, float afZ, string& asCoordSystem) {
    AddBodyForce(asName, afX, afY, afZ, asCoordSystem);
}

void Entity_AddBodyImpulse(string& asName, float afX, float afY, float afZ, string& asCoordSystem) {
    AddBodyImpulse(asName, afX, afY, afZ, asCoordSystem);
}

void Entity_ConnectWithRope(string& asName, string& asPropName, string& asRopeName, bool abInteractOnly, float afSpeedMul, float afToMinSpeed, float afToMaxSpeed, bool abInvert, int alStatesUsed) {
    InteractConnectPropWithRope(asName, asPropName, asRopeName, abInteractOnly, afSpeedMul, afToMinSpeed, afToMaxSpeed, abInvert, alStatesUsed);
}

void Entity_ConnectWithMoveObject(string& asName, string& asPropName, string& asMoveObjectName, bool abInteractOnly, bool abInvert, int alStatesUsed) {
    InteractConnectPropWithMoveObject(asName, asPropName, asMoveObjectName, abInteractOnly, abInvert, alStatesUsed);
}

void Entity_ConnectEntities(string& asName, string& asMainEntity, string& asConnectEntity, bool abInvertStateSent, int alStatesUsed, string& asCallbackFunc) {
    ConnectEntities(asName, asMainEntity, asConnectEntity, abInvertStateSent, alStatesUsed, asCallbackFunc);
}

void Lamp_SetLit(string& asName, bool abLit, bool abEffects) {
    SetLampLit(asName, abLit, abEffects);
}

void SwingDoor_SetLocked(string& asName, bool abLocked, bool abEffects) {
    SetSwingDoorLocked(asName, abLocked, abEffects);
}

void SwingDoor_SetClosed(string& asName, bool abClosed, bool abEffects) {
    SetSwingDoorClosed(asName, abClosed, abEffects);
}

bool SwingDoor_GetLocked(string& asName) {
    return GetSwingDoorLocked(asName);
}

bool SwingDoor_GetClosed(string& asName) {
    return GetSwingDoorClosed(asName);
}

void SwingDoor_SetDisableAutoClose(string& asName, bool abDisableAutoClose) {
    SetSwingDoorDisableAutoClose(asName, abDisableAutoClose);
}

int SwingDoor_GetState(string& asName) {
    return GetSwingDoorState(asName);
}

void LevelDoor_SetLocked(string& asName, bool abLocked) {
    SetLevelDoorLocked(asName, abLocked);
}

void LevelDoor_SetLockedSound(string& asName, string& asSound) {
    SetLevelDoorLockedSound(asName, asSound);
}

void LevelDoor_SetLockedText(string& asName, string& asTextCat, string& asTextEntry) {
    SetLevelDoorLockedText(asName, asTextCat, asTextEntry);
}

void MoveObject_SetState(string& asName, float afState) {
    SetMoveObjectState(asName, afState);
}

void MoveObject_SetStateExt(string& asName, float afState, float afAcc, float afMaxSpeed, float afSlowdownDist, bool abResetSpeed) {
    SetMoveObjectStateExt(asName, afState, afAcc, afMaxSpeed, afSlowdownDist, abResetSpeed);
}

void Entity_SetStuckState(string& asName, int alState) {
    SetPropObjectStuckState(asName, alState);
}

void Wheel_SetStuckState(string& asName, int alState, bool abEffects) {
    SetWheelStuckState(asName, alState, abEffects);
}

void Lever_SetStuckState(string& asName, int alState, bool abEffects) {
    SetLeverStuckState(asName, alState, abEffects);
}

void Wheel_SetAngle(string& asName, float afAngle, bool abAutoMove) {
    SetWheelAngle(asName, afAngle, abAutoMove);
}

void Wheel_SetInteractionDisablesStuck(string& asName, bool abX) {
    SetWheelInteractionDisablesStuck(asName, abX);
}

void Lever_SetInteractionDisablesStuck(string& asName, bool abX) {
    SetLeverInteractionDisablesStuck(asName, abX);
}

int Lever_GetState(string& asName) {
    return GetLeverState(asName);
}

void MultiSlider_SetStuckState(string& asName, int alStuckState, bool abEffects) {
    SetMultiSliderStuckState(asName, alStuckState, abEffects);
}

void MultiSlider_SetCallback(string& asName, string& asCallback) {
    SetMultiSliderCallback(asName, asCallback);
}

void Button_SetSwitchedOn(string& asName, bool abSwitchedOn, bool abEffects) {
    SetButtonSwitchedOn(asName, abSwitchedOn, abEffects);
}

void Entity_SetAllowStickyAreaAttachment(bool abX) {
    SetAllowStickyAreaAttachment(abX);
}

void Entity_AttachToStickyArea(string& asAreaName, string& asProp) {
    AttachPropToStickyArea(asAreaName, asProp);
}

void Entity_AttachBodyToStickyArea(string& asAreaName, string& asBody) {
    AttachBodyToStickyArea(asAreaName, asBody);
}

void Entity_DetachFromStickyArea(string& asAreaName) {
    DetachFromStickyArea(asAreaName);
}

void NPC_SetAwake(string& asName, bool abAwake, bool abEffects) {
    SetNPCAwake(asName, abAwake, abEffects);
}

void NPC_SetFollowPlayer(string& asName, bool abX) {
    SetNPCFollowPlayer(asName, abX);
}

void Enemy_SetDisabled(string& asName, bool abDisabled) {
    SetEnemyDisabled(asName, abDisabled);
}

void Enemy_SetIsHallucination(string& asName, bool abX) {
    SetEnemyIsHallucination(asName, abX);
}

void Enemy_FadeToSmoke(string& asName, bool abPlaySound) {
    FadeEnemyToSmoke(asName, abPlaySound);
}

void Enemy_ShowPlayerPosition(string& asName) {
    ShowEnemyPlayerPosition(asName);
}

void Enemy_AlertPlayerPresence(string &in asName) {
    AlertEnemyOfPlayerPresence(asName);
}

void Enemy_SetTriggersDisabled(string& asName, bool abX) {
    SetEnemyDisableTriggers(asName, abX);
}

void Enemy_AddPatrolNode(string& asName, string& asNodeName, float afWaitTime, string& asAnimation) {
    AddEnemyPatrolNode(asName, asNodeName, afWaitTime, asAnimation);
}

void Enemy_ClearPatrolNodes(string& asEnemyName) {
    ClearEnemyPatrolNodes(asEnemyName);
}

void Enemy_SetSanityDecreaseActive(string &in asName, bool abX) {
    SetEnemySanityDecreaseActive(asName, abX);
}

void Enemy_TeleportToNode(string &in asEnemyName, string &in asNodeName, bool abChangeY) {
    TeleportEnemyToNode(asEnemyName, asNodeName, abChangeY);
}

void Enemy_TeleportToEntity(string &in asEnemyName, string &in asTargetEntity, string &in asTargetBody, bool abChangeY) {
    TeleportEnemyToEntity(asEnemyName, asTargetEntity, asTargetBody, abChangeY);
}

void Enemy_ChangeManPigPose(string&in asName, string&in asPoseType) {
    ChangeManPigPose(asName, asPoseType);
}

void Enemy_SetTeslaPigFadeDisabled(string&in asName, bool abX) {
    SetTeslaPigFadeDisabled(asName, abX);
}

void Enemy_SetTeslaPigSoundDisabled(string&in asName, bool abX) {
    SetTeslaPigSoundDisabled(asName, abX);
}

void Enemy_SetTeslaPigEasyEscapeDisabled(string&in asName, bool abX) {
    SetTeslaPigEasyEscapeDisabled(asName, abX);
}

void Enemy_ForceTeslaPigSighting(string&in asName) {
    ForceTeslaPigSighting(asName);
}

string Enemy_GetStateName(string &in asName) {
    return GetEnemyStateName(asName);
}