NativeLib.galaxy

include "TriggerLibs/natives"

include "TriggerLibs/NativeLib_h"

//--------------------------------------------------------------------------------------------------
// Library: Built-In
//--------------------------------------------------------------------------------------------------
// Variable Initialization
bool libNtve_InitVariables_completed = false;

void libNtve_InitVariables () {
    int init_i;
    int init_j;
    int init_k;

    if (libNtve_InitVariables_completed) {
        return;
    }

    libNtve_InitVariables_completed = true;

    libNtve_gv__CineTransitionStyle = libNtve_ge_CinematicTransitionStyle_Mission;
    libNtve_gv__PlayersInCineMode = PlayerGroupEmpty();
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonDialogs[init_i] = c_invalidDialogId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtons[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonsBorderType[init_i] = c_triggerImageTypeEndCap;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonsBorderImage[init_i] = "Assets\\Textures\\ui_mission_hackingbuttonglow_normalpressed.dds";
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonsHoverImage[init_i] = "Assets\\Textures\\ui_mission_hackingbuttonglow_normaloverpressedover.dds";
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonsFlashingBorderType[init_i] = c_triggerImageTypeEndCap;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonsFlashingBorderImage[init_i] = "Assets\\Textures\\ui_mission_hackingbuttonglow_anim.dds";
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenButtonsFlashingHoverImage[init_i] = "Assets\\Textures\\ui_mission_hackingbuttonglow_anim.dds";
    }
    libNtve_gv_tP_FlashScreenButtonColor1 = Color(0,0,0);
    libNtve_gv_tP_FlashScreenButtonColor2 = Color(0,0,0);
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenImageDialogs[init_i] = c_invalidDialogId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenImageDialogImages[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenLabelDialogs[init_i] = c_invalidDialogId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv_screenLabelDialogLabels[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 33; init_i += 1) {
        libNtve_gv_unitSelectionStored[init_i] = UnitGroupEmpty();
    }
    libNtve_gv__PlayersInStoryMode = PlayerGroupEmpty();
    for (init_i = 0; init_i <= 32; init_i += 1) {
        libNtve_gv__StoryModeSavedSettingUI_Resource[init_i] = true;
    }
    for (init_i = 0; init_i <= 32; init_i += 1) {
        libNtve_gv__StoryModeSavedSettingUI_Supply[init_i] = true;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_Players[init_i] = PlayerGroupEmpty();
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_Race[init_i] = libNtve_ge_BossBarRace_Terran;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_Dialog[init_i] = c_invalidDialogId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_BGImgBar[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_BGImgPortrait[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_PortraitImage[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_TitleLabel[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_HpBorderImage[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_HpLabel[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_HpFullImage[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_HpCurrentImage[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_BarWidth[init_i] = 520;
    }
    for (init_i = 0; init_i <= 50; init_i += 1) {
        libNtve_gv__BB_BarHeight[init_i] = 120;
    }
    for (init_i = 0; init_i <= 16; init_i += 1) {
        for (init_j = 0; init_j <= 100; init_j += 1) {
            for (init_k = 0; init_k <= 3; init_k += 1) {
                libNtve_gv__GameUIVisible[init_i][init_j][init_k] = true;
            }
        }
    }
    libNtve_gv_visibleFilter = UnitFilter((1 << c_targetFilterVisible), 0, 0, 0);
}

// Presets
// Functions
abilcmd libNtve_gf_EventItemAbilityOrUnitAbility () {
    // Variable Declarations
    unit lv_otherUnit;
    abilcmd lv_abilUsed;
    string lv_itemType;
    int lv_classId;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_otherUnit = EventUnitAbilityOtherUnit();
    lv_abilUsed = EventUnitAbility();
    lv_itemType = "";

    // Implementation
    if ((lv_otherUnit != null)) {
        lv_itemType = CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(lv_otherUnit), "Item", UnitGetOwner(lv_otherUnit));
        lv_classId = CatalogEntryClass(c_gameCatalogAbil, CatalogFieldValueGet(c_gameCatalogItem, lv_itemType, "Abil", UnitGetOwner(lv_otherUnit)));
        if (((lv_classId == c_classIdCAbilEffectTarget) || (lv_classId == c_classIdCAbilEffectInstant))) {
            lv_abilUsed = StringToAbilCmd(CatalogFieldValueGet(c_gameCatalogItem, lv_itemType, "Abil", UnitGetOwner(lv_otherUnit)));
        }

    }

    return lv_abilUsed;
}

string libNtve_gf_UnitAbilityGetByType (unit lp_unit, int lp_abilityClass, int lp_index) {
    // Variable Declarations
    string lv_abil;
    int lv_classIndex;

    // Automatic Variable Declarations
    unit auto5A8FAC35_unit;
    int auto5A8FAC35_i;

    // Variable Initialization

    // Implementation
    auto5A8FAC35_unit = lp_unit;
    auto5A8FAC35_i = 1;
    for ( ; auto5A8FAC35_i <= UnitAbilityCount(auto5A8FAC35_unit) ; auto5A8FAC35_i += 1 ) {
        lv_abil = UnitAbilityGet(auto5A8FAC35_unit, auto5A8FAC35_i);
        if ((AbilityClass(lv_abil) == lp_abilityClass)) {
            lv_classIndex += 1;
        }

        if ((lp_index == lv_classIndex)) {
            return lv_abil;
        }

    }
    return null;
}

bool libNtve_gf_AbilityMatchesFilters (string lp_ability, int lp_abilityOwner, int lp_abilityClass, string lp_alias) {
    // Variable Declarations
    string lv_itAlias;
    int lv_player;

    // Automatic Variable Declarations
    int auto0C13F64D_catalog;
    string auto0C13F64D_entry;
    string auto0C13F64D_fieldPath;
    int auto0C13F64D_player;
    int auto0C13F64D_i;

    // Variable Initialization
    lv_itAlias = "";

    // Implementation
    if ((AbilityClass(lp_ability) != c_classIdCAbil)) {
        if ((AbilityClass(lp_ability) != lp_abilityClass)) {
            return false;
        }

    }

    if ((lp_alias == "")) {
    }
    else {
        auto0C13F64D_catalog = c_gameCatalogAbil;
        auto0C13F64D_entry = lp_ability;
        auto0C13F64D_fieldPath = "TechAliasArray";
        auto0C13F64D_player = lv_player;
        auto0C13F64D_i = 0;
        for ( ; auto0C13F64D_i <= CatalogFieldValueCount(c_gameCatalogAbil,auto0C13F64D_entry,auto0C13F64D_fieldPath,auto0C13F64D_player)-1 ; auto0C13F64D_i += 1 ) {
            lv_itAlias = CatalogFieldValueGet(c_gameCatalogAbil,auto0C13F64D_entry,auto0C13F64D_fieldPath+"["+IntToString(auto0C13F64D_i)+"]",auto0C13F64D_player);
            if ((lp_alias == lv_itAlias)) {
                break;
            }

        }
        return false;
    }
    return true;
}

string libNtve_gf_UnitAbilityByFilters (unit lp_unit, int lp_abilityClass, string lp_alias) {
    // Variable Declarations
    string lv_itAbil;
    string lv_itAlias;
    int lv_player;

    // Automatic Variable Declarations
    unit auto981DBC05_unit;
    int auto981DBC05_i;

    // Variable Initialization
    lv_itAlias = "";
    lv_player = UnitGetOwner(lp_unit);

    // Implementation
    auto981DBC05_unit = lp_unit;
    auto981DBC05_i = 1;
    for ( ; auto981DBC05_i <= UnitAbilityCount(auto981DBC05_unit) ; auto981DBC05_i += 1 ) {
        lv_itAbil = UnitAbilityGet(auto981DBC05_unit, auto981DBC05_i);
        if ((libNtve_gf_AbilityMatchesFilters(lv_itAbil, lv_player, lp_abilityClass, lp_alias) == true)) {
            return lv_itAbil;
        }

    }
    return null;
}

actor libNtve_gf_AttachModelToActor (actor lp_actor, string lp_model, string lp_attachPoint) {
    // Variable Declarations
    actorscope lv_scope;
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_scope = ActorScopeFromActor(lp_actor);
    ActorCreate(lv_scope, "SiteHosted", lp_attachPoint, "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorCreate(lv_scope, "ModelHosted", (lp_model), "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    return lv_a;
}

actorscope libNtve_gf_LastCreatedActorScope () {
    // Automatic Variable Declarations
    // Deprecated
    return libNtve_gf_ActorScopeLastCreated();
}

actor libNtve_gf_LastCreatedActor () {
    // Automatic Variable Declarations
    // Deprecated
    return libNtve_gf_ActorLastCreated();
}

actor libNtve_gf_AttachModelToUnit (unit lp_unit, string lp_model, string lp_attachPoint) {
    // Variable Declarations
    actorscope lv_scope;
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_scope = ActorScopeFromUnit(lp_unit);
    ActorCreate(lv_scope, "SiteHosted", lp_attachPoint, "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorCreate(lv_scope, "ModelHosted", (lp_model), "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    return lv_a;
}

actor libNtve_gf_AttachModelToUnitInheritVisibility (unit lp_unit, string lp_model, string lp_attachPoint) {
    // Variable Declarations
    actorscope lv_scope;
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_scope = ActorScopeFromUnit(lp_unit);
    ActorCreate(lv_scope, "SiteHosted", lp_attachPoint, "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorCreate(lv_scope, "ModelHostedInheritVisibility", (lp_model), "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    return lv_a;
}

actor libNtve_gf_AttachModelToActor2 (actor lp_actor, string lp_model, string lp_attachPoint) {
    // Variable Declarations
    string lv_message;
    actorscope lv_scope;
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_message = ("AttachModel {} ");

    // Implementation
    lv_message = ("AttachModel {} " + (lp_model) + " " + lp_attachPoint);
    ActorSendAsText(lp_actor, StringToText(lv_message));
    lv_a = libNtve_gf_ActorLastCreated();
    return lv_a;
}

actorscope libNtve_gf_ActorScopeLastCreated () {
    // Automatic Variable Declarations
    // Implementation
    return ActorScopeFrom("::LastCreated");
}

actorscope libNtve_gf_ActorScopeLastCreatedSend () {
    // Automatic Variable Declarations
    // Implementation
    return ActorScopeFrom("::LastCreated");
}

actor libNtve_gf_ActorLastCreated () {
    // Automatic Variable Declarations
    // Implementation
    return ActorFrom("::LastCreated");
}

actor libNtve_gf_ActorLastCreatedSend () {
    // Automatic Variable Declarations
    // Implementation
    return ActorFrom("::LastCreated");
}

actor libNtve_gf_AttachActorToUnit (unit lp_unit, string lp_actor, string lp_attachPoint) {
    // Variable Declarations
    actorscope lv_scope;
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_scope = ActorScopeFromUnit(lp_unit);
    ActorCreate(lv_scope, "SiteHosted", lp_attachPoint, "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorSend(lv_a, "RefSet ::scope.hostsite ::Self");
    ActorCreate(lv_scope, lp_actor, "", "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorSend(lv_a, "RefSet ::Host ::scope.hostsite");
    return lv_a;
}

actor libNtve_gf_AttachActorToActor (actor lp_hostingActor, string lp_attachingActor, string lp_attachPoint) {
    // Variable Declarations
    actorscope lv_scope;
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_scope = ActorScopeFromActor(lp_hostingActor);
    ActorCreate(lv_scope, "SiteHosted", lp_attachPoint, "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorSend(lv_a, "RefSet ::scope.hostsite ::Self");
    ActorCreate(lv_scope, lp_attachingActor, "", "", "");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorSend(lv_a, "RefSet ::Host ::scope.hostsite");
    return lv_a;
}

actor libNtve_gf_CreateActorAtPoint (string lp_actor, point lp_position) {
    // Variable Declarations
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorCreate(null, lp_actor, null, null, null);
    lv_a = libNtve_gf_ActorLastCreated();
    ActorSend(lv_a, libNtve_gf_SetPositionH(PointGetX(lp_position), PointGetY(lp_position), PointGetHeight(lp_position)));
    return lv_a;
}

actor libNtve_gf_CreateModelAtPoint (string lp_model, point lp_position) {
    // Variable Declarations
    actor lv_a;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorCreate(null, "TriggerModel", (lp_model), null, "null");
    lv_a = libNtve_gf_ActorLastCreated();
    ActorSend(lv_a, libNtve_gf_ActorMsg1("SetPositionH", libNtve_gf_ConvertXYToString(PointGetX(lp_position), PointGetY(lp_position))));
    ActorSend(lv_a, libNtve_gf_SetHeight(PointGetHeight(lp_position)));
    return lv_a;
}

void libNtve_gf_CreateModelWithPointFacing (string lp_model, point lp_position) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_CreateModelAtPoint(lp_model, lp_position);
    libNtve_gf_MakeModelFaceAngle(libNtve_gf_ActorLastCreated(), PointGetFacing(lp_position));
}

void libNtve_gf_SendActorMessageToUnit (unit lp_unit, string lp_message) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(libNtve_gf_MainActorofUnit(lp_unit), lp_message);
}

void libNtve_gf_ActorRegionSendSimple (actor lp_region, string lp_message) {
    // Automatic Variable Declarations
    // Implementation
    ActorRegionSend(lp_region, c_actorIntersectAgainstRadiusContact, lp_message, null, null);
}

void libNtve_gf_SendActorMessageToGameRegion (region lp_region, string lp_message) {
    // Variable Declarations
    actor lv_actorRegion;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_region);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, lp_message, null, null);
    ActorSend(lv_actorRegion, "Destroy");
}

void libNtve_gf_SendActorMessageToGameRegionWithFilters (region lp_region, int lp_intersectType, string lp_message, string lp_classFilters, string lp_terms) {
    // Variable Declarations
    actor lv_actorRegion;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_region);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    ActorRegionSend(lv_actorRegion, lp_intersectType, lp_message, lp_classFilters, lp_terms);
    ActorSend(lv_actorRegion, "Destroy");
}

string libNtve_gf_ActorMsg1 (string lp_msgName, string lp_param1) {
    // Automatic Variable Declarations
    // Implementation
    return ((lp_msgName + " {" + lp_param1 + "}"));
}

string libNtve_gf_ActorMsg2 (string lp_msgName, string lp_param1, string lp_param2) {
    // Automatic Variable Declarations
    // Implementation
    return ((lp_msgName + " {" + lp_param1 + "} {" + lp_param2 + "}"));
}

string libNtve_gf_ActorMsg3 (string lp_msgName, string lp_param1, string lp_param2, string lp_param3) {
    // Automatic Variable Declarations
    // Implementation
    return ((lp_msgName + " {" + lp_param1 + "} {" + lp_param2 + "} {" + lp_param3 + "}"));
}

string libNtve_gf_ActorMsg4 (string lp_msgName, string lp_param1, string lp_param2, string lp_param3, string lp_param4) {
    // Automatic Variable Declarations
    // Implementation
    return ((lp_msgName + " {" + lp_param1 + "} {" + lp_param2 + "} {" + lp_param3 + "} {" + lp_param4 + "}"));
}

string libNtve_gf_ActionDamage () {
    // Automatic Variable Declarations
    // Implementation
    return "ActionDamage";
}

string libNtve_gf_ActionImpact () {
    // Automatic Variable Declarations
    // Implementation
    return "ActionImpact";
}

string libNtve_gf_AliasAdd (string lp_alias) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("AliasAdd", lp_alias);
}

string libNtve_gf_AliasRemove (string lp_alias) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("AliasRemove", lp_alias);
}

string libNtve_gf_AnimBaselineStart () {
    // Automatic Variable Declarations
    // Implementation
    return "AnimBaselineStart";
}

string libNtve_gf_AnimBaselineStop () {
    // Automatic Variable Declarations
    // Implementation
    return "AnimBaselineStop";
}

string libNtve_gf_AnimBlendTimeApply (fixed lp_blendTime) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("AnimBlendTimeApply", FixedToString(lp_blendTime, c_fixedPrecisionAny));
}

string libNtve_gf_AnimBlendTimeRemove () {
    // Automatic Variable Declarations
    // Implementation
    return "AnimBlendTimeRemove";
}

string libNtve_gf_AnimClear (string lp_animName, fixed lp_blendTime) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AnimClear", lp_animName, FixedToString(lp_blendTime, c_fixedPrecisionAny));
}

string libNtve_gf_AnimClearAllBut (string lp_animName, fixed lp_blendTime) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AnimClearAllBut", lp_animName, FixedToString(lp_blendTime, c_fixedPrecisionAny));
}

string libNtve_gf_AnimDumpDB () {
    // Automatic Variable Declarations
    // Implementation
    return "AnimDumpDB";
}

string libNtve_gf_AnimGroupRemoveAll () {
    // Automatic Variable Declarations
    // Implementation
    return "AnimGroupRemoveAll";
}

string libNtve_gf_AnimPlaySequence (string lp_animName, string lp_sequenceList) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AnimPlaySequence", lp_animName, lp_sequenceList);
}

string libNtve_gf_AnimSetCompletion (string lp_animName, fixed lp_percent) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AnimSetCompletion", lp_animName, FixedToString(lp_percent, c_fixedPrecisionAny));
}

string libNtve_gf_AnimSetDuration (string lp_animName, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AnimSetCompletion", lp_animName, FixedToString(lp_duration, c_fixedPrecisionAny));
}

string libNtve_gf_AnimSetPaused (bool lp_pause) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_pause == true)) {
        return libNtve_gf_ActorMsg1("AnimSetPaused", "true");
    }
    else {
        return libNtve_gf_ActorMsg1("AnimSetPaused", "false");
    }
}

string libNtve_gf_AnimSetTime (string lp_animName, fixed lp_time, bool lp_scaled) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg3("AnimSetTime", lp_animName, FixedToString(lp_time, c_fixedPrecisionAny), libNtve_gf_ConvertBooleanToString(lp_scaled));
}

string libNtve_gf_AnimSetTimeScale (string lp_animName, fixed lp_scale) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AnimSetTimeScale", lp_animName, FixedToString(lp_scale, c_fixedPrecisionAny));
}

string libNtve_gf_AnimSetTimeScaleGlobal (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("AnimSetTimeScaleGlobal", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_AttachSetBearings (string lp_attachMethods, string lp_bearings) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AttachSetBearings", lp_attachMethods, lp_bearings);
}

string libNtve_gf_AttachSetBearingsFrom (string lp_attachMethods, string lp_actorName, string lp_actorSiteOps) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg3("AttachSetBearingsFrom", lp_attachMethods, lp_actorName, lp_actorSiteOps);
}

string libNtve_gf_AttachSetPosition (string lp_attachMethods, string lp_position) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AttachSetPosition", lp_attachMethods, lp_position);
}

string libNtve_gf_AttachSetPositionFrom (string lp_attachMethods, string lp_actorName, string lp_actorSiteOps) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg3("AttachSetPositionFrom", lp_attachMethods, lp_actorName, lp_actorSiteOps);
}

string libNtve_gf_AttachSetRotation (string lp_attachMethods, fixed lp_rotation) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("AttachSetRotation", lp_attachMethods, FixedToString(lp_rotation, c_fixedPrecisionAny));
}

string libNtve_gf_AttachSetRotationFrom (string lp_attachMethods, string lp_actorName, string lp_actorSiteOps) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg3("AttachSetRotationFrom", lp_attachMethods, lp_actorName, lp_actorSiteOps);
}

string libNtve_gf_Create (string lp_actor, string lp_content) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("Create", lp_actor, lp_content);
}

string libNtve_gf_CreateCopy (string lp_createKey, string lp_sourceKey) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("CreateCopy", (lp_createKey), (lp_sourceKey));
}

string libNtve_gf_DeathCustomize (string lp_subname) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("DeathCustomize", lp_subname);
}

string libNtve_gf_Destroy () {
    // Automatic Variable Declarations
    // Implementation
    return "Destroy";
}

string libNtve_gf_HostSiteOpsSet (string lp_hostName, string lp_ops, int lp_holdPosition, int lp_holdRotation) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg4("HostSiteOpsSet", lp_hostName, lp_ops, IntToString(lp_holdPosition), IntToString(lp_holdRotation));
}

string libNtve_gf_ListAdd (string lp_actorRefName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("ListAdd", lp_actorRefName);
}

string libNtve_gf_ListRemove (string lp_actorRefName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("ListRemove", lp_actorRefName);
}

string libNtve_gf_MissileTentacleReturn () {
    // Automatic Variable Declarations
    // Implementation
    return "MissileTentacleReturn";
}

string libNtve_gf_ModelEventSuppress (int lp_value, string lp_event) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("ModelEventSuppress", lp_event, IntToString(lp_value));
}

string libNtve_gf_ModelSwap (string lp_model, int lp_variation) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("ModelSwap", (lp_model), IntToString(lp_variation));
}

string libNtve_gf_MoverSetAcceleration (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetAcceleration", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverSetDeceleration (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetDeceleration", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverSetDestination2D (fixed lp_x, fixed lp_y) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetDestination2D", libNtve_gf_ConvertXYToString(lp_x, lp_y));
}

string libNtve_gf_MoverSetDestinationFrom (string lp_actorRefName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetDestinationFrom", lp_actorRefName);
}

string libNtve_gf_MoverSetDestinationH (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetDestinationH", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverSetDestinationZ (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetDestinationZ", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverSetSpeed (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetSpeed", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverSetSpeedMax (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetSpeedMax", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverSetSpeedFromDuration (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("MoverSetSpeedFromDuration", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_MoverMove () {
    // Automatic Variable Declarations
    // Implementation
    return "MoverMove";
}

string libNtve_gf_MoverStop () {
    // Automatic Variable Declarations
    // Implementation
    return "MoverStop";
}

string libNtve_gf_MoverStopNow () {
    // Automatic Variable Declarations
    // Implementation
    return "MoverStopNow";
}

string libNtve_gf_MultiplyScale (fixed lp_x, fixed lp_y, fixed lp_z, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("MultiplyScale", (FixedToString(lp_x, c_fixedPrecisionAny) + "," + FixedToString(lp_y, c_fixedPrecisionAny) + "," + FixedToString(lp_z, c_fixedPrecisionAny)), FixedToString(lp_duration, c_fixedPrecisionAny));
}

string libNtve_gf_Print (string lp_string) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("Print", lp_string);
}

string libNtve_gf_QueryPersistent (string lp_enterResponseActor, string lp_leaveResponeActor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("QueryPersistent", (lp_enterResponseActor), (lp_leaveResponeActor));
}

string libNtve_gf_QueryRadius (fixed lp_radius, string lp_responseActor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("QueryRegion", FixedToString(lp_radius, c_fixedPrecisionAny), lp_responseActor);
}

string libNtve_gf_QueryRegion (string lp_regionActor, string lp_responseActor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("QueryRadius", lp_regionActor, lp_responseActor);
}

string libNtve_gf_RefClear (string lp_actorRefName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("RefClear", lp_actorRefName);
}

string libNtve_gf_RefDestroy (string lp_actorRefName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("RefDestroy", lp_actorRefName);
}

string libNtve_gf_RefDump (string lp_actorRefName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("RefDump", lp_actorRefName);
}

string libNtve_gf_RefNotify (string lp_actorRefName, string lp_subName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("RefSet", lp_actorRefName, lp_subName);
}

string libNtve_gf_RefSet (string lp_actorRefName, string lp_refSource) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("RefSet", lp_actorRefName, lp_refSource);
}

string libNtve_gf_RefSetFromMsg (string lp_actorRefName, string lp_message) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("RefSetFromMsg", lp_actorRefName, lp_message);
}

string libNtve_gf_RefSetFromActor (string lp_actorRefName, string lp_refPrimary, string lp_refSecondary) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg3("RefSetFromActor", lp_actorRefName, lp_refPrimary, lp_refSecondary);
}

string libNtve_gf_RefSetRefreshName (string lp_actorRefName, string lp_refreshName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("RefSetRefreshName", lp_actorRefName, lp_refreshName);
}

string libNtve_gf_SetBearings (fixed lp_positionX, fixed lp_positionY, fixed lp_positionZ, fixed lp_forwardX, fixed lp_forwardY, fixed lp_forwardZ, fixed lp_upX, fixed lp_upY, fixed lp_upZ) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetBearings", ("'" + libNtve_gf_ConvertBearingsToString(lp_positionX, lp_positionY, lp_positionZ, lp_forwardX, lp_forwardY, lp_forwardZ, lp_upX, lp_upY, lp_upZ) + "'"));
}

string libNtve_gf_SetBearingsFrom (string lp_actor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetBearingsFrom", lp_actor);
}

string libNtve_gf_SetBearingsH (fixed lp_positionX, fixed lp_positionY, fixed lp_height, fixed lp_forwardX, fixed lp_forwardY, fixed lp_forwardZ, fixed lp_upX, fixed lp_upY, fixed lp_upZ) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetBearingsH", (FixedToString(lp_positionX, c_fixedPrecisionAny) + "," + FixedToString(lp_positionY, c_fixedPrecisionAny) + " " + FixedToString(lp_height, c_fixedPrecisionAny) + " '" + libNtve_gf_Convert3DVectorToString(lp_forwardX, lp_forwardY, lp_forwardZ) + " " + libNtve_gf_Convert3DVectorToString(lp_upX, lp_upY, lp_upZ) + "'"));
}

string libNtve_gf_SetFacing (fixed lp_facing) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetFacing", FixedToString(lp_facing, c_fixedPrecisionAny));
}

string libNtve_gf_SetHeight (fixed lp_height) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetHeight", FixedToString(lp_height, c_fixedPrecisionAny));
}

string libNtve_gf_SetOpacity (fixed lp_opacity, fixed lp_blendDuration) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("SetOpacity", FixedToString(lp_opacity, c_fixedPrecisionAny), FixedToString(lp_blendDuration, c_fixedPrecisionAny));
}

string libNtve_gf_SetPosition (fixed lp_x, fixed lp_y, fixed lp_z) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetPosition", libNtve_gf_Convert3DVectorToString(lp_x, lp_y, lp_z));
}

string libNtve_gf_SetPosition2D (fixed lp_x, fixed lp_y) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetPosition2D", (FixedToString(lp_x, c_fixedPrecisionAny) + "," + FixedToString(lp_y, c_fixedPrecisionAny)));
}

string libNtve_gf_SetPosition2DH (fixed lp_x, fixed lp_y) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetPosition2DH", (FixedToString(lp_x, c_fixedPrecisionAny) + "," + FixedToString(lp_y, c_fixedPrecisionAny)));
}

string libNtve_gf_SetPositionFrom (string lp_actor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetPositionFrom", lp_actor);
}

string libNtve_gf_SetPositionH (fixed lp_x, fixed lp_y, fixed lp_height) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("SetPositionH", (FixedToString(lp_x, c_fixedPrecisionAny) + "," + FixedToString(lp_y, c_fixedPrecisionAny)), FixedToString(lp_height, c_fixedPrecisionAny));
}

string libNtve_gf_SetRenderToTextureEnabled (bool lp_enabled) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_enabled == true)) {
        return libNtve_gf_ActorMsg1("SetRenderToTextureEnabled", "1");
    }
    else {
        return libNtve_gf_ActorMsg1("SetRenderToTextureEnabled", "0");
    }
}

string libNtve_gf_SetRotation (fixed lp_forwardX, fixed lp_forwardY, fixed lp_forwardZ, fixed lp_upX, fixed lp_upY, fixed lp_upZ) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetRotation", libNtve_gf_Convert3DRotationToString(lp_forwardX, lp_forwardY, lp_forwardZ, lp_upX, lp_upY, lp_upZ));
}

string libNtve_gf_SetRotationFrom (string lp_actor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetRotationFrom", lp_actor);
}

string libNtve_gf_SetScale (fixed lp_x, fixed lp_y, fixed lp_z, fixed lp_blendDuration) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_blendDuration > 0.0)) {
        return libNtve_gf_ActorMsg2("SetScale", libNtve_gf_Convert3DVectorToString(lp_x, lp_y, lp_z), FixedToString(lp_blendDuration, c_fixedPrecisionAny));
    }
    else {
        return libNtve_gf_ActorMsg1("SetScale", libNtve_gf_Convert3DVectorToString(lp_x, lp_y, lp_z));
    }
}

string libNtve_gf_SetScaleAbsolute (fixed lp_x, fixed lp_y, fixed lp_z, fixed lp_blendDuration) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_blendDuration > 0.0)) {
        return libNtve_gf_ActorMsg2("SetScaleAbsolute", libNtve_gf_Convert3DVectorToString(lp_x, lp_y, lp_z), FixedToString(lp_blendDuration, c_fixedPrecisionAny));
    }
    else {
        return libNtve_gf_ActorMsg1("SetScaleAbsolute", libNtve_gf_Convert3DVectorToString(lp_x, lp_y, lp_z));
    }
}

string libNtve_gf_SetTeamColor (color lp_diffuseColor, color lp_emissiveColor) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("SetTeamColor", libNtve_gf_ConvertColorToString(lp_diffuseColor), libNtve_gf_ConvertColorToString(lp_emissiveColor));
}

string libNtve_gf_SetLocalTintColor (color lp_color) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetLocalTintColor", libNtve_gf_ConvertColorToString(lp_color));
}

string libNtve_gf_SetTintColor (color lp_color, fixed lp_hdr, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("SetTintColor", (libNtve_gf_ConvertColorToString(lp_color) + " " + FixedToString(lp_hdr, c_fixedPrecisionAny)), FixedToString(lp_duration, c_fixedPrecisionAny));
}

string libNtve_gf_SetVisibility (bool lp_visible) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_visible == true)) {
        return libNtve_gf_ActorMsg1("SetVisibility", "1");
    }
    else {
        return libNtve_gf_ActorMsg1("SetVisibility", "0");
    }
}

string libNtve_gf_SetWalkAnimMoveSpeed (fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetWalkAnimMoveSpeed", FixedToString(lp_value, c_fixedPrecisionAny));
}

string libNtve_gf_SetZ (fixed lp_z) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SetZ", FixedToString(lp_z, c_fixedPrecisionAny));
}

string libNtve_gf_Signal (string lp_signal) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("Signal", lp_signal);
}

string libNtve_gf_SoundAddDSP (string lp_effect) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SoundAddDSP", lp_effect);
}

string libNtve_gf_SoundSetMuted (bool lp_mutedState, bool lp_fade) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("SoundSetMuted", IntToString(BoolToInt(lp_mutedState)), IntToString(BoolToInt(lp_fade)));
}

string libNtve_gf_SoundSetOffset (int lp_offset) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("SoundSetOffset", IntToString(lp_offset));
}

string libNtve_gf_SoundSetPaused (bool lp_pausedState, bool lp_fade) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("SoundSetPaused", IntToString(BoolToInt(lp_pausedState)), IntToString(BoolToInt(lp_fade)));
}

string libNtve_gf_StatusDecrement (string lp_statusVariable) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("StatusDecrement", lp_statusVariable);
}

string libNtve_gf_StatusIncrement (string lp_statusVariable) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("StatusIncrement", lp_statusVariable);
}

string libNtve_gf_TextureDump () {
    // Automatic Variable Declarations
    // Implementation
    return "TextureDump";
}

string libNtve_gf_TextureDumpDB () {
    // Automatic Variable Declarations
    // Implementation
    return "TextureDumpDB";
}

string libNtve_gf_TextureGroupApply (string lp_textureProps) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("TextureGroupApply", lp_textureProps);
}

string libNtve_gf_TextureGroupRemove (string lp_textureProps) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("TextureGroupRemove", lp_textureProps);
}

string libNtve_gf_TextureSelectByID (string lp_texture) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("TextureSelectById", lp_texture);
}

string libNtve_gf_MakeMsgTextureVideoPlay (string lp_texture, int lp_fPS, int lp_textureVideoPlayFlags, int lp_soundType, string lp_attachQuery) {
    // Automatic Variable Declarations
    // Implementation
    return MakeMsgTextureVideoPlay(TextureGetSlotName(lp_texture), TextureGetSlotComponent(lp_texture), lp_fPS, lp_textureVideoPlayFlags, lp_soundType, lp_attachQuery);
}

string libNtve_gf_TextureVideoSetFrame (string lp_texture, int lp_frame) {
    // Automatic Variable Declarations
    // Implementation
    return MakeMsgTextureVideoSetFrame(TextureGetSlotName(lp_texture), TextureGetSlotComponent(lp_texture), lp_frame);
}

string libNtve_gf_TextureVideoSetPaused (string lp_texture, bool lp_pauseState) {
    // Automatic Variable Declarations
    // Implementation
    return MakeMsgTextureVideoSetPaused(TextureGetSlotName(lp_texture), TextureGetSlotComponent(lp_texture), lp_pauseState);
}

string libNtve_gf_TextureVideoSetTime (string lp_texture, fixed lp_time) {
    // Automatic Variable Declarations
    // Implementation
    return MakeMsgTextureVideoSetTime(TextureGetSlotName(lp_texture), TextureGetSlotComponent(lp_texture), lp_time);
}

string libNtve_gf_TextureVideoStop (string lp_texture) {
    // Automatic Variable Declarations
    // Implementation
    return MakeMsgTextureVideoStop(TextureGetSlotName(lp_texture), TextureGetSlotComponent(lp_texture));
}

string libNtve_gf_TextureVideoStopAll () {
    // Automatic Variable Declarations
    // Implementation
    return ("TextureVideoStopAll");
}

string libNtve_gf_TimerSet (fixed lp_duration, string lp_timerName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg2("TimerSet", FixedToString(lp_duration, c_fixedPrecisionAny), lp_timerName);
}

string libNtve_gf_TimerKill (string lp_timerName) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_ActorMsg1("TimerKill", lp_timerName);
}

void libNtve_gf_KillModel (actor lp_model) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(lp_model, "AnimBracketStop BSD");
}

void libNtve_gf_RemoveDoodadsinRegion (region lp_target, string lp_doodadType) {
    // Variable Declarations
    actor lv_actorRegion;
    string lv_animTermsString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_animTermsString = "";

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_target);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    if ((lp_doodadType != null)) {
        lv_animTermsString = ("ScopeContains " + (lp_doodadType));
        lv_animTermsString = (lv_animTermsString + "; ");
    }

    lv_animTermsString = (lv_animTermsString + "!HasStatus DoodadKilled");
    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, "Destroy", "Doodad", lv_animTermsString);
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
}

void libNtve_gf_RemoveDeathModelsinRegion (region lp_region) {
    // Variable Declarations
    actor lv_actorRegion;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_region);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, "Destroy", "Model", "ScopeContains _DeathModel");
    ActorWorldParticleFXDestroy();
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
}

void libNtve_gf_RemoveDeathModelsinRegionImmediately (region lp_region) {
    // Variable Declarations
    actor lv_actorRegion;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_region);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, "Destroy Immediate", "Model", "ScopeContains _DeathModel");
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
    ActorSend(ActorFrom("::Scene"), "SceneParticlesDestroy");
}

actor libNtve_gf_LookAtTargetFromPointWithZOffset (point lp_point, fixed lp_z) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_CreateActorAtPoint("LookAtTarget", lp_point);
    ActorSend(libNtve_gf_ActorLastCreated(), libNtve_gf_SetHeight(lp_z));
    return libNtve_gf_ActorLastCreated();
}

actor libNtve_gf_LookAtTargetFromUnitAttachPoint (unit lp_unit, string lp_attachPoint) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_AttachModelToUnit(lp_unit, "Invisible", lp_attachPoint);
    return libNtve_gf_ActorLastCreated();
}

void libNtve_gf_CreateLookAtTargetAtPoint (point lp_point) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_CreateActorAtPoint("LookAtTarget", lp_point);
}

void libNtve_gf_CreateLookAtTargetAtUnitAttachPoint (unit lp_unit, string lp_attachPoint) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_AttachModelToUnit(lp_unit, "Invisible", lp_attachPoint);
}

void libNtve_gf_SimpleLookAtStart (unit lp_unit, string lp_type, actor lp_lookAtTarget) {
    // Automatic Variable Declarations
    // Implementation
    ActorLookAtTypeStart(libNtve_gf_MainActorofUnit(lp_unit), lp_type, lp_lookAtTarget);
}

void libNtve_gf_MakeUnitLookAtPoint (unit lp_unit, string lp_type, point lp_point) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_CreateActorAtPoint("LookAtTarget", lp_point);
    libNtve_gf_SimpleLookAtStart(lp_unit, lp_type, libNtve_gf_ActorLastCreated());
}

void libNtve_gf_MakeUnitLookAtUnit (unit lp_unit, string lp_type, unit lp_lookAtTargetUnit, string lp_attachPoint) {
    // Automatic Variable Declarations
    // Implementation
    ActorCreate(ActorScopeFromUnit(lp_lookAtTargetUnit), "SiteHosted", lp_attachPoint, "", "");
    libNtve_gf_SimpleLookAtStart(lp_unit, lp_type, libNtve_gf_ActorLastCreated());
}

void libNtve_gf_SimpleLookAtStop (unit lp_unit, string lp_type) {
    // Automatic Variable Declarations
    // Implementation
    ActorLookAtTypeStop(libNtve_gf_MainActorofUnit(lp_unit), lp_type);
}

actor libNtve_gf_MainActorofUnit (unit lp_unit) {
    // Automatic Variable Declarations
    // Implementation
    return ActorFromScope(ActorScopeFromUnit(lp_unit), "::Main");
}

void libNtve_gf_MakeModelFaceAngle (actor lp_model, fixed lp_angle) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(lp_model, libNtve_gf_SetRotation(Cos(lp_angle), Sin(lp_angle), 0, 0, 0, 1.0));
}

void libNtve_gf_PlayMovieTextureOnUnitActor (unit lp_unit, string lp_movieTexture) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(libNtve_gf_MainActorofUnit(lp_unit), libNtve_gf_ActorMsg1("TextureSelectById", (lp_movieTexture)));
}

void libNtve_gf_StopAllVideoTexturesOnUnit (unit lp_unit) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "TextureVideoStopAll");
}

void libNtve_gf_ShowHideDoodadsInRegion (bool lp_showHide, region lp_target, string lp_doodadType) {
    // Variable Declarations
    string lv_actorMessageString;
    actor lv_actorRegion;
    string lv_termsString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_actorMessageString = "";
    lv_termsString = "";

    // Implementation
    if ((lp_showHide == true)) {
        lv_actorMessageString = ("SetVisibility " + "1");
    }
    else {
        lv_actorMessageString = ("SetVisibility " + "0");
    }
    ActorRegionCreate(null, "TriggerRegion", lp_target);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    if ((lp_doodadType != null)) {
        lv_termsString = ("ScopeContains " + lp_doodadType);
    }

    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, (lv_actorMessageString), "Doodad", lv_termsString);
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
}

int libNtve_gf_DifficultyValueInt (int lp_easy, int lp_normal, int lp_advanced, int lp_expert) {
    // Automatic Variable Declarations
    int auto25C665AE_val;

    // Implementation
    auto25C665AE_val = PlayerDifficulty(1);
    if (auto25C665AE_val == 1) {
        return lp_easy;
    }
    else if (auto25C665AE_val == 2) {
        return lp_normal;
    }
    else if (auto25C665AE_val == 3) {
        return lp_advanced;
    }
    else if (auto25C665AE_val == 4) {
        return lp_expert;
    }
    else {
        return lp_normal;
    }
}

fixed libNtve_gf_DifficultyValueFixed (fixed lp_easy, fixed lp_normal, fixed lp_advanced, fixed lp_expert) {
    // Automatic Variable Declarations
    int auto7E83D6CB_val;

    // Implementation
    auto7E83D6CB_val = PlayerDifficulty(1);
    if (auto7E83D6CB_val == 1) {
        return lp_easy;
    }
    else if (auto7E83D6CB_val == 2) {
        return lp_normal;
    }
    else if (auto7E83D6CB_val == 3) {
        return lp_advanced;
    }
    else if (auto7E83D6CB_val == 4) {
        return lp_expert;
    }
    else {
        return lp_normal;
    }
}

string libNtve_gf_DifficultyValueUnitType (string lp_easy, string lp_normal, string lp_advanced, string lp_expert) {
    // Automatic Variable Declarations
    int auto6A030EA6_val;

    // Implementation
    auto6A030EA6_val = PlayerDifficulty(1);
    if (auto6A030EA6_val == 1) {
        return lp_easy;
    }
    else if (auto6A030EA6_val == 2) {
        return lp_normal;
    }
    else if (auto6A030EA6_val == 3) {
        return lp_advanced;
    }
    else if (auto6A030EA6_val == 4) {
        return lp_expert;
    }
    else {
        return lp_normal;
    }
}

void libNtve_gf_AICast (unit lp_unit, order lp_order) {
    // Automatic Variable Declarations
    // Implementation
    AICast(lp_unit, lp_order, c_noMarker, c_castHold);
}

void libNtve_gf_DeclareNextTown (int lp_player, point lp_center) {
    // Automatic Variable Declarations
    // Implementation
    AIDeclareTown(lp_player, AIGetNextUnusedTownSlot(lp_player), lp_center);
}

void libNtve_gf_SetTacticalAIRange (int lp_player, string lp_unitType, int lp_distance) {
    // Automatic Variable Declarations
    // Implementation
    CatalogFieldValueSet(c_gameCatalogUnit, lp_unitType, "TacticalAIRange", lp_player, IntToString(lp_distance));
}

void libNtve_gf_SetTacticalAIThink (int lp_player, string lp_unitType, string lp_target, bool lp_isNative) {
    // Variable Declarations
    string lv_aIThinkTempStr;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_aIThinkTempStr = "";

    // Implementation
    if ((lp_isNative == true)) {
        lv_aIThinkTempStr = lp_target;
    }
    else {
        lv_aIThinkTempStr = ("gf_" + lp_target);
    }
    CatalogFieldValueSet(c_gameCatalogUnit, lp_unitType, "TacticalAIThink", lp_player, lv_aIThinkTempStr);
}

void libNtve_gf_PlayAnimation (actor lp_target, string lp_identifier, string lp_animation, int lp_flags, fixed lp_blendTime) {
    // Variable Declarations
    string lv_animationString;
    bool lv_fullMatchFlag;
    bool lv_playForeverFlag;
    bool lv_nonLoopingFlag;
    string lv_flagString;
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_animationString = "";
    lv_flagString = "";
    lv_actorMessageString = "";

    // Implementation
    lv_animationString = StringReplaceWord(lp_animation, " ", ",", 0, c_stringCase);
    lv_fullMatchFlag = (lp_flags & c_animFlagFullMatch) == c_animFlagFullMatch;
    lv_playForeverFlag = (lp_flags & c_animFlagPlayForever) == c_animFlagPlayForever;
    lv_nonLoopingFlag = (lp_flags & c_animFlagNonLooping) == c_animFlagNonLooping;
    if ((lv_fullMatchFlag == true)) {
        lv_flagString = (lv_flagString + "FullMatch");
    }

    if ((lv_playForeverFlag == true)) {
        if ((lv_fullMatchFlag == true)) {
            lv_flagString = (lv_flagString + ",");
        }

        lv_flagString = (lv_flagString + "PlayForever");
    }

    if ((lv_nonLoopingFlag == true)) {
        if (((lv_fullMatchFlag == true) || (lv_playForeverFlag == true))) {
            lv_flagString = (lv_flagString + ",");
        }

        lv_flagString = (lv_flagString + "NonLooping");
    }

    if ((lv_flagString == "")) {
        lv_flagString = "0";
    }

    lv_actorMessageString = ("AnimPlay " + lp_identifier + " " + lv_animationString + " " + lv_flagString + " " + FixedToString(lp_blendTime, c_fixedPrecisionAny));
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_PlayAnimationOnDoodadsInRegion (region lp_target, string lp_doodadType, string lp_identifier, string lp_animation, int lp_flags, fixed lp_blendTime) {
    // Variable Declarations
    string lv_animationString;
    bool lv_fullMatchFlag;
    bool lv_playForeverFlag;
    bool lv_nonLoopingFlag;
    string lv_flagString;
    string lv_actorMessageString;
    actor lv_actorRegion;
    string lv_termsString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_animationString = "";
    lv_flagString = "";
    lv_actorMessageString = "";
    lv_termsString = "";

    // Implementation
    lv_animationString = StringReplaceWord(lp_animation, " ", ",", 0, c_stringCase);
    lv_fullMatchFlag = (lp_flags & c_animFlagFullMatch) == c_animFlagFullMatch;
    lv_playForeverFlag = (lp_flags & c_animFlagPlayForever) == c_animFlagPlayForever;
    lv_nonLoopingFlag = (lp_flags & c_animFlagNonLooping) == c_animFlagNonLooping;
    if ((lv_fullMatchFlag == true)) {
        lv_flagString = (lv_flagString + "FullMatch");
    }

    if ((lv_playForeverFlag == true)) {
        if ((lv_fullMatchFlag == true)) {
            lv_flagString = (lv_flagString + ",");
        }

        lv_flagString = (lv_flagString + "PlayForever");
    }

    if ((lv_nonLoopingFlag == true)) {
        if (((lv_fullMatchFlag == true) || (lv_playForeverFlag == true))) {
            lv_flagString = (lv_flagString + ",");
        }

        lv_flagString = (lv_flagString + "NonLooping");
    }

    if ((lv_flagString == "")) {
        lv_flagString = "0";
    }

    lv_actorMessageString = ("AnimPlay " + lp_identifier + " " + lv_animationString + " " + lv_flagString + " " + FixedToString(lp_blendTime, c_fixedPrecisionAny));
    ActorRegionCreate(null, "TriggerRegion", lp_target);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    if ((lp_doodadType != null)) {
        lv_termsString = ("ScopeContains " + lp_doodadType);
    }

    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, (lv_actorMessageString), "Doodad", lv_termsString);
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
}

void libNtve_gf_KillDoodadsInRegion (region lp_target, string lp_doodadType) {
    // Variable Declarations
    actor lv_actorRegion;
    string lv_animTermsString;
    string lv_statusTermsString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_animTermsString = "";
    lv_statusTermsString = "";

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_target);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    if ((lp_doodadType != null)) {
        lv_animTermsString = ("ScopeContains " + (lp_doodadType));
        lv_statusTermsString = lv_animTermsString;
        lv_animTermsString = (lv_animTermsString + "; ");
    }

    lv_animTermsString = (lv_animTermsString + "!HasStatus DoodadKilled");
    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, "AnimPlay Death Death PlayForever,NonLooping", "Doodad", lv_animTermsString);
    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, "StatusIncrement DoodadKilled", "Doodad", lv_statusTermsString);
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
}

void libNtve_gf_ClearAnimation (actor lp_target, string lp_identifier) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(lp_target, (("AnimClear " + lp_identifier)));
}

void libNtve_gf_ClearAnimationOnDoodadsInRegion (region lp_target, string lp_doodadType, string lp_identifier) {
    // Variable Declarations
    actor lv_actorRegion;
    string lv_termsString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_termsString = "";

    // Implementation
    ActorRegionCreate(null, "TriggerRegion", lp_target);
    lv_actorRegion = libNtve_gf_ActorLastCreated();
    if ((lp_doodadType != null)) {
        lv_termsString = ("ScopeContains " + lp_doodadType);
    }

    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, libNtve_gf_AnimClear(lp_identifier, -1.0), "Doodad", lv_termsString);
}

void libNtve_gf_TurnAnimationPropertiesOn (actor lp_target, string lp_prop) {
    // Variable Declarations
    string lv_propertiesString;
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_propertiesString = "";
    lv_actorMessageString = "";

    // Implementation
    lv_propertiesString = StringReplaceWord(lp_prop, " ", ",", 0, c_stringCase);
    lv_actorMessageString = ("AnimGroupApply " + lv_propertiesString);
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_TurnAnimationPropertiesOnWithBlendInOut (actor lp_target, string lp_prop, string lp_blendInAnimation, string lp_blendOutAnimation) {
    // Variable Declarations
    string lv_propertiesString;
    string lv_blendInString;
    string lv_blendOutString;
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_propertiesString = "";
    lv_blendInString = "";
    lv_blendOutString = "";
    lv_actorMessageString = "";

    // Implementation
    lv_propertiesString = StringReplaceWord(lp_prop, " ", ",", 0, c_stringCase);
    lv_blendInString = (lv_propertiesString + "," + StringReplaceWord(lp_blendInAnimation, " ", ",", 0, c_stringCase));
    lv_blendOutString = (lv_propertiesString + "," + StringReplaceWord(lp_blendOutAnimation, " ", ",", 0, c_stringCase));
    lv_actorMessageString = ("AnimGroupApply " + lv_propertiesString + " " + lv_blendInString + " " + lv_blendOutString);
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_TurnAnimationPropertiesOff (actor lp_target, string lp_prop) {
    // Variable Declarations
    string lv_propertiesString;
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_propertiesString = "";
    lv_actorMessageString = "";

    // Implementation
    lv_propertiesString = StringReplaceWord(lp_prop, " ", ",", 0, c_stringCase);
    lv_actorMessageString = ("AnimGroupRemove " + lv_propertiesString);
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_TurnAllAnimationPropertiesOff (actor lp_target) {
    // Automatic Variable Declarations
    // Implementation
    ActorSend(lp_target, "AnimGroupRemoveAll");
}

void libNtve_gf_SetAnimationTime (actor lp_target, string lp_identifier, fixed lp_time, bool lp_scaled) {
    // Variable Declarations
    string lv_scaledOption;
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_scaledOption = "";
    lv_actorMessageString = "";

    // Implementation
    if ((lp_scaled == false)) {
        lv_scaledOption = "0";
    }
    else {
        lv_scaledOption = "1";
    }
    lv_actorMessageString = ("AnimSetTime " + lp_identifier + " " + FixedToString(lp_time, c_fixedPrecisionAny) + " " + lv_scaledOption);
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_SetAnimationTimeScale (actor lp_target, string lp_identifier, fixed lp_scale) {
    // Variable Declarations
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_actorMessageString = "";

    // Implementation
    lv_actorMessageString = ("AnimSetTimeScale " + lp_identifier + " " + FixedToString(lp_scale, c_fixedPrecisionAny));
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_SetAnimationCompletion (actor lp_target, string lp_identifier, fixed lp_percent) {
    // Variable Declarations
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_actorMessageString = "";

    // Implementation
    lv_actorMessageString = ("AnimSetCompletion " + lp_identifier + " " + FixedToString(lp_percent, c_fixedPrecisionAny));
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_SetAnimationDuration (actor lp_target, string lp_identifier, fixed lp_duration) {
    // Variable Declarations
    string lv_actorMessageString;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_actorMessageString = "";

    // Implementation
    lv_actorMessageString = ("AnimSetDuration " + lp_identifier + " " + FixedToString(lp_duration, c_fixedPrecisionAny));
    ActorSend(lp_target, (lv_actorMessageString));
}

void libNtve_gf_SetBehaviorCount (unit lp_inUnit, string lp_inBehavior, unit lp_inCaster, int lp_inCount) {
    // Variable Declarations
    int lv_count;
    int lv_delta;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_count = UnitBehaviorCount(lp_inUnit, lp_inBehavior);
    lv_delta = AbsI((lp_inCount - lv_count));

    // Implementation
    if ((lv_delta == 0)) {
        return ;
    }

    if ((lp_inCount > lv_count)) {
        UnitBehaviorAdd(lp_inUnit, lp_inBehavior, lp_inCaster, lv_delta);
    }
    else {
        UnitBehaviorRemove(lp_inUnit, lp_inBehavior, lv_delta);
    }
}

void libNtve_gf_SwooshCamera (int lp_player, fixed lp_distance1, fixed lp_distance2, point lp_location, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    CameraPan(lp_player, lp_location, 0.0, 0, 10, false);
    CameraSetValue(lp_player, c_cameraValueDistance, lp_distance1, 0.0, 0, 10);
    CameraSetValue(lp_player, c_cameraValueDistance, lp_distance2, lp_duration, 0, 10);
}

camerainfo libNtve_gf_CopyOfCameraObject (camerainfo lp_cam) {
    // Variable Declarations
    camerainfo lv_newCam;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_newCam = CameraInfoDefault();

    // Implementation
    CameraInfoSetTarget(lv_newCam, CameraInfoGetTarget(lp_cam));
    CameraInfoSetValue(lv_newCam, c_cameraValuePitch, CameraInfoGetValue(lp_cam, c_cameraValuePitch));
    CameraInfoSetValue(lv_newCam, c_cameraValueDistance, CameraInfoGetValue(lp_cam, c_cameraValueDistance));
    CameraInfoSetValue(lv_newCam, c_cameraValueFarClip, CameraInfoGetValue(lp_cam, c_cameraValueFarClip));
    CameraInfoSetValue(lv_newCam, c_cameraValueFieldOfView, CameraInfoGetValue(lp_cam, c_cameraValueFieldOfView));
    CameraInfoSetValue(lv_newCam, c_cameraValueHeightOffset, CameraInfoGetValue(lp_cam, c_cameraValueHeightOffset));
    CameraInfoSetValue(lv_newCam, c_cameraValueNearClip, CameraInfoGetValue(lp_cam, c_cameraValueNearClip));
    CameraInfoSetValue(lv_newCam, c_cameraValueRoll, CameraInfoGetValue(lp_cam, c_cameraValueRoll));
    CameraInfoSetValue(lv_newCam, c_cameraValueYaw, CameraInfoGetValue(lp_cam, c_cameraValueYaw));
    CameraInfoSetValue(lv_newCam, c_cameraValueShadowClip, CameraInfoGetValue(lp_cam, c_cameraValueShadowClip));
    return lv_newCam;
}

fixed libNtve_gf_CatalogFieldValueGetAsReal (int lp_catalog, string lp_entry, string lp_fieldPath, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return StringToFixed(CatalogFieldValueGet(lp_catalog, lp_entry, lp_fieldPath, lp_player));
}

fixed libNtve_gf_CatalogReferenceGetAsReal (string lp_reference, int lp_player) {
    // Variable Declarations
    string lv_ref;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_ref = lp_reference;

    // Implementation
    return StringToFixed(CatalogReferenceGet(lv_ref, lp_player));
}

fixed libNtve_gf_CostOfAbility (string lp_ability, string lp_costType) {
    // Variable Declarations
    string lv_value;
    string lv_field;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_value = "";
    lv_field = "";

    // Implementation
    if (((lp_costType == "Minerals") || (lp_costType == "Gas"))) {
        lv_field = ("Cost." + lp_costType);
    }
    else if (((lp_costType == "Energy") || (lp_costType == "Life") || (lp_costType == "Shields"))) {
        lv_field = ("Cost[0].Vital[" + lp_costType + "]");
    }
    lv_value = CatalogFieldValueGet(c_gameCatalogAbil, lp_ability, (lv_field), 1);
    return StringToFixed(lv_value);
}

bool libNtve_gf_CatalogFieldValueSetAsReal (int lp_catalog, string lp_entry, string lp_fieldPath, int lp_player, fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return CatalogFieldValueSet(lp_catalog, lp_entry, lp_fieldPath, lp_player, FixedToString(lp_value, c_fixedPrecisionAny));
}

bool libNtve_gf_CatalogFieldValueModifyBasedOnDefaultValue (int lp_catalog, string lp_entry, string lp_fieldPath, int lp_player, fixed lp_value, int lp_operation) {
    // Variable Declarations
    fixed lv_default;

    // Automatic Variable Declarations
    int auto95ABF8B8_val;

    // Variable Initialization
    lv_default = libNtve_gf_CatalogFieldValueGetAsReal(lp_catalog, lp_entry, lp_fieldPath, c_playerAny);

    // Implementation
    auto95ABF8B8_val = lp_operation;
    if (auto95ABF8B8_val == c_upgradeOperationAdd) {
        return libNtve_gf_CatalogFieldValueSetAsReal(lp_catalog, lp_entry, lp_fieldPath, lp_player, (lv_default + lp_value));
    }
    else if (auto95ABF8B8_val == c_upgradeOperationSubtract) {
        return libNtve_gf_CatalogFieldValueSetAsReal(lp_catalog, lp_entry, lp_fieldPath, lp_player, (lv_default - lp_value));
    }
    else if (auto95ABF8B8_val == c_upgradeOperationMultiply) {
        return libNtve_gf_CatalogFieldValueSetAsReal(lp_catalog, lp_entry, lp_fieldPath, lp_player, (lv_default * lp_value));
    }
    else if (auto95ABF8B8_val == c_upgradeOperationDivide) {
        return libNtve_gf_CatalogFieldValueSetAsReal(lp_catalog, lp_entry, lp_fieldPath, lp_player, (lv_default / lp_value));
    }
    else if (auto95ABF8B8_val == c_upgradeOperationSet) {
        return libNtve_gf_CatalogFieldValueSetAsReal(lp_catalog, lp_entry, lp_fieldPath, lp_player, lp_value);
    }
    else {
        return libNtve_gf_CatalogFieldValueSetAsReal(lp_catalog, lp_entry, lp_fieldPath, lp_player, (lv_default + lp_value));
    }
}

bool libNtve_gf_CatalogReferenceSetAsReal (string lp_reference, int lp_player, fixed lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return CatalogReferenceSet(lp_reference, lp_player, FixedToString(lp_value, c_fixedPrecisionAny));
}

bool libNtve_gf_CatalogReferenceModifyBasedOnDefaultValue (string lp_reference, int lp_player, fixed lp_value, int lp_operation) {
    // Variable Declarations
    string lv_ref;
    fixed lv_default;

    // Automatic Variable Declarations
    int auto70738DD1_val;

    // Variable Initialization
    lv_ref = lp_reference;
    lv_default = libNtve_gf_CatalogReferenceGetAsReal(lv_ref, c_playerAny);

    // Implementation
    auto70738DD1_val = lp_operation;
    if (auto70738DD1_val == c_upgradeOperationAdd) {
        return libNtve_gf_CatalogReferenceSetAsReal(lp_reference, lp_player, (lv_default + lp_value));
    }
    else if (auto70738DD1_val == c_upgradeOperationSubtract) {
        return libNtve_gf_CatalogReferenceSetAsReal(lp_reference, lp_player, (lv_default - lp_value));
    }
    else if (auto70738DD1_val == c_upgradeOperationMultiply) {
        return libNtve_gf_CatalogReferenceSetAsReal(lp_reference, lp_player, (lv_default * lp_value));
    }
    else if (auto70738DD1_val == c_upgradeOperationDivide) {
        return libNtve_gf_CatalogReferenceSetAsReal(lp_reference, lp_player, (lv_default / lp_value));
    }
    else if (auto70738DD1_val == c_upgradeOperationSet) {
        return libNtve_gf_CatalogReferenceSetAsReal(lp_reference, lp_player, lp_value);
    }
    else {
        return libNtve_gf_CatalogReferenceSetAsReal(lp_reference, lp_player, (lv_default + lp_value));
    }
}

void libNtve_gf__CineModeTurnOnOffForPlayer (int lp_player, bool lp_onOff) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_onOff == true)) {
        PlayerGroupAdd(libNtve_gv__PlayersInCineMode, lp_player);
    }
    else {
        PlayerGroupRemove(libNtve_gv__PlayersInCineMode, lp_player);
    }
}

void libNtve_gf__CineModeTurnOnOffForPlayerGroup (playergroup lp_players, bool lp_onOff) {
    // Variable Declarations
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup autoB2419D0B_g;

    // Variable Initialization

    // Implementation
    autoB2419D0B_g = lp_players;
    lv_pickedPlayer = -1;
    while (true) {
        lv_pickedPlayer = PlayerGroupNextPlayer(autoB2419D0B_g, lv_pickedPlayer);
        if (lv_pickedPlayer < 0) { break; }
        libNtve_gf__CineModeTurnOnOffForPlayer(lv_pickedPlayer, lp_onOff);
    }
}

bool libNtve_gf__CineModeFogSetting (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv__CineModeSavedSettingFog[lp_player];
}

void libNtve_gf__CineModeChangeFogSettingForPlayer (int lp_player, bool lp_fog) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv__CineModeSavedSettingFog[lp_player] = lp_fog;
}

void libNtve_gf__CineModeChangeFogSettingForPlayerGroup (playergroup lp_players, bool lp_fog) {
    // Variable Declarations
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup auto5A0494EE_g;

    // Variable Initialization

    // Implementation
    auto5A0494EE_g = lp_players;
    lv_pickedPlayer = -1;
    while (true) {
        lv_pickedPlayer = PlayerGroupNextPlayer(auto5A0494EE_g, lv_pickedPlayer);
        if (lv_pickedPlayer < 0) { break; }
        libNtve_gf__CineModeChangeFogSettingForPlayer(lv_pickedPlayer, lp_fog);
    }
}

bool libNtve_gf__CineModeMaskSetting (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv__CineModeSavedSettingMask[lp_player];
}

void libNtve_gf__CineModeChangeMaskSettingForPlayer (int lp_player, bool lp_mask) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv__CineModeSavedSettingMask[lp_player] = lp_mask;
}

void libNtve_gf__CineModeChangeMaskSettingForPlayerGroup (playergroup lp_players, bool lp_mask) {
    // Variable Declarations
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup autoBFF267B3_g;

    // Variable Initialization

    // Implementation
    autoBFF267B3_g = lp_players;
    lv_pickedPlayer = -1;
    while (true) {
        lv_pickedPlayer = PlayerGroupNextPlayer(autoBFF267B3_g, lv_pickedPlayer);
        if (lv_pickedPlayer < 0) { break; }
        libNtve_gf__CineModeChangeMaskSettingForPlayer(lv_pickedPlayer, lp_mask);
    }
}

void libNtve_gf__CineModeHideUI (playergroup lp_players) {
    // Variable Declarations
    int lv_uIFrame;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_uIFrame = c_syncFrameTypeMenuBar;

    // Implementation
    libNtve_gf__StoreGameUIVisibleStates(true, lp_players, libNtve_ge_GameUIStoreIndex_CinematicMode);
    lv_uIFrame = c_syncFrameTypeFirst;
    for ( ; lv_uIFrame <= c_syncFrameTypeLast ; lv_uIFrame += 1 ) {
        if (((GameMapIsBlizzard() == true) || (lv_uIFrame != c_syncFrameTypeBattleUI)) && (libNtve_gv__GameUIFrameFiltered[(lv_uIFrame)] == false)) {
            UISetFrameVisible(lp_players, lv_uIFrame, false);
        }

    }
}

void libNtve_gf__CineModeRestoreUI (playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf__StoreGameUIVisibleStates(false, lp_players, libNtve_ge_GameUIStoreIndex_CinematicMode);
}

void libNtve_gf__CineModeStoreCheatStatus () {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    int auto384D4A4D_ae;
    const int auto384D4A4D_ai = 1;

    // Variable Initialization

    // Implementation
    auto384D4A4D_ae = c_gameCheatLast;
    lv_index = 0;
    for ( ; ( (auto384D4A4D_ai >= 0 && lv_index <= auto384D4A4D_ae) || (auto384D4A4D_ai < 0 && lv_index >= auto384D4A4D_ae) ) ; lv_index += auto384D4A4D_ai ) {
        libNtve_gv__CineModeSavedCheatAllowed[lv_index] = GameCheatIsAllowed(lv_index);
    }
}

void libNtve_gf__CineModeRestoreCheatStatus () {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    int auto20BC43B5_ae;
    const int auto20BC43B5_ai = 1;

    // Variable Initialization

    // Implementation
    auto20BC43B5_ae = c_gameCheatLast;
    lv_index = 0;
    for ( ; ( (auto20BC43B5_ai >= 0 && lv_index <= auto20BC43B5_ae) || (auto20BC43B5_ai < 0 && lv_index >= auto20BC43B5_ae) ) ; lv_index += auto20BC43B5_ai ) {
        if ((libNtve_gv__CineModeSavedCheatAllowed[lv_index] == true)) {
            GameCheatAllow(lv_index, true);
        }
        else {
            GameCheatAllow(lv_index, false);
        }
    }
}

void libNtve_gf_CinematicMode (bool lp_onOff, playergroup lp_players, fixed lp_duration) {
    // Variable Declarations
    playergroup lv_validPlayers;
    int lv_pickedPlayer;
    int lv_index;

    // Automatic Variable Declarations
    playergroup auto0ACAB445_g;
    playergroup autoA2450245_g;
    playergroup auto451C348A_g;
    playergroup auto10906981_g;
    playergroup auto1544564B_g;
    playergroup auto74C9138D_g;
    playergroup autoCF5F6C0D_g;
    playergroup auto2009A28F_g;

    // Variable Initialization
    lv_validPlayers = PlayerGroupEmpty();

    // Implementation
    lv_validPlayers = PlayerGroupCopy(lp_players);
    if ((lp_onOff == true)) {
        autoA2450245_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(autoA2450245_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInCinematicMode(lv_pickedPlayer) == true)) {
                PlayerGroupRemove(lv_validPlayers, lv_pickedPlayer);
            }

        }
        if ((PlayerGroupCount(lv_validPlayers) == 0)) {
            return ;
        }

        UISetHotkeyAllowed(lv_validPlayers, c_hotkeyCameraFollow, false);
        libNtve_gf__CineModeTurnOnOffForPlayerGroup(lv_validPlayers, true);
        libNtve_gf__CineModeHideUI(lv_validPlayers);
        CinematicMode(lv_validPlayers, true, lp_duration);
        UIClearMessages(lv_validPlayers, c_messageAreaAll);
        UISetCursorVisible(lv_validPlayers, false);
        libNtve_gf_ShowHidePlacementModels(false);
        libNtve_gf_SetAllSoundChannelVolumes(libNtve_ge_VolumeChannelMode_Cinematic, lv_validPlayers, MaxF(lp_duration, 1.5));
        auto74C9138D_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto74C9138D_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeLetterboxed, lp_duration);
        }
        autoCF5F6C0D_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(autoCF5F6C0D_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            PlayerPauseAllCharges(lv_pickedPlayer, true);
            PlayerPauseAllCooldowns(lv_pickedPlayer, true);
        }
        auto2009A28F_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto2009A28F_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            PlayerScoreValueEnableAll(lv_pickedPlayer, false);
        }
        UIFlyerHelperOverride(lv_validPlayers, libNtve_ge_FlyerHelperDisplay_c_flyerDisplayNone);
        TriggerSendEvent("CinematicModeOn");
    }
    else {
        auto0ACAB445_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto0ACAB445_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInCinematicMode(lv_pickedPlayer) == false)) {
                PlayerGroupRemove(lv_validPlayers, lv_pickedPlayer);
            }

        }
        if ((PlayerGroupCount(lv_validPlayers) == 0)) {
            return ;
        }

        if ((libNtve_gv__CineTransitionStyle == libNtve_ge_CinematicTransitionStyle_Mission) && (lp_onOff == false)) {
            TransmissionClearGroup(lp_players);
        }

        libNtve_gf_HideAllCinematicPortraits(lv_validPlayers);
        libNtve_gf__CineModeTurnOnOffForPlayerGroup(lv_validPlayers, false);
        libNtve_gf_SetAllSoundChannelVolumes(libNtve_ge_VolumeChannelMode_Game, lv_validPlayers, MaxF(lp_duration, 1.5));
        libNtve_gf__CineModeRestoreUI(lv_validPlayers);
        CinematicMode(lv_validPlayers, false, lp_duration);
        auto451C348A_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto451C348A_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInStoryMode(lv_pickedPlayer) == false)) {
                UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeConsole, lp_duration);
            }
            else {
                UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeFullscreen, lp_duration);
            }
        }
        UISetCursorVisible(lv_validPlayers, true);
        libNtve_gf_ShowHidePlacementModels(true);
        auto10906981_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto10906981_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            PlayerPauseAllCharges(lv_pickedPlayer, false);
            PlayerPauseAllCooldowns(lv_pickedPlayer, false);
        }
        auto1544564B_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto1544564B_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            PlayerScoreValueEnableAll(lv_pickedPlayer, true);
        }
        UIFlyerHelperClearOverride(lv_validPlayers);
        UISetHotkeyAllowed(lv_validPlayers, c_hotkeyCameraFollow, true);
        TriggerSendEvent("CinematicModeOff");
    }
}

void libNtve_gf_GlobalCinematicSetting (bool lp_onOff) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_GlobalCinematicSettingFixedSeedOnOff(lp_onOff, true);
}

void libNtve_gf_GlobalCinematicSettingFixedSeedOnOff (bool lp_onOff, bool lp_fixedSeedOnOff) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv__CineModeGlobalOn == lp_onOff)) {
        return ;
    }

    if ((lp_onOff == true)) {
        libNtve_gv__CineModeSavedSpeed = GameGetSpeedValue();
        GameSetSpeedValue(c_gameSpeedNormal);
        libNtve_gv__CineModeSavedAIPaused = AITimeIsPaused();
        AITimePause(true);
        GameSetSpeedLocked(true);
        GameSetSeedLocked(lp_fixedSeedOnOff);
        GamePauseAllCharges(true);
        VisEnable(c_visTypeMask, false);
        VisEnable(c_visTypeFog, false);
        GameSetMissionTimePaused(true);
        libNtve_gf__CineModeStoreCheatStatus();
        GameCheatAllow(c_gameCheatAny, false);
    }
    else {
        GameSetSpeedValue(libNtve_gv__CineModeSavedSpeed);
        if ((libNtve_gv__CineModeSavedAIPaused == false)) {
            AITimePause(false);
        }

        GameSetSpeedLocked(false);
        GameSetSeedLocked(false);
        GamePauseAllCharges(false);
        VisEnable(c_visTypeMask, true);
        VisEnable(c_visTypeFog, true);
        GameSetMissionTimePaused(false);
        libNtve_gf__CineModeRestoreCheatStatus();
    }
    libNtve_gv__CineModeGlobalOn = lp_onOff;
}

void libNtve_gf_SetCinematicTransitionStyle (int lp_style) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv__CineTransitionStyle = lp_style;
}

bool libNtve_gf_PlayerInCinematicMode (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return PlayerGroupHasPlayer(libNtve_gv__PlayersInCineMode, lp_player);
}

void libNtve_gf_MovieDynamicSubtitlesandDuration (string lp_soundFile) {
    // Automatic Variable Declarations
    // Implementation
    MovieAddSubTitleText((StringExternal("Param/Value/lib_Ntve_1081F0A4") + StringToText(CatalogFieldValueGet(c_gameCatalogSound, lp_soundFile, "AssetArray[" + IntToString(0) + "].Speaker", c_playerAny)) + StringExternal("Param/Value/lib_Ntve_6565C051") + StringToText(CatalogFieldValueGet(c_gameCatalogSound, lp_soundFile, "AssetArray[" + IntToString(0) + "].Subtitle", c_playerAny))), ((1000 * FixedToInt(SoundLengthSync(SoundLink(lp_soundFile, 0)))) + 400), -1);
}

text libNtve_gf_ConvertBooleanToText (bool lp_value) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_value == true)) {
        return StringExternal("Param/Value/lib_Ntve_AB4DD212");
    }
    else {
        return StringExternal("Param/Value/lib_Ntve_1E5D9313");
    }
}

string libNtve_gf_ConvertBooleanToString (bool lp_value) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_value == true)) {
        return "True";
    }
    else {
        return "False";
    }
}

bool libNtve_gf_ConvertStringToBoolean (string lp_value) {
    // Automatic Variable Declarations
    // Implementation
    if ((StringCase(lp_value, false) == "true")) {
        return true;
    }
    else {
        return false;
    }
}

string libNtve_gf_ConvertPointToString (point lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return (FixedToString(PointGetX(lp_value), c_fixedPrecisionAny) + " " + FixedToString(PointGetY(lp_value), c_fixedPrecisionAny) + " " + FixedToString(PointGetFacing(lp_value), c_fixedPrecisionAny));
}

point libNtve_gf_ConvertStringToPoint (string lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_PointFacingAngle(Point(StringToFixed(StringWord(lp_value, 1)), StringToFixed(StringWord(lp_value, 2))), StringToFixed(StringWord(lp_value, 3)));
}

color libNtve_gf_ConvertPlayerColorToColor (int lp_playerColor) {
    // Automatic Variable Declarations
    // Implementation
    return ColorFromIndex((lp_playerColor), c_teamColorDiffuse);
}

string libNtve_gf_ConvertColorToString (color lp_color) {
    // Automatic Variable Declarations
    // Implementation
    return (IntToString(Color255FromFixed(ColorGetComponent(lp_color, c_colorComponentRed))) + "," + IntToString(Color255FromFixed(ColorGetComponent(lp_color, c_colorComponentGreen))) + "," + IntToString(Color255FromFixed(ColorGetComponent(lp_color, c_colorComponentBlue))));
}

string libNtve_gf_ConvertBearingsToString (fixed lp_positionX, fixed lp_positionY, fixed lp_positionZ, fixed lp_forwardX, fixed lp_forwardY, fixed lp_forwardZ, fixed lp_upX, fixed lp_upY, fixed lp_upZ) {
    // Automatic Variable Declarations
    // Implementation
    return (libNtve_gf_Convert3DVectorToString(lp_positionX, lp_positionY, lp_positionZ) + " " + libNtve_gf_Convert3DRotationToString(lp_forwardX, lp_forwardY, lp_forwardZ, lp_upX, lp_upY, lp_upZ));
}

string libNtve_gf_ConvertXYToString (fixed lp_x, fixed lp_y) {
    // Automatic Variable Declarations
    // Implementation
    return (FixedToString(lp_x, c_fixedPrecisionAny) + "," + FixedToString(lp_y, c_fixedPrecisionAny));
}

string libNtve_gf_Convert3DVectorToString (fixed lp_x, fixed lp_y, fixed lp_z) {
    // Automatic Variable Declarations
    // Implementation
    return (FixedToString(lp_x, c_fixedPrecisionAny) + "," + FixedToString(lp_y, c_fixedPrecisionAny) + "," + FixedToString(lp_z, c_fixedPrecisionAny));
}

string libNtve_gf_Convert3DRotationToString (fixed lp_forwardX, fixed lp_forwardY, fixed lp_forwardZ, fixed lp_upX, fixed lp_upY, fixed lp_upZ) {
    // Automatic Variable Declarations
    // Implementation
    return (libNtve_gf_Convert3DVectorToString(lp_forwardX, lp_forwardY, lp_forwardZ) + " " + libNtve_gf_Convert3DVectorToString(lp_upX, lp_upY, lp_upZ));
}

string libNtve_gf_ConvertStringToUILayoutFrameName (string lp_value) {
    // Automatic Variable Declarations
    // Implementation
    return lp_value;
}

void libNtve_gf_SaveDataTableInstanceValueDialogItem (int lp_instance, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableInstanceSetInt(lp_instance, lp_name, lp_value);
}

void libNtve_gf_SaveDataTableInstanceValueDifficultyLevel (int lp_instance, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableInstanceSetInt(lp_instance, lp_name, lp_value);
}

void libNtve_gf_SaveDataTableInstanceValuePlayerColor (int lp_instance, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableInstanceSetInt(lp_instance, lp_name, lp_value);
}

void libNtve_gf_SaveDataTableInstanceValueTextTag (int lp_instance, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableInstanceSetInt(lp_instance, lp_name, lp_value);
}

int libNtve_gf_ValueFromDataTableInstanceDialogItem (int lp_instance, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableInstanceGetInt(lp_instance, lp_name);
}

int libNtve_gf_ValueFromDataTableInstanceDifficultyLevel (int lp_instance, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableInstanceGetInt(lp_instance, lp_name);
}

int libNtve_gf_ValueFromDataTableInstancePlayerColor (int lp_instance, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableInstanceGetInt(lp_instance, lp_name);
}

int libNtve_gf_ValueFromDataTableInstanceTextTag (int lp_instance, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableInstanceGetInt(lp_instance, lp_name);
}

void libNtve_gf_SaveDataTableValueDialogItem (bool lp_scope, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableSetInt(lp_scope, lp_name, lp_value);
}

void libNtve_gf_SaveDataTableValueDifficultyLevel (bool lp_scope, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableSetInt(lp_scope, lp_name, lp_value);
}

void libNtve_gf_SaveDataTableValuePlayerColor (bool lp_scope, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableSetInt(lp_scope, lp_name, lp_value);
}

void libNtve_gf_SaveDataTableValueTextTag (bool lp_scope, string lp_name, int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    DataTableSetInt(lp_scope, lp_name, lp_value);
}

int libNtve_gf_ValueFromDataTableDialogItem (bool lp_scope, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableGetInt(lp_scope, lp_name);
}

int libNtve_gf_ValueFromDataTableDifficultyLevel (bool lp_scope, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableGetInt(lp_scope, lp_name);
}

int libNtve_gf_ValueFromDataTablePlayerColor (bool lp_scope, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableGetInt(lp_scope, lp_name);
}

int libNtve_gf_ValueFromDataTableTextTag (bool lp_scope, string lp_name) {
    // Automatic Variable Declarations
    // Implementation
    return DataTableGetInt(lp_scope, lp_name);
}

string libNtve_gf_GetCurrentDayofWeek () {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_GetWeekdayFromDateTime(CurrentDateTimeGet());
}

bool libNtve_gf_DateTimeisBetween (datetime lp_dateTime, datetime lp_beginning, datetime lp_end) {
    // Automatic Variable Declarations
    // Implementation
    if ((DateTimeIsAfter(lp_dateTime, lp_beginning) == true) && (DateTimeIsBefore(lp_dateTime, lp_end) == true)) {
        return true;
    }
    else {
        return false;
    }
}

string libNtve_gf_GetWeekdayFromDateTime (datetime lp_datetime) {
    // Automatic Variable Declarations
    int auto6C45CF4C_val;

    // Implementation
    auto6C45CF4C_val = GetDateTimeWeekday(lp_datetime);
    if (auto6C45CF4C_val == 0) {
        return "Sunday";
    }
    else if (auto6C45CF4C_val == 1) {
        return "Monday";
    }
    else if (auto6C45CF4C_val == 2) {
        return "Tuesday";
    }
    else if (auto6C45CF4C_val == 3) {
        return "Wednesday";
    }
    else if (auto6C45CF4C_val == 4) {
        return "Thursday";
    }
    else if (auto6C45CF4C_val == 5) {
        return "Friday";
    }
    else if (auto6C45CF4C_val == 6) {
        return "Saturday";
    }
    else {
        return "Sunday";
    }
}

string libNtve_gf_GetMonthFromDateTime (datetime lp_datetime) {
    // Automatic Variable Declarations
    int autoA4673075_val;

    // Implementation
    autoA4673075_val = GetDateTimeMonth(lp_datetime);
    if (autoA4673075_val == 1) {
        return "January";
    }
    else if (autoA4673075_val == 2) {
        return "February";
    }
    else if (autoA4673075_val == 3) {
        return "March";
    }
    else if (autoA4673075_val == 4) {
        return "April";
    }
    else if (autoA4673075_val == 5) {
        return "May";
    }
    else if (autoA4673075_val == 6) {
        return "June";
    }
    else if (autoA4673075_val == 7) {
        return "July";
    }
    else if (autoA4673075_val == 8) {
        return "August";
    }
    else if (autoA4673075_val == 9) {
        return "September";
    }
    else if (autoA4673075_val == 10) {
        return "October";
    }
    else if (autoA4673075_val == 11) {
        return "November";
    }
    else if (autoA4673075_val == 12) {
        return "December";
    }
    else {
        return "January";
    }
}

bool libNtve_gf_DateTimeisWeekend (datetime lp_datetime) {
    // Variable Declarations
    string lv_weekday;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_weekday = libNtve_gf_GetWeekdayFromDateTime(lp_datetime);

    // Implementation
    if (((lv_weekday == "Saturday") || (lv_weekday == "Sunday"))) {
        return true;
    }
    else {
        return false;
    }
}

bool libNtve_gf_DateTimeisMorning (datetime lp_datetime) {
    // Variable Declarations
    int lv_hour;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_hour = GetDateTimeHour(lp_datetime);

    // Implementation
    if ((lv_hour < 12)) {
        return true;
    }
    else {
        return false;
    }
}

bool libNtve_gf_DateTimeisAfternoon (datetime lp_datetime) {
    // Variable Declarations
    int lv_hour;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_hour = GetDateTimeHour(lp_datetime);

    // Implementation
    if ((lv_hour >= 12) && (lv_hour < 18)) {
        return true;
    }
    else {
        return false;
    }
}

bool libNtve_gf_DateTimeisEvening (datetime lp_datetime) {
    // Variable Declarations
    int lv_hour;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_hour = GetDateTimeHour(lp_datetime);

    // Implementation
    if ((lv_hour >= 18)) {
        return true;
    }
    else {
        return false;
    }
}

string libNtve_gf_FormatDateTimeasString (datetime lp_datetime) {
    // Variable Declarations
    int lv_hourIndex;
    int lv_displayHour;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_hourIndex = GetDateTimeHour(lp_datetime);
    lv_displayHour = (ModI((lv_hourIndex - 1), 12) + 1);

    // Implementation
    if ((lv_hourIndex >= 12)) {
        return ((libNtve_gf_GetWeekdayFromDateTime(lp_datetime)) + ", " + (libNtve_gf_GetMonthFromDateTime(lp_datetime)) + " " + IntToString(GetDateTimeDay(lp_datetime)) + ", " + IntToString(GetDateTimeYear(lp_datetime)) + ", " + IntToString(lv_displayHour) + ":" + IntToString(GetDateTimeMinute(lp_datetime)) + ":" + IntToString(GetDateTimeSecond(lp_datetime)) + " PM");
    }
    else {
        return ((libNtve_gf_GetWeekdayFromDateTime(lp_datetime)) + ", " + (libNtve_gf_GetMonthFromDateTime(lp_datetime)) + " " + IntToString(GetDateTimeDay(lp_datetime)) + ", " + IntToString(GetDateTimeYear(lp_datetime)) + ", " + IntToString(lv_displayHour) + ":" + IntToString(GetDateTimeMinute(lp_datetime)) + ":" + IntToString(GetDateTimeSecond(lp_datetime)) + " AM");
    }
}

int libNtve_gf_ConvertIntegerToDebugMessageType (int lp_value) {
    // Automatic Variable Declarations
    // Implementation
    if (((lp_value < 1) || (lp_value > 16))) {
        return 1;
    }

    return lp_value;
}

void libNtve_gf_SetDialogItemText (int lp_dialogItem, text lp_text, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsText(lp_dialogItem, c_triggerControlPropertyText, lp_players, lp_text);
}

text libNtve_gf_DialogItemText (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsText(lp_dialogItem, c_triggerControlPropertyText, lp_player);
}

int libNtve_gf_CreateDialogItemAchievement (int lp_dialog, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY, text lp_tooltip, string lp_achievement) {
    // Variable Declarations
    int lv_dialogitem;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dialogitem = c_invalidDialogControlId;

    // Implementation
    DialogControlCreate(lp_dialog, c_triggerControlTypeAchievement);
    lv_dialogitem = DialogControlLastCreated();
    DialogControlSetSize(lv_dialogitem, PlayerGroupAll(), lp_width, lp_height);
    DialogControlSetPosition(lv_dialogitem, PlayerGroupAll(), lp_anchor, lp_offsetX, lp_offsetY);
    libNtve_gf_SetDialogItemTooltip(lv_dialogitem, lp_tooltip, PlayerGroupAll());
    libNtve_gf_SetDialogItemAchievement(lv_dialogitem, lp_achievement, PlayerGroupAll());
    return lv_dialogitem;
}

int libNtve_gf_CreateDialogItemButton (int lp_dialog, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY, text lp_tooltip, text lp_buttonText, string lp_hoverImage) {
    // Variable Declarations
    int lv_dialogitem;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dialogitem = c_invalidDialogControlId;

    // Implementation
    DialogControlCreate(lp_dialog, c_triggerControlTypeButton);
    lv_dialogitem = DialogControlLastCreated();
    DialogControlSetSize(lv_dialogitem, PlayerGroupAll(), lp_width, lp_height);
    DialogControlSetPosition(lv_dialogitem, PlayerGroupAll(), lp_anchor, lp_offsetX, lp_offsetY);
    libNtve_gf_SetDialogItemTooltip(lv_dialogitem, lp_tooltip, PlayerGroupAll());
    libNtve_gf_SetDialogItemText(lv_dialogitem, lp_buttonText, PlayerGroupAll());
    if ((lp_hoverImage != "")) {
        libNtve_gf_SetDialogItemImage2(lv_dialogitem, lp_hoverImage, PlayerGroupAll());
    }

    return lv_dialogitem;
}

int libNtve_gf_CreateDialogItemCheckBox (int lp_dialog, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY, text lp_tooltip, bool lp_checked) {
    // Variable Declarations
    int lv_dialogitem;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dialogitem = c_invalidDialogControlId;

    // Implementation
    DialogControlCreate(lp_dialog, c_triggerControlTypeCheckBox);
    lv_dialogitem = DialogControlLastCreated();
    DialogControlSetSize(lv_dialogitem, PlayerGroupAll(), lp_width, lp_height);
    DialogControlSetPosition(lv_dialogitem, PlayerGroupAll(), lp_anchor, lp_offsetX, lp_offsetY);
    libNtve_gf_SetDialogItemTooltip(lv_dialogitem, lp_tooltip, PlayerGroupAll());
    libNtve_gf_SetDialogItemChecked(lv_dialogitem, lp_checked, PlayerGroupAll());
    return lv_dialogitem;
}

int libNtve_gf_CreateDialogItemImage (int lp_dialog, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY, text lp_tooltip, string lp_image, int lp_imageType, bool lp_tiled, color lp_tintColor, int lp_blendMode) {
    // Variable Declarations
    int lv_dialogitem;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dialogitem = c_invalidDialogControlId;

    // Implementation
    DialogControlCreate(lp_dialog, c_triggerControlTypeImage);
    lv_dialogitem = DialogControlLastCreated();
    DialogControlSetSize(lv_dialogitem, PlayerGroupAll(), lp_width, lp_height);
    DialogControlSetPosition(lv_dialogitem, PlayerGroupAll(), lp_anchor, lp_offsetX, lp_offsetY);
    libNtve_gf_SetDialogItemTooltip(lv_dialogitem, lp_tooltip, PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(lv_dialogitem, lp_image, PlayerGroupAll());
    libNtve_gf_SetDialogItemImageType(lv_dialogitem, lp_imageType, PlayerGroupAll());
    libNtve_gf_SetDialogItemImageType2(lv_dialogitem, lp_tiled, PlayerGroupAll());
    libNtve_gf_SetDialogItemColor(lv_dialogitem, lp_tintColor, PlayerGroupAll());
    libNtve_gf_SetDialogItemBlendMode(lv_dialogitem, lp_blendMode, PlayerGroupAll());
    return lv_dialogitem;
}

int libNtve_gf_CreateDialogItemLabel (int lp_dialog, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY, text lp_text, color lp_color, bool lp_textWriteout, fixed lp_textWriteoutDuration) {
    // Variable Declarations
    int lv_dialogitem;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_dialogitem = c_invalidDialogControlId;

    // Implementation
    DialogControlCreate(lp_dialog, c_triggerControlTypeLabel);
    lv_dialogitem = DialogControlLastCreated();
    DialogControlSetSize(lv_dialogitem, PlayerGroupAll(), lp_width, lp_height);
    DialogControlSetPosition(lv_dialogitem, PlayerGroupAll(), lp_anchor, lp_offsetX, lp_offsetY);
    libNtve_gf_SetDialogItemText(lv_dialogitem, lp_text, PlayerGroupAll());
    libNtve_gf_SetDialogItemTextWriteout(lv_dialogitem, lp_textWriteout, PlayerGroupAll());
    if ((lp_color != ColorWithAlpha(0,0,0,0))) {
        libNtve_gf_SetDialogItemColor(lv_dialogitem, lp_color, PlayerGroupAll());
    }

    if ((lp_textWriteout == true)) {
        libNtve_gf_SetDialogItemTextWriteoutDuration(lv_dialogitem, lp_textWriteoutDuration, PlayerGroupAll());
    }

    return lv_dialogitem;
}

void libNtve_gf_SetDialogItemRotation (int lp_dialogItem, int lp_rotation, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyRotation, lp_players, (lp_rotation));
}

void libNtve_gf_SetDialogItemtoUseAspectUncorrection (int lp_dialogItem, bool lp_useAspectUncorrection, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyUseAspectUncorrection, lp_players, lp_useAspectUncorrection);
}

void libNtve_gf_SetDialogItemCurrentValue (int lp_dialogItem, fixed lp_currentValue, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyValue, lp_players, lp_currentValue);
}

void libNtve_gf_SetDialogItemMinimumValue (int lp_dialogItem, fixed lp_minValue, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyMinValue, lp_players, lp_minValue);
}

void libNtve_gf_SetDialogItemMaximumValue (int lp_dialogItem, fixed lp_maxValue, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyMaxValue, lp_players, lp_maxValue);
}

void libNtve_gf_SetDialogItemChecked (int lp_dialogItem, bool lp_checked, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_checked == true)) {
        DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyChecked, lp_players, true);
    }
    else {
        DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyChecked, lp_players, false);
    }
}

void libNtve_gf_SetDialogItemEditorValue (int lp_dialogItem, string lp_value, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyEditText, lp_players, lp_value);
}

fixed libNtve_gf_DialogItemValue (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyValue, lp_player);
}

fixed libNtve_gf_DialogItemMaximumValue (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyMaxValue, lp_player);
}

fixed libNtve_gf_DialogItemMinimumValue (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyMinValue, lp_player);
}

bool libNtve_gf_DialogItemIsChecked (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyChecked, lp_player);
}

string libNtve_gf_DialogItemEditValue (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsString(lp_dialogItem, c_triggerControlPropertyEditText, lp_player);
}

void libNtve_gf_SetDialogItemColor (int lp_dialogItem, color lp_color, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyColor, lp_players, lp_color);
}

void libNtve_gf_SetDialogItemStyle (int lp_dialogItem, string lp_style, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyStyle, lp_players, lp_style);
}

void libNtve_gf_SetDialogItemTextWriteout (int lp_dialogItem, bool lp_writeout, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyTextWriteout, lp_players, lp_writeout);
}

void libNtve_gf_SetDialogItemTextWriteoutDuration (int lp_dialogItem, fixed lp_duration, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyTextWriteoutDuration, lp_players, lp_duration);
}

void libNtve_gf_SetDialogItemTooltip (int lp_dialogItem, text lp_tooltip, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsText(lp_dialogItem, c_triggerControlPropertyTooltip, lp_players, lp_tooltip);
}

color libNtve_gf_DialogItemColor (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyColor, lp_player);
}

string libNtve_gf_DialogItemStyle (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsString(lp_dialogItem, c_triggerControlPropertyStyle, lp_player);
}

text libNtve_gf_DialogItemTooltip (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsText(lp_dialogItem, c_triggerControlPropertyTooltip, lp_player);
}

void libNtve_gf_SetDialogItemImage (int lp_dialogItem, string lp_image, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyImage, lp_players, lp_image);
}

void libNtve_gf_SetDialogItemImage2 (int lp_dialogItem, string lp_image, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyHoverImage, lp_players, lp_image);
}

void libNtve_gf_SetDialogItemImageType (int lp_dialogItem, int lp_imageType, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyImageType, lp_players, (lp_imageType));
}

void libNtve_gf_SetDialogItemBlendMode (int lp_dialogItem, int lp_blendMode, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyBlendMode, lp_players, (lp_blendMode));
}

void libNtve_gf_SetDialogItemImageType2 (int lp_dialogItem, bool lp_tiled, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyTiled, lp_players, lp_tiled);
}

string libNtve_gf_DialogItemImage (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsString(lp_dialogItem, c_triggerControlPropertyImage, lp_player);
}

int libNtve_gf_DialogItemImageType (int lp_dialogItem, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return DialogControlGetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyImageType, lp_player);
}

void libNtve_gf_SetDialogItemFlash (int lp_dialogItem, string lp_flash, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyFile, lp_players, lp_flash);
}

void libNtve_gf_SetDialogItemCutscene (int lp_dialogItem, string lp_cutscene, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyFile, lp_players, lp_cutscene);
}

void libNtve_gf_SetDialogItemAchievement (int lp_dialogItem, string lp_achievement, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyAchievement, lp_players, lp_achievement);
}

void libNtve_gf_SetDialogItemRenderPriority (int lp_dialogItem, int lp_renderPriority, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyRenderPriority, lp_players, lp_renderPriority);
}

void libNtve_gf_SetDialogItemClickOnDown (int lp_dialogItem, bool lp_clickOnDown, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyClickOnDown, lp_players, lp_clickOnDown);
}

void libNtve_gf_SetDialogItemToggled (int lp_dialogItem, bool lp_toggled, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyToggled, lp_players, lp_toggled);
}

void libNtve_gf_SetDialogItemMovie (int lp_dialogItem, string lp_movie, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyFile, lp_players, lp_movie);
}

void libNtve_gf_SetDialogItemDesaturated (int lp_dialogItem, bool lp_desaturated, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyDesaturated, lp_players, lp_desaturated);
}

void libNtve_gf_SetDialogItemDesaturationColor (int lp_dialogItem, color lp_color, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyDesaturationColor, lp_players, lp_color);
}

void libNtve_gf_SetDialogItemCustomTooltip (int lp_dialogItem, int lp_tooltip, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsControl(lp_dialogItem, c_triggerControlPropertyCustomTooltip, lp_players, lp_tooltip);
}

void libNtve_gf_SetDialogItemUnit (int lp_dialogItem, unit lp_unit, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsUnit(lp_dialogItem, c_triggerControlPropertyUnit, lp_players, lp_unit);
}

void libNtve_gf_SetDialogItemModel (int lp_dialogItem, string lp_model, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyModel, lp_players, (lp_model));
}

void libNtve_gf_SetDialogItemAnimation (int lp_dialogItem, string lp_animation, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyAnim, lp_players, (lp_animation));
}

void libNtve_gf_SetDialogItemCamera (int lp_dialogItem, string lp_camera, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyCamera, lp_players, lp_camera);
}

void libNtve_gf_SetDialogItemBorderVisible (int lp_dialogItem, bool lp_visible, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyBorderVisible, lp_players, lp_visible);
}

void libNtve_gf_SetDialogItemBorderImage (int lp_dialogItem, string lp_image, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyBorderImage, lp_players, lp_image);
}

void libNtve_gf_SetDialogItemBackgroundVisible (int lp_dialogItem, bool lp_visible, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyBackgroundVisible, lp_players, lp_visible);
}

void libNtve_gf_SetDialogItemUseTransition (int lp_dialogItem, bool lp_useTransition, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyUseTransition, lp_players, lp_useTransition);
}

void libNtve_gf_SetDialogItemMuted (int lp_dialogItem, bool lp_muted, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyMuted, lp_players, lp_muted);
}

void libNtve_gf_SetDialogItemPaused (int lp_dialogItem, bool lp_paused, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyPaused, lp_players, lp_paused);
}

void libNtve_gf_SetDialogItemAcceptMouse (int lp_dialogItem, bool lp_acceptMouse, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyAcceptMouseTarget, lp_players, lp_acceptMouse);
}

void libNtve_gf_SetDialogItemTintColor (int lp_dialogItem, color lp_color, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyTintColor, lp_players, lp_color);
}

void libNtve_gf_SetDialogItemTeamColor (int lp_dialogItem, color lp_color, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyTeamColor, lp_players, lp_color);
}

void libNtve_gf_SetDialogItemLight (int lp_dialogItem, string lp_light, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyLight, lp_players, (lp_light));
}

void libNtve_gf_SetDialogItemTransitionModel (int lp_dialogItem, string lp_model, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyTransitionModel, lp_players, (lp_model));
}

void libNtve_gf_SetDialogItemForceVisible (int lp_dialogItem, bool lp_visible, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsBool(lp_dialogItem, c_triggerControlPropertyForceVisible, lp_players, lp_visible);
}

void libNtve_gf_SetDialogItemRenderType (int lp_dialogItem, int lp_renderType, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyRenderType, lp_players, (lp_renderType));
}

void libNtve_gf_SetDialogItemUnitLink (int lp_dialogItem, string lp_unitLink, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyUnitLink, lp_players, (lp_unitLink));
}

void libNtve_gf_SetDialogItemTeamColorIndex (int lp_dialogItem, int lp_index, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyTeamColorIndex, lp_players, lp_index);
}

void libNtve_gf_SetDialogItemAnimationDuration (int lp_dialogItem, fixed lp_time, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyAnimDuration, lp_players, lp_time);
}

void libNtve_gf_SetDialogItemAnimationTime (int lp_dialogItem, fixed lp_time, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsFixed(lp_dialogItem, c_triggerControlPropertyAnimTime, lp_players, lp_time);
}

void libNtve_gf_SetDialogItemActor (int lp_dialogItem, string lp_actor, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyActor, lp_players, (lp_actor));
}

void libNtve_gf_SetDialogItemBehavior (int lp_dialogItem, string lp_behavior, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyBehavior, lp_players, (lp_behavior));
}

void libNtve_gf_SetDialogItemHotkey (int lp_dialogItem, int lp_hotkey, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyHotkey, lp_players, lp_hotkey);
}

void libNtve_gf_SetDialogItemAllowedMouseButtons (int lp_dialogItem, int lp_allowedButtons, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyAllowedButtons, lp_players, lp_allowedButtons);
}

void libNtve_gf_SetDialogItemAlphaMask (int lp_dialogItem, string lp_image, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyAlphaMask, lp_players, lp_image);
}

void libNtve_gf_SetDialogItemAnimationIndex (int lp_dialogItem, int lp_index, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyAnimIndex, lp_players, lp_index);
}

void libNtve_gf_SetDialogItemHandle (int lp_dialogItem, string lp_handle, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyHandle, lp_players, lp_handle);
}

void libNtve_gf_SetDialogItemBorderColor (int lp_dialogItem, color lp_color, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyBorderColor, lp_players, lp_color);
}

void libNtve_gf_SetDialogItemFillColor (int lp_dialogItem, color lp_color, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsColor(lp_dialogItem, c_triggerControlPropertyFillColor, lp_players, lp_color);
}

void libNtve_gf_SetDialogItemSubmenu (int lp_dialogItem, string lp_submenu, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertySubmenu, lp_players, lp_submenu);
}

void libNtve_gf_SetDialogItemUnitGroup (int lp_dialogItem, unitgroup lp_unitGroup, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsUnitGroup(lp_dialogItem, c_triggerControlPropertyUnitGroup, lp_players, lp_unitGroup);
}

void libNtve_gf_SetDialogItemPlayerId (int lp_dialogItem, int lp_playerId, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyPlayerId, lp_players, lp_playerId);
}

void libNtve_gf_SetDialogItemScoreValueLink (int lp_dialogItem, string lp_scoreValueLink, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsString(lp_dialogItem, c_triggerControlPropertyScoreValueLink, lp_players, (lp_scoreValueLink));
}

void libNtve_gf_SetDialogItemStateIndex (int lp_dialogItem, int lp_stateIndex, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    DialogControlSetPropertyAsInt(lp_dialogItem, c_triggerControlPropertyStateIndex, lp_players, lp_stateIndex);
}

void libNtve_gf_DisplayScreenButton (int lp_screenButtonID, text lp_text, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY, trigger lp_callback) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_screenButtonID > libNtve_gv_c_ScreenButtonMaxCount)) {
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Ntve_3EFBEA6A") + IntToText(libNtve_gv_c_ScreenButtonMaxCount) + StringExternal("Param/Value/lib_Ntve_8BE5995A")));
        return ;
    }

    if ((libNtve_gv_screenButtonDialogs[lp_screenButtonID] == c_invalidDialogId)) {
        DialogCreate(1, 1, c_anchorCenter, 0, 0, true);
        libNtve_gv_screenButtonDialogs[lp_screenButtonID] = DialogLastCreated();
        DialogSetImageVisible(DialogLastCreated(), false);
    }

    DialogSetSize(libNtve_gv_screenButtonDialogs[lp_screenButtonID], lp_width, lp_height);
    DialogSetPosition(libNtve_gv_screenButtonDialogs[lp_screenButtonID], lp_anchor, lp_offsetX, lp_offsetY);
    if ((libNtve_gv_screenButtons[lp_screenButtonID] == c_invalidDialogControlId)) {
        DialogControlCreate(libNtve_gv_screenButtonDialogs[lp_screenButtonID], c_triggerControlTypeButton);
        libNtve_gv_screenButtons[lp_screenButtonID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), libNtve_gv_screenButtonsBorderType[lp_screenButtonID], PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), libNtve_gv_screenButtonsBorderImage[lp_screenButtonID], PlayerGroupAll());
        libNtve_gf_SetDialogItemImage2(DialogControlLastCreated(), libNtve_gv_screenButtonsHoverImage[lp_screenButtonID], PlayerGroupAll());
        libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "ScreenButtonText", PlayerGroupAll());
    }

    DialogControlSetSize(libNtve_gv_screenButtons[lp_screenButtonID], PlayerGroupAll(), lp_width, lp_height);
    DialogControlSetPosition(libNtve_gv_screenButtons[lp_screenButtonID], PlayerGroupAll(), c_anchorCenter, 0, 0);
    DialogControlSetPropertyAsText(libNtve_gv_screenButtons[lp_screenButtonID], c_triggerControlPropertyText, PlayerGroupAll(), lp_text);
    libNtve_gv_screenButtonCallbacks[lp_screenButtonID] = lp_callback;
    DialogSetVisible(libNtve_gv_screenButtonDialogs[lp_screenButtonID], PlayerGroupAll(), true);
}

void libNtve_gf_HideScreenButton (bool lp_showHide, int lp_screenButtonID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_screenButtonDialogs[lp_screenButtonID] == c_invalidDialogId)) {
        return ;
    }

    DialogSetVisible(libNtve_gv_screenButtonDialogs[lp_screenButtonID], PlayerGroupAll(), lp_showHide);
}

void libNtve_gf_FlashScreenButton (int lp_screenButtonID, fixed lp_flashTime, color lp_color1, color lp_color2) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_screenButtonDialogs[lp_screenButtonID] == c_invalidDialogId)) {
        return ;
    }

    libNtve_gv_tP_FlashScreenButtonID = lp_screenButtonID;
    libNtve_gv_tP_FlashScreenButtonFlashTime = lp_flashTime;
    libNtve_gv_tP_FlashScreenButtonColor1 = lp_color1;
    libNtve_gv_tP_FlashScreenButtonColor2 = lp_color2;
    TriggerExecute(libNtve_gt_FlashScreenButton, true, false);
}

void libNtve_gf_StopFlashingScreenButton (int lp_screenButtonID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_screenButtonDialogs[lp_screenButtonID] == c_invalidDialogId)) {
        return ;
    }

    if ((libNtve_gv_screenButtonsFlashing[lp_screenButtonID] == false)) {
        return ;
    }

    if ((libNtve_gv_screenButtonsFlashStopping[lp_screenButtonID] == true)) {
        return ;
    }

    libNtve_gv_screenButtonsFlashStopping[lp_screenButtonID] = true;
    libNtve_gf_SetDialogItemImageType(libNtve_gv_screenButtons[lp_screenButtonID], libNtve_gv_screenButtonsBorderType[lp_screenButtonID], PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libNtve_gf_ScreenButton(lp_screenButtonID), libNtve_gv_screenButtonsFlashingBorderImage[lp_screenButtonID], PlayerGroupAll());
    libNtve_gf_SetDialogItemImage2(libNtve_gf_ScreenButton(lp_screenButtonID), libNtve_gv_screenButtonsFlashingHoverImage[lp_screenButtonID], PlayerGroupAll());
}

void libNtve_gf_SetScreenButtonBorderImage (int lp_screenButtonID, string lp_borderImage, string lp_hoverImage, int lp_borderType) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv_screenButtonsBorderType[lp_screenButtonID] = lp_borderType;
    libNtve_gv_screenButtonsBorderImage[lp_screenButtonID] = lp_borderImage;
    libNtve_gv_screenButtonsHoverImage[lp_screenButtonID] = lp_hoverImage;
    libNtve_gf_SetDialogItemImageType(libNtve_gv_screenButtons[lp_screenButtonID], libNtve_gv_screenButtonsBorderType[lp_screenButtonID], PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libNtve_gf_ScreenButton(lp_screenButtonID), libNtve_gv_screenButtonsBorderImage[lp_screenButtonID], PlayerGroupAll());
    libNtve_gf_SetDialogItemImage2(libNtve_gf_ScreenButton(lp_screenButtonID), libNtve_gv_screenButtonsHoverImage[lp_screenButtonID], PlayerGroupAll());
}

void libNtve_gf_SetScreenButtonFlashingBorderImage (int lp_screenButtonID, string lp_borderImage, string lp_hoverImage, int lp_borderType) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv_screenButtonsFlashingBorderType[lp_screenButtonID] = lp_borderType;
    libNtve_gv_screenButtonsFlashingBorderImage[lp_screenButtonID] = lp_borderImage;
    libNtve_gv_screenButtonsFlashingHoverImage[lp_screenButtonID] = lp_hoverImage;
}

int libNtve_gf_ScreenButtonDialog (int lp_screenButtonID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv_screenButtonDialogs[lp_screenButtonID];
}

int libNtve_gf_ScreenButton (int lp_screenButtonID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv_screenButtons[lp_screenButtonID];
}

void libNtve_gf_DisplayScreenImage (int lp_screenImageID, string lp_image, int lp_blendMode, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_screenImageID == libNtve_gv_c_ScreenImageMaxCount)) {
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Ntve_83A50D3D") + IntToText(libNtve_gv_c_ScreenImageMaxCount) + StringExternal("Param/Value/lib_Ntve_B9D80F71")));
        return ;
    }

    if ((libNtve_gv_screenImageDialogs[lp_screenImageID] == c_invalidDialogId)) {
        DialogCreate(1, 1, c_anchorCenter, 0, 0, false);
        libNtve_gv_screenImageDialogs[lp_screenImageID] = DialogLastCreated();
    }

    DialogSetImageVisible(libNtve_gv_screenImageDialogs[lp_screenImageID], false);
    DialogSetSize(libNtve_gv_screenImageDialogs[lp_screenImageID], lp_width, lp_height);
    DialogSetPosition(libNtve_gv_screenImageDialogs[lp_screenImageID], lp_anchor, lp_offsetX, lp_offsetY);
    DialogSetTransparency(libNtve_gv_screenImageDialogs[lp_screenImageID], 0.0);
    if ((libNtve_gv_screenImageDialogImages[lp_screenImageID] == c_invalidDialogControlId)) {
        DialogControlCreate(libNtve_gv_screenImageDialogs[lp_screenImageID], c_triggerControlTypeImage);
        libNtve_gv_screenImageDialogImages[lp_screenImageID] = DialogControlLastCreated();
    }

    libNtve_gf_SetDialogItemImageType(libNtve_gv_screenImageDialogImages[lp_screenImageID], c_triggerImageTypeNormal, PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libNtve_gv_screenImageDialogImages[lp_screenImageID], lp_image, PlayerGroupAll());
    libNtve_gf_SetDialogItemBlendMode(libNtve_gv_screenImageDialogImages[lp_screenImageID], lp_blendMode, PlayerGroupAll());
    DialogControlSetSize(libNtve_gv_screenImageDialogImages[lp_screenImageID], PlayerGroupAll(), lp_width, lp_height);
    libNtve_gf_SetDialogItemRotation(libNtve_gv_screenImageDialogImages[lp_screenImageID], 0, PlayerGroupAll());
    DialogControlSetPosition(libNtve_gv_screenImageDialogImages[lp_screenImageID], PlayerGroupAll(), c_anchorCenter, 0, 0);
    libNtve_gv_screenImagePulsing[lp_screenImageID] = false;
    DialogSetVisible(libNtve_gv_screenImageDialogs[lp_screenImageID], PlayerGroupAll(), true);
}

void libNtve_gf_HideScreenImage (bool lp_showHideOption, int lp_screenImageID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_screenImageDialogs[lp_screenImageID] == c_invalidDialogId)) {
        return ;
    }

    DialogSetVisible(libNtve_gv_screenImageDialogs[lp_screenImageID], PlayerGroupAll(), lp_showHideOption);
}

void libNtve_gf_PulseScreenImage (int lp_screenImageID, fixed lp_period, fixed lp_transparency1, fixed lp_transparency2) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv_tP_PulseScreenImageID = lp_screenImageID;
    libNtve_gv_tP_PulseScreenImagePeriod = lp_period;
    libNtve_gv_tP_PulseScreenImageTransparency1 = lp_transparency1;
    libNtve_gv_tP_PulseScreenImageTransparency2 = lp_transparency2;
    TriggerExecute(libNtve_gt_PulseScreenImage, true, false);
}

void libNtve_gf_StopPulsingScreenImage (int lp_screenImageID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_screenImageDialogs[lp_screenImageID] == c_invalidDialogId)) {
        return ;
    }

    libNtve_gv_screenImagePulsing[lp_screenImageID] = false;
}

int libNtve_gf_ScreenImageDialog (int lp_screenImageID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv_screenImageDialogs[lp_screenImageID];
}

int libNtve_gf_ScreenImageDialogItem (int lp_screenImageID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv_screenImageDialogImages[lp_screenImageID];
}

void libNtve_gf_DisplayScreenLabel (int lp_screenLabelID, text lp_label, string lp_style, int lp_width, int lp_height, int lp_anchor, int lp_offsetX, int lp_offsetY) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_screenLabelID == libNtve_gv_c_ScreenLabelMaxCount)) {
        UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Ntve_78462626") + IntToText(libNtve_gv_c_ScreenLabelMaxCount) + StringExternal("Param/Value/lib_Ntve_333F226E")));
        return ;
    }

    if ((libNtve_gv_screenLabelDialogs[lp_screenLabelID] == c_invalidDialogId)) {
        DialogCreate(1, 1, c_anchorCenter, 0, 0, false);
        libNtve_gv_screenLabelDialogs[lp_screenLabelID] = DialogLastCreated();
    }

    DialogSetImageVisible(libNtve_gv_screenLabelDialogs[lp_screenLabelID], false);
    DialogSetSize(libNtve_gv_screenLabelDialogs[lp_screenLabelID], lp_width, lp_height);
    DialogSetPosition(libNtve_gv_screenLabelDialogs[lp_screenLabelID], lp_anchor, lp_offsetX, lp_offsetY);
    if ((libNtve_gv_screenLabelDialogLabels[lp_screenLabelID] == c_invalidDialogControlId)) {
        DialogControlCreate(libNtve_gv_screenLabelDialogs[lp_screenLabelID], c_triggerControlTypeLabel);
        libNtve_gv_screenLabelDialogLabels[lp_screenLabelID] = DialogControlLastCreated();
        DialogControlSetFullDialog(DialogControlLastCreated(), PlayerGroupAll(), true);
        DialogControlSetPosition(DialogControlLastCreated(), PlayerGroupAll(), c_anchorCenter, 0, 0);
    }

    libNtve_gf_SetDialogItemText(libNtve_gv_screenLabelDialogLabels[lp_screenLabelID], lp_label, PlayerGroupAll());
    libNtve_gf_SetDialogItemStyle(libNtve_gv_screenLabelDialogLabels[lp_screenLabelID], lp_style, PlayerGroupAll());
    DialogSetVisible(libNtve_gv_screenLabelDialogs[lp_screenLabelID], PlayerGroupAll(), true);
}

void libNtve_gf_HideScreenImage2 (bool lp_showHideOption, int lp_screenLabelID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_screenLabelDialogs[lp_screenLabelID] == c_invalidDialogId)) {
        return ;
    }

    DialogSetVisible(libNtve_gv_screenLabelDialogs[lp_screenLabelID], PlayerGroupAll(), lp_showHideOption);
}

int libNtve_gf_ScreenLabelDialog (int lp_screenLabelID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv_screenLabelDialogs[lp_screenLabelID];
}

int libNtve_gf_ScreenLabelDialogItem (int lp_screenLabelID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gv_screenLabelDialogLabels[lp_screenLabelID];
}

void libNtve_gf_CreateExplosionAtPoint (int lp_size, int lp_race, point lp_point) {
    // Variable Declarations
    string lv_race;
    string lv_size;
    actor lv_explosion;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_race = "Terran";
    lv_size = "Large";

    // Implementation
    libNtve_gf_CreateActorAtPoint("TriggeredExplosion", lp_point);
    lv_explosion = libNtve_gf_ActorLastCreated();
    if ((lp_race == libNtve_ge_ExplosionType_Protoss)) {
        lv_race = "Protoss";
    }
    else {
        if ((lp_race == libNtve_ge_ExplosionType_Zerg)) {
            lv_race = "Zerg";
        }

    }
    if ((lp_size == libNtve_ge_ExplosionSize_Small)) {
        lv_size = "Small";
    }

    ActorSend(lv_explosion, (("Signal " + lv_race + lv_size)));
}

bool libNtve_gf_PlayerCanCreateEffectAtPoint (int lp_player, string lp_effect, point lp_point) {
    // Automatic Variable Declarations
    // Implementation
    return (PlayerValidateEffectPoint(lp_player, lp_effect, lp_point) == 0);
}

bool libNtve_gf_PlayerCanCreateEffectOnUnit (int lp_player, string lp_effect, unit lp_target) {
    // Automatic Variable Declarations
    // Implementation
    return (PlayerValidateEffectUnit(lp_player, lp_effect, lp_target) == 0);
}

bool libNtve_gf_UnitCanCreateEffectAtPoint (unit lp_caster, string lp_effect, point lp_point) {
    // Automatic Variable Declarations
    // Implementation
    return (UnitValidateEffectPoint(lp_caster, lp_effect, lp_point) == 0);
}

bool libNtve_gf_UnitCanCreateEffectOnUnit (unit lp_caster, string lp_effect, unit lp_target) {
    // Automatic Variable Declarations
    // Implementation
    return (UnitValidateEffectUnit(lp_caster, lp_effect, lp_target) == 0);
}

fixed libNtve_gf_GamePlayTime (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return GameGetMissionTime();
}

void libNtve_gf_GameRemoveChargeRegen (string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    GameAddChargeRegen(lp_inCharge, (-1.0 * GameGetChargeRegen(lp_inCharge)));
}

void libNtve_gf_GameRemoveChargeUsed (string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    GameAddChargeUsed(lp_inCharge, (-1.0 * GameGetChargeUsed(lp_inCharge)));
}

void libNtve_gf_GameRemoveCooldown (string lp_inCooldown) {
    // Automatic Variable Declarations
    // Implementation
    GameAddCooldown(lp_inCooldown, (-1.0 * GameGetCooldown(lp_inCooldown)));
}

void libNtve_gf_PreloadModelAnimation (string lp_file, bool lp_queue) {
    // Automatic Variable Declarations
    // Implementation
    PreloadModel(lp_file, lp_queue);
}

void libNtve_gf_PreloadModelObject (string lp_id, bool lp_queue) {
    // Automatic Variable Declarations
    // Implementation
    PreloadObject(c_gameCatalogModel, (lp_id), lp_queue);
}

void libNtve_gf_PreloadSoundObject (string lp_id, bool lp_queue) {
    // Automatic Variable Declarations
    // Implementation
    PreloadObject(c_gameCatalogSound, (lp_id), lp_queue);
}

void libNtve_gf_PreloadSoundtrack (string lp_soundtrack, bool lp_queue) {
    // Automatic Variable Declarations
    // Implementation
    PreloadObject(c_gameCatalogSoundtrack, (lp_soundtrack), lp_queue);
}

void libNtve_gf_PreloadUnit (string lp_unit, bool lp_queue) {
    // Automatic Variable Declarations
    // Implementation
    PreloadObject(c_gameCatalogUnit, (lp_unit), lp_queue);
}

void libNtve_gf_WaitForTimer (timer lp_timer, fixed lp_time, bool lp_waitType) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_waitType == true)) {
        while (!((TimerGetElapsed(lp_timer) >= lp_time))) {
            Wait(0.05, c_timeGame);
        }
    }
    else {
        while (!((TimerGetRemaining(lp_timer) <= lp_time))) {
            Wait(0.05, c_timeGame);
        }
    }
}

void libNtve_gf_ShowHideLeaderboard (int lp_board, bool lp_showHide, playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_showHide == true)) {
        BoardSetState(lp_board, lp_players, c_boardStateShowing, true);
    }
    else {
        BoardSetState(lp_board, lp_players, c_boardStateShowing, false);
    }
}

void libNtve_gf_CreateRandomItemLootAtPoint (int lp_dropPlayer, point lp_dropLocation, int lp_level, string lp_class, int lp_killerPlayer) {
    // Variable Declarations
    string lv_generator;
    string lv_level;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_generator = "TriggerRandomItemGeneratorAnyClass";
    lv_level = IntToString(lp_level);

    // Implementation
    if ((lp_class != "")) {
        lv_generator = "TriggerRandomItemGenerator";
        CatalogReferenceSet("Loot,TriggerRandomItemGenerator,ClassArray[0]", lp_dropPlayer, (lp_class));
    }
    else {
        CatalogFieldValueSet(c_gameCatalogLoot, lv_generator, "MaxLevel", lp_dropPlayer, lv_level);
    }
    CatalogFieldValueSet(c_gameCatalogLoot, lv_generator, "MinLevel", lp_dropPlayer, lv_level);
    UnitLootDropPoint(lp_dropPlayer, lp_dropLocation, lv_generator, lp_killerPlayer);
}

int libNtve_gf_ArithmeticIntClamp (int lp_value, int lp_min, int lp_max) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_value < lp_min)) {
        return lp_min;
    }

    if ((lp_value > lp_max)) {
        return lp_max;
    }

    return lp_value;
}

fixed libNtve_gf_ArithmeticRealClamp (fixed lp_value, fixed lp_min, fixed lp_max) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_value < lp_min)) {
        return lp_min;
    }

    if ((lp_value > lp_max)) {
        return lp_max;
    }

    return lp_value;
}

fixed libNtve_gf_Log (fixed lp_x, fixed lp_x2) {
    // Automatic Variable Declarations
    // Implementation
    return (Log2(lp_x)/Log2(lp_x2));
}

fixed libNtve_gf_RandomPercent () {
    // Automatic Variable Declarations
    // Implementation
    return RandomFixed(0.0, 100.0);
}

fixed libNtve_gf_RandomAngle () {
    // Automatic Variable Declarations
    // Implementation
    return RandomFixed(0.0, 360.0);
}

order libNtve_gf_ReviveOrderTargetingPoint (abilcmd lp_abilCmd, point lp_p, unit lp_reviveUnit) {
    // Variable Declarations
    order lv_reviveOrder;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_reviveOrder = OrderTargetingPoint(lp_abilCmd, lp_p);
    OrderSetTargetItem(lv_reviveOrder, lp_reviveUnit);
    return lv_reviveOrder;
}

order libNtve_gf_ReviveOrderWithNoTarget (abilcmd lp_abilCmd, unit lp_reviveUnit) {
    // Variable Declarations
    order lv_reviveOrder;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_reviveOrder = Order(lp_abilCmd);
    OrderSetTargetItem(lv_reviveOrder, lp_reviveUnit);
    return lv_reviveOrder;
}

void libNtve_gf_CreatePingFacingAngle (playergroup lp_players, string lp_model, point lp_position, color lp_color, fixed lp_duration, fixed lp_angle) {
    // Variable Declarations
    point lv_pointWithAngle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_pointWithAngle = libNtve_gf_PointFacingAngle(lp_position, lp_angle);
    PingCreate(lp_players, lp_model, lv_pointWithAngle, lp_color, lp_duration);
}

void libNtve_gf_PlayerApplySkinReplacingExistingUnit (int lp_player, string lp_skin, bool lp_activateDeactivate) {
    // Variable Declarations
    string lv_modelOld;
    string lv_modelNew;
    int lv_i;
    int lv_c;
    string lv_entry;
    actor lv_ar;
    string lv_fromPath;
    string lv_toPath;
    string lv_replacementType;

    // Automatic Variable Declarations
    int auto8B0EB0F9_ae;
    const int auto8B0EB0F9_ai = 1;

    // Variable Initialization
    lv_modelOld = "";
    lv_modelNew = "";
    lv_c = (CatalogFieldValueCount(c_gameCatalogSkin, lp_skin, "ReplacementArray", c_playerAny) - 1);
    lv_fromPath = "From";
    lv_toPath = "To";
    lv_replacementType = "";

    // Implementation
    PlayerApplySkin(lp_player, lp_skin, lp_activateDeactivate);
    if ((lp_activateDeactivate == false)) {
        lv_fromPath = "To";
        lv_toPath = "From";
    }

    ActorRegionCreate(null, "TriggerRegion", RegionEntireMap());
    lv_ar = libNtve_gf_ActorLastCreated();
    auto8B0EB0F9_ae = lv_c;
    lv_i = 0;
    for ( ; ( (auto8B0EB0F9_ai >= 0 && lv_i <= auto8B0EB0F9_ae) || (auto8B0EB0F9_ai < 0 && lv_i >= auto8B0EB0F9_ae) ) ; lv_i += auto8B0EB0F9_ai ) {
        lv_replacementType = CatalogFieldValueGet(c_gameCatalogSkin, lp_skin, "ReplacementArray[" + IntToString(lv_i) + "].Catalog", c_playerAny);
        if ((lv_replacementType == "Model")) {
            lv_modelOld = CatalogFieldValueGet(c_gameCatalogSkin, lp_skin, (("ReplacementArray[" + IntToString(lv_i) + "]." + lv_fromPath)), c_playerAny);
            lv_modelNew = CatalogFieldValueGet(c_gameCatalogSkin, lp_skin, (("ReplacementArray[" + IntToString(lv_i) + "]." + lv_toPath)), c_playerAny);
            if ((CatalogEntryIsValid(c_gameCatalogModel, lv_modelOld) == true) && (CatalogEntryIsValid(c_gameCatalogModel, lv_modelNew) == true)) {
                ActorRegionSend(lv_ar, c_actorIntersectAgainstRadiusContact, (("ModelSwap " + lv_modelNew)), "Unit", ("ModelName " + lv_modelOld + "; PlayerId " + IntToString(lp_player) + " " + IntToString(lp_player)));
            }

        }

    }
    ActorSend(lv_ar, "Destroy");
}

void libNtve_gf_ClearAlliance (int lp_sourcePlayer, int lp_targetPlayer) {
    // Automatic Variable Declarations
    // Implementation
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdChat, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdSeekHelp, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdGiveHelp, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPushable, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdSpend, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdTrade, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdControl, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdDefeat, lp_targetPlayer, false);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, false);
}

void libNtve_gf_MakeAlly (int lp_sourcePlayer, int lp_targetPlayer) {
    // Automatic Variable Declarations
    // Implementation
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdChat, lp_targetPlayer, true);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdSeekHelp, lp_targetPlayer, true);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdGiveHelp, lp_targetPlayer, true);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer, true);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdTrade, lp_targetPlayer, true);
    PlayerSetAlliance(lp_sourcePlayer, c_allianceIdDefeat, lp_targetPlayer, true);
}

void libNtve_gf_SetAlliance (int lp_sourcePlayer, int lp_targetPlayer, int lp_alliance) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_SetAllianceOneWay(lp_sourcePlayer, lp_targetPlayer, lp_alliance);
    libNtve_gf_SetAllianceOneWay(lp_targetPlayer, lp_sourcePlayer, lp_alliance);
}

void libNtve_gf_SetAllianceOneWay (int lp_sourcePlayer, int lp_targetPlayer, int lp_alliance) {
    // Automatic Variable Declarations
    int autoC4A67CFA_val;

    // Implementation
    if ((lp_sourcePlayer != lp_targetPlayer)) {
        libNtve_gf_ClearAlliance(lp_sourcePlayer, lp_targetPlayer);
        autoC4A67CFA_val = lp_alliance;
        if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_Ally) {
            libNtve_gf_MakeAlly(lp_sourcePlayer, lp_targetPlayer);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_AllyWithSharedVision) {
            libNtve_gf_MakeAlly(lp_sourcePlayer, lp_targetPlayer);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_AllyWithSharedVisionAndPushable) {
            libNtve_gf_MakeAlly(lp_sourcePlayer, lp_targetPlayer);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPushable, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_AllyWithSharedVisionAndControl) {
            libNtve_gf_MakeAlly(lp_sourcePlayer, lp_targetPlayer);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPushable, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdControl, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_AllyWithSharedVisionControlAndSpending) {
            libNtve_gf_MakeAlly(lp_sourcePlayer, lp_targetPlayer);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPushable, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdControl, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdSpend, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_Neutral) {
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_NeutralWithSharedVision) {
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_NeutralWithSharedVisionAndPushable) {
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdPushable, lp_targetPlayer, true);
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_Enemy) {
        }
        else if (autoC4A67CFA_val == libNtve_ge_AllianceSetting_EnemyWithSharedVision) {
            PlayerSetAlliance(lp_sourcePlayer, c_allianceIdVision, lp_targetPlayer, true);
        }
        else {
        }
    }

}

void libNtve_gf_SetPlayerGroupAlliance (playergroup lp_players, int lp_alliance) {
    // Variable Declarations
    int lv_player1;
    int lv_player2;

    // Automatic Variable Declarations
    playergroup autoC679B4B5_g;
    playergroup auto92EC5468_g;

    // Variable Initialization

    // Implementation
    autoC679B4B5_g = lp_players;
    lv_player1 = -1;
    while (true) {
        lv_player1 = PlayerGroupNextPlayer(autoC679B4B5_g, lv_player1);
        if (lv_player1 < 0) { break; }
        auto92EC5468_g = lp_players;
        lv_player2 = -1;
        while (true) {
            lv_player2 = PlayerGroupNextPlayer(auto92EC5468_g, lv_player2);
            if (lv_player2 < 0) { break; }
            if ((lv_player1 != lv_player2)) {
                libNtve_gf_SetAllianceOneWay(lv_player1, lv_player2, lp_alliance);
            }

        }
    }
}

void libNtve_gf_SetAllianceBetweenTwoPlayerGroups (playergroup lp_sourcePlayers, playergroup lp_targetPlayers, int lp_alliance) {
    // Variable Declarations
    int lv_player1;
    int lv_player2;

    // Automatic Variable Declarations
    playergroup auto5D267C1B_g;
    playergroup auto0889F63A_g;

    // Variable Initialization

    // Implementation
    auto5D267C1B_g = lp_sourcePlayers;
    lv_player1 = -1;
    while (true) {
        lv_player1 = PlayerGroupNextPlayer(auto5D267C1B_g, lv_player1);
        if (lv_player1 < 0) { break; }
        auto0889F63A_g = lp_targetPlayers;
        lv_player2 = -1;
        while (true) {
            lv_player2 = PlayerGroupNextPlayer(auto0889F63A_g, lv_player2);
            if (lv_player2 < 0) { break; }
            if ((lv_player1 != lv_player2)) {
                libNtve_gf_SetAllianceOneWay(lv_player1, lv_player2, lp_alliance);
            }

        }
    }
}

void libNtve_gf_SetAllianceAspectForPlayerGroup (playergroup lp_players, int lp_inAllianceId, bool lp_ally) {
    // Variable Declarations
    int lv_player1;
    int lv_player2;

    // Automatic Variable Declarations
    playergroup autoD869EC3F_g;
    playergroup autoF24022F6_g;

    // Variable Initialization

    // Implementation
    autoD869EC3F_g = lp_players;
    lv_player1 = -1;
    while (true) {
        lv_player1 = PlayerGroupNextPlayer(autoD869EC3F_g, lv_player1);
        if (lv_player1 < 0) { break; }
        autoF24022F6_g = lp_players;
        lv_player2 = -1;
        while (true) {
            lv_player2 = PlayerGroupNextPlayer(autoF24022F6_g, lv_player2);
            if (lv_player2 < 0) { break; }
            if ((lv_player1 != lv_player2)) {
                PlayerSetAlliance(lv_player1, lp_inAllianceId, lv_player2, lp_ally);
            }

        }
    }
}

bool libNtve_gf_PlayerIsEnemy (int lp_sourcePlayer, int lp_targetPlayer, int lp_relation) {
    // Automatic Variable Declarations
    int auto180886E4_val;

    // Implementation
    auto180886E4_val = lp_relation;
    if (auto180886E4_val == libNtve_ge_PlayerRelation_Ally) {
        return (PlayerGetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer) && PlayerGetAlliance(lp_sourcePlayer, c_allianceIdChat, lp_targetPlayer));
    }
    else if (auto180886E4_val == libNtve_ge_PlayerRelation_AllyMutual) {
        return (PlayerGetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer) && PlayerGetAlliance(lp_sourcePlayer, c_allianceIdChat, lp_targetPlayer) && PlayerGetAlliance(lp_targetPlayer, c_allianceIdPassive, lp_sourcePlayer) && PlayerGetAlliance(lp_targetPlayer, c_allianceIdChat, lp_sourcePlayer));
    }
    else if (auto180886E4_val == libNtve_ge_PlayerRelation_Neutral) {
        return (PlayerGetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer) && !(PlayerGetAlliance(lp_sourcePlayer, c_allianceIdChat, lp_targetPlayer)));
    }
    else if (auto180886E4_val == libNtve_ge_PlayerRelation_NeutralMutual) {
        return (PlayerGetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer) && !(PlayerGetAlliance(lp_sourcePlayer, c_allianceIdChat, lp_targetPlayer)) && PlayerGetAlliance(lp_targetPlayer, c_allianceIdPassive, lp_sourcePlayer) && !(PlayerGetAlliance(lp_targetPlayer, c_allianceIdChat, lp_sourcePlayer)));
    }
    else if (auto180886E4_val == libNtve_ge_PlayerRelation_Enemy) {
        return !(PlayerGetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer));
    }
    else if (auto180886E4_val == libNtve_ge_PlayerRelation_EnemyMutual) {
        return (!(PlayerGetAlliance(lp_sourcePlayer, c_allianceIdPassive, lp_targetPlayer)) && !(PlayerGetAlliance(lp_targetPlayer, c_allianceIdPassive, lp_sourcePlayer)));
    }
    else {
    }
    return false;
}

void libNtve_gf_PlayerRemoveChargeRegen (int lp_inPlayer, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    PlayerAddChargeRegen(lp_inPlayer, lp_inCharge, (-1.0 * PlayerGetChargeRegen(lp_inPlayer, lp_inCharge)));
}

void libNtve_gf_PlayerRemoveChargeUsed (int lp_inPlayer, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    PlayerAddChargeUsed(lp_inPlayer, lp_inCharge, (-1.0 * PlayerGetChargeUsed(lp_inPlayer, lp_inCharge)));
}

void libNtve_gf_PlayerRemoveCooldown (int lp_inPlayer, string lp_inCooldown) {
    // Automatic Variable Declarations
    // Implementation
    PlayerAddCooldown(lp_inPlayer, lp_inCooldown, (-1.0 * PlayerGetCooldown(lp_inPlayer, lp_inCooldown)));
}

playergroup libNtve_gf_AlliesEnemiesOfPlayerCountInactiveAndSelf (int lp_alliance, int lp_player) {
    // Variable Declarations
    int lv_itPlayer;
    playergroup lv_playerGroup;

    // Automatic Variable Declarations
    playergroup autoB554E2D1_g;

    // Variable Initialization
    lv_playerGroup = PlayerGroupEmpty();

    // Implementation
    if ((lp_player == c_playerAny)) {
        return PlayerGroupEmpty();
    }

    autoB554E2D1_g = PlayerGroupAll();
    lv_itPlayer = -1;
    while (true) {
        lv_itPlayer = PlayerGroupNextPlayer(autoB554E2D1_g, lv_itPlayer);
        if (lv_itPlayer < 0) { break; }
        if ((libNtve_gf_PlayerIsEnemy(lp_player, lv_itPlayer, lp_alliance) == true)) {
            PlayerGroupAdd(lv_playerGroup, lv_itPlayer);
        }

    }
    return lv_playerGroup;
}

void libNtve_gf_AddPlayerGroupToPlayerGroup (playergroup lp_sourceGroup, playergroup lp_targetGroup) {
    // Variable Declarations
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup auto57A2B8C2_g;

    // Variable Initialization

    // Implementation
    auto57A2B8C2_g = lp_sourceGroup;
    lv_pickedPlayer = -1;
    while (true) {
        lv_pickedPlayer = PlayerGroupNextPlayer(auto57A2B8C2_g, lv_pickedPlayer);
        if (lv_pickedPlayer < 0) { break; }
        PlayerGroupAdd(lp_targetGroup, lv_pickedPlayer);
    }
}

void libNtve_gf_RemovePlayerGroupFromPlayerGroup (playergroup lp_sourceGroup, playergroup lp_targetGroup) {
    // Variable Declarations
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup auto2647939F_g;

    // Variable Initialization

    // Implementation
    auto2647939F_g = lp_sourceGroup;
    lv_pickedPlayer = -1;
    while (true) {
        lv_pickedPlayer = PlayerGroupNextPlayer(auto2647939F_g, lv_pickedPlayer);
        if (lv_pickedPlayer < 0) { break; }
        PlayerGroupRemove(lp_targetGroup, lv_pickedPlayer);
    }
}

playergroup libNtve_gf_UnionOfPlayerGroups (playergroup lp_groupA, playergroup lp_groupB) {
    // Variable Declarations
    playergroup lv_group;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_group = PlayerGroupCopy(lp_groupA);

    // Implementation
    libNtve_gf_AddPlayerGroupToPlayerGroup(lp_groupB, lv_group);
    return lv_group;
}

playergroup libNtve_gf_IntersectionOfPlayerGroups (playergroup lp_groupA, playergroup lp_groupB) {
    // Variable Declarations
    playergroup lv_group;
    int lv_itPlayer;

    // Automatic Variable Declarations
    playergroup auto6FEE7F4A_g;

    // Variable Initialization
    lv_group = PlayerGroupEmpty();

    // Implementation
    auto6FEE7F4A_g = lp_groupA;
    lv_itPlayer = -1;
    while (true) {
        lv_itPlayer = PlayerGroupNextPlayer(auto6FEE7F4A_g, lv_itPlayer);
        if (lv_itPlayer < 0) { break; }
        if ((PlayerGroupHasPlayer(lp_groupB, lv_itPlayer) == true)) {
            PlayerGroupAdd(lv_group, lv_itPlayer);
        }

    }
    return lv_group;
}

point libNtve_gf_PointFromPositionAndAngle (point lp_point, fixed lp_angle) {
    // Variable Declarations
    point lv_pointWithFacing;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_pointWithFacing = lp_point;
    PointSetFacing(lv_pointWithFacing, lp_angle);
    return lv_pointWithFacing;
}

point libNtve_gf_PointFromXYZ (fixed lp_x, fixed lp_y, fixed lp_y2) {
    // Variable Declarations
    point lv_point;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_point = Point(lp_x, lp_y);
    PointSetHeight(lv_point, lp_y2);
    return lv_point;
}

point libNtve_gf_PointFacingAngle (point lp_point, fixed lp_angle) {
    // Variable Declarations
    point lv_pointWithFacing;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_pointWithFacing = libNtve_gf_PointFromXYZ(PointGetX(lp_point), PointGetY(lp_point), PointGetHeight(lp_point));
    PointSetFacing(lv_pointWithFacing, lp_angle);
    return lv_pointWithFacing;
}

point libNtve_gf_PointWithZOffset (point lp_p, fixed lp_z) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_PointFromXYZ(PointGetX(lp_p), PointGetY(lp_p), lp_z);
}

point libNtve_gf_PointOffsetTowardsPoint (point lp_sourcePoint, fixed lp_distance, point lp_targetPoint) {
    // Automatic Variable Declarations
    // Implementation
    return PointWithOffsetPolar(lp_sourcePoint, lp_distance, AngleBetweenPoints(lp_sourcePoint, lp_targetPoint));
}

point libNtve_gf_RandomPointBetweenPoints (point lp_point1, point lp_point2) {
    // Variable Declarations
    fixed lv_p1Weight;
    fixed lv_x;
    fixed lv_y;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_p1Weight = RandomFixed(0.0, 1.0);
    lv_x = ((lv_p1Weight * PointGetX(lp_point1)) + ((1.0 - lv_p1Weight) * PointGetX(lp_point2)));
    lv_y = ((lv_p1Weight * PointGetY(lp_point1)) + ((1.0 - lv_p1Weight) * PointGetY(lp_point2)));
    return Point(lv_x, lv_y);
}

int libNtve_gf_CinematicPortrait (int lp_position) {
    // Variable Declarations
    int lv_index;
    int lv_width;
    int lv_height;
    int lv_anchor;
    int lv_offsetX;
    int lv_offsetY;

    // Automatic Variable Declarations
    int auto0CE35058_val;

    // Variable Initialization
    lv_anchor = c_anchorBottomLeft;

    // Implementation
    lv_height = 360;
    lv_width = FixedToInt((IntToFixed(lv_height) * (144.0 / 219.0)));
    lv_offsetX = 25;
    auto0CE35058_val = lp_position;
    if (auto0CE35058_val == libNtve_ge_CinematicPortraitPosition_TopLeft) {
        lv_index = libNtve_ge_CinematicPortraitIndex_CinematicPortraitTopLeft;
        lv_anchor = c_anchorTopLeft;
        lv_offsetY = 90;
    }
    else if (auto0CE35058_val == libNtve_ge_CinematicPortraitPosition_TopRight) {
        lv_index = libNtve_ge_CinematicPortraitIndex_CinematicPortraitTopRight;
        lv_anchor = c_anchorTopRight;
        lv_offsetY = 90;
    }
    else if (auto0CE35058_val == libNtve_ge_CinematicPortraitPosition_BottomLeft) {
        lv_index = libNtve_ge_CinematicPortraitIndex_CinematicPortraitBottomLeft;
        lv_anchor = c_anchorBottomLeft;
        lv_offsetY = 190;
    }
    else if (auto0CE35058_val == libNtve_ge_CinematicPortraitPosition_BottomRight) {
        lv_index = libNtve_ge_CinematicPortraitIndex_CinematicPortraitBottomRight;
        lv_anchor = c_anchorBottomRight;
        lv_offsetY = 190;
    }
    else if (auto0CE35058_val == libNtve_ge_CinematicPortraitPosition_CenterLeft) {
        lv_index = libNtve_ge_CinematicPortraitIndex_CinematicPortraitCenterLeft;
        lv_anchor = c_anchorLeft;
        lv_offsetY = -50;
    }
    else if (auto0CE35058_val == libNtve_ge_CinematicPortraitPosition_CenterRight) {
        lv_index = libNtve_ge_CinematicPortraitIndex_CinematicPortraitCenterRight;
        lv_anchor = c_anchorRight;
        lv_offsetY = -50;
    }
    else {
        return c_invalidPortraitId;
    }
    if ((libNtve_gv_cinematicPortraits[lv_index] != c_invalidPortraitId)) {
        return libNtve_gv_cinematicPortraits[lv_index];
    }

    PortraitCreate(lv_offsetX, lv_offsetY, lv_anchor, lv_width, lv_height, null, "Dflt", "", true, true);
    libNtve_gv_cinematicPortraits[lv_index] = PortraitLastCreated();
    PortraitSetBorderVisible(libNtve_gv_cinematicPortraits[lv_index], true);
    PortraitUseTransition(libNtve_gv_cinematicPortraits[lv_index], true);
    PortraitSetVisible(libNtve_gv_cinematicPortraits[lv_index], PlayerGroupAll(), false, false);
    return libNtve_gv_cinematicPortraits[lv_index];
}

void libNtve_gf_HideAllCinematicPortraits (playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitBottomLeft] != c_invalidPortraitId)) {
        PortraitSetVisible(libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitBottomLeft], lp_players, false, false);
    }

    if ((libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitBottomRight] != c_invalidPortraitId)) {
        PortraitSetVisible(libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitBottomRight], lp_players, false, false);
    }

    if ((libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitCenterLeft] != c_invalidPortraitId)) {
        PortraitSetVisible(libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitCenterLeft], lp_players, false, false);
    }

    if ((libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitCenterRight] != c_invalidPortraitId)) {
        PortraitSetVisible(libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitCenterRight], lp_players, false, false);
    }

    if ((libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitTopLeft] != c_invalidPortraitId)) {
        PortraitSetVisible(libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitTopLeft], lp_players, false, false);
    }

    if ((libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitTopRight] != c_invalidPortraitId)) {
        PortraitSetVisible(libNtve_gv_cinematicPortraits[libNtve_ge_CinematicPortraitIndex_CinematicPortraitTopRight], lp_players, false, false);
    }

}

int libNtve_gf_FullscreenPortrait () {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_index = libNtve_ge_CinematicPortraitIndex_FullscreenPortrait;
    if ((libNtve_gv_cinematicPortraits[lv_index] != c_invalidPortraitId)) {
        return libNtve_gv_cinematicPortraits[lv_index];
    }

    PortraitCreate(0, 0, c_anchorCenter, 0, 0, null, "Dflt", "", true, true);
    libNtve_gv_cinematicPortraits[lv_index] = PortraitLastCreated();
    PortraitSetFullscreen(libNtve_gv_cinematicPortraits[lv_index], true);
    PortraitSetBorderVisible(libNtve_gv_cinematicPortraits[lv_index], false);
    PortraitUseTransition(libNtve_gv_cinematicPortraits[lv_index], false);
    PortraitSetVisible(libNtve_gv_cinematicPortraits[lv_index], PlayerGroupAll(), false, false);
    return libNtve_gv_cinematicPortraits[lv_index];
}

void libNtve_gf_PortraitSetAnim (int lp_Portrait, string lp_Anim, string lp_identifier, int lp_flags, fixed lp_blendTime) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_PlayAnimation(ActorFromPortrait(lp_Portrait), lp_identifier, lp_Anim, lp_flags, lp_blendTime);
}

void libNtve_gf_ClearPortraitAnimation (int lp_portrait, string lp_identifier) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_ClearAnimation(ActorFromPortrait(lp_portrait), lp_identifier);
}

fixed libNtve_gf_WidthOfRegion (region lp_region) {
    // Automatic Variable Declarations
    // Implementation
    return AbsF((PointGetX(RegionGetBoundsMax(lp_region)) - PointGetX(RegionGetBoundsMin(lp_region))));
}

fixed libNtve_gf_HeightOfRegion (region lp_region) {
    // Automatic Variable Declarations
    // Implementation
    return AbsF((PointGetY(RegionGetBoundsMax(lp_region)) - PointGetY(RegionGetBoundsMin(lp_region))));
}

bool libNtve_gf_UnitTypeIsSelected (string lp_unitType, int lp_player) {
    // Variable Declarations
    unit lv_indexUnit;

    // Automatic Variable Declarations
    unitgroup auto338A0609_g;
    int auto338A0609_u;

    // Variable Initialization

    // Implementation
    auto338A0609_g = UnitGroupSelected(lp_player);
    auto338A0609_u = UnitGroupCount(auto338A0609_g, c_unitCountAll);
    for (;; auto338A0609_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(auto338A0609_g, auto338A0609_u);
        if (lv_indexUnit == null) { break; }
        if ((UnitGetType(lv_indexUnit) == lp_unitType)) {
            return true;
        }

    }
    return false;
}

void libNtve_gf_StoreUnitSelection (int lp_forPlayer, int lp_storeOption) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv_unitSelectionStored[lp_forPlayer] = UnitGroupSelected(lp_forPlayer);
    if ((lp_storeOption == libNtve_ge_UnitSelectionStoreOption_ClearUnitSelection)) {
        UnitClearSelection(lp_forPlayer);
    }

}

void libNtve_gf_RestoreUnitSelection (int lp_forPlayer) {
    // Automatic Variable Declarations
    // Implementation
    UnitClearSelection(lp_forPlayer);
    UnitGroupSelect(libNtve_gv_unitSelectionStored[lp_forPlayer], lp_forPlayer, true);
}

void libNtve_gf_CopyUnitControlGroups (unit lp_sourceUnit, unit lp_targetUnit) {
    // Variable Declarations
    playergroup lv_clearSelectionGroup;
    int lv_itPlayer;

    // Automatic Variable Declarations
    playergroup auto8C5BEE0F_g;
    playergroup auto52E24D77_g;

    // Variable Initialization
    lv_clearSelectionGroup = PlayerGroupEmpty();

    // Implementation
    auto8C5BEE0F_g = PlayerGroupActive();
    lv_itPlayer = -1;
    while (true) {
        lv_itPlayer = PlayerGroupNextPlayer(auto8C5BEE0F_g, lv_itPlayer);
        if (lv_itPlayer < 0) { break; }
        if ((UnitIsSelected(lp_targetUnit, lv_itPlayer) == false)) {
            PlayerGroupAdd(lv_clearSelectionGroup, lv_itPlayer);
        }

    }
    UnitCreateEffectUnit(lp_targetUnit, "CopyTargetSelectionAndControlGroups", lp_sourceUnit);
    auto52E24D77_g = lv_clearSelectionGroup;
    lv_itPlayer = -1;
    while (true) {
        lv_itPlayer = PlayerGroupNextPlayer(auto52E24D77_g, lv_itPlayer);
        if (lv_itPlayer < 0) { break; }
        UnitSelect(lp_targetUnit, lv_itPlayer, false);
    }
}

void SoundPlayScene (soundlink lp_soundLink, playergroup lp_players, unitgroup lp_units, string lp_animation) {
    // Automatic Variable Declarations
    // Implementation
    SoundPlaySceneForPlayer(lp_soundLink, c_maxPlayers, lp_players, lp_units, lp_animation);
}

void SoundPlay (soundlink lp_soundLink, playergroup lp_players, fixed lp_volume, fixed lp_offset) {
    // Automatic Variable Declarations
    // Implementation
    SoundPlayForPlayer(lp_soundLink, c_maxPlayers, lp_players, lp_volume, lp_offset);
}

void SoundPlayOnUnit (soundlink lp_soundLink, playergroup lp_players, unit lp_unit, fixed lp_height, fixed lp_volume, fixed lp_offset) {
    // Automatic Variable Declarations
    // Implementation
    SoundPlayOnUnitForPlayer(lp_soundLink, c_maxPlayers, lp_players, lp_unit, lp_height, lp_volume, lp_offset);
}

void SoundPlayAtPoint (soundlink lp_soundLink, playergroup lp_players, point lp_location, fixed lp_height, fixed lp_volume, fixed lp_offset) {
    // Automatic Variable Declarations
    // Implementation
    SoundPlayAtPointForPlayer(lp_soundLink, c_maxPlayers, lp_players, lp_location, lp_height, lp_volume, lp_offset);
}

void libNtve_gf_SetAllSoundChannelVolumes (int lp_mode, playergroup lp_players, fixed lp_duration) {
    // Automatic Variable Declarations
    int auto37650D48_val;

    // Implementation
    auto37650D48_val = lp_mode;
    if (auto37650D48_val == libNtve_ge_VolumeChannelMode_Cinematic) {
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAlert, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAmbient, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryBuild, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDialogue, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDoodad, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFlames, 60.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFoley, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryGather, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryME, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMission, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovement, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovie, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 70.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryOther, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryReady, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySAmbient, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySEmitters, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySPieces, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySpell, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryTV, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUI, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser11, 0.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser18, 0.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryVoice, 0.0, lp_duration);
    }
    else if (auto37650D48_val == libNtve_ge_VolumeChannelMode_Speech) {
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAlert, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAmbient, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryBuild, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDialogue, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDoodad, 40.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFlames, 60.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFoley, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryGather, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryME, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMission, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovement, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovie, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 70.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryOther, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryReady, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySAmbient, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySEmitters, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySPieces, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySpell, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryTV, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUI, 25.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser11, 0.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser18, 0.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryVoice, 0.0, lp_duration);
    }
    else if (auto37650D48_val == libNtve_ge_VolumeChannelMode_Game) {
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAlert, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAmbient, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryBuild, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDialogue, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDoodad, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFlames, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFoley, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryGather, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryME, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMission, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovement, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovie, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryOther, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryReady, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySAmbient, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySEmitters, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySPieces, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySpell, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryTV, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUI, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser11, 100.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser18, 100.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryVoice, 100.0, lp_duration);
    }
    else if (auto37650D48_val == libNtve_ge_VolumeChannelMode_Victory) {
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAlert, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryAmbient, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryBuild, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryCombat, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDeath, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDialogue, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryDoodad, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFlames, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryFoley, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryGather, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryME, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMission, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovement, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMovie, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryMusic, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryOther, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryReady, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySAmbient, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySEmitters, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySPieces, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategorySpell, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryTV, 0.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUI, 100.0, lp_duration);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser11, 0.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryUser18, 0.0, 0.0);
        SoundChannelSetVolume(PlayerGroupAll(), c_soundCategoryVoice, 0.0, lp_duration);
    }
    else {
    }
}

void libNtve_gf__StoryModeOnOffForPlayer (int lp_player, bool lp_onOff) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_onOff == true)) {
        PlayerGroupAdd(libNtve_gv__PlayersInStoryMode, lp_player);
    }
    else {
        PlayerGroupRemove(libNtve_gv__PlayersInStoryMode, lp_player);
    }
}

void libNtve_gf__StoryModeOnOffForPlayerGroup (playergroup lp_players, bool lp_onOff) {
    // Variable Declarations
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup auto476D40C9_g;

    // Variable Initialization

    // Implementation
    auto476D40C9_g = lp_players;
    lv_pickedPlayer = -1;
    while (true) {
        lv_pickedPlayer = PlayerGroupNextPlayer(auto476D40C9_g, lv_pickedPlayer);
        if (lv_pickedPlayer < 0) { break; }
        libNtve_gf__StoryModeOnOffForPlayer(lv_pickedPlayer, lp_onOff);
    }
}

void libNtve_gf__StoryModeHideUI (playergroup lp_players) {
    // Variable Declarations
    int lv_indexFrame;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_indexFrame = c_syncFrameTypeMenuBar;

    // Implementation
    libNtve_gf__StoreGameUIVisibleStates(true, lp_players, libNtve_ge_GameUIStoreIndex_StoryMode);
    lv_indexFrame = c_syncFrameTypeFirst;
    for ( ; lv_indexFrame <= c_syncFrameTypeLast ; lv_indexFrame += 1 ) {
        if ((libNtve_gf_UIFrameFlagCheck(lv_indexFrame, libNtve_ge_UIFrameFlag_StoryModeFrame) == false) && (libNtve_gv__GameUIFrameFiltered[(lv_indexFrame)] == false)) {
            UISetFrameVisible(lp_players, lv_indexFrame, false);
        }

    }
}

void libNtve_gf__StoryModeRestoreUI (playergroup lp_players) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf__StoreGameUIVisibleStates(false, lp_players, libNtve_ge_GameUIStoreIndex_StoryMode);
}

void libNtve_gf_StoryMode (playergroup lp_players, bool lp_onOff) {
    // Variable Declarations
    playergroup lv_validPlayers;
    int lv_pickedPlayer;

    // Automatic Variable Declarations
    playergroup auto4DCAC640_g;
    playergroup autoF122BA15_g;
    playergroup auto24E8EA3B_g;
    playergroup autoD6B5FE03_g;

    // Variable Initialization
    lv_validPlayers = PlayerGroupEmpty();

    // Implementation
    lv_validPlayers = PlayerGroupCopy(lp_players);
    if ((lp_onOff == true)) {
        auto24E8EA3B_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto24E8EA3B_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInStoryMode(lv_pickedPlayer) == true)) {
                PlayerGroupRemove(lv_validPlayers, lv_pickedPlayer);
            }

        }
        if ((PlayerGroupCount(lv_validPlayers) == 0)) {
            return ;
        }

        libNtve_gf__StoryModeOnOffForPlayerGroup(lv_validPlayers, true);
        libNtve_gf__StoryModeHideUI(lv_validPlayers);
        autoD6B5FE03_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(autoD6B5FE03_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInCinematicMode(lv_pickedPlayer) == false)) {
                UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeFullscreen, 0.0);
            }
            else {
                UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeLetterboxed, 0.0);
            }
        }
        StoryMode(lv_validPlayers, true);
    }
    else {
        auto4DCAC640_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(auto4DCAC640_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInStoryMode(lv_pickedPlayer) == false)) {
                PlayerGroupRemove(lv_validPlayers, lv_pickedPlayer);
            }

        }
        if ((PlayerGroupCount(lv_validPlayers) == 0)) {
            return ;
        }

        libNtve_gf__StoryModeOnOffForPlayerGroup(lv_validPlayers, false);
        libNtve_gf__StoryModeRestoreUI(lv_validPlayers);
        autoF122BA15_g = lv_validPlayers;
        lv_pickedPlayer = -1;
        while (true) {
            lv_pickedPlayer = PlayerGroupNextPlayer(autoF122BA15_g, lv_pickedPlayer);
            if (lv_pickedPlayer < 0) { break; }
            if ((libNtve_gf_PlayerInCinematicMode(lv_pickedPlayer) == false)) {
                UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeConsole, 0.0);
            }
            else {
                UISetMode(PlayerGroupSingle(lv_pickedPlayer), c_uiModeLetterboxed, 0.0);
            }
        }
        StoryMode(lv_validPlayers, false);
    }
}

bool libNtve_gf_PlayerInStoryMode (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return PlayerGroupHasPlayer(libNtve_gv__PlayersInStoryMode, lp_player);
}

void libNtve_gf_SetUpgradeLevelForPlayer (int lp_p, string lp_upgrade, int lp_levels) {
    // Variable Declarations
    int lv_levelCurrent;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_levelCurrent = TechTreeUpgradeCount(lp_p, lp_upgrade, c_techCountCompleteOnly);
    TechTreeUpgradeAddLevel(lp_p, lp_upgrade, (lp_levels - lv_levelCurrent));
}

void libNtve_gf_StopTimer (timer lp_timer) {
    // Automatic Variable Declarations
    // Implementation
    TimerStart(lp_timer, 0.0, false, c_timeGame);
    TimerPause(lp_timer, true);
}

void libNtve_gf_SendTransmissionSimple (transmissionsource lp_Source, int lp_Target, soundlink lp_Sound, fixed lp_Duration, int lp_DurationType, bool lp_WaitUntilDone) {
    // Automatic Variable Declarations
    // Implementation
    TransmissionSend(PlayerGroupAll(), lp_Source, lp_Target, "Talk", lp_Sound, null, null, lp_Duration, lp_DurationType, lp_WaitUntilDone);
}

int TransmissionSendAdvanced (playergroup lp_Players, transmissionsource lp_Source, int lp_Target, string lp_portraitActor, string lp_PortraitAnim, soundlink lp_Sound, text lp_Speaker, text lp_Subtitle, fixed lp_Duration, int lp_DurationType, bool lp_WaitUntilDone) {
    // Automatic Variable Declarations
    // Implementation
    TransmissionSendForPlayer(lp_Players, lp_Source, lp_Target, lp_portraitActor, lp_PortraitAnim, lp_Sound, lp_Speaker, lp_Subtitle, lp_Duration, lp_DurationType, lp_WaitUntilDone, c_maxPlayers);
    return TransmissionLastSent();
}

int TransmissionSend (playergroup lp_Players, transmissionsource lp_Source, int lp_Target, string lp_PortraitAnim, soundlink lp_Sound, text lp_Speaker, text lp_Subtitle, fixed lp_Duration, int lp_DurationType, bool lp_WaitUntilDone) {
    // Automatic Variable Declarations
    // Implementation
    TransmissionSendForPlayer(lp_Players, lp_Source, lp_Target, "", lp_PortraitAnim, lp_Sound, lp_Speaker, lp_Subtitle, lp_Duration, lp_DurationType, lp_WaitUntilDone, c_maxPlayers);
    return TransmissionLastSent();
}

void libNtve_gf_TriggerExecuteByName (string lp_t, bool lp_check, bool lp_wait) {
    // Variable Declarations
    trigger lv_trigger;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_trigger = TriggerCreate(lp_t);

    // Implementation
    TriggerExecute(lv_trigger, lp_check, lp_wait);
    TriggerDestroy(lv_trigger);
}

void libNtve_gf_UIErrorMessage (playergroup lp_players, text lp_message, soundlink lp_sound) {
    // Automatic Variable Declarations
    // Implementation
    UIDisplayMessage(lp_players, c_messageAreaError, lp_message);
    SoundPlay(lp_sound, lp_players, 100.0, 0.0);
}

int libNtve_gf__BB_PortraitBorderWidth (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gv__BB_BarHeight[lp_barID]) - 40.0));
}

int libNtve_gf__BB_PortraitBorderHeight (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf__BB_PortraitBorderWidth(lp_barID);
}

int libNtve_gf__BB_PortraitWidth (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gf__BB_PortraitBorderWidth(lp_barID)) - 10.0));
}

int libNtve_gf__BB_PortraitHeight (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gf__BB_PortraitWidth(lp_barID)) - 0.0));
}

int libNtve_gf__BB_TitleBarWidth (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return ((libNtve_gv__BB_BarWidth[lp_barID] - libNtve_gf__BB_PortraitWidth(lp_barID)) - 30);
}

int libNtve_gf__BB_TitleBarHeight (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gv__BB_BarHeight[lp_barID]) * 0.4));
}

int libNtve_gf__BB_HPBorderWidth (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return (libNtve_gf__BB_TitleBarWidth(lp_barID) - 60);
}

int libNtve_gf__BB_HPBorderHeight (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gv__BB_BarHeight[lp_barID]) * 0.31));
}

int libNtve_gf__BB_HPBarWidth (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gf__BB_HPBorderWidth(lp_barID)) - 10.0));
}

int libNtve_gf__BB_HPBarHeight (int lp_barID) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt((IntToFixed(libNtve_gf__BB_HPBorderHeight(lp_barID)) - 3.0));
}

int libNtve_gf__BB_HPBarCurrentWidth (int lp_barID) {
    // Variable Declarations
    fixed lv_current;
    fixed lv_max;
    int lv_width;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((libNtve_gv__BB_Boss[lp_barID] == null)) {
        lv_current = libNtve_gv__BB_CurrentValue[lp_barID];
        lv_max = libNtve_gv__BB_MaxValue[lp_barID];
    }
    else {
        lv_current = (UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropLife, c_unitPropCurrent) + UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropShields, c_unitPropCurrent));
        lv_max = (UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropLifeMax, c_unitPropCurrent) + UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropShieldsMax, c_unitPropCurrent));
    }
    if ((lv_max <= 0.0)) {
        lv_max = 1.0;
    }

    if ((lv_current > lv_max)) {
        lv_current = lv_max;
    }

    lv_width = FixedToInt((IntToFixed(libNtve_gf__BB_HPBarWidth(lp_barID)) * (lv_current / lv_max)));
    return lv_width;
}

text libNtve_gf__BB_HPBarFormatLabel (int lp_barID) {
    // Variable Declarations
    fixed lv_current;
    fixed lv_max;
    text lv_label;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((libNtve_gv__BB_Boss[lp_barID] == null)) {
        lv_current = libNtve_gv__BB_CurrentValue[lp_barID];
        lv_max = libNtve_gv__BB_MaxValue[lp_barID];
    }
    else {
        lv_current = (UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropLife, c_unitPropCurrent) + UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropShields, c_unitPropCurrent));
        lv_max = (UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropLifeMax, c_unitPropCurrent) + UnitGetPropertyFixed(libNtve_gv__BB_Boss[lp_barID], c_unitPropShieldsMax, c_unitPropCurrent));
    }
    lv_label = (IntToText(FixedToInt(lv_current)) + StringExternal("Param/Value/lib_Ntve_22BDA933") + IntToText(FixedToInt(lv_max)));
    return lv_label;
}

trigger auto_libNtve_gf__BB_HPBarChange_Trigger = null;
int auto_libNtve_gf__BB_HPBarChange_lp_barID;

void libNtve_gf__BB_HPBarChange (int lp_barID) {
    auto_libNtve_gf__BB_HPBarChange_lp_barID = lp_barID;

    if (auto_libNtve_gf__BB_HPBarChange_Trigger == null) {
        auto_libNtve_gf__BB_HPBarChange_Trigger = TriggerCreate("auto_libNtve_gf__BB_HPBarChange_TriggerFunc");
    }

    TriggerExecute(auto_libNtve_gf__BB_HPBarChange_Trigger, false, false);
}

bool auto_libNtve_gf__BB_HPBarChange_TriggerFunc (bool testConds, bool runActions) {
    int lp_barID = auto_libNtve_gf__BB_HPBarChange_lp_barID;

    // Variable Declarations
    fixed lv_current;
    fixed lv_max;
    text lv_label;
    int lv_newWidth;
    int lv_width;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if (((libNtve_gv__BB_HPOldWidth[lp_barID] < 0) || (libNtve_gv__BB_HPOldWidth[lp_barID] > libNtve_gf__BB_HPBarWidth(lp_barID)))) {
        libNtve_gv__BB_HPOldWidth[lp_barID] = libNtve_gf__BB_HPBarWidth(lp_barID);
    }

    lv_newWidth = libNtve_gf__BB_HPBarCurrentWidth(lp_barID);
    lv_width = (libNtve_gv__BB_HPOldWidth[lp_barID] - lv_newWidth);
    libNtve_gv__BB_HPOldWidth[lp_barID] = lv_newWidth;
    if ((lv_width > 0)) {
        DialogControlCreate(libNtve_gv__BB_Dialog[lp_barID], c_triggerControlTypeImage);
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), c_triggerImageTypeBorder, PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), "Assets\\Textures\\ui_mission_leaderboard_progressbar_fill.dds", PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(DialogControlLastCreated(), Color(78.43, 78.43, 0.00), libNtve_gv__BB_Players[lp_barID]);
        DialogControlSetSize(DialogControlLastCreated(), libNtve_gv__BB_Players[lp_barID], lv_width, libNtve_gf__BB_HPBarHeight(lp_barID));
        DialogControlSetPositionRelative(DialogControlLastCreated(), libNtve_gv__BB_Players[lp_barID], c_anchorLeft, libNtve_gv__BB_HpFullImage[lp_barID], c_anchorLeft, MaxI((lv_newWidth - 1), 0), 0);
        DialogControlFadeTransparency(DialogControlLastCreated(), libNtve_gv__BB_Players[lp_barID], 0.2, 20.0);
        Wait(0.2, c_timeReal);
        DialogControlFadeTransparency(DialogControlLastCreated(), libNtve_gv__BB_Players[lp_barID], 0.8, 100.0);
        Wait(0.8, c_timeReal);
        DialogControlDestroy(DialogControlLastCreated());
    }

    return true;
}

void libNtve_gf_DisplayBossBar (int lp_bossBarID, string lp_portrait, text lp_title, int lp_max, playergroup lp_players) {
    // Variable Declarations
    const int lv_width = 800;
    const int lv_height = 100;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_bossBarID <= 0)) {
        return ;
    }

    if ((lp_bossBarID > libNtve_gv__BBC_BossBarMaxCount)) {
        UIDisplayMessage(lp_players, c_messageAreaSubtitle, (StringExternal("Param/Value/lib_Ntve_13ECDD4D") + IntToText(libNtve_gv__BBC_BossBarMaxCount) + StringExternal("Param/Value/lib_Ntve_84FA80EA")));
        return ;
    }

    libNtve_gv__BB_Players[lp_bossBarID] = lp_players;
    libNtve_gv__BB_Portraits[lp_bossBarID] = lp_portrait;
    libNtve_gv__BB_Title[lp_bossBarID] = lp_title;
    libNtve_gv__BB_Boss[lp_bossBarID] = null;
    libNtve_gf_SetBossBarMaximumValue(lp_bossBarID, lp_max, false);
    libNtve_gf_SetBossBarCurrentValue(lp_bossBarID, lp_max, false);
    libNtve_gv__BB_HPOldWidth[lp_bossBarID] = -1;
    if ((libNtve_gv__BB_Dialog[lp_bossBarID] == c_invalidDialogId)) {
        DialogCreate(libNtve_gv__BB_BarWidth[lp_bossBarID], libNtve_gv__BB_BarHeight[lp_bossBarID], c_anchorTop, 0, 50, false);
        libNtve_gv__BB_Dialog[lp_bossBarID] = DialogLastCreated();
        DialogSetImageVisible(DialogLastCreated(), false);
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeImage);
        libNtve_gv__BB_BGImgBar[lp_bossBarID] = DialogControlLastCreated();
        DialogControlSetFullDialog(DialogControlLastCreated(), PlayerGroupAll(), true);
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), c_triggerImageTypeBorder, PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), "Assets\\Textures\\ui_mission_leaderboard_frame_light.dds", PlayerGroupAll());
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeImage);
        libNtve_gv__BB_BGImgPortrait[lp_bossBarID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), c_triggerImageTypeBorder, PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), "Assets\\Textures\\ui_mission_leaderboard_frame_unit.dds", PlayerGroupAll());
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeImage);
        libNtve_gv__BB_PortraitImage[lp_bossBarID] = DialogControlLastCreated();
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeLabel);
        libNtve_gv__BB_TitleLabel[lp_bossBarID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "BossBarTitle", PlayerGroupAll());
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeImage);
        libNtve_gv__BB_HpBorderImage[lp_bossBarID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), c_triggerImageTypeBorder, PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), "Assets\\Textures\\ui_mission_leaderboard_progressbar_frame.dds", PlayerGroupAll());
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeImage);
        libNtve_gv__BB_HpFullImage[lp_bossBarID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), c_triggerImageTypeBorder, PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), "Assets\\Textures\\ui_mission_leaderboard_progressbar_fill.dds", PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(DialogControlLastCreated(), Color(100.00, 0.00, 0.00), PlayerGroupAll());
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeImage);
        libNtve_gv__BB_HpCurrentImage[lp_bossBarID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemImageType(DialogControlLastCreated(), c_triggerImageTypeBorder, PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(DialogControlLastCreated(), "Assets\\Textures\\ui_mission_leaderboard_progressbar_fill.dds", PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(DialogControlLastCreated(), Color(0.00, 100.00, 0.00), PlayerGroupAll());
        DialogControlCreate(DialogLastCreated(), c_triggerControlTypeLabel);
        libNtve_gv__BB_HpLabel[lp_bossBarID] = DialogControlLastCreated();
        libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), "BossBarHP", PlayerGroupAll());
        libNtve_gf_SetDialogItemRenderPriority(DialogControlLastCreated(), 520, PlayerGroupAll());
    }

    libNtve_gf_SetBossBarRace(lp_bossBarID, libNtve_ge_BossBarRace_Terran, false);
    libNtve_gf_RefreshBossBar(lp_bossBarID);
    DialogSetVisible(libNtve_gv__BB_Dialog[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], true);
}

void libNtve_gf_SetBossBarMaximumValue (int lp_bossBarID, int lp_max, bool lp_refresh) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv__BB_MaxValue[lp_bossBarID] = IntToFixed(lp_max);
    if ((libNtve_gv__BB_MaxValue[lp_bossBarID] <= 0.0)) {
        libNtve_gv__BB_MaxValue[lp_bossBarID] = 1.0;
    }

    libNtve_gv__BB_Boss[lp_bossBarID] = null;
    if ((lp_refresh == true)) {
        libNtve_gf_RefreshBossBar(lp_bossBarID);
    }

}

void libNtve_gf_SetBossBarCurrentValue (int lp_bossBarID, int lp_current, bool lp_refresh) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv__BB_CurrentValue[lp_bossBarID] = IntToFixed(lp_current);
    if ((libNtve_gv__BB_CurrentValue[lp_bossBarID] < 0.0)) {
        libNtve_gv__BB_CurrentValue[lp_bossBarID] = 0.0;
    }

    libNtve_gv__BB_Boss[lp_bossBarID] = null;
    if ((lp_refresh == true)) {
        libNtve_gf_RefreshBossBar(lp_bossBarID);
    }

}

void libNtve_gf_SetBossBarBoss (int lp_bossBarID, unit lp_boss, bool lp_refresh) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_boss != null)) {
        TriggerEnable(libNtve_gt__BB_BossHPChanged, true);
    }

    libNtve_gv__BB_Boss[lp_bossBarID] = lp_boss;
    libNtve_gv__BB_MaxValue[lp_bossBarID] = 0.0;
    libNtve_gv__BB_CurrentValue[lp_bossBarID] = 0.0;
    if ((lp_refresh == true)) {
        libNtve_gf_RefreshBossBar(lp_bossBarID);
    }

}

void libNtve_gf_SetBossBarRace (int lp_bossBarID, int lp_race, bool lp_refresh) {
    // Automatic Variable Declarations
    int auto070B1B5C_val;

    // Implementation
    libNtve_gv__BB_Race[lp_bossBarID] = lp_race;
    auto070B1B5C_val = libNtve_gv__BB_Race[lp_bossBarID];
    if (auto070B1B5C_val == libNtve_ge_BossBarRace_Terran) {
        libNtve_gf_SetDialogItemStyle(libNtve_gv__BB_TitleLabel[lp_bossBarID], "BossBarTitleTerran", PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_BGImgBar[lp_bossBarID], Color(21.18, 82.35, 49.80), PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_BGImgPortrait[lp_bossBarID], Color(21.18, 82.35, 49.80), PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_HpBorderImage[lp_bossBarID], Color(21.18, 82.35, 49.80), PlayerGroupAll());
    }
    else if (auto070B1B5C_val == libNtve_ge_BossBarRace_Protoss) {
        libNtve_gf_SetDialogItemStyle(libNtve_gv__BB_TitleLabel[lp_bossBarID], "BossBarTitleProtoss", PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_BGImgBar[lp_bossBarID], Color(24.71, 70.98, 89.41), PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_BGImgPortrait[lp_bossBarID], Color(24.71, 70.98, 89.41), PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_HpBorderImage[lp_bossBarID], Color(24.71, 70.98, 89.41), PlayerGroupAll());
    }
    else if (auto070B1B5C_val == libNtve_ge_BossBarRace_Zerg) {
        libNtve_gf_SetDialogItemStyle(libNtve_gv__BB_TitleLabel[lp_bossBarID], "BossBarTitleZerg", PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_BGImgBar[lp_bossBarID], Color(100.00, 50.20, 0.00), PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_BGImgPortrait[lp_bossBarID], Color(100.00, 50.20, 0.00), PlayerGroupAll());
        libNtve_gf_SetDialogItemColor(libNtve_gv__BB_HpBorderImage[lp_bossBarID], Color(71.37, 32.16, 8.63), PlayerGroupAll());
    }
    else {
    }
}

void libNtve_gf_MoveBossBar (int lp_bossBarID, int lp_anchor, int lp_offsetX, int lp_offsetY) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv__BB_Dialog[lp_bossBarID] == c_invalidDialogId)) {
        return ;
    }

    DialogSetPosition(libNtve_gv__BB_Dialog[lp_bossBarID], lp_anchor, lp_offsetX, lp_offsetY);
}

void libNtve_gf_ShowHideBossBar (bool lp_showHide, int lp_bossBarID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv__BB_Dialog[lp_bossBarID] == c_invalidDialogId)) {
        return ;
    }

    DialogSetVisible(libNtve_gv__BB_Dialog[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], lp_showHide);
}

void libNtve_gf_RefreshBossBar (int lp_bossBarID) {
    // Automatic Variable Declarations
    // Implementation
    if ((libNtve_gv__BB_Dialog[lp_bossBarID] == c_invalidDialogId)) {
        return ;
    }

    DialogControlSetSize(libNtve_gv__BB_BGImgPortrait[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_PortraitBorderWidth(lp_bossBarID), libNtve_gf__BB_PortraitBorderHeight(lp_bossBarID));
    DialogControlSetPosition(libNtve_gv__BB_BGImgPortrait[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], c_anchorLeft, 18, 1);
    libNtve_gf_SetDialogItemImage(libNtve_gv__BB_PortraitImage[lp_bossBarID], libNtve_gv__BB_Portraits[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID]);
    DialogControlSetSize(libNtve_gv__BB_PortraitImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_PortraitWidth(lp_bossBarID), libNtve_gf__BB_PortraitHeight(lp_bossBarID));
    DialogControlSetPositionRelative(libNtve_gv__BB_PortraitImage[lp_bossBarID], PlayerGroupAll(), c_anchorCenter, libNtve_gv__BB_BGImgPortrait[lp_bossBarID], c_anchorCenter, 0, 0);
    libNtve_gf_SetDialogItemText(libNtve_gv__BB_TitleLabel[lp_bossBarID], libNtve_gv__BB_Title[lp_bossBarID], PlayerGroupAll());
    DialogControlSetSize(libNtve_gv__BB_TitleLabel[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_TitleBarWidth(lp_bossBarID), libNtve_gf__BB_TitleBarHeight(lp_bossBarID));
    DialogControlSetPositionRelative(libNtve_gv__BB_TitleLabel[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], c_anchorTopLeft, libNtve_gv__BB_PortraitImage[lp_bossBarID], c_anchorTopRight, 0, 0);
    DialogControlSetSize(libNtve_gv__BB_HpBorderImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_HPBorderWidth(lp_bossBarID), libNtve_gf__BB_HPBorderHeight(lp_bossBarID));
    DialogControlSetPositionRelative(libNtve_gv__BB_HpBorderImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], c_anchorTop, libNtve_gv__BB_TitleLabel[lp_bossBarID], c_anchorBottom, 0, -12);
    libNtve_gf_SetDialogItemText(libNtve_gv__BB_HpLabel[lp_bossBarID], libNtve_gf__BB_HPBarFormatLabel(lp_bossBarID), PlayerGroupAll());
    DialogControlSetSize(libNtve_gv__BB_HpLabel[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_HPBorderWidth(lp_bossBarID), libNtve_gf__BB_HPBorderHeight(lp_bossBarID));
    DialogControlSetPositionRelative(libNtve_gv__BB_HpLabel[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], c_anchorCenter, libNtve_gv__BB_HpBorderImage[lp_bossBarID], c_anchorCenter, 0, 1);
    DialogControlSetSize(libNtve_gv__BB_HpFullImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_HPBarWidth(lp_bossBarID), libNtve_gf__BB_HPBarHeight(lp_bossBarID));
    DialogControlSetPositionRelative(libNtve_gv__BB_HpFullImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], c_anchorCenter, libNtve_gv__BB_HpBorderImage[lp_bossBarID], c_anchorCenter, 0, 0);
    DialogControlSetSize(libNtve_gv__BB_HpCurrentImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], libNtve_gf__BB_HPBarCurrentWidth(lp_bossBarID), libNtve_gf__BB_HPBarHeight(lp_bossBarID));
    DialogControlSetPositionRelative(libNtve_gv__BB_HpCurrentImage[lp_bossBarID], libNtve_gv__BB_Players[lp_bossBarID], c_anchorLeft, libNtve_gv__BB_HpFullImage[lp_bossBarID], c_anchorLeft, 0, 0);
    libNtve_gf__BB_HPBarChange(lp_bossBarID);
}

void libNtve_gf__StoreGameUIVisibleStates (bool lp_storeRestore, playergroup lp_players, int lp_index) {
    // Variable Declarations
    int lv_player;
    int lv_indexFrame;

    // Automatic Variable Declarations
    playergroup auto1380166C_g;

    // Variable Initialization
    lv_indexFrame = c_syncFrameTypeMenuBar;

    // Implementation
    if ((lp_storeRestore == true)) {
        libNtve_gv__GameUIStored[(lp_index)] = true;
    }
    else {
        if ((libNtve_gv__GameUIStored[(lp_index)] == false)) {
            return ;
        }

    }
    auto1380166C_g = lp_players;
    lv_player = -1;
    while (true) {
        lv_player = PlayerGroupNextPlayer(auto1380166C_g, lv_player);
        if (lv_player < 0) { break; }
        lv_indexFrame = c_syncFrameTypeFirst;
        for ( ; lv_indexFrame <= c_syncFrameTypeLast ; lv_indexFrame += 1 ) {
            if (((GameMapIsBlizzard() == true) || (lv_indexFrame != c_syncFrameTypeBattleUI)) && (libNtve_gv__GameUIFrameFiltered[(lv_indexFrame)] == false)) {
                if ((lp_storeRestore == true)) {
                    if ((UIFrameVisible(lv_player, lv_indexFrame) == true)) {
                        libNtve_gv__GameUIVisible[lv_player][lv_indexFrame][(lp_index)] = true;
                    }
                    else {
                        libNtve_gv__GameUIVisible[lv_player][lv_indexFrame][(lp_index)] = false;
                    }
                }
                else {
                    UISetFrameVisible(PlayerGroupSingle(lv_player), lv_indexFrame, libNtve_gv__GameUIVisible[lv_player][lv_indexFrame][(lp_index)]);
                }
            }

        }
    }
}

void libNtve_gf_HideGameUI (bool lp_showHide, playergroup lp_players) {
    // Variable Declarations
    int lv_player;
    int lv_uIFrame;

    // Automatic Variable Declarations
    playergroup auto659B6716_g;
    playergroup autoE7F18298_g;

    // Variable Initialization
    lv_uIFrame = c_syncFrameTypeMenuBar;

    // Implementation
    if ((lp_showHide == true)) {
        autoE7F18298_g = lp_players;
        lv_player = -1;
        while (true) {
            lv_player = PlayerGroupNextPlayer(autoE7F18298_g, lv_player);
            if (lv_player < 0) { break; }
            if ((libNtve_gf_PlayerInCinematicMode(lv_player) == false) && (libNtve_gf_PlayerInStoryMode(lv_player) == false)) {
                UISetMode(PlayerGroupSingle(lv_player), c_uiModeConsole, c_transitionDurationImmediate);
            }

        }
        libNtve_gf__StoreGameUIVisibleStates(false, lp_players, libNtve_ge_GameUIStoreIndex_GameUI);
    }
    else {
        auto659B6716_g = lp_players;
        lv_player = -1;
        while (true) {
            lv_player = PlayerGroupNextPlayer(auto659B6716_g, lv_player);
            if (lv_player < 0) { break; }
            if ((libNtve_gf_PlayerInCinematicMode(lv_player) == false) && (libNtve_gf_PlayerInStoryMode(lv_player) == false)) {
                UISetMode(PlayerGroupSingle(lv_player), c_uiModeFullscreen, c_transitionDurationImmediate);
            }

        }
        libNtve_gf__StoreGameUIVisibleStates(true, lp_players, libNtve_ge_GameUIStoreIndex_GameUI);
        lv_uIFrame = c_syncFrameTypeFirst;
        for ( ; lv_uIFrame <= c_syncFrameTypeLast ; lv_uIFrame += 1 ) {
            if (((GameMapIsBlizzard() == true) || (lv_uIFrame != c_syncFrameTypeBattleUI)) && (libNtve_gv__GameUIFrameFiltered[(lv_uIFrame)] == false)) {
                UISetFrameVisible(lp_players, lv_uIFrame, false);
            }

        }
    }
}

void libNtve_gf_AddRemoveUIFrameTypeForGlobalFilterList (bool lp_addRemove, int lp_frameType) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gv__GameUIFrameFiltered[(lp_frameType)] = (lp_addRemove == true);
}

bool libNtve_gf_UIFrameFlagCheck (int lp_uIFrame, int lp_flag) {
    // Variable Declarations
    int lv_indexFrame;

    // Automatic Variable Declarations
    int auto74E786FF_val;

    // Variable Initialization
    lv_indexFrame = c_syncFrameTypeMenuBar;

    // Implementation
    auto74E786FF_val = lp_flag;
    if (auto74E786FF_val == libNtve_ge_UIFrameFlag_StoryModeFrame) {
        if (((lp_uIFrame == c_syncFrameTypeBattleUI) || (lp_uIFrame == c_syncFrameTypeMenuBar) || (lp_uIFrame == c_syncFrameTypeAchievementMenuButton) || (lp_uIFrame == c_syncFrameTypeHelpMenuButton) || (lp_uIFrame == c_syncFrameTypeCashPanel) || (lp_uIFrame == c_syncFrameTypeTipAlertPanel))) {
            return true;
        }
        else {
            return false;
        }
    }
    else {
    }
    return false;
}

text libNtve_gf_FormatTipTitle (text lp_title, int lp_type) {
    // Variable Declarations
    text lv_colorCode1;
    text lv_colorCode2;
    text lv_colorCode3;
    text lv_colorCode4;

    // Automatic Variable Declarations
    int auto17A93AD3_val;

    // Variable Initialization
    lv_colorCode1 = StringToText("");
    lv_colorCode2 = StringToText("");
    lv_colorCode3 = StringToText("");
    lv_colorCode4 = StringToText("");

    // Implementation
    lv_colorCode1 = StringExternal("Param/Value/lib_Ntve_17346975");
    lv_colorCode2 = StringExternal("Param/Value/lib_Ntve_9196C077");
    lv_colorCode3 = StringExternal("Param/Value/lib_Ntve_7B619F3C");
    lv_colorCode4 = StringExternal("Param/Value/lib_Ntve_3A5DC4AF");
    auto17A93AD3_val = lp_type;
    if (auto17A93AD3_val == libNtve_ge_TipType_NewUnit) {
        return (lv_colorCode1 + StringExternal("Param/Value/lib_Ntve_0DBBF5F5") + lv_colorCode2 + lv_colorCode3 + lp_title + lv_colorCode4);
    }
    else if (auto17A93AD3_val == libNtve_ge_TipType_NewStructure) {
        return (lv_colorCode1 + StringExternal("Param/Value/lib_Ntve_18619CE6") + lv_colorCode2 + lv_colorCode3 + lp_title + lv_colorCode4);
    }
    else if (auto17A93AD3_val == libNtve_ge_TipType_NewAbility) {
        return (lv_colorCode1 + StringExternal("Param/Value/lib_Ntve_CD27226C") + lv_colorCode2 + lv_colorCode3 + lp_title + lv_colorCode4);
    }
    else if (auto17A93AD3_val == libNtve_ge_TipType_MissionStrategy) {
        return (lv_colorCode1 + StringExternal("Param/Value/lib_Ntve_2661F030") + lv_colorCode2 + lv_colorCode3 + lp_title + lv_colorCode4);
    }
    else {
    }
    return (lv_colorCode3 + lp_title + lv_colorCode4);
}

void libNtve_gf_CreateUnitsWithDefaultFacing (int lp_count, string lp_type, int lp_style, int lp_player, point lp_p) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((CatalogFieldValueGet(c_gameCatalogUnit, lp_type, "FlagArray", lp_player) == "1")) {
        lv_angle = libNtve_gf_RandomAngle();
    }
    else {
        lv_angle = StringToFixed(CatalogFieldValueGet(c_gameCatalogUnit, lp_type, "Facing", lp_player));
        lv_angle -= 90.0;
    }
    UnitCreate(lp_count, lp_type, lp_style, lp_player, lp_p, lv_angle);
}

void libNtve_gf_CreateUnitsAtPoint2 (int lp_count, string lp_type, int lp_flags, int lp_player, point lp_p) {
    // Automatic Variable Declarations
    // Implementation
    UnitCreate(lp_count, lp_type, lp_flags, lp_player, lp_p, PointGetFacing(lp_p));
}

unitgroup libNtve_gf_UnitCreateFacingPoint (int lp_count, string lp_type, int lp_flags, int lp_player, point lp_pos, point lp_facing) {
    // Automatic Variable Declarations
    // Implementation
    UnitCreate(lp_count, lp_type, lp_flags, lp_player, lp_pos, AngleBetweenPoints(lp_pos, lp_facing));
    return UnitLastCreatedGroup();
}

void libNtve_gf_ReplaceUnit (unit lp_unit, string lp_unitType, int lp_options) {
    // Variable Declarations
    int lv_owner;
    point lv_position;
    fixed lv_facing;
    unit lv_newUnit;

    // Automatic Variable Declarations
    int auto481D3762_val;

    // Variable Initialization

    // Implementation
    if (((lp_unit == null) || (UnitGetType(lp_unit) == lp_unitType))) {
        DataTableSetUnit(false, "%REPLACEDUNIT%", lp_unit);
        return ;
    }

    lv_owner = UnitGetOwner(lp_unit);
    lv_position = UnitGetPosition(lp_unit);
    lv_facing = UnitGetFacing(lp_unit);
    libNtve_gf_ShowHideUnit(lp_unit, false);
    UnitCreate(1, lp_unitType, c_unitCreateIgnorePlacement, lv_owner, lv_position, lv_facing);
    lv_newUnit = UnitLastCreated();
    auto481D3762_val = lp_options;
    if (auto481D3762_val == libNtve_ge_ReplaceUnitOptions_OldUnits) {
        UnitSetPropertyFixed(lv_newUnit, c_unitPropLife, UnitGetPropertyFixed(lp_unit, c_unitPropLife, c_unitPropCurrent));
        UnitSetPropertyFixed(lv_newUnit, c_unitPropShields, UnitGetPropertyFixed(lp_unit, c_unitPropShields, c_unitPropCurrent));
        UnitSetPropertyFixed(lv_newUnit, c_unitPropEnergy, UnitGetPropertyFixed(lp_unit, c_unitPropEnergy, c_unitPropCurrent));
    }
    else if (auto481D3762_val == libNtve_ge_ReplaceUnitOptions_OldUnitsRelative) {
        UnitSetPropertyFixed(lv_newUnit, c_unitPropLifePercent, UnitGetPropertyFixed(lp_unit, c_unitPropLifePercent, c_unitPropCurrent));
        if ((UnitGetPropertyFixed(lp_unit, c_unitPropShieldsMax, c_unitPropCurrent) > 0.0)) {
            UnitSetPropertyFixed(lv_newUnit, c_unitPropShieldsPercent, UnitGetPropertyFixed(lp_unit, c_unitPropShieldsPercent, c_unitPropCurrent));
        }

        if ((UnitGetPropertyFixed(lp_unit, c_unitPropEnergyMax, c_unitPropCurrent) > 0.0)) {
            UnitSetPropertyFixed(lv_newUnit, c_unitPropEnergyPercent, UnitGetPropertyFixed(lp_unit, c_unitPropEnergyPercent, c_unitPropCurrent));
        }

    }
    else if (auto481D3762_val == libNtve_ge_ReplaceUnitOptions_NewUnitssMax) {
        UnitSetPropertyFixed(lv_newUnit, c_unitPropLife, UnitGetPropertyFixed(lv_newUnit, c_unitPropLifeMax, c_unitPropNormal));
        UnitSetPropertyFixed(lv_newUnit, c_unitPropShields, UnitGetPropertyFixed(lv_newUnit, c_unitPropShieldsMax, c_unitPropNormal));
        UnitSetPropertyFixed(lv_newUnit, c_unitPropEnergy, UnitGetPropertyFixed(lv_newUnit, c_unitPropEnergyMax, c_unitPropNormal));
    }
    else {
    }
    UnitRemove(lp_unit);
    DataTableSetUnit(false, "%REPLACEDUNIT%", lv_newUnit);
}

unit libNtve_gf_LastReplacedUnit () {
    // Automatic Variable Declarations
    // Implementation
    return DataTableGetUnit(false, "%REPLACEDUNIT%");
}

void libNtve_gf_RescueUnit (unit lp_unit, int lp_player, bool lp_changeColor) {
    // Variable Declarations
    fixed lv_lifePercent;
    fixed lv_shieldsPercent;
    fixed lv_energyPercent;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    SoundPlay(SoundLink("UI_TerranRescueUnit", 0), PlayerGroupSingle(lp_player), 100.0, 0.0);
    UnitFlashSelection(lp_unit, 3.0);
    UnitBehaviorAdd(lp_unit, "Rescued", lp_unit, 1);
    lv_lifePercent = UnitGetPropertyFixed(lp_unit, c_unitPropLifePercent, c_unitPropCurrent);
    lv_shieldsPercent = UnitGetPropertyFixed(lp_unit, c_unitPropShieldsPercent, c_unitPropCurrent);
    lv_energyPercent = UnitGetPropertyFixed(lp_unit, c_unitPropEnergyPercent, c_unitPropCurrent);
    UnitSetOwner(lp_unit, lp_player, lp_changeColor);
    UnitSetPropertyFixed(lp_unit, c_unitPropLifePercent, lv_lifePercent);
    UnitSetPropertyFixed(lp_unit, c_unitPropShieldsPercent, lv_shieldsPercent);
    UnitSetPropertyFixed(lp_unit, c_unitPropEnergyPercent, lv_energyPercent);
}

void libNtve_gf_RescueUnit2 (unitgroup lp_unit, int lp_player, bool lp_changeColor) {
    // Variable Declarations
    unit lv_forUnit;

    // Automatic Variable Declarations
    unitgroup auto5209AAFA_g;
    int auto5209AAFA_u;

    // Variable Initialization

    // Implementation
    auto5209AAFA_g = lp_unit;
    auto5209AAFA_u = UnitGroupCount(auto5209AAFA_g, c_unitCountAll);
    for (;; auto5209AAFA_u -= 1) {
        lv_forUnit = UnitGroupUnitFromEnd(auto5209AAFA_g, auto5209AAFA_u);
        if (lv_forUnit == null) { break; }
        libNtve_gf_RescueUnit(lv_forUnit, lp_player, lp_changeColor);
    }
}

bool libNtve_gf_UnitGroupIsDead (unitgroup lp_units) {
    // Automatic Variable Declarations
    // Implementation
    return (UnitGroupCount(lp_units, c_unitCountAlive) == 0);
}

void libNtve_gf_MakeUnitFacePoint (unit lp_unit, point lp_point, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    UnitSetFacing(lp_unit, AngleBetweenPoints(UnitGetPosition(lp_unit), lp_point), lp_duration);
}

void libNtve_gf_PauseUnit (unit lp_unit, bool lp_pauseUnpause) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_pauseUnpause == true)) {
        UnitSetState(lp_unit, c_unitStatePaused, true);
    }
    else {
        UnitSetState(lp_unit, c_unitStatePaused, false);
    }
}

void libNtve_gf_SleepUnit (unit lp_unit, bool lp_sleepWakeUp) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_sleepWakeUp == true)) {
        UnitSetState(lp_unit, c_unitStateSleeping, true);
    }
    else {
        UnitSetState(lp_unit, c_unitStateSleeping, false);
    }
}

void libNtve_gf_ShowHideUnit (unit lp_unit, bool lp_showHide) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_showHide == true)) {
        UnitSetState(lp_unit, c_unitStateHidden, false);
    }
    else {
        UnitSetState(lp_unit, c_unitStateHidden, true);
    }
}

void libNtve_gf_ShareVisionofUnit (unit lp_unit, bool lp_shareUnshare, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_shareUnshare == true)) {
        UnitBehaviorAddPlayer(lp_unit, "PermanentShareVision", lp_player, 1);
    }
    else {
        UnitBehaviorRemovePlayer(lp_unit, "PermanentShareVision", lp_player, 1);
    }
}

bool libNtve_gf_UnitIsPaused (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStatePaused);
}

bool libNtve_gf_UnitIsSleepiing (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateSleeping);
}

bool libNtve_gf_UnitIsHidden (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateHidden);
}

bool libNtve_gf_UnitIsVisibleToPlayer (unit lp_unit, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    return UnitFilterMatch(lp_unit, lp_player, libNtve_gv_visibleFilter);
}

bool libNtve_gf_UnitInRegion (unit lp_u, region lp_regioin) {
    // Automatic Variable Declarations
    // Implementation
    return RegionContainsPoint(lp_regioin, UnitGetPosition(lp_u));
}

unit libNtve_gf_KillingUnit () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitDamageSourceUnit();
}

int libNtve_gf_KillingPlayer () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitDamageSourcePlayer();
}

unit libNtve_gf_AcquiredTarget () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitTarget();
}

void libNtve_gf_MakeUnitInvulnerable (unit lp_unit, bool lp_option) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_option == true)) {
        UnitSetState(lp_unit, c_unitStateInvulnerable, true);
    }
    else {
        UnitSetState(lp_unit, c_unitStateInvulnerable, false);
    }
}

void libNtve_gf_MakeUnitUncommandable (unit lp_unit, bool lp_option) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_option == true)) {
        UnitBehaviorAdd(lp_unit, "PermanentlyUncommandable", lp_unit, 1);
    }
    else {
        UnitBehaviorRemove(lp_unit, "PermanentlyUncommandable", 1);
    }
}

bool libNtve_gf_UnitIsInvulnerable (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateInvulnerable);
}

int libNtve_gf_UnitGetPropertyKills (unit lp_u, bool lp_current) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt(UnitGetPropertyFixed(lp_u, c_unitPropKills, lp_current));
}

int libNtve_gf_UnitGetPropertyResources (unit lp_u, bool lp_current) {
    // Automatic Variable Declarations
    // Implementation
    return FixedToInt(UnitGetPropertyFixed(lp_u, c_unitPropResources, lp_current));
}

bool libNtve_gf_UnitMoverExists (string lp_unitType, string lp_mover) {
    // Variable Declarations
    int lv_noPlayer;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_noPlayer = 16;

    // Implementation
    if ((CatalogFieldValueGet(c_gameCatalogUnit, lp_unitType, "Mover", lv_noPlayer) == lp_mover)) {
        return true;
    }
    else {
        return false;
    }
}

void libNtve_gf_SetUnitInfoButtonAbilityTooltip (unit lp_unit, abilcmd lp_key, text lp_text) {
    // Automatic Variable Declarations
    // Implementation
    UnitSetInfoButtonTooltip(lp_unit, ((AbilityCommandGetAbility(lp_key)) + "," + IntToString(AbilityCommandGetCommand(lp_key))), lp_text);
}

void libNtve_gf_SetUnitInfoButtonButtonTooltip (unit lp_unit, string lp_key, text lp_text) {
    // Automatic Variable Declarations
    // Implementation
    UnitSetInfoButtonTooltip(lp_unit, (lp_key), lp_text);
}

void libNtve_gf_SetUnitInfoButtonItemTooltip (unit lp_item, text lp_text) {
    // Automatic Variable Declarations
    // Implementation
    UnitSetInfoButtonTooltip(lp_item, "@", lp_text);
}

void libNtve_gf_ResetUnitInfoButtonAbilityTooltip (unit lp_unit, abilcmd lp_abilcmd) {
    // Automatic Variable Declarations
    // Implementation
    UnitClearInfoButtonTooltip(lp_unit, ((AbilityCommandGetAbility(lp_abilcmd)) + "," + IntToString(AbilityCommandGetCommand(lp_abilcmd))));
}

void libNtve_gf_ResetUnitInfoButtonButtonTooltip (unit lp_unit, string lp_button) {
    // Automatic Variable Declarations
    // Implementation
    UnitClearInfoButtonTooltip(lp_unit, (lp_button));
}

void libNtve_gf_ResetUnitInfoButtonItemTooltip (unit lp_item) {
    // Automatic Variable Declarations
    // Implementation
    UnitClearInfoButtonTooltip(lp_item, "@");
}

void libNtve_gf_UnitSetVariation (unit lp_unit, string lp_model, int lp_percent, string lp_textures) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_SendActorMessageToUnit(lp_unit, libNtve_gf_ModelSwap(lp_model, lp_percent));
    if ((StringLength(lp_textures) > 0)) {
        libNtve_gf_SendActorMessageToUnit(lp_unit, MakeMsgTextureSelectBySlot("main", c_textureSlotComponentDefault, ("BestMatch " + lp_textures)));
    }

}

void libNtve_gf_ChangeUnitDamage (unit lp_unit, int lp_takeDeal, int lp_option) {
    // Automatic Variable Declarations
    int autoFCC9BD29_val;
    int auto01104878_val;
    int autoAD3C10F2_val;
    int auto328DEC3D_val;

    // Implementation
    autoFCC9BD29_val = lp_takeDeal;
    if (autoFCC9BD29_val == libNtve_ge_UnitDamageTakenDealt_Damage_Take) {
        UnitBehaviorRemove(lp_unit, "DamageTakenMega", 1);
        UnitBehaviorRemove(lp_unit, "DamageTakenDouble", 1);
        UnitBehaviorRemove(lp_unit, "DamageTakenMinimal", 1);
        UnitBehaviorRemove(lp_unit, "DamageTakenNone", 1);
    }
    else if (autoFCC9BD29_val == libNtve_ge_UnitDamageTakenDealt_Damage_Deal) {
        UnitBehaviorRemove(lp_unit, "DamageDealtMega", 1);
        UnitBehaviorRemove(lp_unit, "DamageDealtDouble", 1);
        UnitBehaviorRemove(lp_unit, "DamageDealtMinimal", 1);
        UnitBehaviorRemove(lp_unit, "DamageDealtNone", 1);
    }
    else {
        return ;
    }
    if ((lp_option == libNtve_ge_UnitDamageChangeOption_Full)) {
        return ;
    }

    auto01104878_val = lp_takeDeal;
    if (auto01104878_val == libNtve_ge_UnitDamageTakenDealt_Damage_Take) {
        autoAD3C10F2_val = lp_option;
        if (autoAD3C10F2_val == libNtve_ge_UnitDamageChangeOption_Mega) {
            UnitBehaviorAdd(lp_unit, "DamageTakenMega", lp_unit, 1);
        }
        else if (autoAD3C10F2_val == libNtve_ge_UnitDamageChangeOption_Mega2) {
            UnitBehaviorAdd(lp_unit, "DamageTakenDouble", lp_unit, 1);
        }
        else if (autoAD3C10F2_val == libNtve_ge_UnitDamageChangeOption_Minimal) {
            UnitBehaviorAdd(lp_unit, "DamageTakenMinimal", lp_unit, 1);
        }
        else if (autoAD3C10F2_val == libNtve_ge_UnitDamageChangeOption_No) {
            UnitBehaviorAdd(lp_unit, "DamageTakenNone", lp_unit, 1);
        }
        else {
        }
    }
    else if (auto01104878_val == libNtve_ge_UnitDamageTakenDealt_Damage_Deal) {
        auto328DEC3D_val = lp_option;
        if (auto328DEC3D_val == libNtve_ge_UnitDamageChangeOption_Mega) {
            UnitBehaviorAdd(lp_unit, "DamageDealtMega", lp_unit, 1);
        }
        else if (auto328DEC3D_val == libNtve_ge_UnitDamageChangeOption_Mega2) {
            UnitBehaviorAdd(lp_unit, "DamageDealtDouble", lp_unit, 1);
        }
        else if (auto328DEC3D_val == libNtve_ge_UnitDamageChangeOption_Minimal) {
            UnitBehaviorAdd(lp_unit, "DamageDealtMinimal", lp_unit, 1);
        }
        else if (auto328DEC3D_val == libNtve_ge_UnitDamageChangeOption_No) {
            UnitBehaviorAdd(lp_unit, "DamageDealtNone", lp_unit, 1);
        }
        else {
        }
    }
    else {
        return ;
    }
}

unitfilter libNtve_gf_ConvertTargetFilterStringToUnitFilter (string lp_targetFilterString) {
    // Variable Declarations
    string lv_newTargetFilterString;
    int lv_wordIndex;
    string lv_wordOfFilterString;
    int lv_filterType;
    int lv_filterState;
    unitfilter lv_unitFilter;

    // Automatic Variable Declarations
    string autoE509B1ED_val;

    // Variable Initialization
    lv_newTargetFilterString = "";
    lv_wordIndex = 1;
    lv_wordOfFilterString = "";
    lv_filterType = c_targetFilterAir;
    lv_filterState = c_unitFilterRequired;
    lv_unitFilter = UnitFilter(0, 0, 0, 0);

    // Implementation
    lv_newTargetFilterString = StringReplaceWord(lp_targetFilterString, ",", " ", 0, c_stringCase);
    lv_newTargetFilterString = StringReplaceWord(lv_newTargetFilterString, ";", " DIV ", 0, c_stringCase);
    lv_wordOfFilterString = StringWord(lv_newTargetFilterString, 1);
    while ((lv_wordOfFilterString != "")) {
        if ((lv_wordOfFilterString == "DIV")) {
            lv_filterState = c_unitFilterExcluded;
        }
        else {
            if ((lv_wordOfFilterString != "-")) {
                autoE509B1ED_val = lv_wordOfFilterString;
                if (autoE509B1ED_val == "Air") {
                    lv_filterType = c_targetFilterAir;
                }
                else if (autoE509B1ED_val == "Ally") {
                    lv_filterType = c_targetFilterAlly;
                }
                else if (autoE509B1ED_val == "Armored") {
                    lv_filterType = c_targetFilterArmored;
                }
                else if (autoE509B1ED_val == "Benign") {
                    lv_filterType = c_targetFilterBenign;
                }
                else if (autoE509B1ED_val == "Biological") {
                    lv_filterType = c_targetFilterBiological;
                }
                else if (autoE509B1ED_val == "Buried") {
                    lv_filterType = c_targetFilterBuried;
                }
                else if (autoE509B1ED_val == "CanHaveEnergy") {
                    lv_filterType = c_targetFilterCanHaveEnergy;
                }
                else if (autoE509B1ED_val == "CanHaveShields") {
                    lv_filterType = c_targetFilterCanHaveShields;
                }
                else if (autoE509B1ED_val == "Cloaked") {
                    lv_filterType = c_targetFilterCloaked;
                }
                else if (autoE509B1ED_val == "Dazed") {
                    lv_filterType = c_targetFilterDazed;
                }
                else if (autoE509B1ED_val == "Dead") {
                    lv_filterType = c_targetFilterDead;
                }
                else if (autoE509B1ED_val == "Destructible") {
                    lv_filterType = c_targetFilterDestructible;
                }
                else if (autoE509B1ED_val == "Detector") {
                    lv_filterType = c_targetFilterDetector;
                }
                else if (autoE509B1ED_val == "Enemy") {
                    lv_filterType = c_targetFilterEnemy;
                }
                else if (autoE509B1ED_val == "Ground") {
                    lv_filterType = c_targetFilterGround;
                }
                else if (autoE509B1ED_val == "Hallucination") {
                    lv_filterType = c_targetFilterHallucination;
                }
                else if (autoE509B1ED_val == "HarvestableResource") {
                    lv_filterType = c_targetFilterHarvestableResource;
                }
                else if (autoE509B1ED_val == "HasEnergy") {
                    lv_filterType = c_targetFilterHasEnergy;
                }
                else if (autoE509B1ED_val == "HasShields") {
                    lv_filterType = c_targetFilterHasShields;
                }
                else if (autoE509B1ED_val == "Heroic") {
                    lv_filterType = c_targetFilterHeroic;
                }
                else if (autoE509B1ED_val == "Hidden") {
                    lv_filterType = c_targetFilterHidden;
                }
                else if (autoE509B1ED_val == "Hover") {
                    lv_filterType = c_targetFilterHover;
                }
                else if (autoE509B1ED_val == "Invulnerable") {
                    lv_filterType = c_targetFilterInvulnerable;
                }
                else if (autoE509B1ED_val == "Item") {
                    lv_filterType = c_targetFilterItem;
                }
                else if (autoE509B1ED_val == "Light") {
                    lv_filterType = c_targetFilterLight;
                }
                else if (autoE509B1ED_val == "MapBoss") {
                    lv_filterType = c_targetFilterMapBoss;
                }
                else if (autoE509B1ED_val == "Massive") {
                    lv_filterType = c_targetFilterMassive;
                }
                else if (autoE509B1ED_val == "Mechanical") {
                    lv_filterType = c_targetFilterMechanical;
                }
                else if (autoE509B1ED_val == "Missile") {
                    lv_filterType = c_targetFilterMissile;
                }
                else if (autoE509B1ED_val == "Neutral") {
                    lv_filterType = c_targetFilterNeutral;
                }
                else if (autoE509B1ED_val == "Outer") {
                    lv_filterType = c_targetFilterOuter;
                }
                else if (autoE509B1ED_val == "Passive") {
                    lv_filterType = c_targetFilterPassive;
                }
                else if (autoE509B1ED_val == "Player") {
                    lv_filterType = c_targetFilterPlayer;
                }
                else if (autoE509B1ED_val == "PreventDefeat") {
                    lv_filterType = c_targetFilterPreventDefeat;
                }
                else if (autoE509B1ED_val == "PreventReveal") {
                    lv_filterType = c_targetFilterPreventReveal;
                }
                else if (autoE509B1ED_val == "Psionic") {
                    lv_filterType = c_targetFilterPsionic;
                }
                else if (autoE509B1ED_val == "Radar") {
                    lv_filterType = c_targetFilterRadar;
                }
                else if (autoE509B1ED_val == "RawResource") {
                    lv_filterType = c_targetFilterRawResource;
                }
                else if (autoE509B1ED_val == "Resistant") {
                    lv_filterType = c_targetFilterResistant;
                }
                else if (autoE509B1ED_val == "Revivable") {
                    lv_filterType = c_targetFilterRevivable;
                }
                else if (autoE509B1ED_val == "Robotic") {
                    lv_filterType = c_targetFilterRobotic;
                }
                else if (autoE509B1ED_val == "Self") {
                    lv_filterType = c_targetFilterSelf;
                }
                else if (autoE509B1ED_val == "Silenced") {
                    lv_filterType = c_targetFilterSilenced;
                }
                else if (autoE509B1ED_val == "Stasis") {
                    lv_filterType = c_targetFilterStasis;
                }
                else if (autoE509B1ED_val == "Structure") {
                    lv_filterType = c_targetFilterStructure;
                }
                else if (autoE509B1ED_val == "Stunned") {
                    lv_filterType = c_targetFilterStunned;
                }
                else if (autoE509B1ED_val == "Summoned") {
                    lv_filterType = c_targetFilterSummoned;
                }
                else if (autoE509B1ED_val == "Uncommandable") {
                    lv_filterType = c_targetFilterUncommandable;
                }
                else if (autoE509B1ED_val == "UnderConstruction") {
                    lv_filterType = c_targetFilterUnderConstruction;
                }
                else if (autoE509B1ED_val == "Unstoppable") {
                    lv_filterType = c_targetFilterUnstoppable;
                }
                else if (autoE509B1ED_val == "User1") {
                    lv_filterType = c_targetFilterUser1;
                }
                else if (autoE509B1ED_val == "Visible") {
                    lv_filterType = c_targetFilterVisible;
                }
                else if (autoE509B1ED_val == "Worker") {
                    lv_filterType = c_targetFilterWorker;
                }
                else {
                }
                UnitFilterSetState(lv_unitFilter, lv_filterType, lv_filterState);
            }

        }
        lv_wordIndex += 1;
        lv_wordOfFilterString = StringWord(lv_newTargetFilterString, lv_wordIndex);
    }
    return lv_unitFilter;
}

bool libNtve_gf_UnitIsInsideTransport (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateInsideTransport);
}

bool libNtve_gf_UnitIsInsideUnitTransport (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateInsideUnitTransport);
}

bool libNtve_gf_UnitIsInsidePlayerTransport (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateInsidePlayerTransport);
}

bool libNtve_gf_UnitCanAttackUnit (unit lp_u, unit lp_s) {
    // Variable Declarations
    int lv_weapon;
    unitfilter lv_weaponFilter;

    // Automatic Variable Declarations
    int auto761381D2_ae;
    const int auto761381D2_ai = 1;

    // Variable Initialization
    lv_weaponFilter = UnitFilter(0, 0, 0, 0);

    // Implementation
    auto761381D2_ae = UnitWeaponCount(lp_u);
    lv_weapon = 1;
    for ( ; ( (auto761381D2_ai >= 0 && lv_weapon <= auto761381D2_ae) || (auto761381D2_ai < 0 && lv_weapon >= auto761381D2_ae) ) ; lv_weapon += auto761381D2_ai ) {
        lv_weaponFilter = libNtve_gf_ConvertTargetFilterStringToUnitFilter(CatalogFieldValueGet(c_gameCatalogWeapon, UnitWeaponGet(lp_u, lv_weapon), "TargetFilters", UnitGetOwner(lp_u)));
        if ((UnitWeaponIsEnabled(lp_u, lv_weapon) == true) && (UnitFilterMatch(lp_s, UnitGetOwner(lp_u), lv_weaponFilter) == true)) {
            return true;
        }

    }
    return false;
}

bool libNtve_gf_UnitIsUnderConstruction (unit lp_u) {
    // Automatic Variable Declarations
    // Implementation
    return UnitTestState(lp_u, c_unitStateUnderConstruction);
}

string libNtve_gf_TriggeringProgressAbility () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitProgressObjectType();
}

string libNtve_gf_TriggeringProgressEffect () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitProgressObjectType();
}

string libNtve_gf_TriggeringProgressUnitType () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitProgressObjectType();
}

string libNtve_gf_TriggeringProgressUpgrade () {
    // Automatic Variable Declarations
    // Implementation
    return EventUnitProgressObjectType();
}

string libNtve_gf_QueuedBehaviorTypeInTrainingQueueSlot (unit lp_unit, int lp_slot, int lp_item) {
    // Automatic Variable Declarations
    // Implementation
    return UnitQueueItemGet(lp_unit, lp_slot, lp_item);
}

string libNtve_gf_QueuedUnitTypeInTrainingQueueSlot (unit lp_unit, int lp_slot, int lp_item) {
    // Automatic Variable Declarations
    // Implementation
    return UnitQueueItemGet(lp_unit, lp_slot, lp_item);
}

string libNtve_gf_QueuedUpgradeTypeInTrainingQueueSlot (unit lp_unit, int lp_slot, int lp_item) {
    // Automatic Variable Declarations
    // Implementation
    return UnitQueueItemGet(lp_unit, lp_slot, lp_item);
}

void libNtve_gf_UnitBehaviorRemoveChargeRegen (unit lp_inUnit, string lp_inBehavior, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    UnitBehaviorAddChargeRegen(lp_inUnit, lp_inBehavior, lp_inCharge, (-1.0 * UnitBehaviorGetChargeRegen(lp_inUnit, lp_inBehavior, lp_inCharge)));
}

void libNtve_gf_UnitAbilityRemoveChargeRegen (unit lp_inUnit, string lp_inAbil, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    UnitAbilityAddChargeRegen(lp_inUnit, lp_inAbil, lp_inCharge, (-1.0 * UnitAbilityGetChargeRegen(lp_inUnit, lp_inAbil, lp_inCharge)));
}

void libNtve_gf_UnitRemoveChargeRegen (unit lp_inUnit, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    UnitAddChargeRegen(lp_inUnit, lp_inCharge, (-1.0 * UnitGetChargeRegen(lp_inUnit, lp_inCharge)));
}

void libNtve_gf_UnitBehaviorRemoveChargeUsed (unit lp_inUnit, string lp_inBehavior, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    UnitBehaviorAddChargeUsed(lp_inUnit, lp_inBehavior, lp_inCharge, (-1.0 * UnitBehaviorGetChargeUsed(lp_inUnit, lp_inBehavior, lp_inCharge)));
}

void libNtve_gf_UnitAbilityRemoveChargeUsed (unit lp_inUnit, string lp_inAbil, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    UnitAbilityAddChargeUsed(lp_inUnit, lp_inAbil, lp_inCharge, (-1.0 * UnitAbilityGetChargeUsed(lp_inUnit, lp_inAbil, lp_inCharge)));
}

void libNtve_gf_UnitRemoveChargeUsed (unit lp_inUnit, string lp_inCharge) {
    // Automatic Variable Declarations
    // Implementation
    UnitAddChargeUsed(lp_inUnit, lp_inCharge, (-1.0 * UnitGetChargeUsed(lp_inUnit, lp_inCharge)));
}

void libNtve_gf_UnitBehaviorRemoveCooldown (unit lp_inUnit, string lp_inBehavior, string lp_inCooldown) {
    // Automatic Variable Declarations
    // Implementation
    UnitBehaviorAddCooldown(lp_inUnit, lp_inBehavior, lp_inCooldown, (-1.0 * UnitBehaviorGetCooldown(lp_inUnit, lp_inBehavior, lp_inCooldown)));
}

void libNtve_gf_UnitAbilityRemoveCooldown (unit lp_inUnit, string lp_inAbil, string lp_inCooldown) {
    // Automatic Variable Declarations
    // Implementation
    UnitAbilityAddCooldown(lp_inUnit, lp_inAbil, lp_inCooldown, (-1.0 * UnitAbilityGetCooldown(lp_inUnit, lp_inAbil, lp_inCooldown)));
}

void libNtve_gf_UnitRemoveCooldown (unit lp_inUnit, string lp_inCooldown) {
    // Automatic Variable Declarations
    // Implementation
    UnitModifyCooldown(lp_inUnit, lp_inCooldown, 0.0, c_cooldownOperationSet);
}

unitgroup libNtve_gf_ConvertUnitToUnitGroup (unit lp_unit) {
    // Variable Declarations
    unitgroup lv_group;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_group = UnitGroupEmpty();

    // Implementation
    UnitGroupAdd(lv_group, lp_unit);
    return lv_group;
}

unitgroup libNtve_gf_UnitsInRegionWithAllianceToPlayerMatchingCondition (string lp_type, string lp_type2, string lp_type22, int lp_player, int lp_alliance, region lp_reg, unitfilter lp_unitFilter, int lp_count) {
    // Variable Declarations
    unitgroup lv_resultGroup;
    unit lv_indexUnit;
    int lv_unitCount;
    bool lv_matched;

    // Automatic Variable Declarations
    unitgroup auto10F35CAE_g;
    int auto10F35CAE_u;

    // Variable Initialization

    // Implementation
    if ((lp_alliance == -1)) {
        lv_resultGroup = UnitGroupEmpty();
        UnitGroupAddUnitGroup(lv_resultGroup, UnitGroup(lp_type, lp_player, lp_reg, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        if ((lp_type2 != "") && (lp_type2 != lp_type)) {
            UnitGroupAddUnitGroup(lv_resultGroup, UnitGroup(lp_type2, lp_player, lp_reg, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        }

        if ((lp_type22 != "") && (lp_type22 != lp_type) && (lp_type22 != lp_type2)) {
            UnitGroupAddUnitGroup(lv_resultGroup, UnitGroup(lp_type22, lp_player, lp_reg, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        }

    }
    else {
        lv_resultGroup = UnitGroupAlliance(lp_player, lp_alliance, lp_reg, lp_unitFilter, 0);
        if ((((lp_type != null)) || ((lp_type2 != "")) || ((lp_type22 != "")))) {
            auto10F35CAE_g = lv_resultGroup;
            auto10F35CAE_u = UnitGroupCount(auto10F35CAE_g, c_unitCountAll);
            for (;; auto10F35CAE_u -= 1) {
                lv_indexUnit = UnitGroupUnitFromEnd(auto10F35CAE_g, auto10F35CAE_u);
                if (lv_indexUnit == null) { break; }
                lv_matched = false;
                if ((lp_type != null) && (UnitGetType(lv_indexUnit) == lp_type)) {
                    lv_matched = true;
                }
                else if ((lp_type2 != "") && (UnitGetType(lv_indexUnit) == lp_type2)) {
                    lv_matched = true;
                }
                else if ((lp_type22 != "") && (UnitGetType(lv_indexUnit) == lp_type22)) {
                    lv_matched = true;
                }
                if ((lv_matched == false)) {
                    UnitGroupRemove(lv_resultGroup, lv_indexUnit);
                }

            }
        }

    }
    if ((lp_count != 0) && (lp_count >= 0)) {
        while (true) {
            lv_unitCount = UnitGroupCount(lv_resultGroup, c_unitCountAlive);
            if ((lv_unitCount > lp_count)) {
                UnitGroupRemove(lv_resultGroup, UnitGroupUnit(lv_resultGroup, lv_unitCount));
            }
            else {
                break;
            }
        }
    }

    return lv_resultGroup;
}

unitgroup libNtve_gf_UnitsInUnitGroupWithCustomValue (unitgroup lp_group, int lp_index, fixed lp_value) {
    // Variable Declarations
    unit lv_indexUnit;
    unitgroup lv_resultGroup;

    // Automatic Variable Declarations
    unitgroup auto903C4223_g;
    int auto903C4223_u;

    // Variable Initialization
    lv_resultGroup = UnitGroupEmpty();

    // Implementation
    auto903C4223_g = lp_group;
    auto903C4223_u = UnitGroupCount(auto903C4223_g, c_unitCountAll);
    for (;; auto903C4223_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(auto903C4223_g, auto903C4223_u);
        if (lv_indexUnit == null) { break; }
        if ((UnitGetCustomValue(lv_indexUnit, lp_index) == lp_value)) {
            UnitGroupAdd(lv_resultGroup, lv_indexUnit);
        }

    }
    return lv_resultGroup;
}

void libNtve_gf_AddUnitGroupToUnitGroup (unitgroup lp_sourceUnitGroup, unitgroup lp_targetUnitGroup) {
    // Variable Declarations
    unit lv_pickedUnit;

    // Automatic Variable Declarations
    unitgroup autoCAE39990_g;
    int autoCAE39990_u;

    // Variable Initialization

    // Implementation
    autoCAE39990_g = lp_sourceUnitGroup;
    autoCAE39990_u = UnitGroupCount(autoCAE39990_g, c_unitCountAll);
    for (;; autoCAE39990_u -= 1) {
        lv_pickedUnit = UnitGroupUnitFromEnd(autoCAE39990_g, autoCAE39990_u);
        if (lv_pickedUnit == null) { break; }
        UnitGroupAdd(lp_targetUnitGroup, lv_pickedUnit);
    }
}

void libNtve_gf_RemoveUnitGroupFromUnitGroup (unitgroup lp_sourceUnitGroup, unitgroup lp_targetUnitGroup) {
    // Variable Declarations
    unit lv_pickedUnit;

    // Automatic Variable Declarations
    unitgroup auto153074BC_g;
    int auto153074BC_u;

    // Variable Initialization

    // Implementation
    auto153074BC_g = lp_sourceUnitGroup;
    auto153074BC_u = UnitGroupCount(auto153074BC_g, c_unitCountAll);
    for (;; auto153074BC_u -= 1) {
        lv_pickedUnit = UnitGroupUnitFromEnd(auto153074BC_g, auto153074BC_u);
        if (lv_pickedUnit == null) { break; }
        UnitGroupRemove(lp_targetUnitGroup, lv_pickedUnit);
    }
}

unit libNtve_gf_ClosestUnitToPoint (point lp_point, unitgroup lp_group) {
    // Variable Declarations
    unit lv_pickedUnit;
    unit lv_closestUnit;
    fixed lv_distance;
    fixed lv_distanceShortest;
    point lv_unitLocation;
    fixed lv_xDiff;
    fixed lv_yDiff;

    // Automatic Variable Declarations
    unitgroup auto9FF4A9A2_g;
    int auto9FF4A9A2_u;

    // Variable Initialization

    // Implementation
    lv_distanceShortest = -1.0;
    lv_closestUnit = null;
    auto9FF4A9A2_g = lp_group;
    auto9FF4A9A2_u = UnitGroupCount(auto9FF4A9A2_g, c_unitCountAll);
    for (;; auto9FF4A9A2_u -= 1) {
        lv_pickedUnit = UnitGroupUnitFromEnd(auto9FF4A9A2_g, auto9FF4A9A2_u);
        if (lv_pickedUnit == null) { break; }
        lv_unitLocation = UnitGetPosition(lv_pickedUnit);
        lv_xDiff = (PointGetX(lv_unitLocation) - PointGetX(lp_point));
        lv_yDiff = (PointGetY(lv_unitLocation) - PointGetY(lp_point));
        lv_distance = ((lv_xDiff * lv_xDiff) + (lv_yDiff * lv_yDiff));
        if (((lv_distanceShortest < 0.0) || (lv_distance < lv_distanceShortest))) {
            lv_distanceShortest = lv_distance;
            lv_closestUnit = lv_pickedUnit;
        }

    }
    return lv_closestUnit;
}

point libNtve_gf_CenterOfUnitGroup (unitgroup lp_unitGroup) {
    // Variable Declarations
    unit lv_forUnit;
    point lv_unitLocation;
    fixed lv_xSum;
    fixed lv_ySum;
    int lv_count;

    // Automatic Variable Declarations
    unitgroup autoC1C95F67_g;
    int autoC1C95F67_u;

    // Variable Initialization

    // Implementation
    lv_xSum = 0.0;
    lv_ySum = 0.0;
    lv_count = 0;
    autoC1C95F67_g = lp_unitGroup;
    autoC1C95F67_u = UnitGroupCount(autoC1C95F67_g, c_unitCountAll);
    for (;; autoC1C95F67_u -= 1) {
        lv_forUnit = UnitGroupUnitFromEnd(autoC1C95F67_g, autoC1C95F67_u);
        if (lv_forUnit == null) { break; }
        lv_unitLocation = UnitGetPosition(lv_forUnit);
        lv_xSum = (lv_xSum + PointGetX(lv_unitLocation));
        lv_ySum = (lv_ySum + PointGetY(lv_unitLocation));
        lv_count = (lv_count + 1);
    }
    if ((lv_count == 0)) {
        return null;
    }
    else {
        return Point((lv_xSum / IntToFixed(lv_count)), (lv_ySum / IntToFixed(lv_count)));
    }
}

int libNtve_gf_UserDataInstanceGetIndex (string lp_userType, string lp_instance) {
    // Variable Declarations
    int lv_index;
    int lv_count;

    // Automatic Variable Declarations
    int autoD00D9D69_ae;
    const int autoD00D9D69_ai = 1;

    // Variable Initialization
    lv_count = UserDataInstanceCount(lp_userType);

    // Implementation
    autoD00D9D69_ae = lv_count;
    lv_index = 1;
    for ( ; ( (autoD00D9D69_ai >= 0 && lv_index <= autoD00D9D69_ae) || (autoD00D9D69_ai < 0 && lv_index >= autoD00D9D69_ae) ) ; lv_index += autoD00D9D69_ai ) {
        if ((UserDataInstance(lp_userType, lv_index) == lp_instance)) {
            return lv_index;
        }

    }
    return -1;
}

void libNtve_gf_ShowHidePlacementModels (bool lp_show) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_show == true)) {
        libNtve_gf_SendActorMessageToGameRegion(RegionEntireMap(), "Signal ShowPlacement");
    }
    else {
        libNtve_gf_SendActorMessageToGameRegion(RegionEntireMap(), "Signal HidePlacement");
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: ScreenButton Clicked
//--------------------------------------------------------------------------------------------------
bool libNtve_gt_ScreenButtonClicked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;

    // Automatic Variable Declarations
    const int auto6600C605_ae = libNtve_gv_c_ScreenButtonMaxCount;
    const int auto6600C605_ai = 1;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_index = 1;
    for ( ; ( (auto6600C605_ai >= 0 && lv_index <= auto6600C605_ae) || (auto6600C605_ai < 0 && lv_index >= auto6600C605_ae) ) ; lv_index += auto6600C605_ai ) {
        if ((EventDialogControl() == libNtve_gv_screenButtons[lv_index])) {
            TriggerExecute(libNtve_gv_screenButtonCallbacks[lv_index], true, false);
            return true;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libNtve_gt_ScreenButtonClicked_Init () {
    libNtve_gt_ScreenButtonClicked = TriggerCreate("libNtve_gt_ScreenButtonClicked_Func");
    TriggerAddEventDialogControl(libNtve_gt_ScreenButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Flash Screen Button
//--------------------------------------------------------------------------------------------------
bool libNtve_gt_FlashScreenButton_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_iD;
    fixed lv_flashTime;
    fixed lv_flashTimeHalf;
    color lv_color1;
    color lv_color2;
    int lv_image;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_color1 = Color(0,0,0);
    lv_color2 = Color(0,0,0);
    lv_image = c_invalidDialogControlId;

    // Actions
    if (!runActions) {
        return true;
    }

    lv_iD = libNtve_gv_tP_FlashScreenButtonID;
    lv_flashTime = libNtve_gv_tP_FlashScreenButtonFlashTime;
    lv_color1 = libNtve_gv_tP_FlashScreenButtonColor1;
    lv_color2 = libNtve_gv_tP_FlashScreenButtonColor2;
    lv_flashTimeHalf = (lv_flashTime / 2.0);
    if (((lv_flashTime <= 0.0) || (lv_flashTimeHalf <= 0.0))) {
        return true;
    }

    while (!((libNtve_gv_screenButtonsFlashStopping[lv_iD] == false))) {
        Wait(0.125, c_timeReal);
    }
    if (((libNtve_gf_ScreenButtonDialog(lv_iD) == c_invalidDialogId) || (libNtve_gv_screenButtonsFlashing[lv_iD] == true))) {
        return true;
    }

    libNtve_gv_screenButtonsFlashing[lv_iD] = true;
    while (true) {
        if (((libNtve_gf_ScreenButtonDialog(lv_iD) == c_invalidDialogId) || (libNtve_gv_screenButtonsFlashing[lv_iD] == false) || (libNtve_gv_screenButtonsFlashStopping[lv_iD] == true))) {
            break;
        }

        libNtve_gf_SetDialogItemImageType(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsFlashingBorderType[lv_iD], PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsFlashingBorderImage[lv_iD], PlayerGroupAll());
        libNtve_gf_SetDialogItemImage2(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsFlashingHoverImage[lv_iD], PlayerGroupAll());
        Wait(lv_flashTimeHalf, c_timeReal);
        if (((libNtve_gf_ScreenButtonDialog(lv_iD) == c_invalidDialogId) || (libNtve_gv_screenButtonsFlashing[lv_iD] == false) || (libNtve_gv_screenButtonsFlashStopping[lv_iD] == true))) {
            break;
        }

        libNtve_gf_SetDialogItemImageType(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsBorderType[lv_iD], PlayerGroupAll());
        libNtve_gf_SetDialogItemImage(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsBorderImage[lv_iD], PlayerGroupAll());
        libNtve_gf_SetDialogItemImage2(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsHoverImage[lv_iD], PlayerGroupAll());
        Wait(lv_flashTimeHalf, c_timeReal);
    }
    libNtve_gv_screenButtonsFlashing[lv_iD] = false;
    libNtve_gv_screenButtonsFlashStopping[lv_iD] = false;
    libNtve_gf_SetDialogItemImageType(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsBorderType[lv_iD], PlayerGroupAll());
    libNtve_gf_SetDialogItemImage(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsBorderImage[lv_iD], PlayerGroupAll());
    libNtve_gf_SetDialogItemImage2(libNtve_gf_ScreenButton(lv_iD), libNtve_gv_screenButtonsHoverImage[lv_iD], PlayerGroupAll());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libNtve_gt_FlashScreenButton_Init () {
    libNtve_gt_FlashScreenButton = TriggerCreate("libNtve_gt_FlashScreenButton_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Pulse Screen Image
//--------------------------------------------------------------------------------------------------
bool libNtve_gt_PulseScreenImage_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_screenImageID;
    fixed lv_period;
    fixed lv_transparency1;
    fixed lv_transparency2;
    fixed lv_halfPeriod;

    // Automatic Variable Declarations
    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_screenImageID = libNtve_gv_tP_PulseScreenImageID;
    lv_period = libNtve_gv_tP_PulseScreenImagePeriod;
    lv_transparency1 = libNtve_gv_tP_PulseScreenImageTransparency1;
    lv_transparency2 = libNtve_gv_tP_PulseScreenImageTransparency2;
    if (((lv_period <= 0.0) || (libNtve_gv_screenImageDialogs[lv_screenImageID] == c_invalidDialogId) || (libNtve_gv_screenImagePulsing[lv_screenImageID] == true))) {
        return true;
    }

    libNtve_gv_screenImagePulsing[lv_screenImageID] = true;
    lv_halfPeriod = (lv_period / 2.0);
    libNtve_gf_HideScreenImage(true, lv_screenImageID);
    DialogControlFadeTransparency(libNtve_gv_screenImageDialogImages[lv_screenImageID], PlayerGroupAll(), 0.0, lv_transparency1);
    while (true) {
        DialogControlFadeTransparency(libNtve_gv_screenImageDialogImages[lv_screenImageID], PlayerGroupAll(), lv_halfPeriod, lv_transparency2);
        Wait(lv_halfPeriod, c_timeGame);
        if ((libNtve_gv_screenImagePulsing[lv_screenImageID] == false)) {
            return true;
        }

        DialogControlFadeTransparency(libNtve_gv_screenImageDialogImages[lv_screenImageID], PlayerGroupAll(), lv_halfPeriod, lv_transparency1);
        Wait(lv_halfPeriod, c_timeGame);
        if ((libNtve_gv_screenImagePulsing[lv_screenImageID] == false)) {
            return true;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libNtve_gt_PulseScreenImage_Init () {
    libNtve_gt_PulseScreenImage = TriggerCreate("libNtve_gt_PulseScreenImage_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: _BB_BossHPChanged
//--------------------------------------------------------------------------------------------------
bool libNtve_gt__BB_BossHPChanged_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_index;
    bool lv_bossSet;

    // Automatic Variable Declarations
    const int auto8BB89956_ae = libNtve_gv__BBC_BossBarMaxCount;
    const int auto8BB89956_ai = 1;

    // Variable Initialization

    // Actions
    if (!runActions) {
        return true;
    }

    lv_index = 1;
    for ( ; ( (auto8BB89956_ai >= 0 && lv_index <= auto8BB89956_ae) || (auto8BB89956_ai < 0 && lv_index >= auto8BB89956_ae) ) ; lv_index += auto8BB89956_ai ) {
        if ((libNtve_gv__BB_Boss[lv_index] == EventUnit())) {
            libNtve_gf_RefreshBossBar(lv_index);
        }

        if ((libNtve_gv__BB_Boss[lv_index] != null)) {
            lv_bossSet = true;
        }

    }
    if ((lv_bossSet == false)) {
        TriggerEnable(TriggerGetCurrent(), false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libNtve_gt__BB_BossHPChanged_Init () {
    libNtve_gt__BB_BossHPChanged = TriggerCreate("libNtve_gt__BB_BossHPChanged_Func");
    TriggerEnable(libNtve_gt__BB_BossHPChanged, false);
    TriggerAddEventUnitProperty(libNtve_gt__BB_BossHPChanged, null, c_unitPropLife);
    TriggerAddEventUnitProperty(libNtve_gt__BB_BossHPChanged, null, c_unitPropShields);
}

void libNtve_InitTriggers () {
    libNtve_gt_ScreenButtonClicked_Init();
    libNtve_gt_FlashScreenButton_Init();
    libNtve_gt_PulseScreenImage_Init();
    libNtve_gt__BB_BossHPChanged_Init();
}

//--------------------------------------------------------------------------------------------------
// Library Initialization
//--------------------------------------------------------------------------------------------------
bool libNtve_InitLib_completed = false;

void libNtve_InitLib () {
    if (libNtve_InitLib_completed) {
        return;
    }

    libNtve_InitLib_completed = true;

    libNtve_InitVariables();
    libNtve_InitTriggers();
}