Create a new version of paste:

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);
}