common.eai

 //==================================================================================================
//  $Id: common.ai,v 1.68 2003/05/12 02:34:18 bfitch Exp $    (the base blizzard version 1.19 - 1.20c)
//
//  AMAI (Advanced Melee AI) common.ai by Strategy Master
//==================================================================================================
#DEFINE $ONE$ 1
#DEFINE $ZERO$ 0

#INCLUDE <Natives.j>

globals

   //============================================================================
   // Standard Constants and Variables
   //============================================================================

    constant integer M1                 =    60
    constant integer M2                 =  2*60
    constant integer M3                 =  3*60
    constant integer M4                 =  4*60
    constant integer M5                 =  5*60
    constant integer M6                 =  6*60
    constant integer M7                 =  7*60
    constant integer M8                 =  8*60
    constant integer M9                 =  9*60
    constant integer M10                = 10*60
    constant integer M11                = 11*60
    constant integer M12                = 12*60
    constant integer M13                = 13*60
    constant integer M14                = 14*60
    constant integer M15                = 15*60

    constant integer EASY               = 1
    constant integer NORMAL             = 2
    constant integer HARD               = 3
    constant integer INSANE             = 4 // not used

    constant integer MELEE_NEWBIE       = 1
    constant integer MELEE_NORMAL       = 2
    constant integer MELEE_INSANE       = 3

    constant integer ATTACK_CAPTAIN     = 1
    constant integer DEFENSE_CAPTAIN    = 2
    constant integer BOTH_CAPTAINS      = 3

    constant integer BUILD_UNIT         = 1
    constant integer BUILD_UPGRADE      = 2
    constant integer BUILD_EXPAND       = 3

    constant integer UPKEEP_TIER1       = 50
    constant integer UPKEEP_TIER2       = 80

    //--------------------------------------------------------------------

    player  ai_player

    integer sleep_seconds
    integer total_gold              = 0
    integer total_wood              = 0
    integer gold_buffer             = 0 // usually for potion money
    integer difficulty              = NORMAL
    integer exp_seen                = 0
    integer racial_farm             = 'hhou'
    integer hero_id                 = 'Hamg'
    integer hero_id2                = 'Hmkg'
    integer hero_id3                = 'Hpal'
    integer array skill
    integer array skills1
    integer array skills2
    integer array skills3
    integer max_hero_level          = 0

    integer array harass_qty
    integer array harass_max
    integer array harass_units
    integer harass_length           = 0

    integer array defense_qty
    integer array defense_units
    integer defense_length          = 0

    integer array build_qty
    integer array build_type
    integer array build_item
    integer array build_town
    integer build_length            = 0

    integer campaign_gold_peons     = 5
    integer campaign_wood_peons     = 3
    integer campaign_basics_speed   = 5

    integer min_creeps              = -1
    integer max_creeps              = -1

    boolean harvest_town1           = true
    boolean harvest_town2           = true
    boolean harvest_town3           = true
    boolean do_campaign_farms       = true
    boolean two_heroes              = false
    boolean allow_air_creeps        = false
    boolean take_exp                = false
    boolean allow_signal_abort      = false
    boolean ready_for_zeppelin      = true
    boolean get_zeppelin            = false

    boolean build_campaign_attackers = true

    boolean do_debug_cheats         = false
    boolean trace_on                = true
    boolean zep_next_wave           = false
    boolean form_group_timeouts     = true


    // =============================================================
    // AMAI constants
    // =============================================================



    constant integer o0                 = 0
    string array unitNames

#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR
  integer %1 = %row  // Cannot be constants for VS AI support
  constant integer o%1 = '%2'
#AFTERINCLUDE
  constant integer OBJECT_NUM = %row
#ENDINCLUDE
#INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "AI_COMP"
  integer %3 = %1
  integer o%3 = o%1
#ENDINCLUDE

#INCLUDETABLE <$VER$\HeroAbilities.txt> #EFR
  constant integer %1 = '%2'
#ENDINCLUDE


    constant integer BUILD_ITEM         = 4

    constant integer BLOC_STD = 1
    constant integer BLOC_FRONT = 2
    constant integer BLOC_MINE = 3

    constant integer NOT_ENOUGH_RES = 1
    constant integer CANNOT_BUILD = 2
    constant integer BUILT_ALL = 3
    constant integer BUILT_SOME = 4

    constant integer SR_RANDOM = 0
    constant integer SR_ELF = 1
    constant integer SR_HUMAN = 2
    constant integer SR_ORC = 3
    constant integer SR_UNDEAD = 4

    constant integer R_RANDOM = 0
#DEFINE $RACENUM$ 0
#INCLUDETABLE <$VER$\Races.txt>
    constant integer R_%1 = %row
#DEFINE $RACENUM$ %row
#AFTERINCLUDE
    constant integer R_NEUTRAL = #EVAL{%row+1}
    constant integer RACE_NUMBER = %row
#ENDINCLUDE

#DEFINE $HEROLEVELNUM$ 0
#INCLUDETABLE <$VER$\HeroLevels.txt>
#DEFINE $HEROLEVELNUM$ %row
#AFTERINCLUDE
    constant integer HERO_LEVEL_NUMBER = %row
#ENDINCLUDE

#SEARCHTREE Jobs <Jobs.txt> %1 %2 %3 #EFR

#SEARCHLIST Jobs
    constant integer %1 = %row
#ENDSEARCHLIST

    constant integer STRATEGY_TYPE_MELEE = 0
    constant integer STRATEGY_TYPE_RANGED = 1
    constant integer STRATEGY_TYPE_AIR = 2
    constant integer STRATEGY_TYPE_CASTER = 3

    constant integer NEUTRAL_TAVERN = 0
    constant integer NEUTRAL_OBSERVATORY = 1
    constant integer NEUTRAL_MERC_CAMP = 2
    constant integer NEUTRAL_DRAGON_ROOST = 3
    constant integer NEUTRAL_HEALING_FOUNTAIN = 4
    constant integer NEUTRAL_MERCHANT = 5
    constant integer NEUTRAL_MANA_FOUNTAIN = 6
    constant integer NEUTRAL_SHIPYARD = 7
    constant integer NEUTRAL_MARKETPLACE = 8
    constant integer NEUTRAL_POWER_FOUNTAIN = 9
    constant integer NEUTRAL_HEAL_WARD = 10
    constant integer NEUTRAL_COUNT = 11

    constant integer UPKEEP_UNDECIDED = 0
    constant integer UPKEEP_NOT_ALLOWED = 1
    constant integer UPKEEP_ALLOWED = 2

#INCLUDETABLE <$VER$\Upkeep.txt> #EFR
    constant integer UPKEEP_%1 = #EVAL{%row-1}
#AFTERINCLUDE
    constant integer UPKEEP_NUM = %row
#ENDINCLUDE

    constant integer HEALER_TYPE_NO_TARGET = 0
    constant integer HEALER_TYPE_SUDDEN = 1
    constant integer HEALER_TYPE_CONTINUOUS = 2
    constant integer HEALER_TYPE_WARD = 3
    constant integer HEALER_TYPE_HERO = 4

    constant integer UPGRADED = 9999

    constant integer BT_UNIT = 0
    constant integer BT_BUILDING = 1
    constant integer BT_HERO = 2
    constant integer BT_UPGRADE = 3
    constant integer BT_ML_UPGRADE = 4
    constant integer BT_RACIAL_ITEM = 5
    constant integer BT_NEUTRAL_HERO = 6
    constant integer BT_MERC = 7
    constant integer BT_GOBLIN_MERC = 8
    constant integer BT_DRAGON = 9
    constant integer BT_MERCHANT_ITEM = 10

    constant integer COMPARE_TRUE = 0
    constant integer COMPARE_EQ = 1
    constant integer COMPARE_UNEQ = 2
    constant integer COMPARE_GREATER = 3
    constant integer COMPARE_GREATER_EQ = 4
    constant integer COMPARE_LESS = 5
    constant integer COMPARE_LESS_EQ = 6

    constant integer HEALINGITEM_MASS = 0
    constant integer HEALINGITEM_SINGLE = 1
    constant integer MERCHANTITEM_MASS = 2
    constant integer GLOBALHEALING = 3
    constant integer HEALINGITEM_HERO = 4
    constant integer MANAITEM_HERO = 5
    constant integer ITEMTYPE_SUDDEN = 0
    constant integer ITEMTYPE_CONTINUOUS = 1

    constant integer HERO_SKILL_MAJOR = 0
    constant integer HERO_SKILL_MINOR = 1
    constant integer HERO_SKILL_RARE = 2

//==============================================================
// (AMAI) Global Settings
//==============================================================
#PRAGMA START VERSION SETTINGS
    real sleep_multiplier = 1  // increases performance by checking stuff not so often
    integer slm_start = 4  // how many computer players is needed tor the sleep multiplier to start increasing
    integer slm_end = 10 // how many computer players is needed tor the sleep multiplier to stop increasing
    real slm_start_mult = 1 // how much is the sleep multiplied when it´s below the slm_start codition
    real slm_end_mult = 2  // how much is the sleep multiplied when it´s above the slm_end codition
    real hero_radius = 200  // scanning this small area around hero to detect if the hero gets surrounded by enemy or is in danger of becoming that so it should move
    boolean use_linear_upkeep_saving = false  // should the computers save the upkeep threshold gold over the time above or save it all at once when it get's to the upkeep border?
    integer repair_threshold = 6  // computers only repair buildings if they have more than this many workers
    integer repair_threshold_threatened = 8 // computers only repair buildings when the town is under attack if they got more than this many workers
    real max_follow_dist = 1000  // Max Distance behind the army a zeppelin follows
    integer neutral_hero_time = 25  // when is neutral heroes available in seconds /5
    real buy_timeout_large = 120  // time in seconds the hero goes to a shop before it gives up if it haven't reached it
    real buy_timeout_small = 15  // time in seconds a hero tries to buy items at shop before giving up
    real buy_distance = 350  // how close to a shop does a unit have to be for buying?
    integer build_array_reset_time = 100  // every this * 5 seconds, the build array is reset
    integer rp_strat_normal = 250  // normalizing strategy priorities added from strengths with this value
    integer strategy_tier_bonus = 35  // the priority bonus added to a strategy if the computer is in the same tier as specified for the strategy
    integer attacking_strategy = 4       // strategy when attacking enemy players
    real focus_fire_limit = 35	// if a enemy heros hp fall below the computers combined strength of ranged attackers in a battle * this, they will focus fire on the hero
    real focus_fire_ranged_dist = 600 // Distance from ranged units enemy units can be targeted with focus fire
    real focus_fire_melee_dist = 50 // Distance from melee units enemy units can be targeted with focus fire
    real flee_health_percentage = 0.25  // Units flee from battle if the health goes below his % value(0.25 = 25%)
    real flee_minimum_health = 100  // Units flee from battle if the health goes below this
    real statue_distance = 300  // how near the units a statue used by undead should be in the fights
    real teleport_radius = 800  // units will stay within this radius from a hero that is using town portal
    integer gold_exchange_level = 650  // computers give extra gold above this value to other computers on the same team in need of gold
    integer wood_exchange_level = 350  // computers give extra lumber above this value to other computers on the same team in need of lumber
    integer max_towns = 5  // how many towns is a computer allowed to have?
    boolean add_tag = true // Add the [AMAI] tag in front of name
    boolean add_skill = true // Add the current skill after the name
    integer fav_hero_add = 20  // priority added to heroes to be picked if they are favorites of the used profile
    integer max_harass_groups = 10  // how many different harass groups you can use
    integer attacking_aggression = -12  // the base agression value for all computers, higher value and they will play more agressive. Recomended -5 to 5
    real expansion_radius = 650  // the radius araound a mine computers check for creeps before expanding there
    real harass_radius_attack_ranged = 800  // how far away from ranged enemy units harassing units attack a inferior enemy unit
    real harass_radius_attack_melee = 400  // how far away from melee enemy units harassing units attack a inferior enemy unit
    real harass_radius_flee_ranged = 1200  // how far away from ranged enemy units harassing units turn and flee
    real harass_radius_flee_melee = 800  // how far away from melee enemy units harassing units turn and flee
    boolean chatting	= true  // set to false to turn off computer taunts and chatting (Can still talk in observer mode)
    real full_threat_distance = 600  // a enemy army within this distance is counted as a full threat
    real no_threat_distance = 3000  // a enemy army outside this distance is counted as no threat
    real distance_threat_exponent = 0.8  // how fast the threat increases as the enemy army gets from the no_threat_distance to the full_threat_distance
    real distance_threat_mult = 540  // how much the threat vlaue goes up on a town when a enemy army aproaches, higher value means higher threat to town
    real atl_time_start = 300  // accepted threat level increase starts at this time
    real atl_time_end = 900    // and ends at that time
    real atl_time_start_val = 10  // it starts with this value
    real atl_time_end_val = 20  // and ends with that value
    real atl_enemy_start = 1 // accepted threat level multiplier increases at that enemy number
    real atl_enemy_end = 4   // until that enemy number
    real atl_enemy_start_mult = 1  // the multiplier starts for accepted threat level starts with this
    real atl_enemy_end_mult = 1.5    // and ends with this
    real teleport_low_threat = 40  // Army uses TP to get home and defend if a threat is greater than this
    real teleport_high_threat = 80  // Army uses TP to get home and defend if a threat is greater than this
    real teleport_low_threat_distance = 6000  // Army won't use TP home if they are closer to base than this and a low threat level appears
    real teleport_high_threat_distance = 3000  // Army won't use TP home if they are closer to base than this and a high threat level appears
    real teleport_army_min_strength = 20  // how big the army need to be for use of TP to threatened town
    real teleport_min_threat = 70  // minimum threat level TP use is allowed on
    integer shredder_peon_count = 12  // how many peons does a goblin shredder replace in lumber harvesting
    integer minimum_peon_wood = 2000 // computers don't build any workers for lumber harvesting if they have more lumber than this
    integer maximum_peon_wood = 200  // computers build all needed workers for lumber harvesting if they have lumber lower than this
#PRAGMA END VERSION SETTINGS

//==============================================================
// (AMAI) Version Properties
//==============================================================

#PRAGMA START VERSION SETTINGS
  boolean ver_neutral_heroes_available = true  // does the version have neutral heroes ?
  integer ver_neutral_hero_number = 0  // how many neutral heroes ?
  boolean ver_only_heroes_buy = false  // can only heroes buy stuff ?
  integer ver_food_limit = 100  // what is the food limit ?
  integer ver_strat_change_enemy_strength_min = 25  // don't allow strategy change unless the maximum strength of all enemy players in the game is above this.
  integer ver_hero_base_value = 4  // what is the base strength of a hero (the level number is added to get the actual strength) ?
  integer ver_hero_ultimate_level = 6  // at what level do the heroes get their ultimates ?
  integer ver_hero_ultimate_value = 4  // how much extra strength does the ultimate give to the hero ?
  real ver_creeps_attack_buildings_dist = 1000  // how far away do creeps attack buildings ?
  boolean ver_mercs_night_buy = false // can mercs be bought at night without waking up creeps ?
  real ver_tower_check_radius = 2000  // check for towers in this radius around a target
  real ver_harass_tower_check_radius = 1400  // check for towers in this radius during harassing
  integer ver_optimal_gold = 5  // The optimal number of peons that should be harvesting gold
  real ver_flee_multiple1 = 1  // Multiplier to players strength at lowest aggression to measure if amai is allowed to flee
  real ver_flee_multiple2 = 2  // Multiplier to players strength at highest aggression to measure if amai allowed to flee
  real ver_flee_multiple3 = 3  // Multipler to players strength at highest aggression to measure if amai will flee
  real ver_low_aggression = -15  // Aggression below this uses the lowest strength flee multiplier
  real ver_high_aggression = 45  // Agression above this uses the highest strength flee multiplier
#PRAGMA END VERSION SETTINGS

//==============================================================
// (AMAI) Race Properties
//==============================================================



#PRAGMA START RACIAL SETTINGS
    integer hero1_revive_prio = 200  // priority for reviving hero1
    integer hero2_revive_prio = 120  // priority for reviving hero2
    integer hero3_revive_prio = 80  // priority for reviving hero1
    integer prio_n_inc = 2  // priority increase for building needed buildings
    integer prio_t_inc = 1  // priority increase in time
    integer prio_q_inc = 2  // priority increase in quantity
    integer farm_food2 = 1 // builds another farm at the same time when this near food used to food produced
    integer farm_prio = 400 // priority for farm building
    integer peon_prio = 280 // priority for peon building
    integer ghoul_prio = 250  // priority for ghoul building
    integer expa_prio = 200 // priority for expansion building
    integer expa_emergency_prio = 300  // priority for rebuilding an expansion
    integer expa_rebuild_prio = 200 // priority for rebuilding an expansion
    integer peon_1_mine_number = 12 // maximum number of peons to build when 1 mine is owned (redundent if race uses ghouls)
    integer peon_2_mines_number = 17 // maximum number of peons to build when 2 mines are owned (redundent if race uses ghouls)
    integer peon_mines_number = 22  // maximum number of peons to build when more mines are owned (redundent if race uses ghouls)
    integer min_peon_number_single_mine = 8 // minimum number of peons when 1 mine is owned
    integer min_peon_number_double_mine = 13  // minimum number of peons when 2 mines are owned
    integer min_peon_number_multi_mine = 18 // minimum number of peons when more than 1 mine is owned
    integer strat_food_persistence = 2  // * current food use added to priority for current strategy (prevents computers from changing styrategy when having large army)
    integer relevant_strat_change_number = 3   // number of strategies with highest RPs that can be chosen when changing strategy
    integer kb_add1 = 8  // priority added to all strategies having a building the computer already got as a key building
    integer kb_add2 = 9  // priority added to all strategies having a building the computer already started to build as key building
    integer kb_add3 = 7  // priority added to all strategies having both building the computer already got as key buildings
    integer kb_add4 = 10 // value for 2 of a key buildings
    integer ku_add1 = 4  // priority added to all strategies having a upgrade the computer already got as key upgrade in first level
    integer ku_add2 = 7  // priority added to all strategies having a upgrade the computer already got as key upgrade in second level
    integer ku_add3 = 8  // priority added to all strategies having a upgrade the computer already got as key upgrade in third level
    integer fav_unit_add = 20  // priority added to strategies havign the current profiles favorite unit as key units.
    integer debug_strategy = -1  // this race is locked to this strategy number for testing.(-1 is unlocked)
    boolean race_use_fountain = true  // does the race use healing fountains ?
    boolean race_manual_loading = true  // does the race need manual loading of wisps in goldmines ?
    integer race_manual_loading_wisp = 0 //
    integer race_manual_loading_mine = 0 //
    boolean race_towerrush_available = false  // does the race have a towerrush ?
    integer race_tower_item = 0  // if the race_tower_id need Blig land (AbilityId 'Abgl'), Please set
    boolean race_tower_item_must = false  // the item is build towers is must?
    integer race_tower_item_quantity = 0  // how many items at a time , if can buy
    integer race_towerrush_requirement = 0  // what is the building required to build towers ?
    integer race_tower_id = 0  // what is the id of the races towers?
    integer race_tower_id_replace = 0  // if the race_tower_id has Blig land (AbilityId 'Abgl'), cannot create Blig land , and this build should can replace shop
    integer race_tower_upgrade1 = 0  //what is the id of the tower upgrade1 (core)?
    integer race_tower_upgrade2	= 0  //what is the id of the tower upgrade2 (secondary)?
    boolean race_tower_move = false  //tower can move , like ELF tree or StarCraft human build fly?
    string race_tower_movestartstring = ""  //what is the unitstring/name of tower start move? -- like use root to loc move
    string race_tower_moveendstring = ""  //what is the unitstring/name of tower end move?
    boolean race_tower_bypeon = false  //tower is peon become , like ELF? AI will compensate more 2 peon
    integer race_tower_peon	= 2  // the peons go to build towers , how much need compensation peons , usually compensation be equal to go build peons , if build like UD , just summon ,can set less
    integer race_towerrush_probability = 5 // how high (in percent) is the probability of doing a tower rush?
    integer race_towerrush_hero_rush_level = 1  // the bonus strength value hero must have to be able to do the tower rush
    boolean race_militia_expansion_available = false  // does the race have a militia expansion ?
    integer race_hero_number = 4  // how many racial heroes ?
    integer race_simple_melee = 0  // a basic melee unit, only necessary when basic_melee is used
    integer race_advanced_melee = 0  // an advanced melee unit to replace the basic one, only necessary when basic_melee is used
    boolean race_has_ghouls = false  // has the race a ghoul-like wood harvester/fighter unit ?
    boolean race_ghouls_attack = true  // do those ghouls go with the army on attacks ?
    integer race_min_ghouls = 2  // smallest number of ghouls to build at all times
    integer race_max_ghouls = 5  // maximum number of ghouls to build in low lumber situations
    boolean race_has_power_build = false  // can multiple racial workers work on the same building ?
    boolean race_no_wood_harvest = false  // has the race no wood harvesters ?
    boolean race_ignore_injured = false  // should the race leave injured units at home ?
    boolean race_uses_mine_expansion = false  // does the race expand with a mine building like undead ?
    boolean race_uses_shredder = true  // does the race use the goblin shredder ?
    boolean race_militia_available = false  // does the race have militia ?
    real race_militia_max_distance = 1000  // how far away from the town hall are the militia allowed ?
    integer race_militia_id = 'hmil'  // what is the militia unit type id?
    integer race_militia_ability = 'Amil'  // what is the militia ability id ?
    integer race_militia_hall_ability = 'Amic'  // what is the militia ability of the hall ?
    string race_militia_unitstring = "militia"  // what is the unitstring/name of the militia ?
    string race_militiaworker_unitstring = "peasant"  // what is the string of the unit that can be turned to militia ?
    boolean race_ancient_expansion_available = false  // can the race expand with an uprooted building that also helps fighting the creeps ?
    integer race_ancient_expansion_probability = 33  // how high (in percent) is the probability of doing an ancient expansion when possible ?
    integer race_ancient_expansion_strength = 15  // up to how much expansion strength is an ancient expansion allowed ?
    integer race_ancient_expansion_help_id = 'earc'  // the unit id of the unit that should help in ancient expansion
    integer race_ancient_expansion_hero_rush_level = 2  // the bonus strength value hero must have to be able to do the ancient expansion
    boolean race_item_expansion_available = false  // can expand with item building ?
    integer race_item_expansion_probability = 5 // how high (in percent) is the probability of doing a item expansion?
    integer race_item_sale_level = 0  // buy expand item need hall level ?
    integer race_item_expansion_item_id = 0  // what is expand item name(from StandardUnits.txt) ?
    boolean race_sell_ziggurats = false  // does the race sell ziggurats that are at no more needed expansions ?
    real race_ziggurat_keep_distance = 1500  // keep ziggurat if this near another building except a ziggurat is
    boolean race_build_farms_front = false  // should the race build farms towards the front (as soon as the front is computed) ?
    integer race_farms_front_limit = 4  // limit the number of farms at the front to this number
    integer race_farms_at_mine = 0  // the first that many farms will be built at the mine
    real race_max_expa_mine_distance = 850  // the maximum distance between the mine and the expansion building
    boolean race_has_moonwells = false  // Racial farms have healing properties
    integer groundid = 'ewsp'  // Used to create path units, must be different from race peon
    integer racial_burrow = 0 // Building id that can house peons/units and then shoot enemies.
    integer structid = 'ngnh'  // Used to trigger melee defeat conditions on surrender.
    integer race_ancient_barracks_rush_chance = 0  // If above 0 will set the chance to attack first nearby creep camp using an ancient building, uses the rushcreep flag in standardunits if available for race

#PRAGMA END RACIAL SETTINGS

//==============================================================
// (AMAI) Misc Properties
//==============================================================

#PRAGMA START VERSION SETTINGS
    boolean destroy_buildings_on_defeat = false  // Should the buildings of the AI be destroyed on defeat or given to neutral player ?
    integer attack_reform_length = 20  // reform the attack group (getting new units) every that time on an attack (in seconds / 2)
    real front_base_distance = 1100  // the distance of the front locations from the start location
    boolean ver_heroes = true  // Does this version have heroes?
    boolean fixedcomputername = false  // Enable to force computers to have there fixed name instead of a profile name
    integer green_creep_camp_strength_bonus = 0  // Bonus strength added to minor creep camps
    integer orange_creep_camp_strength_bonus = 5  // Bonus strength added to mediocre creep camps
    integer red_creep_camp_strength_bonus = 10  // Bonus strength added to major creep camps
    boolean disable_surrender = false  // Set to true to stop amai from giving up early when it detects its going to lose
    real strategy_change_threshold = 1.2  // New strategy priority must be larger than this (default 1.20) multiple to the current strategy prority
    boolean debugging = false  // Can turn on for debugging mode to display debug type messages
    integer major_hero_skill_value = 60  // Priority to choose the first line of hero skills
    integer minor_hero_skill_value = 30  // Priority to choose the second line of hero skills
    integer rare_hero_skill_value = 10  // Priority to choose the third line of hero skills
#PRAGMA END VERSION SETTINGS

//==============================================================
// (AMAI)  General Stuff
//==============================================================
    boolean IsAMAI = false
    boolean leadally = false

    boolean campaign_ai = false

    string language = "Chinese"
    #INCLUDETABLE <backlanguage.txt>
    string backlanguage = "%1"
    #ENDINCLUDE

    string ai_id = ""

    string message_add = ""

    real command_wait = 3

    real time_of_day = 0

    boolean water_map = false

    string array digit_map

    integer array player_race
    integer array player_race_pref
    string array race_name

    boolean game_is_ffa = false
    boolean game_is_1on1 = false


    integer total_food              = 0
    integer wood_buffer             = 0
    real    gold_income             = 0
    integer income_per_mine         = 10  // rate per second
    real    gold_unit_percentage    = 0.9
    boolean take_all_ghouls_along = false


    integer racial_peon	= 0
    integer neededPeons = 0
    integer array racial_hall
    integer array racial_goldmine
    integer minearray = 0
    integer array gold_mines_ids
    integer gold_mine_ids_size = 0
    integer array racial_zigg
    integer ziggarray = 0
    integer racial_expansion = 0
    integer racial_altar = 0
    integer racial_shop = 0
    integer racial_militia = 0
    integer racial_militiahero = 0
    integer racial_ghoul = 0
    integer racial_lumber = 0
    integer racial_rushcreep = 0
    boolean br_rush_built = false
    boolean br_rush_attacked = false
    unit rushcreep_target = null
    integer array racial_highbuild_lv2  // tier2
    integer racial_highbuild_lv2_length = 0
    integer racial_highbuild_lv2_total = 1
    integer array racial_highbuild_lv3  // tier3
    integer racial_highbuild_lv3_length = 0
    integer racial_highbuild_lv3_total = 1
    integer neutral_shredder = 0
    integer neutral_zeppelin = 0
    integer neutral_ship = 0
    integer tp_item = 0
    integer sanctuary_item = 0
    integer preservation_item = 0
    integer singe_tp_item = 0
    //boolean array herocanuse
    integer tiernum = 3
    integer mapSize = 0
    boolean firstattackhp = false  //big map or more player first attack human player?

    integer array hero
    integer array hero_skills // The skill line chosen for the hero, major, minor or rare
    integer array skills
    integer array tempskills
    integer array allskills
    integer first_choosable_hero = 0
    boolean array hero_built
    integer array hero_revive_prio
    unit array hero_unit
    integer array all_heroes
    integer array all_heroes_copy
    integer array hero_rp
    integer hero_number = 0
    integer chosen = 0

    real array action_points
    integer action_numbers = 0

    real enemy_density = 0
    location enemy_density_loc = Location(0,0)
    real ally_density = 0
    location ally_density_loc = Location(0,0)

    real nearest_enemy_range = 10000000
    player nearest_enemy = null
    player nearest_human_enemy = null

    integer array upkeep_allowed
    integer array last_upkeep_allowed
    integer array upkeep_border
    real array upkeep_goldchange
    integer array upkeep_resistance
    integer array upkeep_save_time
    integer array upkeep_time
    integer array upkeep_mines_needed

    integer array attack_qty
    integer array attack_max
    integer array attack_units
    integer attack_length           = 0

//==============================================================
    // (AMAI)  Build Variables
    //==============================================================
//    integer array build_qty
//    integer array build_type
//    integer array build_item
//    integer array build_town
    integer array build_prio
    integer array build_loc
//    integer build_length            = 0

    integer array t_build_qty
    integer array t_build_type
    integer array t_build_item
    integer array t_build_town
    integer array t_build_prio
    integer array t_build_loc
    integer t_build_length            = 0

    integer array bl_req_qty
    integer array bl_req_type
    integer array bl_allow_qty
    integer array bl_allow_type
    integer array bl_expire_time
    boolean array bl_only_done
    integer bl_length = 0
    integer blocked_gold = 0
    integer blocked_wood = 0
    integer blocked_food = 0

    integer array rbl_req_gold
    integer array rbl_req_wood
    integer array rbl_req_food   // Food required before building unit
    integer array rbl_allow_qty
    integer array rbl_allow_type
    integer array rbl_expire_time
    integer rbl_length = 0

    boolean build_lock = true
    integer array bl_tier_foodlock
    real array bl_tier_unitlock
    boolean array bl_tier_expansionblock
    boolean array bl_tier_lockactive

    //==============================================================
    // (AMAI)  Standard Unit Variables
    //==============================================================
    integer array old_id
    integer array needed1  // needed building and factory if unit
    integer array needed2  // needed building 2
    integer array needed3  // needed for upgrade level 3
    integer array build_free // free buildings
    integer array gold_sum
    integer array build_time_sum
    integer array build_num
    real array income_percentage
    integer array prio_sum
    integer array tc_add1  // building that has to be added for TownCount
    integer array tc_add2  // building that has to be added for TownCount
    integer array available_time
    integer array regenerate_time
    integer array attacking_max_num
    integer array upgrade_time
    integer array gold_price
    integer array wood_price
    integer array hero_rush_bonus
    integer array buy_type

//==============================================================
// (AMAI)  Misc Globals
//==============================================================
    integer array building
    integer building_length = 0

    integer array campaign_defenders

    integer array creep_strength
    integer creep_strength_length = 0

    unit follow_zeppelin = null
    boolean zeppelin_following = false

    boolean array neutral_available
    unit array nearest_neutral
    boolean array neutral_guarded
    integer array neutral_enemy
    boolean array neutral_ordered
    unit array neutral_sent
    boolean array neutral_night_buy
    integer array neutral_id
    real array buy_time_large
    real array buy_time_small
    integer array neutral_wanted
    boolean no_sleep = false
    integer array dragons
    integer array merc_unit
    integer merc_number = 0
    integer dragon_number = 0
#INCLUDETABLE <$VER$\MercTypes.txt>
    integer merc_%1 = 0
#ENDINCLUDE

    integer minimum_attack_strength = 11

    integer max_farms = 0

    integer exp_time_count = 0
    integer exp_first_time = 30
    integer exp_second_time = 180
    real expansion_taken_radius = 1000  // the radius around a mine where enemy or allied buildings are considered as possessing that mine (it is considered taken then)

    integer creep_camp_radius = 550
    integer camp_scan_depth = 3
    integer camp_last_checked = 40

    integer air_strength = 0
    integer array p_str_cache
    integer array p_str_cache_timeout
    integer p_str_cache_valid_time = 2

    boolean ai_no_creep = false
    boolean town_threat_break = true
    //boolean captain_flee = true

//==============================================================
// (AMAI)  Strategy System Variables
//==============================================================
    integer strategy = 0
    integer chosen_strategy = 0
    integer last_strategy = 100
    string array strategy_name
    string array strategy_default_name
    string array strategy_default_report
    integer array key_building1
    integer array key_building2
    integer array key_upgrade1
    integer array key_upgrade2
    integer array key_unit
    integer array rp_strat
    integer array rp_strat_sort
    boolean array beginning_strat
    integer array strat_minimum_time
    integer rp_strat_length = 0
    integer rp_strat_sort_length = 0
    integer small_map_tier1_bonus = 20
    real k_add_start_mult = 3
    real k_add_end_mult = 1
    real k_add_start_time = 120
    real k_add_end_time = 1200
    boolean array strategy_type_used
//    integer used_strategies = 0
    integer array strategy_type
    integer strategy_type_used_penalty = 30
    integer array strategy_tier
    integer array strategy_first_exp_time
    integer array strategy_second_exp_time
    integer array strategy_first_hero
    integer array strategy_first_hero_bonus
    integer array strategy_second_hero
    integer array strategy_second_hero_bonus
    integer array strategy_third_hero
    integer array strategy_third_hero_bonus
    integer array strategy_race_aggression

    boolean attacking_expansion = false
    boolean recalculate_heros = false // Tavern heros cannot be trained so get a normal hero
    boolean TavernResurrect = false

    integer tier = 0
    integer own_strength = 0
    integer uncertainty = 10
    integer tower_factor = 10
    integer array race_aggression
    integer array b_race_aggression
    integer added_aggression = 0  // aggression added when upkeep becomes higher
    boolean h_siege = false
    unit alli_target = null
    integer expansion_target_bonus = 7
    integer comp_chosen_target_bonus = 5
    real comp_chosen_target_rate = 0.5

    boolean balancing = false
    texttag debugstrattag = CreateTextTag()
    texttag debugcountertag = CreateTextTag()
    texttag debugjobtag = CreateTextTag()

//==============================================================
// (AMAI)  Healing System Globals
//==============================================================
    group healer_group = CreateGroup()
    boolean ward_cast = false

    group urgent_healing_group = CreateGroup()
    group medium_healing_group = CreateGroup()
    group small_healing_group = CreateGroup()
    integer urgent_healing_count = 0
    integer medium_healing_count = 0
    integer small_healing_count = 0
    boolean fountain_available = false

    integer build_emergency_healing_item = 0

    integer array healer_id
    integer array healer_spell
    integer array healer_type
    integer array healer_mana_cost
    integer array healer_upg_id
    integer array healer_upg_level
    integer healer_length = 0

//==============================================================
// (AMAI)  Misc Globals
//==============================================================
    integer array c_enemy  // number of enemy players of certain races or random
    integer c_enemy_total	= 0
    integer array c_ally  // number of allied players of certain races
    integer c_ally_total = 0
    integer c_enemy_user_total = 0  //number of enemy human player
    integer c_ally_user_total = 0  //number of ally human player
    integer c_ai_total = 0
    boolean enemy_revealed = false
    integer strat_prev = 0  // strategy chosen by the ai before this one
    integer hero_prev = 0  // hero chosen by the ai before this one
    integer picked_hero = 0
    //boolean first_ai = true
    //integer next_ai = 0
    boolean no_ai_ally = false
    boolean no_ally_ctrl = true

    boolean player_defeated	= false

#INCLUDETABLE <$VER$\Strengths.txt>
    real enemy_%1 = 0
    real ally_%1 = 0
#ENDINCLUDE


    boolean array town_built
    location array own_town_loc
    real array own_town_dist
    unit array own_town_mine
    integer first_town_mine = 0
    location array exist_town
    integer Forced_Harvest_total = 0

    integer attacking_ghouls = 0
    integer harvesting_ghouls = 0

    integer ai_time = 0

    integer tq_length = 0
    real array tq_time
    integer array tq_jid
    integer array tq_par
    unit array tq_unit_par
    group array tq_group_par
    unit array tq_unit_par2

    //hashtable tq_hashtable = InitHashtable()
    boolean tq_lock = true
    timer tq_timer = CreateTimer()

    integer pj_length = 0
    real array pj_time
    real array pj_frequency
    integer array pj_jid
    integer array pj_par
    boolean array pj_remove

    boolean attack_running = false
    boolean no_attack_allowed = false

    integer order_cancel = 851976
    integer order_attack = 851983

//==============================================================
// (AMAI)  Chatting variables
//==============================================================
    sound chatSound = CreateSound( "Sound\\Interface\\InGameChatWhat1.wav", false, false, false, 10, 10, "" )
    sound importantSound = CreateSound( "Sound\\Interface\\CreepAggroWhat1.wav", false, false, false, 10, 10, "" )

    boolean array chat_target_obs
    boolean array chat_target_ally
    boolean array chat_target_enemy
    boolean array chat_important
    string array chat_list
    string array chat_list_race
    integer array chat_list_eq
    integer chat_list_length = 0
    string chat_race = ""
    integer chat_eq = 0
    string array chat_queue
    boolean array chat_queue_importance
    player array chat_queue_player
    boolean chat_queue_locked = true
    string chat_strategy = null
    integer chat_queue_size = -1
    constant integer C_STRATEGY = 0

#INCLUDETABLE <ChatEvents.txt> #EFR
    string array chat_%1
    boolean array chat_cond_%1
    integer chat_%1_length = 0
    constant integer C_%1 = %row
#ENDINCLUDE

    string chat_no_unit_selected = ""
    string chat_confirm_attack_unit = ""
    string chat_towerrush = ""
    string chat_no_towerrush = ""
    string chat_unsuited_towerrush = ""
    string chat_stop_towerrush = ""
    string chat_dynamic_counter = ""
    string militia_expansion_chat = ""
    string invalid_strategy_number = ""

    //gamecache translation_map = InitGameCache("AMAI_TM.w3v")
    hashtable translation_map = InitHashtable()
    string array translation
    integer translation_length = 0

    //gamecache additional_info = InitGameCache("AMAI_AI.w3v") // Used for harrass data
    //gamecache com = InitGameCache("AMAI_Com.w3v")
    hashtable additional_info = InitHashtable() // For harass logic
    constant integer START_STRENGTH = 0
    constant integer AVOID_TOWERS = 1
    constant integer STRENGTH_LIMIT = 2
    constant integer STATE_ATTACKING = 3
    constant integer FLEE_PERCENT = 4
    constant integer FLEE_NUMBER = 5
    constant integer INVISIBLE_COUNT = 6
    constant integer LOCX = 7
    constant integer LOCY = 8
    constant integer STATE_RETREAT = 9
    constant integer WINDWALK_COUNT = 10
    constant integer START_STRENGTH_TEMP = 11
    constant integer HARASS_TARGET = 12
    constant integer HARASS_UNITGROUP = 13 // permanent store of the unit group
    hashtable com = InitHashtable()
    constant integer TEAM_STATEGY_INUSE = 1
    constant integer IS_AMAI = 2
    constant integer RACE = 3
    constant integer RACE_PREF = 4
    constant integer USE_SPECIAL_RACES = 5
    constant integer PROFILE_SELECTION = 6
    constant integer NEUTRAL_GUARDS = 7
    constant integer TYPECASTING = 8
    hashtable attacktable = InitHashtable() // To build custom attack groups
    constant integer CUSTOM_ATTACK = 1

    gamecache amaiCache = InitGameCache("AMAI_AI.w3v")
    constant integer PROFILE_USED = 0
    constant integer GREETINGS_NUM = 1
    constant integer CHAT_LOCK = 2
    constant integer ALLIANCE_TARGET = 3

    //gamecache settings = InitGameCache("AMAI_Set.w3v")

    string array char_table
    string array char_bug_table
    integer char_table_length = 0
    hashtable language_table = InitHashtable()
    constant integer CHAR_TABLE = 0
    constant integer CHAT_VARS_TABLE = 1
    string array chat_vars
    integer chat_vars_length = 1
    //gamecache chat_vars_map = InitGameCache("AMAI_CVM.w3v")
    //hashtable chat_vars_map = InitHashtable()

//===========================================================================
// (AMAI)  Job variables
//===========================================================================
#DEFINE GLOBAL
#INCLUDETABLE <Jobs.txt> #EFR
  #INCLUDESCRIPT <Jobs\%1.eai>
#ENDINCLUDE
#UNDEF GLOBAL

//===========================================================================
// (AMAI)  Variables for controlling the AI (different states)
//===========================================================================

    boolean console_on = false
    boolean creeping_only = false

    boolean break_attack 	= false
    boolean go_home		= false
    boolean attack_player	= false
    boolean attack_point	= false
    boolean attack_unit		= false
    boolean no_attack		= false
    boolean no_creep_attack	= false
    boolean no_player_attack	= false
    boolean strat_change_allowed = true
    integer attack_target_p	= 0
    integer attack_target_x	= 0
    integer attack_target_y	= 0
#INCLUDETABLE <$VER$\CommandBuilds.txt> #EFR
    integer bn_%1 = 0
#ENDINCLUDE
    unit 	target_unit = null
    integer array target_queue_x
    integer array target_queue_y
    unit    array target_queue_u
    integer queue_length	= 0
    integer queue_pointer	= 0
    boolean queue_running	= false
    boolean queue_attack_p	= false
    boolean queue_attack_u	= false
    integer queue_t_x		= 0
    integer queue_t_y		= 0
    unit	queue_t_u = null

    real lastcaptainx = 0
    real lastcaptainy = 0

//==============================================================
// (AMAI)  Profile system globals
//==============================================================

    integer profile_length      = 0
    integer profile            = 0
    integer debug_profile = -1

    string ai_name = "Computer"
    integer own_race = 0
    real taunt_rate = 1.00 // how man % of the time computers taunt, set by profiles. Recommended values 0.50 to 1.50
    integer taunt_start_time = 60  // the time for the computers to start taunting (in seconds * 5)
    integer farm_food = 8 // build farm when this near food used to food produced
    integer strat_persistence = 1000  // extra priority to the current strategy to make computer not change strategy too fast

    // Profile settings
    string array profilename
    integer array fav_hero
    integer array fav_unit
    integer array p_race  // Desired race for the profile to be picked (default random)
    integer array p_aggression  // aggression modify to total attacking_aggression. reccomended -10 to 10
    integer array p_uncertainty  // adds or subtracts this value to the enemies strength every so often. reccomended 5 to 15
    integer array p_minimum_attack_strength  // How much strength required before amai can start attacking. reccomended 3 to 6
    integer array p_farm_food  // How much food to have left before building a new farm
    integer array p_exp_first_time  // Make amai build expansion earlier or later by this number of seconds. reccomended -10 to 10
    integer array p_exp_second_time
    integer array p_strat_persistence  // How persistance amai is to keep its current strategy. reccomended 1.05 to 2.00
    integer array p_expansion_target_bonus  // aggression bonus for expansion targets
    integer array p_comp_chosen_target_bonus  // aggression bonus for targets chosen by the hard coded AI
    integer array p_surrender  // How likly amai will give up, 0 being never give up and 4 being give up really easily
    integer array p_rare // Ensures the profile is rarely picked
    real array p_gold_unit_percentage  // The higher this is the more unit production buildings are constructed. reccomended 0.9 to 1
    real array p_taunt_rate // Will display a taunt every 5th second for this percent of the time. Reccomended 1 to 2
//    real taunt_rate = 1.00 // how man % of the time computers taunt, set by profiles. Recommended values 0.50 to 1.50
//    integer taunt_start_time = 60  // the time for the computers to start taunting (in seconds * 5)
    real array p_comp_chosen_target_rate  // how often the computer considers an attack target chosen by the hard coded AI

//==============================================================
// (AMAI)  Pathing variables
//==============================================================

    real path_top = GetCameraBoundMaxY()+GetCameraMargin(CAMERA_MARGIN_TOP)
    real path_bottom = GetCameraBoundMinY()-GetCameraMargin(CAMERA_MARGIN_BOTTOM)
    real path_left = GetCameraBoundMinX()-GetCameraMargin(CAMERA_MARGIN_LEFT)
    real path_right = GetCameraBoundMaxX()+GetCameraMargin(CAMERA_MARGIN_RIGHT)
    //rect playable_rect = Rect(path_left, path_bottom, path_right, path_top)

    unit array expansion_list
    location array expansion_ancient
    real array expansion_dist
    hashtable expansion_creeps = InitHashtable()
    integer expansion_list_length = 0

    unit array water_expansion_list
    integer water_expansion_list_length = 0
    real array water_expansion_dist
    group water_expansion = CreateGroup()
    hashtable water_expansion_creeps = InitHashtable()
    group far_expansion = CreateGroup()

    unit expansion_peon = null
    unit build_zeppelin = null
    //location exp_loc_cache = Location(0,0)
    integer exp_loc_cache_timeout = 0

    integer exp_number = 0
    integer array exp_rp
    unit array exp_unit
    real array exp_dist
    location array exp_ancient
    integer array exp_creeps
    boolean array exp_iswater

    integer current_expansion_creeps = 0
    boolean current_expansion_iswater = false
    unit current_expansion = null
    boolean specialexpand = false
    unit fixmine = null
    integer fixharvest = 0
    boolean first_expansion_chosen = false
    unit not_taken_expansion = null  // used to MultipleMinefix , militai expansion , ancient expansion and item expansion system
    unit chaos_expansion = null
    boolean chaos_expansion_run = false
    boolean pathing_done = false

    integer confirm_count = 0
    integer array ai_force
    integer ai_force_length = 0
    boolean pathing_receive_finished = false

    integer home_field = 0

    location mine_loc = null
    location array front_loc   // the locations along the frontier of the main base (on the way to the enemies and a certain distance from the base)
    integer front_loc_num = 0  // the number of front locations
    boolean front_locs_computed = false  // are the front points computed ?

//==============================================================
// (AMAI)  Debug variables
//==============================================================
    integer udg_unique_counter = 0
    gamecache udg_debug_cache = null
    string udg_current_category = null
    timer udg_debug_timer = CreateTimer()
    boolean job_debug = false  // Job system reports will be displayed (used for finding thread crashes)
    integer debug_player = 0

//==============================================================
// (AMAI)  Dynamic Strategy variables
//==============================================================
    integer chosen_counter = -1
    integer chosen_counter_unit = 0
    boolean no_counter = true
    string array strengthtext
    #INCLUDETABLE <$VER$\Strengths.txt>
    integer array dyanti_%1
    integer totalanti_%1 = 0
    integer array dychance_%1
    integer totalchance_%1 = 0
    boolean dydistribute_%1 = false
    #ENDINCLUDE

    #DEFINE GLOBAL
    #INCLUDESCRIPT <custom_common.eai>
    #UNDEF GLOBAL

endglobals

    #INCLUDESCRIPT <custom_common.eai>
//_________________________________________________________________________________________________________________________________________________
//_________________________________________________________________________________________________________________________________________________
  // Global Utility Functions ( A collection of functions used for debugging and
  // language utilities. Also contains the algorithm functions e.g. hashmaps etc)

//============================================================================
// (AMAI)  Debug Functions
//============================================================================
//function H2I takes handle h returns integer
//  return h
//  return 0
//endfunction

function I2U takes integer i returns unit
  call SaveFogStateHandle(com, TYPECASTING, 0, ConvertFogState(i))
  return LoadUnitHandle(com, TYPECASTING, 0)
endfunction

//function SetHandleHandle takes handle subject, string name, handle value returns nothing
//    if value==null then
//        call FlushStoredInteger(LocalVars(),I2S(H2I(subject)),name)
//    else
//        call StoreInteger(LocalVars(), I2S(H2I(subject)), name, H2I(value))
//    endif
//endfunction

//function SetHandleInt takes handle subject, string name, integer value returns nothing
//    if value==0 then
//        call FlushStoredInteger(LocalVars(),I2S(H2I(subject)),name)
//    else
//        call StoreInteger(LocalVars(), I2S(H2I(subject)), name, value)
//    endif
//endfunction

//function SetHandleReal takes handle subject, string name, real value returns nothing
//    if value==0 then
//        call FlushStoredReal(LocalVars(), I2S(H2I(subject)), name)
//    else
//        call StoreReal(LocalVars(), I2S(H2I(subject)), name, value)
//    endif
//endfunction

//function SetHandleString takes handle subject, string name, string value returns nothing
//    if value==null then
//        call FlushStoredString(LocalVars(), I2S(H2I(subject)), name)
//    else
//        call StoreString(LocalVars(), I2S(H2I(subject)), name, value)
//    endif
//endfunction

//function GetHandleInt takes handle subject, string name returns integer
//    return GetStoredInteger(LocalVars(), I2S(H2I(subject)), name)
//endfunction
//function GetHandleBoolean takes handle subject, string name returns boolean
//   return GetStoredBoolean(LocalVars(), I2S(H2I(subject)), name)
//endfunction
//function GetHandleReal takes handle subject, string name returns real
//    return GetStoredReal(LocalVars(), I2S(H2I(subject)), name)
//endfunction
//function GetHandleString takes handle subject, string name returns string
//    return GetStoredString(LocalVars(), I2S(H2I(subject)), name)
//endfunction

//function FlushHandleLocals takes handle subject returns nothing
//    call FlushStoredMission(LocalVars(), I2S(H2I(subject)) )
//endfunction

//============================================================================
//function String2Int takes string s returns integer
//  return s
//  return 0
//endfunction

//============================================================================
function DoNothing takes nothing returns nothing
endfunction

//============================================================================
// Properly clear the game caches to make sure they are empty on use
function InitAMAIGameCache takes nothing returns nothing
  //call FlushGameCache(InitGameCache("AMAI_TM.w3v"))
  //call FlushGameCache(amaiCache)  // Do not flush as breaks further use of the cache
  //call FlushGameCache(InitGameCache("AMAI_Com.w3v"))
  //call FlushGameCache(InitGameCache("AMAI_Set.w3v"))
  //call FlushGameCache(InitGameCache("AMAI_CVM.w3v"))
  //set translation_map = InitHashtable()
  //set additional_info = InitGameCache("AMAI_AI.w3v")
  //set com = InitHashtable()
  //set settings = InitGameCache("AMAI_Set.w3v")
  //set chat_vars_map = InitHashtable()
endfunction

#INCLUDE <playercolors.j>

//============================================================================
function c2s takes playercolor c returns string
  return cs2s(ai_name, c) + ": "
endfunction

//===========================================================================
// Converts a percentage (real, 0..100) into a scaled integer (0..max),
// clipping the result to 0..max in case the input is invalid.
//
function AMAIPercentToInt takes real percentage, integer max returns integer
  local integer result = R2I(percentage * I2R(max) * 0.01)

  if (result < 0) then
    set result = 0
  elseif (result > max) then
    set result = max
  endif

  return result
endfunction

//===========================================================================
function AMAIPercentTo255 takes real percentage returns integer
  return AMAIPercentToInt(percentage, 255)
endfunction

//===========================================================================
function SetDebugTagColor takes texttag tt returns nothing
  local playercolor c = GetPlayerColor(ai_player)
  if c == PLAYER_COLOR_RED then
    call SetTextTagColor(tt, 255, 0, 0, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_BLUE then
    call SetTextTagColor(tt, 0, 100, 255, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_CYAN then
    call SetTextTagColor(tt, 27, 231, 186, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_PURPLE then
    call SetTextTagColor(tt, 85, 0, 129, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_YELLOW then
    call SetTextTagColor(tt, 255, 252, 0, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_ORANGE then
    call SetTextTagColor(tt, 255, 138, 13, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_GREEN then
    call SetTextTagColor(tt, 32, 191, 0, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_PINK then
    call SetTextTagColor(tt, 228, 92, 175, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_LIGHT_GRAY then
    call SetTextTagColor(tt, 148, 150, 150, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_LIGHT_BLUE then
    call SetTextTagColor(tt, 126, 191, 241, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_AQUA then
    call SetTextTagColor(tt, 19, 98, 71, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_MAROON then
    call SetTextTagColor(tt, 156, 0, 0, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_NAVY then
    call SetTextTagColor(tt, 0, 0, 195, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_TURQUOISE then
    call SetTextTagColor(tt, 0, 235, 255, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_VIOLET then
    call SetTextTagColor(tt, 189, 0, 255, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_WHEAT then
    call SetTextTagColor(tt, 236, 205, 135, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_PEACH then
    call SetTextTagColor(tt, 247, 165, 139, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_MINT then
    call SetTextTagColor(tt, 191, 255, 129, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_LAVENDER then
    call SetTextTagColor(tt, 219, 185, 235, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_COAL then
    call SetTextTagColor(tt, 79, 80, 85, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_SNOW then
    call SetTextTagColor(tt, 236, 240, 255, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_EMERALD then
    call SetTextTagColor(tt, 0, 120, 30, AMAIPercentTo255(100-0))
  elseif c == PLAYER_COLOR_PEANUT then
    call SetTextTagColor(tt, 165, 112, 51, AMAIPercentTo255(100-0))
  else // PLAYER_COLOR_BROWN
    call SetTextTagColor(tt, 79, 43, 5, AMAIPercentTo255(100-0))
  endif
  set c = null
endfunction

function UpdateDebugTextTag takes texttag tt, string s, real fontsize, real posx, real posy returns nothing
  if debugging then
    call SetTextTagText(tt, s, ( fontsize * 0.023 / 10))  // *0.023/10 creates the correct font size from given real
    call SetTextTagPos(tt, posx, posy, 0)
    call SetDebugTagColor(tt)
  endif
endfunction

function CreateDebugTagLoc takes string s, real fontsize, real posx, real posy, real lifespan, real fadespan returns nothing
	local texttag tt = null

	if debugging then
		set tt = CreateTextTag()
		call SetTextTagText(tt, s, ( fontsize * 0.023 / 10))  // *0.023/10 creates the correct font size from given real
		call SetTextTagPos(tt, posx, posy, 0)
		call SetDebugTagColor(tt)
		call SetTextTagPermanent(tt, false)
		call SetTextTagLifespan(tt, lifespan)
		call SetTextTagFadepoint(tt, fadespan)
		set tt = null
	endif
endfunction

// Create a texttag over a specific unit for a certain amount of time
function CreateDebugTag takes string s, real fontsize, unit u, real lifespan, real fadespan returns nothing
	local texttag tt = null

	if debugging then
		set tt = CreateTextTag()
		call SetTextTagText(tt, s, ( fontsize * 0.023 / 10))  // *0.023/10 creates the correct font size from given real
		call SetTextTagPosUnit(tt, u, 0)
		call SetDebugTagColor(tt)
		call SetTextTagPermanent(tt, false)
		call SetTextTagLifespan(tt, lifespan)
		call SetTextTagFadepoint(tt, fadespan)
		set tt = null
	endif
endfunction


//============================================================================
// (AMAI)	Int2Str
//  Converts and integer number to a string (This only works for actual integer numbers)
//  Cannot use native I2S in any AI related code
//  for unit ids etc you must use common.j natives
//============================================================================
function InitDigits takes nothing returns nothing
  set digit_map[0] = "0"
  set digit_map[1] = "1"
  set digit_map[2] = "2"
  set digit_map[3] = "3"
  set digit_map[4] = "4"
  set digit_map[5] = "5"
  set digit_map[6] = "6"
  set digit_map[7] = "7"
  set digit_map[8] = "8"
  set digit_map[9] = "9"
endfunction

function Int2Str takes integer ic returns string
  local string s = ""
  local integer i = ic
  local integer ialt = 0
  local boolean neg = false

  if digit_map[0] == null then
    call InitDigits() // If called before digits has been initialized do it ourselves.
  endif

  if i == 0 then
    set s = null
    return "0"
  endif
  if i < 0 then
    set neg = true
    set i = i * -1
  endif
  loop
    exitwhen i < 1
    set ialt = i
    set i = i / 10
    set s = digit_map[ ialt - 10*i ] + s
  endloop
  if neg then
    return "-"+s
  endif
  return s
endfunction

function Real2Str takes real num returns string
  local string s = ""
  local real r = num

  set s = Int2Str(R2I(r))
  set r = r - R2I(r) // Remove the integer bit to leave the decimal
  if r > 0 then
    set s = s + "." // The decimal point
    set r = r * 1000 // 3 decimal places
    set s = s + Int2Str(R2I(r))
  endif
  return s
endfunction

//============================================================================
// (AMAI)	More Debug functions
//============================================================================
function B2S takes boolean b returns string
  if b then
    return "true"
  else
    return "false"
  endif
endfunction

//============================================================================
function DebugSequenceStart takes string name returns nothing
  //call FlushGameCache(udg_debug_cache)
  set udg_debug_cache = InitGameCache("Debug.w3v")
  set udg_current_category = Int2Str(GetRandomInt(1, 100000000))
  call TimerStart(udg_debug_timer, 1000000, false, null)
  call StoreString(udg_debug_cache, udg_current_category, "Debug0", "SequenceStart "+name)
  set udg_unique_counter = 1
endfunction

//============================================================================
function DebugSequenceEnd takes nothing returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), "SequenceEnd")
  call SaveGameCache(udg_debug_cache)
endfunction

//============================================================================
function DumpString takes string label, string s returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), label)
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter+1), s)
  set udg_unique_counter = udg_unique_counter + 2
endfunction

//============================================================================
function DumpInteger takes string label, integer i returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), label)
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter+1), Int2Str(i))
  set udg_unique_counter = udg_unique_counter + 2
endfunction

//============================================================================
function DumpReal takes string label, real r returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), label)
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter+1), Int2Str(R2I(r * 1000)))
  set udg_unique_counter = udg_unique_counter + 2
endfunction

//============================================================================
function DumpBoolean takes string label, boolean b returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), label)
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter+1), B2S(b))
  set udg_unique_counter = udg_unique_counter + 2
endfunction

//============================================================================
function DumpHandle takes string label, handle h returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), label)
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter+1), Int2Str(GetHandleId(h)))
  set udg_unique_counter = udg_unique_counter + 2
endfunction

//============================================================================
function EndDump takes string label returns nothing
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter), "EndDump "+label)
  call StoreString(udg_debug_cache, udg_current_category, "Debug"+Int2Str(udg_unique_counter+1), Int2Str(R2I(TimerGetElapsed(udg_debug_timer)*1000)))
  set udg_unique_counter = udg_unique_counter + 2
endfunction

//============================================================================
function DumpMessage takes string label, string s returns nothing
  call DumpString("Message", s)
  call EndDump(label)
endfunction

//============================================================================
// (AMAI) Language Translation/ Chat functions
//============================================================================
function AddTrans takes string lang, string key, string value returns nothing

  set translation[translation_length] = value
  call SaveInteger(translation_map, StringHash(lang), StringHash(key), translation_length)
  set translation_length = translation_length + 1

endfunction

//============================================================================
function ApplyTrans takes string s returns string
  //local integer transnum = LoadInteger(translation_map, StringHash(language), StringHash(s))
  //if transnum != null then
  local string trans = null
  local integer l = StringHash(language)
  local integer c = StringHash(s)
  if HaveSavedInteger(translation_map, l, c) then
    //return translation[transnum]
    set trans = translation[LoadInteger(translation_map, l, c)]
  endif
  set l = StringHash(backlanguage)
  if (trans == null or trans == "") and HaveSavedInteger(translation_map, l, c) then // Backup translate to english
    set trans = translation[LoadInteger(translation_map, l, c)]
  endif
  if (trans == null or trans == "") then
    //call DisplayTimedTextToPlayer(Player(0),0,0,15,message_add+s+":handle not saved")
    set trans = null
    return s
  else
    return trans
  endif
endfunction

//============================================================================
function InitTrans takes nothing returns nothing
  local string lang = ""
#INCLUDETABLE <Languages.txt> #EFR
  set lang = "%1"
  #INCLUDETABLE <Languages\%1\Translations.txt> #ENC:%4 #EFR
  call AddTrans(lang, "%1", "%2")
  #ENDINCLUDE
  #INCLUDETABLE <Languages\%1\Strengths.txt> #ENC:%4 #EFR
  call AddTrans(lang, "%1", "%2")
  #ENDINCLUDE
#ENDINCLUDE
  set lang = null
endfunction

// call SetSoundDuration( chatSound, 208 )

//============================================================================
function DisplayToAll takes string s returns nothing
  if GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING or IsPlayerObserver(GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToAllImportant takes string s returns nothing
  if GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING or IsPlayerObserver(GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(importantSound)
  endif
endfunction

//============================================================================
function DisplayToAllies takes string s returns nothing
  if IsPlayerAlly(ai_player,GetLocalPlayer()) and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToAlliesImportant takes string s returns nothing
  if IsPlayerAlly(ai_player,GetLocalPlayer()) and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(importantSound)
  endif
endfunction

//============================================================================
function DisplayToEnemy takes string s returns nothing
  if IsPlayerEnemy(ai_player,GetLocalPlayer()) and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToEnemyImportant takes string s returns nothing
  if IsPlayerEnemy(ai_player,GetLocalPlayer()) and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(importantSound)
  endif
endfunction

//============================================================================
function DisplayToObservers takes string s returns nothing
  if IsPlayerObserver(GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToObserversImportant takes string s returns nothing
  if IsPlayerObserver(GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(importantSound)
  endif
endfunction

//============================================================================
// Just a general debugging system.
//============================================================================

//function SAddI takes string message, integer val returns string
// Unfortunatly disabled as translation system causes substring to return incorrect values
//	local integer start = 0
//	local integer end = 2
//	local string temp = ""
//	local string newstring = ""
//	local integer length = StringLength(message)

//	loop
//		exitwhen end > length + 1
//		set temp = SubString(message, start, end)
//		call DisplayToAll(temp)
//		if temp == "%d" then
//			if start - 1 < 0 then
//				set start = 0
//			else
//				set start = start - 1
//			endif
//			if end + 1 > length then
//				set end = length
//			else
//				set end = end + 1
//			endif
//			set newstring = SubString(message,1,start) + I2S(val) + SubString(message,end, length)
//			call DisplayToAll("returned full string")
//			return newstring
//		endif
//		set start = start + 1
//		set end = end + 1
//	endloop
//	return message  // So still works if you use wrong Trace function
//endfunction

//============================================================================
// Only displays messages originating from a particular ai player
//============================================================================
function DisplayToAllFromPlayer takes string s, integer playernum, boolean important returns nothing
	local integer i = 0
	local string m = message_add+s
	local player p = null
	if GetAiPlayer() == playernum then
		loop
			set p = Player(i)
			if GetPlayerSlotState(p) == PLAYER_SLOT_STATE_PLAYING or IsPlayerObserver(p) then
				call DisplayTimedTextToPlayer(p,0,0,15,m)
			endif
			set i = i + 1
			exitwhen i >= GetBJMaxPlayers()
		endloop
		set p = null
		if important then
			call StartSound(importantSound)
		else
			call StartSound(chatSound)
		endif
	endif
	set m = null
endfunction

function UpdateDebugPlayer takes nothing returns nothing
  local integer i = GetBJMaxPlayers()
  local player p = Player(debug_player)
  if IsPlayerObserver(p) == true then
    if debug_player >= i then
      set debug_player = i // Do not go above MaxPlayers
    else
      set debug_player = debug_player + 1
    endif
  endif
  if GetPlayerUnitCount(p, true) == 0 then
    if debug_player >= i then
      set debug_player = i
    else
      set debug_player = debug_player + 1
    endif
  endif
  //if GetChar(GetPlayerName(p), 1) != "A" then
    //if debug_player >= i then
    //  set debug_player = i
    //else
    //  set debug_player = debug_player + 1   // If not containing AMAI in player name increment until it is
    //endif
  //endif
  if GetPlayerSlotState(p) != PLAYER_SLOT_STATE_PLAYING then
    if debug_player >= i then
      set debug_player = i
    else
      set debug_player = debug_player + 1
    endif
  endif
  set p = null
endfunction

function TracePlayer takes string s, integer playernum returns nothing
	if debugging then
		call DisplayToAllFromPlayer(s, playernum, false)
	endif
endfunction

//============================================================================
function Trace takes string s returns nothing
	if debugging then
		call UpdateDebugPlayer()
		call DisplayToAllFromPlayer(s, debug_player, false)
	endif
	// Blizzard ai part
	if trace_on then
		call DisplayText(GetAiPlayer(),s)
	endif
endfunction

function TraceAll takes string s returns nothing
  if debugging then
    call DisplayToAll(s)
  endif
endfunction

//============================================================================
function TraceI takes string s, integer val returns nothing
	if debugging then
		call UpdateDebugPlayer()
		call DisplayToAllFromPlayer(s+":"+Int2Str(val), debug_player, false)
	endif
	if trace_on then
		call DisplayTextI(GetAiPlayer(),s,val)
	endif
endfunction

//============================================================================
function TraceII takes string message, integer v1, integer v2 returns nothing
	if debugging then
		call UpdateDebugPlayer()
		call DisplayToAllFromPlayer(message+":"+Int2Str(v1)+":"+Int2Str(v2), debug_player, false)
	endif
	if trace_on then
		call DisplayTextII(GetAiPlayer(),message,v1,v2)
	endif
endfunction

//============================================================================
function TraceIII takes string message, integer v1, integer v2, integer v3 returns nothing
	if debugging then
		call UpdateDebugPlayer()
		call DisplayToAllFromPlayer(message+":"+Int2Str(v1)+":"+Int2Str(v2)+":"+Int2Str(v3), debug_player, false)
	endif
	if trace_on then
		call DisplayTextIII(GetAiPlayer(),message,v1,v2,v3)
	endif
endfunction

//============================================================================
//  A specialised debugging sytem. Modify the player number for work on
//  replays where the job system crashes to display when jobs run
//============================================================================
function DisplayToAllJobDebug takes string s returns nothing
  if job_debug then
    call DisplayToAllFromPlayer(s, debug_player, false)
  endif
endfunction

//============================================================================
function DisplayToAlliesChat takes string s returns nothing
  if chatting and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING and IsPlayerAlly(ai_player,GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToEnemyChat takes string s returns nothing
  if chatting and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING and IsPlayerEnemy(ai_player,GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToAlliesDebug takes string s returns nothing
  if debugging and GetPlayerSlotState(GetLocalPlayer()) == PLAYER_SLOT_STATE_PLAYING and IsPlayerAlly(ai_player,GetLocalPlayer()) then
    call DisplayTimedTextToPlayer(GetLocalPlayer(),0,0,15,message_add+s)
    call StartSound(chatSound)
  endif
endfunction

//============================================================================
function DisplayToPlayer takes string s, player p, boolean important returns nothing
  //if p == GetLocalPlayer() then
    call DisplayTimedTextToPlayer(p,0,0,15,message_add+s)
    if important then
      call StartSound(importantSound)
    else
      call StartSound(chatSound)
    endif
  //endif
endfunction

//============================================================================
// (AMAI) Utility Functions
//============================================================================
// AI function
function PlayerEx takes integer slot returns player
  return Player(slot-1)
endfunction

function Abs takes integer a returns integer
  if a >= 0 then
    return a
  else
    return a * -1
  endif
endfunction

function RAbs takes real a returns real
  if a >= 0 then
    return a
  else
    return a * -1
  endif
endfunction

// Ai Function
function Min takes integer A, integer B returns integer
  if A < B then
    return A
  else
    return B
  endif
endfunction

function RMin takes real A, real B returns real
  if A < B then
    return A
  else
    return B
  endif
endfunction

// Ai Function
function Max takes integer A, integer B returns integer
  if A > B then
    return A
  else
    return B
  endif
endfunction

function RMax takes real A, real B returns real
  if A > B then
    return A
  else
    return B
  endif
endfunction

//===========================================================================
// Calculate the modulus/remainder of (dividend) divided by (divisor).
// Examples:  18 mod 5 = 3.  15 mod 5 = 0.  -8 mod 5 = 2.
//
function ModuloInteger takes integer dividend, integer divisor returns integer
  local integer modulus = dividend - (dividend / divisor) * divisor

  // If the dividend was negative, the above modulus calculation will
  // be negative, but within (-divisor..0).  We can add (divisor) to
  // shift this result into the desired range of (0..divisor).
  if (modulus < 0) then
    set modulus = modulus + divisor
  endif

  return modulus
endfunction

//===========================================================================
// Calculate the modulus/remainder of (dividend) divided by (divisor).
// Examples:  13.000 mod 2.500 = 0.500.  -6.000 mod 2.500 = 1.500.
//
function ModuloReal takes real dividend, real divisor returns real
  local real modulus = dividend - I2R(R2I(dividend / divisor)) * divisor

  // If the dividend was negative, the above modulus calculation will
  // be negative, but within (-divisor..0).  We can add (divisor) to
  // shift this result into the desired range of (0..divisor).
  if (modulus < 0) then
    set modulus = modulus + divisor
  endif

  return modulus
endfunction

//============================================================================
function GetRandomDiff takes integer maxdiff returns integer
  if GetRandomInt(0,1) == 1 then
    return GetRandomInt(0,maxdiff)
  else
    return GetRandomInt(0,maxdiff) * -1
  endif
endfunction

//============================================================================
function ISign takes nothing returns integer
  if GetRandomInt(0,1) == 1 then
    return 1
  else
    return -1
  endif
endfunction

//============================================================================
function LinearInterpolation takes real x1, real x2, real y1, real y2, real p returns real
  local real i = x2 - x1
  if p <= x1 then
    return y1
  elseif p >= x2 then
    return y2
  else
    if i == 0 then
      set i = 1
    endif
    return y1 + ((p - x1) / (i)) * (y2 - y1)
  endif
endfunction

// This is just size of hashtable not total number of real units
// If storing other things in hashtable start value can be set to start later.
function UnitHashtableSize takes hashtable ht, integer key, integer start returns integer
  return LoadInteger(ht, key, start)
endfunction
// Persist units into a hash table for long term storage
// normal groups units become null when they die which makes iterating them later impossible
function AddUnitsToHashtable takes hashtable ht, integer key, integer start, group gunits returns hashtable
  local integer i = UnitHashtableSize(ht, key, start) + start
  local unit u = null
  loop
    set u = FirstOfGroup(gunits)
    exitwhen u == null
    set i = i + 1
    call SaveUnitHandle(ht, key, i, u)
    call GroupRemoveUnit(gunits, u)
  endloop
  call SaveInteger(ht, key, start, i - start) // First number is the group size
  return ht
endfunction
// Only returns valid units, null entries are ignored
function ReturnUnitsOfHashtable takes hashtable ht, integer key, integer start, group gunits returns group
  local integer size = UnitHashtableSize(ht, key, start) + start
  local integer i = start
  local unit u = null
  call GroupClear(gunits)
  if size - start <= 0 then
    return gunits
  endif
  loop
    exitwhen i >= size
    set i = i + 1
    set u = LoadUnitHandle(ht, key, i)
    if u != null then
      call GroupAddUnit(gunits, u)
    endif
  endloop
  set u = null
  return gunits
endfunction
function ReturnLivingUnitsOfHashtable takes hashtable ht, integer key, integer start, group gunits returns group
  local integer size = UnitHashtableSize(ht, key, start) + start
  local integer i = start
  local unit u = null
  call GroupClear(gunits)
  if size - start <= 0 then
    return gunits
  endif
  loop
    exitwhen i >= size
    set i = i + 1
    set u = LoadUnitHandle(ht, key, i)
    if u != null and UnitAlive(u) then
      call GroupAddUnit(gunits, u)
    endif
  endloop
  set u = null
  return gunits
endfunction
// Remove dead entries to make iteration more optimal in the future
function FlushUnitHashtable takes hashtable ht, integer key, integer start returns hashtable
  local integer size = UnitHashtableSize(ht, key, start) + start
  local integer i = start
  local group g = null
  if size - start <= 0 then
    return ht
  endif
  set g = CreateGroup()
  set g = ReturnUnitsOfHashtable(ht, key, start, g)
  loop
    exitwhen i >= size
    set i = i + 1
    call RemoveSavedHandle(ht, key, i)
  endloop
  set ht = AddUnitsToHashtable(ht, key, start, g)
  call DestroyGroup(g)
  set g = null
  return ht
endfunction

function RemoveUnitFromHashtable takes hashtable ht, integer key, integer start, unit u returns hashtable
  local integer size = UnitHashtableSize(ht, key, start) + start
  local integer i = start
  local group g = null
  if size - start <= 0 then
    return ht
  endif
  set g = CreateGroup()
  set g = ReturnUnitsOfHashtable(ht, key, start, g)
  call GroupRemoveUnit(g, u)
  loop
    exitwhen i >= size
    set i = i + 1
    call RemoveSavedHandle(ht, key, i)
  endloop
  set ht = AddUnitsToHashtable(ht, key, start, g)
  call DestroyGroup(g)
  set g = null
  return ht
endfunction

//============================================================================
// These utility functions return the rescource cost correctly for upgraded units/buildings
function GetUnitGoldCost2 takes integer id returns integer
  if needed3[id] == UPGRADED then
    return GetUnitGoldCost(old_id[id]) - GetUnitGoldCost(old_id[needed1[id]])
  else
    return GetUnitGoldCost(old_id[id])
  endif
endfunction

function GetUnitWoodCost2 takes integer id returns integer
  if needed3[id] == UPGRADED then
    return GetUnitWoodCost(old_id[id]) - GetUnitWoodCost(old_id[needed1[id]])
  else
    return GetUnitWoodCost(old_id[id])
  endif
endfunction

//============================================================================
// Get a peon. Should be used if you really need a peon and GetExpansionPeon failed
function GetExpansionPeon2 takes unit u returns unit
  local group g = CreateGroup()
  local integer id = 0
  local integer h = OrderId("harvest")
  local integer rh = OrderId("resumeharvesting")
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  call GroupRemoveUnit(g, expansion_peon)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set id = GetUnitCurrentOrder(u)
    exitwhen GetUnitTypeId(u) == old_id[racial_peon] and UnitAlive(u) and (id == h or id == rh or id == 0) and not IsUnitHidden(u) and not IsUnitLoaded(u)
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
  return u
endfunction

//============================================================================
// (AMAI)	CharTable Functions
//============================================================================
function LookupCT takes string s returns string
  //local integer i = StringHash(s)
  local integer i = 0
  //local string storedstring = ""
  //if (i >= JASS_MAX_ARRAY_SIZE) then
  // 	set i = i - (i/(JASS_MAX_ARRAY_SIZE-1) - 1) * JASS_MAX_ARRAY_SIZE
  //set i = i - (i/JASS_MAX_ARRAY_SIZE)*JASS_MAX_ARRAY_SIZE
  //endif

  loop
    exitwhen i >= char_table_length
    if (s == char_bug_table[i]) then
      //call DisplayTimedTextToPlayer(Player(0),0,0,15,message_add+"1:Char Match:" + s + " With stored char:" + char_table[i])
      return char_table[i]
    endif
    set i = i + 1
  endloop

  return ""
  // set storedstring = LoadStr(language_table, CHAR_TABLE, StringHash(s))
  // if (storedstring == null) then
  // return ""
  // else
    // //call DisplayTimedTextToPlayer(Player(0),0,0,15,message_add+"2:Char match:" + s + " With stored char:" + storedstring)
  // return storedstring
  // endif
endfunction

//============================================================================
function AddToCT takes string s returns nothing
// Substring dosn't work in ai code and returns strange values in Jass (but is the same value so we do a comparison of the substring value then return the actual character
// Outright crashes in LUA mode
  local string firstchar = s //SubString(s,0,1)
  local integer i = 0
  if (firstchar == null) then
    set firstchar = ""
  endif
  call Trace("Add char: " + firstchar)
  set i = StringHash(firstchar)
  call Trace("String hash " + Int2Str(i))
  //if (i >= JASS_MAX_ARRAY_SIZE) then
  //set i = i - (i/(JASS_MAX_ARRAY_SIZE-1) - 1) * JASS_MAX_ARRAY_SIZE
  //set i = i - (i/JASS_MAX_ARRAY_SIZE)*JASS_MAX_ARRAY_SIZE
  //endif

  set char_bug_table[char_table_length] = firstchar
  set char_table[char_table_length] = s
  set char_table_length = char_table_length + 1
  call SaveStr(language_table, CHAR_TABLE, i, s)
  //call DisplayTimedTextToPlayer(Player(0),0,0,15,message_add+s+" Hash:"+Int2Str(i)+": Returned:"+LoadStr(language_table, CHAR_TABLE, i))
  set firstchar = null
endfunction

//============================================================================
function GetChar takes string s, integer num returns string
  local string linechar = s //SubString(s, num, num + 1)
  return LookupCT(linechar)
endfunction

//============================================================================
function InitCT takes nothing returns nothing
  set chat_vars[0] = ""
#INCLUDETABLE <Languages\StandardCharTable.txt> #NOUTF8
  call Trace("Adding char:%1")
  call AddToCT("%1")
#ENDINCLUDE
  call AddToCT("#")
  call AddToCT("\"") //"
  call AddToCT("\\")
  // chinese punctuation
  call AddToCT("。")
  call AddToCT("，")
  call AddToCT("？")
  call AddToCT("、")
  call AddToCT("！")
  call AddToCT("《")
  call AddToCT("》")
  call AddToCT("（")
  call AddToCT("）")
  call AddToCT("：")
  call AddToCT("；")
  call AddToCT("‘")
  call AddToCT("’")
  call AddToCT("“")
  call AddToCT("”")
  call AddToCT("【")
  call AddToCT("】")
  call AddToCT("…")
  call AddToCT("—")
endfunction

//============================================================================
function SetChatVar takes string key, string value returns nothing
  local integer i = 0
  local integer k = StringHash(key)
  //if i == 0 then
  if (HaveSavedInteger(language_table, CHAT_VARS_TABLE, k) == false) then
    set i = chat_vars_length
    set chat_vars_length = chat_vars_length + 1
    //call StoreInteger(chat_vars_map, ai_id, key, i)
    call SaveInteger(language_table, CHAT_VARS_TABLE, k, i)
  else
    set i = LoadInteger(language_table, CHAT_VARS_TABLE, k)
  endif
  set chat_vars[i] = value
endfunction

//============================================================================
function GetChatVar takes string key returns string
  //return chat_vars[GetStoredInteger(chat_vars_map, ai_id, key)]
  return chat_vars[LoadInteger(language_table, CHAT_VARS_TABLE, StringHash(key))]
endfunction

//============================================================================
function SetChatVarB takes string key, boolean value returns nothing
  //call StoreBoolean(chat_vars_map, ai_id, key, value)
  call SaveBoolean(language_table, CHAT_VARS_TABLE, StringHash(key+"B"), value)
endfunction

//============================================================================
function GetChatVarB takes string key returns boolean
  //return GetStoredBoolean(chat_vars_map, ai_id, key)
  return LoadBoolean(language_table, CHAT_VARS_TABLE, StringHash(key+"B"))
endfunction

//============================================================================
function SetChatVarR takes string key, real value returns nothing
  call SaveReal(language_table, CHAT_VARS_TABLE, StringHash(key+"R"), value)
endfunction

//============================================================================
function GetChatVarR takes string key returns real
  //return GetStoredReal(chat_vars_map, ai_id, key)
  return LoadReal(language_table, CHAT_VARS_TABLE, StringHash(key+"R"))
endfunction

function GetTargetStrengthChat takes nothing returns real
  return GetChatVarR("TargetStrength")
endfunction

//============================================================================
// Converts translational parts of text to actual text
//============================================================================
function ApplyChatVars takes string s_in returns string
  local string s = ""
  local integer i = 0
  local integer l = StringLength(s_in)
  local boolean is_cv = false
  local boolean is_wf = false
  local boolean is_cond = false
  local string key = ""
  local string wf = ""
  local string c = ""
  loop
    exitwhen i >= l
    set c = GetChar(s_in, i)
    if c == "" then
      set key = null
      set wf = null
      set c = null
      return s_in  // Means a character not in the StandardCharTable.txt so return original text as we cannot perform placeholder replacement.
    endif
    if c == "}" then
      set is_cond = false
    elseif is_cond then
    elseif c == "{" then
      set is_cond = true
    elseif c == "[" then
      set is_cv = true
      set key = ""
      set wf = ""
    elseif c == "]" then
      set is_cv = false
      set is_wf = false
      set s = s + ApplyTrans(GetChatVar(key)+wf)
    elseif is_cv then
      if c == ":" then
        set is_cv = false
        set is_wf = true
        set wf = ":"
      else
        set key = key + c
      endif
    elseif is_wf then
      set wf = wf + c
    else
      set s = s + c
    endif
    set i = i + 1
  endloop
  set key = null
  set wf = null
  set c = null
  return s
endfunction

//============================================================================
function CompareReal takes real x, real y, integer compare returns boolean
  if compare == COMPARE_GREATER then
    return x > y
  elseif compare == COMPARE_GREATER_EQ then
    return x >= y
  elseif compare == COMPARE_LESS then
    return x < y
  else
    return x <= y
  endif
endfunction

//============================================================================
// Determines if the chat statement conditions are true
//============================================================================
// function CheckChatCondition takes string s returns boolean
  // local integer i = 1
  // local boolean is_compare = false
  // local integer compare = 0
  // local string key = ""
  // local string value = ""
  // local string c = ""
  // local boolean part_cond = true
  // local boolean not_cond = false
  // local boolean return_bool = false
  // local boolean exitloop = false

  // set chat_eq = COMPARE_TRUE
  // set c = GetChar(s, 0)
  // if c != "{" then
    // set return_bool = true
    // // call DisplayTimedTextToPlayer(Player(0),0,0,15,message_add+B2S(return_bool)+":"+c)
    // //return true
  // else
  // loop
    // exitwhen (exitloop == true)
    // set c = GetChar(s, i)
    // if c == "}" then
      // if is_compare then
        // if key == "PlayerRace" then
          // set chat_race = value
          // set chat_eq = compare
          // set return_bool = true
          // set exitloop = true
          // //return true
        // elseif compare == COMPARE_EQ then
          // set return_bool = (GetChatVar(key) == value)
          // set exitloop = true
          // //return GetChatVar(key) == value
        // elseif compare == COMPARE_UNEQ then
          // set return_bool = (GetChatVar(key) != value)
          // set exitloop = true
          // //return GetChatVar(key) != value
        // else
          // set return_bool = CompareReal(GetChatVarR(key), S2R(value), compare)
          // set exitloop = true
          // //return CompareReal(GetChatVarR(key), S2R(value), compare)
        // endif
      // else
          // set return_bool = (not_cond != GetChatVarB(key))
          // set exitloop = true
        // //return not_cond != GetChatVarB(key)
      // endif
    // elseif c == "," then
      // if is_compare then
        // if key == "PlayerRace" then
          // set chat_race = value
          // set chat_eq = compare
        // elseif compare == COMPARE_EQ then
          // set part_cond = (GetChatVar(key) == value)
        // elseif compare == COMPARE_UNEQ then
          // set part_cond = (GetChatVar(key) != value)
        // else
          // set part_cond = CompareReal(GetChatVarR(key), S2R(value), compare)
        // endif
      // else
        // set part_cond = (not_cond != GetChatVarB(key))
      // endif
      // if not part_cond then
          // set return_bool = false
          // set exitloop = true
          // //return false
      // else
          // set is_compare = false
          // set not_cond = false
          // set key = ""
          // set value = ""
          // set compare = 0
      // endif
    // elseif c == "=" then
      // if is_compare then
        // if compare == COMPARE_GREATER then
          // set compare = COMPARE_GREATER_EQ
        // elseif compare == COMPARE_LESS then
          // set compare = COMPARE_LESS_EQ
        // endif
      // else
        // set is_compare = true
        // if not_cond then
          // set compare = COMPARE_UNEQ
        // else
          // set compare = COMPARE_EQ
        // endif
      // endif
    // elseif c == "<" then
      // set is_compare = true
      // set compare = COMPARE_LESS
    // elseif c == ">" then
      // set is_compare = true
      // set compare = COMPARE_GREATER
    // elseif c == "!" then
      // set not_cond = true
    // elseif is_compare then
      // set value = value + c
    // else
      // set key = key + c
    // endif
    // set i = i + 1
  // endloop
  // endif
  // //call DisplayTimedTextToPlayer(Player(0),0,0,15,message_add+B2S(return_bool)+":"+key)
  // return return_bool
// endfunction

function CheckChatCondition takes string s returns boolean
  local integer i = 1
  local boolean is_compare = false
  local integer compare = 0
  local string key = ""
  local string value = ""
  local string c = ""
  local boolean part_cond = true
  local boolean not_cond = false
  local boolean b = false
  set chat_eq = COMPARE_TRUE
  set c = GetChar(s, 0)
  if c != "{" then
    set key = null
    set value = null
    set c = null
    return true
  endif
  loop
    set c = GetChar(s, i)
    if c == "}" then
      if is_compare then
        if key == "PlayerRace" then
          set chat_race = value
          set chat_eq = compare
          set key = null
          set value = null
          set c = null
          return true
        elseif compare == COMPARE_EQ then
          set b = GetChatVar(key) == value
          set key = null
          set value = null
          set c = null
          return b
        elseif compare == COMPARE_UNEQ then
          set b = GetChatVar(key) != value
          set key = null
          set value = null
          set c = null
          return b
        else
          set b = CompareReal(GetChatVarR(key), S2R(value), compare)
          set key = null
          set value = null
          set c = null
          return b
        endif
      else
        set b = not_cond != GetChatVarB(key)
        set key = null
        set value = null
        set c = null
        return b
      endif
    elseif c == "," then
      if is_compare then
        if key == "PlayerRace" then
          set chat_race = value
          set chat_eq = compare
        elseif compare == COMPARE_EQ then
          set part_cond = GetChatVar(key) == value
        elseif compare == COMPARE_UNEQ then
          set part_cond = GetChatVar(key) != value
        else
          set part_cond = CompareReal(GetChatVarR(key), S2R(value), compare)
        endif
      else
        set part_cond = not_cond != GetChatVarB(key)
      endif
      if not part_cond then
        set key = null
        set value = null
        set c = null
        return false
      endif
      set is_compare = false
      set not_cond = false
      set key = ""
      set value = ""
      set compare = 0
    elseif c == "=" then
      if is_compare then
        if compare == COMPARE_GREATER then
          set compare = COMPARE_GREATER_EQ
        elseif compare == COMPARE_LESS then
          set compare = COMPARE_LESS_EQ
        endif
      else
        set is_compare = true
        if not_cond then
          set compare = COMPARE_UNEQ
        else
          set compare = COMPARE_EQ
        endif
      endif
    elseif c == "<" then
      set is_compare = true
      set compare = COMPARE_LESS
    elseif c == ">" then
      set is_compare = true
      set compare = COMPARE_GREATER
    elseif c == "!" then
      set not_cond = true
    elseif is_compare then
      set value = value + c
    else
      set key = key + c
    endif
    set i = i + 1
  endloop
  set key = null
  set value = null
  set c = null
  return false
endfunction

//============================================================================
function ApplyChatConditions takes nothing returns nothing
  local integer i = 0
  local integer free = 0
  loop
    exitwhen i >= chat_list_length
    call SetChatVarR("Random",GetRandomReal(0,100))
    if CheckChatCondition(chat_list[i]) then
      set chat_list[free] = chat_list[i]
      set chat_list_race[free] = chat_race
      set chat_list_eq[free] = chat_eq
      set free = free + 1
    endif
    set i = i + 1
  endloop
  set chat_list_length = free
endfunction

//_________________________________________________________________________________________________________________________________________________
//_________________________________________________________________________________________________________________________________________________
   // Global Functions that are used in both AMAI and standard ai

//============================================================================
//  Finds the AMAI id code for when we are using normal ai
function GetAMAIId takes integer id returns integer
	local integer i = 0
	loop
		exitwhen i > OBJECT_NUM
		if old_id[i] == id then
			call Trace("Returned AMAI id - " + Int2Str(i) + ":" + UnitId2String(old_id[i]) + " for " + UnitId2String(id))
			return i
		endif
		set i = i + 1
	endloop
	call Trace("Couldnt get AMAI id - " + UnitId2String(id))
	return 0
endfunction

//============================================================================
function GetGold takes nothing returns integer
  return GetPlayerState(ai_player,PLAYER_STATE_RESOURCE_GOLD)
endfunction

//============================================================================
function GetWood takes nothing returns integer
  return GetPlayerState(ai_player,PLAYER_STATE_RESOURCE_LUMBER)
endfunction

//============================================================================
function InitDefenseGroup takes nothing returns nothing
  set defense_length = 0
endfunction

//============================================================================
function InitAssaultGroup takes nothing returns nothing
  if IsAMAI then
    set attack_length = 0
  else
    set harass_length = 0
  endif
endfunction

//============================================================================
function GetUnitCountEx takes integer unitid, boolean only_done, integer townid returns integer

  if unitid < 1 then // can happen but lets speed up calculation a little instead of running the functions
    return 0
  endif

  if IsAMAI then
    if townid == -1 then
      if only_done then
        return GetUnitCountDone(old_id[unitid])
      else
        return GetUnitCount(old_id[unitid])
      endif
    else
      return GetTownUnitCount(old_id[unitid],townid,only_done)
    endif
  else
    if townid == -1 then
      if only_done then
        return GetUnitCountDone(unitid)
      else
        return GetUnitCount(unitid)
      endif
    else
      return GetTownUnitCount(unitid,townid,only_done)
    endif
  endif
endfunction

//============================================================================
// If units upgrade requirement unit is the same as passed in upgrade unit id for three levels of upgrades.
// TODO Won't currently work with 4 or more tiers.
function isSameUpgradeLine takes integer unitid, integer upgradeid returns boolean
  if upgradeid == 0 or unitid < 1 then
    return false
  endif
  if needed3[unitid] == UPGRADED and needed1[unitid] == upgradeid then
    return true
  endif
  return false
endfunction

// Counts other units that count as this unit, can optionally pass an upgradeid that is ignored from the count
function GetUnitCountAlt takes integer unitid, integer upgradeid, boolean only_done, integer townid returns integer
  local integer have_qty = 0
  if unitid < 1 then
    return 0
  endif
  if IsAMAI then
    if upgradeid != tc_add1[unitid] and not isSameUpgradeLine(tc_add1[unitid], upgradeid) then
      set have_qty = have_qty + GetUnitCountEx(tc_add1[unitid],only_done,townid)
    endif
    if upgradeid != tc_add2[unitid] and not isSameUpgradeLine(tc_add2[unitid], upgradeid) then
      set have_qty = have_qty + GetUnitCountEx(tc_add2[unitid],only_done,townid)
    endif
  else
  #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%9" ne "0"
    if unitid == %1 and upgradeid != %9 and not isSameUpgradeLine(%9, upgradeid) then
      set have_qty = have_qty + GetUnitCountEx(%9,only_done,townid)
    endif
  #ENDINCLUDE
  #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%10" ne "0"
    if unitid == %1 and upgradeid != %10 and not isSameUpgradeLine(%10, upgradeid) then
      set have_qty = have_qty + GetUnitCountEx(%10, only_done,townid)
    endif
  #ENDINCLUDE
  endif

#INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "TC_ADD"
  if unitid == %1 and upgradeid != %3 and not isSameUpgradeLine(%3, upgradeid) then
    set have_qty = have_qty + GetUnitCountEx(%3, only_done, townid)
  endif
#ENDINCLUDE
  return have_qty
endfunction

function TownCountEx takes integer unitid, boolean only_done, integer townid returns integer
  //local integer newid = 0
    //set newid = GetAMAIId(unitid)
    //set have_qty = GetUnitCountEx(unitid,only_done,townid) + GetUnitCountEx(tc_add1[newid],false,townid) + GetUnitCountEx(tc_add2[newid],false,townid)
  return GetUnitCountEx(unitid,only_done,townid) + GetUnitCountAlt(unitid,0,only_done,townid)
endfunction

//============================================================================
function TownCountDone takes integer base returns integer
  return TownCountEx(base,true,-1)
endfunction

//============================================================================
function TownCount takes integer base returns integer
  return TownCountEx(base,false,-1)
endfunction

//============================================================================
function TownCountTown takes integer base, integer townid returns integer
  return TownCountEx(base,false,townid)
endfunction

//============================================================================
function HallsCompleted takes integer unitid returns boolean
  if IsAMAI then
    return GetUnitCount(old_id[unitid]) == GetUnitCountDone(old_id[unitid])
  endif
  return GetUnitCount(unitid) == GetUnitCountDone(unitid)
endfunction

//============================================================================
function StaggerSleep takes real base, real spread returns nothing
  local real sleep = base + spread * I2R(GetAiPlayer()) / I2R(GetPlayers()) + GetRandomReal(-0.1, 0.1)
  if sleep <= 0 then
    return
  endif
  set sleep = RMax(0.1, sleep)
  call Sleep(sleep)
endfunction

//============================================================================
function FoodUsed takes nothing returns integer
  return GetPlayerState(ai_player,PLAYER_STATE_RESOURCE_FOOD_USED)
endfunction

//============================================================================
function FoodCap takes nothing returns integer
  return GetPlayerState(ai_player,PLAYER_STATE_RESOURCE_FOOD_CAP)
endfunction

//============================================================================
function FoodSpace takes nothing returns integer
  return FoodCap() - FoodUsed()
endfunction

//============================================================================
function FoodAvail takes integer base returns integer
  return GetFoodMade(old_id[racial_farm]) * TownCount(racial_farm) + GetFoodMade(old_id[base]) * TownCount(base)
endfunction

//_________________________________________________________________________________________________________________________________________________
//_________________________________________________________________________________________________________________________________________________

//============================================================================
// AMAI Common.ai Section reworked by Strategy Master
//      - Based off code written by Aiandy and Zalamander
//
//============================================================================

function InitMapSizeVars takes nothing returns nothing
  local real x = path_right - path_left
  local real y = path_top - path_bottom
  local real a = (x / 1000)*(y / 1000)
  call SetChatVarR("MapSizeX", x)
  call SetChatVarR("MapSizeY", y)
  if GetBJMaxPlayers() < 24 then
    if a < 120 then
      call SetChatVar("MapSize", "tiny")
      set mapSize = 1
    elseif a < 240 then
      call SetChatVar("MapSize", "small")
      set mapSize = 2
    elseif a < 380 then
      call SetChatVar("MapSize", "medium")
      set mapSize = 3
    elseif a < 540 then
      call SetChatVar("MapSize", "large")
      set mapSize = 4
    else
      call SetChatVar("MapSize", "huge")
      set mapSize = 5
    endif
  else
    if a < 90 then
      call SetChatVar("MapSize", "extrasmall")
      set mapSize = 0
    elseif a < 120 then
      call SetChatVar("MapSize", "tiny")
      set mapSize = 1
    elseif a < 240 then
      call SetChatVar("MapSize", "small")
      set mapSize = 2
    elseif a < 380 then
      call SetChatVar("MapSize", "medium")
      set mapSize = 3
    elseif a < 540 then
      call SetChatVar("MapSize", "large")
      set mapSize = 4
    elseif a < 960 then
      call SetChatVar("MapSize", "extralarge")
      set mapSize = 5
    elseif a < 2048 then
      call SetChatVar("MapSize", "huge")
      set mapSize = 6
    else
      call SetChatVar("MapSize", "legendary")
      set mapSize = 7
    endif
  endif
  set raceshop_distance_limit = raceshop_distance_limit * Max(mapSize, 1)
  set merchant_distance_limit = merchant_distance_limit * Max(mapSize, 1)
endfunction

//============================================================================
function InitDifficultyVars takes nothing returns nothing
  if difficulty == HARD then
    call SetChatVar("Difficulty", "Insane")
  elseif difficulty == NORMAL then
    call SetChatVar("Difficulty", "Normal")
  else
    call SetChatVar("Difficulty", "Easy")
  endif
  call SetChatVarR("Handicap", GetPlayerHandicap(ai_player))
endfunction

//============================================================================
function InitChatVars takes nothing returns nothing
  call SetChatVar("Race", race_name[own_race])
  call SetChatVar("Color", ColorText(GetPlayerColor(ai_player)))
  call SetChatVarR("PlayerNum", c_ally_total + c_enemy_total + 1)
  call SetChatVar("PlayerNum", Int2Str(c_ally_total + c_enemy_total + 1))
  call SetChatVarB("1vs1", game_is_1on1)
  call SetChatVarB("FFA", game_is_ffa)
  call SetChatVarB("RaceChoiceRandom", player_race_pref[GetAiPlayer()] == R_RANDOM)
  call SetChatVar("MaxPlayerNum", Int2Str(GetPlayers()))
  call SetChatVarR("MaxPlayerNum", GetPlayers())
  call InitMapSizeVars()
  call InitDifficultyVars()
endfunction

//============================================================================
function SetChatVarsPlayer takes player p returns nothing
  call SetChatVar("PlayerRace", race_name[player_race[GetPlayerId(p)]])
  call SetChatVar("PlayerColor", ColorText(GetPlayerColor(p)))
endfunction


//==============================================================
// (AMAI) Vector utility functions
//==============================================================

//===========================================================================
// Returns a location which is (distance) away from (src) in the direction of (targ).
//
function AIGetProjectedLoc takes location src, location targ, real distance, real deltaAngle returns location
  local real srcX = GetLocationX(src)
  local real srcY = GetLocationY(src)
  local real direction = Atan2(GetLocationY(targ) - srcY, GetLocationX(targ) - srcX) + deltaAngle
  return Location(srcX + distance * Cos(direction), srcY + distance * Sin(direction))
endfunction

function GetSumLoc takes location l1, location l2 returns location
  return Location(GetLocationX(l1) + GetLocationX(l2), GetLocationY(l1) + GetLocationY(l2))
endfunction
// Set freel1 and freel2 to true to remove that location
function GetSumLoc_dd takes location l1, location l2 returns location
  local real locX = GetLocationX(l1) + GetLocationX(l2)
  local real locY = GetLocationY(l1) + GetLocationY(l2)
  call RemoveLocation(l1)
  call RemoveLocation(l2)
  return Location(locX, locY)
endfunction
function GetSumLoc_kd takes location l1, location l2 returns location
  local real locX = GetLocationX(l1) + GetLocationX(l2)
  local real locY = GetLocationY(l1) + GetLocationY(l2)
  call RemoveLocation(l2)
  return Location(locX, locY)
endfunction
function GetSumLoc_dk takes location l1, location l2 returns location
  local real locX = GetLocationX(l1) + GetLocationX(l2)
  local real locY = GetLocationY(l1) + GetLocationY(l2)
  call RemoveLocation(l1)
  return Location(locX, locY)
endfunction

//============================================================================
function GetSubtractionLoc takes location l1, location l2 returns location
  return Location(GetLocationX(l1) - GetLocationX(l2), GetLocationY(l1) - GetLocationY(l2))
endfunction

function GetSubtractionLoc_dd takes location l1, location l2 returns location
  local real locX = GetLocationX(l1) - GetLocationX(l2)
  local real locY = GetLocationY(l1) - GetLocationY(l2)
  call RemoveLocation(l1)
  call RemoveLocation(l2)
  return Location(locX, locY)
endfunction
function GetSubtractionLoc_kd takes location l1, location l2 returns location
  local real locX = GetLocationX(l1) - GetLocationX(l2)
  local real locY = GetLocationY(l1) - GetLocationY(l2)
  call RemoveLocation(l2)
  return Location(locX, locY)
endfunction
function GetSubtractionLoc_dk takes location l1, location l2 returns location
  local real locX = GetLocationX(l1) - GetLocationX(l2)
  local real locY = GetLocationY(l1) - GetLocationY(l2)
  call RemoveLocation(l1)
  return Location(locX, locY)
endfunction

//============================================================================
function GetMultipleLoc takes location l, real m returns location
  return Location(GetLocationX(l) * m, GetLocationY(l) * m)
endfunction

function GetMultipleLoc_d takes location l, real m returns location
  local real locX = GetLocationX(l) * m
  local real locY = GetLocationY(l) * m
  call RemoveLocation(l)
  return Location(locX, locY)
endfunction

//============================================================================
function GetDivisionLoc takes location l, real d returns location
  return Location(GetLocationX(l) / d, GetLocationY(l) / d)
endfunction

function GetDivisionLoc_d takes location l, real d returns location
  local real locX = GetLocationX(l) / d
  local real locY = GetLocationY(l) / d
  call RemoveLocation(l)
  return Location(locX, locY)
endfunction

//============================================================================
function GetLengthOfLoc takes location l returns real
  local real x = GetLocationX(l)
  local real y = GetLocationY(l)
  return SquareRoot(x * x + y * y)
endfunction

function GetLengthOfLoc_d takes location l returns real
  local real x = GetLocationX(l)
  local real y = GetLocationY(l)
  call RemoveLocation(l)
  return SquareRoot(x * x + y * y)
endfunction

//============================================================================
function GetNormalisedLoc takes location l returns location
  return GetDivisionLoc(l, RMax(GetLengthOfLoc(l),1.00))
endfunction

function GetNormalisedLoc_d takes location l returns location
  return GetDivisionLoc_d(l, RMax(GetLengthOfLoc(l),1.00))
endfunction

//============================================================================
function GetProjectedLoc takes location l, location v, real r returns location
  local location loc = GetNormalisedLoc(v)
  local location loc2 = GetMultipleLoc_d(loc, r)
  local location returnloc = GetSumLoc_kd(l, loc2)
  local real x = GetLocationX(returnloc)
  local real y = GetLocationY(returnloc)
  set loc = null
  set loc2 = null
  call RemoveLocation(returnloc)
  set returnloc = null
  return Location(x, y)
endfunction

function GetProjectedLoc_dd takes location l, location v, real r returns location
  local location loc = GetNormalisedLoc_d(v)
  local location loc2 = GetMultipleLoc_d(loc, r)
  local location returnloc = GetSumLoc_dd(l, loc2)
  local real x = GetLocationX(returnloc)
  local real y = GetLocationY(returnloc)
  set loc = null
  set loc2 = null
  call RemoveLocation(returnloc)
  set returnloc = null
  return Location(x, y)
endfunction

//============================================================================
function l_smult_kk takes location l1, location l2 returns real
  return GetLocationX(l1) * GetLocationX(l2) + GetLocationY(l1) * GetLocationY(l2)
endfunction

//============================================================================
function GetAngleBetweenLocs takes location l1, location l2 returns real
  local real i = GetLengthOfLoc(l1) * GetLengthOfLoc(l2)
  if i == 0 then
    set i = 1
  endif
  return Acos(l_smult_kk(l1, l2) / i)
endfunction

//==============================================================
// (AMAI) Profile system
//==============================================================
function set_profiles takes nothing returns nothing

#INCLUDETABLE <$VER$\Profiles.txt> #EFR
  set profilename[#EVAL{%row-1}] = "%1"
  set p_race[#EVAL{%row-1}] = R_%2
  set p_aggression[#EVAL{%row-1}] = %3
  set p_uncertainty[#EVAL{%row-1}] = %4
  set p_minimum_attack_strength[#EVAL{%row-1}] = %5
  set p_farm_food[#EVAL{%row-1}] = %6
  set p_exp_first_time[#EVAL{%row-1}] = %7
  set p_exp_second_time[#EVAL{%row-1}] = %8
  set p_strat_persistence[#EVAL{%row-1}] = %9
  set p_gold_unit_percentage[#EVAL{%row-1}] = %10
  set p_taunt_rate[#EVAL{%row-1}] = %11
  set p_expansion_target_bonus[#EVAL{%row-1}] = %12
  set p_comp_chosen_target_bonus[#EVAL{%row-1}] = %13
  set p_comp_chosen_target_rate[#EVAL{%row-1}] = %14
  set p_surrender[#EVAL{%row-1}] = %15

  #FOR $X$ FROM $ONE$ TO $RACENUM$
  set fav_hero[#EVAL{(%row-1)*($RACENUM$+1)+$X$-1}] = %#OEVAL{15+$X$}
  #ENDFOR
  set fav_hero[#EVAL{(%row-1)*($RACENUM$+1)+$RACENUM$}] = %#OEVAL{16+$RACENUM$}

  #FOR $X$ FROM $ONE$ TO $RACENUM$
  set fav_unit[#EVAL{(%row-1)*$RACENUM$+$X$-1}] = %#OEVAL{16+$RACENUM$+$X$}
  #ENDFOR
  set p_rare[#EVAL{%row-1}] = %#OEVAL{17+$RACENUM$+$RACENUM$}

#AFTERINCLUDE
  set profile_length = #EVAL{%row-1}
#ENDINCLUDE

endfunction

//============================================================================
function IsProfileUsed takes integer profile returns boolean
  //return LoadBoolean(com, PROFILE_USED, profile)
  return GetStoredBoolean(amaiCache, Int2Str(PROFILE_USED), Int2Str(profile))
endfunction

//============================================================================
function SetProfileUsed takes integer profile returns nothing
  call SaveBoolean(com, PROFILE_USED, profile, true)
  call StoreBoolean(amaiCache, Int2Str(PROFILE_USED), Int2Str(profile), true) // Profile selection has to use gamecaches as hashtables are not saved between AI's
endfunction

function SetProfileNotUsed takes integer profile returns nothing
  call SaveBoolean(com, PROFILE_USED, profile, false)
  call StoreBoolean(amaiCache, Int2Str(PROFILE_USED), Int2Str(profile), false)
endfunction

function GetUnusedProfile takes player p returns integer
  local integer i = 0
  local integer array unusedProfiles
  local integer unusedCount = 0
  local integer array unusedRareProfiles
  local integer unusedRareCount = 0
  local integer profile = 0
  local integer p_sum = 0
  loop
    if p_rare[i] == 0 and (p_race[i] == R_RANDOM or p_race[i] == own_race) and (not IsProfileUsed(i)) then
      set unusedProfiles[unusedCount] = i
      set unusedCount = unusedCount + 1
    elseif p_rare[i] == 1 and (p_race[i] == R_RANDOM or p_race[i] == own_race) and (not IsProfileUsed(i)) then
      set unusedRareProfiles[unusedRareCount] = i
      set unusedRareCount = unusedRareCount + 1
    endif
    set i = i + 1
    exitwhen i >= profile_length
  endloop
  if (unusedRareCount > 0 and GetRandomInt(0,9) == 0) then
    set profile = GetRandomInt(0, unusedRareCount - 1)
    set profile = unusedRareProfiles[profile]
    call TracePlayer("Rare Profile select " + Int2Str(profile), GetPlayerId(ai_player))
  elseif unusedCount > 0 then // pick from unused profiles
    set profile = GetRandomInt(0, unusedCount - 1)
    set profile = unusedProfiles[profile]
    call TracePlayer("Profile select " + Int2Str(profile), GetPlayerId(ai_player))
  else // fail safe - pick anything as no valid profile available
    set profile = GetRandomInt(0, profile_length)
    call TracePlayer("FAILSAFE Profile Selection " + Int2Str(profile), GetPlayerId(ai_player))
  endif
  call SetProfileUsed(profile)
  return profile
endfunction

//============================================================================
function InitProfile takes nothing returns nothing
  local integer i = 0
  local integer countplayers = 0

  call set_profiles()

  if debug_profile != -1 then
    set profile = debug_profile
  else

    call Sleep((GetPlayerId(ai_player)*0.02)) // Staggered entry into method for thread safety with profile cache

    loop
      exitwhen not IsProfileUsed(-1)
      call Sleep(0.01)
    endloop

    call SetProfileUsed(-1) // current AI locks to ensure only it is processing profiles
    call TracePlayer("Has locked profile selection ID:" + Int2Str(GetPlayerId(ai_player)), GetPlayerId(ai_player))

    set profile = GetUnusedProfile(ai_player)
    call SetProfileNotUsed(-1)
  endif

  if not fixedcomputername then
    set ai_name = profilename[profile]
  elseif add_tag then
    set ai_name = "AMAI"
  else
    set ai_name = "Computer"
  endif

  call SetChatVar("Name", ai_name)

  if add_tag == true and not fixedcomputername and not add_skill then
    set ai_name = ai_name + " [AMAI]"
  elseif add_tag == true and not fixedcomputername and add_skill then
    if difficulty == EASY then
      set ai_name = ai_name + " [AMAI Easy]"
    elseif difficulty == HARD then
      set ai_name = ai_name + " [AMAI Insane]"
    else
      set ai_name = ai_name + " [AMAI Normal]"
    endif
  elseif add_skill == true then
    if difficulty == EASY then
      set ai_name = ai_name+" [Easy]"
    elseif difficulty == HARD then
      set ai_name = ai_name+" [Insane]"
    else
      set ai_name = ai_name+" [Normal]"
    endif
  endif

  call SetPlayerName(ai_player, ai_name)
  set message_add = c2s(GetPlayerColor(ai_player))

  set attacking_aggression = attacking_aggression + p_aggression[profile]
  set uncertainty = p_uncertainty[profile]
  set area_uncertainty = uncertainty / 2
  set minimum_attack_strength = p_minimum_attack_strength[profile]
  set farm_food = p_farm_food[profile]
  set exp_first_time = p_exp_first_time[profile]
  set exp_second_time = p_exp_second_time[profile]
  set strat_persistence = p_strat_persistence[profile]
  set gold_unit_percentage = p_gold_unit_percentage[profile]
  set taunt_rate = p_taunt_rate[profile]
  set expansion_target_bonus = p_expansion_target_bonus[profile]
  set comp_chosen_target_bonus = p_comp_chosen_target_bonus[profile]
  set comp_chosen_target_rate = p_comp_chosen_target_rate[profile]

endfunction

//============================================================================
function AddFavoriteUnitRP takes nothing returns nothing
  local integer i = 0
  local string team = "Team" + Int2Str(GetPlayerTeam(ai_player)) + "StratUsed"
  if debug_strategy != -1 then
    set rp_strat[debug_strategy] = 100000000
  endif
  loop
    exitwhen i >= rp_strat_length
    if key_unit[i] == fav_unit[profile*RACE_NUMBER+own_race-1] then
      set rp_strat[i] = rp_strat[i] + fav_unit_add
    endif
    set i = i + 1
  endloop
  if ai_time < 10 then
    set i = 0
    loop
      exitwhen i >= 4
      set strategy_type_used[i] = LoadBoolean(com, TEAM_STATEGY_INUSE, i)
      set i = i + 1
    endloop
    set i = 0
    loop
      exitwhen i >= rp_strat_length
      if strategy_type_used[strategy_type[i]] then
        set rp_strat[i] = rp_strat[i] - strategy_type_used_penalty
      endif
      set i = i + 1
    endloop
  endif
  set team = null
endfunction

//============================================================================
function AddFavoriteHeroRP takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= hero_number
    if all_heroes[i] == fav_hero[profile*(RACE_NUMBER+1)+own_race-1] or all_heroes[i] == fav_hero[profile*(RACE_NUMBER+1)+R_NEUTRAL-1] then
      set hero_rp[i] = hero_rp[i] + fav_hero_add
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI)	InitArrays
//============================================================================
function InitAiUnits takes nothing returns nothing
	if IsAMAI then
	else
	// Set the unit ids to that of the original ai for compatability with non AMAI scripts

#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR
		set %1 = o%1
#ENDINCLUDE

#INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "AI_COMP"
		set %3 = %1
#ENDINCLUDE
	endif
endfunction

function InitArrays takes nothing returns nothing

#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR
  set old_id[%1] = o%1
  set buy_type[%1] = BT_%5
  set needed1[%1] = %6
  set needed2[%1] = %7
  set needed3[%1] = %8
  set tc_add1[%1] = %9
  set tc_add2[%1] = %10
  set available_time[%1] = R2I(%12 / 5)
  set regenerate_time[%1] = R2I(%13 / 5)
  set gold_price[%1] = %14
  set wood_price[%1] = %15
  set hero_rush_bonus[%1] = %16

#ENDINCLUDE
  //    call RLHashSet(o%1, %1)
endfunction

//============================================================================
// (AMAI) Chat arrays
//============================================================================
#INCLUDETABLE <Languages.txt> #EFR
function InitChatArrays%1 takes nothing returns nothing
#DEFINE $lang$ %1
#DEFINE $enc$ %4
#INCLUDETABLE <ChatEvents.txt> #EFR
#DEFINE $chatevent$ %1
  set chat_$chatevent$_length = 0
  #INCLUDETABLE <Languages\$lang$\Chat$chatevent$.txt> #ENC:$enc$
#EVAL{"%3" ? "if %2\"%3\" then" : ("%2" ? "if %2 then" : "")}
  set chat_$chatevent$[chat_$chatevent$_length] = "%1"
  set chat_$chatevent$_length = chat_$chatevent$_length + 1
#EVAL{("%2" or "%3") ? "endif" : ""}
  #ENDINCLUDE
#ENDINCLUDE
  #INCLUDETABLE <Languages\%1\ChatMisc.txt> #ENC:%4
  set %1 = "%2"
  #ENDINCLUDE
  #INCLUDETABLE <backlanguage.txt>
    #DEFINE $back$ %1
    #INCLUDETABLE <Languages\$back$\ChatMisc.txt> #ENC:$enc$
  if %1 == null or %1 == "" then
    set %1 = "%2"
  endif
    #ENDINCLUDE
  #ENDINCLUDE
endfunction

#ENDINCLUDE

//============================================================================
#INCLUDETABLE <ChatEvents.txt> #EFR
function CopyChat%1 takes nothing returns nothing
  local integer i = 0
  set chat_list_length = chat_%1_length
  loop
    exitwhen i >= chat_%1_length
    set chat_list[i] = chat_%1[i]
    set i = i + 1
  endloop
endfunction
#ENDINCLUDE

//============================================================================
function CommonStratsDefault takes nothing returns nothing
#INCLUDETABLE <$VER$\CommandBuilds.txt> #EFR
  set strategy_name[#EVAL{49+%row}] = "%1"
  set strategy_default_name[#EVAL{49+%row}] = "%6"
  set strategy_default_report[#EVAL{49+%row}] = "%7"
#ENDINCLUDE
endfunction

//============================================================================
function InitChatArrays takes nothing returns nothing
  if false then
#INCLUDETABLE <Languages.txt> #EFR
  elseif language == "%1" then
    call InitChatArrays%1()
#ENDINCLUDE
  endif
endfunction

//============================================================================
function InitChatEvents takes nothing returns nothing
#INCLUDETABLE <ChatEvents.txt> #EFR
  set chat_target_ally[%row] = %2
  set chat_target_enemy[%row] = %3
  set chat_target_obs[%row] = %4
  set chat_important[%row] = %5
#ENDINCLUDE
endfunction

//============================================================================
function AddTranslation takes string lang, string strat_name, string trans_name, string trans_report returns nothing
  local integer l = StringHash(lang)
  set translation[translation_length] = trans_name
  call SaveInteger(translation_map, l, StringHash("Name"+strat_name), translation_length)
  set translation_length = translation_length + 1
  set translation[translation_length] = trans_report
  call SaveInteger(translation_map, l, StringHash("Report"+strat_name), translation_length)
  set translation_length = translation_length + 1
endfunction

//============================================================================
function InitTranslations takes nothing returns nothing
  local string lang = ""
#INCLUDETABLE <Languages.txt> #EFR
  set lang = "%1"
  #INCLUDETABLE <Languages\%1\Strategy.txt> #ENC:%4 #EFR
  call AddTranslation(lang, "%1", "%2", "%3")
  #ENDINCLUDE
#ENDINCLUDE
  set lang = null
endfunction

//============================================================================
function GetStrategyTxt takes integer stratnum, string txt returns string
  local string trans = null
  local integer l = StringHash(language)
  local integer t = StringHash(txt+strategy_name[stratnum])
  if HaveSavedInteger(translation_map, l, t) then
    set trans = translation[LoadInteger(translation_map, l, t)]
  endif
  set l = StringHash(backlanguage)
  if (trans == "" or trans == null) and HaveSavedInteger(translation_map, l, t) then
    set trans = translation[LoadInteger(translation_map, l, t)]
  endif
  if (trans == "" or trans == null) then
    set trans = null
    return strategy_default_name[stratnum]
  else
    return trans
  endif
endfunction

function GetStrategyName takes integer stratnum returns string
  return GetStrategyTxt(stratnum, "Name")
endfunction

//============================================================================
function GetStrategyReport takes integer stratnum returns string
  return GetStrategyTxt(stratnum, "Report")
endfunction

//============================================================================
function GetCurrentStrategyName takes nothing returns string
  return GetStrategyName(strategy)
endfunction

//============================================================================
function GetCurrentStrategyReport takes nothing returns string
  return GetStrategyReport(strategy)
endfunction

function GetCurrentDynamicReport takes nothing returns string
  if chosen_counter >= 0 and strengthtext[chosen_counter] != null and no_counter == false then
    return " " + chat_dynamic_counter + " " + ApplyTrans(strengthtext[chosen_counter])
  endif
  return ""
endfunction

//============================================================================
//  (AMAI)    Chat function
//============================================================================
function RemoveOldMessage takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen chat_queue_locked
    call Sleep(0.02)
  endloop
  set chat_queue_locked = false
  loop
    exitwhen i >= chat_queue_size
    set chat_queue[i] = chat_queue[i+1]
    set chat_queue_player[i] = chat_queue_player[i+1]
    set chat_queue_importance[i] = chat_queue_importance[i+1]
    set i = i + 1
  endloop
  if i > 0 then
    set chat_queue[i] = null
    set chat_queue_player[i] = null
    set chat_queue_importance[i] = false
  endif
  set chat_queue_size = chat_queue_size - 1
  set chat_queue_locked = true
endfunction

function QueueChat takes string text, player p, boolean important returns nothing
  set chat_queue_size = chat_queue_size + 1
  set chat_queue[chat_queue_size] = text
  set chat_queue_player[chat_queue_size] = p
  set chat_queue_importance[chat_queue_size] = important
  if chat_queue_size > (5 * c_ai_total) then
    call RemoveOldMessage()
  endif
endfunction

function DisplayChat takes integer chat, boolean ally, boolean enemy, boolean obs, boolean important, boolean immediate returns nothing
  local integer i = 0
  local player p = null
  local integer chat_greet_count = 0
  local string parsed_chat = null
  local string cgold = null
  local string gold = null
  local string target = null
  local string color = null
  local string num = null
  local string pi = null
  //call ApplyChatConditions() Not supported in lua
  if chat_list_length == 0 then
    return
  endif
  set parsed_chat = ApplyChatVars(chat_list[GetRandomInt(0, chat_list_length - 1)])
  set cgold = ApplyTrans("CurrentGold")
  set gold = Int2Str(GetGold())
  set target = ApplyTrans("Target")
  set color = ApplyTrans(GetChatVar("TargetColor"))
  loop
    exitwhen i >= GetBJMaxPlayers()
    set p = Player(i)
    if (GetPlayerSlotState(p) == PLAYER_SLOT_STATE_PLAYING and GetPlayerController(p) != MAP_CONTROL_COMPUTER and not IsPlayerObserver(p) and ((ally and IsPlayerAlly(p, ai_player)) or (enemy and IsPlayerEnemy(p, ai_player)))) or (obs and IsPlayerObserver(p)) then
      set pi = Int2Str(i)
      call SetChatVarsPlayer(p)
      // Only send a limited number of greetings to a single player
      if chat == C_Goldproblem then
        set parsed_chat = parsed_chat + " " + cgold + ": " + gold
      elseif chat == C_Ally or chat == C_Attack or chat == C_Megatarget then
        set parsed_chat = parsed_chat + " " + target + " (" + color + ")"
      endif
      if chat == C_Greet then
        set num = Int2Str(GREETINGS_NUM)
        if (HaveStoredInteger(amaiCache, num, pi)) then
          set chat_greet_count = GetStoredInteger(amaiCache, num, pi)
        endif
        if chat_greet_count < Max(R2I(c_ai_total / 3) + 2, 6) then
          //call DisplayToAllFromPlayer("GREET" + Int2Str(chat_greet_count), GetAiPlayer(), false)
          call StoreInteger(amaiCache, num, pi, chat_greet_count + 1 )
          //call SyncStoredInteger(amaiCache, num, num)
          call DisplayToPlayer(parsed_chat, p, important)
        endif
        set num = null
      elseif immediate then
        call DisplayToPlayer(parsed_chat, p, important)
      else
        call QueueChat(parsed_chat, p, important)
      endif
    endif
    set i = i + 1
  endloop
  set p = null
  set parsed_chat = null
  set cgold = null
  set gold = null
  set target = null
  set color = null
  set pi = null
endfunction

function QueueStrategy takes string text returns nothing
  set chat_strategy = text
endfunction

//============================================================================
function Chat takes integer c returns nothing
  local real chance = 0
  local boolean immediate = false
  if campaign_ai or player_defeated then
    return
  endif

  if c == C_STRATEGY then
    if chatting then
      call QueueStrategy(GetCurrentStrategyReport() + GetCurrentDynamicReport())
    endif
    //call DisplayToAlliesImportant( GetCurrentStrategyReport() + GetCurrentDynamicReport() )
    //call DisplayToObserversImportant( GetCurrentStrategyReport() + GetCurrentDynamicReport() )
  else
    if not (chatting or chat_important[c]) then
      return
    endif
    call InitChatArrays() // Reset conditions checks to only use chats conditions are valid for
    if false then
  #INCLUDETABLE <ChatEvents.txt> #EFR
    elseif c == C_%1 then
      set chance = %6
      call CopyChat%1()
  #ENDINCLUDE
    else
      return
    endif
    if c == C_AGG or c == C_EGG or c == C_Goldproblem or c == C_Thanks or c == C_Ally or c == C_Attack or c == C_Megatarget or c == C_Expansion or c == C_Creep then
      set immediate = true
    endif
    if chance >= GetRandomReal(0.00,100.00) then
      call DisplayChat(c, chat_target_ally[c], chat_target_enemy[c], chat_target_obs[c], chat_important[c], immediate)
    endif
  endif
endfunction

//============================================================================
function GetPlayerStartLocationLoc takes player whichPlayer returns location
  if whichPlayer == null then
    return null
  endif
  return GetStartLocationLoc(GetPlayerStartLocation(whichPlayer))
endfunction

//============================================================================
function DisplayStratNames takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= rp_strat_length
    call DisplayToAllies(Int2Str(i) + ". " + GetStrategyName(i))
    set i = i + 1
  endloop
endfunction

//===========================================================================
// (AMAI) Neutral Heroes skill array
//===========================================================================

function InitNeutralSkills takes nothing returns nothing
#INCLUDETABLE <$VER$\NeutralHeroSkills.txt> #EFR
  #FOR $X$ FROM $ONE$ TO $HEROLEVELNUM$
  set allskills[#EVAL{%row*$HEROLEVELNUM$ + $X$ - 10}] = %$X$
  #ENDFOR

#ENDINCLUDE
endfunction

//============================================================================
// (AMAI) Utility Functions
//============================================================================

function TownCountExForUpgrade takes integer unitid, integer unitid_upgr, boolean only_done, integer townid returns integer
  local integer count = 0
  if tc_add1[unitid] != unitid_upgr then
    set count = count + GetUnitCountEx(tc_add1[unitid],false,townid)
  endif
  if tc_add2[unitid] != unitid_upgr then
    set count = count + GetUnitCountEx(tc_add2[unitid],false,townid)
  endif
#INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "TC_ADD"
  if unitid == %1 and unitid_upgr != %1 then
    set count = count + GetUnitCountEx(%3, false, townid)
  endif
#ENDINCLUDE
  return count

endfunction

function ApplyFleeStrengthModifier takes real strength, boolean isFleeCheck returns real
  local real fleemultmin = ver_flee_multiple1
  local real fleemultmax = ver_flee_multiple2
  if (isFleeCheck) then
    set fleemultmin = ver_flee_multiple2
    set fleemultmax = ver_flee_multiple3
  endif
  return LinearInterpolation(ver_low_aggression,ver_high_aggression,fleemultmin,fleemultmax,attacking_aggression + added_aggression + added_target_aggression + added_racial_aggression)*strength
endfunction

//===========================================================================
// (AMAI)  functions for coordination and choice of strategies
//===========================================================================
function DistanceBetweenPoints takes location locA, location locB returns real
  local real distance = GetLengthOfLoc_d(GetSubtractionLoc(locB, locA))
  return distance
endfunction
function DistanceBetweenPoints_kd takes location locA, location locB returns real
  local real distance = GetLengthOfLoc_d(GetSubtractionLoc_dk(locB, locA))
  return distance
endfunction
function DistanceBetweenPoints_dk takes location locA, location locB returns real
  local real distance = GetLengthOfLoc_d(GetSubtractionLoc_kd(locB, locA))
  return distance
endfunction
function DistanceBetweenPoints_dd takes location locA, location locB returns real
  local real distance = GetLengthOfLoc_d(GetSubtractionLoc_dd(locB, locA))
  return distance
endfunction

//============================================================================
function DistanceBetweenUnits takes unit unitA, unit unitB returns real
  local real r = DistanceBetweenPoints_dd(GetUnitLoc(unitA), GetUnitLoc(unitB))
  return r
endfunction

//============================================================================
function GetTimeToReachUnit takes unit u, unit target returns real
	local real distance = DistanceBetweenUnits(target, u)
	local real movespeed = GetUnitMoveSpeed(u)
	local real time = 15

	if movespeed != 0 then
		set time = distance / movespeed
	endif

	return time

endfunction

//============================================================================
//  (AMAI) Gets the time for a unit to travel to a specific location
//   This is based only on distance between two respective points
//============================================================================
function GetTimeToReachLoc takes unit u, location target returns real
	local real movespeed = GetUnitMoveSpeed(u)
	local real time = 15
	local real distance = DistanceBetweenPoints_kd(target, GetUnitLoc(u))
	//call DisplayToAllJobDebug("gettime: before")
	if movespeed != 0 then
		set time = distance / movespeed
	endif
	//call DisplayToAllJobDebug("gettime: after")
	return time
endfunction

//============================================================================
function EstimatedTimeToReachUnit_d takes location locA, unit target, real movespeed returns real
  local real time = 15
  local real distance = DistanceBetweenPoints_dd(locA, GetUnitLoc(target))

  if movespeed != 0 then
    set time = distance / movespeed
  endif
  return time

endfunction

//============================================================================
function GetLocationBetweenLoc takes location locA, location locB, real d returns location
  local location locC = GetSubtractionLoc(locA, locB)
  local location locD = GetMultipleLoc(locC, d)
  local location l = GetSumLoc(locA, locD)
  local real x = GetLocationX(l)
  local real y = GetLocationY(l)
  call RemoveLocation(locC)
  set locC = null
  call RemoveLocation(locD)
  set locD = null
  call RemoveLocation(l)
  set l = null
  return Location(x,y)
endfunction

//============================================================================
function GetLocationBetweenUnits takes unit u1, unit u2, real d returns location
  local location loc1 = GetUnitLoc(u1)
  local location loc2 = GetUnitLoc(u2)
  local location l = GetLocationBetweenLoc(loc1, loc2, d)
  local real x = GetLocationX(l)
  local real y = GetLocationY(l)
  call RemoveLocation(loc1)
  set loc1 = null
  call RemoveLocation(loc2)
  set loc2 = null
  call RemoveLocation(l)
  set l = null
  return Location(x,y)
endfunction

//============================================================================
function GetNearestEnemyToLoc_k takes location l returns player
  local integer i = 0
  local integer min_p = 30
  local real nr = 0
  local real min_nr = 1000000

  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set nr = DistanceBetweenPoints_dk(GetPlayerStartLocationLoc(enemy_force[i]), l)
      if nr < min_nr then
        set min_nr = nr
        set min_p = i
      endif
    endif
    set i = i + 1
  endloop
  if min_p != 30 then
    return enemy_force[min_p]
  endif
  return null
endfunction

function GetNearestEnemyToLoc_d takes location l returns player
  local integer i = 0
  local integer min_p = 30
  local real nr = 0
  local real min_nr = 1000000

  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set nr = DistanceBetweenPoints_dk(GetPlayerStartLocationLoc(enemy_force[i]), l)
      if nr < min_nr then
        set min_nr = nr
        set min_p = i
      endif
    endif
    set i = i + 1
  endloop
  call RemoveLocation(l)
  if min_p != 30 then
    return enemy_force[min_p]
  endif
  return null
endfunction

//============================================================================
function SetNearestEnemy takes nothing returns nothing
  local integer i = 0
  local real nr = 0
  local real humanrange = Max(3, mapSize) * 3200  // preventing long-distance attacks
  set nearest_enemy = null
  set nearest_human_enemy = null
  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set nr = DistanceBetweenPoints_dk(GetPlayerStartLocationLoc(enemy_force[i]), home_location)
      if nr < nearest_enemy_range then
        set nearest_enemy_range = nr
        set nearest_enemy = enemy_force[i]
        if GetPlayerController(enemy_force[i]) != MAP_CONTROL_COMPUTER and nr < humanrange then
          set humanrange = nr
          set nearest_human_enemy = enemy_force[i]
        endif
      endif
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function countAllyEnemy takes nothing returns nothing
  local integer i = 0
  local integer ai_total = 0
  local integer force_num = 0
  local integer ally = 0
  local integer ally_user = 0
  local integer enemy = 0
  local integer enemy_user = 0
  local boolean self_came = false
  local boolean next_came = false
  local boolean first_ai = true
  local integer next_ai = 0
  local player p = null
  loop
    exitwhen i > RACE_NUMBER
    set c_ally[i] = 0
    set c_enemy[i] = 0
    set i = i + 1
  endloop
  set i = 0
  loop
    exitwhen i >= GetBJMaxPlayers()
    set p = Player(i)
    if GetPlayerSlotState(p) == PLAYER_SLOT_STATE_PLAYING and not IsPlayerObserver(p) then
      if GetPlayerController(p) == MAP_CONTROL_COMPUTER then
        set ai_total = ai_total + 1
      endif
      if IsPlayerAlly(ai_player,p) then
        if i == GetAiPlayer() then
          set self_came = true
          set next_came = true
          set own_force[force_num] = p
          set force_num = force_num + 1
        else
          if GetPlayerController(p) == MAP_CONTROL_COMPUTER then
            if not self_came then
              set first_ai = false
            elseif next_came then
              set next_ai = i
              set next_came = false
            endif
            set own_force[force_num] = p
            set force_num = force_num + 1
          else
            set no_ally_ctrl = false
            set ally_user = ally_user + 1
          endif
          set c_ally[player_race[i]] = c_ally[player_race[i]] + 1
          set ally_force[ally] = p
          set ally = ally + 1
        endif
      elseif IsPlayerEnemy(ai_player,p) then
        if GetPlayerController(p) != MAP_CONTROL_COMPUTER then
          set enemy_user = enemy_user + 1
        endif
        set c_enemy[player_race_pref[i]] = c_enemy[player_race_pref[i]] + 1
        set enemy_force[enemy] = p
        set enemy = enemy + 1
      endif
    endif
    set i = i + 1
  endloop
  set p = null
  set c_ai_total = ai_total
  set force_number = force_num
  set c_ally_total = ally
  set c_ally_user_total = ally_user
  set c_enemy_total = enemy
  set c_enemy_user_total = enemy_user
  set no_ai_ally = first_ai and next_ai == 0
endfunction

//==========================================================================
// (AMAI)	CopyGroup
//==========================================================================
function CopyGroup takes group g , group gnew returns group
  set gnew = CreateGroup()
  if FirstOfGroup(g) != null then
    call BlzGroupAddGroupFast(g,gnew)
  endif
  return gnew
endfunction

// Is unit actually invisible to player via abilities
function IsUnitInvisibleAM takes unit u, player target returns boolean
  local boolean isInvis = false
  set isInvis = UnitInvis(u) and not IsUnitDetected(u,target) // UnitInvis only detects some specific invisibility cases (e.g windwalkers are not one of them)
  set isInvis = isInvis or (IsUnitInvisible(u, target) and not IsUnitMasked(u, target) and not IsUnitFogged(u, target)) //IsUnitInvisible also takes actual visibility into account so fogged/masked need to be excluded
  return isInvis
endfunction

//==========================================================================
// (AMAI)	AreUnitsOfType
//==========================================================================
function AreUnitsOfType takes group g, integer id returns boolean
  local group cg = null
  local unit u = null
  set cg = CopyGroup(g,cg)
  loop
    set u = FirstOfGroup(cg)
    exitwhen u == null
    if GetUnitTypeId(u) != id then
      call DestroyGroup(cg)
      set cg = null
      set u = null
      return false
    endif
    call GroupRemoveUnit(cg, u)
  endloop
  call DestroyGroup(cg)
  set cg = null
  return true
endfunction

//==========================================================================
// (AMAI)	AddAbilityToGroup
//==========================================================================
function AddAbilityToGroup takes group g, integer abil returns nothing
  local unit u = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetUnitAbilityLevel(u, abil) <= 0 then
      call UnitAddAbility(u, abil)
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
endfunction

//==========================================================================
// (AMAI)	SelectNumberOfId
//==========================================================================
function SelectNumberOfId takes group rg, integer n, integer id returns group
  local integer c = 0
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    exitwhen c == n
    if GetUnitTypeId(u) == id then
      set c = c + 1
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  set u = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectById
//==========================================================================
function SelectById takes group rg, integer id, boolean is_id returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if (GetUnitTypeId(u) == id) == is_id then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByIdOr
//==========================================================================
function SelectByIdOr takes group rg, integer id1, integer id2, boolean is_id returns group
  local integer id = 0
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set id = GetUnitTypeId(u)
    if (id == id1 or id == id2) == is_id then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectUnittype
//==========================================================================
function SelectUnittype takes group rg, unittype typ, boolean is_of_type returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitType(u, typ) == is_of_type then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByIllusion
//==========================================================================
function SelectByIllusion takes group rg, boolean is_illusion returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitIllusion(u) == is_illusion then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByLoaded
//==========================================================================
function SelectByLoaded takes group rg, boolean is_loaded returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitLoaded(u) == is_loaded then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByHidden takes group rg, boolean is_visible returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitHidden(u) == is_visible then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByAlive
//==========================================================================
function SelectByAlive takes group rg, boolean is_alive returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if UnitAlive(u) == is_alive then
    //if not IsUnitType(u, UNIT_TYPE_DEAD) == is_alive then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByAlive2 takes group rg, boolean is_alive returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if (GetUnitState(u, UNIT_STATE_LIFE) > 0) == is_alive then
    //if not IsUnitType(u, UNIT_TYPE_DEAD) == is_alive then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

// This function is used in the harrass code and only affects units (not heroes)
function SelectByFullHealth takes group rg, boolean is_healed returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if (GetUnitState(u, UNIT_STATE_LIFE) >= GetUnitState(u, UNIT_STATE_MAX_LIFE)) == is_healed or IsUnitType(u, UNIT_TYPE_HERO) then
    //if not IsUnitType(u, UNIT_TYPE_DEAD) == is_alive then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByPlayer
//==========================================================================
function SelectByPlayer takes group rg, player p, boolean is_owner returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if (GetOwningPlayer(u) == p) == is_owner then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByInvisibleAM takes group rg, player enemy, boolean is_visible returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitInvisibleAM(u, enemy) == is_visible then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByInvisible takes group rg, player enemy, boolean is_visible returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitInvisible(u, enemy) == is_visible then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByVisible takes group rg, player enemy, boolean is_visible returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitVisible(u, enemy) == is_visible then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByDetected takes group rg, player enemy, boolean is_detected returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitDetected(u, enemy) == is_detected then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByEnemy
//==========================================================================
function SelectByEnemy takes group rg, player p, boolean is_enemy returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsPlayerEnemy(p, GetOwningPlayer(u)) == is_enemy then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByUserData
//==========================================================================
function IsStandardUnit takes unit u returns boolean
  if IsUnitInGroup(u, unit_healing) or IsUnitInGroup(u, unit_harassing) or IsUnitInGroup(u, unit_rescueing) or IsUnitInGroup(u, unit_zepplin_move) then
    return false
  endif
  return true
endfunction

function IsUnitBuying takes unit u returns boolean
  if IsUnitInGroup(u, unit_buying_item) or IsUnitInGroup(u, unit_buying_merc) or IsUnitInGroup(u, unit_buying_tavern) then
    return true
  endif
  return false
endfunction

function SelectByUnitStandard takes group rg, boolean has_data returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsStandardUnit(u) == has_data then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByUnitFree takes group rg, boolean has_data returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitBuying(u) == has_data then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByOrder
//==========================================================================
function SelectByOrder takes group rg, integer my_order, boolean has_order returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if (GetUnitCurrentOrder(u) == my_order) == has_order then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//============================================================================
function SelectByOrderOr takes group rg, integer my_order1, integer my_order2, boolean has_order returns group
  local integer order = 0
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set order = GetUnitCurrentOrder(u)
    if ((order == my_order1) or (order == my_order2)) == has_order then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

function SelectByOrderOr2 takes group rg, integer my_order1, integer my_order2, integer my_order3, boolean has_order returns group
  local integer order = 0
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set order = GetUnitCurrentOrder(u)
    if ((order == my_order1) or (order == my_order2) or (order == my_order3)) == has_order then
      call GroupAddUnit(rg, u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	SelectByLocation
//==========================================================================
function SelectByLocation takes group rg, location l, real dist, boolean is_near returns group
  local unit u = null
  local group g = rg
  set rg = CreateGroup()
  if l != null then
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      if (DistanceBetweenPoints_dk(GetUnitLoc(u), l) <= dist) == is_near then
        call GroupAddUnit(rg, u )
      endif
      call GroupRemoveUnit(g, u )
    endloop
  endif
  call DestroyGroup(g)
  set g = null
  return rg
endfunction

//==========================================================================
// (AMAI)	GroupAddGroup
//==========================================================================
function GroupAddGroup takes group g, group to_add returns group
  call BlzGroupAddGroupFast(to_add, g) // Params intentionally reversed
  return g
endfunction


//==========================================================================
// (AMAI)	GroupAddType
//==========================================================================
function GroupAddType takes group g, integer id, player p returns nothing
  local group ag = CreateGroup()
  call GroupEnumUnitsOfPlayer(ag, p, null)
  set ag = SelectNumberOfId(ag, 100, id)
  call GroupAddGroup(g, ag)
  call DestroyGroup(ag)
  set ag = null
endfunction

//==========================================================================
// (AMAI)	GroupAddTypeAndRemoveGuard
//==========================================================================
function GroupAddTypeAndRemoveGuard takes group g, integer id, player p returns nothing
  local unit u = null
  local group ag = CreateGroup()
  call GroupEnumUnitsOfPlayer(ag, p, null)
  loop
    set u = FirstOfGroup(ag)
    exitwhen u == null
    if GetUnitTypeId(u) == id then
      call RemoveGuardPosition(u)
      call CreateDebugTag("Remove Guard Position Group Add Type", 10, u, 3.00, 1.50)
      call GroupAddUnit(g,u)
    endif
    call GroupRemoveUnit(ag, u)
  endloop
  call DestroyGroup(ag)
  set ag = null
endfunction

//==========================================================================
// (AMAI)	GroupRemoveGuardPositionInstant
//==========================================================================
function GroupRemoveGuardPositionInstant takes group g returns nothing
  local unit u = null
  local group ug = null
  set ug = CopyGroup(g,ug)

  loop
    set u = FirstOfGroup(ug)
    exitwhen u == null
    call RemoveGuardPosition(u)
    call CreateDebugTag("Remove Guard Position Instant", 10, u, 3.00, 1.50)
    call GroupRemoveUnit(ug,u)
  endloop
  call DestroyGroup(ug)
  set ug = null
endfunction

//==========================================================================
// (AMAI)	GroupRecycleGuardPositionInstant
//==========================================================================
function GroupRecycleGuardPositionInstant takes group g returns nothing
  local unit u = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    call RecycleGuardPosition(u)
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
endfunction

function GroupRecycleHarrassPositionInstant takes group g returns nothing
  local unit u = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    call RecycleGuardPosition(u)
    call AddAssault(1, GetUnitTypeId(u))
    call GroupRemoveUnit(unit_harassing, u)
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
endfunction

function GroupRecycleGuardPositionByStandard takes group g returns nothing
  local unit u = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsStandardUnit(u) then
      call RecycleGuardPosition( u )
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
endfunction

//==========================================================================
// (AMAI)	RemoveSentUnits
//     NOT CURRENTLY USED
//==========================================================================
function RemoveSentUnits takes group g returns group
  call GroupRemoveUnit(g, neutral_sent[NEUTRAL_TAVERN])
  call GroupRemoveUnit(g, neutral_sent[NEUTRAL_OBSERVATORY])
  call GroupRemoveUnit(g, neutral_sent[NEUTRAL_MERC_CAMP])
  call GroupRemoveUnit(g, neutral_sent[NEUTRAL_DRAGON_ROOST])
//  call GroupRemoveUnit(g, follow_zeppelin )
  return SelectById(g, 'nzep', false)
endfunction

//==========================================================================
// (AMAI)	GetOneOfId
//==========================================================================
function GetOneOfId takes unit u, player p, integer id returns unit
  local group g = CreateGroup()
  call GroupEnumUnitsOfPlayer(g, p, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetUnitTypeId(u) == id and UnitAlive(u) and not IsUnitHidden(u) then
      call DestroyGroup(g)
      set g = null
      return u
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return u
endfunction

//==========================================================================
// (AMAI)	GetOneOfIdNearLoc
//==========================================================================
function GetOneOfIdNearLoc takes unit u, player p, integer id, location l, real dist returns unit
  local group g = CreateGroup()
  call GroupEnumUnitsInRangeOfLoc(g, l, dist, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetUnitTypeId(u) == id and GetOwningPlayer(u) == p and UnitAlive(u) and not IsUnitHidden(u) then
      call DestroyGroup(g)
      set g = null
      return u
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  set g = null
  return u
endfunction

//==========================================================================
// (AMAI)	GetMineNearLoc
//==========================================================================
function GetMineNearLoc takes unit u, location l, real dist returns unit
  local group g = CreateGroup()
  local integer i = 0
  local real d1 = 0
  local real d2 = dist
  local unit mine = null
  local boolean captures_mines = race_uses_mine_expansion or race_manual_loading
  set u = null
  if minearray == 0 then
    call DisplayToAll("Warning - No standard gold mine set in standardunits.slk")
    call Sleep(3)
  else
    call GroupEnumUnitsInRangeOfLoc(g, l, dist, null)
    loop
      set mine = FirstOfGroup(g)
      exitwhen mine == null
      if UnitAlive(mine) and GetResourceAmount(mine) > 0 and (not captures_mines or GetOwningPlayer(mine) == ai_player) then
        set i = 0
        loop
          exitwhen i >= minearray
          if GetUnitTypeId(mine) == racial_goldmine[i] then
            set i = minearray
            set d1 = DistanceBetweenPoints_dk(GetUnitLoc(mine), l)
            if d1 <= d2 then  // get close mine
              set d2 = d1
              set u = mine
            endif
          endif
          set i = i + 1
        endloop
      endif
      call GroupRemoveUnit(g,mine)
    endloop
    set mine = null
    if u != null then
      call Trace("GetMineNearLOC: A Mine match found")
    endif
  endif
  call DestroyGroup(g)
  set g = null
  return u
endfunction

//==========================================================================
// (AMAI Addition by SM) Get Nearest Neutral
//==========================================================================
// function CanPathToLoc takes location locA, location target, pathingtype path returns real

// // This function returns the time to path to a location. If positive its pathable, if negative
// // its unpathable.

    // local integer groundid = 'ewsp'
    // local integer seaid = 'hdes'
    // local integer amphibiousid = 'nsnp'
    // local integer flyid = 'hgyr'
    // local unit u = null
    // local real distance = 0
    // local location l = null
    // local real checktime = 0
    // local real totaltime = 0
	// local boolean exitloop = false
	// local location prev_loc = null
	// local integer checks = 0	// Number of times unit has stayed at same position

    // if path == PATHING_TYPE_WALKABILITY then
        // set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), groundid, GetLocationX(locA), GetLocationY(locA), 270.00)
    // elseif path == PATHING_TYPE_FLOATABILITY then
        // set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), seaid, GetLocationX(locA), GetLocationY(locA), 270.00)
    // elseif path == PATHING_TYPE_AMPHIBIOUSPATHING then
        // set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), amphibiousid, GetLocationX(locA), GetLocationY(locA), 270.00)
    // elseif path == PATHING_TYPE_FLYABILITY then
        // set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), flyid, GetLocationX(locA), GetLocationY(locA), 270.00)
    // else
        // set totaltime = -1
    // endif

	// if totaltime == 0 then
	    // call SetUnitInvulnerable(u, true)
      // call ShowUnit(u, false)
      // call SetUnitUseFood(u, false)
      // call SetUnitMoveSpeed(u, 520)
      // call RemoveGuardPosition(u)
      // call IssuePointOrder(u, "move", GetLocationX(target), GetLocationY(target))

    // set checktime =  GetTimeToReachLoc(u, target)
    // set totaltime = checktime
    // //call UnitApplyTimedLife(u, 'BTLF', checktime * 5)
    // //call Sleep(checktime)
    // set checktime = 2.00

    // loop
		// exitwhen (exitloop == true)
		// //	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "pathing loop")
        // set l = GetUnitLoc(u)
        // set distance = DistanceBetweenPoints(l,target)
        // if distance <= buy_distance then
		// //	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Tavern is pathable")
			// call CreateDebugTag("Target Destination is pathable", 10, u, 3.00, 1.50)
			// call RemoveUnit(u)
			// set u = null
			// set exitloop = true
      // //return totaltime
		// //elseif GetUnitCurrentOrder(u) == OrderId("stop") then
          // //return (totaltime * -1)
        // elseif GetUnitState(u, UNIT_STATE_LIFE) <= 0 then
			// call RemoveUnit(u)
			// set u = null
			// set exitloop = true
			// set totaltime = totaltime * -1
            // //return (totaltime * -1)
        // elseif GetUnitCurrentOrder(u) == OrderId("stop") or GetUnitCurrentOrder(u) != OrderId("move") then
			// set checks = checks + 1
			// call CreateDebugTag("Invisible Path unit has stopped", 10, u, 3.00, 1.50)
			// if checks > 1 then
				// call CreateDebugTag("Target Destination was not reached", 10, u, 3.00, 1.50)
				// call RemoveUnit(u)
				// set u = null
				// set exitloop = true
				// set totaltime = totaltime * -1
				// //return (totaltime * -1)
			// endif
		// else
			// set checks = 0	// means unit is moving and not standing still
			// call CreateDebugTag("Invisible Path Unit Here", 10, u, 3.00, 1.50)
        // endif
		// call RemoveLocation(l)
		// set l = null
    // set totaltime = totaltime + checktime
    // call Sleep(checktime)

    // endloop
	// endif

    // return (totaltime)

// endfunction

function CreatePathingUnitFull takes unit u, player p, integer id, real x, real y returns unit
  if not IsVisibleToPlayer(x, y, ai_player) and p != Player(PLAYER_NEUTRAL_PASSIVE) then
    set p = Player(PLAYER_NEUTRAL_PASSIVE)
  endif
  set u = CreateUnit(p, id, x, y, 270.00)
  if (not debugging) then
    call ShowUnit(u, false)
  endif
  call UnitShareVision(u, ai_player, false)
  call UnitRemoveAbility(u, 'Adtn') // Remove detonate to avoid any automatic deaths
  call SetUnitInvulnerable(u, true)
  call SetUnitUseFood(u, false)
  call SetUnitMoveSpeed(u, 522)
  if p != ai_player then
    call SetUnitOwner(u, ai_player, true)  // player overriden as neutral players cannot be used
  endif
  call RemoveGuardPosition(u)
  return u
endfunction

function CreatePathingUnit takes unit u returns unit
  // local integer groundid = 'ewsp'
  // if GetPlayerRace(ai_player) == RACE_NIGHTELF then
  //   set groundid = 'uaco' // alternative for night elf players to avoid it counting for players peon count
  // endif
  // Have to use ai_player as larger maps the passive player ai is restricted at such large numbers of units with orders being paused for seconds then continuing. Appears to be hardcoded into the warcraft 3 engine.
  set u = CreatePathingUnitFull(u, ai_player, groundid, GetLocationX(home_location), GetLocationY(home_location))
  return u
endfunction

function CanPathToLoc takes location locA, location target, pathingtype path returns real

// This function returns the time to path to a location. If positive its pathable, if negative
// its unpathable.

  //local integer groundid = 'ewsp'
  local integer seaid = 'hdes'
  local integer amphibiousid = 'nsnp'
  local integer flyid = 'hgyr'
  local unit u = null
  local real distance = 0
  //local location l = null
  local real checktime = 0
  local real totaltime = 0
  //local location prev_loc = null
  local integer checks = 0	// Number of times unit has stayed at same position

  if path == PATHING_TYPE_WALKABILITY then
    set u = CreatePathingUnitFull(u, Player(PLAYER_NEUTRAL_PASSIVE), groundid, GetLocationX(locA), GetLocationY(locA))
  elseif path == PATHING_TYPE_FLOATABILITY then
    set u = CreatePathingUnitFull(u, Player(PLAYER_NEUTRAL_PASSIVE), seaid, GetLocationX(locA), GetLocationY(locA))
  elseif path == PATHING_TYPE_AMPHIBIOUSPATHING then
    set u = CreatePathingUnitFull(u, Player(PLAYER_NEUTRAL_PASSIVE), amphibiousid, GetLocationX(locA), GetLocationY(locA))
  elseif path == PATHING_TYPE_FLYABILITY then
    set u = CreatePathingUnitFull(u, Player(PLAYER_NEUTRAL_PASSIVE), flyid, GetLocationX(locA), GetLocationY(locA))
  else
    return -1.0
  endif

  call IssuePointOrder(u, "move", GetLocationX(target), GetLocationY(target))
//	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Path Unit Created")

  set checktime =  GetTimeToReachLoc(u, target)
  set totaltime = checktime
  //call UnitApplyTimedLife(u, 'BTLF', checktime * 5)
  //call Sleep(checktime)
  set checktime = 2.00

  loop
  //	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "pathing loop")
    set distance = DistanceBetweenPoints_dk(GetUnitLoc(u),target)
    if distance <= buy_distance then
  //	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Tavern is pathable")
      call CreateDebugTag("Target Destination is pathable", 10, u, 3.00, 1.50)
      call RemoveUnit(u)
      set u = null
      return totaltime
  //elseif GetUnitCurrentOrder(u) == OrderId("stop") then
      //return (totaltime * -1)
    elseif GetUnitState(u, UNIT_STATE_LIFE) <= 0 then
      call RemoveUnit(u)
      set u = null
      return (totaltime * -1)
    elseif GetUnitCurrentOrder(u) == OrderId("stop") or GetUnitCurrentOrder(u) != OrderId("move") then
      set checks = checks + 1
      call CreateDebugTag("Invisible Path unit has stopped", 10, u, 3.00, 1.50)
      if checks > 1 then
        call CreateDebugTag("Target Destination was not reached", 10, u, 3.00, 1.50)
        call RemoveUnit(u)
        set u = null
        return (totaltime * -1)
      endif
    else
      set checks = 0	// means unit is moving and not standing still
      call CreateDebugTag("Invisible Path Unit Here", 10, u, 3.00, 1.50)
    endif
    set totaltime = totaltime + checktime
    call Sleep(checktime)
  endloop
  return (totaltime * -1)

endfunction

//==========================================================================
// (AMAI) Finds nearest neutral quick without checking if it is passable
//        this is used so computer dosn't get stuck waiting for the longer
//        method to compute
//==========================================================================
function GetNearestNeutralQuick takes unit ru, integer id returns unit
  local group g = CreateGroup()
  local unit u = null
  local real distance = 10000000
  local real newdistance = 0
  set ru = null
  call GroupEnumUnitsOfPlayer(g, Player(PLAYER_NEUTRAL_PASSIVE), null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetUnitTypeId(u) == id and UnitAlive(u) then
      set newdistance = DistanceBetweenPoints_kd(home_location, GetUnitLoc(u))
      if newdistance < distance then
        set distance = newdistance
        set ru = u
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
  if ru != null and GetUnitTypeId(ru) == neutral_id[NEUTRAL_HEAL_WARD] and IsUnitType(ru, UNIT_TYPE_SUMMONED) then
    set ru = null
  endif
  return ru
endfunction

//==========================================================================
// (AMAI) Finds nearest neutral that is passable
//==========================================================================
function CalcNearestNeutrals takes nothing returns nothing
  local group g = CreateGroup()
  local unit u = null
  local real distance = 0
  local group tempg = null
  local unit array pather
  local integer i = 0
  local integer neutral_i = 0
  local integer array checks
  local boolean pathingdone = true
  local real array lx
  local real array ly

  call GroupEnumUnitsOfPlayer(g, Player(PLAYER_NEUTRAL_PASSIVE), null)
  set tempg = CopyGroup(g, tempg)
  loop
    set u = FirstOfGroup(tempg)
    exitwhen u == null
    if UnitAlive(u) and not IsUnitType(u, UNIT_TYPE_SUMMONED) then  //prevent neutral_id[NEUTRAL_HEAL_WARD]
      set neutral_i = 0
      loop
        exitwhen neutral_i >= NEUTRAL_COUNT
        if GetUnitTypeId(u) == neutral_id[neutral_i] then
          set nearest_neutral[neutral_i] = null
          set pather[i] = CreatePathingUnit(pather[i])
          set checks[i] = 0
          call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
          if (ModuloInteger(i,10) == 0) then
            call StaggerSleep(0.1 * sleep_multiplier, GetRandomReal(0.2, 0.4) * sleep_multiplier)
          endif
          set i = i + 1
        endif
        exitwhen GetUnitTypeId(u) == neutral_id[neutral_i]
        set neutral_i = neutral_i + 1
      endloop
      if neutral_i >= NEUTRAL_COUNT then
        // Not a valid unit to track
        call GroupRemoveUnit(g, u)
      endif
    else
      call GroupRemoveUnit(g, u)
    endif
    call GroupRemoveUnit(tempg, u)
  endloop

  call Trace("Total Neutrals to path to:" + Int2Str(i))
  call DestroyGroup(tempg)
  loop
    set pathingdone = true
    set tempg = CopyGroup(g, tempg)
    set i = 0
    loop
      set u = FirstOfGroup(tempg)
      exitwhen u == null
      if pather[i] != null then
        set distance = DistanceBetweenUnits(pather[i],u)
        set neutral_i = 0
        loop
          exitwhen neutral_i >= NEUTRAL_COUNT
          exitwhen pather[i] == null
          if GetUnitTypeId(u) == neutral_id[neutral_i] then
            if nearest_neutral[neutral_i] != null then
              call RemoveUnit(pather[i])
              set pather[i] = null
            elseif distance <= buy_distance then
              call CreateDebugTag("Target Destination is pathable", 10, pather[i], 10.00, 8.00)
              call RemoveUnit(pather[i])
              set pather[i] = null
              if nearest_neutral[neutral_i] == null then
                set nearest_neutral[neutral_i] = u
              endif
            elseif GetUnitState(pather[i], UNIT_STATE_LIFE) <= 0 then
              call RemoveUnit(pather[i])
              set pather[i] = null
            elseif GetUnitCurrentOrder(pather[i]) == OrderId("stop") or GetUnitCurrentOrder(pather[i]) != OrderId("move") then
              set checks[i] = checks[i] + 1
              if checks[i] > 2 then
                call CreateDebugTag("Target Destination was not reached", 10, pather[i], 10.00, 8.00)
                call RemoveUnit(pather[i])
                set pather[i] = null
              else
                call CreateDebugTag("Invisible Path unit has stopped", 10, pather[i], 10.00, 8.00)
                call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
              endif
            else
              //call CreateDebugTag("Invisible Path Unit Here and Moving", 10, pather[i], 10.00, 8.00)
              if (lx[i] != 0 and ly[i] != 0) then
                if GetUnitX(pather[i]) == lx[i] and GetUnitY(pather[i]) == ly[i] then
                  // Actually stuck
                  call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
                endif
              endif
              set lx[i] = GetUnitX(pather[i])
              set ly[i] = GetUnitY(pather[i])
            endif
          endif
          exitwhen GetUnitTypeId(u) == neutral_id[neutral_i]
          set neutral_i = neutral_i + 1
        endloop
        set pathingdone = false
      endif
      call GroupRemoveUnit(tempg, u)
      set i = i + 1
    endloop
    call DestroyGroup(tempg)
    exitwhen pathingdone
    call StaggerSleep(0.8 * sleep_multiplier, 1 * sleep_multiplier)
  endloop
  set tempg = null
  call DestroyGroup(g)
  set g = null
endfunction

function GetNearestNeutral takes unit ru, integer id returns unit
  local group g = CreateGroup()
  local unit u = null
//    local unit homepeon = GetExpansionPeon() //Is to be used for checking pathability again
  local real distance = 0
//    local real newdistance = 0
//    local location l = null
  local group tempg = null
  local unit array pather
  local integer i = 0
  local integer array checks
  local boolean pathingdone = true
  //local real totaltime = 0
  //local integer groundid = 'ewsp'
//call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "get nearest neutral start")


//call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "neutral start loop")

//----- initial loop to get the nearest neutral

//----- check if it really is passable
//set l = GetUnitLoc(unit_nearest)
//set newdistance = CanPathToLoc(start_loc, l, PATHING_TYPE_WALKABILITY)
//call RemoveLocation(l)
//set l = null

//----- closest not passable so try others
//call GroupClear(g)
  call GroupEnumUnitsOfPlayer(g, Player(PLAYER_NEUTRAL_PASSIVE), null)
//call GroupRemoveUnit(g, unit_nearest)
  set ru = null
  set tempg = CopyGroup(g,tempg)
  loop
    set u = FirstOfGroup(tempg)
    exitwhen u == null
    if GetUnitTypeId(u) == id and UnitAlive(u) and not IsUnitType(u, UNIT_TYPE_SUMMONED) then  //prevent neutral_id[NEUTRAL_HEAL_WARD]
      set pather[i] = CreatePathingUnit(pather[i])
      set checks[i] = 0
      call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
      if ModuloInteger(i,10) == 0 then
        call StaggerSleep(0.2 * sleep_multiplier, 0.3 * sleep_multiplier)
      endif
      set i = i + 1
    else
      call GroupRemoveUnit(g, u)
    endif
    call GroupRemoveUnit(tempg, u)
  endloop
  call Trace("Total Neutrals to path to:" + Int2Str(i))
  call DestroyGroup(tempg)
  //set distance = 10000000
  loop
    //set totaltime = totaltime + 3
    set pathingdone = true
    set tempg = CopyGroup(g,tempg)
    set i = 0
    loop
      set u = FirstOfGroup(tempg)
      exitwhen u == null
      if pather[i] != null then
        set distance = DistanceBetweenUnits(pather[i],u)
        if ru != null then
          call RemoveUnit(pather[i])
          set pather[i] = null
        elseif distance <= buy_distance then
        //call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Tavern is pathable")
          call CreateDebugTag("Target Destination is pathable", 10, pather[i], 3.00, 3.00)
          call RemoveUnit(pather[i])
          set pather[i] = null
          if ru == null then
            set ru = u
          endif
        //elseif GetUnitCurrentOrder(u) == OrderId("stop") then
          //return (totaltime * -1)
        elseif GetUnitState(pather[i], UNIT_STATE_LIFE) <= 0 then
          call RemoveUnit(pather[i])
          set pather[i] = null
        elseif GetUnitCurrentOrder(pather[i]) == OrderId("stop") or GetUnitCurrentOrder(pather[i]) != OrderId("move") then
          set checks[i] = checks[i] + 1
          call CreateDebugTag("Invisible Path unit has stopped", 10, pather[i], 3.00, 3.00)
          if checks[i] > 2 then
            call CreateDebugTag("Target Destination was not reached", 10, pather[i], 3.00, 3.00)
            call RemoveUnit(pather[i])
            set pather[i] = null
          else
            call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
          endif
        //else
          //set checks = 0	// means unit is moving and not standing still
          //call CreateDebugTag("Invisible Path Unit Here", 10, pather[i], 3.00, 3.00)
        endif
        set pathingdone = false
      endif
      call GroupRemoveUnit(tempg, u)
      set i = i + 1
    endloop
    call DestroyGroup(tempg)
    exitwhen pathingdone
    call StaggerSleep(0.8 * sleep_multiplier, 1 * sleep_multiplier)
  endloop
  set tempg = null
  call DestroyGroup(g)
  set g = null
  return ru
	//loop
	//	set u = FirstOfGroup(g)
	//	exitwhen u == null
	//	set l = GetUnitLoc(u)
	//	if GetUnitTypeId(u) == id then
	//	//set newdistance = DistanceBetweenPoints(start_loc, l )
	//	  	set newdistance = CanPathToLoc(start_loc, l, PATHING_TYPE_WALKABILITY)
	//		if newdistance > 0 and newdistance < distance then
	//		 set distance = newdistance
	//		 set ru = u
	//	     endif
	//     endif

    //    call GroupRemoveUnit(g, u)
	//	call RemoveLocation(l)
	//	set l = null
	//endloop

	//	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "neutral out loop")
	//call DestroyGroup(g)
	//set g = null
	//call RemoveLocation(start_loc)
	//set start_loc = null

endfunction

//==========================================================================
// (AMAI)	GetNearestOfGroup
// NOTE: Function will remove units from the group passed to it
//==========================================================================
function GetNearestOfGroup takes unit ru, group g, location l returns unit
  local real d = 0
  local unit u = null
  local real sd = 1000000
  set ru = null
  if l != null then
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      set d = DistanceBetweenPoints_dk(GetUnitLoc(u), l)
      if d < sd then
        set sd = d
        set ru = u
      endif
      call GroupRemoveUnit(g, u )
    endloop
  endif
  return ru
endfunction

//==========================================================================
// (AMAI)	GetNearestSubGroupOfGroup
// NOTE: Function will remove units from the group passed to it
//==========================================================================
function GetNearestSubGroupOfGroup takes group rg, location l, integer n returns group
  local unit array ua
  local real array da
  local integer size = 0
  local integer i = 0
  local integer ru = 0
  local unit u = null
  local real d = 0
  loop
    set u = FirstOfGroup(rg)
    exitwhen u == null
    set d = DistanceBetweenPoints_dk(GetUnitLoc(u), l)
    set i = size - 1
    loop
      exitwhen i < 0 or da[i] >= d
      set ua[i+1] = ua[i]
      set da[i+1] = da[i]
      set i = i - 1
    endloop
    set i = i + 1
    set ua[i] = u
    set da[i] = d
    set size = size + 1
    call GroupRemoveUnit(rg,u)
  endloop
  set i = size - Min(n, size)
  loop
    exitwhen ru > size
    if ru == i and i < size then
      call GroupAddUnit(rg, ua[i])
      set i = i + 1
    endif
    set ua[ru] = null
    set ru = ru + 1
  endloop
  return rg
endfunction

//==========================================================================
// (AMAI)	GetFarestOfGroup
//==========================================================================
function GetFarestOfGroup takes unit ru, group g, location l returns unit
  local real d = 0
  local unit u = null
  local real sd = 0
  set ru = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set d = DistanceBetweenPoints_dk(GetUnitLoc(u), l)
    if d > sd then
      set sd = d
      set ru = u
    endif
    call GroupRemoveUnit(g, u )
  endloop
  return ru
endfunction

//==========================================================================
// (AMAI)	GetFastestToPointOfGroup
//==========================================================================
function GetFastestToPointOfGroup takes unit ru, group g, location l returns unit
  local real d = 0
  local unit u = null
  local real sd = 1000000
  set ru = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set d = DistanceBetweenPoints_dk(GetUnitLoc(u), l) / RMax(GetUnitMoveSpeed(u),0.01)
    if d < sd then
      set sd = d
      set ru = u
    endif
    call GroupRemoveUnit(g, u )
  endloop
  return ru
endfunction

//==========================================================================
// (AMAI)	GetLeastHPUnitOfGroup
//==========================================================================
function GetLeastHPUnitOfGroup takes unit ru, group g returns unit
  local real hp = 0
  local unit u = null
  local real lhp = 1000000
  set ru = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set hp = GetUnitState(u, UNIT_STATE_LIFE)
    if hp < lhp then
      set lhp = hp
      set ru = u
    endif
    call GroupRemoveUnit(g, u )
  endloop
  call DestroyGroup(g)
  return ru
endfunction

//==========================================================================
// (AMAI)	UnitAliveInGroup
//==========================================================================
function UnitAliveInGroup takes group rg returns boolean
  local unit u = null
  local group g = null
  set g = CopyGroup(rg, g)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not UnitAlive(u) then
      call GroupRemoveUnit(rg, u)
      call GroupRemoveUnit(unit_harassing, u)
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
  return FirstOfGroup(rg) != null
endfunction

//==========================================================================
// (AMAI)	GetUnitToBuy
//==========================================================================
function GetUnitToBuy takes unit ru, unit buy_place returns unit
  local group g = CreateGroup()
  local unit u = null
  local real distance = 10000
  local real newdistance = 0
  set ru = null
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  if follow_zeppelin != null then
    call GroupRemoveUnit(g, follow_zeppelin)
  endif
  call GroupRemoveUnit(g, expansion_peon)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitType(u, UNIT_TYPE_STRUCTURE) and not IsUnitType(u, UNIT_TYPE_PEON) and not IsUnitType(u, UNIT_TYPE_SUMMONED) and GetUnitState(u, UNIT_STATE_LIFE) > 0 and not IsUnitHidden(u) and not IsUnitLoaded(u) and not IsUnitIllusion(u) and not IsUnitBuying(u) and IsStandardUnit(u) then
      set newdistance = DistanceBetweenUnits(buy_place, u)
      if newdistance < distance then
        set distance = newdistance
        set ru = u
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
  if ru == null then
    set ru = GetExpansionPeon()
    if ru == null or not UnitAlive(ru) then
      set ru = GetExpansionPeon2(ru)
    endif
  endif
  return ru
endfunction

//==========================================================================
// (AMAI)	GetUnitOfTypeNearUnit
//==========================================================================
function GetUnitOfTypeNearUnit takes integer ut, unit nu, unit ru returns unit
  local group g = CreateGroup()
  local location unitloc = GetUnitLoc(nu)

  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  set g = SelectById(g, ut, true)
  set g = SelectByAlive(g, true)
  set g = SelectByHidden(g, false)
  set ru = GetNearestOfGroup(ru, g, unitloc)
  call DestroyGroup(g)
  set g = null
  call RemoveLocation(unitloc)
  set unitloc = null
  return ru
endfunction

//==========================================================================
// (AMAI)	GetUnusedZeppelin
//==========================================================================
function GetUnusedZeppelinNearUnit takes unit ru, unit nu returns unit
  local group g = CreateGroup()
  local location unitloc = GetUnitLoc(nu)

  call GroupEnumUnitsOfType(g, "goblinzeppelin", null)
  set g = SelectByPlayer(g, ai_player, true)
  set g = SelectByAlive(g, true)
  set g = SelectByOrderOr(g, 0, order_cancel, true)
  set g = SelectByUnitFree(g, true)
  set g = SelectByUnitStandard(g, true)
  set ru = GetNearestOfGroup(ru, g, unitloc)
  call DestroyGroup(g)
  set g = null
  call RemoveLocation(unitloc)
  set unitloc = null
  return ru
endfunction

//==========================================================================
// (AMAI)	RemoveUnitsOfType
//==========================================================================
function RemoveUnitsOfType takes string ut returns nothing
  local group g = CreateGroup()
  local unit u = null
  call GroupEnumUnitsOfType(g, ut, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    call GroupRemoveUnit(g, u)
    call RemoveUnit(u)
  endloop
  call DestroyGroup(g)
  set g = null
endfunction

//==========================================================================
// (AMAI)	Hero Utility Functions
//==========================================================================
function GetHeroNumber takes integer id returns integer
  local integer i = 1
  loop
    exitwhen i > 3
    if id == old_id[hero[i]] then
      return i
    endif
    set i = i + 1
  endloop
  return 1
endfunction

//==========================================================================
function GetHeroNumberOfUnit takes unit u returns integer
  local integer i = 1
  loop
    exitwhen i > 3
    if u == hero_unit[i] then
      return i
    endif
    set i = i + 1
  endloop
  return 1
endfunction

//==========================================================================
// (AMAI)	GetMajorHero
//==========================================================================

// gets a unit that can act as a hero for versions without heroes
function GetUnitHero takes unit u returns unit
  local group g = CreateGroup()
  call GroupEnumUnitsOfPlayer(g,ai_player,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitType(u, UNIT_TYPE_STRUCTURE) and not IsUnitType(u, UNIT_TYPE_SUMMONED) and not IsUnitType(u, UNIT_TYPE_PEON) and UnitAlive(u) and not IsUnitHidden(u) and IsStandardUnit(u) then
      call DestroyGroup(g)
      set g = null
      return u
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  return u
endfunction

function GetUnitHeroReplacement takes unit u , location l returns unit
  local group g = CreateGroup()
  call GroupEnumUnitsInRangeOfLoc(g, l, battle_radius, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetOwningPlayer(u) == ai_player and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and not IsUnitType(u, UNIT_TYPE_SUMMONED) and not IsUnitType(u, UNIT_TYPE_PEON) and UnitAlive(u) and not IsUnitHidden(u) and IsStandardUnit(u) then
      call DestroyGroup(g)
      set g = null
      return u
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  return u
endfunction

function GetMajorHero takes unit u returns unit
  local integer i = 1
  loop
    exitwhen i > 3
    if hero_built[i] and UnitAlive(hero_unit[i]) and not IsUnitInGroup(hero_unit[i], unit_healing) then
      return hero_unit[i]
    endif
    set i = i + 1
  endloop
  return GetUnitHero(u)
  //return null
endfunction

//==========================================================================
function GetMajorHeroReplacement_d takes unit u, location l returns unit
  local integer i = 1

  loop
    exitwhen i > 3
    if hero_built[i] and UnitAlive(hero_unit[i]) and IsUnitInRangeLoc(hero_unit[i], l, battle_radius) and not IsUnitInGroup(hero_unit[i], unit_healing) then
      call RemoveLocation(l)
      return hero_unit[i]
    endif
    set i = i + 1
  endloop
  set u = GetUnitHeroReplacement(u,l)
  call RemoveLocation(l)
  return u
endfunction

function GetMajorHeroReplacement_k takes unit u, location l returns unit
  local integer i = 1

  loop
    exitwhen i > 3
    if hero_built[i] and UnitAlive(hero_unit[i]) and IsUnitInRangeLoc(hero_unit[i], l, battle_radius) and not IsUnitInGroup(hero_unit[i], unit_healing) then
      return hero_unit[i]
    endif
    set i = i + 1
  endloop
  return GetUnitHeroReplacement(u,l)
endfunction

//==========================================================================
// (AMAI)	GetNeutralNumber
//==========================================================================
function GetNeutralNumber takes integer id returns integer
  if buy_type[id] == BT_NEUTRAL_HERO then
    return NEUTRAL_TAVERN
  elseif buy_type[id] == BT_GOBLIN_MERC then
    return NEUTRAL_OBSERVATORY
  elseif buy_type[id] == BT_MERC then
    return NEUTRAL_MERC_CAMP
  else
    return NEUTRAL_DRAGON_ROOST
  endif
endfunction

function GetTQLock takes nothing returns nothing
  loop
    exitwhen tq_lock
    call Sleep(0.5)
  endloop
  set tq_lock = false
endfunction

function ReleaseTQLock takes nothing returns nothing
  set tq_lock = true
endfunction

// To run a sleep within the job thread, that will delay all other jobs as well
function TQSleep takes real time returns nothing
  local integer i = 1
  call GetTQLock()
  loop
    exitwhen i > tq_length
    set tq_time[i] = tq_time[i] + time
    set i = i + 1
  endloop
  call ReleaseTQLock()
  call Sleep(time)
endfunction

//==========================================================================
// (AMAI)	Action List Utility functions
//==========================================================================
function ActionListInit takes integer an returns nothing
  local integer i = 0
  set action_numbers = an
  loop
    exitwhen i >= an
    set action_points[i] = 0.0
    set i = i + 1
  endloop
endfunction

//==========================================================================
function ActionRule takes boolean b, integer chn, real cha returns nothing
  if b then
    set action_points[chn] = action_points[chn] + cha
  endif
endfunction

//==========================================================================
function ActionRule2 takes boolean b, integer chn, real cha, integer chn2, real cha2 returns nothing
  if b then
    set action_points[chn] = action_points[chn] + cha
    set action_points[chn2] = action_points[chn2] + cha2
  endif
endfunction

//==========================================================================
function ActionRule3 takes boolean b, integer chn, real cha, integer chn2, real cha2, integer chn3, real cha3 returns nothing
  if b then
    set action_points[chn] = action_points[chn] + cha
    set action_points[chn2] = action_points[chn2] + cha2
    set action_points[chn3] = action_points[chn3] + cha3
  endif
endfunction

//==========================================================================
function ActionListEval takes nothing returns integer
  local integer i = 0
  local integer max_i = -1
  local real max_val = -10000000.0
  loop
    exitwhen i >= action_numbers
    if action_points[i] > max_val then
      set max_i = i
      set max_val = action_points[i]
    endif
    set i = i + 1
  endloop
  return max_i
endfunction

//==========================================================================
// (AMAI) Get Strength of a Player
//==========================================================================
function GetPlayerStrengthHandicap takes player p returns real
  return SquareRoot(GetPlayerHandicap(p))
endfunction

//============================================================================
function GetPlayerHeroBonusStrength takes player p returns integer
  local integer strength = 0
  #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND %#OEVAL{16} != 0
  set strength = strength + %#OEVAL{16} * GetPlayerUnitTypeCount(p, o%1 )
  #ENDINCLUDE
  return strength
endfunction
//============================================================================
function GetHeroStrength takes unit u returns integer
  local integer lvl = GetHeroLevel(u)
  if GetOwningPlayer(u) != ai_player or not IsUnitInGroup(u, unit_healing) then
    if lvl >= ver_hero_ultimate_level then
      return R2I(ver_hero_base_value + lvl + ver_hero_ultimate_value + 0.5)
    else
      return R2I(ver_hero_base_value + lvl + 0.5)
    endif
  endif
  return 0
endfunction

//============================================================================
function GetPlayerHeroStrengthMod takes player p returns integer
  local group g = CreateGroup()
  local unit u = null
  local integer sum = 0
  local real handicap = GetPlayerStrengthHandicap(p)
  call GroupEnumUnitsOfPlayer(g, p, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitType(u, UNIT_TYPE_HERO) and UnitAlive(u) then
      set sum = sum + R2I(GetHeroStrength(u) * handicap * (GetUnitState(u, UNIT_STATE_LIFE) / RMax(GetUnitState(u, UNIT_STATE_MAX_LIFE), 1)))
    endif
    call GroupRemoveUnit(g,u)
  endloop
  set sum = sum + GetPlayerHeroBonusStrength(p)
  call DestroyGroup(g)
  set g = null
  return sum
endfunction

//============================================================================
function GetUnitStrengthEx takes unit u returns integer
  if GetOwningPlayer(u) != Player(PLAYER_NEUTRAL_AGGRESSIVE) then
    if IsUnitType(u, UNIT_TYPE_HERO) then
      return GetHeroStrength(u)
    else
      return R2I((GetUnitFoodUsed(u) + GetUnitLevel(u)) / 2 + 0.5) // +0.5 for rounding , food used often matches the level but can be weaker or stronger forms of a lvl 2 unit so uses average
    endif
  else
    return R2I(GetUnitLevel(u) + 0.5) // Creeps entirely use the level in evaluating strength
  endif
  return 0
endfunction

function IsUnitTower takes unit u returns boolean
  local integer i = 0
  if IsUnitType(u, UNIT_TYPE_STRUCTURE) then
    if IsUnitType(u, UNIT_TYPE_RANGED_ATTACKER) then
      return true
    endif
    set i = GetUnitTypeId(u)
    if i == 'hwtw' or i == 'uzig' or i == 'ocbw' then
      return true
    endif
  elseif GetUnitMoveSpeed(u) == 0 and not IsUnitType(u, UNIT_TYPE_SUMMONED) then
    set i = GetUnitTypeId(u)
    if i == 'osp1' or i == 'osp2' or i == 'osp3' or i == 'osp4' then
      return true
    endif
  endif
  return false
endfunction

//============================================================================
function GetTowerStrength takes unit u returns real
  if GetUnitState(u, UNIT_STATE_MAX_LIFE) == 0 then
    call DisplayToAll("ERROR: Major error has occured and caused amai system to crash at function GetUnitStrength")
    call DisplayToAll("Please contact the creator and provide this replay to them")
  endif
  if IsUnitType(u, UNIT_TYPE_RANGED_ATTACKER) then
    return 1 * (GetUnitState(u, UNIT_STATE_LIFE) / GetUnitState(u, UNIT_STATE_MAX_LIFE))
  endif
  return 0.5 * (GetUnitState(u, UNIT_STATE_LIFE) / GetUnitState(u, UNIT_STATE_MAX_LIFE))
endfunction

function GetUnitStrength takes unit u returns real
  if GetUnitState(u, UNIT_STATE_MAX_LIFE) == 0 then
    call DisplayToAll("ERROR: Major error has occured and caused amai system to crash at function GetUnitStrength")
    call DisplayToAll("Please contact the creator and provide this replay to them")
  endif
  if IsUnitTower(u) then
    return GetTowerStrength(u)
  endif
  return GetUnitStrengthEx(u) * GetPlayerStrengthHandicap(GetOwningPlayer(u)) * (GetUnitState(u, UNIT_STATE_LIFE) / GetUnitState(u, UNIT_STATE_MAX_LIFE))
endfunction

//============================================================================
function GetPlayerStrength takes player p returns real
//  local integer peon_count = 0
// #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\bpeon\b/
//  set peon_count = peon_count + GetPlayerUnitTypeCount(p, o%1)
// #ENDINCLUDE
//  return R2I((I2R(GetPlayerState(p, PLAYER_STATE_RESOURCE_FOOD_USED) - peon_count)*2 + GetPlayerHeroStrengthMod(p) ) * GetPlayerStrengthHandicap(p))

  local group g = CreateGroup()
  local unit u = null
  local real sum = 0

  call GroupEnumUnitsOfPlayer(g, p, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitType(u, UNIT_TYPE_HERO) and not IsUnitType(u, UNIT_TYPE_PEON) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and UnitAlive(u) and not IsUnitHidden(u) then
      //call Trace("A Unit strength added: " + Int2Str(R2I(GetUnitStrength(u))))
      set sum = sum + GetUnitStrength(u)
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  //call Trace("A HERO strength added: " + Int2Str(GetPlayerHeroStrengthMod(p)))
  return sum + I2R(GetPlayerHeroStrengthMod(p))


endfunction

//============================================================================
function GetUnexactPlayerStrength takes player p returns integer
  local integer pid = GetPlayerId(p)
  if p_str_cache_timeout[pid] < ai_time then
    if difficulty == HARD then
      set p_str_cache[pid] = Max(0,R2I(GetPlayerStrength(p)))
    else
      set p_str_cache[pid] = Max(0, R2I(GetPlayerStrength(p) * GetRandomReal(1 - I2R(uncertainty) / 50, 1 + I2R(uncertainty) / 50)) + GetRandomDiff(uncertainty / 5))
    endif
    set p_str_cache_timeout[pid] = ai_time + p_str_cache_valid_time
  endif
  return p_str_cache[pid]
endfunction

//============================================================================
function GetMaximumEnemyStrength takes nothing returns integer
  local integer i = 0
  local integer max = 0
  local player p = null
  loop
    exitwhen i >= c_enemy_total
    set p = enemy_force[i]
    if GetPlayerSlotState(p) == PLAYER_SLOT_STATE_PLAYING then
      set max = Max(max, R2I(GetPlayerStrength(p)))
    endif
    set i = i + 1
  endloop
  set p = null
  return max
endfunction

//==========================================================================
// (AMAI) Get Player Strength in certain areas
//==========================================================================
#INCLUDETABLE <$VER$\Strengths.txt>
function GetPlayer%1Strength takes player p returns real
  local real strength = 0
  #DEFINE $STRENGTHNUM$ %row
  #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND %#OEVAL{16+$STRENGTHNUM$} != 0
  set strength = strength + %#OEVAL{16+$STRENGTHNUM$} * GetPlayerUnitTypeCount(p, o%1 )
  #ENDINCLUDE
  #DEFINE $CSTRENGTH$ %1
  #INCLUDETABLE <$VER$\StrengthPredictionRules.txt> #EFR #COND '%1' eq '$CSTRENGTH$'
  if ai_time >= %2 and ai_time <= %3 and %4 then
    set strength = strength + %5
  endif
  #ENDINCLUDE
  return strength
endfunction
#ENDINCLUDE

//============================================================================
function GetPlayerAntiAirStrength takes player p returns real
  local group g = CreateGroup()
  local unit u = null
  local real sum = 0

  call GroupEnumUnitsOfPlayer(g, p, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsUnitType(u, UNIT_TYPE_ATTACKS_FLYING) and not IsUnitType(u, UNIT_TYPE_PEON) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and UnitAlive(u) and not IsUnitHidden(u) then
      set sum = sum + GetUnitStrength(u)
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  return sum
endfunction

//============================================================================
function IsCreepsAwake takes real x, real y, real radius returns boolean
  local group g = CreateGroup()
  local unit u = null
  local boolean awake_creeps = false

  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null or awake_creeps
    if GetOwningPlayer(u) == Player(PLAYER_NEUTRAL_AGGRESSIVE) and UnitAlive(u) and not IsUnitHidden(u) then
      set awake_creeps = not IsUnitType(u, UNIT_TYPE_SLEEPING)
    endif
    call GroupRemoveUnit(g,u)
  endloop

  call DestroyGroup(g)
  set g = null
  set u = null
  return awake_creeps
endfunction

//============================================================================
function GetLocationCreepStrength takes real x, real y, real radius returns integer
  local group g = CreateGroup()
  local real sum = 0
  local real strength = 0
  local unit u = null
  local real airsum = 0
  set no_sleep = false
  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetOwningPlayer(u) == Player(PLAYER_NEUTRAL_AGGRESSIVE) and UnitAlive(u) and not IsUnitHidden(u) then
      //call Trace("Getting unit strength begin")
      set strength = GetUnitStrength(u)
      set sum = sum + strength
      if IsUnitType(u, UNIT_TYPE_FLYING) then
        set airsum = airsum + strength
      endif
      if not UnitCanSleep(u) then
        set no_sleep = true
      endif
      //call Trace("Getting unit strength end")
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  set air_strength = R2I(airsum + 0.5)
  return R2I(sum + 0.5)
endfunction

//============================================================================
function GetLocationCreepAirStrength takes real x, real y, real radius returns integer
  local group g = CreateGroup()
  local unit u = null
  local real airsum = 0
  set no_sleep = false
  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetOwningPlayer(u) == Player(PLAYER_NEUTRAL_AGGRESSIVE) and UnitAlive(u) and not IsUnitHidden(u) then
      if IsUnitType(u, UNIT_TYPE_FLYING) then
        set airsum = airsum + GetUnitStrength(u)
      endif
      if not UnitCanSleep(u) then
        set no_sleep = true
      endif
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  return R2I(airsum + 0.5)
endfunction

//============================================================================
function GetLocationNonCreepStrength takes real x, real y, real radius returns integer
  local group g = CreateGroup()
  local real sum = 0
  local real strength = 0
  local unit u = null
  local real airsum = 0
  local player p = null
  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set p = GetOwningPlayer(u)
    if IsPlayerEnemy(ai_player, p) and p != Player(PLAYER_NEUTRAL_AGGRESSIVE) and not IsUnitType(u,UNIT_TYPE_STRUCTURE) and not IsUnitType(u,UNIT_TYPE_PEON) and UnitAlive(u) and not IsUnitHidden(u) then
      set strength = GetUnitStrength(u)
      set sum = sum + strength
      if IsUnitType(u, UNIT_TYPE_FLYING) then
        set airsum = airsum + strength
      endif
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  set p = null
  set air_strength = R2I(airsum + 0.5)
  return R2I(sum + 0.5)
endfunction

//============================================================================
function GetLocationEnemyStrength takes real x, real y, real radius, boolean only_structures returns real
  local group g = CreateGroup()
  local real sum = 0
  local unit u = null
  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsPlayerEnemy(ai_player, GetOwningPlayer(u)) and ((only_structures and IsUnitType(u, UNIT_TYPE_STRUCTURE)) or (not only_structures and not IsUnitType(u, UNIT_TYPE_PEON))) and GetUnitState(u, UNIT_STATE_LIFE) > 0 and not IsUnitHidden(u) and not IsUnitInvisibleAM(u, ai_player) then
      if IsUnitType(u, UNIT_TYPE_STRUCTURE) then
        set sum = sum + 1
      else
        set sum = sum + GetUnitStrength(u)
      endif
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  return sum
endfunction

//============================================================================
function GetLocationTowerStrength takes real x, real y, real radius returns real
  local group g = CreateGroup()
  local unit u = null
  local real sum = 0
  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if IsPlayerEnemy(ai_player, GetOwningPlayer(u)) and IsUnitTower(u) and UnitAlive(u) and not IsUnitHidden(u) then
      set sum = sum + GetTowerStrength(u)
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  return sum
endfunction

//============================================================================
function GetLocationStrength takes real x, real y, real radius returns real
  local group g = CreateGroup()
  local real sum = 0
  local real strength = 0
  local unit u = null
  local real airsum = 0
  call GroupEnumUnitsInRange(g,x,y,radius,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitType(u,UNIT_TYPE_PEON) and UnitAlive(u) and not IsUnitHidden(u) and not IsUnitInvisibleAM(u, ai_player) then
      set strength = GetUnitStrength(u)
      set sum = sum + strength
      if IsUnitType(u, UNIT_TYPE_FLYING) then
        set airsum = airsum + strength
      endif
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  set air_strength = R2I(airsum + 0.5)
  return sum
endfunction

//============================================================================
// Adds the global setting bonuses to the creep camp depending on if its green, orange or red
function GetCreepBonus takes unit u, real radius returns integer
  local integer i = GetLocationCreepStrength(GetUnitX(u), GetUnitY(u), radius)
  //call Trace("Got bonus")
  if i >= 20 then // lvl 20 or more
    return i + red_creep_camp_strength_bonus
  elseif i >= 10 then // lvl 10 - 19
    return i + orange_creep_camp_strength_bonus
  else
    return i + green_creep_camp_strength_bonus
  endif
endfunction

//============================================================================
function GetExpansionStrength takes nothing returns integer
  //call Trace("Getting expansion strength")
  return GetCreepBonus(current_expansion, expansion_radius)
endfunction

//============================================================================
function GetCreepCampStrength takes unit u returns integer
  return GetCreepBonus(u, creep_camp_radius)
endfunction

//============================================================================
function GetOwnStrength takes nothing returns integer
  local real sum = 0
  local group g = CreateGroup()
  local unit u = null
  local integer max_ghouls = TownCountDone(racial_ghoul) - harvesting_ghouls
  local integer ghoul_num = 0
  local real airsum = 0
  local real strength = 0
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitType(u, UNIT_TYPE_PEON) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and not IsUnitType(u, UNIT_TYPE_HERO) and UnitAlive(u) and not IsUnitHidden(u) and not IsUnitInGroup(u, unit_healing) then
      set strength = GetUnitStrength(u)
      if GetUnitTypeId(u) == old_id[racial_ghoul] then
        if ghoul_num < max_ghouls then
          set sum = sum + strength
          set ghoul_num = ghoul_num + 1
        endif
      else
        set sum = sum + strength
      endif
      if IsUnitType(u, UNIT_TYPE_ATTACKS_FLYING) then
        set airsum = airsum + strength
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  // if ancient_expanding and (ancient_exp_state == 2 or ancient_exp_state == 3) and ancient_exp_unit != null and UnitAlive(ancient_exp_unit) then
  //   set sum = sum + 7
  // endif
  call DestroyGroup(g)
  set g = null
  set air_strength = R2I(airsum + 0.5)
  return R2I(sum) + GetPlayerHeroStrengthMod(ai_player)
endfunction

//============================================================================
// (AMAI) Time Priority Queue (Controls Job Timings)
//============================================================================

//============================================================================
function TQDisplay takes nothing returns nothing
  local integer i = 1
  call DisplayToAll("Displaying heap")
  loop
    exitwhen i > tq_length
    call DisplayToAll(Int2Str(R2I(tq_time[i])) + " " + Int2Str(tq_jid[i]))
    set i = i + 1
  endloop
endfunction

//============================================================================
function TQCopy takes integer spos, integer tpos returns nothing
  set tq_time[tpos] = tq_time[spos]
  set tq_jid[tpos] = tq_jid[spos]
  set tq_par[tpos] = tq_par[spos]
  set tq_unit_par[tpos] = tq_unit_par[spos]
  set tq_group_par[tpos] = tq_group_par[spos]
  set tq_unit_par2[tpos] = tq_unit_par2[spos]
endfunction

//============================================================================
function TQExchange takes integer pos1, integer pos2 returns nothing
  call TQCopy(pos2, tq_length+1)
  call TQCopy(pos1, pos2)
  call TQCopy(tq_length+1, pos1)
endfunction

//============================================================================
function TQUpHeap takes integer pos, integer runnum returns nothing
  if tq_time[pos] < tq_time[pos / 2] then
    call TQExchange(pos, pos / 2)
    if (ModuloInteger(runnum, 200) == 0) then
      call Sleep(0.1)
    endif
    call TQUpHeap(pos / 2, runnum + 1)
  endif
endfunction

//============================================================================
function TQFillPos takes integer pos returns integer
  local integer lpos = 2*pos
  local integer rpos = 2*pos + 1
  if lpos > tq_length then
    return pos
  elseif rpos > tq_length then
    call TQCopy(lpos, pos)
    return lpos
  elseif tq_time[lpos] <= tq_time[rpos] then
    call TQCopy(lpos, pos)
    return TQFillPos(lpos)
  else
    call TQCopy(rpos, pos)
    return TQFillPos(rpos)
  endif
endfunction

//============================================================================
function TQRemoveRoot takes nothing returns nothing
  local integer pos = 0
  call GetTQLock()
  set pos = TQFillPos(1)
  set tq_length = tq_length - 1
  if pos <= tq_length then
    call TQCopy(tq_length + 1, pos)
    call TQUpHeap(pos, 1)
  endif
  call ReleaseTQLock()
endfunction

//============================================================================
function TQAddJobEx takes real time, integer jid, integer par, unit unit_par, group group_par, unit unit_par_2 returns nothing
  if tq_length >= JASS_MAX_ARRAY_SIZE then
    if unit_par != null then
      call CreateDebugTag("RECYCLE Full", 10, unit_par, 3.00, 1.50)
      call RecycleGuardPosition(unit_par)
      call GroupRemoveUnit(unit_healing, unit_par)
      call GroupRemoveUnit(unit_rescueing, unit_par)
      call GroupRemoveUnit(unit_harassing, unit_par)
      call GroupRemoveUnit(unit_zepplin_move, unit_par)
    endif
    if unit_par_2 != null then
      call CreateDebugTag("RECYCLE Full", 10, unit_par_2, 3.00, 1.50)
      call RecycleGuardPosition(unit_par_2)
      call GroupRemoveUnit(unit_healing, unit_par_2)
      call GroupRemoveUnit(unit_rescueing, unit_par_2)
      call GroupRemoveUnit(unit_harassing, unit_par_2)
      call GroupRemoveUnit(unit_zepplin_move, unit_par_2)
    endif
    if group_par != null then
      call GroupRecycleGuardPositionInstant(group_par)
    endif
    // Do nothing too many jobs already
    return
  endif
  call GetTQLock()
  set tq_length = tq_length + 1
  //call SaveReal(tq_hashtable, time, tq_length, time)
  //call SaveInteger(tq_hashtable, jid, tq_length, jid)
  //call SaveInteger(tq_hashtable, par, tq_length, par)
  //call SaveUnitHandle(tq_hashtable, unit_par, tq_length, unit_par)
  //call SaveGroupHandle(tq_hashtable, group_par, tq_length, group_par)
  set tq_time[tq_length] = time
  set tq_jid[tq_length] = jid
  set tq_par[tq_length] = par
  set tq_unit_par[tq_length] = unit_par
  set tq_group_par[tq_length] = group_par
  set tq_unit_par2[tq_length] = unit_par_2
  call TQUpHeap(tq_length, 1)
  call ReleaseTQLock()
endfunction

//============================================================================
function TQAddJob takes real time, integer jid, integer par returns nothing
  call TQAddJobEx(TimerGetElapsed(tq_timer) + time, jid, par, null, null, null)
endfunction

//============================================================================
function TQAddUnitJob takes real time, integer jid, integer par, unit unit_par returns nothing
  if unit_par != null then
    call TQAddJobEx(TimerGetElapsed(tq_timer) + time, jid, par, unit_par, null, null)
  endif
endfunction

function TQAddUnit2Job takes real time, integer jid, integer par, unit unit_par, unit unit_par2 returns nothing
  call TQAddJobEx(TimerGetElapsed(tq_timer) + time, jid, par, unit_par, null, unit_par2)
endfunction

//============================================================================
function TQAddGroupJob takes real time, integer jid, integer par, unit unit_par, group group_par returns nothing
  call TQAddJobEx(TimerGetElapsed(tq_timer) + time, jid, par, unit_par, group_par, null)
endfunction

//==============================================================
// (AMAI) Scanning functions
//==============================================================

//  OLD SCANNING FUNCTIONS REMOVED

//==============================================================
// (AMAI) Pathing functions
//==============================================================

// OLD PATHING FUNCTIONS REMOVED

//============================================================================
function GetLocationInDistanceFromLoc takes location loc, real dist, boolean injob returns location
  local real distance = 0
  local real x = 0
  local real y = 0
  local unit u = null
  //local real checktime = 0
  local boolean exitloop = false
  if loc == null then
    return null
  endif
  set u = CreatePathingUnitFull(u,Player(PLAYER_NEUTRAL_PASSIVE), groundid, GetLocationX(loc),GetLocationY(loc))
  call IssuePointOrder(u, "move", GetLocationX(home_location), GetLocationY(home_location))
  //set checktime = GetTimeToReachLoc(u, home_location)
  loop
    exitwhen (exitloop == true)
    set x = GetUnitX(u)
    set y = GetUnitY(u)
    set distance = DistanceBetweenPoints_dk(Location(x,y), loc)
    if distance >= dist then
      //call DisplayToAll("loc found")
      call RemoveUnit(u)
      set u = null
      return Location(x,y)
    elseif GetUnitState(u, UNIT_STATE_LIFE) <= 0 or GetUnitCurrentOrder(u) == OrderId("stop") or GetUnitCurrentOrder(u) != OrderId("move") then
      set exitloop = true
      //return null
    endif
    if injob then
      call Sleep(0.2)
    else
      call Sleep(0.2)
    endif
  endloop
  call RemoveUnit(u)
  set u = null
  return null
endfunction


//============================================================================
function GetLocationInDistanceFromBaseToLoc takes location loc, real d returns location
  local real distance = 0
  local real x = 0
  local real y = 0
  local unit u = null
  //local real checktime = 0

// call DisplayToAll("Checking")
// call PingMinimap(GetLocationX(start_loc), GetLocationY(start_loc), 20)
  set u = CreatePathingUnit(u)
  call IssuePointOrderLoc(u, "move", loc)
  //set checktime = GetTimeToReachLoc(u, loc)
  loop
    set x = GetUnitX(u)
    set y = GetUnitY(u)
    set distance = DistanceBetweenPoints_dk(Location(x,y), home_location)
    if distance >= d then
//        call DisplayToAll("loc found")
//        call PingMinimap(GetLocationX(l), GetLocationY(l), 20)
      call RemoveUnit(u)
      set u = null
      return Location(x,y)
    elseif GetUnitState(u, UNIT_STATE_LIFE) <= 0 or GetUnitCurrentOrder(u) == OrderId("stop") or GetUnitCurrentOrder(u) != OrderId("move") then
      call RemoveUnit(u)
      set u = null
//        call DisplayToAll("loc not found")
      return null
    endif
    call Sleep(0.2)
  endloop
  call RemoveUnit(u)
  set u = null
  return null
endfunction

//============================================================================
function GetBuildLocationInDistanceFromLoc_d takes integer id, location loc, real distance, boolean injob returns location
  local location buildloc = GetLocationInDistanceFromLoc(loc, distance, injob)
  local unit u = null
  local real x = 0
  local real y = 0

  call RemoveLocation(loc)
  if buildloc != null then
    set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), id, GetLocationX(buildloc), GetLocationY(buildloc), 270.0)
    call RemoveLocation(buildloc)
    set buildloc = null
    set x = GetUnitX(u)
    set y = GetUnitY(u)
    call RemoveUnit(u)
    set u = null
    return Location(x,y)
  endif
  return null
endfunction

//============================================================================
// Gets the best location to build a lumber mill building
//============================================================================
function GetLumberLocationAtBase takes nothing returns location
  local integer ground_id = old_id[racial_peon]
  local real x = 0
  local real y = 0
  local unit u = null
  if race_has_ghouls then
    set ground_id = old_id[racial_ghoul]
  endif
  set u = CreatePathingUnitFull(u, Player(PLAYER_NEUTRAL_PASSIVE), ground_id, GetLocationX(home_location), GetLocationY(home_location))
  call IssueImmediateOrder(u, "autoharvestlumber")
  call Sleep(2.00)
  if GetUnitCurrentOrder(u) == 0 then  // home near no tree , move unit to random coordinates
    call IssuePointOrder(u, "move", GetLocationX(home_location) + GetRandomInt(1000,1200)*ISign(), GetLocationY(home_location) + GetRandomInt(1000,1200)*ISign())
    call Sleep(2.00)
    call IssueImmediateOrder(u, "autoharvestlumber")
    call Sleep(1.00)
  endif
  if GetUnitCurrentOrder(u) == 0 then  // home no tree , fix build
    call RemoveUnit(u)
    set u = CreatePathingUnitFull(u, Player(PLAYER_NEUTRAL_PASSIVE), old_id[racial_lumber], GetLocationX(home_location) + GetRandomInt(700,1200)*ISign(), GetLocationY(home_location) + GetRandomInt(700,1200)*ISign())
  else
    call Sleep(4.00)
  endif
  set x = GetUnitX(u)
  set y = GetUnitY(u)
  call RemoveUnit(u)
  set u = null
  return Location(x,y)
endfunction

function BuildLumberMillAtBase takes nothing returns boolean
  local location buildloc = GetLumberLocationAtBase()
  local unit u = null
  local unit peon = GetExpansionPeon()
  local boolean b = false
  if buildloc != null then
    if peon == null then
      set peon = GetExpansionPeon2(peon)
    endif
    set u = CreateUnitAtLoc(Player(PLAYER_NEUTRAL_PASSIVE), old_id[racial_lumber], buildloc, 270.0)
    call RemoveLocation(buildloc)
    set buildloc = GetUnitLoc(u)
    call RemoveUnit(u)
    set u = null
    call IssuePointOrderByIdLoc(peon, old_id[racial_lumber], buildloc)
    call CreateDebugTag("Build Lumber", 10, peon, 4.00, 2.00)
    set b = true
    call RemoveLocation(buildloc)
    set buildloc = null
  endif
  set peon = null
  return b
endfunction

//============================================================================
// Gets the best location to build a RushCreep building , if use GetCreepCamp , then location cannot control
//============================================================================
function BuildBRAtCreep takes nothing returns boolean
  local integer i = 0
  local integer s = 0
  local integer r = 0
  local real distance = 3200
  local group g = CreateGroup()
  local unit u = null
  local unit array ua
  local unit array ub
  local unit array uc
  local location loc = null
  local boolean success = false
  call Trace("Build Ancient Barracks for creeping")
  call GroupEnumUnitsInRange(g,GetLocationX(home_location), GetLocationY(home_location),distance,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null or i >= 7  //7 shoul have 2 creepcamp
    if GetOwningPlayer(u) == Player(PLAYER_NEUTRAL_AGGRESSIVE) and not IsUnitType(u, UNIT_TYPE_FLYING) and UnitAlive(u) and GetUnitLevel(u) < 5 and GetCreepCampStrength(u) < 10 then
      set ua[i] = CreatePathingUnit(ua[i])
      call IssuePointOrder(ua[i], "move", GetUnitX(u), GetUnitY(u))
      set ub[i] = CreatePathingUnitFull(ub[i],ai_player,groundid,GetUnitX(u), GetUnitY(u))
      call IssueTargetOrder(ub[i], "smart", ua[i])  //go in opposite directions , save time
      set uc[i] = u
      set i = i + 1
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  set u = null
  if i == 0 then
    return false
  endif
  set r = i
  loop
    if i >= r then
      set i = 0
    endif
    exitwhen loc != null or s >= r
    if (DistanceBetweenUnits(ua[i], ub[i]) < 200 or DistanceBetweenUnits(ua[i], uc[i]) < 600) and GetUnitState(uc[i], UNIT_STATE_LIFE) > 0 then
      set loc = GetUnitLoc(uc[i])
      set rushcreep_target = uc[i]
    elseif GetUnitState(ua[i], UNIT_STATE_LIFE) <= 0 or GetUnitCurrentOrder(ua[i]) == OrderId("stop") or GetUnitCurrentOrder(ua[i]) != OrderId("move") or DistanceBetweenPoints_kd(home_location,GetUnitLoc(ua[i])) > 3200 then
      set s = s + 1
    elseif GetUnitState(ub[i], UNIT_STATE_LIFE) <= 0 or DistanceBetweenPoints_kd(home_location,GetUnitLoc(ub[i])) > 3200 then
      set s = s + 1
    elseif GetUnitState(uc[i], UNIT_STATE_LIFE) <= 0 then
      set s = s + 1
    endif
    set i = i + 1
    call Sleep(0.05)
  endloop
  set i = 0
  loop
    exitwhen i >= r
    call RemoveUnit(ua[i])
    set ua[i] = null
    call RemoveUnit(ub[i])
    set ub[i] = null
    set uc[i] = null
    set i = i + 1
  endloop
  if s >= r then  // fail , not found creep
    call RemoveLocation(loc)
    set loc = null
    return false
  endif
  set loc = GetBuildLocationInDistanceFromLoc_d(old_id[racial_rushcreep], loc, 600, false)
  if loc != null and DistanceBetweenPoints(loc, home_location) < distance and GetLocationEnemyStrength(GetLocationX(loc), GetLocationY(loc), 510, false) <= 0 then  //Prevent some islands/shallow water terrain from creating u on the other side of the map or have enemy
    set u = GetExpansionPeon2(u)
    if (u == null or GetUnitCurrentOrder(u) != OrderId("harvest")) and own_town_mine[0] != null then
      set g = CreateGroup()
      call GroupEnumUnitsOfPlayer(g, ai_player, null)
      set g = SelectUnittype(g, UNIT_TYPE_PEON, true)
      set g = SelectByLoaded(g, true)
      set u = FirstOfGroup(g)
      call DestroyGroup(g)
      set g = null
      if u == null then
        call RemoveLocation(loc)
        set loc = null
        return false
      endif
      call IssueTargetOrder(own_town_mine[0], "unload", u)
      call Sleep(0.01)
    endif
    call RemoveGuardPosition(u)
    call IssuePointOrderByIdLoc(u, old_id[racial_rushcreep], loc)
    call TQAddUnitJob(16, RESET_GUARD_POSITION, 20, u)
    set success = true
    set u = null
  endif
  call RemoveLocation(loc)
  set loc = null
  return success
endfunction

//home_location have multiple mine
function MultipleMinefix takes nothing returns boolean
  local integer c = 0
  local integer gold = 0
  local real i = 0
  local real distance = 2000
  local location l = null
  local group g = null
  local unit u = null
  local boolean b = false
  if town_threatened or not hero_built[1] or (not race_manual_loading and not race_uses_mine_expansion and ((not_taken_expansion != null and DistanceBetweenPoints_kd(home_location,GetUnitLoc(not_taken_expansion)) < expansion_taken_radius and GetResourceAmount(not_taken_expansion) > 200) or (fixmine != null and GetResourceAmount(fixmine) > 200))) or (race_manual_loading and GetUnitCount(old_id[race_manual_loading_mine]) > 1) or (race_uses_mine_expansion and TownCount(racial_expansion) > 1) then
    return b  //no first hero priority build army , human and orc just harvest
  endif
  call Trace("Check Multiple Mine")
  set g = CreateGroup()
  call GroupEnumUnitsInRangeOfLoc(g, home_location, expansion_taken_radius, null)
  set g = SelectById(g, old_id[GOLD_MINE], true)
  set g = SelectByHidden(g, false)
  set g = SelectByAlive(g, true)
  if FirstOfGroup(g) == null then
    call DestroyGroup(g)
    set g = null
    set not_taken_expansion = null
    if not race_manual_loading then
      set first_town_mine = -1  //home_location no mine , if not ELF , need end HARVEST CHECK job , return to normal
    else
      set first_town_mine = 0
    endif
    call Trace("Multiple Mine fix done , no mine")
    return b
  endif
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetResourceAmount(u) > 0 then
      set i = DistanceBetweenPoints_kd(home_location,GetUnitLoc(u))
      if i <= distance then
        set distance = i
        if fixmine == null or GetResourceAmount(fixmine) == 0 then
          set fixmine = u
        endif
      endif
      set gold = GetResourceAmount(u) + gold
      set c = c + 1
    endif
    call GroupRemoveUnit(g, u)
  endloop
  if fixmine != null and not_taken_expansion != fixmine and first_town_mine > 1 then
    set not_taken_expansion = fixmine  // prevent build too much TOWNHALL , olny first_town_mine > 1 mode need set
  endif
  if race_manual_loading then
    if fixmine != null then
      if GetUnitCount(old_id[race_manual_loading_mine]) < TownCount(racial_expansion) then
        if ancient_exp_unit == null or not UnitAlive(ancient_exp_unit) then
          call GroupEnumUnitsInRangeOfLoc(g, home_location, expansion_taken_radius, null)
          set g = SelectUnittype(g, UNIT_TYPE_TOWNHALL,true)
          set g = SelectByHidden(g, false)
          set g = SelectByAlive(g, true)
          set ancient_exp_unit = FirstOfGroup(g)
        endif
        if ancient_exp_unit != null and (GetUnitCurrentOrder(ancient_exp_unit) != OrderId("entangle") or GetRandomInt(0,3) == 1) then  // random prevent tree stop
          call IssueTargetOrder(ancient_exp_unit, "entangle", fixmine)  // first entangle , not build , this API only return false , cannot set b
          call CreateDebugTag("Multiple Mine fix - entangle", 10, ancient_exp_unit, 10.00, 8.00)
          set b = true
        endif
      elseif TownCount(racial_expansion) < 2 and c > 1 and gold > 3 * GetUnitGoldCost(old_id[racial_expansion]) then  //  build one tree
        set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), old_id[racial_expansion], GetUnitX(fixmine), GetUnitY(fixmine), 270.0)
        set l = GetUnitLoc(u)
        call RemoveUnit(u)
        set u = null
        if expansion_peon == null or not UnitAlive(expansion_peon) then
          set expansion_peon = GetExpansionPeon()
        endif
        if expansion_peon != null and UnitAlive(expansion_peon) and DistanceBetweenPoints_kd(l, GetUnitLoc(fixmine)) <= race_max_expa_mine_distance and GetGold() > GetUnitGoldCost(old_id[racial_expansion]) and GetWood() > GetUnitWoodCost(old_id[racial_expansion]) then
          call IssuePointOrderByIdLoc(expansion_peon, old_id[racial_expansion], l)  // this API only return false , cannot set b
          call CreateDebugTag("Multiple Mine fix - expansion", 10, expansion_peon, 10.00, 8.00)
          set b = true
        endif
        call RemoveLocation(l)
        set l = null
      endif
    endif
  elseif race_uses_mine_expansion then
    if fixmine != null and (TownCount(racial_expansion) < 2 or (GetGold() > 1200 and TownCount(racial_expansion) < 3)) and Min(GetResourceAmount(fixmine) * 2, GetGold()) > GetUnitGoldCost(old_id[racial_expansion]) and GetWood() > GetUnitWoodCost(old_id[racial_expansion]) then
      if expansion_peon == null or not UnitAlive(expansion_peon) then
        set expansion_peon = GetExpansionPeon()
      endif
      if expansion_peon != null and UnitAlive(expansion_peon) then
        call IssueTargetOrderById(expansion_peon, old_id[racial_expansion], fixmine)  // this API only return false , cannot set b
        call CreateDebugTag("Multiple Mine fix - expansion", 10, expansion_peon, 10.00, 8.00)
        set b = true
      endif
    endif
  else
    set b = c < 2
  endif
  call DestroyGroup(g)
  set g = null
  return b
endfunction

function IsUnitGoldMine takes unit u returns boolean
  local integer i = 0
  local integer id = GetUnitTypeId(u)
  loop
    exitwhen i >= gold_mine_ids_size
    if id == gold_mines_ids[i] then
      return true
    endif
    set i = i + 1
  endloop
  return false
endfunction

function IsValidMineClaimed takes unit u returns boolean
  local integer id = GetUnitTypeId(u)
  return GetOwningPlayer(u) != Player(PLAYER_NEUTRAL_PASSIVE) and (not race_manual_loading or id != old_id[race_manual_loading_mine]) and (not race_uses_mine_expansion or not IsUnitIdType(id, UNIT_TYPE_TOWNHALL))
endfunction

//============================================================================
function CheckExpansionTaken takes unit expa returns boolean
  local group g = null
  local unit u = null
  local player p = null
  local integer claimedMines = 0
  local integer minecount = 0
  local integer ownedmines = 0
  local integer id = 0
  local boolean mineclaimed = true
  if expa == null or (first_town_mine > 1 and DistanceBetweenPoints_dk(GetUnitLoc(expa), home_location) < expansion_taken_radius) then
    return false
  endif
  set g = CreateGroup()
  call GroupEnumUnitsInRange(g, GetUnitX(expa), GetUnitY(expa), expansion_taken_radius, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    // Enemy holds the area
    set p = GetOwningPlayer(u)
    if p != Player(PLAYER_NEUTRAL_AGGRESSIVE) and IsUnitType(u, UNIT_TYPE_STRUCTURE) and GetUnitState(u, UNIT_STATE_LIFE) > 0 then  // Creeps dosn't mean expansion is taken
      if IsPlayerEnemy(p, ai_player) then
        call DestroyGroup(g)
        set g = null
        set u = null
        set p = null
        return true
      endif
      if u == expa then
        set mineclaimed = false // Mine not been captured by elf or undead
      endif
      if IsUnitGoldMine(u) then // This is just informative doesnt affect check
        if GetOwningPlayer(u) == Player(PLAYER_NEUTRAL_PASSIVE) then
          set minecount = minecount + 1
        else
          set ownedmines = ownedmines + 1
        endif
      endif
      // A single town hall of humans and orcs can capture close enough mines
      // For now elf will also claim the mines, due to elf mine has to wait for tree of ages to be built so don't want allies to grab mine before its complete.
      set id = GetUnitTypeId(u)
      if IsUnitType(u,UNIT_TYPE_TOWNHALL) and id != old_id[NECROPOLIS_1] and id != old_id[NECROPOLIS_2] and id != old_id[NECROPOLIS_3] and DistanceBetweenUnits(u, expa) < race_max_expa_mine_distance then
        set claimedMines = claimedMines + 1
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
  set p = null
  call CreateDebugTagLoc("Mines:" + Int2Str(minecount) +" Taken:" + Int2Str(claimedMines) + " Own:" + Int2Str(ownedmines), 10, GetUnitX(expa), GetUnitY(expa), 10.00, 1.80)
  return claimedMines >= 1 or mineclaimed// While there may be extra mines, we focusing on is this mine taken
endfunction

// Prevent some map creeps too far away
function CheckCreepsByRadius takes group g , unit u , real n returns group
  call GroupClear(g)
  call GroupEnumUnitsInRange(g, GetUnitX(u), GetUnitY(u), n, null)
  set g = SelectByPlayer(g, Player(PLAYER_NEUTRAL_AGGRESSIVE), true)
  set g = SelectByAlive(g, true)
  return g
endfunction

//  Gets the groups of creeps guarding the specified mine (or other structure)
function GetExpFoeGroup takes group g , unit mine returns group
  set g = CheckCreepsByRadius(g, mine, expansion_radius)
  return g
endfunction

function GetCreepGuardGroup takes integer nn returns nothing
  local integer i = 0
  local unit u = null
  local group g = null
  if nearest_neutral[nn] != null then
    set g = CreateGroup()
    set g = CheckCreepsByRadius(g, nearest_neutral[nn], 750)
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      set i = i + 1
      call SaveUnitHandle(com, NEUTRAL_GUARDS, i, u)
      call GroupRemoveUnit(g, u)
    endloop
    call SaveInteger(com, NEUTRAL_GUARDS, 0, i) // Store size in first element
    call DestroyGroup(g)
    set g = null
  endif
endfunction

//==============================================================
function AddExpansion takes unit u, real d returns nothing
  local group g = CreateGroup()
  set expansion_list[expansion_list_length] = u
  set expansion_dist[expansion_list_length] = d
  set g = GetExpFoeGroup(g,u)  // group of the the creeps that guard this mine
  call AddUnitsToHashtable(expansion_creeps, expansion_list_length, 0, g)
  call DestroyGroup(g)
  set g = null
  if first_expansion_chosen == false then
    set first_expansion_chosen = d > front_base_distance and not CheckExpansionTaken(u)
  endif
  if d > 6000 then
    call GroupAddUnit(far_expansion, u)
  endif
  set expansion_list_length = expansion_list_length + 1
endfunction

//==============================================================
function AddWaterExpansion takes unit u, real d returns nothing
  local group g = CreateGroup()
  set water_expansion_list[water_expansion_list_length] = u
  set water_expansion_dist[water_expansion_list_length] = d
  call GroupAddUnit(water_expansion, u)
  set g = GetExpFoeGroup(g,u)  // group of the the creeps that guard this mine
  call AddUnitsToHashtable(water_expansion_creeps, water_expansion_list_length, 0, g)
  call DestroyGroup(g)
  set g = null
  set water_expansion_list_length = water_expansion_list_length + 1
endfunction

//==============================================================
function GetExpNearestMin takes unit ru returns unit
// Return the nearest mine, uses old system so computer has a mine as new system can take a while to calculate

local real distance = 0
local real seconddistance = 0
local unit u = null
local real mindistance = 10000  // max distance away the first mine can be
local real secMaxDistance = 6000  // max distance range second mine must be in
local unit nearmine = null
local unit secondmine = null
local group g = CreateGroup()
local integer rand = GetRandomInt(1,4)
call GroupEnumUnitsOfType(g, "goldmine", null)
loop
  set u = FirstOfGroup(g)
  exitwhen u == null
  if not CheckExpansionTaken(u) and GetLocationCreepStrength(GetUnitX(u), GetUnitY(u), expansion_radius) < 40 then
    set distance = DistanceBetweenPoints_dk(GetUnitLoc(u), home_location)
    if distance < mindistance then
      if mindistance < secMaxDistance then
        set secondmine = nearmine
        set seconddistance = mindistance
      endif
      set mindistance = distance
      set nearmine = u
    elseif distance < seconddistance and distance <= secMaxDistance then
      set seconddistance = distance
      set secondmine = u
    endif
  endif
  call GroupRemoveUnit(g, u)
endloop
call DestroyGroup(g)
set g = null

if secondmine != null then
	if rand <= 3 then
		set secondmine = null
		set ru = nearmine
		set nearmine = null
		return ru
	else
		set nearmine = null
		set ru = secondmine
		set secondmine = null
		return ru
	endif
else
	set secondmine = null
	set ru = nearmine
	set nearmine = null
	return ru
endif
endfunction

//==============================================================
function MakeExpansionList takes nothing returns nothing
  local group g = CreateGroup()
  local unit u = null
  local unit array pather
  local integer array traveltime
  local boolean array patherdone
  local integer i = 0
  local group tempg = null
  local integer array checks // Number of times unit has stayed at same position
  local boolean pathingdone = true
  local real totaltime = 0
  local real array lx
  local real array ly

  call GroupEnumUnitsOfType(g, "goldmine", null)
//  call GroupRemoveUnit(g, current_expansion) // because quick expansion adds mine already

  call Trace("Find Expansions Create Units")
  set tempg = CopyGroup(g,tempg)
  loop
    set u = FirstOfGroup(tempg)
    exitwhen u == null
    set pather[i] = CreatePathingUnit(pather[i])
    set checks[i] = 0
    call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
    call GroupRemoveUnit(tempg, u)
    if (ModuloInteger(i,10) == 0) then
      call Sleep(GetRandomReal(0.2, 0.4) * sleep_multiplier) // help spread start lag
    endif
    set i = i + 1
  endloop
  call DestroyGroup(tempg)
  call Trace("Find Expansions Path Units Created:" + Int2Str(i))
  loop
    set totaltime = totaltime + 3 * (sleep_multiplier)
    set pathingdone = true
    set tempg = CopyGroup(g,tempg)
    set i = 0
    loop
      set u = FirstOfGroup(tempg)
      exitwhen u == null
      if pather[i] != null then
        if DistanceBetweenUnits(pather[i],u) <= buy_distance then
          //call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Tavern is pathable")
          call CreateDebugTag("Target Destination is pathable", 10, pather[i], 5.00, 3.00)
          call RemoveUnit(pather[i])
          set pather[i] = null
          set patherdone[i] = true
          call AddExpansion(u, totaltime * 512)
        //elseif GetUnitCurrentOrder(u) == OrderId("stop") then
          //return (totaltime * -1)
        elseif GetUnitState(pather[i], UNIT_STATE_LIFE) <= 0 then
          call RemoveUnit(pather[i])
          set pather[i] = null
          set patherdone[i] = true
        elseif GetUnitCurrentOrder(pather[i]) == OrderId("stop") or GetUnitCurrentOrder(pather[i]) != OrderId("move") then
          set checks[i] = checks[i] + 1
          call CreateDebugTag("Invisible Path unit has stopped", 10, pather[i], 5.00, 3.00)
          if checks[i] > 3 then
            call CreateDebugTag("Target Destination was not reached", 10, pather[i], 5.00, 3.00)
            call RemoveUnit(pather[i])
            set pather[i] = null
            set patherdone[i] = true
            call AddWaterExpansion(u, DistanceBetweenPoints_kd(home_location, GetUnitLoc(u)))
          else
            call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u)) // Try again?
          endif
        else
          //call CreateDebugTag("Invisible Path Unit Here", 10, pather[i], 5.00, 3.00)
          if (lx[i] != 0 and ly[i] != 0) then
            if GetUnitX(pather[i]) == lx[i] and GetUnitY(pather[i]) == ly[i] then
              // Actually stuck
              call IssuePointOrder(pather[i], "move", GetUnitX(u), GetUnitY(u))
            endif
          endif
          set lx[i] = GetUnitX(pather[i])
          set ly[i] = GetUnitY(pather[i])
        endif
        set pathingdone = false
      endif
      call GroupRemoveUnit(tempg, u)
      set i = i + 1
    endloop
    call DestroyGroup(tempg)
    exitwhen pathingdone
    call Sleep(1 * sleep_multiplier)
  endloop
  call DestroyGroup(g)
  set g = null
  set tempg = null
  call Trace("Expansion number: " + Int2Str(expansion_list_length))

//  loop
//    set u = FirstOfGroup(g)
//    exitwhen u == null
//    set l = GetUnitLoc(u)
//    set timeaway = CanPathToLoc(start_loc, l, PATHING_TYPE_WALKABILITY)
//    if timeaway > 0 then
//      call AddExpansion(u, timeaway)
//    else
//  This requires use of transports to work
//  NYI
//      call AddWaterExpansion(u)
//    endif
//    call GroupRemoveUnit(g, u)
//    call RemoveLocation(l)
//    set l = null
//  endloop

endfunction

//============================================================================
// (AMAI) ChooseExpansion
//============================================================================
function make_exp_rp_positive takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= exp_number
    if exp_rp[i] < 0 then
      set exp_rp[i] = 0
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function sum_exp_rp takes nothing returns integer
  local integer i = 0
  local integer sum = 0
  loop
    exitwhen i >= exp_number
    set sum = sum + exp_rp[i]
    set i = i + 1
  endloop
//  call DisplayToAll("Sum is " + Int2Str(sum))
//  call DisplayToAll("exp_number is " + Int2Str(exp_number))
  return sum
endfunction

//============================================================================
function ChooseExp takes nothing returns integer
// This function returns a mine to expand to.

  local integer i = 1
  local integer sum = 0
  local integer exp_roll = GetRandomInt(1,100)
  local integer first = 0
  local integer second = 0
  local integer third = 0
  local integer riskyexp = GetRandomInt(1, exp_number - 1)
  loop
    exitwhen i >= exp_number
    if exp_rp[i] < exp_rp[first] then
      set third = second
      set second = first
      set first = i
    else
      if exp_rp[i] < exp_rp[second] then
        set third = second
        set second = i
      else
        if exp_rp[i] < exp_rp[third] then
          set third = i
        endif
      endif
    endif
    set i = i + 1
  endloop
  if (exp_roll <= 80) then
    return first  // The closest expansion choice
  elseif (exp_roll <= 100) then
    return second // The second closest expansion choice
  else
    return riskyexp  // Complete Random choice (effectively disabled at the moment)
  endif
  return 0
endfunction

//============================================================================
function remove_exp takes integer h returns nothing
  local integer i = h
  set exp_number = exp_number - 1
  loop
    exitwhen i >= exp_number
    set exp_rp[i] = exp_rp[i + 1]
    set exp_unit[i] = exp_unit[i + 1]
    set exp_dist[i] = exp_dist[i + 1]
    set i = i + 1
  endloop
endfunction

//============================================================================
function add_exp takes unit u, real dist, location ancient, integer creeps, boolean iswater returns nothing
  set exp_unit[exp_number] = u
  set exp_dist[exp_number] = dist
  set exp_ancient[exp_number] = ancient
  set exp_creeps[exp_number] = creeps
  set exp_iswater[exp_number] = iswater
  set exp_number = exp_number + 1
endfunction

//============================================================================
function GetNearestEnemyDistance takes nothing returns real
local integer i = 0
local real dist = 0
local real mindistance = 1000000
local real humandistance = 1000000
local player nearplayer = null
local player nearhumanplayer = null
local group g = CreateGroup()
local unit u = null
local unit tempu = null
local unit temphumanu = null
//loop
//    exitwhen i >= c_enemy_total
//    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
//    set loc = GetPlayerStartLocationLoc(enemy_force[i])
//		set dist = DistanceBetweenPoints_kd(home_location, loc)
//    call RemoveLocation(loc)
//    set loc = null
//		if dist < mindistance then
//			set mindistance = dist
//			set nearplayer = p
//		endif
//    endif
//    set i = i + 1
//endloop

loop
	exitwhen i >= c_enemy_total
	if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
		call GroupEnumUnitsOfPlayer(g, enemy_force[i], null)
		set g = SelectUnittype(g, UNIT_TYPE_TOWNHALL, true)
		set g = SelectByAlive(g, true)
		set g = SelectByHidden(g, false)
		if FirstOfGroup(g) == null and GetPlayerRace(enemy_force[i]) == RACE_UNDEAD then
			call GroupClear(g)
			call GroupEnumUnitsOfPlayer(g, enemy_force[i], null)
			set g = SelectById(g, 'ugol', true)  //some human UD player donot build TOWNHALL
			set g = SelectByAlive(g, true)
			set g = SelectByHidden(g, false)
		endif
		loop
			set u = FirstOfGroup(g)
			exitwhen u == null
			set dist = DistanceBetweenPoints_kd(home_location, GetUnitLoc(u))  //GetNearestEnemy base from all base, no longer GetPlayerStartLocationLoc
			if dist < mindistance then
				set mindistance = dist
				set nearplayer = enemy_force[i]
				set tempu = u
			endif
			if GetPlayerController(enemy_force[i]) != MAP_CONTROL_COMPUTER and dist < humandistance then
				set humandistance = dist
				set nearhumanplayer = enemy_force[i]
				set temphumanu = u
			endif
			call GroupRemoveUnit(g, u)
		endloop
		call GroupClear(g)
	endif
	set i = i + 1
endloop
if temphumanu != null then  //Prioritize TR human players
	set builder[10] = temphumanu
	set rushedplayer = nearhumanplayer
	set mindistance = humandistance
elseif tempu != null then
	set builder[10] = tempu
	set rushedplayer = nearplayer
endif
call DestroyGroup(g)
set g = null
set nearplayer = null
set nearhumanplayer = null
set tempu = null
set temphumanu = null
return mindistance
endfunction

//============================================================================
function MinRangeToEnemy takes location l returns real
  local integer i = 0
  local real d = 0
  local real min_d = 1000000

  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set d = DistanceBetweenPoints_kd(l, GetPlayerStartLocationLoc(enemy_force[i]))
      if d < min_d then
        set min_d = d
      endif
    endif
    set i = i + 1
  endloop
  return min_d
endfunction

//============================================================================
//function WayMinRangeToEnemy takes location l returns real
//  local integer i = GetReachableNearby(GetGridField_k(l), 5)
//  local integer h = home_field
//  local real m = 10000000
//  loop
//    set m = r_minimum(MinRangeToEnemy_d(GetFieldLoc(i)), m)
//    exitwhen i == h
//    set i = path_from[i]
//    exitwhen i == h
//    set i = path_from[i]
//    exitwhen i == h
//    set i = path_from[i]
//  endloop
//  return m
//endfunction
// THESE FUNCTIONS ARE AWAITING require rework to use new pathing method
//============================================================================

//============================================================================
function GetRushFactor takes nothing returns integer
  return R2I(MinRangeToEnemy(home_location)) + (1000*(GetPlayers() - (c_enemy_total + c_ally_total + 1)))
endfunction

//============================================================================
// Returns true if we need to rebuild an expansion and no enemies are around
function CheckExpansionRebuild takes nothing returns boolean
  local group g = CreateGroup()
  local unit u = null
  call GroupEnumUnitsInRange(g, GetUnitX(current_expansion), GetUnitY(current_expansion), expansion_taken_radius, null)
  set g = SelectUnittype(g, UNIT_TYPE_STRUCTURE, true)
  //set g = SelectByPlayer(g, Player(PLAYER_NEUTRAL_PASSIVE), false)  // no need the Select
  set g = SelectByPlayer(g, ai_player, true)
  set g = SelectByAlive(g, true)

  if FirstOfGroup(g) != null then
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      if GetUnitTypeId(u) == old_id[racial_expansion] then
        call DestroyGroup(g)
        set g = null
        set u = null
        return false
      endif
      call GroupRemoveUnit(g, u)
    endloop
    if GetResourceAmount(current_expansion) > 2 * GetUnitGoldCost2(racial_expansion) and GetLocationNonCreepStrength(GetUnitX(current_expansion),GetUnitY(current_expansion),expansion_taken_radius) <= 0 then
      call DestroyGroup(g)
      set g = null
      return true
    endif
  endif
  call DestroyGroup(g)
  set g = null
  return false

endfunction

//============================================================================
function ExpansionFormula takes integer exp_d, unit exp_u returns integer
// Lower Result back is better
  local group g = CreateGroup()
  local unit u = null
// AMAI EDITORS NOTE:- May move into the actual choose_exp function to always rebuild damaged expansion
// -----------------------------------------------------------------------------------------------------

  call GroupEnumUnitsInRange(g, GetUnitX(exp_u), GetUnitY(exp_u), expansion_taken_radius, null)
  //set g = SelectUnittype(g, UNIT_TYPE_STRUCTURE, true)

  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetOwningPlayer(u) == ai_player and (IsUnitType(u, UNIT_TYPE_STRUCTURE) or IsUnitType(u, UNIT_TYPE_PEON)) and UnitAlive(u) and not IsUnitHidden(u) then
      call DestroyGroup(g)
      set g = null
      set u = null
      return R2I(exp_d*0.5)      // Increased likelyhood to build if was once owned by player
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
// -----------------------------------------------------------------------------------------------------

  //return exp_d + R2I(I2R(GetLocationCreepStrength(GetUnitX(exp_u), GetUnitY(exp_u), expansion_radius)) / 2)
  return exp_d

endfunction

//============================================================================
function add_exp_rp takes nothing returns nothing
  local integer i = 0
  local real way_dist = 0.0
  local integer max = 0
  local integer min = 1000000
  local real sv = 0.7
  local integer red = 0
  loop
    exitwhen i >= exp_number
//    set way_dist = WayMinRangeToEnemy_d(GetUnitLoc(exp_unit[i]))
    set exp_rp[i] = ExpansionFormula(R2I(exp_dist[i]), exp_unit[i])
    if exp_rp[i] > max then
      set max = exp_rp[i]
    endif
    if exp_rp[i] < min then
      set min = exp_rp[i]
    endif
//    if way_dist < 1500 then
//      set exp_rp[i] = Max(exp_rp[i] - 30, 1)
//    endif
    set i = i + 1
  endloop
//  if min < 1000000 and max > 0 then
//    set red = Max(R2I(((0.3) * max - min) / sv), -min)
//    if red < 0 then
//      set i = 0
//      loop
//        exitwhen i >= exp_number
//        set exp_rp[i] = Max(exp_rp[i] + red, 1)
//        set i = i + 1
//      endloop
//    endif
//  endif
endfunction

//============================================================================
function IsRacialHall takes unit u, integer min_tier returns boolean
  local integer i = Max(min_tier, 1)
  local integer id = GetUnitTypeId(u)
  loop
    exitwhen i > tiernum
    if id == old_id[racial_hall[i]] then
      return true
    endif
    set i = i + 1
  endloop
  return false
endfunction

//============================================================================
function IsRacialHallId takes integer id, integer min_tier returns boolean
  local integer i = Max(min_tier, 1)
  loop
    exitwhen i > tiernum
    if id == racial_hall[i] then
      return true
    endif
    set i = i + 1
  endloop
  return false
endfunction

//============================================================================
function GetRacialBuildHallLV takes integer id returns integer
  local integer i = 1
  if id > 0 then
    loop
      exitwhen i > tiernum
      if racial_hall[i] != 0 and (needed1[id] == racial_hall[i] or needed2[id] == racial_hall[i] or needed3[id] == racial_hall[i]) then
        return i
      endif
      set i = i + 1
    endloop
  endif
  return 1  // hall 1 , base BARRACKS , tower , farm , altar , shop , expansion , lumber , goldmine , UPGRADED
endfunction

//============================================================================
function ChooseExpansion takes nothing returns nothing
  local integer i = 0
  local integer exp_chosen = 0
  local integer gold = 2 * GetUnitGoldCost2(racial_expansion)
  set exp_number = 0
  loop
    exitwhen i >= expansion_list_length
    if GetResourceAmount(expansion_list[i]) > gold and expansion_list[i] != not_taken_expansion and not CheckExpansionTaken(expansion_list[i]) and DistanceBetweenPoints_kd(home_location,GetUnitLoc(expansion_list[i])) > expansion_taken_radius then
      call add_exp(expansion_list[i], expansion_dist[i], expansion_ancient[i], i, false)
    endif
    set i = i + 1
  endloop
  if TownCountDone(neutral_zeppelin) > 1 then  //first taken normal mine // Only do water expansions when more than 1 zepplin as can move units more easily
    set i = 0
    loop
      exitwhen i >= water_expansion_list_length
      if GetResourceAmount(water_expansion_list[i]) > gold and expansion_list[i] != not_taken_expansion and not CheckExpansionTaken(water_expansion_list[i]) then
        call add_exp(water_expansion_list[i], water_expansion_dist[i] + 5120, null, i, true)
      endif
      set i = i + 1
    endloop
  endif
  call add_exp_rp()
//  call make_exp_rp_positive()
  if exp_number == 0 then
    set current_expansion = null
    call Trace("No valid expansions")
  else
    set exp_chosen = ChooseExp()
    set current_expansion = exp_unit[exp_chosen]
    //set ancient_exp_loc = exp_ancient[exp_chosen]
    set current_expansion_creeps = exp_creeps[exp_chosen]
    set current_expansion_iswater = exp_iswater[exp_chosen]
//    call PingMinimap(GetUnitX(current_expansion), GetUnitY(current_expansion), 20)
  endif
endfunction

//============================================================================
function GetExpFoe takes unit nearunit returns unit
  local location l = null
  local group g = CreateGroup()
  local real nearest = 10000000
  local real tempnear = 0
  local integer i = 0
  local integer c = 0
  local unit u = null
  if current_expansion_iswater then
    set g = ReturnLivingUnitsOfHashtable(water_expansion_creeps, current_expansion_creeps, 0, g)
  else
    set g = ReturnLivingUnitsOfHashtable(expansion_creeps, current_expansion_creeps, 0, g)
  endif
  if BlzGroupGetSize(g) <= 0 then
    //call Trace("GetExpFoe: No creeps in current expansion")
    call DestroyGroup(g)
    set g = null
    return null
  endif
  set nearunit = null
  set l = GetUnitLoc(current_expansion)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set tempnear = DistanceBetweenPoints_dk(GetUnitLoc(u), l)
    set c = c + 1
    if tempnear < nearest then
      set nearunit = u
      set nearest = tempnear
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call RemoveLocation(l)
  set l = null
  call DestroyGroup(g)
  set g = null
  //if nearunit != null then
    //call Trace("GetExpFoe: Have a foe")
  //endif
  return nearunit
endfunction

function GetNeutralGuard takes integer nn returns nothing
  local location l = null
  local unit u = null
  local unit nearunit = null
  local boolean b = false
  //local integer i = 0
  local real nearest = 10000000
  local real tempnear = 0
  local boolean can_sleep = true
  local group g = null
  if nearest_neutral[nn] == null then  //or LoadInteger(com, NEUTRAL_GUARDS, 0) == 0 then
    set neutral_guarded[nn] = false
    set neutral_night_buy[nn] = true
    return
  endif
  set l = GetUnitLoc(nearest_neutral[nn])
  set g = CreateGroup()
  set g = CheckCreepsByRadius(g, nearest_neutral[nn], 750)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set tempnear = DistanceBetweenPoints_dk(GetUnitLoc(u), l)
    if not UnitCanSleep(u) then
      set can_sleep = false
    endif
    if tempnear < nearest then
      set nearunit = u
      set nearest = tempnear
    endif
    call GroupRemoveUnit(g, u)
  endloop
  //loop
  //  exitwhen i > LoadInteger(com, NEUTRAL_GUARDS, 0)
  //  set i = i + 1
  //  set u = LoadUnitHandle(com, NEUTRAL_GUARDS, i)
  //  if u != null and UnitAlive(u) then
  //    set tempnear = DistanceBetweenPoints_dk(GetUnitLoc(u), l)
  //    if not UnitCanSleep(u) then
  //      set can_sleep = false
  //    endif
  //    if tempnear < nearest then
  //      set nearunit = u
  //      set nearest = tempnear
  //    endif
  //  endif
  //endloop
  call RemoveLocation(l)
  set l = null
  call DestroyGroup(g)
  set g = null
  set neutral_guarded[nn] = (nearunit != null)
  set neutral_night_buy[nn] = can_sleep
  set u = null
  set nearunit = null
endfunction

//============================================================================
function SetAIArray takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= GetBJMaxPlayers()
    if GetPlayerSlotState(Player(i)) == PLAYER_SLOT_STATE_PLAYING and GetPlayerController(Player(i)) == MAP_CONTROL_COMPUTER and LoadBoolean(com, IS_AMAI, i) then
      set ai_force[ai_force_length] = i
      set ai_force_length = ai_force_length + 1
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function CheckFastExpansion takes nothing returns nothing
  local integer es = 0
  local real timeaway = 0

  if current_expansion != null then
    set es = GetExpansionStrength()
    if GetRandomInt(1,2) == 1 and ((GetPlayers() > 2 and MinRangeToEnemy(home_location) > 7000 and es <= 0) or exp_number >= (c_enemy_total + c_ally_total + 1)*2 or race_militia_expansion_available) then
      set exp_time_count = -exp_first_time
    endif
  endif
endfunction

//============================================================================
function AddFrontPoint takes location l returns nothing
  local real x = GetLocationX(l)
  local real y = GetLocationY(l)
  local unit pathable = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), groundid, x, y, 270.00)
  if DistanceBetweenPoints_dd(GetUnitLoc(pathable), l) <= 200 then
    call CreateDebugTagLoc("Front Point Added", 10, x, y, 60.00, 55.00)
    set front_loc[front_loc_num] = Location(x,y)
    set front_loc_num = front_loc_num + 1
  //else
    //call CreateDebugTagLoc("Front Point : Not Buildable", 10, x, y, 60.00, 55.00)
  endif
  call RemoveUnit(pathable)
  set pathable = null
endfunction

//============================================================================
function ComputeFrontPoints takes nothing returns nothing
  local integer i = 0
  local integer n = 0
  local player p = null
  local unit array u
  local boolean array enemyplayers
  //local player mainplayer = Player(GetAiPlayer())
  local boolean pathingdone = true
  local boolean array patherdone
  local location l = null
  local real distance = 0
  local location array backuplocs
  local boolean frontnotfound = false
  loop
    exitwhen i >= GetBJMaxPlayers()
    set p = Player(i)
    set patherdone[i] = false
    set enemyplayers[i] = false
    set backuplocs[i] = null
    if p != ai_player then
      set l = GetPlayerStartLocationLoc(p)
      if l != null then
        set u[n] = CreatePathingUnit(u[n])
        set enemyplayers[n] = IsPlayerEnemy(ai_player, p)
        call IssuePointOrder(u[n], "move", GetLocationX(l), GetLocationY(l))
        call RemoveLocation(l)
        set n = n + 1
      endif
    endif
    set i = i + 1
  endloop

  loop
    set pathingdone = true
    set i = 0
    loop
      exitwhen i >= n
      if patherdone[i] == false then
        if u[i] != null then
          set l = GetUnitLoc(u[i])
          set distance = DistanceBetweenPoints(l, home_location)
          if distance >= front_base_distance then
            call CreateDebugTag("Front Point Found", 10, u[i], 10.00, 8.00)
            call RemoveUnit(u[i])
            set u[i] = null
            set patherdone[i] = true
            if enemyplayers[i] then
              set front_loc[front_loc_num] = Location(GetLocationX(l), GetLocationY(l))
              set front_loc_num = front_loc_num + 1
              call AddFrontPoint(AIGetProjectedLoc(l, home_location, 100, 90))
              call AddFrontPoint(AIGetProjectedLoc(l, home_location, 100, -90))
              call AddFrontPoint(AIGetProjectedLoc(l, home_location, 200, 80))
              call AddFrontPoint(AIGetProjectedLoc(l, home_location, 200, -80))
            else
              set backuplocs[i] = Location(GetLocationX(l), GetLocationY(l))
            endif
          elseif GetUnitState(u[i], UNIT_STATE_LIFE) <= 0 or GetUnitCurrentOrder(u[i]) == OrderId("stop") or GetUnitCurrentOrder(u[i]) != OrderId("move") then
            set patherdone[i] = true
            call RemoveUnit(u[i])
            set u[i] = null
          endif
          call RemoveLocation(l)
          set pathingdone = false
        endif
      endif
      set i = i + 1
    endloop
    exitwhen pathingdone
    call Sleep(0.1)
  endloop
  set i = 0
  set frontnotfound = (front_loc_num == 0)
  loop
    exitwhen i >= n
    if backuplocs[i] != null then
      if frontnotfound then
        set front_loc[front_loc_num] = Location(GetLocationX(backuplocs[i]), GetLocationY(backuplocs[i]))
        set front_loc_num = front_loc_num + 1
        call AddFrontPoint(AIGetProjectedLoc(backuplocs[i], home_location, 100, 90))
        call AddFrontPoint(AIGetProjectedLoc(backuplocs[i], home_location, 100, -90))
        call AddFrontPoint(AIGetProjectedLoc(backuplocs[i], home_location, 200, 80))
        call AddFrontPoint(AIGetProjectedLoc(backuplocs[i], home_location, 200, -80))
      endif
      call RemoveLocation(backuplocs[i])
      set backuplocs[i] = null
    endif
    set i = i + 1
  endloop
  if front_loc_num == 0 then
    call Trace("WARN: No front locations at all")
    set front_locs_computed = false
  elseif front_loc[0] == null then
    call Trace("ERROR: Unexpected Front Location")
    if front_loc_num > 0 then
      set front_loc[0] = front_loc[front_loc_num - 1]
    endif
    set front_locs_computed = false
  else
    set front_locs_computed = true
  endif
  set l = null
  set p = null
  //set mainplayer = null
endfunction

//============================================================================
function PingFrontPoints takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= front_loc_num
    if front_loc[i] != null then
      call PingMinimap(GetLocationX(front_loc[i]), GetLocationY(front_loc[i]), 20)
    endif
    set i = i + 1
  endloop
endfunction

//==========================================================================
// (AMAI) Resource utility functions
//==========================================================================
function GetPlayerGold takes player p returns integer
    return GetPlayerState(p,PLAYER_STATE_RESOURCE_GOLD)
endfunction

function GetPlayerWood takes player p returns integer
    return GetPlayerState(p,PLAYER_STATE_RESOURCE_LUMBER)
endfunction

//============================================================================
// (AMAI) set_aggression
//============================================================================
function set_aggression takes nothing returns nothing
  local integer f = FoodUsed()
  if false then
#INCLUDETABLE <$VER$\AddedAggression.txt> #EFR
  elseif f >= %1 then
    set added_aggression = %2
#ENDINCLUDE
  else
    set added_aggression = 0
  endif

  if GetUnitCountDone(old_id[hero[1]]) == 0 then
    set added_aggression = added_aggression - 10
  endif
endfunction

//============================================================================
// (AMAI) expansion_distance
//============================================================================
function GetExpansionDistance takes nothing returns real
  return DistanceBetweenPoints_kd(home_location,GetUnitLoc(current_expansion))
endfunction

//============================================================================
// (AMAI) Items
//============================================================================
function GetItemNumberOnUnit takes integer id, unit u returns integer
  local integer i = 0
  local integer sum = 0
  local integer t = old_id[id]
  loop
    exitwhen i > 5
    if GetItemTypeId(UnitItemInSlot(u, i)) == t then
      set sum = sum + 1
    endif
    set i = i + 1
  endloop
  return sum
endfunction

function GetItemEquivalence takes integer id, unit u returns integer
  local integer qty = 0
  #INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "TC_ITEM"
  if id == %1 then
    set qty = qty + GetItemNumberOnUnit(%3, u)
  endif
  if id == %3 then
    set qty = qty + GetItemNumberOnUnit(%1, u)
  endif
  #ENDINCLUDE
  return qty
endfunction

//============================================================================
function GetItemNumber takes integer id returns integer
  local integer sum = 0
  local integer i = 1
  loop
    exitwhen i > 3
    if hero_built[i] then
      set sum = sum + GetItemNumberOnUnit(id, hero_unit[i]) + GetItemEquivalence(id, hero_unit[i])
    endif
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
function GetItemOfTypeOnUnit takes integer id, unit u returns item
  local integer i = 0
  local integer t = old_id[id]
  loop
    exitwhen i > 5
    if GetItemTypeId(UnitItemInSlot(u, i)) == t then
      return UnitItemInSlot(u, i)
    endif
    set i = i + 1
  endloop
  return null
endfunction

//============================================================================
function GetItemOfType takes item t, integer id returns item
  local integer i = 1
  loop
    exitwhen i > 3
    if hero_built[i] then
      set t = GetItemOfTypeOnUnit(id, hero_unit[i])
      if t != null then
        return t
      endif
    endif
    set i = i + 1
  endloop
  return null
endfunction

//============================================================================
function GetSlotsFreeOnUnit takes unit u returns integer
  local integer i = 0
  local integer sum = 0
  loop
    exitwhen i > 5
    if UnitItemInSlot(u, i) == null then
      set sum = sum + 1
    endif
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
function GetSlotsFree takes nothing returns integer
  local integer sum = 0
  local integer i = 1
  loop
    exitwhen i > 3
    if hero_built[i] then
      set sum = sum + GetSlotsFreeOnUnit(hero_unit[i])
    endif
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
function GetHeroToBuyItem takes unit shop, real limit, boolean is_healing_included, integer itemid, boolean itemstacking, boolean moreshop returns unit
  local integer i = 1
  local integer r = 0
  local real d = 0
  local real dmin = 0
  loop
    exitwhen i > 3
    if hero_built[i] and UnitAlive(hero_unit[i]) then
      set d = DistanceBetweenUnits(hero_unit[i], shop)
      if GetSlotsFreeOnUnit(hero_unit[i]) > 0 and (moreshop or d < limit) and not IsUnitInGroup(hero_unit[i], unit_buying_tavern) and not IsUnitInGroup(hero_unit[i], unit_buying_merc) and not IsUnitInGroup(hero_unit[i], unit_harassing) then
        if (is_healing_included == true and IsUnitInGroup(hero_unit[i], unit_healing)) or (itemstacking == false and GetItemOfTypeOnUnit(itemid, hero_unit[i]) != null) then
        else
          if moreshop then
            return hero_unit[i]  // more own shop , take first hero , wait find close shop
          elseif dmin < d then
            set dmin = d
            set r = i
          endif
        endif
      endif
    endif
    set i = i + 1
  endloop
  if r > 0 then
    return hero_unit[r]  // one shop or not own shop , take close hero
  endif
  return null
endfunction

//============================================================================
function GetItemHero takes item it returns unit
  local integer i = 1
  if it != null then
    loop
      exitwhen i > 3
      if hero_built[i] and UnitAlive(hero_unit[i]) then
        if UnitHasItem(hero_unit[i], it) then
          return hero_unit[i]
        endif
      endif
      set i = i + 1
    endloop
  endif
  return null
endfunction

//============================================================================
// function CheckUseSaveItem takes integer i returns boolean
//   set herocanuse[i] = hero_built[i] and UnitAlive(hero_unit[i]) and not UnitInvis(hero_unit[i]) and not IsUnitBuying(hero_unit[i]) and IsStandardUnit(hero_unit[i])
//   return herocanuse[i]
// endfunction

function CheckBlinkAbility takes unit u returns boolean
  if (GetUnitAbilityLevel(u, 'AEbl') == 1 and GetUnitState(u, UNIT_STATE_MANA) > 50) or (GetUnitAbilityLevel(u, 'AEbl') > 1 and GetUnitState(u, UNIT_STATE_MANA) > 10) then
    return true
  elseif GetUnitAbilityLevel(u, 'AIbk') > 0 or GetUnitAbilityLevel(u, 'ANbl') > 0 then
    return true
  endif
  return false
endfunction

//============================================================================
// (AMAI) Save Unit (Attempts to heal or rescue unit from imminent harm)
//============================================================================
function AddHealer takes integer id, integer spell, integer mana_cost,integer t, integer upg_id, integer upg_level returns nothing
  set healer_id[healer_length] = id
  set healer_spell[healer_length] = spell
  set healer_mana_cost[healer_length] = mana_cost
  set healer_type[healer_length] = t
  set healer_upg_id[healer_length] = upg_id
  set healer_upg_level[healer_length] = upg_level
  set healer_length = healer_length + 1
endfunction

//============================================================================
function InitHealers takes nothing returns nothing
#INCLUDETABLE <$VER$\Healers.txt> #EFR #COND "%2" ne "NEUTRAL"
  if own_race == R_%2 then
    call AddHealer(o%1, %4, %5, HEALER_TYPE_%3, o%6, %7)
  endif
#ENDINCLUDE
  if false then
#INCLUDETABLE <$VER$\Healers.txt> #EFR #COND "%2" eq "NEUTRAL"
  elseif merc_healer == %1 then
    call AddHealer(o%1, %4, %5, HEALER_TYPE_%3, o%6, %7)
#ENDINCLUDE
  endif
endfunction

//============================================================================
function GetHealerId takes integer id returns integer
  local integer i = 0
  loop
    exitwhen i >= healer_length
    if healer_id[i] == id then
      return i
    endif
    set i = i + 1
  endloop
  return -1
endfunction

//============================================================================
function IsUnitHealer takes unit u returns boolean
  if GetUnitState(u, UNIT_STATE_MAX_MANA) <= 0 then
    return false
  else
    if GetHealerId(GetUnitTypeId(u)) >= 0 then
      return true
    endif
  endif
  return false
endfunction

//============================================================================
function HealUnit takes unit healer, unit to_heal, boolean hero_heal returns nothing
  local integer id = GetHealerId(GetUnitTypeId(healer))
  if id != -1 and healer_type[id] != HEALER_TYPE_NO_TARGET then
    if healer_type[id] == HEALER_TYPE_WARD then
      if not ward_cast then
        call IssuePointOrderById(healer, healer_spell[id], GetUnitX(healer), GetUnitY(healer))
        call GroupRemoveUnit(unit_healing, healer)
      endif
    else
      if healer_type[id] != HEALER_TYPE_HERO or hero_heal then
        call IssueTargetOrderById(healer, healer_spell[id], to_heal)
        call GroupRemoveUnit(unit_healing, healer)
      endif
    endif
  endif
endfunction

//============================================================================
function GetHealer takes unit u returns unit
  local integer id = 0
  local group rg = null
  set rg = CopyGroup(healer_group, rg)
  loop
    set u = FirstOfGroup(rg)
    exitwhen u == null
    set id = GetHealerId(GetUnitTypeId(u))
    if id != -1 and not IsUnitLoaded(u) and UnitAlive(u) and GetUnitState(u, UNIT_STATE_MANA) >= healer_mana_cost[id] and ((healer_upg_id[id] == 0) or (GetUpgradeLevel(healer_upg_id[id]) >= healer_upg_level[id])) and IsStandardUnit(u) and not IsUnitBuying(u) then
      call DestroyGroup(rg)
      set rg = null
      return u
    endif
    call GroupRemoveUnit(rg, u)
  endloop
  call DestroyGroup(rg)
  set rg = null
  return u
endfunction

//============================================================================
function GetArmyOfUnit takes unit u returns integer
  local integer i = 0
  local player p = GetOwningPlayer(u)
  loop
    exitwhen i >= army_num
    if Player(army_owner[i]) == p and IsUnitInGroup(u, army_group[i]) then
      set p = null
      return i
    endif
    set i = i + 1
  endloop
  set p = null
  return -1
endfunction

//============================================================================
function GroupRecycleGuardPosition takes group g returns nothing
  local unit u = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    call TQAddUnitJob(30, RESET_GUARD_POSITION, 0, u)
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
endfunction

function GroupRecycleGuardPositionDelay takes group g, real delay returns nothing
  local unit u = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    call TQAddUnitJob(delay, RESET_GUARD_POSITION, 0, u)
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
endfunction

//============================================================================
//  Get Specialized items
function GetHealingItem takes nothing returns integer
	if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%3" eq "HEALINGITEM_SINGLE"
	elseif %2 and available_time[%1] <= ai_time then
		return %1
#ENDINCLUDE
	endif
	return 0
endfunction

//============================================================================
function GetMassHealingItem takes nothing returns integer
  if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%3" eq "HEALINGITEM_MASS"
  elseif %2 and available_time[%1] <= ai_time then
    return %1
#ENDINCLUDE
  endif
  return 0
endfunction

//============================================================================
function GetMerchantMassHealingItem takes nothing returns integer
	if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%3" eq "MERCHANTITEM_MASS"
	elseif %2 and available_time[%1] <= ai_time then
		return %1
#ENDINCLUDE
	endif
	return 0
endfunction

//============================================================================
//   Items that do not heal units directly
function GetGlobalHealingItem takes nothing returns integer
	if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%3" eq "GLOBALHEALING"
	elseif %2 and available_time[%1] <= ai_time then
		return %1
#ENDINCLUDE
	endif
	return 0
endfunction

//============================================================================
//   Items that re-gain the heros mana
function GetHeroManaItem takes nothing returns integer
	if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%3" eq "MANAITEM_HERO"
	elseif %2 and available_time[%1] <= ai_time then
		return %1
#ENDINCLUDE
	endif
	return 0
endfunction

//============================================================================
function GetItemHealingTime takes integer id returns integer
  if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%4" eq "CONTINUOUS" or "%4" eq "NO_TARGET"
  elseif %1 == id then
    return %5
#ENDINCLUDE
  endif
  return 0
endfunction

// Is the item an instant healing or a heal over time
function GetItemInstantType takes integer id returns integer
  if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%4" eq "SUDDEN"
  elseif %1 == id then
    return ITEMTYPE_SUDDEN
#ENDINCLUDE
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%4" eq "CONTINUOUS"
  elseif %1 == id then
    return ITEMTYPE_CONTINUOUS
#ENDINCLUDE
  endif
  return 0
endfunction

//    Gets items that the hero can use to heal itself. Otherwise tries the racial items.
function GetHeroHealingItem takes nothing returns integer
	if false then
#INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%3" eq "HEALINGITEM_HERO"
	elseif %2 and available_time[%1] <= ai_time then
		return %1
#ENDINCLUDE
	elseif GetHealingItem() != 0 then
		return GetHealingItem()
	elseif GetGlobalHealingItem() != 0 then
		return GetGlobalHealingItem()
	elseif GetMassHealingItem() != 0 then
		return GetMassHealingItem()
	elseif GetMerchantMassHealingItem() != 0 then
		return GetMerchantMassHealingItem()
	endif
	return 0
endfunction

function GetSleepMultipler takes integer aiCount returns real
  local real i = LinearInterpolation(I2R(slm_start), I2R(slm_end), slm_start_mult, slm_end_mult, I2R(aiCount)) + GetRandomReal(-0.2, 0.2)
  set i = RMax(0.1, i)
  return i
endfunction

//============================================================================
// (AMAI) Jobs Listing (Custom Job Scripts are placed here)
//============================================================================

#INCLUDETABLE <Jobs.txt> #EFR
  #INCLUDESCRIPT <Jobs\%1.eai>
#ENDINCLUDE

//============================================================================
function TQDoJob takes integer jid, integer par, unit unit_par, group group_par, unit unit_par2 returns nothing
  #SEARCHCODE Jobs jid
endfunction

//============================================================================
function TQHandleOnce takes nothing returns boolean
  local integer jid = tq_jid[1]
  local integer par = tq_par[1]
  local unit unit_par = tq_unit_par[1]
  local group group_par = tq_group_par[1]
  local unit unit_par2 = tq_unit_par2[1]
  local real jobtimings = 0
  local boolean b = false
//  call DisplayToAll(Int2Str(R2I(TimerGetElapsed(tq_timer))))
//  call TQDisplay()
  if TimerGetElapsed(tq_timer) >= tq_time[1] then
    set jobtimings = TimerGetElapsed(tq_timer)
    call TQRemoveRoot()
    call UpdateDebugTextTag(debugjobtag, Int2Str(jid), 24, GetLocationX(home_location) + 300, GetLocationY(home_location) + 300)
    call TQDoJob(jid, par, unit_par, group_par, unit_par2)
    if jobtimings - TimerGetElapsed(tq_timer) >= 1 then
      call Trace("WARN: Job " + Int2Str(jid) + " took a long time " + Real2Str(jobtimings - TimerGetElapsed(tq_timer)) + "s")
    endif
    set b = true
  endif
  set unit_par = null
  set group_par = null
  set unit_par2 = null
  return b
endfunction

//============================================================================
function TQInitJobs takes nothing returns nothing
  call TQAddJob(GetRandomReal(20, 35), TIMED_CHAT, C_Greet)
  call TQAddJob(GetRandomReal(40, 60), TIMED_CHAT, C_STRATEGY)
#INCLUDETABLE <Jobs.txt> #EFR #COND '%4' eq 'true'
  call TQAddJob(GetRandomReal(%5, %6), %1, 0)
#ENDINCLUDE

#INCLUDETABLE <Jobs.txt> #EFR #COND '%4' ne 'true' and '%4' ne 'false'
  if %4 then
    call TQAddJob(GetRandomReal(%5, %6), %1, 0)
  endif
#ENDINCLUDE
endfunction

//============================================================================
function TQLoop takes nothing returns nothing
  local real i = 0
  if debugging then
    call SetTextTagPermanent(debugjobtag, true)
  endif
  set tq_time[0] = 0
  call TimerStart(tq_timer, 1000000, false, null)
  //call Trace("Starting Job Loop Thread")
  call TQInitJobs()
  //call Trace("Job Initialisation done")
  loop
    exitwhen player_defeated
    if tq_length > 0 then
      if not TQHandleOnce() then
        set i = tq_time[1] - TimerGetElapsed(tq_timer)
        if i >= 1 then
          call Sleep(1)
        elseif i >= 0.3 then
          call Sleep(i+(0.05*sleep_multiplier))
        else
          call Sleep(RMax(0.05, GetRandomReal(0, 0.3)*sleep_multiplier))
        endif
      else
        call Sleep(RMax(0.05, GetRandomReal(0, 0.3)*sleep_multiplier))
      endif
    else
      call Trace("TQLOOP: No job is ready to fire")
      call Sleep(1)
    endif
  endloop
  if debugging then
    call SetTextTagText(debugjobtag, "Shutting down Job Thread", 0.1)
  endif
  //call Trace("Shutting down Job Thread")
  loop
    if force_number > 1 then
      call ExchangeOnce()
    endif
    call Sleep(30)
  endloop
endfunction

//==========================================================================
// (AMAI)	CheckNeutral
//==========================================================================
function CheckNeutral takes integer nn returns nothing
  if neutral_available[nn] == true then
    set neutral_ordered[nn] = false
    set neutral_sent[nn] = null
    set buy_time_large[nn] = -1
    set buy_time_small[nn] = -1
    if nearest_neutral[nn] == null then
      call Trace("Neutral Pathing ID done (no pathable neutral): " + Int2Str(nn))
      set neutral_available[nn] = false
      return  // SUMMONED or water path
    endif
    call GetCreepGuardGroup(nn)
    call GetNeutralGuard(nn)
    // set neutral_night_buy[nn] = not no_sleep
    call Trace("Neutral Pathing ID done: " + Int2Str(nn))
  endif
endfunction

//==========================================================================
function InitNeutralBuildings takes nothing returns nothing
  local group g = CreateGroup()
  local integer id = 0
  local integer i = 0
  local integer j = 0
  local integer k = 0
  local integer m = 0
  local integer array camp
  local integer array roost
  local integer array merc_types
  local boolean mercfound = false
  local boolean roostfound = false
  local boolean tavernfound = false
  local unit u = null

#INCLUDETABLE <$VER$\NeutralShops.txt> #EFR
  set neutral_id[%1] = '%2'
#ENDINCLUDE

#DEFINE $MERCTYPENUM$ 0
#INCLUDETABLE <$VER$\MercTypes.txt>
  #DEFINE $MERCTYPENUM$ %row
#ENDINCLUDE

#INCLUDETABLE <$VER$\Mercs.txt> #EFR
  set camp[%row] = '%2'
#AFTERINCLUDE
  set j = %row
#ENDINCLUDE

#DEFINE $DRAGONTYPENUM$ 0
#INCLUDETABLE <$VER$\DragonTypes.txt>
  #DEFINE $DRAGONTYPENUM$ %row
#ENDINCLUDE

#INCLUDETABLE <$VER$\Dragons.txt> #EFR
  set roost[%row] = '%2'
#AFTERINCLUDE
  set m = %row
#ENDINCLUDE

  call GroupEnumUnitsOfPlayer(g, Player(PLAYER_NEUTRAL_PASSIVE), null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    set id = GetUnitTypeId(u)
    if id == neutral_id[NEUTRAL_TAVERN] then
      set neutral_available[NEUTRAL_TAVERN] = true
    elseif id == neutral_id[NEUTRAL_MERCHANT] then
      set neutral_available[NEUTRAL_MERCHANT] = true
    elseif id == neutral_id[NEUTRAL_OBSERVATORY] then
      set neutral_available[NEUTRAL_OBSERVATORY] = true
    elseif id == neutral_id[NEUTRAL_HEALING_FOUNTAIN] then
      set neutral_available[NEUTRAL_HEALING_FOUNTAIN] = true
    elseif id == neutral_id[NEUTRAL_MANA_FOUNTAIN] then
      set neutral_available[NEUTRAL_MANA_FOUNTAIN] = true
    elseif id == neutral_id[NEUTRAL_POWER_FOUNTAIN] then
      set neutral_available[NEUTRAL_POWER_FOUNTAIN] = true
    elseif id == neutral_id[NEUTRAL_HEAL_WARD] and not IsUnitType(u, UNIT_TYPE_SUMMONED) then
      set neutral_available[NEUTRAL_HEAL_WARD] = true
    elseif id == neutral_id[NEUTRAL_SHIPYARD] then
      set neutral_available[NEUTRAL_SHIPYARD] = true
    elseif id == neutral_id[NEUTRAL_MARKETPLACE] then
      set neutral_available[NEUTRAL_MARKETPLACE] = true
    else
      if not mercfound then
        set i = 0
        loop
          set i = i + 1
          if id == camp[i] then
            set mercfound = true
          endif
          exitwhen mercfound or i >= j
        endloop
      endif
        if not roostfound then
        set k = 0
        loop
          set k = k + 1
          if id == roost[k] then
            set roostfound = true
          endif
          exitwhen roostfound or k >= m
        endloop
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null

if mercfound then

  if not mercfound then
#INCLUDETABLE <$VER$\Mercs.txt> #EFR
  elseif i == %row then
    set merc_unit[0] = %3
    set merc_unit[1] = %4
    set merc_unit[2] = %5
    set merc_unit[3] = %6
  #FOR $X$ FROM $ONE$ TO $MERCTYPENUM$
    set merc_types[$X$] = %#OEVAL{6+$X$}
  #ENDFOR
#ENDINCLUDE
  endif

#INCLUDETABLE <$VER$\MercTypes.txt>
  set merc_%1 = merc_types[%row]
#ENDINCLUDE
  set j = 0
  loop
    exitwhen j >= 4
    if merc_unit[j] != 0 then
      set merc_number = merc_number + 1
    endif
    set j = j + 1
  endloop
  set neutral_id[NEUTRAL_MERC_CAMP] = camp[i]
  set neutral_available[NEUTRAL_MERC_CAMP] = true
endif

if roostfound then
  if not roostfound then
#INCLUDETABLE <$VER$\Dragons.txt> #EFR
  elseif k == %row then
  #FOR $X$ FROM $ONE$ TO $DRAGONTYPENUM$
    set dragons[$X$] = %#OEVAL{2+$X$}
  #ENDFOR
#AFTERINCLUDE
  endif
  set dragon_number = $DRAGONTYPENUM$
#ENDINCLUDE
  set neutral_id[NEUTRAL_DRAGON_ROOST] = roost[k]
  set neutral_available[NEUTRAL_DRAGON_ROOST] = true
endif

endfunction

//==========================================================================
function CheckAllNeutrals takes nothing returns nothing
  local integer i = 0
  call CalcNearestNeutrals()
  loop
    exitwhen i >= NEUTRAL_COUNT
    call CheckNeutral(i)
    set i = i + 1
  endloop

endfunction

//============================================================================
function CheckNeutralQuick takes integer nn returns nothing
set neutral_ordered[nn] = false
set neutral_sent[nn] = null
set buy_time_large[nn] = -1
set buy_time_small[nn] = -1
if neutral_available[nn] == true then
//	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "checkneutral")
  set nearest_neutral[nn] = GetNearestNeutralQuick(nearest_neutral[nn],neutral_id[nn])
  if nearest_neutral[nn] == null then
    if nn == NEUTRAL_TAVERN and hero[1] != 0 and buy_type[hero[1]] == BT_NEUTRAL_HERO then  //guarantee to train Ownrace hero at the first time
      set recalculate_heros = true
    endif
    return  // let CheckAllNeutrals check
  endif
  call GetCreepGuardGroup(nn)
//	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "finished check")
  call GetNeutralGuard(nn)
  if neutral_guarded[nn] then
    call TQAddJob(30 * sleep_multiplier, NEUTRAL_GUARDED, nn)
    if nn == NEUTRAL_TAVERN and hero[1] != 0 and buy_type[hero[1]] == BT_NEUTRAL_HERO then  //guarantee to train Ownrace hero at the first time
      set recalculate_heros = true
    endif
  endif
endif
endfunction

//============================================================================
function CheckAllNeutralsQuick takes nothing returns nothing
  local integer i = 0

  loop
    exitwhen i >= NEUTRAL_COUNT
    call CheckNeutralQuick(i)
    set i = i + 1
  endloop

  if nearest_neutral[NEUTRAL_HEALING_FOUNTAIN] != null then
    call TQAddJob(10, NEUTRAL_ENEMY_CHECK, NEUTRAL_HEALING_FOUNTAIN)
  endif
  if nearest_neutral[NEUTRAL_MANA_FOUNTAIN] != null then
    call TQAddJob(10, NEUTRAL_ENEMY_CHECK, NEUTRAL_MANA_FOUNTAIN)
  endif
  if nearest_neutral[NEUTRAL_POWER_FOUNTAIN] != null then
    call TQAddJob(10, NEUTRAL_ENEMY_CHECK, NEUTRAL_POWER_FOUNTAIN)
  endif
  if nearest_neutral[NEUTRAL_HEAL_WARD] != null then
    call TQAddJob(10, NEUTRAL_ENEMY_CHECK, NEUTRAL_HEAL_WARD)
  endif
endfunction

//============================================================================
function CopyPJ takes integer t returns nothing
  local integer i = t
  loop
    exitwhen i >= pj_length
    set pj_time[i] = pj_time[i + 1]
    set pj_frequency[i] = pj_frequency[i + 1]
    set pj_jid[i] = pj_jid[i + 1]
    set pj_par[i] = pj_par[i + 1]
    set pj_remove[i] = pj_remove[i + 1]
    set i = i + 1
  endloop
  set pj_length = pj_length - 1
endfunction

function RemovePJ takes integer jid, integer par, integer t returns nothing
  if jid == NEUTRAL_GUARDED and nearest_neutral[par] == null then
    call CopyPJ(t)
  elseif jid == NEUTRAL_ENEMY_CHECK and (nearest_neutral[par] == null or not UnitAlive(nearest_neutral[par])) then
    call CopyPJ(t)
  endif
endfunction

function PathingJobEx takes real frequency, integer jid, integer par, boolean remove returns nothing
  set pj_length = pj_length + 1
  set pj_time[pj_length] = TimerGetElapsed(tq_timer) + frequency
  set pj_frequency[pj_length] = frequency
  set pj_jid[pj_length] = jid
  set pj_par[pj_length] = par
  set pj_remove[pj_length] = remove
  call Sleep(GetRandomReal(0.8, 1.2))
endfunction

function PJInitJobs takes nothing returns nothing
  local integer i = 0
  call PathingJobEx(6, CHAT_VARS, 0, false)                                                       //ChatVarsJob
  call PathingJobEx(15, REPAIR_CONTROL, 0, false)                                                 //RepairControlJob
  if race_has_power_build then
    call PathingJobEx(10, FAST_BUILD, 0, false)                                                   //FastBuild
  endif
  if race_sell_ziggurats then
    call PathingJobEx(30, SELL_ZIGGURATS, 0, false)                                               //SellZigguratJob
  endif
  call PathingJobEx(60, CLEANUP_BLOCKS, 0, false)                                                 //CleanupBlocksJob
  call PathingJobEx(160, ITEM_REPEAT_CHECK, 0, false)                                             //ItemRepeatCheck
  call PathingJobEx(180, STRUCTURE_CONTROL, 0, false)                                             //StructureControlJob
  if c_ally_total + c_enemy_total > 1 then
    call PathingJobEx(1200, REVEAL_ENEMY, 0, false)                                                 //RevealEnemy
  endif
  if nearest_neutral[NEUTRAL_HEALING_FOUNTAIN] != null then
    call PathingJobEx(6 * sleep_multiplier, NEUTRAL_ENEMY_CHECK, NEUTRAL_HEALING_FOUNTAIN, true)  //NeutralEnemyCheckJob
  endif
  if nearest_neutral[NEUTRAL_MANA_FOUNTAIN] != null then
    call PathingJobEx(6 * sleep_multiplier, NEUTRAL_ENEMY_CHECK, NEUTRAL_MANA_FOUNTAIN, true)     //NeutralEnemyCheckJob
  endif
  if nearest_neutral[NEUTRAL_POWER_FOUNTAIN] != null then
    call PathingJobEx(6 * sleep_multiplier, NEUTRAL_ENEMY_CHECK, NEUTRAL_POWER_FOUNTAIN, true)    //NeutralEnemyCheckJob
  endif
  if nearest_neutral[NEUTRAL_HEAL_WARD] != null then
    call PathingJobEx(6 * sleep_multiplier, NEUTRAL_ENEMY_CHECK, NEUTRAL_HEAL_WARD, true)         //NeutralEnemyCheckJob
  endif
  call PathingJobEx(13 * sleep_multiplier, DETECT_DEFEAT, 0, false)                               //DetectDefeatJob
  call PathingJobEx(15 * sleep_multiplier, UPDATE_STRENGTH, 0, false)                             //UpdateStrengthJob
  loop
    exitwhen i >= NEUTRAL_COUNT
    if nearest_neutral[i] != null and UnitAlive(nearest_neutral[i]) and neutral_guarded[i] then
      call PathingJobEx(30 * sleep_multiplier, NEUTRAL_GUARDED, i, true)                          //NeutralGuardedJob
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function PathingThread takes nothing returns nothing
  local integer t = 0
  call StaggerSleep(1,5)
  call SetAIArray()
  //  set command_wait = 0.5
  //  set command_wait = 3
  call ComputeFrontPoints()
  //  call Sleep(3)
  if debugging then
    call PingFrontPoints()
  endif
  call CheckAllNeutralsQuick() // Old system check
  call MakeExpansionList()
  set water_map = water_expansion_list_length >= expansion_list_length
  set first_expansion_chosen = first_expansion_chosen == true or (water_expansion_list_length > 0)  // no expansion but have water expansion , can take expansion
  call CheckAllNeutrals() // The more advanced new system check
  call Trace("pathing thread done and run job" )
  set pathing_done = true
  call PJInitJobs()  // this job no need run on job system , help job system more focused on combat
  call StaggerSleep(1,10)
  loop
    exitwhen player_defeated or pj_length < 1
    if t >= pj_length then
      set t = 0
    endif
    set t = t + 1
    if pj_remove[t] then
      call RemovePJ(pj_jid[t], pj_par[t], t)
    endif
    if TimerGetElapsed(tq_timer) >= pj_time[t] then
      call TQDoJob(pj_jid[t], pj_par[t], null, null, null)
      set pj_time[t] = TimerGetElapsed(tq_timer) + pj_frequency[t]
    endif
    call StaggerSleep(1, 1.8)
  endloop
endfunction

//============================================================================
// (AMAI) Queue utility functions
//============================================================================
function QueueReset takes nothing returns nothing
  set queue_length  = 0
  set queue_pointer	= 0
endfunction

//============================================================================
function QueueRestart takes nothing returns nothing
  set queue_pointer	= 0
endfunction

//============================================================================
function QueueGetNextUnit takes nothing returns unit
  return target_queue_u[queue_pointer]
endfunction

//============================================================================
function QueueGetNextX takes nothing returns integer
  return target_queue_x[queue_pointer]
endfunction

//============================================================================
function QueueGetNextY takes nothing returns integer
  return target_queue_y[queue_pointer]
endfunction

//============================================================================
function QueuePopCommand takes nothing returns nothing
  set queue_pointer = queue_pointer + 1
endfunction

//============================================================================
function QueueFinished takes nothing returns boolean
  return queue_pointer >= queue_length
endfunction

//============================================================================
function QueueGetNextCommand takes nothing returns boolean
  if QueueFinished() then
    set queue_running = false
    call QueueReset()
    return false
  else
    set queue_t_u = QueueGetNextUnit()
    if queue_t_u == null then
      set queue_t_x = QueueGetNextX()
      set queue_t_y = QueueGetNextY()
      set queue_attack_p = true
      set queue_attack_u = false
    else
      set queue_attack_u = true
      set queue_attack_p = false
    endif
    call QueuePopCommand()
    return true
  endif
endfunction

//============================================================================
function QueueSetCommand takes integer x, integer y, unit u returns nothing
  set target_queue_x[queue_length] = x
  set target_queue_y[queue_length] = y
  set target_queue_u[queue_length] = u
  set queue_length = queue_length + 1
endfunction

//============================================================================
function QueueRemoveCommand takes nothing returns nothing
  set queue_length = queue_length - 1
endfunction

//===========================================================================
// (AMAI) Command recieving loop
//===========================================================================
function cmd_cancel takes integer cmd, integer data returns nothing
  if cmd == 0 then		// Cancel all orders
    set break_attack = false
    set go_home = false
    set strategy = chosen_strategy
    set attack_player = false
    set attack_point = false
    set no_attack = false
    set no_creep_attack = false
    set no_player_attack = false
    set queue_running	= false
    call Trace("Cancel All command" )

  elseif cmd == 1 then	// Cancel build orders
    set strategy = chosen_strategy
    call Trace("Cancel Build Command" )

  elseif cmd == 2 then	// Cancel attacking orders
    set attack_player = false
    set attack_point = false
    set no_attack = false
    set no_creep_attack = false
    set no_player_attack = false
    set queue_running = false
    call Trace("Cancel Attack Command" )

  endif
endfunction

//============================================================================
function cmd_attack takes integer cmd, integer data returns nothing
  local group gr = null
  if cmd == 10 then	// Stop the current attack
    set break_attack = true
    set go_home = true
    set queue_running = false
    set attack_player = false
    set attack_point = false
    call Trace("Stop Attack Command" )

  elseif cmd == 11 then	// Start no attacks
    set break_attack = true
    set no_attack = true
    call Trace("No Attacks Command" )
  elseif cmd == 12 then	// Attack specific player
    set break_attack = true
    set go_home = false
    set attack_target_p = data
    set attack_player = true
    set attack_point = false
    call Trace("Attack Player Command" )

  elseif cmd == 13 then	// Attack specific point
    call Trace("Attack Point Command" )
    loop
      exitwhen CommandsWaiting()!=0
      call Sleep(0.5)
    endloop
    set attack_target_x = GetLastCommand()
    set attack_target_y = GetLastData()
    set break_attack = true
    set go_home = false
    set attack_point = true
    set attack_player = false
    call PopLastCommand()
    call Trace("Attack Coordinates received" )

  elseif cmd == 14 then	// No attacks on creeps
    set no_creep_attack = true
    call Trace("Attack No Creeps" )

  elseif cmd == 15 then	// No attack on players
    set no_player_attack = true
    call Trace("Attack No Player" )

  elseif cmd == 16 then	// Attack selected unit
    set gr = CreateGroup()
    call GroupEnumUnitsSelected(gr, Player(data), null)
    set target_unit	= FirstOfGroup(gr)
    call DestroyGroup(gr)
    set gr = null
    if target_unit == null then
      call DisplayToAllies(chat_no_unit_selected)
    endif
    set attack_point = false
    set attack_player = false
    set attack_unit = true
    set break_attack = true
    set go_home = false
    call DisplayToAllies(chat_confirm_attack_unit)

  elseif cmd == 17 then // Towerrush
    if race_towerrush_available then
      if not towerrush then
        call TQAddJob(0, TOWER_RUSH_CHECK, 1)
      else  // rushing
        call DisplayToAllies(chat_towerrush)
        call DisplayToObserversImportant(chat_towerrush)
      endif
      set Console_TR_Commands = true
    else
      call DisplayToAllies(chat_no_towerrush)
      call DisplayToObserversImportant(chat_no_towerrush)
    endif

  endif
endfunction

//============================================================================
function cmd_build takes integer cmd, integer data returns nothing
  if false then
#INCLUDETABLE <$VER$\CommandBuilds.txt> #EFR
  elseif cmd == #EVAL{19+%row} then
    set strategy = #EVAL{49+%row}
    set bn_%1 = data
#ENDINCLUDE
  endif
endfunction

//============================================================================
function cmd_queue takes integer cmd, integer data returns nothing
  local group gr = null
  if cmd == 30 then	// Cancel queue
    call QueueReset()
    set queue_running = false
    call Trace("Cancel Queue Command" )

  elseif cmd == 31 then	// Queue Attack specific point
    call Trace("Queue Attack Point Command" )
    loop
      exitwhen CommandsWaiting()!=0
      call Sleep(0.5)
    endloop
    call QueueSetCommand(GetLastCommand(), GetLastData(), null)
    call PopLastCommand()
    call Trace("Attack Coordinates received" )

  elseif cmd == 32 then	// Queue Attack selected unit
    set gr = CreateGroup()
    call GroupEnumUnitsSelected(gr, Player(data), null)
    if FirstOfGroup(gr) == null then
      call DisplayToAllies(chat_no_unit_selected)
    else
      call QueueSetCommand(0,0, FirstOfGroup(gr))
      call DisplayToAllies(chat_confirm_attack_unit)
    endif
    call DestroyGroup(gr)
    set gr = null

  elseif cmd == 33 then	// Starting or Restarting queue
    call QueueRestart()
    if QueueGetNextCommand() then
      set queue_running = true
      set no_attack = false
      call Trace("Queue started" )
    else
      call Trace("Queue is empty" )
    endif

  elseif cmd == 34 then	// Pausing queue
    set queue_running = false

  elseif cmd == 35 then	// Unpausing queue
    set queue_running = true

  elseif cmd == 36 then	// Removing last command
    call QueueRemoveCommand()

  endif
endfunction

//============================================================================
function cmd_misc takes integer cmd, integer data returns nothing
  if cmd == 50 then	// Triggering chat
    set chatting = not chatting

  elseif cmd == 51 then	// Triggering debug
    set debugging = not debugging

  elseif cmd == 52 then	// Triggering balancing
    set balancing = not balancing

  elseif cmd == 53 then
    set strat_change_allowed = not strat_change_allowed

  elseif cmd == 60 then // Show strat name
    call DisplayToAllies(GetCurrentStrategyReport() + GetCurrentDynamicReport())

  elseif cmd == 61 then // Show all strats
    call DisplayStratNames()

  elseif cmd == 70 then // change strategy
    if data < rp_strat_length then
      set strategy = data
      set chosen_strategy = strategy
    else
      call DisplayToAllies(invalid_strategy_number)
    endif

  elseif cmd == 71 then // change language
    if false then
  #INCLUDETABLE <Languages.txt> #EFR
    elseif data == #EVAL{%row-1} then
      set language = "%1"
  #ENDINCLUDE
    endif
    call InitChatArrays()

  elseif cmd == 72 then // change backlanguage
    if false then
  #INCLUDETABLE <Languages.txt> #EFR
    elseif data == #EVAL{%row-1} then
      set backlanguage = "%1"
  #ENDINCLUDE
    endif

  elseif cmd == 73 then
    set console_on = true

  elseif cmd == 80 then
    set recalculate_heros = true
  endif
endfunction

//============================================================================
function cmd_loop takes nothing returns nothing
  local integer cmd = 0
  local integer data = 0
  call StaggerSleep(0,3)
  call Trace("Starting Commander Thread Loop" )

  loop
    loop
      exitwhen CommandsWaiting() != 0
      exitwhen player_defeated
      call Sleep(command_wait * sleep_multiplier)
    endloop
    exitwhen player_defeated
    set cmd = GetLastCommand()
    set data = GetLastData()
    call PopLastCommand()
    call Trace("Receiving command" )

    if cmd < 10 then
      call cmd_cancel(cmd, data)

    elseif cmd < 20 then
      call cmd_attack(cmd, data)

    elseif cmd < 30 then
      call cmd_build(cmd, data)

    elseif cmd < 40 then
      call cmd_queue(cmd, data)

    else
      call cmd_misc(cmd, data)

    endif

  endloop
//call DisplayToAll("shutting down cmd_loop")

endfunction

//===========================================================================
function InitCheckHarvest takes nothing returns nothing
  local group g = CreateGroup()
  local unit u = null
  local integer i = GOLD_MINE
  local integer c = 0 // gold mine count
  local integer s = 0 // captured gold mine count
  local integer m = 0 // captured by other player
  local integer p = 1 // number of players claimed a mine
  local real check = 0
  local real distance = 10000
  local boolean array b
  local player play = null
  // some map home_location 1500 radius just one mine , but old war3 (maybe 1.24~1.28 , 1.36+ maybe no) UD and ELF still cannot harvest(maybe need 2300 radius no more mine)
  if race_manual_loading then
    set i = race_manual_loading_mine
  elseif race_uses_mine_expansion then
    set i = racial_expansion
  endif
  call GroupEnumUnitsInRangeOfLoc(g, home_location, 2500, null)  // Some maps still need to expand distance , like friends and dustwallowkeys
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if UnitAlive(u) and not IsUnitHidden(u) then
      set m = 0
      set play = GetOwningPlayer(u)
      if GetResourceAmount(u) > 0 then
        if GetUnitTypeId(u) == old_id[GOLD_MINE] then
          set check = DistanceBetweenPoints_kd(home_location,GetUnitLoc(u))  // human and orc need find closest mine
          if check < expansion_taken_radius and check < distance then
            set distance = check
            if i == GOLD_MINE and own_town_mine[0] == null then
              set own_town_mine[0] = u
            else
              set fixmine = u
            endif
          endif
          set c = c + 1
        else
          if i != GOLD_MINE and play == ai_player and (own_town_mine[0] == null or GetUnitTypeId(own_town_mine[0]) != old_id[i]) then
            set own_town_mine[0] = u
          elseif play != ai_player then
            set m = 1
          endif
          set s = s + 1  //race mine and mine cannot be calculated repeatedly
        endif
      endif
      if (IsUnitType(u, UNIT_TYPE_TOWNHALL) or m > 0) and play != ai_player and play != Player(PLAYER_NEUTRAL_AGGRESSIVE) and play != Player(PLAYER_NEUTRAL_PASSIVE) and GetPlayerSlotState(play) == PLAYER_SLOT_STATE_PLAYING then
        if b[GetPlayerId(play)] == false then  // town and mine of the same player cannot be calculated repeatedly
          set b[GetPlayerId(play)] = true
          set p = p + 1
        endif
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  if p > 1 then
    if c + s == p and i != GOLD_MINE then
      set first_town_mine = 1  // mode one , Right number of players and mines or this mine too close (like (4)synergybigpaved.w3x) , just fix UD and ELF harvest
    elseif c + s > p then
      set first_town_mine = 2  // mode two , more mines than players, one player have more mine , fix UD and ELF harvest and all race expensive - prior take closest home_location mine
    endif
    set br_rush_built = true  // maybe will build at other player home , so not build
  elseif (i == GOLD_MINE and c + s > p) or (i != GOLD_MINE and c > 0) then
    set first_town_mine = 3  // mode three , one player have this mine , fix all race harvest and expensive - prior take closest home_location mine
  endif
  if (first_town_mine == 0 and GetMinesOwned() > 1) or (c + s > p and first_town_mine != 3) then
    set first_town_mine = 3  // Hardcoded redundent check
  endif
  call DestroyGroup(g)
  set g = null
  set play = null
  if first_town_mine > 0 then
    call TQAddJob(4, FIX_BUILD, 0)  // run fix build job
    call HarvestGold(0,3)
    call HarvestWood(0,2)  // Early triggering Harvest , convenient HARVEST CHECK job check peon
  endif
  call CreateDebugTag("fix mine", 10, fixmine, 4.00, 2.00)
  call Trace("first town mine mode : " + Int2Str(first_town_mine) + ", sys mine : " + Int2Str(GetMinesOwned()) + ", gold mine : " + Int2Str(c) + ", race mine : "+ Int2Str(s) + ", player : " + Int2Str(p))
endfunction

//===========================================================================
function InitTownBuilt takes nothing returns nothing
  local integer i = 1
  loop
    exitwhen i >= max_towns
    set town_built[i] = false
    set own_town_loc[i] = null
    set i = i + 1
  endloop
  set town_built[0] = true
  set own_town_loc[0] = Location(GetLocationX(home_location), GetLocationY(home_location))
  set exist_town[0] = home_location
  set own_town_dist[0] = 0
  set own_town_mine[0] = GetMineNearLoc(own_town_mine[0] ,home_location, 1500)
endfunction

//============================================================================
function GetBuildLock takes nothing returns nothing
  loop
    exitwhen build_lock
    //call Trace("Build Lock not received")
    call Sleep(0.5)
  endloop
  set build_lock = false
endfunction

//============================================================================
function ReleaseBuildLock takes nothing returns nothing
  set build_lock = true
endfunction

//===========================================================================
// (AMAI) Upkeep utility functions
//===========================================================================
function InitUpkeep takes nothing returns nothing
#INCLUDETABLE <$VER$\Upkeep.txt> #EFR
  set upkeep_allowed[UPKEEP_%1] = UPKEEP_UNDECIDED
  set upkeep_border[UPKEEP_%1] = %2
  set upkeep_resistance[UPKEEP_%1] = %3
  set upkeep_save_time[UPKEEP_%1] = %4
  set upkeep_mines_needed[UPKEEP_%1] = %5
  set upkeep_time[UPKEEP_%1] = -1
  set upkeep_goldchange[UPKEEP_%1] = %6
#ENDINCLUDE
endfunction

//===========================================================================
function InitLastUpkeep takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= UPKEEP_NUM
    set last_upkeep_allowed[i] = UPKEEP_UNDECIDED
    set i = i + 1
  endloop
endfunction

//===========================================================================
function CheckUpkeepAllowed takes integer food returns nothing
  local integer i = 0
  loop
    exitwhen i >= UPKEEP_NUM
    if last_upkeep_allowed[i] == UPKEEP_ALLOWED or last_upkeep_allowed[i] == UPKEEP_UNDECIDED then
      set upkeep_time[i] = -1
    endif
    set last_upkeep_allowed[i] = UPKEEP_UNDECIDED
    if food > upkeep_border[i] then
      set upkeep_time[i] = -1
      set upkeep_allowed[i] = UPKEEP_ALLOWED
    else
      set upkeep_allowed[i] = UPKEEP_UNDECIDED
    endif
    set i = i + 1
  endloop
endfunction

//===========================================================================
function ApplyUpkeepCheck takes integer afford_food, integer food, integer food_cost, integer need_qty returns integer
  local integer mines = GetMinesOwned()
  local integer i = 0
  loop
    exitwhen i >= UPKEEP_NUM
    if food + food_cost * need_qty > upkeep_border[i] then
      if upkeep_allowed[i] == UPKEEP_UNDECIDED then
        if total_gold > upkeep_resistance[i] or mines >= upkeep_mines_needed[i] then // Saved enough gold or got enough mines to support early tier up
          set upkeep_allowed[i] = UPKEEP_ALLOWED
        else
          set upkeep_allowed[i] = UPKEEP_NOT_ALLOWED
        endif
      endif
      if upkeep_allowed[i] == UPKEEP_NOT_ALLOWED then
        if food_cost == 0 then
          set afford_food = need_qty
        else
          set afford_food = Max(upkeep_border[i] - food, 0) / food_cost
        endif
      endif
    endif
    set i = i + 1
  endloop
  return afford_food
endfunction

//===========================================================================
function ApplyUpkeepSaving takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= UPKEEP_NUM
    if upkeep_allowed[i] == UPKEEP_ALLOWED then
      set upkeep_time[i] = -1
    elseif last_upkeep_allowed[i] == UPKEEP_UNDECIDED and upkeep_allowed[i] == UPKEEP_NOT_ALLOWED then
      if upkeep_time[i] == -1 then
        if total_gold > 0 and total_wood > 0 then
          set upkeep_time[i] = ai_time
        endif
      endif
      if use_linear_upkeep_saving then
        // Note do not use as requires more cash as time goes on not less.
        set total_gold = total_gold - R2I(LinearInterpolation(upkeep_time[i], upkeep_time[i] + upkeep_save_time[i], 0, upkeep_resistance[i], ai_time))
      elseif ai_time <= upkeep_time[i] + upkeep_save_time[i] then
//        call DisplayToAll("Saving "+Int2Str(upkeep_resistance[i])+" from "+Int2Str(total_gold))
        set total_gold = total_gold - upkeep_resistance[i]
      endif
    endif
    set i = i + 1
  endloop
endfunction

//===========================================================================
function UpdateLastUpkeep takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= UPKEEP_NUM
    set last_upkeep_allowed[i] = upkeep_allowed[i]
    set i = i + 1
  endloop
endfunction

//===========================================================================
function ResetUpkeepSaveTime takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= UPKEEP_NUM
    if upkeep_allowed[i] == UPKEEP_UNDECIDED then
      set upkeep_time[i] = -1
    endif
    set i = i + 1
  endloop
endfunction

//===========================================================================
// (AMAI) Function Initializations
//===========================================================================
function InitBuildArrayAM takes nothing returns nothing
  local integer i = 0
  call GetBuildLock()
  set build_length = 0
  loop
    exitwhen i >= building_length
    set income_percentage[building[i]] = 0
    set i = i + 1
  endloop
  call ReleaseBuildLock()
endfunction

//===========================================================================
function InitUpgradeTimeArray takes nothing returns nothing
  local integer i = 1
  loop
    exitwhen i > OBJECT_NUM
    set upgrade_time[i] = -1
    set i = i + 1
  endloop
endfunction

//===========================================================================
function InitPlayerStrengthCache takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= GetBJMaxPlayers()
    set p_str_cache[i] = 0
    set p_str_cache_timeout[i] = 0
    set i = i + 1
  endloop
endfunction

//===========================================================================
function InitHeroArrays takes nothing returns nothing
  local integer i = 1
  loop
    exitwhen i > 3
    set hero[i] = 0
    set hero_built[i] = false
    set hero_unit[i] = null
    set i = i + 1
  endloop
  set hero_revive_prio[1] = hero1_revive_prio
  set hero_revive_prio[2] = hero2_revive_prio
  set hero_revive_prio[3] = hero3_revive_prio
endfunction

//===========================================================================
function InitNeutralSpecial takes nothing returns nothing
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\btransporter\b/
  set neutral_zeppelin = %1
#ENDINCLUDE
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\btransporter_water\b/
  set neutral_ship = %1
#ENDINCLUDE
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\bshredder\b/
  set neutral_shredder = %1
#ENDINCLUDE
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\btp\b/
  set tp_item = %1
#ENDINCLUDE
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\bsinge_tp\b/
  set singe_tp_item = %1
#ENDINCLUDE
endfunction

function InitSpecialItem takes nothing returns nothing
  #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\bpreservation_item\b/
  set preservation_item = %1
  #ENDINCLUDE
  #INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\bsanctuary_item\b/
  set sanctuary_item = %1
  #ENDINCLUDE
endfunction

//===========================================================================
function InitCreepStrengthArray takes nothing returns nothing
//#INCLUDETABLE <$VER$\LevelStrengthMap.txt> #EFR
//  set creep_strength[%1] = %2
//#AFTERINCLUDE
//  set creep_strength_length = %row
//#ENDINCLUDE
endfunction

//===========================================================================
function InitGlobalSettings takes nothing returns nothing
  call VersionCheck()
#INCLUDETABLE <$VER$\GlobalSettings.txt> #EFR
  set %1 = %2
#ENDINCLUDE
  if racial_lumber == 0 or race_no_wood_harvest then
    set front_base_distance = front_base_distance + 100
  endif
endfunction

//===========================================================================
function IsGameFFA takes nothing returns boolean
  local boolean array team_exists
  local integer i = 0
  local integer tc = 0
  loop
    exitwhen i >= GetBJMaxPlayers()
    set team_exists[i] = false
    set i = i + 1
  endloop
  set i = 0
  loop
    exitwhen i >= GetBJMaxPlayers()
    if GetPlayerSlotState(Player(i)) == PLAYER_SLOT_STATE_PLAYING then
      set team_exists[GetPlayerTeam(Player(i))] = true
    endif
    set i = i + 1
  endloop
  set i = 0
  loop
    exitwhen i >= GetBJMaxPlayers()
    if team_exists[i] then
      set tc = tc + 1
    endif
    set i = i + 1
  endloop
  return tc > 3
endfunction

//===========================================================================
//function GetEnemyFoodUse takes nothing returns integer
//  local integer p = 0
//  local integer food = 0
//
//  GetPlayerState(p, PLAYER_STATE_RESOURCE_FOOD_USED)
//
//
//endfunction

//===========================================================================
function InitRaceNames takes nothing returns nothing
#INCLUDETABLE <$VER$\Races.txt>
  set race_name[%row] = "%1"
#ENDINCLUDE
endfunction

//===========================================================================
function InitSpecialRaces takes nothing returns nothing
  local integer i = 0
  local string s = null
  loop
    exitwhen i >= GetBJMaxPlayers()
    set s = Int2Str(i)
    set player_race[i] = LoadInteger(com, RACE, i)
    set player_race_pref[i] = LoadInteger(com, RACE_PREF, i)
    set i = i + 1
  endloop
  set s = null
endfunction

//===========================================================================
function InitStandardRaces takes nothing returns nothing
  local integer i = 0
  local player p = null
  loop
    exitwhen i >= GetBJMaxPlayers()
    set p = Player(i)
    set player_race_pref[i] = SR_RANDOM
    if GetPlayerRace(p) == RACE_NIGHTELF then
      set player_race[i] = SR_ELF
      if IsPlayerRacePrefSet(p, RACE_PREF_NIGHTELF) then
        set player_race_pref[i] = SR_ELF
      endif
    elseif GetPlayerRace(p) == RACE_HUMAN then
      set player_race[i] = SR_HUMAN
      if IsPlayerRacePrefSet(p, RACE_PREF_HUMAN) then
        set player_race_pref[i] = SR_HUMAN
      endif
    elseif GetPlayerRace(p) == RACE_ORC then
      set player_race[i] = SR_ORC
      if IsPlayerRacePrefSet(p, RACE_PREF_ORC) then
        set player_race_pref[i] = SR_ORC
      endif
    else
      set player_race[i] = SR_UNDEAD
      if IsPlayerRacePrefSet(p, RACE_PREF_UNDEAD) then
        set player_race_pref[i] = SR_UNDEAD
      endif
    endif
    set i = i + 1
  endloop
  set p = null
endfunction

//===========================================================================
function InitRaces takes nothing returns nothing
  if LoadBoolean(com, USE_SPECIAL_RACES, StringHash("Special")) then
    call InitSpecialRaces()
  else
    call InitStandardRaces()
  endif
endfunction

//===========================================================================
function GetMaxFarms takes nothing returns integer
  local integer fm = GetFoodMade(old_id[racial_farm])
  local integer div = ver_food_limit / Max(fm, 1)
  if div * fm < ver_food_limit then
    set div = div + 1
  endif
  return div
endfunction

//===========================================================================

//============================================================================
// AMAI Code
//============================================================================
function InitAMAI takes nothing returns nothing
  if debugging and IsPlayerObserver(GetLocalPlayer()) then
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_HELP_REQUEST,  true)
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_HELP_RESPONSE, true)
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_SHARED_XP,     true)
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_SHARED_SPELLS, true)
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_SHARED_VISION, true)
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_SHARED_CONTROL, true)
    call SetPlayerAlliance(ai_player, GetLocalPlayer(), ALLIANCE_SHARED_ADVANCED_CONTROL, true)
  endif
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR
  set unitNames[%row] = "%1"
#ENDINCLUDE
  set message_add = c2s(GetPlayerColor(ai_player))
  if race_militia_available then
    set militia_hall = GetMilitiaHall(militia_hall)
  endif
  call InitDigits()
  set ai_id = Int2Str(GetAiPlayer())
  call SaveBoolean(com, IS_AMAI, GetAiPlayer(), true)
  call InitRaces()
  if IsGameFFA() then
    set game_is_ffa = true
    set attacking_strategy = 5
  endif
  call countAllyEnemy()
  if c_enemy_total == 1 and c_ally_total == 0 then
    set game_is_1on1 = true
  endif
  set sleep_multiplier = GetSleepMultipler(c_ai_total)
  set difficulty = MeleeDifficulty()
  set income_per_mine = income_per_mine * Max(difficulty - 1, 1)
  call Trace("Init AMAI step 1")
  call InitNeutralSpecial()
  call Trace("Init AMAI step 2")
  call InitSpecialItem()
  call Trace("Init AMAI step 3")
  call InitHeroArrays()
  call Trace("Init AMAI step 4")
  call InitArrays()  // Has been moved to be set before all other code as is only variable declaration
  call Trace("Init AMAI step 5")
  call InitChatArrays()
  call Trace("Init AMAI step 6")
  call InitChatEvents()
  call Trace("Init AMAI step 7")
  call InitTrans()
  call Trace("Init AMAI step 8")
  call InitTranslations()
  call Trace("Init AMAI step 9")
  call InitRaceNames()
  call Trace("Init AMAI step 10")
  call InitCT()
  call Trace("Init AMAI step 11")
//    call TestCT()
  call InitChatVars()
  call Trace("Init AMAI step 12")
  call InitCreepStrengthArray()
  call Trace("Init AMAI step 13")
  call StopGathering()
  call InitBuildArrayAM()
  call InitUpkeep()
  call InitNeutralBuildings()
  call Trace("Init AMAI step 14")
  call StartThread(function PathingThread)
  //call StartThread(function ExpansionThread)
  //call StartThread(function CheckAllNeutrals)
  call InitHealers()
  call InitUpgradeTimeArray()
  call InitPlayerStrengthCache()
  call SetNearestEnemy()
  call InitTownBuilt()
  call Trace("Init AMAI step end")
  set max_farms = GetMaxFarms()
  if own_town_mine[0] != null then
    set mine_loc = GetUnitLoc(own_town_mine[0])
  endif
  set firstattackhp = c_enemy_user_total > 0 and (c_ally_total + c_enemy_total >= 10 or mapSize > 3 or (mapSize < 3 and c_enemy_user_total < 3))  // player too much or big map , first attack HumanPlayer
//    call DebugSequenceStart("DebugRun")

endfunction

//============================================================================
function AMAI takes code heroes, code peons, code attacks returns nothing
    local boolean isNewbie = (difficulty == EASY)

    // call sendToNextAI()
    call SaveBoolean(com, TEAM_STATEGY_INUSE, strategy_type[chosen_strategy], true)
    set last_strategy = strategy

    call SetMeleeAI()

#INCLUDETABLE <$VER$\StandardAiSettings.txt> #EFR
    call %1(%2)
#ENDINCLUDE

    call CreateCaptains()
    set captain_home = home_location
    call SetCaptainHome(BOTH_CAPTAINS, GetLocationX(home_location), GetLocationY(home_location))
    call Trace("Setting hero levels")
    call SetHeroLevels(heroes)
    call Trace("heros set")
    call Sleep(0.3) // Run before harvest to help hardcoded mine claims to help hint to only collect resources from owned mines.
    call InitCheckHarvest()  // Fix harvest logic for multiple mines and elf and undead unable to harvest (old war3 version distance need 2200+ )
    // Job Thread
    call StartThread(function TQLoop)
    //call Trace("TQLoop")
    call StartThread(peons)
    //call Trace("peons")
    call StartThread(attacks)
    //call Trace("attacks")
    call StartThread(function cmd_loop)
    //call Trace("cmd_loop")
endfunction

//============================================================================
function InitCampaignDefenders takes nothing returns nothing
  local integer i = 1
  loop
    exitwhen i > 200
    set campaign_defenders[i] = 0
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) KeyBuildingAdd
//============================================================================
function KeyAddTimeModify takes integer k_add returns integer
  local real t = TimerGetElapsed(tq_timer)
  return R2I(LinearInterpolation(k_add_start_time, k_add_end_time, k_add_start_mult, k_add_end_mult, t) * I2R(k_add))
endfunction

//============================================================================
function GetKeyBuildingAddExt takes integer kb returns integer
  if TownCountDone(kb) > 1 then
    return kb_add4
  elseif TownCountDone(kb) > 0 then
    return kb_add1
  elseif TownCount(kb) > 0 then
    return kb_add2
  elseif TownCountDone(needed1[kb]) > 0 and TownCountDone(needed2[kb]) > 0 then
    return kb_add3
  endif
  return 0
endfunction

//============================================================================
function GetKeyBuildingAdd takes integer sn returns integer
  return KeyAddTimeModify(GetKeyBuildingAddExt(key_building1[sn]) + GetKeyBuildingAddExt(key_building2[sn]))
endfunction

//============================================================================
function KeyBuildingAdd takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i>= rp_strat_length
    set rp_strat[i] = rp_strat[i] + GetKeyBuildingAdd(i)
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) KeyUpgradeAdd
//============================================================================
function GetKeyUpgradeAddExt takes integer kb returns integer
  local integer ul = GetUpgradeLevel(old_id[kb])
  if ul >= 3 then
    return ku_add3
  elseif ul == 2 then
    return ku_add2
  elseif ul == 1 then
    return ku_add1
  endif
  return 0
endfunction

//============================================================================
function GetKeyUpgradeAdd takes integer sn returns integer
  return KeyAddTimeModify(GetKeyUpgradeAddExt(key_upgrade1[sn]) + GetKeyUpgradeAddExt(key_upgrade2[sn]))
endfunction

//============================================================================
function KeyUpgradeAdd takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i>= rp_strat_length
    set rp_strat[i] = rp_strat[i] + GetKeyUpgradeAdd(i)
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) KeyUnitAdd
//============================================================================
function GetKeyUnitAddExt takes integer kb returns integer
  if kb != 0 then
    return TownCountDone(kb) * GetFoodUsed(old_id[kb])
  endif
  return 0
endfunction

//============================================================================
function GetKeyUnitAdd takes integer sn returns integer
  return KeyAddTimeModify(GetKeyUnitAddExt(key_unit[sn]))
endfunction

//============================================================================
function KeyUnitAdd takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i>= rp_strat_length
    set rp_strat[i] = rp_strat[i] + GetKeyUnitAdd(i)
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) SmallMapsAdd (Bonus to strategies at tier 1 on small maps)
//============================================================================
function SmallMapsAdd takes nothing returns nothing
  local integer i = 0
  if GetPlayers() > 3 or mapSize >= 3 then
    return
  endif
  loop
    exitwhen i >= rp_strat_length
    if strategy_tier[i] == 1 then
      set rp_strat[i] = rp_strat[i] + small_map_tier1_bonus
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) rp_strat functions (Strategy and Priority functions)
//============================================================================
function sum_rp_strat takes integer num returns integer
  local integer i = 0
  local integer sum = 0
  loop
    exitwhen i >= num
    set sum = sum + rp_strat[i]
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
function choose_strategy takes nothing returns integer
  local integer i = 1
  local integer rp_sum = sum_rp_strat(rp_strat_length)
  local integer strategy_roll = GetRandomInt(1, rp_sum)
  if rp_sum <= 0 then
    return 0
  endif
  loop
    exitwhen strategy_roll <= sum_rp_strat(i)
    set i = i + 1
  endloop

  return i - 1
endfunction

//============================================================================
function mult_rp_strat takes integer m returns nothing
  local integer i = 0
  loop
    exitwhen i >= rp_strat_length
    set rp_strat[i] = rp_strat[i] * m
    set i = i + 1
  endloop
endfunction

//============================================================================
function div_rp_strat takes integer d returns nothing
  local integer i = 0
  if d == 0 then
    set d = 1
  endif
  loop
    exitwhen i >= rp_strat_length
    set rp_strat[i] = rp_strat[i] / d
    set i = i + 1
  endloop
endfunction

//============================================================================
function make_rp_strat_positive takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= rp_strat_length
    if rp_strat[i] < 0 then
      set rp_strat[i] = 0
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function normalize_rp_strat takes nothing returns nothing
  local integer i = 0
  local integer sum = sum_rp_strat(rp_strat_length)
  if sum == 0 then
    set sum = 1
  endif
  loop
    exitwhen i >= rp_strat_length
    set rp_strat[i] = (rp_strat[i] * rp_strat_normal) / sum
    set i = i + 1
  endloop
endfunction

//============================================================================
function add_tier_bonus takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= rp_strat_length
    if tier == strategy_tier[i] then
      set rp_strat[i] = rp_strat[i] + strategy_tier_bonus
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function display_rp_strat takes nothing returns nothing
  local integer i = 0
  local real sum = 0
  if balancing then
    set sum = I2R(sum_rp_strat(rp_strat_length))
    if sum == 0 then
      set sum = 1
    endif
    loop
      exitwhen i >= rp_strat_length
      call DisplayToAll(GetStrategyName(i)+": "+Int2Str(R2I(I2R(100 * rp_strat[i]) / sum))+" %")
      set i = i + 1
    endloop
  endif
endfunction

//============================================================================
function init_rp_strat_sort takes nothing returns nothing
  set rp_strat_sort_length = 0
endfunction

//============================================================================
function sum_rp_strat_sort takes integer num returns integer
  local integer i = 0
  local integer sum = 0
  loop
    exitwhen i >= num
    set sum = sum + rp_strat[rp_strat_sort[i]]
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
function display_rp_strat_sort takes nothing returns nothing
  local integer i = 0
  local real sum = 0
  if balancing then
    set sum = I2R(sum_rp_strat_sort(relevant_strat_change_number))
    if sum == 0 then
      set sum = 1
    endif
    loop
      exitwhen i >= relevant_strat_change_number
      call DisplayToAll(GetStrategyName(rp_strat_sort[i])+": "+Int2Str(R2I(I2R(100 * rp_strat[rp_strat_sort[i]]) / sum))+" %")
      set i = i + 1
    endloop
  endif
endfunction

//============================================================================
function sort_rp_strat takes nothing returns nothing
  local integer i = 0
  local integer j = 0
  loop
    exitwhen i >= rp_strat_length
    set j = rp_strat_sort_length - 1
    loop
      exitwhen j < 0
      exitwhen rp_strat[rp_strat_sort[j]] > rp_strat[i]
      set rp_strat_sort[j + 1] = rp_strat_sort[j]
      set j = j - 1
    endloop
    set rp_strat_sort[j + 1] = i
    set rp_strat_sort_length = rp_strat_sort_length + 1
    set i = i + 1
  endloop
endfunction

//============================================================================
function nullify_bad_strats takes nothing returns nothing
  local integer i = 0
  local integer f = strat_persistence + (FoodUsed() * strat_food_persistence)
  loop
    if rp_strat[i] < (rp_strat[strategy] - f) * strategy_change_threshold then
      set rp_strat[i] = 0
    endif
    set i = i + 1
    exitwhen i >= rp_strat_length
  endloop
endfunction

//============================================================================
function finish_strategy_change takes nothing returns nothing
  local integer strategy_roll = 0
  local integer sum = 0
  local integer i = 0

  call KeyBuildingAdd()
  call KeyUpgradeAdd()
  call KeyUnitAdd()
  call add_tier_bonus()
  set rp_strat[strategy] = rp_strat[strategy] + strat_persistence + strat_food_persistence * FoodUsed() // Add the bonuses to persistance
  call nullify_bad_strats()

  set rp_strat[strategy] = R2I(I2R(rp_strat[strategy]) * Pow(c_enemy_total,0.75))
  call make_rp_strat_positive()
  call init_rp_strat_sort()
  call sort_rp_strat()
//  call display_rp_strat_sort()
  set sum = sum_rp_strat_sort(relevant_strat_change_number)
  if sum < 1 then
    return
  endif
  set strategy_roll = GetRandomInt(1,sum)
  set sum = 0
  loop
    set sum = sum + rp_strat[rp_strat_sort[i]]
    if strategy_roll <= sum then
      //if rp_strat[rp_strat_sort[i]] / Max(rp_strat[strategy], 1) > strategy_change_threshold then
      set strategy = rp_strat_sort[i]
      set chosen_strategy = strategy
      call SetChatVar("Strategy", GetCurrentStrategyName())
      //endif
      return
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function removeNonBeginningStrats takes nothing returns nothing
  local integer i = 0
  if nearest_enemy_range < 5000 or not ((game_is_ffa and c_enemy_total > 3) or (c_ally_total > 2 and c_enemy_total > 3)) then
    loop
      exitwhen i >= rp_strat_length
      if not beginning_strat[i] and (debug_strategy != i) then
        set rp_strat[i] = 0
      endif
      set i = i + 1
    endloop
  endif
endfunction

//============================================================================
function AddStrategyHeroRP takes integer h, integer to_add returns nothing
  local integer i = 0
  loop
    exitwhen i >= hero_number
    if all_heroes[i] == h then
      set hero_rp[i] = hero_rp[i] + to_add
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) Race Aggression
//============================================================================
function ApplyStrategyRaceAggression takes nothing returns nothing
  local integer i = 0
  local integer l = tiernum * RACE_NUMBER
  loop
    exitwhen i >= l
    set race_aggression[i] = b_race_aggression[i] + strategy_race_aggression[strategy*l + i]
    set i = i + 1
  endloop
endfunction

//============================================================================
// (AMAI) Hero Choice
//============================================================================
function make_hero_rp_positive takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= hero_number
    if hero_rp[i] < 0 then
      set hero_rp[i] = 0
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function sum_hero_rp takes nothing returns integer
  local integer i = first_choosable_hero
  local integer sum = 0
  loop
    exitwhen i >= hero_number
    set sum = sum + hero_rp[i]
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
function ChooseHero takes nothing returns integer
  local integer i = first_choosable_hero
  local integer sum = 0
  local integer rp_sum = sum_hero_rp()
  local integer hero_roll = GetRandomInt(1,Max(rp_sum,1))
  if rp_sum > 0 then
    loop
      exitwhen i >= hero_number
      set sum = sum + hero_rp[i]
      if hero_roll <= sum then
        return i
      endif
      set i = i + 1
    endloop
  endif
  return 0
endfunction

//============================================================================
function remove_hero takes integer h returns nothing
  local integer i = h
  set hero_number = hero_number - 1
  loop
    exitwhen i >= hero_number
    set hero_rp[i] = hero_rp[i + 1]
    set all_heroes[i] = all_heroes[i + 1]
    set i = i + 1
  endloop
endfunction

//============================================================================
//
//============================================================================
function GetExistingHero takes nothing returns integer
  local group g = CreateGroup()
  local unit u = null
  local integer oid = 0
  local integer i = 0
  local integer c = 1
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  set g = SelectUnittype(g, UNIT_TYPE_HERO, true)
  set u = FirstOfGroup(g)
  call DestroyGroup(g)
  set g = null
  if u == null then
    call DisplayToAll("Hero not found")
    return 0
  endif
  set oid = GetUnitTypeId(u)
  loop
    exitwhen i >= hero_number
    if old_id[all_heroes[i]] == oid then
      set chosen = i
      if major_hero == null then
        set major_hero = u
      endif
      call SelectHeroSkill(u, allskills[GetRandomInt(0, 2)*HERO_LEVEL_NUMBER + i*9*HERO_LEVEL_NUMBER + 1])
      set u = null
      return all_heroes[i]
    endif
    set i = i + 1
  endloop
  call DisplayToAll("Unknown hero")
  set u = null
  return 0
endfunction

//============================================================================
function ChooseFirstHero takes nothing returns integer
  local integer i = 0
  if hero_built[1] and recalculate_heros then
    loop
      exitwhen i >= hero_number
      if hero[1] == all_heroes[i] then
        set chosen = i
        return chosen
      endif
      set i = i + 1
    endloop
  endif
  if IsMapFlagSet(MAP_RANDOM_HERO) then
//    call DisplayToAll("Map flag set")
    set hero[1] = GetExistingHero()
  else
    call make_hero_rp_positive()
    set chosen = ChooseHero()
    set hero[1] = all_heroes[chosen]
  endif
  return chosen
endfunction

//============================================================================
function ChooseSecondHero takes nothing returns nothing
  local integer i = 0
  call make_hero_rp_positive()
  call remove_hero(chosen)
  if hero_built[2] and recalculate_heros then
    loop
      exitwhen i >= hero_number
      if hero[2] == all_heroes[i] then
        set chosen = i
        return
      endif
      set i = i + 1
    endloop
  endif
  set chosen = ChooseHero()
  set hero[2] = all_heroes[chosen]
endfunction

//============================================================================
function ChooseRestHeroes takes nothing returns nothing
  local integer i = 0
  call make_hero_rp_positive()
  call remove_hero(chosen)
  if hero_built[3] and recalculate_heros then
    loop
      exitwhen i >= hero_number
      if hero[3] == all_heroes[i] then
        set chosen = i
        return
      endif
      set i = i + 1
    endloop
  endif
  set hero[3] = all_heroes[ChooseHero()]
endfunction

//============================================================================
// (AMAI) Building Functions
//============================================================================
function GetMinesHarvested takes nothing returns integer
  local integer twm = TownWithMine()
  local integer i = twm
  local integer sum = 0
  local integer mine = racial_expansion
  local boolean b = race_manual_loading == true or race_uses_mine_expansion == true
  if race_manual_loading then
    set mine = race_manual_loading_mine
  endif
  if b or first_town_mine > 0 then  //home_location have multiple mine or just one mine but UD and ELF cannot harvested
    set twm = TownCountDone(mine) - 1
  endif
  if twm < 0 then
    return 0
  endif
  if b then
    return twm + 1
  endif
  set i = twm
  loop
    exitwhen i > twm + 3
    if TownHasMine(i) and TownCountEx(mine,true,i) > 0 then
      set sum = sum + 1
    endif
    set i = i + 1
  endloop
  return sum
endfunction

//============================================================================
// Total expected income per second (plus spare gold)
function GetGoldIncome takes nothing returns real
  local real inc = I2R(GetMinesHarvested()*income_per_mine)
  local integer i = 0
  local real upkeep = 1
  loop
    exitwhen i >= UPKEEP_NUM
    if FoodUsed() >= upkeep_border[i] then
      set upkeep = upkeep_goldchange[i]
    endif
    set i = i + 1
  endloop
  set inc = RMin(inc * upkeep, I2R(GetGoldOwned()))
  return inc + GetGold() * gold_unit_percentage
endfunction

//============================================================================
// Returns % impact such that more units required is negligable, while less units greatly reduces the rate
function GetFactoryRate takes integer qty returns real
  if qty <= 3 then
    return 0.0
  endif
  return 1 - 1 / I2R(qty)
endfunction

//============================================================================
// in_percent = total gold cost of units required / gold_income
// gold_income = (GetGoldRate of mines + current gold) * 0.9
function GetFactoryQty takes integer qty, integer build_time, integer gold_cost, integer wood_cost, integer buildingid, real in_percentage returns integer
  local real gIncomePerSecond = GetFactoryRate(qty) * gold_income
  local real gPerSecondToAffordUnit = I2R(gold_cost) / I2R(Max(build_time, 1))
  local real wIncomePerSecond = (GetFactoryRate(qty) * (GetWood()*gold_unit_percentage + 10)) // Assuming flat 10 wood per second
  local integer woodFactories = R2I(wIncomePerSecond / RMax(I2R(wood_cost) / I2R(Max(build_time, 1)), 1))
  local integer count = TownCount(buildingid)
  //call DisplayToAll("factory number returned: "+Int2Str(Max(Min(R2I(gip / gic), difficulty),1)))
  //call Trace("Income per second " + Real2Str(gIncomePerSecond) + " gold required per second " + gPerSecondToAffordUnit)
  // Smallest factories number based on gold per second and wood per second, if both are in a good state then factory output will be higher
  local integer requiredFactories = Max(Min(Min(R2I(gIncomePerSecond / RMax(gPerSecondToAffordUnit,1)),woodFactories), difficulty),1) // Difficulty no more than 3 on insane, 2 on normal
  if buildingid != 0 and count < requiredFactories and requiredFactories > 1 then
    set gIncomePerSecond = GetUnitGoldCost2(buildingid)*1.75
    set wIncomePerSecond = GetUnitWoodCost2(buildingid)*1.75
    loop
      exitwhen requiredFactories <= 1
      if GetGold() > ((requiredFactories - count) * gIncomePerSecond) and GetWood() > ((requiredFactories - count) * wIncomePerSecond) then
        return requiredFactories
      endif
      set requiredFactories = requiredFactories - 1
    endloop
  endif
  return requiredFactories
endfunction

//============================================================================
function IsOneOnlyBuilding takes integer unitid returns boolean
  if false then
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\boneonly\b/
  elseif unitid == %1 then
    return true
#ENDINCLUDE
  endif
  return false
endfunction

function isTieringUp takes nothing returns boolean
  local integer i = tiernum
  loop
    exitwhen i <= 1
    if GetUnitCountDone(racial_hall[i - 1]) > 0 then
      return GetUnitCountDone(racial_hall[i]) < GetUnitCount(racial_hall[i])
    endif
    set i = i - 1
  endloop
  return false
endfunction

//============================================================================
function Get_f_qty takes integer qty, integer unitid, integer town  returns integer
  if buy_type[unitid] != BT_UNIT or unitid == racial_peon or IsOneOnlyBuilding(needed1[unitid]) or isTieringUp() then
    return 1
  endif
  return GetFactoryQty(qty - TownCountTown(unitid, town), GetUnitBuildTime(old_id[unitid]), GetUnitGoldCost2(unitid), GetUnitWoodCost2(unitid), needed1[unitid], income_percentage[needed1[unitid]])
endfunction

//============================================================================
// Tier is the block levels set if tier is the current tier
// unitper is % of previously built units must have been built, otherwise tier up is blocked
// foodlimit is amount of food used that must bypass Block
// expansionblock if set expanding will block tier up
function SetTierBlock takes integer tier, real unitper, integer foodlimit, boolean expansionblock returns nothing
  if tier < 1 then
    set tier = 1
  endif
  set bl_tier_foodlock[tier - 1] = foodlimit
  set bl_tier_unitlock[tier - 1] = unitper
  set bl_tier_expansionblock[tier - 1] = expansionblock
endfunction

function AddBlock takes integer req_qty, integer req_type, boolean only_done, integer allow_qty, integer allow_type, integer expire_time returns nothing
  set bl_req_qty[bl_length] = req_qty
  set bl_req_type[bl_length] = req_type
  set bl_only_done[bl_length] = only_done
  set bl_allow_qty[bl_length] = allow_qty
  set bl_allow_type[bl_length] = allow_type
  set bl_expire_time[bl_length] = expire_time
  set bl_length = bl_length + 1
endfunction

function InitBlockList takes nothing returns nothing
  local integer i = 0
  set bl_length = 0
  loop
    exitwhen i >= tier
    set bl_tier_foodlock[i] = 0
    set bl_tier_unitlock[i] = 0
    set bl_tier_expansionblock[i] = false
    set i = i + 1
  endloop
endfunction

function BlockListCheck takes integer qty, integer t returns integer
  local integer i = 0
  local integer max_qty = qty
  loop
    exitwhen i >= bl_length
    //if bl_allow_type[i] == t then
      //call Trace("BlockList Id " + unitNames[t] + " time:" + Int2Str(ai_time) + " expiry time:" + Int2Str(bl_expire_time[i]))
    //endif
    if ai_time < bl_expire_time[i] and bl_allow_type[i] == t then
      if TownCountEx(bl_req_type[i], bl_only_done[i], -1) < bl_req_qty[i] then
        set max_qty = Min(max_qty, bl_allow_qty[i])
        //call Trace("BlockList Id " + unitNames[t] + " original qty:" + Int2Str(qty) + " new qty:" + Int2Str(max_qty))
      endif
    endif
    set i = i + 1
  endloop
  return max_qty
endfunction

//============================================================================
function AddRBlock takes integer req_gold, integer req_wood, integer req_food, integer allow_qty, integer allow_type, integer expire_time returns nothing
  set rbl_req_gold[rbl_length] = req_gold
  set rbl_req_wood[rbl_length] = req_wood
  set rbl_req_food[rbl_length] = req_food
  set rbl_allow_qty[rbl_length] = allow_qty
  set rbl_allow_type[rbl_length] = allow_type
  set rbl_expire_time[rbl_length] = expire_time
  set rbl_length = rbl_length + 1
endfunction

function InitRBlockList takes nothing returns nothing
  set rbl_length = 0
endfunction

function RBlockListCheck takes integer qty, integer t returns integer
  local integer i = 0
  local integer max_qty = qty
  local integer f = FoodUsed()
  local string q = Int2Str(qty)
  loop
    exitwhen i >= rbl_length
    if ai_time < rbl_expire_time[i] and rbl_allow_type[i] == t then
      if total_gold < rbl_req_gold[i] or total_wood < rbl_req_wood[i] or f < rbl_req_food[i] then
        set max_qty = Min(max_qty, rbl_allow_qty[i])
        call Trace("RBlockList Id " + unitNames[t] + " original qty:" + q + " new qty:" + Int2Str(max_qty))
        set blocked_gold = Max(blocked_gold, rbl_req_gold[i])
        set blocked_wood = Max(blocked_wood, rbl_req_wood[i])
        set blocked_food = Max(blocked_food, rbl_req_food[i])
      endif
    endif
    set i = i + 1
  endloop
  set q = null
  return max_qty
endfunction

//============================================================================
//AMAI Build Code
//============================================================================

function SetBuildAllAMCore takes integer t, integer qty, integer unitid, integer town, integer bloc, integer prio returns nothing
  local integer i = 0
  local integer j = 0
  if unitid < 1 or qty == 0 then
    return
  endif
  if t == BUILD_UPGRADE then
    if GetUpgradeLevel(old_id[unitid]) >= qty then
      return
    endif
  elseif t == BUILD_ITEM then
    if GetItemNumber(unitid) >= qty then
      return
    endif
  elseif TownCountTown(unitid, town) >= qty or (buy_type[unitid] > BT_RACIAL_ITEM and not neutral_available[GetNeutralNumber(unitid)]) then
    return
  endif
  call GetBuildLock()
  set j = Max(build_length - 1,0)
  loop
    exitwhen i >= build_length
    exitwhen build_prio[i] < prio
    if build_item[i] == unitid and build_qty[i] >= qty and build_town[i] == town then
      call ReleaseBuildLock()
      return
    endif
    set i = i + 1
  endloop
  loop
    exitwhen j < i
    set build_qty[j+1] = build_qty[j]
    set build_type[j+1] = build_type[j]
    set build_item[j+1] = build_item[j]
    set build_town[j+1] = build_town[j]
    set build_loc[j+1] = build_loc[j]
    set build_prio[j+1] = build_prio[j]
    set j = j - 1
  endloop
  set build_qty[i] = qty
  set build_type[i] = t
  set build_item[i] = unitid
  set build_town[i] = town
  set build_loc[i] = bloc
  set build_prio[i] = prio
  set build_length = build_length + 1
  call ReleaseBuildLock()

  if qty > 1 then
    call SetBuildAllAMCore(t, qty - 1, unitid, town, bloc, prio + prio_q_inc )
  endif

endfunction

function RefreshNeeded takes integer t, integer qty, integer unitid, integer town, integer bloc, integer prio returns nothing
  if unitid < 1 then
    return
  endif
  if buy_type[unitid] == BT_ML_UPGRADE then
    if qty == 1 then
      if needed1[unitid] != 0 then
        call SetBuildAllAMCore(BUILD_UNIT, Get_f_qty(qty, unitid, town), needed1[unitid], -1, BLOC_STD, prio + prio_n_inc*3)
      endif
    elseif qty == 2 then
      call SetBuildAllAMCore(BUILD_UPGRADE, 1, unitid, town, BLOC_STD, prio + prio_n_inc*2)
      if needed2[unitid] != 0 then
        call SetBuildAllAMCore(BUILD_UNIT, 1, needed2[unitid], -1, BLOC_STD, prio + prio_n_inc*2)
      endif
    else
      call SetBuildAllAMCore(BUILD_UPGRADE, 1, unitid, town, BLOC_STD, prio + prio_n_inc*2)
      call SetBuildAllAMCore(BUILD_UPGRADE, 2, unitid, town, BLOC_STD, prio + prio_n_inc)
      if needed3[unitid] != 0 then
        call SetBuildAllAMCore(BUILD_UNIT, 1, needed3[unitid], -1, BLOC_STD, prio + prio_n_inc)
      endif
    endif
  elseif buy_type[unitid] == BT_HERO or buy_type[unitid] == BT_NEUTRAL_HERO then
    if unitid == hero[1] or unitid == hero[2] or unitid == hero[3] then
      if needed1[unitid] != 0 then
        call SetBuildAllAMCore(BUILD_UNIT, 1, needed1[unitid], -1, BLOC_STD, prio + prio_n_inc*2)
      endif
    endif
    if (unitid == hero[2] and not hero_built[2]) or (unitid == hero[3] and not hero_built[3]) then
      if needed2[unitid] != 0 then
        call SetBuildAllAMCore(BUILD_UNIT, 1, needed2[unitid], -1, BLOC_STD, prio + prio_n_inc*2)
      endif
    endif
    if unitid == hero[3] and not hero_built[3] then
      if needed3[unitid] != 0 then
        call SetBuildAllAMCore(BUILD_UNIT, 1, needed3[unitid], -1, BLOC_STD, prio + prio_n_inc*2)
      endif
    endif
  else
    if needed1[unitid] != 0 then
      if needed3[unitid] == UPGRADED then
        // Number needed is on top of the already upgraded as cannot upgrade the already upgraded. Remove existing desired upgrade from count to avoid it infinitely increasing.
        call SetBuildAllAMCore(BUILD_UNIT, Max(0,qty + GetUnitCountAlt(needed1[unitid], unitid, false, town)), needed1[unitid], town, bloc, prio + prio_n_inc*3)
      else
        call SetBuildAllAMCore(BUILD_UNIT, Get_f_qty(qty, unitid, town), needed1[unitid], -1, BLOC_STD, prio + prio_n_inc*3)
      endif
    endif
    if needed2[unitid] != 0 then
      call SetBuildAllAMCore(BUILD_UNIT, 1, needed2[unitid], -1, BLOC_STD, prio + prio_n_inc*2)
    endif
    if needed3[unitid] != 0 and needed3[unitid] != UPGRADED then
      call SetBuildAllAMCore(BUILD_UNIT, 1, needed3[unitid], -1, BLOC_STD, prio + prio_n_inc)
    endif
  endif
  #INCLUDETABLE <$VER$\NeededExtra.txt> #EFR
  if unitid == %1 then
    call SetBuildAllAMCore(BUILD_%2, %3, %4, -1, BLOC_STD, prio + prio_n_inc)
  endif
  #ENDINCLUDE
endfunction

function SetBuildAllAM takes integer t, integer mqty, integer unitid, integer town, integer bloc, integer prio returns nothing
  set mqty = BlockListCheck(mqty, unitid)
  if unitid != 0 and mqty > 0 then
    call SetBuildAllAMCore(t, mqty, unitid, town, bloc, prio)
    call RefreshNeeded(t, mqty, unitid, town, bloc, prio)
  endif
endfunction

//============================================================================
function CanBuildUnit takes integer unitid returns boolean
  local boolean b = (needed1[unitid] == 0 or TownCountDone(needed1[unitid]) > 0) and (needed2[unitid] == 0 or TownCountDone(needed2[unitid]) > 0) and (needed3[unitid] == 0 or needed3[unitid] == UPGRADED or TownCountDone(needed3[unitid]) > 0)
#INCLUDETABLE <$VER$\NeededExtra.txt> #EFR #COND "%2" eq "UNIT"
  set b = b and (unitid != %1 or TownCountDone(%4) > 0)
#ENDINCLUDE
#INCLUDETABLE <$VER$\NeededExtra.txt> #EFR #COND "%2" eq "UPGRADE"
  set b = b and (unitid != %1 or GetUpgradeLevel(old_id[%4]) >= %3)
#ENDINCLUDE
  return b
endfunction

//============================================================================
function BuildUnit takes integer qty, integer unitid, integer prio returns nothing
  local integer i = BLOC_STD
  if buy_type[unitid] == BT_BUILDING and not IsRacialHallId(unitid, 1) and GetRacialBuildHallLV(unitid) > 1 then
    if minebuild then
      set i = BLOC_MINE
    elseif not homebuild and not shredderbuild then
      set i = BLOC_FRONT
    endif
  endif
  call SetBuildAllAM(BUILD_UNIT,qty,unitid,-1, i, prio)
endfunction

//============================================================================
function SetBuildUnitIfAvailable takes integer qty, integer unitid, integer prio returns nothing
  if CanBuildUnit(unitid) then
    call BuildUnit(qty, unitid, prio)
  endif
endfunction

//============================================================================
function SetBuildUnitExAM takes integer easy, integer med, integer hard, integer unitid, integer prio returns nothing
  if difficulty == EASY then
    call SetBuildAllAM(BUILD_UNIT,easy,unitid,-1, BLOC_STD, prio)
  elseif difficulty == NORMAL then
    call SetBuildAllAM(BUILD_UNIT,med,unitid,-1, BLOC_STD, prio)
  else
    call SetBuildAllAM(BUILD_UNIT,hard,unitid,-1, BLOC_STD, prio)
  endif
endfunction

//============================================================================
function SecondaryTownAM takes integer town, integer qty, integer unitid, integer prio returns nothing
  call SetBuildAllAM(BUILD_UNIT,qty,unitid,town, BLOC_STD, prio)
endfunction

//============================================================================
function BuildUpgr takes integer qty, integer unitid, integer prio returns nothing
  call SetBuildAllAM(BUILD_UPGRADE,qty,unitid,-1, BLOC_STD, prio)
endfunction

//============================================================================
// Makes upgrades have a dynamic priority that changes based on the number of
// units that have been built.
// Param : quantity-num to build, unitid-the upgrade, start tier- must be at this tier to research, unitcount- number of units (NOTE must calculate yourself and then pass)
//              maxunits - number of units needed to make priority 100% the value given,
//              prio - Base priority, this actually starts at priority of 1 and steadily increases as number of units goes up
//              tierbonus - adds or subtracts a bonus when you reach later tiers
//============================================================================

function BuildAdvUpgr takes integer qty, integer unitid, integer starttier, integer unitcount, integer maxunits, integer tierprio, integer prio returns nothing
  if tier >= starttier then
    if unitcount > 0 then
      if qty >= tier-starttier+1 then
        call BuildUpgr(tier-starttier + 1, unitid, R2I(LinearInterpolation(0, maxunits, 1, prio + ((tier-starttier)* tierprio) , unitcount)))
      else
        // If tier greater than the start tier and qty is less than the difference between the two
        call BuildUpgr(qty, unitid, R2I(LinearInterpolation(0, maxunits, 1, prio + ((tier-starttier)* tierprio), unitcount)))
      endif
    endif
  endif
endfunction

//============================================================================
// Makes upgrades be built by chance based on number of relevant units. Unlike BuildAdvUpgr the priority of the upgrade stays at the value specified if the random element succeeds.
// Note the random element is re-run very often.
// Note tier bonus priority is a fixed bonus.
// Param : quantity-num to build, unitid-the upgrade,  start tier- must be at this tier to research, unitcount- number of units (NOTE must calculate yourself and then pass)
//              unitper - Number of units to give a 10% chance of building upgrade,
//              max - Maximum chance to research
//              prio - Base priority
//============================================================================

function BuildAdvUpgr2 takes integer qty, integer upgid, integer starttier, integer unitcount, real unitper, integer max, integer prio returns nothing
//set num = (R2I((100 - FoodUsed()) / GetFoodUsed(old_id[])) - 1) * prio_q_inc   // build upgrade priority at priority of unit
  if tier >= starttier then
    if unitcount > unitper then
      if unitper == 0 then
        set unitper = 1
      endif
      if GetRandomInt(1, 100) <= Min(R2I((10*unitcount) / unitper), max) or (unitcount > unitper*2 and GetRandomInt(1, 100) <= max) then
        if qty >= tier-starttier+1 then
          call BuildUpgr(tier-starttier + 1, upgid, prio + ((tier-starttier)*4))
        else
          // If tier greater than the start tier and qty is less than the difference between the two
          call BuildUpgr(qty, upgid, prio + ((tier-starttier)*4))
        endif
      endif
    endif
  endif
endfunction
//============================================================================
function SetBuildUpgrExAM takes integer easy, integer med, integer hard, integer unitid, integer prio returns nothing
  if difficulty == EASY then
    call SetBuildAllAM(BUILD_UPGRADE,easy,unitid,-1, BLOC_STD, prio)
  elseif difficulty == NORMAL then
    call SetBuildAllAM(BUILD_UPGRADE,med,unitid,-1, BLOC_STD, prio)
  else
    call SetBuildAllAM(BUILD_UPGRADE,hard,unitid,-1, BLOC_STD, prio)
  endif
endfunction

//============================================================================
function BuildExpa takes integer qty, integer unitid, integer prio returns nothing
  call SetBuildAllAM(BUILD_EXPAND,qty,unitid,-1, BLOC_STD, prio)
endfunction

//============================================================================
function BuildItem takes integer qty, integer unitid, integer prio returns nothing
  call SetBuildAllAM(BUILD_ITEM,qty,unitid,-1, BLOC_STD, prio)
endfunction

//============================================================================
function BuildFront takes integer qty, integer unitid, integer prio returns nothing
  call SetBuildAllAM(BUILD_UNIT, qty, unitid, -1, BLOC_FRONT, prio)
endfunction

//============================================================================
function BuildAtMine takes integer qty, integer unitid, integer prio returns nothing
  call SetBuildAllAM(BUILD_UNIT, qty, unitid, -1, BLOC_MINE, prio)
endfunction

//============================================================================
// Unlike other build commands priority works backwards so it always builds first units at prio specified then works backwards. This is because otherwise its unknown how many units it will build as its first units will build at variable priority based on number of units it actually builds.
// Min value is in addition to the number built within the food use.
// Builds both units in unison if a mix
function SetBuildReact takes integer food, integer min1, integer unit1, integer min2, integer unit2, real enemy_strength, real strength1, real strength2, integer prio returns nothing
  local integer num1 = R2I(LinearInterpolation(strength1, strength2, I2R(food), 0, enemy_strength)) / Max(GetFoodUsed(old_id[unit1]),1)
  local integer num2 = (food - num1 * GetFoodUsed(old_id[unit1])) / Max(GetFoodUsed(old_id[unit2]),1)
  local integer prio1 = 0
  local integer prio2 = 0
  if min1+num1 >= min2+num2 then
    set prio1 = prio - (min1+num1)*2 // Set priority so first units will be build at `prio` first then decrease
    set prio2 = prio - 1 + (-(min1+num1)+(min2+num2))*2 // Ensure this then builds at same priority as prio1 to interweave the two units by making up the difference
                                                        //if equal second unit is always slightly less priority
  elseif min2+num2 > min1+num1 then
    set prio1 = prio + (-(min2+num2)+(min1+num1))*2
    set prio2 = prio - (min2+num2)*2 - 1
  endif

  if min1 + num1 > 0 then
    call BuildUnit(min1 + num1, unit1, prio1)
  endif
  if min2 + num2 > 0 then
    call BuildUnit(min2 + num2, unit2, prio2)
  endif
endfunction

//============================================================================
function GetTier takes nothing returns integer
  local integer i = tiernum
  loop
    exitwhen i <= 1
    exitwhen TownCountDone(racial_hall[i]) >= 1
    set i = i - 1
  endloop
  return i
endfunction

//============================================================================
// Dynamic Strategy Functions
//============================================================================
function DetermineCounterForce takes nothing returns integer
  local integer strength = 0
  local integer total_strength = 0
  local integer array tstrength
  local integer num_strengths
  local integer j
  local integer random
  local integer maxstr = 0
  local integer secondstr = -1
  local integer thirdstr = -1
  local integer array temps
  local real ally_null = 0    // Blank point
  local string strdebug = " Counter Strengths: "

  set num_strengths = 0
  set j = 0
#INCLUDETABLE <$VER$\Strengths.txt>
  set tstrength[num_strengths] = R2I(RMax(enemy_%1 - (ally_%2 / 20) - (ally_%3 / 20),0)*10)
  //set strength = strength + tstrength[num_strengths]
  set strengthtext[num_strengths] = "%1"
  set num_strengths = num_strengths + 1
#ENDINCLUDE

  loop
    exitwhen j >= num_strengths
    if tstrength[j] > tstrength[maxstr] then
      set thirdstr = secondstr
      set secondstr = maxstr
      set maxstr = j
    elseif secondstr == -1 or tstrength[j] > tstrength[secondstr] then
      set thirdstr = secondstr
      set secondstr = j
    elseif thirdstr == -1 or tstrength[j] > tstrength[thirdstr] then
      set thirdstr = j
    endif
    set j = j + 1
  endloop
  if chosen_counter >= 0 then
    if tstrength[chosen_counter] > 0 then
      call Trace("Persistence counter bonus:" + Int2Str(R2I(strat_persistence / 20)))
      set tstrength[chosen_counter] = tstrength[chosen_counter] + R2I(strat_persistence / 20) // Bonus to current counter
      //set strength = strength + R2I(strat_persistence/200)
    endif
  endif
  //call Trace("Highest Enemy Unit Strength is:" + strengthtext[maxstr] + " with total:" + Int2Str(tstrength[maxstr]))
  set j = 0
  // Remove bad strats to not affect calculations with really low amounts of strength
  loop
    exitwhen j >= num_strengths
    if tstrength[j] < 3 then
      set tstrength[j] = 0
    endif
    set total_strength = total_strength + tstrength[j]
    set strdebug = strdebug + strengthtext[j] + ":" + Int2Str(tstrength[j]) + " - "
    set j = j+1
  endloop

  // No strength so just use a random option
  if total_strength == 0 then
    set no_counter = true
    set j = GetRandomInt(0, num_strengths - 1)
    call Trace("Chosen counter:" + Int2Str(j) + strdebug)
  else
    set no_counter = false
    set j = 0
    set random =GetRandomInt(1, total_strength)
    set strength = 0
    loop
      if j < num_strengths then
        set strength = strength + tstrength[j]
      endif
      exitwhen random <= strength or j >= num_strengths
      set j = j + 1	// Will be the the chosen strength to build units against
    endloop
    if (j == 11) then
      call Trace("!ERROR: Should not get a counter that is not within the strength range!")
    endif
    call Trace("Random Num:" + Int2Str(random) + " Chosen counter:" + Int2Str(j) + strdebug)
  endif
  set strdebug = null
  return j
endfunction

// Resets variables to 0
function ResetDynamicSystem takes nothing returns nothing
#INCLUDETABLE <$VER$\Strengths.txt>
	set totalanti_%1 = 0
	set totalchance_%1 = 0
	set dydistribute_%1 = false
#ENDINCLUDE
	set chosen_counter_unit = 0
endfunction

#INCLUDETABLE <$VER$\Strengths.txt>
function AddUnitToAnti%1 takes integer u, integer percent returns nothing
	if percent > 0 then
		set dyanti_%1[totalanti_%1]= u
		set dychance_%1[totalanti_%1]= percent
		set totalanti_%1 = totalanti_%1 + 1
		set totalchance_%1 = totalchance_%1 + percent
	endif
endfunction
#ENDINCLUDE

#INCLUDETABLE <$VER$\Strengths.txt>
function BuildAnti%1Strength takes nothing returns nothing
	local integer u = 0
	local integer i = 0
	local integer choice
	local integer chance = 0

	if totalchance_%1 > 0 then
		set choice = GetRandomInt(0,totalchance_%1) // Build this unit
		loop
			set chance = chance + dychance_%1[i]
			exitwhen choice <= chance or i >= totalanti_%1
			set i = i + 1
		endloop
		if i >= totalanti_%1 and i > 0 then
			set u = dyanti_%1[i-1]
		else
			set u = dyanti_%1[i]
		endif
		//if GetFoodUsed(old_id[u]) == 0 then
		//	call Trace("Divide By Zero:" + Int2Str(u) + ":" + Int2Str(old_id[u]))
		//endif
		if u > 0 and i <= totalanti_%1 then
			//set food1 = food/GetFoodUsed(old_id[units[choice]])
			call Trace("Dynamic building Unit:" + unitNames[u] + " " +Int2Str(u))
			set dydistribute_%1 = true
			set chosen_counter_unit = u
		endif
	endif

endfunction
#ENDINCLUDE

function DynamicBuildUnit takes integer count, integer prio returns nothing
	local integer num
	if chosen_counter_unit > 0 then
		if IsUnitIdType(old_id[chosen_counter_unit], UNIT_TYPE_STRUCTURE) == false and not (buy_type[chosen_counter_unit] > BT_RACIAL_ITEM and buy_type[chosen_counter_unit] < BT_MERCHANT_ITEM) then // Normal units/upgrades
			set num = R2I((count - FoodUsed()) / Max(GetFoodUsed(old_id[chosen_counter_unit]),1))
			if num > 0 and GetUnitCount(old_id[chosen_counter_unit]) < num then
				call BuildUnit(Min(num, GetUnitCountDone(old_id[chosen_counter_unit]) + 10), chosen_counter_unit, prio)
			endif
		elseif buy_type[chosen_counter_unit] > BT_RACIAL_ITEM and buy_type[chosen_counter_unit] < BT_MERCHANT_ITEM then // A neutral mercenary
			set num = R2I((count - FoodUsed()) / Max(GetFoodUsed(old_id[chosen_counter_unit]),1))
			if num > 0 then
				call BuildUnit(GetUnitCountDone(old_id[chosen_counter_unit]) + 1, chosen_counter_unit, prio)
			endif
		else // structure
			call BuildUnit(1, chosen_counter_unit, prio*2)
		endif
	endif
endfunction

function DynamicStrategySelector takes nothing returns nothing
	local integer strength_count = 0

	#INCLUDETABLE <$VER$\Strengths.txt>
	if chosen_counter == strength_count then
		//call Trace("I'm building anti %1 units")
		call BuildAnti%1Strength()
	endif
	set strength_count = strength_count + 1
	#ENDINCLUDE

endfunction

// Change unit attack mode , eliminating the time required for build and immediately allowing existing units to cope with strength imbalance
// Original intention to control units that AI does not control , but use hard-coding
function ExecuteAirDistribute takes group g, boolean anti returns nothing
  local integer i = GetRandomInt(0, Max(TownCountDone(GARGOYLE),TownCountDone(DRUID_TALON)))
  local integer c = 0  // Allow random retention strength and accelerate cycle
  local integer id = 0
  local integer order = 852155
  local unit u = null
  call Trace("Strength Dynamic Distribute - Air")
  if anti == false then
    set order = 852156
  endif
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null or c >= i
    set id = GetUnitTypeId(u)
    if (id == 'edot' or id == 'edtm') and IsStandardUnit(u) and not IsUnitBuying(u) and IssueImmediateOrderById(u, order) then
      set c = c + 1
    elseif id == 'ugar' and AatpAbility and (GetUnitAbilityLevel(u, 'Batp') == 0) == anti and IsStandardUnit(u) and not IsUnitBuying(u) and IssueImmediateOrderById(u, 852677) then  // check 'ugar' Ability ,  prevent war3 is old ver or map is ROC
      set c = c + 1
    endif
    call GroupRemoveUnit(g, u)
  endloop
  set u = null
endfunction

function StrengthDynamicDistribute takes nothing returns nothing
  local group cg = null
  local group g = CreateGroup()
  call Trace("Strength Dynamic Distribute")
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  set g = SelectByHidden(g, false)
  set g = SelectByAlive(g, true)
  if TownCountDone(DRUID_TALON) > 0 or TownCountDone(GARGOYLE) > 0 then
    set cg = CopyGroup(g, cg)
    call ExecuteAirDistribute(cg, dydistribute_air)  // now just have air , If possible , please add , one strength one function
    call DestroyGroup(cg)
    set cg = null
  endif
  call DestroyGroup(g)
  set g = null
endfunction

//============================================================================
// (AMAI) Harrass Functions
//============================================================================
function InitHarass takes nothing returns nothing
  local integer i = 1
  local group g = null
  set resetharass = true
  loop
    exitwhen i > max_harass_groups
    set harass_size[i] = 0
    set harass_time[i] = -1000000
    set i = i + 1
  endloop
  //call Trace("InitHarass")
  if harass_groups == null then
    set harass_groups = InitHashtable()
  else
    set i = 0
    loop
      exitwhen i > max_harass_groups
      set g = CreateGroup()
      set g = ReturnLivingUnitsOfHashtable(additional_info, i, HARASS_UNITGROUP, g)
      call GroupRecycleGuardPositionInstant(g)
      set i = i + 1
    endloop
    call FlushParentHashtable(harass_groups)
    set harass_groups = InitHashtable()
  endif
  //call Trace("InitHarassEnd")
  set distraction_group = 0
  set resetharass = false
  set g = null
endfunction

function AddHarass takes integer groupnum, integer qty, integer unitid returns nothing
  if groupnum >= max_harass_groups then
    call DisplayToAll("ERROR: A Harass group is set over max allowed:" + Int2Str(groupnum))
  endif
  if groupnum == 0 then
    call DisplayToAll("ERROR: A Harass group has been set to 0")
  endif
  call SaveInteger(harass_groups, groupnum, harass_size[groupnum], qty)
  call SaveInteger(harass_groups, groupnum, harass_size[groupnum] + 1, unitid)
  set harass_size[groupnum] = harass_size[groupnum] + 2
  //call Trace("Add Harrass:" + Int2Str(harass_size[groupnum]))
endfunction

function AddHarassUnittype takes group g, group harasser, integer qty, integer uid, integer key returns group
  local group cg = null
  local unit u = null
  local real player_sum = 0
  local integer i = 0
  set cg = CopyGroup(g,cg)
  loop
    set u = FirstOfGroup(cg)
    exitwhen u == null or i >= qty
    if GetUnitTypeId(u) == old_id[uid] and not IsUnitBuying(u) and IsStandardUnit(u) then  // Will ensure units are not already harassing somewhere else
      call GroupAddUnit(harasser,u)
      set player_sum = player_sum + GetUnitStrength(u)
      call GroupRemoveUnit(g,u)
      set i = i + 1
    endif
    call GroupRemoveUnit(cg,u)
  endloop
  call DestroyGroup(cg)
  set cg = null
  set u = null
  call SaveReal(additional_info, key, START_STRENGTH_TEMP, player_sum)
  return harasser
endfunction

function StartHarass takes integer groupnum, integer harass_target, boolean avoid_towers, real strength_limit, real flee_percent, integer flee_number, real lx, real ly returns nothing
  local integer i = 0
  local integer t = 0
  local integer c = 0
  local group harasser = null
  local group g = null
  local unit u = null
  local integer key = groupnum
  local real strength = 0
  local real getstrength = 0
  local integer qty = 0
  local integer uid = 0
  if LoadInteger(additional_info, key, STATE_RETREAT) == 1 or resetharass then
    // This harass is still running
    return
  endif
  set g = CreateGroup()
  set g = ReturnLivingUnitsOfHashtable(additional_info, key, HARASS_UNITGROUP, g)
  set c = BlzGroupGetSize(g)
  if c >= 12 then
    call DestroyGroup(g)
    set g = null
    return
  endif
  call TraceAll("StartHarass : get harass unit" )
  set t = c
  set harasser = CreateGroup()
  call GroupClear(g)
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  set g = SelectByHidden(g, false)
  set g = SelectByAlive(g, true)
  loop
    exitwhen i >= harass_size[key] or FirstOfGroup(g) == null or t >= 12
    set qty = LoadInteger(harass_groups, key, i)
    set uid = LoadInteger(harass_groups, key, i+1)
    if t + qty > 12 then  // Group Order max control 12 unit
      set qty = 12 - t
      set t = 12
    else
      set t = t + qty
    endif
    if qty > 0 then
      set harasser = AddHarassUnittype(g, harasser, qty, uid, key)
      set strength = strength + LoadReal(additional_info, key, START_STRENGTH_TEMP)
    endif
    set i = i + 2
  endloop
  call DestroyGroup(g)
  set g = null
  if FirstOfGroup(harasser) == null or strength <= 0 then
    call DestroyGroup(harasser)
    set harasser = null
    call TraceAll("StartHarass : get harass unit fail" )
    return
  endif
  if c == 0 then
    set harass_time[key] = ai_time
    call GroupAddGroup(unit_harassing, harasser)
    call FlushChildHashtable(additional_info,key)
    call SaveReal(additional_info, key, START_STRENGTH, strength)
    call SaveBoolean(additional_info, key, AVOID_TOWERS, avoid_towers)
    call SaveReal(additional_info, key, STRENGTH_LIMIT, strength_limit)
    call SaveBoolean(additional_info, key, STATE_ATTACKING, true)
    call SaveInteger(additional_info, key, STATE_RETREAT, 0)
    call SaveReal(additional_info, key, FLEE_PERCENT, flee_percent)
    call SaveInteger(additional_info, key, FLEE_NUMBER, flee_number)
    call SaveInteger(additional_info, key, INVISIBLE_COUNT, 0)
    call SaveReal(additional_info, key, LOCX, lx)
    call SaveReal(additional_info, key, LOCY, ly)
    call SaveInteger(additional_info, key, HARASS_TARGET, harass_target)
    call TraceAll("StartHarass : start harass job " + Int2Str(t))
    call AddUnitsToHashtable(additional_info, key, HARASS_UNITGROUP, harasser)
    call TQAddUnitJob(0, HARASS, key, null)
  else
    call GroupAddGroup(unit_harassing, harasser)
    set g = CreateGroup()
    set g = ReturnLivingUnitsOfHashtable(additional_info, key, HARASS_UNITGROUP, g)
    call GroupAddGroup(g, harasser)
    call AddUnitsToHashtable(additional_info, key, HARASS_UNITGROUP, g)
    call SaveReal(additional_info, key, START_STRENGTH, strength + LoadReal(additional_info, key, START_STRENGTH))
    call TraceAll("StartHarass : add new unit to harass group" )
    call DestroyGroup(g)
    set g = null
  endif
  call DestroyGroup(harasser)
  set harasser = null
endfunction

function GetHarassGroupStrength takes integer groupnum returns real
  local real sum = 0
  local real p = GetPlayerHandicap(ai_player)
  local integer id = 0
  local integer i = 0
  local integer qty = 0
  local integer t = 0
  if not resetharass then
    loop
      exitwhen i >= harass_size[groupnum] or t >= 12
      set id = LoadInteger(harass_groups, groupnum, i)
      set qty = LoadInteger(harass_groups, groupnum, i + 1)
      set t = t + qty
      if t + qty > 12 then
        set qty = 12 - t
        set t = 12
      else
        set t = t + qty
      endif
      set sum = sum + Min(qty, TownCountDone(id)) * GetFoodUsed(old_id[id]) * p
      set i = i + 2
    endloop
  endif
  return sum
endfunction

function Harass takes integer groupnum, integer harass_target, boolean avoid_towers, real strength_limit, real flee_percent, integer flee_number, boolean cond, integer min_time, integer time returns nothing
  local integer aggression = attacking_aggression + added_aggression
  local integer chance = R2I(LinearInterpolation(-15,15,10,100,attacking_aggression + added_aggression))
  // If aggression too low skip this instance of harassing
  if cond and ai_time - harass_time[groupnum] >= time and ai_time >= min_time and not attack_running then
    if GetRandomInt(1, 100) <= chance then
      call StartHarass(groupnum, harass_target, avoid_towers, strength_limit, flee_percent, flee_number, 0, 0)
    else
      set harass_time[groupnum] = ai_time
    endif
  endif
endfunction

//============================================================================
// (AMAI) StartUpgrade
//============================================================================

function StartUpgradeAM takes integer level, integer upgid returns integer
  local integer gold_cost = 0
  local integer wood_cost = 0
  local integer upg_level = GetUpgradeLevel(old_id[upgid])

  if upg_level >= level or ai_time < upgrade_time[upgid] then
    return BUILT_ALL
  endif

  if town_threatened then
    return BUILT_SOME // ignore upgrades and build units instead
  endif

  set gold_cost = GetUpgradeGoldCost(old_id[upgid])
  set wood_cost = GetUpgradeWoodCost(old_id[upgid])

  // Not Enough Res doesn't block on upgrades so always save the gold and wood for it.
  set total_gold = total_gold - gold_cost
  set total_wood = total_wood - wood_cost

  if total_gold < 0 and gold_cost > 0 then
    return NOT_ENOUGH_RES
  endif

  if total_wood < 0 and wood_cost > 0 then
    return NOT_ENOUGH_RES
  endif

  if build_free[needed1[upgid]] >= 1 then // If needed1 building exists then remove gold from total, otherwise ignore and below setupgrade will fail
    set build_free[needed1[upgid]] = build_free[needed1[upgid]] - 1
  endif

  if SetUpgrade(old_id[upgid]) then
    set upgrade_time[upgid] = ai_time + 10
    return BUILT_ALL
  else
    return CANNOT_BUILD
  endif
  return BUILT_SOME
endfunction



//============================================================================
// (AMAI) Utility Functions
//============================================================================

function HasExpanded takes nothing returns boolean
  return TownWithMine() >= 1 or GetMinesOwned() > 1 or TownCountDone(racial_expansion) > 1
endfunction

function GuardSecondaryAM takes integer townid, integer qty, integer unitid, integer prio returns nothing
  if TownHasHall(townid) and TownHasMine(townid) then
    call SecondaryTownAM( townid, qty, unitid, prio )
  endif
endfunction

function DefendTownsEx takes boolean only_done, boolean at_front, integer qty, integer unitid, integer prio returns nothing
  local integer twm = TownWithMine()
  local integer i = twm
  //call Trace("DefendTownsEx TownWithMine:" + Int2Str(twm))
  if not at_front then
    set twm = Max(twm, 1) // Home town is town 0 and exclude if at_front is not set
  else
    set twm = Max(twm, 0)
  endif
  set i = twm
  loop
    exitwhen i > twm + 2
    if TownHasMine(i) and TownCountEx(racial_expansion,only_done,i) > 0 then
      if i <= 0 and at_front then
        call BuildFront(qty, unitid, prio)
      else
        call SecondaryTownAM(i, qty, unitid, prio)
      endif
    endif
    set i = i + 1
  endloop
endfunction

function DefendTowns takes integer qty, integer unitid, integer prio returns nothing
  call DefendTownsEx(false, false, qty, unitid, prio)
endfunction

function DefendTownsDone takes integer qty, integer unitid, integer prio returns nothing
  call DefendTownsEx(true, false, qty, unitid, prio)
endfunction

// Same as defend towns but will also build at the main town and will build at the front locations for that town.
function DefendTownsFront takes integer qty, integer unitid, integer prio returns nothing
  call DefendTownsEx(false, true, qty, unitid, prio)
endfunction

function DefendTownsFrontDone takes integer qty, integer unitid, integer prio returns nothing
  call DefendTownsEx(true, true, qty, unitid, prio)
endfunction

function DefendTownsCond takes integer qty, integer unitid, integer min_dist, integer max_dist, integer min_gold, integer prio returns nothing
  local integer twm = Max(TownWithMine(),1)
  local integer i = twm
  loop
    exitwhen i > twm + 2
    if TownHasMine(i) and town_built[i] and own_town_dist[i] >= min_dist and own_town_dist[i] <= max_dist and GetResourceAmount(own_town_mine[i]) >= min_gold then
      call SecondaryTownAM(i, qty, unitid, prio)
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function BasicExpansionAM takes boolean build_it, integer unitid, integer prio returns nothing
  if build_it and HallsCompleted(unitid) then
    call BuildExpa( TownCount(unitid)+1, unitid, prio )
  endif
endfunction

//============================================================================
function UpgradeAllAM takes integer baseid, integer newid, integer prio returns nothing
  call BuildUnit( TownCountDone(baseid), newid, prio )
endfunction

//============================================================================
//  FoodPool
//============================================================================

function FoodPoolAM takes integer food, boolean weak, integer id1, integer use1, boolean strong, integer id2, integer use2, integer prio returns nothing
  if strong then
    call BuildUnit( (food - use1 * TownCount(id1)) / Max(use2, 1), id2, prio )
  elseif weak then
    call BuildUnit( (food - use2 * TownCount(id2)) / Max(use1, 1), id1, prio )
  endif
endfunction

//============================================================================
//  MeleeTownHall
//============================================================================

function MeleeTownHallAM takes integer townid, integer unitid, integer prio returns nothing
  if TownHasMine(townid) and not TownHasHall(townid) then
    call SecondaryTownAM( townid, 1, unitid, prio )
  endif
endfunction

//============================================================================
// (AMAI) Refresh and Builds
//============================================================================
function AddRefresh takes integer t, integer qty, integer unitid, integer town, integer bloc, integer prio returns nothing
  set t_build_qty[t_build_length] = qty
  set t_build_type[t_build_length] = t
  set t_build_item[t_build_length] = unitid
  set t_build_town[t_build_length] = town
  set t_build_loc[t_build_length] = bloc
  set t_build_prio[t_build_length] = prio
  set t_build_length = t_build_length + 1
endfunction

//============================================================================
function RefreshAllNeeded takes nothing returns nothing
  local integer index = 0
  loop
    exitwhen index >= t_build_length
    call RefreshNeeded(t_build_type[index], t_build_qty[index], t_build_item[index], t_build_town[index], t_build_loc[index], t_build_prio[index])
    set index = index + 1
  endloop
endfunction

//============================================================================
function GetNeutralHero takes integer unitid returns integer

  call Trace("I Want a Tavern Hero")

  if not neutral_available[NEUTRAL_TAVERN] then
    call Trace("No Tavern Available")
    return BUILT_ALL
  endif
  if nearest_neutral[NEUTRAL_TAVERN] == null or neutral_guarded[NEUTRAL_TAVERN] then
    // Returns null if it cannot path to a tavern succesfully
    // Should switch to using transportation to get to it
    // Not Yet Implemented - will instead just build standard heroes
    call Trace("Tavern not usable: Getting standard hero")
    set recalculate_heros = true
    //set first_choosable_hero = ver_neutral_hero_number
    //loop
    //	exitwhen i > hero_number
    //	set all_heroes[i] = all_heroes_copy[i]
    //	set i = i + 1
    //endloop
    //if hero[1] == unitid then
    //	set picked_hero = ChooseFirstHero()
    //elseif hero[2] == unitid then
    //	set hero[1] = GetExistingHero()
    //	call ChooseSecondHero()
    //else
    //	call ChooseRestHeroes()
    //endif
    //if nearest_neutral[NEUTRAL_TAVERN] == null then
    //	call DisplayToAll("No Tavern Reachable")
    //else
    //	call DisplayToAll("Tavern is guarded")
    //endif

    // call set_skills()       NOT YET IMPLEMENTED - if tavern is not passable it just chooses a normal hero, unfortunately it at moment has no skills
    return CANNOT_BUILD
  endif


  if (unitid == hero[1] and hero_built[1]) or (unitid == hero[2] and hero_built[2]) or (unitid == hero[3] and hero_built[3]) then
    call Trace("Try To Resurrect Tavern Hero")
    if SetProduce(1,old_id[unitid],-1) then
      return BUILT_ALL
    else
      return CANNOT_BUILD
    endif
  endif

  if (unitid != hero[1] and unitid != hero[2] and unitid != hero[3]) then
    return CANNOT_BUILD // Mismatch we somehow trying to build a hero that isn't the chosen hero we now want to build
  endif

//   if neutral_sent[NEUTRAL_TAVERN] == null then
//   	set neutral_sent[NEUTRAL_TAVERN] = GetUnitToBuy(nearest_neutral[NEUTRAL_TAVERN])
//   	if neutral_sent[NEUTRAL_TAVERN]  == null then
//		return CANNOT_BUILD
//	endif
//    endif

//	call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "check requirements")
  if TownCountDone(needed1[unitid]) < 1 or (unitid == hero[2] and TownCountDone(needed2[unitid]) < 1) or (unitid == hero[3] and TownCountDone(needed3[unitid]) < 1) then
    call Trace("Requirements failed to get hero")
    return CANNOT_BUILD
  endif


  if not neutral_ordered[NEUTRAL_TAVERN] then
    call Trace("Prepare to Do Tavern Job")
    set neutral_ordered[NEUTRAL_TAVERN] = true
    set neutral_wanted[NEUTRAL_TAVERN] = 1
    call TQAddJob(0, BUY_NEUTRAL_HERO, unitid)
  endif
  return BUILT_SOME
endfunction

//============================================================================
function CheckNotBuiltFrom takes integer unitid returns boolean
#INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "BUILT_FROM"
  if unitid == %1 then
    return false
  endif
#ENDINCLUDE
  return true
endfunction

//============================================================================
function GetBuildLocation takes integer bloc returns location
  local integer i = Max(GetRandomInt(0, front_loc_num - 1),0)
  if bloc == BLOC_MINE and mine_loc != null then
    return mine_loc
  endif
  if front_loc[i] != null then
    return front_loc[i]
  endif
  return home_location
endfunction

//============================================================================
function UpgradeBuilding takes integer qty, integer unitid, integer town, integer bloc returns integer
  local unit u = null
  local group g = CreateGroup()
  local integer current_town = town
  local integer num = 0
  if bloc != BLOC_STD then
    call GroupEnumUnitsInRangeOfLoc(g, GetBuildLocation(bloc), 800, null)
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      if GetOwningPlayer(u) == ai_player and GetUnitTypeId(u) == old_id[needed1[unitid]] and UnitAlive(u) and not IsUnitHidden(u) then
        if IssueImmediateOrderById(u, old_id[unitid]) then
          set num = num + 1
          if num >= qty then
            call DestroyGroup(g)
            set g = null
            set u = null
            return BUILT_ALL
          endif
        endif
      endif
      call GroupRemoveUnit(g,u)
    endloop
  endif
  if town == -1 then
    set current_town = 0
  endif
  if own_town_loc[current_town] != null then
    call GroupClear(g)
    call GroupEnumUnitsInRangeOfLoc(g, own_town_loc[current_town], 2000, null)
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      if GetOwningPlayer(u) == ai_player and GetUnitTypeId(u) == old_id[needed1[unitid]] and UnitAlive(u) and not IsUnitHidden(u) then
        if IssueImmediateOrderById(u, old_id[unitid]) then
          set num = num + 1
          if num >= qty then
            call DestroyGroup(g)
            set g = null
            set u = null
            return BUILT_ALL
          endif
        endif
      endif
      call GroupRemoveUnit(g,u)
    endloop
  endif
  call DestroyGroup(g)
  set g = null
  if town != -1 then
    if num == 0 then
      return CANNOT_BUILD
    else
      return BUILT_SOME
    endif
  endif
  set g = CreateGroup()
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetUnitTypeId(u) == old_id[needed1[unitid]] and UnitAlive(u) and not IsUnitHidden(u) then
      if IssueImmediateOrderById(u, old_id[unitid]) then
        set num = num + 1
        if num >= qty then
          call DestroyGroup(g)
          set g = null
          set u = null
          return BUILT_ALL
        endif
      endif
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  if num == 0 then
    return CANNOT_BUILD
  else
    return BUILT_SOME
  endif
endfunction

//============================================================================
function BuildAtSpecialLoc takes integer unitid, integer town, integer bloc returns integer
  local unit u = null
  local unit spaceunit = null
  local unit spaceunit2 = null  //utemp is seat, leave a passage , unit can ensure correct position
  local location l = null
  local unit peon = GetExpansionPeon()
  local location loc = GetBuildLocation(bloc)
  local real d = 0
  local integer i = 0
  if peon == null or not UnitAlive(peon) then
    set peon = GetExpansionPeon2(peon)	// In case we can't get the expansion peon
  endif
  if peon == null then
    call Trace("BuildatspecialLoc: No peon available")
    return CANNOT_BUILD
  endif
  set spaceunit = CreateUnitAtLoc(Player(PLAYER_NEUTRAL_PASSIVE), old_id[unitid], loc, 270.0)
  if bloc != BLOC_MINE then
    set spaceunit2 = CreateUnitAtLoc(Player(PLAYER_NEUTRAL_PASSIVE), old_id[unitid], loc, 270.0)
    set u = CreateUnitAtLoc(Player(PLAYER_NEUTRAL_PASSIVE), old_id[unitid], loc, 270.0)
    call RemoveUnit(spaceunit2)
    set spaceunit2 = null
  else
    set u = CreateUnitAtLoc(Player(PLAYER_NEUTRAL_PASSIVE), old_id[unitid], loc, 270.0)
  endif
  call RemoveUnit(spaceunit)
  set spaceunit = null
  set l = GetUnitLoc(u)
  call RemoveUnit(u)
  set u = null
  set loc = null
  if l == null then
    //call Trace("BuildatspecialLoc: No location found")
    //call RemoveLocation(l)
    //set l = null
    set peon = null
    return CANNOT_BUILD
  else
    if bloc == BLOC_FRONT then
      set d = DistanceBetweenPoints(l,home_location)
      if d >= front_base_distance + 400 or d < 600 then
        call Trace("BuildatspecialLoc: Build loc too far or close, fix build loc")
        if front_loc_num > 0 then
          set i = GetRandomInt(0, front_loc_num - 1)
          call RemoveLocation(l)
          if front_loc[i] != null then
            set l = AIGetProjectedLoc(front_loc[i], home_location, 200, 0)
          else
            set l = AIGetProjectedLoc(front_loc[0], home_location, GetRandomInt(100, 200), GetRandomInt(-90, 90))
          endif
        endif
      endif
    endif
    call IssuePointOrderByIdLoc(peon, old_id[unitid], l) // Always returns false whether successful or not
  endif
  call RemoveLocation(l)
  set l = null
  set peon = null
  call Trace("BuildatspecialLoc: build done")
  return BUILT_SOME
endfunction

//============================================================================
// AMAI Build Codes
//============================================================================
function StartUnitAM takes integer ask_qty, integer unitid, integer town, integer bloc, integer prio, integer max_order returns integer
    local integer have_qty = 0
    local integer need_qty = 0
    local integer afford_gold = 0
    local integer afford_wood = 0
    local integer afford_food = 0
    local integer afford_qty = 0
    local integer gold_cost = 0
    local integer wood_cost = 0
    local integer food_cost = 0
    local integer cost_qty = 0
    local integer n1 = needed1[unitid]
    local real daytime = GetFloatGameState(GAME_STATE_TIME_OF_DAY)
    local integer nn = GetNeutralNumber(unitid)
    local integer i = 1

    // If specified town not built ignore town specific requests
    if town != -1 and (not town_built[town] or (unitid != racial_expansion and TownCountTown(racial_expansion, town) <= 0)) then
      return BUILT_ALL
    endif

    // If merc must wait for appropiate time to buy, otherwise ignore
    if buy_type[unitid] > BT_RACIAL_ITEM and (ai_time < available_time[unitid] or (neutral_guarded[nn] and ((daytime >= 5 and daytime < 18) or not neutral_night_buy[nn] or (buy_type[unitid] != BT_NEUTRAL_HERO and not ver_mercs_night_buy)))) then
      return BUILT_SOME
    endif

    // Previous upgrade will set some time aside while upgrading, during which time requests are ignored till time has expired
    if needed3[unitid] == UPGRADED and town != -1 and ai_time < available_time[unitid] then
      return BUILT_SOME
    endif

    if bloc == BLOC_FRONT and not front_locs_computed then
      return BUILT_SOME
    endif

    if bloc == BLOC_MINE and mine_loc == null then
      return BUILT_SOME
    endif

    // Used so lower priority town hall upgrades only occur when all peons at a higher priority have been built
    if unitid == racial_peon then
      set neededPeons = neededPeons + ask_qty
    endif

    //------------------------------------------------------------------------
    // if we have all we're asking for then make nothing
    //
    set have_qty = TownCountTown(unitid,town)

    if have_qty >= ask_qty then
      return BUILT_ALL
    endif
    set need_qty = ask_qty - have_qty

    //------------------------------------------------------------------------
    // limit the qty we're requesting to the amount of resources available
    //
    set gold_cost = GetUnitGoldCost2(unitid) // When hero is free this is returning 0 correctly
    set wood_cost = GetUnitWoodCost2(unitid)
    set food_cost = GetFoodUsed(old_id[unitid])

    if gold_cost == 0 then
      set afford_gold = need_qty
    else
      set afford_gold = total_gold / gold_cost
    endif
    if afford_gold < need_qty then
      set afford_qty = afford_gold
    else
      set afford_qty = need_qty
    endif

    if wood_cost == 0 then
      set afford_wood = need_qty
    else
      set afford_wood = total_wood / wood_cost
    endif
    if afford_wood < afford_qty then
      set afford_qty = afford_wood
    endif

    if food_cost == 0 then
      set afford_food = need_qty
    else
      set afford_food = total_food / food_cost
    endif
    if afford_food < afford_qty then
      set afford_qty = afford_food
    endif

    // If at food limit skip units in build queue rather than block
    if food_cost > 0 and need_qty > 0 and food_cost > total_food then
      return CANNOT_BUILD
    endif

    // Check if allowed to go over upkeep limit otherwise restrict qty
    if (food_cost > 0) then
      set afford_food = ApplyUpkeepCheck(afford_food, ver_food_limit - total_food, food_cost, afford_qty)
      call ApplyUpkeepSaving()
      call UpdateLastUpkeep()
    endif

    set afford_qty = Min(afford_qty, afford_food)

    // if not enough resources gold, wood, food or spare buildings to build even 1 unit then block
    if afford_qty <= 0 then
      return NOT_ENOUGH_RES
    endif
    //if (need_qty > 3 and afford_qty + have_qty < 3 and have_qty == 0) then
    //  return NOT_ENOUGH_RES // For large build orders ensure built some before building the next items in queue
    //endif

    if (buy_type[unitid] == BT_UNIT or buy_type[unitid] == BT_HERO) and CheckNotBuiltFrom(unitid) then
      // If enough needed1 building exists and isn't building something else then remove gold from total for what we can build right now
      // Note doesn't actually matter to much as SetProduce will only build what it can, but it would always return fail, but this ensures we can return success partly
      if build_free[n1] >= need_qty then
        set cost_qty = need_qty
        set build_free[n1] = build_free[n1] - need_qty
      else
        set cost_qty = build_free[n1]
        set build_free[n1] = 0
      endif
      // Set various variables for evaluating additional factory buildings
      if unitid != racial_peon then
        set gold_sum[n1] = gold_sum[n1] + need_qty * gold_cost
        set build_time_sum[n1] = build_time_sum[n1] + need_qty * GetUnitBuildTime(old_id[unitid])
        set build_num[n1] = build_num[n1] + need_qty
        set prio_sum[n1] = prio_sum[n1] + need_qty * prio
      endif
    else
      set cost_qty = need_qty
    endif
    set afford_qty = Min(cost_qty, afford_qty) // Apply what we can actually build from free buildings this time, this occurs after resource limit so it doesn't block as may already be building this unit

    // If haven't started building this unit ever then block
    //if afford_qty <= 0 and have_qty == 0 then
    //  return NOT_ENOUGH_RES
    //endif

    set total_gold = total_gold - gold_cost * afford_qty
    set total_wood = total_wood - wood_cost * afford_qty
    set total_food = total_food - food_cost * afford_qty

    //------------------------------------------------------------------------
    // give the AI a chance to make the units (it may not be able to right now
    // but that doesn't stop us from trying other units after this as long
    // as we have enough money to make this AND the needed, unbuilt ones)
    //

    if needed3[unitid] == UPGRADED then
      if needed1[unitid] != 0 and GetUnitCountEx(needed1[unitid],true,town) < 1 then
        return CANNOT_BUILD
      endif
    endif

    // Don't upgrade if there is a higher priority need for peons first and the racial hall required to build them, but we are requesting a lower priority hall upgrade
    if IsRacialHallId(unitid, 2) and IsRacialHallId(needed1[racial_peon], 1) then
      if Min(neededPeons, 10) > TownCountDone(racial_peon) and TownCountDone(racial_hall[1]) == 1 then  // Includes upgraded halls due to Add to counting
        return CANNOT_BUILD
      endif
    endif

    // If research has modified the unit permanently into a different unit
  #INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "UPGRADED_TO"
    if unitid == %1 and GetUpgradeLevel(o%4) >= %5 then
      if SetProduce(afford_qty,o%3,town) then
        if (afford_qty + have_qty == need_qty) then
          return BUILT_ALL
        else
          return BUILT_SOME
        endif
      else
        return CANNOT_BUILD
      endif
    endif
  #ENDINCLUDE

    // Unit must be built/transformed from another unit
  #INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "BUILT_FROM"
    if unitid == %1 then
      if GetUpgradeLevel(o%4) >= %5 then
        if ConvertUnits(afford_qty + have_qty, o%3) then
          if (afford_qty + have_qty == need_qty) then
            return BUILT_ALL
          else
            return BUILT_SOME
          endif
        else
          return CANNOT_BUILD
        endif
      else
        return CANNOT_BUILD
      endif
    endif
  #ENDINCLUDE

    if buy_type[unitid] == BT_NEUTRAL_HERO then
      return GetNeutralHero(unitid)
    endif

    if unitid == racial_rushcreep and not br_rush_built then
      set br_rush_built = true //just run once
      if CreepsOnMap() and not towerrush then
        if BuildBRAtCreep() then
          return BUILT_SOME  // Success
        endif
      endif
    endif

    if buy_type[unitid] > BT_RACIAL_ITEM and buy_type[unitid] < BT_MERCHANT_ITEM then
      if not neutral_ordered[nn] and not attack_running and nearest_neutral[nn] != null then
        set neutral_ordered[nn] = true
        set neutral_wanted[nn] = afford_qty + have_qty
        call TQAddJob(0, BUY_NEUTRAL, unitid)
      endif
      return BUILT_SOME
    endif

    if needed3[unitid] == UPGRADED and buy_type[unitid] == BT_BUILDING then
      return UpgradeBuilding(afford_qty, unitid, town, bloc)
    endif

    // Intentionally not using have_qty as the build lumber mill at base can not be picked up by the count as it builds somewhere else
    if unitid == racial_lumber and town < 1 and GetUnitCount(old_id[unitid]) < 1 then
      if BuildLumberMillAtBase() then
        return BUILT_SOME
      else
        return CANNOT_BUILD
      endif
    endif

    // Shouldn't be needed as needed extra handled elsewhere, and setproduce will just fail already when it can't build it
    //if not CanBuildUnit(unitid) then
    //  return CANNOT_BUILD
    //endif

    if bloc != BLOC_STD then
      if BuildAtSpecialLoc(unitid, town, bloc) != CANNOT_BUILD then   // This only occurs if no peon could be obtained
        return BUILT_SOME
      endif
    endif

    if SetProduce(afford_qty,old_id[unitid],town) then
      if needed3[unitid] == UPGRADED then
        set available_time[unitid] = ai_time + GetUnitBuildTime(old_id[unitid]) / 5 + 1
      endif
      if (afford_qty + have_qty == need_qty) then
        return BUILT_ALL
      else
        return BUILT_SOME
      endif
    else
      return CANNOT_BUILD
    endif
endfunction

//============================================================================
function ConstructExpansion takes unit peon, integer unitid returns boolean
  local unit u = null
  local real x = 0
  local real y = 0
  if ai_time > exp_loc_cache_timeout then
    set exp_loc_cache_timeout = ai_time + 4
    set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), unitid, GetUnitX(current_expansion), GetUnitY(current_expansion), 270.0)
    set x = GetUnitX(u)
    set y = GetUnitY(u)
    call RemoveUnit(u)
    set u = null
    if DistanceBetweenPoints_dd(Location(x, y), GetUnitLoc(current_expansion)) <= race_max_expa_mine_distance then
      call TQAddUnit2Job(2 * sleep_multiplier, BUILD_EXPANSION, 0, peon, current_expansion)
      call IssuePointOrderById(peon, unitid, x, y)
      return true
    endif
  endif
  return false
endfunction

//============================================================================
function IsWaterExpansion takes unit u returns boolean
  //local integer i = 0
  // loop
  //   exitwhen i == water_expansion_list_length
  //   if water_expansion_list[i] == u then
  //     return true
  //   endif
  //   set i = i + 1
  // endloop
  return IsUnitInGroup(u,water_expansion)
endfunction

//============================================================================
function BuildMovePeonZeppelin takes unit peon, unit target, boolean waterexp returns boolean
  local real d = race_max_expa_mine_distance
  if IsUnitInTransport(peon, build_zeppelin) then
    if DistanceBetweenUnits(build_zeppelin, target) < d then
      call IssueImmediateOrder(build_zeppelin, "stop")
      call IssueTargetOrder(build_zeppelin, "unload", peon)
      call TQAddUnitJob(0.5, RESET_GUARD_POSITION, 80, build_zeppelin)
      call Sleep(0.5)  // unload time
      return true
    endif
    call IssuePointOrder(build_zeppelin, "move", GetUnitX(target) + ISign() * GetRandomReal(200,300), GetUnitY(target) + ISign() * GetRandomReal(200,300))
  else
    if not waterexp then
      set d = d * 2
    endif
    if DistanceBetweenUnits(peon, target) < d then
      call RecycleGuardPosition(build_zeppelin)
      call GroupRemoveUnit(unit_zepplin_move, build_zeppelin)
      return true
    endif
    call IssueTargetOrder(peon, "smart", build_zeppelin)
  endif
  return false
endfunction

//============================================================================
function StartExpansionAM takes integer qty, integer hall returns integer
  local integer count = TownCount(hall)
  local integer countdone = TownCountDone(hall)
  local unit    u = null
  local integer gold_cost = 0
  local integer wood_cost = 0
  local boolean f = false
  local boolean w = false
  if race_manual_loading then  //check actual number mines
    set count = TownCount(race_manual_loading_mine)
    set countdone = TownCountDone(race_manual_loading_mine)
  elseif race_uses_mine_expansion then
    set count = TownCount(racial_expansion)
    set countdone = TownCountDone(racial_expansion)
  elseif first_town_mine > 0 then
    set countdone = Min(countdone, GetMinesOwned())
  endif
  if first_town_mine > 1 or (count == 0 and first_town_mine < 2 and GetMinesOwned() > 0 and (race_manual_loading or race_uses_mine_expansion)) then
    set f = MultipleMinefix()
    if first_town_mine > 1 and f then
      call Trace("AMAIStartexpa: MultiMineFix")  // home_location have multiple mine , fix GetMinesOwned bug
      return BUILT_ALL
    endif
    call Trace("AMAIStartexpa: Try ReBuilt Home Mine")  // no take home near mine forced rebuild home mine when UD mine or ELF mine lost , but not affect expansion
  endif
  if countdone >= qty then
    call Trace("AMAIStartexpa: Built All Expansions")
    return BUILT_ALL
  endif
  if count > countdone then
    call Trace("AMAIStartexpa: All Expansions being built")
    return BUILT_SOME
  endif

  if town_threatened then
    call Trace("AMAIStartexpa: Town threatened")
    return CANNOT_BUILD
  endif

  if current_expansion == null then
    call Trace("AMAIStartexpa: Expansion Not Found")
    return CANNOT_BUILD
  endif
  if CheckExpansionTaken(current_expansion) then
    call Trace("AMAIStartexpa: Expansion Taken by someone else")
    if current_expansion != not_taken_expansion then
      set current_expansion = null
    endif
    return CANNOT_BUILD
  endif
  // call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Expansion Taken Checked")

  // call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Expansion choosen")
  set gold_cost = GetUnitGoldCost2(hall)
  set wood_cost = GetUnitWoodCost2(hall)
  if item_expanding then
    set gold_cost = gold_price[race_item_expansion_item_id]
    set wood_cost = wood_price[race_item_expansion_item_id]
  endif
  if item_expanding and not item_job_running then
    set not_taken_expansion = current_expansion
    call TQAddJob(1, ITEM_EXPANSION, 0)
  endif

  set total_gold = total_gold - gold_cost
  set total_wood = total_wood - wood_cost

  set take_exp = (GetExpFoe(u) != null)
  set u = null

  if ancient_expanding or militia_expanding then
    return BUILT_SOME // Just safety check to prevent normal expansion running while these are both running
  endif

  if take_exp then
    if GetOwnStrength() < GetExpansionStrength() then
      // Not strong enough to take mine so don't save gold and wood for expansion, use to build more troops instead
      set total_gold = total_gold + gold_cost
      set total_wood = total_wood + wood_cost
    endif
    call Trace("AMAIStartexpa: Need to remove creeps from expansion")
    return BUILT_SOME // If creeps need clearing save the gold but don't block building at the moment as may need troops
  endif

  if total_gold < 0 and gold_cost > 0 then
    return NOT_ENOUGH_RES
  endif
  if total_wood < 0 and wood_cost > 0 then
    return NOT_ENOUGH_RES
  endif

  if item_expanding then
    return BUILT_SOME
  endif

  // call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Expansion rescources sorted")
  if expansion_peon == null or not UnitAlive(expansion_peon) then
    set expansion_peon = GetExpansionPeon()
    if expansion_peon == null or not UnitAlive(expansion_peon) then
      set expansion_peon = GetExpansionPeon2(expansion_peon)
    endif
  endif
  //  call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Peon Got")
  set f = IsUnitInGroup(current_expansion, far_expansion)
  set w = IsWaterExpansion(current_expansion)

  if expansion_peon != null and UnitAlive(expansion_peon) then
    if (w or f) and TownCountDone(neutral_zeppelin) > 0 then
      if build_zeppelin == null or not UnitAlive(build_zeppelin) then
        if build_zeppelin != null then
          call GroupRemoveUnit(unit_zepplin_move, build_zeppelin)
        endif
        set build_zeppelin = GetUnusedZeppelinNearUnit(build_zeppelin, expansion_peon)
        if build_zeppelin == null then
          call Trace("AMAIStartexpa: No Zeppelin found for transporting peon")
        else
          call GroupAddUnit(unit_zepplin_move, build_zeppelin)
          call RemoveGuardPosition(build_zeppelin)
          call TQAddUnitJob(GetTimeToReachUnit(build_zeppelin, current_expansion) + GetTimeToReachUnit(build_zeppelin, expansion_peon) + 30, RESET_GUARD_POSITION, 50, build_zeppelin)  // Prevent failure and failure to recover midway
        endif
      endif
      if (w and build_zeppelin == null) then
        call Trace("AMAIStartexpa: Water expansion required waiting to create a zeppelin")
        return CANNOT_BUILD
      endif
      if build_zeppelin != null then
        if not BuildMovePeonZeppelin(expansion_peon, current_expansion, w) then
          call Trace("AMAIStartexpa: Expanding via a zeppelin")
          return BUILT_SOME
        endif
        call RemoveGuardPosition(expansion_peon)  //Prevent being controll away from mine
        call TQAddUnitJob(2, RESET_GUARD_POSITION, 50, expansion_peon)
        call IssuePointOrder(expansion_peon, "move", GetUnitX(current_expansion), GetUnitY(current_expansion))
      endif
    endif
    if race_uses_mine_expansion then
      call TQAddUnit2Job(2 * sleep_multiplier, BUILD_EXPANSION, 0, expansion_peon, current_expansion)
      call IssueTargetOrderById(expansion_peon, old_id[hall], current_expansion)
    else
      call ConstructExpansion(expansion_peon,old_id[hall])
    endif
  endif
  //  call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, "Expansion Finished")
  return BUILT_SOME
endfunction

//============================================================================
function CheckRaceCanBuy takes integer id, race r returns boolean
  if id == sanctuary_item and r != RACE_HUMAN then
    return false
  elseif id == preservation_item and r != RACE_NIGHTELF then
    return false
  endif
  return true
endfunction

// Set up to buy an item
function BuyItem takes integer qty, integer id returns boolean
  if attack_running then
    if towerrush then
      if tower_attack_run and (TownCountDone(racial_shop) < 2 or race_tower_shop < 1 or buy_type[id] != BT_RACIAL_ITEM) then
        return false  // TR need buy item , and TR will build more shop , so have near shop can buy
      endif
    else
      return false
    endif
  endif
  if shop_ordered then
    //call Trace("Already ordered to get an item")
    return true
  endif
  if buy_type[id] == BT_RACIAL_ITEM then
    if not CheckRaceCanBuy(id, GetPlayerRace(ai_player)) then
      return false
    endif
    if shop_unit == null or not UnitAlive(shop_unit) or GetOwningPlayer(shop_unit) != ai_player then
      set shop_unit = GetOneOfId(shop_unit, ai_player, old_id[racial_shop])
    endif
    set shop_distance_limit = raceshop_distance_limit
  else
    set shop_unit = nearest_neutral[NEUTRAL_MERCHANT]
    set shop_distance_limit = merchant_distance_limit
  endif
  if shop_unit != null then
    set shop_wanted = qty
    set shop_ordered = true
    call TQAddJob(0, BUY_ITEM, id)
    return true
  endif
  return false
endfunction

function BuyAllyShopItem takes integer qty, integer id returns boolean
  local group g = null
  local unit u = null
  local integer i = 0
  local integer m = 0
  if CaptainInCombat(true) or attack_running then
    return false
  endif
  if shop_ordered then
    //call Trace("Already ordered to get an item")
    return true
  endif
  loop
    exitwhen i < 0 or i >= c_ally_total
    set m = GetRandomInt(0, Max(c_ally_total - 1, 0))
    set i = i + 1
    if GetPlayerSlotState(ally_force[m]) == PLAYER_SLOT_STATE_PLAYING then
      set i = -1
    endif
  endloop
  set shop_unit = null
  if i < 0 and CheckRaceCanBuy(id, GetPlayerRace(ally_force[m])) then
    set g = CreateGroup()
    call GroupEnumUnitsOfPlayer(g, ally_force[m], null)
    set m = R2I(c_ally_total / 2)
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null or i > m
      if GetUnitAbilityLevel(u, 'Aall') > 0 and IsUnitType(u, UNIT_TYPE_STRUCTURE) and UnitAlive(u) and not IsUnitHidden(u) then  // select ally shop , use JOB TrackTown record ally shop is best, but worried about affecting efficiency , if use new JOB then too wasteful
        if shop_unit == null or GetRandomInt(0, 1) > 0 then
          set shop_unit = u  // get Random shop
          set i = i + 1
        endif
      endif
      call GroupRemoveUnit(g, u)
    endloop
    call DestroyGroup(g)
    set g = null
    set u = null
  endif
  if shop_unit != null then
    call Trace("Buying item form ally shop")
    set shop_wanted = qty
    set shop_distance_limit = raceshop_distance_limit
    set shop_ordered = true
    call TQAddJob(0, BUY_ITEM, id)
    return true
  endif
  return false
endfunction

//============================================================================
// Buy item but ignore all buffer changes to players gold. Buy as fast as possible
function StartEmergencyItem takes integer ask_qty, integer itemid returns integer
  local integer gold_cost = gold_price[itemid]
  local integer wood_cost = wood_price[itemid]
  local integer have_qty = GetItemNumber(itemid)
  local real daytime = GetFloatGameState(GAME_STATE_TIME_OF_DAY)
  local integer gold = GetGold()
  local integer wood = GetWood()

  if have_qty >= ask_qty or (buy_type[itemid] == BT_MERCHANT_ITEM and not neutral_available[NEUTRAL_MERCHANT]) then
    return BUILT_ALL
  endif

  if nearest_neutral[NEUTRAL_MERCHANT] == null and buy_type[itemid] == BT_MERCHANT_ITEM then
    call Trace("No merchant available to buy emergency item")
    // Cannot path so will require transporter
    // NYI
    return BUILT_ALL
  endif

  if available_time[itemid] > ai_time or (buy_type[itemid] == BT_MERCHANT_ITEM and neutral_guarded[NEUTRAL_MERCHANT] and ((daytime >= 5 and daytime < 18) or not neutral_night_buy[NEUTRAL_MERCHANT])) then
    return BUILT_SOME
  endif

  if (needed1[itemid] != 0 and TownCountDone(needed1[itemid]) < 1) or (needed2[itemid] != 0 and TownCountDone(needed2[itemid]) < 1) or (needed3[itemid] != 0 and TownCountDone(needed3[itemid]) < 1) then
    call Trace("Emergency item not enough requirements to buy item")
    set build_emergency_healing_item = itemid
    return CANNOT_BUILD
  endif

  set gold = gold - gold_cost
  set wood = wood - wood_cost

  if gold < 0 and gold_cost > 0 then
    return NOT_ENOUGH_RES
  endif

  if wood < 0 and wood_cost > 0 then
    return NOT_ENOUGH_RES
  endif

  if BuyItem(have_qty + 1, itemid) then
    call Trace("Buying emergency item")
    return BUILT_SOME
  else
    set build_emergency_healing_item = itemid
    return CANNOT_BUILD
  endif
  return BUILT_SOME
endfunction

//============================================================================
function StartItem takes integer ask_qty, integer itemid returns integer
  local integer gold_cost = gold_price[itemid]
  local integer wood_cost = wood_price[itemid]
  local integer have_qty = GetItemNumber(itemid)
  local real daytime = GetFloatGameState(GAME_STATE_TIME_OF_DAY)

  if have_qty >= ask_qty or (buy_type[itemid] == BT_MERCHANT_ITEM and not neutral_available[NEUTRAL_MERCHANT]) then
    return BUILT_ALL
  endif

  if nearest_neutral[NEUTRAL_MERCHANT] == null and buy_type[itemid] == BT_MERCHANT_ITEM then
    // Cannot path so will require transporter
    // NYI
    return BUILT_ALL
  endif

  if available_time[itemid] > ai_time or GetSlotsFree() <= 0 or (buy_type[itemid] == BT_MERCHANT_ITEM and neutral_guarded[NEUTRAL_MERCHANT] and ((daytime >= 5 and daytime < 18) or not neutral_night_buy[NEUTRAL_MERCHANT])) then
    return BUILT_SOME
  endif

  if (needed1[itemid] != 0 and TownCountDone(needed1[itemid]) < 1) or (needed2[itemid] != 0 and TownCountDone(needed2[itemid]) < 1) or (needed3[itemid] != 0 and TownCountDone(needed3[itemid]) < 1) then
    return CANNOT_BUILD
  endif

  if attack_running then
    return CANNOT_BUILD // Don't reserve gold and wood for items when we are not going to be be able to buy right now
  endif

  set total_gold = total_gold - gold_cost
  set total_wood = total_wood - wood_cost

  if total_gold < 0 and (gold_cost > 0) then
    return NOT_ENOUGH_RES
  endif

  if total_wood < 0 and (wood_cost > 0) then
    return NOT_ENOUGH_RES
  endif
  if BuyItem(have_qty + 1, itemid) then
    call Trace("buy item")
    return BUILT_SOME
  else
    if build_emergency_healing_item != itemid and IsHealingItem(old_id[itemid]) and buy_type[itemid] == BT_RACIAL_ITEM and c_ally_total > 0 and GetGold() > 1000 then
      if BuyAllyShopItem(have_qty + 1,itemid) then  //return false just run next time
        call Trace("buy item from ally")
        return BUILT_SOME
      endif
    endif
    return CANNOT_BUILD
  endif
  return BUILT_SOME
endfunction

//============================================================================
function BuildFarms takes integer qty returns nothing
  if TownCount(racial_farm) < race_farms_at_mine then
    call BuildAtMine(Min(TownCountDone(racial_farm) + qty, max_farms), racial_farm, farm_prio)
  elseif race_build_farms_front and front_locs_computed and TownCountDone(racial_farm) <= race_farms_front_limit + 1 and TownCountDone(racial_farm) >= 1 then
    call BuildFront(Min(TownCountDone(racial_farm) + qty, max_farms), racial_farm, farm_prio)
  else
    call BuildUnit(Min(TownCountDone(racial_farm) + qty, max_farms), racial_farm, farm_prio)
  endif
endfunction

//============================================================================
function FarmBuilder takes nothing returns nothing
  if FoodCap() >= ver_food_limit then
    return
  endif
  if FoodSpace() <= farm_food2 then
    call BuildFarms(2)
  elseif FoodSpace() <= farm_food then
    call BuildFarms(1)
  endif
endfunction

//============================================================================
function MercBuilder takes integer unitid1, integer unitid2 returns nothing
  local integer i = unitid1
  if FoodSpace() > 4 and GetGold() > 400 and GetWood() > 300 then
    if GetRandomInt(0, 4) < difficulty or i < 1 then
      set i = unitid2
    endif
    if i > 0 and buy_type[i] == BT_MERC and neutral_available[NEUTRAL_MERC_CAMP] then
      call Trace("Build Merc")
      call BuildUnit(1, i, 25 + tier * 10)
    endif
  endif
endfunction

function DragonAndMercBuilder takes nothing returns nothing
  local integer i = dragons[Min(tier, dragon_number)]
  local boolean b = true
  if GetGold() > 600 and GetWood() > 500 and FoodSpace() > tier * 3 then
    if GetRandomInt(0, 4) > difficulty or i < 1 then
      set i = merc_unit[GetRandomInt(0, Max(merc_number - 1, 0))]
      set b = false
    endif
    if i > 0 and neutral_available[GetNeutralNumber(i)] then
      call Trace("Build Dragon And Merc : buy Dragon - " + B2S(b))
      call BuildUnit(1, i, 25 + tier * 10)
    endif
  endif
endfunction

//============================================================================
function ShredderBuilder takes nothing returns nothing
  local real g = GetGold()
  local real w = Max(GetWood(),1)
  local real gdivw = g / w
  if neutral_available[NEUTRAL_OBSERVATORY] and gdivw > 4 and g - w > 500 and w < 550 and g > GetUnitGoldCost2(neutral_shredder) and w > GetUnitWoodCost2(neutral_shredder) and ai_time - available_time[neutral_shredder] >= -1 then
    if (race_has_ghouls) then
      call BuildUnit(1, neutral_shredder, Max(ghoul_prio - 4,1))
    else
      call BuildUnit(1, neutral_shredder, Max(peon_prio - 10,1))
    endif
  endif
endfunction

//============================================================================
function BuildPeons takes integer number returns nothing
  if towerrush and (TownCount(hero[1]) + TownCount(hero[2]) + TownCount(hero[3])) != 0 then  // towerrush compensate
    if not race_has_ghouls and TownCount(racial_peon) < 14 then
      set number = number + race_tower_peon
    elseif race_has_ghouls and TownCount(racial_peon) < 5 + race_tower_peon then
      set number = number + race_tower_peon
    endif
    if race_tower_bypeon == true then
      set number = Min(TownCountDone(racial_expansion) * ver_optimal_gold + 6, number + 2)
    endif
  endif
  if first_town_mine > 1 and not towerrush then  // startloc have more mine compensate
    if not race_manual_loading and not race_uses_mine_expansion and not race_has_ghouls then
      set number = Min(TownCountDone(racial_expansion) * ver_optimal_gold + 6, number + 3)
    endif
  endif
  call BuildUnit(number, racial_peon, peon_prio)
endfunction

function BuildGhouls takes integer number returns nothing
  if towerrush and TownCount(racial_ghoul) < 8 then  // towerrush compensate
    set number = number + 1
  endif
  call BuildUnit(number, racial_ghoul, ghoul_prio)
endfunction

//============================================================================
function PeonBuilder takes nothing returns nothing
  local integer mo = GetMinesHarvested()
  local integer sc = 0
  local real w = GetWood()
  if race_uses_shredder and neutral_shredder != 0 then
    set sc = TownCount(neutral_shredder)
    call ShredderBuilder()
  endif
  //if w <= maximum_peon_wood then
  //  call BuildPeons( peon_1_mine_number * mo + Max(max_lumber_peons - shredder_peon_count*sc, 1 )  )  // number of peons per mine + wood peons
  //elseif w >= minimum_peon_wood then
  //  call BuildPeons( peon_1_mine_number * mo + Max(min_lumber_peons - shredder_peon_count*sc, 1 )  )
  //else
  //  call BuildPeons( peon_1_mine_number * mo + Max(Max(min_lumber_peons, R2I(I2R(max_lumber_peons) / 2)) - shredder_peon_count*sc, 1 )  )
  //endif

  if race_has_ghouls then  // Ignore shredders
    if mo <= 1 then
      call BuildPeons(min_peon_number_single_mine)
    elseif mo <= 2 then
      call BuildPeons(min_peon_number_double_mine)
    else
      call BuildPeons(min_peon_number_multi_mine)
    endif
  else
    if mo <= 1 then
      // call BuildPeons(Max(min_peon_number_single_mine, R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, peon_1_mine_number, 5, w)) - shredder_peon_count*sc))
      call BuildPeons(Max(R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, peon_1_mine_number, min_peon_number_single_mine, w) - shredder_peon_count*sc),min_peon_number_single_mine))  // the Max condition prevents having loads of shredders stoping amai getting peons for gold
    elseif mo <= 2 then
      // call BuildPeons(Max(min_peon_number_double_mine, R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, peon_2_mines_number, 10, w)) - shredder_peon_count*sc))
      call BuildPeons(Max(R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, peon_2_mines_number, min_peon_number_double_mine, w) - shredder_peon_count*sc),min_peon_number_double_mine))
    else
      // call BuildPeons(Max(min_peon_number_multi_mine, R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, peon_mines_number, 10, w)) - shredder_peon_count*sc))
      call BuildPeons(Max(R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, peon_mines_number, min_peon_number_multi_mine, w) - shredder_peon_count*sc),min_peon_number_multi_mine))
    endif
  endif
  if race_has_ghouls then
    call BuildGhouls(Max(R2I(LinearInterpolation(maximum_peon_wood, minimum_peon_wood, race_max_ghouls, race_min_ghouls, w) - R2I(shredder_peon_count / 2)*sc),2))
  endif
  set neededPeons = 0 // Reset
endfunction

//============================================================================
function SetBuildFree takes nothing returns nothing
local integer i = 0
local integer j = 0
loop
  exitwhen i >= building_length
  set j = building[i]
  set build_free[j] = TownCountDone(j)
  set gold_sum[j] = 0
  set build_time_sum[j] = 0
  set build_num[j] = 0
  set prio_sum[j] = 0
  set i = i + 1
endloop
endfunction

//============================================================================
function ExpansionBuilder takes nothing returns nothing
local integer mines = GetMinesOwned()
local integer gold_left = GetGoldOwned() - (difficulty - 1) * 800
local integer i = 0
local integer f = 0
local boolean exp_prepared = false
local boolean rebuild = false
local unit u = null
local boolean upkeepboost = false
local integer aggexpand = 0
local boolean fastexpa = true
local boolean minetimeready = false

if not first_expansion_chosen then
  call Trace("ExpansionBuilder: Expansions not evaluated yet")
  return
endif
if first_town_mine > 1 and fixmine != null then
  set not_taken_expansion = fixmine  // let race Expansion stop
endif
if current_expansion == null or CheckExpansionTaken(current_expansion) then
  call ChooseExpansion()
  if current_expansion == null then
    call Trace("ExpansionBuilder: No mine available")
    return
  endif
  if CheckExpansionTaken(current_expansion) then
    call Trace("ExpansionBuilder: Expansion taken by someone else")
    if current_expansion != not_taken_expansion then
      set current_expansion = null
    endif
    return
  endif
  set aggexpand = 1
endif
set specialexpand = not IsWaterExpansion(current_expansion) // water expand can't use racial expansion techniques
if fastexpa then
  set fastexpa = false
  call CheckFastExpansion()
endif
set exp_prepared = false

// check actual number of gold mines
if race_manual_loading then
  set mines = TownCount(race_manual_loading_mine)
elseif race_uses_mine_expansion then
  set mines = TownCount(racial_expansion)
endif
if first_town_mine > 0 and not race_manual_loading and not race_uses_mine_expansion then  //home_location have multiple mine , fix GetMinesOwned bug(HUMAN and ORC)
  set mines = Min(TownCount(racial_expansion), mines)
endif

set u = GetExpFoe(u)
set minetimeready = mines < 2 and ai_time - exp_time_count > exp_first_time
set minetimeready = minetimeready or (mines < 3 and (ai_time - exp_time_count > exp_second_time))
set minetimeready = minetimeready or (mines < 4 and attacking_aggression > 0 and ((GetRandomInt(0, 100) < 42 and aggexpand == 1) or aggexpand == 2) and GetGold() > 1000 and GetWood() > 700)
if minetimeready then
  if u != null then
    set take_exp = true
    call Trace("ExpansionBuilder:Need to Creep mine")
  else
    set take_exp = false
    set exp_prepared = true
    call Trace("ExpansionBuilder:Ready to expand to mine")
  endif
endif

// Every mine has chance to check expand
//if (take_exp) then
//  call Trace("Take EXP")
//endif
//if (race_ancient_expansion_available) then
//  call Trace("CAN ANCIENT EXPA")
//endif
//if (not ancient_expanding) then
//  call Trace("CAN ANCIENT EXPA, AS NOT RUNNING")
//endif
//if (specialexpand) then
//  call Trace("RACIAL EXPA POWER READY")
//endif
if take_exp and not_taken_expansion == null and race_militia_expansion_available and not militia_expanding and specialexpand then
  call Trace("ExpansionBuilder:Militia Expand")
  set specialexpand = false
  if GetRandomInt(1, 100) <= 60 then
    set not_taken_expansion = current_expansion
    set current_expansion = null
    call TQAddJob(0, MILITIA_EXPAND, 0)
    set u = null
    return
  endif
endif

//call Trace("ANCIENT: EXP STRENGTH" + Int2Str(GetExpansionStrength()))
//call Trace("ANCIENT: RUSH HERO " + Int2Str(i) + " vs rush level " + Int2Str(race_ancient_expansion_hero_rush_level))
//call Trace("ANCIENT: PROB " + Int2Str(GetRandomInt(1,100)) + " vs race prob " +Int2Str(race_ancient_expansion_probability))
if take_exp and not_taken_expansion == null and race_ancient_expansion_available and not ancient_expanding and specialexpand then
  call TraceAll("ExpansionBuilder:Ancient Expand")
  set specialexpand = false
  if hero_unit[1] != null then
    set i = hero_rush_bonus[hero[1]]
  endif
  if hero_unit[2] != null then
    set i = i + hero_rush_bonus[hero[2]]
  endif
  if hero_unit[3] != null then
    set i = i + hero_rush_bonus[hero[3]]
  endif
  if GetRandomInt(1, 100) <= race_ancient_expansion_probability and i >= race_ancient_expansion_hero_rush_level then
    set not_taken_expansion = current_expansion
    call TQAddJob(0, ANCIENT_EXPANSION_CHECK, 0)
    set u = null
    return
  else
    call TraceAll("ExpansionBuilder:Won't ancient exp this time")
  endif
//elseif race_ancient_expansion_available and not ancient_expanding and specialexpand and c_ally_total <= 0 then
//    call TraceAll("ExpansionBuilder:Could ancient expand")
endif

if not exp_prepared and u == null then
  set rebuild = CheckExpansionRebuild()
  if rebuild then
    call Trace("ExpansionBuilder:Ready to rebuild mine")
    set exp_prepared = true
  endif
endif
set u = null

if exp_prepared and not_taken_expansion == null and race_item_expansion_available and not item_expanding and specialexpand and tier >= race_item_sale_level and GetRandomInt(1, 100) <= race_item_expansion_probability then
  call Trace("ExpansionBuilder:Item Expand")
  set specialexpand = false
  if race_item_expansion_item_id != 0 and (GetResourceAmount(current_expansion) > (gold_price[race_item_expansion_item_id] + 300) or GetItemNumber(race_item_expansion_item_id) > 0) then
    call Trace("Item expansion check - Begin Job")
    set item_expanding = true
  endif
endif

set i = 0
set f = FoodUsed() + 10
loop
  exitwhen i >= UPKEEP_NUM or upkeepboost
  // If near on in an upkeep level that needs more mines then boost expansion priority
  if mines < upkeep_mines_needed[i] and f > upkeep_border[i] then
    set upkeepboost = true
  endif
  set i = i + 1
endloop

if mines < 1 or gold_left < 2500 or exp_prepared then
  call Trace("ExpansionBuilder: Putting mine on build list")
  call CreateDebugTagLoc("Current Expansion", 10, GetUnitX(current_expansion), GetUnitY(current_expansion), 1.00, 0.80)
  if mines < 1 or gold_left < 2500 then
    call BuildExpa(TownCount(racial_expansion) + 1, racial_expansion, expa_emergency_prio)
  elseif rebuild or upkeepboost then
    call BuildExpa(TownCount(racial_expansion) + 1, racial_expansion, expa_rebuild_prio)
  else
    call BuildExpa(TownCount(racial_expansion) + 1, racial_expansion, expa_prio)
  endif
elseif minetimeready and attacking_aggression > 0 and mines > 1 and mines < 4 and not_taken_expansion == null then
  if chaos_expansion != null and chaos_expansion != current_expansion and GetResourceAmount(chaos_expansion) >= GetUnitGoldCost(old_id[racial_expansion]) and GetLocationCreepStrength(GetUnitX(chaos_expansion), GetUnitY(chaos_expansion), expansion_radius) <= 0 and not CheckExpansionTaken(chaos_expansion) then
    set u = GetExpansionPeon()
    if u != null and UnitAlive(u) and u != expansion_peon and not chaos_expansion_run then
      set chaos_expansion_run = true
      set not_taken_expansion = chaos_expansion
      call TQAddUnit2Job(2 * sleep_multiplier, BUILD_EXPANSION, 0, u, chaos_expansion)
      call IssueTargetOrderById(u, old_id[racial_expansion], chaos_expansion)
      call CreateDebugTag("chaos expansion", 10, u, 3.00, 1.50)
      call Trace("ExpansionBuilder: chaos expansion")
      set u = null
      return
    endif
    set u = null
  else
    set chaos_expansion = expansion_list[Max(0, GetRandomInt(0, expansion_list_length - 1))]
    set chaos_expansion_run = false
  endif
endif
//call Trace("ExpansionBuilder: Not ready to build mine")
endfunction

//============================================================================
#DEFINE $SKINSTART$ 3
#DEFINE $SKINEND$ 9
function GetHeroSkin takes integer hn returns nothing
  local integer i = 0
  local integer array skin
  if p_rare[profile] < 1 or GetRandomInt(0, 100) < 20 then  // not fully use new skin , random int use original skin - 0 : change skin will change proper name (AI Scripts cannot use GetHeroProperName and BlzSetHeroProperName)
    return
  #INCLUDETABLE <HeroSkin.txt> #EFR
  elseif old_id[hero[hn]] == '%2' then
    #FOR $X$ FROM $SKINSTART$ TO $SKINEND$
    set skin[#EVAL{$X$-2}] = '%$X$'
    #ENDFOR
    set i = GetRandomInt(1, %1)
    #AFTERINCLUDE
  #ENDINCLUDE
  else
    return // unknow hero
  endif
  if skin[i] != '0' then
    call BlzSetUnitSkinAMAI(hero_unit[hn], skin[i])  // set skin API at 1.33+ and some unit at 1.32+ , old WE make map cannot use - so just in case check max player num
  endif
endfunction
#UNDEF $SKINSTART$
#UNDEF $SKINEND$

function InitHeroInfo takes integer hn returns nothing
  set hero_loc[hn] = GetUnitLoc(hero_unit[hn])
  set hero_dir[hn] = Location(0,0)
  set hero_enemy_loc[hn] = Location(0,0)
  set hero_ally_loc[hn] = Location(0,0)
  set hero_hp[hn] = 1
  if major_hero == null or (not IsUnitType(major_hero, UNIT_TYPE_HERO) and ver_heroes) or not UnitAlive(major_hero) then
    set major_hero = hero_unit[hn]
  endif
  call GetHeroSkin(hn)
endfunction

function HeroReviver takes nothing returns nothing
  local integer i = 1
  loop
    exitwhen i > 3
    if GetUnitCountDone(old_id[hero[i]]) > 0 then
      if not hero_built[i] then
        set hero_unit[i] = GetOneOfId(hero_unit[i], ai_player, old_id[hero[i]])
        if hero_unit[i] != null then
          set hero_built[i] = true
          call InitHeroInfo(i)
          call TQAddJob(1, MICRO_HERO, i)
        endif
      endif
    elseif hero_built[i] then
      if not TavernResurrect then
        if nearest_neutral[NEUTRAL_TAVERN] != null and not neutral_ordered[NEUTRAL_TAVERN] and difficulty > GetRandomInt(0, 4) and FoodSpace() >= GetFoodUsed(old_id[hero[i]]) and (82 * (GetUnitLevel(hero_unit[i]) + 3)) < GetGold() and (22 * (GetUnitLevel(hero_unit[i]) + 3)) < GetWood() then
          set neutral_ordered[NEUTRAL_TAVERN] = true
          set neutral_wanted[NEUTRAL_TAVERN] = 1
          call TQAddJob(0, BUY_NEUTRAL_HERO, hero[i])
          set TavernResurrect = true
          call Trace("Try Resurrect Hero from Tavern")
        else
          call BuildUnit(1, hero[i], hero_revive_prio[i])
        endif
      endif
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function CheckUnitNewTown takes unit u returns boolean
  local integer i = 0
  local location l = GetUnitLoc(u)
  loop
    exitwhen i >= max_towns
    if town_built[i] and own_town_loc[i] != null and DistanceBetweenPoints(l, own_town_loc[i]) < town_radius then
      call RemoveLocation(l)
      set l = null
      return false
    endif
    set i = i + 1
  endloop
  call RemoveLocation(l)
  set l = null
  return true
endfunction

//============================================================================
function LocalizeOldTown takes integer num returns boolean
  local group g = CreateGroup()
  local unit u = null
  call GroupEnumUnitsInRangeOfLoc(g, own_town_loc[num], 1400, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    exitwhen GetOwningPlayer(u) == ai_player and IsUnitType(u, UNIT_TYPE_STRUCTURE) and UnitAlive(u) and not IsUnitHidden(u) and GetTownUnitCount(GetUnitTypeId(u), num, true) > 0
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  if u == null then
    call RemoveLocation(own_town_loc[num])
    set own_town_loc[num] = null
    set own_town_mine[num] = null
    set own_town_dist[num] = 0
    return false
  endif
  set u = null
  return true
endfunction

function LocalizeNewTown takes integer num returns boolean
  local group g = CreateGroup()
  local unit u = null
  local integer e = old_id[racial_expansion]
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    exitwhen GetUnitTypeId(u) == e and UnitAlive(u) and not IsUnitHidden(u) and CheckUnitNewTown(u)
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  if own_town_loc[num] != null then
    call RemoveLocation(own_town_loc[num])
  endif
  if u == null then
//    call DisplayToAll("Debug: New town not found")
    set own_town_loc[num] = null
    set own_town_mine[num] = null
    set own_town_dist[num] = 0
    return false
  endif
  set own_town_loc[num] = GetUnitLoc(u)
  set own_town_mine[num] = GetMineNearLoc(own_town_mine[num], own_town_loc[num], 1500)
  set own_town_dist[num] = DistanceBetweenPoints(home_location, own_town_loc[num])
  if debugging then
    call PingMinimap(GetUnitX(u), GetUnitY(u), 20)
  endif
  set u = null
  return true
endfunction

//============================================================================
function CheckTownBuilt takes nothing returns nothing
  local integer i = 0
  local integer c = 1
  loop
    exitwhen i >= max_towns
    if not town_built[i] then
      if TownCountEx(racial_expansion, true, i) > 0 then
        set town_built[i] = LocalizeNewTown(i)
      endif
    else
      set town_built[i] = LocalizeOldTown(i)
    endif
    if own_town_loc[i] != null then
      call CreateDebugTagLoc("own town loc : " + Int2Str(i), 5, GetLocationX(own_town_loc[i]), GetLocationY(own_town_loc[i]), 1.50, 1.50)
    endif
    if own_town_mine[i] != null and GetResourceAmount(own_town_mine[i]) > 0 then
      call CreateDebugTag("own town mine : " + Int2Str(i), 5, own_town_mine[i], 1.50, 1.50)
    endif
    set i = i + 1
  endloop
  set i = 1
  loop
    exitwhen i >= max_towns
    if own_town_loc[i] != null then
      set exist_town[c] = own_town_loc[i]
      set c = c + 1
    else
      set exist_town[c] = home_location
    endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function TimeKeeper takes nothing returns nothing
  local integer t = ai_time
  //local real new_time_of_day = GetFloatGameState(GAME_STATE_TIME_OF_DAY)
  //if new_time_of_day < time_of_day then
  //  call Chat(C_NewYear)
  //endif
  //set time_of_day = new_time_of_day
  set ai_time = R2I(TimerGetElapsed(tq_timer) / 5)
  if ai_time - t >= taunt_start_time then
    call Chat(C_Taunt)
  endif
endfunction

//============================================================================
function FactoryNumberUpdate takes nothing returns nothing
  local integer g_sum = 0
  local integer i = 0
  local integer j = 0
  local real g = GetRandomReal(0.8,1.1)
  set gold_income = GetGoldIncome()
  loop
    exitwhen i >= building_length
    set g_sum = g_sum + gold_sum[building[i]]
    set i = i + 1
  endloop
  if g_sum == 0 then
    return
  endif
  if gold_income != 0 then
    set g = gold_income
  endif
  set i = 0
  loop
    exitwhen i >= building_length
    set j = building[i]
    set income_percentage[j] = I2R(gold_sum[j]) / g // gold_sum = total costs for the qty of units required
    //if build_num[j] > 0 then
      //call BuildUnit(GetFactoryQty(build_num[j], build_time_sum[j] / build_num[j], gold_sum[j] / build_num[j], income_percentage[j]), j, prio_sum[j] / build_num[j])
    //endif
    set i = i + 1
  endloop
endfunction

//============================================================================
function OneBuildLoopAM takes nothing returns nothing
    local integer index = 0
    local integer index_free = 0
    local integer qty = 0
    local integer id = 0
    local integer tp = 0
    local integer ret = 0
    local integer town = 0
    local integer array max_order
    local integer mo = 0
    local integer traced = 0
    local integer tracedsome = 0
    local integer tracednoresources = 0
    local integer tracedall = 0
    local string logtype = ""
    local boolean blocktierup = false
    local boolean expablocktier = false

    call InitLastUpkeep()

    call TimeKeeper()
    call CheckTownBuilt()
    call SetBuildFree()
    call FarmBuilder()
    call PeonBuilder()
    // Zeppelin builder
    if GetGold() > 600 and GetWood() > 360 then
      if (water_expansion_list_length > 0) then
        call BuildUnit(2, neutral_zeppelin, 80)
      else
        call BuildUnit(2, neutral_zeppelin, 50)
      endif
    endif
    if not campaign_ai then
      call ExpansionBuilder()
      call HeroReviver()
    endif
    set total_gold   = GetGold() - gold_buffer
    set total_wood   = GetWood() - wood_buffer
    set total_food   = ver_food_limit - FoodUsed()

    call CheckUpkeepAllowed(ver_food_limit - total_food)

    set blocked_gold = 0
    set blocked_wood = 0
    set blocked_food = 0
    set t_build_length = 0

    call GetBuildLock()
    loop
      exitwhen index >= build_length
      if index > 0 and ModuloInteger(index, 300) == 0 then
        call Sleep(0.05)
      endif
      set id = build_item[index]
      set qty = RBlockListCheck(build_qty[index], id)
      set qty = BlockListCheck(qty, id)
      set tp = build_type[index]
      set town = Max(build_town[index],0)
      set mo = max_order[id + town*OBJECT_NUM]
//        call DumpInteger("ID"+Int2Str(index),id)
//        call DumpInteger("Qty"+Int2Str(index),qty)
//        call DumpInteger("Gold"+Int2Str(index),total_gold)
//        call DumpInteger("Prio"+Int2Str(index),build_prio[index])

      if qty > mo and qty > 0 then
        if tp == BUILD_UNIT and IsRacialHallId(id, 2) and ((blocktierup and bl_tier_lockactive[tier - 1]) or expablocktier) and GetUnitGoldCost2(id) * 4 > total_gold and GetUnitWoodCost2(id) * 4 > total_wood then
          call Trace("TIER UP block " + logtype + unitNames[id] + " " + Int2Str(id))
          set ret = CANNOT_BUILD // Not ready to tier up
        elseif tp == BUILD_UNIT then
          if IsRacialHallId(id, 2) then
            set bl_tier_lockactive[tier - 1] = false // lock only occurs once per tier, once lock is unlocked for that tier it stays unlocked e.g it doesn't have to start from scratch again if strategy changes or units die within tier 1
          endif
          set logtype = "unit "
          set ret = StartUnitAM(qty,id,build_town[index], build_loc[index], build_prio[index], mo)
        elseif tp == BUILD_UPGRADE then
          set logtype = "upgrade "
          set ret = StartUpgradeAM(qty,id)
        elseif tp == BUILD_EXPAND then
          set logtype = "expand "
          set ret = StartExpansionAM(qty,id)
          if ret == BUILT_SOME and GetMinesHarvested() < 3 then // block tier up while actually expanding or enough mines to support this
            set expablocktier = bl_tier_expansionblock[tier - 1]
          endif
        elseif tp == BUILD_ITEM then
          set logtype = "item "
          set ret = StartItem(qty,id)
        else
          set logtype = "unknown:" + Int2Str(tp)
        endif

        if qty > mo then
          set max_order[id + town*OBJECT_NUM] = qty
        endif

        if ret == CANNOT_BUILD then
          if (traced == 0) then
            call Trace("CANNOT BUILD " + logtype + unitNames[id] + " " + Int2Str(id))
            set traced = id
          endif
          call AddRefresh(tp, qty, id, build_town[index], build_loc[index], build_prio[index])
        elseif ret == BUILT_SOME and tracedsome == 0 then
          //call Trace("BUILT SOME " + logtype + unitNames[id] + " " + Int2Str(id))
          set tracedsome = id
        elseif ret == BUILT_ALL and tracedall == 0 then
          //call Trace("BUILT ALL " + logtype + unitNames[id] + " " + Int2Str(id))
          set tracedall = id
        elseif ret == NOT_ENOUGH_RES and tracednoresources == 0 then
          call Trace("NO RESOURCES " + logtype + unitNames[id] + " " + Int2Str(id))
          set tracednoresources = id
        endif
        if tp == BUILD_UNIT and not IsUnitIdType(old_id[id], UNIT_TYPE_STRUCTURE) and TownCountTown(id,build_town[index]) < build_qty[index] * bl_tier_unitlock[tier-1] and FoodUsed() < bl_tier_foodlock[tier-1] then
          set blocktierup = true // Strictly Block tier up if a large proportion of requested units of strategy not built so we follow strategy definition, otherwise will tier up early if spare resources and can't build higher priority tasks first
        endif
        exitwhen ret == NOT_ENOUGH_RES and tp != BUILD_ITEM and tp != BUILD_UPGRADE // Don't try and build anything else as thing we trying to buy is too expensive
        if ret == CANNOT_BUILD or ret == BUILT_SOME or ret == NOT_ENOUGH_RES or (ret == BUILT_ALL and qty < build_qty[index]) then
          set build_qty[index_free] = build_qty[index]
          set build_type[index_free] = build_type[index]
          set build_item[index_free] = build_item[index]
          set build_loc[index_free] = build_loc[index]
          set build_town[index_free] = build_town[index]
          set build_prio[index_free] = build_prio[index] + prio_t_inc
          set index_free = index_free + 1
        endif
      endif

      set index = index + 1
      set total_gold = total_gold - blocked_gold
      set total_wood = total_wood - blocked_wood
      //set total_food = total_food - blocked_food
      set blocked_gold = 0
      set blocked_wood = 0
      set blocked_food = 0
    endloop

//    call EndDump(Int2Str(ai_time))

    loop
      exitwhen index >= build_length
      if index > 0 and ModuloInteger(index, 300) == 0 then
        call Sleep(0.02)
      endif
      set build_qty[index_free] = build_qty[index]
      set build_type[index_free] = build_type[index]
      set build_item[index_free] = build_item[index]
      set build_town[index_free] = build_town[index]
      set build_loc[index_free] = build_loc[index]
      set build_prio[index_free] = build_prio[index] + prio_t_inc
      set index_free = index_free + 1
      set index = index + 1
    endloop
    set build_length = index_free

    call ResetUpkeepSaveTime()
    call ReleaseBuildLock()
    call RefreshAllNeeded()
    call FactoryNumberUpdate()
    set logtype = null
endfunction


//============================================================================
// AMAI Build Loop
//============================================================================
function BuildLoopAM takes nothing returns nothing
  local integer blc = 0
  //local integer timing = 0
  call OneBuildLoopAM()
  call StaggerSleep(1,5)
  loop
    //call Trace("Build Loop")
    //set timing = ai_time
    exitwhen player_defeated
    set blc = blc + 1
    call OneBuildLoopAM()
    if blc > build_array_reset_time then
      call InitBuildArrayAM()
      set blc = 0
    endif
    call StaggerSleep(5 * sleep_multiplier,6 * sleep_multiplier)
    //call Trace("Build Loop total seconds:" + Int2Str((ai_time - timing) * 5))
  endloop
//    call DisplayToAll("Shutting down BuildLoopAM")
//    call DebugSequenceEnd()
  call InitBuildArrayAM()
  loop
    call Sleep(100)
  endloop
endfunction

//============================================================================
function PlayGameAM takes nothing returns nothing
  call BuildLoopAM()
endfunction

//============================================================================
// AMAI Attack Functions
//============================================================================
function ConversionsAM takes integer desire, integer unitid returns nothing
#INCLUDETABLE <$VER$\UnitConversions.txt> #EFR
  if unitid == %1 then
    call MergeUnits(desire,o%2,o%3,o%1)
  endif
#ENDINCLUDE
endfunction

//============================================================================
function SetAssaultGroupAM takes integer qty, integer max, integer unitid returns nothing
  call ConversionsAM(max,unitid)

  set attack_qty[attack_length] = qty
  set attack_max[attack_length] = max
  set attack_units[attack_length] = unitid
  set attack_length = attack_length + 1
endfunction

//============================================================================
function SetMeleeGroupAM takes integer unitid returns nothing
  if TownCountDone(unitid) > 0 then
    call SetAssaultGroupAM(0,60,unitid)
  endif
endfunction

//============================================================================
function AttackGroupAddNeutrals takes nothing returns nothing
  local integer i = 0
  loop
    exitwhen i >= merc_number
    call SetMeleeGroupAM(merc_unit[i])
    set i = i + 1
  endloop
  set i = 1
  loop
    exitwhen i >= dragon_number
    call SetMeleeGroupAM(dragons[i])
    set i = i + 1
  endloop
endfunction

function AttackGroupAddUnknown takes nothing returns nothing
  local group g = CreateGroup()
  local unit u = null
  local integer i = 0
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  loop
    exitwhen i >= attack_length or FirstOfGroup(g) == null
    set g = SelectById(g, old_id[attack_units[i]], false)
    set i = i + 1
  endloop
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if not IsUnitType(u, UNIT_TYPE_PEON) and not IsUnitType(u, UNIT_TYPE_STRUCTURE) and not IsUnitType(u, UNIT_TYPE_SUMMONED) and not IsUnitType(u, UNIT_TYPE_SAPPER) and (IsUnitType(u, UNIT_TYPE_ATTACKS_FLYING) or IsUnitType(u, UNIT_TYPE_ATTACKS_GROUND)) and UnitAlive(u) and not IsUnitHidden(u) then
      set i = GetUnitTypeId(u)
      if i != 'ngir' then
        call AddAssault(60,i)  //other hero and unit , like other race and custom
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
endfunction

//============================================================================
function FormGroupAM takes integer seconds returns nothing
  local integer index = 0
  local integer count = GetWood()
  local integer unitid = 0
  local integer desire = 0
  local integer ghoul = 0
  local group g = null
  local unit u = null

  call InitAssault()

  if count > minimum_peon_wood then
    set take_all_ghouls_along = true
  elseif count < minimum_peon_wood then
    set take_all_ghouls_along = false
  endif

  if TownCountDone(racial_ghoul) > 0 then  // Ghoul count needs to exclude units sent back to heal otherwise harvesting ghouls will be pulled off.
    set g = CreateGroup()
    call GroupEnumUnitsOfPlayer(g, ai_player, null)
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      if GetUnitTypeId(u) == old_id[racial_ghoul] and UnitAlive(u) and not IsUnitHidden(u) and IsStandardUnit(u) and not IsUnitBuying(u) then
        set ghoul = ghoul + 1
      endif
      call GroupRemoveUnit(g, u)
    endloop
    call DestroyGroup(g)
    set g = null
  endif

  loop
    exitwhen index >= attack_length

    set unitid = attack_units[index]

    #INCLUDETABLE <$VER$\UnitEquivalence.txt> #EFR #COND "%2" eq "UPGRADED_TO"
    if unitid == %1 and GetUpgradeLevel(o%4) >= %5 then
      set unitid = %3
    endif
    #ENDINCLUDE

    set desire = attack_max[index]
    set count  = TownCountDone(unitid)

    if unitid == racial_ghoul then
      if take_all_ghouls_along then
        if towerrush then
          set desire = Min(Max(count - 2 , 0),desire)  // reserve
        endif
        set attacking_ghouls = desire
      else
        set count = count + ghoul
        set desire = (count - harvesting_ghouls) // all spare ghouls should attack and join attack as built
        if towerrush then
          set desire = Min(Max(count - 2 , 0),desire)  // reserve
        endif
        set attacking_ghouls = Max(desire, 0)
      endif
      call Trace("Attacking Ghouls Formed:" + Int2Str(attacking_ghouls))
    endif

    call ConversionsAM(desire,unitid)

    if count >= desire then
      call AddAssault(desire,old_id[unitid])
    else
      call AddAssault(count,old_id[unitid])
    endif

    set index = index + 1
  endloop
  if seconds > 0 then
    call Sleep(seconds)
  endif
endfunction

function FromGroupAndGhoulsAM takes integer seconds returns nothing
  call FormGroupAM(0)
  if not race_has_ghouls or not race_ghouls_attack then
   call Sleep(seconds)
  endif
endfunction

//============================================================================
function EnableRetreatControl takes nothing returns nothing
  set break_attack = false
  if not retreat_controlled then
    call Trace("===Retreat control started===")
    set retreat_controlled = true
    call SetGroupsFlee(false)
    call SetTargetHeroes(false)
    call TQAddJob(2 * sleep_multiplier, RETREAT_CONTROL, 0)
  endif
endfunction

function DoAttackJobs takes nothing returns nothing
  if major_hero == null or not UnitAlive(major_hero) then
    set major_hero = GetMajorHero(major_hero)
  endif
  set battle_radius = normal_battle_radius
  call EnableRetreatControl()
endfunction

//============================================================================
function GetDistractionTarget takes unit ru, unit target returns unit
  local group g = CreateGroup()
  local group tg = CreateGroup()
  local location unitloc = GetUnitLoc(target)
  local player p = GetOwningPlayer(target)
  local unit u = null
  local real d = 0
  local real sd = 0
  call GroupEnumUnitsOfPlayer(g, p, null)
  call GroupEnumUnitsInRangeOfLoc(tg, unitloc, 3000, null)
  set ru = null
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if GetOwningPlayer(u) == p and IsUnitType(u, UNIT_TYPE_STRUCTURE) and UnitAlive(u) and not IsUnitHidden(u) and not IsUnitInGroup(u, tg) then
      set d = DistanceBetweenPoints_dk(GetUnitLoc(u), unitloc)
      if d > sd then
        set sd = d
        set ru = u
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call RemoveLocation(unitloc)
  set unitloc = null
  call DestroyGroup(tg)
  set tg = null
  call DestroyGroup(g)
  set g = null
  set p = null
  return ru
endfunction

//============================================================================
function DoDistractionAttack takes unit target returns nothing
  local unit d_target = null
  set d_target = GetDistractionTarget(d_target, target)
  if d_target != null then
    call StartHarass(distraction_group, HARASS_TARGET_LOCATION, false, 15, 0.25, 1, GetUnitX(d_target), GetUnitY(d_target))
    call Sleep(3)
  endif
  set d_target = null
endfunction

//============================================================================
function SleepInCombatAM takes boolean ally_override returns nothing
  local integer count = 0
  local integer noenemycount = 0
  //local real sleep = 0.1
  local unit u = null
  local group g = CreateGroup()
  local integer attack_length_counter = 0
  //call Trace("SleepInCombat Collect Items")
  //loop
  //  exitwhen count >= (8.0/sleep) or town_threatened
  //  if (lastcaptainx != 0 and lastcaptainy != 0 and not CaptainIsEmpty() and ((CaptainAtGoal() and not CaptainInCombat(true)) or CaptainRetreating() or CaptainIsHome())) then
  //    call TeleportCaptain(lastcaptainx, lastcaptainy) // Keep units around killed unit/target to help collect any loot
      //call AttackMoveXY(R2I(lastcaptainx), R2I(lastcaptainy))
  //  endif
    //if (lastcaptainx != 0 and lastcaptainy != 0 and not CaptainIsEmpty() and (CaptainAtGoal() and  or CaptainIsHome())) and not CaptainInCombat(true) then
    //  call CreateDebugTagLoc("SleepInCombat", 10, lastcaptainx, lastcaptainy, 1.00, 0.80)
    //  call AttackMoveXY(R2I(lastcaptainx), R2I(lastcaptainy)) // Keep units around killed unit/target to help collect any loot
    //endif
  //  set count = count + 1
  //  call Sleep(sleep)
  //endloop
  call Trace("SleepInCombat")
  //set count = 0
  loop
    exitwhen town_threat_break and town_threatened // under attack
    exitwhen break_attack // forced attack to end
    exitwhen CaptainIsEmpty()// no troops so stop attack
    exitwhen count >= 900 // Took longer than 15 mins to stop lingering something is wrong
    exitwhen isfleeing // Retreat control says to retreat
    if lastcaptainx != 0 and lastcaptainy != 0 then
      call CreateDebugTagLoc("Sleep at captainloc", 10, lastcaptainx, lastcaptainy, 1.00, 0.80)
      if u == null or not UnitAlive(u) or IsUnitInvisibleAM(u, ai_player) then
        call GroupEnumUnitsInRange(g, lastcaptainx, lastcaptainy, battle_radius,null)
        loop
          set u = FirstOfGroup(g)
          exitwhen u == null
          exitwhen IsPlayerEnemy(ai_player, GetOwningPlayer(u)) and UnitAlive(u) and not IsUnitHidden(u) and not IsUnitInvisibleAM(u, ai_player)
          call GroupRemoveUnit(g, u)
        endloop
        call GroupClear(g)
      endif
      if u == null then
        exitwhen noenemycount >= 4 // no enemies so exit
        set noenemycount = noenemycount + 1 // 8 seconds to pick up items on ground
        if not CaptainInCombat(true) then
          call TeleportCaptain(lastcaptainx, lastcaptainy)
        endif
      endif
    else
      call CreateDebugTagLoc("Sleep in combat", 10, GetLocationX(home_location),GetLocationY(home_location), 1.00, 0.80)
    endif
    if (u != null and not CaptainInCombat(true)) then
      set attack_length_counter = attack_length_counter + 1
      if attack_length_counter > R2I(LinearInterpolation(30, 80, attack_reform_length, attack_reform_length * 10, FoodUsed())+0.5) then
        set attack_length_counter = 0
        call FormGroupAM(0)
      endif
      if true or CaptainAtGoal() or (attack_length_counter == 0 and not CaptainInCombat(true)) or CaptainInCombat(true) or ally_override or c_ally_total == 0 then
        call AttackMoveKill(u) // Use existing troops
      elseif (c_ally_total > 0 and not ally_override) then
        call CaptainAttack(GetUnitX(u), GetUnitY(u)) // Override hardcoded logic with attackmovekill as ally targets will change the attackmovekill we wanted. Teleport ignores the ally control.
      endif
      call CreateDebugTag("Combat sleep attack", 10, u, 1.00, 0.80)
    endif
    exitwhen (not CaptainInCombat(true) or CaptainRetreating() or CaptainIsHome()) and count > 180  // Fail safe using hardcoded checks
    set count = count + 1
    call Sleep(1)
  endloop
  call DestroyGroup(g)
  set g = null
  set u = null
  call Trace("exit SleepInCombat")
endfunction

//============================================================================
function GetNearAlliedStrength takes unit target returns real
  local integer i = 0
  local real sum = 0
  local location unitloc = GetUnitLoc(target)
  local real dist = DistanceBetweenPoints(unitloc, ally_loc) + 600
  loop
    exitwhen i >= army_num
    if IsPlayerAlly(ai_player, Player(army_owner[i])) and Player(army_owner[i]) != ai_player then
      if army_loc[i] != null and army_future[i] != null and DistanceBetweenPoints(unitloc, army_loc[i]) > dist and DistanceBetweenPoints(unitloc, army_future[i]) < 1300 then
        set sum = sum + army_strength[i]
      endif
    endif
    set i = i + 1
  endloop
  call RemoveLocation(unitloc)
  set unitloc = null
  return sum
endfunction

//============================================================================
function GetNearerAlliedStrength takes unit target returns real
  local integer i = 0
  local real sum = 0
  local location unitloc = GetUnitLoc(target)
  local real dist = DistanceBetweenPoints(unitloc, ally_loc) + 600
  loop
    exitwhen i >= army_num
    if IsPlayerAlly(ai_player, Player(army_owner[i])) and Player(army_owner[i]) != ai_player then
      if army_loc[i] != null and army_future[i] != null and DistanceBetweenPoints(unitloc, army_loc[i]) <= dist and DistanceBetweenPoints(unitloc, army_future[i]) < 1600 then
        set sum = sum + army_strength[i]
      endif
    endif
    set i = i + 1
  endloop
  call RemoveLocation(unitloc)
  set unitloc = null
  return sum
endfunction

//============================================================================
function CheckAttackWait takes unit target returns boolean
  local real target_strength = GetLocationStrength(GetUnitX(target), GetUnitY(target), battle_radius)
  local real strength = GetOwnStrength()
  local real nearer_strength = GetNearerAlliedStrength(target)
  if strength + nearer_strength > target_strength * 1.1 then
    return false
  endif
  return GetNearAlliedStrength(target) > 10.0
endfunction

//============================================================================
function DesperationAssault takes nothing returns nothing
  local group g = null
  local unit u = null
  local integer i = 0
  if not player_defeated then
    call Trace("Adding desperation troops")
    set g = CreateGroup()
    call GroupEnumUnitsOfPlayer(g, ai_player, null)
    loop
      set u = FirstOfGroup(g)
      exitwhen u == null
      if (IsUnitType(u, UNIT_TYPE_ANCIENT) or not IsUnitType(u, UNIT_TYPE_STRUCTURE)) and UnitAlive(u) and not IsUnitHidden(u) then
        call AddAssault(60, GetUnitTypeId(u))
      endif
      call GroupRemoveUnit(g, u )
    endloop
    call DestroyGroup(g)
    set g = null
  endif
endfunction

function CommonSleepUntilTargetDeadAM takes unit target, boolean iscreeping, boolean reform, boolean ally_override returns nothing
  local real dist = 0
  local integer attack_length_counter = 0
  local integer combat_length_counter = 0
  local unit ally_target = null
  //local group g = null
  set lastcaptainx = GetUnitX(target)
  set lastcaptainy = GetUnitY(target)
  loop
    //call Trace("SleepExitThreat:" + B2S(town_threat_break and town_threatened and not desperation_assault))
    exitwhen player_defeated
    exitwhen town_threat_break and town_threatened and not desperation_assault
    //call Trace("SleepExitBreak:" + B2S(break_attack and not desperation_assault))
    exitwhen break_attack and not desperation_assault
    //exitwhen captain_flee and CaptainRetreating()
    //call Trace("SleepExitFlee:" + B2S(isfleeing and (CaptainRetreating() or CaptainIsHome()) and not desperation_assault))
    exitwhen isfleeing and not desperation_assault
    //call Trace("SleepExitEmpty:" + B2S(CaptainIsEmpty() and not desperation_assault))
    exitwhen CaptainIsEmpty() and not desperation_assault
    //if (c_ally_total > 0 and GetAllianceTarget() != null) then // If alliance target exists this overrides hardcoded attack controls regardless of unit you pass, so reconfigure attack to be aware of this
    //  set target = GetAllianceTarget()
    //endif
    //call Trace("SleepExitNull:" + B2S(target == null))
    exitwhen target == null // Fail safe
    //call Trace("SleepExitInvalid:" + B2S(IsPlayerAlly(ai_player, GetOwningPlayer(target)) or not UnitAlive(target) or (IsUnitInvisible(target, ai_player))))
    exitwhen not UnitAlive(target)
    exitwhen IsPlayerAlly(ai_player, GetOwningPlayer(target))
    exitwhen IsUnitInvisibleAM(target, ai_player)
    //if IsPlayerAlly(ai_player, GetOwningPlayer(target)) or not UnitAlive(target) or (UnitInvis(target) and not IsUnitDetected(target, ai_player)) then
    //  set g = CreateGroup()
    //  call GroupEnumUnitsInRange(g,GetUnitX(target), GetUnitY(target),battle_radius,null)
    //  set g = SelectByAlive(g,true)
    //  set g = SelectByEnemy(g,ai_player, true)
    //  if not UnitAlive(target) or UnitInvis(target) then
    //    set g = SelectByVisible(g,ai_player,true)  // to find enemies that ai has noticed
    //  endif
    //  if iscreeping then
    //    set g = SelectByPlayer(g, Player(PLAYER_NEUTRAL_AGGRESSIVE), true)  // if creeping and unit invisible see if any other creeps targetable
    //  endif
    //  set target = FirstOfGroup(g)
    //  call DestroyGroup(g)
    //endif
    //exitwhen target == null
    //if not iscreeping then
      //	exitwhen GetLocationNonCreepStrength(unitx, unity, battle_radius) <= 0 and not UnitAlive(target) and GetLocationEnemyStrength(unitx, unity, battle_radius, true) <= 0 // enemies are dead and target dead
    //else
      //call Trace("Units, Creeps: " + Int2Str(GetLocationNonCreepStrength(unitx, unity, battle_radius)) + "," + Int2Str(GetLocationCreepStrength(unitx, unity, 500)))
      //	exitwhen GetLocationNonCreepStrength(unitx, unity, battle_radius) <= 0 and not UnitAlive(target) and GetLocationCreepStrength(unitx, unity, 500) <= 0
    //endif
    set dist = DistanceBetweenPoints_kd(ally_loc, GetUnitLoc(target))
    if c_ally_total > 0 and dist > 1300 and dist < 2500 and CheckAttackWait(target) and ally_override then
      set lastcaptainx = GetLocationX(ally_loc)
      set lastcaptainy = GetLocationY(ally_loc)
      //call SetCaptainHome(, lastcaptainx, lastcaptainy)
      if true or CaptainAtGoal() or attack_length_counter == 0 or CaptainInCombat(true) or ally_override or c_ally_total == 0 then
        call AttackMoveXY(R2I(lastcaptainx), R2I(lastcaptainy))
      elseif (c_ally_total > 0 and not ally_override) then
        call CaptainAttack(lastcaptainx, lastcaptainy) // Override and help nearby ally
      endif
      call CreateDebugTagLoc("Reform near ally", 10, lastcaptainx, lastcaptainy, 1.00, 0.80)
    else
      set lastcaptainx = GetUnitX(target)
      set lastcaptainy = GetUnitY(target)
      set ally_target = I2U(GetStoredInteger(amaiCache, Int2Str(ALLIANCE_TARGET), "0"))
      // We now control ally, only certain attack operations will let AMAI join around a shared ally target
      if (ally_override and c_ally_total > 0 and ally_target != null and ally_target != target) then
        set target = ally_target
      endif
      if true or CaptainAtGoal() or (attack_length_counter == 0 and not CaptainInCombat(true)) or CaptainInCombat(true) or ally_override or c_ally_total == 0 then
        call AttackMoveKill(target) // use attack length counter to do an ocassional attack move incase enemies nearby
      elseif (c_ally_total > 0 and not ally_override) then // CURRENTLY DISABLED AS FIGHTS WITH ABOVE, NEED NEW COMBAT ATTACK MOVE FUNCTION
        call CaptainAttack(GetUnitX(target), GetUnitY(target)) // Override hardcoded logic from attackmovekill which will help allies, but this is not an attack move operation
      endif
      // Below is old style alliance but this overrides all hardcoded attacks whether you want it to or not
      //if (GetAllianceTarget() == target) then
      //  call AttackMoveKill(target)
      //else
      //  call AttackMoveXY(R2I(lastcaptainx), R2I(lastcaptainy)) // Override and ignore the alliance target
      //endif
      // Below is old style alliance but this overrides all hardcoded attacks whether you want it to or not
      //if (GetAllianceTarget() == target) then
      //  call AttackMoveKill(target)
      //else
      //  call AttackMoveXY(R2I(lastcaptainx), R2I(lastcaptainy)) // Override and ignore the alliance target
      //endif
      if (c_ally_total > 0 and ally_target == target) then
        call CreateDebugTag("Reform until ally dead", 10, target, 1.00, 0.80)
      else
        call CreateDebugTag("Reform until target dead", 10, target, 1.00, 0.80)
      endif
      set ally_target = null
    endif

    call StaggerSleep(1 * sleep_multiplier, (1 * sleep_multiplier) + 2)

    if desperation_assault and attack_length_counter > attack_reform_length * 10 then
      call DesperationAssault()
      set attack_length_counter = 0
    else
      set attack_length_counter = attack_length_counter + 1
    endif
    if not desperation_assault and reform then // Do not bother reforming in desperation mode, full attack speed
      if CaptainInCombat(true) then
        set combat_length_counter = combat_length_counter + 1
      else
        set attack_length_counter = attack_length_counter + 1
        set combat_length_counter = 0
      endif
      if CaptainInCombat(true) and combat_length_counter > attack_reform_length then
        set combat_length_counter = 0
        call FormGroupAM(0) // Safe in combat as reinforces while fight is ongoing
      elseif not CaptainInCombat(true) and attack_length_counter > R2I(LinearInterpolation(30, 80, attack_reform_length, attack_reform_length * 10, FoodUsed())+0.5) then // If a large army generally don't want to wait for reinforcements, so only reform occasionally
        set attack_length_counter = 0
        set combat_length_counter = 0
        //call TraceAll("Reform army")
        call FormGroupAM(1)
      endif
    endif
  endloop
  //set g = null
endfunction

//============================================================================
function ReformUntilTargetDeadAM takes unit target, boolean iscreeping, boolean ally_override returns nothing
  call CommonSleepUntilTargetDeadAM(target,iscreeping,true, ally_override)
endfunction

//============================================================================
function SleepUntilTargetDeadAM takes unit target, boolean iscreeping, boolean ally_override returns nothing
  call CommonSleepUntilTargetDeadAM(target,iscreeping,false, ally_override)
endfunction

//============================================================================
function SleepUntilAtGoalAM takes nothing returns nothing
  local integer lcount = 0
  call Trace("SleepUntilGoal")
  loop
    exitwhen town_threat_break and town_threatened
    exitwhen player_defeated
    set lcount = lcount + 1
    exitwhen break_attack
    exitwhen isfleeing
    if lcount >= 6 then
      exitwhen CaptainAtGoal()        // reached goal
      exitwhen CaptainIsHome()        // failed to path and returned home
    endif
    exitwhen CaptainIsEmpty()       // all units died
    //call Trace("Sleeping until target reached")
    call StaggerSleep(2 * sleep_multiplier, 3 * sleep_multiplier)
  endloop
  call Trace("SleepUntilGoal exit")
endfunction

function SetChatVarsAttack takes unit u returns nothing
  local player p = GetOwningPlayer(u)
  if GetPlayerId(p) < PLAYER_NEUTRAL_AGGRESSIVE then
    call SetChatVar("TargetRace", race_name[player_race[GetPlayerId(p)]])
    call SetChatVar("TargetColor", ColorText(GetPlayerColor(p)))
    call SetChatVarR("TargetStrength", GetPlayerStrength(p))
  endif
  set p = null
endfunction

function SetAllianceTargetIfLead takes unit u returns nothing
  local string t = Int2Str(ALLIANCE_TARGET)
  if u != null and not HaveStoredInteger(amaiCache, t, "0") then // if leadally
    call StoreInteger(amaiCache, t, "0", GetHandleId(u))
    //call SetAllianceTarget(u)
  endif
  if u == null and HaveStoredInteger(amaiCache, t, "0") then
    call FlushStoredInteger(amaiCache, t, "0")
  endif
  set t = null
endfunction

function SetAllianceTargetIfLeadAndChat takes unit u, integer chat returns nothing
  local string t = Int2Str(ALLIANCE_TARGET)
  if u != null and not HaveStoredInteger(amaiCache, t, "0") then // if leadally
    call StoreInteger(amaiCache, t, "0", GetHandleId(u))
    call SetAllianceTarget(u) // Just sends alliance attack signal, doesn't actually control ally attack target as originally thought, thats hardcoded into attackmovekill
    call SetChatVarsAttack(u)
    call Chat(chat)
  elseif u == null and HaveStoredInteger(amaiCache, t, "0") then
    call SetAllianceTarget(u)
    call FlushStoredInteger(amaiCache, t, "0")
  endif
  set t = null
endfunction

function ClearAllianceTarget takes unit old returns nothing
  if old == null or GetHandleId(old) == GetStoredInteger(amaiCache, Int2Str(ALLIANCE_TARGET), "0") then
    call SetAllianceTargetIfLead(null)
  endif
endfunction

//============================================================================
function BRRush takes nothing returns boolean
  local location loc = null
  local location l = null
  local unit u = null
  local unit utemp = null
  local group g = CreateGroup()
  local player p = null
  local integer i = 0
  call GroupEnumUnitsInRange(g, GetUnitX(rushcreep_target), GetUnitY(rushcreep_target),800,null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null or i == 1
    set p = GetOwningPlayer(u)
    if p != Player(PLAYER_NEUTRAL_AGGRESSIVE) and UnitAlive(u) and not IsUnitHidden(u) then
      if IsPlayerEnemy(ai_player,p) then
        set i = 1  // have other player
      elseif p == ai_player and GetUnitTypeId(u) == old_id[racial_rushcreep] then
        set utemp = u
      endif
    endif
    call GroupRemoveUnit(g, u)
  endloop
  call DestroyGroup(g)
  set g = null
  set p = null
  if i != 1 and utemp != null and GetUnitState(utemp, UNIT_STATE_LIFE) >= GetUnitState(utemp, UNIT_STATE_MAX_LIFE) * 0.65 then
    call Trace("Ancient Barracks Creep Rush Attack")
    set attack_running = true
    set br_rush_attacked = true
    call EnableRetreatControl()
    set l = GetUnitLoc(utemp)
    call IssueImmediateOrderById(utemp, OrderIdCancel) // Cancel building order
    call IssueImmediateOrder(utemp, "unroot")  //try unroot
    call FromGroupAndGhoulsAM(3) // unroot time
    call IssuePointOrder(utemp, "attack", GetUnitX(rushcreep_target), GetUnitY(rushcreep_target))
    call AttackMoveKill(rushcreep_target)
    call ReformUntilTargetDeadAM(rushcreep_target, true, false)
    call SleepInCombatAM(false)
    call Chat(C_Done)
    call Trace("===BR Finished===")
    set u = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), 'eaom', GetLocationX(l), GetLocationY(l), 270.0)
    set loc = GetUnitLoc(u)
    call RemoveUnit(u)
    set u = null
    call IssuePointOrderLoc(utemp, "root", loc)
    call TQAddUnitJob(10, RESET_ANCIENT, -1, utemp)
    // if not IssuePointOrderLoc(utemp, "root", l) then  //root tree , this code olny return false
    //   call IssuePointOrderLoc(utemp, "move", GetLocationX(l) + ISign() * GetRandomReal(200, 400), GetLocationY(l) + ISign() * GetRandomReal(200, 400))  // no remove GuardPosition , no need send root order
    // endif
    call RemoveLocation(loc)
    set loc = null
    call RemoveLocation(l)
    set l = null
  endif
  set attack_running = false
  set rushcreep_target = null // after attack ends put don't try to repeat as after a retreat tree may not be in a good position
  set utemp = null
  set u = null
  if br_rush_attacked then
    set br_rush_attacked = false
    return true
  endif
  return false
endfunction

//============================================================================
function AttackMoveKillAAM takes unit target, boolean ally_override returns nothing
  local real s = 0
  if target == null or not UnitAlive(target) then
    call Trace("Bad target passed to AttackMoveKillAAM")
    call Sleep(3 * sleep_multiplier)
    return
  endif
  set attack_running = true
  call DoAttackJobs()
  if distraction_group != 0 and GetOwningPlayer(target) != Player(PLAYER_NEUTRAL_AGGRESSIVE) and GetRandomInt(1,10) < 5 then
    set s = GetHarassGroupStrength(distraction_group)
    if s > 0 and s < GetOwnStrength() / 3 then
      call DoDistractionAttack(target)
    endif
  endif
  call AttackMoveKill(target)
  call ReformUntilTargetDeadAM(target, false, ally_override)
  call SleepInCombatAM(ally_override)
  call Chat(C_Done)
  call Trace("===Attack Fully Finished===")
  set attack_running = false
  call Sleep(2.5)
endfunction

//============================================================================
// Attack target code without the battle radius set so uses the creep radius
// and without distraction attack
function AttackMoveKillCreep takes unit target, boolean ally_override returns nothing
  if target == null or not UnitAlive(target) then
    call Trace("Bad target passed to AttackMoveKillCreep")
    call Sleep(3 * sleep_multiplier)
    return
  endif
  call FromGroupAndGhoulsAM(3)
  set attack_running = true
  call EnableRetreatControl()
  call AttackMoveKill(target)
  call ReformUntilTargetDeadAM(target, true, ally_override)
  call SleepInCombatAM(ally_override)
  call Chat(C_Done)
  call Trace("===Attack Fully Finished===")
  set attack_running = false
endfunction

//============================================================================
function AttackMoveKillXYAAM takes integer x, integer y returns nothing
  set attack_running = true
  call DoAttackJobs()
  if zep_next_wave then
    call LoadZepWave(x,y)
    set zep_next_wave = false
  endif
  call AttackMoveXY(x,y)
  set lastcaptainx = x
  set lastcaptainy = y
  call SleepUntilAtGoalAM()
  call SleepInCombatAM(true)
  set attack_running = false
endfunction

//============================================================================
function AttackMoveTowerRush takes nothing returns nothing
	local integer x = R2I(enemy_point_x)
	local integer y = R2I(enemy_point_y)
	local integer attack_length_counter = 0
	local integer i = 0
	local integer exp = 0
	local real threat = teleport_low_threat * 1.5
	local real d = 0
	local real md = 10000
	local group g = CreateGroup()
	local location l = GetStartLocationLoc(GetPlayerStartLocation(rushedplayer))
	local unit mine = null
	local unit u = null
	set break_attack = false
	loop
		exitwhen not towerrush
		exitwhen town_threatened and most_threatened_town >= 0 and town_threat[most_threatened_town] >= threat
		exitwhen break_attack and not teleporting
		exitwhen CaptainIsEmpty()  // all units died
		if tower_attack_run != true and (GetUnitCountDone(old_id[hero[1]]) + GetUnitCountDone(old_id[hero[2]]) + GetUnitCountDone(old_id[hero[3]])) > 0 and (race_tower_item_must != true or (race_tower_item_must == true and (builder[0] != null or tower_used_item))) then
			set tower_attack_run = true
			set attack_running = true
			if not town_threatened then
				call SetAllianceTargetIfLead(builder[10])
			endif
		elseif tower_attack_run then
			if take_exp and GetMinesOwned() < 2 and (mine == null or CheckExpansionTaken(mine)) then
				loop
					exitwhen i >= expansion_list_length
					if GetResourceAmount(expansion_list[i]) > 0 and not CheckExpansionTaken(expansion_list[i]) then
						set d = DistanceBetweenPoints_dk(GetUnitLoc(expansion_list[i]), l)
						if d < md then
							set md = d
							set mine = expansion_list[i]
							set exp = i
						endif
					endif
					set i = i + 1
				endloop
				if mine != null then
					set current_expansion_iswater = false
					set current_expansion = mine
					set current_expansion_creeps = exp
					set u = GetExpFoe(mine)
				endif
				set i = 0
			endif
			if mine != null and u != null and GetPlayerStrength(rushedplayer) < 3 and towers_built > 3 then
				call CreateDebugTag("TRush: take mine", 10, u, 4.00, 2.00)
				call Trace("TR : take mine" )
				call AttackMoveKillCreep(u, false)
				call ClearCaptainTargets()
				set u = null
			endif
			if not town_threatened then
				if builder[10] == null or not UnitAlive(builder[10]) then
					call GroupEnumUnitsInRange(g, enemy_point_x, enemy_point_y, 1200, null)
					set g = SelectUnittype(g, UNIT_TYPE_STRUCTURE, true)
					set g = SelectByAlive(g, true)
					set g = SelectByHidden(g,false)
					set builder[10] = FirstOfGroup(g)
					call GroupClear(g)
				endif
				if builder[10] != null and ModuloInteger(attack_length_counter + 1,6) == 0 then
					call SetAllianceTargetIfLead(builder[10])
				endif
			endif
			if towers_built < 4 then
				if tower_peon_inplace then
					if towers_built_count + force_number - 1 > 35 and towers_built < 2 then  //Prevent cannot build tower , but Enemy army is weak (maybe have ally attack), and AI not attack Enemy home
						call AttackMoveXY(R2I((x + first_tower_point_x) / 3),R2I((y + first_tower_point_y) / 3))
					elseif towers_built_count + force_number - 1 > 50 and towers_built < 2 then
						call AttackMoveXY(x,y)
					else
						call AttackMoveXY(R2I(first_tower_point_x),R2I(first_tower_point_y))
					endif
				else
					if tower_peon_point_x != 0 and tower_peon_point_y != 0 and ModuloInteger(attack_length_counter + 1,6) == 0 and not town_threatened then
						call GroupEnumUnitsInRange(g, tower_peon_point_x, tower_peon_point_y, 1200, null)
						set g = SelectUnittype(g, UNIT_TYPE_PEON, true)
						set g = SelectByPlayer(g, ai_player, true)
						set g = SelectByAlive(g, true)
						set g = SelectByHidden(g,false)
					endif
					set u = FirstOfGroup(g)  // Ensure always give U a value
					if u != null then
						call AttackMoveXY(R2I(GetUnitX(u)),R2I(GetUnitY(u)))
					elseif builder[1] != null and UnitAlive(builder[1]) then
						call AttackMoveXY(R2I(GetUnitX(builder[1])),R2I(GetUnitY(builder[1])))
					else
						call AttackMoveXY(R2I(first_tower_point_x),R2I(first_tower_point_x))
					endif
					call GroupClear(g)
				endif
			elseif towers_built < 7 then
				if second_attack_point_x != 0 and second_attack_point_y != 0 then
					call AttackMoveXY(R2I(second_attack_point_x),R2I(second_attack_point_y))
				else
					call AttackMoveXY(R2I((x + first_tower_point_x) / 2),R2I((y + first_tower_point_y) / 2))
				endif
			else
				call AttackMoveXY(x,y)
			endif
			set attack_length_counter = attack_length_counter + 1
		endif
		call StaggerSleep(1*sleep_multiplier, 2*sleep_multiplier)
		//call AttackMoveKill(builder[20])
		//if towers_built == 0 then
			//call CreateDebugTag("Reform protect peon", 10, builder[1], 2.00, 1.50)
			//call AttackMoveKill(builder[1])
		//else
			//call SetCaptainHome(BOTH_CAPTAINS,R2I(((enemy_point_x - first_tower_point_x)/ 4) + first_tower_point_x),R2I(((enemy_point_y - first_tower_point_y)/ 4) + first_tower_point_y))
			//call SetCaptainHome(BOTH_CAPTAINS, R2I(enemy_point_x), R2I(enemy_point_y))
			//if towers_built < 3 then
				//call AttackMoveXY(R2I(enemy_point_x), R2I(enemy_point_y))
				//call AttackMoveXY(R2I(((enemy_point_x - first_tower_point_x)/ 6) + first_tower_point_x), R2I(((enemy_point_y - first_tower_point_y)/ 6) + first_tower_point_y))
			//elseif towers_built < 6 then
				//call AttackMoveXY(R2I(((enemy_point_x - first_tower_point_x)/ 3) + first_tower_point_x), R2I(((enemy_point_y - first_tower_point_y)/ 3) + first_tower_point_y))
			//elseif towers_built <= 9 then
				//call AttackMoveXY(R2I(enemy_point_x), R2I(enemy_point_y))
			//endif
		//endif
		if attack_length_counter > attack_reform_length * 2 then
			set attack_length_counter = 0
			call FromGroupAndGhoulsAM(0)
			if towers_built >= 7 or (towers_built_count + force_number - 1 > 50 and towers_built < 2) then
				call GroupEnumUnitsInRange(g, enemy_point_x, enemy_point_y, 1800, null)
				set g = SelectByEnemy(g, ai_player, true)
				set g = SelectUnittype(g, UNIT_TYPE_STRUCTURE, true)
				set g = SelectByAlive(g, true)
				set g = SelectByHidden(g,false)
				set u = FirstOfGroup(g)
				if u != null then
					set x = R2I(GetUnitX(u))
					set y = R2I(GetUnitY(u))
				endif
				call GroupClear(g)
			endif
		endif
	endloop
	call DestroyGroup(g)
	set g = null
	call RemoveLocation(l)
	set l = null
	set u = null
	set attack_running = false
	call ClearAllianceTarget(null)
	call ClearCaptainTargets()
endfunction

//============================================================================
function GetIntervalCreep takes unit u, integer lower, integer upper, integer str, integer anti_air_strength, boolean allow_air, integer sd returns unit
  local integer creepstrength = 0
  local integer creepstrengthalt = 0
  local integer creepstrength_air = 0
  local unit alt = null
  local integer middle = (lower + upper) / 2

  if sd < 0 then
    return null
  endif
  set u = GetCreepCamp(1, middle, allow_air)
  set alt = GetCreepCamp(1, middle, false)
  if u == null and alt == null then
    return GetIntervalCreep(u, middle, upper, str, anti_air_strength, allow_air, sd - 1)
  endif
  if u != null then
    set creepstrength = GetCreepCampStrength(u) + 1
    set creepstrength_air = air_strength
  endif
  if alt != null then
    set creepstrengthalt = GetCreepCampStrength(alt) + 1
    set creepstrength_air = air_strength
  endif
  if balancing then
    //call Trace("Creep strength: " + Int2Str(creepstrength))
    call PingMinimap(GetUnitX(u), GetUnitY(u), 1)
  endif
  if u != null and creepstrength < str then
    if creepstrength_air <= anti_air_strength then
      set alt = null
      return u
    elseif alt != null and creepstrengthalt < str then
      set u = alt
      set alt = null
      return u
    endif
  elseif alt != null and creepstrengthalt < str then
    set u = alt
    set alt = null
    return u
  endif
  set alt = null
  return GetIntervalCreep(u, lower, middle, str, anti_air_strength, allow_air, sd - 1)
endfunction

//============================================================================
function GetFittingCreep takes unit u, integer str returns unit
  local integer anti_air_strength = R2I(GetPlayerAntiAirStrength(ai_player))
  local integer creepstrength = 0
  local integer creep_air_strength = 0
  local boolean allow_air = false
  local integer lvl = str

  set u = GetCreepCamp(1, lvl, true)
  if u != null then
    set creep_air_strength = GetLocationCreepAirStrength(GetUnitX(u), GetUnitY(u), creep_camp_radius)
    //set air_strength = creep_air_strength
  endif
  set allow_air = creep_air_strength <= anti_air_strength

  if not allow_air then
    set u = GetCreepCamp(1, lvl, false)
  endif

  //call Trace("Our strength: " + Int2Str(str))
  if u != null then
    set creepstrength = GetCreepCampStrength(u)
  endif
  if u != null and creepstrength < str and creep_air_strength <= anti_air_strength then
    //call Trace("Creep match")
    call Trace("Creeping strength: " + Int2Str(creepstrength))
    //set air_strength = creepstrength
    return u
  endif
  return GetIntervalCreep(u, 1,100,str, anti_air_strength, allow_air, camp_scan_depth)
endfunction

//============================================================================
function CreepAttack takes integer str returns nothing
  local unit target = null
  local integer creepair = 0
  if str < 1 or not CreepsOnMap() then
    call Trace("own no strength or no creeps")
    call Sleep(3 * sleep_multiplier)
    return
  endif
  set target = GetFittingCreep(target,str)
  set creepair = air_strength
// Creep camp small is level 1 - 9
// Creep camp medium is level 10 - 19
// Creep camp strong is level 20 - 100

  if target == null then
    call Trace("No creep target found")
    call Sleep(3 * sleep_multiplier)
    return
  endif
  if creepair > 15 then
    call SetAllianceTargetIfLeadAndChat(target, C_Creep)
  endif
  call AttackMoveKillCreep(target, true)
  call ClearAllianceTarget(target)
  set target = null
endfunction

//============================================================================
function QueueAttackMoveXY takes integer x, integer y returns nothing
  set attack_running = true
  call DoAttackJobs()
  loop
    call Sleep(sleep_multiplier)
    call AttackMoveXY(x,y)
    exitwhen break_attack or player_defeated
    exitwhen CaptainRetreating()
    exitwhen CaptainAtGoal()
    call Sleep(sleep_multiplier)
  endloop
  set lastcaptainx = x
  set lastcaptainy = y
  call SleepInCombatAM(false)
  if CaptainAtGoal() then
    call QueueGetNextCommand()
  endif
  set attack_running = false
endfunction

//============================================================================
// (AMAI)  ChooseAttackTarget
//============================================================================
function GetRangePenalty takes unit target returns real
  if major_hero == null or not UnitAlive(major_hero) or not UnitAlive(target) then
    return DistanceBetweenPoints_kd(home_location, GetPlayerStartLocationLoc(GetOwningPlayer(target)))
  endif
  return DistanceBetweenUnits(major_hero, target) / 1400
endfunction

//============================================================================
function GetWeakestEnemy takes nothing returns player
  local integer i = 0
  local integer pmin = 30
  local integer minstr = 1000
  local integer cstr = 0
  local unit u = null
  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set cstr = GetUnexactPlayerStrength(enemy_force[i])
      if cstr < minstr then
        set u = GetBuilding(enemy_force[i])
        if u != null and UnitAlive(u) then
          set pmin = i
          set minstr = cstr
        endif
      endif
    endif
    set i = i + 1
  endloop
  set u = null
  if pmin != 30 then
    return enemy_force[pmin]
  endif
  return null
endfunction

//============================================================================
function GetStrongestEnemy takes nothing returns player
  local integer i = 0
  local integer pmax = 30
  local integer maxstr = 0
  local integer cstr = 0
  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set cstr = GetUnexactPlayerStrength(enemy_force[i])
      if cstr > maxstr then
        set pmax = i
        set maxstr = cstr
      endif
    endif
    set i = i + 1
  endloop
  if pmax != 30 then
    return enemy_force[pmax]
  endif
  return null
endfunction

//============================================================================
function GetWeakAndNearEnemy takes nothing returns player
  local integer i = 0
  local integer pmin = -1
  local real minstr = 10000
  local real cstr = 0
  local unit cbuilding = null
  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set cbuilding = GetBuilding(enemy_force[i])
      if cbuilding != null and UnitAlive(cbuilding) then
        set cstr = GetUnexactPlayerStrength(enemy_force[i]) + GetRangePenalty(cbuilding)
        if cstr < minstr then
          set pmin = i
          set minstr = cstr
        endif
      endif
    endif
    set i = i + 1
  endloop
  set cbuilding = null
  if pmin != -1 then
    return enemy_force[pmin]
  endif
  //   call Trace("Debug: GetWeakAndNearEnemy failed!")
  return null
endfunction

//============================================================================
function GetNearestEnemy takes nothing returns player
local integer i = 0
local integer nearplayer = 30
local real dist = 0
local real mindistance = 1000000

loop
  exitwhen i >= c_enemy_total
  if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
    set dist = DistanceBetweenPoints_kd(home_location, GetPlayerStartLocationLoc(enemy_force[i]))
    if dist < mindistance then
      set mindistance = dist
      set nearplayer = i
    endif
  endif
  set i = i + 1
endloop
if nearplayer != 30 then
  return enemy_force[nearplayer]
endif
return null
endfunction

//============================================================================
function GetSecondNearestEnemy takes nothing returns player
  local integer i = 0
  local integer pmin = -1
  local integer spmin = -1
  local real minstr = 10000
  local real sminstr = 10000
  local real cstr = 0
  local unit cbuilding = null
  loop
    exitwhen i >= c_enemy_total
    if GetPlayerSlotState(enemy_force[i]) == PLAYER_SLOT_STATE_PLAYING then
      set cbuilding = GetBuilding(enemy_force[i])
      if cbuilding != null and UnitAlive(cbuilding) then
        set cstr = GetRangePenalty(cbuilding)
        if cstr < minstr then
          set spmin = pmin
          set pmin = i
          set sminstr = minstr
          set minstr = cstr
        elseif cstr < sminstr then
          set spmin = i
          set sminstr = cstr
        endif
      endif
    endif
    set i = i + 1
  endloop
  set cbuilding = null
  if spmin != -1 then
    return enemy_force[spmin]
  endif
  //   call Trace("Debug: GetSecondNearestEnemy failed!")
  return null
endfunction

function GetNearHumanPlayerEnemy takes unit u returns unit
  local group g = CreateGroup()
  if nearest_human_enemy == null or GetPlayerSlotState(nearest_human_enemy) != PLAYER_SLOT_STATE_PLAYING then
    call SetNearestEnemy()
  endif
  if nearest_human_enemy != null then
    call GroupEnumUnitsOfPlayer(g, nearest_human_enemy, null)
    set g = SelectUnittype(g, UNIT_TYPE_TOWNHALL, true)
    set g = SelectByAlive(g, true)
    set g = SelectByHidden(g, false)
    set u = FirstOfGroup(g)
  endif
  call DestroyGroup(g)
  set g = null
  return u
endfunction

//============================================================================
function GetFFAEnemy takes nothing returns player
  if GetRandomInt(1, 3) == 1 then
    return GetSecondNearestEnemy()
  else
    return GetNearestEnemy()
  endif
endfunction

//============================================================================
function GetTowerFactor takes unit target returns real
  local real tstrength = GetLocationTowerStrength(GetUnitX(target), GetUnitY(target), ver_tower_check_radius)
  if h_siege then
    return tstrength
  else
    return 4*tstrength
  endif
endfunction

//============================================================================
function GetRace takes player p returns integer
  return player_race[GetPlayerId(p)]
endfunction

//============================================================================
function GetRaceAggression takes unit target returns integer
  if GetPlayerId(GetOwningPlayer(target)) < PLAYER_NEUTRAL_AGGRESSIVE then
    return race_aggression[Max((GetRace(GetOwningPlayer(target)) - 1) * tiernum + tier - 1,0)]
  endif
  return 0
endfunction

//============================================================================
function GetTargetStrength takes unit target returns integer
  local integer str = GetUnexactPlayerStrength(GetOwningPlayer(target))
  if str < 100 then
    set str = Min(str + R2I(GetRangePenalty(target)), 100)
  endif
  return str
endfunction

//============================================================================
function GetEnemyAllyStrength takes player tp returns integer
  local integer i = 0
  local integer ally_sum = 0
  local integer enemy_sum = 0
  local player p = null
  loop
    exitwhen i >= GetBJMaxPlayers()
    set p = Player(i)
    if GetPlayerSlotState(p) == PLAYER_SLOT_STATE_PLAYING and not IsPlayerObserver(p) then
      if p != ai_player and p != tp then
        if IsPlayerAlly(p, ai_player) then
          set ally_sum = ally_sum + R2I(GetPlayerStrength(p))
        elseif IsPlayerAlly(p, tp) then
          set enemy_sum = enemy_sum + GetUnexactPlayerStrength(p)
        endif
      endif
    endif
    set i = i + 1
  endloop
  set p = null
  return (enemy_sum - ally_sum) / 2
endfunction

//============================================================================
function IsTargetGood takes unit target, integer attacker_bonus returns boolean
  if target != null then
    set added_target_aggression = attacker_bonus
    set added_racial_aggression = GetRaceAggression(target)
    return GetTargetStrength(target) + GetTowerFactor(target) <= own_strength + attacking_aggression + added_aggression + added_racial_aggression + attacker_bonus
  else
    return false
  endif
endfunction

//============================================================================
function ChooseEnemyExpansionTarget takes unit u returns unit
  set u = GetEnemyExpansion()
  if u != null then
    if IsTargetGood(u, expansion_target_bonus) then
      call Trace("Hardcoded enemy expansion target chosen")
    else
      set u = null
    endif
  endif
  return u
endfunction

//============================================================================
function ChooseEnemyBaseTarget takes unit u returns unit
  local integer c = 0
  call StartGetEnemyBase()
  loop
    exitwhen not WaitGetEnemyBase()
    if c > 4 or town_threatened or isfleeing or CaptainIsEmpty() then
      return null
    endif
    call Sleep(1)
    set c = c + 1
  endloop
  set u = GetEnemyBase()
  if u != null and IsTargetGood(u, comp_chosen_target_bonus) then
    call Trace("Hardcoded Enemy Base Target chosen")
    return u
  endif
  return null
endfunction

//============================================================================
function ChooseAnEnemyTarget takes unit u returns unit
  local player target_enemy = null
  local group g = CreateGroup()
  local location enemy_base = null

  if attacking_strategy == 1 or attacking_strategy == 3 then
    set target_enemy = GetWeakestEnemy()
    //call Trace("Chooing Weakest Enemy")
  elseif attacking_strategy == 2 then
    set target_enemy = GetStrongestEnemy()
    //call Trace("Choosing Strongest Enemy")
  elseif attacking_strategy == 5 then
    set target_enemy = GetFFAEnemy()
    //call Trace("Choosing FFA Enemy")
  else
    set target_enemy = GetWeakAndNearEnemy()
    //call Trace("Choosing weakest closest Enemy")
  endif
  if target_enemy != null then
    call GroupEnumUnitsOfPlayer(g, target_enemy, null)
    set enemy_base = GetPlayerStartLocationLoc(target_enemy)
    set g = SelectUnittype(g, UNIT_TYPE_TOWNHALL, true)
    set g = SelectByLocation(g, enemy_base, 1000, false)
    set g = SelectByAlive(g, true)
    set g = SelectByHidden(g, false)
    set u = FirstOfGroup(g)
    if u == null then
      set u = GetBuilding(target_enemy)
    endif
    call RemoveLocation(enemy_base)
    set enemy_base = null
    set target_enemy = null
  endif
  call DestroyGroup(g)
  set g = null
  return u
endfunction

function ChooseAnyEnemyTarget takes unit u returns unit
  local player p = null
  set u = ChooseAnEnemyTarget(u)
  if IsTargetGood(u,0) then
    call Trace("Enemy Advanced Target Chosen")
    set alli_target = u
    if attacking_strategy == 3 then
      set p = GetStrongestEnemy()
      if p != null then
        set alli_target = GetBuilding(p)
        set p = null
      endif
    endif
    return u
  endif
  return null
endfunction

//============================================================================
function ChooseAttackTarget takes unit u returns unit
  //call DisplayToAll("Choosing attack target")
  set alli_target = null
  if GetRandomReal(0.0,1.0) > comp_chosen_target_rate then
    set u = ChooseEnemyExpansionTarget(u)
    if u == null then
      //call DisplayToAll("Attack enemy Base")
      set u = ChooseEnemyBaseTarget(u)
    endif
    set alli_target = u
  endif

  if u == null then
    set u = ChooseAnyEnemyTarget(u)
  endif
  return u
endfunction

//============================================================================
// Militia Expansion melee attack
//============================================================================
function Militia_Expansion takes integer m returns nothing
  local group g = null
  local group cg = null
  local unit u = null
  local unit efoe = null
  local integer t = 0
  if IsUnitInGroup(current_expansion,water_expansion) then  //is WaterExpansion
    return
  endif
  set efoe = GetExpFoe(efoe)
  if efoe == null then
    return
  endif
  set g = CreateGroup()
  set break_attack = false  // to persuade attack system to hopefully not exit early and do the reforming behaviour
  set militia_check_enabled = false
  //call BuildExpa( TownCount(racial_expansion)+1, racial_expansion, farm_prio + 50 )
  call DisplayToAlliesChat(militia_expansion_chat)
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  set g = SelectNumberOfId(g, 100, old_id[racial_peon])
  set g = SelectByAlive(g, true)
  set g = GetNearestSubGroupOfGroup(g, home_location, m)
  //set expansion_peon = FirstOfGroup(g)
  call AddAbilityToGroup(CopyGroup(g,cg), race_militia_ability)
  call GroupImmediateOrder(g, race_militia_unitstring)
  call RemoveInjuries()
  call FormGroupAM(4)
  loop
    exitwhen AreUnitsOfType(g, race_militia_id)
    exitwhen t > 4
    call Sleep(1)
    set t = t + 1
  endloop
  //call AddAssault(m, old_id[racial_militia])   // Lil problem with adding assaults. For some reasons
  //call AttackMoveKill(efoe)
  call GroupPointOrder(g, "attack", GetUnitX(current_expansion), GetUnitY(current_expansion))
  set town_threat_break = false
  //set captain_flee = false
  //call SetCaptainHome(ATTACK_CAPTAIN, GetUnitX(efoe), GetUnitY(efoe)) //
  //call AttackMoveKillCreep(efoe, false)
  set attack_running = true
  //if not retreat_controlled then
  //  call Trace("===Retreat control started===")
  //  set retreat_controlled = true
  //  call SetGroupsFlee(false)
  //  call SetTargetHeroes(false)
  //  call TQAddJob(2 * sleep_multiplier, RETREAT_CONTROL, 0)
  //endif
  call AttackMoveKill(efoe)
  call SleepUntilTargetDeadAM(efoe, true, false)
  call SleepInCombatAM(false)
  call Chat(C_Done)
  call Trace("===Attack Fully Finished===")
  //call GroupPointOrder(g, "move", GetLocationX(home_location), GetLocationY(home_location))  //no need
  call GroupImmediateOrder(g, "militiaoff")
  set attack_running = false
  //call SetCaptainHome(ATTACK_CAPTAIN, GetLocationX(home_location), GetLocationY(home_location))
  set militia_check_enabled = true
  set town_threat_break = true
  //set captain_flee = true
  //set militia = false
  set take_exp = false
  call DestroyGroup(g)
  set g = null
  set cg = null
  set efoe = null
  set u = null
endfunction

//============================================================================
// (AMAI) Defending
//============================================================================
function SleepUntilTownDefended takes integer ai_strength returns nothing
  local integer defense_length_counter = 0
  local integer enemy_army = -1
  local boolean b = CaptainIsHome()
  //set own_strength = ai_strength
  call Trace("==Sleep Defend Town==" )
  if not b and not CaptainRetreating() then
    call CaptainGoHome()
  endif
  // Attack logic still overridden by allies, so commented out - just return to home location 
  //call FormGroupAM(0)
  //if town_threatened and most_threatened_town >= 0 then
    // We want to intercept the army
  //   set enemy_army = town_threat_army[most_threatened_town]
  //   call CaptainAttack(GetLocationX(army_loc[enemy_army]), GetLocationY(army_loc[enemy_army]))// Not attack move to get here fast
  // else
  //   call CaptainAttack(GetLocationX(captain_home), GetLocationY(captain_home)) // Unknown where the threat is return home
  // endif
  loop
    //call DisplayToAll("Town Threatened:" + B2S(town_threatened) + " HardTown Threatened:" + B2S(TownThreatened()) + " CaptainInCombat:" + B2S(CaptainInCombat(false)) + " i:" )
    call CreateDebugTagLoc("Sleep until town defended", 10, GetLocationX(captain_home), GetLocationY(captain_home), 1.00, 0.80)
    exitwhen not town_threatened and not TownThreatened() and not CaptainInCombat(false)
    exitwhen player_defeated
    set defense_length_counter = defense_length_counter + 1
    if defense_length_counter > attack_reform_length then
      set defense_length_counter = 0
      //call FormGroupAM(0)
    endif
    if not b then
      set b = CaptainIsHome()
      if not b then
        call CaptainGoHome()
      endif
    endif
    //if CaptainAtGoal() or CaptainInCombat(true) or CaptainInCombat(false) then
      // Attack move to actually defend
    //   if town_threatened and most_threatened_town >= 0 then
    //   set enemy_army = town_threat_army[most_threatened_town]
    //     call AttackMoveXY(R2I(GetLocationX(army_loc[enemy_army])), R2I(GetLocationY(army_loc[enemy_army]))) // Only attack move when at target
    //   else
    //     call AttackMoveXY(R2I(GetLocationX(captain_home)), R2I(GetLocationY(captain_home)))
    //   endif
    // else
      // This ensures units return to defend location and don't wonder
    //   if town_threatened and most_threatened_town >= 0 then
    //   set enemy_army = town_threat_army[most_threatened_town]
    //     call CaptainAttack(GetLocationX(army_loc[enemy_army]), GetLocationY(army_loc[enemy_army]))// Not attack move to get here fast
    //   else
    //     call CaptainAttack(GetLocationX(captain_home), GetLocationY(captain_home)) // Unknown where the threat is return home
    //   endif
    // endif
    call StaggerSleep(2 * sleep_multiplier, (2 * sleep_multiplier) + 2)
  endloop
  call CaptainGoHome()
  call Trace("==exit Sleep Defend Town==")
endfunction

function AncientExpaAttack takes nothing returns nothing
  //local location loc = null
  //local real attacktimer = 0
  //local integer i = 0
  //local real creepstrength = 0
  call Trace("An Ancient Expansion Attack")
  set break_attack = false
  set attack_running = true
  set ancient_attack_running = true
  call FromGroupAndGhoulsAM(3)
  // if (ancient_exp_creep != null and UnitAlive(ancient_exp_creep)) then
  //   set loc = GetUnitLoc(ancient_exp_creep)
  // else
  //   set loc = GetUnitLoc(ancient_exp_mine)
  // endif
  // loop
  //   exitwhen CaptainAtGoal() or DistanceBetweenPoints(army_loc[main_army], loc) < 500 // Attack force at ancient
  //   exitwhen desperation_assault or break_attack
  //   exitwhen town_threat_break and town_threatened and most_threatened_town >= 0 and town_threat[most_threatened_town] >= teleport_high_threat
  //   exitwhen ancient_exp_unit == null or not UnitAlive(ancient_exp_unit) or not ancient_exp_maintree or TownCount(racial_expansion) < 1
  //   exitwhen isfleeing or CaptainRetreating() or CaptainIsEmpty()
  //   call CaptainAttack(GetUnitX(ancient_exp_unit), GetUnitY(ancient_exp_unit))
  //   call Sleep(2)
  // endloop
  // call IssuePointOrderLoc(ancient_exp_unit, "attack", loc)
  // call RemoveLocation(loc)
  // set loc = null
  //set creepstrength = GetAncientCampStrength()
  //if GetOwnStrength() >= creepstrength then
    // Just creep normally as safer if tree not actually required in attack
  call AttackMoveKillCreep(ancient_exp_creep, false)
  //endif
  //call IssueTargetOrder(ancient_exp_unit, "entangle", ancient_exp_mine)
  set ancient_attack_running = false
  set attack_running = false
endfunction

function SetLeadAlly takes nothing returns nothing
  local integer i = 0
  local boolean checkdone = false
  local player p = null
  loop
    exitwhen i >= GetBJMaxPlayers() or checkdone
    set p = Player(i)
    if GetPlayerSlotState(p) == PLAYER_SLOT_STATE_PLAYING and IsPlayerAlly(p, ai_player) and GetPlayerController(p) == MAP_CONTROL_COMPUTER then
      if p != ai_player then
        set leadally = false
        set checkdone = true
      elseif p == ai_player then
        set leadally = true
        set checkdone = true
      endif
    endif
    set i = i + 1
  endloop
  set p = null
endfunction

//============================================================================
// AMAI SingleMeleeAttack
//============================================================================
function SingleMeleeAttackAM takes boolean needs_exp, boolean has_siege, integer ai_strength returns nothing
local unit hall = null
local unit mega = null
local unit creep = null
local unit common = null
local unit humanhall = null

//call Trace("SingleMeleeAttack")

if desperation_assault and not no_attack then
  // Perpetual attack regardless of power or strength
  if c_ally_total > 0 then
    call SetLeadAlly()
    if difficulty != EASY then
      set common = I2U(GetStoredInteger(amaiCache, Int2Str(ALLIANCE_TARGET), "0")) //GetAllianceTarget()
      if common != null then
        call Trace("===Desperation Attack Alliance Target===")
        //call Chat(C_Ally)
        call FromGroupAndGhoulsAM(3)
        call DesperationAssault()
        call AttackMoveKillAAM(common, true)
        call ClearAllianceTarget(common)
        set common = null
        return
      endif
    endif
  endif

  set common = ChooseAnEnemyTarget(common)
  if (common != null) then
    call Trace("===Desperation Attack Random Enemy Target===")
    call SetAllianceTargetIfLeadAndChat(common, C_Ally)
    call FromGroupAndGhoulsAM(3)
    call DesperationAssault()
    call AttackMoveKillAAM(common, true)
    call ClearAllianceTarget(common)
    set common = null
    return
  endif

endif

if town_threatened then
  set break_attack = false
  call SleepUntilTownDefended(ai_strength)
  return
endif

call Trace("===Single Melee Attack===" )
call Trace("AI strength: " + Int2Str(ai_strength))

set h_siege = has_siege
set own_strength = ai_strength

call set_aggression()


// Commander Control Attacks
//
if no_attack then
  call Trace("No Attack is on" )
  call Sleep(4 * sleep_multiplier)
  call ClearCaptainTargets()
  return
endif

if queue_running then

  if queue_attack_p then
    call Trace("Attacking point "+Int2Str(queue_t_x)+","+Int2Str(queue_t_y) )
    call FromGroupAndGhoulsAM(3)
    call QueueAttackMoveXY(queue_t_x, queue_t_y)
    call Trace("Point reached or aborted" )
    return

  elseif queue_attack_u then
    if queue_t_u == null then
      call Trace("No unit targeted, queue stopped" )
      set queue_running = false
    elseif not UnitAlive(queue_t_u) then
      call Trace("Unit is dead, next command" )
      call QueueGetNextCommand()
    else
      call Trace("Attacking unit" )
      call FromGroupAndGhoulsAM(3)
      call AttackMoveKillAAM(queue_t_u, false)
      call Trace("Attack complete" )
      return
    endif
  endif

endif

if attack_player then
  call Trace("Attacking player" )
  set hall = GetBuilding(Player(attack_target_p))
  if hall == null then
    call Trace("No target found" )
    set attack_player = false
    return
  endif
  call FromGroupAndGhoulsAM(3)
  call AttackMoveKillAAM(hall, false)
  call Trace("Attack complete" )
  set hall = null
  return
endif

if attack_point then
  call Trace("Attacking point "+Int2Str(attack_target_x)+","+Int2Str(attack_target_y) )
  call FromGroupAndGhoulsAM(3)
  call AttackMoveKillXYAAM(attack_target_x, attack_target_y)
  call Trace("Attack complete" )
  return
endif

if attack_unit then
  if target_unit == null then
    call Trace("No unit targeted" )
    set attack_unit = false
  elseif not UnitAlive(target_unit) then
    call Trace("Unit is dead" )
    set attack_unit = false
  else
    call Trace("Attacking unit" )
    call FromGroupAndGhoulsAM(3)
    call AttackMoveKillAAM(target_unit, false)
    call Trace("Attack complete" )
    return
  endif
endif

if not creeping_only then	// Do the normal attack sequence

  // tower rush attack
  //
  if towerrush then
    call Trace("A Tower Rush Attack")
    call FromGroupAndGhoulsAM(0)
    call AttackMoveTowerRush()
    return
  endif

  // militia expansion
  //
  if militia_expanding then
    if current_expansion == null then
      call Trace("Militia expansion Attack but none found")
    else
      call Trace("A Militia Expansion")
      call Militia_Expansion(6)
      set militia_exp_attack = false
      return
    endif
  endif

  // ancient expansion attack
  //
  if ancient_expanding and GetOwnStrength() >= GetAncientCampStrength() then
    if (ancient_exp_state == 2 or ancient_exp_state == 3) and ancient_exp_unit != null and UnitAlive(ancient_exp_unit) then
      call AncientExpaAttack()
    else
      call Trace("Prep for ancient expand")  // Don't do new attacks yet as nearly ready to help expansion
    endif
    return
  endif

  if rushcreep_target != null and UnitAlive(rushcreep_target) and GetLocationCreepStrength(GetUnitX(rushcreep_target), GetUnitY(rushcreep_target), 510) < own_strength + 5 then // Matches getOwnStrength +5 addition for ancient
    set battle_radius = creep_battle_radius 
    call Trace("ELF BR Attack")
    if BRRush() then
      return
    endif
    set battle_radius = normal_battle_radius
  endif

  // defend expansion from other expansion
  //
  if double_expansion_target != null and IsTargetGood(double_expansion_target, 10) then
    call Trace("Double Expansion Attack")
    call SetAllianceTargetIfLeadAndChat(double_expansion_target, C_Ally)
    call FromGroupAndGhoulsAM(3)
    call AttackMoveKillAAM(double_expansion_target, false)
    call ClearAllianceTarget(double_expansion_target)
    if not UnitAlive(double_expansion_target) then
      set double_expansion_target = null
    endif
    return
  endif

  if not (no_creep_attack or ai_no_creep) then

    // take expansions as needed
    //
    if needs_exp and first_expansion_chosen then
      if current_expansion == null or CheckExpansionTaken(current_expansion) then
        call Trace("Need expansion but no valid free expansion available")
      else
        set creep = GetExpFoe(creep)
        if creep != null then
          call Trace("Creep the Expansion")
          set attacking_expansion = true
          set battle_radius = creep_battle_radius
          call SetAllianceTargetIfLeadAndChat(creep, C_Expansion)
          call AttackMoveKillCreep(creep, false)
          call ClearAllianceTarget(creep)
          if creep == null or not UnitAlive(creep) then
            set take_exp = false
          endif
          call Sleep(10)
          set attacking_expansion = false
          set creep = null
          return
        endif
      endif
    endif
  endif

  // coordinate with allies
  //
  if c_ally_total > 0 then
    call SetLeadAlly()
    if difficulty != EASY then
      set common = I2U(GetStoredInteger(amaiCache, Int2Str(ALLIANCE_TARGET), "0")) //GetAllianceTarget()
      if common != null then
        call Trace("Attack Alliance Target")
        //call Chat(C_Ally)
        call FromGroupAndGhoulsAM(3)
        call AttackMoveKillAAM(common, true)
        call Trace("Attack Alliance Target complete")
        call ClearAllianceTarget(common)
        set common = null
        return
      endif
    endif
  endif

  if not no_player_attack then
    if firstattackhp then
      set humanhall = GetNearHumanPlayerEnemy(humanhall)
      if tier > 2 or humanhall == null then  // Closing mechanism
        set firstattackhp = false
      endif
      if humanhall != null then
        call Chat(C_Attack)
        call Trace("Attack real human player")
        call SetAllianceTargetIfLead(humanhall)
        call FromGroupAndGhoulsAM(3)
        call AttackMoveKillAAM(humanhall, true)
        call ClearAllianceTarget(humanhall)
        set humanhall = null
        return
      endif
    endif

    // all-out attack if the player is weak
    //
    if difficulty != EASY then
      set mega = GetMegaTarget()
      if mega != null and UnitAlive(mega) then
        call Trace("Mega Attack Target")
        call SetAllianceTargetIfLeadAndChat(mega, C_Megatarget)
        //call SetChatVarsAttack(mega)
        call Chat(C_Mega) // This chat is to enemies not allies
        call FromGroupAndGhoulsAM(3)
        call AttackMoveKillAAM(mega, true)
        call ClearAllianceTarget(mega)
        set mega = null
        return
      endif
      set mega = null
    endif

    if GetHeroXP(hero_unit[1]) < GetRandomInt(50,150) or GetHeroXP(hero_unit[1]) > GetRandomInt(300,850) or GetHeroXP(hero_unit[2]) > 450 or FoodUsed() > GetRandomInt(40,60) then
      set hall = ChooseAttackTarget(hall)
      if hall != null and UnitAlive(hall) then
        call SetAllianceTargetIfLeadAndChat(alli_target, C_Attack)
        call Trace("Attack Choose target")
        call FromGroupAndGhoulsAM(3)
        call AttackMoveKillAAM(hall, true)
        //call ClearAllianceTarget(null)
        set hall = null
        return
      endif
      set hall = null
    endif
  endif
endif // if not creep only

if no_creep_attack or ai_no_creep then
  call Trace("no creeping" )
  call Sleep(4 * sleep_multiplier)
  return
endif

// nothing better to do, so kill a creep camp
//
set battle_radius = creep_battle_radius

call Trace("Just gonna be creeping")
call CreepAttack(own_strength)

endfunction


//============================================================================
//  SkillArraysAM
//============================================================================
function SkillArraysAM takes nothing returns integer
  local integer level = GetHeroLevelAI()
  local integer hn = GetHeroNumber(GetHeroId())
  if level > max_hero_level then
    set max_hero_level = level
  endif
  if skillfix == true and hero_unit[hn] != null and UnitAlive(hero_unit[hn]) then    //Assisted Hero Learning Skills , for war3 1.31 bug
    call SelectHeroSkill(hero_unit[hn], skills[(hn - 1) * HERO_LEVEL_NUMBER + level])
  endif
  return skills[(hn - 1) * HERO_LEVEL_NUMBER + level]
endfunction

//============================================================================
function StoreSkills takes integer ta returns nothing
  local integer i = 1
  loop
    exitwhen i > HERO_LEVEL_NUMBER
    set skills[(ta - 1) * HERO_LEVEL_NUMBER + i] = tempskills[i]
    set i = i + 1
  endloop
endfunction

//============================================================================
function LoadSkillsExt takes integer sa returns nothing
  local integer i = 1
  loop
    exitwhen i > HERO_LEVEL_NUMBER
    set tempskills[i] = allskills[sa + i]
    set i = i + 1
  endloop
endfunction

//============================================================================
// sa = tier hero picked at, hn = hero number, ta is again tier hero picked at
function LoadSkills takes integer sa, integer hn, integer ta returns nothing
  local integer perc = GetRandomInt(0,major_hero_skill_value+minor_hero_skill_value+rare_hero_skill_value)
  local integer sk = 0	// is which of the 3 skill lines is chosen

  if perc <= rare_hero_skill_value then
    set sk = HERO_SKILL_RARE
  elseif perc <= minor_hero_skill_value+rare_hero_skill_value then
    set sk = HERO_SKILL_MINOR
  endif
  set hero_skills[sa] = sk // set global variable so we can use the fact of knowning what skill was chosen in AMAI
  call LoadSkillsExt((sa-1)*3*HERO_LEVEL_NUMBER + sk*HERO_LEVEL_NUMBER + (hn-1)*9*HERO_LEVEL_NUMBER)
  call StoreSkills(ta)
endfunction

//============================================================================
//  AwaitMeleeHeroesAM
//  Ensure we have a hero available
//============================================================================
//============================================================================
// (AMAI) HeroHealingBugFix
//  Fixes the bug where for some reason the hero dosn't get removed from the
//  healing group. Micro usage e.g. health fountain or returning home puts
//  the hero in the healing groups so a bug occurs in those functions.
//============================================================================
function HeroHealingBugFix takes integer i returns nothing
  if HeroBugFixHealthCheck(i) then
    call Trace("HERO: Healing Bug Fix")
    call RecycleGuardPosition(hero_unit[i])
    call GroupRemoveUnit(unit_healing, hero_unit[i])
  endif
endfunction

// Returns a boolean if it should only attack creeps
function AwaitMeleeHeroesAM takes nothing returns boolean
  local integer i = 1
  local boolean hero_available = false

  loop
    if TownCountDone(hero[i]) > 0 then
      if hero_unit[i] != null and not IsUnitInGroup(hero_unit[i], unit_healing) then  //or HeroHealingBugFix(i) then
        return false
      endif
      set hero_available = true
    endif
    exitwhen player_defeated or hero_available
    set i = i + 1
    if i > 3 then
      call Trace("AwaitMeleeHeroesAM: No Heroes Ready")
      call Sleep(2 * sleep_multiplier)
      set i = 1
    endif
  endloop

  return true
endfunction

//============================================================================
// (AMAI) HealArmy
//============================================================================
function GetArmyHealthState takes nothing returns real
  local group g = CreateGroup()
  local unit u = null
  local unit ward = null
  local real health_sum = 0.0
  local integer count = 0
  local real uhs = 0.0
  //local integer hid = 0
  local integer hFountainID = GetHealthFountainID()
  local boolean prev_ward = false
  call GroupClear(urgent_healing_group)
  call GroupClear(medium_healing_group)
  call GroupClear(small_healing_group)
  set urgent_healing_count = 0
  set medium_healing_count = 0
  set small_healing_count = 0
  call GroupEnumUnitsOfPlayer(g, ai_player, null)
  loop
    set u = FirstOfGroup(g)
    exitwhen u == null
    if UnitAlive(u) and not (IsUnitHidden(u) or IsUnitType(u, UNIT_TYPE_PEON) or IsUnitType(u, UNIT_TYPE_STRUCTURE) or IsUnitIllusion(u)) and not IsUnitBuying(u) then
      if GetUnitTypeId(u) == 'ohwd' then
        set prev_ward = true
      else
        if not prev_ward and ward == null and (GetUnitAbilityLevel(u, 'Ahwd') > 0 or GetUnitAbilityLevel(u, 'AChw') > 0) then
          set ward = u
        endif
        if IsUnitType(u, UNIT_TYPE_MECHANICAL) or IsUnitType(u, UNIT_TYPE_SUMMONED) then
          set health_sum = health_sum + 1 // Because is not currently handled by healing and we don't want army to run away if only 1 human unit is hurt
          set uhs = 1
        else
          set uhs = GetUnitState(u, UNIT_STATE_LIFE) / RMax(GetUnitState(u, UNIT_STATE_MAX_LIFE), 1)
          set health_sum = health_sum + uhs
        endif
        set count = count + 1
        if uhs < 0.5 then
          call GroupAddUnit(urgent_healing_group, u)
          set urgent_healing_count = urgent_healing_count + 1
        elseif uhs < 0.75 then
          call GroupAddUnit(medium_healing_group, u)
          set medium_healing_count = medium_healing_count + 1
        elseif uhs < 1 then
          call GroupAddUnit(small_healing_group, u)
          set small_healing_count = small_healing_count + 1
        endif
      endif
    endif
    call GroupRemoveUnit(g,u)
  endloop
  call DestroyGroup(g)
  set g = null
  if nearest_neutral[hFountainID] == null or not neutral_available[hFountainID] or not race_use_fountain then
    set fountain_available = false
  else
    set fountain_available = (neutral_night_buy[hFountainID] and (GetFloatGameState(GAME_STATE_TIME_OF_DAY) >= 18 or GetFloatGameState(GAME_STATE_TIME_OF_DAY) < 6)) or not neutral_guarded[hFountainID]
  endif
  if ward != null and not prev_ward and CaptainIsHome() and UnitAlive(ward) and not IsUnitBuying(ward) then
    call IssuePointOrder(ward, "healingward", GetUnitX(ward), GetUnitY(ward))
    set ward_cast = true
  else
    set ward_cast = prev_ward
  endif
  set ward = null
  if count == 0 then
    return 1.0
  endif
  return ((health_sum / count) + (1-(urgent_healing_count + medium_healing_count) / count)) / 2
endfunction

//============================================================================
//     Orders unit to use the given mass healing item

function ApplyMassHealingItem takes unit u, item mh_i returns nothing
  local unit hu = null
  //local real time = 3
  local real x = GetUnitX(u)
  local real y = GetUnitY(u)

  set hu = FirstOfGroup(urgent_healing_group)
  if hu == null then
    set hu = FirstOfGroup(medium_healing_group)
    if hu == null then
      set hu = FirstOfGroup(small_healing_group)
      if hu == null then
        return
      endif
    endif
  endif

  call RemoveGuardPosition(u)
  call GroupPointOrder(urgent_healing_group, "move", x, y)
  call GroupPointOrder(medium_healing_group, "move", x, y)
  call GroupPointOrder(small_healing_group, "move", x, y)
  if DistanceBetweenPoints_dd(Location(x, y), GetUnitLoc(hu)) < 1200 then
    call IssuePointOrder(u, "move", GetUnitX(hu), GetUnitY(hu))
    //set time = RMax((GetTimeToReachUnit(u, hu) + GetTimeToReachUnit(hu, u)) / 2,2)    // Average of times. Not accurate as is longer than it should be to definatly make sure units surround the hero
  endif
  call Sleep(3)
  call UnitUseItem(u, mh_i)
  call RecycleGuardPosition(u)
  set hu = null
endfunction

//============================================================================
function ApplyHealingItem takes unit u, item heal_item returns nothing
//     Orders unit to use the given healing item on a particular unit

  local unit target = null
  local group urgent = null
  local group medium = null
  local group g = CreateGroup()
  local real x = GetUnitX(u)
  local real y = GetUnitY(u)
  local boolean b = false
  if false then
  #INCLUDETABLE <$VER$\HealingItems.txt> #EFR #COND "%1" eq "RITUAL_DAGGER"
  elseif GetItemTypeId(heal_item) == old_id[%1] then  //prevent killing high health units
    set b = true
  #ENDINCLUDE
  endif
  set urgent = CopyGroup(urgent_healing_group,urgent)
  set medium = CopyGroup(medium_healing_group,medium)
  call RemoveGuardPosition(u)
  call GroupPointOrder(urgent_healing_group, "move", x, y)
  call GroupPointOrder(medium_healing_group, "move", x, y)
  if b then
    call GroupPointOrder(small_healing_group, "move", x, y)
  endif
  call Sleep(4)
  call GroupEnumUnitsInRange(g, x, y, 1300, null)
  if b then
    loop
      set target = FirstOfGroup(urgent)
      exitwhen target == null
      exitwhen not UnitHasItem(u, heal_item)
      if target != null and IsUnitInGroup(target, g) then
        call UnitUseItemTarget(u, heal_item, target)
        call Sleep(3)
      endif
      call GroupRemoveUnit(urgent, target)
    endloop
  else
    loop
      exitwhen not UnitHasItem(u, heal_item)
      set target = FirstOfGroup(urgent)
      if target != null and IsUnitInGroup(target, g) then
        call UnitUseItemTarget(u, heal_item, target)
        call GroupRemoveUnit(urgent, target)
      else
        set target = FirstOfGroup(medium)
        if target != null and IsUnitInGroup(target, g) then
          call UnitUseItemTarget(u, heal_item, target)
          call GroupRemoveUnit(medium, target)
        endif
      endif
      exitwhen target == null
      call Sleep(2)
    endloop
  endif
  call RecycleGuardPosition(u)
  call DestroyGroup(urgent)
  call DestroyGroup(medium)
  call DestroyGroup(g)
  set urgent = null
  set medium = null
  set g = null
  set target = null
endfunction

//============================================================================
//  Orders unit to use an item that does a global healing effect
function ApplyGlobalItem takes unit u, item heal_item returns nothing
  call UnitUseItem(u, heal_item)
endfunction
//============================================================================
function HealArmy takes nothing returns nothing
  local real hs = 0.0
  local unit u = null
  local integer mh_item = 0
  local integer i = 0
  local item mh_i = null
  local boolean mass_healed = false
  local boolean global_heal = false
  local integer sleepLength = 2
  local real healthTrigger = 0.75
  local integer sleepFrequency = 0
  set ward_cast = false
  loop
    if not CaptainIsHome() then
      call CaptainGoHome()
    endif
    set hs = GetArmyHealthState()
    if ward_cast and hs < healthTrigger then
      loop
        exitwhen player_defeated or town_threatened or i >= 4
        call StaggerSleep(sleep_multiplier, 1.6 * sleep_multiplier)
        set i = i + 1
      endloop
      call Trace("function HealArmy: wait ward cast heal" + Int2Str(i))
      if i >= 4 then
        set hs = GetArmyHealthState()
      endif
      set i = 0
    endif
    exitwhen sleepFrequency >= 3 and hs > healthTrigger // Tried to heal but overall still strong so exit loop
    exitwhen urgent_healing_count + medium_healing_count <= 3 and hs > healthTrigger
    exitwhen player_defeated or town_threatened or ver_heroes == false
    call Trace("function HealArmy: Army is badly damaged and needs healing " + Real2Str(hs))
    set build_emergency_healing_item = 0
    set mh_item = GetMassHealingItem()
    if mh_item > 0 then
      set mass_healed = true
    endif
    if mh_item == 0 then
      set mh_item = GetMerchantMassHealingItem()
      if mh_item > 0 then
        set mass_healed = true
      endif
    endif
    if mh_item == 0 then
      set mh_item = GetGlobalHealingItem()
      if mh_item > 0 then
        set global_heal = true
      endif
    endif
    if mh_item == 0 then
      set mh_item = GetHealingItem()
    endif
    if mh_item > 0 then
      set mh_i = GetItemOfType(mh_i,mh_item)
      if mh_i != null then
        set u = GetItemHero(mh_i)
        if u != null then
          if mass_healed then
            set sleepLength = 10
            call ApplyMassHealingItem(u, mh_i)
          elseif global_heal then
            set sleepLength = 25
            call ApplyGlobalItem(u, mh_i)
          else
            set sleepLength = 10
            call ApplyHealingItem(u, mh_i)
          endif
          if hs <= healthTrigger then
          else
            set sleepLength = 2
          endif
        endif
      else
        call StartEmergencyItem(1, mh_item)
        if hs <= healthTrigger then
          set sleepLength = 8
        endif
      endif
    endif
    set sleepFrequency = sleepFrequency + 1
    call StaggerSleep(sleepLength * sleep_multiplier, sleepLength * sleep_multiplier + 1) // Wait some time for item effects to work
    set mass_healed = false
    set global_heal = false
  endloop
  set ward_cast = false
  set mh_i = null
  set u = null
endfunction

//============================================================================
// (AMAI) Universal attack sequence
//============================================================================
function universal_attack_sequence takes nothing returns nothing
  local boolean needs_exp = false
  local boolean has_siege = false
  local integer ai_strength = 0
  local integer ai_antiair_strength = 0
  local integer exp_strength = 0
  local integer exp_air_strength = 0
  local integer defense_length_counter = attack_reform_length

  if hero_unit[1] == null and ver_heroes and not desperation_assault then
    call Sleep(sleep_multiplier)
    return
  endif
  call SetTargetHeroes(difficulty != EASY)
  set ai_strength = GetOwnStrength()
  set ai_antiair_strength = air_strength
  if current_expansion != null then
    set exp_strength = GetExpansionStrength()
    set exp_air_strength = air_strength
  endif
  if major_hero == null or not UnitAlive(major_hero) or not IsStandardUnit(major_hero) or (IsUnitType(major_hero, UNIT_TYPE_HERO) == false and ver_heroes) then
    set major_hero = GetMajorHero(major_hero)
  endif

  set needs_exp        = take_exp and (ai_strength > exp_strength and ai_antiair_strength >= exp_air_strength)
  set has_siege        = ai_strength > 60
#INCLUDETABLE <$VER$\StandardUnits.txt> #EFR #COND "%4" =~ /\bsiege\b/
  set has_siege        = has_siege or TownCountDone(%1) > 0
#ENDINCLUDE

  call SingleMeleeAttackAM(needs_exp,has_siege,ai_strength)
  set added_target_aggression = 0
  set added_racial_aggression = 0

  //call TeleportCaptain(GetLocationX(home_location), GetLocationY(home_location))

  loop
    exitwhen not teleporting
    call CreateDebugTagLoc("Teleporting Home", 10, GetLocationX(home_location), GetLocationY(home_location), 1.00, 0.80)
    call Sleep(1)
  endloop

  loop
    exitwhen not retreat_controlled
    call CreateDebugTagLoc("Sleep until retreated", 10, GetLocationX(home_location), GetLocationY(home_location), 1.00, 0.80)
    if retreat_controlled and isfleeing then
      set defense_length_counter = defense_length_counter + 1
      if defense_length_counter > attack_reform_length then
        set defense_length_counter = 0
        //call FormGroupAM(0)
        //call TraceAll("Retreat FIX")
        //call InitAssault()
      endif
      //if main_army >= 0
      //if not CaptainAtGoal() then
        //call CaptainAttack(GetLocationX(captain_home), GetLocationY(captain_home)) // Prevent fight and flight behaviour
        //call TeleportCaptain(GetLocationX(captain_home), GetLocationY(captain_home)) // Prevent fight and flight behaviour
      //endif
    endif
    call Sleep(1) // Retreat must have fully run its course, units are sent home via job
  endloop

  if town_threatened or TownThreatened() then // Attack has finished so any AMAI detections or hardcoded threat detections should be dealt with
    set break_attack = false
    //call FormGroupAM(1)
    call SleepUntilTownDefended(ai_strength)
  //elseif not towerrush and not ancient_expanding and not militia_expanding and not item_expanding then
    //call SetCaptainHome(DEFENSE_CAPTAIN, GetLocationX(home_location), GetLocationY(home_location))
  endif

  if go_home then
    call Trace("UNIVERSAL ATTACK: Going home" )
    call CaptainGoHome()
  endif
  set break_attack = false
  set go_home = false
endfunction

//============================================================================
// (AMAI) Universal peon assignment
//============================================================================
function ForcedHarvest takes nothing returns boolean
  local integer T = 0
  local integer i = 0
  local integer c = Min(TownCountDone(racial_expansion), GetMinesOwned())
  if Forced_Harvest_total == 0 and first_town_mine < 1 and (c > 1 or GetGoldOwned() < 3000) and (FoodUsed() < 26 or GetGold() < (1000 + tier * 200)) then  // later stages of the game, AI may not be harvest
    loop
      exitwhen i >= max_towns or T > c
      if own_town_mine[i] != null and GetResourceAmount(own_town_mine[i]) > 0 then
        call PeonMineCheck(own_town_mine[i])
        set T = T + 1
        call CreateDebugTag("Forced Harvest mine " + Int2Str(i), 10, own_town_mine[i], 3.00, 1.50)
      endif
      set i = i + 1
    endloop
  endif
  if (Forced_Harvest_total > 3 and c > 1) or Forced_Harvest_total > 6 then
    set Forced_Harvest_total = 0  //Prevent peon excessive harvest
  else
    set Forced_Harvest_total = Forced_Harvest_total + 1
  endif
  call Trace("Forced Harvest mine total : " + Int2Str(T))
  return T > 0
endfunction

function universal_peon_assignment takes nothing returns nothing
  local integer T = TownWithMine()
  local integer g = GetGold()
  local integer w = GetWood()
  local integer pwh = 0
  local integer swh = 0
  local real gdivw = I2R(g) / I2R(Max(w,1))
  local integer i = T + 1

  if T < 0 then
    set T = 0
    set i = 1
  endif

  if g - w > 300 then
    set pwh = 2
  elseif g - w > 500 and w < 100 then
    set pwh = 5
  elseif g - w > 900 and w < 200 then
    set pwh = 8
  else
    set pwh = 2
  endif

  if w < 200 then
    set swh = 6 - pwh
  elseif gdivw < 0.5 then
    set swh = 0
  elseif gdivw < 0.8 then
    set swh = Max(1 - pwh,0)
  elseif gdivw < 1.1 then
    set swh = Max(2 - pwh,0)
  elseif gdivw < 1.4 then
    set swh = Max(3 - pwh,0)
  elseif gdivw < 1.7 then
    set swh = Max(4 - pwh,0)
  elseif gdivw < 2.0 then
    set swh = Max(5 - pwh,0)
  else
    set swh = Max(6 - pwh,0)
  endif

  set swh = Max(swh - 4 * TownCountDone(neutral_shredder),0)

  if towerrush and swh <= race_tower_peon then
    set swh = race_tower_peon + 2
  endif

  call ClearHarvestAI()

  if (desperation_assault) then
    return
  endif

  // if TownHasMine(T) then
  //   call Trace("Harvest Gold at Town:" + Int2Str(T))
  // endif
  // if TownHasMine(T+1) then
  //   call Trace("Harvest Gold at Town:" + Int2Str(T+1))
  // endif
  // if TownHasMine(T+2) then
  //   call Trace("Harvest Gold at Town:" + Int2Str(T+2))
  // endif
  call HarvestGold(T,ver_optimal_gold - 1)
  call HarvestWood(0,1)
  call HarvestGold(T,1)
  call HarvestWood(0,pwh)
  call HarvestWood(0,swh)

  set T = Max(T + 3,TownCountDone(racial_expansion))
  if not ForcedHarvest() then
    loop
      exitwhen i > T
      if T != i and TownHasMine(i) and TownCountEx(racial_expansion,true,i) > 0 then
        if gdivw < 3.0 or g < 300 then
          call HarvestGold(i,ver_optimal_gold)
        else
          call HarvestGold(i,ver_optimal_gold - 2)
        endif
      endif
      set i = i + 1
    endloop
  endif
  call HarvestWood(0,20)
endfunction

//============================================================================
// (AMAI) Campaign extras
//============================================================================
function SetAIResources takes integer g, integer w returns nothing
  call SetPlayerGold(ai_player, g)
  call SetPlayerWood(ai_player, w)
endfunction

//============================================================================
function IncreaseAIResources takes integer g, integer w returns nothing
  call IncreasePlayerGold(ai_player, g)
  call IncreasePlayerWood(ai_player, w)
endfunction

//============================================================================
function AddWaveResources takes nothing returns nothing
  local integer g = 0
  local integer w = 0
  local integer i = 0
  local integer unitid = 0
  local integer desire = 0

  loop
    exitwhen i >= attack_length
    set unitid = attack_units[i]
    set desire = attack_qty[i]
    set g = g + desire * GetUnitGoldCost2(unitid)
    set w = w + desire * GetUnitWoodCost2(unitid)
    set i = i + 1
  endloop

  call IncreaseAIResources(g,w)

endfunction

//============================================================================
function BuildAndAttack takes player p, integer prio returns nothing
    local integer index = 0
    local integer unitid = 0
    local integer desire = 0
    local boolean group_ready = true

    call AddWaveResources()

    loop
      set index = 0
      set group_ready = true
      loop
        exitwhen index >= attack_length
        set unitid = attack_units[index]
        set desire = attack_qty[index] + campaign_defenders[unitid]
        if TownCountDone(unitid)<desire then
          set group_ready = false
          call BuildUnit(desire , unitid, prio)
        endif
        set index = index + 1
      endloop
      exitwhen group_ready
      call Sleep(5 * sleep_multiplier)
    endloop

    call FormGroupAM(5)
    call SuicidePlayer(p, true)
    loop
      exitwhen CaptainIsEmpty()
      call Sleep(5 * sleep_multiplier)
    endloop

endfunction

//============================================================================
function BuildDefendersAM takes integer prio returns nothing
  local integer index = 0
  local integer unitid = 0
  local integer qty = 0
  loop
    exitwhen index >= defense_length

    set unitid = defense_units[index]
    set qty = defense_qty[index]

    call BuildUnit(qty, unitid, prio)
    if qty > 0 and TownCountDone(unitid) > 0 then
      call ConversionsAM(qty,unitid)
      call AddDefenders(qty,old_id[unitid])
    endif
    set campaign_defenders[unitid] = qty

    set index = index + 1
  endloop
endfunction



//_________________________________________________________________________________________________________________________________________________
//AMAI VS AI Support
#INCLUDESCRIPT <common_original.eai>

//function main takes nothing returns nothing

//endfunction
//library themain
//
//! inject main
//some function calls may go here
// this places vjass initializations there, notice structs are first initialized then library initializers
// are called
//! dovjassinit
//! endinject
//
//endlibrary