VoidCampaignMissionLib.galaxy

include "TriggerLibs/NativeLib"
include "TriggerLibs/LibertyLib"
include "TriggerLibs/SwarmLib"
include "TriggerLibs/VoidLib"
include "TriggerLibs/VoidCampaignLib_h"
include "TriggerLibs/VoidCampaignStoryLib_h"
include "TriggerLibs/VoidCampaignUILib_h"

include "TriggerLibs/VoidCampaignMissionLib_h"

//--------------------------------------------------------------------------------------------------
// Library: Mission (Void)
//--------------------------------------------------------------------------------------------------
// External Library Initialization
void libVCMI_InitLibraries () {
    libNtve_InitVariables();
    libLbty_InitVariables();
    libHots_InitVariables();
    libVoiC_InitVariables();
    libVCST_InitVariables();
    libVCUI_InitVariables();
}

// Variable Initialization
bool libVCMI_InitVariables_completed = false;

void libVCMI_InitVariables () {
    int init_i;

    if (libVCMI_InitVariables_completed) {
        return;
    }

    libVCMI_InitVariables_completed = true;

    libVCMI_gv_pM_ScreenMode = c_uiModeConsole;
    libVCMI_gv_pM_SoACasterGroup = UnitGroupEmpty();
    libVCMI_gv_pM_SoATargetingDirectionGroup = UnitGroupEmpty();
    libVCMI_gv_soA_TargetingMode_Timer = TimerCreate();
    libVCMI_gv_sOA_TimeFreezeUI = c_invalidDialogId;
    libVCMI_gv_fenixChargeEnergyCost = libNtve_gf_CostOfAbility("FenixCharge", "Energy");
    libVCMI_gv_kerriganPsiStrikeEnergyCost = libNtve_gf_CostOfAbility("PsiStrikeBlink", "Energy");
    libVCMI_gv_kerriganAstralShiftEnergyCost = libNtve_gf_CostOfAbility("KerriganEpilogue03LineDashAttack", "Energy");
    libVCMI_gv_pM_GameCheat_DialogWidth = 300;
    libVCMI_gv_pM_GameCheat_DialogHeight = 400;
    libVCMI_gv_pM_GameCheat_Dialog = c_invalidDialogId;
    libVCMI_gv_pM_GameCheat_Minimize = c_invalidDialogControlId;
    libVCMI_gv_pM_GameCheat_OpenMissionCheat = c_invalidDialogControlId;
    for (init_i = 0; init_i <= 25; init_i += 1) {
        libVCMI_gv_pM_GameCheat_CheckBox[init_i] = c_invalidDialogControlId;
    }
    for (init_i = 0; init_i <= libVCMI_gv_pMC_MissionCheat_MaxCheats; init_i += 1) {
        libVCMI_gv_pM_MissionCheat_Cheats[init_i].lv_titleString = "";
        libVCMI_gv_pM_MissionCheat_Cheats[init_i].lv_buttonDialog = c_invalidDialogControlId;
        libVCMI_gv_pM_MissionCheat_Cheats[init_i].lv_editBoxDialog = c_invalidDialogControlId;
    }
    libVCMI_gv_pM_MissionCheat_Dialog = c_invalidDialogId;
    for (init_i = 0; init_i <= libVCMI_gv_pMC_MissionCheat_PanelCountMAX; init_i += 1) {
        libVCMI_gv_pM_MissionCheat_Panel[init_i] = c_invalidDialogControlId;
    }
    libVCMI_gv_pM_MissionCheat_CloseButton = c_invalidDialogControlId;
    for (init_i = 0; init_i <= libVCMI_gv_pMC_HEROCOUNT; init_i += 1) {
        libVCMI_gv_pM_HeroReviveCDLink[init_i] = "";
    }
    libVCMI_gv_pM_PlanetPortrait = c_invalidPortraitId;
    libVCMI_gv_pM_NeedPylonEnabled = true;
    libVCMI_gv_pM_NeedPylonFoodRequired = 1;
    for (init_i = 0; init_i <= 20; init_i += 1) {
        libVCMI_gv_pM_MissionTipType[init_i] = libNtve_ge_TipType_NormalTip;
    }
    libVCMI_gv_pM_MissionHelpButton = c_invalidDialogControlId;
    libVCMI_gv_pM_MissionHelpButtonTipPanel = c_invalidDialogControlId;
    libVCMI_gv_pM_SendTransmissionCampaignPortrait = c_invalidPortraitId;
    libVCMI_gv_pM_SendTransmissionCampaignPlayingTick = 3;
    libVCMI_gv_pM_SendTransmissionCampaignChatBubbleOn = true;
    libVCMI_gv_pM_DropPod_TP_Units = UnitGroupEmpty();
    libVCMI_gv_pM_UpgradeTextTag = c_textTagNone;
}

// Presets
// Functions
void libVCMI_gf_AIDarkArchon (int lp_owner, unit lp_darkArchon, unitgroup lp_nearbyUnits) {
    // Variable Declarations
    unitgroup lv_enemyGroup7;
    unit lv_currentUnit;
    unit lv_target;

    // Automatic Variable Declarations
    unitgroup auto07EB9AE6_g;
    int auto07EB9AE6_u;
    unitgroup auto46F9A6FC_g;
    int auto46F9A6FC_u;
    unitgroup autoC5AF83C6_g;
    int autoC5AF83C6_u;

    // Variable Initialization
    lv_enemyGroup7 = UnitGroupEmpty();

    // Implementation
    lv_enemyGroup7 = libVCMI_gf_AITacticalEnemiesWithinRange(lp_darkArchon, 7.0, UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterHeroic) | (1 << c_targetFilterMissile) | (1 << c_targetFilterUncommandable), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))));
    if ((UnitGroupCount(lv_enemyGroup7, c_unitCountAlive) > 0) && (UnitGetPropertyFixed(lp_darkArchon, c_unitPropEnergy, c_unitPropCurrent) >= libNtve_gf_CostOfAbility("DarkArchonMindControl", "Energy")) && (UnitAbilityCheck(lp_darkArchon, "DarkArchonMindControl", true) == true) && (UnitCheckAbilCmdState(lp_darkArchon, AbilityCommand("DarkArchonMindControl", 0), c_cmdStateCooldown) == false)) {
        auto07EB9AE6_g = lv_enemyGroup7;
        auto07EB9AE6_u = UnitGroupCount(auto07EB9AE6_g, c_unitCountAll);
        for (;; auto07EB9AE6_u -= 1) {
            lv_currentUnit = UnitGroupUnitFromEnd(auto07EB9AE6_g, auto07EB9AE6_u);
            if (lv_currentUnit == null) { break; }
            if (((UnitHasBehavior2(lv_currentUnit, "Frenzy") == true) || (UnitGetPropertyFixed(lv_currentUnit, c_unitPropLifeMax, c_unitPropCurrent) < 120.0))) {
                UnitGroupRemove(lv_enemyGroup7, lv_currentUnit);
            }

        }
        if ((UnitGroupCount(lv_enemyGroup7, c_unitCountAlive) > 0)) {
            lv_target = UnitGroupRandomUnit(lv_enemyGroup7, c_unitCountAlive);
            auto46F9A6FC_g = lv_enemyGroup7;
            auto46F9A6FC_u = UnitGroupCount(auto46F9A6FC_g, c_unitCountAll);
            for (;; auto46F9A6FC_u -= 1) {
                lv_currentUnit = UnitGroupUnitFromEnd(auto46F9A6FC_g, auto46F9A6FC_u);
                if (lv_currentUnit == null) { break; }
                if ((UnitGetPropertyFixed(lv_currentUnit, c_unitPropLifeMax, c_unitPropCurrent) > UnitGetPropertyFixed(lv_target, c_unitPropLifeMax, c_unitPropCurrent))) {
                    lv_target = lv_currentUnit;
                }

            }
            libNtve_gf_AICast(lp_darkArchon, OrderTargetingUnit(AbilityCommand("DarkArchonMindControl", 0), lv_target));
            return ;
        }

    }

    lv_enemyGroup7 = libVCMI_gf_AITacticalEnemiesWithinRange(lp_darkArchon, 7.0, UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterHeroic) | (1 << c_targetFilterMissile) | (1 << c_targetFilterUncommandable), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))));
    UnitGroupRemoveUnitGroup(lv_enemyGroup7, libVCMI_gf_AITacticalEnemiesWithinRange(lp_darkArchon, 1.5, UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterHeroic) | (1 << c_targetFilterMissile) | (1 << c_targetFilterUncommandable), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32)))));
    if ((UnitGroupCount(lv_enemyGroup7, c_unitCountAlive) > 0) && (UnitGetPropertyFixed(lp_darkArchon, c_unitPropEnergy, c_unitPropCurrent) >= libNtve_gf_CostOfAbility("DarkArchonConfusion", "Energy")) && (UnitAbilityCheck(lp_darkArchon, "DarkArchonConfusion", true) == true) && (UnitCheckAbilCmdState(lp_darkArchon, AbilityCommand("DarkArchonConfusion", 0), c_cmdStateCooldown) == false)) {
        autoC5AF83C6_g = lv_enemyGroup7;
        autoC5AF83C6_u = UnitGroupCount(autoC5AF83C6_g, c_unitCountAll);
        for (;; autoC5AF83C6_u -= 1) {
            lv_currentUnit = UnitGroupUnitFromEnd(autoC5AF83C6_g, autoC5AF83C6_u);
            if (lv_currentUnit == null) { break; }
            if (((UnitHasBehavior2(lv_currentUnit, "Frenzy") == true) || (UnitGetType(lv_currentUnit) == "Medivac") || (UnitGetType(lv_currentUnit) == "Overlord") || (UnitGetType(lv_currentUnit) == "WarpPrism") || (UnitGetType(lv_currentUnit) == "WarpPrismPhasing") || (UnitGetType(lv_currentUnit) == "Zergling") || (UnitGetType(lv_currentUnit) == "Carrier"))) {
                UnitGroupRemove(lv_enemyGroup7, lv_currentUnit);
            }

        }
        if ((UnitGroupCount(lv_enemyGroup7, c_unitCountAlive) > 0)) {
            lv_target = UnitGroupRandomUnit(lv_enemyGroup7, c_unitCountAlive);
            libNtve_gf_AICast(lp_darkArchon, OrderTargetingPoint(AbilityCommand("DarkArchonConfusion", 0), UnitGetPosition(lv_target)));
        }

    }

}

void libVCMI_gf_AIHighTemplarTaldarim (int lp_owner, unit lp_highTemplarTaldarim, unitgroup lp_nearbyUnits) {
    // Variable Declarations
    unitgroup lv_enemyGroup10;
    unit lv_currentUnit;
    unit lv_target;
    int lv_clusterCount;

    // Automatic Variable Declarations
    unitgroup auto5ED0FEDB_g;
    int auto5ED0FEDB_u;
    unitgroup autoB9E38ECC_g;
    int autoB9E38ECC_u;

    // Variable Initialization
    lv_enemyGroup10 = UnitGroupEmpty();

    // Implementation
    lv_enemyGroup10 = libVCMI_gf_AITacticalEnemiesWithinRange(lp_highTemplarTaldarim, 10.0, UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterMissile) | (1 << c_targetFilterUncommandable), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))));
    if ((UnitGroupCount(lv_enemyGroup10, c_unitCountAlive) > 0) && (UnitGetPropertyFixed(lp_highTemplarTaldarim, c_unitPropEnergy, c_unitPropCurrent) >= libNtve_gf_CostOfAbility("VoidHighTemplarMindBlast", "Energy")) && (UnitAbilityCheck(lp_highTemplarTaldarim, "VoidHighTemplarMindBlast", true) == true) && (UnitCheckAbilCmdState(lp_highTemplarTaldarim, AbilityCommand("VoidHighTemplarMindBlast", 0), c_cmdStateCooldown) == false)) {
        if ((UnitGetPropertyFixed(lp_highTemplarTaldarim, c_unitPropShields, c_unitPropCurrent) == 0.0)) {
            lv_target = UnitGroupClosestToPoint(lv_enemyGroup10, UnitGetPosition(lp_highTemplarTaldarim));
            libNtve_gf_AICast(lp_highTemplarTaldarim, OrderTargetingUnit(AbilityCommand("VoidHighTemplarMindBlast", 0), lv_target));
            return ;
        }
        else {
            auto5ED0FEDB_g = lv_enemyGroup10;
            auto5ED0FEDB_u = UnitGroupCount(auto5ED0FEDB_g, c_unitCountAll);
            for (;; auto5ED0FEDB_u -= 1) {
                lv_currentUnit = UnitGroupUnitFromEnd(auto5ED0FEDB_g, auto5ED0FEDB_u);
                if (lv_currentUnit == null) { break; }
                if (((UnitGetPropertyFixed(lv_currentUnit, c_unitPropLife, c_unitPropCurrent) < 120.0) || (UnitGetPropertyFixed(lv_currentUnit, c_unitPropLifeMax, c_unitPropCurrent) < 200.0))) {
                    UnitGroupRemove(lv_enemyGroup10, lv_currentUnit);
                }

            }
            if ((UnitGroupCount(lv_enemyGroup10, c_unitCountAlive) > 0)) {
                lv_target = UnitGroupRandomUnit(lv_enemyGroup10, c_unitCountAlive);
                libNtve_gf_AICast(lp_highTemplarTaldarim, OrderTargetingUnit(AbilityCommand("VoidHighTemplarMindBlast", 0), lv_target));
                return ;
            }

        }
    }

    lv_enemyGroup10 = libVCMI_gf_AITacticalEnemiesWithinRange(lp_highTemplarTaldarim, 10.0, UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterMissile) | (1 << c_targetFilterUncommandable), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterInvulnerable - 32))));
    if ((UnitGroupCount(lv_enemyGroup10, c_unitCountAlive) > 0) && (UnitGetPropertyFixed(lp_highTemplarTaldarim, c_unitPropEnergy, c_unitPropCurrent) >= libNtve_gf_CostOfAbility("VoidHighTemplarPsiOrb", "Energy")) && (UnitAbilityCheck(lp_highTemplarTaldarim, "VoidHighTemplarPsiOrb", true) == true) && (UnitCheckAbilCmdState(lp_highTemplarTaldarim, AbilityCommand("VoidHighTemplarPsiOrb", 0), c_cmdStateCooldown) == false)) {
        if ((UnitGetPropertyFixed(lp_highTemplarTaldarim, c_unitPropShields, c_unitPropCurrent) == 0.0)) {
            lv_target = UnitGroupClosestToPoint(lv_enemyGroup10, UnitGetPosition(lp_highTemplarTaldarim));
            libNtve_gf_AICast(lp_highTemplarTaldarim, OrderTargetingPoint(AbilityCommand("VoidHighTemplarPsiOrb", 0), UnitGetPosition(lv_target)));
            return ;
        }
        else {
            lv_target = null;
            lv_clusterCount = 2;
            autoB9E38ECC_g = lv_enemyGroup10;
            autoB9E38ECC_u = UnitGroupCount(autoB9E38ECC_g, c_unitCountAll);
            for (;; autoB9E38ECC_u -= 1) {
                lv_currentUnit = UnitGroupUnitFromEnd(autoB9E38ECC_g, autoB9E38ECC_u);
                if (lv_currentUnit == null) { break; }
                if ((UnitGroupCount(UnitGroupAlliance(UnitGetOwner(lp_highTemplarTaldarim), c_unitAllianceEnemy, RegionCircle(UnitGetPosition(lv_currentUnit), 2.5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), c_unitCountAlive) > lv_clusterCount)) {
                    lv_target = lv_currentUnit;
                    lv_clusterCount = UnitGroupCount(UnitGroupAlliance(UnitGetOwner(lp_highTemplarTaldarim), c_unitAllianceEnemy, RegionCircle(UnitGetPosition(lv_currentUnit), 2.5), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), c_unitCountAlive);
                }

            }
            if ((lv_target != null)) {
                libNtve_gf_AICast(lp_highTemplarTaldarim, OrderTargetingPoint(AbilityCommand("VoidHighTemplarPsiOrb", 0), UnitGetPosition(lv_target)));
                return ;
            }

        }
    }

}

unitgroup libVCMI_gf_AITacticalEnemiesWithinRange (unit lp_unit, fixed lp_range, unitfilter lp_filter) {
    // Automatic Variable Declarations
    // Implementation
    return UnitGroupAlliance(UnitGetOwner(lp_unit), c_unitAllianceEnemy, RegionCircle(UnitGetPosition(lp_unit), lp_range), lp_filter, 0);
}

void libVCMI_gf_PM_MissionAutoSave (text lp_description) {
    // Variable Declarations
    text lv_name;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_name = StringToText("");

    // Implementation
    libVCMI_gv_pM_MissionAutoSaveIndex += 1;
    TextExpressionSetToken("Param/Expression/lib_VCMI_87B2D44D", "A", libVoiC_gf_PC_CampaignMapName(libVoiC_gf_CurrentMap()));
    lv_name = TextExpressionAssemble("Param/Expression/lib_VCMI_87B2D44D");
    GameSaveCreate(lv_name, lp_description, "", true);
    Wait(1.0, c_timeGame);
    libVCMI_gv_pM_MissionAutoSaveDone = true;
}

void libVCMI_gf_CreateMissionAutosavePoint (text lp_description) {
    // Variable Declarations
    text lv_name;
    int lv_autosaveDialog;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_name = StringToText("");
    lv_autosaveDialog = c_invalidDialogId;

    // Implementation
    if ((libVoiC_gf_CurrentMap() == null)) {
        return ;
    }

    libVCMI_gv_pM_MissionAutoSaveDone = false;
    libVCMI_gf_PM_MissionAutoSave(lp_description);
}

void libVCMI_gf_CreateExplosionatPointAdvanced (point lp_point, string lp_actor, soundlink lp_sound) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_point != null)) {
        if ((lp_actor != null)) {
            libNtve_gf_CreateActorAtPoint(lp_actor, lp_point);
        }

        if ((lp_sound != null)) {
            SoundPlayAtPoint(lp_sound, PlayerGroupAll(), lp_point, 0.0, 100.0, 0.0);
        }

    }

}

bool libVCMI_gf_PlayerInCinematicModeCampaign () {
    // Automatic Variable Declarations
    // Implementation
    return libNtve_gf_PlayerInCinematicMode(1);
}

string libVCMI_gf_PM_SoundDataTableName () {
    // Automatic Variable Declarations
    // Implementation
    return (libVCMI_gv_pMC_SoundDataTableIdentifier + IntToString(libVCMI_gv_pM_SoundDataTableIndex));
}

void libVCMI_gf_PlaySoundCinematic (soundlink lp_soundLink, playergroup lp_players, fixed lp_volume, fixed lp_offset) {
    // Variable Declarations
    bool lv_playerInCinematic;
    int lv_playerIndex;

    // Automatic Variable Declarations
    playergroup autoEDCAAF8F_g;

    // Variable Initialization

    // Implementation
    autoEDCAAF8F_g = lp_players;
    lv_playerIndex = -1;
    while (true) {
        lv_playerIndex = PlayerGroupNextPlayer(autoEDCAAF8F_g, lv_playerIndex);
        if (lv_playerIndex < 0) { break; }
        if ((libNtve_gf_PlayerInCinematicMode(lv_playerIndex) == true)) {
            lv_playerInCinematic = true;
            break;
        }

    }
    if ((lv_playerInCinematic == false)) {
        return ;
    }

    SoundPlay(lp_soundLink, lp_players, lp_volume, lp_offset);
    libVCMI_gv_pM_SoundDataTableIndex += 1;
    DataTableSetSound(true, libVCMI_gf_PM_SoundDataTableName(), SoundLastPlayed());
}

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

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    while ((libVCMI_gv_pM_SoundDataTableIndex > 0)) {
        SoundStop(DataTableGetSound(true, libVCMI_gf_PM_SoundDataTableName()), true);
        libVCMI_gv_pM_SoundDataTableIndex -= 1;
    }
}

void libVCMI_gf_SetScreenModeCampaign (int lp_mode, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    if ((libVCMI_gv_pM_ScreenMode == c_uiModeConsole) && (lp_mode != c_uiModeConsole)) {
        libVCUI_gf_PU_GPVisibilityAutoUpdate(false, lp_duration);
    }
    else if ((libVCMI_gv_pM_ScreenMode != c_uiModeConsole) && (lp_mode == c_uiModeConsole)) {
        libVCUI_gf_PU_GPVisibilityAutoUpdate(true, lp_duration);
    }
    UISetMode(PlayerGroupAll(), lp_mode, lp_duration);
    libVCMI_gv_pM_ScreenMode = lp_mode;
}

void libVCMI_gf_CinematicModeCampaign (bool lp_onOff, fixed lp_duration, bool lp_waitOptions) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_onOff == true)) {
        libVCMI_gv_pM_InCinematic = true;
    }
    else {
        libVCMI_gv_pM_InCinematic = false;
    }
    if ((lp_waitOptions == false)) {
        libVCMI_gf_PM_CinematicModeNoWait(lp_onOff, lp_duration);
    }
    else {
        libVCMI_gf_PM_CinematicModeInternal(lp_onOff, lp_duration);
    }
}

trigger auto_libVCMI_gf_PM_CinematicModeNoWait_Trigger = null;
bool auto_libVCMI_gf_PM_CinematicModeNoWait_lp_onOff;
fixed auto_libVCMI_gf_PM_CinematicModeNoWait_lp_duration;

void libVCMI_gf_PM_CinematicModeNoWait (bool lp_onOff, fixed lp_duration) {
    auto_libVCMI_gf_PM_CinematicModeNoWait_lp_onOff = lp_onOff;
    auto_libVCMI_gf_PM_CinematicModeNoWait_lp_duration = lp_duration;

    if (auto_libVCMI_gf_PM_CinematicModeNoWait_Trigger == null) {
        auto_libVCMI_gf_PM_CinematicModeNoWait_Trigger = TriggerCreate("auto_libVCMI_gf_PM_CinematicModeNoWait_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_PM_CinematicModeNoWait_Trigger, false, false);
}

bool auto_libVCMI_gf_PM_CinematicModeNoWait_TriggerFunc (bool testConds, bool runActions) {
    bool lp_onOff = auto_libVCMI_gf_PM_CinematicModeNoWait_lp_onOff;
    fixed lp_duration = auto_libVCMI_gf_PM_CinematicModeNoWait_lp_duration;

    // Automatic Variable Declarations
    // Implementation
    libVCMI_gf_PM_CinematicModeInternal(lp_onOff, lp_duration);
    return true;
}

void libVCMI_gf_PM_CinematicModeInternal (bool lp_onOff, fixed lp_duration) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_onOff == true)) {
        libVCMI_gv_pM_CinematicModeSoAEnergy = libVCMI_gf_SpearofAdunEnergy(libVCMI_ge_SpearofAdunEnergyType_Absolute);
        libVCUI_gf_PU_GPVisibilityAutoUpdate(false, lp_duration);
        TriggerExecute(libVCMI_gt_PM_SoATargetingForceOff, true, false);
        libVCMI_gf_PM_ShowHideCampaignTeaching(false);
        if ((lp_duration != c_transitionDurationImmediate)) {
            UISetMode(PlayerGroupAll(), c_uiModeFullscreen, lp_duration);
        }

        if ((lp_duration > 0.0) && (lp_duration != c_transitionDurationImmediate)) {
            Wait(lp_duration, c_timeReal);
        }

        libVCMI_gf_PauseUnpauseSpearofAdunCooldowns(true);
        libNtve_gf_CinematicMode(true, PlayerGroupAll(), 0.0);
        libNtve_gf_GlobalCinematicSetting(true);
        libVoiC_gv_pC_TimeMissionPaused = true;
    }
    else {
        libVCMI_gf_PauseUnpauseSpearofAdunCooldowns(false);
        libVCMI_gf_SetSpearofAdunEnergy(libVCMI_gv_pM_CinematicModeSoAEnergy, libVCMI_ge_SpearofAdunEnergyType_Absolute);
        libNtve_gf_CinematicMode(false, PlayerGroupAll(), lp_duration);
        libNtve_gf_GlobalCinematicSetting(false);
        libVoiC_gv_pC_TimeMissionPaused = false;
        libVCUI_gf_PU_GPVisibilityAutoUpdate(true, lp_duration);
        libVCMI_gf_PM_ShowHideCampaignTeaching(true);
        if ((lp_duration > 0.0) && (lp_duration != c_transitionDurationImmediate)) {
            Wait(lp_duration, c_timeReal);
        }

    }
}

void libVCMI_gf_SpearofAdunTargetingModeExited (trigger t, int lp_exitType) {
    // Automatic Variable Declarations
    // Implementation
    DataTableSetInt(false, TriggerEventParamName(libVCMI_gv_pMC_SoATargetingEventExited, libVCMI_gv_pMC_SoATargetingParamReason), (lp_exitType));
    TriggerAddEventGeneric(t, libVCMI_gv_pMC_SoATargetingEventExited);
}

string libVCMI_gf_SpearofAdunTargetingModeAbility () {
    // Automatic Variable Declarations
    // Implementation
    return libVCMI_gv_pM_SoATargetingAbilityInstance;
}

void libVCMI_gf_PM_SoATargetingModeEnter () {
    // Variable Declarations
    int lv_count;

    // Automatic Variable Declarations
    const int auto21FDAFFC_n = 16;
    int auto21FDAFFC_i;
    playergroup auto27618A4A_g;
    int auto27618A4A_var;
    playergroup auto3E000444_g;
    int auto3E000444_var;
    unitgroup autoA1F6EF3C_g;
    int autoA1F6EF3C_u;
    unit autoA1F6EF3C_var;

    // Variable Initialization

    // Implementation
    TriggerEnable(libVCMI_gt_PM_SoATargetingCancel, true);
    TriggerEnable(libVCMI_gt_PM_SoATargetingClearAll, true);
    TriggerEnable(libVCMI_gt_PM_SoATargetingForceOff, true);
    while (!((libVCMI_gv_pM_SoATargetingTransitioning == false))) {
        Wait(0.0625, c_timeGame);
    }
    if ((libVCMI_gf_PlayerInCinematicModeCampaign() == true)) {
        return ;
    }

    libVCMI_gv_pM_SoAExitInstantly = false;
    libVCMI_gv_pM_SoAForceExit = false;
    UISetDragSelectEnabled(PlayerGroupAll(), false);
    libVCUI_gf_PU_TargetingSetCharges(libVCMI_gv_pM_SoATargetingChargesTotal, libVCMI_gv_pM_SoATargetingChargesTotal);
    if ((libVCMI_gv_pM_SoATargetingOrder != null)) {
        UISetTargetingOrder(PlayerGroupSingle(1), libVCUI_gv_pU_GPCasterGroup, libVCMI_gv_pM_SoATargetingOrder, false);
    }

    libVCMI_gv_pM_SoATargetingCycling = false;
    libVCMI_gv_pM_SoATargetingTransitioning = true;
    libVCUI_gf_PU_TargetingUI_EnterTargetingMode(true, false);
    libVCUI_gf_PU_TargetingSetInstructionText(libVoiC_gf_PC_PerkTargetingText(libVCMI_gv_pM_SoATargetingAbilityInstance, 1));
    libVCMI_gf_PM_SetFogAlphaOverTime(100.0, 0.5);
    CameraSetValue(1, c_cameraValueDistance, 50.0, 1.0, -1, 10.0);
    CameraSetValue(1, c_cameraValuePitch, 70.0, 1.0, -1, 10.0);
    CameraSetData(PlayerGroupAll(), "SOATargetingModeCamera");
    if ((libVCMI_gf_PM_SoATargetingPauseEnabled() == true)) {
        libNtve_gf_PauseUnit(libVCMI_gv_sOA_CasterUnit, true);
        for (auto21FDAFFC_i = 1; auto21FDAFFC_i <= auto21FDAFFC_n; auto21FDAFFC_i += 1) {
            if ((libVCMI_gv_pM_SoAForceExit == true)) {
                break;
            }

            auto27618A4A_g = PlayerGroupAll();
            auto27618A4A_var = -1;
            while (true) {
                auto27618A4A_var = PlayerGroupNextPlayer(auto27618A4A_g, auto27618A4A_var);
                if (auto27618A4A_var < 0) { break; }
                if ((TechTreeUpgradeCount(auto27618A4A_var, "SOAUIFreezePrevent", c_techCountCompleteOnly) < 8)) {
                    TechTreeUpgradeAddLevel(auto27618A4A_var, "SOAUIFreezePrevent", 1);
                }

            }
            GameSetGlobalTimeScale((GameGetGlobalTimeScale() * 0.8178));
            Wait(0.0625, c_timeGame);
        }
        auto3E000444_g = PlayerGroupAll();
        auto3E000444_var = -1;
        while (true) {
            auto3E000444_var = PlayerGroupNextPlayer(auto3E000444_g, auto3E000444_var);
            if (auto3E000444_var < 0) { break; }
            libNtve_gf_SetUpgradeLevelForPlayer(auto3E000444_var, "SOAUIFreezePrevent", 8);
        }
        GameSetGlobalTimeScale(0.04);
        if ((libVCMI_gv_pM_SoAForceExit == true)) {
            GameSetGlobalTimeScale(1.0);
            TriggerExecute(libVCMI_gt_PM_SoATargetingForceOff, true, false);
            return ;
        }

        autoA1F6EF3C_g = UnitGroup(null, c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        autoA1F6EF3C_u = UnitGroupCount(autoA1F6EF3C_g, c_unitCountAll);
        for (;; autoA1F6EF3C_u -= 1) {
            autoA1F6EF3C_var = UnitGroupUnitFromEnd(autoA1F6EF3C_g, autoA1F6EF3C_u);
            if (autoA1F6EF3C_var == null) { break; }
            libNtve_gf_SendActorMessageToUnit(autoA1F6EF3C_var, "AnimSetPausedAll");
            libNtve_gf_SendActorMessageToUnit(autoA1F6EF3C_var, "Signal SOATargetingOn");
        }
        UnitPauseAll(true);
        libVoiC_gf_PC_TimeMissionTemporarySet(true);
        libVoiC_gf_PC_TimeAITemporarySet(true);
    }

    libVCMI_gv_pM_SoATargetingTransitioning = false;
    libVCMI_gv_soA_TargetingMode_TimesUsed += 1;
    TimerStart(libVCMI_gv_soA_TargetingMode_Timer, c_timerDurationInfinite, false, c_timeReal);
}

void libVCMI_gf_PM_SoATargetingModeExit () {
    // Automatic Variable Declarations
    unitgroup auto8A7C96C5_g;
    int auto8A7C96C5_u;
    unit auto8A7C96C5_var;
    const int autoBB182E5F_n = 8;
    int autoBB182E5F_i;
    playergroup auto146275EF_g;
    int auto146275EF_var;
    playergroup autoB2103AAC_g;
    int autoB2103AAC_var;
    unitgroup auto6BEE115D_g;
    int auto6BEE115D_u;
    unit auto6BEE115D_var;

    // Implementation
    if ((libVCMI_gv_pM_SoAExitInstantly == false)) {
        while (!((libVCMI_gv_pM_SoATargetingTransitioning == false))) {
            Wait(0.0625, c_timeGame);
        }
    }

    libVCMI_gv_pM_SoATargetingTransitioning = true;
    UISetDragSelectEnabled(PlayerGroupAll(), true);
    if ((libVCMI_gv_pM_SoAExitInstantly == false)) {
        libVCMI_gf_PM_ResetFogAlphaOverTime(0.5);
        CameraSetValue(1, c_cameraValueDistance, 34.0, 0.5, -1, 10.0);
        CameraSetValue(1, c_cameraValuePitch, 56.0, 0.5, -1, 10.0);
        libVCUI_gf_PU_TargetingUI_EnterTargetingMode(false, false);
    }
    else {
        VisResetFoWAlpha(1);
        CameraSetValue(1, c_cameraValueDistance, 34.0, 0.0, -1, 10.0);
        CameraSetValue(1, c_cameraValuePitch, 56.0, 0.0, -1, 10.0);
        libVCUI_gf_PU_TargetingUI_EnterTargetingMode(false, true);
    }
    CameraSetData(PlayerGroupAll(), "Dflt");
    libNtve_gf_RestoreUnitSelection(1);
    if ((libVCMI_gf_PM_SoATargetingPauseEnabled() == true)) {
        auto8A7C96C5_g = UnitGroup(null, c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto8A7C96C5_u = UnitGroupCount(auto8A7C96C5_g, c_unitCountAll);
        for (;; auto8A7C96C5_u -= 1) {
            auto8A7C96C5_var = UnitGroupUnitFromEnd(auto8A7C96C5_g, auto8A7C96C5_u);
            if (auto8A7C96C5_var == null) { break; }
            libNtve_gf_SendActorMessageToUnit(auto8A7C96C5_var, "Signal SOATargetingOff");
            libNtve_gf_SendActorMessageToUnit(auto8A7C96C5_var, "AnimSetPausedAll 0");
        }
        UnitPauseAll(false);
        libVoiC_gf_PC_TimeAITemporaryRestore();
        libVoiC_gf_PC_TimeMissionTemporaryRestore();
        if ((libVCMI_gv_pM_SoAExitInstantly == false)) {
            for (autoBB182E5F_i = 1; autoBB182E5F_i <= autoBB182E5F_n; autoBB182E5F_i += 1) {
                Wait(0.0625, c_timeGame);
                GameSetGlobalTimeScale((GameGetGlobalTimeScale() * 1.4953));
                auto146275EF_g = PlayerGroupAll();
                auto146275EF_var = -1;
                while (true) {
                    auto146275EF_var = PlayerGroupNextPlayer(auto146275EF_g, auto146275EF_var);
                    if (auto146275EF_var < 0) { break; }
                    if ((TechTreeUpgradeCount(auto146275EF_var, "SOAUIFreezePrevent", c_techCountCompleteOnly) > 0)) {
                        TechTreeUpgradeAddLevel(auto146275EF_var, "SOAUIFreezePrevent", -1);
                    }

                }
            }
        }

        GameSetGlobalTimeScale(1.0);
        autoB2103AAC_g = PlayerGroupAll();
        autoB2103AAC_var = -1;
        while (true) {
            autoB2103AAC_var = PlayerGroupNextPlayer(autoB2103AAC_g, autoB2103AAC_var);
            if (autoB2103AAC_var < 0) { break; }
            libNtve_gf_SetUpgradeLevelForPlayer(autoB2103AAC_var, "SOAUIFreezePrevent", 0);
        }
        auto6BEE115D_g = UnitGroup(null, c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto6BEE115D_u = UnitGroupCount(auto6BEE115D_g, c_unitCountAll);
        for (;; auto6BEE115D_u -= 1) {
            auto6BEE115D_var = UnitGroupUnitFromEnd(auto6BEE115D_g, auto6BEE115D_u);
            if (auto6BEE115D_var == null) { break; }
            libNtve_gf_SendActorMessageToUnit(auto6BEE115D_var, "AnimSetPausedAll 0");
        }
    }

    libVCMI_gv_pM_SoATargetingActivateAbility = null;
    libVCMI_gv_pM_SoATargetingTransitioning = false;
    libVCMI_gv_soA_TargetingMode_TimeSpent += FixedToInt(TimerGetElapsed(libVCMI_gv_soA_TargetingMode_Timer));
    TriggerEnable(libVCMI_gt_PM_SoATargetingForceOff, false);
}

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

    // Automatic Variable Declarations
    const int auto1F706296_ae = libVCMI_gv_pMC_SOATARGETCOUNTMAX;
    const int auto1F706296_ai = 1;

    // Variable Initialization

    // Implementation
    lv_index = 1;
    for ( ; ( (auto1F706296_ai >= 0 && lv_index <= auto1F706296_ae) || (auto1F706296_ai < 0 && lv_index >= auto1F706296_ae) ) ; lv_index += auto1F706296_ai ) {
        if ((libVCMI_gv_pM_SoATargetingActors[lv_index] != null)) {
            ActorSend(libVCMI_gv_pM_SoATargetingActors[lv_index], "Signal Destroy");
            libVCMI_gv_pM_SoATargetingActors[lv_index] = null;
        }

        if ((libVCMI_gv_pM_SoATargetingUnit[lv_index] != null)) {
            UnitRemove(libVCMI_gv_pM_SoATargetingUnit[lv_index]);
            libVCMI_gv_pM_SoATargetingUnit[lv_index] = null;
        }

    }
}

void libVCMI_gf_PM_SoACasterUnitSet (unit lp_unit) {
    // Automatic Variable Declarations
    // Implementation
    libVCMI_gv_sOA_CasterUnit = lp_unit;
    libVCMI_gv_pM_SoACasterGroup = libNtve_gf_ConvertUnitToUnitGroup(lp_unit);
}

bool libVCMI_gf_PM_SoATargetingPauseEnabled () {
    // Automatic Variable Declarations
    // Implementation
    return libLotv_gf_DifficultyValueVoidBoolean(true, true, true, true);
}

trigger auto_libVCMI_gf_PM_SetFogAlphaOverTime_Trigger = null;
fixed auto_libVCMI_gf_PM_SetFogAlphaOverTime_lp_targetAlpha;
fixed auto_libVCMI_gf_PM_SetFogAlphaOverTime_lp_duration;

void libVCMI_gf_PM_SetFogAlphaOverTime (fixed lp_targetAlpha, fixed lp_duration) {
    auto_libVCMI_gf_PM_SetFogAlphaOverTime_lp_targetAlpha = lp_targetAlpha;
    auto_libVCMI_gf_PM_SetFogAlphaOverTime_lp_duration = lp_duration;

    if (auto_libVCMI_gf_PM_SetFogAlphaOverTime_Trigger == null) {
        auto_libVCMI_gf_PM_SetFogAlphaOverTime_Trigger = TriggerCreate("auto_libVCMI_gf_PM_SetFogAlphaOverTime_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_PM_SetFogAlphaOverTime_Trigger, false, false);
}

bool auto_libVCMI_gf_PM_SetFogAlphaOverTime_TriggerFunc (bool testConds, bool runActions) {
    fixed lp_targetAlpha = auto_libVCMI_gf_PM_SetFogAlphaOverTime_lp_targetAlpha;
    fixed lp_duration = auto_libVCMI_gf_PM_SetFogAlphaOverTime_lp_duration;

    // Variable Declarations
    fixed lv_currentAlpha;
    fixed lv_alphaIncrement;
    fixed lv_incrementFrequency;
    int lv_increments;

    // Automatic Variable Declarations
    int autoF2E39D27_n;
    int autoF2E39D27_i;

    // Variable Initialization

    // Implementation
    lv_incrementFrequency = 0.05;
    lv_currentAlpha = VisGetFoWAlpha(1);
    lv_increments = AbsI(FixedToInt((lp_duration / lv_incrementFrequency)));
    lv_alphaIncrement = ((lp_targetAlpha-lv_currentAlpha)/IntToFixed(lv_increments));
    autoF2E39D27_n = lv_increments;
    for (autoF2E39D27_i = 1; autoF2E39D27_i <= autoF2E39D27_n; autoF2E39D27_i += 1) {
        Wait(lv_incrementFrequency, c_timeGame);
        lv_currentAlpha += lv_alphaIncrement;
        VisSetFoWAlpha(1, lv_currentAlpha);
    }
    VisSetFoWAlpha(1, lp_targetAlpha);
    return true;
}

trigger auto_libVCMI_gf_PM_ResetFogAlphaOverTime_Trigger = null;
fixed auto_libVCMI_gf_PM_ResetFogAlphaOverTime_lp_duration;

void libVCMI_gf_PM_ResetFogAlphaOverTime (fixed lp_duration) {
    auto_libVCMI_gf_PM_ResetFogAlphaOverTime_lp_duration = lp_duration;

    if (auto_libVCMI_gf_PM_ResetFogAlphaOverTime_Trigger == null) {
        auto_libVCMI_gf_PM_ResetFogAlphaOverTime_Trigger = TriggerCreate("auto_libVCMI_gf_PM_ResetFogAlphaOverTime_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_PM_ResetFogAlphaOverTime_Trigger, false, false);
}

bool auto_libVCMI_gf_PM_ResetFogAlphaOverTime_TriggerFunc (bool testConds, bool runActions) {
    fixed lp_duration = auto_libVCMI_gf_PM_ResetFogAlphaOverTime_lp_duration;

    // Variable Declarations
    fixed lv_currentAlpha;
    fixed lv_alphaIncrement;
    fixed lv_incrementFrequency;
    int lv_increments;
    fixed lv_targetAlpha;

    // Automatic Variable Declarations
    int auto30DD2C34_n;
    int auto30DD2C34_i;

    // Variable Initialization

    // Implementation
    lv_incrementFrequency = 0.05;
    lv_currentAlpha = VisGetFoWAlpha(1);
    VisResetFoWAlpha(1);
    lv_targetAlpha = VisGetFoWAlpha(1);
    lv_increments = AbsI(FixedToInt((lp_duration / lv_incrementFrequency)));
    lv_alphaIncrement = ((lv_targetAlpha-lv_currentAlpha)/IntToFixed(lv_increments));
    VisSetFoWAlpha(1, lv_currentAlpha);
    auto30DD2C34_n = lv_increments;
    for (auto30DD2C34_i = 1; auto30DD2C34_i <= auto30DD2C34_n; auto30DD2C34_i += 1) {
        Wait(lv_incrementFrequency, c_timeGame);
        lv_currentAlpha += lv_alphaIncrement;
        VisSetFoWAlpha(1, lv_currentAlpha);
    }
    VisResetFoWAlpha(1);
    return true;
}

void libVCMI_gf_CreateOrbitalStrikeTarget (int lp_targetIndex, point lp_targetPoint) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_targetIndex > 5)) {
        return ;
    }

    libVCMI_gv_pM_SoAOrbitalStrike_Points[lp_targetIndex] = lp_targetPoint;
    libNtve_gf_CreateActorAtPoint("SOAOrbitalStrikeTargetModel", libVCMI_gv_pM_SoAOrbitalStrike_Points[lp_targetIndex]);
    libVCMI_gv_pM_SoAOrbitalStrike_Actors[lp_targetIndex] = libNtve_gf_ActorLastCreated();
    libNtve_gf_CreateActorAtPoint("SOATargetingModeConfirmationSound", libVCMI_gv_pM_SoAOrbitalStrike_Points[lp_targetIndex]);
}

trigger auto_libVCMI_gf_FireOrbitalStrikeAtTarget_Trigger = null;
int auto_libVCMI_gf_FireOrbitalStrikeAtTarget_lp_targetIndex;

void libVCMI_gf_FireOrbitalStrikeAtTarget (int lp_targetIndex) {
    auto_libVCMI_gf_FireOrbitalStrikeAtTarget_lp_targetIndex = lp_targetIndex;

    if (auto_libVCMI_gf_FireOrbitalStrikeAtTarget_Trigger == null) {
        auto_libVCMI_gf_FireOrbitalStrikeAtTarget_Trigger = TriggerCreate("auto_libVCMI_gf_FireOrbitalStrikeAtTarget_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_FireOrbitalStrikeAtTarget_Trigger, false, false);
}

bool auto_libVCMI_gf_FireOrbitalStrikeAtTarget_TriggerFunc (bool testConds, bool runActions) {
    int lp_targetIndex = auto_libVCMI_gf_FireOrbitalStrikeAtTarget_lp_targetIndex;

    // Automatic Variable Declarations
    // Implementation
    if (((lp_targetIndex > 5) || (libVCMI_gv_pM_SoAOrbitalStrike_Points[lp_targetIndex] == null))) {
        return true;
    }

    UnitCreateEffectPoint(libVCMI_gv_sOA_CasterUnit, "SOAOrbitalStrikeCP", libVCMI_gv_pM_SoAOrbitalStrike_Points[lp_targetIndex]);
    libVCMI_gv_pM_SoAOrbitalStrike_Points[lp_targetIndex] = null;
    ActorSend(libVCMI_gv_pM_SoAOrbitalStrike_Actors[lp_targetIndex], "Signal Destroy");
    return true;
}

void libVCMI_gf_CleanUpOrbitalStrikeTargets () {
    // Variable Declarations
    int lv_indexActor;

    // Automatic Variable Declarations
    const int auto18061515_ae = 5;
    const int auto18061515_ai = 1;

    // Variable Initialization

    // Implementation
    lv_indexActor = 1;
    for ( ; ( (auto18061515_ai >= 0 && lv_indexActor <= auto18061515_ae) || (auto18061515_ai < 0 && lv_indexActor >= auto18061515_ae) ) ; lv_indexActor += auto18061515_ai ) {
        if ((libVCMI_gv_pM_SoAOrbitalStrike_Points[lv_indexActor] != null)) {
            libVCMI_gv_pM_SoAOrbitalStrike_Points[lv_indexActor] = null;
            ActorSend(libVCMI_gv_pM_SoAOrbitalStrike_Actors[lv_indexActor], "Signal Destroy");
        }

    }
}

void libVCMI_gf_EnterOrbitalStrikeTargetingMode () {
    // Automatic Variable Declarations
    // Implementation
    UnitIssueOrder(libVCMI_gv_sOA_CasterUnit, Order(AbilityCommand("SOAOrbitalStrikeActivate", 0)), c_orderQueueReplace);
}

void libVCMI_gf_CreateGravitonBombTarget (int lp_targetIndex, point lp_targetPoint) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_targetIndex > 3)) {
        return ;
    }

    libVCMI_gv_sOA_GravitonBomb_Points[lp_targetIndex] = lp_targetPoint;
    libNtve_gf_CreateActorAtPoint("SOAGravitonBombTargetModel", libVCMI_gv_sOA_GravitonBomb_Points[lp_targetIndex]);
    libVCMI_gv_sOA_GravitonBomb_Actors[lp_targetIndex] = libNtve_gf_ActorLastCreated();
    libNtve_gf_CreateActorAtPoint("SOAGravitonBombTargetSound", libVCMI_gv_sOA_GravitonBomb_Points[lp_targetIndex]);
}

trigger auto_libVCMI_gf_FireGravitonBombAtTarget_Trigger = null;
int auto_libVCMI_gf_FireGravitonBombAtTarget_lp_targetIndex;

void libVCMI_gf_FireGravitonBombAtTarget (int lp_targetIndex) {
    auto_libVCMI_gf_FireGravitonBombAtTarget_lp_targetIndex = lp_targetIndex;

    if (auto_libVCMI_gf_FireGravitonBombAtTarget_Trigger == null) {
        auto_libVCMI_gf_FireGravitonBombAtTarget_Trigger = TriggerCreate("auto_libVCMI_gf_FireGravitonBombAtTarget_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_FireGravitonBombAtTarget_Trigger, false, false);
}

bool auto_libVCMI_gf_FireGravitonBombAtTarget_TriggerFunc (bool testConds, bool runActions) {
    int lp_targetIndex = auto_libVCMI_gf_FireGravitonBombAtTarget_lp_targetIndex;

    // Automatic Variable Declarations
    // Implementation
    if (((lp_targetIndex > 3) || (libVCMI_gv_sOA_GravitonBomb_Points[lp_targetIndex] == null))) {
        return true;
    }

    UnitCreateEffectPoint(libVCMI_gv_sOA_CasterUnit, "SOAGravitonBombLM", libVCMI_gv_sOA_GravitonBomb_Points[lp_targetIndex]);
    libVCMI_gv_sOA_GravitonBomb_Points[lp_targetIndex] = null;
    Wait(0.125, c_timeGame);
    ActorSend(libVCMI_gv_sOA_GravitonBomb_Actors[lp_targetIndex], "Signal Destroy");
    return true;
}

void libVCMI_gf_EnterGravitonBombTargetingMode () {
    // Automatic Variable Declarations
    // Implementation
    UnitIssueOrder(libVCMI_gv_sOA_CasterUnit, Order(AbilityCommand("SOAGravitonBombActivate", 0)), c_orderQueueReplace);
}

void libVCMI_gf_FireSingleThermalLanceShot (point lp_originPoint, point lp_targetPoint) {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_UnitCreateFacingPoint(1, "SOAThermalLanceTargeter", c_unitCreateIgnorePlacement, 1, lp_originPoint, lp_targetPoint);
    UnitIssueOrder(UnitLastCreated(), OrderTargetingPoint(AbilityCommand("SOAThermalLanceExecute", 0), lp_targetPoint), c_orderQueueReplace);
}

void libVCMI_gf_SOA_TimeFreezeVisual (fixed lp_cameraPOSX, fixed lp_cameraPOSY) {
    // Automatic Variable Declarations
    // Implementation
    PlayerCreateEffectPoint(1, "SOATimeFreezeVisual", Point(lp_cameraPOSX, lp_cameraPOSY));
}

void libVCMI_gf_PM_AddAlarakAvatarUpgrade (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    TechTreeUpgradeAddLevel(lp_player, "AlarakAvatar", 1);
}

void libVCMI_gf_PM_RemoveAlarakAvatarUpgrade (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    TechTreeUpgradeAddLevel(lp_player, "AlarakAvatar", -1);
    libNtve_gf_SetUpgradeLevelForPlayer(lp_player, "AlarakAvatar", 0);
}

void libVCMI_gf_PM_RemoveAlarakSoulStealUpgrade () {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_SetUpgradeLevelForPlayer(1, "AlarakSoulStealPassive", 0);
}

void libVCMI_gf_PM_AddAlarakSoulStealUpgrade () {
    // Automatic Variable Declarations
    // Implementation
}

point libVCMI_gf_AlarakKnockbackOffsetFindPoint (fixed lp_angle, point lp_startingPoint, fixed lp_distance) {
    // Variable Declarations
    fixed lv_i;
    bool lv_pathGood;
    point lv_lastGoodPoint;

    // Automatic Variable Declarations
    fixed auto50F82DCD_ae;
    const fixed auto50F82DCD_ai = 0.5;

    // Variable Initialization
    lv_pathGood = true;

    // Implementation
    lv_lastGoodPoint = lp_startingPoint;
    auto50F82DCD_ae = lp_distance;
    lv_i = 0.0;
    for ( ; ( (auto50F82DCD_ai >= 0 && lv_i <= auto50F82DCD_ae) || (auto50F82DCD_ai < 0 && lv_i >= auto50F82DCD_ae) ) ; lv_i += auto50F82DCD_ai ) {
        if ((lv_pathGood == true)) {
            if ((PathingType(PointWithOffsetPolar(lp_startingPoint, lv_i, lp_angle)) == c_pathingGround)) {
                lv_lastGoodPoint = PointWithOffsetPolar(lp_startingPoint, lv_i, lp_angle);
            }
            else {
                lv_pathGood = false;
            }
        }

    }
    return lv_lastGoodPoint;
}

void libVCMI_gf_PM_DetectionUpgradesApply () {
    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    const int auto4CF9774B_ae = 15;
    const int auto4CF9774B_ai = 1;

    // Variable Initialization

    // Implementation
    libNtve_gf_SetUpgradeLevelForPlayer(1, "DetectionFriendly", 1);
    lv_i = 2;
    for ( ; ( (auto4CF9774B_ai >= 0 && lv_i <= auto4CF9774B_ae) || (auto4CF9774B_ai < 0 && lv_i >= auto4CF9774B_ae) ) ; lv_i += auto4CF9774B_ai ) {
        if (((libNtve_gf_PlayerIsEnemy(1, lv_i, libNtve_ge_PlayerRelation_Enemy) == true) || (libNtve_gf_PlayerIsEnemy(1, lv_i, libNtve_ge_PlayerRelation_EnemyMutual) == true))) {
            libNtve_gf_SetUpgradeLevelForPlayer(lv_i, "DetectionEnemy", 1);
        }

    }
}

void libVCMI_gf_PM_MissionCheat_UpdateButtonEnabled () {
    // Variable Declarations
    int lv_arrayIter;

    // Automatic Variable Declarations
    int auto0D8B4302_ae;
    const int auto0D8B4302_ai = 1;

    // Variable Initialization

    // Implementation
    if ((libVCMI_gv_pM_MissionCheat_Dialog == c_invalidDialogId)) {
        return ;
    }

    auto0D8B4302_ae = libVCMI_gv_pM_MissionCheat_ArrayCount;
    lv_arrayIter = 1;
    for ( ; ( (auto0D8B4302_ai >= 0 && lv_arrayIter <= auto0D8B4302_ae) || (auto0D8B4302_ai < 0 && lv_arrayIter >= auto0D8B4302_ae) ) ; lv_arrayIter += auto0D8B4302_ai ) {
        if ((TriggerIsEnabled(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_trigger) == false)) {
            DialogControlSetEnabled(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_buttonDialog, PlayerGroupAll(), false);
            TextExpressionSetToken("Param/Expression/lib_VCMI_9BF57690", "Button Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_titleText);
            libNtve_gf_SetDialogItemText(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_buttonDialog, TextExpressionAssemble("Param/Expression/lib_VCMI_9BF57690"), PlayerGroupAll());
            if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_uIType == libVCMI_ge_MissionCheatUIType_ButtonEditBoxCombo)) {
                DialogControlSetEnabled(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_editBoxDialog, PlayerGroupAll(), false);
            }

        }
        else {
            DialogControlSetEnabled(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_buttonDialog, PlayerGroupAll(), true);
            TextExpressionSetToken("Param/Expression/lib_VCMI_80CEDAC6", "Button Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_titleText);
            libNtve_gf_SetDialogItemText(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_buttonDialog, TextExpressionAssemble("Param/Expression/lib_VCMI_80CEDAC6"), PlayerGroupAll());
            if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_uIType == libVCMI_ge_MissionCheatUIType_ButtonEditBoxCombo)) {
                DialogControlSetEnabled(libVCMI_gv_pM_MissionCheat_Cheats[lv_arrayIter].lv_editBoxDialog, PlayerGroupAll(), true);
            }

        }
    }
}

void libVCMI_gf_PM_MissionCheat_ButtonTextInit () {
    // Variable Declarations
    int lv_cheatIndex01;
    int lv_cheatIndex02;

    // Automatic Variable Declarations
    int auto6A612C5A_ae;
    const int auto6A612C5A_ai = 1;
    int autoDF102A18_ae;
    const int autoDF102A18_ai = 1;
    int auto5B343B0C_ae;
    const int auto5B343B0C_ai = 1;

    // Variable Initialization

    // Implementation
    auto6A612C5A_ae = libVCMI_gv_pM_MissionCheat_ArrayCount;
    lv_cheatIndex01 = 1;
    for ( ; ( (auto6A612C5A_ai >= 0 && lv_cheatIndex01 <= auto6A612C5A_ae) || (auto6A612C5A_ai < 0 && lv_cheatIndex01 >= auto6A612C5A_ae) ) ; lv_cheatIndex01 += auto6A612C5A_ai ) {
        libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleText = StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString);
    }
    autoDF102A18_ae = libVCMI_gv_pM_MissionCheat_ArrayCount;
    lv_cheatIndex01 = 1;
    for ( ; ( (autoDF102A18_ai >= 0 && lv_cheatIndex01 <= autoDF102A18_ae) || (autoDF102A18_ai < 0 && lv_cheatIndex01 >= autoDF102A18_ae) ) ; lv_cheatIndex01 += autoDF102A18_ai ) {
        if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_trigger == null)) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_BB000415", "Button Text", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString));
            TextExpressionSetToken("Param/Expression/lib_VCMI_BB000415", "Error Text", StringToText("Error"));
            libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleText = TextExpressionAssemble("Param/Expression/lib_VCMI_BB000415");
            TextExpressionSetToken("Param/Expression/lib_VCMI_CA1103D4", "Tip Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_description);
            TextExpressionSetToken("Param/Expression/lib_VCMI_CA1103D4", "Error Text", StringToText("Error: Trigger not set for this Button"));
            libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_description = TextExpressionAssemble("Param/Expression/lib_VCMI_CA1103D4");
        }
        else {
            auto5B343B0C_ae = libVCMI_gv_pM_MissionCheat_ArrayCount;
            lv_cheatIndex02 = (lv_cheatIndex01 + 1);
            for ( ; ( (auto5B343B0C_ai >= 0 && lv_cheatIndex02 <= auto5B343B0C_ae) || (auto5B343B0C_ai < 0 && lv_cheatIndex02 >= auto5B343B0C_ae) ) ; lv_cheatIndex02 += auto5B343B0C_ai ) {
                if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_trigger == libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_trigger)) {
                    TextExpressionSetToken("Param/Expression/lib_VCMI_345DFBBA", "Button Text", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString));
                    TextExpressionSetToken("Param/Expression/lib_VCMI_345DFBBA", "Error Text", StringToText("Error"));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleText = TextExpressionAssemble("Param/Expression/lib_VCMI_345DFBBA");
                    TextExpressionSetToken("Param/Expression/lib_VCMI_E29A6B4F", "Desc Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_description);
                    TextExpressionSetToken("Param/Expression/lib_VCMI_E29A6B4F", "trigname", StringToText(TriggerGetFunction(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_trigger)));
                    TextExpressionSetToken("Param/Expression/lib_VCMI_E29A6B4F", "command", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleString));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_description = TextExpressionAssemble("Param/Expression/lib_VCMI_E29A6B4F");
                    TextExpressionSetToken("Param/Expression/lib_VCMI_60CA52DA", "Button Text", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleString));
                    TextExpressionSetToken("Param/Expression/lib_VCMI_60CA52DA", "Error Text", StringToText("Error"));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleText = TextExpressionAssemble("Param/Expression/lib_VCMI_60CA52DA");
                    TextExpressionSetToken("Param/Expression/lib_VCMI_B57553DC", "Desc Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_description);
                    TextExpressionSetToken("Param/Expression/lib_VCMI_B57553DC", "trigname", StringToText(TriggerGetFunction(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_trigger)));
                    TextExpressionSetToken("Param/Expression/lib_VCMI_B57553DC", "command", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_description = TextExpressionAssemble("Param/Expression/lib_VCMI_B57553DC");
                }

                if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString == libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleString)) {
                    TextExpressionSetToken("Param/Expression/lib_VCMI_3E2FD972", "Button Text", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString));
                    TextExpressionSetToken("Param/Expression/lib_VCMI_3E2FD972", "Error Text", StringToText("Error"));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleText = TextExpressionAssemble("Param/Expression/lib_VCMI_3E2FD972");
                    TextExpressionSetToken("Param/Expression/lib_VCMI_BF425BB2", "Desc Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_description);
                    TextExpressionSetToken("Param/Expression/lib_VCMI_BF425BB2", "command", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_titleString));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex01].lv_description = TextExpressionAssemble("Param/Expression/lib_VCMI_BF425BB2");
                    TextExpressionSetToken("Param/Expression/lib_VCMI_84AF9873", "Button Text", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleString));
                    TextExpressionSetToken("Param/Expression/lib_VCMI_84AF9873", "Error Text", StringToText("Error"));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleText = TextExpressionAssemble("Param/Expression/lib_VCMI_84AF9873");
                    TextExpressionSetToken("Param/Expression/lib_VCMI_53441A0B", "Desc Text", libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_description);
                    TextExpressionSetToken("Param/Expression/lib_VCMI_53441A0B", "command", StringToText(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_titleString));
                    libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex02].lv_description = TextExpressionAssemble("Param/Expression/lib_VCMI_53441A0B");
                }

            }
        }
    }
}

void libVCMI_gf_AddMissionCheat (string lp_command, string lp_description, trigger lp_trigger, int lp_cheatType, int lp_uIType) {
    // Variable Declarations
    string lv_stageString;
    int lv_stage;

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

    // Implementation
    if ((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == false)) {
        return ;
    }

    if ((libVCMI_gv_pM_MissionCheat_ArrayCount == libVCMI_gv_pMC_MissionCheat_MaxCheats)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_C3493724", "ErrorMessage", StringToText("Maximum Mission Cheats reached!"));
        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_VCMI_C3493724"), true);
        return ;
    }

    libVCMI_gv_pM_MissionCheat_ArrayCount += 1;
    libVCMI_gv_pM_MissionCheat_Cheats[libVCMI_gv_pM_MissionCheat_ArrayCount].lv_titleString = StringReplaceWord(lp_command, " ", "", c_stringReplaceAll, c_stringCase);
    libVCMI_gv_pM_MissionCheat_Cheats[libVCMI_gv_pM_MissionCheat_ArrayCount].lv_description = StringToText(lp_description);
    libVCMI_gv_pM_MissionCheat_Cheats[libVCMI_gv_pM_MissionCheat_ArrayCount].lv_trigger = lp_trigger;
    libVCMI_gv_pM_MissionCheat_Cheats[libVCMI_gv_pM_MissionCheat_ArrayCount].lv_cheatType = lp_cheatType;
    libVCMI_gv_pM_MissionCheat_CategoryUsed[lp_cheatType] = true;
    libVCMI_gv_pM_MissionCheat_Cheats[libVCMI_gv_pM_MissionCheat_ArrayCount].lv_uIType = lp_uIType;
}

int libVCMI_gf_MissionCheatEditBoxValueInteger (trigger lp_cheatTrigger) {
    // Variable Declarations
    string lv_returnValue;

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

    // Implementation
    lv_returnValue = DataTableGetString(true, ("PS_" + TriggerGetFunction(lp_cheatTrigger)));
    return StringToInt(lv_returnValue);
}

fixed libVCMI_gf_MissionCheatEditBoxValueReal (trigger lp_cheatTrigger) {
    // Variable Declarations
    string lv_returnValue;

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

    // Implementation
    lv_returnValue = DataTableGetString(true, ("PS_" + TriggerGetFunction(lp_cheatTrigger)));
    return StringToFixed(lv_returnValue);
}

string libVCMI_gf_MissionCheatEditBoxValueString (trigger lp_cheatTrigger) {
    // Variable Declarations
    string lv_returnValue;

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

    // Implementation
    lv_returnValue = DataTableGetString(true, ("PS_" + TriggerGetFunction(lp_cheatTrigger)));
    return lv_returnValue;
}

void libVCMI_gf_GameOver (int lp_gameOverType) {
    // Automatic Variable Declarations
    // Implementation
    libVCMI_gv_pM_GameOverResult = lp_gameOverType;
    GameCheatAllow(c_gameCheatVictory, false);
    GameCheatAllow(c_gameCheatDefeat, false);
}

bool libVCMI_gf_GameIsOver () {
    // Automatic Variable Declarations
    // Implementation
    return (libVCMI_gv_pM_GameOverResult != libVCMI_ge_CampaignMissionGameResultType_None);
}

void libVCMI_gf_PM_PostMissionVictoryUpdate () {
    // Variable Declarations
    int lv_missionDifficulty;
    int lv_bestTime;
    string lv_indexObjective;

    // Automatic Variable Declarations
    int auto29898FAE_ae;
    int auto29898FAE_ai;

    // Variable Initialization
    lv_missionDifficulty = 1;

    // Implementation
    if ((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindStory) == true)) {
        return ;
    }

    lv_missionDifficulty = PlayerDifficulty(1);
    libVCMI_gv_pM_MissionCompleteTime = FixedToInt(libNtve_gf_GamePlayTime(1));
    lv_bestTime = libVoiC_gf_MissionCompleteBestTime(libVoiC_gf_CurrentMap(), lv_missionDifficulty);
    if (((lv_bestTime <= 0) || (libVCMI_gv_pM_MissionCompleteTime < lv_bestTime))) {
        libVoiC_gf_PC_SetMissionCompletionBestTime(libVoiC_gf_CurrentMap(), lv_missionDifficulty, libVCMI_gv_pM_MissionCompleteTime);
    }

    auto29898FAE_ae = CatalogFieldValueCount(c_gameCatalogMap, libVoiC_gf_CurrentMap(), "ObjectiveArray", 1);
    auto29898FAE_ai = 1;
    while (auto29898FAE_ai <= auto29898FAE_ae) {
        lv_indexObjective = CatalogFieldValueGet(c_gameCatalogMap, libVoiC_gf_CurrentMap(), "ObjectiveArray["+IntToString(auto29898FAE_ai-1)+"]", 1);
        auto29898FAE_ai = auto29898FAE_ai + 1;
        if ((libVoiC_gf_MissionObjectiveIsPrimary(lv_indexObjective) == false)) {
            if ((libVoiC_gf_MissionObjectiveProgress(lv_indexObjective) > libVoiC_gf_PS_MissionObjectivePreviousProgress(lv_indexObjective))) {
                libVoiC_gf_PS_MissionObjectivePreviousProgressSet(lv_indexObjective, libVoiC_gf_MissionObjectiveProgress(lv_indexObjective));
            }

        }

    }
}

void libVCMI_gf_PM_MissionEndStats (int lp_type) {
    // Variable Declarations
    string lv_indexArmyCategory;
    string lv_indexArmyUnit;
    string lv_indexPerk;
    string lv_indexSoAUpgrade;
    string lv_indexObjective;
    string lv_purchasedUnit;

    // Automatic Variable Declarations
    int autoD86639D2_ae;
    int autoD86639D2_ai;
    int autoD89F2D02_ai;
    int autoD89F2D02_ae;
    int auto2A422365_ai;
    int auto2A422365_ae;
    int autoD74C5D59_ae;
    int autoD74C5D59_ai;
    int autoC085A94F_ae;
    int autoC085A94F_ai;
    int autoA40095C7_ae;
    int autoA40095C7_ai;
    int auto1132B9C5_ai;
    int auto1132B9C5_ae;

    // Variable Initialization

    // Implementation
    if ((libVoiC_gf_CurrentMap() == null)) {
        return ;
    }

    if ((libVCMI_gv_pM_MissionEndStatsRecorded == true)) {
        return ;
    }

    libVCMI_gv_pM_MissionEndStatsRecorded = true;
    libVoiC_gf_PC_StatEventCreate("MissionEnd");
    if ((lp_type == c_gameOverVictory)) {
        libVoiC_gf_PC_StatEventAddInt("Victory", 1, libVoiC_gf_PC_StatEventLast());
    }
    else {
        libVoiC_gf_PC_StatEventAddInt("Victory", 0, libVoiC_gf_PC_StatEventLast());
    }
    libVoiC_gf_PC_StatEventAddInt("MissionTime", FixedToInt(libNtve_gf_GamePlayTime(1)), libVoiC_gf_PC_StatEventLast());
    libVoiC_gf_PC_StatEventAddInt("Difficulty", libVoiC_gf_PC_DifficultyIndex(PlayerDifficulty(1)), libVoiC_gf_PC_StatEventLast());
    libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
    if ((libVoiC_gf_CurrentMap() != "PMoebius01") && (libVoiC_gf_CurrentMap() != "PAiur01") && (libVoiC_gf_CurrentMap() != "PAiur02") && (libVoiC_gf_CurrentMap() != "PAiur03") && (libVoiC_gf_CurrentMap() != "SC2Epilogue01") && (libVoiC_gf_CurrentMap() != "SC2Epilogue02") && (libVoiC_gf_CurrentMap() != "SC2Epilogue03")) {
        libVoiC_gf_PC_StatEventCreate("ArmyChoices");
        autoD86639D2_ae = CatalogEntryCount(c_gameCatalogArmyCategory);
        autoD86639D2_ai = 1;
        while (autoD86639D2_ai <= autoD86639D2_ae) {
            lv_indexArmyCategory = CatalogEntryGet(c_gameCatalogArmyCategory, autoD86639D2_ai);
            if ((libVoiC_gf_ArmyCategoryStateCheck(lv_indexArmyCategory, c_armyCategoryStateUnlocked) == true)) {
                lv_purchasedUnit = libVoiC_gf_PC_ArmyCategoryPurchasedUnit(lv_indexArmyCategory);
                if ((lv_purchasedUnit == null)) {
                    libVoiC_gf_PC_StatEventAddStr((lv_indexArmyCategory), "None", libVoiC_gf_PC_StatEventLast());
                }
                else {
                    libVoiC_gf_PC_StatEventAddStr((lv_indexArmyCategory), (lv_purchasedUnit), libVoiC_gf_PC_StatEventLast());
                }
            }

            autoD86639D2_ai = autoD86639D2_ai + 1;
        }
        libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
        libVoiC_gf_PC_StatEventCreate("SoAChoices");
        autoD89F2D02_ai = 1;
        autoD89F2D02_ae = UserDataInstanceCount("CampaignPerk")+1;
        while (autoD89F2D02_ai < autoD89F2D02_ae) {
            lv_indexPerk = UserDataInstance("CampaignPerk", autoD89F2D02_ai);
            autoD89F2D02_ai = autoD89F2D02_ai+1;
            if ((libVoiC_gf_PC_PerkStateCheck(lv_indexPerk, libVoiC_ge_PC_PerkState_Active) == true)) {
                libVoiC_gf_PC_StatEventAddStr((libVoiC_gf_PC_PerkGroupOfPerk(lv_indexPerk)), (lv_indexPerk), libVoiC_gf_PC_StatEventLast());
            }

        }
        auto2A422365_ai = 1;
        auto2A422365_ae = UserDataInstanceCount("SpearofAdunUpgrade")+1;
        while (auto2A422365_ai < auto2A422365_ae) {
            lv_indexSoAUpgrade = UserDataInstance("SpearofAdunUpgrade", auto2A422365_ai);
            auto2A422365_ai = auto2A422365_ai+1;
            libVoiC_gf_PC_StatEventAddInt((lv_indexSoAUpgrade), libVoiC_gf_PC_SoAUpgradeLevel(lv_indexSoAUpgrade), libVoiC_gf_PC_StatEventLast());
        }
        libVoiC_gf_PC_SoACalculateCurrency();
        libVoiC_gf_PC_StatEventAddInt("SolariteUsed", libVoiC_gf_PC_PerkActiveCost(), libVoiC_gf_PC_StatEventLast());
        libVoiC_gf_PC_StatEventAddInt("SolariteTotal", libVoiC_gf_PC_SoACurrencyMax(), libVoiC_gf_PC_StatEventLast());
        libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
    }

    libVoiC_gf_PC_StatEventCreate("Objectives");
    autoD74C5D59_ae = CatalogFieldValueCount(c_gameCatalogMap, libVoiC_gf_CurrentMap(), "ObjectiveArray", 1);
    autoD74C5D59_ai = 1;
    while (autoD74C5D59_ai <= autoD74C5D59_ae) {
        lv_indexObjective = CatalogFieldValueGet(c_gameCatalogMap, libVoiC_gf_CurrentMap(), "ObjectiveArray["+IntToString(autoD74C5D59_ai-1)+"]", 1);
        autoD74C5D59_ai = autoD74C5D59_ai + 1;
        if ((libVoiC_gf_MissionObjectiveIsPrimary(lv_indexObjective) == false)) {
            libVoiC_gf_PC_StatEventAddInt((lv_indexObjective), libVoiC_gf_MissionObjectiveProgress(lv_indexObjective), libVoiC_gf_PC_StatEventLast());
        }

    }
    libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
    autoC085A94F_ae = CatalogEntryCount(c_gameCatalogArmyCategory);
    autoC085A94F_ai = 1;
    while (autoC085A94F_ai <= autoC085A94F_ae) {
        lv_indexArmyCategory = CatalogEntryGet(c_gameCatalogArmyCategory, autoC085A94F_ai);
        if ((libVoiC_gf_PC_TechUnitOfArmyCategory(lv_indexArmyCategory) != null) && (libVoiC_gf_PC_ArmyCategoryUnitType(lv_indexArmyCategory) != null) && (UserDataGetGameLink("TechUnit", libVoiC_gf_PC_TechUnitOfArmyCategory(lv_indexArmyCategory), "RequiredRace", 1) == "Prot")) {
            libVoiC_gf_PC_StatEventCreate("UnitStats");
            libVoiC_gf_PC_StatEventAddStr("UnitID", (libVoiC_gf_PC_ArmyCategoryUnitType(lv_indexArmyCategory)), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("UnitsMade", DataTableGetInt(true, ("UnitMade_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("UnitsLost", DataTableGetInt(true, ("UnitDied_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("DamageDone", DataTableGetInt(true, ("DmgDone_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("DamageTaken", DataTableGetInt(true, ("DmgTaken_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("DamageHealed", DataTableGetInt(true, ("UnitHeal_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("MineralsDone", DataTableGetInt(true, ("MinDone_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("VespeneDone", DataTableGetInt(true, ("VesDone_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("MineralsSpent", DataTableGetInt(true, ("MinSpent_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("VespeneSpent", DataTableGetInt(true, ("VesSpent_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("MineralsLost", DataTableGetInt(true, ("MinLost_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventAddInt("VespeneLost", DataTableGetInt(true, ("VesLost_" + libVoiC_gf_PC_ArmyStringFromArmyCategory(lv_indexArmyCategory))), libVoiC_gf_PC_StatEventLast());
            libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
            autoA40095C7_ae = CatalogFieldValueCount(c_gameCatalogArmyCategory, lv_indexArmyCategory, "ArmyUnitArray", 1);
            autoA40095C7_ai = 1;
            while (autoA40095C7_ai <= autoA40095C7_ae) {
                lv_indexArmyUnit = CatalogFieldValueGet(c_gameCatalogArmyCategory, lv_indexArmyCategory, "ArmyUnitArray["+IntToString(autoA40095C7_ai-1)+"]", 1);
                libVoiC_gf_PC_StatEventCreate("UnitStats");
                libVoiC_gf_PC_StatEventAddStr("UnitID", (libVoiC_gf_PC_StoryArmyUnitUnitType(lv_indexArmyUnit)), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("UnitsMade", DataTableGetInt(true, ("UnitMade_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("UnitsLost", DataTableGetInt(true, ("UnitDied_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("DamageDone", DataTableGetInt(true, ("DmgDone_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("DamageTaken", DataTableGetInt(true, ("DmgTaken_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("DamageHealed", DataTableGetInt(true, ("UnitHeal_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("MineralsDone", DataTableGetInt(true, ("MinDone_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("VespeneDone", DataTableGetInt(true, ("VesDone_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("MineralsSpent", DataTableGetInt(true, ("MinSpent_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("VespeneSpent", DataTableGetInt(true, ("VesSpent_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("MineralsLost", DataTableGetInt(true, ("MinLost_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventAddInt("VespeneLost", DataTableGetInt(true, ("VesLost_" + libVoiC_gf_PC_ArmyStringFromArmyUnit(lv_indexArmyUnit))), libVoiC_gf_PC_StatEventLast());
                libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
                autoA40095C7_ai = autoA40095C7_ai + 1;
            }
        }

        autoC085A94F_ai = autoC085A94F_ai + 1;
    }
    libVoiC_gf_PC_StatRecordMiscUnits();
    libVoiC_gf_PC_StatEventCreate("SoATargetingMode");
    libVoiC_gf_PC_StatEventAddInt("TimesUsed", libVCMI_gv_soA_TargetingMode_TimesUsed, libVoiC_gf_PC_StatEventLast());
    libVoiC_gf_PC_StatEventAddInt("TimesQuit", libVoiC_gv_pC_StatTargetingModeAborts, libVoiC_gf_PC_StatEventLast());
    libVoiC_gf_PC_StatEventAddInt("TimeSpent", libVCMI_gv_soA_TargetingMode_TimeSpent, libVoiC_gf_PC_StatEventLast());
    libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
    auto1132B9C5_ai = 1;
    auto1132B9C5_ae = UserDataInstanceCount("CampaignPerk")+1;
    while (auto1132B9C5_ai < auto1132B9C5_ae) {
        lv_indexPerk = UserDataInstance("CampaignPerk", auto1132B9C5_ai);
        auto1132B9C5_ai = auto1132B9C5_ai+1;
        libVoiC_gf_PC_StatEventCreate("AbilityStats");
        libVoiC_gf_PC_StatEventAddStr("AbilityID", (lv_indexPerk), libVoiC_gf_PC_StatEventLast());
        libVoiC_gf_PC_StatEventAddInt("TimesUsed", DataTableGetInt(true, ("AbilUsed_" + (lv_indexPerk))), libVoiC_gf_PC_StatEventLast());
        libVoiC_gf_PC_StatEventAddInt("DamageDone", DataTableGetInt(true, ("DmgDone_" + (lv_indexPerk))), libVoiC_gf_PC_StatEventLast());
        libVoiC_gf_PC_StatEventDone(libVoiC_gf_PC_StatEventLast());
    }
    libVoiC_gf_PC_StatRecordMiscAbilities();
    libVoiC_gf_PC_StatRecordSoAEnergyCapStop();
}

void libVCMI_gf_RunMissionVictorySequence (trigger lp_victoryCinematic) {
    // Automatic Variable Declarations
    // Implementation
    if ((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindStory) == true)) {
        return ;
    }

    libVCMI_gf_GameOver(libVCMI_ge_CampaignMissionGameResultType_Victory);
    libVCMI_gf_PM_PostMissionVictoryUpdate();
    TriggerQueueClear(c_triggerQueueRetain);
    TriggerQueuePause(false);
    libVCMI_gv_pM_MissionVictoryActionQueyeEmpty = false;
    TriggerExecute(libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute, true, false);
    while (!((libVCMI_gv_pM_MissionVictoryActionQueyeEmpty == true))) {
        Wait(1.0, c_timeGame);
    }
    TriggerQueueClear(c_triggerQueueKill);
    TriggerExecute(lp_victoryCinematic, true, false);
    TriggerExecute(libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueue, true, false);
}

void libVCMI_gf_EndCampaignMission (int lp_player, int lp_type) {
    // Variable Declarations
    unit lv_indexUnit;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    PerfTestStop();
    TriggerQueueClear(c_triggerQueueRetain);
    TriggerQueuePause(true);
    libVCMI_gf_PM_MissionEndStats(lp_type);
    if ((lp_type != c_gameOverVictory)) {
        GameOver(lp_player, lp_type, true, false);
        return ;
    }

    GameCheatAllow(c_gameCheatProgress, false);
    AITimePause(true);
    UnitPauseAll(true);
    libVCUI_gf_PU_ShowHideHeroPanel(false);
    libNtve_gf_SendActorMessageToGameRegion(RegionEntireMap(), "Destroy Immediate");
    libNtve_gf_HideAllCinematicPortraits(PlayerGroupAll());
    SoundStopAllTriggerSounds(false);
    libVoiC_gf_PrepareForStoryMode(c_gameOverVictory, libVoiC_gv_pCX_CampaignDifficulty);
    if ((libVoiC_gv_pC_InLoadedMission == true)) {
        libVoiC_gf_PC_ArchivesBankSyncForSave();
    }

    if ((libVoiC_gv_pCX_IsSimulation == false)) {
        libVoiC_gf_PC_UpdateCampaignScreen(libVoiC_gf_CurrentMap());
    }

    if (((libVoiC_gf_CurrentMap() == "SC2Epilogue03") || (libVoiC_gf_CurrentMap() == "PAiur06") || (libVoiC_gf_PC_CampaignIsComplete() == true))) {
        libVoiC_gf_PC_CompletedSavesEnable();
    }

    TextExpressionSetToken("Param/Expression/lib_VCMI_20839488", "A", libVoiC_gf_PC_CampaignMapName(libVoiC_gf_CurrentMap()));
    libVoiC_gf_CreateStoryModeTransitionSave(TextExpressionAssemble("Param/Expression/lib_VCMI_20839488"), StringToText(""));
    if (((libVoiC_gf_CurrentMap() != "SC2Epilogue03") || (libVoiC_gf_CurrentMissionIsSimulation() == true))) {
        libVCUI_gf_DisplayCampaignVictoryScoreScreen(libVoiC_gf_CurrentMap());
    }
    else {
        libVCMI_gf_PU_CampaignVictory();
    }
    if ((libVoiC_gv_pCX_IsSimulation == true)) {
        libVoiC_gf_PC_OpenCampaignBank();
        libVoiC_gf_PC_LoadTransitionVars(BankLastCreated(), libVoiC_gf_CurrentMap());
    }

    libVoiC_gf_PC_SoACalculateCurrency();
    AchievementTermQuantitySet(1, "SolarPowered50", libVoiC_gf_PC_SoACurrencyMax());
    AchievementTermQuantitySet(1, "SolarPowered100", libVoiC_gf_PC_SoACurrencyMax());
    AchievementTermQuantitySet(1, "SolarPowered150", libVoiC_gf_PC_SoACurrencyMax());
    AchievementTermQuantitySet(1, "SolarPowered200", libVoiC_gf_PC_SoACurrencyMax());
    AchievementTermQuantitySet(1, "SolarPowered250", libVoiC_gf_PC_SoACurrencyMax());
    AchievementTermQuantitySet(1, "SolarPowered300", libVoiC_gf_PC_SoACurrencyMax());
    libVoiC_gf_PC_AchievementAwardMission(libVoiC_gf_CurrentMap());
}

void libVCMI_gf_PU_CampaignVictory () {
    // Automatic Variable Declarations
    // Implementation
    libVoiC_gf_PlayCinematic("EpilogueEnd", false);
    UISetWorldVisible(PlayerGroupAll(), false);
    libVCUI_gf_SetHeroPanelUnit(1, null);
    PlayerSetRace(1, "Prot");
    libNtve_gf_HideGameUI(false, PlayerGroupAll());
    libVCUI_gf_PU_GPVisibilityAutoUpdate(false, c_transitionDurationImmediate);
    libVCUI_gf_HideCampaignDirective();
    UIClearMessages(PlayerGroupAll(), c_messageAreaAll);
    UISetCursorVisible(PlayerGroupAll(), false);
    UISetFrameVisible(PlayerGroupAll(), c_syncFrameTypeBattleUI, false);
    Wait(0.1, c_timeReal);
    SoundtrackDefault(PlayerGroupAll(), c_soundtrackCategoryMusic, null, c_soundtrackCueAny, c_soundtrackIndexAny);
    SoundtrackDefault(PlayerGroupAll(), c_soundtrackCategoryAmbience, null, c_soundtrackCueAny, c_soundtrackIndexAny);
    SoundtrackStop(PlayerGroupAll(), c_soundtrackCategoryMusic, false);
    SoundtrackStop(PlayerGroupAll(), c_soundtrackCategoryAmbience, false);
    SoundChannelStop(PlayerGroupAll(), c_soundCategoryUI);
    SoundStopAllTriggerSounds(false);
    TransmissionClearAll();
    libVCUI_gf_PU_CreditsEpilogueDisplay();
    TriggerDebugOutput(1, StringExternal("Param/Value/lib_VCMI_7935DF9F"), false);
    CinematicFade(false, 0.5, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
    if ((libVoiC_gv_pCX_IsSimulation == false)) {
        GameSetNextMap("");
    }

    if ((AchievementsDisabled(1) == false)) {
        CampaignProgressDeleteCampaignSave(PlayerGroupAll());
    }

    GameOver(1, c_gameOverVictory, false, false);
}

void libVCMI_gf_PU_CampaignVictory2 () {
    // Automatic Variable Declarations
    // Implementation
    UISetWorldVisible(PlayerGroupAll(), false);
    SoundtrackDefault(PlayerGroupAll(), c_soundtrackCategoryMusic, null, c_soundtrackCueAny, c_soundtrackIndexAny);
    SoundtrackDefault(PlayerGroupAll(), c_soundtrackCategoryAmbience, null, c_soundtrackCueAny, c_soundtrackIndexAny);
    SoundtrackStop(PlayerGroupAll(), c_soundtrackCategoryMusic, true);
    SoundtrackStop(PlayerGroupAll(), c_soundtrackCategoryAmbience, true);
    SoundStopAllTriggerSounds(true);
    TransmissionClearAll();
    libNtve_gf_CinematicMode(true, PlayerGroupAll(), c_transitionDurationImmediate);
    libVCUI_gf_PU_CreditsVoidDisplay();
    libVoiC_gf_CinematicFade(true, 0.0, Color(0.00, 0.00, 0.00), true);
    libVoiC_gf_CampaignPlayCutscene2("Cutscenes\\Cutscene_ProtossStinger.SC2Cutscene", true, false);
    TriggerDebugOutput(1, StringExternal("Param/Value/lib_VCMI_7A38473E"), false);
    CinematicFade(false, 0.1, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
    if ((libVoiC_gv_pCX_IsSimulation == false)) {
        GameSetNextMap("");
        CampaignProgressDeleteCampaignSave(PlayerGroupAll());
    }

    GameOver(1, c_gameOverVictory, false, false);
}

trigger auto_libVCMI_gf_HandleHeroDeathVoid_Trigger = null;
unit auto_libVCMI_gf_HandleHeroDeathVoid_lp_heroUnit;
unit auto_libVCMI_gf_HandleHeroDeathVoid_lp_reviveLocation;
fixed auto_libVCMI_gf_HandleHeroDeathVoid_lp_reviveTime;

void libVCMI_gf_HandleHeroDeathVoid (unit lp_heroUnit, unit lp_reviveLocation, fixed lp_reviveTime) {
    auto_libVCMI_gf_HandleHeroDeathVoid_lp_heroUnit = lp_heroUnit;
    auto_libVCMI_gf_HandleHeroDeathVoid_lp_reviveLocation = lp_reviveLocation;
    auto_libVCMI_gf_HandleHeroDeathVoid_lp_reviveTime = lp_reviveTime;

    if (auto_libVCMI_gf_HandleHeroDeathVoid_Trigger == null) {
        auto_libVCMI_gf_HandleHeroDeathVoid_Trigger = TriggerCreate("auto_libVCMI_gf_HandleHeroDeathVoid_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_HandleHeroDeathVoid_Trigger, false, false);
}

bool auto_libVCMI_gf_HandleHeroDeathVoid_TriggerFunc (bool testConds, bool runActions) {
    unit lp_heroUnit = auto_libVCMI_gf_HandleHeroDeathVoid_lp_heroUnit;
    unit lp_reviveLocation = auto_libVCMI_gf_HandleHeroDeathVoid_lp_reviveLocation;
    fixed lp_reviveTime = auto_libVCMI_gf_HandleHeroDeathVoid_lp_reviveTime;

    // Variable Declarations
    int lv_heroType;
    unit lv_actualReviveLocation;
    string lv_reviveUnitType;
    text lv_reviveMessage;
    text lv_reviveRebuildMessage;
    fixed lv_reviveCooldown;
    bool lv_updateRally;

    // Automatic Variable Declarations
    int autoEABFE1D8_val;
    int autoE295FE6A_val;

    // Variable Initialization

    // Implementation
    if ((lp_reviveLocation != null) && (UnitIsAlive(lp_reviveLocation) == false)) {
        TriggerDebugOutput(1, StringExternal("Param/Value/lib_VCMI_59A400F9"), false);
        return true;
    }

    lv_heroType = libVCMI_gf_PM_HeroTypeFromUnitType(UnitGetType(lp_heroUnit));
    libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)] = UnitGetOwner(lp_heroUnit);
    libVCMI_gv_pM_HeroRevivingUnit[(lv_heroType)] = lp_heroUnit;
    autoEABFE1D8_val = lv_heroType;
    if (autoEABFE1D8_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan) {
        lv_reviveUnitType = "KerriganReviveCocoon";
        libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)] = "Abil/KerriganRevive";
        libVCMI_gv_pM_HeroReviveCommand[(lv_heroType)] = AbilityCommand("KerriganRevive", 0);
        if ((lp_reviveTime == -1.0)) {
            lv_reviveCooldown = libVCMI_gv_pM_ReviveCooldownTimeKerrigan;
        }
        else {
            lv_reviveCooldown = lp_reviveTime;
        }
        if ((libVCMI_gv_pM_ReviveUseAltMessage == true)) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_5054DF3B", "A", IntToText(FixedToInt(lv_reviveCooldown)));
            lv_reviveMessage = TextExpressionAssemble("Param/Expression/lib_VCMI_5054DF3B");
            lv_reviveRebuildMessage = StringExternal("Param/Value/lib_VCMI_C27E3E9D");
        }
        else {
            TextExpressionSetToken("Param/Expression/lib_VCMI_E7DF13E9", "A", IntToText(FixedToInt(lv_reviveCooldown)));
            lv_reviveMessage = TextExpressionAssemble("Param/Expression/lib_VCMI_E7DF13E9");
            lv_reviveRebuildMessage = StringExternal("Param/Value/lib_VCMI_06409747");
        }
        if ((libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)] == 1)) {
            lv_updateRally = true;
        }

    }
    else if (autoEABFE1D8_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga) {
        lv_reviveUnitType = "KerriganXelNagaReviveCocoon";
        libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)] = "Abil/KerriganRevive";
        libVCMI_gv_pM_HeroReviveCommand[(lv_heroType)] = AbilityCommand("KerriganRevive", 0);
        if ((lp_reviveTime == -1.0)) {
            lv_reviveCooldown = libVCMI_gv_pM_ReviveCooldownTimeKerriganXelNaga;
        }
        else {
            lv_reviveCooldown = lp_reviveTime;
        }
        if ((libVCMI_gv_pM_ReviveUseAltMessage == true)) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_399D4B3D", "A", IntToText(FixedToInt(lv_reviveCooldown)));
            lv_reviveMessage = TextExpressionAssemble("Param/Expression/lib_VCMI_399D4B3D");
            lv_reviveRebuildMessage = StringExternal("Param/Value/lib_VCMI_444CF7C1");
        }
        else {
            TextExpressionSetToken("Param/Expression/lib_VCMI_68545161", "A", IntToText(FixedToInt(lv_reviveCooldown)));
            lv_reviveMessage = TextExpressionAssemble("Param/Expression/lib_VCMI_68545161");
            lv_reviveRebuildMessage = StringExternal("Param/Value/lib_VCMI_302D050C");
        }
        if ((libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)] == 1)) {
            lv_updateRally = true;
        }

    }
    else if (autoEABFE1D8_val == libVCMI_ge_PM_HeroType_PM_HeroType_Fenix) {
        lv_reviveUnitType = "FenixCocoon";
        libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)] = "Abil/FenixRevive";
        libVCMI_gv_pM_HeroReviveCommand[(lv_heroType)] = AbilityCommand("FenixRevive", 0);
        if ((lp_reviveTime == -1.0)) {
            lv_reviveCooldown = libVCMI_gv_pM_ReviveCooldownTimeFenix;
        }
        else {
            lv_reviveCooldown = lp_reviveTime;
        }
        TextExpressionSetToken("Param/Expression/lib_VCMI_D17F5A07", "A", IntToText(FixedToInt(lv_reviveCooldown)));
        lv_reviveMessage = TextExpressionAssemble("Param/Expression/lib_VCMI_D17F5A07");
        lv_reviveRebuildMessage = StringExternal("Param/Value/lib_VCMI_783D9F58");
    }
    else if (autoEABFE1D8_val == libVCMI_ge_PM_HeroType_PM_HeroType_Stukov) {
        lv_reviveUnitType = "StukovReviveCocoon";
        libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)] = "Abil/StukovRevive";
        libVCMI_gv_pM_HeroReviveCommand[(lv_heroType)] = AbilityCommand("StukovRevive", 0);
        if ((lp_reviveTime == -1.0)) {
            lv_reviveCooldown = libVCMI_gv_pM_ReviveCooldownTimeStukov;
        }
        else {
            lv_reviveCooldown = lp_reviveTime;
        }
        TextExpressionSetToken("Param/Expression/lib_VCMI_14461E7B", "A", IntToText(FixedToInt(lv_reviveCooldown)));
        lv_reviveMessage = TextExpressionAssemble("Param/Expression/lib_VCMI_14461E7B");
        lv_reviveRebuildMessage = StringExternal("Param/Value/lib_VCMI_6A6A7100");
    }
    else if (autoEABFE1D8_val == libVCMI_ge_PM_HeroType_PM_HeroType_Zagara) {
        lv_reviveUnitType = "ZagaraReviveCocoon";
        libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)] = "Abil/ZagaraRevive";
        libVCMI_gv_pM_HeroReviveCommand[(lv_heroType)] = AbilityCommand("ZagaraRevive", 0);
        if ((lp_reviveTime == -1.0)) {
            lv_reviveCooldown = libVCMI_gv_pM_ReviveCooldownTimeZagara;
        }
        else {
            lv_reviveCooldown = lp_reviveTime;
        }
    }
    else {
        TextExpressionSetToken("Param/Expression/lib_VCMI_A9DB134E", "A", StringToText((UnitGetType(lp_heroUnit))));
        TriggerDebugOutput(1, TextExpressionAssemble("Param/Expression/lib_VCMI_A9DB134E"), false);
        return true;
    }
    libVCMI_gv_pM_ReviveUseAltMessage = false;
    if ((lp_reviveLocation != null)) {
        lv_actualReviveLocation = lp_reviveLocation;
    }
    else {
        lv_actualReviveLocation = libVCMI_gf_PM_FindPrimaryTownHall(libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)]);
    }
    if ((libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)] == 1)) {
        if (((lv_actualReviveLocation == null) || (UnitIsAlive(lv_actualReviveLocation) == false))) {
            libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_Warning, lv_reviveRebuildMessage, libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
        }
        else {
            libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_Warning, lv_reviveMessage, libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
        }
    }

    Wait(2.0, c_timeGame);
    while (((lv_actualReviveLocation == null) || (UnitIsAlive(lv_actualReviveLocation) == false))) {
        Wait(1.0, c_timeGame);
        lv_actualReviveLocation = libVCMI_gf_PM_FindPrimaryTownHall(libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)]);
    }
    if ((UnitIsAlive(lp_heroUnit) == false)) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, lv_reviveUnitType, 0, libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)], UnitGetPosition(lv_actualReviveLocation));
        libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)] = UnitLastCreated();
        if ((lv_heroType == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)) {
            libVCUI_gf_SetHeroPanelUnit(1, UnitLastCreated());
        }

        if ((lv_updateRally == true)) {
            UnitCreateEffectUnit(lv_actualReviveLocation, "CopyHatcheryRally", libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)]);
            UnitIssueOrder(libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)], OrderTargetingUnit(AbilityCommand("RallyHatchery", 1), libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)]), c_orderQueueReplace);
        }

        libNtve_gf_PlayerRemoveCooldown(libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)], libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)]);
        PlayerAddCooldown(libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)], libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)], lv_reviveCooldown);
    }

    autoE295FE6A_val = lv_heroType;
    if (autoE295FE6A_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganCooldownWait, true);
    }
    else if (autoE295FE6A_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait, true);
    }
    else if (autoE295FE6A_val == libVCMI_ge_PM_HeroType_PM_HeroType_Fenix) {
        UnitBehaviorAdd(libVCMI_gv_pM_SoAUnit, "SOAFenixCooldownDummy", libVCMI_gv_pM_SoAUnit, 1);
        TriggerEnable(libVCMI_gt_PM_HeroReviveFenixCooldownWait, true);
    }
    else if (autoE295FE6A_val == libVCMI_ge_PM_HeroType_PM_HeroType_Stukov) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveStukovCooldownWait, true);
    }
    else if (autoE295FE6A_val == libVCMI_ge_PM_HeroType_PM_HeroType_Zagara) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveZagaraCooldownWait, true);
    }
    else {
    }
    Wait(7.0, c_timeGame);
    if ((UnitIsAlive(lp_heroUnit) == false)) {
        UnitSetPosition(lp_heroUnit, UnitGetPosition(libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)]), false);
    }

    return true;
}

void libVCMI_gf_ReviveHeroInstantly (unit lp_heroUnit, bool lp_displayReviveMessage) {
    // Variable Declarations
    int lv_heroType;

    // Automatic Variable Declarations
    int auto81273459_val;
    int autoE5152A70_val;

    // Variable Initialization

    // Implementation
    lv_heroType = libVCMI_gf_PM_HeroTypeFromUnitType(UnitGetType(lp_heroUnit));
    auto81273459_val = lv_heroType;
    if (auto81273459_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganCooldownWait, false);
    }
    else if (auto81273459_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait, false);
    }
    else if (auto81273459_val == libVCMI_ge_PM_HeroType_PM_HeroType_Fenix) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveFenixCooldownWait, false);
    }
    else if (auto81273459_val == libVCMI_ge_PM_HeroType_PM_HeroType_Stukov) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveStukovCooldownWait, false);
    }
    else if (auto81273459_val == libVCMI_ge_PM_HeroType_PM_HeroType_Zagara) {
        TriggerEnable(libVCMI_gt_PM_HeroReviveStukovCooldownWait, false);
    }
    else {
    }
    libNtve_gf_PlayerRemoveCooldown(libVCMI_gv_pM_HeroRevivePlayer[(lv_heroType)], libVCMI_gv_pM_HeroReviveCDLink[(lv_heroType)]);
    UnitIssueOrder(libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)], libNtve_gf_ReviveOrderWithNoTarget(libVCMI_gv_pM_HeroReviveCommand[(lv_heroType)], libVCMI_gv_pM_HeroRevivingUnit[(lv_heroType)]), c_orderQueueReplace);
    Wait(0.0625, c_timeGame);
    UnitKill(libVCMI_gv_pM_HeroReviverUnit[(lv_heroType)]);
    if ((lv_heroType == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)) {
        UnitIssueOrder(libVCMI_gv_pM_HeroRevivingUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)], Order(AbilityCommand("KerriganEpilogue03Unburrow", 0)), c_orderQueueReplace);
    }

    if ((lv_heroType == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)) {
        UnitIssueOrder(libVCMI_gv_pM_HeroRevivingUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)], Order(AbilityCommand("KerriganEpilogue03Unburrow", 0)), c_orderQueueReplace);
    }

    if ((lp_displayReviveMessage == true)) {
        autoE5152A70_val = lv_heroType;
        if (autoE5152A70_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan) {
            libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_0BBEA80B"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
        }
        else if (autoE5152A70_val == libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga) {
            libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_176E90A7"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
        }
        else if (autoE5152A70_val == libVCMI_ge_PM_HeroType_PM_HeroType_Fenix) {
            libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_78D8179B"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
        }
        else if (autoE5152A70_val == libVCMI_ge_PM_HeroType_PM_HeroType_Stukov) {
            libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_C61F90A6"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
        }
        else {
        }
    }

}

void libVCMI_gf_PM_HeroRevive (int lp_heroType) {
    // Variable Declarations
    int lv_heroIndex;

    // Automatic Variable Declarations
    unitgroup auto7AB41B75_g;
    int auto7AB41B75_u;
    unit auto7AB41B75_var;

    // Variable Initialization

    // Implementation
    lv_heroIndex = (lp_heroType);
    UnitIssueOrder(libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex], libNtve_gf_ReviveOrderWithNoTarget(libVCMI_gv_pM_HeroReviveCommand[lv_heroIndex], libVCMI_gv_pM_HeroRevivingUnit[lv_heroIndex]), c_orderQueueReplace);
    Wait(0.125, c_timeGame);
    if ((libVCMI_gv_pM_HeroRevivePlayer[lv_heroIndex] == 1)) {
        auto7AB41B75_g = UnitGroupSelected(1);
        auto7AB41B75_u = UnitGroupCount(auto7AB41B75_g, c_unitCountAll);
        for (;; auto7AB41B75_u -= 1) {
            auto7AB41B75_var = UnitGroupUnitFromEnd(auto7AB41B75_g, auto7AB41B75_u);
            if (auto7AB41B75_var == null) { break; }
            if ((auto7AB41B75_var == libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex])) {
                UnitSelect(libVCMI_gv_pM_HeroRevivingUnit[lv_heroIndex], libVCMI_gv_pM_HeroRevivePlayer[lv_heroIndex], true);
            }

        }
    }

    UnitKill(libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex]);
}

int libVCMI_gf_PM_HeroTypeFromUnitType (string lp_unitType) {
    // Automatic Variable Declarations
    // Implementation
    if (((lp_unitType == "KerriganVoid") || (lp_unitType == "KerriganVoidBurrowed") || (lp_unitType == "K5Kerrigan") || (lp_unitType == "K5KerriganBurrowed"))) {
        return libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan;
    }
    else if (((lp_unitType == "FenixSOA") || (lp_unitType == "FenixSOAMark2") || (lp_unitType == "FenixSOAMark3"))) {
        return libVCMI_ge_PM_HeroType_PM_HeroType_Fenix;
    }
    else if ((lp_unitType == "InfestedStukov")) {
        return libVCMI_ge_PM_HeroType_PM_HeroType_Stukov;
    }
    else if ((lp_unitType == "KerriganEpilogue03")) {
        return libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga;
    }
    else if (((lp_unitType == "ZaGara") || (lp_unitType == "ZaGaraBurrowed"))) {
        return libVCMI_ge_PM_HeroType_PM_HeroType_Zagara;
    }
    return libVCMI_ge_PM_HeroType_PM_HeroType_None;
}

unit libVCMI_gf_PM_FindPrimaryTownHall (int lp_player) {
    // Variable Declarations
    fixed lv_distance;
    unitgroup lv_townHallGroup;
    unit lv_indexTownHall;
    unit lv_closestTownHall;

    // Automatic Variable Declarations
    string auto1C944BDB_val;
    unitgroup auto59F7820C_g;
    int auto59F7820C_u;

    // Variable Initialization
    lv_distance = 500.0;
    lv_townHallGroup = UnitGroupEmpty();

    // Implementation
    auto1C944BDB_val = PlayerRace(lp_player);
    if (auto1C944BDB_val == "Prot") {
        lv_townHallGroup = UnitGroup("Nexus", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterUnderConstruction - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    }
    else if (auto1C944BDB_val == "Terr") {
        lv_townHallGroup = UnitGroup("CommandCenter", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        UnitGroupAddUnitGroup(lv_townHallGroup, UnitGroup("OrbitalCommand", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        UnitGroupAddUnitGroup(lv_townHallGroup, UnitGroup("OrbitalCommandFlying", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        UnitGroupAddUnitGroup(lv_townHallGroup, UnitGroup("CommandCenterFlying", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        UnitGroupAddUnitGroup(lv_townHallGroup, UnitGroup("PlanetaryFortress", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    }
    else if (auto1C944BDB_val == "Zerg") {
        lv_townHallGroup = UnitGroup("Hive", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        UnitGroupAddUnitGroup(lv_townHallGroup, UnitGroup("Lair", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
        UnitGroupAddUnitGroup(lv_townHallGroup, UnitGroup("Hatchery", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    }
    else {
    }
    auto59F7820C_g = lv_townHallGroup;
    auto59F7820C_u = UnitGroupCount(auto59F7820C_g, c_unitCountAll);
    for (;; auto59F7820C_u -= 1) {
        lv_indexTownHall = UnitGroupUnitFromEnd(auto59F7820C_g, auto59F7820C_u);
        if (lv_indexTownHall == null) { break; }
        if ((DistanceBetweenPoints(PlayerStartLocation(lp_player), UnitGetPosition(lv_indexTownHall)) < lv_distance)) {
            lv_distance = DistanceBetweenPoints(PlayerStartLocation(lp_player), UnitGetPosition(lv_indexTownHall));
            lv_closestTownHall = lv_indexTownHall;
        }

    }
    return lv_closestTownHall;
}

void libVCMI_gf_SetHeroIsAliveStatus (bool lp_isAlive, string lp_hero) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_isAlive == true)) {
        UserDataSetInt("HeroStatus", lp_hero, "IsAlive", 1, 1);
    }
    else {
        UserDataSetInt("HeroStatus", lp_hero, "IsAlive", 1, 0);
    }
}

void libVCMI_gf_SetSpearofAdunEnergy (fixed lp_energy, int lp_type) {
    // Automatic Variable Declarations
    int autoC599E855_val;

    // Implementation
    autoC599E855_val = lp_type;
    if (autoC599E855_val == libVCMI_ge_SpearofAdunEnergyType_Absolute) {
        UnitSetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergy, lp_energy);
    }
    else if (autoC599E855_val == libVCMI_ge_SpearofAdunEnergyType_Percent) {
        UnitSetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergyPercent, lp_energy);
    }
    else if (autoC599E855_val == libVCMI_ge_SpearofAdunEnergyType_Regeneration) {
        UnitSetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergyRegen, lp_energy);
    }
    else {
    }
    if ((libVCMI_gf_PlayerInCinematicModeCampaign() == true) && (lp_type != libVCMI_ge_SpearofAdunEnergyType_Regeneration)) {
        libVCMI_gv_pM_CinematicModeSoAEnergy = UnitGetPropertyFixed(libVCMI_gv_sOA_CasterUnit, c_unitPropEnergy, c_unitPropCurrent);
    }

}

fixed libVCMI_gf_SpearofAdunEnergy (int lp_type) {
    // Automatic Variable Declarations
    int auto848F162A_val;

    // Implementation
    auto848F162A_val = lp_type;
    if (auto848F162A_val == libVCMI_ge_SpearofAdunEnergyType_Percent) {
        return UnitGetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergyPercent, c_unitPropCurrent);
    }
    else if (auto848F162A_val == libVCMI_ge_SpearofAdunEnergyType_Absolute) {
        return UnitGetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergy, c_unitPropCurrent);
    }
    else if (auto848F162A_val == libVCMI_ge_SpearofAdunEnergyType_Regeneration) {
        return UnitGetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergyRegen, c_unitPropCurrent);
    }
    else {
    }
    return 0.0;
}

void libVCMI_gf_PlaySpearofAdunAttackCutscene (camerainfo lp_camera) {
    // Variable Declarations
    string lv_locationFilter;
    string lv_spaceScene;

    // Automatic Variable Declarations
    string auto96F65A59_val;

    // Variable Initialization
    lv_locationFilter = "";
    lv_spaceScene = "Cutscenes\\Mission_SoACalldown_OrbitalStrike.SC2Cutscene";

    // Implementation
    CameraSetValue(1, c_cameraValueDistance, 100.0, 0.3, -1, 0.0);
    Wait(0.25, c_timeGame);
    auto96F65A59_val = libVoiC_gf_StoryMapPlanet(libVoiC_gf_CurrentMap());
    if (auto96F65A59_val == "Korhal") {
        lv_locationFilter = "Korhal";
    }
    else if (auto96F65A59_val == "Shakuras") {
        lv_locationFilter = "Shakuras";
    }
    else {
    }
    CutsceneAddGlobalFilter(lv_locationFilter);
    libVoiC_gf_CampaignPlayCutscene2(lv_spaceScene, true, true);
    CutsceneRemoveGlobalFilter(lv_locationFilter);
    CameraApplyInfo(1, lp_camera, 0.0, -1, 10, true);
    CameraSetValue(1, c_cameraValueDistance, 100.0, 0.0, -1, 0.0);
    CameraSetValue(1, c_cameraValueDistance, CameraInfoGetValue(lp_camera, c_cameraValueDistance), 0.4, -1, 0.0);
}

void libVCMI_gf_PauseUnpauseSpearofAdunCooldowns (bool lp_pauseUnpause) {
    // Automatic Variable Declarations
    // Implementation
    if ((lp_pauseUnpause == true)) {
        libVCMI_gv_pM_SoAPaused = true;
        if ((UnitHasBehavior2(libVCMI_gv_pM_SoAUnit, "SOAAbilityDisable") == false)) {
            UnitBehaviorAdd(libVCMI_gv_pM_SoAUnit, "SOAAbilityDisable", libVCMI_gv_pM_SoAUnit, 1);
        }

    }
    else {
        libVCMI_gv_pM_SoAPaused = false;
        UnitBehaviorRemove(libVCMI_gv_pM_SoAUnit, "SOAAbilityDisable", 1);
    }
}

void libVCMI_gf_PM_SoACreateUnit () {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_CreateUnitsWithDefaultFacing(1, "SoACaster", c_unitCreateIgnorePlacement, libVoiC_gv_pCC_SoAPlayerSlot, Point(0.0, 0.0));
    libVCMI_gv_pM_SoAUnit = UnitLastCreated();
    UnitSetState(libVCMI_gv_pM_SoAUnit, c_unitStateSelectable, false);
    libVCUI_gf_PU_GPSetUnit(libVCMI_gv_pM_SoAUnit);
    libVCMI_gf_PM_SoACasterUnitSet(libVCMI_gv_pM_SoAUnit);
    if ((libVCMI_gv_pM_SoAPaused == true)) {
        UnitBehaviorAdd(libVCMI_gv_pM_SoAUnit, "SOAAbilityDisable", libVCMI_gv_pM_SoAUnit, 1);
    }

    if ((libVCMI_gf_PlayerInCinematicModeCampaign() == true)) {
        libVCMI_gv_pM_CinematicModeSoAEnergy = libVCMI_gf_SpearofAdunEnergy(libVCMI_ge_SpearofAdunEnergyType_Absolute);
    }

}

void libVCMI_gf_PreparePlanetPortraitZoomIn (string lp_model, camerainfo lp_camera, string lp_light) {
    // Variable Declarations

    // Automatic Variable Declarations
    string autoC182DE42_val;

    // Variable Initialization

    // Implementation
    if ((libVCMI_gv_pM_PlanetPortrait == c_invalidPortraitId)) {
        PortraitCreate(0, 0, c_anchorTopLeft, 50, 50, lp_model, "", "Default", false, false);
        libVCMI_gv_pM_PlanetPortrait = PortraitLastCreated();
        PortraitSetOffscreen(libVCMI_gv_pM_PlanetPortrait, true);
        PortraitSetBackgroundVisible(libVCMI_gv_pM_PlanetPortrait, false);
        PortraitSetBorderVisible(libVCMI_gv_pM_PlanetPortrait, false);
        PortraitUseTransition(PortraitLastCreated(), false);
        PortraitWaitForLoad(libVCMI_gv_pM_PlanetPortrait);
    }
    else {
        PortraitSetModel(libVCMI_gv_pM_PlanetPortrait, lp_model, true);
    }
    autoC182DE42_val = lp_model;
    {
    }
    PortraitSetLight(libVCMI_gv_pM_PlanetPortrait, lp_light);
    GameSetLighting(lp_light, 0.0);
    PortraitSetPosition(libVCMI_gv_pM_PlanetPortrait, c_anchorTopLeft, 0, 0);
    PortraitSetFullscreen(libVCMI_gv_pM_PlanetPortrait, true);
    PortraitSetOffscreen(libVCMI_gv_pM_PlanetPortrait, false);
    PortraitSetVisible(libVCMI_gv_pM_PlanetPortrait, PlayerGroupAll(), true, true);
    libVoiC_gf_CinematicFade(false, 0.0, Color(0.00, 0.00, 0.00), true);
    libVoiC_gf_CinematicFade(true, 2.0, Color(0.00, 0.00, 0.00), true);
    libVCMI_gv_pM_PlanetPortraitPlayerCamera = lp_camera;
    CameraApplyInfo(1, lp_camera, 0.0, -1, 10, true);
    CameraSetValue(1, c_cameraValueDistance, (CameraInfoGetValue(lp_camera, c_cameraValueDistance) + 100.0), 0.0, -1, 20.0);
    CinematicFade(true, 0.0, c_fadeStyleNormal, Color(0.00, 0.00, 0.00), 0.0, true);
}

void libVCMI_gf_ZoomInPlanetPortrait () {
    // Automatic Variable Declarations
    // Implementation
    SoundPlay(SoundLink("UI_Evolutions_PlanetaryZoom", -1), PlayerGroupAll(), 100.0, 0.0);
    ActorSend(ActorFromPortrait(libVCMI_gv_pM_PlanetPortrait), "AnimPlay Custom Spell PlayForever,NonLooping");
    Wait(3.0, c_timeGame);
    CameraSetValue(1, c_cameraValueDistance, CameraInfoGetValue(libVCMI_gv_pM_PlanetPortraitPlayerCamera, c_cameraValueDistance), 2.0, 100.0, 10.0);
    Wait(1.5, c_timeGame);
}

trigger auto_libVCMI_gf_HidePlanetPortrait_Trigger = null;

void libVCMI_gf_HidePlanetPortrait () {
    if (auto_libVCMI_gf_HidePlanetPortrait_Trigger == null) {
        auto_libVCMI_gf_HidePlanetPortrait_Trigger = TriggerCreate("auto_libVCMI_gf_HidePlanetPortrait_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_HidePlanetPortrait_Trigger, false, false);
}

bool auto_libVCMI_gf_HidePlanetPortrait_TriggerFunc (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Implementation
    PortraitSetOffscreen(libVCMI_gv_pM_PlanetPortrait, true);
    ActorSend(ActorFromPortrait(libVCMI_gv_pM_PlanetPortrait), "AnimClear Custom 0.000000");
    return true;
}

void libVCMI_gf_StartAIPersonalityForPlayerCampaign (int lp_player, string lp_personality) {
    // Automatic Variable Declarations
    // Deprecated
}

void libVCMI_gf_StartAIPersonalitiesForAllPlayersCampaign () {
    // Variable Declarations
    int lv_indexPlayer;

    // Automatic Variable Declarations
    // Variable Initialization

    // Deprecated
    CampaignInitAI();
}

void libVCMI_gf_StartCampaignAIForAllPlayersVoid () {
    // Automatic Variable Declarations
    // Deprecated
    CampaignInitAI();
}

void libVCMI_gf_StartCampaignAIForPlayerVoid (int lp_player) {
    // Automatic Variable Declarations
    // Deprecated
    AICampaignStart(lp_player);
}

void libVCMI_gf_EnableVoidCampaignAIBehaviorForAllPlayers () {
    // Variable Declarations
    int lv_indexPlayer;

    // Automatic Variable Declarations
    playergroup autoDF48CB2F_g;

    // Variable Initialization

    // Implementation
    autoDF48CB2F_g = PlayerGroupAll();
    lv_indexPlayer = -1;
    while (true) {
        lv_indexPlayer = PlayerGroupNextPlayer(autoDF48CB2F_g, lv_indexPlayer);
        if (lv_indexPlayer < 0) { break; }
        if ((PlayerType(lv_indexPlayer) == c_playerTypeComputer)) {
            libVCMI_gf_EnableVoidCampaignAIBehaviorForPlayer(lv_indexPlayer);
        }

    }
}

void libVCMI_gf_EnableVoidCampaignAIBehaviorForPlayer (int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    AISetDifficulty(lp_player, c_diffAvoidMindControlled, false);
    AICombatDiffFlagTieBreakHealers (lp_player, c_combatFlagDisable);
}

void libVCMI_gf_EnableDisableNeedPylonInfo (bool lp_enableDisable) {
    // Automatic Variable Declarations
    // Implementation
    libVCMI_gv_pM_NeedPylonEnabled = lp_enableDisable;
    if ((libVCMI_gv_pM_NeedPylonEnabled == false)) {
        if ((libVCMI_gv_pM_NeedPylonAbilityHighlightOn == true)) {
            libVCMI_gv_pM_NeedPylonAbilityHighlightOn = false;
            UIClearMessages(PlayerGroupSingle(1), c_messageAreaDirective);
            UISetButtonHighlighted(PlayerGroupSingle(1), AbilityCommand("ProtossBuild", 1), false);
            CatalogFieldValueSet(c_gameCatalogButton, "Pylon", "Tooltip", 1, "Button/Tooltip/Pylon");
        }

    }

}

bool libVCMI_gf_NeedPylonHighlightOn () {
    // Automatic Variable Declarations
    // Implementation
    return libVCMI_gv_pM_NeedPylonAbilityHighlightOn;
}

bool libVCMI_gf_ValidAntiAirUnitIsNearUnit (int lp_player, unit lp_unit) {
    // Variable Declarations
    bool lv_validAttackerFound;
    point lv_unitPosition;

    // Automatic Variable Declarations
    unitgroup auto4C6B244C_g;
    int auto4C6B244C_u;
    unit auto4C6B244C_var;
    unitgroup auto89AFDACF_g;
    int auto89AFDACF_u;
    unit auto89AFDACF_var;

    // Variable Initialization

    // Implementation
    lv_unitPosition = UnitGetPosition(lp_unit);
    auto4C6B244C_g = UnitGroup(null, lp_player, RegionCircle(lv_unitPosition, 16.0), UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterWorker) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto4C6B244C_u = UnitGroupCount(auto4C6B244C_g, c_unitCountAll);
    for (;; auto4C6B244C_u -= 1) {
        auto4C6B244C_var = UnitGroupUnitFromEnd(auto4C6B244C_g, auto4C6B244C_u);
        if (auto4C6B244C_var == null) { break; }
        if ((UnitCanAttackTarget(auto4C6B244C_var, lp_unit) == true)) {
            lv_validAttackerFound = true;
            break;
        }

    }
    if ((lv_validAttackerFound == false)) {
        auto89AFDACF_g = UnitGroup(null, lp_player, RegionCircle(lv_unitPosition, 8.0), UnitFilter((1 << c_targetFilterStructure), 0, (1 << c_targetFilterWorker) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto89AFDACF_u = UnitGroupCount(auto89AFDACF_g, c_unitCountAll);
        for (;; auto89AFDACF_u -= 1) {
            auto89AFDACF_var = UnitGroupUnitFromEnd(auto89AFDACF_g, auto89AFDACF_u);
            if (auto89AFDACF_var == null) { break; }
            if ((UnitCanAttackTarget(auto89AFDACF_var, lp_unit) == true)) {
                lv_validAttackerFound = true;
                break;
            }

        }
    }

    return lv_validAttackerFound;
}

trigger auto_libVCMI_gf_RemindPlayertoCreateAntiAirUnits_Trigger = null;

void libVCMI_gf_RemindPlayertoCreateAntiAirUnits () {
    if (auto_libVCMI_gf_RemindPlayertoCreateAntiAirUnits_Trigger == null) {
        auto_libVCMI_gf_RemindPlayertoCreateAntiAirUnits_Trigger = TriggerCreate("auto_libVCMI_gf_RemindPlayertoCreateAntiAirUnits_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_RemindPlayertoCreateAntiAirUnits_Trigger, false, false);
}

bool auto_libVCMI_gf_RemindPlayertoCreateAntiAirUnits_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_currentUnit;
    bool lv_sendTransmission;

    // Automatic Variable Declarations
    unitgroup auto78DC738F_g;
    int auto78DC738F_u;

    // Variable Initialization

    // Implementation
    while (true) {
        auto78DC738F_g = UnitGroupAlliance(1, c_unitAllianceEnemy, RegionPlayableMap(), UnitFilter((1 << c_targetFilterAir), 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterCloaked), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)) | (1 << (c_targetFilterBenign - 32)) | (1 << (c_targetFilterPassive - 32))), 0);
        auto78DC738F_u = UnitGroupCount(auto78DC738F_g, c_unitCountAll);
        for (;; auto78DC738F_u -= 1) {
            lv_currentUnit = UnitGroupUnitFromEnd(auto78DC738F_g, auto78DC738F_u);
            if (lv_currentUnit == null) { break; }
            if ((UnitGroupCount(UnitGroup(null, 1, RegionCircle(UnitGetPosition(lv_currentUnit), 4.0), UnitFilter((1 << c_targetFilterGround), 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterWorker) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 1), c_unitCountAlive) > 0)) {
                if ((libVCMI_gf_ValidAntiAirUnitIsNearUnit(1, lv_currentUnit) == false)) {
                    Wait(5.0, c_timeAI);
                    if ((UnitIsAlive(lv_currentUnit) == true)) {
                        if ((UnitGroupCount(UnitGroup(null, 1, RegionCircle(UnitGetPosition(lv_currentUnit), 4.0), UnitFilter((1 << c_targetFilterGround), 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterWorker) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 1), c_unitCountAlive) > 0) && (libVCMI_gf_ValidAntiAirUnitIsNearUnit(1, lv_currentUnit) == false)) {
                            lv_sendTransmission = true;
                        }

                    }

                }

                break;
            }

            Wait(0.1, c_timeAI);
        }
        if ((lv_sendTransmission == true)) {
            break;
        }

        Wait(1.0, c_timeAI);
    }
    TriggerQueueEnter();
    if ((libVCMI_gf_GameIsOver() == true)) {
        return true;
    }

    libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Speech);
    libVCMI_gf_SendTransmissionCampaign(null, "pTutorial_Gameplay|Line00010", c_transmissionDurationAdd, 0.0, true, libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter, libVCMI_ge_MissionTransmissionCueSoundOptions_DefaultCueSoundBehavior);
    libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Game);
    TriggerQueueExit();
    return true;
}

trigger auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_Trigger = null;
string auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_lp_bonusObjective;
fixed auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_lp_delay;

void libVCMI_gf_RemindPlayertoCompleteBonusObjective (string lp_bonusObjective, fixed lp_delay) {
    auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_lp_bonusObjective = lp_bonusObjective;
    auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_lp_delay = lp_delay;

    if (auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_Trigger == null) {
        auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_Trigger = TriggerCreate("auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_Trigger, false, false);
}

bool auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_TriggerFunc (bool testConds, bool runActions) {
    string lp_bonusObjective = auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_lp_bonusObjective;
    fixed lp_delay = auto_libVCMI_gf_RemindPlayertoCompleteBonusObjective_lp_delay;

    // Automatic Variable Declarations
    // Implementation
    Wait(lp_delay, c_timeAI);
    if ((libVoiC_gf_MissionObjectiveProgress(lp_bonusObjective) == 0)) {
        TriggerQueueEnter();
        if ((libVCMI_gf_GameIsOver() == true)) {
            return true;
        }

        libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Speech);
        libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Game);
        TriggerQueueExit();
    }

    return true;
}

trigger auto_libVCMI_gf_RemindPlayertoBuildProbes_Trigger = null;
fixed auto_libVCMI_gf_RemindPlayertoBuildProbes_lp_delay;
int auto_libVCMI_gf_RemindPlayertoBuildProbes_lp_amount;

void libVCMI_gf_RemindPlayertoBuildProbes (fixed lp_delay, int lp_amount) {
    auto_libVCMI_gf_RemindPlayertoBuildProbes_lp_delay = lp_delay;
    auto_libVCMI_gf_RemindPlayertoBuildProbes_lp_amount = lp_amount;

    if (auto_libVCMI_gf_RemindPlayertoBuildProbes_Trigger == null) {
        auto_libVCMI_gf_RemindPlayertoBuildProbes_Trigger = TriggerCreate("auto_libVCMI_gf_RemindPlayertoBuildProbes_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_RemindPlayertoBuildProbes_Trigger, false, false);
}

bool auto_libVCMI_gf_RemindPlayertoBuildProbes_TriggerFunc (bool testConds, bool runActions) {
    fixed lp_delay = auto_libVCMI_gf_RemindPlayertoBuildProbes_lp_delay;
    int lp_amount = auto_libVCMI_gf_RemindPlayertoBuildProbes_lp_amount;

    // Variable Declarations
    int lv_probeCount;
    order lv_currentOrder;

    // Automatic Variable Declarations
    unitgroup autoD777BD30_g;
    int autoD777BD30_u;
    unit autoD777BD30_var;

    // Variable Initialization

    // Implementation
    Wait(lp_delay, c_timeAI);
    autoD777BD30_g = UnitGroup("Probe", 1, RegionPlayableMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterBuried), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoD777BD30_u = UnitGroupCount(autoD777BD30_g, c_unitCountAll);
    for (;; autoD777BD30_u -= 1) {
        autoD777BD30_var = UnitGroupUnitFromEnd(autoD777BD30_g, autoD777BD30_u);
        if (autoD777BD30_var == null) { break; }
        lv_currentOrder = UnitOrder(autoD777BD30_var, 0);
        if ((((OrderGetAbilityCommand(lv_currentOrder) == AbilityCommand("ProbeHarvest", 0)) && ((UnitGetType(OrderGetTargetUnit(lv_currentOrder)) == "MineralField") || (UnitGetType(OrderGetTargetUnit(lv_currentOrder)) == "RichMineralField"))) || ((OrderGetAbilityCommand(lv_currentOrder) == AbilityCommand("ProbeHarvest", 1)) && ((UnitHasBehavior(autoD777BD30_var, "CarryMineralFieldMinerals") == true) || (UnitHasBehavior(autoD777BD30_var, "CarryHighYieldMineralFieldMinerals") == true))))) {
            lv_probeCount += 1;
        }

    }
    if ((lv_probeCount <= lp_amount)) {
        TriggerQueueEnter();
        if ((libVCMI_gf_GameIsOver() == true)) {
            return true;
        }

        libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Speech);
        libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Game);
        TriggerQueueExit();
    }

    return true;
}

trigger auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_Trigger = null;
unit auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_lp_assimilator;
fixed auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_lp_delay;

void libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator (unit lp_assimilator, fixed lp_delay) {
    auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_lp_assimilator = lp_assimilator;
    auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_lp_delay = lp_delay;

    if (auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_Trigger == null) {
        auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_Trigger = TriggerCreate("auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_Trigger, false, false);
}

bool auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_TriggerFunc (bool testConds, bool runActions) {
    unit lp_assimilator = auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_lp_assimilator;
    fixed lp_delay = auto_libVCMI_gf_RemindPlayertoAssign3ProbestoAssimilator_lp_delay;

    // Variable Declarations
    int lv_probeCount;
    order lv_currentOrder;

    // Automatic Variable Declarations
    const int auto860A7A22_n = 3;
    int auto860A7A22_i;
    unitgroup auto7D3CC923_g;
    int auto7D3CC923_u;
    unit auto7D3CC923_var;
    unitgroup autoB8EF7717_g;
    int autoB8EF7717_u;
    unit autoB8EF7717_var;

    // Variable Initialization

    // Implementation
    if ((UnitGetType(lp_assimilator) != "Assimilator")) {
        return true;
    }

    Wait(lp_delay, c_timeAI);
    if ((UnitIsAlive(lp_assimilator) == false)) {
        return true;
    }

    for (auto860A7A22_i = 1; auto860A7A22_i <= auto860A7A22_n; auto860A7A22_i += 1) {
        auto7D3CC923_g = UnitGroup("Probe", 1, RegionCircle(UnitGetPosition(lp_assimilator), 5.0), UnitFilter(0, 0, (1 << c_targetFilterMissile) | (1 << c_targetFilterBuried), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        auto7D3CC923_u = UnitGroupCount(auto7D3CC923_g, c_unitCountAll);
        for (;; auto7D3CC923_u -= 1) {
            auto7D3CC923_var = UnitGroupUnitFromEnd(auto7D3CC923_g, auto7D3CC923_u);
            if (auto7D3CC923_var == null) { break; }
            lv_currentOrder = UnitOrder(auto7D3CC923_var, 0);
            if ((((OrderGetAbilityCommand(lv_currentOrder) == AbilityCommand("ProbeHarvest", 0)) && (OrderGetTargetUnit(lv_currentOrder) == lp_assimilator)) || ((OrderGetAbilityCommand(lv_currentOrder) == AbilityCommand("ProbeHarvest", 1)) && (UnitHasBehavior(auto7D3CC923_var, "CarryHarvestableVespeneGeyserGasProtoss") == true)))) {
                lv_probeCount += 1;
            }

        }
        autoB8EF7717_g = UnitGroup("Drone", 1, RegionEntireMap(), UnitFilter(0, (1 << (c_targetFilterHidden - 32)), (1 << c_targetFilterMissile) | (1 << c_targetFilterBuried), (1 << (c_targetFilterDead - 32))), 0);
        autoB8EF7717_u = UnitGroupCount(autoB8EF7717_g, c_unitCountAll);
        for (;; autoB8EF7717_u -= 1) {
            autoB8EF7717_var = UnitGroupUnitFromEnd(autoB8EF7717_g, autoB8EF7717_u);
            if (autoB8EF7717_var == null) { break; }
            lv_currentOrder = UnitOrder(autoB8EF7717_var, 0);
            if ((OrderGetAbilityCommand(lv_currentOrder) == AbilityCommand("DroneHarvest", 0)) && (OrderGetTargetUnit(lv_currentOrder) == lp_assimilator)) {
                lv_probeCount += 1;
            }

        }
        if ((lv_probeCount >= 3)) {
            return true;
        }
        else {
            lv_probeCount = 0;
            Wait(0.5, c_timeAI);
        }
    }
    TriggerQueueEnter();
    if (((libVCMI_gf_GameIsOver() == true) || (UnitIsAlive(lp_assimilator) == false))) {
        return true;
    }

    libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Speech);
    libVCMI_gf_SendTransmissionCampaign(null, "pTutorial_Gameplay|Line00004", c_transmissionDurationAdd, 0.0, true, libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter, libVCMI_ge_MissionTransmissionCueSoundOptions_DefaultCueSoundBehavior);
    libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Game);
    TriggerQueueExit();
    return true;
}

trigger auto_libVCMI_gf_RemindPlayertoTransformGateways_Trigger = null;

void libVCMI_gf_RemindPlayertoTransformGateways () {
    if (auto_libVCMI_gf_RemindPlayertoTransformGateways_Trigger == null) {
        auto_libVCMI_gf_RemindPlayertoTransformGateways_Trigger = TriggerCreate("auto_libVCMI_gf_RemindPlayertoTransformGateways_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_RemindPlayertoTransformGateways_Trigger, false, false);
}

bool auto_libVCMI_gf_RemindPlayertoTransformGateways_TriggerFunc (bool testConds, bool runActions) {
    // Variable Declarations
    unitgroup lv_gateways;
    unitgroup lv_warpgates;
    unit lv_indexUnit;

    // Automatic Variable Declarations
    unitgroup autoED4DB1AA_g;
    int autoED4DB1AA_u;

    // Variable Initialization
    lv_gateways = UnitGroupEmpty();
    lv_warpgates = UnitGroupEmpty();

    // Implementation
    lv_gateways = UnitGroup("Gateway", 1, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    autoED4DB1AA_g = lv_gateways;
    autoED4DB1AA_u = UnitGroupCount(autoED4DB1AA_g, c_unitCountAll);
    for (;; autoED4DB1AA_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(autoED4DB1AA_g, autoED4DB1AA_u);
        if (lv_indexUnit == null) { break; }
        if ((UnitHasBehavior2(lv_indexUnit, "RecentlyCreated") == true)) {
            UnitGroupRemove(lv_gateways, lv_indexUnit);
        }

    }
    lv_warpgates = UnitGroup("WarpGate", 1, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    if ((UnitGroupCount(lv_gateways, c_unitCountAlive) != 0) && (UnitGroupCount(lv_warpgates, c_unitCountAlive) != 0)) {
        TriggerEnable(libVCMI_gt_PM_ReminderPlayerConstructsFromGateway, false);
        TriggerQueueEnter();
        libVCMI_gf_SendTransmissionCampaign(null, "pTutorial_Gameplay|Line00015", c_transmissionDurationAdd, 0.0, true, libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter, libVCMI_ge_MissionTransmissionCueSoundOptions_DefaultCueSoundBehavior);
        TriggerQueueExit();
    }

    return true;
}

int libVCMI_gf_CampaignPlayerColor () {
    // Automatic Variable Declarations
    // Implementation
    return 2;
}

void libVCMI_gf_ResearchAIUpgrade (int lp_count, string lp_upgrade, int lp_player) {
    // Automatic Variable Declarations
    int auto2117ABBB_n;
    int auto2117ABBB_i;

    // Implementation
    auto2117ABBB_n = lp_count;
    for (auto2117ABBB_i = 1; auto2117ABBB_i <= auto2117ABBB_n; auto2117ABBB_i += 1) {
        AIResearch(lp_player, 4, -1, lp_upgrade);
    }
}

void libVCMI_gf_ShareVisionAmongPlayers (playergroup lp_players) {
    // Variable Declarations
    int lv_indexPlayer1;
    int lv_indexPlayer2;

    // Automatic Variable Declarations
    playergroup autoE1FC9780_g;
    playergroup auto201B96D5_g;

    // Variable Initialization

    // Implementation
    autoE1FC9780_g = lp_players;
    lv_indexPlayer1 = -1;
    while (true) {
        lv_indexPlayer1 = PlayerGroupNextPlayer(autoE1FC9780_g, lv_indexPlayer1);
        if (lv_indexPlayer1 < 0) { break; }
        auto201B96D5_g = lp_players;
        lv_indexPlayer2 = -1;
        while (true) {
            lv_indexPlayer2 = PlayerGroupNextPlayer(auto201B96D5_g, lv_indexPlayer2);
            if (lv_indexPlayer2 < 0) { break; }
            if ((lv_indexPlayer1 != lv_indexPlayer2)) {
                PlayerSetAlliance(lv_indexPlayer1, c_allianceIdVision, lv_indexPlayer2, true);
            }

        }
    }
}

bool libVCMI_gf_PlayerIsInCombat (int lp_player) {
    // Variable Declarations
    fixed lv_combatTime;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((libNtve_gf_PlayerInCinematicMode(lp_player) == true)) {
        return false;
    }

    lv_combatTime = MaxF(PlayerGetPropertyFixed(lp_player, c_playerPropDamageDealtTime), PlayerGetPropertyFixed(lp_player, c_playerPropDamageTakenTime));
    lv_combatTime = (TimerGetElapsed(libVCMI_gv_pM_CombatTimer) - lv_combatTime);
    return (lv_combatTime < 4.0);
}

void libVCMI_gf_SetMissionObjectiveProgress2 (string lp_objective, int lp_current, bool lp_showHideMax, text lp_label, bool lp_updatetext) {
    // Automatic Variable Declarations
    // Deprecated
    libVCMI_gf_SetMissionObjectiveProgress(lp_objective, lp_current);
}

void libVCMI_gf_SetMissionObjectiveProgress (string lp_objective, int lp_current) {
    // Variable Declarations
    text lv_name;
    text lv_bonusText;
    text lv_baseText;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    libVoiC_gf_ZS_SetObjectiveProgressData(lp_objective, lp_current);
    if ((libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective) == null)) {
        return ;
    }

    if (((libVoiC_gf_MissionObjectiveItemCount(lp_objective) == 1) || (libVoiC_gf_MissionObjectiveItemCount(lp_objective) == 0))) {
        lv_baseText = UserDataGetText("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "FormatTextSingle", 1);
    }
    else {
        lv_baseText = UserDataGetText("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "FormatText", 1);
    }
    lv_name = TextReplaceWord(lv_baseText, StringExternal("Param/Value/lib_VCMI_90EC773D"), libVoiC_gf_MissionObjectiveName(lp_objective), c_stringReplaceAll, c_stringCase);
    lv_name = TextReplaceWord(lv_name, StringExternal("Param/Value/lib_VCMI_F72DF09B"), IntToText(lp_current), c_stringReplaceAll, c_stringCase);
    lv_name = TextReplaceWord(lv_name, StringExternal("Param/Value/lib_VCMI_7AA38B9D"), IntToText(libVoiC_gf_MissionObjectiveItemCount(lp_objective)), c_stringReplaceAll, c_stringCase);
    if ((libVoiC_gf_MissionObjectiveStateCheck(lp_objective, libVoiC_ge_MissionObjectiveState_Completed) == true)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_BEDEFD56", "A", lv_name);
        lv_name = TextExpressionAssemble("Param/Expression/lib_VCMI_BEDEFD56");
    }

    lv_bonusText = libVoiC_gf_PS_CampaignObjectiveBonusText(lp_objective);
    if (((lv_bonusText != null) == true)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_5966D169", "A", lv_name);
        TextExpressionSetToken("Param/Expression/lib_VCMI_5966D169", "B", lv_bonusText);
        lv_name = TextExpressionAssemble("Param/Expression/lib_VCMI_5966D169");
    }

    if ((libVoiC_gf_MissionObjectiveStateCheck(lp_objective, libVoiC_ge_MissionObjectiveState_Completed) == true)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_E3BF1656", "A", lv_name);
        lv_name = TextExpressionAssemble("Param/Expression/lib_VCMI_E3BF1656");
    }

    ObjectiveSetName(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective)), lv_name);
}

void libVCMI_gf_CreateObjectiveCampaign (string lp_objectiveData) {
    // Variable Declarations
    bool lv_isPrimary;
    text lv_name;
    text lv_bonusText;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_name = libVoiC_gf_MissionObjectiveName(lp_objectiveData);
    lv_bonusText = libVoiC_gf_PS_CampaignObjectiveBonusText(lp_objectiveData);
    if (((lv_bonusText != null) == true)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_6E2C27E8", "A", lv_name);
        lv_name = TextExpressionAssemble("Param/Expression/lib_VCMI_6E2C27E8");
    }

    ObjectiveCreate(lv_name, libVoiC_gf_MissionObjectiveDescription(lp_objectiveData), c_objectiveStateActive, libVoiC_gf_PS_GetObjectiveTypeBoolean(lp_objectiveData));
    DataTableSetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objectiveData), ObjectiveLastCreated());
    if ((libVoiC_gf_PS_ObjectiveCountsDown(lp_objectiveData) == false)) {
        libVCMI_gf_SetMissionObjectiveProgress(lp_objectiveData, 0);
    }
    else {
        libVCMI_gf_SetMissionObjectiveProgress(lp_objectiveData, libVoiC_gf_MissionObjectiveItemCount(lp_objectiveData));
    }
}

void libVCMI_gf_ZS_SetMissionObjectiveState (string lp_objective, int lp_state) {
    // Automatic Variable Declarations
    int autoD2FFF70D_val;

    // Implementation
    autoD2FFF70D_val = lp_state;
    if (autoD2FFF70D_val == libVoiC_ge_MissionObjectiveState_Available) {
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Available", 1, 1);
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Complete", 1, 0);
        ObjectiveSetState(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective)), c_objectiveStateActive);
    }
    else if (autoD2FFF70D_val == libVoiC_ge_MissionObjectiveState_Completed) {
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Complete", 1, 1);
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Available", 1, 0);
        ObjectiveSetState(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective)), c_objectiveStateCompleted);
        TextExpressionSetToken("Param/Expression/lib_VCMI_0B6E0658", "A", ObjectiveGetName(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective))));
        ObjectiveSetName(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective)), TextExpressionAssemble("Param/Expression/lib_VCMI_0B6E0658"));
        libVoiC_gf_ZS_SetObjectiveProgressData(lp_objective, libVoiC_gf_MissionObjectiveItemCount(lp_objective));
    }
    else if (autoD2FFF70D_val == libVoiC_ge_MissionObjectiveState_Undiscovered) {
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Complete", 1, 0);
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Available", 1, 0);
        ObjectiveSetState(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective)), c_objectiveStateHidden);
    }
    else if (autoD2FFF70D_val == libVoiC_ge_MissionObjectiveState_Failed) {
        UserDataSetInt("MissionObjective", libVoiC_gf_PS_ObjectiveUserDataInstance(lp_objective), "Complete", 1, 0);
        ObjectiveSetState(DataTableGetObjective(true, libVoiC_gf_PS_ObjectiveTableString(lp_objective)), c_objectiveStateFailed);
    }
    else {
    }
}

void libVCMI_gf_AddMissionTipCampaign (string lp_tipData) {
    // Variable Declarations
    int lv_createdCount;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((UserDataGetInt("CampaignTips", lp_tipData, "Created", 1) >= UserDataGetInt("CampaignTips", lp_tipData, "Display Limit", 1)) && (UserDataGetInt("CampaignTips", lp_tipData, "Display Limit", 1) != 0)) {
        return ;
    }

    libVCMI_gv_pM_MissionTipCount += 1;
    libVCMI_gv_pM_MissionTip[libVCMI_gv_pM_MissionTipCount] = lp_tipData;
    lv_createdCount = UserDataGetInt("CampaignTips", lp_tipData, "Created", 1);
    UserDataSetInt("CampaignTips", lp_tipData, "Created", 1, (lv_createdCount + 1));
    libVCMI_gf_PM_RefreshTip();
}

trigger auto_libVCMI_gf_DisplayMissionTip_Trigger = null;

void libVCMI_gf_DisplayMissionTip () {
    if (auto_libVCMI_gf_DisplayMissionTip_Trigger == null) {
        auto_libVCMI_gf_DisplayMissionTip_Trigger = TriggerCreate("auto_libVCMI_gf_DisplayMissionTip_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_DisplayMissionTip_Trigger, false, false);
}

bool auto_libVCMI_gf_DisplayMissionTip_TriggerFunc (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Implementation
    if ((libLotv_gf_DifficultyValueInt2(1, 1, 1, 0) == 1)) {
        DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer/HelpTipCallout");
        libVCMI_gv_pM_MissionHelpButtonTipPanel = DialogControlLastCreated();
        DialogControlHookupStandard(c_triggerControlTypeButton, "UIContainer/FullscreenUpperContainer/MenuBar/HelpButton");
        libVCMI_gv_pM_MissionHelpButton = DialogControlLastCreated();
        DialogControlSetVisible(libVCMI_gv_pM_MissionHelpButtonTipPanel, PlayerGroupAll(), true);
        TriggerEnable(libVCMI_gt_PM_MissionTipClicked, true);
    }

    Wait(6.0, c_timeReal);
    if ((libVCMI_gv_pM_MissionHelpButtonTipPanel != c_invalidDialogControlId)) {
        DialogControlSetVisible(libVCMI_gv_pM_MissionHelpButtonTipPanel, PlayerGroupAll(), false);
    }

    return true;
}

void libVCMI_gf_PM_RefreshTip () {
    // Variable Declarations
    int lv_index;
    text lv_tipName;
    text lv_tipDescription;
    string lv_tipIcon;

    // Automatic Variable Declarations
    const int auto8FF5A5CB_ae = 1;
    const int auto8FF5A5CB_ai = -1;

    // Variable Initialization

    // Implementation
    HelpPanelDestroyAllTips();
    lv_index = libVCMI_gv_pM_MissionTipCount;
    for ( ; ( (auto8FF5A5CB_ai >= 0 && lv_index <= auto8FF5A5CB_ae) || (auto8FF5A5CB_ai < 0 && lv_index >= auto8FF5A5CB_ae) ) ; lv_index += auto8FF5A5CB_ai ) {
        if ((UserDataGetText("CampaignTips", libVCMI_gv_pM_MissionTip[lv_index], "Name", 1) != null)) {
            lv_tipName = UserDataGetText("CampaignTips", libVCMI_gv_pM_MissionTip[lv_index], "Name", 1);
        }
        else {
            lv_tipName = StringExternal("Param/Value/lib_VCMI_758AA553");
        }
        if ((UserDataGetText("CampaignTips", libVCMI_gv_pM_MissionTip[lv_index], "Description", 1) != null)) {
            lv_tipDescription = UserDataGetText("CampaignTips", libVCMI_gv_pM_MissionTip[lv_index], "Description", 1);
        }
        else {
            lv_tipDescription = StringExternal("Param/Value/lib_VCMI_4837CBD0");
        }
        lv_tipIcon = UserDataGetImagePath("CampaignTips", libVCMI_gv_pM_MissionTip[lv_index], "Icon", 1);
        libVCUI_gf_PU_AddTip(lv_tipName, libNtve_ge_TipType_NormalTip, lv_tipDescription, lv_tipName, lv_tipIcon);
    }
}

void libVCMI_gf_SendTransmissionCampaign (unit lp_unit, string lp_conversationLine, int lp_durationType, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption) {
    // Variable Declarations
    soundlink lv_sound;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_sound = SoundLink("EditorDefaultSound", -1);

    // Implementation
    lv_sound = SoundLink(ConversationDataGetSound(lp_conversationLine, true), c_soundIndexAny);
    if ((lv_sound == null)) {
        return ;
    }

    libVCMI_gf_PM_SendTransmissionCampaignInternal(false, lp_unit, null, lv_sound, null, null, lp_durationType, lp_duration, lp_waitUntilDone, lp_keepPortraitVisible, lp_cueSoundOption, CatalogFieldValueGet(c_gameCatalogSound, ConversationDataGetSound(lp_conversationLine, true), "AssetArray[" + IntToString(0) + "].PortraitActor", c_playerAny));
}

void libVCMI_gf_TurnTransmissionOptionsOnOffCampaign (int lp_option, bool lp_onOff) {
    // Automatic Variable Declarations
    int auto664A67F5_val;

    // Implementation
    auto664A67F5_val = lp_option;
    if (auto664A67F5_val == libVCMI_ge_MissionTransmissionOptions_ChatBubble) {
        libVCMI_gv_pM_SendTransmissionCampaignChatBubbleOn = lp_onOff;
    }
    else {
    }
}

void libVCMI_gf_PM_SendTransmissionCampaignInternal (bool lp_isPlaceHolder, unit lp_unit, string lp_model, soundlink lp_sound, text lp_speaker, text lp_message, int lp_durationType, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption, string lp_portraitActor) {
    // Variable Declarations
    int lv_portrait;
    transmissionsource lv_source;
    int lv_localIndex;
    unit lv_oldSpeaker;
    trigger lv_oldTrigger;
    actor lv_talkBubble;
    actor lv_talkRing;
    int lv_ping;
    bool lv_flashOption;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_portrait = c_invalidPortraitId;
    lv_source = TransmissionSource();
    lv_ping = c_invalidPingId;
    lv_flashOption = true;

    // Implementation
    if ((lp_sound == null)) {
        return ;
    }

    libVCMI_gv_pM_SendTransmissionCampaignIndex += 1;
    lv_localIndex = libVCMI_gv_pM_SendTransmissionCampaignIndex;
    lv_oldSpeaker = libVCMI_gv_pM_SendTransmissionCampaignSpeaker;
    libVCMI_gv_pM_SendTransmissionCampaignSpeaker = lp_unit;
    lv_oldTrigger = libVCMI_gv_pM_SendTransmissionCampaignTrigger;
    libVCMI_gv_pM_SendTransmissionCampaignTrigger = TriggerGetCurrent();
    if ((lp_keepPortraitVisible != libVCMI_ge_MissionTransmissionPortraitOptioins_DontShowPortrait) && ((lp_model != null) || ((lp_model == null) && (SoundPortraitModel(lp_sound) != null)) || ((lp_isPlaceHolder == true) && (lp_unit != null)))) {
        if ((libNtve_gf_PlayerInCinematicMode(1) == false) && (libNtve_gf_PlayerInStoryMode(1) == false)) {
            lv_portrait = libNtve_gf_CinematicPortrait(libNtve_ge_CinematicPortraitPosition_CenterLeft);
        }
        else {
            lv_portrait = libNtve_gf_CinematicPortrait(libNtve_ge_CinematicPortraitPosition_BottomLeft);
        }
    }
    else {
        lv_portrait = c_invalidPortraitId;
    }
    if (((lp_cueSoundOption == libVCMI_ge_MissionTransmissionCueSoundOptions_PlayCueSound) || ((lp_cueSoundOption == libVCMI_ge_MissionTransmissionCueSoundOptions_DefaultCueSoundBehavior) && (libNtve_gf_PlayerInCinematicMode(1) == false) && (lv_portrait != c_invalidPortraitId) && (PortraitVisible(libVCMI_gv_pM_SendTransmissionCampaignPortrait, 1) == false)))) {
        libLbty_gf_PlayTransmissionCueSound(PlayerGroupAll());
    }

    libVCMI_gv_pM_SendTransmissionCampaignPortrait = lv_portrait;
    if ((libVCMI_gv_pM_SendTransmissionCampaignPortrait != c_invalidPortraitId)) {
        PortraitSetVisible(libVCMI_gv_pM_SendTransmissionCampaignPortrait, PlayerGroupAll(), true, false);
    }

    libVCMI_gv_pM_SendTransmissionCampaignPlayingTick = 3;
    if ((lp_unit == null)) {
        if ((lv_portrait == c_invalidPortraitId)) {
            lv_source = TransmissionSource();
        }
        else {
            if ((lp_model == null)) {
                lv_source = TransmissionSourceFromModel(null);
            }
            else {
                lv_source = TransmissionSourceFromModel(lp_model);
            }
        }
    }
    else {
        if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {
            lv_flashOption = false;
        }
        else {
            lv_flashOption = true;
        }
        if ((lp_isPlaceHolder == false)) {
            lv_source = TransmissionSourceFromUnit(lp_unit, lv_flashOption, false, "Talk");
        }
        else {
            if ((lp_model == null)) {
                if ((UnitGetOwner(lp_unit) == 1)) {
                    lv_source = TransmissionSourceFromUnit(lp_unit, lv_flashOption, true, "Talk");
                }

            }
            else {
                lv_source = TransmissionSourceFromModel(lp_model);
            }
        }
    }
    if ((lp_unit != null) && (lp_unit != lv_oldSpeaker) && (UnitIsAlive(lp_unit) == true)) {
        if ((libVCMI_gv_pM_SendTransmissionCampaignChatBubbleOn == true)) {
            if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {
                if (((UnitGetType(lp_unit) == "Marine") || (UnitGetType(lp_unit) == "WarPig") || (UnitGetType(lp_unit) == "MengskMarine") || (UnitGetType(lp_unit) == "Medic") || (UnitGetType(lp_unit) == "Firebat") || (UnitGetType(lp_unit) == "Marauder"))) {
                    ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelOneShot TalkIconBubble {Overhead 0} 0.000000,0.000000,0.500000");
                }
                else {
                    ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelOneShot TalkIconBubble {Overhead 0} 0.000000,0.000000,0.600000");
                }
            }
            else {
                ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelOneShot TalkIconBubble {Overhead 0} 0.000000,0.000000,0.600000");
            }
            lv_talkBubble = ActorFrom("::LastCreatedActual");
            ActorSend(libNtve_gf_MainActorofUnit(lp_unit), "AttachModelOffset ModelOneShot TalkIconRing {Origin 0} 0.000000,0.000000,0.100000");
            lv_talkRing = ActorFrom("::LastCreatedActual");
        }

        if ((libNtve_gf_UnitIsVisibleToPlayer(lp_unit, 1) == true)) {
            libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), "TalkIcon", PointWithOffset(UnitGetPosition(lp_unit), 0.5, 3.5), ColorWithAlpha(100.00, 100.00, 100.00, 0.00), 2.0, 270.0);
            lv_ping = PingLastCreated();
            PingSetScale(PingLastCreated(), 0.3);
        }

    }

    TransmissionSendAdvanced(PlayerGroupAll(), lv_source, lv_portrait, lp_portraitActor, "Talk", lp_sound, lp_speaker, lp_message, lp_duration, lp_durationType, lp_waitUntilDone);
    if ((lp_waitUntilDone == false)) {
        libVCMI_gf_PM_SendTransmissionCampaignCleanUp(TransmissionLastSent(), lp_keepPortraitVisible, lv_portrait, lv_talkBubble, lv_talkRing, lv_ping, lv_localIndex);
    }
    else {
        libVCMI_gf_PM_SendTransmissionCampaignCleanUp(c_invalidTransmissionId, lp_keepPortraitVisible, lv_portrait, lv_talkBubble, lv_talkRing, lv_ping, lv_localIndex);
    }
}

trigger auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_Trigger = null;
int auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_transmission;
int auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_keepPortraitVisible;
int auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_portrait;
actor auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_talkIcon;
actor auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_talkRing;
int auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_ping;
int auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_localIndex;

void libVCMI_gf_PM_SendTransmissionCampaignCleanUp (int lp_transmission, int lp_keepPortraitVisible, int lp_portrait, actor lp_talkIcon, actor lp_talkRing, int lp_ping, int lp_localIndex) {
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_transmission = lp_transmission;
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_keepPortraitVisible = lp_keepPortraitVisible;
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_portrait = lp_portrait;
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_talkIcon = lp_talkIcon;
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_talkRing = lp_talkRing;
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_ping = lp_ping;
    auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_localIndex = lp_localIndex;

    if (auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_Trigger == null) {
        auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_Trigger = TriggerCreate("auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_Trigger, false, false);
}

bool auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_TriggerFunc (bool testConds, bool runActions) {
    int lp_transmission = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_transmission;
    int lp_keepPortraitVisible = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_keepPortraitVisible;
    int lp_portrait = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_portrait;
    actor lp_talkIcon = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_talkIcon;
    actor lp_talkRing = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_talkRing;
    int lp_ping = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_ping;
    int lp_localIndex = auto_libVCMI_gf_PM_SendTransmissionCampaignCleanUp_lp_localIndex;

    // Automatic Variable Declarations
    // Implementation
    if ((lp_transmission != c_invalidTransmissionId)) {
        TransmissionWait(lp_transmission, 0.0);
    }

    Wait(0.75, c_timeReal);
    if ((lp_localIndex != libVCMI_gv_pM_SendTransmissionCampaignIndex)) {
        if ((libVCMI_gv_pM_SendTransmissionCampaignPortrait != lp_portrait) && (lp_portrait != c_invalidPortraitId) && (lp_keepPortraitVisible == libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter)) {
            PortraitSetModel(lp_portrait, "StaticPortrait", false);
            PortraitSetVisible(lp_portrait, PlayerGroupAll(), false, false);
        }

        if ((lp_talkIcon != null)) {
            libNtve_gf_KillModel(lp_talkIcon);
        }

        if ((lp_talkRing != null)) {
            libNtve_gf_KillModel(lp_talkRing);
        }

        return true;
    }

    libVCMI_gv_pM_SendTransmissionCampaignIndex = 0;
    libVCMI_gv_pM_SendTransmissionCampaignSpeaker = null;
    TriggerExecute(libVCMI_gt_PM_SendTransmissionCampaignTick, true, false);
    if ((lp_keepPortraitVisible == libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter) && (lp_portrait != c_invalidPortraitId)) {
        PortraitSetModel(lp_portrait, "StaticPortrait", false);
        PortraitSetVisible(lp_portrait, PlayerGroupAll(), false, false);
    }

    if ((lp_talkIcon != null)) {
        libNtve_gf_KillModel(lp_talkIcon);
    }

    if ((lp_talkRing != null)) {
        libNtve_gf_KillModel(lp_talkRing);
    }

    if ((lp_ping != c_invalidPingId)) {
        PingDestroy(lp_ping);
    }

    return true;
}

void libVCMI_gf_HideCampaignTransmissionPortrait () {
    // Automatic Variable Declarations
    // Implementation
    libNtve_gf_HideAllCinematicPortraits(PlayerGroupAll());
}

fixed libVCMI_gf_ConvesationLineDuration (string lp_conversationLine) {
    // Variable Declarations
    soundlink lv_sound;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_sound = SoundLink("EditorDefaultSound", -1);

    // Implementation
    lv_sound = SoundLink(ConversationDataGetSound(lp_conversationLine, true), c_soundIndexAny);
    return SoundLengthSync(lv_sound);
}

void libVCMI_gf_SendTransmissionCampaignPlaceHolder (unit lp_unit, string lp_model, text lp_speaker, text lp_message, fixed lp_duration, bool lp_waitUntilDone, int lp_keepPortraitVisible, int lp_cueSoundOption) {
    // Variable Declarations
    unit lv_actualUnit;
    string lv_actualModel;
    soundlink lv_sound;
    string lv_portraitActor;

    // Automatic Variable Declarations
    string auto41A5E975_val;
    string autoFFDC7B44_val;

    // Variable Initialization
    lv_sound = SoundLink("EditorDefaultSound", -1);
    lv_portraitActor = "";

    // Implementation
    lv_actualUnit = lp_unit;
    lv_actualModel = lp_model;
    if ((lp_unit != null) && (UnitIsAlive(lp_unit) == false) && (lp_unit == libVCMI_gv_pM_HeroRevivingUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)])) {
        if ((libVCMI_gv_pM_HeroReviverUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)] != null) && (UnitIsAlive(libVCMI_gv_pM_HeroReviverUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)]) == true)) {
            lv_actualUnit = libVCMI_gv_pM_HeroReviverUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)];
        }
        else {
            lv_actualUnit = null;
            lv_actualModel = "KerriganReviveCocoon";
        }
    }

    auto41A5E975_val = UnitGetType(lv_actualUnit);
    if (auto41A5E975_val == "KerriganVoidUlnar02") {
        lv_portraitActor = "KerriganPrimalPortrait";
    }
    else if (auto41A5E975_val == "KerriganVoidBurrowed") {
        lv_portraitActor = "KerriganPrimalPortrait";
    }
    else if (auto41A5E975_val == "KerriganEpilogue02") {
        lv_portraitActor = "KerriganPrimalPortrait";
    }
    else if (auto41A5E975_val == "KerriganEpilogue03") {
        lv_portraitActor = "KerriganEpilogue03Portrait";
    }
    else {
    }
    autoFFDC7B44_val = lp_model;
    if (autoFFDC7B44_val == "VorazunEx2Portrait") {
        lv_portraitActor = "VorazunEx2Portrait";
    }
    else if (autoFFDC7B44_val == "ArtanisEx2Portrait") {
        lv_portraitActor = "ArtanisEx2Portrait";
    }
    else if (autoFFDC7B44_val == "AlarakEx2Portrait") {
        lv_portraitActor = "AlarakEx2Portrait";
    }
    else if (autoFFDC7B44_val == "KaraxEx2Portrait") {
        lv_portraitActor = "KaraxEx2Portrait";
    }
    else if (autoFFDC7B44_val == "RohanaEx2Portrait") {
        lv_portraitActor = "RohanaEx2Portrait";
    }
    else if (autoFFDC7B44_val == "FenixEx2Portrait") {
        lv_portraitActor = "FenixEx2Portrait";
    }
    else {
    }
    lv_sound = SoundLink("PlaceholderSoundFile", c_soundIndexAny);
    libVCMI_gf_PM_SendTransmissionCampaignInternal(true, lv_actualUnit, lv_actualModel, lv_sound, lp_speaker, (StringExternal("Param/Value/lib_VCMI_19071613") + lp_message), c_transmissionDurationSet, lp_duration, lp_waitUntilDone, lp_keepPortraitVisible, lp_cueSoundOption, lv_portraitActor);
}

void libVCMI_gf_PM_DropPod_Zerg_Wait (point lp_location, unitgroup lp_units, int lp_player) {
    // Variable Declarations
    unit lv_chosenUnit;
    unit lv_dropPod;
    point lv_dropPodLocation;
    fixed lv_angle;
    point lv_dropLocation;
    unit lv_creep;

    // Automatic Variable Declarations
    unitgroup auto29D5EF81_g;
    int auto29D5EF81_u;
    unitgroup auto5CF90E73_g;
    int auto5CF90E73_u;
    unitgroup auto7E0D3E3B_g;
    int auto7E0D3E3B_u;

    // Variable Initialization

    // Implementation
    auto29D5EF81_g = lp_units;
    auto29D5EF81_u = UnitGroupCount(auto29D5EF81_g, c_unitCountAll);
    for (;; auto29D5EF81_u -= 1) {
        lv_chosenUnit = UnitGroupUnitFromEnd(auto29D5EF81_g, auto29D5EF81_u);
        if (lv_chosenUnit == null) { break; }
        libNtve_gf_ShowHideUnit(lv_chosenUnit, false);
        libNtve_gf_PauseUnit(lv_chosenUnit, true);
    }
    libNtve_gf_CreateUnitsAtPoint2(1, "ZergDropPod", c_unitCreateIgnorePlacement, lp_player, lp_location);
    lv_dropPod = UnitLastCreated();
    Wait(2.5, c_timeGame);
    if ((UnitIsAlive(lv_dropPod) == false)) {
        auto5CF90E73_g = lp_units;
        auto5CF90E73_u = UnitGroupCount(auto5CF90E73_g, c_unitCountAll);
        for (;; auto5CF90E73_u -= 1) {
            lv_chosenUnit = UnitGroupUnitFromEnd(auto5CF90E73_g, auto5CF90E73_u);
            if (lv_chosenUnit == null) { break; }
            UnitRemove(lv_chosenUnit);
        }
        return ;
    }

    lv_dropPodLocation = UnitGetPosition(lv_dropPod);
    libNtve_gf_CreateUnitsAtPoint2(1, "ZergDropPodCreep", c_unitCreateIgnorePlacement, lp_player, lv_dropPodLocation);
    lv_creep = UnitLastCreated();
    Wait(1.0, c_timeGame);
    lv_angle = 0.0;
    auto7E0D3E3B_g = lp_units;
    auto7E0D3E3B_u = UnitGroupCount(auto7E0D3E3B_g, c_unitCountAll);
    for (;; auto7E0D3E3B_u -= 1) {
        lv_chosenUnit = UnitGroupUnitFromEnd(auto7E0D3E3B_g, auto7E0D3E3B_u);
        if (lv_chosenUnit == null) { break; }
        lv_dropLocation = PointWithOffsetPolar(lv_dropPodLocation, RandomFixed(0.5, 2.0), lv_angle);
        UnitSetPosition(lv_chosenUnit, lv_dropLocation, false);
        libNtve_gf_ShowHideUnit(lv_chosenUnit, true);
        libNtve_gf_PauseUnit(lv_chosenUnit, false);
        Wait(0.125, c_timeGame);
        lv_angle = (lv_angle + 77.0);
    }
    libNtve_gf_PauseUnit(lv_creep, true);
    Wait(3.0, c_timeGame);
    UnitRemove(lv_creep);
    Wait(4.0, c_timeGame);
    UnitKill(lv_dropPod);
}

void libVCMI_gf_PM_DropPod_Terran_Wait (point lp_location, unitgroup lp_units, int lp_player) {
    // Variable Declarations
    unit lv_indexUnit;
    unit lv_dropPod;
    point lv_dropPodLocation;
    fixed lv_angle;
    fixed lv_angleStart;
    point lv_dropLocation;
    fixed lv_distance;
    int lv_subIndex;
    point lv_moveLocation;
    int lv_countPerLine;

    // Automatic Variable Declarations
    unitgroup autoB56D9329_g;
    int autoB56D9329_u;
    unitgroup auto2AE26FD9_g;
    int auto2AE26FD9_u;
    unit auto2AE26FD9_var;
    unitgroup auto7DD6500F_g;
    int auto7DD6500F_u;

    // Variable Initialization

    // Implementation
    autoB56D9329_g = lp_units;
    autoB56D9329_u = UnitGroupCount(autoB56D9329_g, c_unitCountAll);
    for (;; autoB56D9329_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(autoB56D9329_g, autoB56D9329_u);
        if (lv_indexUnit == null) { break; }
        libNtve_gf_ShowHideUnit(lv_indexUnit, false);
        libNtve_gf_PauseUnit(lv_indexUnit, true);
    }
    libNtve_gf_CreateUnitsAtPoint2(1, "TerranDropPod", c_unitCreateIgnorePlacement, lp_player, lp_location);
    lv_dropPod = UnitLastCreated();
    libNtve_gf_PlayAnimation(libNtve_gf_MainActorofUnit(lv_dropPod), c_animNameDefault, "Birth", c_animFlagNonLooping, c_animTimeDefault);
    Wait(3.5, c_timeGame);
    if ((UnitIsAlive(lv_dropPod) == false)) {
        auto2AE26FD9_g = lp_units;
        auto2AE26FD9_u = UnitGroupCount(auto2AE26FD9_g, c_unitCountAll);
        for (;; auto2AE26FD9_u -= 1) {
            auto2AE26FD9_var = UnitGroupUnitFromEnd(auto2AE26FD9_g, auto2AE26FD9_u);
            if (auto2AE26FD9_var == null) { break; }
            UnitRemove(auto2AE26FD9_var);
        }
        return ;
    }

    lv_countPerLine = 4;
    if ((UnitGroupCount(lp_units, c_unitCountAlive) > 16)) {
        lv_countPerLine = ((UnitGroupCount(lp_units, c_unitCountAlive) + 3) / 4);
    }

    if ((UnitIsValid(lv_dropPod) == true)) {
        lv_dropPodLocation = UnitGetPosition(lv_dropPod);
        lv_distance = (0.8 + ((IntToFixed((UnitGroupCount(lp_units, c_unitCountAlive) + 3)) / IntToFixed(lv_countPerLine)) * 0.8));
        lv_subIndex = 1;
        lv_angleStart = 225.0;
        lv_angle = lv_angleStart;
        auto7DD6500F_g = lp_units;
        auto7DD6500F_u = UnitGroupCount(auto7DD6500F_g, c_unitCountAll);
        for (;; auto7DD6500F_u -= 1) {
            lv_indexUnit = UnitGroupUnitFromEnd(auto7DD6500F_g, auto7DD6500F_u);
            if (lv_indexUnit == null) { break; }
            lv_dropLocation = PointWithOffsetPolar(lv_dropPodLocation, 1.0, lv_angle);
            SoundPlayAtPoint(SoundLink("Medivac_Unload", 0), PlayerGroupAll(), lv_dropLocation, 0.0, 100.0, 0.0);
            Wait(0.125, c_timeGame);
            UnitSetPosition(lv_indexUnit, lv_dropLocation, false);
            libNtve_gf_ShowHideUnit(lv_indexUnit, true);
            libNtve_gf_PauseUnit(lv_indexUnit, false);
            lv_moveLocation = PointWithOffsetPolar(lv_dropPodLocation, lv_distance, lv_angle);
            UnitIssueOrder(lv_indexUnit, OrderTargetingPoint(AbilityCommand("move", 0), lv_moveLocation), c_orderQueueReplace);
            if ((lv_subIndex == lv_countPerLine)) {
                lv_subIndex = 1;
                lv_angle = lv_angleStart;
                lv_distance -= 0.8;
            }
            else {
                lv_subIndex += 1;
                lv_angle += 10.0;
            }
        }
        UnitKill(lv_dropPod);
    }

}

void libVCMI_gf_CreateDropPod (int lp_race, point lp_location, unitgroup lp_units, bool lp_waitDontWait, int lp_player) {
    // Variable Declarations
    point lv_dropLocation;
    unitgroup lv_dropUnits;

    // Automatic Variable Declarations
    int auto30FEF00B_val;

    // Variable Initialization
    lv_dropUnits = UnitGroupEmpty();

    // Implementation
    lv_dropLocation = Point(PointGetX(lp_location), PointGetY(lp_location));
    PointSetFacing(lv_dropLocation, PointGetFacing(lp_location));
    lv_dropUnits = UnitGroupCopy(lp_units);
    DataTableSetUnitGroup(false, libVCMI_gf_PM_DropPod_LastDroppedUnitsDataTableName(), lv_dropUnits);
    auto30FEF00B_val = lp_race;
    if (auto30FEF00B_val == libVCMI_ge_DropPodRace_Terran) {
        if ((lp_waitDontWait == true)) {
            libVCMI_gf_PM_DropPod_Terran_Wait(lv_dropLocation, lv_dropUnits, lp_player);
        }
        else {
            libVCMI_gv_pM_DropPod_TP_Location = lv_dropLocation;
            libVCMI_gv_pM_DropPod_TP_Units = lv_dropUnits;
            libVCMI_gv_pM_DropPod_TP_Player = lp_player;
            TriggerExecute(libVCMI_gt_PM_DropPod_Terran_DontWait, true, false);
        }
    }
    else if (auto30FEF00B_val == libVCMI_ge_DropPodRace_Zerg) {
        if ((lp_waitDontWait == true)) {
            libVCMI_gf_PM_DropPod_Zerg_Wait(lv_dropLocation, lv_dropUnits, lp_player);
        }
        else {
            libVCMI_gv_pM_DropPod_TP_Location = lv_dropLocation;
            libVCMI_gv_pM_DropPod_TP_Units = lv_dropUnits;
            libVCMI_gv_pM_DropPod_TP_Player = lp_player;
            TriggerExecute(libVCMI_gt_PM_DropPod_Zerg_DontWait, true, false);
        }
    }
    else {
    }
}

void libVCMI_gf_CreateDropPodForZergBuilding (string lp_buildingType, point lp_landingPoint, int lp_player, bool lp_waitDontWait) {
    // Automatic Variable Declarations
    bool autoFAF09496_val;

    // Implementation
    libNtve_gf_CreateUnitsWithDefaultFacing(1, lp_buildingType, c_unitCreateIgnorePlacement, lp_player, lp_landingPoint);
    libVCMI_gv_pM_DropPod_TP_ZergBuilding = UnitLastCreated();
    libNtve_gf_ShowHideUnit(UnitLastCreated(), false);
    DataTableSetUnitGroup(false, libVCMI_gf_PM_DropPod_LastDroppedUnitsDataTableName(), UnitLastCreatedGroup());
    autoFAF09496_val = lp_waitDontWait;
    if (autoFAF09496_val == true) {
        libVCMI_gf_PM_DropPodCreateZergBuilding_Wait(lp_buildingType, lp_landingPoint, lp_player);
    }
    else if (autoFAF09496_val == false) {
        libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait(lp_buildingType, lp_landingPoint, lp_player);
    }
    else {
    }
}

trigger auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_Trigger = null;
string auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_buildingType;
point auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_landingPoint;
int auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_player;

void libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait (string lp_buildingType, point lp_landingPoint, int lp_player) {
    auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_buildingType = lp_buildingType;
    auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_landingPoint = lp_landingPoint;
    auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_player = lp_player;

    if (auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_Trigger == null) {
        auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_Trigger = TriggerCreate("auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_Trigger, false, false);
}

bool auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_TriggerFunc (bool testConds, bool runActions) {
    string lp_buildingType = auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_buildingType;
    point lp_landingPoint = auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_landingPoint;
    int lp_player = auto_libVCMI_gf_PM_DropPodCreateZergBuilding_DontWait_lp_player;

    // Automatic Variable Declarations
    // Implementation
    libVCMI_gf_PM_DropPodCreateZergBuilding_Wait(lp_buildingType, lp_landingPoint, lp_player);
    return true;
}

void libVCMI_gf_PM_DropPodCreateZergBuilding_Wait (string lp_buildingType, point lp_landingPoint, int lp_player) {
    // Variable Declarations
    unit lv_dropPod;

    // Automatic Variable Declarations
    unitgroup auto5CF01D86_g;
    int auto5CF01D86_u;
    unit auto5CF01D86_var;

    // Variable Initialization

    // Implementation
    UnitCreate(1, "ZergDropPod", c_unitCreateIgnorePlacement, lp_player, lp_landingPoint, 270.0);
    lv_dropPod = UnitLastCreated();
    Wait(2.0, c_timeReal);
    if ((UnitIsAlive(lv_dropPod) == false)) {
        UnitRemove(libVCMI_gv_pM_DropPod_TP_ZergBuilding);
        return ;
    }

    UnitTypeMoveBlockersFromPoint(lp_buildingType, lp_player, lp_landingPoint, 0.0);
    Wait(1.25, c_timeReal);
    if ((UnitIsAlive(lv_dropPod) == false)) {
        UnitRemove(libVCMI_gv_pM_DropPod_TP_ZergBuilding);
        return ;
    }

    auto5CF01D86_g = UnitGroup(null, c_playerAny, RegionCircle(lp_landingPoint, 2.5), UnitFilter(0, 0, (1 << c_targetFilterStructure) | (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto5CF01D86_u = UnitGroupCount(auto5CF01D86_g, c_unitCountAll);
    for (;; auto5CF01D86_u -= 1) {
        auto5CF01D86_var = UnitGroupUnitFromEnd(auto5CF01D86_g, auto5CF01D86_u);
        if (auto5CF01D86_var == null) { break; }
        if ((UnitGetType(auto5CF01D86_var) != "ZergDropPodLarge") && (auto5CF01D86_var != UnitLastCreated())) {
            if (((UnitGetOwner(auto5CF01D86_var) == lp_player) || (libNtve_gf_PlayerIsEnemy(lp_player, UnitGetOwner(auto5CF01D86_var), libNtve_ge_PlayerRelation_Ally) == true))) {
                UnitSetPosition(auto5CF01D86_var, UnitTypePlacementFromPoint(lp_buildingType, UnitGetOwner(auto5CF01D86_var), lp_landingPoint, 4.0), true);
            }
            else {
                UnitKill(auto5CF01D86_var);
            }
        }

    }
    libNtve_gf_ShowHideUnit(libVCMI_gv_pM_DropPod_TP_ZergBuilding, true);
    Wait(5.0, c_timeReal);
    UnitKill(lv_dropPod);
}

string libVCMI_gf_PM_DropPod_LastDroppedUnitsDataTableName () {
    // Automatic Variable Declarations
    // Implementation
    return "LASTDROPPODEDUNITS";
}

unitgroup libVCMI_gf_LastDroppedUnits () {
    // Automatic Variable Declarations
    // Implementation
    return DataTableGetUnitGroup(false, libVCMI_gf_PM_DropPod_LastDroppedUnitsDataTableName());
}

unit libVCMI_gf_PM_NexusBestWorkerRallyMineral (unit lp_nexus) {
    // Variable Declarations
    unit lv_indexUnitOuter;
    unit lv_indexUnitInner;
    unit lv_indexResource;
    fixed lv_bestDistance;
    fixed lv_curDistance;
    region lv_searchArea;
    unitgroup lv_mineralGroup;
    unit lv_bestMineral;

    // Automatic Variable Declarations
    unitgroup autoEC5BF080_g;
    int autoEC5BF080_u;
    unitgroup auto956D9CE4_g;
    int auto956D9CE4_u;
    unitgroup auto226EA3E5_g;
    int auto226EA3E5_u;

    // Variable Initialization
    lv_mineralGroup = UnitGroupEmpty();

    // Implementation
    lv_searchArea = RegionCircle(UnitGetPosition(lp_nexus), 10.0);
    lv_mineralGroup = UnitGroup(null, c_playerAny, lv_searchArea, UnitFilter((1 << c_targetFilterHarvestableResource), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);
    autoEC5BF080_g = lv_mineralGroup;
    autoEC5BF080_u = UnitGroupCount(autoEC5BF080_g, c_unitCountAll);
    for (;; autoEC5BF080_u -= 1) {
        lv_indexResource = UnitGroupUnitFromEnd(autoEC5BF080_g, autoEC5BF080_u);
        if (lv_indexResource == null) { break; }
        if ((CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(lv_indexResource), "ResourceType", c_playerAny) != "Minerals")) {
            UnitGroupRemove(lv_mineralGroup, lv_indexResource);
        }

    }
    auto956D9CE4_g = lv_mineralGroup;
    auto956D9CE4_u = UnitGroupCount(auto956D9CE4_g, c_unitCountAll);
    for (;; auto956D9CE4_u -= 1) {
        lv_indexUnitOuter = UnitGroupUnitFromEnd(auto956D9CE4_g, auto956D9CE4_u);
        if (lv_indexUnitOuter == null) { break; }
        lv_curDistance = 0.0;
        auto226EA3E5_g = lv_mineralGroup;
        auto226EA3E5_u = UnitGroupCount(auto226EA3E5_g, c_unitCountAll);
        for (;; auto226EA3E5_u -= 1) {
            lv_indexUnitInner = UnitGroupUnitFromEnd(auto226EA3E5_g, auto226EA3E5_u);
            if (lv_indexUnitInner == null) { break; }
            if ((lv_indexUnitOuter != lv_indexUnitInner)) {
                lv_curDistance += DistanceBetweenPoints(UnitGetPosition(lv_indexUnitOuter), UnitGetPosition(lv_indexUnitInner));
            }

        }
        if (((lv_bestDistance == 0.0) || (lv_curDistance < lv_bestDistance))) {
            lv_bestDistance = lv_curDistance;
            lv_bestMineral = lv_indexUnitOuter;
        }

    }
    return lv_bestMineral;
}

void libVCMI_gf_SetWorkerRallyPointforNexus (unit lp_nexus) {
    // Variable Declarations
    unit lv_bestMineral;
    point lv_rallyPoint;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_bestMineral = libVCMI_gf_PM_NexusBestWorkerRallyMineral(lp_nexus);
    if ((lv_bestMineral != null)) {
        if ((PlayerDifficulty(UnitGetOwner(lp_nexus)) == 1)) {
            UnitIssueOrder(lp_nexus, OrderTargetingUnit(AbilityCommand("RallyNexus", 1), lv_bestMineral), c_orderQueueReplace);
        }
        else {
            UnitIssueOrder(lp_nexus, OrderTargetingUnit(AbilityCommand("RallyNexus", 0), lv_bestMineral), c_orderQueueReplace);
        }
    }

}

void libVCMI_gf_SetWorkerRallyPointsPlayersNexuses (int lp_player) {
    // Variable Declarations
    unit lv_indexNexus;
    unitgroup lv_nexusGroup;

    // Automatic Variable Declarations
    unitgroup auto01E01BBA_g;
    int auto01E01BBA_u;

    // Variable Initialization
    lv_nexusGroup = UnitGroupEmpty();

    // Implementation
    lv_nexusGroup = UnitGroup("Nexus", lp_player, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto01E01BBA_g = lv_nexusGroup;
    auto01E01BBA_u = UnitGroupCount(auto01E01BBA_g, c_unitCountAll);
    for (;; auto01E01BBA_u -= 1) {
        lv_indexNexus = UnitGroupUnitFromEnd(auto01E01BBA_g, auto01E01BBA_u);
        if (lv_indexNexus == null) { break; }
        libVCMI_gf_SetWorkerRallyPointforNexus(lv_indexNexus);
    }
}

void libVCMI_gf_PM_UseUnitNameAsUnitTip (unit lp_unit) {
    // Automatic Variable Declarations
    // Implementation
    if (((UnitGetType(lp_unit) == "ZergDropPod") || (UnitGetType(lp_unit) == "ZergDropPodLarge") || (UnitGetType(lp_unit) == "TerranDropPod") || (UnitGetType(lp_unit) == "ZergDropPodCreep"))) {
        return ;
    }

    UnitSetState(lp_unit, c_unitStateTooltipable, true);
}

void libVCMI_gf_PM_ApplyCampaignTeachingToUnit (unit lp_teachUnit) {
    // Automatic Variable Declarations
    // Implementation
    while (!((libVoiC_gv_pC_CampaignTechApplied == true))) {
        Wait(0.1, c_timeGame);
    }
    if ((libVoiC_gv_pCX_UpgradesTaught == false) && (libVCMI_gv_pM_UpgradeUnit == null) && (UnitGetType(lp_teachUnit) == "CyberneticsCore") && (TechTreeUpgradeIsAllowed(1, "ProtossAirWeaponsLevel1") == true) && (libVoiC_gf_PC_CampaignInEpilogue() == false)) {
        if ((libNtve_gf_UnitIsUnderConstruction(lp_teachUnit) == true)) {
            while (true) {
                if ((UnitIsAlive(lp_teachUnit) == false)) {
                    return ;
                }

                if ((libNtve_gf_UnitIsUnderConstruction(lp_teachUnit) == false)) {
                    break;
                }

                Wait(0.5, c_timeAI);
            }
        }

        libVCMI_gf_AttachReticleEffectAndTextTagOnUnit(libVCMI_ge_CampaginReticleType_ProtossBonusObjective, libVCMI_ge_CampaginReticleSize_Medium, StringExternal("Param/Value/lib_VCMI_3BCD0A9C"), lp_teachUnit, "Ref_Center");
        libVCMI_gv_pM_UpgradeUnit = lp_teachUnit;
        libVCMI_gv_pM_UpgradeReticle = libNtve_gf_ActorLastCreated();
        libVCMI_gv_pM_UpgradeTextTag = TextTagLastCreated();
        if ((libVCMI_gf_PlayerInCinematicModeCampaign() == true)) {
            libVCMI_gf_PM_ShowHideCampaignTeaching(false);
        }

        TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsSelected, true);
        TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsDestroyed, true);
        TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsRemoved, true);
    }

}

void libVCMI_gf_PM_ShowHideCampaignTeaching (bool lp_showHide) {
    // Automatic Variable Declarations
    // Implementation
    if ((libVCMI_gv_pM_UpgradeUnit != null)) {
        if ((lp_showHide == true)) {
            TextTagShow(libVCMI_gv_pM_UpgradeTextTag, PlayerGroupAll(), true);
            ActorSend(libVCMI_gv_pM_UpgradeReticle, "SetVisibility 1");
        }
        else {
            TextTagShow(libVCMI_gv_pM_UpgradeTextTag, PlayerGroupAll(), false);
            ActorSend(libVCMI_gv_pM_UpgradeReticle, "SetVisibility");
        }
    }

}

void libVCMI_gf_PM_CampaignCyberneticsSearch () {
    // Variable Declarations
    unit lv_indexUnit;

    // Automatic Variable Declarations
    unitgroup auto15A10DF8_g;
    int auto15A10DF8_u;

    // Variable Initialization

    // Implementation
    auto15A10DF8_g = UnitGroup("CyberneticsCore", 1, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 1);
    auto15A10DF8_u = UnitGroupCount(auto15A10DF8_g, c_unitCountAll);
    for (;; auto15A10DF8_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(auto15A10DF8_g, auto15A10DF8_u);
        if (lv_indexUnit == null) { break; }
        libVCMI_gf_PM_ApplyCampaignTeachingToUnit(lv_indexUnit);
    }
}

void libVCMI_gf_SetUnitInfoTextCampaign (unit lp_unit, text lp_info, text lp_tip, text lp_subTip) {
    // Variable Declarations
    text lv_tipStyled;
    text lv_subTipStyled;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_tip != null)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_3704A828", "A", lp_tip);
        lv_tipStyled = TextExpressionAssemble("Param/Expression/lib_VCMI_3704A828");
    }
    else {
        lv_tipStyled = lp_tip;
    }
    if ((lp_subTip != null)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_50F2381C", "A", lp_subTip);
        lv_subTipStyled = TextExpressionAssemble("Param/Expression/lib_VCMI_50F2381C");
    }
    else {
        lv_subTipStyled = lp_subTip;
    }
    UnitSetInfoText(lp_unit, lp_info, lv_tipStyled, lv_subTipStyled);
    UnitSetState(lp_unit, c_unitStateTooltipable, true);
}

void libVCMI_gf_SetUnitInfoTextCampaignDetailed (unit lp_unit, text lp_info, text lp_tip, text lp_subTip) {
    // Variable Declarations
    text lv_tipStyled;
    text lv_subTipStyled;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    if ((lp_tip != null)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_1C88F6E4", "A", lp_tip);
        lv_tipStyled = TextExpressionAssemble("Param/Expression/lib_VCMI_1C88F6E4");
    }
    else {
        lv_tipStyled = lp_tip;
    }
    if ((lp_subTip != null)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_08BB63F6", "A", lp_subTip);
        lv_subTipStyled = TextExpressionAssemble("Param/Expression/lib_VCMI_08BB63F6");
    }
    else {
        lv_subTipStyled = lp_subTip;
    }
    UnitSetInfoText(lp_unit, lp_info, lv_tipStyled, lv_subTipStyled);
    UnitSetState(lp_unit, c_unitStateTooltipable, true);
}

void libVCMI_gf_SpawnLarvaForHatchery (unit lp_hatchery, int lp_larvaCount) {
    // Automatic Variable Declarations
    // Implementation
    UnitBehaviorSpawn(lp_hatchery, "SpawnLarva", lp_larvaCount);
}

void libVCMI_gf_BurrowUnburrowZergUnitGroup (unitgroup lp_unitGroup, int lp_burrowUnburrow) {
    // Automatic Variable Declarations
    unitgroup autoE783BF51_g;
    int autoE783BF51_u;
    unit autoE783BF51_var;
    string autoDFCA4B63_val;
    unitgroup autoB0B5B76D_g;
    int autoB0B5B76D_u;
    unit autoB0B5B76D_var;
    string auto210433CB_val;

    // Implementation
    if ((lp_burrowUnburrow == libVCMI_ge_BurrowUnburrowOption_Burrow)) {
        autoB0B5B76D_g = lp_unitGroup;
        autoB0B5B76D_u = UnitGroupCount(autoB0B5B76D_g, c_unitCountAll);
        for (;; autoB0B5B76D_u -= 1) {
            autoB0B5B76D_var = UnitGroupUnitFromEnd(autoB0B5B76D_g, autoB0B5B76D_u);
            if (autoB0B5B76D_var == null) { break; }
            auto210433CB_val = UnitGetType(autoB0B5B76D_var);
            if (auto210433CB_val == "SwarmHost") {
                UnitIssueOrder(autoB0B5B76D_var, Order(AbilityCommand("MorphToSwarmHostBurrowed", 0)), c_orderQueueReplace);
            }
            else if (auto210433CB_val == "SwarmHostSplitA") {
                UnitIssueOrder(autoB0B5B76D_var, Order(AbilityCommand("MorphToSwarmHostSplitABurrowed", 0)), c_orderQueueReplace);
            }
            else if (auto210433CB_val == "SwarmHostSplitB") {
                UnitIssueOrder(autoB0B5B76D_var, Order(AbilityCommand("MorphToSwarmHostSplitBBurrowed", 0)), c_orderQueueReplace);
            }
            else if (auto210433CB_val == "Lurker") {
                UnitIssueOrder(autoB0B5B76D_var, Order(AbilityCommand("BurrowLurkerDown", 0)), c_orderQueueReplace);
            }
            else if (auto210433CB_val == "Impaler") {
                UnitIssueOrder(autoB0B5B76D_var, Order(AbilityCommand("BurrowImpaler", 0)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(autoB0B5B76D_var, Order(AbilityCommand("BurrowZerglingDown", 0)), c_orderQueueReplace);
            }
        }
    }
    else {
        autoE783BF51_g = lp_unitGroup;
        autoE783BF51_u = UnitGroupCount(autoE783BF51_g, c_unitCountAll);
        for (;; autoE783BF51_u -= 1) {
            autoE783BF51_var = UnitGroupUnitFromEnd(autoE783BF51_g, autoE783BF51_u);
            if (autoE783BF51_var == null) { break; }
            autoDFCA4B63_val = UnitGetType(autoE783BF51_var);
            if (autoDFCA4B63_val == "SwarmHostBurrowed") {
                UnitIssueOrder(autoE783BF51_var, Order(AbilityCommand("MorphToSwarmHost", 0)), c_orderQueueReplace);
            }
            else if (autoDFCA4B63_val == "SwarmHostSplitABurrowed") {
                UnitIssueOrder(autoE783BF51_var, Order(AbilityCommand("MorphToSwarmHostSplitA", 0)), c_orderQueueReplace);
            }
            else if (autoDFCA4B63_val == "SwarmHostSplitBBurrowed") {
                UnitIssueOrder(autoE783BF51_var, Order(AbilityCommand("MorphToSwarmHostSplitB", 0)), c_orderQueueReplace);
            }
            else if (autoDFCA4B63_val == "LurkerBurrowed") {
                UnitIssueOrder(autoE783BF51_var, Order(AbilityCommand("BurrowLurkerUp", 0)), c_orderQueueReplace);
            }
            else if (autoDFCA4B63_val == "ImpalerBurrowed") {
                UnitIssueOrder(autoE783BF51_var, Order(AbilityCommand("UnburrowImpaler", 0)), c_orderQueueReplace);
            }
            else {
                UnitIssueOrder(autoE783BF51_var, Order(AbilityCommand("BurrowZerglingUp", 0)), c_orderQueueReplace);
            }
        }
    }
}

void libVCMI_gf_SendActorMessageToDoodadsInRegion (string lp_message, string lp_doodadType, region lp_target) {
    // Variable Declarations
    actor lv_actorRegion;
    string lv_terms;

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

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

    ActorRegionSend(lv_actorRegion, c_actorIntersectAgainstRadiusContact, lp_message, "Doodad", lv_terms);
    ActorScopeKill(ActorScopeFromActor(lv_actorRegion));
}

void libVCMI_gf_DestroyCacheAndGivePlayerResources (unit lp_cacheUnit, int lp_resourceType, int lp_resourceAmount, string lp_resourceIcon, text lp_resourceText, int lp_player) {
    // Automatic Variable Declarations
    // Implementation
    libVCMI_gf_GivePlayerResources(UnitGetPosition(lp_cacheUnit), lp_resourceType, lp_resourceAmount, lp_resourceIcon, lp_resourceText, lp_player);
    UnitKill(lp_cacheUnit);
}

void libVCMI_gf_GivePlayerResources (point lp_location, int lp_resourceType, int lp_resourceAmount, string lp_resourceIcon, text lp_resourceText, int lp_player) {
    // Variable Declarations
    text lv_text;

    // Automatic Variable Declarations
    int auto8ED25223_val;

    // Variable Initialization

    // Implementation
    auto8ED25223_val = lp_resourceType;
    if (auto8ED25223_val == libVCMI_ge_CacheResourceType_Mineral) {
        PlayerModifyPropertyInt(lp_player, c_playerPropMinerals, c_playerPropOperAdd, lp_resourceAmount);
    }
    else if (auto8ED25223_val == libVCMI_ge_CacheResourceType_Vespene) {
        PlayerModifyPropertyInt(lp_player, c_playerPropVespene, c_playerPropOperAdd, lp_resourceAmount);
    }
    else if (auto8ED25223_val == libVCMI_ge_CacheResourceType_Solarite) {
        TriggerDebugOutput(1, StringExternal("Param/Value/lib_VCMI_E1D6FEA3"), true);
        return ;
    }
    else {
    }
    libVCMI_gf_DisplayRewardFloatingText(lp_location, lp_resourceType, lp_resourceAmount, lp_resourceIcon, lp_resourceText, lp_player);
}

void libVCMI_gf_DisplayRewardFloatingText (point lp_location, int lp_resourceType, int lp_resourceAmount, string lp_resourceIcon, text lp_resourceText, int lp_player) {
    // Variable Declarations
    text lv_text;

    // Automatic Variable Declarations
    int auto2128925C_val;
    int autoC4309F63_val;

    // Variable Initialization

    // Implementation
    auto2128925C_val = lp_resourceType;
    if (auto2128925C_val == libVCMI_ge_CacheResourceType_Mineral) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_FA2F2D3B", "A", StringToText(("Kicker_Minerals")));
        TextExpressionSetToken("Param/Expression/lib_VCMI_FA2F2D3B", "B", IntToText(lp_resourceAmount));
        lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_FA2F2D3B");
    }
    else if (auto2128925C_val == libVCMI_ge_CacheResourceType_Vespene) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_3D845762", "A", StringToText(("Kicker_Gas")));
        TextExpressionSetToken("Param/Expression/lib_VCMI_3D845762", "B", IntToText(lp_resourceAmount));
        lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_3D845762");
    }
    else {
        TextExpressionSetToken("Param/Expression/lib_VCMI_261E2441", "A", StringToText(("Kicker_Protoss")));
        TextExpressionSetToken("Param/Expression/lib_VCMI_261E2441", "B", IntToText(lp_resourceAmount));
        lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_261E2441");
    }
    if ((lp_resourceIcon != null)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_F881F2B7", "A", lv_text);
        TextExpressionSetToken("Param/Expression/lib_VCMI_F881F2B7", "B", StringToText(lp_resourceIcon));
        lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_F881F2B7");
    }
    else {
        autoC4309F63_val = lp_resourceType;
        if (autoC4309F63_val == libVCMI_ge_CacheResourceType_Mineral) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_C99B9DE4", "A", lv_text);
            lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_C99B9DE4");
        }
        else if (autoC4309F63_val == libVCMI_ge_CacheResourceType_Vespene) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_6CB2A27A", "A", lv_text);
            lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_6CB2A27A");
        }
        else {
        }
    }
    if (((lp_resourceText != null) == true)) {
        TextExpressionSetToken("Param/Expression/lib_VCMI_A8624C75", "A", lv_text);
        TextExpressionSetToken("Param/Expression/lib_VCMI_A8624C75", "B", lp_resourceText);
        lv_text = TextExpressionAssemble("Param/Expression/lib_VCMI_A8624C75");
    }

    SoundPlay(SoundLink("UI_ResourcePickup", 0), PlayerGroupSingle(lp_player), 100.0, 0.0);
    TextTagCreate(lv_text, 24, lp_location, 2.0, true, false, PlayerGroupAll());
    TextTagSetVelocity(TextTagLastCreated(), 0.7, 90.0);
    TextTagSetBackgroundImage(TextTagLastCreated(), "Assets\\Textures\\blank.dds", true);
    if ((lp_resourceType == libVCMI_ge_CacheResourceType_CustomResource)) {
    }

    TextTagShowBackground(TextTagLastCreated(), true);
    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.0);
}

void libVCMI_gf_DisplayMissionObjectiveRewardFloatingText (point lp_location, string lp_objective) {
    // Variable Declarations
    text lv_floatingText;
    int lv_objectiveAmount;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_objectiveAmount = libVoiC_gf_MissionObjectiveRewards(lp_objective, "ShipEnergy");
    lv_objectiveAmount += libVoiC_gf_MissionObjectiveRewards2(lp_objective, "ShipEnergy");
    TextExpressionSetToken("Param/Expression/lib_VCMI_6743CDD8", "A", StringToText(("Kicker_Protoss")));
    TextExpressionSetToken("Param/Expression/lib_VCMI_6743CDD8", "B", IntToText(lv_objectiveAmount));
    lv_floatingText = TextExpressionAssemble("Param/Expression/lib_VCMI_6743CDD8");
    SoundPlay(SoundLink("UI_ResourcePickup", 0), PlayerGroupSingle(1), 100.0, 0.0);
    TextTagCreate(lv_floatingText, 24, lp_location, (PointGetHeight(lp_location)+2.0), true, false, PlayerGroupAll());
    TextTagSetVelocity(TextTagLastCreated(), 0.7, 90.0);
    TextTagSetBackgroundImage(TextTagLastCreated(), "Assets\\Textures\\blank.dds", true);
    TextTagShowBackground(TextTagLastCreated(), true);
    TextTagSetTime(TextTagLastCreated(), c_textTagTimeDuration, 3.0);
}

bool libVCMI_gf_PM_StartingWorkerAutoHarvestEnabled () {
    // Automatic Variable Declarations
    // Implementation
    return PlayerGetState(1, c_playerStateStartingRallyEnabled);
}

void libVCMI_gf_StartingWorkersAutoHarvest (region lp_regionMineralWorker, region lp_regionGasWorker) {
    // Variable Declarations
    unit lv_indexWorker;
    unitgroup lv_resourceGroup;
    unit lv_indexResource;
    unitgroup lv_unitGroupHarvestMinerals;
    unitgroup lv_unitGroupHarvestGas;

    // Automatic Variable Declarations
    unitgroup autoA8D4E691_g;
    int autoA8D4E691_u;
    unitgroup auto7A456887_g;
    int auto7A456887_u;
    unitgroup auto219ADB5D_g;
    int auto219ADB5D_u;
    unitgroup auto85EF0FC7_g;
    int auto85EF0FC7_u;

    // Variable Initialization
    lv_resourceGroup = UnitGroupEmpty();
    lv_unitGroupHarvestMinerals = UnitGroupEmpty();
    lv_unitGroupHarvestGas = UnitGroupEmpty();

    // Implementation
    if ((libVCMI_gf_PM_StartingWorkerAutoHarvestEnabled() == false)) {
        return ;
    }

    if ((lp_regionMineralWorker != null)) {
        lv_unitGroupHarvestMinerals = UnitGroup(null, 1, lp_regionMineralWorker, UnitFilter((1 << c_targetFilterWorker), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    }

    if ((TechTreeUpgradeCount(1, "K5AutoExtractor", c_techCountQueuedOrBetter) > 0)) {
        UnitGroupAddUnitGroup(lv_unitGroupHarvestMinerals, UnitGroup(null, 1, lp_regionGasWorker, UnitFilter((1 << c_targetFilterWorker), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0));
    }
    else {
        if ((lp_regionGasWorker != null)) {
            lv_unitGroupHarvestGas = UnitGroup(null, 1, lp_regionGasWorker, UnitFilter((1 << c_targetFilterWorker), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
        }

    }
    if ((lv_unitGroupHarvestMinerals != UnitGroupEmpty())) {
        autoA8D4E691_g = lv_unitGroupHarvestMinerals;
        autoA8D4E691_u = UnitGroupCount(autoA8D4E691_g, c_unitCountAll);
        for (;; autoA8D4E691_u -= 1) {
            lv_indexWorker = UnitGroupUnitFromEnd(autoA8D4E691_g, autoA8D4E691_u);
            if (lv_indexWorker == null) { break; }
            UnitGroupClear(lv_resourceGroup);
            auto7A456887_g = UnitGroup(null, 0, RegionCircle(UnitGetPosition(lv_indexWorker), 6.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
            auto7A456887_u = UnitGroupCount(auto7A456887_g, c_unitCountAll);
            for (;; auto7A456887_u -= 1) {
                lv_indexResource = UnitGroupUnitFromEnd(auto7A456887_g, auto7A456887_u);
                if (lv_indexResource == null) { break; }
                if ((CatalogFieldValueGet(c_gameCatalogUnit, UnitGetType(lv_indexResource), "ResourceType", c_playerAny) == "Minerals")) {
                    UnitGroupAdd(lv_resourceGroup, lv_indexResource);
                }

            }
            if ((UnitGroupCount(lv_resourceGroup, c_unitCountAlive) > 0)) {
                UnitIssueOrder(lv_indexWorker, OrderTargetingUnit(null, UnitGroupClosestToPoint(lv_resourceGroup, UnitGetPosition(lv_indexWorker))), c_orderQueueReplace);
            }

        }
    }

    if ((lv_unitGroupHarvestGas != UnitGroupEmpty())) {
        auto219ADB5D_g = lv_unitGroupHarvestGas;
        auto219ADB5D_u = UnitGroupCount(auto219ADB5D_g, c_unitCountAll);
        for (;; auto219ADB5D_u -= 1) {
            lv_indexWorker = UnitGroupUnitFromEnd(auto219ADB5D_g, auto219ADB5D_u);
            if (lv_indexWorker == null) { break; }
            UnitGroupClear(lv_resourceGroup);
            auto85EF0FC7_g = UnitGroup(null, 1, RegionCircle(UnitGetPosition(lv_indexWorker), 6.0), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
            auto85EF0FC7_u = UnitGroupCount(auto85EF0FC7_g, c_unitCountAll);
            for (;; auto85EF0FC7_u -= 1) {
                lv_indexResource = UnitGroupUnitFromEnd(auto85EF0FC7_g, auto85EF0FC7_u);
                if (lv_indexResource == null) { break; }
                if (((UnitGetType(lv_indexResource) == "Refinery") || (UnitGetType(lv_indexResource) == "Extractor") || (UnitGetType(lv_indexResource) == "Assimilator"))) {
                    UnitGroupAdd(lv_resourceGroup, lv_indexResource);
                }

            }
            if ((UnitGroupCount(lv_resourceGroup, c_unitCountAlive) > 0)) {
                UnitIssueOrder(lv_indexWorker, OrderTargetingUnit(null, UnitGroupClosestToPoint(lv_resourceGroup, UnitGetPosition(lv_indexWorker))), c_orderQueueReplace);
            }

        }
    }

}

text libVCMI_gf_UnitAbilityHotkeyText (string lp_unitType, string lp_abilityButton) {
    // Variable Declarations
    int lv_row;
    int lv_column;
    int lv_buttonIndex;

    // Automatic Variable Declarations
    int autoCD238B57_ae;
    const int autoCD238B57_ai = 1;

    // Variable Initialization

    // Implementation
    autoCD238B57_ae = CatalogFieldValueCount(c_gameCatalogUnit, lp_unitType, "CardLayouts[" + IntToString(0) + "].LayoutButtons", c_playerAny);
    lv_buttonIndex = 0;
    for ( ; ( (autoCD238B57_ai >= 0 && lv_buttonIndex <= autoCD238B57_ae) || (autoCD238B57_ai < 0 && lv_buttonIndex >= autoCD238B57_ae) ) ; lv_buttonIndex += autoCD238B57_ai ) {
        if ((CatalogFieldValueGet(c_gameCatalogUnit, lp_unitType, "CardLayouts[" + IntToString(0) + "].LayoutButtons[" + IntToString(lv_buttonIndex) + "].Face", c_playerAny) == (lp_abilityButton))) {
            lv_row = StringToInt(CatalogFieldValueGet(c_gameCatalogUnit, lp_unitType, "CardLayouts[" + IntToString(0) + "].LayoutButtons[" + IntToString(lv_buttonIndex) + "].Row", c_playerAny));
            lv_column = StringToInt(CatalogFieldValueGet(c_gameCatalogUnit, lp_unitType, "CardLayouts[" + IntToString(0) + "].LayoutButtons[" + IntToString(lv_buttonIndex) + "].Column", c_playerAny));
            TextExpressionSetToken("Param/Expression/lib_VCMI_7545F4E8", "UNIT", StringToText((lp_unitType)));
            TextExpressionSetToken("Param/Expression/lib_VCMI_7545F4E8", "BTN", StringToText((lp_abilityButton)));
            TextExpressionSetToken("Param/Expression/lib_VCMI_7545F4E8", "ROW", IntToText(lv_row));
            TextExpressionSetToken("Param/Expression/lib_VCMI_7545F4E8", "COL", IntToText(lv_column));
            return TextExpressionAssemble("Param/Expression/lib_VCMI_7545F4E8");
        }

    }
    if ((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true)) {
        return StringExternal("Param/Value/lib_VCMI_A53A2400");
    }

    return StringToText("");
}

void libVCMI_gf_DisplayCampaignMessage (playergroup lp_toPlayerGroup, int lp_messageType, text lp_message, int lp_formatOrNot) {
    // Automatic Variable Declarations
    int auto859F408A_val;

    // Implementation
    if ((lp_formatOrNot == libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage)) {
        auto859F408A_val = lp_messageType;
        if (auto859F408A_val == libVCMI_ge_CampaignMessageType_Hint) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_64DF7A24", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_64DF7A24"));
            SoundPlay(SoundLink("UI_TerranHint", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_SimpleHint) {
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, lp_message);
            SoundPlay(SoundLink("UI_TerranHint", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_Secret) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_C1624255", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_C1624255"));
            SoundPlay(SoundLink("TUISecret", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_NewUnitAcquired) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_A49EDD0B", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_A49EDD0B"));
            SoundPlay(SoundLink("UI_TerranNewUnitAcquired", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_NewUnitAvailable) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_BA0BF873", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_BA0BF873"));
            SoundPlay(SoundLink("UI_TerranNewUnitAvailable", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_NewTechAvailable) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_39320B7C", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_39320B7C"));
            SoundPlay(SoundLink("UI_TerranNewTechAvailable", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_NewUnitAvailable2) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_D6A0DA61", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_D6A0DA61"));
            SoundPlay(SoundLink("UI_TerranNewTechAvailable", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_Warning) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_19CBF466", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_19CBF466"));
            SoundPlay(SoundLink("UI_ZergWarning", 0), lp_toPlayerGroup, 100.0, 0.0);
        }
        else if (auto859F408A_val == libVCMI_ge_CampaignMessageType_MissionFailed) {
            TextExpressionSetToken("Param/Expression/lib_VCMI_A4179B16", "A", lp_message);
            UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, TextExpressionAssemble("Param/Expression/lib_VCMI_A4179B16"));
            SoundPlay(SoundLink("UI_TerranMissionFailed", 1), lp_toPlayerGroup, 100.0, 0.0);
        }
        else {
        }
    }
    else {
        UIDisplayMessage(lp_toPlayerGroup, c_messageAreaSubtitle, lp_message);
    }
}

void libVCMI_gf_CreateObjectivePing (bool lp_objectiveType, point lp_position, text lp_tooltip) {
    // Variable Declarations
    color lv_color;
    fixed lv_scale;
    string lv_model;

    // Automatic Variable Declarations
    bool autoF871CA08_val;

    // Variable Initialization
    lv_color = Color(0,0,0);

    // Implementation
    autoF871CA08_val = lp_objectiveType;
    if (autoF871CA08_val == true) {
        lv_color = Color(0.00, 100.00, 0.00);
        lv_scale = 1.0;
        lv_model = "PingObjective";
    }
    else if (autoF871CA08_val == false) {
        lv_color = Color(100.00, 100.00, 0.00);
        lv_scale = 0.6;
        lv_model = "PingBonus";
    }
    else {
    }
    libNtve_gf_CreatePingFacingAngle(PlayerGroupAll(), lv_model, lp_position, lv_color, 0.0, 270.0);
    PingSetScale(PingLastCreated(), lv_scale);
    PingSetTooltip(PingLastCreated(), lp_tooltip);
    TriggerExecute(libVCMI_gt_VoidPingSound, true, false);
}

trigger auto_libVCMI_gf_PingMinimapCampaign_Trigger = null;
playergroup auto_libVCMI_gf_PingMinimapCampaign_lp_players;
point auto_libVCMI_gf_PingMinimapCampaign_lp_pos;
fixed auto_libVCMI_gf_PingMinimapCampaign_lp_dur;
color auto_libVCMI_gf_PingMinimapCampaign_lp_color;

void libVCMI_gf_PingMinimapCampaign (playergroup lp_players, point lp_pos, fixed lp_dur, color lp_color) {
    auto_libVCMI_gf_PingMinimapCampaign_lp_players = lp_players;
    auto_libVCMI_gf_PingMinimapCampaign_lp_pos = lp_pos;
    auto_libVCMI_gf_PingMinimapCampaign_lp_dur = lp_dur;
    auto_libVCMI_gf_PingMinimapCampaign_lp_color = lp_color;

    if (auto_libVCMI_gf_PingMinimapCampaign_Trigger == null) {
        auto_libVCMI_gf_PingMinimapCampaign_Trigger = TriggerCreate("auto_libVCMI_gf_PingMinimapCampaign_TriggerFunc");
    }

    TriggerExecute(auto_libVCMI_gf_PingMinimapCampaign_Trigger, false, false);
}

bool auto_libVCMI_gf_PingMinimapCampaign_TriggerFunc (bool testConds, bool runActions) {
    playergroup lp_players = auto_libVCMI_gf_PingMinimapCampaign_lp_players;
    point lp_pos = auto_libVCMI_gf_PingMinimapCampaign_lp_pos;
    fixed lp_dur = auto_libVCMI_gf_PingMinimapCampaign_lp_dur;
    color lp_color = auto_libVCMI_gf_PingMinimapCampaign_lp_color;

    // Automatic Variable Declarations
    playergroup autoC51461E9_g;
    int autoC51461E9_var;
    string autoC47256CC_val;

    // Implementation
    autoC51461E9_g = lp_players;
    autoC51461E9_var = -1;
    while (true) {
        autoC51461E9_var = PlayerGroupNextPlayer(autoC51461E9_g, autoC51461E9_var);
        if (autoC51461E9_var < 0) { break; }
        autoC47256CC_val = PlayerRace(autoC51461E9_var);
        if (autoC47256CC_val == "Prot") {
            SoundPlay(SoundLink("UI_TerranPing", -1), PlayerGroupSingle(autoC51461E9_var), 100.0, 0.0);
        }
        else if (autoC47256CC_val == "Terr") {
            SoundPlay(SoundLink("UI_TerranPing", -1), PlayerGroupSingle(autoC51461E9_var), 100.0, 0.0);
        }
        else if (autoC47256CC_val == "Zerg") {
            SoundPlay(SoundLink("UI_ZergWarningPing", -1), PlayerGroupSingle(autoC51461E9_var), 100.0, 0.0);
        }
        else {
        }
    }
    libNtve_gf_CreatePingFacingAngle(lp_players, "PingAlert", lp_pos, lp_color, lp_dur, 270.0);
    Wait(lp_dur, c_timeGame);
    PingDestroy(PingLastCreated());
    return true;
}

string libVCMI_gf_PM_ReticleModelOfStyle (int lp_type, int lp_size) {
    // Variable Declarations
    string lv_model;

    // Automatic Variable Declarations
    int autoCDEF28CD_val;
    int autoBEC58E6C_val;
    int auto993B9915_val;
    int auto1B271D82_val;

    // Variable Initialization

    // Implementation
    autoCDEF28CD_val = lp_size;
    if (autoCDEF28CD_val == libVCMI_ge_CampaginReticleSize_Large) {
        autoBEC58E6C_val = lp_type;
        if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_ProtossBonusObjective) {
            lv_model = "BriefingUnitSelectProtossLarge";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_ProtossEnemy) {
            lv_model = "BriefingUnitSelectProtossLarge";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_ProtossMainObjective) {
            lv_model = "BriefingUnitSelectProtossLarge";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_TerranBonusObjective) {
            lv_model = "BriefingUnitSelectLarge";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_TerranEnemy) {
            lv_model = "BriefingUnitSelectLargeRed";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_TerranMainObjective) {
            lv_model = "BriefingUnitSelectLarge";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_ZergBonusObjective) {
            lv_model = "BriefingUnitSelectLargeZergGreen";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_ZergEnemy) {
            lv_model = "BriefingUnitSelectLargeZergRed";
        }
        else if (autoBEC58E6C_val == libVCMI_ge_CampaginReticleType_ZergMainObjective) {
            lv_model = "BriefingUnitSelectLargeZergGreen";
        }
        else {
        }
    }
    else if (autoCDEF28CD_val == libVCMI_ge_CampaginReticleSize_Medium) {
        auto993B9915_val = lp_type;
        if (auto993B9915_val == libVCMI_ge_CampaginReticleType_ProtossBonusObjective) {
            lv_model = "BriefingUnitSelectProtoss";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_ProtossEnemy) {
            lv_model = "BriefingUnitSelectProtoss";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_ProtossMainObjective) {
            lv_model = "BriefingUnitSelectProtoss";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_TerranBonusObjective) {
            lv_model = "BriefingUnitSelect";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_TerranEnemy) {
            lv_model = "BriefingUnitSelectRed";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_TerranMainObjective) {
            lv_model = "BriefingUnitSelect";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_ZergBonusObjective) {
            lv_model = "BriefingUnitSelectZergGreen";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_ZergEnemy) {
            lv_model = "BriefingUnitSelectZergRed";
        }
        else if (auto993B9915_val == libVCMI_ge_CampaginReticleType_ZergMainObjective) {
            lv_model = "BriefingUnitSelectZergGreen";
        }
        else {
        }
    }
    else if (autoCDEF28CD_val == libVCMI_ge_CampaginReticleSize_Small) {
        auto1B271D82_val = lp_type;
        if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_ProtossBonusObjective) {
            lv_model = "BriefingUnitSelectProtossSmall";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_ProtossEnemy) {
            lv_model = "BriefingUnitSelectProtossSmall";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_ProtossMainObjective) {
            lv_model = "BriefingUnitSelectProtossSmall";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_TerranBonusObjective) {
            lv_model = "BriefingUnitSelectSmall";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_TerranEnemy) {
            lv_model = "BriefingUnitSelectRedSmall";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_TerranMainObjective) {
            lv_model = "BriefingUnitSelectSmall";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_ZergBonusObjective) {
            lv_model = "BriefingUnitSelectZergSmallGreen";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_ZergEnemy) {
            lv_model = "BriefingUnitSelectZergSmallRed";
        }
        else if (auto1B271D82_val == libVCMI_ge_CampaginReticleType_ZergMainObjective) {
            lv_model = "BriefingUnitSelectZergSmallGreen";
        }
        else {
        }
    }
    else {
    }
    return lv_model;
}

string libVCMI_gf_PM_ReticleTextFontOfStyle (int lp_type) {
    // Variable Declarations
    string lv_fontStyle;

    // Automatic Variable Declarations
    int auto4C012C4E_val;

    // Variable Initialization
    lv_fontStyle = "SwarmReticleZergMainObjective";

    // Implementation
    auto4C012C4E_val = lp_type;
    if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_ProtossBonusObjective) {
        lv_fontStyle = "VoidReticleProtossBonusObjective";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_ProtossEnemy) {
        lv_fontStyle = "VoidReticleProtossEnemy";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_ProtossMainObjective) {
        lv_fontStyle = "VoidReticleProtossMainObjective";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_TerranBonusObjective) {
        lv_fontStyle = "VoidReticleTerranBonusObjective";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_TerranEnemy) {
        lv_fontStyle = "VoidReticleTerranEnemy";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_TerranMainObjective) {
        lv_fontStyle = "VoidReticleTerranMainObjective";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_ZergBonusObjective) {
        lv_fontStyle = "VoidReticleZergBonusObjective";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_ZergEnemy) {
        lv_fontStyle = "VoidReticleZergEnemy";
    }
    else if (auto4C012C4E_val == libVCMI_ge_CampaginReticleType_ZergMainObjective) {
        lv_fontStyle = "VoidReticleZergMainObjective";
    }
    else {
    }
    return lv_fontStyle;
}

void libVCMI_gf_PM_ReticleApplyTint (actor lp_reticle, int lp_type) {
    // Automatic Variable Declarations
    int autoF8A9C4D8_val;

    // Implementation
    autoF8A9C4D8_val = lp_type;
    if (autoF8A9C4D8_val == libVCMI_ge_CampaginReticleType_ProtossMainObjective) {
        ActorSend(libNtve_gf_ActorLastCreated(), "SetTeamColor NULL 0,255,0");
    }
    else if (autoF8A9C4D8_val == libVCMI_ge_CampaginReticleType_ProtossEnemy) {
        ActorSend(libNtve_gf_ActorLastCreated(), "SetTeamColor NULL 255,0,0");
    }
    else if (autoF8A9C4D8_val == libVCMI_ge_CampaginReticleType_ProtossBonusObjective) {
        ActorSend(libNtve_gf_ActorLastCreated(), "SetTeamColor NULL 0,255,0");
    }
    else {
    }
}

void libVCMI_gf_CreateReticleEffectAndTextTagAtPoint (int lp_type, int lp_size, text lp_text, point lp_location) {
    // Variable Declarations
    string lv_model;
    string lv_fontStyle;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_fontStyle = "SwarmReticleZergMainObjective";

    // Implementation
    lv_model = libVCMI_gf_PM_ReticleModelOfStyle(lp_type, lp_size);
    if ((lv_model == null)) {
        return ;
    }

    libNtve_gf_CreateModelAtPoint(lv_model, lp_location);
    libVCMI_gf_PM_ReticleApplyTint(libNtve_gf_ActorLastCreated(), lp_type);
    if (((lp_text != null) == false)) {
        return ;
    }

    lv_fontStyle = libVCMI_gf_PM_ReticleTextFontOfStyle(lp_type);
    TextExpressionSetToken("Param/Expression/lib_VCMI_C1B831B2", "Style", StringToText((lv_fontStyle)));
    TextExpressionSetToken("Param/Expression/lib_VCMI_C1B831B2", "A", lp_text);
    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_VCMI_C1B831B2"), 24, lp_location, 1.0, true, true, PlayerGroupSingle(1));
    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);
}

void libVCMI_gf_AttachReticleEffectAndTextTagOnUnit (int lp_type, int lp_size, text lp_text, unit lp_target, string lp_attachPoint) {
    // Variable Declarations
    string lv_model;
    string lv_fontStyle;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_fontStyle = "SwarmReticleZergMainObjective";

    // Implementation
    lv_model = libVCMI_gf_PM_ReticleModelOfStyle(lp_type, lp_size);
    if ((lv_model == null)) {
        return ;
    }

    libNtve_gf_AttachModelToUnitInheritVisibility(lp_target, lv_model, lp_attachPoint);
    libVCMI_gf_PM_ReticleApplyTint(libNtve_gf_ActorLastCreated(), lp_type);
    if (((lp_text != null) == false)) {
        return ;
    }

    lv_fontStyle = libVCMI_gf_PM_ReticleTextFontOfStyle(lp_type);
    TextExpressionSetToken("Param/Expression/lib_VCMI_242FDFAD", "Style", StringToText((lv_fontStyle)));
    TextExpressionSetToken("Param/Expression/lib_VCMI_242FDFAD", "A", lp_text);
    TextTagCreate(TextExpressionAssemble("Param/Expression/lib_VCMI_242FDFAD"), 24, UnitGetPosition(lp_target), 0.0, true, true, PlayerGroupSingle(1));
    TextTagAttachToUnit(TextTagLastCreated(), lp_target, 1.0);
    TextTagSetFogVisibility(TextTagLastCreated(), c_visTypeFog);
}

text libVCMI_gf_FormatTextWithReplacement (text lp_text, text lp_replacement1, text lp_replacement2, text lp_replacement3, text lp_replacement4) {
    // Variable Declarations
    text lv_result;

    // Automatic Variable Declarations
    // Variable Initialization

    // Implementation
    lv_result = lp_text;
    if (((lp_replacement1 != null) == true)) {
        lv_result = TextReplaceWord(lv_result, StringExternal("Param/Value/lib_VCMI_19D2DFD7"), lp_replacement1, c_stringReplaceAll, c_stringCase);
    }

    if (((lp_replacement2 != null) == true)) {
        lv_result = TextReplaceWord(lv_result, StringExternal("Param/Value/lib_VCMI_533A7AAD"), lp_replacement2, c_stringReplaceAll, c_stringCase);
    }

    if (((lp_replacement3 != null) == true)) {
        lv_result = TextReplaceWord(lv_result, StringExternal("Param/Value/lib_VCMI_F9C95DE7"), lp_replacement3, c_stringReplaceAll, c_stringCase);
    }

    if (((lp_replacement4 != null) == true)) {
        lv_result = TextReplaceWord(lv_result, StringExternal("Param/Value/lib_VCMI_533821B5"), lp_replacement4, c_stringReplaceAll, c_stringCase);
    }

    return lv_result;
}

void libVCMI_gf_PM_VoidCampaignMissionInit () {
    // Variable Declarations
    unit lv_indexUnit;

    // Automatic Variable Declarations
    unitgroup auto0BA529BF_g;
    int auto0BA529BF_u;

    // Variable Initialization

    // Implementation
    if ((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindStory) == true)) {
        return ;
    }

    libVCMI_gv_pM_CombatTimer = TimerCreate();
    TimerStart(libVCMI_gv_pM_CombatTimer, 86400.0, false, c_timeGame);
    UnitEventSetNullVariableInvalid(true);
    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer");
    libVCUI_gv_pU_MissionUIContainer = DialogControlLastCreated();
    UISetFrameVisible(PlayerGroupAll(), c_syncFrameTypeTipAlertPanel, false);
    libVCMI_gf_DifficultySetting(PlayerDifficulty(1));
    if ((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindMission) == true)) {
        UISetGameMenuItemVisible(PlayerGroupSingle(1), c_gameMenuDialogRestartDifficultyPulldown, true);
    }

    auto0BA529BF_g = UnitGroup(null, c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);
    auto0BA529BF_u = UnitGroupCount(auto0BA529BF_g, c_unitCountAll);
    for (;; auto0BA529BF_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(auto0BA529BF_g, auto0BA529BF_u);
        if (lv_indexUnit == null) { break; }
        if ((UnitGetType(lv_indexUnit) != "Nexus")) {
            UnitSetPropertyFixed(lv_indexUnit, c_unitPropEnergyPercent, 100.0);
        }

    }
    if ((libLotv_gf_DifficultyValueInt2(1, 1, 0, 0) == 1) && (libVoiC_gf_MissionStatusCheck("PKorhal02", libVoiC_ge_MissionStatus_Completed) == false) && (libVoiC_gf_MissionStatusCheck("PShakuras02", libVoiC_ge_MissionStatus_Completed) == false)) {
        TriggerExecute(libVCMI_gt_PM_PlayerNeedPylon, true, false);
    }

    TriggerExecute(libVCMI_gt_PM_CampaignUnit, true, false);
    TriggerExecute(libVCMI_gt_PM_BaseUnderAttackInit, true, false);
    TriggerExecute(libVCUI_gt_PS_ArmyButtonMissionInit, true, false);
    if ((libLotv_gf_DifficultyValueInt2(1, 0, 0, 0) == 1)) {
        TechTreeUpgradeAddLevel(1, "VoidCasualRallyBlock", 1);
    }

    DialogControlHookupStandard(c_triggerControlTypePanel, "UIContainer/ConsoleUIContainer/ObjectivePanel");
    libVCUI_gv_pU_ObjectivePanel = DialogControlLastCreated();
    libVCUI_gf_PU_UpdateObjectivePanel();
}

void libVCMI_gf_DifficultySetting (int lp_difficulty) {
    // Automatic Variable Declarations
    int autoBB45CCF8_val;

    // Implementation
    autoBB45CCF8_val = lp_difficulty;
    if (autoBB45CCF8_val == 1) {
        GameSetSpeedValueMinimum(c_gameSpeedSlow);
        PlayerModifyPropertyInt(1, c_playerPropDamageTakenPercent, c_playerPropOperSetTo, FixedToInt((UserDataGetFixed("DifficultySettings", "Casual", "DamageTakenRatio", 1) * 100.0)));
        TechTreeUpgradeAddLevel(1, "SuperiorWarpGates", 1);
    }
    else if (autoBB45CCF8_val == 2) {
        GameSetSpeedValueMinimum(c_gameSpeedNormal);
        PlayerModifyPropertyInt(1, c_playerPropDamageTakenPercent, c_playerPropOperSetTo, FixedToInt((UserDataGetFixed("DifficultySettings", "Normal", "DamageTakenRatio", 1) * 100.0)));
        TechTreeUpgradeAddLevel(1, "SuperiorWarpGates", 1);
    }
    else if (autoBB45CCF8_val == 3) {
        GameSetSpeedValueMinimum(c_gameSpeedFast);
        PlayerModifyPropertyInt(1, c_playerPropDamageTakenPercent, c_playerPropOperSetTo, FixedToInt((UserDataGetFixed("DifficultySettings", "Hard", "DamageTakenRatio", 1) * 100.0)));
    }
    else if (autoBB45CCF8_val == 4) {
        GameSetSpeedValueMinimum(c_gameSpeedFaster);
        PlayerModifyPropertyInt(1, c_playerPropDamageTakenPercent, c_playerPropOperSetTo, FixedToInt((UserDataGetFixed("DifficultySettings", "Brutal", "DamageTakenRatio", 1) * 100.0)));
    }
    else {
    }
}

// Triggers
//--------------------------------------------------------------------------------------------------
// Trigger: PM_CinematicModeOn
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CinematicModeOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    playergroup auto806AEE93_g;
    int auto806AEE93_var;
    playergroup autoC67544CC_g;
    int autoC67544CC_var;

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

    if ((libNtve_gf_PlayerInCinematicMode(1) == true)) {
        libVCMI_gv_pM_ScreenMode = c_uiModeLetterboxed;
    }

    auto806AEE93_g = PlayerGroupAll();
    auto806AEE93_var = -1;
    while (true) {
        auto806AEE93_var = PlayerGroupNextPlayer(auto806AEE93_g, auto806AEE93_var);
        if (auto806AEE93_var < 0) { break; }
        PlayerScoreValueEnableAll(auto806AEE93_var, false);
    }
    autoC67544CC_g = PlayerGroupAll();
    autoC67544CC_var = -1;
    while (true) {
        autoC67544CC_var = PlayerGroupNextPlayer(autoC67544CC_g, autoC67544CC_var);
        if (autoC67544CC_var < 0) { break; }
        libNtve_gf_SetUpgradeLevelForPlayer(autoC67544CC_var, "CinematicMode", 1);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CinematicModeOn_Init () {
    libVCMI_gt_PM_CinematicModeOn = TriggerCreate("libVCMI_gt_PM_CinematicModeOn_Func");
    TriggerAddEventGeneric(libVCMI_gt_PM_CinematicModeOn, "CinematicModeOn");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CinematicModeOff
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CinematicModeOff_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unitgroup lv_group;

    // Automatic Variable Declarations
    playergroup auto8E4FBCB3_g;
    int auto8E4FBCB3_var;
    playergroup autoB4558D44_g;
    int autoB4558D44_var;

    // Variable Initialization
    lv_group = UnitGroupEmpty();

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

    if ((libNtve_gf_PlayerInCinematicMode(1) == false)) {
        if ((UIFrameVisible(1, c_syncFrameTypeConsolePanel) == true)) {
            libVCMI_gv_pM_ScreenMode = c_uiModeConsole;
        }
        else {
            libVCMI_gv_pM_ScreenMode = c_uiModeFullscreen;
        }
    }
    else {
        libVCMI_gv_pM_ScreenMode = c_uiModeLetterboxed;
    }
    auto8E4FBCB3_g = PlayerGroupAll();
    auto8E4FBCB3_var = -1;
    while (true) {
        auto8E4FBCB3_var = PlayerGroupNextPlayer(auto8E4FBCB3_g, auto8E4FBCB3_var);
        if (auto8E4FBCB3_var < 0) { break; }
        PlayerScoreValueEnableAll(auto8E4FBCB3_var, true);
    }
    autoB4558D44_g = PlayerGroupAll();
    autoB4558D44_var = -1;
    while (true) {
        autoB4558D44_var = PlayerGroupNextPlayer(autoB4558D44_g, autoB4558D44_var);
        if (autoB4558D44_var < 0) { break; }
        libNtve_gf_SetUpgradeLevelForPlayer(autoB4558D44_var, "CinematicMode", 0);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CinematicModeOff_Init () {
    libVCMI_gt_PM_CinematicModeOff = TriggerCreate("libVCMI_gt_PM_CinematicModeOff_Func");
    TriggerAddEventGeneric(libVCMI_gt_PM_CinematicModeOff, "CinematicModeOff");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingForceOff
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingForceOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gv_pM_SoAExitInstantly = true;
    libVCMI_gv_pM_SoAForceExit = true;
    TriggerExecute(libVCMI_gt_PM_SoATargetingCancel, false, false);
    libVCMI_gv_pM_CinematicModeSoAEnergy = libVCMI_gf_SpearofAdunEnergy(libVCMI_ge_SpearofAdunEnergyType_Absolute);
    libVCUI_gf_PU_GPVisibilityAutoUpdate(false, c_transitionDurationImmediate);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingForceOff_Init () {
    libVCMI_gt_PM_SoATargetingForceOff = TriggerCreate("libVCMI_gt_PM_SoATargetingForceOff_Func");
    TriggerEnable(libVCMI_gt_PM_SoATargetingForceOff, false);
    TriggerAddEventGeneric(libVCMI_gt_PM_SoATargetingForceOff, "CinematicModeOn");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingDeactivated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingDeactivated_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    if (((libVCMI_gv_pM_SoATargetingChargesSpent == 0) || ((libVCMI_gf_PM_SoATargetingPauseEnabled() == true) && (libVCMI_gv_pM_SoATargetingChargesSpent != libVCMI_gv_pM_SoATargetingChargesTotal)))) {
        DataTableSetInt(false, TriggerEventParamName(libVCMI_gv_pMC_SoATargetingEventExited, libVCMI_gv_pMC_SoATargetingParamReason), (libVCMI_ge_SpearofAdunTargetingExitType_ByCanceling));
        TriggerSendEvent(libVCMI_gv_pMC_SoATargetingEventExited);
    }
    else {
        DataTableSetInt(false, TriggerEventParamName(libVCMI_gv_pMC_SoATargetingEventExited, libVCMI_gv_pMC_SoATargetingParamReason), (libVCMI_ge_SpearofAdunTargetingExitType_ByFiring));
        TriggerSendEvent(libVCMI_gv_pMC_SoATargetingEventExited);
    }
    UISetTargetingOrder(PlayerGroupSingle(1), libVCUI_gv_pU_GPCasterGroup, null, false);
    libVCMI_gv_pM_SoATargetingChargesSpent = 0;
    TriggerEnable(libVCMI_gt_PM_SoATargetingCancel, false);
    TriggerEnable(libVCMI_gt_PM_SoATargetingClearAll, false);
    TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, false);
    TriggerEnable(libVCMI_gt_PM_SoATargetingDirectionChosen, false);
    libVCMI_gf_PM_SoATargetingModeExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingDeactivated_Init () {
    libVCMI_gt_PM_SoATargetingDeactivated = TriggerCreate("libVCMI_gt_PM_SoATargetingDeactivated_Func");
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoATargetingDeactivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAOrbitalStrikeActivate", c_unitBehaviorChangeDeactivate);
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoATargetingDeactivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAGravitonBombActivate", c_unitBehaviorChangeDeactivate);
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoATargetingDeactivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAThermalLanceActivate", c_unitBehaviorChangeDeactivate);
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoATargetingDeactivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAStrafeAttackActivate", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingPointChosen
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingPointChosen_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_targetPoint;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libVCMI_gv_pM_SoATargetingChargesSpent < libVCMI_gv_pM_SoATargetingChargesTotal))) {
            return false;
        }
    }

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

    lv_targetPoint = OrderGetTargetPoint(EventUnitOrder());
    if ((VisIsVisibleForPlayer(1, lv_targetPoint) == false)) {
        return true;
    }

    libVCMI_gv_pM_SoATargetingCycling = true;
    libVCMI_gv_pM_SoATargetingChargesSpent += 1;
    libNtve_gf_CreateActorAtPoint(libVCMI_gv_pM_SoATargetingModel, lv_targetPoint);
    libVCMI_gv_pM_SoATargetingActors[libVCMI_gv_pM_SoATargetingChargesSpent] = libNtve_gf_ActorLastCreated();
    libNtve_gf_CreateActorAtPoint("SOATargetingModeConfirmationSound", lv_targetPoint);
    if ((libVCMI_gv_pM_SoATargetingUnitType == null)) {
        UnitIssueOrder(libVCMI_gv_sOA_CasterUnit, OrderTargetingPoint(libVCMI_gv_pM_SoATargetingExecuteCommand, lv_targetPoint), c_orderQueueAddToEnd);
        libVCUI_gf_PU_TargetingSetCharges((libVCMI_gv_pM_SoATargetingChargesTotal-libVCMI_gv_pM_SoATargetingChargesSpent), libVCMI_gv_pM_SoATargetingChargesTotal);
        if ((libVCMI_gv_pM_SoATargetingChargesSpent == libVCMI_gv_pM_SoATargetingChargesTotal)) {
            TriggerEnable(libVCMI_gt_PM_SoATargetingCancel, false);
            Wait(0.125, c_timeGame);
            UnitBehaviorRemove(libVCMI_gv_sOA_CasterUnit, libVCMI_gv_pM_SoATargetingBehavior, 1);
            DataTableSetInt(true, ("AbilUsed_" + (libVCMI_gv_pM_SoATargetingAbilityInstance)), (DataTableGetInt(true, ("AbilUsed_" + (libVCMI_gv_pM_SoATargetingAbilityInstance)))+1));
        }
        else {
            Wait(0.1, c_timeGame);
            UISetTargetingOrder(PlayerGroupSingle(1), libVCMI_gv_pM_SoACasterGroup, libVCMI_gv_pM_SoATargetingOrder, false);
        }
    }
    else {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, libVCMI_gv_pM_SoATargetingUnitType, 0, 1, lv_targetPoint);
        libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent] = UnitLastCreated();
        libVCMI_gv_pM_SoATargetingDirectionGroup = libNtve_gf_ConvertUnitToUnitGroup(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent]);
        if ((libVCMI_gf_PM_SoATargetingPauseEnabled() == true)) {
            libNtve_gf_PauseUnit(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent], true);
            UnitBehaviorAdd(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent], "SOAThermalLanceStun", libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent], 1);
            UnitBehaviorSetDuration(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent], "SOAThermalLanceStun", (0.125 * libVCMI_gv_pM_SoATargetingChargesSpent));
        }

        libVCUI_gf_PU_TargetingSetInstructionText(libVoiC_gf_PC_PerkTargetingText(libVCMI_gv_pM_SoATargetingAbilityInstance, 2));
        TriggerEnable(TriggerGetCurrent(), false);
        Wait(0.1, c_timeGame);
        UISetTargetingOrder(PlayerGroupSingle(1), libVCMI_gv_pM_SoATargetingDirectionGroup, OrderTargetingPoint(libVCMI_gv_pM_SoATargetingExecuteCommand, UnitGetPosition(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent])), false);
        TriggerEnable(libVCMI_gt_PM_SoATargetingDirectionChosen, true);
    }
    libVCMI_gv_pM_SoATargetingCycling = false;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingPointChosen_Init () {
    libVCMI_gt_PM_SoATargetingPointChosen = TriggerCreate("libVCMI_gt_PM_SoATargetingPointChosen_Func");
    TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, false);
    TriggerAddEventUnitOrder(libVCMI_gt_PM_SoATargetingPointChosen, UnitRefFromVariable("libVCMI_gv_pM_SoAUnit"), AbilityCommand("SOAOrbitalStrikeTargetingDummy", 0));
    TriggerAddEventUnitOrder(libVCMI_gt_PM_SoATargetingPointChosen, UnitRefFromVariable("libVCMI_gv_pM_SoAUnit"), AbilityCommand("SOAThermalLanceTargetingDummy", 0));
    TriggerAddEventUnitOrder(libVCMI_gt_PM_SoATargetingPointChosen, UnitRefFromVariable("libVCMI_gv_pM_SoAUnit"), AbilityCommand("SOAGravitonBomb", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingDirectionChosen
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingDirectionChosen_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_targetPoint;

    // Automatic Variable Declarations
    // Variable Initialization

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

    libVCMI_gv_pM_SoATargetingCycling = true;
    lv_targetPoint = OrderGetTargetPoint(EventUnitOrder());
    libNtve_gf_CreateActorAtPoint("SOATargetingModeConfirmationSound", lv_targetPoint);
    ActorSend(libVCMI_gv_pM_SoATargetingActors[libVCMI_gv_pM_SoATargetingChargesSpent], "Signal Destroy");
    libNtve_gf_MakeUnitFacePoint(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent], lv_targetPoint, 0.0);
    if ((libVCMI_gf_PM_SoATargetingPauseEnabled() == true)) {
        libNtve_gf_SendActorMessageToUnit(libVCMI_gv_pM_SoATargetingUnit[libVCMI_gv_pM_SoATargetingChargesSpent], "Signal GuideOn");
    }

    libVCUI_gf_PU_TargetingSetCharges((libVCMI_gv_pM_SoATargetingChargesTotal-libVCMI_gv_pM_SoATargetingChargesSpent), libVCMI_gv_pM_SoATargetingChargesTotal);
    if ((libVCMI_gv_pM_SoATargetingChargesSpent == libVCMI_gv_pM_SoATargetingChargesTotal)) {
        TriggerEnable(libVCMI_gt_PM_SoATargetingCancel, false);
        UnitBehaviorRemove(libVCMI_gv_sOA_CasterUnit, libVCMI_gv_pM_SoATargetingBehavior, 1);
        Wait(0.1, c_timeGame);
    }
    else {
        libVCUI_gf_PU_TargetingSetInstructionText(libVoiC_gf_PC_PerkTargetingText(libVCMI_gv_pM_SoATargetingAbilityInstance, 1));
        Wait(0.1, c_timeGame);
        UISetTargetingOrder(PlayerGroupSingle(1), libVCMI_gv_pM_SoACasterGroup, libVCMI_gv_pM_SoATargetingOrder, false);
        TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, true);
        TriggerEnable(TriggerGetCurrent(), false);
    }
    libVCMI_gv_pM_SoATargetingCycling = false;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingDirectionChosen_Init () {
    libVCMI_gt_PM_SoATargetingDirectionChosen = TriggerCreate("libVCMI_gt_PM_SoATargetingDirectionChosen_Func");
    TriggerEnable(libVCMI_gt_PM_SoATargetingDirectionChosen, false);
    TriggerAddEventUnitOrder(libVCMI_gt_PM_SoATargetingDirectionChosen, null, AbilityCommand("SOAThermalLanceExecute", 0));
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingEffectFired
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingEffectFired_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_SoATargetingCleanupActorsAndUnits();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingEffectFired_Init () {
    libVCMI_gt_PM_SoATargetingEffectFired = TriggerCreate("libVCMI_gt_PM_SoATargetingEffectFired_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoATargetingEffectFired, 1, "SOAOrbitalStrikeCP");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoATargetingEffectFired, 1, "SOAGravitonBombLM");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingClearAll
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingClearAll_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gv_pM_SoATargetingCycling == false))) {
            return false;
        }

        if (!(((EventTargetModeAbilCmd() == AbilityCommand("SOAOrbitalStrikeTargetingDummy", 0)) || (EventTargetModeAbilCmd() == AbilityCommand("SOAThermalLanceTargetingDummy", 0)) || (EventTargetModeAbilCmd() == AbilityCommand("SOAGravitonBomb", 0)) || (EventTargetModeAbilCmd() == AbilityCommand("SOAThermalLanceExecute", 0))))) {
            return false;
        }
    }

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

    if ((libVCMI_gv_pM_SoATargetingChargesSpent != 0) && (libVCMI_gf_PM_SoATargetingPauseEnabled() == true)) {
        UnitIssueOrder(libVCMI_gv_sOA_CasterUnit, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
        libVCMI_gv_pM_SoATargetingChargesSpent = 0;
        libVCUI_gf_PU_TargetingSetInstructionText(libVoiC_gf_PC_PerkTargetingText(libVCMI_gv_pM_SoATargetingAbilityInstance, 1));
        UISetTargetingOrder(PlayerGroupSingle(1), libVCMI_gv_pM_SoACasterGroup, libVCMI_gv_pM_SoATargetingOrder, false);
        libVCMI_gf_PM_SoATargetingCleanupActorsAndUnits();
        libVCUI_gf_PU_TargetingSetCharges(libVCMI_gv_pM_SoATargetingChargesTotal, libVCMI_gv_pM_SoATargetingChargesTotal);
        TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, true);
        TriggerEnable(libVCMI_gt_PM_SoATargetingDirectionChosen, false);
    }
    else {
        TriggerExecute(libVCMI_gt_PM_SoATargetingCancel, false, false);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingClearAll_Init () {
    libVCMI_gt_PM_SoATargetingClearAll = TriggerCreate("libVCMI_gt_PM_SoATargetingClearAll_Func");
    TriggerEnable(libVCMI_gt_PM_SoATargetingClearAll, false);
    TriggerAddEventTargetModeUpdate(libVCMI_gt_PM_SoATargetingClearAll, 1, null, c_targetModeStateOff);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingCancel
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingCancel_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVoiC_gf_PC_StatRecordTargetingModeAbort();
    UnitIssueOrder(libVCMI_gv_sOA_CasterUnit, Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    UISetTargetingOrder(PlayerGroupSingle(1), libVCUI_gv_pU_GPCasterGroup, null, false);
    libVCMI_gf_PM_SoATargetingCleanupActorsAndUnits();
    if (((libVCMI_gv_pM_SoATargetingChargesSpent == 0) || (libVCMI_gf_PM_SoATargetingPauseEnabled() == true))) {
        libNtve_gf_UnitAbilityRemoveCooldown(libVCMI_gv_sOA_CasterUnit, libVCMI_gv_pM_SoATargetingActivateAbility, libVCMI_gv_pM_SoATargetingCooldown);
        UnitSetPropertyFixed(libVCMI_gv_sOA_CasterUnit, c_unitPropEnergy, (UnitGetPropertyFixed(libVCMI_gv_sOA_CasterUnit, c_unitPropEnergy, c_unitPropCurrent) + libNtve_gf_CostOfAbility(libVCMI_gv_pM_SoATargetingActivateAbility, "Energy")));
    }

    UnitBehaviorRemove(libVCMI_gv_sOA_CasterUnit, libVCMI_gv_pM_SoATargetingBehavior, 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingCancel_Init () {
    libVCMI_gt_PM_SoATargetingCancel = TriggerCreate("libVCMI_gt_PM_SoATargetingCancel_Func");
    TriggerEnable(libVCMI_gt_PM_SoATargetingCancel, false);
    libVCUI_gf_PU_TargetingCancel(libVCMI_gt_PM_SoATargetingCancel);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingCameraShake
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingCameraShake_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_distance;
    fixed[4] lv_cameraPosition;
    fixed[4] lv_effectPosition;

    // Automatic Variable Declarations
    // Variable Initialization

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

    lv_cameraPosition[0] = PointGetX(CameraGetTarget(1));
    lv_cameraPosition[1] = (PointGetY(CameraGetTarget(1))-(Cos(CameraGetPitch(1))*CameraGetDistance(1)));
    lv_cameraPosition[2] = (WorldHeight(c_heightMapGround, CameraGetTarget(1))+(Sin(CameraGetPitch(1))*CameraGetDistance(1)));
    lv_effectPosition[0] = PointGetX(EventPlayerEffectUsedPoint(c_effectLocationTargetPoint));
    lv_effectPosition[1] = PointGetY(EventPlayerEffectUsedPoint(c_effectLocationTargetPoint));
    lv_effectPosition[2] = WorldHeight(c_heightMapGround, EventPlayerEffectUsedPoint(c_effectLocationTargetPoint));
    lv_distance = SquareRoot((Pow((lv_cameraPosition[0]-lv_effectPosition[0]), 2.0) + Pow((lv_cameraPosition[1]-lv_effectPosition[1]), 2.0) + Pow((lv_cameraPosition[2]-lv_effectPosition[2]), 2.0)));
    CameraShakeStart(1, c_cameraPositionTarget, c_cameraDirectionZ, MaxF((1-(lv_distance/50)), 0.0), 2.5, 100.0, 0.1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingCameraShake_Init () {
    libVCMI_gt_PM_SoATargetingCameraShake = TriggerCreate("libVCMI_gt_PM_SoATargetingCameraShake_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoATargetingCameraShake, 1, "SOAOrbitalStrikeImpactSearch");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoATargetingCameraShake, 1, "SOAGravitonBombCP");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAOrbitalStrikeActivated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAOrbitalStrikeActivated_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_StoreUnitSelection(1, libNtve_ge_UnitSelectionStoreOption_ClearUnitSelection);
    libVCMI_gv_pM_SoATargetingActivateAbility = "SOAOrbitalStrikeActivate";
    libVCMI_gv_pM_SoATargetingExecuteCommand = AbilityCommand("SOAOrbitalStrikeExecute", 0);
    libVCMI_gv_pM_SoATargetingCooldown = "Abil/SOAOrbitalStrikeActivate";
    libVCMI_gv_pM_SoATargetingBehavior = "SOAOrbitalStrikeActivate";
    libVCMI_gv_pM_SoATargetingModel = "SOAOrbitalStrikeTargetModel";
    libVCMI_gv_pM_SoATargetingOrder = OrderTargetingPoint(AbilityCommand("SOAOrbitalStrikeTargetingDummy", 0), UnitGetPosition(libVCMI_gv_sOA_CasterUnit));
    libVCMI_gv_pM_SoATargetingAbilityInstance = "GPTier2Power1";
    libVCMI_gv_pM_SoATargetingUnitType = null;
    libVCMI_gv_pM_SoATargetingChargesTotal = 5;
    TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, true);
    libVCMI_gf_PM_SoATargetingModeEnter();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAOrbitalStrikeActivated_Init () {
    libVCMI_gt_PM_SoAOrbitalStrikeActivated = TriggerCreate("libVCMI_gt_PM_SoAOrbitalStrikeActivated_Func");
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoAOrbitalStrikeActivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAOrbitalStrikeActivate", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAGravitonBombActivated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAGravitonBombActivated_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_StoreUnitSelection(1, libNtve_ge_UnitSelectionStoreOption_ClearUnitSelection);
    libVCMI_gv_pM_SoATargetingActivateAbility = "SOAGravitonBombActivate";
    libVCMI_gv_pM_SoATargetingExecuteCommand = AbilityCommand("SOAGravitonBombExecute", 0);
    libVCMI_gv_pM_SoATargetingCooldown = "Abil/SOAGravitonBombActivate";
    libVCMI_gv_pM_SoATargetingBehavior = "SOAGravitonBombActivate";
    libVCMI_gv_pM_SoATargetingModel = "SOAGravitonBombTargetModel";
    libVCMI_gv_pM_SoATargetingOrder = OrderTargetingPoint(AbilityCommand("SOAGravitonBomb", 0), UnitGetPosition(libVCMI_gv_sOA_CasterUnit));
    libVCMI_gv_pM_SoATargetingAbilityInstance = "GPTier2Power2";
    libVCMI_gv_pM_SoATargetingUnitType = null;
    libVCMI_gv_pM_SoATargetingChargesTotal = 3;
    TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, true);
    libVCMI_gf_PM_SoATargetingModeEnter();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAGravitonBombActivated_Init () {
    libVCMI_gt_PM_SoAGravitonBombActivated = TriggerCreate("libVCMI_gt_PM_SoAGravitonBombActivated_Func");
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoAGravitonBombActivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAGravitonBombActivate", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAThermalLanceActivated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAThermalLanceActivated_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_StoreUnitSelection(1, libNtve_ge_UnitSelectionStoreOption_ClearUnitSelection);
    libVCMI_gv_pM_SoATargetingActivateAbility = "SOAThermalLanceActivate";
    libVCMI_gv_pM_SoATargetingExecuteCommand = AbilityCommand("SOAThermalLanceExecute", 0);
    libVCMI_gv_pM_SoATargetingCooldown = "Abil/SOAThermalLanceActivate";
    libVCMI_gv_pM_SoATargetingBehavior = "SOAThermalLanceActivate";
    libVCMI_gv_pM_SoATargetingModel = "SOAThermalLanceTargetingModel";
    libVCMI_gv_pM_SoATargetingOrder = OrderTargetingPoint(AbilityCommand("SOAThermalLanceTargetingDummy", 0), UnitGetPosition(libVCMI_gv_sOA_CasterUnit));
    libVCMI_gv_pM_SoATargetingAbilityInstance = "GPTier2Power3";
    libVCMI_gv_pM_SoATargetingUnitType = "SOAThermalLanceTargeter";
    libVCMI_gv_pM_SoATargetingChargesTotal = 3;
    TriggerEnable(libVCMI_gt_PM_SoATargetingPointChosen, true);
    libVCMI_gf_PM_SoATargetingModeEnter();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAThermalLanceActivated_Init () {
    libVCMI_gt_PM_SoAThermalLanceActivated = TriggerCreate("libVCMI_gt_PM_SoAThermalLanceActivated_Func");
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_PM_SoAThermalLanceActivated, UnitRefFromVariable("libVCMI_gv_sOA_CasterUnit"), "SOAThermalLanceActivate", c_unitBehaviorChangeActivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATimeFreezeCast
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATimeFreezeCast_Func (bool testConds, bool runActions) {
    // Variable Declarations
    bool lv_originalPauseState;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_originalPauseState = true;

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

    libVCMI_gf_SOA_TimeFreezeVisual(PointGetX(CameraGetTarget(1)), PointGetY(CameraGetTarget(1)));
    libVoiC_gf_PC_TimeAITemporarySet(true);
    Wait(IntToFixed(CatalogFieldValueGetAsInt(c_gameCatalogBehavior, "SOATimeFreeze", "Duration", c_playerAny)), c_timeGame);
    libVoiC_gf_PC_TimeAITemporaryRestore();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATimeFreezeCast_Init () {
    libVCMI_gt_PM_SoATimeFreezeCast = TriggerCreate("libVCMI_gt_PM_SoATimeFreezeCast_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoATimeFreezeCast, 1, "SOATimeFreeze");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoARecall_PrimarySearch
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoARecall_PrimarySearch_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_closestNexus;

    // Automatic Variable Declarations
    // Variable Initialization

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

    if (((libVCMI_gv_sOA_Recall_PrimaryNexus == null) || (libNtve_gf_UnitIsHidden(libVCMI_gv_sOA_Recall_PrimaryNexus) == true) || (!(UnitIsValid(libVCMI_gv_sOA_Recall_PrimaryNexus)) == true))) {
        lv_closestNexus = libVCMI_gf_PM_FindPrimaryTownHall(1);
        if ((lv_closestNexus != null)) {
            UnitBehaviorAdd(lv_closestNexus, "SOARecallPrimaryNexus", lv_closestNexus, 1);
            libVCMI_gv_sOA_Recall_PrimaryNexus = lv_closestNexus;
        }

    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoARecall_PrimarySearch_Init () {
    libVCMI_gt_PM_SoARecall_PrimarySearch = TriggerCreate("libVCMI_gt_PM_SoARecall_PrimarySearch_Func");
    TriggerEnable(libVCMI_gt_PM_SoARecall_PrimarySearch, false);
    TriggerAddEventTimePeriodic(libVCMI_gt_PM_SoARecall_PrimarySearch, 3.0, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoARecall_PrimaryNexusDies
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoARecall_PrimaryNexusDies_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerExecute(libVCMI_gt_PM_SoARecall_PrimarySearch, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoARecall_PrimaryNexusDies_Init () {
    libVCMI_gt_PM_SoARecall_PrimaryNexusDies = TriggerCreate("libVCMI_gt_PM_SoARecall_PrimaryNexusDies_Func");
    TriggerEnable(libVCMI_gt_PM_SoARecall_PrimaryNexusDies, false);
    TriggerAddEventUnitDied(libVCMI_gt_PM_SoARecall_PrimaryNexusDies, UnitRefFromVariable("libVCMI_gv_sOA_Recall_PrimaryNexus"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoARecall_PrimaryNexusInit
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoARecall_PrimaryNexusInit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((PlayerRace(1) == "Prot"))) {
            return false;
        }
    }

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

    TriggerEnable(libVCMI_gt_PM_SoARecall_PrimarySearch, true);
    TriggerEnable(libVCMI_gt_PM_SoARecall_PrimaryNexusDies, true);
    TriggerExecute(libVCMI_gt_PM_SoARecall_PrimarySearch, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoARecall_PrimaryNexusInit_Init () {
    libVCMI_gt_PM_SoARecall_PrimaryNexusInit = TriggerCreate("libVCMI_gt_PM_SoARecall_PrimaryNexusInit_Func");
    libVoiC_gf_CampaignMissionStarts(libVCMI_gt_PM_SoARecall_PrimaryNexusInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingPurifierBeamOn
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingPurifierBeamOn_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_StoreUnitSelection(1, libNtve_ge_UnitSelectionStoreOption_ClearUnitSelection);
    libVCMI_gv_pM_SoATargetingActivateAbility = "SOAPurifierBeam";
    libVCMI_gv_pM_SoATargetingOrder = null;
    libVCMI_gv_pM_SoATargetingExecuteCommand = null;
    libVCMI_gv_pM_SoATargetingCooldown = "";
    libVCMI_gv_pM_SoATargetingBehavior = null;
    libVCMI_gv_pM_SoATargetingModel = null;
    libVCMI_gv_pM_SoATargetingAbilityInstance = "GPTier6Power1";
    libVCMI_gv_pM_SoATargetingUnitType = null;
    libVCMI_gv_pM_SoATargetingChargesTotal = 1;
    libVCMI_gf_PM_SoATargetingModeEnter();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingPurifierBeamOn_Init () {
    libVCMI_gt_PM_SoATargetingPurifierBeamOn = TriggerCreate("libVCMI_gt_PM_SoATargetingPurifierBeamOn_Func");
    TriggerAddEventTargetModeUpdate(libVCMI_gt_PM_SoATargetingPurifierBeamOn, 1, AbilityCommand("SOAPurifierBeam", 0), c_targetModeStateOn);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoATargetingPurifierBeamOff
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoATargetingPurifierBeamOff_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_SoATargetingModeExit();
    Wait(0.03, c_timeGame);
    if ((UnitAbilityGetCooldown(libVCMI_gv_sOA_CasterUnit, "SOAPurifierBeam", "Abil/SOAPurifierBeam") > 0.0)) {
        DataTableSetInt(false, TriggerEventParamName(libVCMI_gv_pMC_SoATargetingEventExited, libVCMI_gv_pMC_SoATargetingParamReason), (libVCMI_ge_SpearofAdunTargetingExitType_ByFiring));
        TriggerSendEvent(libVCMI_gv_pMC_SoATargetingEventExited);
    }
    else {
        DataTableSetInt(false, TriggerEventParamName(libVCMI_gv_pMC_SoATargetingEventExited, libVCMI_gv_pMC_SoATargetingParamReason), (libVCMI_ge_SpearofAdunTargetingExitType_ByCanceling));
        TriggerSendEvent(libVCMI_gv_pMC_SoATargetingEventExited);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoATargetingPurifierBeamOff_Init () {
    libVCMI_gt_PM_SoATargetingPurifierBeamOff = TriggerCreate("libVCMI_gt_PM_SoATargetingPurifierBeamOff_Func");
    TriggerAddEventTargetModeUpdate(libVCMI_gt_PM_SoATargetingPurifierBeamOff, 1, AbilityCommand("SOAPurifierBeam", 0), c_targetModeStateOff);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAStrafeActivated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAStrafeActivated_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_radius;
    fixed lv_radiusMinimum;
    fixed lv_radiusMaximum;
    int lv_i;
    point lv_targetPoint;
    revealer lv_revealer;

    // Automatic Variable Declarations
    const int autoE747AC09_ae = 100;
    const int autoE747AC09_ai = 1;

    // Variable Initialization
    lv_radiusMinimum = 2.0;
    lv_radiusMaximum = 10.0;
    lv_targetPoint = EventPlayerEffectUsedPoint(c_effectLocationTargetPoint);

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

    lv_i = 1;
    for ( ; ( (autoE747AC09_ai >= 0 && lv_i <= autoE747AC09_ae) || (autoE747AC09_ai < 0 && lv_i >= autoE747AC09_ae) ) ; lv_i += autoE747AC09_ai ) {
        lv_radius = (((lv_i / 100.0) * (lv_radiusMaximum - lv_radiusMinimum)) + lv_radiusMinimum);
        UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitCaster), "SOAStrafeAttackDamage", RegionRandomPoint(RegionCircle(lv_targetPoint, lv_radius)));
        UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitCaster), "SOAStrafeAttackDamage", RegionRandomPoint(RegionCircle(lv_targetPoint, lv_radius)));
        VisRevealerCreate(1, RegionCircle(lv_targetPoint, lv_radius));
        lv_revealer = VisRevealerLastCreated();
        Wait(0.15, c_timeGame);
        while (!((libVCMI_gv_pM_SoATargetingActivateAbility == null))) {
            Wait(0.0625, c_timeGame);
        }
        VisRevealerDestroy(lv_revealer);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAStrafeActivated_Init () {
    libVCMI_gt_PM_SoAStrafeActivated = TriggerCreate("libVCMI_gt_PM_SoAStrafeActivated_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoAStrafeActivated, c_playerAny, "SOAStrafeAttackCreateTargeter");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoASuperShieldsActivated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoASuperShieldsActivated_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    playergroup autoD511EADB_g;
    int autoD511EADB_var;
    unitgroup auto7D86169B_g;
    int auto7D86169B_u;
    unit auto7D86169B_var;

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

    autoD511EADB_g = PlayerGroupAll();
    autoD511EADB_var = -1;
    while (true) {
        autoD511EADB_var = PlayerGroupNextPlayer(autoD511EADB_g, autoD511EADB_var);
        if (autoD511EADB_var < 0) { break; }
        if ((TechTreeUpgradeCount(autoD511EADB_var, "SOASuperShield", c_techCountQueuedOrBetter) >= 1)) {
            auto7D86169B_g = UnitGroup(null, autoD511EADB_var, RegionEntireMap(), UnitFilter((1 << c_targetFilterVisible), 0, (1 << c_targetFilterNeutral) | (1 << c_targetFilterEnemy) | (1 << c_targetFilterMissile) | (1 << c_targetFilterItem), (1 << (c_targetFilterStasis - 32)) | (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
            auto7D86169B_u = UnitGroupCount(auto7D86169B_g, c_unitCountAll);
            for (;; auto7D86169B_u -= 1) {
                auto7D86169B_var = UnitGroupUnitFromEnd(auto7D86169B_g, auto7D86169B_u);
                if (auto7D86169B_var == null) { break; }
                UnitCreateEffectUnit(EventPlayerEffectUsedUnit(c_effectUnitCaster), "SOASuperShieldApply", auto7D86169B_var);
            }
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoASuperShieldsActivated_Init () {
    libVCMI_gt_PM_SoASuperShieldsActivated = TriggerCreate("libVCMI_gt_PM_SoASuperShieldsActivated_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_SoASuperShieldsActivated, 1, "SOASuperShieldDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Confusion End Suicide
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_ConfusionEndSuicide_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    AISetUnitSuicide(EventPlayerEffectUsedUnit(c_effectUnitTarget), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_ConfusionEndSuicide_Init () {
    libVCMI_gt_ConfusionEndSuicide = TriggerCreate("libVCMI_gt_ConfusionEndSuicide_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_ConfusionEndSuicide, c_playerAny, "IssueAIOrderSuicide");
}

//--------------------------------------------------------------------------------------------------
// Trigger: GlobalUpgrade
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_GlobalUpgrade_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_i;

    // Automatic Variable Declarations
    const int auto1B6263AA_ae = 15;
    const int auto1B6263AA_ai = 1;

    // Variable Initialization

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

    lv_i = 0;
    for ( ; ( (auto1B6263AA_ai >= 0 && lv_i <= auto1B6263AA_ae) || (auto1B6263AA_ai < 0 && lv_i >= auto1B6263AA_ae) ) ; lv_i += auto1B6263AA_ai ) {
        TechTreeUpgradeAddLevel(lv_i, "VoidStoryUnitGlobalUpgrade", 1);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_GlobalUpgrade_Init () {
    libVCMI_gt_GlobalUpgrade = TriggerCreate("libVCMI_gt_GlobalUpgrade_Func");
    TriggerAddEventMapInit(libVCMI_gt_GlobalUpgrade);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HandleUseDeepShadows
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HandleUseDeepShadows_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    unitgroup auto6304B951_g;
    int auto6304B951_u;
    unit auto6304B951_var;

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

    auto6304B951_g = UnitGroup("DarkTemplar", EventPlayer(), RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0);
    auto6304B951_u = UnitGroupCount(auto6304B951_g, c_unitCountAll);
    for (;; auto6304B951_u -= 1) {
        auto6304B951_var = UnitGroupUnitFromEnd(auto6304B951_g, auto6304B951_u);
        if (auto6304B951_var == null) { break; }
        if ((UnitHasBehavior2(auto6304B951_var, "DarkTemplarChampionDarkReinforcementsTimedLife") == true)) {
            UnitBehaviorAdd(auto6304B951_var, "DeepShadows", auto6304B951_var, 1);
        }

    }
    UnitBehaviorAdd(EventUnit(), "DeepShadows", EventUnit(), 1);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HandleUseDeepShadows_Init () {
    libVCMI_gt_PM_HandleUseDeepShadows = TriggerCreate("libVCMI_gt_PM_HandleUseDeepShadows_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_PM_HandleUseDeepShadows, null, AbilityCommand("DarkTemplarChampionDeepShadows", 0), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HandleUseAlarakAvatar
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HandleUseAlarakAvatar_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_AddAlarakAvatarUpgrade(EventPlayer());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HandleUseAlarakAvatar_Init () {
    libVCMI_gt_PM_HandleUseAlarakAvatar = TriggerCreate("libVCMI_gt_PM_HandleUseAlarakAvatar_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_PM_HandleUseAlarakAvatar, null, AbilityCommand("AlarakAvatar", 0), c_unitAbilStageAll, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HandleAlarakAvatarFinal
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HandleAlarakAvatarFinal_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_RemoveAlarakAvatarUpgrade(EventPlayer());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HandleAlarakAvatarFinal_Init () {
    libVCMI_gt_PM_HandleAlarakAvatarFinal = TriggerCreate("libVCMI_gt_PM_HandleAlarakAvatarFinal_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_PM_HandleAlarakAvatarFinal, c_playerAny, "AlarakAvatarFinalDummy");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 4
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback4_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 4.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback4_Init () {
    libVCMI_gt_AlarakKnockback4 = TriggerCreate("libVCMI_gt_AlarakKnockback4_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback4, c_playerAny, "AlarakKnockbackBy4");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 5
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback5_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 5.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback5_Init () {
    libVCMI_gt_AlarakKnockback5 = TriggerCreate("libVCMI_gt_AlarakKnockback5_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback5, c_playerAny, "AlarakKnockbackBy5");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 6
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback6_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 6.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback6_Init () {
    libVCMI_gt_AlarakKnockback6 = TriggerCreate("libVCMI_gt_AlarakKnockback6_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback6, c_playerAny, "AlarakKnockbackBy6");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 7
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback7_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 7.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback7_Init () {
    libVCMI_gt_AlarakKnockback7 = TriggerCreate("libVCMI_gt_AlarakKnockback7_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback7, c_playerAny, "AlarakKnockbackBy7");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 8
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback8_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 8.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback8_Init () {
    libVCMI_gt_AlarakKnockback8 = TriggerCreate("libVCMI_gt_AlarakKnockback8_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback8, c_playerAny, "AlarakKnockbackBy8");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 9
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback9_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 9.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback9_Init () {
    libVCMI_gt_AlarakKnockback9 = TriggerCreate("libVCMI_gt_AlarakKnockback9_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback9, c_playerAny, "AlarakKnockbackBy9");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 10
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback10_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 10.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback10_Init () {
    libVCMI_gt_AlarakKnockback10 = TriggerCreate("libVCMI_gt_AlarakKnockback10_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback10, c_playerAny, "AlarakKnockbackBy10");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 11
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback11_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 11.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback11_Init () {
    libVCMI_gt_AlarakKnockback11 = TriggerCreate("libVCMI_gt_AlarakKnockback11_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback11, c_playerAny, "AlarakKnockbackBy11");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Alarak Knockback 12
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AlarakKnockback12_Func (bool testConds, bool runActions) {
    // Variable Declarations
    fixed lv_angle;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((UnitHasBehavior2(EventPlayerEffectUsedUnit(c_effectUnitCaster), "AlarakKnockbackTriggerOverride") == true))) {
            return false;
        }
    }

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

    lv_angle = UnitGetFacing(EventPlayerEffectUsedUnit(c_effectUnitCaster));
    UnitCreateEffectPoint(EventPlayerEffectUsedUnit(c_effectUnitTarget), "AlarakTriggerUnitKnockback", libVCMI_gf_AlarakKnockbackOffsetFindPoint(lv_angle, UnitGetPosition(EventPlayerEffectUsedUnit(c_effectUnitTarget)), 12.0));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AlarakKnockback12_Init () {
    libVCMI_gt_AlarakKnockback12 = TriggerCreate("libVCMI_gt_AlarakKnockback12_Func");
    TriggerAddEventPlayerEffectUsed(libVCMI_gt_AlarakKnockback12, c_playerAny, "AlarakKnockbackBy12");
}

//--------------------------------------------------------------------------------------------------
// Trigger: Fenix Charge
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_FenixCharge_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_k;
    point lv_t;
    point lv_finalT;
    fixed lv_facing;
    fixed lv_distance;
    bool lv_goodPositionFound;
    int lv_i;

    // Automatic Variable Declarations
    const int auto5EA436F8_ae = 14;
    const int auto5EA436F8_ai = 1;

    // Variable Initialization
    lv_k = UnitGetPosition(EventUnit());
    lv_t = EventUnitTargetPoint();
    lv_facing = AngleBetweenPoints(UnitGetPosition(EventUnit()), EventUnitTargetPoint());
    lv_distance = 10.0;

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

    lv_t = libNtve_gf_PointOffsetTowardsPoint(lv_k, 10.0, lv_t);
    lv_finalT = lv_t;
    while ((lv_distance >= 0.6) && (lv_goodPositionFound == false)) {
        lv_t = libNtve_gf_PointOffsetTowardsPoint(lv_k, lv_distance, lv_t);
        if ((PointPathingCost(lv_k, lv_t) <= FixedToInt((lv_distance * 1.5))) && (WorldHeight(c_heightMapGround, lv_k) < (WorldHeight(c_heightMapGround, lv_t) + 1.0)) && (WorldHeight(c_heightMapGround, lv_k) > (WorldHeight(c_heightMapGround, lv_t) - 1.0))) {
            lv_goodPositionFound = true;
        }

        lv_distance -= 0.5;
    }
    Wait(0.0625, c_timeGame);
    if ((lv_goodPositionFound == true)) {
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_t), c_orderQueueReplace);
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_finalT), c_orderQueueAddToEnd);
    }
    else {
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_finalT), c_orderQueueReplace);
    }
    Wait(0.1875, c_timeGame);
    lv_i = 1;
    for ( ; ( (auto5EA436F8_ai >= 0 && lv_i <= auto5EA436F8_ae) || (auto5EA436F8_ai < 0 && lv_i >= auto5EA436F8_ae) ) ; lv_i += auto5EA436F8_ai ) {
        libVCMI_gv_fenixChargeFacing = UnitGetFacing(EventUnit());
        if ((lv_facing > 90.0)) {
            if (((libVCMI_gv_fenixChargeFacing < (lv_facing - 90.0)) && (libVCMI_gv_fenixChargeFacing > (lv_facing - 270.0)))) {
                UnitBehaviorRemove(EventUnit(), "FenixChargeSpeed", 1);
                break;
            }

        }
        else {
            if ((lv_facing < -90.0)) {
                if (((libVCMI_gv_fenixChargeFacing > (lv_facing + 90.0)) && (libVCMI_gv_fenixChargeFacing < (lv_facing + 270.0)))) {
                    UnitBehaviorRemove(EventUnit(), "FenixChargeSpeed", 1);
                    break;
                }

            }
            else {
                if (((libVCMI_gv_fenixChargeFacing > (lv_facing + 90.0)) || (libVCMI_gv_fenixChargeFacing < (lv_facing - 90.0)))) {
                    UnitBehaviorRemove(EventUnit(), "FenixChargeSpeed", 1);
                    break;
                }

            }
        }
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_FenixCharge_Init () {
    libVCMI_gt_FenixCharge = TriggerCreate("libVCMI_gt_FenixCharge_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_FenixCharge, null, AbilityCommand("FenixCharge", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Kerrigan Psi Strike
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_KerriganPsiStrike_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_k;
    point lv_t;
    point lv_finalT;
    fixed lv_facing;
    fixed lv_distance;
    bool lv_goodPositionFound;
    int lv_i;

    // Automatic Variable Declarations
    const int autoABE5947F_ae = 14;
    const int autoABE5947F_ai = 1;

    // Variable Initialization
    lv_k = UnitGetPosition(EventUnit());
    lv_t = EventUnitTargetPoint();
    lv_facing = AngleBetweenPoints(UnitGetPosition(EventUnit()), EventUnitTargetPoint());
    lv_distance = 8.0;

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

    lv_t = libNtve_gf_PointOffsetTowardsPoint(lv_k, 8.0, lv_t);
    lv_finalT = lv_t;
    while ((lv_distance >= 0.6) && (lv_goodPositionFound == false)) {
        lv_t = libNtve_gf_PointOffsetTowardsPoint(lv_k, lv_distance, lv_t);
        if ((PointPathingCost(lv_k, lv_t) <= FixedToInt((lv_distance * 1.5))) && (WorldHeight(c_heightMapGround, lv_k) < (WorldHeight(c_heightMapGround, lv_t) + 1.0)) && (WorldHeight(c_heightMapGround, lv_k) > (WorldHeight(c_heightMapGround, lv_t) - 1.0))) {
            lv_goodPositionFound = true;
        }

        lv_distance -= 0.5;
    }
    Wait(0.0625, c_timeGame);
    if ((lv_goodPositionFound == true)) {
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_t), c_orderQueueReplace);
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_finalT), c_orderQueueAddToEnd);
    }
    else {
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_finalT), c_orderQueueReplace);
    }
    Wait(0.1875, c_timeGame);
    lv_i = 1;
    for ( ; ( (autoABE5947F_ai >= 0 && lv_i <= autoABE5947F_ae) || (autoABE5947F_ai < 0 && lv_i >= autoABE5947F_ae) ) ; lv_i += autoABE5947F_ai ) {
        libVCMI_gv_kerriganPsiStrikeFacing = UnitGetFacing(EventUnit());
        if ((lv_facing > 90.0)) {
            if (((libVCMI_gv_kerriganPsiStrikeFacing < (lv_facing - 90.0)) && (libVCMI_gv_kerriganPsiStrikeFacing > (lv_facing - 270.0)))) {
                UnitBehaviorRemove(EventUnit(), "PsiStrikeWalkSpeed", 1);
                break;
            }

        }
        else {
            if ((lv_facing < -90.0)) {
                if (((libVCMI_gv_kerriganPsiStrikeFacing > (lv_facing + 90.0)) && (libVCMI_gv_kerriganPsiStrikeFacing < (lv_facing + 270.0)))) {
                    UnitBehaviorRemove(EventUnit(), "PsiStrikeWalkSpeed", 1);
                    break;
                }

            }
            else {
                if (((libVCMI_gv_kerriganPsiStrikeFacing > (lv_facing + 90.0)) || (libVCMI_gv_kerriganPsiStrikeFacing < (lv_facing - 90.0)))) {
                    UnitBehaviorRemove(EventUnit(), "PsiStrikeWalkSpeed", 1);
                    break;
                }

            }
        }
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_KerriganPsiStrike_Init () {
    libVCMI_gt_KerriganPsiStrike = TriggerCreate("libVCMI_gt_KerriganPsiStrike_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_KerriganPsiStrike, null, AbilityCommand("PsiStrikeWalk", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Kerrigan Astral Shift
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_KerriganAstralShift_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_k;
    point lv_t;
    point lv_finalT;
    fixed lv_facing;
    fixed lv_distance;
    bool lv_goodPositionFound;
    int lv_i;

    // Automatic Variable Declarations
    const int autoA7FCA599_ae = 14;
    const int autoA7FCA599_ai = 1;

    // Variable Initialization
    lv_k = UnitGetPosition(EventUnit());
    lv_t = EventUnitTargetPoint();
    lv_facing = AngleBetweenPoints(UnitGetPosition(EventUnit()), EventUnitTargetPoint());
    lv_distance = 12.0;

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

    lv_t = libNtve_gf_PointOffsetTowardsPoint(lv_k, 12.0, lv_t);
    lv_finalT = lv_t;
    while ((lv_distance >= 0.6) && (lv_goodPositionFound == false)) {
        lv_t = libNtve_gf_PointOffsetTowardsPoint(lv_k, lv_distance, lv_t);
        if ((PointPathingCost(lv_k, lv_t) <= FixedToInt((lv_distance * 1.5))) && (WorldHeight(c_heightMapGround, lv_k) < (WorldHeight(c_heightMapGround, lv_t) + 1.0)) && (WorldHeight(c_heightMapGround, lv_k) > (WorldHeight(c_heightMapGround, lv_t) - 1.0))) {
            lv_goodPositionFound = true;
        }

        lv_distance -= 0.5;
    }
    Wait(0.0625, c_timeGame);
    if ((lv_goodPositionFound == true)) {
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_t), c_orderQueueReplace);
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_finalT), c_orderQueueAddToEnd);
    }
    else {
        UnitIssueOrder(EventUnit(), OrderTargetingPoint(AbilityCommand("move", 0), lv_finalT), c_orderQueueReplace);
    }
    Wait(0.1875, c_timeGame);
    lv_i = 1;
    for ( ; ( (autoA7FCA599_ai >= 0 && lv_i <= autoA7FCA599_ae) || (autoA7FCA599_ai < 0 && lv_i >= autoA7FCA599_ae) ) ; lv_i += autoA7FCA599_ai ) {
        libVCMI_gv_kerriganAstralShiftFacing = UnitGetFacing(EventUnit());
        if ((lv_facing > 90.0)) {
            if (((libVCMI_gv_kerriganAstralShiftFacing < (lv_facing - 90.0)) && (libVCMI_gv_kerriganAstralShiftFacing > (lv_facing - 270.0)))) {
                UnitBehaviorRemove(EventUnit(), "KerriganEpilogue03LineDashAttackSpeed", 1);
                break;
            }

        }
        else {
            if ((lv_facing < -90.0)) {
                if (((libVCMI_gv_kerriganAstralShiftFacing > (lv_facing + 90.0)) && (libVCMI_gv_kerriganAstralShiftFacing < (lv_facing + 270.0)))) {
                    UnitBehaviorRemove(EventUnit(), "KerriganEpilogue03LineDashAttackSpeed", 1);
                    break;
                }

            }
            else {
                if (((libVCMI_gv_kerriganAstralShiftFacing > (lv_facing + 90.0)) || (libVCMI_gv_kerriganAstralShiftFacing < (lv_facing - 90.0)))) {
                    UnitBehaviorRemove(EventUnit(), "KerriganEpilogue03LineDashAttackSpeed", 1);
                    break;
                }

            }
        }
        Wait(0.0625, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_KerriganAstralShift_Init () {
    libVCMI_gt_KerriganAstralShift = TriggerCreate("libVCMI_gt_KerriganAstralShift_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_KerriganAstralShift, null, AbilityCommand("KerriganEpilogue03LineDashAttack", 0), c_abilEffectStageCast, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Extinction
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_Extinction_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    VisRevealArea(UnitGetOwner(EventUnit()), RegionEntireMap(), 10.0, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_Extinction_Init () {
    libVCMI_gt_Extinction = TriggerCreate("libVCMI_gt_Extinction_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_Extinction, null, AbilityCommand("KerriganEpilogue03Extinction", 0), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: StrikeAmon
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_StrikeAmon_Func (bool testConds, bool runActions) {
    // Variable Declarations
    point lv_startingPoint;
    point lv_targetPoint;
    fixed lv_xDistance;
    fixed lv_yDistance;
    fixed lv_zDistance;
    fixed lv_zOriginal;
    fixed lv_xPartial;
    fixed lv_yPartial;
    fixed lv_zPartial;
    fixed lv_zTotal;
    fixed lv_travelDistance;
    int lv_travelDistanceInt;
    int lv_i;
    fixed lv_r;
    unit lv_kerriganStrikeAmon;
    unit lv_kerriganOriginalUnit;
    bool lv_kerriganSelected;
    unit lv_amonTargetUnit;

    // Automatic Variable Declarations
    unitgroup autoA477DDF1_g;
    int autoA477DDF1_u;
    unit autoA477DDF1_var;
    const int auto9910E736_ae = 10;
    const int auto9910E736_ai = 1;
    const fixed auto28C26F1E_ae = 90.0;
    const fixed auto28C26F1E_ai = 2.5;
    const fixed auto49FA58AE_ae = 0.0;
    const fixed auto49FA58AE_ai = -3.0;

    // Variable Initialization
    lv_startingPoint = UnitGetPosition(EventUnit());
    lv_targetPoint = EventUnitTargetPoint();
    lv_xDistance = (PointGetX(lv_targetPoint) - PointGetX(lv_startingPoint));
    lv_yDistance = (PointGetY(lv_targetPoint) - PointGetY(lv_startingPoint));
    lv_zDistance = (-45.0 - WorldHeight(c_heightMapGround, UnitGetPosition(EventUnit())));
    lv_zOriginal = WorldHeight(c_heightMapGround, UnitGetPosition(EventUnit()));
    lv_kerriganOriginalUnit = EventUnit();

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

    autoA477DDF1_g = UnitGroupSelected(1);
    autoA477DDF1_u = UnitGroupCount(autoA477DDF1_g, c_unitCountAll);
    for (;; autoA477DDF1_u -= 1) {
        autoA477DDF1_var = UnitGroupUnitFromEnd(autoA477DDF1_g, autoA477DDF1_u);
        if (autoA477DDF1_var == null) { break; }
        if ((autoA477DDF1_var == lv_kerriganOriginalUnit)) {
            lv_kerriganSelected = true;
            libVCMI_gv_amonStrikeUnitSelected = false;
            TriggerEnable(libVCMI_gt_AmonStrikeSelectionCheck, true);
        }

    }
    UnitCreate(1, "KerriganEpilogue03StrikeAmon", c_unitCreateIgnorePlacement, UnitGetOwner(lv_kerriganOriginalUnit), UnitGetPosition(lv_kerriganOriginalUnit), UnitGetFacing(lv_kerriganOriginalUnit));
    libNtve_gf_ShowHideUnit(lv_kerriganOriginalUnit, false);
    lv_kerriganStrikeAmon = UnitLastCreated();
    UnitSetHeight(UnitLastCreated(), WorldHeight(c_heightMapGround, UnitGetPosition(EventUnit())), 0.0);
    libNtve_gf_SendActorMessageToUnit(lv_kerriganStrikeAmon, "Signal StrikeAmonStart");
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonStart", lv_kerriganStrikeAmon);
    libNtve_gf_MakeUnitFacePoint(lv_kerriganStrikeAmon, EventUnitTargetPoint(), 0.5);
    lv_amonTargetUnit = UnitGroupClosestToPoint(UnitGroup("KerriganEpilogue03StrikeAmonTarget", c_playerAny, RegionEntireMap(), UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32))), 0), EventUnitTargetPoint());
    lv_i = 1;
    for ( ; ( (auto9910E736_ai >= 0 && lv_i <= auto9910E736_ae) || (auto9910E736_ai < 0 && lv_i >= auto9910E736_ae) ) ; lv_i += auto9910E736_ai ) {
        UnitSetHeight(lv_kerriganStrikeAmon, ((1.0 * lv_i) + lv_zOriginal), 0.0625);
        Wait(0.0625, c_timeGame);
    }
    lv_zTotal = (45.0 + UnitGetHeight(lv_kerriganStrikeAmon));
    libNtve_gf_SendActorMessageToUnit(lv_kerriganStrikeAmon, "Signal StrikeAmonArcStart");
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonArcStart", lv_kerriganStrikeAmon);
    lv_r = 0.0;
    for ( ; ( (auto28C26F1E_ai >= 0 && lv_r <= auto28C26F1E_ae) || (auto28C26F1E_ai < 0 && lv_r >= auto28C26F1E_ae) ) ; lv_r += auto28C26F1E_ai ) {
        lv_xPartial = (Sin(lv_r) * lv_xDistance);
        lv_yPartial = (Sin(lv_r) * lv_yDistance);
        lv_zPartial = (Cos(lv_r) * lv_zTotal);
        UnitSetPosition(lv_kerriganStrikeAmon, Point((PointGetX(UnitGetPosition(lv_kerriganOriginalUnit)) + lv_xPartial), (PointGetY(UnitGetPosition(lv_kerriganOriginalUnit)) + lv_yPartial)), true);
        UnitSetHeight(lv_kerriganStrikeAmon, (-45.0 + (lv_zPartial + 0.0)), 0.0625);
        libNtve_gf_MakeUnitFacePoint(lv_kerriganStrikeAmon, UnitGetPosition(lv_amonTargetUnit), 0.0625);
        Wait(0.0625, c_timeGame);
    }
    libNtve_gf_SendActorMessageToUnit(lv_kerriganStrikeAmon, "Signal StrikeAmonArcArrive");
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonArcArrive", lv_kerriganStrikeAmon);
    libNtve_gf_MakeUnitFacePoint(lv_kerriganStrikeAmon, UnitGetPosition(lv_amonTargetUnit), 0.5);
    Wait(0.5, c_timeGame);
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonBeamHit0", lv_amonTargetUnit);
    Wait(1.0, c_timeGame);
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonBeamHit1", lv_amonTargetUnit);
    Wait(1.0, c_timeGame);
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonBeamHit2", lv_amonTargetUnit);
    Wait(1.0, c_timeGame);
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonBeamHit3", lv_amonTargetUnit);
    Wait(1.0, c_timeGame);
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonBeamHit4", lv_amonTargetUnit);
    Wait(0.5, c_timeGame);
    libNtve_gf_SendActorMessageToUnit(lv_kerriganStrikeAmon, "Signal StrikeAmonReturnStart");
    UnitCreateEffectUnit(lv_kerriganStrikeAmon, "StrikeAmonReturnStart", lv_kerriganStrikeAmon);
    lv_zTotal = (45.0 + WorldHeight(c_heightMapGround, UnitGetPosition(lv_kerriganOriginalUnit)));
    libNtve_gf_MakeUnitFacePoint(lv_kerriganStrikeAmon, lv_startingPoint, 1.0);
    lv_r = 90.0;
    for ( ; ( (auto49FA58AE_ai >= 0 && lv_r <= auto49FA58AE_ae) || (auto49FA58AE_ai < 0 && lv_r >= auto49FA58AE_ae) ) ; lv_r += auto49FA58AE_ai ) {
        lv_xPartial = (Sin(lv_r) * lv_xDistance);
        lv_yPartial = (Sin(lv_r) * lv_yDistance);
        lv_zPartial = (Cos(lv_r) * lv_zTotal);
        UnitSetPosition(lv_kerriganStrikeAmon, Point((PointGetX(UnitGetPosition(lv_kerriganOriginalUnit)) + lv_xPartial), (PointGetY(UnitGetPosition(lv_kerriganOriginalUnit)) + lv_yPartial)), true);
        UnitSetHeight(lv_kerriganStrikeAmon, (-45.0 + (lv_zPartial + 0.0)), 0.0625);
        Wait(0.0625, c_timeGame);
    }
    UnitSetFacing(lv_kerriganOriginalUnit, UnitGetFacing(lv_kerriganStrikeAmon), 0.0);
    UnitRemove(lv_kerriganStrikeAmon);
    libNtve_gf_ShowHideUnit(lv_kerriganOriginalUnit, true);
    UnitCreateEffectUnit(lv_kerriganOriginalUnit, "StrikeAmonReturnArrive", lv_kerriganOriginalUnit);
    if ((lv_kerriganSelected == true) && (libVCMI_gv_amonStrikeUnitSelected == false)) {
        UnitSelect(lv_kerriganOriginalUnit, UnitGetOwner(lv_kerriganOriginalUnit), true);
    }

    UnitBehaviorRemove(EventUnit(), "KerriganEpilogue03StrikeAmonDummyCasterStun", 1);
    TriggerEnable(libVCMI_gt_AmonStrikeSelectionCheck, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_StrikeAmon_Init () {
    libVCMI_gt_StrikeAmon = TriggerCreate("libVCMI_gt_StrikeAmon_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_StrikeAmon, null, AbilityCommand("KerriganEpilogue03StrikeAmon", 0), c_unitAbilStageExecute, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Amon Strike Selection Check
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_AmonStrikeSelectionCheck_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    libVCMI_gv_amonStrikeUnitSelected = true;
    TriggerEnable(TriggerGetCurrent(), false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_AmonStrikeSelectionCheck_Init () {
    libVCMI_gt_AmonStrikeSelectionCheck = TriggerCreate("libVCMI_gt_AmonStrikeSelectionCheck_Func");
    TriggerEnable(libVCMI_gt_AmonStrikeSelectionCheck, false);
    TriggerAddEventUnitSelected(libVCMI_gt_AmonStrikeSelectionCheck, null, 1, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Oracle Wormhole
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_OracleWormhole_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((PlayerType(UnitGetOwner(EventUnit())) != c_playerTypeUser))) {
            return false;
        }
    }

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

    UnitIssueOrder(EventUnit(), Order(AbilityCommand("stop", 0)), c_orderQueueReplace);
    AISetUnitScriptControlled(EventUnit(), false);
    AIRemoveUnitFromAnyWaves(EventUnit());
    AISetUnitSuicide(EventUnit(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_OracleWormhole_Init () {
    libVCMI_gt_OracleWormhole = TriggerCreate("libVCMI_gt_OracleWormhole_Func");
    TriggerAddEventUnitBehaviorChange(libVCMI_gt_OracleWormhole, null, "EnterWormhole", c_unitBehaviorChangeDeactivate);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_GameCheat_CreateDialog
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_GameCheat_CreateDialog_Func (bool testConds, bool runActions) {
    // Variable Declarations
    text lv_label;
    text lv_tooltip;

    // Automatic Variable Declarations
    const int auto4E6B6E6D_ae = 25;
    int auto4E6B6E6D_var;
    int auto7CE5AB5F_val;
    const int auto4C53ABEC_ae = 25;
    int auto4C53ABEC_var;
    int auto30B906DD_val;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    DialogCreate(libVCMI_gv_pM_GameCheat_DialogWidth, libVCMI_gv_pM_GameCheat_DialogHeight, c_anchorTopRight, 0, 50, true);
    libVCMI_gv_pM_GameCheat_Dialog = DialogLastCreated();
    DialogSetTitle(DialogLastCreated(), StringExternal("Param/Value/lib_VCMI_392837B9"));
    libNtve_gf_CreateDialogItemButton(libVCMI_gv_pM_GameCheat_Dialog, 40, 40, c_anchorTopRight, 0, 0, StringExternal("Param/Value/lib_VCMI_21C58550"), StringExternal("Param/Value/lib_VCMI_E5CED145"), "");
    libVCMI_gv_pM_GameCheat_Minimize = DialogControlLastCreated();
    auto4E6B6E6D_var = 0;
    for ( ; auto4E6B6E6D_var <= auto4E6B6E6D_ae; auto4E6B6E6D_var += 1 ) {
        if (((auto4E6B6E6D_var == (c_gameCheatCooldown)) || (auto4E6B6E6D_var == (c_gameCheatFastBuild)) || (auto4E6B6E6D_var == (c_gameCheatGod)) || (auto4E6B6E6D_var == (c_gameCheatShowmap)))) {
            libVCMI_gv_pM_GameCheat_ArrayIndex += 1;
            libNtve_gf_CreateDialogItemCheckBox(libVCMI_gv_pM_GameCheat_Dialog, 25, 25, c_anchorTopLeft, 50, ((libVCMI_gv_pM_GameCheat_ArrayIndex * 50) + 50), StringExternal("Param/Value/lib_VCMI_2974025E"), false);
            libVCMI_gv_pM_GameCheat_CheckBox[auto4E6B6E6D_var] = DialogControlLastCreated();
            if ((libVCMI_gv_pM_GameCheat_CheatState[auto4E6B6E6D_var] == true)) {
                libNtve_gf_SetDialogItemChecked(libVCMI_gv_pM_GameCheat_CheckBox[auto4E6B6E6D_var], true, PlayerGroupAll());
            }
            else {
                libNtve_gf_SetDialogItemChecked(libVCMI_gv_pM_GameCheat_CheckBox[auto4E6B6E6D_var], false, PlayerGroupAll());
            }
            auto7CE5AB5F_val = auto4E6B6E6D_var;
            if (auto7CE5AB5F_val == (c_gameCheatCooldown)) {
                lv_label = StringExternal("Param/Value/lib_VCMI_DCE0A764");
            }
            else if (auto7CE5AB5F_val == (c_gameCheatFastBuild)) {
                lv_label = StringExternal("Param/Value/lib_VCMI_3DD7FD94");
            }
            else if (auto7CE5AB5F_val == (c_gameCheatGod)) {
                lv_label = StringExternal("Param/Value/lib_VCMI_C010EED9");
            }
            else if (auto7CE5AB5F_val == (c_gameCheatShowmap)) {
                lv_label = StringExternal("Param/Value/lib_VCMI_81D737B5");
            }
            else {
            }
            libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), lv_label, PlayerGroupAll());
            libNtve_gf_CreateDialogItemLabel(libVCMI_gv_pM_GameCheat_Dialog, 200, 25, c_anchorTopLeft, 80, ((libVCMI_gv_pM_GameCheat_ArrayIndex * 50) + 55), lv_label, Color(100,100,100), false, 2.0);
        }

    }
    auto4C53ABEC_var = 0;
    for ( ; auto4C53ABEC_var <= auto4C53ABEC_ae; auto4C53ABEC_var += 1 ) {
        if (((auto4C53ABEC_var == (c_gameCheatGimme)) || (auto4C53ABEC_var == (c_gameCheatTechTree)))) {
            libVCMI_gv_pM_GameCheat_ArrayIndex += 1;
            auto30B906DD_val = auto4C53ABEC_var;
            if (auto30B906DD_val == (c_gameCheatGimme)) {
                lv_label = StringExternal("Param/Value/lib_VCMI_41DADEA5");
                lv_tooltip = StringExternal("Param/Value/lib_VCMI_46DF5396");
            }
            else if (auto30B906DD_val == (c_gameCheatTechTree)) {
                lv_label = StringExternal("Param/Value/lib_VCMI_3437D367");
                lv_tooltip = StringExternal("Param/Value/lib_VCMI_E7FED887");
            }
            else {
            }
            libNtve_gf_CreateDialogItemButton(libVCMI_gv_pM_GameCheat_Dialog, 200, 50, c_anchorTopLeft, 50, ((libVCMI_gv_pM_GameCheat_ArrayIndex * 50) + 50), lv_tooltip, lv_label, "");
            libVCMI_gv_pM_GameCheat_CheckBox[auto4C53ABEC_var] = DialogControlLastCreated();
        }

    }
    libVCMI_gv_pM_GameCheat_ArrayIndex += 1;
    libNtve_gf_CreateDialogItemButton(libVCMI_gv_pM_GameCheat_Dialog, 200, 50, c_anchorTopLeft, 50, ((libVCMI_gv_pM_GameCheat_ArrayIndex * 50) + 50), StringExternal("Param/Value/lib_VCMI_CBE06FD6"), StringExternal("Param/Value/lib_VCMI_52B3321E"), "");
    libVCMI_gv_pM_GameCheat_OpenMissionCheat = DialogControlLastCreated();
    if ((DialogGetHeight(libVCMI_gv_pM_GameCheat_Dialog) < ((libVCMI_gv_pM_GameCheat_ArrayIndex * 50) + 150))) {
        libVCMI_gv_pM_GameCheat_DialogHeight = ((libVCMI_gv_pM_GameCheat_ArrayIndex * 50) + 150);
        DialogSetSize(libVCMI_gv_pM_GameCheat_Dialog, libVCMI_gv_pM_GameCheat_DialogWidth, libVCMI_gv_pM_GameCheat_DialogHeight);
    }

    DialogSetVisible(DialogLastCreated(), PlayerGroupAll(), true);
    TriggerEnable(libVCMI_gt_PS_GameCheat_CheckboxUsed, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_GameCheat_CreateDialog_Init () {
    libVCMI_gt_PM_GameCheat_CreateDialog = TriggerCreate("libVCMI_gt_PM_GameCheat_CreateDialog_Func");
    TriggerAddEventChatMessage(libVCMI_gt_PM_GameCheat_CreateDialog, c_playerAny, "cheats", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_GameCheat_CheckboxUsed
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PS_GameCheat_CheckboxUsed_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    const int autoF1D87FF8_ae = 25;
    int autoF1D87FF8_var;
    int autoF189DDA6_val;

    // Conditions
    if (testConds) {
        if (!((EventPlayer() == 1))) {
            return false;
        }

        if (!((DialogControlGetDialog(EventDialogControl()) == libVCMI_gv_pM_GameCheat_Dialog))) {
            return false;
        }
    }

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

    if ((libVCMI_gv_pM_GameCheat_Minimize == EventDialogControl())) {
        if ((libVCMI_gv_pM_GameCheat_Minimized == false)) {
            DialogSetSize(libVCMI_gv_pM_GameCheat_Dialog, 50, 50);
            libNtve_gf_SetDialogItemText(libVCMI_gv_pM_GameCheat_Minimize, StringExternal("Param/Value/lib_VCMI_507ED1DB"), PlayerGroupAll());
            libNtve_gf_SetDialogItemTooltip(libVCMI_gv_pM_GameCheat_Minimize, StringExternal("Param/Value/lib_VCMI_4966D256"), PlayerGroupAll());
        }
        else {
            DialogSetSize(libVCMI_gv_pM_GameCheat_Dialog, libVCMI_gv_pM_GameCheat_DialogWidth, libVCMI_gv_pM_GameCheat_DialogHeight);
            libNtve_gf_SetDialogItemText(libVCMI_gv_pM_GameCheat_Minimize, StringExternal("Param/Value/lib_VCMI_B98D5E73"), PlayerGroupAll());
            libNtve_gf_SetDialogItemTooltip(libVCMI_gv_pM_GameCheat_Minimize, StringExternal("Param/Value/lib_VCMI_90FAD008"), PlayerGroupAll());
        }
        libVCMI_gv_pM_GameCheat_Minimized = !(libVCMI_gv_pM_GameCheat_Minimized);
        return true;
    }

    if ((libVCMI_gv_pM_GameCheat_OpenMissionCheat == EventDialogControl())) {
        if ((libVCMI_gv_pM_MissionCheat_Dialog == c_invalidDialogId)) {
            TriggerExecute(libVCMI_gt_PM_MissionCheat_CreateDialog, true, false);
        }

        return true;
    }

    autoF1D87FF8_var = 0;
    for ( ; autoF1D87FF8_var <= autoF1D87FF8_ae; autoF1D87FF8_var += 1 ) {
        if ((libVCMI_gv_pM_GameCheat_CheckBox[autoF1D87FF8_var] == EventDialogControl())) {
            autoF189DDA6_val = autoF1D87FF8_var;
            if (autoF189DDA6_val == (c_gameCheatCooldown)) {
                ConsoleCommand("cd", true, true);
            }
            else if (autoF189DDA6_val == (c_gameCheatFastBuild)) {
                ConsoleCommand("fb", true, true);
            }
            else if (autoF189DDA6_val == (c_gameCheatGod)) {
                ConsoleCommand("god 1", true, true);
            }
            else if (autoF189DDA6_val == (c_gameCheatShowmap)) {
                ConsoleCommand("sm", true, true);
            }
            else if (autoF189DDA6_val == (c_gameCheatGimme)) {
                ConsoleCommand("gimme", true, true);
            }
            else if (autoF189DDA6_val == (c_gameCheatTechTree)) {
                ConsoleCommand("tt", true, true);
                DialogControlSetEnabled(libVCMI_gv_pM_GameCheat_CheckBox[autoF1D87FF8_var], PlayerGroupAll(), false);
                libNtve_gf_SetDialogItemTooltip(libVCMI_gv_pM_GameCheat_CheckBox[autoF1D87FF8_var], StringExternal("Param/Value/lib_VCMI_CDEC4192"), PlayerGroupAll());
            }
            else {
            }
            break;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PS_GameCheat_CheckboxUsed_Init () {
    libVCMI_gt_PS_GameCheat_CheckboxUsed = TriggerCreate("libVCMI_gt_PS_GameCheat_CheckboxUsed_Func");
    TriggerEnable(libVCMI_gt_PS_GameCheat_CheckboxUsed, false);
    TriggerAddEventDialogControl(libVCMI_gt_PS_GameCheat_CheckboxUsed, 1, c_invalidDialogControlId, c_triggerControlEventTypeClick);
    TriggerAddEventDialogControl(libVCMI_gt_PS_GameCheat_CheckboxUsed, 1, c_invalidDialogControlId, c_triggerControlEventTypeChecked);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_GameCheat_CheatUsed
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PS_GameCheat_CheatUsed_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    const int auto731EB4A6_ae = 25;
    int auto731EB4A6_var;

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

    auto731EB4A6_var = 0;
    for ( ; auto731EB4A6_var <= auto731EB4A6_ae; auto731EB4A6_var += 1 ) {
        if ((auto731EB4A6_var == (EventCheatUsed()))) {
            TriggerEnable(libVCMI_gt_PS_GameCheat_CheckboxUsed, false);
            libVCMI_gv_pM_GameCheat_CheatState[auto731EB4A6_var] = !(libVCMI_gv_pM_GameCheat_CheatState[auto731EB4A6_var]);
            if ((libVCMI_gv_pM_GameCheat_Dialog != c_invalidDialogId) && (DialogIsVisible(libVCMI_gv_pM_GameCheat_Dialog, 1) == true)) {
                if ((libVCMI_gv_pM_GameCheat_CheatState[auto731EB4A6_var] == true)) {
                    libNtve_gf_SetDialogItemChecked(libVCMI_gv_pM_GameCheat_CheckBox[auto731EB4A6_var], true, PlayerGroupSingle(1));
                }
                else {
                    libNtve_gf_SetDialogItemChecked(libVCMI_gv_pM_GameCheat_CheckBox[auto731EB4A6_var], false, PlayerGroupSingle(1));
                }
            }

            Wait(0.1, c_timeGame);
            TriggerEnable(libVCMI_gt_PS_GameCheat_CheckboxUsed, true);
            return true;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PS_GameCheat_CheatUsed_Init () {
    libVCMI_gt_PS_GameCheat_CheatUsed = TriggerCreate("libVCMI_gt_PS_GameCheat_CheatUsed_Func");
    TriggerAddEventCheatUsed(libVCMI_gt_PS_GameCheat_CheatUsed, c_playerAny, c_gameCheatAny);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionCheat_CreateDialog
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionCheat_CreateDialog_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_buttonWidth;
    int lv_buttonHeight;
    string lv_boarderImage;
    string lv_buttonImage;
    string lv_buttonImageHover;
    string lv_buttonTextStyle;
    string lv_editBoxTextStyle;
    string lv_closeButtonTextStyle;
    int lv_RelativeAnchor;
    int lv_RelativeAnchor2;
    int lv_panelCount;
    int[libVCMI_gv_pMC_MissionCheat_PanelCountMAX + 1] lv_itemsInPanel;
    int lv_cheatUIHeight;
    int lv_panelIndex;
    int lv_cheatIndex;

    // Automatic Variable Declarations
    int auto487E3D4B_ae;
    const int auto487E3D4B_ai = 1;
    int auto4960B2E2_ae;
    const int auto4960B2E2_ai = 1;
    const int auto29FEF9E8_ae = libVCMI_gv_pMC_MissionCheat_PanelCountMAX;
    const int auto29FEF9E8_ai = 1;

    // Variable Initialization
    lv_buttonWidth = 200;
    lv_buttonHeight = 40;
    lv_boarderImage = "Assets\\Textures\\ui_ingame_subpanel2.dds";
    lv_buttonImage = "Assets\\Textures\\ui_button_generic_normaloverpressedover_protoss.dds";
    lv_buttonImageHover = "Assets\\Textures\\ui_battlenet_settings_dropdownbutton_normaloverpressedover.dds";
    lv_buttonTextStyle = "ModCenterSize16";
    lv_editBoxTextStyle = "ModLeftSize12";
    lv_closeButtonTextStyle = "ModCenterSize16Bold";
    lv_RelativeAnchor = c_anchorTopLeft;
    lv_RelativeAnchor2 = c_anchorTopLeft;

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gf_PM_MissionCheat_ButtonTextInit();
    while (!((libVCMI_gf_GameIsOver() == false) && (libNtve_gf_PlayerInCinematicMode(1) == false))) {
        Wait(0.2, c_timeGame);
    }
    DialogCreate(20, 20, c_anchorTopRight, 5, 60, true);
    libVCMI_gv_pM_MissionCheat_Dialog = DialogLastCreated();
    DialogSetImage(libVCMI_gv_pM_MissionCheat_Dialog, lv_boarderImage);
    auto487E3D4B_ae = ((libVCMI_ge_MissionCheatType_User02) - 1);
    lv_panelIndex = 1;
    for ( ; ( (auto487E3D4B_ai >= 0 && lv_panelIndex <= auto487E3D4B_ae) || (auto487E3D4B_ai < 0 && lv_panelIndex >= auto487E3D4B_ae) ) ; lv_panelIndex += auto487E3D4B_ai ) {
        if ((libVCMI_gv_pM_MissionCheat_CategoryUsed[lv_panelIndex] == true)) {
            DialogControlCreate(libVCMI_gv_pM_MissionCheat_Dialog, c_triggerControlTypePanel);
            libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex] = DialogControlLastCreated();
            lv_panelCount += 1;
        }

    }
    auto4960B2E2_ae = libVCMI_gv_pM_MissionCheat_ArrayCount;
    lv_cheatIndex = 1;
    for ( ; ( (auto4960B2E2_ai >= 0 && lv_cheatIndex <= auto4960B2E2_ae) || (auto4960B2E2_ai < 0 && lv_cheatIndex >= auto4960B2E2_ae) ) ; lv_cheatIndex += auto4960B2E2_ai ) {
        lv_itemsInPanel[(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_cheatType)] += 1;
        DialogControlCreateInPanel(libVCMI_gv_pM_MissionCheat_Panel[(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_cheatType)], c_triggerControlTypeButton);
        libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_buttonDialog = DialogControlLastCreated();
        libNtve_gf_SetDialogItemText(DialogControlLastCreated(), libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_titleText, PlayerGroupAll());
        libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), lv_buttonTextStyle, PlayerGroupAll());
        libNtve_gf_SetDialogItemTooltip(DialogControlLastCreated(), libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_description, PlayerGroupAll());
        DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), lv_buttonWidth, lv_buttonHeight);
        DialogControlSetPositionRelative(DialogControlLastCreated(), PlayerGroupAll(), lv_RelativeAnchor2, libVCMI_gv_pM_MissionCheat_Panel[(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_cheatType)], lv_RelativeAnchor, 0, (( (lv_itemsInPanel[(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_cheatType)] - 1) * lv_buttonHeight ) + 2));
        if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_uIType == libVCMI_ge_MissionCheatUIType_ButtonEditBoxCombo)) {
            DialogControlCreateInPanel(libVCMI_gv_pM_MissionCheat_Panel[(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_cheatType)], c_triggerControlTypeEditBox);
            libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), lv_editBoxTextStyle, PlayerGroupAll());
            libNtve_gf_SetDialogItemTintColor(DialogControlLastCreated(), Color(149*100/255,150*100/255,151*100/255), PlayerGroupAll());
            libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_editBoxDialog = DialogControlLastCreated();
            DialogControlSetSize(DialogControlLastCreated(), PlayerGroupAll(), ((lv_buttonWidth * 1) / 3), lv_buttonHeight);
            DialogControlSetPositionRelative(DialogControlLastCreated(), PlayerGroupAll(), c_anchorTopLeft, libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_buttonDialog, c_anchorTopRight, 0, 0);
            DialogControlSetSize(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_buttonDialog, PlayerGroupAll(), ((lv_buttonWidth * 2) / 3), lv_buttonHeight);
            libNtve_gf_SetDialogItemEditorValue(libVCMI_gv_pM_MissionCheat_Cheats[lv_cheatIndex].lv_editBoxDialog, "0", PlayerGroupAll());
        }

    }
    DialogControlSetPosition(libVCMI_gv_pM_MissionCheat_Panel[(libVCMI_ge_MissionCheatType_Stage)], PlayerGroupAll(), c_anchorTopLeft, 3, 3);
    DialogControlSetSize(libVCMI_gv_pM_MissionCheat_Panel[(libVCMI_ge_MissionCheatType_Stage)], PlayerGroupAll(), (lv_buttonWidth + 6), (( lv_itemsInPanel[(libVCMI_ge_MissionCheatType_Stage)] * lv_buttonHeight ) + 20));
    lv_panelIndex = 1;
    for ( ; ( (auto29FEF9E8_ai >= 0 && lv_panelIndex <= auto29FEF9E8_ae) || (auto29FEF9E8_ai < 0 && lv_panelIndex >= auto29FEF9E8_ae) ) ; lv_panelIndex += auto29FEF9E8_ai ) {
        if ((lv_panelIndex > 1) && (libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex] != c_invalidDialogControlId)) {
            DialogControlSetPositionRelative(libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex], PlayerGroupAll(), c_anchorTopLeft, libVCMI_gv_pM_MissionCheat_Panel[(lv_panelIndex - 1)], c_anchorBottomLeft, 0, 0);
            DialogControlSetSize(libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex], PlayerGroupAll(), (lv_buttonWidth + 6), (( lv_itemsInPanel[lv_panelIndex] * lv_buttonHeight ) + 20));
        }

        if ((libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex] != c_invalidDialogControlId) && (DialogGetWidth(libVCMI_gv_pM_MissionCheat_Dialog) < DialogControlGetWidth(libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex], 1))) {
            DialogSetSize(libVCMI_gv_pM_MissionCheat_Dialog, (DialogControlGetWidth(libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex], 1) + 0), DialogGetHeight(libVCMI_gv_pM_MissionCheat_Dialog));
        }

        if ((libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex] != c_invalidDialogControlId)) {
            lv_cheatUIHeight += DialogControlGetHeight(libVCMI_gv_pM_MissionCheat_Panel[lv_panelIndex], 1);
        }

    }
    DialogSetSize(libVCMI_gv_pM_MissionCheat_Dialog, DialogGetWidth(libVCMI_gv_pM_MissionCheat_Dialog), (lv_cheatUIHeight + 75));
    libNtve_gf_CreateDialogItemButton(libVCMI_gv_pM_MissionCheat_Dialog, (( lv_buttonWidth * 3 ) / 4), lv_buttonHeight, c_anchorBottomRight, 3, 3, StringToText(""), StringExternal("Param/Value/lib_VCMI_619B3399"), "");
    libNtve_gf_SetDialogItemStyle(DialogControlLastCreated(), lv_closeButtonTextStyle, PlayerGroupAll());
    libVCMI_gv_pM_MissionCheat_CloseButton = DialogControlLastCreated();
    libVCMI_gf_PM_MissionCheat_UpdateButtonEnabled();
    DialogSetVisible(libVCMI_gv_pM_MissionCheat_Dialog, PlayerGroupAll(), true);
    while (!((libVCMI_gv_pM_MissionCheat_CloseButtonClicked == true))) {
        Wait(0.1, c_timeReal);
    }
    DialogDestroy(libVCMI_gv_pM_MissionCheat_Dialog);
    libVCMI_gv_pM_MissionCheat_Dialog = c_invalidDialogId;
    libVCMI_gv_pM_MissionCheat_CloseButtonClicked = false;
    TriggerEnable(TriggerGetCurrent(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionCheat_CreateDialog_Init () {
    libVCMI_gt_PM_MissionCheat_CreateDialog = TriggerCreate("libVCMI_gt_PM_MissionCheat_CreateDialog_Func");
    TriggerAddEventChatMessage(libVCMI_gt_PM_MissionCheat_CreateDialog, c_playerAny, "mcheats", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionCheat_ButtonClicked
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionCheat_ButtonClicked_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_dialogIndex;
    string lv_editBoxValue;

    // Automatic Variable Declarations
    int auto69405232_ae;
    const int auto69405232_ai = 1;

    // Variable Initialization
    lv_editBoxValue = "";

    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }

        if (!((libVCMI_gv_pM_MissionCheat_Dialog != c_invalidDialogId))) {
            return false;
        }

        if (!((DialogControlGetDialog(EventDialogControl()) == libVCMI_gv_pM_MissionCheat_Dialog))) {
            return false;
        }
    }

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

    auto69405232_ae = libVCMI_gv_pM_MissionCheat_ArrayCount;
    lv_dialogIndex = 1;
    for ( ; ( (auto69405232_ai >= 0 && lv_dialogIndex <= auto69405232_ae) || (auto69405232_ai < 0 && lv_dialogIndex >= auto69405232_ae) ) ; lv_dialogIndex += auto69405232_ai ) {
        if ((EventDialogControl() == libVCMI_gv_pM_MissionCheat_Cheats[lv_dialogIndex].lv_buttonDialog)) {
            if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_dialogIndex].lv_uIType == libVCMI_ge_MissionCheatUIType_ButtonEditBoxCombo)) {
                lv_editBoxValue = libNtve_gf_DialogItemEditValue(libVCMI_gv_pM_MissionCheat_Cheats[lv_dialogIndex].lv_editBoxDialog, 1);
                if ((lv_editBoxValue != "")) {
                    DataTableSetString(true, ("PS_" + TriggerGetFunction(libVCMI_gv_pM_MissionCheat_Cheats[lv_dialogIndex].lv_trigger)), lv_editBoxValue);
                }

            }

            TriggerExecute(libVCMI_gv_pM_MissionCheat_Cheats[lv_dialogIndex].lv_trigger, true, false);
            libVCMI_gf_PM_MissionCheat_UpdateButtonEnabled();
            return true;
        }

    }
    if ((EventDialogControl() == libVCMI_gv_pM_MissionCheat_CloseButton)) {
        libVCMI_gv_pM_MissionCheat_CloseButtonClicked = true;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionCheat_ButtonClicked_Init () {
    libVCMI_gt_PM_MissionCheat_ButtonClicked = TriggerCreate("libVCMI_gt_PM_MissionCheat_ButtonClicked_Func");
    TriggerAddEventDialogControl(libVCMI_gt_PM_MissionCheat_ButtonClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionCheat_CheatEntered
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionCheat_CheatEntered_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_iter;
    string lv_cheatParameter;

    // Automatic Variable Declarations
    const int autoB629ABE7_ae = libVCMI_gv_pMC_MissionCheat_MaxCheats;
    const int autoB629ABE7_ai = 1;

    // Variable Initialization
    lv_cheatParameter = "";

    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    lv_iter = 1;
    for ( ; ( (autoB629ABE7_ai >= 0 && lv_iter <= autoB629ABE7_ae) || (autoB629ABE7_ai < 0 && lv_iter >= autoB629ABE7_ae) ) ; lv_iter += autoB629ABE7_ai ) {
        if ((StringCase(libVCMI_gv_pM_MissionCheat_Cheats[lv_iter].lv_titleString, false) == StringCase(StringWord(EventChatMessage(false), 1), false))) {
            if ((libVCMI_gv_pM_MissionCheat_Cheats[lv_iter].lv_uIType == libVCMI_ge_MissionCheatUIType_ButtonEditBoxCombo)) {
                DataTableSetString(true, ("PS_" + TriggerGetFunction(libVCMI_gv_pM_MissionCheat_Cheats[lv_iter].lv_trigger)), StringWord(EventChatMessage(false), 2));
            }

            TriggerExecute(libVCMI_gv_pM_MissionCheat_Cheats[lv_iter].lv_trigger, true, false);
            libVCMI_gf_PM_MissionCheat_UpdateButtonEnabled();
            return true;
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionCheat_CheatEntered_Init () {
    libVCMI_gt_PM_MissionCheat_CheatEntered = TriggerCreate("libVCMI_gt_PM_MissionCheat_CheatEntered_Func");
    TriggerAddEventChatMessage(libVCMI_gt_PM_MissionCheat_CheatEntered, c_playerAny, "", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_DebugVictoryS
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_DebugVictoryS_Func (bool testConds, bool runActions) {
    // Variable Declarations
    trigger lv_cineTrigger;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerQueueClear(c_triggerQueueKill);
    TransmissionClearAll();
    libVCMI_gf_HideCampaignTransmissionPortrait();
    libVCMI_gv_pM_MissionVictoryActionQueyeEmpty = false;
    TriggerExecute(libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute, true, false);
    while (!((libVCMI_gv_pM_MissionVictoryActionQueyeEmpty == true))) {
        Wait(1.0, c_timeGame);
    }
    TriggerQueueClear(c_triggerQueueKill);
    lv_cineTrigger = TriggerCreate("gt_VictorySequence_Func");
    TriggerExecute(lv_cineTrigger, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_DebugVictoryS_Init () {
    libVCMI_gt_PM_DebugVictoryS = TriggerCreate("libVCMI_gt_PM_DebugVictoryS_Func");
    TriggerAddEventChatMessage(libVCMI_gt_PM_DebugVictoryS, c_playerAny, "VICTORYS", true);
    TriggerAddEventChatMessage(libVCMI_gt_PM_DebugVictoryS, c_playerAny, "VICTORYSEQUENCE", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_ToggleFlyoverMode
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_ToggleFlyoverMode_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    if ((libVCMI_gv_pM_FlyoverModeEnabled == false)) {
        libNtve_gf_CreateUnitsWithDefaultFacing(1, "FlyoverUnit", 0, 1, RegionGetCenter(RegionEntireMap()));
        libVCMI_gv_pM_FlyoverUnit = UnitLastCreated();
        UnitGroupSelect(UnitGroupSelected(1), 1, false);
        UnitSelect(libVCMI_gv_pM_FlyoverUnit, 1, true);
        libNtve_gf_HideGameUI(false, PlayerGroupAll());
        UISetDragSelectEnabled(PlayerGroupAll(), false);
        UISetSelectionTypeEnabled(PlayerGroupAll(), c_localSelectionTypeUnknown, false);
        CameraFollowUnitGroup(1, UnitLastCreatedGroup(), true, false);
        CameraForceFollowUnitGroup(1, true);
        CameraLockInput(1, true);
        AITimePause(true);
        ConsoleCommand("togui", true, true);
        libVCMI_gv_pM_FlyoverModeEnabled = true;
        TriggerEnable(libVCMI_gt_PM_TurnOffFlyoverMode, true);
    }
    else {
        UISetDragSelectEnabled(PlayerGroupAll(), true);
        UISetSelectionTypeEnabled(PlayerGroupAll(), c_localSelectionTypeUnknown, true);
        UnitKill(libVCMI_gv_pM_FlyoverUnit);
        CameraLockInput(1, false);
        AITimePause(false);
        ConsoleCommand("togui", true, true);
        libNtve_gf_HideGameUI(true, PlayerGroupAll());
        libVCMI_gv_pM_FlyoverUnit = null;
        libVCMI_gv_pM_FlyoverModeEnabled = false;
        TriggerEnable(libVCMI_gt_PM_TurnOffFlyoverMode, false);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_ToggleFlyoverMode_Init () {
    libVCMI_gt_PM_ToggleFlyoverMode = TriggerCreate("libVCMI_gt_PM_ToggleFlyoverMode_Func");
    TriggerAddEventChatMessage(libVCMI_gt_PM_ToggleFlyoverMode, c_playerAny, "FlyoverMode", true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_TurnOffFlyoverMode
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_TurnOffFlyoverMode_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    TriggerExecute(libVCMI_gt_PM_ToggleFlyoverMode, true, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_TurnOffFlyoverMode_Init () {
    libVCMI_gt_PM_TurnOffFlyoverMode = TriggerCreate("libVCMI_gt_PM_TurnOffFlyoverMode_Func");
    TriggerEnable(libVCMI_gt_PM_TurnOffFlyoverMode, false);
    TriggerAddEventKeyPressed(libVCMI_gt_PM_TurnOffFlyoverMode, c_playerAny, c_keyB, true, c_keyModifierStateIgnore, c_keyModifierStateIgnore, c_keyModifierStateIgnore);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_DebugSetSoAEnergy
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_DebugSetSoAEnergy_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((GameCheatsEnabled(c_gameCheatCategoryDevelopment) == true))) {
            return false;
        }
    }

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

    libVCMI_gf_SetSpearofAdunEnergy(StringToFixed(StringWord(EventChatMessage(false), 2)), libVCMI_ge_SpearofAdunEnergyType_Percent);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_DebugSetSoAEnergy_Init () {
    libVCMI_gt_PM_DebugSetSoAEnergy = TriggerCreate("libVCMI_gt_PM_DebugSetSoAEnergy_Func");
    TriggerAddEventChatMessage(libVCMI_gt_PM_DebugSetSoAEnergy, c_playerAny, "-soaenergy", false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionVictoryCallbackBlockActionQueueOneMinute
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    libVCMI_gv_pM_MissionVictoryActionQueyeEmpty = true;
    Wait(60.0, c_timeReal);
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute_Init () {
    libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute = TriggerCreate("libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionVictoryCallbackBlockActionQueue
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueue_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerQueueEnter();
    libVCMI_gv_pM_MissionVictoryActionQueyeEmpty = true;
    while (true) {
        Wait(10.0, c_timeReal);
    }
    TriggerQueueExit();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueue_Init () {
    libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueue = TriggerCreate("libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueue_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_Abort Mission
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_AbortMission_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_indexUnit;

    // Automatic Variable Declarations
    unitgroup auto5DDB9E2A_g;
    int auto5DDB9E2A_u;

    // Variable Initialization

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

    if (((libVoiC_gf_CurrentMap() == "PAiur06") || (libVoiC_gf_CurrentMap() == "SC2Epilogue03")) && (libVoiC_gv_pCX_IsVictoryPlayAgain == true) && (libVoiC_gv_pCX_IsSimulation == false)) {
        libVCMI_gf_GameOver(libVCMI_ge_CampaignMissionGameResultType_Victory);
        TransmissionClearAll();
        UnitPauseAll(true);
        auto5DDB9E2A_g = UnitGroup(null, c_playerAny, RegionEntireMap(), UnitFilter(0, 0, 0, (1 << (c_targetFilterHidden - 32))), 0);
        auto5DDB9E2A_u = UnitGroupCount(auto5DDB9E2A_g, c_unitCountAll);
        for (;; auto5DDB9E2A_u -= 1) {
            lv_indexUnit = UnitGroupUnitFromEnd(auto5DDB9E2A_g, auto5DDB9E2A_u);
            if (lv_indexUnit == null) { break; }
            libNtve_gf_MakeUnitInvulnerable(lv_indexUnit, true);
            libNtve_gf_ShowHideUnit(lv_indexUnit, false);
        }
        UISetWorldVisible(PlayerGroupAll(), false);
        libNtve_gf_HideGameUI(false, PlayerGroupAll());
        UISetFrameVisible(PlayerGroupAll(), c_syncFrameTypeBattleUI, true);
        UIClearMessages(PlayerGroupAll(), c_messageAreaAll);
        if ((libVoiC_gf_CurrentMap() == "PAiur06")) {
            libVCUI_gf_ShowSpearofAdunUI(false, c_transitionDurationImmediate);
        }

        TransmissionClearAll();
        ConversationDataStop();
        libNtve_gf_SendActorMessageToGameRegion(RegionEntireMap(), "SetVisibility");
        libNtve_gf_HideAllCinematicPortraits(PlayerGroupAll());
        TriggerQueueClear(c_triggerQueueRetain);
        TriggerQueuePause(true);
        SoundStopAllTriggerSounds(false);
        if ((libVoiC_gf_PC_CampaignInEpilogue() == true)) {
            libVCMI_gf_PU_CampaignVictory();
        }
        else {
            libVCMI_gf_PU_CampaignVictory2();
        }
    }
    else {
        libVoiC_gf_PrepareForStoryMode(c_gameOverDefeat, PlayerDifficulty(1));
        GameOver(1, c_gameOverDefeat, false, false);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_AbortMission_Init () {
    libVCMI_gt_PM_AbortMission = TriggerCreate("libVCMI_gt_PM_AbortMission_Func");
    TriggerAddEventAbortMission(libVCMI_gt_PM_AbortMission, c_playerAny);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionEndsPlayerExit
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionEndsPlayerExit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_MissionEndStats(c_gameOverDefeat);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionEndsPlayerExit_Init () {
    libVCMI_gt_PM_MissionEndsPlayerExit = TriggerCreate("libVCMI_gt_PM_MissionEndsPlayerExit_Func");
    TriggerAddEventPlayerLeft(libVCMI_gt_PM_MissionEndsPlayerExit, c_playerAny, c_gameResultUndecided);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_VictoryContinue
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_VictoryContinue_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_nextMap;

    // Automatic Variable Declarations
    string auto4EEECEDA_val;

    // Variable Initialization

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

    if ((libVoiC_gf_CurrentMap() == "PAiur06")) {
        libVCMI_gf_PU_CampaignVictory2();
        return true;
    }

    if ((libVoiC_gf_CurrentMap() == "SC2Epilogue03")) {
        UISetCursorVisible(PlayerGroupAll(), false);
        libVCMI_gf_PU_CampaignVictory();
        return true;
    }

    if ((libVoiC_gv_pCX_IsSimulation == true)) {
        GameOver(1, c_gameOverVictory, false, false);
        return true;
    }

    lv_nextMap = libVoiC_gf_PostMissionStoryMap(libVoiC_gf_CurrentMap(), libVoiC_gv_pCX_IsSimulation, c_gameOverVictory, true);
    if ((lv_nextMap == "PStory01")) {
        GameOver(1, c_gameOverVictory, false, false);
        return true;
    }

    libVoiC_gf_RegisterCampaignEvent(libVoiC_ge_PC_Event_UIMissionLaunch, libVCMI_gt_PM_VictoryNextMissionLaunched);
    libVoiC_gf_RegisterCampaignEvent(libVoiC_ge_PC_Event_UIMissionQuit, libVCMI_gt_PM_VictoryQuit);
    libVoiC_gf_CinematicFade(true, 0.0, Color(0.00, 0.00, 0.00), true);
    UISetCursorVisible(PlayerGroupAll(), false);
    auto4EEECEDA_val = libVoiC_gf_CurrentMap();
    if (auto4EEECEDA_val == "PAiur01") {
        libVoiC_gf_PlayCinematic("Aiur01Debrief", false);
    }
    else if (auto4EEECEDA_val == "PAiur02") {
        libVoiC_gf_PlayCinematic("Aiur02Debrief", false);
    }
    else if (auto4EEECEDA_val == "SC2Epilogue01") {
        PlayerSetRace(1, "Terr");
        Wait(0.1, c_timeGame);
    }
    else {
    }
    UISetCursorVisible(PlayerGroupAll(), true);
    libNtve_gf_StoryMode(PlayerGroupAll(), true);
    libVCUI_gf_PU_MissionDisplay(lv_nextMap);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_VictoryContinue_Init () {
    libVCMI_gt_PM_VictoryContinue = TriggerCreate("libVCMI_gt_PM_VictoryContinue_Func");
    libVCUI_gf_PU_VictoryClosed(libVCMI_gt_PM_VictoryContinue);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_VictoryNextMissionLaunched
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_VictoryNextMissionLaunched_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCST_gf_ShowHideStoryUI(false);
    libVoiC_gf_CinematicFade(false, 0.7, Color(0.00, 0.00, 0.00), true);
    libVoiC_gf_LaunchMission(libVCUI_gv_pU_MissionNextMap, false, libVCUI_gf_PU_MissionSelectedDifficulty());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_VictoryNextMissionLaunched_Init () {
    libVCMI_gt_PM_VictoryNextMissionLaunched = TriggerCreate("libVCMI_gt_PM_VictoryNextMissionLaunched_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_VictoryQuit
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_VictoryQuit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    GameSetNextMap("");
    GameOver(1, c_gameOverVictory, false, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_VictoryQuit_Init () {
    libVCMI_gt_PM_VictoryQuit = TriggerCreate("libVCMI_gt_PM_VictoryQuit_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_VictoryTravelLaunched
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_VictoryTravelLaunched_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVoiC_gf_PC_SetLocationActive(libVCUI_gf_PU_StarmapLaunchLocation());
    libVoiC_gf_PS_UpdatePlanetData();
    libVoiC_gf_PrepareForStoryMode(c_gameOverVictory, libVoiC_gv_pCX_CampaignDifficulty);
    GameOver(1, c_gameOverVictory, false, false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_VictoryTravelLaunched_Init () {
    libVCMI_gt_PM_VictoryTravelLaunched = TriggerCreate("libVCMI_gt_PM_VictoryTravelLaunched_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HeroReviveKerriganCooldownWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HeroReviveKerriganCooldownWait_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((PlayerGetCooldown(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)], libVCMI_gv_pM_HeroReviveCDLink[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)]) == 0.0))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gf_PM_HeroRevive(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan);
    if ((libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)] == 1)) {
        libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_C597D3C9"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HeroReviveKerriganCooldownWait_Init () {
    libVCMI_gt_PM_HeroReviveKerriganCooldownWait = TriggerCreate("libVCMI_gt_PM_HeroReviveKerriganCooldownWait_Func");
    TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganCooldownWait, false);
    TriggerAddEventTimePeriodic(libVCMI_gt_PM_HeroReviveKerriganCooldownWait, 1.0, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HeroReviveStukovCooldownWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HeroReviveStukovCooldownWait_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((PlayerGetCooldown(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Stukov)], libVCMI_gv_pM_HeroReviveCDLink[(libVCMI_ge_PM_HeroType_PM_HeroType_Stukov)]) == 0.0))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gf_PM_HeroRevive(libVCMI_ge_PM_HeroType_PM_HeroType_Stukov);
    if ((libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Stukov)] == 1)) {
        libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_5EBE0A4D"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HeroReviveStukovCooldownWait_Init () {
    libVCMI_gt_PM_HeroReviveStukovCooldownWait = TriggerCreate("libVCMI_gt_PM_HeroReviveStukovCooldownWait_Func");
    TriggerEnable(libVCMI_gt_PM_HeroReviveStukovCooldownWait, false);
    TriggerAddEventTimePeriodic(libVCMI_gt_PM_HeroReviveStukovCooldownWait, 1.0, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HeroReviveZagaraCooldownWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HeroReviveZagaraCooldownWait_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((PlayerGetCooldown(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Zagara)], libVCMI_gv_pM_HeroReviveCDLink[(libVCMI_ge_PM_HeroType_PM_HeroType_Zagara)]) == 0.0))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gf_PM_HeroRevive(libVCMI_ge_PM_HeroType_PM_HeroType_Zagara);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HeroReviveZagaraCooldownWait_Init () {
    libVCMI_gt_PM_HeroReviveZagaraCooldownWait = TriggerCreate("libVCMI_gt_PM_HeroReviveZagaraCooldownWait_Func");
    TriggerEnable(libVCMI_gt_PM_HeroReviveZagaraCooldownWait, false);
    TriggerAddEventTimePeriodic(libVCMI_gt_PM_HeroReviveZagaraCooldownWait, 1.0, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HeroReviveFenixCooldownWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HeroReviveFenixCooldownWait_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((PlayerGetCooldown(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Fenix)], libVCMI_gv_pM_HeroReviveCDLink[(libVCMI_ge_PM_HeroType_PM_HeroType_Fenix)]) == 0.0))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gf_PM_HeroRevive(libVCMI_ge_PM_HeroType_PM_HeroType_Fenix);
    if ((libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Fenix)] == 1)) {
        libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_A4A10BFE"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HeroReviveFenixCooldownWait_Init () {
    libVCMI_gt_PM_HeroReviveFenixCooldownWait = TriggerCreate("libVCMI_gt_PM_HeroReviveFenixCooldownWait_Func");
    TriggerEnable(libVCMI_gt_PM_HeroReviveFenixCooldownWait, false);
    TriggerAddEventTimePeriodic(libVCMI_gt_PM_HeroReviveFenixCooldownWait, 1.0, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HeroReviveKerriganXelNagaCooldownWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_heroIndex;
    unit lv_closestHatchery;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_closestHatchery = libVCMI_gf_PM_FindPrimaryTownHall(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)]);

    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((PlayerGetCooldown(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)], libVCMI_gv_pM_HeroReviveCDLink[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)]) == 0.0))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    lv_heroIndex = (libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga);
    if ((libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex] != null)) {
        if ((UnitIsAlive(libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex]) == true)) {
            UnitCreateEffectUnit(lv_closestHatchery, "CopyHatcheryRally", libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex]);
        }

    }

    libVCMI_gf_PM_HeroRevive(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga);
    if ((libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex] != null)) {
        if ((UnitIsAlive(libVCMI_gv_pM_HeroReviverUnit[lv_heroIndex]) == true)) {
            UnitSetPosition(libVCMI_gv_pM_HeroRevivingUnit[lv_heroIndex], PointWithOffsetPolar(UnitGetPosition(lv_closestHatchery), 3.0, 270.0), false);
        }

    }

    UnitBehaviorAdd(libVCMI_gv_pM_HeroRevivingUnit[lv_heroIndex], "KerriganXelNagaReviveStun", libVCMI_gv_pM_HeroRevivingUnit[lv_heroIndex], 1);
    libVCUI_gf_SetHeroPanelUnit(1, libVCMI_gv_pM_HeroRevivingUnit[lv_heroIndex]);
    if ((libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan_XelNaga)] == 1)) {
        libVCMI_gf_DisplayCampaignMessage(PlayerGroupAll(), libVCMI_ge_CampaignMessageType_SimpleHint, StringExternal("Param/Value/lib_VCMI_49506498"), libVCMI_ge_CampaignMessageFormatNotFormat_FormatMessage);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait_Init () {
    libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait = TriggerCreate("libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait_Func");
    TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait, false);
    TriggerAddEventTimePeriodic(libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait, 1.0, c_timeGame);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_HeroKerriganReviverDeath
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_HeroKerriganReviverDeath_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((PlayerGetCooldown(libVCMI_gv_pM_HeroRevivePlayer[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)], libVCMI_gv_pM_HeroReviveCDLink[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)]) > 0.0))) {
            return false;
        }

        if (!((UnitIsAlive(libVCMI_gv_pM_HeroRevivingUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)]) == false))) {
            return false;
        }
    }

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

    TriggerEnable(libVCMI_gt_PM_HeroReviveKerriganCooldownWait, false);
    TriggerStop(libVCMI_gt_PM_HeroReviveKerriganCooldownWait);
    libVCMI_gv_pM_ReviveUseAltMessage = true;
    libVCMI_gf_HandleHeroDeathVoid(libVCMI_gv_pM_HeroRevivingUnit[(libVCMI_ge_PM_HeroType_PM_HeroType_Kerrigan)], null, -1.0);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_HeroKerriganReviverDeath_Init () {
    libVCMI_gt_PM_HeroKerriganReviverDeath = TriggerCreate("libVCMI_gt_PM_HeroKerriganReviverDeath_Func");
    TriggerAddEventUnitDied(libVCMI_gt_PM_HeroKerriganReviverDeath, UnitRefFromVariable("libVCMI_gv_pM_HeroReviverUnit[1]"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAStatusWatch
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAStatusWatch_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    while (true) {
        if (((libVCMI_gv_pM_SoAUnit == null) || (UnitIsAlive(libVCMI_gv_pM_SoAUnit) == false))) {
            libVCMI_gf_PM_SoACreateUnit();
            UnitSetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergy, libVCMI_gv_pM_SoALastKnownEnergy);
        }
        else {
            libVCMI_gv_pM_SoALastKnownEnergy = UnitGetPropertyFixed(libVCMI_gv_pM_SoAUnit, c_unitPropEnergy, c_unitPropCurrent);
        }
        Wait(0.5, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAStatusWatch_Init () {
    libVCMI_gt_PM_SoAStatusWatch = TriggerCreate("libVCMI_gt_PM_SoAStatusWatch_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAInit
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAInit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    string lv_indexPerk;

    // Automatic Variable Declarations
    int autoAFC1BA1E_ai;
    int autoAFC1BA1E_ae;

    // Variable Initialization

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

    libVCMI_gf_PM_SoACreateUnit();
    if ((libVoiC_gf_MissionStatusCheck("PAiur03", libVoiC_ge_MissionStatus_Completed) == false)) {
        libVCUI_gf_ShowSpearofAdunUI(false, c_transitionDurationImmediate);
        return true;
    }

    TriggerExecute(libVCMI_gt_PM_SoAStatusWatch, true, false);
    autoAFC1BA1E_ai = 1;
    autoAFC1BA1E_ae = UserDataInstanceCount("CampaignPerk")+1;
    while (autoAFC1BA1E_ai < autoAFC1BA1E_ae) {
        lv_indexPerk = UserDataInstance("CampaignPerk", autoAFC1BA1E_ai);
        autoAFC1BA1E_ai = autoAFC1BA1E_ai+1;
        if ((libVoiC_gf_PC_PerkStateCheck(lv_indexPerk, libVoiC_ge_PC_PerkState_Active) == true)) {
            if ((libNtve_gf_PlayerInCinematicMode(1) == false)) {
                libVCUI_gf_PU_GPVisibilityAutoUpdate(true, c_transitionDurationImmediate);
            }

            return true;
        }

    }
    libVCUI_gf_ShowSpearofAdunUI(false, c_transitionDurationImmediate);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAInit_Init () {
    libVCMI_gt_PM_SoAInit = TriggerCreate("libVCMI_gt_PM_SoAInit_Func");
    libVoiC_gf_CampaignMissionStarts(libVCMI_gt_PM_SoAInit);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SoAStatPylonUsed
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SoAStatPylonUsed_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    DataTableSetInt(true, ("AbilUsed_" + ("GPTier1Power1")), (DataTableGetInt(true, ("GPTier1Power1"))+1));
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SoAStatPylonUsed_Init () {
    libVCMI_gt_PM_SoAStatPylonUsed = TriggerCreate("libVCMI_gt_PM_SoAStatPylonUsed_Func");
    TriggerAddEventUnitAbility(libVCMI_gt_PM_SoAStatPylonUsed, UnitRefFromVariable("libVCMI_gv_pM_SoAUnit"), AbilityCommand("SOAProxyPylon", 0), c_unitAbilStageComplete, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_PlayerNeedPylon
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_PlayerNeedPylon_Func (bool testConds, bool runActions) {
    // Variable Declarations
    text lv_newTooltip;
    fixed lv_used;
    fixed lv_made;
    fixed lv_limit;
    bool lv_transmissionDelivered;

    // Automatic Variable Declarations
    // Variable Initialization
    lv_newTooltip = StringExternal("Param/Value/lib_VCMI_075E5731");

    // Conditions
    if (testConds) {
        if (!((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindMission) == true))) {
            return false;
        }
    }

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

    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, true);
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3, true);
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4, true);
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6, true);
    while (true) {
        Wait(1.0, c_timeAI);
        if ((libVCMI_gf_GameIsOver() == true)) {
            return true;
        }

        if ((libVCMI_gv_pM_NeedPylonEnabled == true) && (libNtve_gf_PlayerInCinematicMode(1) == false) && (TechTreeUnitCount(1, "Nexus", c_techCountQueuedOrBetter) > 0)) {
            lv_made = PlayerGetPropertyFixed(1, c_playerPropSuppliesMade);
            lv_used = PlayerGetPropertyFixed(1, c_playerPropSuppliesUsed);
            lv_limit = PlayerGetPropertyFixed(1, c_playerPropSuppliesLimit);
            if (((lv_made + (TechTreeUnitCount(1, "Pylon", c_techCountInProgressOnly) * StringToFixed(CatalogFieldValueGet(c_gameCatalogUnit, "Pylon", "Food", 1)))) < lv_limit) && ((lv_made + (TechTreeUnitCount(1, "Pylon", c_techCountInProgressOnly) * StringToFixed(CatalogFieldValueGet(c_gameCatalogUnit, "Pylon", "Food", 1)))) <= ((lv_used + libVCMI_gv_pM_NeedPylonFoodRequired) - 0.1))) {
                if ((libVCMI_gv_pM_NeedPylonAbilityHighlightOn == false)) {
                    if ((lv_transmissionDelivered == false)) {
                        lv_transmissionDelivered = true;
                        TriggerQueueEnter();
                        libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Speech);
                        libVCMI_gf_SendTransmissionCampaign(null, "pTutorial_Gameplay|Line00002", c_transmissionDurationAdd, 0.0, true, libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter, libVCMI_ge_MissionTransmissionCueSoundOptions_DefaultCueSoundBehavior);
                        libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Game);
                        TriggerQueueExit();
                    }
                    else {
                        libVCMI_gv_pM_NeedPylonAbilityHighlightOn = true;
                        UIDisplayMessage(PlayerGroupAll(), c_messageAreaDirective, StringExternal("Param/Value/lib_VCMI_1142C38C"));
                        UISetButtonHighlighted(PlayerGroupSingle(1), AbilityCommand("ProtossBuild", 1), true);
                        CatalogFieldValueSet(c_gameCatalogButton, "Pylon", "Tooltip", 1, "Param/Value/lib_VoiC_F569C4E3");
                        DialogControlHookupStandard(c_triggerControlTypeImage, "UIContainer/FullscreenUpperContainer/ResourcePanel/ResourceFrame/SupplyHighlight");
                        DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), true);
                        DialogControlDestroy(DialogControlLastCreated());
                    }
                }

            }
            else {
                if ((libVCMI_gv_pM_NeedPylonAbilityHighlightOn == true)) {
                    libVCMI_gv_pM_NeedPylonAbilityHighlightOn = false;
                    UIClearMessages(PlayerGroupSingle(1), c_messageAreaDirective);
                    UISetButtonHighlighted(PlayerGroupSingle(1), AbilityCommand("ProtossBuild", 1), false);
                    CatalogFieldValueSet(c_gameCatalogButton, "Pylon", "Tooltip", 1, "Button/Tooltip/Pylon");
                    DialogControlHookupStandard(c_triggerControlTypeImage, "UIContainer/FullscreenUpperContainer/ResourcePanel/ResourceFrame/SupplyHighlight");
                    DialogControlSetVisible(DialogControlLastCreated(), PlayerGroupAll(), false);
                    DialogControlDestroy(DialogControlLastCreated());
                }

            }
        }

    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_PlayerNeedPylon_Init () {
    libVCMI_gt_PM_PlayerNeedPylon = TriggerCreate("libVCMI_gt_PM_PlayerNeedPylon_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_PlayerNeedPylonButtonClicked (Food 2)
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_localIndex;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }
    }

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

    libVCMI_gv_pM_NeedPylonFoodRequired2Index += 1;
    lv_localIndex = libVCMI_gv_pM_NeedPylonFoodRequired2Index;
    libVCMI_gv_pM_NeedPylonFoodRequired = MaxI(libVCMI_gv_pM_NeedPylonFoodRequired, 2);
    Wait(15.0, c_timeGame);
    if ((lv_localIndex == libVCMI_gv_pM_NeedPylonFoodRequired2Index) && (libVCMI_gv_pM_NeedPylonFoodRequired == 2)) {
        libVCMI_gv_pM_NeedPylonFoodRequired = 1;
        libVCMI_gv_pM_NeedPylonFoodRequired2Index = 0;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2_Init () {
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2 = TriggerCreate("libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2_Func");
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, false);
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "Zealot");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "Sentry");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "Stalker");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "HighTemplar");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "DarkTemplar");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "WarpPrism");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2, 1, "Phoenix");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_PlayerNeedPylonButtonClicked (Food 3)
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_localIndex;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }
    }

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

    libVCMI_gv_pM_NeedPylonFoodRequired3Index += 1;
    lv_localIndex = libVCMI_gv_pM_NeedPylonFoodRequired3Index;
    libVCMI_gv_pM_NeedPylonFoodRequired = MaxI(libVCMI_gv_pM_NeedPylonFoodRequired, 3);
    Wait(15.0, c_timeGame);
    if ((lv_localIndex == libVCMI_gv_pM_NeedPylonFoodRequired3Index) && (libVCMI_gv_pM_NeedPylonFoodRequired == 3)) {
        libVCMI_gv_pM_NeedPylonFoodRequired = 1;
        libVCMI_gv_pM_NeedPylonFoodRequired3Index = 0;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3_Init () {
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3 = TriggerCreate("libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3_Func");
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3, false);
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3, 1, "VoidRay");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_PlayerNeedPylonButtonClicked (Food 4)
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_localIndex;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }
    }

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

    libVCMI_gv_pM_NeedPylonFoodRequired4Index += 1;
    lv_localIndex = libVCMI_gv_pM_NeedPylonFoodRequired4Index;
    libVCMI_gv_pM_NeedPylonFoodRequired = MaxI(libVCMI_gv_pM_NeedPylonFoodRequired, 4);
    Wait(15.0, c_timeGame);
    if ((lv_localIndex == libVCMI_gv_pM_NeedPylonFoodRequired4Index) && (libVCMI_gv_pM_NeedPylonFoodRequired == 4)) {
        libVCMI_gv_pM_NeedPylonFoodRequired = 1;
        libVCMI_gv_pM_NeedPylonFoodRequired4Index = 0;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4_Init () {
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4 = TriggerCreate("libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4_Func");
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4, false);
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4, 1, "Immortal");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_PlayerNeedPylonButtonClicked (Food 6)
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6_Func (bool testConds, bool runActions) {
    // Variable Declarations
    int lv_localIndex;

    // Automatic Variable Declarations
    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }
    }

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

    libVCMI_gv_pM_NeedPylonFoodRequired6Index += 1;
    lv_localIndex = libVCMI_gv_pM_NeedPylonFoodRequired6Index;
    libVCMI_gv_pM_NeedPylonFoodRequired = MaxI(libVCMI_gv_pM_NeedPylonFoodRequired, 6);
    Wait(15.0, c_timeGame);
    if ((lv_localIndex == libVCMI_gv_pM_NeedPylonFoodRequired6Index) && (libVCMI_gv_pM_NeedPylonFoodRequired == 6)) {
        libVCMI_gv_pM_NeedPylonFoodRequired = 1;
        libVCMI_gv_pM_NeedPylonFoodRequired6Index = 0;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6_Init () {
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6 = TriggerCreate("libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6_Func");
    TriggerEnable(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6, false);
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6, 1, "Colossus");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6, 1, "Tempest");
    TriggerAddEventButtonPressed(libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6, 1, "Carrier");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_BaseUnderAttackInit
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_BaseUnderAttackInit_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libLotv_gf_DifficultyValueVoidBoolean(true, true, false, false) == true))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    if (((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindMission) == false) || (libVoiC_gf_PC_ArmyCategoryState("PhotonCannon") != c_armyCategoryStateUnlocked) || (libVoiC_gf_NumberOfMissions(libVoiC_ge_MissionCountOptions_Completed) > 6))) {
        return true;
    }

    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt, true);
    Wait(300.0, c_timeGame);
    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGround, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_BaseUnderAttackInit_Init () {
    libVCMI_gt_PM_BaseUnderAttackInit = TriggerCreate("libVCMI_gt_PM_BaseUnderAttackInit_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_BaseUnderAttackByGround
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_BaseUnderAttackByGround_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    fixed auto1D4B0537_at;

    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((libNtve_gf_PlayerInCinematicMode(1) == false))) {
            return false;
        }

        if (!((UnitGetOwner(EventUnit()) == 1))) {
            return false;
        }

        if (!((EventUnitDamageSourcePlayer() != 1))) {
            return false;
        }

        if (!((UnitGetType(EventUnit()) != "PhotonCannon"))) {
            return false;
        }

        if (!((libVCMI_gv_pM_PhotonCannonBuilt == false))) {
            return false;
        }

        if (!((UnitFilterMatch(EventUnit(), 1, UnitFilter((1 << c_targetFilterStructure), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterHidden - 32)))) == true))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt, true);
    Wait(5.0, c_timeAI);
    auto1D4B0537_at = 0;
    while (!((TriggerQueueIsEmpty() == true)) && auto1D4B0537_at <= 10.0) {
        Wait(1.0, c_timeAI);
        auto1D4B0537_at = auto1D4B0537_at + 1.0;
    }
    if ((libVCMI_gv_pM_PhotonCannonBuilt == true)) {
        libVCMI_gv_pM_PhotonCannonBuilt = false;
        TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt, false);
        return true;
    }

    TriggerQueueEnter();
    libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Speech);
    libVCMI_gf_SendTransmissionCampaign(null, "pMission_Shakuras01|Line00162", c_transmissionDurationAdd, 0.0, true, libVCMI_ge_MissionTransmissionPortraitOptioins_HidePortraitAfter, libVCMI_ge_MissionTransmissionCueSoundOptions_DefaultCueSoundBehavior);
    libVoiC_gf_SetAllSoundChannelVolumesCampaign(libVoiC_ge_VolumeChannelModeCampaign_Game);
    if ((libVCMI_gv_pM_PhotonCannonTipPlayed == false)) {
        libVCMI_gv_pM_PhotonCannonTipPlayed = true;
        Wait(libVCMI_gv_campaignHintDelay, c_timeReal);
    }

    TriggerQueueExit();
    UISetButtonHighlighted(PlayerGroupAll(), AbilityCommand("ProtossBuild", 7), true);
    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_BaseUnderAttackByGround_Init () {
    libVCMI_gt_PM_BaseUnderAttackByGround = TriggerCreate("libVCMI_gt_PM_BaseUnderAttackByGround_Func");
    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGround, false);
    TriggerAddEventUnitDamaged(libVCMI_gt_PM_BaseUnderAttackByGround, null, c_unitDamageTypeAny, c_unitDamageEither, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_BaseUnderAttackByGroundPhotonCannonBuilt
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((libNtve_gf_PlayerInCinematicMode(1) == false))) {
            return false;
        }

        if (!((UnitGetOwner(EventUnit()) == 1))) {
            return false;
        }

        if (!(((UnitGetType(EventUnitProgressUnit()) == "PhotonCannon") || (UnitGetType(EventUnitProgressUnit()) == "KhaydarinMonolith")))) {
            return false;
        }

        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    libVCMI_gv_pM_PhotonCannonBuilt = true;
    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGround, false);
    TriggerStop(libVCMI_gt_PM_BaseUnderAttackInit);
    UISetButtonHighlighted(PlayerGroupAll(), AbilityCommand("ProtossBuild", 7), false);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt_Init () {
    libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt = TriggerCreate("libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt_Func");
    TriggerEnable(libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt, false);
    TriggerAddEventUnitConstructProgress(libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt, null, c_unitProgressStageStart);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_ReminderPlayerConstructsFromGateway
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_ReminderPlayerConstructsFromGateway_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnit()) == 1))) {
            return false;
        }

        if (!(((UnitGetType(EventUnit()) == "Gateway") || (UnitGetType(EventUnit()) == "WarpGate")))) {
            return false;
        }
    }

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

    if (((libVoiC_gf_MissionStatusCheck("PAiur02", libVoiC_ge_MissionStatus_Completed) == false) || (libVoiC_gf_PC_MissionisInstallation(libVoiC_gf_CurrentMap()) == true) || (libVoiC_gf_PC_CampaignInEpilogue() == true) || (libVoiC_gf_MissionStatusCheck("PUlnar03", libVoiC_ge_MissionStatus_Completed) == true) || (libLotv_gf_DifficultyValueInt2(1, 1, 0, 0) == 0))) {
        TriggerEnable(TriggerGetCurrent(), false);
        return true;
    }

    libVCMI_gf_RemindPlayertoTransformGateways();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_ReminderPlayerConstructsFromGateway_Init () {
    libVCMI_gt_PM_ReminderPlayerConstructsFromGateway = TriggerCreate("libVCMI_gt_PM_ReminderPlayerConstructsFromGateway_Func");
    TriggerAddEventUnitTrainProgress(libVCMI_gt_PM_ReminderPlayerConstructsFromGateway, null, c_unitProgressStageStart);
    TriggerAddEventUnitConstructProgress(libVCMI_gt_PM_ReminderPlayerConstructsFromGateway, null, c_unitProgressStageStart);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_MissionTipClicked
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_MissionTipClicked_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((EventDialogControl() == libVCMI_gv_pM_MissionHelpButton))) {
            return false;
        }
    }

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

    if ((libVCMI_gv_pM_MissionHelpButtonTipPanel != c_invalidDialogControlId)) {
        DialogControlSetVisible(libVCMI_gv_pM_MissionHelpButtonTipPanel, PlayerGroupAll(), false);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_MissionTipClicked_Init () {
    libVCMI_gt_PM_MissionTipClicked = TriggerCreate("libVCMI_gt_PM_MissionTipClicked_Func");
    TriggerEnable(libVCMI_gt_PM_MissionTipClicked, false);
    TriggerAddEventDialogControl(libVCMI_gt_PM_MissionTipClicked, c_playerAny, c_invalidDialogControlId, c_triggerControlEventTypeClick);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_SendTransmissionCampaignTick
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_SendTransmissionCampaignTick_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    while (true) {
        if ((libVCMI_gv_pM_SendTransmissionCampaignIndex == 0) && (libVCMI_gv_pM_SendTransmissionCampaignPlayingTick > 0)) {
            libVCMI_gv_pM_SendTransmissionCampaignPlayingTick -= 1;
        }

        Wait(1.0, c_timeGame);
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_SendTransmissionCampaignTick_Init () {
    libVCMI_gt_PM_SendTransmissionCampaignTick = TriggerCreate("libVCMI_gt_PM_SendTransmissionCampaignTick_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_DropPod_Zerg_Don'tWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_DropPod_Zerg_DontWait_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_DropPod_Zerg_Wait(libVCMI_gv_pM_DropPod_TP_Location, libVCMI_gv_pM_DropPod_TP_Units, libVCMI_gv_pM_DropPod_TP_Player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_DropPod_Zerg_DontWait_Init () {
    libVCMI_gt_PM_DropPod_Zerg_DontWait = TriggerCreate("libVCMI_gt_PM_DropPod_Zerg_DontWait_Func");
    TriggerEnable(libVCMI_gt_PM_DropPod_Zerg_DontWait, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_DropPod_Terran_Don'tWait
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_DropPod_Terran_DontWait_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libVCMI_gf_PM_DropPod_Terran_Wait(libVCMI_gv_pM_DropPod_TP_Location, libVCMI_gv_pM_DropPod_TP_Units, libVCMI_gv_pM_DropPod_TP_Player);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_DropPod_Terran_DontWait_Init () {
    libVCMI_gt_PM_DropPod_Terran_DontWait = TriggerCreate("libVCMI_gt_PM_DropPod_Terran_DontWait_Func");
    TriggerEnable(libVCMI_gt_PM_DropPod_Terran_DontWait, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignUnit
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignUnit_Func (bool testConds, bool runActions) {
    // Variable Declarations
    unit lv_indexUnit;

    // Automatic Variable Declarations
    unitgroup autoD03D3C7E_g;
    int autoD03D3C7E_u;

    // Variable Initialization

    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }

        if (!((libVoiC_gf_PC_CampaignMapTypeCheck(libVoiC_gf_CurrentMap(), c_mapKindMission) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    autoD03D3C7E_g = UnitGroup(null, c_playerAny, null, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32))), 0);
    autoD03D3C7E_u = UnitGroupCount(autoD03D3C7E_g, c_unitCountAll);
    for (;; autoD03D3C7E_u -= 1) {
        lv_indexUnit = UnitGroupUnitFromEnd(autoD03D3C7E_g, autoD03D3C7E_u);
        if (lv_indexUnit == null) { break; }
        if (((UnitGetOwner(lv_indexUnit) == 1) || (UnitFilterMatch(lv_indexUnit, 1, UnitFilter((1 << c_targetFilterHarvestableResource), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)))) == true) || (UnitFilterMatch(lv_indexUnit, 1, UnitFilter((1 << c_targetFilterRawResource), 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)) | (1 << (c_targetFilterHidden - 32)))) == true))) {
            libVCMI_gf_PM_UseUnitNameAsUnitTip(lv_indexUnit);
            libVCMI_gf_PM_ApplyCampaignTeachingToUnit(lv_indexUnit);
        }

    }
    TriggerEnable(libVCMI_gt_PM_CampaignUnitCreated, true);
    TriggerEnable(libVCMI_gt_PM_CampaignUnitChangeOwner, true);
    TriggerEnable(libVCMI_gt_PM_CampaignUnitInfoUnitMorphes, true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignUnit_Init () {
    libVCMI_gt_PM_CampaignUnit = TriggerCreate("libVCMI_gt_PM_CampaignUnit_Func");
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignUnitCreated
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignUnitCreated_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((libVCMI_gf_GameIsOver() == false))) {
            return false;
        }

        if (!((UnitGetOwner(EventUnitCreatedUnit()) == 1))) {
            return false;
        }

        if (!((UnitFilterMatch(EventUnitCreatedUnit(), 1, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)))) == true))) {
            return false;
        }
    }

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

    libVCMI_gf_PM_UseUnitNameAsUnitTip(EventUnitCreatedUnit());
    libVCMI_gf_PM_ApplyCampaignTeachingToUnit(EventUnitCreatedUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignUnitCreated_Init () {
    libVCMI_gt_PM_CampaignUnitCreated = TriggerCreate("libVCMI_gt_PM_CampaignUnitCreated_Func");
    TriggerEnable(libVCMI_gt_PM_CampaignUnitCreated, false);
    TriggerAddEventUnitCreated(libVCMI_gt_PM_CampaignUnitCreated, null, null, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignCyberneticsSelected
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignCyberneticsSelected_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnit()) == 1))) {
            return false;
        }

        if (!((UnitGetType(EventUnit()) == "CyberneticsCore"))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsDestroyed, false);
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsRemoved, false);
    libVoiC_gv_pCX_UpgradesTaught = true;
    libNtve_gf_KillModel(libVCMI_gv_pM_UpgradeReticle);
    TextTagDestroy(libVCMI_gv_pM_UpgradeTextTag);
    libVCMI_gv_pM_UpgradeUnit = null;
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignCyberneticsSelected_Init () {
    libVCMI_gt_PM_CampaignCyberneticsSelected = TriggerCreate("libVCMI_gt_PM_CampaignCyberneticsSelected_Func");
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsSelected, false);
    TriggerAddEventUnitSelected(libVCMI_gt_PM_CampaignCyberneticsSelected, null, 1, true);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignCyberneticsDestroyed
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignCyberneticsDestroyed_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsSelected, false);
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsRemoved, false);
    libNtve_gf_KillModel(libVCMI_gv_pM_UpgradeReticle);
    TextTagDestroy(libVCMI_gv_pM_UpgradeTextTag);
    libVCMI_gv_pM_UpgradeUnit = null;
    libVCMI_gf_PM_CampaignCyberneticsSearch();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignCyberneticsDestroyed_Init () {
    libVCMI_gt_PM_CampaignCyberneticsDestroyed = TriggerCreate("libVCMI_gt_PM_CampaignCyberneticsDestroyed_Func");
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsDestroyed, false);
    TriggerAddEventUnitDied(libVCMI_gt_PM_CampaignCyberneticsDestroyed, UnitRefFromVariable("libVCMI_gv_pM_UpgradeUnit"));
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignCyberneticsRemoved
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignCyberneticsRemoved_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((EventUnit() == libVCMI_gv_pM_UpgradeUnit))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsSelected, false);
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsDestroyed, false);
    libNtve_gf_KillModel(libVCMI_gv_pM_UpgradeReticle);
    TextTagDestroy(libVCMI_gv_pM_UpgradeTextTag);
    libVCMI_gv_pM_UpgradeUnit = null;
    libVCMI_gf_PM_CampaignCyberneticsSearch();
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignCyberneticsRemoved_Init () {
    libVCMI_gt_PM_CampaignCyberneticsRemoved = TriggerCreate("libVCMI_gt_PM_CampaignCyberneticsRemoved_Func");
    TriggerEnable(libVCMI_gt_PM_CampaignCyberneticsRemoved, false);
    TriggerAddEventUnitRemoved(libVCMI_gt_PM_CampaignCyberneticsRemoved, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignUnitChangeOwner
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignUnitChangeOwner_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnit()) == 1))) {
            return false;
        }

        if (!((UnitFilterMatch(EventUnit(), 1, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)))) == true))) {
            return false;
        }
    }

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

    libVCMI_gf_PM_UseUnitNameAsUnitTip(EventUnit());
    libVCMI_gf_PM_ApplyCampaignTeachingToUnit(EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignUnitChangeOwner_Init () {
    libVCMI_gt_PM_CampaignUnitChangeOwner = TriggerCreate("libVCMI_gt_PM_CampaignUnitChangeOwner_Func");
    TriggerEnable(libVCMI_gt_PM_CampaignUnitChangeOwner, false);
    TriggerAddEventUnitChangeOwner(libVCMI_gt_PM_CampaignUnitChangeOwner, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_CampaignUnitInfoUnitMorphes
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_CampaignUnitInfoUnitMorphes_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((UnitGetOwner(EventUnit()) == 1))) {
            return false;
        }

        if (!((UnitFilterMatch(EventUnit(), 1, UnitFilter(0, 0, (1 << c_targetFilterMissile), (1 << (c_targetFilterDead - 32)))) == true))) {
            return false;
        }
    }

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

    libVCMI_gf_PM_UseUnitNameAsUnitTip(EventUnit());
    libVCMI_gf_PM_ApplyCampaignTeachingToUnit(EventUnit());
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_CampaignUnitInfoUnitMorphes_Init () {
    libVCMI_gt_PM_CampaignUnitInfoUnitMorphes = TriggerCreate("libVCMI_gt_PM_CampaignUnitInfoUnitMorphes_Func");
    TriggerEnable(libVCMI_gt_PM_CampaignUnitInfoUnitMorphes, false);
}

//--------------------------------------------------------------------------------------------------
// Trigger: PM_UnitBeingRemoved
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_PM_UnitBeingRemoved_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Actions
    if (!runActions) {
        return true;
    }

    libNtve_gf_SendActorMessageToUnit(EventUnit(), "Signal UnitRemoved");
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_PM_UnitBeingRemoved_Init () {
    libVCMI_gt_PM_UnitBeingRemoved = TriggerCreate("libVCMI_gt_PM_UnitBeingRemoved_Func");
    TriggerAddEventUnitRemoved(libVCMI_gt_PM_UnitBeingRemoved, null);
}

//--------------------------------------------------------------------------------------------------
// Trigger: Void Ping Sound
//--------------------------------------------------------------------------------------------------
bool libVCMI_gt_VoidPingSound_Func (bool testConds, bool runActions) {
    // Automatic Variable Declarations
    // Conditions
    if (testConds) {
        if (!((TriggerIsEnabled(TriggerGetCurrent()) == true))) {
            return false;
        }
    }

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

    TriggerEnable(TriggerGetCurrent(), false);
    SoundPlay(SoundLink("UI_TerranPing", -1), PlayerGroupAll(), 100.0, 0.0);
    Wait(SoundLengthSync(SoundLink("UI_TerranPing", -1)), c_timeReal);
    TriggerEnable(TriggerGetCurrent(), true);
    return true;
}

//--------------------------------------------------------------------------------------------------
void libVCMI_gt_VoidPingSound_Init () {
    libVCMI_gt_VoidPingSound = TriggerCreate("libVCMI_gt_VoidPingSound_Func");
}

void libVCMI_InitTriggers () {
    libVCMI_gt_PM_CinematicModeOn_Init();
    libVCMI_gt_PM_CinematicModeOff_Init();
    libVCMI_gt_PM_SoATargetingForceOff_Init();
    libVCMI_gt_PM_SoATargetingDeactivated_Init();
    libVCMI_gt_PM_SoATargetingPointChosen_Init();
    libVCMI_gt_PM_SoATargetingDirectionChosen_Init();
    libVCMI_gt_PM_SoATargetingEffectFired_Init();
    libVCMI_gt_PM_SoATargetingClearAll_Init();
    libVCMI_gt_PM_SoATargetingCancel_Init();
    libVCMI_gt_PM_SoATargetingCameraShake_Init();
    libVCMI_gt_PM_SoAOrbitalStrikeActivated_Init();
    libVCMI_gt_PM_SoAGravitonBombActivated_Init();
    libVCMI_gt_PM_SoAThermalLanceActivated_Init();
    libVCMI_gt_PM_SoATimeFreezeCast_Init();
    libVCMI_gt_PM_SoARecall_PrimarySearch_Init();
    libVCMI_gt_PM_SoARecall_PrimaryNexusDies_Init();
    libVCMI_gt_PM_SoARecall_PrimaryNexusInit_Init();
    libVCMI_gt_PM_SoATargetingPurifierBeamOn_Init();
    libVCMI_gt_PM_SoATargetingPurifierBeamOff_Init();
    libVCMI_gt_PM_SoAStrafeActivated_Init();
    libVCMI_gt_PM_SoASuperShieldsActivated_Init();
    libVCMI_gt_ConfusionEndSuicide_Init();
    libVCMI_gt_GlobalUpgrade_Init();
    libVCMI_gt_PM_HandleUseDeepShadows_Init();
    libVCMI_gt_PM_HandleUseAlarakAvatar_Init();
    libVCMI_gt_PM_HandleAlarakAvatarFinal_Init();
    libVCMI_gt_AlarakKnockback4_Init();
    libVCMI_gt_AlarakKnockback5_Init();
    libVCMI_gt_AlarakKnockback6_Init();
    libVCMI_gt_AlarakKnockback7_Init();
    libVCMI_gt_AlarakKnockback8_Init();
    libVCMI_gt_AlarakKnockback9_Init();
    libVCMI_gt_AlarakKnockback10_Init();
    libVCMI_gt_AlarakKnockback11_Init();
    libVCMI_gt_AlarakKnockback12_Init();
    libVCMI_gt_FenixCharge_Init();
    libVCMI_gt_KerriganPsiStrike_Init();
    libVCMI_gt_KerriganAstralShift_Init();
    libVCMI_gt_Extinction_Init();
    libVCMI_gt_StrikeAmon_Init();
    libVCMI_gt_AmonStrikeSelectionCheck_Init();
    libVCMI_gt_OracleWormhole_Init();
    libVCMI_gt_PM_GameCheat_CreateDialog_Init();
    libVCMI_gt_PS_GameCheat_CheckboxUsed_Init();
    libVCMI_gt_PS_GameCheat_CheatUsed_Init();
    libVCMI_gt_PM_MissionCheat_CreateDialog_Init();
    libVCMI_gt_PM_MissionCheat_ButtonClicked_Init();
    libVCMI_gt_PM_MissionCheat_CheatEntered_Init();
    libVCMI_gt_PM_DebugVictoryS_Init();
    libVCMI_gt_PM_ToggleFlyoverMode_Init();
    libVCMI_gt_PM_TurnOffFlyoverMode_Init();
    libVCMI_gt_PM_DebugSetSoAEnergy_Init();
    libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueueOneMinute_Init();
    libVCMI_gt_PM_MissionVictoryCallbackBlockActionQueue_Init();
    libVCMI_gt_PM_AbortMission_Init();
    libVCMI_gt_PM_MissionEndsPlayerExit_Init();
    libVCMI_gt_PM_VictoryContinue_Init();
    libVCMI_gt_PM_VictoryNextMissionLaunched_Init();
    libVCMI_gt_PM_VictoryQuit_Init();
    libVCMI_gt_PM_VictoryTravelLaunched_Init();
    libVCMI_gt_PM_HeroReviveKerriganCooldownWait_Init();
    libVCMI_gt_PM_HeroReviveStukovCooldownWait_Init();
    libVCMI_gt_PM_HeroReviveZagaraCooldownWait_Init();
    libVCMI_gt_PM_HeroReviveFenixCooldownWait_Init();
    libVCMI_gt_PM_HeroReviveKerriganXelNagaCooldownWait_Init();
    libVCMI_gt_PM_HeroKerriganReviverDeath_Init();
    libVCMI_gt_PM_SoAStatusWatch_Init();
    libVCMI_gt_PM_SoAInit_Init();
    libVCMI_gt_PM_SoAStatPylonUsed_Init();
    libVCMI_gt_PM_PlayerNeedPylon_Init();
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood2_Init();
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood3_Init();
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood4_Init();
    libVCMI_gt_PM_PlayerNeedPylonButtonClickedFood6_Init();
    libVCMI_gt_PM_BaseUnderAttackInit_Init();
    libVCMI_gt_PM_BaseUnderAttackByGround_Init();
    libVCMI_gt_PM_BaseUnderAttackByGroundPhotonCannonBuilt_Init();
    libVCMI_gt_PM_ReminderPlayerConstructsFromGateway_Init();
    libVCMI_gt_PM_MissionTipClicked_Init();
    libVCMI_gt_PM_SendTransmissionCampaignTick_Init();
    libVCMI_gt_PM_DropPod_Zerg_DontWait_Init();
    libVCMI_gt_PM_DropPod_Terran_DontWait_Init();
    libVCMI_gt_PM_CampaignUnit_Init();
    libVCMI_gt_PM_CampaignUnitCreated_Init();
    libVCMI_gt_PM_CampaignCyberneticsSelected_Init();
    libVCMI_gt_PM_CampaignCyberneticsDestroyed_Init();
    libVCMI_gt_PM_CampaignCyberneticsRemoved_Init();
    libVCMI_gt_PM_CampaignUnitChangeOwner_Init();
    libVCMI_gt_PM_CampaignUnitInfoUnitMorphes_Init();
    libVCMI_gt_PM_UnitBeingRemoved_Init();
    libVCMI_gt_VoidPingSound_Init();
}

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

void libVCMI_InitLib () {
    if (libVCMI_InitLib_completed) {
        return;
    }

    libVCMI_InitLib_completed = true;

    libVCMI_InitLibraries();
    libVCMI_InitVariables();
    libVCMI_InitTriggers();
}

include "TriggerLibs/VoidCampaignLib"
include "TriggerLibs/VoidCampaignStoryLib"
include "TriggerLibs/VoidCampaignUILib"