Changeset 160 for trunk/AI/StdAI

Timestamp:

Mar 6, 2019, 8:10:23 AM (6 years ago)

Author:

chronos

Message:

• Added: StdAI from original game. Previously used only AI dev kit.

Location:

trunk/AI/StdAI

Files:

• AI.pas (modified) (3 diffs)
• AIProject.ai.txt (deleted)
• AIProject.lpi (deleted)
• AIProject.lpr (deleted)
• AIProject.res (deleted)
• Barbarina.pas (added)
• CustomAI.pas (modified) (8 diffs)
• CustomAI_Reload.pas (added)
• Names.pas (modified) (1 diff)
• Pile.pas (modified) (2 diffs)
• StdAI.lpi (added)
• StdAI.lpr (added)
• ToolAI.pas (modified) (12 diffs)
• _aidev3.gif (deleted)
• _aidev4.gif (deleted)
• _aidev5.gif (deleted)
• libstdai-amd64.so (modified) ( previous)
• manual.html (deleted)

trunk/AI/StdAI/AI.pas

@@ -1 +1 @@
 {$INCLUDE Switches.inc}
+{//$DEFINE PERF}
 unit AI;
 
@@ -5 +6 @@
 
 uses
-{$IFDEF DEBUG}SysUtils, {$ENDIF} // necessary for debug exceptions
-  Protocol, CustomAI, ToolAI;
+{$IFDEF DEBUG}SysUtils,Names,{$ENDIF} // necessary for debug exceptions
+{$IFDEF PERF}SysUtils,Windows,{$ENDIF} // necessary for performance measurement
+Protocol, CustomAI, ToolAI, Barbarina;
+
+
+const
+WaitAfterReject=20; // don't try to contact this number of turn after contact was rejected
+MinCityFood=3;
+LeaveDespotism=80; // stay in despotism until this turn
+TechReportOutdated=30;
+MilProdShare=50; // minimum share of total production to specialize in military production
+
+FutureTech=[futResearchTechnology,futProductionTechnology,futArmorTechnology,
+  futMissileTechnology];
+
+nResearchOrder=46;
+ResearchOrder: array[0..1,0..nResearchOrder-1] of integer=
+((adWheel,adWarriorCode,adHorsebackRiding,adCeremonialBurial,adPolytheism,
+adMonarchy,adMysticism,adPoetry,adAstronomy,adMonotheism,
+adTheology,adChivalry,adPottery,adMedicine,adGunpowder,adChemistry,
+adExplosives,adUniversity,adTactics,adSeafaring,adNavigation,adRefining,adCombustionEngine,
+adAutomobile,adPhysics,adMagnetism,adElectricity,adRefrigeration,
+adRadioCommunication,adTheoryOfGravity,adAtomicTheory,adElectronics,
+adMassProduction,adPlastics,adFlight,adEnvironmentalism,
+adSanitation,adMin,adComputers,adRecycling,adSyntheticFood,
+adSelfContainedEnvironment,adNuclearFission,adNuclearPower,adTheLaser,
+adIntelligenArms),
+(adWheel,adWarriorCode,adHorsebackRiding,adAlphabet,adMapMaking,adBronzeWorking,adWriting,
+adCodeOfLaws,adCurrency,adTrade,adLiterature,adTheRepublic,adMathematics,
+adPhilosophy,adScience,adMasonry,adConstruction,adEngineering,adInvention,
+adIronWorking,adBridgeBuilding,adSteamEngine,adRailroad,adSteel,
+adBanking,adIndustrialization,adConscription,adDemocracy,adEconomics,
+adTheCorporation,adMassProduction,adRobotics,adCommunism,adMetallurgy,
+adBallistics,adMobileWarfare,adAmphibiousWarfare,adMin,adComputers,adRocketry,adAdvancedRocketry,
+adAdvancedFlight,adSpaceFlight,adComposites,adIntelligence,adCombinedArms));
+
+LeaveOutTechs=[adPolytheism,adMysticism,adInvention,adEconomics,adPottery,
+adMedicine,adEnvironmentalism,adRefining,adTrade,adLiterature,adMathematics,
+adPhilosophy,adChemistry,adConscription,adCombustionEngine,adPhysics,
+adTheoryOfGravity,adAtomicTheory,adSyntheticFood,adNuclearFission];
+
+TechValue_ForResearch_LeaveOut=$700;
+TechValue_ForResearch_Urgent=$600;
+TechValue_ForResearch_Next=$400;
+TechValue_ForResearch=$FF;
+ForceNeeded_NoLeaveOut=20; // advancedness behind to state-of-art
+ForceNeeded_LeaveOut=30; // advancedness behind of state-of-art
+Compromise=6;
+
+// basic strategies
+bGender=$0001;
+bMale=$0000;
+bFemale=$0001;
+bBarbarina=$0006;
+bBarbarina_Hide=$0002;
+
+// model categories
+nModelCat=4;
+mctNone=-1; mctGroundDefender=0; mctGroundAttacker=1; mctTransport=2; mctCruiser=3;
+
+// mil research
+BetterQuality: array[0..nModelCat-1] of integer=(50,50,80,80);
+MaxBuildWorseThanBestModel=20; MaxExistWorseThanBestModel=50;
+
+maxCOD=256;
+PresenceUnknown=$10000;
+
+nRequestedTechs=48;
+
+PlayerHash: array[0..nPl-1] of integer=(7,6,0,2,10,8,12,14,4,1,3,5,9,11,13);
 
 type
-  UnitRole = (Roam, Defend);
-
-  TAI = class(TToolAI)
-    constructor Create(Nation: integer); override;
-
-  protected
-    procedure DoTurn; override;
-    procedure DoNegotiation; override;
-    function ChooseResearchAdvance: integer; override;
-    function ChooseGovernment: integer; override;
-    function WantNegotiation(Nation: integer; NegoTime: TNegoTime)
-      : boolean; override;
-
-    procedure ProcessSettlers;
-    procedure ProcessUnit(uix: integer; Role: UnitRole);
-    procedure SetCityProduction;
-  end;
+Suggestion=(suContact, suPeace, suFriendly);
+
+TPersistentData=record
+  LastResearchTech, BehaviorFlags, TheologyPartner: integer;
+  RejectTurn: array[Suggestion,0..15] of smallint;
+  RequestedTechs: array[0..nRequestedTechs-1] of integer;
+    // ad + p shl 8 + Turn shl 16
+  end;
+
+TAI = class(TBarbarina)
+  constructor Create(Nation: integer); override;
+
+  procedure SetDataDefaults; override;
+
+protected
+  Data: ^TPersistentData;
+  WarNations, BombardingNations, mixSettlers, mixCaravan, mixTownGuard,
+    mixSlaves, mixMilitia, mixCruiser, OceanWithShip: integer;
+  NegoCause: (Routine,CheckBarbarina);
+  SettlerSurplus: array[0..maxCOD-1] of integer;
+  uixPatrol: array[0..maxCOD-1] of integer;
+
+  ContinentPresence: array[0..maxCOD-1] of integer;
+  OceanPresence: array[0..maxCOD-1] of integer;
+  UnitLack: array[0..maxCOD-1,mctGroundDefender..mctGroundAttacker] of integer;
+
+  TotalPopulation: array[0..nPl-1] of integer;
+  ContinentPopulation: array[0..nPl-1,0..maxCOD-1] of integer;
+    // 1 means enemy territory spotted but no city
+  DistrictPopulation: array[0..maxCOD-1] of integer;
+
+  ModelCat: array[0..nMmax-1] of integer;
+  ModelQuality: array[0..nMmax-1] of integer;
+  ModelBestQuality: array[0..nModelCat-1] of integer;
+
+  AdvanceValue: array[0..nAdv-1] of integer;
+  AdvanceValuesSet: boolean;
+
+  procedure DoTurn; override;
+  procedure DoNegotiation; override;
+  function ChooseResearchAdvance: integer; override;
+  function ChooseStealAdvance: integer; override;
+  function ChooseGovernment: integer; override;
+  function WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean; override;
+  function OnNegoRejected_CancelTreaty: boolean; override;
+
+  procedure FindBestTrade(Nation: integer; var adWanted, adGiveAway: integer);
+  procedure CheckGender;
+  procedure AnalyzeMap;
+  procedure CollectModelCatStat;
+  procedure AttackAndPatrol;
+  procedure MoveUnitsHome;
+  procedure CheckAttack(uix: integer);
+  procedure Patrol(uix: integer);
+  procedure SetCityProduction;
+  procedure SetAdvanceValues;
+  function HavePort: boolean;
+  {$IFDEF DEBUG}procedure TraceAdvanceValues(Nation: integer);{$ENDIF}
+
+  // research
+  procedure RateModel(const mi: TModelInfo; var Category, Quality: integer);
+  procedure RateMyModel(mix: integer; var Category, Quality: integer);
+  function IsBetterModel(const mi: TModelInfo): boolean;
+
+  //terraforming
+  procedure TileWorkPlan(Loc, cix: integer;
+    var Value, NextJob, TotalWork: integer);
+  procedure ProcessSettlers;
+
+  // diplomacy
+  function MostWanted(Nation, adGiveAway: integer): integer;
+
+  end;
+
 
 implementation
 
 uses
-  Pile;
+Pile;
 
 const
-  // fine adjustment
-  Aggressive = 40; // 0 = never attacks, 100 = attacks even with heavy losses
-  DestroyBonus = 30; // percent of building cost
+// fine adjustment
+Aggressive=40; // 0 = never attacks, 100 = attacks even with heavy losses
+DestroyBonus=30; // percent of building cost
+
+var
+LeaveOutValue: array[0..nAdv-1] of integer;
+
 
 constructor TAI.Create(Nation: integer);
 begin
-  inherited;
+inherited;
+Data:=pointer(RO.Data);
+{$IFDEF DEBUG}if Nation=1 then SetDebugMap(DebugMap);{$ENDIF}
+AdvanceValuesSet:=false;
 end;
 
-
-// -------------------------------
-// MY TURN
-// -------------------------------
-
-procedure TAI.DoTurn;
+procedure TAI.SetDataDefaults;
+begin
+with Data^ do
+  begin
+  LastResearchTech:=-1;
+  if PlayerHash[me]>7 then BehaviorFlags:=bFemale else BehaviorFlags:=bMale;
+  DebugMessage(1, 'Gender:='+char(48+BehaviorFlags and bGender));
+  TheologyPartner:=-1;
+  fillchar(RejectTurn,sizeof(RejectTurn),$FF);
+  Fillchar(RequestedTechs, sizeof(RequestedTechs), $FF);
+  end
+end;
+
+function TAI.OnNegoRejected_CancelTreaty: boolean;
+begin
+Data.RejectTurn[suContact,Opponent]:=RO.Turn;
+result:= Data.BehaviorFlags and bBarbarina<>0;
+end;
+
+
+//-------------------------------
+//            RESEARCH
+//-------------------------------
+
+procedure TAI.RateModel(const mi: TModelInfo; var Category, Quality: integer);
 var
-  uix: integer;
+EffectiveTransport: integer;
 begin
-  // correct tax rate if necessary
-  if RO.Money > RO.nCity * 16 then
-    ChangeRates(RO.TaxRate - 10, 0)
-  else if RO.Money < RO.nCity * 8 then
-    ChangeRates(RO.TaxRate + 10, 0);
-
-  // better government form available?
-  if RO.Government <> gAnarchy then
-    if IsResearched(adTheRepublic) then
-    begin
-      if RO.Government <> gRepublic then
-        Revolution
+if mi.Kind>=mkScout then
+  begin Category:=mctNone; exit end;
+case mi.Domain of
+  dGround:
+    if mi.Speed>=250 then
+      begin
+      Category:=mctGroundAttacker;
+      if mi.Attack=0 then Quality:=0
+      else
+        begin
+        Quality:=trunc(100*(ln(mi.Attack)+ln(mi.Defense)+ln(mi.Speed/150)*1.7-ln(mi.Cost)));
+        if mi.Cap and (1 shl (mcFanatic-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.5)));
+        if mi.Cap and (1 shl (mcLongRange-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.5)));
+        end
+      end
+    else
+      begin
+      Category:=mctGroundDefender;
+      Quality:=trunc(100*(ln(mi.Defense)-ln(mi.Cost)*0.6));
+      if mi.Cap and (1 shl (mcFanatic-mcFirstNonCap))<>0 then
+        inc(Quality,trunc(100*ln(1.5)));
+      end;
+  dSea:
+    if mi.Attack=0 then
+      begin
+      Category:=mctTransport;
+      if mi.TTrans=0 then Quality:=0
+      else
+        begin
+        EffectiveTransport:=mi.TTrans;
+        if EffectiveTransport>4 then EffectiveTransport:=4; // rarely used more
+        Quality:=100+trunc(100*(ln(EffectiveTransport)+ln(mi.Speed/150)+ln(mi.Defense)-ln(mi.Cost)));
+        if mi.Cap and (1 shl (mcNav-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.5)));
+        if mi.Cap and (1 shl (mcAirDef-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.3)));
+        end
+      end
+    else
+      begin
+      Category:=mctCruiser;
+      if mi.Attack=0 then Quality:=0
+      else
+        begin
+        Quality:=trunc(100*(ln(mi.Attack)+ln(mi.Defense)*0.6-ln(mi.Cost)));
+        if mi.Cap and (1 shl (mcNav-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.4)));
+        if mi.Cap and (1 shl (mcAirDef-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.3)));
+        if mi.Cap and (1 shl (mcLongRange-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(2.0)));
+        if mi.Cap and (1 shl (mcRadar-mcFirstNonCap))<>0 then
+          inc(Quality,trunc(100*ln(1.5)));
+        end
+      end;
+  dAir:
+    begin
+    Category:=mctNone;
+    Quality:=0
+    end;
+  end;
+//!!!assert(Quality>0);
+end;
+
+procedure TAI.RateMyModel(mix: integer; var Category, Quality: integer);
+var
+mi: TModelInfo;
+begin
+MakeModelInfo(me,mix,MyModel[mix],mi);
+RateModel(mi,Category,Quality);
+end;
+
+function TAI.IsBetterModel(const mi: TModelInfo): boolean;
+var
+mix,Cat,Quality,Cat1,Quality1: integer;
+begin
+RateModel(mi,Cat,Quality);
+for mix:=0 to RO.nModel-1 do if mi.Domain=MyModel[mix].Domain then
+  begin
+  RateMyModel(mix,Cat1,Quality1);
+  if (Cat=Cat1) and (Quality<Quality1+BetterQuality[Cat])then
+    begin result:=false; exit end
+  end;
+result:=true;
+end;
+
+function TAI.ChooseResearchAdvance: integer;
+var
+adNext,iad,i,ad,Count,EarliestNeeded,EarliestNeeded_NoLeaveOut,
+  NewResearch,StateOfArt,mix: integer;
+mi: TModelInfo;
+Entry: array[0..nAdv-1] of boolean;
+ok: boolean;
+
+  function MarkEntry(ad: integer): boolean;
+  begin
+  if RO.Tech[ad]>=tsApplicable then
+    result:=false // nothing more to research here
+  else if RO.Tech[ad]=tsSeen then
+    begin
+    Entry[ad]:=true;
+    result:=true
     end
-    else if IsResearched(adMonarchy) then
-    begin
-      if RO.Government <> gMonarchy then
-        Revolution
-    end;
-
-  // do combat
-  for uix := 0 to RO.nUn - 1 do
-    if (MyUnit[uix].Loc >= 0) and not(MyModel[MyUnit[uix].mix].Kind
-      in [mkSettler, mkSlaves]) then
-      ProcessUnit(uix, Roam);
-
-  ProcessSettlers;
-
-  // do discover/patrol
-
-  OptimizeCityTiles;
-  SetCityProduction;
+  else
+    begin
+    Entry[ad]:=true;
+    if ad=adScience then
+      begin
+      if MarkEntry(adTheology) then Entry[ad]:=false;
+      if MarkEntry(adPhilosophy) then Entry[ad]:=false;
+      end
+    else if ad=adMassProduction then
+      begin
+      if MarkEntry(adAutomobile) then Entry[ad]:=false;
+      if Data.BehaviorFlags and bGender=bMale then
+        begin if MarkEntry(adElectronics) then Entry[ad]:=false; end
+      else begin if MarkEntry(adTheCorporation) then Entry[ad]:=false; end
+      end
+    else
+      begin
+      if AdvPreq[ad,0]>=0 then
+        if MarkEntry(AdvPreq[ad,0]) then Entry[ad]:=false;
+      if AdvPreq[ad,1]>=0 then
+        if MarkEntry(AdvPreq[ad,1]) then Entry[ad]:=false;
+      end;
+    result:=true
+    end
+  end;
+
+  procedure OptimizeDevModel(OptimizeCaps: integer);
+  var
+  f,Cat,OriginalCat,Quality,BestQuality,Best: integer;
+  mi: TModelInfo;
+  begin
+  MakeModelInfo(me,0,RO.DevModel,mi);
+  RateModel(mi,OriginalCat,BestQuality);
+  repeat
+    Best:=-1;
+    for f:=0 to nFeature-1 do
+      if (1 shl f and OptimizeCaps<>0)
+        and ((Feature[f].Preq<0) or IsResearched(Feature[f].Preq)) // check prerequisite
+        and (RO.DevModel.Weight+Feature[f].Weight<=RO.DevModel.MaxWeight)
+        and not((f>=mcFirstNonCap) and (RO.DevModel.Cap[f]>0)) then
+        begin
+        if SetNewModelFeature(f,RO.DevModel.Cap[f]+1)>=rExecuted then
+          begin
+          MakeModelInfo(me,0,RO.DevModel,mi);
+          RateModel(mi,Cat,Quality);
+          assert(Cat=OriginalCat);
+          if Quality>BestQuality then
+            begin
+            Best:=f;
+            BestQuality:=Quality;
+            end;
+          SetNewModelFeature(f,RO.DevModel.Cap[f]-1)
+          end
+        end;
+    if Best>=0 then
+      SetNewModelFeature(Best,RO.DevModel.Cap[Best]+1)
+  until Best<0
+  end;
+
+  function LeaveOutsMissing(ad: integer): boolean;
+  var
+  i: integer;
+  begin
+  result:=false;
+  if RO.Tech[ad]<tsSeen then
+    if ad in LeaveOutTechs then result:=true
+    else if ad=adScience then
+      begin
+      result:=result or LeaveOutsMissing(adTheology);
+      result:=result or LeaveOutsMissing(adPhilosophy);
+      end
+    else if ad=adMassProduction then
+      result:=true
+    else for i:=0 to 1 do
+      if AdvPreq[ad,i]>=0 then
+        result:=result or LeaveOutsMissing(AdvPreq[ad,i]);
+  end;
+
+begin
+if Data.BehaviorFlags and bBarbarina<>0 then
+  begin
+  result:=Barbarina_ChooseResearchAdvance;
+  if result>=0 then exit
+  end;
+
+SetAdvanceValues;
+
+// always complete traded techs first
+result:=-1;
+for ad:=0 to nAdv-1 do
+  if (RO.Tech[ad]=tsSeen)
+    and ((result<0) or (AdvanceValue[ad]>AdvanceValue[result])) then
+    result:=ad;
+if result>=0 then exit;
+
+if Data.BehaviorFlags and bBarbarina=0 then
+  begin
+  // develop new model?
+  if IsResearched(adWarriorCode) and IsResearched(adHorsebackRiding)
+    and not ((Data.BehaviorFlags and bGender=bMale) and (RO.Tech[adIronWorking]>=tsApplicable) // wait for gunpowder
+      and (RO.Tech[adGunPowder]<tsApplicable)) then
+    begin // check new ground models
+    PrepareNewModel(dGround);
+    SetNewModelFeature(mcDefense,1);
+    SetNewModelFeature(mcOffense,2);
+    SetNewModelFeature(mcMob,2);
+    OptimizeDevModel(1 shl mcOffense+1 shl mcDefense+1 shl mcMob
+      +1 shl mcLongRange+1 shl mcFanatic);
+    MakeModelInfo(me,0,RO.DevModel,mi);
+    if IsBetterModel(mi) then
+      begin result:=adMilitary; exit end;
+
+    PrepareNewModel(dGround);
+    SetNewModelFeature(mcDefense,2);
+    SetNewModelFeature(mcOffense,1);
+    OptimizeDevModel(1 shl mcOffense+1 shl mcDefense+1 shl mcFanatic);
+    MakeModelInfo(me,0,RO.DevModel,mi);
+    if IsBetterModel(mi) then
+      begin result:=adMilitary; exit end;
+    end;
+
+  if IsResearched(adMapMaking) and IsResearched(adSeafaring)
+    and IsResearched(adNavigation) and IsResearched(adSteamEngine) then
+    begin
+    result:=adMilitary;
+    for mix:=0 to RO.nModel-1 do if MyModel[mix].Cap[mcNav]>0 then result:=-1;
+    if result=adMilitary then
+      begin
+      PrepareNewModel(dSea);
+      SetNewModelFeature(mcWeapons,0);
+      SetNewModelFeature(mcDefense,3);
+      exit
+      end
+    end;
+
+  (*
+  if IsResearched(adMapMaking) and IsResearched(adSeafaring) then
+    begin // check new naval models
+    PrepareNewModel(dSea);
+    if RO.DevModel.MTrans>1 then
+      begin // new transport?
+      SetNewModelFeature(mcDefense,2);
+      SetNewModelFeature(mcOffense,2);
+      SetNewModelFeature(mcSeaTrans,1);
+      OptimizeDevModel(1 shl mcDefense+1 shl mcSeaTrans+1 shl mcTurbines
+        +1 shl mcAirDef);
+      MakeModelInfo(me,0,RO.DevModel,mi);
+      if IsBetterModel(mi) then
+        begin result:=adMilitary; exit end;
+      end;
+
+    // new cruiser?
+    if IsResearched(adBallistics) or IsResearched(adGunPowder) then
+      begin
+      PrepareNewModel(dSea);
+      SetNewModelFeature(mcDefense,1);
+      SetNewModelFeature(mcOffense,2);
+      OptimizeDevModel(1 shl mcOffense+1 shl mcDefense
+        +1 shl mcLongRange+1 shl mcAirDef+1 shl mcRadar);
+      MakeModelInfo(me,0,RO.DevModel,mi);
+      if IsBetterModel(mi) then
+        begin result:=adMilitary; exit end;
+      end
+    end;
+  *)
+  end;
+
+NewResearch:=-1;
+
+// check if cooperation with other gender doesn't work -- go for old needed techs then
+StateOfArt:=-1;
+for ad:=0 to nAdv-1 do
+  if (RO.Tech[ad]>=tsApplicable) and (Advancedness[ad]>StateOfArt) then
+    StateOfArt:=Advancedness[ad];
+EarliestNeeded:=-1;
+EarliestNeeded_NoLeaveOut:=-1;
+for ad:=0 to nAdv-1 do
+  if (RO.Tech[ad]<tsSeen) and (AdvanceValue[ad]>=$100)
+    and ((EarliestNeeded<0)
+      or (Advancedness[ad]<Advancedness[EarliestNeeded])) then
+    begin
+    ok:=false;
+    for iad:=0 to nResearchOrder-1 do
+      if ResearchOrder[Data.BehaviorFlags and bGender,iad]=ad then
+        begin ok:=true; break; end;
+    if not ok then
+      begin
+      EarliestNeeded:=ad;
+      if not LeaveOutsMissing(ad) then
+        EarliestNeeded_NoLeaveOut:=ad;
+      end
+    end;
+if EarliestNeeded>=0 then
+  begin
+  if (EarliestNeeded_NoLeaveOut>=0)
+    and (Advancedness[EarliestNeeded_NoLeaveOut]+ForceNeeded_NoLeaveOut<StateOfArt) then
+    begin
+    {$IFDEF DEBUG}DebugMessage(2,'No partner found, go for '
+      +Name_Advance[EarliestNeeded_NoLeaveOut]);{$ENDIF}
+    NewResearch:=EarliestNeeded_NoLeaveOut
+    end
+  else if Advancedness[EarliestNeeded]+ForceNeeded_LeaveOut<StateOfArt then
+    begin
+    {$IFDEF DEBUG}DebugMessage(2,'No partner found, go for '
+      +Name_Advance[EarliestNeeded]);{$ENDIF}
+    NewResearch:=EarliestNeeded
+    end
+  end;
+
+// choose first directly researchable advance from own branch
+adNext:=-1;
+if NewResearch<0 then
+  for iad:=0 to nResearchOrder-1 do
+    begin
+    ad:=ResearchOrder[Data.BehaviorFlags and bGender,iad];
+    if RO.Tech[ad]<tsApplicable then
+      begin
+      if adNext<0 then adNext:=ad;
+      if AdvPreq[ad,2]<>preNone then
+        begin // 2 of 3 required
+        count:=0;
+        for i:=0 to 2 do
+          if RO.Tech[AdvPreq[ad,i]]>=tsApplicable then inc(count);
+        if count>=2 then
+          begin result:=ad; exit end
+        end
+      else if ((AdvPreq[ad,0]=preNone) or (RO.Tech[AdvPreq[ad,0]]>=tsApplicable))
+        and ((AdvPreq[ad,1]=preNone) or (RO.Tech[AdvPreq[ad,1]]>=tsApplicable)) then
+        begin result:=ad; exit end
+      end
+    end;
+
+if NewResearch<0 then
+  if adNext>=0 then
+    NewResearch:=adNext // need tech from other gender
+  else if EarliestNeeded_NoLeaveOut>=0 then
+    NewResearch:=EarliestNeeded_NoLeaveOut // own branch complete, pick tech from other gender
+  else if EarliestNeeded>=0 then
+    NewResearch:=EarliestNeeded // own branch complete, pick tech from other gender
+  else
+    begin // go for future techs
+    result:=-1;
+    i:=0;
+    for ad:=nAdv-4 to nAdv-1 do
+      if (RO.Tech[ad]<MaxFutureTech) and (RO.Tech[AdvPreq[ad,0]]>=tsApplicable) then
+        begin
+        inc(i);
+        if random(i)=0 then result:=ad
+        end;
+    assert((result<0) or AdvanceResearchable(result));
+    exit;
+    end;
+
+assert(NewResearch>=0);
+fillchar(Entry, sizeof(Entry), false);
+MarkEntry(NewResearch);
+result:=-1;
+for ad:=0 to nAdv-1 do
+  if Entry[ad]
+    and ((result<0) or (Advancedness[ad]>Advancedness[result])) then
+    result:=ad;
+assert(result>=0);
+end;
+
+function TAI.ChooseStealAdvance: integer;
+var
+ad: integer;
+begin
+result:=-1;
+for ad:=0 to nAdv-1 do
+  if AdvanceStealable(ad)
+    and ((result<0) or (Advancedness[ad]>Advancedness[result])) then
+    result:=ad
+end;
+
+
+//-------------------------------
+//         TERRAFORMING
+//-------------------------------
+
+const
+twpAllowFarmland=$0001;
+
+procedure TAI.TileWorkPlan(Loc, cix: integer;
+  var Value, NextJob, TotalWork: integer);
+var
+OldTile,TerrType: Cardinal;
+TileInfo: TTileInfo;
+begin
+TotalWork:=0;
+NextJob:=jNone;
+if Map[Loc] and (fRare1 or fRare2)<>0 then
+  begin Value:=3*8-1; exit end; // better than any tile with 2 food
+
+OldTile:=Map[Loc];
+TerrType:=Map[Loc] and fTerrain;
+if (TerrType>=fGrass) then
+  begin
+  if Map[Loc] and fPoll<>0 then
+    begin // clean pollution
+    if NextJob=jNone then NextJob:=jPoll;
+    inc(TotalWork,PollWork);
+    Map[Loc]:=Map[Loc] and not fPoll;
+    end;
+  if Map[Loc] and (fTerrain or fSpecial)=fSwamp then
+    begin // drain swamp
+    if NextJob=jNone then NextJob:=jClear;
+    inc(TotalWork,Terrain[TerrType].IrrClearWork);
+    Map[Loc]:=Map[Loc] and not fTerrain or fGrass;
+    TerrType:=fGrass;
+    Map[Loc]:=Map[Loc] or
+      Cardinal(SpecialTile(Loc,TerrType,G.lx) shl 5);
+    end
+  else if IsResearched(adExplosives)
+    and (Map[Loc] and (fTerrain or fSpecial) in [fTundra,fHills])
+    and (Map[Loc] and fTerImp<>tiMine)
+    and (SpecialTile(Loc,fHills,G.lx)=0) then
+    begin // transform
+    if NextJob=jNone then NextJob:=jTrans;
+    inc(TotalWork,Terrain[TerrType].TransWork);
+    Map[Loc]:=Map[Loc] and not fTerrain or fGrass;
+    TerrType:=fGrass;
+    Map[Loc]:=Map[Loc] or
+      Cardinal(SpecialTile(Loc,TerrType,G.lx) shl 5);
+    end;
+  if (Terrain[TerrType].MineEff>0) and (RO.Government<>gDespotism) then
+    begin
+    if Map[Loc] and fTerImp<>tiMine then
+      begin // add mine
+      if NextJob=jNone then NextJob:=jMine;
+      inc(TotalWork,Terrain[TerrType].MineAfforestWork);
+      Map[Loc]:=Map[Loc] and not fTerImp or tiMine;
+      end
+    end
+  else if Terrain[TerrType].IrrEff>0 then
+    begin
+    if Map[Loc] and fTerImp=tiIrrigation then
+      begin // add farmland
+      if (MyCity[cix].Built[imSupermarket]>0) and IsResearched(adRefrigeration) 
+        and (RO.Government<>gDespotism) then
+        begin
+        if NextJob=jNone then NextJob:=jFarm;
+        inc(TotalWork,Terrain[TerrType].IrrClearWork*FarmWork);
+        Map[Loc]:=Map[Loc] and not fTerImp or tiFarm;
+        end
+      end
+    else if Map[Loc] and fTerImp<>tiFarm then
+      begin // add irrigation
+      if (RO.Government<>gDespotism)
+        or (Map[Loc] and (fTerrain or fSpecial)<>fGrass) then
+        begin
+        if NextJob=jNone then NextJob:=jIrr;
+        inc(TotalWork,Terrain[TerrType].IrrClearWork);
+        Map[Loc]:=Map[Loc] and not fTerImp or tiIrrigation;
+        end
+      end
+    end;
+  if (Terrain[TerrType].MoveCost=1)
+    and (Map[Loc] and (fRoad or fRR)=0)
+    and ((Map[Loc] and fRiver=0) or IsResearched(adBridgeBuilding)) then
+    begin // add road
+    if NextJob=jNone then NextJob:=jRoad;
+    inc(TotalWork,RoadWork);
+    Map[Loc]:=Map[Loc] or fRoad;
+    end;
+  if ((Map[Loc] and fTerImp=tiMine)
+      or (Terrain[TerrType].ProdRes[Map[Loc] shr 5 and 3]>=2))
+    and IsResearched(adRailroad) 
+    and (Map[Loc] and fRR=0)
+    and ((Map[Loc] and fRiver=0) or IsResearched(adBridgeBuilding))
+    and (RO.Government<>gDespotism) then
+    begin // add railroad
+    if Map[Loc] and fRoad=0 then
+      begin
+      if NextJob=jNone then NextJob:=jRoad;
+      inc(TotalWork,RoadWork*Terrain[TerrType].MoveCost);
+      end;
+    if NextJob=jNone then NextJob:=jRR;
+    inc(TotalWork,RRWork*Terrain[TerrType].MoveCost);
+    Map[Loc]:=Map[Loc] and not fRoad or fRR;
+    end;
+  end;
+Server(sGetTileInfo,me,Loc,TileInfo);
+Value:=TileInfo.Food*8+TileInfo.Prod*2+TileInfo.Trade;
+Map[Loc]:=OldTile;
 end;
 
@@ -87 +698 @@
 procedure TAI.ProcessSettlers;
 var
-  uix, cix, ecix, Loc, RadiusLoc, TestScore, BestNearCityScore, TerrType,
-    Special, V21: integer;
-  Radius: TVicinity21Loc;
-  ResourceScore, CityScore: array [0 .. lxmax * lymax - 1] of integer;
+i,uix,cix,ecix,dtr,Loc,RadiusLoc,Special,Food,Prod,Trade,CityFood,Happy,
+  TestScore,BestNearCityScore,BestUnusedValue,BestUnusedLoc,
+  Value,NextJob,TotalWork,V21,part,Loc1: integer;
+Tile: Cardinal;
+FoodOk,Started: boolean;
+Radius: TVicinity21Loc;
+CityAreaInfo: TCityAreaInfo;
+TileFood, ResourceScore, CityScore: array[0..lxmax*lymax-1] of integer;
+
+  procedure AddJob(Loc,Job,Score: integer);
+  // set Score=1 for low-priority jobs
+  begin
+  JobAssignment_AddJob(Loc,Job,Score);
+  if (Score>1) and (District[Loc]>=0) and (District[Loc]<maxCOD) then
+    dec(SettlerSurplus[District[Loc]]);
+  end;
 
   procedure ReserveCityRadius(Loc: integer);
   var
-    V21, RadiusLoc: integer;
-    Radius: TVicinity21Loc;
-  begin
-    V21_to_Loc(Loc, Radius);
-    for V21 := 1 to 26 do
-    begin
-      RadiusLoc := Radius[V21];
-      if (RadiusLoc >= 0) and (RadiusLoc < MapSize) then
-        ResourceScore[RadiusLoc] := 0
+  V21,RadiusLoc: integer;
+  Radius: TVicinity21Loc;
+  begin
+  V21_to_Loc(Loc,Radius);
+  for V21:=1 to 26 do
+    begin
+    RadiusLoc:=Radius[V21];
+    if (RadiusLoc>=0) then
+      begin
+      ResourceScore[RadiusLoc]:=0;
+      TileFood[RadiusLoc]:=0;
+      end
     end
   end;
 
-begin
-  JobAssignment_Initialize;
-
-  // rate resources of all tiles
-  fillchar(ResourceScore, MapSize * sizeof(integer), 0);
-  for Loc := 0 to MapSize - 1 do
-    if (Map[Loc] and fRare) = 0 then
-      if (Map[Loc] and fTerrain) = fGrass then
-        if (Map[Loc] and fSpecial) <> 0 then
-          ResourceScore[Loc] := 3 // plains, 3 points
-        else
-          ResourceScore[Loc] := 2 // grassland, 2 points
-      else if (Map[Loc] and fSpecial) <> 0 then
-        ResourceScore[Loc] := 4; // special resource, 4 points
-  for cix := 0 to RO.nCity - 1 do
-    if MyCity[cix].Loc >= 0 then
-      ReserveCityRadius(MyCity[cix].Loc); // these resources already have a city
-  for uix := 0 to RO.nUn - 1 do
-    if (MyUnit[uix].Loc >= 0) and (MyUnit[uix].Job = jCity) then
-      ReserveCityRadius(MyUnit[uix].Loc);
-  // these resources almost already have a city
-  for ecix := 0 to RO.nEnemyCity - 1 do
-    if RO.EnemyCity[ecix].Loc >= 0 then
-      ReserveCityRadius(RO.EnemyCity[ecix].Loc);
-  // these resources already have an enemy city
-
-  // rate possible new cities
-  fillchar(CityScore, MapSize * sizeof(integer), 0);
-  for Loc := 0 to MapSize - 1 do
-    if ((Map[Loc] and fTerrain) = fGrass) and ((Map[Loc] and fRare) = 0) and
-      ((RO.Territory[Loc] < 0) or (RO.Territory[Loc] = me)) then
-    // don't consider founding cities in foreign nation territory
-    begin
-      TestScore := 0;
-      BestNearCityScore := 0;
-      V21_to_Loc(Loc, Radius);
-      for V21 := 1 to 26 do
-      begin // sum resource scores in potential city radius
-        RadiusLoc := Radius[V21];
-        if (RadiusLoc >= 0) and (RadiusLoc < MapSize) then
-        begin
-          TestScore := TestScore + ResourceScore[RadiusLoc];
-          if CityScore[RadiusLoc] > BestNearCityScore then
-            BestNearCityScore := CityScore[RadiusLoc]
-        end
-      end;
-      if TestScore >= 10 then // city is worth founding
-      begin
-        TestScore := TestScore shl 8 + ((Loc xor me) * 4567) mod 251;
-        // some unexactness, random but always the same for this tile
-        if TestScore > BestNearCityScore then
-        begin // better than all other sites in radius
-          if BestNearCityScore > 0 then // found no other cities in radius
+  procedure ScoreRoadConnections;
+  var
+  V8,nFragments,Loc,Loc1,History,RoadScore,a,b,FullyDeveloped,ConnectMask: integer;
+  BridgeOk: boolean;
+  Adjacent: TVicinity8Loc;
+  begin
+  BridgeOk:= IsResearched(adBridgeBuilding);
+  if IsResearched(adRailroad) then FullyDeveloped:=fRR or fCity
+  else FullyDeveloped:=fRoad or fRR or fCity;
+  for Loc:=G.lx to G.lx*(G.ly-1)-1 do
+    if ((1 shl (Map[Loc] and fTerrain)) and (1 shl fOcean or 1 shl fShore or 1 shl fDesert or 1 shl fArctic or 1 shl fUNKNOWN)=0)
+      and (RO.Territory[Loc]=me)
+      and (Map[Loc] and FullyDeveloped=0)
+      and (BridgeOk or (Map[Loc] and fRiver=0)) then
+      begin
+      nFragments:=0;
+      History:=0;
+      if Map[Loc] and fRoad<>0 then ConnectMask:=fRR or fCity // check for railroad
+      else ConnectMask:=fRoad or fRR or fCity; // check for road
+      V8_to_Loc(Loc,Adjacent);
+      for V8:=0 to 9 do
+        begin
+        Loc1:=Adjacent[V8 and 7];
+        History:=History shl 1;
+        if (Loc1>=0) and (RO.Territory[Loc1]=me)
+          and (Map[Loc1] and ConnectMask<>0) then
           begin
-            for V21 := 1 to 26 do
+          inc(History);
+          if V8>=2 then
             begin
-              RadiusLoc := Radius[V21];
-              if (RadiusLoc >= 0) and (RadiusLoc < MapSize) then
-                CityScore[RadiusLoc] := 0;
+            inc(nFragments);
+            case V8 and 1 of
+              0:
+                if History and 6<>0 then
+                  dec(nFragments);
+              1:
+                if History and 2<>0 then
+                  dec(nFragments)
+                else if History and 4<>0 then
+                  begin
+                  V8_to_ab((V8-1) and 7,a,b);
+                  ab_to_Loc(Loc,a shl 1,b shl 1,Loc1);
+                  if (Loc1>=0)
+                    and (Map[Loc1] and ConnectMask<>0) then
+                    dec(nFragments)
+                  end
+              end
             end;
           end;
-          CityScore[Loc] := TestScore
         end;
-      end
-    end;
-  for Loc := 0 to MapSize - 1 do
-    if CityScore[Loc] > 0 then
-      JobAssignment_AddJob(Loc, jCity, 10);
-
-  // improve terrain
-  for cix := 0 to RO.nCity - 1 do
-    with MyCity[cix] do
-      if Loc >= 0 then
-      begin
-        V21_to_Loc(Loc, Radius);
-        for V21 := 1 to 26 do
-          if (Tiles and (1 shl V21) and not(1 shl CityOwnTile)) <> 0 then
-          begin // tile is exploited, but not the city own tile -- check if improvable
-            RadiusLoc := Radius[V21];
-            assert((RadiusLoc >= 0) and (RadiusLoc < MapSize));
-            if (RadiusLoc >= 0) and (RadiusLoc < MapSize) then
+      if nFragments>=2 then // road or railroad connection desirable
+        begin
+        if Map[Loc] and fRiver<>0 then RoadScore:=44+(nFragments-2)*4
+        else RoadScore:=56-Terrain[Map[Loc] and fTerrain].MoveCost*4
+          +(nFragments-2)*4;
+        if Map[Loc] and fRoad<>0 then
+          AddJob(Loc, jRR, RoadScore)
+        else AddJob(Loc, jRoad, RoadScore)
+        end;
+      end;
+  end;
+
+begin
+fillchar(SettlerSurplus, sizeof(SettlerSurplus), 0);
+JobAssignment_Initialize;
+
+if (Data.BehaviorFlags and bBarbarina=0) or (RO.nCity<3) then
+  begin
+  fillchar(TileFood,sizeof(TileFood),0);
+  fillchar(ResourceScore,sizeof(ResourceScore),0);
+  for Loc:=0 to MapSize-1 do
+    if Map[Loc] and fTerrain<>fUNKNOWN then
+      if Map[Loc] and fDeadLands<>0 then
+        begin
+        if not IsResearched(adMassProduction) or (Map[Loc] and fModern<>0) then
+          ResourceScore[Loc]:=20;
+        end
+      else if Map[Loc] and fTerrain=fGrass then
+        TileFood[Loc]:=Terrain[fGrass].FoodRes[Map[Loc] shr 5 and 3]-1
+      else
+        begin
+        Special:=SpecialTile(Loc,Map[Loc] and fTerrain,G.lx);
+        if Special<>0 then with Terrain[Map[Loc] and fTerrain] do
+          begin
+          Food:=FoodRes[Special];
+          if MineEff=0 then inc(Food,IrrEff);
+          Prod:=ProdRes[Special]+MineEff;
+          Trade:=TradeRes[Special];
+          if MoveCost=1 then inc(Trade);
+          ResourceScore[Loc]:=Food+2*Prod+Trade-7;
+          if Food>2 then TileFood[Loc]:=Food-2;
+          end
+        end;
+
+  for cix:=0 to RO.nCity-1 do
+    if MyCity[cix].Loc>=0 then
+      ReserveCityRadius(MyCity[cix].Loc); // these resources already have a city
+  for uix:=0 to RO.nUn-1 do
+    if (MyUnit[uix].Loc>=0) and (MyUnit[uix].Job=jCity) then
+      ReserveCityRadius(MyUnit[uix].Loc); // these resources almost already have a city
+  for ecix:=0 to RO.nEnemyCity-1 do
+    if RO.EnemyCity[ecix].Loc>=0 then
+      ReserveCityRadius(RO.EnemyCity[ecix].Loc); // these resources already have an enemy city
+
+  // rate possible new cities
+  fillchar(CityScore, MapSize*sizeof(integer), 0);
+  for Loc:=0 to MapSize-1 do
+    begin
+    FoodOk:= (TileFood[Loc]>0)
+      and ((Map[Loc] and fTerrain=fGrass)
+          and ((RO.Government<>gDespotism) or (Map[Loc] and fSpecial=fSpecial1))
+        or (Map[Loc] and (fTerrain or fSpecial)=fPrairie or fSpecial1));
+    if FoodOk and ((RO.Territory[Loc]<0) or (RO.Territory[Loc]=me)) then
+      begin
+      TestScore:=0;
+      CityFood:=0;
+      BestNearCityScore:=0;
+      V21_to_Loc(Loc,Radius);
+      for V21:=1 to 26 do
+        begin // sum resource scores in potential city radius
+        RadiusLoc:=Radius[V21];
+        if (RadiusLoc>=0) then
+          begin
+          inc(CityFood,TileFood[RadiusLoc]);
+          if ResourceScore[RadiusLoc]>0 then
+            inc(TestScore,ResourceScore[RadiusLoc]);
+          if CityScore[RadiusLoc]>BestNearCityScore then
+            BestNearCityScore:=CityScore[RadiusLoc]
+          end
+        end;
+      if CityFood>=MinCityFood then // city is worth founding
+        begin
+        TestScore:=(72+2*TestScore) shl 8 + ((loc xor me)*4567) mod 251;
+          // some unexactness, random but always the same for this tile
+        if TestScore>BestNearCityScore then
+          begin // better than all other sites in radius
+          if BestNearCityScore>0 then // found no other cities in radius
             begin
-              TerrType := Map[RadiusLoc] and fTerrain;
-              Special := Map[RadiusLoc] shr 5 and 3;
-              if TerrType >= fGrass then // can't improve water tiles
-                if (Terrain[TerrType].IrrEff > 0) // terrain is irrigatable
-                  and not((RO.Government = gDespotism) and
-                  (Terrain[TerrType].FoodRes[Special] >= 3))
-                // improvement makes no sense when limit is depotism
-                  and ((Map[RadiusLoc] and fTerImp) = 0) then
-                // no terrain improvement yet
-                  JobAssignment_AddJob(RadiusLoc, jIrr, 50) // irrigate!
-                else if (Terrain[TerrType].MoveCost = 1) // plain terrain
-                  and ((Map[RadiusLoc] and (fRoad or fRR or fRiver)) = 0) then
-                // no road or railroad yet, no river
-                  JobAssignment_AddJob(RadiusLoc, jRoad, 40);
-              // build road (The Wheel trade benefit)
+            for V21:=1 to 26 do
+              begin
+              RadiusLoc:=Radius[V21];
+              if (RadiusLoc>=0) then
+                CityScore[RadiusLoc]:=0;
+              end;
+            end;
+          CityScore[Loc]:=TestScore
+          end;
+        end
+      end;
+    end;
+  for Loc:=0 to MapSize-1 do
+    if CityScore[Loc]>0 then
+      AddJob(Loc, jCity, CityScore[Loc] shr 8);
+  end;
+
+// improve terrain
+for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+  begin // order terrain improvements
+  BestUnusedValue:=0;
+  City_GetAreaInfo(cix,CityAreaInfo);
+  V21_to_Loc(Loc,Radius);
+  for V21:=1 to 26 do if V21<>CityOwnTile then
+    if 1 shl V21 and Tiles<>0 then
+      begin // tile is being exploited!
+      RadiusLoc:=Radius[V21];
+      if not (Map[RadiusLoc] and fTerrain in [fDesert,fArctic]) then
+        begin
+        assert(RadiusLoc>=0);
+        TileWorkPlan(RadiusLoc,cix,Value,NextJob,TotalWork);
+        if (NextJob=jRoad)
+          and (Built[imPalace]+Built[imCourt]+Built[imTownHall]=0) then
+          AddJob(RadiusLoc, NextJob, 44)
+        else if NextJob<>jNone then
+          AddJob(RadiusLoc, NextJob, 84)
+        end
+      end
+    else if CityAreaInfo.Available[V21]=faAvailable then
+      begin // tile could be exploited
+      RadiusLoc:=Radius[V21];
+      assert(RadiusLoc>=0);
+      if not (Map[RadiusLoc] and fTerrain in [fDesert,fArctic]) then
+        begin
+        TileWorkPlan(RadiusLoc,cix,Value,NextJob,TotalWork);
+        Value:=Value shl 16 +$FFFF-TotalWork;
+        if Value>BestUnusedValue then
+          begin
+          BestUnusedValue:=Value;
+          BestUnusedLoc:=RadiusLoc;
+          end
+        end
+      end;
+  if BestUnusedValue>0 then
+    begin
+    TileWorkPlan(BestUnusedLoc,cix,Value,NextJob,TotalWork);
+    if NextJob<>jNone then
+      AddJob(BestUnusedLoc, NextJob, 44)
+    end
+  end;
+
+ScoreRoadConnections;
+
+if Data.BehaviorFlags and bBarbarina=0 then // low priority jobs
+  for Loc:=0 to MapSize-1 do if RO.Territory[Loc]=me then
+    begin
+    Tile:=Map[Loc];
+    if Tile and fPoll<>0 then
+      AddJob(Loc, jPoll, 1)
+    else case Tile and (fTerrain or fSpecial or fCity) of
+      fGrass, fGrass+fSpecial1:
+        if IsResearched(adExplosives) and (SpecialTile(Loc,fHills,G.lx)>0) then
+          AddJob(Loc, jTrans, 1);
+      fSwamp:
+        if SpecialTile(Loc,fSwamp,G.lx)=0 then
+          AddJob(Loc, jClear, 1);
+      fTundra,fHills:
+        if IsResearched(adExplosives) and (Tile and fTerImp<>tiMine)
+          and (SpecialTile(Loc,fHills,G.lx)=0) then
+          AddJob(Loc, jTrans, 1);
+      end
+    end;
+
+// cities for colony ship production
+if Data.BehaviorFlags and bBarbarina=bBarbarina then
+  begin
+  for part:=0 to nShipPart-1 do
+    for i:=0 to ColonyShipPlan[part].nLocFoundCity-1 do
+      begin
+      Loc:=ColonyShipPlan[part].LocFoundCity[i];
+      Started:=false;
+      for uix:=0 to RO.nUn-1 do
+        if (MyUnit[uix].Loc=Loc) and (MyUnit[uix].Job=jCity) then
+          begin
+          Started:=true;
+          break
+          end;
+      if not Started then
+        begin
+        Tile:=RO.Map[Loc];
+        if (Tile and fTerrain=fForest) or (Tile and fTerrain=fSwamp) then
+          AddJob(Loc,jClear,235)
+        else if Tile and fTerrain=fHills then
+          begin
+          if IsResearched(adExplosives) then
+            AddJob(Loc,jTrans,235)
+          end
+        else AddJob(Loc,jCity,235);
+        end;
+      V21_to_Loc(Loc, Radius);
+      for V21:=1 to 26 do
+        begin
+        Loc1:=Radius[V21];
+        if (Loc1>=0) and (RO.Map[Loc1] and (fTerrain or fSpecial)=fSwamp) then
+          AddJob(Loc1,jClear,255);
+        end
+      end
+  end;
+
+// choose all settlers to work
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+  if (Loc>=0) and ((mix=mixSettlers) or (mix=mixSlaves)
+    or (Data.BehaviorFlags and bBarbarina<>0) and (MyModel[mix].Kind=mkSettler)) then
+    begin
+    JobAssignment_AddUnit(uix);
+    if (District[Loc]>=0) and (District[Loc]<maxCOD) then
+      inc(SettlerSurplus[District[Loc]]);
+    end;
+
+JobAssignment_Go;
+
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+  if (Loc>=0) and (Map[Loc] and fCity=0) and (Job=jNone)
+    and ((mix=mixSettlers) or (mix=mixSlaves))
+    and not JobAssignment_GotJob(uix) then
+    Unit_MoveEx(uix, maNextCity);
+
+//{$IFDEF DEBUG}DebugMessage(2, Format('Settler surplus in district 0: %d',[SettlerSurplus[0]]));{$ENDIF}
+
+// add settlers to city
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+  if (Loc>=0) and (Map[Loc] and fCity<>0)
+    and (MyModel[MyUnit[uix].mix].Kind=mkSettler) then
+    begin
+    dtr:=District[Loc];
+    if (mix<>mixSettlers)
+      or (dtr>=0) and (dtr<maxCOD)
+      and (SettlerSurplus[dtr]>DistrictPopulation[dtr] div 8) then
+      begin
+      City_FindMyCity(Loc, cix);
+      with MyCity[cix] do
+        if (Built[imSewer]>0)
+          or (Built[imAqueduct]>0) and (Size<=NeedSewerSize-2)
+          or (Size<=NeedAqueductSize-2) then
+          begin // settlers could be added to this city
+          Happy:=BasicHappy;
+          for i:=0 to 27 do if Built[i]>0 then inc(Happy);
+          if Built[imTemple]>0 then inc(Happy);
+          if Built[imCathedral]>0 then
+            begin
+            inc(Happy,2);
+            if RO.Wonder[woBach].EffectiveOwner=me then inc(Happy,1)
+            end;
+          if Built[imTheater]>0 then inc(Happy,2);
+          if (Built[imColosseum]>0) or (Happy shl 1>=Size+2) then
+            begin // bigger city would be happy
+//            {$IFDEF DEBUG}DebugMessage(2, Format('Adding settlers to city at %d',[Loc]));{$ENDIF}
+            Unit_AddToCity(uix);
+            if (dtr>=0) and (dtr<maxCOD) then dec(SettlerSurplus[dtr])
             end
           end;
-      end;
-
-  // choose all settlers to work
-  for uix := 0 to RO.nUn - 1 do
-    if (MyUnit[uix].Loc >= 0) and
-      (MyModel[MyUnit[uix].mix].Kind in [mkSettler, mkSlaves]) then
-      JobAssignment_AddUnit(uix);
-
-  JobAssignment_Go;
+      end
+    end;
 end; // ProcessSettlers
 
-// ProcessUnit: execute attack, capture, discover or patrol task according to unit role
-procedure TAI.ProcessUnit(uix: integer; Role: UnitRole);
+
+//-------------------------------
+//            MY TURN
+//-------------------------------
+
+procedure TAI.DoTurn;
+var
+emix,i,p1,TaxSum,ScienceSum,NewTaxRate: integer;
+AllHateMe: boolean;
+{$IFDEF PERF}PF,t0,t1,t2,t3,t4,t5,t6,t7,t8,t9: int64;{$ENDIF}
+begin
+{$IFDEF DEBUG}fillchar(DebugMap, sizeof(DebugMap),0);{$ENDIF}
+
+{$IFDEF PERF}QueryPerformanceFrequency(PF);{$ENDIF}
+{$IFDEF PERF}QueryPerformanceCounter(t0);{$ENDIF}
+
+WarNations:=PresenceUnknown;
+for p1:=0 to nPl-1 do
+  if (p1<>me) and (1 shl p1 and RO.Alive<>0) and (RO.Treaty[p1]<trPeace) then
+    inc(WarNations,1 shl p1);
+BombardingNations:=0;
+for emix:=0 to RO.nEnemyModel-1 do with RO.EnemyModel[emix] do
+  if (Domain=dSea) and (1 shl (mcLongRange-mcFirstNonCap) and Cap<>0) then
+    BombardingNations:=BombardingNations or (1 shl Owner);
+BombardingNations:=BombardingNations and WarNations;
+
+AnalyzeMap;
+//for i:=0 to MapSize-1 do DebugMap[i]:=Formation[i];
+
+if (Data.BehaviorFlags and bBarbarina=0)
+  and (RO.Tech[ResearchOrder[Data.BehaviorFlags and bGender,8]]<tsApplicable) then
+  CheckGender;
+
+if G.Difficulty[me]<MaxDiff then // not on beginner level
+  begin
+  if  (Data.LastResearchTech=adHorsebackRiding)
+    and (RO.ResearchTech<0) and (random(6)=0)
+    and (HavePort or (ContinentPresence[0] and not (1 shl me or PresenceUnknown)<>0)) then
+    begin
+    Data.BehaviorFlags:=Data.BehaviorFlags or bBarbarina_Hide;
+    DebugMessage(1, 'Early Barbarina!');
+    end;
+  if Data.BehaviorFlags and bBarbarina=0 then
+    begin
+    AllHateMe:=false;
+    for p1:=0 to nPl-1 do
+      if (1 shl p1 and RO.Alive<>0) and (RO.Treaty[p1]>=trNone) then
+        if (RO.Treaty[p1]<trPeace) and
+          ((Data.RejectTurn[suContact,p1]>=0)
+          or (Data.RejectTurn[suPeace,p1]>=0)) then
+          AllHateMe:=true
+        else begin AllHateMe:=false; break end;
+    if AllHateMe then
+      begin
+      Data.BehaviorFlags:=Data.BehaviorFlags or bBarbarina_Hide;
+      DebugMessage(1, 'All hate me!');
+      end
+    end;
+
+  if Data.BehaviorFlags and bBarbarina=0 then
+    if Barbarina_GoHidden then
+      begin
+      Data.BehaviorFlags:=Data.BehaviorFlags or bBarbarina_Hide;
+      DebugMessage(1, 'Barbarina!');
+      end;
+  if Data.BehaviorFlags and bBarbarina=bBarbarina_Hide then
+    if Barbarina_Go then
+      begin
+      Data.BehaviorFlags:=Data.BehaviorFlags or bBarbarina;
+      DebugMessage(1, 'Barbarina - no mercy!');
+      end;
+  end;
+
+{$IFDEF PERF}QueryPerformanceCounter(t1);{$ENDIF}
+
+  // better government form available?
+if (Data.BehaviorFlags and bBarbarina=0) and (RO.Turn>=LeaveDespotism)
+  and (RO.Government<>gAnarchy) then
+  if IsResearched(adDemocracy) then
+    begin
+    if RO.Government<>gDemocracy then
+      Revolution //!!!
+    end
+  else if IsResearched(adTheRepublic) then
+    begin
+    if RO.Government<>gRepublic then
+      Revolution
+    end
+  else if IsResearched(adMonarchy) then
+    begin
+    if RO.Government<>gMonarchy then
+      Revolution
+    end;
+
+CollectModelCatStat;
+
+if Data.BehaviorFlags and bBarbarina=bBarbarina then
+  begin
+  MakeColonyShipPlan;
+  Barbarina_DoTurn
+  end
+else
+  begin
+  {$IFDEF PERF}QueryPerformanceCounter(t2);{$ENDIF}
+
+  {$IFDEF PERF}QueryPerformanceCounter(t3);{$ENDIF}
+
+  AttackAndPatrol;
+
+  {$IFDEF PERF}QueryPerformanceCounter(t4);{$ENDIF}
+
+  MoveUnitsHome;
+
+  {$IFDEF PERF}QueryPerformanceCounter(t5);{$ENDIF}
+  end;
+
+ProcessSettlers;
+
+{$IFDEF PERF}QueryPerformanceCounter(t6);{$ENDIF}
+
+if Data.BehaviorFlags and bBarbarina<>0 then
+  Barbarina_SetCityProduction
+else
+  SetCityProduction;
+
+{$IFDEF PERF}QueryPerformanceCounter(t7);{$ENDIF}
+
+// correct tax rate if necessary
+if not IsResearched(adWheel) then
+  ChangeRates(0,0)
+else
+  begin
+  if (RO.TaxRate=0) or (RO.Money<(TotalPopulation[me]-4)*2) then
+    NewTaxRate:=RO.TaxRate // don't check decreasing tax
+  else NewTaxRate:=RO.TaxRate-10;
+  while NewTaxRate<100 do
+    begin
+    SumCities(NewTaxRate,TaxSum,ScienceSum);
+    if RO.Money+TaxSum>=(TotalPopulation[me]-4) then break; // enough
+    inc(NewTaxRate,10);
+    end;
+  if NewTaxRate<>RO.TaxRate then
+    begin
+  //  {$IFDEF DEBUG}DebugMessage(3,Format('New tax rate: %d',[NewTaxRate]));{$ENDIF}
+    ChangeRates(NewTaxRate,0)
+    end;
+  end;
+
+// clean up RequestedTechs
+if (Data.LastResearchTech>=0)
+  and (Data.LastResearchTech<>RO.ResearchTech) then // research completed
+  for p1:=0 to nPl-1 do
+    if (p1<>me) and (1 shl p1 and RO.Alive<>0)
+      and (RO.EnemyReport[p1].TurnOfCivilReport+TechReportOutdated>RO.Turn)
+      and (RO.EnemyReport[p1].Tech[Data.LastResearchTech]<tsSeen) then
+      begin // latest researched advance might be of interest to this nation
+      for i:=0 to nRequestedTechs-1 do
+        if (Data.RequestedTechs[i]>=0)
+          and (Data.RequestedTechs[i] shr 8 and $F=p1) then
+          Data.RequestedTechs[i]:=-1;
+      end;
+if RO.ResearchTech=adMilitary then Data.LastResearchTech:=-1
+else Data.LastResearchTech:=RO.ResearchTech;
+for i:=0 to nRequestedTechs-1 do
+  if (Data.RequestedTechs[i]>=0)
+    and (RO.Tech[Data.RequestedTechs[i] and $FF]>=tsSeen) then
+    Data.RequestedTechs[i]:=-1;
+
+// prepare negotiation
+AdvanceValuesSet:=false;
+SetAdvanceValues;
+
+
+{$IFDEF DEBUG}
+(*for p1:=0 to nPl-1 do
+  if (p1<>me) and (1 shl p1 and RO.Alive<>0) and (RO.Treaty[p1]>=trPeace)
+    and (RO.EnemyReport[p1].TurnOfCivilReport>=0) then
+    TraceAdvanceValues(p1);*)
+{$ENDIF}
+
+{$IFDEF PERF}DebugMessage(2,Format('t1=%d t2=%d t3=%d t4=%d t5=%d t6=%d t7=%d t8=%d t9=%d (ns)',[(t1-t0)*1000000 div PF,(t2-t1)*1000000 div PF,(t3-t2)*1000000 div PF,(t4-t3)*1000000 div PF,(t5-t4)*1000000 div PF,(t6-t5)*1000000 div PF,(t7-t6)*1000000 div PF,(t8-t7)*1000000 div PF,(t9-t8)*1000000 div PF]));{$ENDIF}
+end;
+
+{$IFDEF DEBUG}
+procedure TAI.TraceAdvanceValues(Nation: integer);
+var
+ad: integer;
+begin
+for ad:=0 to nAdv-1 do
+  if (RO.Tech[ad]<tsSeen) and (RO.EnemyReport[Nation].Tech[ad]>=tsApplicable)
+    and (AdvanceValue[ad]>0) then
+    begin
+    DebugMessage(2,Format('%s (%d): +%x',
+      [Name_Advance[ad], Advancedness[ad], AdvanceValue[ad]]))
+    end
+end;
+{$ENDIF}
+
+
+procedure TAI.CheckGender;
+var
+p1,NewGender: integer;
+begin
+NewGender:=-1;
+for p1:=0 to nPl-1 do
+  if (p1<>me) and (1 shl p1 and RO.Alive<>0)
+    and (RO.Treaty[p1]>=trFriendlyContact) then
+    if PlayerHash[me]>PlayerHash[p1] then
+      begin
+      if NewGender=bMale then
+        begin NewGender:=-2; break end; // ambiguous, don't change gender
+      NewGender:=bFemale;
+      end
+    else
+      begin
+      if NewGender=bFemale then
+        begin NewGender:=-2; break end; // ambiguous, don't change gender
+      NewGender:=bMale;
+      end;
+if (NewGender>=0) and (NewGender<>Data.BehaviorFlags and bGender) then
+  begin
+  Data.BehaviorFlags:=Data.BehaviorFlags and not bGender or NewGender;
+  DebugMessage(1, 'Gender:='+char(48+NewGender));
+  end
+end;
+
+
+procedure TAI.SetAdvanceValues;
+
+  procedure RateResearchAdv(ad, Time: integer);
+  var
+  Value: integer;
+  begin
+  if Time=0 then Value:=TechValue_ForResearch_Next
+  else Value:=TechValue_ForResearch-Time;
+  if AdvanceValue[ad]<Value then
+    AdvanceValue[ad]:=Value;
+  end;
+
+  procedure SetPreqValues(ad, Value: integer);
+  begin
+  if (RO.Tech[ad]<tsSeen) and (ad<>RO.ResearchTech) then
+    begin
+    if AdvanceValue[ad]<Value then
+      AdvanceValue[ad]:=Value;
+    if ad=adScience then
+      begin
+      SetPreqValues(adTheology,Value-1);
+      SetPreqValues(adPhilosophy,Value-1);
+      end
+    else if ad=adMassProduction then
+      // preqs should be researched now
+    else
+      begin
+      if AdvPreq[ad,0]>=0 then
+        SetPreqValues(AdvPreq[ad,0],Value-1);
+      if AdvPreq[ad,1]>=0 then
+        SetPreqValues(AdvPreq[ad,1],Value-1);
+      end;
+    end
+  end;
+
+  procedure RateImpPreq(iix, Value: integer);
+  begin
+  if (Value>0) and (Imp[iix].Preq>=0) then
+    inc(AdvanceValue[Imp[iix].Preq],Value);
+  end;
+
+var
+emix,cix,adMissing,iad,ad,count,i,Time,d,CurrentCost,CurrentStrength,
+  MaxSize, MaxTrade: integer;
+PreView,Emergency,Bombarded: boolean;
+begin
+if AdvanceValuesSet then exit;
+AdvanceValuesSet:=true;
+
+fillchar(AdvanceValue,sizeof(AdvanceValue),0);
+
+// rate techs to ensure research progress
+Time:=0;
+for ad:=0 to nAdv-1 do if RO.Tech[ad]=tsSeen then inc(Time);
+adMissing:=-1;
+Emergency:=true;
+for iad:=0 to nResearchOrder-1 do
+  begin
+  ad:=ResearchOrder[Data.BehaviorFlags and bGender,iad];
+  if (ad<>RO.ResearchTech) and (RO.Tech[ad]<tsSeen) then
+    begin
+    if adMissing<0 then adMissing:=ad;
+    RateResearchAdv(ad,Time); // unseen tech of own gender
+    if AdvPreq[ad,2]<>preNone then
+      begin // 2 of 3 required
+      count:=0;
+      for i:=0 to 2 do
+        if (AdvPreq[ad,i]=RO.ResearchTech)
+          or (RO.Tech[AdvPreq[ad,i]]>=tsSeen) then
+          inc(count);
+      if count>=2 then Emergency:=false
+      else
+        begin
+        if ad<>adMassProduction then // don't score third preq for MP
+          begin
+          for i:=0 to 2 do
+            if (AdvPreq[ad,i]<>RO.ResearchTech)
+              and (RO.Tech[AdvPreq[ad,i]]<tsSeen) then
+              RateResearchAdv(AdvPreq[ad,i],Time);
+          end;
+        inc(Time,2-count)
+        end
+      end
+    else
+      begin
+      count:=0;
+      for i:=0 to 1 do
+        if (AdvPreq[ad,i]<>preNone) and (AdvPreq[ad,i]<>RO.ResearchTech)
+          and (RO.Tech[AdvPreq[ad,i]]<tsSeen) then
+          begin
+          RateResearchAdv(AdvPreq[ad,i],Time);
+          inc(count)
+          end;
+      if count=0 then Emergency:=false;
+      inc(Time,count);
+      end;
+    inc(Time,2);
+    end
+  end;
+if Emergency and (adMissing>=0) then
+  begin
+  {$IFDEF DEBUG}DebugMessage(2, 'Research emergency: Go for'
+    +Name_Advance[adMissing]+' now!');{$ENDIF}
+  SetPreqValues(adMissing, TechValue_ForResearch_Urgent);
+  end;
+for iad:=0 to nResearchOrder-1 do
+  begin
+  ad:=ResearchOrder[Data.BehaviorFlags and bGender xor 1,iad];
+  if ad=adScience then
+    inc(AdvanceValue[ad], 5*TechValue_ForResearch_LeaveOut)
+  else if LeaveOutValue[ad]>0 then
+    if AdvanceValue[ad]>0 then
+      inc(AdvanceValue[ad], LeaveOutValue[ad]*TechValue_ForResearch_LeaveOut)
+//    else AdvanceValue[ad]:=1;
+  end;
+
+// rate military techs
+for d:=0 to nDomains-1 do
+  begin
+  CurrentCost:=0;
+  CurrentStrength:=0;
+  for PreView:=true downto false do
+    for i:=0 to nUpgrade-1 do with Upgrade[d,i] do
+      if (Preq>=0) and not (Preq in FutureTech) then
+        if ((Ro.ResearchTech=Preq) or (RO.Tech[Preq]>=tsSeen)) = PreView then
+          if PreView then
+            begin
+            if Cost>CurrentCost then CurrentCost:=Cost;
+            inc(CurrentStrength, Strength);
+            end
+          else
+            begin // rate
+            if (i>0) and (Trans>0) then inc(AdvanceValue[Preq],$400);
+            if Cost<=CurrentCost then
+              inc(AdvanceValue[Preq], (4-d)*Strength*$400 div (CurrentStrength+Upgrade[d,0].Strength))
+            else inc(AdvanceValue[Preq], (4-d)*Strength*$200 div (CurrentStrength+Upgrade[d,0].Strength))
+            end;
+  end;
+// speed
+inc(AdvanceValue[adSteamEngine],$400);
+inc(AdvanceValue[adNuclearPower],$400);
+inc(AdvanceValue[adRocketry],$400);
+// features
+inc(AdvanceValue[adBallistics],$800);
+inc(AdvanceValue[adCommunism],$800);
+// weight
+inc(AdvanceValue[adAutomobile],$800);
+inc(AdvanceValue[adSteel],$800);
+inc(AdvanceValue[adAdvancedFlight],$400);
+
+// civil non-improvement
+if RO.Turn>=LeaveDespotism then
+  begin
+  inc(AdvanceValue[adDemocracy],$80*RO.nCity);
+  inc(AdvanceValue[adTheRepublic],$800);
+  end;
+inc(AdvanceValue[adRailroad],$800);
+// inc(AdvanceValue[adExplosives],$800); // no, has enough 
+inc(AdvanceValue[adBridgeBuilding],$200);
+inc(AdvanceValue[adSpaceFlight],$200);
+inc(AdvanceValue[adSelfContainedEnvironment],$200);
+inc(AdvanceValue[adImpulseDrive],$200);
+inc(AdvanceValue[adTransstellarColonization],$200);
+
+// city improvements
+MaxSize:=0;
+for cix:=0 to RO.nCity-1 do
+  if MyCity[cix].Size>MaxSize then
+    MaxSize:=MyCity[cix].Size;
+if RO.Government in [gRepublic,gDemocracy,gLybertarianism] then
+  MaxTrade:=(MaxSize-1)*3
+else MaxTrade:=(MaxSize-1)*2;
+
+RateImpPreq(imCourt,(RO.nCity-1)*$100);
+RateImpPreq(imLibrary,(MaxTrade-10)*$180);
+RateImpPreq(imMarket,(MaxTrade-10)*$140);
+RateImpPreq(imUniversity,(MaxTrade-10)*$140);
+RateImpPreq(imBank,(MaxTrade-10)*$100);
+RateImpPreq(imObservatory,(MaxTrade-10)*$100);
+RateImpPreq(imResLab,(MaxTrade-14)*$140);
+RateImpPreq(imStockEx,(MaxTrade-10)*$10*(RO.nCity-1));
+RateImpPreq(imHighways,(MaxSize-5)*$200);
+RateImpPreq(imFactory,(MaxSize-8)*$200);
+RateImpPreq(imMfgPlant,(MaxSize-8)*$1C0);
+RateImpPreq(imRecycling,(MaxSize-8)*$180);
+RateImpPreq(imHarbor,(MaxSize-7)*$200);
+RateImpPreq(imSuperMarket,$300);
+if RO.Turn>=40 then RateImpPreq(imTemple,$400);
+if RO.Government<>gDespotism then
+  begin
+  RateImpPreq(imCathedral,$400);
+  RateImpPreq(imTheater,$400);
+  end;
+if MaxSize>=NeedAqueductSize-1 then
+  begin
+  RateImpPreq(imAqueduct,$600);
+  RateImpPreq(imGrWall,$300);
+  end;
+if cixStateImp[imPalace]>=0 then
+  with MyCity[cixStateImp[imPalace]] do
+    if (Built[imColosseum]+Built[imObservatory]>0) and (Size>=NeedSewerSize-1) then
+      RateImpPreq(imSewer,$400);
+Bombarded:=false;
+for emix:=0 to RO.nEnemyModel-1 do
+  if 1 shl (mcLongRange-mcFirstNonCap) and RO.EnemyModel[emix].Cap<>0 then
+    Bombarded:=true;
+if Bombarded then
+  RateImpPreq(imCoastalFort,$400);
+end;
+
+procedure TAI.AnalyzeMap;
+var
+cix,Loc,Loc1,V8,f1,p1: integer;
+Adjacent: TVicinity8Loc;
+begin
+inherited AnalyzeMap;
+
+// collect nation presence information for continents and oceans
+fillchar(ContinentPresence, sizeof(ContinentPresence), 0);
+fillchar(OceanPresence, sizeof(OceanPresence), 0);
+for Loc:=0 to MapSize-1 do
+  begin
+  f1:=Formation[Loc];
+  case f1 of
+    0..maxCOD-1:
+      begin
+      p1:=RO.Territory[Loc];
+      if p1>=0 then
+        if Map[Loc] and fTerrain>=fGrass then
+          ContinentPresence[f1]:=ContinentPresence[f1] or (1 shl p1)
+        else OceanPresence[f1]:=OceanPresence[f1] or (1 shl p1);
+      end;
+    nfUndiscovered:
+      begin // adjacent formations are not completely discovered
+      V8_to_Loc(Loc,Adjacent);
+      for V8:=0 to 7 do
+        begin
+        Loc1:=Adjacent[V8];
+        if Loc1>=0 then
+          begin
+          f1:=Formation[Loc1];
+          if (f1>=0) and (f1<maxCOD) then
+            if Map[Loc1] and fTerrain>=fGrass then
+              ContinentPresence[f1]:=ContinentPresence[f1] or PresenceUnknown
+            else OceanPresence[f1]:=OceanPresence[f1] or PresenceUnknown
+          end
+        end
+      end;
+    nfPeace:
+      begin // nation present in adjacent formations
+      V8_to_Loc(Loc,Adjacent);
+      for V8:=0 to 7 do
+        begin
+        Loc1:=Adjacent[V8];
+        if Loc1>=0 then
+          begin
+          f1:=Formation[Loc1];
+          if (f1>=0) and (f1<maxCOD) then
+            if Map[Loc1] and fTerrain>=fGrass then
+              ContinentPresence[f1]:=ContinentPresence[f1]
+                or (1 shl RO.Territory[Loc])
+            else OceanPresence[f1]:=OceanPresence[f1]
+              or (1 shl RO.Territory[Loc])
+          end
+        end
+      end;
+    end;
+  end;
+
+fillchar(TotalPopulation, sizeof(TotalPopulation), 0);
+fillchar(ContinentPopulation, sizeof(ContinentPopulation), 0);
+fillchar(DistrictPopulation, 4*nDistrict, 0);
+
+// count population
+for cix:=0 to RO.nEnemyCity-1 do with RO.EnemyCity[cix] do if Loc>=0 then
+  begin
+  inc(TotalPopulation[Owner],Size);
+  if (Formation[Loc]>=0) and (Formation[Loc]<maxCOD) then
+    inc(ContinentPopulation[Owner,Formation[Loc]],Size);
+  end;
+for cix:=0 to RO.nCity-1 do with RO.City[cix] do if Loc>=0 then
+  begin
+  inc(TotalPopulation[me],Size);
+  assert(District[Loc]>=0);
+  if District[Loc]<maxCOD then
+    inc(DistrictPopulation[District[Loc]],Size);
+  end;
+end;
+
+procedure TAI.CollectModelCatStat;
+var
+i,uix,Cat,mix,Quality: integer;
+begin
+// categorize models
+for Cat:=0 to nModelCat-1 do
+  ModelBestQuality[Cat]:=0;
+mixCaravan:=-1;
+mixSlaves:=-1;
+mixCruiser:=-1;
+for mix:=0 to RO.nModel-1 do
+  begin
+  ModelCat[mix]:=mctNone;
+  if mix=1 then mixMilitia:=mix
+  else
+    case MyModel[mix].Kind of
+      $00..$0F: // common units
+        if MyModel[mix].Cap[mcNav]>0 then mixCruiser:=mix // temporary!!!
+        else
+          begin
+          RateMyModel(mix,Cat,Quality);
+          ModelCat[mix]:=Cat;
+          ModelQuality[mix]:=Quality;
+          if (Cat>=0) and (Quality>ModelBestQuality[Cat]) then
+            ModelBestQuality[Cat]:=Quality;
+          end;
+      mkSpecial_TownGuard: mixTownGuard:=mix;
+      mkSettler: mixSettlers:=mix; // engineers always have higher mix
+      mkCaravan: mixCaravan:=mix;
+      mkSlaves: mixSlaves:=mix
+      end
+  end;
+
+// mark obsolete models with quality=0
+for mix:=0 to RO.nModel-1 do
+  if (MyModel[mix].Kind<$10) and (ModelCat[mix]>=0)
+    and (ModelQuality[mix]+MaxExistWorseThanBestModel
+      < ModelBestQuality[ModelCat[mix]]) then
+    ModelQuality[mix]:=ModelQuality[mix]-$40000000;
+
+OceanWithShip:=0;
+if mixCruiser>=0 then
+  for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+    if (Loc>=0) and (mix=mixCruiser) and (Map[Loc] and fTerrain<fGrass) then
+      begin
+      i:=Formation[Loc];
+      if (i>=0) and (i<maxCOD) then OceanWithShip:=OceanWithShip or (1 shl i)
+      end;
+end;
+
+
+procedure TAI.MoveUnitsHome;
 const
-  DistanceScore = 4;
+PatrolDestination=lxmax*lymax;
+FirstSurplusLoop: array[mctGroundDefender..mctGroundAttacker] of integer= (2,1);
 var
-  BestScore, BestCount, BestLoc, TerrType, TestLoc, NextLoc, TestDistance, Tile,
-    V8, TestScore, euix, MyDamage, EnemyDamage, TerrOwner, StepSize, OldLoc,
-    AttackForecast, MoveResult, AttackResult: integer;
-  Exhausted: boolean;
-  TestTask, BestTask: (utNone, utAttack, utCapture, utDiscover, utPatrol,
-    utGoHome);
+Cat,i,mix,cix,uix,Loop,nModelOrder: integer;
+Adjacent: TVicinity8Loc;
+LocNeed: array[0..lxmax*lymax-1] of shortint;
+Destination: array[0..nUmax-1] of integer;
+DistrictNeed,DistrictNeed0: array[0..maxCOD-1] of integer;
+ModelOrder: array[0..nMmax-1] of integer;
+complete,Fortified: boolean;
+
+  function IsBombarded(cix: integer): boolean;
+  var
+  Loc1,V8: integer;
   Adjacent: TVicinity8Loc;
-  AdjacentUnknown: array [0 .. lxmax * lymax - 1] of integer;
-
-begin
+  begin
+  result:=false;
+  if BombardingNations<>0 then with MyCity[cix] do
+    begin
+    V8_to_Loc(Loc,Adjacent);
+    for V8:=0 to 7 do
+      begin
+      Loc1:=Adjacent[V8];
+      if (Loc1>=0) and (Map[Loc1] and fTerrain<fGrass)
+        and (Formation[Loc1]>=0) and (Formation[Loc1]<maxCOD)
+        and (OceanPresence[Formation[Loc1]] and (BombardingNations or PresenceUnknown)<>0) then
+        begin result:=true; exit end
+      end;
+    end;
+  end;
+
+  procedure TryUtilize(uix: integer);
+  var
+  cix, ProdCost, UtilizeCost: integer;
+  begin
+  if (MyUnit[uix].Health=100)
+    and (Map[MyUnit[uix].Loc] and (fCity or fOwned)=fCity or fOwned) then
+    begin
+    City_FindMyCity(MyUnit[uix].Loc,cix);
+    with MyCity[cix] do if Project and cpImp=0 then
+      begin
+      ProdCost:=MyModel[Project and cpIndex].Cost;
+      UtilizeCost:=MyModel[MyUnit[uix].mix].Cost;
+      if Prod<(ProdCost-UtilizeCost*2 div 3)*BuildCostMod[G.Difficulty[me]] div 12 then
+        Unit_Disband(uix);
+      end
+    end
+  end;
+
+  procedure FindDestination(uix: integer);
+  var
+  MoveStyle,V8,Loc1,Time,NextLoc,NextTime,RecoverTurns: integer;
+  Reached: array[0..lxmax*lymax-1] of boolean;
+  begin
+  fillchar(Reached, MapSize, false);
   Pile.Create(MapSize);
   with MyUnit[uix] do
-    repeat
-      BestScore := -999999;
-      BestTask := utNone;
-      fillchar(AdjacentUnknown, sizeof(AdjacentUnknown), $FF);
-      // -1, indicates tiles not checked yet
-      Pile.Empty;
-      Pile.Put(Loc, 0); // start search for something to do at current location
-      while Pile.Get(TestLoc, TestDistance) do
-      begin
-        TestScore := 0;
-        Tile := Map[TestLoc];
-        AdjacentUnknown[TestLoc] := 0;
-
-        if ((Tile and fUnit) <> 0) and ((Tile and fOwned) = 0) then
+    begin
+    Pile.Put(Loc, $800-Movement);
+    MoveStyle:=GetMyMoveStyle(mix, 100);
+    end;
+  while Pile.Get(Loc1, Time) do
+    begin
+    if LocNeed[Loc1]>0 then
+      begin
+      LocNeed[Loc1]:=0;
+      if (District[Loc1]>=0) and (District[Loc1]<maxCOD) then
+        begin
+        assert(DistrictNeed[District[Loc1]]>0);
+        dec(DistrictNeed[District[Loc1]]);
+        end;
+      Destination[uix]:=Loc1;
+      break;
+      end;
+    Reached[Loc1]:=true;
+    V8_to_Loc(Loc1, Adjacent);
+    for V8:=0 to 7 do
+      begin
+      NextLoc:=Adjacent[V8];
+      if (NextLoc>=0) and not Reached[NextLoc] and (RO.Territory[NextLoc]=me) then
+        case CheckStep(MoveStyle, Time, V8 and 1, NextTime, RecoverTurns, Map[Loc1], Map[NextLoc], false) of
+          csOk:
+            Pile.Put(NextLoc, NextTime);
+          csForbiddenTile:
+            Reached[NextLoc]:=true; // don't check moving there again
+          csCheckTerritory:
+            assert(false);
+          end
+      end;
+    end;
+  Pile.Free;
+  end;
+
+begin
+if not (RO.Government in [gAnarchy, gDespotism]) then // utilize townguards
+  for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+    if (Loc>=0) and (Master<0) and (mix=mixTownGuard) then
+    Unit_Disband(uix);
+
+fillchar(UnitLack,sizeof(UnitLack),0);
+fillchar(Destination, 4*RO.nUn, $FF);
+for i:=0 to maxCOD-1 do
+  if uixPatrol[i]>=0 then
+    Destination[uixPatrol[i]]:=PatrolDestination;
+for uix:=0 to RO.nUn-1 do
+  if (MyUnit[uix].mix=mixMilitia) or (MyUnit[uix].mix=mixCruiser) then
+    Destination[uix]:=PatrolDestination;
+
+// distribute attackers and defenders
+for Cat:=mctGroundDefender to mctGroundAttacker do
+  begin
+  nModelOrder:=0;
+  for mix:=0 to Ro.nModel-1 do
+    if ModelCat[mix]=Cat then
+      begin
+      i:=nModelOrder;
+      while (i>0) and (ModelQuality[mix]<ModelQuality[ModelOrder[i-1]]) do
+        begin ModelOrder[i]:=ModelOrder[i-1]; dec(i) end;
+      ModelOrder[i]:=mix;
+      inc(nModelOrder);
+      end;
+
+  Loop:=0;
+  repeat
+    if Loop=FirstSurplusLoop[Cat] then
+      for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+        if (Loc>=0) and (Destination[uix]<0) and (Master<0)
+          and (ModelCat[mix]=Cat)
+          and (ModelQuality[mix]<0) then
+          TryUtilize(uix);
+
+    fillchar(LocNeed, MapSize, 0);
+    fillchar(DistrictNeed, sizeof(DistrictNeed), 0);
+
+    for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+      if ((Cat<>mctGroundDefender) or (Loop<>0) or IsBombarded(cix))
+        and ((Loop<>FirstSurplusLoop[Cat]) or (Built[imBarracks]+Built[imMilAcademy]>0))
+        and ((Loop<>FirstSurplusLoop[Cat]+1) or (Built[imBarracks]+Built[imMilAcademy]=0)) then
+        begin
+        LocNeed[Loc]:=1;
+        if (District[Loc]>=0) and (District[Loc]<maxCOD) then
+          begin
+          inc(DistrictNeed[District[Loc]]);
+          if Loop<FirstSurplusLoop[Cat] then
+            inc(UnitLack[District[Loc],Cat])
+          end
+        end;
+
+    if Loop=0 then // protect city building sites
+      for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+        if (Loc>=0) and (Job=jCity) and (RO.Territory[Loc]=me) then
+          begin
+          LocNeed[Loc]:=1;
+          if (District[Loc]>=0) and (District[Loc]<maxCOD) then
+            inc(DistrictNeed[District[Loc]]);
+          end;
+
+    complete:= Loop>=FirstSurplusLoop[Cat];
+    for i:=nModelOrder-1 downto 0 do
+      begin
+      for Fortified:=true downto false do
+        for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+          if (mix=ModelOrder[i])
+            and (Loc>=0) and (Destination[uix]<0) and (Master<0)
+            and ((Flags and unFortified<>0) = Fortified)
+            and (LocNeed[Loc]>0) then
+            begin
+            LocNeed[Loc]:=0;
+            if (District[Loc]>=0) and (District[Loc]<maxCOD) then
+              dec(DistrictNeed[District[Loc]]);
+            Destination[uix]:=Loc;
+            complete:=false;
+            end;
+
+      for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+        if (mix=ModelOrder[i])
+          and (Loc>=0) and (Destination[uix]<0) and (Master<0) then
+          if (District[Loc]>=0) and (District[Loc]<maxCOD)
+            and (DistrictNeed[District[Loc]]=0) then
+          else
+            begin // unassigned unit
+            FindDestination(uix);
+            if Destination[uix]>=0 then complete:=false;
+            end;
+      end;
+    inc(Loop)
+  until complete;
+  end;
+
+// distribute obsolete settlers
+repeat
+  fillchar(LocNeed, MapSize, 0);
+  fillchar(DistrictNeed, sizeof(DistrictNeed), 0);
+
+  for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+    if (Built[imSewer]>0)
+      or (Built[imAqueduct]>0) and (Size<=NeedSewerSize-2)
+      or (Size<=NeedAqueductSize-2)
+      or (Project=mixSettlers) then
+      begin
+      LocNeed[Loc]:=1;
+      if (District[Loc]>=0) and (District[Loc]<maxCOD) then
+        inc(DistrictNeed[District[Loc]]);
+      end;
+  DistrictNeed0:=DistrictNeed;
+
+  complete:=true;
+  for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+    if (Loc>=0) and (Destination[uix]<0) and (Master<0) then
+      if (MyModel[mix].Kind=mkSettler) and (mix<>mixSettlers)
+        and (Job=jNone) then
+        if (District[Loc]>=0) and (District[Loc]<maxCOD)
+          and (DistrictNeed[District[Loc]]=0) then
+          begin
+          if DistrictNeed0[District[Loc]]>0 then
+            complete:=false
+          end
+        else
+          begin // unassigned unit
+          FindDestination(uix);
+//          if (Destination[uix]<0) and (RO.Territory[Loc]=me) then
+//            complete:=false; // causes hangup when unit can't move due to zoc
+          end;
+until complete;
+
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do if Loc>=0 then
+  if Destination[uix]<0 then
+    begin
+    if (MyModel[mix].Kind<>mkSettler) and (MyModel[mix].Kind<>mkSlaves)
+      and (Master<0) and (Map[Loc] and fCity=0) then
+      Unit_MoveEx(uix, maNextCity);
+    end
+  else if (Destination[uix]<>PatrolDestination) and (Loc<>Destination[uix]) then
+    Unit_MoveEx(uix, Destination[uix]);
+
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+  if (Loc>=0) and (RO.Territory[Loc]=me)
+    and (District[Loc]>=0) and (District[Loc]<maxCOD)
+    and (ModelQuality[mix]>0) then
+    case ModelCat[mix] of
+      mctGroundDefender,mctGroundAttacker:
+        dec(UnitLack[District[Loc],ModelCat[mix]])
+      end;
+end; // MoveUnitsHome
+
+
+procedure TAI.CheckAttack(uix: integer);
+var
+AttackScore,BestCount,AttackLoc,TestLoc,NextLoc,TestTime,V8,
+  TestScore,euix,MyDamage,EnemyDamage,OldLoc,
+  AttackForecast,MoveResult,AttackResult,MoveStyle,NextTime,RecoverTurns: integer;
+Tile: Cardinal;
+Exhausted: boolean;
+Adjacent: TVicinity8Loc;
+Reached: array[0..lxmax*lymax-1] of boolean;
+
+begin
+with MyUnit[uix] do
+  begin
+  MoveStyle:=GetMyMoveStyle(mix,Health);
+  repeat
+    AttackScore:=-999999;
+    AttackLoc:=-1;
+    fillchar(Reached, MapSize, false);
+    Pile.Create(MapSize);
+    Pile.Put(Loc, $800-Movement); // start search for something to do at current location
+    while Pile.Get(TestLoc,TestTime) do
+      begin
+      TestScore:=0;
+      Tile:=Map[TestLoc];
+      Reached[TestLoc]:=true;
+
+      if ((Tile and fUnit)<>0) and ((Tile and fOwned)=0) then
         begin // enemy unit
-          Unit_FindEnemyDefender(TestLoc, euix);
-          if RO.Treaty[RO.EnemyUn[euix].Owner] < trPeace then
-          begin // unfriendly unit -- check attack
-            if Unit_AttackForecast(uix, TestLoc, 100, AttackForecast) then
+        assert(TestTime<$1000);
+        Unit_FindEnemyDefender(TestLoc,euix);
+        if RO.Treaty[RO.EnemyUn[euix].Owner]<trPeace then
+          if Unit_AttackForecast(uix,TestLoc,$800-TestTime,AttackForecast) then
             begin // attack possible, but advantageous?
-              if AttackForecast > 0 then
+            if AttackForecast=0 then
               begin // enemy unit would be destroyed
-                MyDamage := Health - AttackForecast;
-                EnemyDamage := RO.EnemyUn[euix].Health + DestroyBonus;
+              MyDamage:=Health+DestroyBonus;
+              EnemyDamage:=RO.EnemyUn[euix].Health+DestroyBonus;
               end
-              else // own unit would be destroyed
+            else if AttackForecast>0 then
+              begin // enemy unit would be destroyed
+              MyDamage:=Health-AttackForecast;
+              EnemyDamage:=RO.EnemyUn[euix].Health+DestroyBonus;
+              end
+            else // own unit would be destroyed
               begin
-                MyDamage := Health + DestroyBonus;
-                EnemyDamage := RO.EnemyUn[euix].Health + AttackForecast;
+              MyDamage:=Health+DestroyBonus;
+              EnemyDamage:=RO.EnemyUn[euix].Health+AttackForecast;
               end;
-              TestScore := Aggressive * 2 *
-                (EnemyDamage * RO.EnemyModel[RO.EnemyUn[euix].emix].Cost)
-                div (MyDamage * MyModel[mix].Cost);
-              if TestScore <= 100 then
-                TestScore := 0 // own losses exceed enemy losses, no good
-              else
+            TestScore:=Aggressive*2
+              *(EnemyDamage*RO.EnemyModel[RO.EnemyUn[euix].emix].Cost)
+              div (MyDamage*MyModel[mix].Cost);
+            if TestScore<=100 then TestScore:=0 // own losses exceed enemy losses, no good
+            else
               begin
-                TestScore := (TestScore - 100) div 10 + 30;
-                TestTask := utAttack
+              if TestScore>AttackScore then
+                BestCount:=0;
+              if TestScore>=AttackScore then
+                begin
+                inc(BestCount);
+                if random(BestCount)=0 then
+                  begin
+                  AttackScore:=TestScore;
+                  AttackLoc:=TestLoc;
+                  end
+                end;
               end
-            end
-          end
+            end;
         end // enemy unit
 
-        else if ((Tile and fCity) <> 0) and ((Tile and fOwned) = 0) then
-        begin // enemy city, empty or unobserved
-          if (MyModel[mix].Domain = dGround)
-          // ships of this AI have no long-range guns, so don't try to attack cities with them
-            and ((RO.Territory[TestLoc] < 0)
-            // happens only for unobserved cities of extinct tribes, new owner unknown
-            or (RO.Treaty[RO.Territory[TestLoc]] < trPeace)) then
-          begin // unfriendly city -- check attack/capture
-            if (Tile and fObserved) <> 0 then
-            begin // observed and no unit present -- city is undefended, capture!
-              TestScore := 40;
-              TestTask := utCapture
-            end
-            else if Role = Roam then
-            begin // unobserved city, possibly defended -- go for attack
-              TestScore := 30;
-              TestTask := utPatrol
-            end
-          end
-        end // enemy city, empty or unobserved
-
+      else if ((Tile and fCity)<>0) and ((Tile and fOwned)=0) then
+        // enemy city
+
+      else
+        begin // no enemy city or unit here
+        V8_to_Loc(TestLoc,Adjacent);
+        for V8:=0 to 7 do
+          begin
+          NextLoc:=Adjacent[V8];
+          if (NextLoc>=0) and not Reached[NextLoc]
+            and (Map[NextLoc] and fTerrain<>fUNKNOWN) then
+            if Map[NextLoc] and (fUnit or fOwned)=fUnit then
+              Pile.Put(NextLoc, TestTime) // foreign unit!
+            else case CheckStep(MoveStyle, TestTime, V8 and 1, NextTime,
+              RecoverTurns, Map[Loc], Map[NextLoc], true) of
+              csOk,csCheckTerritory:
+                if NextTime<$1000 then Pile.Put(NextLoc, NextTime);
+              csForbiddenTile:
+                Reached[NextLoc]:=true; // don't check moving there again
+              end
+          end;
+        end; // no enemy city or unit here
+      end; // while Pile.Get
+    Pile.Free;
+
+    if AttackLoc>=0 then
+      begin
+      OldLoc:=Loc;
+      MoveResult:=Unit_Move(uix,AttackLoc);
+      Exhausted:= (Loc=OldLoc)
+        or ((MoveResult and (rMoreTurns or rUnitRemoved))<>0);
+      if MoveResult and rLocationReached<>0 then
+        if Movement<100 then
+          Exhausted:=true
         else
+          begin
+          AttackResult:=Unit_Attack(uix,AttackLoc);
+          Exhausted:= ((AttackResult and rExecuted)=0)
+            or ((AttackResult and rUnitRemoved)<>0);
+          end;
+      end
+    else Exhausted:=true;
+  until Exhausted;
+  end;
+end; // CheckAttack
+
+
+procedure TAI.Patrol(uix: integer);
+const
+DistanceScore=4;
+var
+PatrolScore,BestCount,PatrolLoc,TestLoc,NextLoc,TestTime,V8,
+  TestScore,OldLoc,MoveResult,MoveStyle,NextTime,RecoverTurns: integer;
+Tile: Cardinal;
+Exhausted,CaptureOnly: boolean;
+Adjacent: TVicinity8Loc;
+AdjacentUnknown: array[0..lxmax*lymax-1] of shortint;
+
+begin
+with MyUnit[uix] do
+  begin
+  CaptureOnly:= ((100-Health)*Terrain[Map[Loc] and fTerrain].Defense>60)
+    and not (Map[Loc] and fTerrain in [fOcean, fShore, fArctic, fDesert]);
+  MoveStyle:=GetMyMoveStyle(mix, Health);
+  repeat
+    PatrolScore:=-999999;
+    PatrolLoc:=-1;
+    FillChar(AdjacentUnknown,MapSize,$FF); // -1, indicates tiles not checked yet
+    Pile.Create(MapSize);
+    Pile.Put(Loc, $800-Movement);
+    while Pile.Get(TestLoc,TestTime) do
+      begin
+      if (50*$1000-DistanceScore*TestTime<=PatrolScore) // assume a score of 50 is the best achievable
+        or CaptureOnly and (TestTime>=$1000) then
+        break;
+
+      TestScore:=0;
+      Tile:=Map[TestLoc];
+      AdjacentUnknown[TestLoc]:=0;
+
+      if ((Tile and fUnit)<>0) and ((Tile and fOwned)=0) then
+        // enemy unit
+
+      else if ((Tile and fCity)<>0) and ((Tile and fOwned)=0) then
+        begin
+        if ((Tile and fObserved)<>0)
+          and (MyModel[mix].Domain=dGround) and (MyModel[mix].Attack>0)
+          and ((RO.Territory[TestLoc]<0) // happens only for unobserved cities of extinct tribes, new owner unknown
+            or (RO.Treaty[RO.Territory[TestLoc]]<trPeace)) then
+          TestScore:=40 // unfriendly undefended city -- capture!
+        end
+
+      else
         begin // no enemy city or unit here
-          // add surrounding tiles to queue, but only if there's a chance to beat BestScore
-          if 50 - DistanceScore * (TestDistance + 1) >= BestScore then
-          // assume a score of 50 is the best achievable
+        V8_to_Loc(TestLoc,Adjacent);
+        for V8:=0 to 7 do
           begin
-            V8_to_Loc(TestLoc, Adjacent);
-            for V8 := 0 to 7 do
+          NextLoc:=Adjacent[V8];
+          if (NextLoc>=0) and (AdjacentUnknown[NextLoc]<0) then
+            if Map[NextLoc] and fTerrain=fUNKNOWN then
+              inc(AdjacentUnknown[TestLoc])
+            else if Formation[NextLoc]=Formation[TestLoc] then
+              case CheckStep(MoveStyle, TestTime, V8 and 1, NextTime, RecoverTurns, Map[TestLoc], Map[NextLoc], true) of
+                csOk:
+                  Pile.Put(NextLoc, NextTime);
+                csForbiddenTile:
+                  AdjacentUnknown[NextLoc]:=0; // don't check moving there again
+                csCheckTerritory:
+                  if RO.Territory[NextLoc]=RO.Territory[TestLoc] then
+                    Pile.Put(NextLoc, NextTime);
+                end
+          end;
+        if not CaptureOnly then
+          if AdjacentUnknown[TestLoc]>0 then
+            TestScore:=20+AdjacentUnknown[TestLoc]
+          else TestScore:=(RO.Turn-RO.MapObservedLast[TestLoc]) div 16;
+        end; // no enemy city or unit here
+
+      if TestScore>0 then
+        begin
+        TestScore:=TestScore*$1000-DistanceScore*TestTime;
+        if TestScore>PatrolScore then
+          BestCount:=0;
+        if TestScore>=PatrolScore then
+          begin
+          inc(BestCount);
+          if random(BestCount)=0 then
             begin
-              NextLoc := Adjacent[V8];
-              if (NextLoc >= 0) and (NextLoc < MapSize) and
-                (AdjacentUnknown[NextLoc] < 0) then // tile not checked yet
-              begin
-                TerrType := Map[NextLoc] and fTerrain;
-                if TerrType = fUNKNOWN then
-                  inc(AdjacentUnknown[TestLoc])
-                else
-                begin
-                  case MyModel[mix].Domain of
-                    dGround:
-                      begin
-                        TerrOwner := RO.Territory[NextLoc];
-                        if (TerrType >= fGrass) and (TerrType <> fArctic)
-                        // terrain can be walked
-                          and ((TerrOwner < 0) or (TerrOwner = me) or
-                          (RO.Treaty[TerrOwner] < trPeace))
-                        // no peace treaty violated
-                          and (((Map[NextLoc] and (fUnit or fCity)) <> 0) or
-                          (Map[TestLoc] and Map[NextLoc] and fInEnemyZoC = 0))
-                        then // no ZoC violated
-                        begin // yes, consider walking this tile
-                          if TerrType = fMountains then
-                            StepSize := 2 // mountains cause delay
-                          else
-                            StepSize := 1
-                        end
-                        else
-                          StepSize := 0 // no, don't walk here
-                      end;
-                    dSea:
-                      if TerrType = fShore then
-                      // ships of this AI can only move along shore
-                        StepSize := 1
-                      else
-                        StepSize := 0;
-                    dAir:
-                      StepSize := 1;
-                  end;
-                  if StepSize > 0 then
-                    Pile.Put(NextLoc, TestDistance + StepSize)
-                end
-              end;
-            end;
-          end;
-          if Role = Defend then
-            TestScore := 0 // don't discover/patrol
-          else if AdjacentUnknown[TestLoc] > 0 then
-          begin
-            TestScore := 20 + AdjacentUnknown[TestLoc];
-            TestTask := utDiscover
-          end
-          else
-          begin
-            TestScore := (RO.Turn - RO.MapObservedLast[TestLoc]) div 10;
-            TestTask := utPatrol
-          end
-        end; // no enemy city or unit here
-
-        if TestScore > 0 then
-        begin
-          TestScore := TestScore - DistanceScore * TestDistance;
-          if TestScore > BestScore then
-            BestCount := 0;
-          if TestScore >= BestScore then
-          begin
-            inc(BestCount);
-            if random(BestCount) = 0 then
-            begin
-              BestScore := TestScore;
-              BestLoc := TestLoc;
-              BestTask := TestTask;
+            PatrolScore:=TestScore;
+            PatrolLoc:=TestLoc;
             end
           end;
         end
-      end;
-
-      if (BestTask = utNone) and ((Map[Loc] and fCity) = 0) then
-      begin // nothing to do, move home
-        if Home >= 0 then
-          BestLoc := MyCity[Home].Loc
-        else
-          BestLoc := maNextCity;
-        BestTask := utGoHome;
-      end;
-      if BestTask <> utNone then
+      end; // while Pile.Get
+    Pile.Free;
+
+    if PatrolLoc>=0 then
       begin // attack/capture/discover/patrol task found, execute it
-        OldLoc := Loc;
-        MoveResult := Unit_Move(uix, BestLoc);
-        Exhausted := (Loc = OldLoc) or
-          ((MoveResult and (rMoreTurns or rUnitRemoved)) <> 0);
-        if (BestTask = utAttack) and ((MoveResult and rLocationReached) <> 0)
-        then
-          if Movement < 100 then
-            Exhausted := true
-          else
-          begin
-            AttackResult := Unit_Attack(uix, BestLoc);
-            Exhausted := ((AttackResult and rExecuted) = 0) or
-              ((AttackResult and rUnitRemoved) <> 0);
-          end;
-        if not Exhausted then
-          Exhausted := (Movement < 100) and
-            ((Map[Loc] and (fRoad or fRR or fRiver or fCity)) = 0);
-        // no road, too few movement points for further movement
-      end
-      else
-        Exhausted := true;
-    until Exhausted;
-  Pile.Free;
-end; // ProcessUnit
-
-// SetCityProduction: choose production of each city
+      OldLoc:=Loc;
+      MoveResult:=Unit_Move(uix,PatrolLoc);
+      Exhausted:= (Loc=OldLoc)
+        or ((MoveResult and (rMoreTurns or rUnitRemoved))<>0);
+      end
+    else Exhausted:=true;
+  until Exhausted;
+  end;
+end; // Patrol
+
+procedure TAI.AttackAndPatrol;
+const
+nAttackCatOrder=3;
+AttackCatOrder: array[0..nAttackCatOrder-1] of integer=
+(mctGroundAttacker, mctCruiser, mctGroundDefender);
+var
+iCat,uix,uix1: integer;
+IsPatrolUnit,Fortified: boolean;
+begin
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do // utilize militia
+  if (Loc>=0) and (mix=mixMilitia)
+    and ((Formation[Loc]<0) or (Formation[Loc]>=maxCOD)
+      or (ContinentPresence[Formation[Loc]] and PresenceUnknown=0)) then
+    Unit_Disband(uix);
+
+if RO.nEnemyUn>0 then
+  for iCat:=0 to nAttackCatOrder-1 do
+    for Fortified:=false to true do
+      for uix:=RO.nUn-1 downto 0 do with MyUnit[uix] do
+        if (Loc>=0) and (ModelCat[mix]=AttackCatOrder[iCat])
+          and (MyModel[mix].Attack>0)
+          and ((Flags and unFortified<>0) = Fortified) then
+          CheckAttack(uix);
+
+fillchar(uixPatrol, sizeof(uixPatrol), $FF);
+for uix:=0 to RO.nUn-1 do with MyUnit[uix],MyModel[mix] do
+  if (Loc>=0) and (Domain=dGround) and (Attack>0) and (Speed>=250)
+    and (Map[Loc] and fTerrain>=fGrass)
+    and (Formation[Loc]>=0) and (Formation[Loc]<maxCOD)
+    and ((uixPatrol[Formation[Loc]]<0)
+      or (MyUnit[uix].ID<MyUnit[uixPatrol[Formation[Loc]]].ID)) then
+      uixPatrol[Formation[Loc]]:=uix;
+
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do if Loc>=0 then
+  begin
+  if mix=mixMilitia then
+    if (RO.nUn<3) and (RO.nCity=1) or (Map[Loc] and fCity=0) then
+      IsPatrolUnit:=true
+    else
+      begin // militia
+      IsPatrolUnit:=false;
+      for uix1:=0 to RO.nUn-1 do
+        if (uix1<>uix) and (MyUnit[uix1].Loc=Loc)
+          and (MyUnit[uix1].mix<>mixSettlers) then
+          IsPatrolUnit:=true
+      end
+  else IsPatrolUnit:=(mix=mixCruiser)
+    or (Map[Loc] and fTerrain>=fGrass)
+    and (Formation[Loc]>=0) and (Formation[Loc]<maxCOD)
+    and (uix=uixPatrol[Formation[Loc]]);
+  if IsPatrolUnit then Patrol(uix);
+  end
+end; // AttackAndPatrol
+
+
+function TAI.HavePort: boolean;
+var
+V8, cix,AdjacentLoc,f: integer;
+Adjacent: TVicinity8Loc;
+begin
+result:=false;
+for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+  begin
+  V8_to_Loc(Loc,Adjacent);
+  for V8:=0 to 7 do
+    begin
+    AdjacentLoc:=Adjacent[V8];
+    if (AdjacentLoc>=0) and ((Map[AdjacentLoc] and fTerrain)<fGrass) then
+      begin
+      f:=Formation[AdjacentLoc];
+      if (f>=0) and (f<maxCOD) and (OceanPresence[f] and not (1 shl me)<>0) then
+        result:=true;
+      end
+    end;
+  end
+end;
+
+
 procedure TAI.SetCityProduction;
 var
-  cix, mix, mixSettler, mixShip, mixArmy, V8, NewImprovement, count, wix,
-    AdjacentLoc: integer;
-  IsPort: boolean;
-  Adjacent: TVicinity8Loc;
-  Report: TCityReport;
+uix,cix,iix,dtr,V8,V21,NewImprovement,AdjacentLoc,MaxSettlers,
+  maxcount,cixMilAcademy: integer;
+TerrType: cardinal;
+IsPort,IsNavalBase,NeedCruiser,CheckProd,Destructed,ProduceSettlers,ProduceMil: boolean;
+Adjacent: TVicinity8Loc;
+Radius: TVicinity21Loc;
+Report: TCityReport;
+HomeCount, CityProdRep: array[0..nCmax-1] of integer;
+MilProdCity: array[0..nCmax-1] of boolean;
 
   procedure TryBuild(Improvement: integer);
   begin
-    if (NewImprovement < 0) // already improvement of higher priority found
-      and (MyCity[cix].Built[Improvement] = 0) // not built yet
-      and City_Improvable(cix, Improvement) then
-      NewImprovement := Improvement;
+  if (NewImprovement=imTrGoods) // not already improvement of higher priority found
+    and (MyCity[cix].Built[Improvement]=0) // not built yet
+    and ((Imp[Improvement].Preq=preNone)
+      or (RO.Tech[Imp[Improvement].Preq]>=tsApplicable))
+    and City_Improvable(cix, Improvement) then
+    NewImprovement:=Improvement;
+  end;
+
+  procedure TryDestruct(Improvement: integer);
+  begin
+  if Destructed or (MyCity[cix].Built[Improvement]=0) then exit;
+  if City_CurrentImprovementProject(cix)>=0 then
+    City_RebuildImprovement(cix,Improvement)
+  else City_SellImprovement(cix, Improvement);
+{    if (CurrentImprovementProject>=0)
+      and (Imp[CurrentImprovementProject].Kind in [ikCommon,ikNatGlobal,ikNatLocal])
+      and ((Imp[CurrentImprovementProject].Cost*3-Imp[Improvement].Cost*2)
+      *BuildCostMod[G.Difficulty[me]]>MyCity[cix].Prod*(12*3)) then}
+  Destructed:=true
+  end;
+
+  function ChooseBuildModel(Cat: integer): integer;
+  var
+  count, mix: integer;
+  begin
+  count:=0;
+  for mix:=0 to RO.nModel-1 do
+    if (ModelCat[mix]=Cat)
+      and (ModelQuality[mix]>=ModelBestQuality[Cat]-MaxBuildWorseThanBestModel) then
+      begin inc(count); if random(count)=0 then result:=mix end;
+  assert(count>0);
+  end;
+
+  procedure NominateMilProdCities;
+  // find military production cities
+  var
+  cix, Total, d, Threshold, NewThreshold, Share, SharePlus, cixWorst: integer;
+  begin
+  fillchar(MilProdCity, RO.nCity, 0);
+  GetCityProdPotential;
+  for d:=0 to maxCOD-1 do
+    begin
+    Total:=0;
+    for cix:=0 to RO.nCity-1 do with MyCity[cix] do
+      if (Loc>=0) and (District[Loc]=d) then
+        Total:=Total+CityResult[cix];
+    if Total=0 then continue; // district does not exist
+
+    Share:=0;
+    cixWorst:=-1;
+    for cix:=0 to RO.nCity-1 do with MyCity[cix] do
+      if (Loc>=0) and (District[Loc]=d)
+        and (Built[imBarracks]+Built[imMilAcademy]>0) then
+        begin
+        MilProdCity[cix]:=true;
+        inc(Share,CityResult[cix]);
+        if (cixWorst<0) or (CityResult[cix]<CityResult[cixWorst]) then
+          cixWorst:=cix
+        end;
+
+    Threshold:=$FFFF;
+    while (Threshold>0) and (Share<Total*MilProdShare div 100) do
+      begin
+      NewThreshold:=-1;
+      for cix:=0 to RO.nCity-1 do with MyCity[cix] do
+        if (Loc>=0) and (District[Loc]=d)
+          and (Built[imBarracks]+Built[imMilAcademy]=0) and (Built[imObservatory]=0)
+          and (CityResult[cix]<Threshold)
+          and (CityResult[cix]>=NewThreshold) then
+          if CityResult[cix]>NewThreshold then
+            begin
+            NewThreshold:=CityResult[cix];
+            SharePlus:=CityResult[cix]
+            end
+          else inc(SharePlus,CityResult[cix]);
+      Threshold:=NewThreshold;
+      inc(Share,SharePlus);
+      end;
+
+    for cix:=0 to RO.nCity-1 do with MyCity[cix] do
+      if (Loc>=0) and (District[Loc]=d)
+        and (Built[imBarracks]+Built[imMilAcademy]=0)
+        and (CityResult[cix]>=Threshold) then
+        MilProdCity[cix]:=true;
+{    if (cixWorst>=0)
+      and (Share-CityResult[cixWorst]*2>=Total*MilProdShare div 100) then
+      MilProdCity[cixWorst]:=false;}
+    end;
+
+  // check best city for military academy
+  cixMilAcademy:=cixStateImp[imMilAcademy];
+  if cixStateImp[imPalace]>=0 then
+    begin
+    d:=District[MyCity[cixStateImp[imPalace]].Loc];
+    if (d>=0) and (d<maxCOD) then
+      begin
+      cixMilAcademy:=-1;
+      for cix:=0 to RO.nCity-1 do with MyCity[cix] do
+        if (Loc>=0) and (District[Loc]=d)
+          and (Built[imObservatory]+Built[imPalace]=0)
+          and ((cixMilAcademy<0) or (CityResult[cix]>CityResult[cixMilAcademy])) then
+          cixMilAcademy:=cix;
+      end;
+    if (cixMilAcademy>=0) and (cixStateImp[imMilAcademy]>=0)
+      and (cixMilAcademy<>cixStateImp[imMilAcademy])
+      and (MyCity[cixStateImp[imMilAcademy]].Built[imObservatory]=0)
+      and (CityResult[cixMilAcademy]<=CityResult[cixStateImp[imMilAcademy]]*3 div 2) then
+      cixMilAcademy:=cixStateImp[imMilAcademy] // because not so much better
+    end
+  end;
+
+  procedure ChangeHomeCities;
+  var
+  uix,NewHome,HomeSupport,NewHomeSupport,SingleSupport: integer;
+  begin
+  if RO.Government in [gAnarchy, gFundamentalism] then exit;
+  for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+    if (Loc>=0) and (Home>=0) and (Map[Loc] and fCity<>0)
+      and (MyCity[Home].Loc<>Loc) and (MyModel[mix].Kind<>mkSettler) then
+      begin
+      City_FindMyCity(Loc, NewHome);
+      case RO.Government of
+        gDespotism:
+          begin
+          HomeSupport:=HomeCount[Home]-MyCity[Home].Size;
+          NewHomeSupport:=HomeCount[NewHome]-MyCity[NewHome].Size;
+          end;
+        gMonarchy, gCommunism:
+          begin
+          HomeSupport:=HomeCount[Home]-MyCity[Home].Size div 2;
+          NewHomeSupport:=HomeCount[NewHome]-MyCity[NewHome].Size div 2;
+          end;
+        else
+          begin
+          HomeSupport:=HomeCount[Home];
+          NewHomeSupport:=HomeCount[NewHome];
+          end;
+        end;
+      if HomeSupport>0 then
+        begin
+        if MyModel[mix].Flags and mdDoubleSupport=0 then SingleSupport:=1
+        else SingleSupport:=2;
+        HomeSupport:=HomeSupport-SingleSupport;
+        NewHomeSupport:=NewHomeSupport+SingleSupport;
+        if HomeSupport<0 then HomeSupport:=0;
+        if NewHomeSupport<0 then NewHomeSupport:=0;
+        if (NewHomeSupport<=0)
+          or (CityProdRep[Home]-HomeSupport<=CityProdRep[NewHome]-NewHomeSupport) then
+          begin
+          dec(HomeCount[Home],SingleSupport);
+          inc(HomeCount[NewHome],SingleSupport);
+          Unit_SetHomeHere(uix)
+          end
+        end
+      end
   end;
 
 begin
-  // only produce newest models
-  mixSettler := -1;
-  mixArmy := -1;
-  mixShip := -1;
-  for mix := 0 to RO.nModel - 1 do
-    with MyModel[mix] do
-      if Kind = mkSettler then
-        mixSettler := mix
-      else if (Domain = dGround) and (Kind < mkSpecial_TownGuard) then
-        mixArmy := mix
-      else if Domain = dSea then
-        mixShip := mix;
-
-  for cix := 0 to RO.nCity - 1 do
-    with MyCity[cix] do
-      if (RO.Turn = 0) or ((Flags and chProduction) <> 0)
-      // city production complete
-        or not City_HasProject(cix) then
+fillchar(HomeCount, 4*RO.nCity, 0);
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+  if (Loc>=0) and (Home>=0) then
+    if MyModel[mix].Flags and mdDoubleSupport=0 then
+      inc(HomeCount[Home])
+    else inc(HomeCount[Home],2);
+
+NominateMilProdCities;
+
+for cix:=0 to RO.nCity-1 do with MyCity[cix] do
+  if (Loc>=0) and (Flags and chCaptured=0) and (District[Loc]>=0) then
+    begin
+    if size<4 then
+      City_OptimizeTiles(cix,rwMaxGrowth)
+    else City_OptimizeTiles(cix,rwForceProd);
+
+    City_GetReport(cix, Report);
+    CityProdRep[cix]:=Report.ProdRep;
+
+    Destructed:=false;
+    CheckProd:= (RO.Turn=0) or ((Flags and chProduction)<>0) // city production complete
+      or not City_HasProject(cix);
+    if not CheckProd then
+      begin // check whether producing double state improvement or wonder
+      iix:=City_CurrentImprovementProject(cix);
+      if (iix>=0)
+        and (((Imp[iix].Kind in [ikNatLocal,ikNatGlobal]) and (RO.NatBuilt[iix]>0))
+          or ((Imp[iix].Kind=ikWonder) and (RO.Wonder[iix].CityID<>-1))) then
+        CheckProd:=true;
+      end;
+    if CheckProd then
       begin // check production
-        IsPort := false;
-        V8_to_Loc(Loc, Adjacent);
-        for V8 := 0 to 7 do
-        begin
-          AdjacentLoc := Adjacent[V8];
-          if (AdjacentLoc >= 0) and (AdjacentLoc < MapSize) and
-            ((Map[AdjacentLoc] and fTerrain) = fShore) then
-            IsPort := true; // shore tile at adjacent location -- city is port!
+      IsPort:=false;
+      IsNavalBase:=false;
+      NeedCruiser:=false;
+      V8_to_Loc(Loc,Adjacent);
+      for V8:=0 to 7 do
+        begin
+        AdjacentLoc:=Adjacent[V8];
+        if (AdjacentLoc>=0) and ((Map[AdjacentLoc] and fTerrain)<fGrass) then
+          begin
+          IsPort:=true; // shore tile at adjacent location -- city is port!
+          if (Formation[AdjacentLoc]>=0) and (Formation[AdjacentLoc]<maxCOD)
+            and (OceanPresence[Formation[AdjacentLoc]] and WarNations<>0) then
+            begin
+            IsNavalBase:=true;
+            if (1 shl Formation[AdjacentLoc]) and OceanWithShip=0 then
+              NeedCruiser:=true
+            end
+          end
         end;
-        City_GetReport(cix, Report);
-
-        if (Report.Support = 0) or (SupportFree[RO.Government] < 2) and
-          (Report.Support < Report.ProdRep div 2) then
-        begin // enough material to support more units
-          if (RO.Turn > 4) and
-            ((Report.Eaten - Size * 2) div SettlerFood[RO.Government] <
-            Size div 4) then
-            // less than 1 settler per 4 citizens -- produce more!
-            City_StartUnitProduction(cix, mixSettler)
-          else if IsPort and (mixShip >= 0) and (random(2) = 0) then
-            City_StartUnitProduction(cix, mixShip)
-          else
-            City_StartUnitProduction(cix, mixArmy)
+
+      if RO.Turn=0 then
+        begin
+        NewImprovement:=-1;
+        City_StartUnitProduction(cix,mixMilitia); // militia
         end
-        else
-        begin // check for building a city improvement
-          NewImprovement := -1;
-          if Built[imPalace] + Built[imCourt] + Built[imTownHall] = 0 then
+      else NewImprovement:=imTrGoods;
+
+      dtr:=District[Loc]; // formation of city
+
+      if NewImprovement=imTrGoods then
+        begin
+        if (Built[imPalace]+Built[imCourt]+Built[imTownHall]=0) then
+          TryBuild(imTownHall);
+        end;
+
+      if (NewImprovement=imTrGoods)
+        and (RO.Government=gDespotism) and (Report.Support=0) then
+        begin // produce town guard
+        NewImprovement:=-1;
+        City_StartUnitProduction(cix,mixTownGuard);
+        end;
+
+      if NewImprovement=imTrGoods then
+        begin
+        if RO.Government=gDespotism then maxcount:=Size
+        else maxcount:=Size div 2;
+
+        if IsResearched(adRailroad) and (mixSettlers=0) // better wait for engineers
+          or (Built[imColosseum]+Built[imObservatory]>0) then
+          MaxSettlers:=1
+        else MaxSettlers:=(Size+2) div 6;
+        ProduceSettlers:=(HomeCount[cix]<maxcount+Size div 2)
+          and ((Report.Eaten-Size*2) div SettlerFood[RO.Government]<MaxSettlers)
+          and ((dtr<0) or (dtr>=maxCOD) or (SettlerSurplus[dtr]<=0));
+
+        ProduceMil:=(HomeCount[cix]<maxcount+Size div 2)
+          and (Built[imBarracks]+Built[imMilAcademy]>0)
+          and ((ModelBestQuality[mctGroundDefender]>0)
+            or (ModelBestQuality[mctGroundAttacker]>0))
+          and ((dtr<maxCOD)
+            and ((UnitLack[dtr,mctGroundAttacker]>0)
+              or (UnitLack[dtr,mctGroundDefender]>0))
+            or (HomeCount[cix]<maxcount));
+
+        if ProduceMil or not ProduceSettlers and (HomeCount[cix]<maxcount) then
           begin
-            TryBuild(imCourt);
-            TryBuild(imTownHall);
+          NewImprovement:=-1;
+          if (dtr>=maxCOD)
+            or (ModelBestQuality[mctGroundDefender]=0)
+            or (UnitLack[dtr,mctGroundAttacker]
+              >=UnitLack[dtr,mctGroundDefender]) then
+            City_StartUnitProduction(cix,ChooseBuildModel(mctGroundAttacker))
+          else City_StartUnitProduction(cix,ChooseBuildModel(mctGroundDefender))
+          end
+        else if ProduceSettlers then
+          begin
+          NewImprovement:=-1;
+          City_StartUnitProduction(cix,mixSettlers);
+          end
+        end;
+
+      if NewImprovement>=0 then
+        begin // produce improvement
+        if (RO.Turn>=40) and (Report.Happy*2<=Size)
+          and (Built[imColosseum]=0) then
+          TryBuild(imTemple);
+        if cix=cixMilAcademy then
+          TryBuild(imMilAcademy)
+        else if ((Built[imPalace]>0) or MilProdCity[cix] and (Built[imTemple]>0))
+          and (Built[imObservatory]=0) then
+          TryBuild(imBarracks);
+        if Report.Trade-Report.Corruption>=11 then
+          TryBuild(imLibrary);
+        if Report.Trade-Report.Corruption>=11 then
+          TryBuild(imMarket);
+        if (Report.Trade-Report.Corruption>=11) and (Report.Happy>=4) then
+          TryBuild(imUniversity);
+        if (Built[imPalace]>0) and (Report.Trade-Report.Corruption>=11)
+          and (Report.Happy>=4) and (RO.NatBuilt[imObservatory]=0) then
+          TryBuild(imObservatory); // always build observatory in capital
+        if (Report.Trade-Report.Corruption>=15) and (Report.Happy>=4) then
+          TryBuild(imResLab);
+        if (Size>=9) and (Built[imPalace]+Built[imCourt]>0) then
+          TryBuild(imHighways);
+        if (RO.Government<>gDespotism) and (Report.Happy*2<=Size)
+          and (Built[imCathedral]+Built[imTheater]+Built[imColosseum]=0) then
+          begin
+          TryBuild(imCathedral);
+          TryBuild(imTheater);
           end;
-          if Report.Trade - Report.Corruption >= 11 then
-            TryBuild(imLibrary);
-          if Report.Trade - Report.Corruption >= 11 then
-            TryBuild(imMarket);
-          if Size >= 9 then
-            TryBuild(imHighways);
-          if (RO.Government <> gDespotism) and (Size >= 4) then
-            TryBuild(imTemple);
-          if (RO.Government <> gDespotism) and (Size >= 6) then
-            TryBuild(imTheater);
-          if (RO.Government <> gDespotism) and (Size >= 8) then
-            TryBuild(imAqueduct);
-          if (Report.ProdRep >= 4) or (RO.nCity = 1) then
-            TryBuild(imBarracks);
-          TryBuild(imWalls);
-          if IsPort then
-            TryBuild(imCoastalFort);
-          if NewImprovement < 0 then
-          begin // nothing to produce -- check for building a wonder
-            count := 0;
-            for wix := 0 to nImp - 1 do
-              if (Imp[wix].Kind = ikWonder) and (RO.Wonder[wix].CityID = -1)
-              // not built yet
-                and ((Report.ProdRep - Report.Support) * 40 >= Imp[wix].Cost)
-              // takes less than 40 turns to produce
-                and City_Improvable(cix, wix) then
-              begin
-                inc(count);
-                if random(count) = 0 then
-                  NewImprovement := wix // yes, build this wonder!
-              end;
+        if (RO.Government<>gDespotism) and (Size>=NeedAqueductSize) then
+          TryBuild(imAqueduct);
+        if (Built[imColosseum]+Built[imObservatory]>0) and (Size>=NeedSewerSize) then
+          TryBuild(imSewer);
+        if (RO.NatBuilt[imGrWall]=0) and (Built[imObservatory]+Built[imMilAcademy]=0)
+          and (RO.nCity>=6) and (cixStateImp[imPalace]>=0)
+          and (Formation[Loc]=Formation[MyCity[cixStateImp[imPalace]].Loc])
+          and (Report.ProdRep-Report.Support>=6) then
+          TryBuild(imGrWall);
+  //        if Map[Loc] and fGrWall=0 then
+  //          TryBuild(imWalls);
+  //        if IsNavalBase then
+  //          TryBuild(imCoastalFort);
+        if (RO.NatBuilt[imSpacePort]=0) and (Built[imObservatory]+Built[imMilAcademy]=0)
+          and (Report.ProdRep-Report.Support>=10) then
+          TryBuild(imSpacePort);
+        if Report.ProdRep>=8 then
+          TryBuild(imFactory);
+        if Report.ProdRep>=12 then
+          TryBuild(imMfgPlant);
+        if IsPort then
+          if Size>8 then
+            TryBuild(imHarbor)
+          else if (Built[imHarbor]=0) and (Size>4)
+            and ((Size and 1<>0) and (Report.Happy*2>Size)
+              or (Built[imColosseum]>0)) then
+            begin // check building harbor
+            V21_to_Loc(Loc,Radius);
+            for V21:=1 to 26 do // city is in growth mode - using any 1-food tile?
+              if Tiles and (1 shl V21)<>0 then
+                begin
+                TerrType:=Map[Radius[V21]] and (fTerrain or fSpecial);
+                if TerrType in [fDesert,fTundra,fSwamp,fForest,fHills,fMountains] then
+                  begin TryBuild(imHarbor); break end
+                end
+            end;
+        if (Size<=10) and (Report.FoodRep-Report.Eaten<2) and
+          (Report.Happy*2>=Size+2) then
+          TryBuild(imSuperMarket);
+
+        // less important
+        if (Built[imPalace]>0) and (RO.NatBuilt[imColosseum]=0)
+          and (Size>=10) then
+          TryBuild(imColosseum); // always build colosseum in capital
+        if (Built[imPalace]+Built[imCourt]=0)
+          and ((Report.Corruption>2) or IsResearched(Imp[imHighways].Preq)) then
+          TryBuild(imCourt); // replace courthouse
+        if Report.PollRep>=15 then
+          TryBuild(imRecycling);
+        if (Report.Trade-Report.Corruption>=11)
+          and (RO.Money<TotalPopulation[me]*2) then
+          TryBuild(imBank);
+        if (RO.NatBuilt[imStockEx]=0) and (Built[imObservatory]+Built[imMilAcademy]=0)
+          and (Report.ProdRep-Report.Support>=8) then
+          TryBuild(imStockEx);
+
+        // every improvement checked -- start production now
+        if NewImprovement<>imTrGoods then
+          begin
+          if City_StartImprovement(cix, NewImprovement)<rExecuted then
+            NewImprovement:=imTrGoods
           end;
-          if NewImprovement >= 0 then
-            City_StartImprovement(cix, NewImprovement)
-          else if City_HasProject(cix) then
-            City_StopProduction(cix); // nothing to produce
-        end
-      end // check production
+        if (NewImprovement=imTrGoods) and (RO.Turn and $F=0) then
+          begin // try colony ship parts
+          NewImprovement:=imShipComp;
+          while (NewImprovement<=imShipHab)
+            and ((RO.Tech[Imp[NewImprovement].Preq]<0)
+            or (City_StartImprovement(cix, NewImprovement)<rExecuted)) do
+            inc(NewImprovement);
+          if NewImprovement>imShipHab then NewImprovement:=imTrGoods
+          end
+        end;
+
+      if (NewImprovement=imTrGoods) and NeedCruiser and (mixCruiser>=0)
+        and (Project and (cpImp or cpIndex)<>mixCruiser)
+        and (Report.ProdRep-Report.Support>=6) then
+        begin
+        NewImprovement:=-1;
+        City_StartUnitProduction(cix,mixCruiser);
+        end;
+
+      if (NewImprovement=imTrGoods) and City_HasProject(cix) then
+        City_StopProduction(cix);
+
+      // rebuild imps no longer needed
+      if (RO.TaxRate=0) and (RO.Money>=TotalPopulation[me]*4) then
+        TryDestruct(imBank)
+      else if Report.Happy*2>=Size+6 then
+        TryDestruct(imTheater)
+      else if Report.Happy*2>=Size+4 then
+        TryDestruct(imTemple)
+      end;
+
+    // rebuild imps no longer needed, no report needed
+    if (Built[imObservatory]>0)
+      or (Project and (cpImp or cpIndex)=cpImp or imObservatory)
+      {or not MilProdCity[cix]} then
+      TryDestruct(imBarracks);
+    if Map[Loc] and fGrWall<>0 then
+      TryDestruct(imWalls);
+    if Built[imColosseum]>0 then
+      begin
+      TryDestruct(imTheater);
+      TryDestruct(imCathedral);
+      TryDestruct(imTemple);
+      end;
+    end;
+
+ChangeHomeCities;
 end; // SetCityProduction
 
-function TAI.ChooseResearchAdvance: integer;
-var
-  mix: integer;
-begin
-  if not IsResearched(adWheel) then
-  begin
-    result := adWheel;
-    exit
-  end // research the wheel first
-  else if not IsResearched(adWarriorCode) then
-  begin
-    result := adWarriorCode;
-    exit
-  end // research warrior code first
-  else if not IsResearched(adHorsebackRiding) then
-  begin
-    result := adHorsebackRiding;
-    exit
-  end; // research horseback riding first
-
-  result := -1; // random advance
-  if random(10) = 0 then
-  begin // check military research
-    result := adMilitary;
-    if IsResearched(adMapMaking) and (random(2) = 0) then
-    begin // try to develop new ship
-      PrepareNewModel(dSea);
-      SetNewModelFeature(mcDefense, 3);
-      SetNewModelFeature(mcOffense, RO.DevModel.MaxWeight - 3);
-    end
-    else
-    begin // try to develop new ground unit
-      PrepareNewModel(dGround);
-      SetNewModelFeature(mcDefense, 1);
-      SetNewModelFeature(mcOffense, RO.DevModel.MaxWeight - 4);
-      SetNewModelFeature(mcMob, 2);
-    end;
-
-    // don't develop model twice
-    for mix := 0 to RO.nModel - 1 do
-      if (RO.DevModel.Domain = MyModel[mix].Domain) and
-        (RO.DevModel.Attack = MyModel[mix].Attack) and
-        (RO.DevModel.Defense = MyModel[mix].Defense) then
-        result := -1; // already have this model
-  end;
-end; // ChooseResearchAdvance
 
 function TAI.ChooseGovernment: integer;
 begin
-  if IsResearched(adTheRepublic) then
-    result := gRepublic
-  else if IsResearched(adMonarchy) then
-    result := gMonarchy
+if Data.BehaviorFlags and bBarbarina<>0 then
+  if IsResearched(adTheology) then result:=gFundamentalism
+  else result:=gDespotism
+else if IsResearched(adDemocracy) then
+  result:=gDemocracy //!!!
+else if IsResearched(adTheRepublic) then
+  result:=gRepublic
+else if IsResearched(adMonarchy) then
+  result:=gMonarchy
+else result:=gDespotism
+end;
+
+
+//-------------------------------
+//           DIPLOMACY
+//-------------------------------
+
+function TAI.MostWanted(Nation, adGiveAway: integer): integer;
+var
+ad: integer;
+begin
+result:=-1;
+if RO.Tech[adGiveAway]>=tsApplicable then
+  if (adGiveAway=adTheRepublic) and (Data.BehaviorFlags and bGender=bFemale)
+    and (RO.Tech[adTheology]<tsSeen) then
+    begin
+    if RO.EnemyReport[Nation].Tech[adTheology]>=tsApplicable then
+      result:=adTheology
+    end
+  else for ad:=0 to nAdv-5 do // no future techs
+      if (AdvanceValue[ad]>0)
+        and (RO.Tech[ad]<tsSeen) and (ad<>RO.ResearchTech)
+        and (RO.EnemyReport[Nation].Tech[ad]>=tsApplicable)
+        and ((Advancedness[adGiveAway]<=Advancedness[ad]+AdvanceValue[ad] shr 8+Compromise)
+          or (adGiveAway=adScience) and (Nation=Data.TheologyPartner))
+        and ((result<0)
+          or ((Advancedness[adGiveAway]+Compromise>=Advancedness[ad]) // acceptable for opponent
+            or (ad=adScience))
+          and (AdvanceValue[ad]>AdvanceValue[result])
+          or (result<>adScience)
+          and (Advancedness[adGiveAway]+Compromise<Advancedness[result])
+          and (Advancedness[ad]<Advancedness[result]))
+        and ((ad<>adTheRepublic) or (Data.BehaviorFlags and bGender=bFemale)
+          or (RO.EnemyReport[Nation].Tech[adTheology]>=tsSeen)) then
+        result:=ad
+end;
+
+procedure TAI.FindBestTrade(Nation: integer; var adWanted, adGiveAway: integer);
+var
+i,ad,ead,adTestGiveAway: integer;
+begin
+adWanted:=-1;
+adGiveAway:=-1;
+for ead:=0 to nAdv-5 do // no future techs
+  if (AdvanceValue[ead]>=$100)
+    and (RO.Tech[ead]<tsSeen) and (ead<>RO.ResearchTech)
+    and (RO.EnemyReport[Nation].Tech[ead]>=tsApplicable)
+    and ((adWanted<0) or (AdvanceValue[ead]>AdvanceValue[adWanted])) then
+    begin
+    adTestGiveAway:=-1;
+    for i:=0 to nRequestedTechs-1 do
+      if (Data.RequestedTechs[i]>=0)
+        and (Data.RequestedTechs[i] and $FFFF=Nation shl 8+ead) then
+        adTestGiveAway:=-2; // already requested before
+    if adTestGiveAway=-1 then
+      begin
+      for ad:=0 to nAdv-5 do // no future techs
+        if (RO.Tech[ad]>=tsApplicable)
+          and (ad<>RO.EnemyReport[Nation].ResearchTech)
+          and (RO.EnemyReport[Nation].Tech[ad]<tsSeen)
+          and ((Advancedness[ad]+Compromise>=Advancedness[ead]) or (ead=adScience))
+          and (Advancedness[ad]<=Advancedness[ead]+AdvanceValue[ead] shr 8+Compromise)
+          and ((adTestGiveAway<0) or (Advancedness[ad]<Advancedness[adTestGiveAway])) then
+          adTestGiveAway:=ad;
+      if adTestGiveAway>=0 then
+        begin
+        adWanted:=ead;
+        adGiveAway:=adTestGiveAway
+        end
+      end
+    end;
+end;
+
+
+function TAI.WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
+var
+p1,count,adWanted,adGiveAway: integer;
+begin
+if Data.BehaviorFlags and bBarbarina=bBarbarina then
+  begin result:=Barbarina_WantNegotiation(Nation,NegoTime); exit end;
+
+if RO.Treaty[Nation]<trPeace then
+  begin
+  if Data.BehaviorFlags and bBarbarina<>0 then
+    begin result:=false; exit end;
+  count:=0;
+  for p1:=0 to nPl-1 do
+    if (p1<>me) and (1 shl p1 and RO.Alive<>0) and (RO.Treaty[p1]>=trPeace) then
+      inc(count);
+  if count>=3 then // enough peace made
+    begin result:=false; exit; end
+  end;
+
+NegoCause:=Routine;
+case NegoTime of
+  EnemyCalled:
+    result:=true;
+  EndOfTurn:
+    if (Data.RejectTurn[suContact,Nation]>=0)
+      and (Data.RejectTurn[suContact,Nation]+WaitAfterReject>=RO.Turn) then
+      result:=false
+    else if RO.Treaty[Nation]<trPeace then
+      result:=(Data.RejectTurn[suPeace,Nation]<0)
+        or (Data.RejectTurn[suPeace,Nation]+WaitAfterReject<RO.Turn)
+    else if RO.Treaty[Nation]=trPeace then
+      result:= (Data.BehaviorFlags and bBarbarina=0)
+        and ((Data.RejectTurn[suFriendly,Nation]<0)
+          or (Data.RejectTurn[suFriendly,Nation]+WaitAfterReject<RO.Turn))
+    else
+      begin
+      FindBestTrade(Nation,adWanted,adGiveAway);
+      result:= adWanted>=0;
+      end;
+  BeginOfTurn:
+    if (Data.RejectTurn[suContact,Nation]>=0)
+      and (Data.RejectTurn[suContact,Nation]+WaitAfterReject>=RO.Turn) then
+      result:=false
+    else if (Data.BehaviorFlags and bGender=bMale) and Barbarina_WantCheckNegotiation(Nation) then
+      begin NegoCause:=CheckBarbarina; result:=true; end
+    else result:=false;
+  end;
+end;
+
+procedure TAI.DoNegotiation;
+var
+i, adWanted, adGiveAway, adToGet, Slot: integer;
+BuildFreeOffer: boolean;
+begin
+if MyLastAction=scDipOffer then
+  if OppoAction=scDipAccept then
+    begin // evaluate accepted offers
+    AdvanceValuesSet:=false;
+    if (MyLastOffer.nDeliver=1) and (MyLastOffer.nCost>0)
+      and (MyLastOffer.Price[1]=opTech+adTheology) then
+      Data.TheologyPartner:=Opponent;
+    end
   else
-    result := gDespotism
+    begin // evaluate rejected offers
+    if MyLastOffer.nDeliver+MyLastOffer.nCost=1 then
+      if MyLastOffer.Price[0]=opTreaty+trPeace then
+        Data.RejectTurn[suPeace,Opponent]:=RO.Turn
+      else if MyLastOffer.Price[0]=opTreaty+trFriendlyContact then
+        Data.RejectTurn[suFriendly,Opponent]:=RO.Turn;
+    end;
+if OppoAction=scDipBreak then
+  Data.RejectTurn[suContact,Opponent]:=RO.Turn
+else if OppoAction=scDipCancelTreaty then
+  begin
+  case RO.Treaty[Opponent] of
+    trNone: Data.RejectTurn[suPeace,Opponent]:=RO.Turn;
+    trPeace: Data.RejectTurn[suFriendly,Opponent]:=RO.Turn;
+    end;
+  end;
+
+if Data.BehaviorFlags and bBarbarina=bBarbarina then
+  begin Barbarina_DoNegotiation; exit end;
+
+if NegoCause=CheckBarbarina then
+  begin Barbarina_DoCheckNegotiation; exit end;
+
+SetAdvanceValues; // in case no turn played after loading this game
+
+BuildFreeOffer:=false;
+if (OppoAction=scDipStart) or (OppoAction=scDipAccept) then
+  BuildFreeOffer:=true
+else if (OppoAction=scDipOffer) and (OppoOffer.nDeliver+OppoOffer.nCost=0) then
+  BuildFreeOffer:=true
+else if OppoAction=scDipOffer then
+  begin
+  if (Data.BehaviorFlags and bBarbarina=0)
+    and (OppoOffer.nDeliver+OppoOffer.nCost=1)
+    and (OppoOffer.Price[0] and opMask=opTreaty)
+    and (integer(OppoOffer.Price[0]-opTreaty)>RO.Treaty[Opponent])
+    and ((OppoOffer.Price[0]-opTreaty<trAlliance) or (RO.Tech[adScience]>=tsSeen)) then
+    MyAction:=scDipAccept // accept all treaties
+  else if (RO.Treaty[Opponent]>=trPeace)
+    and (OppoOffer.nDeliver=1)
+    and (OppoOffer.Price[0] and $FFFF0000=opCivilReport+cardinal(Opponent) shl 16)
+    and (OppoOffer.nCost=1)
+    and (OppoOffer.Price[1] and $FFFF0000=opCivilReport+cardinal(me) shl 16) then
+    MyAction:=scDipAccept // accept exchange of civil reports
+  else if (OppoOffer.nDeliver=1) and (OppoOffer.nCost=1)
+    and (OppoOffer.Price[1] and opMask=opTech) then
+    begin // opponent wants tech
+    BuildFreeOffer:=true;
+    adGiveAway:=OppoOffer.Price[1]-opTech;
+    if (OppoOffer.Price[0] and opMask=opTech)
+      and (MyLastAction=scDipOffer)
+      and (MyLastOffer.nDeliver=1) and (MyLastOffer.nCost=1)
+      and (OppoOffer.Price[0]=MyLastOffer.Price[1]) then
+      begin // opponent makes counter offer, check whether to accept
+      adToGet:=OppoOffer.Price[0]-opTech;
+      if (adGiveAway=adTheRepublic) and (Data.BehaviorFlags and bGender=bFemale)
+        and (RO.Tech[adTheology]<tsSeen) then
+        begin
+        if adToGet=adTheology then MyAction:=scDipAccept;
+        end
+      else if (RO.Tech[adGiveAway]>=tsApplicable) and (RO.Tech[adToGet]<tsSeen)
+        and (AdvanceValue[adToGet]>0)
+        and ((Advancedness[adGiveAway]<=Advancedness[adToGet]
+          +AdvanceValue[adToGet] shr 8+Compromise)
+          or (adGiveAway=adScience) and (Opponent=Data.TheologyPartner)) then
+        MyAction:=scDipAccept
+      end
+    else if (OppoOffer.Price[0] and opMask=opChoose)
+      or (OppoOffer.Price[0] and opMask=opTech) then
+      begin // choose price
+      adWanted:=MostWanted(Opponent,OppoOffer.Price[1]-opTech);
+      if (OppoOffer.Price[0] and opMask=opTech)
+        and (Cardinal(adWanted)=OppoOffer.Price[0]-opTech) then
+        MyAction:=scDipAccept // opponent's offer is already perfect
+      else if adWanted>=0 then
+        begin // make improved counter offer
+        MyOffer.nDeliver:=1;
+        MyOffer.nCost:=1;
+        MyOffer.Price[0]:=OppoOffer.Price[1];
+        MyOffer.Price[1]:=opTech+adWanted;
+        MyAction:=scDipOffer;
+        BuildFreeOffer:=false
+        end
+      end;
+    if MyAction=scDipAccept then BuildFreeOffer:=false
+    end
+  else BuildFreeOffer:=true
+  end;
+if (MyAction=scDipAccept) and (OppoAction=scDipOffer) then
+  begin
+  AdvanceValuesSet:=false;
+  if (OppoOffer.nDeliver>0) and (OppoOffer.Price[0]=opTech+adTheology) then
+    Data.TheologyPartner:=Opponent
+  end;
+
+if BuildFreeOffer then
+  begin
+  if (Data.BehaviorFlags and bBarbarina=0)
+    and (RO.Treaty[Opponent]<trPeace)
+    and ((Data.RejectTurn[suPeace,Opponent]<0)
+      or (Data.RejectTurn[suPeace,Opponent]+WaitAfterReject<RO.Turn)) then
+    begin
+    MyOffer.nDeliver:=1;
+    MyOffer.nCost:=0;
+    MyOffer.Price[0]:=opTreaty+trPeace;
+    MyAction:=scDipOffer
+    end
+  else if (Data.BehaviorFlags and bBarbarina=0)
+    and (RO.Treaty[Opponent]=trPeace)
+    and ((Data.RejectTurn[suFriendly,Opponent]<0)
+      or (Data.RejectTurn[suFriendly,Opponent]+WaitAfterReject<RO.Turn)) then
+    begin
+    MyOffer.nDeliver:=1;
+    MyOffer.nCost:=0;
+    MyOffer.Price[0]:=opTreaty+trFriendlyContact;
+    MyAction:=scDipOffer
+    end
+  else
+    begin
+    FindBestTrade(Opponent, adWanted, adGiveAway);
+    if adWanted>=0 then
+      begin
+      MyOffer.nDeliver:=1;
+      MyOffer.nCost:=1;
+      MyOffer.Price[0]:=opTech+adGiveAway;
+      MyOffer.Price[1]:=opTech+adWanted;
+      MyAction:=scDipOffer;
+      for i:=0 to nRequestedTechs-1 do
+        if Data.RequestedTechs[i]<0 then
+          begin Slot:=i; break end
+        else if (i=0) or (Data.RequestedTechs[i] shr 16
+          <Data.RequestedTechs[Slot] shr 16) then // find most outdated entry
+          Slot:=i;
+      Data.RequestedTechs[Slot]:=RO.Turn shl 16+Opponent shl 8+adWanted
+      end
+    end
+  end;
+end; // Negotiation
+
+
+procedure SetLeaveOutValue;
+  procedure Process(ad: integer);
+  var
+  i: integer;
+  begin
+  if LeaveOutValue[ad]<0 then
+    begin
+    LeaveOutValue[ad]:=0;
+    for i:=0 to 1 do if AdvPreq[ad,i]>=0 then
+      begin
+      Process(AdvPreq[ad,i]);
+      if AdvPreq[ad,i] in LeaveOutTechs then
+        inc(LeaveOutValue[ad], LeaveOutValue[AdvPreq[ad,i]]+1)
+      end
+    end
+  end;
+var
+ad: integer;
+begin
+FillChar(LeaveOutValue,SizeOf(LeaveOutValue),$FF);
+for ad:=0 to nAdv-5 do Process(ad);
 end;
 
 
-// -------------------------------
-// DIPLOMACY
-// -------------------------------
-
-function TAI.WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
-begin
-  result := (NegoTime = EnemyCalled) // always accept contact
-    or (NegoTime = EndOfTurn) and (RO.Turn mod 20 = Nation + me)
-  // ask for contact only once in 20 turns
-end;
-
-procedure TAI.DoNegotiation;
-begin
-  if (RO.Treaty[Opponent] < trPeace) and Odd(me + Opponent) then
-  // make peace with some random nations
-    if (OppoAction = scDipOffer) and (OppoOffer.nCost = 0) and
-      (OppoOffer.nDeliver = 1) and (OppoOffer.Price[0] = opTreaty + trPeace)
-    then
-      MyAction := scDipAccept // accept peace
-    else if OppoAction = scDipStart then
-    begin
-      MyOffer.nCost := 0;
-      MyOffer.nDeliver := 1;
-      MyOffer.Price[0] := opTreaty + trPeace;
-      // offer peace in exchange of nothing
-      MyAction := scDipOffer;
-    end
-end;
+initialization
+RWDataSize:=sizeof(TPersistentData);
+SetLeaveOutValue;
 
 end.
+

trunk/AI/StdAI/CustomAI.pas

@@ -5 +5 @@
 
 uses
-{$IFDEF DEBUG}SysUtils, {$ENDIF} // necessary for debug exceptions
+{$IFDEF DEBUG}SysUtils,{$ENDIF} // necessary for debug exceptions
   Protocol;
 
 type
-  TNegoTime = (BeginOfTurn, EndOfTurn, EnemyCalled);
-
-  TCustomAI = class
-  public
-    procedure Process(Command: integer; var Data);
-
-    // overridables
-    constructor Create(Nation: integer); virtual;
-    destructor Destroy; override;
-    procedure SetDataDefaults; virtual;
-    procedure SetDataRandom; virtual;
-    procedure OnBeforeEnemyAttack(UnitInfo: TUnitInfo;
-      ToLoc, EndHealth, EndHealthDef: integer); virtual;
-    procedure OnBeforeEnemyCapture(UnitInfo: TUnitInfo;
-      ToLoc: integer); virtual;
-    procedure OnAfterEnemyAttack; virtual;
-    procedure OnAfterEnemyCapture; virtual;
-
-  protected
-    me: integer; // index of the controlled nation
-    RO: ^TPlayerContext;
-    Map: ^TTileList;
-    MyUnit: ^TUnList;
-    MyCity: ^TCityList;
-    MyModel: ^TModelList;
-
-    cixStateImp: array [imPalace .. imSpacePort] of integer;
-
-    // negotiation
-    Opponent: integer;
-    // nation i'm in negotiation with, -1 indicates no-negotiation mode
-    MyAction, MyLastAction, OppoAction: integer;
-    MyOffer, MyLastOffer, OppoOffer: TOffer;
-
-    // overridables
-    procedure DoTurn; virtual;
-    procedure DoNegotiation; virtual;
-    function ChooseResearchAdvance: integer; virtual;
-    function ChooseStealAdvance: integer; virtual;
-    function ChooseGovernment: integer; virtual;
-    function WantNegotiation(Nation: integer; NegoTime: TNegoTime)
-      : boolean; virtual;
-    function OnNegoRejected_CancelTreaty: boolean; virtual;
-
-    // general functions
-    function IsResearched(Advance: integer): boolean;
-    function ResearchCost: integer;
-    function ChangeAttitude(Nation, Attitude: integer): integer;
-    function Revolution: integer;
-    function ChangeRates(Tax, Lux: integer): integer;
-    function PrepareNewModel(Domain: integer): integer;
-    function SetNewModelFeature(F, Count: integer): integer;
-    function AdvanceResearchable(Advance: integer): boolean;
-    function AdvanceStealable(Advance: integer): boolean;
-    function GetJobProgress(Loc: integer;
-      var JobProgress: TJobProgressData): boolean;
-    function DebugMessage(Level: integer; Text: string): boolean;
-    function SetDebugMap(var DebugMap): boolean;
-
-    // unit functions
-    procedure Unit_FindMyDefender(Loc: integer; var uix: integer);
-    procedure Unit_FindEnemyDefender(Loc: integer; var euix: integer);
-    function Unit_Move(uix, ToLoc: integer): integer;
-    function Unit_Step(uix, ToLoc: integer): integer;
-    function Unit_Attack(uix, ToLoc: integer): integer;
-    function Unit_DoMission(uix, MissionType, ToLoc: integer): integer;
-    function Unit_MoveForecast(uix, ToLoc: integer;
-      var RemainingMovement: integer): boolean;
-    function Unit_AttackForecast(uix, ToLoc, AttackMovement: integer;
-      var RemainingHealth: integer): boolean;
-    function Unit_DefenseForecast(euix, ToLoc: integer;
-      var RemainingHealth: integer): boolean;
-    function Unit_Disband(uix: integer): integer;
-    function Unit_StartJob(uix, NewJob: integer): integer;
-    function Unit_SetHomeHere(uix: integer): integer;
-    function Unit_Load(uix: integer): integer;
-    function Unit_Unload(uix: integer): integer;
-    function Unit_SelectTransport(uix: integer): integer;
-    function Unit_AddToCity(uix: integer): integer;
-
-    // city functions
-    procedure City_FindMyCity(Loc: integer; var cix: integer);
-    procedure City_FindEnemyCity(Loc: integer; var ecix: integer);
-    function City_HasProject(cix: integer): boolean;
-    function City_CurrentImprovementProject(cix: integer): integer;
-    function City_CurrentUnitProject(cix: integer): integer;
-    function City_GetTileInfo(cix, TileLoc: integer;
-      var TileInfo: TTileInfo): integer;
-    function City_GetReport(cix: integer; var Report: TCityReport): integer;
-    function City_GetHypoReport(cix, HypoTiles, HypoTax, HypoLux: integer;
-      var Report: TCityReport): integer;
-    function City_GetReportNew(cix: integer;
-      var Report: TCityReportNew): integer;
-    function City_GetHypoReportNew(cix, HypoTiles, HypoTaxRate,
-      HypoLuxuryRate: integer; var Report: TCityReportNew): integer;
-    function City_GetAreaInfo(cix: integer;
-      var AreaInfo: TCityAreaInfo): integer;
-    function City_StartUnitProduction(cix, mix: integer): integer;
-    function City_StartEmigration(cix, mix: integer;
-      AllowDisbandCity, AsConscripts: boolean): integer;
-    function City_StartImprovement(cix, iix: integer): integer;
-    function City_Improvable(cix, iix: integer): boolean;
-    function City_StopProduction(cix: integer): integer;
-    function City_BuyProject(cix: integer): integer;
-    function City_SellImprovement(cix, iix: integer): integer;
-    function City_RebuildImprovement(cix, iix: integer): integer;
-    function City_SetTiles(cix, NewTiles: integer): integer;
-    procedure City_OptimizeTiles(cix: integer;
-      ResourceWeights: integer = rwMaxGrowth);
-
-    // negotiation
-    function Nego_CheckMyAction: integer;
-
-  private
-    HaveTurned: boolean;
-    UnwantedNego: set of 0 .. nPl - 1;
-    Contacted: set of 0 .. nPl - 1;
-    procedure StealAdvance;
+TNegoTime=(BeginOfTurn, EndOfTurn, EnemyCalled);
+
+TCustomAI=class
+public
+  procedure Process(Command: integer; var Data);
+
+  // overridables
+  constructor Create(Nation: integer); virtual;
+  destructor Destroy; override;
+  procedure SetDataDefaults; virtual;
+  procedure SetDataRandom; virtual;
+  procedure OnBeforeEnemyAttack(UnitInfo: TUnitInfo;
+    ToLoc, EndHealth, EndHealthDef: integer); virtual;
+  procedure OnBeforeEnemyCapture(UnitInfo: TUnitInfo; ToLoc: integer); virtual;
+  procedure OnAfterEnemyAttack; virtual;
+  procedure OnAfterEnemyCapture; virtual;
+
+protected
+  me: integer; // index of the controlled nation
+  RO: ^TPlayerContext;
+  Map: ^TTileList;
+  MyUnit: ^TUnList;
+  MyCity: ^TCityList;
+  MyModel: ^TModelList;
+
+  cixStateImp: array[imPalace..imSpacePort] of integer;
+
+  // negotiation
+  Opponent: integer; // nation i'm in negotiation with, -1 indicates no-negotiation mode
+  MyAction, MyLastAction, OppoAction: integer;
+  MyOffer, MyLastOffer, OppoOffer: TOffer;
+
+  // overridables
+  procedure DoTurn; virtual;
+  procedure DoNegotiation; virtual;
+  function ChooseResearchAdvance: integer; virtual;
+  function ChooseStealAdvance: integer; virtual;
+  function ChooseGovernment: integer; virtual;
+  function WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean; virtual;
+  function OnNegoRejected_CancelTreaty: boolean; virtual;
+
+  // general functions
+  function IsResearched(Advance: integer): boolean;
+  function ResearchCost: integer;
+  function ChangeAttitude(Nation, Attitude: integer): integer;
+  function Revolution: integer;
+  function ChangeRates(Tax,Lux: integer): integer;
+  function PrepareNewModel(Domain: integer): integer;
+  function SetNewModelFeature(F, Count: integer): integer;
+  function AdvanceResearchable(Advance: integer): boolean;
+  function AdvanceStealable(Advance: integer): boolean;
+  function GetJobProgress(Loc: integer; var JobProgress: TJobProgressData): boolean;
+  function DebugMessage(Level: integer; Text: string): boolean;
+  function SetDebugMap(var DebugMap): boolean;
+
+  // unit functions
+  procedure Unit_FindMyDefender(Loc: integer; var uix: integer);
+  procedure Unit_FindEnemyDefender(Loc: integer; var euix: integer);
+  function Unit_Move(uix,ToLoc: integer): integer;
+  function Unit_Step(uix,ToLoc: integer): integer;
+  function Unit_Attack(uix,ToLoc: integer): integer;
+  function Unit_DoMission(uix,MissionType,ToLoc: integer): integer;
+  function Unit_MoveForecast(uix,ToLoc: integer; var RemainingMovement: integer): boolean;
+  function Unit_AttackForecast(uix,ToLoc,AttackMovement: integer; var RemainingHealth: integer): boolean;
+  function Unit_DefenseForecast(euix,ToLoc: integer; var RemainingHealth: integer): boolean;
+  function Unit_Disband(uix: integer): integer;
+  function Unit_StartJob(uix,NewJob: integer): integer;
+  function Unit_SetHomeHere(uix: integer): integer;
+  function Unit_Load(uix: integer): integer;
+  function Unit_Unload(uix: integer): integer;
+  function Unit_SelectTransport(uix: integer): integer;
+  function Unit_AddToCity(uix: integer): integer;
+
+  // city functions
+  procedure City_FindMyCity(Loc: integer; var cix: integer);
+  procedure City_FindEnemyCity(Loc: integer; var ecix: integer);
+  function City_HasProject(cix: integer): boolean;
+  function City_CurrentImprovementProject(cix: integer): integer;
+  function City_CurrentUnitProject(cix: integer): integer;
+  function City_GetTileInfo(cix,TileLoc: integer; var TileInfo: TTileInfo): integer;
+  function City_GetReport(cix: integer; var Report: TCityReport): integer;
+  function City_GetHypoReport(cix, HypoTiles, HypoTax, HypoLux: integer; var Report: TCityReport): integer;
+  function City_GetReportNew(cix: integer; var Report: TCityReportNew): integer;
+  function City_GetHypoReportNew(cix, HypoTiles, HypoTaxRate, HypoLuxuryRate: integer; var Report: TCityReportNew): integer;
+  function City_GetAreaInfo(cix: integer; var AreaInfo: TCityAreaInfo): integer;
+  function City_StartUnitProduction(cix,mix: integer): integer;
+  function City_StartEmigration(cix,mix: integer; AllowDisbandCity, AsConscripts: boolean): integer;
+  function City_StartImprovement(cix,iix: integer): integer;
+  function City_Improvable(cix,iix: integer): boolean;
+  function City_StopProduction(cix: integer): integer;
+  function City_BuyProject(cix: integer): integer;
+  function City_SellImprovement(cix,iix: integer): integer;
+  function City_RebuildImprovement(cix,iix: integer): integer;
+  function City_SetTiles(cix,NewTiles: integer): integer;
+  procedure City_OptimizeTiles(cix: integer; ResourceWeights: cardinal = rwMaxGrowth);
+
+  // negotiation
+  function Nego_CheckMyAction: integer;
+
+private
+  HaveTurned: boolean;
+  UnwantedNego: set of 0..nPl-1;
+  Contacted: set of 0..nPl-1;
+  procedure StealAdvance;
   end;
 
-var
-  Server: TServerCall;
-  G: TNewGameData;
-  RWDataSize, MapSize: integer;
-  decompose24: cardinal;
-  nodata: pointer;
+
+var
+Server: TServerCall;
+G: TNewGameData;
+RWDataSize, MapSize: integer;
+decompose24: cardinal;
+nodata: pointer;
 
 const
-  CityOwnTile = 13; // = ab_to_V21(0,0)
-
-  // additional return codes
-  rLocationReached = $00010000;
-  // Unit_Move: move was not interrupted, location reached
-  rMoreTurns = $00020000;
-  // Unit_Move: move was not interrupted, location not reached yet
+CityOwnTile = 13; // = ab_to_V21(0,0)
+
+// additional return codes
+rLocationReached=       $00010000; // Unit_Move: move was not interrupted, location reached
+rMoreTurns=             $00020000; // Unit_Move: move was not interrupted, location not reached yet
 
 type
-  TVicinity8Loc = array [0 .. 7] of integer;
-  TVicinity21Loc = array [0 .. 27] of integer;
+TVicinity8Loc=array[0..7] of integer;
+TVicinity21Loc=array[0..27] of integer;
+
 
 procedure Init(NewGameData: TNewGameData);
 
-procedure ab_to_Loc(Loc0, a, b: integer; var Loc: integer);
-procedure Loc_to_ab(Loc0, Loc: integer; var a, b: integer);
-procedure ab_to_V8(a, b: integer; var V8: integer);
-procedure V8_to_ab(V8: integer; var a, b: integer);
-procedure ab_to_V21(a, b: integer; var V21: integer);
-procedure V21_to_ab(V21: integer; var a, b: integer);
+procedure ab_to_Loc(Loc0,a,b: integer; var Loc: integer);
+procedure Loc_to_ab(Loc0,Loc: integer; var a,b: integer);
+procedure ab_to_V8(a,b: integer; var V8: integer);
+procedure V8_to_ab(V8: integer; var a,b: integer);
+procedure ab_to_V21(a,b: integer; var V21: integer);
+procedure V21_to_ab(V21: integer; var a,b: integer);
 procedure V8_to_Loc(Loc0: integer; var VicinityLoc: TVicinity8Loc);
 procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
+function Distance(Loc0,Loc1: integer): integer;
+
 
 implementation
 
 const
-  ab_v8: array [-4 .. 4] of integer = (5, 6, 7, 4, -1, 0, 3, 2, 1);
-  v8_a: array [0 .. 7] of integer = (1, 1, 0, -1, -1, -1, 0, 1);
-  v8_b: array [0 .. 7] of integer = (0, 1, 1, 1, 0, -1, -1, -1);
-
-procedure ab_to_Loc(Loc0, a, b: integer; var Loc: integer);
-{ relative location from Loc0 }
-var
-  y0: integer;
-begin
-  assert((Loc0 >= 0) and (Loc0 < MapSize) and (a - b + G.lx >= 0));
-  y0 := cardinal(Loc0) * decompose24 shr 24;
-  Loc := (Loc0 + (a - b + y0 and 1 + G.lx + G.lx) shr 1) mod G.lx + G.lx *
-    (y0 + a + b);
-  if Loc >= MapSize then
-    Loc := -$1000
-end;
-
-procedure Loc_to_ab(Loc0, Loc: integer; var a, b: integer);
+ab_v8: array[-4..4] of integer = (5,6,7,4,-1,0,3,2,1);
+v8_a: array[0..7] of integer = (1,1,0,-1,-1,-1,0,1);
+v8_b: array[0..7] of integer = (0,1,1,1,0,-1,-1,-1);
+
+
+procedure ab_to_Loc(Loc0,a,b: integer; var Loc: integer);
+{relative location from Loc0}
+var
+y0: integer;
+begin
+assert((Loc0>=0) and (Loc0<MapSize) and (a-b+G.lx>=0));
+y0:=cardinal(Loc0)*decompose24 shr 24;
+Loc:=(Loc0+(a-b+y0 and 1+G.lx+G.lx) shr 1) mod G.lx +G.lx*(y0+a+b);
+if Loc>=MapSize then Loc:=-$1000
+end;
+
+procedure Loc_to_ab(Loc0,Loc: integer; var a,b: integer);
 {$IFDEF FPC} // freepascal
 var
-  dx, dy: integer;
-begin
-  dx := ((Loc mod G.lx * 2 + Loc div G.lx and 1) -
-    (Loc0 mod G.lx * 2 + Loc0 div G.lx and 1) + 3 * G.lx) mod (2 * G.lx) - G.lx;
-  dy := Loc div G.lx - Loc0 div G.lx;
-  a := (dx + dy) div 2;
-  b := (dy - dx) div 2;
+dx,dy: integer;
+begin
+dx:=((Loc mod G.lx *2 +Loc div G.lx and 1)
+  -(Loc0 mod G.lx *2 +Loc0 div G.lx and 1)+3*G.lx) mod (2*G.lx) -G.lx;
+dy:=Loc div G.lx-Loc0 div G.lx;
+a:=(dx+dy) div 2;
+b:=(dy-dx) div 2;
 end;
 {$ELSE} // delphi
 register;
 asm
-  push ebx
-
-  // calculate
-  push ecx
-  div byte ptr [G]
-  xor ebx,ebx
-  mov bl,ah  // ebx:=Loc0 mod G.lx
-  mov ecx,eax
-  and ecx,$000000FF // ecx:=Loc0 div G.lx
-  mov eax,edx
-  div byte ptr [G]
-  xor edx,edx
-  mov dl,ah // edx:=Loc mod G.lx
-  and eax,$000000FF // eax:=Loc div G.lx
-  sub edx,ebx // edx:=Loc mod G.lx-Loc0 mod G.lx
-  mov ebx,eax
-  sub ebx,ecx // ebx:=dy
-  and eax,1
-  and ecx,1
-  add edx,edx
-  add eax,edx
-  sub eax,ecx // eax:=dx, not normalized
-  pop ecx
-
-  // normalize
-  mov edx,dword ptr [G]
-  cmp eax,edx
-  jl @a
+push ebx
+
+// calculate
+push ecx
+div byte ptr [G]
+xor ebx,ebx
+mov bl,ah  // ebx:=Loc0 mod G.lx
+mov ecx,eax
+and ecx,$000000FF // ecx:=Loc0 div G.lx
+mov eax,edx
+div byte ptr [G]
+xor edx,edx
+mov dl,ah // edx:=Loc mod G.lx
+and eax,$000000FF // eax:=Loc div G.lx
+sub edx,ebx // edx:=Loc mod G.lx-Loc0 mod G.lx
+mov ebx,eax
+sub ebx,ecx // ebx:=dy
+and eax,1
+and ecx,1
+add edx,edx
+add eax,edx
+sub eax,ecx // eax:=dx, not normalized
+pop ecx
+
+// normalize
+mov edx,dword ptr [G]
+cmp eax,edx
+jl @a
   sub eax,edx
   sub eax,edx
   jmp @ok
 @a:
-  neg edx
-  cmp eax,edx
-  jnl @ok
+neg edx
+cmp eax,edx
+jnl @ok
   sub eax,edx
   sub eax,edx
 
-  // return results
+// return results
 @ok:
-  mov edx,ebx
-  sub edx,eax
-  add eax,ebx
-  sar edx,1 // edx:=b
-  mov ebx,[b]
-  mov [ebx],edx
-  sar eax,1 // eax:=a
-  mov [a],eax
-
-  pop ebx
+mov edx,ebx
+sub edx,eax
+add eax,ebx
+sar edx,1 // edx:=b
+mov ebx,[b]
+mov [ebx],edx
+sar eax,1 // eax:=a
+mov [a],eax
+
+pop ebx
 end;
 {$ENDIF}
 
-procedure ab_to_V8(a, b: integer; var V8: integer);
-begin
-  assert((abs(a) <= 1) and (abs(b) <= 1) and ((a <> 0) or (b <> 0)));
-  V8 := ab_v8[2 * b + b + a];
-end;
-
-procedure V8_to_ab(V8: integer; var a, b: integer);
-begin
-  a := v8_a[V8];
-  b := v8_b[V8];
-end;
-
-procedure ab_to_V21(a, b: integer; var V21: integer);
-begin
-  V21 := (a + b + 3) shl 2 + (a - b + 3) shr 1;
-end;
-
-procedure V21_to_ab(V21: integer; var a, b: integer);
-var
-  dx, dy: integer;
-begin
-  dy := V21 shr 2 - 3;
-  dx := V21 and 3 shl 1 - 3 + (dy + 3) and 1;
-  a := (dx + dy) div 2;
-  b := (dy - dx) div 2;
+procedure ab_to_V8(a,b: integer; var V8: integer);
+begin
+assert((abs(a)<=1) and (abs(b)<=1) and ((a<>0) or (b<>0)));
+V8:=ab_v8[2*b+b+a];
+end;
+
+procedure V8_to_ab(V8: integer; var a,b: integer);
+begin
+a:=v8_a[V8]; b:=V8_b[V8];
+end;
+
+procedure ab_to_V21(a,b: integer; var V21: integer);
+begin
+V21:=(a+b+3) shl 2+(a-b+3) shr 1;
+end;
+
+procedure V21_to_ab(V21: integer; var a,b: integer);
+var
+dx,dy: integer;
+begin
+dy:=V21 shr 2-3;
+dx:=V21 and 3 shl 1 -3 + (dy+3) and 1;
+a:=(dx+dy) div 2;
+b:=(dy-dx) div 2;
 end;
 
 procedure V8_to_Loc(Loc0: integer; var VicinityLoc: TVicinity8Loc);
 var
-  x0, y0, lx: integer;
-begin
-  lx := G.lx;
-  y0 := cardinal(Loc0) * decompose24 shr 24;
-  x0 := Loc0 - y0 * lx; // Loc0 mod lx;
-  VicinityLoc[1] := Loc0 + lx * 2;
-  VicinityLoc[3] := Loc0 - 1;
-  VicinityLoc[5] := Loc0 - lx * 2;
-  VicinityLoc[7] := Loc0 + 1;
-  inc(Loc0, y0 and 1);
-  VicinityLoc[0] := Loc0 + lx;
-  VicinityLoc[2] := Loc0 + lx - 1;
-  VicinityLoc[4] := Loc0 - lx - 1;
-  VicinityLoc[6] := Loc0 - lx;
-
-  // world is round!
-  if x0 < lx - 1 then
+x0,y0,lx: integer;
+begin
+lx:=G.lx;
+y0:=cardinal(Loc0)*decompose24 shr 24;
+x0:=Loc0-y0*lx; // Loc0 mod lx;
+VicinityLoc[1]:=Loc0+lx*2;
+VicinityLoc[3]:=Loc0-1;
+VicinityLoc[5]:=Loc0-lx*2;
+VicinityLoc[7]:=Loc0+1;
+inc(Loc0,y0 and 1);
+VicinityLoc[0]:=Loc0+lx;
+VicinityLoc[2]:=Loc0+lx-1;
+VicinityLoc[4]:=Loc0-lx-1;
+VicinityLoc[6]:=Loc0-lx;
+
+// world is round!
+if x0<lx-1 then
   begin
-    if x0 = 0 then
+  if x0=0 then
     begin
-      inc(VicinityLoc[3], lx);
-      if y0 and 1 = 0 then
+    inc(VicinityLoc[3],lx);
+    if y0 and 1=0 then
       begin
-        inc(VicinityLoc[2], lx);
-        inc(VicinityLoc[4], lx);
+      inc(VicinityLoc[2],lx);
+      inc(VicinityLoc[4],lx);
       end
     end
   end
-  else
+else
   begin
-    dec(VicinityLoc[7], lx);
-    if y0 and 1 = 1 then
+  dec(VicinityLoc[7],lx);
+  if y0 and 1=1 then
     begin
-      dec(VicinityLoc[0], lx);
-      dec(VicinityLoc[6], lx);
+    dec(VicinityLoc[0],lx);
+    dec(VicinityLoc[6],lx);
     end
   end;
 
-  // check south pole
-  case G.ly - y0 of
-    1:
+// check south pole
+case G.ly-y0 of
+  1:
+    begin
+    VicinityLoc[0]:=-$1000;
+    VicinityLoc[1]:=-$1000;
+    VicinityLoc[2]:=-$1000;
+    end;
+  2: VicinityLoc[1]:=-$1000;
+  end
+end;
+
+procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
+var
+dx,dy,bit,y0,xComp,yComp,xComp0,xCompSwitch: integer;
+dst: ^integer;
+begin
+y0:=cardinal(Loc0)*decompose24 shr 24;
+xComp0:=Loc0-y0*G.lx-1; // Loc0 mod G.lx -1
+xCompSwitch:=xComp0-1+y0 and 1;
+if xComp0<0 then inc(xComp0,G.lx);
+if xCompSwitch<0 then inc(xCompSwitch,G.lx);
+xCompSwitch:=xCompSwitch xor xComp0;
+yComp:=G.lx*(y0-3);
+dst:=@VicinityLoc;
+bit:=1;
+for dy:=0 to 6 do
+  if yComp<MapSize then
+    begin
+    xComp0:=xComp0 xor xCompSwitch;
+    xComp:=xComp0;
+    for dx:=0 to 3 do
       begin
-        VicinityLoc[0] := -$1000;
-        VicinityLoc[1] := -$1000;
-        VicinityLoc[2] := -$1000;
+      if bit and $67F7F76<>0 then dst^:=xComp+yComp
+      else dst^:=-1;
+      inc(xComp);
+      if xComp>=G.lx then dec(xComp, G.lx);
+      inc(dst);
+      bit:=bit shl 1;
       end;
-    2:
-      VicinityLoc[1] := -$1000;
-  end
-end;
-
-procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
-var
-  dx, dy, bit, y0, xComp, yComp, xComp0, xCompSwitch: integer;
-  dst: ^integer;
-begin
-  y0 := cardinal(Loc0) * decompose24 shr 24;
-  xComp0 := Loc0 - y0 * G.lx - 1; // Loc0 mod G.lx -1
-  xCompSwitch := xComp0 - 1 + y0 and 1;
-  if xComp0 < 0 then
-    inc(xComp0, G.lx);
-  if xCompSwitch < 0 then
-    inc(xCompSwitch, G.lx);
-  xCompSwitch := xCompSwitch xor xComp0;
-  yComp := G.lx * (y0 - 3);
-  dst := @VicinityLoc;
-  bit := 1;
-  for dy := 0 to 6 do
-    if yComp < MapSize then
+    inc(yComp,G.lx);
+    end
+  else
     begin
-      xComp0 := xComp0 xor xCompSwitch;
-      xComp := xComp0;
-      for dx := 0 to 3 do
+    for dx:=0 to 3 do
+      begin dst^:=-$1000; inc(dst); end;
+    end
+end;
+
+function Distance(Loc0,Loc1: integer): integer;
+var
+a,b,dx,dy: integer;
+begin
+Loc_to_ab(Loc0,Loc1,a,b);
+dx:=abs(a-b);
+dy:=abs(a+b);
+result:=dx+dy+abs(dx-dy) shr 1;
+end;
+
+
+procedure Init(NewGameData: TNewGameData);
+{$IFDEF DEBUG}var Loc: integer;{$ENDIF}
+begin
+G:=NewGameData;
+MapSize:=G.lx*G.ly;
+decompose24:=(1 shl 24-1) div G.lx +1;
+{$IFDEF DEBUG}for Loc:=0 to MapSize-1 do assert(cardinal(Loc)*decompose24 shr 24=cardinal(Loc div G.lx));{$ENDIF}
+end;
+
+
+constructor TCustomAI.Create(Nation: integer);
+begin
+inherited Create;
+me:=Nation;
+RO:=pointer(G.RO[Nation]);
+Map:=pointer(RO.Map);
+MyUnit:=pointer(RO.Un);
+MyCity:=pointer(RO.City);
+MyModel:=pointer(RO.Model);
+Opponent:=-1;
+end;
+
+destructor TCustomAI.Destroy;
+begin
+Server(sSetDebugMap,me,0,nodata^);
+end;
+
+
+procedure TCustomAI.Process(Command: integer; var Data);
+var
+Nation,NewResearch,NewGov,count,ad,cix,iix: integer;
+NegoTime: TNegoTime;
+begin
+case Command of
+  cTurn, cContinue:
+    begin
+    if RO.Alive and (1 shl me)=0 then
+      begin // I'm dead, huhu
+      Server(sTurn,me,0,nodata^);
+      exit
+      end;
+    if Command=cTurn then
       begin
-        if bit and $67F7F76 <> 0 then
-          dst^ := xComp + yComp
-        else
-          dst^ := -1;
-        inc(xComp);
-        if xComp >= G.lx then
-          dec(xComp, G.lx);
-        inc(dst);
-        bit := bit shl 1;
+      fillchar(cixStateImp, sizeof(cixStateImp), $FF);
+      for cix:=0 to RO.nCity-1 do if MyCity[cix].Loc>=0 then
+        for iix:=imPalace to imSpacePort do
+          if MyCity[cix].Built[iix]>0 then
+            cixStateImp[iix]:=cix;
+      if RO.Happened and phChangeGov<>0 then
+        begin
+        NewGov:=ChooseGovernment;
+        if NewGov>gAnarchy then
+          Server(sSetGovernment,me,NewGov,nodata^);
+        end;
+      HaveTurned:=false;
+      Contacted:=[];
       end;
-      inc(yComp, G.lx);
-    end
+    if (Command=cContinue) and (MyAction=scContact) then
+      begin
+      if OnNegoRejected_CancelTreaty then
+        if RO.Treaty[Opponent]>=trPeace then
+          if Server(sCancelTreaty,me,0,nodata^)<rExecuted then
+            assert(false)
+      end
+    else UnwantedNego:=[];
+    Opponent:=-1;
+    repeat
+      if HaveTurned then NegoTime:=EndOfTurn
+      else NegoTime:=BeginOfTurn;
+      if RO.Government<>gAnarchy then
+        for Nation:=0 to nPl-1 do
+           if (Nation<>me) and (1 shl Nation and RO.Alive<>0)
+             and (RO.Treaty[Nation]>=trNone)
+             and not (Nation in Contacted) and not (Nation in UnwantedNego)
+             and (Server(scContact-sExecute + Nation shl 4, me, 0, nodata^)>=rExecuted) then
+             if WantNegotiation(Nation, NegoTime) then
+               begin
+               if Server(scContact + Nation shl 4, me, 0, nodata^)>=rExecuted then
+                 begin
+                 include(Contacted, Nation);
+                 Opponent:=Nation;
+                 MyAction:=scContact;
+                 exit;
+                 end;
+               end
+             else include(UnwantedNego,Nation);
+      if NegoTime=BeginOfTurn then
+        begin
+        DoTurn;
+        HaveTurned:=true;
+        Contacted:=[];
+        UnwantedNego:=[];
+        end
+      else break;
+    until false;
+    if RO.Happened and phTech<>0 then
+      begin
+      NewResearch:=ChooseResearchAdvance;
+      if NewResearch<0 then
+        begin // choose random research
+        count:=0;
+        for ad:=0 to nAdv-1 do if AdvanceResearchable(ad) then
+          begin inc(count); if random(count)=0 then NewResearch:=ad end
+        end;
+      Server(sSetResearch,me,NewResearch,nodata^)
+      end;
+    if Server(sTurn,me,0,nodata^)<rExecuted then
+      assert(false);
+    end;
+  scContact:
+    if WantNegotiation(integer(Data), EnemyCalled) then
+      begin
+      if Server(scDipStart, me, 0, nodata^)<rExecuted then
+        assert(false);
+      Opponent:=integer(Data);
+      MyAction:=scDipStart;
+      end
     else
+      begin
+      if Server(scReject, me, 0, nodata^)<rExecuted then
+        assert(false);
+      end;
+  scDipStart, scDipNotice, scDipAccept, scDipCancelTreaty, scDipOffer, scDipBreak:
     begin
-      for dx := 0 to 3 do
+    OppoAction:=Command;
+    if Command=scDipOffer then OppoOffer:=TOffer(Data);
+    if Command=scDipStart then
+      MyLastAction:=scContact
+    else
       begin
-        dst^ := -$1000;
-        inc(dst);
+      MyLastAction:=MyAction;
+      MyLastOffer:=MyOffer;
       end;
-    end
-end;
-
-procedure Init(NewGameData: TNewGameData);
-{$IFDEF DEBUG}var
-  Loc: integer; {$ENDIF}
-begin
-  G := NewGameData;
-  MapSize := G.lx * G.ly;
-  decompose24 := (1 shl 24 - 1) div G.lx + 1;
-{$IFDEF DEBUG} for Loc := 0 to MapSize - 1 do
-    assert(cardinal(Loc) * decompose24 shr 24 = cardinal(Loc div G.lx));
-  {$ENDIF}
-end;
-
-constructor TCustomAI.Create(Nation: integer);
-begin
-  inherited Create;
-  me := Nation;
-  RO := pointer(G.RO[Nation]);
-  Map := pointer(RO.Map);
-  MyUnit := pointer(RO.Un);
-  MyCity := pointer(RO.City);
-  MyModel := pointer(RO.Model);
-  Opponent := -1;
-end;
-
-destructor TCustomAI.Destroy;
-begin
-  Server(sSetDebugMap, me, 0, nodata^);
-end;
-
-procedure TCustomAI.Process(Command: integer; var Data);
-var
-  Nation, NewResearch, NewGov, Count, ad, cix, iix: integer;
-  NegoTime: TNegoTime;
-begin
-  case Command of
-    cTurn, cContinue:
-      begin
-        if RO.Alive and (1 shl me) = 0 then
-        begin // I'm dead, huhu
-          Server(sTurn, me, 0, nodata^);
-          exit
-        end;
-        if Command = cTurn then
-        begin
-          fillchar(cixStateImp, sizeof(cixStateImp), $FF);
-          for cix := 0 to RO.nCity - 1 do
-            if MyCity[cix].Loc >= 0 then
-              for iix := imPalace to imSpacePort do
-                if MyCity[cix].Built[iix] > 0 then
-                  cixStateImp[iix] := cix;
-          if RO.Happened and phChangeGov <> 0 then
-          begin
-            NewGov := ChooseGovernment;
-            if NewGov > gAnarchy then
-              Server(sSetGovernment, me, NewGov, nodata^);
-          end;
-          HaveTurned := false;
-          Contacted := [];
-        end;
-        if (Command = cContinue) and (MyAction = scContact) then
-        begin
-          if OnNegoRejected_CancelTreaty then
-            if RO.Treaty[Opponent] >= trPeace then
-              if Server(sCancelTreaty, me, 0, nodata^) < rExecuted then
-                assert(false)
-        end
-        else
-          UnwantedNego := [];
-        Opponent := -1;
-        repeat
-          if HaveTurned then
-            NegoTime := EndOfTurn
-          else
-            NegoTime := BeginOfTurn;
-          if RO.Government <> gAnarchy then
-            for Nation := 0 to nPl - 1 do
-              if (Nation <> me) and (1 shl Nation and RO.Alive <> 0) and
-                (RO.Treaty[Nation] >= trNone) and not(Nation in Contacted) and
-                not(Nation in UnwantedNego) and
-                (Server(scContact - sExecute + Nation shl 4, me, 0, nodata^) >=
-                rExecuted) then
-                if WantNegotiation(Nation, NegoTime) then
-                begin
-                  if Server(scContact + Nation shl 4, me, 0, nodata^) >= rExecuted
-                  then
-                  begin
-                    include(Contacted, Nation);
-                    Opponent := Nation;
-                    MyAction := scContact;
-                    exit;
-                  end;
-                end
-                else
-                  include(UnwantedNego, Nation);
-          if NegoTime = BeginOfTurn then
-          begin
-            DoTurn;
-            HaveTurned := true;
-            Contacted := [];
-            UnwantedNego := [];
-          end
-          else
-            break;
-        until false;
-        if RO.Happened and phTech <> 0 then
-        begin
-          NewResearch := ChooseResearchAdvance;
-          if NewResearch < 0 then
-          begin // choose random research
-            Count := 0;
-            for ad := 0 to nAdv - 1 do
-              if AdvanceResearchable(ad) then
-              begin
-                inc(Count);
-                if random(Count) = 0 then
-                  NewResearch := ad
-              end
-          end;
-          Server(sSetResearch, me, NewResearch, nodata^)
-        end;
-        if Server(sTurn, me, 0, nodata^) < rExecuted then
-          assert(false);
-      end;
-    scContact:
-      if WantNegotiation(integer(Data), EnemyCalled) then
-      begin
-        if Server(scDipStart, me, 0, nodata^) < rExecuted then
-          assert(false);
-        Opponent := integer(Data);
-        MyAction := scDipStart;
-      end
-      else
-      begin
-        if Server(scReject, me, 0, nodata^) < rExecuted then
-          assert(false);
-      end;
-    scDipStart, scDipNotice, scDipAccept, scDipCancelTreaty, scDipOffer,
-      scDipBreak:
-      begin
-        OppoAction := Command;
-        if Command = scDipOffer then
-          OppoOffer := TOffer(Data);
-        if Command = scDipStart then
-          MyLastAction := scContact
-        else
-        begin
-          MyLastAction := MyAction;
-          MyLastOffer := MyOffer;
-        end;
-        if (OppoAction = scDipCancelTreaty) or (OppoAction = scDipBreak) then
-          MyAction := scDipNotice
-        else
-        begin
-          MyAction := scDipOffer;
-          MyOffer.nDeliver := 0;
-          MyOffer.nCost := 0;
-        end;
-        DoNegotiation;
-        assert((MyAction = scDipNotice) or (MyAction = scDipAccept) or
-          (MyAction = scDipCancelTreaty) or (MyAction = scDipOffer) or
-          (MyAction = scDipBreak));
-        if MyAction = scDipOffer then
-          Server(MyAction, me, 0, MyOffer)
-        else
-          Server(MyAction, me, 0, nodata^);
-      end;
-    cShowEndContact:
-      Opponent := -1;
+    if (OppoAction=scDipCancelTreaty) or (OppoAction=scDipBreak) then
+      MyAction:=scDipNotice
+    else begin MyAction:=scDipOffer; MyOffer.nDeliver:=0; MyOffer.nCost:=0; end;
+    DoNegotiation;
+    assert((MyAction=scDipNotice) or (MyAction=scDipAccept)
+      or (MyAction=scDipCancelTreaty) or (MyAction=scDipOffer)
+      or (MyAction=scDipBreak));
+    if MyAction=scDipOffer then Server(MyAction, me, 0, MyOffer)
+    else Server(MyAction, me, 0, nodata^);
+    end;
+  cShowEndContact:
+    Opponent:=-1;
   end;
 end;
 
 {$HINTS OFF}
-
 procedure TCustomAI.SetDataDefaults;
 begin
@@ -561 +525 @@
 end;
 
-procedure TCustomAI.OnBeforeEnemyAttack(UnitInfo: TUnitInfo;
-  ToLoc, EndHealth, EndHealthDef: integer);
+procedure TCustomAI.OnBeforeEnemyAttack(UnitInfo: TUnitInfo; ToLoc, EndHealth,
+  EndHealthDef: integer);
 begin
 end;
@@ -580 +544 @@
 function TCustomAI.ChooseResearchAdvance: integer;
 begin
-  result := -1
+result:=-1
 end;
 
 function TCustomAI.ChooseStealAdvance: integer;
 begin
-  result := -1
+result:=-1
 end;
 
 function TCustomAI.ChooseGovernment: integer;
 begin
-  result := gDespotism
-end;
-
-function TCustomAI.WantNegotiation(Nation: integer;
-  NegoTime: TNegoTime): boolean;
-begin
-  result := false;
+result:=gDespotism
+end;
+
+function TCustomAI.WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
+begin
+result:=false;
 end;
 
 function TCustomAI.OnNegoRejected_CancelTreaty: boolean;
 begin
-  result := false;
+result:=false;
 end;
 {$HINTS ON}
@@ -607 +570 @@
 procedure TCustomAI.StealAdvance;
 var
-  Steal, ad, Count: integer;
-begin
-  Steal := ChooseStealAdvance;
-  if Steal < 0 then
+Steal, ad, count: integer;
+begin
+Steal:=ChooseStealAdvance;
+if Steal<0 then
   begin // choose random advance
-    Count := 0;
-    for ad := 0 to nAdv - 1 do
-      if AdvanceStealable(ad) then
-      begin
-        inc(Count);
-        if random(Count) = 0 then
-          Steal := ad
-      end
+  count:=0;
+  for ad:=0 to nAdv-1 do if AdvanceStealable(ad) then
+    begin inc(count); if random(count)=0 then Steal:=ad end
   end;
-  if Steal >= 0 then
-    Server(sStealTech, me, Steal, nodata^);
-  RO.Happened := RO.Happened and not phStealTech
+if Steal>=0 then Server(sStealTech,me,Steal,nodata^);
+RO.Happened:=RO.Happened and not phStealTech
 end;
 
 function TCustomAI.IsResearched(Advance: integer): boolean;
 begin
-  result := RO.Tech[Advance] >= tsApplicable
+result:= (Advance=preNone)
+  or (Advance<>preNA) and (RO.Tech[Advance]>=tsApplicable)
 end;
 
 function TCustomAI.ResearchCost: integer;
 begin
-  Server(sGetTechCost, me, 0, result)
+Server(sGetTechCost,me,0,result)
 end;
 
 function TCustomAI.ChangeAttitude(Nation, Attitude: integer): integer;
 begin
-  result := Server(sSetAttitude + Nation shl 4, me, Attitude, nodata^)
+result:=Server(sSetAttitude+Nation shl 4,me,Attitude,nodata^)
 end;
 
 function TCustomAI.Revolution: integer;
 begin
-  result := Server(sRevolution, me, 0, nodata^);
-end;
-
-function TCustomAI.ChangeRates(Tax, Lux: integer): integer;
-begin
-  result := Server(sSetRates, me, Tax div 10 and $F + Lux div 10 and
-    $F shl 4, nodata^)
+result:=Server(sRevolution,me,0,nodata^);
+end;
+
+function TCustomAI.ChangeRates(Tax,Lux: integer): integer;
+begin
+result:=Server(sSetRates,me,Tax div 10 and $f+Lux div 10 and $f shl 4,nodata^)
 end;
 
 function TCustomAI.PrepareNewModel(Domain: integer): integer;
 begin
-  result := Server(sCreateDevModel, me, Domain, nodata^);
+result:=Server(sCreateDevModel,me,Domain,nodata^);
 end;
 
 function TCustomAI.SetNewModelFeature(F, Count: integer): integer;
 begin
-  result := Server(sSetDevModelCap + Count shl 4, me, F, nodata^)
+result:=Server(sSetDevModelCap+Count shl 4,me,F,nodata^)
 end;
 
 function TCustomAI.AdvanceResearchable(Advance: integer): boolean;
 begin
-  result := Server(sSetResearch - sExecute, me, Advance, nodata^) >= rExecuted;
+result:= Server(sSetResearch-sExecute,me,Advance,nodata^)>=rExecuted;
 end;
 
 function TCustomAI.AdvanceStealable(Advance: integer): boolean;
 begin
-  result := Server(sStealTech - sExecute, me, Advance, nodata^) >= rExecuted;
-end;
-
-function TCustomAI.GetJobProgress(Loc: integer;
-  var JobProgress: TJobProgressData): boolean;
-begin
-  result := Server(sGetJobProgress, me, Loc, JobProgress) >= rExecuted;
+result:= Server(sStealTech-sExecute,me,Advance,nodata^)>=rExecuted;
+end;
+
+function TCustomAI.GetJobProgress(Loc: integer; var JobProgress: TJobProgressData): boolean;
+begin
+result:= Server(sGetJobProgress,me,Loc,JobProgress)>=rExecuted;
 end;
 
 function TCustomAI.DebugMessage(Level: integer; Text: string): boolean;
 begin
-  Text := copy('P' + char(48 + me) + ' ' + Text, 1, 254);
-  Server(sMessage, me, Level, pchar(Text)^);
-
-  result := true;
+Text:=copy('P'+char(48+me)+' '+Text,1,254);
+Server(sMessage,me,Level,pchar(Text)^);
+
+result:=true;
   // always returns true so that it can be used like
   // "assert(DebugMessage(...));" -> not compiled in release build
@@ -690 +646 @@
 function TCustomAI.SetDebugMap(var DebugMap): boolean;
 begin
-  Server(sSetDebugMap, me, 0, DebugMap);
-
-  result := true;
+Server(sSetDebugMap, me, 0, DebugMap);
+
+result:=true;
   // always returns true so that it can be used like
   // "assert(SetDebugMap(...));" -> not compiled in release build
@@ -699 +655 @@
 procedure TCustomAI.Unit_FindMyDefender(Loc: integer; var uix: integer);
 begin
-  if Server(sGetDefender, me, Loc, uix) < rExecuted then
-    uix := -1
+if Server(sGetDefender,me,Loc,uix)<rExecuted then uix:=-1
 end;
 
 procedure TCustomAI.Unit_FindEnemyDefender(Loc: integer; var euix: integer);
 begin
-  euix := RO.nEnemyUn - 1;
-  while (euix >= 0) and (RO.EnemyUn[euix].Loc <> Loc) do
-    dec(euix);
-end;
-
-function TCustomAI.Unit_Move(uix, ToLoc: integer): integer;
-var
-  Step: integer;
-  DestinationReached: boolean;
-  Advice: TMoveAdviceData;
-begin
-  assert((uix >= 0) and (uix < RO.nUn) and (MyUnit[uix].Loc >= 0)); // is a unit
-  { Loc_to_ab(MyUnit[uix].Loc,ToLoc,a,b);
-    assert((a<>0) or (b<>0));
-    if (a>=-1) and (a<=1) and (b>=-1) and (b<=1) then
-    begin // move to adjacent tile
-    !!!problem: if move is invalid, return codes are not consistent with other branch (eNoWay)
-    Advice.nStep:=1;
-    Advice.dx[0]:=a-b;
-    Advice.dy[0]:=a+b;
-    Advice.MoreTurns:=0;
-    Advice.MaxHostile_MovementLeft:=MyUnit[uix].Movement;
-    result:=eOK;
+euix:=RO.nEnemyUn-1;
+while (euix>=0) and (RO.EnemyUn[euix].Loc<>Loc) do
+  dec(euix);
+end;
+
+function TCustomAI.Unit_Move(uix,ToLoc: integer): integer;
+var
+Step: integer;
+DestinationReached: boolean;
+Advice: TMoveAdviceData;
+begin
+assert((uix>=0) and (uix<RO.nUn) and (MyUnit[uix].Loc>=0)); // is a unit
+{Loc_to_ab(MyUnit[uix].Loc,ToLoc,a,b);
+assert((a<>0) or (b<>0));
+if (a>=-1) and (a<=1) and (b>=-1) and (b<=1) then
+  begin // move to adjacent tile
+  !!!problem: if move is invalid, return codes are not consistent with other branch (eNoWay)
+  Advice.nStep:=1;
+  Advice.dx[0]:=a-b;
+  Advice.dy[0]:=a+b;
+  Advice.MoreTurns:=0;
+  Advice.MaxHostile_MovementLeft:=MyUnit[uix].Movement;
+  result:=eOK;
+  end
+else}
+  begin // move to non-adjacent tile, find shortest path
+  Advice.ToLoc:=ToLoc;
+  Advice.MoreTurns:=9999;
+  Advice.MaxHostile_MovementLeft:=100;
+  result:=Server(sGetMoveAdvice,me,uix,Advice);
+  end;
+if result=eOk then
+  begin
+  DestinationReached:=false;
+  Step:=0;
+  repeat
+    if result and (rExecuted or rUnitRemoved)=rExecuted then // check if destination reached
+      if (ToLoc>=0) and (Advice.MoreTurns=0) and (Step=Advice.nStep-1)
+        and ((Map[ToLoc] and (fUnit or fOwned)=fUnit) // attack
+          or (Map[ToLoc] and (fCity or fOwned)=fCity)
+          and ((MyModel[MyUnit[uix].mix].Domain<>dGround) // bombardment
+            or (MyModel[MyUnit[uix].mix].Flags and mdCivil<>0))) then // can't capture
+        begin DestinationReached:=true; break end // stop next to destination
+      else if Step=Advice.nStep then
+        DestinationReached:=true; // normal move -- stop at destination
+
+    if (Step=Advice.nStep) or (result<>eOK) and (result<>eLoaded) then
+      break;
+
+    result:=Server(sMoveUnit+(Advice.dx[Step] and 7) shl 4 +(Advice.dy[Step] and 7) shl 7,
+      me,uix,nodata^);
+    inc(Step);
+    if RO.Happened and phStealTech<>0 then StealAdvance;
+  until false;
+  if DestinationReached then
+    if Advice.nStep=25 then
+      result:=Unit_Move(uix,ToLoc) // Shinkansen
+    else if Advice.MoreTurns=0 then
+      result:=result or rLocationReached
+    else result:=result or rMoreTurns;
+  end
+end;
+
+function TCustomAI.Unit_Step(uix,ToLoc: integer): integer;
+var
+a,b: integer;
+begin
+Loc_to_ab(MyUnit[uix].Loc, ToLoc, a, b);
+assert(((a<>0) or (b<>0)) and (a>=-1) and (a<=1) and (b>=-1) and (b<=1));
+result:=Server(sMoveUnit+((a-b) and 7) shl 4 +((a+b) and 7) shl 7, me, uix, nodata^);
+if RO.Happened and phStealTech<>0 then StealAdvance;
+end;
+
+function TCustomAI.Unit_Attack(uix,ToLoc: integer): integer;
+var
+a,b: integer;
+begin
+assert((uix>=0) and (uix<RO.nUn) and (MyUnit[uix].Loc>=0) // is a unit
+  and ((Map[ToLoc] and (fUnit or fOwned)=fUnit) // is an attack
+  or (Map[ToLoc] and (fCity or fOwned)=fCity)
+  and (MyModel[MyUnit[uix].mix].Domain<>dGround))); // is a bombardment
+Loc_to_ab(MyUnit[uix].Loc,ToLoc,a,b);
+assert(((a<>0) or (b<>0)) and (a>=-1) and (a<=1) and (b>=-1) and (b<=1)); // attack to adjacent tile
+result:=Server(sMoveUnit+(a-b) and 7 shl 4 +(a+b) and 7 shl 7,me,uix,nodata^);
+end;
+
+function TCustomAI.Unit_DoMission(uix,MissionType,ToLoc: integer): integer;
+var
+a,b: integer;
+begin
+result:=Server(sSetSpyMission + MissionType shl 4,me,0,nodata^);
+if result>=rExecuted then
+  begin
+  assert((uix>=0) and (uix<RO.nUn) and (MyUnit[uix].Loc>=0) // is a unit
+    and (MyModel[MyUnit[uix].mix].Kind=mkDiplomat)); // is a commando
+  Loc_to_ab(MyUnit[uix].Loc,ToLoc,a,b);
+  assert(((a<>0) or (b<>0)) and (a>=-1) and (a<=1) and (b>=-1) and (b<=1)); // city must be adjacent
+  result:=Server(sMoveUnit-sExecute+(a-b) and 7 shl 4 +(a+b) and 7 shl 7,me,uix,nodata^);
+  if result=eMissionDone then
+    result:=Server(sMoveUnit+(a-b) and 7 shl 4 +(a+b) and 7 shl 7,me,uix,nodata^)
+  else if (result<>eNoTime_Move) and (result<>eTreaty) and (result<>eNoTurn) then
+    result:=eInvalid // not a special commando mission!
+  end
+end;
+
+function TCustomAI.Unit_MoveForecast(uix,ToLoc: integer;
+  var RemainingMovement: integer): boolean;
+var
+Advice: TMoveAdviceData;
+begin
+assert((uix>=0) and (uix<RO.nUn) and (MyUnit[uix].Loc>=0)); // is a unit
+Advice.ToLoc:=ToLoc;
+Advice.MoreTurns:=0;
+Advice.MaxHostile_MovementLeft:=100;
+if Server(sGetMoveAdvice,me,uix,Advice)=eOk then
+  begin
+  RemainingMovement:=Advice.MaxHostile_MovementLeft;
+  result:=true
+  end
+else
+  begin
+  RemainingMovement:=-1;
+  result:=false
+  end
+end;
+
+// negative RemainingHealth is remaining helth of defender if lost
+function TCustomAI.Unit_AttackForecast(uix,ToLoc,AttackMovement: integer;
+  var RemainingHealth: integer): boolean;
+var
+BattleForecast: TBattleForecast;
+begin
+assert((uix>=0) and (uix<RO.nUn) and (MyUnit[uix].Loc>=0) // is a unit
+  and (Map[ToLoc] and (fUnit or fOwned)=fUnit)); // is an attack
+RemainingHealth:=-$100;
+result:=false;
+if AttackMovement>=0 then with MyUnit[uix] do
+  begin
+  BattleForecast.pAtt:=me;
+  BattleForecast.mixAtt:=mix;
+  BattleForecast.HealthAtt:=Health;
+  BattleForecast.ExpAtt:=Exp;
+  BattleForecast.FlagsAtt:=Flags;
+  BattleForecast.Movement:=AttackMovement;
+  if Server(sGetBattleForecast,me,ToLoc,BattleForecast)>=rExecuted then
+    begin
+    if BattleForecast.EndHealthAtt>0 then
+      RemainingHealth:=BattleForecast.EndHealthAtt
+    else RemainingHealth:=-BattleForecast.EndHealthDef;
+    result:=true
     end
-    else }
-  begin // move to non-adjacent tile, find shortest path
-    Advice.ToLoc := ToLoc;
-    Advice.MoreTurns := 9999;
-    Advice.MaxHostile_MovementLeft := 100;
-    result := Server(sGetMoveAdvice, me, uix, Advice);
-  end;
-  if result = eOk then
+  end
+end;
+
+function TCustomAI.Unit_DefenseForecast(euix,ToLoc: integer;
+  var RemainingHealth: integer): boolean;
+var
+BattleForecast: TBattleForecast;
+begin
+assert((euix>=0) and (euix<RO.nEnemyUn) and (RO.EnemyUn[euix].Loc>=0) // is an enemy unit
+  and (Map[ToLoc] and (fUnit or fOwned)=(fUnit or fOwned))); // is an attack
+RemainingHealth:=$100;
+result:=false;
+with RO.EnemyUn[euix] do
   begin
-    DestinationReached := false;
-    Step := 0;
-    repeat
-      if result and (rExecuted or rUnitRemoved) = rExecuted then
-      // check if destination reached
-        if (ToLoc >= 0) and (Advice.MoreTurns = 0) and (Step = Advice.nStep - 1)
-          and ((Map[ToLoc] and (fUnit or fOwned) = fUnit) // attack
-          or (Map[ToLoc] and (fCity or fOwned) = fCity) and
-          ((MyModel[MyUnit[uix].mix].Domain <> dGround) // bombardment
-          or (MyModel[MyUnit[uix].mix].Flags and mdCivil <> 0))) then
-        // can't capture
-        begin
-          DestinationReached := true;
-          break
-        end // stop next to destination
-        else if Step = Advice.nStep then
-          DestinationReached := true; // normal move -- stop at destination
-
-      if (Step = Advice.nStep) or (result <> eOk) and (result <> eLoaded) then
-        break;
-
-      result := Server(sMoveUnit + (Advice.dx[Step] and 7) shl 4 +
-        (Advice.dy[Step] and 7) shl 7, me, uix, nodata^);
-      inc(Step);
-      if RO.Happened and phStealTech <> 0 then
-        StealAdvance;
-    until false;
-    if DestinationReached then
-      if Advice.nStep = 25 then
-        result := Unit_Move(uix, ToLoc) // Shinkansen
-      else if Advice.MoreTurns = 0 then
-        result := result or rLocationReached
-      else
-        result := result or rMoreTurns;
-  end
-end;
-
-function TCustomAI.Unit_Step(uix, ToLoc: integer): integer;
-var
-  a, b: integer;
-begin
-  Loc_to_ab(MyUnit[uix].Loc, ToLoc, a, b);
-  assert(((a <> 0) or (b <> 0)) and (a >= -1) and (a <= 1) and (b >= -1) and
-    (b <= 1));
-  result := Server(sMoveUnit + ((a - b) and 7) shl 4 + ((a + b) and 7) shl 7,
-    me, uix, nodata^);
-  if RO.Happened and phStealTech <> 0 then
-    StealAdvance;
-end;
-
-function TCustomAI.Unit_Attack(uix, ToLoc: integer): integer;
-var
-  a, b: integer;
-begin
-  assert((uix >= 0) and (uix < RO.nUn) and (MyUnit[uix].Loc >= 0) // is a unit
-    and ((Map[ToLoc] and (fUnit or fOwned) = fUnit) // is an attack
-    or (Map[ToLoc] and (fCity or fOwned) = fCity) and
-    (MyModel[MyUnit[uix].mix].Domain <> dGround))); // is a bombardment
-  Loc_to_ab(MyUnit[uix].Loc, ToLoc, a, b);
-  assert(((a <> 0) or (b <> 0)) and (a >= -1) and (a <= 1) and (b >= -1) and
-    (b <= 1)); // attack to adjacent tile
-  result := Server(sMoveUnit + (a - b) and 7 shl 4 + (a + b) and 7 shl 7, me,
-    uix, nodata^);
-end;
-
-function TCustomAI.Unit_DoMission(uix, MissionType, ToLoc: integer): integer;
-var
-  a, b: integer;
-begin
-  result := Server(sSetSpyMission + MissionType shl 4, me, 0, nodata^);
-  if result >= rExecuted then
+  BattleForecast.pAtt:=Owner;
+  BattleForecast.mixAtt:=mix;
+  BattleForecast.HealthAtt:=Health;
+  BattleForecast.ExpAtt:=Exp;
+  BattleForecast.FlagsAtt:=Flags;
+  BattleForecast.Movement:=100;
+  if Server(sGetBattleForecast,me,ToLoc,BattleForecast)>=rExecuted then
+    begin
+    if BattleForecast.EndHealthDef>0 then
+      RemainingHealth:=BattleForecast.EndHealthDef
+    else RemainingHealth:=-BattleForecast.EndHealthAtt;
+    result:=true
+    end
+  end
+end;
+
+function TCustomAI.Unit_Disband(uix: integer): integer;
+begin
+result:=Server(sRemoveUnit,me,uix,nodata^)
+end;
+
+function TCustomAI.Unit_StartJob(uix,NewJob: integer): integer;
+begin
+result:=Server(sStartJob+NewJob shl 4,me,uix,nodata^)
+end;
+
+function TCustomAI.Unit_SetHomeHere(uix: integer): integer;
+begin
+result:=Server(sSetUnitHome,me,uix,nodata^)
+end;
+
+function TCustomAI.Unit_Load(uix: integer): integer;
+begin
+result:=Server(sLoadUnit,me,uix,nodata^)
+end;
+
+function TCustomAI.Unit_Unload(uix: integer): integer;
+begin
+result:=Server(sUnloadUnit,me,uix,nodata^)
+end;
+
+function TCustomAI.Unit_AddToCity(uix: integer): integer;
+begin
+result:=Server(sAddToCity,me,uix,nodata^)
+end;
+
+function TCustomAI.Unit_SelectTransport(uix: integer): integer;
+begin
+result:=Server(sSelectTransport,me,uix,nodata^)
+end;
+
+
+procedure TCustomAI.City_FindMyCity(Loc: integer; var cix: integer);
+begin
+if Map[Loc] and (fCity or fOwned)<>fCity or fOwned then
+  cix:=-1
+else
   begin
-    assert((uix >= 0) and (uix < RO.nUn) and (MyUnit[uix].Loc >= 0) // is a unit
-      and (MyModel[MyUnit[uix].mix].Kind = mkDiplomat)); // is a commando
-    Loc_to_ab(MyUnit[uix].Loc, ToLoc, a, b);
-    assert(((a <> 0) or (b <> 0)) and (a >= -1) and (a <= 1) and (b >= -1) and
-      (b <= 1)); // city must be adjacent
-    result := Server(sMoveUnit - sExecute + (a - b) and 7 shl 4 + (a + b) and
-      7 shl 7, me, uix, nodata^);
-    if result = eMissionDone then
-      result := Server(sMoveUnit + (a - b) and 7 shl 4 + (a + b) and 7 shl 7,
-        me, uix, nodata^)
-    else if (result <> eNoTime_Move) and (result <> eTreaty) and
-      (result <> eNoTurn) then
-      result := eInvalid // not a special commando mission!
-  end
-end;
-
-function TCustomAI.Unit_MoveForecast(uix, ToLoc: integer;
-  var RemainingMovement: integer): boolean;
-var
-  Advice: TMoveAdviceData;
-begin
-  assert((uix >= 0) and (uix < RO.nUn) and (MyUnit[uix].Loc >= 0)); // is a unit
-  Advice.ToLoc := ToLoc;
-  Advice.MoreTurns := 0;
-  Advice.MaxHostile_MovementLeft := 100;
-  if Server(sGetMoveAdvice, me, uix, Advice) = eOk then
+  cix:=RO.nCity-1;
+  while (cix>=0) and (MyCity[cix].Loc<>Loc) do
+    dec(cix);
+  end
+end;
+
+procedure TCustomAI.City_FindEnemyCity(Loc: integer; var ecix: integer);
+begin
+if Map[Loc] and (fCity or fOwned)<>fCity then
+  ecix:=-1
+else
   begin
-    RemainingMovement := Advice.MaxHostile_MovementLeft;
-    result := true
-  end
-  else
+  ecix:=RO.nEnemyCity-1;
+  while (ecix>=0) and (RO.EnemyCity[ecix].Loc<>Loc) do
+    dec(ecix);
+  end
+end;
+
+function TCustomAI.City_HasProject(cix: integer): boolean;
+begin
+result:= MyCity[cix].Project and (cpImp+cpIndex)<>cpImp+imTrGoods
+end;
+
+function TCustomAI.City_CurrentImprovementProject(cix: integer): integer;
+begin
+if MyCity[cix].Project and cpImp=0 then result:=-1
+else
   begin
-    RemainingMovement := -1;
-    result := false
-  end
-end;
-
-function TCustomAI.Unit_AttackForecast(uix, ToLoc, AttackMovement: integer;
-  var RemainingHealth: integer): boolean;
-var
-  BattleForecast: TBattleForecast;
-begin
-  assert((uix >= 0) and (uix < RO.nUn) and (MyUnit[uix].Loc >= 0) // is a unit
-    and (Map[ToLoc] and (fUnit or fOwned) = fUnit)); // is an attack
-  RemainingHealth := -$100;
-  result := false;
-  if AttackMovement >= 0 then
-    with MyUnit[uix] do
-    begin
-      BattleForecast.pAtt := me;
-      BattleForecast.mixAtt := mix;
-      BattleForecast.HealthAtt := Health;
-      BattleForecast.ExpAtt := Exp;
-      BattleForecast.FlagsAtt := Flags;
-      BattleForecast.Movement := AttackMovement;
-      if Server(sGetBattleForecast, me, ToLoc, BattleForecast) >= rExecuted then
-      begin
-        if BattleForecast.EndHealthAtt > 0 then
-          RemainingHealth := BattleForecast.EndHealthAtt
-        else
-          RemainingHealth := -BattleForecast.EndHealthDef;
-        result := true
-      end
-    end
-end;
-
-function TCustomAI.Unit_DefenseForecast(euix, ToLoc: integer;
-  var RemainingHealth: integer): boolean;
-var
-  BattleForecast: TBattleForecast;
-begin
-  assert((euix >= 0) and (euix < RO.nEnemyUn) and (RO.EnemyUn[euix].Loc >= 0)
-    // is an enemy unit
-    and (Map[ToLoc] and (fUnit or fOwned) = (fUnit or fOwned))); // is an attack
-  RemainingHealth := $100;
-  result := false;
-  with RO.EnemyUn[euix] do
-  begin
-    BattleForecast.pAtt := Owner;
-    BattleForecast.mixAtt := mix;
-    BattleForecast.HealthAtt := Health;
-    BattleForecast.ExpAtt := Exp;
-    BattleForecast.FlagsAtt := Flags;
-    BattleForecast.Movement := 100;
-    if Server(sGetBattleForecast, me, ToLoc, BattleForecast) >= rExecuted then
-    begin
-      if BattleForecast.EndHealthDef > 0 then
-        RemainingHealth := BattleForecast.EndHealthDef
-      else
-        RemainingHealth := -BattleForecast.EndHealthAtt;
-      result := true
-    end
-  end
-end;
-
-function TCustomAI.Unit_Disband(uix: integer): integer;
-begin
-  result := Server(sRemoveUnit, me, uix, nodata^)
-end;
-
-function TCustomAI.Unit_StartJob(uix, NewJob: integer): integer;
-begin
-  result := Server(sStartJob + NewJob shl 4, me, uix, nodata^)
-end;
-
-function TCustomAI.Unit_SetHomeHere(uix: integer): integer;
-begin
-  result := Server(sSetUnitHome, me, uix, nodata^)
-end;
-
-function TCustomAI.Unit_Load(uix: integer): integer;
-begin
-  result := Server(sLoadUnit, me, uix, nodata^)
-end;
-
-function TCustomAI.Unit_Unload(uix: integer): integer;
-begin
-  result := Server(sUnloadUnit, me, uix, nodata^)
-end;
-
-function TCustomAI.Unit_AddToCity(uix: integer): integer;
-begin
-  result := Server(sAddToCity, me, uix, nodata^)
-end;
-
-function TCustomAI.Unit_SelectTransport(uix: integer): integer;
-begin
-  result := Server(sSelectTransport, me, uix, nodata^)
-end;
-
-procedure TCustomAI.City_FindMyCity(Loc: integer; var cix: integer);
-begin
-  if Map[Loc] and (fCity or fOwned) <> fCity or fOwned then
-    cix := -1
-  else
-  begin
-    cix := RO.nCity - 1;
-    while (cix >= 0) and (MyCity[cix].Loc <> Loc) do
-      dec(cix);
-  end
-end;
-
-procedure TCustomAI.City_FindEnemyCity(Loc: integer; var ecix: integer);
-begin
-  if Map[Loc] and (fCity or fOwned) <> fCity then
-    ecix := -1
-  else
-  begin
-    ecix := RO.nEnemyCity - 1;
-    while (ecix >= 0) and (RO.EnemyCity[ecix].Loc <> Loc) do
-      dec(ecix);
-  end
-end;
-
-function TCustomAI.City_HasProject(cix: integer): boolean;
-begin
-  result := MyCity[cix].Project and (cpImp + cpIndex) <> cpImp + imTrGoods
-end;
-
-function TCustomAI.City_CurrentImprovementProject(cix: integer): integer;
-begin
-  if MyCity[cix].Project and cpImp = 0 then
-    result := -1
-  else
-  begin
-    result := MyCity[cix].Project and cpIndex;
-    if result = imTrGoods then
-      result := -1
+  result:=MyCity[cix].Project and cpIndex;
+  if result=imTrGoods then result:=-1
   end
 end;
@@ -983 +918 @@
 function TCustomAI.City_CurrentUnitProject(cix: integer): integer;
 begin
-  if MyCity[cix].Project and cpImp <> 0 then
-    result := -1
-  else
-    result := MyCity[cix].Project and cpIndex;
-end;
-
-function TCustomAI.City_GetTileInfo(cix, TileLoc: integer;
-  var TileInfo: TTileInfo): integer;
-begin
-  TileInfo.ExplCity := cix;
-  result := Server(sGetHypoCityTileInfo, me, TileLoc, TileInfo)
-end;
-
-function TCustomAI.City_GetReport(cix: integer;
-  var Report: TCityReport): integer;
-begin
-  Report.HypoTiles := -1;
-  Report.HypoTax := -1;
-  Report.HypoLux := -1;
-  result := Server(sGetCityReport, me, cix, Report)
+if MyCity[cix].Project and cpImp<>0 then result:=-1
+else result:=MyCity[cix].Project and cpIndex;
+end;
+
+function TCustomAI.City_GetTileInfo(cix,TileLoc: integer; var TileInfo: TTileInfo): integer;
+begin
+TileInfo.ExplCity:=cix;
+result:=Server(sGetHypoCityTileInfo,me,TileLoc,TileInfo)
+end;
+
+function TCustomAI.City_GetReport(cix: integer; var Report: TCityReport): integer;
+begin
+Report.HypoTiles:=-1;
+Report.HypoTax:=-1;
+Report.HypoLux:=-1;
+result:=Server(sGetCityReport,me,cix,Report)
 end;
 
@@ -1008 +939 @@
   var Report: TCityReport): integer;
 begin
-  Report.HypoTiles := HypoTiles;
-  Report.HypoTax := HypoTax;
-  Report.HypoLux := HypoLux;
-  result := Server(sGetCityReport, me, cix, Report)
-end;
-
-function TCustomAI.City_GetReportNew(cix: integer;
+Report.HypoTiles:=HypoTiles;
+Report.HypoTax:=HypoTax;
+Report.HypoLux:=HypoLux;
+result:=Server(sGetCityReport,me,cix,Report)
+end;
+
+function TCustomAI.City_GetReportNew(cix: integer; var Report: TCityReportNew): integer;
+begin
+Report.HypoTiles:=-1;
+Report.HypoTaxRate:=-1;
+Report.HypoLuxuryRate:=-1;
+result:=Server(sGetCityReportNew,me,cix,Report)
+end;
+
+function TCustomAI.City_GetHypoReportNew(cix, HypoTiles, HypoTaxRate, HypoLuxuryRate: integer;
   var Report: TCityReportNew): integer;
 begin
-  Report.HypoTiles := -1;
-  Report.HypoTaxRate := -1;
-  Report.HypoLuxuryRate := -1;
-  result := Server(sGetCityReportNew, me, cix, Report)
-end;
-
-function TCustomAI.City_GetHypoReportNew(cix, HypoTiles, HypoTaxRate,
-  HypoLuxuryRate: integer; var Report: TCityReportNew): integer;
-begin
-  Report.HypoTiles := HypoTiles;
-  Report.HypoTaxRate := HypoTaxRate;
-  Report.HypoLuxuryRate := HypoLuxuryRate;
-  result := Server(sGetCityReportNew, me, cix, Report)
-end;
-
-function TCustomAI.City_GetAreaInfo(cix: integer;
-  var AreaInfo: TCityAreaInfo): integer;
-begin
-  result := Server(sGetCityAreaInfo, me, cix, AreaInfo)
-end;
-
-function TCustomAI.City_StartUnitProduction(cix, mix: integer): integer;
-begin
-  result := Server(sSetCityProject, me, cix, mix)
-end;
-
-function TCustomAI.City_StartEmigration(cix, mix: integer;
+Report.HypoTiles:=HypoTiles;
+Report.HypoTaxRate:=HypoTaxRate;
+Report.HypoLuxuryRate:=HypoLuxuryRate;
+result:=Server(sGetCityReportNew,me,cix,Report)
+end;
+
+function TCustomAI.City_GetAreaInfo(cix: integer; var AreaInfo: TCityAreaInfo): integer;
+begin
+result:=Server(sGetCityAreaInfo,me,cix,AreaInfo)
+end;
+
+function TCustomAI.City_StartUnitProduction(cix,mix: integer): integer;
+begin
+if (MyCity[cix].Project and (cpImp+cpIndex)<>mix) then
+  // not already producing that
+  result:=Server(sSetCityProject,me,cix,mix)
+end;
+
+function TCustomAI.City_StartEmigration(cix,mix: integer;
   AllowDisbandCity, AsConscripts: boolean): integer;
 var
-  NewProject: integer;
-begin
-  NewProject := mix;
-  if AllowDisbandCity then
-    NewProject := NewProject or cpDisbandCity;
-  if AsConscripts then
-    NewProject := NewProject or cpConscripts;
-  result := Server(sSetCityProject, me, cix, NewProject)
-end;
-
-function TCustomAI.City_StartImprovement(cix, iix: integer): integer;
-var
-  NewProject: integer;
-begin
-  NewProject := iix + cpImp;
-  result := Server(sSetCityProject, me, cix, NewProject)
-end;
-
-function TCustomAI.City_Improvable(cix, iix: integer): boolean;
-var
-  NewProject: integer;
-begin
-  NewProject := iix + cpImp;
-  result := Server(sSetCityProject - sExecute, me, cix, NewProject) >=
-    rExecuted;
+NewProject: integer;
+begin
+NewProject:=mix;
+if AllowDisbandCity then NewProject:=NewProject or cpDisbandCity;
+if AsConscripts then NewProject:=NewProject or cpConscripts;
+result:=Server(sSetCityProject,me,cix,NewProject)
+end;
+
+function TCustomAI.City_StartImprovement(cix,iix: integer): integer;
+var
+NewProject: integer;
+begin
+NewProject:=iix+cpImp;
+if (MyCity[cix].Project and (cpImp+cpIndex)<>NewProject) then
+  // not already producing that
+  result:=Server(sSetCityProject,me,cix,NewProject)
+end;
+
+function TCustomAI.City_Improvable(cix,iix: integer): boolean;
+var
+NewProject: integer;
+begin
+NewProject:=iix+cpImp;
+result:= Server(sSetCityProject-sExecute,me,cix,NewProject)>=rExecuted;
 end;
 
 function TCustomAI.City_StopProduction(cix: integer): integer;
 var
-  NewProject: integer;
-begin
-  NewProject := imTrGoods + cpImp;
-  result := Server(sSetCityProject, me, cix, NewProject)
+NewProject: integer;
+begin
+NewProject:=imTrGoods+cpImp;
+result:=Server(sSetCityProject,me,cix,NewProject)
 end;
 
 function TCustomAI.City_BuyProject(cix: integer): integer;
 begin
-  result := Server(sBuyCityProject, me, cix, nodata^)
-end;
-
-function TCustomAI.City_SellImprovement(cix, iix: integer): integer;
-begin
-  result := Server(sSellCityImprovement, me, cix, iix)
-end;
-
-function TCustomAI.City_RebuildImprovement(cix, iix: integer): integer;
-begin
-  result := Server(sRebuildCityImprovement, me, cix, iix)
-end;
-
-function TCustomAI.City_SetTiles(cix, NewTiles: integer): integer;
-begin
-  result := Server(sSetCityTiles, me, cix, NewTiles)
-end;
-
-procedure TCustomAI.City_OptimizeTiles(cix: integer; ResourceWeights: integer);
-var
-  Advice: TCityTileAdviceData;
-begin
-  Advice.ResourceWeights := ResourceWeights;
-  Server(sGetCityTileAdvice, me, cix, Advice);
-  City_SetTiles(cix, Advice.Tiles);
-end;
+result:=Server(sBuyCityProject,me,cix,nodata^)
+end;
+
+function TCustomAI.City_SellImprovement(cix,iix: integer): integer;
+begin
+result:=Server(sSellCityImprovement,me,cix,iix)
+end;
+
+function TCustomAI.City_RebuildImprovement(cix,iix: integer): integer;
+begin
+result:=Server(sRebuildCityImprovement,me,cix,iix)
+end;
+
+function TCustomAI.City_SetTiles(cix,NewTiles: integer): integer;
+begin
+result:=Server(sSetCityTiles,me,cix,NewTiles)
+end;
+
+procedure TCustomAI.City_OptimizeTiles(cix: integer; ResourceWeights: cardinal);
+var
+Advice: TCityTileAdviceData;
+begin
+Advice.ResourceWeights:=ResourceWeights;
+Server(sGetCityTileAdvice, me, cix, Advice);
+City_SetTiles(cix, Advice.Tiles);
+end;
+
 
 // negotiation
 function TCustomAI.Nego_CheckMyAction: integer;
 begin
-  assert(Opponent >= 0); // only allowed in negotiation mode
-  assert((MyAction = scDipNotice) or (MyAction = scDipAccept) or
-    (MyAction = scDipCancelTreaty) or (MyAction = scDipOffer) or
-    (MyAction = scDipBreak));
-  if MyAction = scDipOffer then
-    result := Server(MyAction - sExecute, me, 0, MyOffer)
-  else
-    result := Server(MyAction - sExecute, me, 0, nodata^);
-end;
+assert(Opponent>=0); // only allowed in negotiation mode
+assert((MyAction=scDipNotice) or (MyAction=scDipAccept)
+  or (MyAction=scDipCancelTreaty) or (MyAction=scDipOffer)
+  or (MyAction=scDipBreak));
+if MyAction=scDipOffer then result:=Server(MyAction-sExecute, me, 0, MyOffer)
+else result:=Server(MyAction-sExecute, me, 0, nodata^);
+end;
+
 
 initialization
-
-nodata := pointer(0);
-RWDataSize := 0;
+nodata:=pointer(0);
+RWDataSize:=0;
 
 end.
+

trunk/AI/StdAI/Names.pas

@@ -4 +4 @@
 
 uses
-  Protocol;
+Protocol;
 
 const
 
-  Name_Advance: array [0 .. nAdv - 1] of string = ('Advanced Flight',
-    'Amphibious Warfare', 'Astronomy', 'Atomic Theory', 'Automobile',
-    'Ballistics', 'Banking', 'Bridge Building', 'Bronze Working',
-    'Ceremonial Burial', 'Chemistry', 'Chivalry', 'Composites', 'Code of Laws',
-    'Combined Arms', 'Combustion Engine', 'Communism', 'Computers',
-    'Conscription', 'Construction', 'The Corporation', 'Space Flight',
-    'Currency', 'Democracy', 'Economics', 'Electricity', 'Electronics',
-    'Engineering', 'Environmentalism', 'The Wheel', 'Explosives', 'Flight',
-    'Intelligence', 'Gunpowder', 'Horseback Riding', 'Impulse Drive',
-    'Industrialization', 'Intelligent Arms', 'Invention', 'Iron Working',
-    'The Laser', 'Nuclear Power', 'Literature', 'Internet', 'Magnetism',
-    'Map Making', 'Masonry', 'Mass Production', 'Mathematics', 'Medicine',
-    'Metallurgy', 'Miniaturization', 'Mobile Warfare', 'Monarchy', 'Mysticism',
-    'Navigation', 'Nuclear Fission', 'Philosophy', 'Physics', 'Plastics',
-    'Poetry', 'Pottery', 'Radio Communication', 'Recycling', 'Refrigeration',
-    'Monotheism', 'The Republic', 'Robotics', 'Rocketry', 'Railroad',
-    'Sanitation', 'Science', 'Writing', 'Seafaring',
-    'Self-Contained Environment', 'Stealth', 'Steam Engine', 'Steel',
-    'Synthetic Food', 'Tactics', 'Theology', 'Theory of Gravity', 'Trade',
-    'Transstellar Colonization', 'University', 'Advanced Rocketry',
-    'Warrior Code', 'Alphabet', 'Polytheism', 'Refining',
-    'Computing Technology', 'Nano Technology', 'Material Technology',
-    'Artificial Intelligence');
-
-  Name_Improvement: array [0 .. nImp - 1] of string = ('The Pyramids',
-    'The Temple of Zeus', 'The Hanging Gardens', 'The Colossus',
-    'The Lighthouse', 'The Great Library', 'The Oracle',
-    'Sun Tzu''s War Academy', 'Leonardo''s Workshop', 'Magellan''s Expedition',
-    'Michelangelo''s Chapel', '*', 'Newton''s College', 'Bach''s Cathedral',
-    '*', 'The Statue of Liberty', 'The Eiffel Tower', 'The Hoover Dam',
-    'The Shinkansen Express', 'The Manhattan Project', 'MIR Space Station', '*',
-    '*', '*', '*', '*', '*', '*', 'Trade Goods', 'Barracks', 'Granary',
-    'Temple', 'Marketplace', 'Library', 'Courthouse', 'City Walls', 'Aqueduct',
-    'Bank', 'Cathedral', 'University', 'Harbor', 'Theater', 'Factory',
-    'Manufacturing Plant', 'Recycling Center', 'Power Station',
-    'Hydroelectric Dam', 'Nuclear Plant', 'Offshore Platform', 'Town Hall',
-    'Sewer System', 'Supermarket', 'Superhighways', 'Research Lab',
-    'SAM Missile Battery', 'Coastal Fortress', 'Airport', 'Dockyard', 'Palace',
-    'Great Wall', 'Colosseum', 'Observatory', 'Military Academy',
-    'Command Bunker', 'Algae Plant', 'Stock Exchange', 'Space Port',
-    'Colony Ship Component', 'Power Module', 'Habitation Module');
-
-  Name_Feature: array [0 .. nFeature - 1] of string = ('Weapons', 'Armor',
-    'Mobility', 'Sea Transport', 'Carrier', 'Turbines', 'Bombs', 'Fuel',
-    'Air Transport', 'Navigation', 'Radar / Sonar', 'Submarine', 'Artillery',
-    'Alpine', 'Supply Ship', 'Overweight', 'Air Defence', 'Spy Plane',
-    'Steam Power', 'Nuclear Power', 'Jet Engines', 'Stealth', 'Fanatic',
-    'First Strike', 'Power of Will', 'Academy Training', 'Line Production');
-
-  Name_TerrainType: array [0 .. 11] of string = ('Ocean', 'Coast', 'Grassland',
-    'Desert', 'Prairie', 'Tundra', 'Arctic', 'Swamp', '*', 'Forest', 'Hills',
-    'Mountains');
-
-  Name_Government: array [0 .. nGov - 1] of string = ('Anarchy', 'Despotism',
-    'Monarchy', 'Republic', 'Fundamentalism', 'Communism', 'Democracy',
-    'Future Society');
+Name_Advance: array[0..nAdv-1] of string=
+('Advanced Flight',
+'Amphibious Warfare',
+'Astronomy',
+'Atomic Theory',
+'Automobile',
+'Ballistics',
+'Banking',
+'Bridge Building',
+'Bronze Working',
+'Ceremonial Burial',
+'Chemistry',
+'Chivalry',
+'Composites',
+'Code of Laws',
+'Combined Arms',
+'Combustion Engine',
+'Communism',
+'Computers',
+'Conscription',
+'Construction',
+'The Corporation',
+'Space Flight',
+'Currency',
+'Democracy',
+'Economics',
+'Electricity',
+'Electronics',
+'Engineering',
+'Environmentalism',
+'The Wheel',
+'Explosives',
+'Flight',
+'Intelligence',
+'Gunpowder',
+'Horseback Riding',
+'Impulse Drive',
+'Industrialization',
+'Intelligent Arms',
+'Invention',
+'Iron Working',
+'The Laser',
+'Nuclear Power',
+'Literature',
+'Internet',
+'Magnetism',
+'Map Making',
+'Masonry',
+'Mass Production',
+'Mathematics',
+'Medicine',
+'Metallurgy',
+'Miniaturization',
+'Mobile Warfare',
+'Monarchy',
+'Mysticism',
+'Navigation',
+'Nuclear Fission',
+'Philosophy',
+'Physics',
+'Plastics',
+'Poetry',
+'Pottery',
+'Radio Communication',
+'Recycling',
+'Refrigeration',
+'Monotheism',
+'The Republic',
+'Robotics',
+'Rocketry',
+'Railroad',
+'Sanitation',
+'Science',
+'Writing',
+'Seafaring',
+'Self-Contained Environment',
+'Stealth',
+'Steam Engine',
+'Steel',
+'Synthetic Food',
+'Tactics',
+'Theology',
+'Theory of Gravity',
+'Trade',
+'Transstellar Colonization',
+'University',
+'Advanced Rocketry',
+'Warrior Code',
+'Alphabet',
+'Polytheism',
+'Refining',
+'Computing Technology',
+'Nano Technology',
+'Material Technology',
+'Artificial Intelligence');
+
+Name_Improvement: array[0..nImp-1] of string=
+('The Pyramids',
+'The Temple of Zeus',
+'The Hanging Gardens',
+'The Colossus',
+'The Lighthouse',
+'The Great Library',
+'The Oracle',
+'Sun Tzu''s War Academy',
+'Leonardo''s Workshop',
+'Magellan''s Expedition',
+'Michelangelo''s Chapel',
+'*',
+'Newton''s College',
+'Bach''s Cathedral',
+'*',
+'The Statue of Liberty',
+'The Eiffel Tower',
+'The Hoover Dam',
+'The Shinkansen Express',
+'The Manhattan Project',
+'MIR Space Station',
+'*',
+'*',
+'*',
+'*',
+'*',
+'*',
+'*',
+'Trade Goods',
+'Barracks',
+'Granary',
+'Temple',
+'Marketplace',
+'Library',
+'Courthouse',
+'City Walls',
+'Aqueduct',
+'Bank',
+'Cathedral',
+'University',
+'Harbor',
+'Theater',
+'Factory',
+'Manufacturing Plant',
+'Recycling Center',
+'Power Station',
+'Hydroelectric Dam',
+'Nuclear Plant',
+'Offshore Platform',
+'Town Hall',
+'Sewer System',
+'Supermarket',
+'Superhighways',
+'Research Lab',
+'SAM Missile Battery',
+'Coastal Fortress',
+'Airport',
+'Dockyard',
+'Palace',
+'Great Wall',
+'Colosseum',
+'Observatory',
+'Military Academy',
+'Command Bunker',
+'Algae Plant',
+'Stock Exchange',
+'Space Port',
+'Colony Ship Component',
+'Power Module',
+'Habitation Module');
+
+Name_Feature: array[0..nFeature-1] of string=
+('Weapons',
+'Armor',
+'Mobility',
+'Sea Transport',
+'Carrier',
+'Turbines',
+'Bombs',
+'Fuel',
+'Air Transport',
+'Navigation',
+'Radar / Sonar',
+'Submarine',
+'Artillery',
+'Alpine',
+'Supply Ship',
+'Overweight',
+'Air Defence',
+'Spy Plane',
+'Steam Power',
+'Nuclear Power',
+'Jet Engines',
+'Stealth',
+'Fanatic',
+'First Strike',
+'Power of Will',
+'Academy Training',
+'Line Production');
+
+Name_TerrainType: array[0..11] of string=
+('Ocean',
+'Coast',
+'Grassland',
+'Desert',
+'Prairie',
+'Tundra',
+'Arctic',
+'Swamp',
+'*',
+'Forest',
+'Hills',
+'Mountains');
+
+Name_Government: array[0..nGov-1] of string=
+('Anarchy',
+'Despotism',
+'Monarchy',
+'Republic',
+'Fundamentalism',
+'Communism',
+'Democracy',
+'Future Society');
 
 implementation
 
 end.
+

trunk/AI/StdAI/Pile.pas

@@ -1 @@
-{ single instance priority queue
-  main parts contributed by Rassim Eminli }
+{single instance priority queue
+main parts contributed by Rassim Eminli}
 
 {$INCLUDE Switches.inc}
+
 unit Pile;
 
@@ -14 +15 @@
 function Get(var Item, Value: integer): boolean;
 
+
 implementation
 
 const
-  MaxSize = 9600;
+MaxSize=9600;
 
 type
-  TheapItem = record
-    Item: integer;
-    Value: integer;
-  end;
+TheapItem = record
+        Item:   integer;
+        Value:  integer;
+end;
 
 var
-  bh: array [0 .. MaxSize - 1] of TheapItem;
-  Ix: array [0 .. MaxSize - 1] of integer;
-  n, CurrentSize: integer;
-{$IFDEF DEBUG}InUse: boolean; {$ENDIF}
+bh: array[0..MaxSize-1] of TheapItem;
+Ix: array[0..MaxSize-1] of integer;
+n, CurrentSize: integer;
+{$IFDEF DEBUG}InUse: boolean;{$ENDIF}
+
 
 procedure Create(Size: integer);
 begin
-{$IFDEF DEBUG}assert(not InUse, 'Pile is a single instance class, ' + 'no multiple usage possible. Always call Pile.Free after use.'); {$ENDIF}
-  assert(Size <= MaxSize);
-  if (n <> 0) or (Size > CurrentSize) then
-  begin
-    FillChar(Ix, Size * sizeOf(integer), 255);
-    n := 0;
-  end;
-  CurrentSize := Size;
-{$IFDEF DEBUG}InUse := true; {$ENDIF}
+        {$IFDEF DEBUG}assert(not InUse, 'Pile is a single instance class, '
+          +'no multiple usage possible. Always call Pile.Free after use.');{$ENDIF}
+        assert(Size<=MaxSize);
+        if (n <> 0) or (Size > CurrentSize) then
+        begin
+                FillChar(Ix, Size*sizeOf(integer), 255);
+                n := 0;
+        end;
+        CurrentSize := Size;
+        {$IFDEF DEBUG}InUse:=true;{$ENDIF}
 end;
 
 procedure Free;
 begin
-{$IFDEF DEBUG}assert(InUse);
-  InUse := false; {$ENDIF}
+        {$IFDEF DEBUG}assert(InUse);InUse:=false;{$ENDIF}
 end;
 
 procedure Empty;
 begin
-  if n <> 0 then
-  begin
-    FillChar(Ix, CurrentSize * sizeOf(integer), 255);
-    n := 0;
-  end;
+        if n <> 0 then
+        begin
+                FillChar(Ix, CurrentSize*sizeOf(integer), 255);
+                n := 0;
+        end;
 end;
 
-// Parent(i) = (i-1)/2.
-function Put(Item, Value: integer): boolean; // O(lg(n))
+//Parent(i) = (i-1)/2.
+function Put(Item, Value: integer): boolean; //O(lg(n))
 var
-  i, j: integer;
+        i, j:   integer;
 begin
-  assert(Item < CurrentSize);
-  i := Ix[Item];
-  if i >= 0 then
-  begin
-    if bh[i].Value <= Value then
-    begin
-      result := false;
-      exit;
-    end;
-  end
-  else
-  begin
-    i := n;
-    Inc(n);
-  end;
+        assert(Item<CurrentSize);
+        i := Ix[Item];
+        if i >= 0 then
+        begin
+                if bh[i].Value <= Value then
+                begin
+                        result := False;
+                        exit;
+                end;
+        end
+        else
+        begin
+                i := n;
+                Inc(n);
+        end;
 
-  while i > 0 do
-  begin
-    j := (i - 1) shr 1; // Parent(i) = (i-1)/2
-    if Value >= bh[j].Value then
-      break;
-    bh[i] := bh[j];
-    Ix[bh[i].Item] := i;
-    i := j;
-  end;
-  // Insert the new Item at the insertion point found.
-  bh[i].Value := Value;
-  bh[i].Item := Item;
-  Ix[bh[i].Item] := i;
-  result := true;
+        while i > 0 do
+        begin
+                j := (i-1) shr 1;       //Parent(i) = (i-1)/2
+                if Value >= bh[j].Value then    break;
+                bh[i] := bh[j];
+                Ix[bh[i].Item] := i;
+                i := j;
+        end;
+        //      Insert the new Item at the insertion point found.
+        bh[i].Value := Value;
+        bh[i].Item := Item;
+        Ix[bh[i].Item] := i;
+        result := True;
 end;
 
 function TestPut(Item, Value: integer): boolean;
 var
-  i: integer;
+        i: integer;
 begin
-  assert(Item < CurrentSize);
-  i := Ix[Item];
-  result := (i < 0) or (bh[i].Value > Value);
+        assert(Item<CurrentSize);
+        i := Ix[Item];
+        result := (i < 0) or (bh[i].Value > Value);
 end;
 
-// Left(i) = 2*i+1.
-// Right(i) = 2*i+2 => Left(i)+1
-function Get(var Item, Value: integer): boolean; // O(lg(n))
+//Left(i) = 2*i+1.
+//Right(i) = 2*i+2 => Left(i)+1
+function Get(var Item, Value: integer): boolean; //O(lg(n))
 var
-  i, j: integer;
-  last: TheapItem;
+        i, j:   integer;
+        last:   TheapItem;
 begin
-  if n = 0 then
-  begin
-    result := false;
-    exit;
-  end;
+        if n = 0 then
+        begin
+                result := False;
+                exit;
+        end;
 
-  Item := bh[0].Item;
-  Value := bh[0].Value;
+        Item := bh[0].Item;
+        Value := bh[0].Value;
 
-  Ix[Item] := -1;
+        Ix[Item] := -1;
 
-  dec(n);
-  if n > 0 then
-  begin
-    last := bh[n];
-    i := 0;
-    j := 1;
-    while j < n do
-    begin
-      // Right(i) = Left(i)+1
-      if (j < n - 1) and (bh[j].Value > bh[j + 1].Value) then
-        Inc(j);
-      if last.Value <= bh[j].Value then
-        break;
+        dec(n);
+        if n > 0 then
+        begin
+                last := bh[n];
+                i := 0;         j := 1;
+                while j < n do
+                begin
+                                                                                //      Right(i) = Left(i)+1
+                        if(j < n-1) and (bh[j].Value > bh[j + 1].Value)then
+                                inc(j);
+                        if last.Value <= bh[j].Value then               break;
 
-      bh[i] := bh[j];
-      Ix[bh[i].Item] := i;
-      i := j;
-      j := j shl 1 + 1; // Left(j) = 2*j+1
-    end;
+                        bh[i] := bh[j];
+                        Ix[bh[i].Item] := i;
+                        i := j;
+                        j := j shl 1+1; //Left(j) = 2*j+1
+                end;
 
-    // Insert the root in the correct place in the heap.
-    bh[i] := last;
-    Ix[last.Item] := i;
-  end;
-  result := true
+                // Insert the root in the correct place in the heap.
+                bh[i] := last;
+                Ix[last.Item] := i;
+        end;
+        result := True
 end;
 
 initialization
+        n:=0;
+        CurrentSize:=0;
+        {$IFDEF DEBUG}InUse:=false;{$ENDIF}
+end.
 
-n := 0;
-CurrentSize := 0;
-{$IFDEF DEBUG}InUse := false; {$ENDIF}
-
-end.

trunk/AI/StdAI/ToolAI.pas

@@ -5 +5 @@
 
 uses
-{$IFDEF DEBUG}SysUtils, {$ENDIF} // necessary for debug exceptions
-{$IFDEF DEBUG}Names, {$ENDIF}
-  Protocol, CustomAI;
+{$IFDEF DEBUG}SysUtils,{$ENDIF} // necessary for debug exceptions
+Math,
+{$IFDEF DEBUG}Names,{$ENDIF}
+Protocol, CustomAI;
+
 
 type
-  TGroupTransportPlan = record
-    LoadLoc, uixTransport, nLoad, TurnsEmpty, TurnsLoaded: integer;
-    uixLoad: array [0 .. 15] of integer;
-  end;
-
-  TToolAI = class(TCustomAI)
-  protected
-{$IFDEF DEBUG}DebugMap: array [0 .. lxmax * lymax - 1] of integer; {$ENDIF}
-    function CityTaxBalance(cix: integer;
-      const CityReport: TCityReport): integer;
+TGroupTransportPlan=record
+  LoadLoc, uixTransport, nLoad, TurnsEmpty, TurnsLoaded: integer;
+  uixLoad: array[0..15] of integer;
+  end;
+
+
+TToolAI = class(TCustomAI)
+protected
+  {$IFDEF DEBUG}DebugMap: array[0..lxmax*lymax-1] of integer;{$ENDIF}
+
+  function CenterOfEmpire: integer;
+    // tile that is in the middle of all own cities
+
+  function CityTaxBalance(cix: integer; const CityReport: TCityReport): integer;
     // calculates exact difference of income and maintenance cost for a single city
     // positive result = income higher than maintenance
@@ -25 +31 @@
     // respects production and food converted to gold
     // CityReport must have been prepared before
-    procedure SumCities(TaxRate: integer; var TaxSum, ScienceSum: integer);
+  procedure SumCities(TaxRate: integer; var TaxSum, ScienceSum: integer);
     // calculates exact total tax and science income
     // tax is reduced by maintenance (so might be negative)
     // luxury not supported
 
-    procedure OptimizeCityTiles;
+  procedure OptimizeCityTiles;
     // obsolete; use City_OptimizeTiles instead
 
-    procedure GetCityProdPotential;
+  procedure GetCityProdPotential;
     // calculates potential collected production resources of a city
     // result: list for all cities in CityResult
-    procedure GetCityTradePotential;
+  procedure GetCityTradePotential;
     // calculates potential collected trade resources of a city
     // result: list for all cities in CityResult
 
-    procedure JobAssignment_Initialize;
+  procedure JobAssignment_Initialize;
     // initialization, must be called first of the JobAssignment functions
-    procedure JobAssignment_AddJob(Loc, Job, Score: integer);
+  procedure JobAssignment_AddJob(Loc, Job, Score: integer);
     // add job for settlers with certain score
     // jobs include founding cities!
-    procedure JobAssignment_AddUnit(uix: integer);
+  procedure JobAssignment_AddUnit(uix: integer);
     // add a settler unit to do jobs
-    procedure JobAssignment_Go;
+  procedure JobAssignment_Go;
     // to be called after all jobs and the settlers for them have been added
     // assigns each job to one settler, moves the settlers and makes them work
@@ -53 +59 @@
     // starting a job one turn earlier counts the same as 4 points of score
     // function does not cancel jobs that are already started
-    function JobAssignment_GotJob(uix: integer): boolean;
+  function JobAssignment_GotJob(uix: integer): boolean;
     // can be called after JobAssignment_Go to find out whether
     // a certain settler has been assigned a job to
 
-    procedure AnalyzeMap;
+  procedure AnalyzeMap;
     // calculates formations and districts
 
-    function CheckStep(MoveStyle, TimeBeforeStep, CrossCorner: integer;
-      var TimeAfterStep, RecoverTurns: integer;
-      FromTile, ToTile: integer): integer;
+  function CheckStep(MoveStyle, TimeBeforeStep, CrossCorner: integer;
+    var TimeAfterStep, RecoverTurns: integer; FromTile, ToTile: integer; IsCapture: boolean): integer;
     // forecast single unit move between adjacent tiles
     // format of TimeBeforeStep and TimeAfterStep: $1000*number of turns + $800-MP left
     // RecoverTurns: number of turns needed to rest outside city in order to
-    // recover from damage taken in this move (rounded up)
+    //   recover from damage taken in this move (rounded up)
     // FromTile and ToTile must be Map[FromLoc] and Map[ToLoc], no location codes
     // CrossCorner=1 for long moves that cross the tile corner, =0 for short ones that don't
 
-    function GetMyMoveStyle(mix, Health: integer): integer;
-
-    function Unit_MoveEx(uix, ToLoc: integer; Options: integer = 0): integer;
-
-    procedure SeaTransport_BeginInitialize;
-    procedure SeaTransport_EndInitialize;
+  function GetMyMoveStyle(mix,Health: integer): integer;
+
+  function Unit_MoveEx(uix,ToLoc: integer; Options: integer = 0): integer;
+
+  procedure SeaTransport_BeginInitialize;
+  procedure SeaTransport_EndInitialize;
     // sea transport, obligatory call order:
     // 1. BeginInitialize
@@ -86 +91 @@
     // - all transports have same capacity
     // - no transport is damaged
-    procedure SeaTransport_AddLoad(uix: integer);
-    procedure SeaTransport_AddTransport(uix: integer);
-    procedure SeaTransport_AddDestination(Loc: integer);
-    function SeaTransport_MakeGroupPlan(var TransportPlan
-      : TGroupTransportPlan): boolean;
+  procedure SeaTransport_AddLoad(uix: integer);
+  procedure SeaTransport_AddTransport(uix: integer);
+  procedure SeaTransport_AddDestination(Loc: integer);
+  function SeaTransport_MakeGroupPlan(var TransportPlan: TGroupTransportPlan): boolean;
     // make plan for group of units to transport from a single loading location by a single transport
     // the plan optimizes:
@@ -97 +101 @@
     // - time for the transport to move to one of the destination locations
     // after the plan is made, units and transport are removed from the pool, so that
-    // subsequent calls to MakeGroupPlan result in plans that may be executed parallel
+    //   subsequent calls to MakeGroupPlan result in plans that may be executed parallel
     // function returns false if no more transports are possible
 
-  end;
+  function CurrentMStrength(Domain: integer): integer;
+  end;
+
 
 const
-  // no-formations
-  nfUndiscovered = -1;
-  nfPole = -2;
-  nfPeace = -3;
-
-  // return codes of CheckStep
-  csOk = 0;
+// no-formations
+nfUndiscovered=-1; nfPole=-2; nfPeace=-3;
+
+// return codes of CheckStep
+csOk=0;
   // step is valid
   // TimeAfterMove has been calculated
-  csForbiddenTile = 1;
+csForbiddenTile=1;
   // unit can not move onto this tile
   // TimeAfterMove not calculated
-  csForbiddenStep = 2;
+csForbiddenStep=2;
   // (ZoC unit only) unit can not do this step because of ZoC violation
   // maybe tile can be reached using another way
   // TimeAfterMove not calculated
-  csCheckTerritory = 3;
+csCheckTerritory=3;
   // move within other nations's territory shortly after making peace
   // step is only possible if RO.Territory is the same for both tiles
   // TimeAfterMove has been calculated
 
-  // Unit_MoveEx
-  mxAdjacent = $00000001;
-
-var
-  nContinent, nOcean, nDistrict: integer;
-  Formation: array [0 .. lxmax * lymax - 1] of integer;
+// Unit_MoveEx
+mxAdjacent=$00000001;
+
+
+var
+nContinent, nOcean, nDistrict: integer;
+Formation: array[0..lxmax*lymax-1] of integer;
   // water: ocean index, land: continent index, sorted by size
   // territory unpassable due to peace treaty divides a continent
-  District: array [0 .. lxmax * lymax - 1] of integer;
+District: array[0..lxmax*lymax-1] of integer;
   // index of coherent own territory, sorted by size
-  CityResult: array [0 .. nCmax - 1] of integer;
-
-  Advancedness: array [0 .. nAdv - 1] of integer;
-  // total number of prerequisites for each advance
+CityResult: array[0..nCmax-1] of integer;
+
+Advancedness: array[0..nAdv-1] of integer; // total number of prerequisites for each advance
+
 
 implementation
 
 uses
-  Pile;
+Pile;
 
 type
-  pinteger = ^integer;
-
-var
-  // for JobAssignment
-  MaxScore: integer;
-  TileJob, TileJobScore: array [0 .. lxmax * lymax - 1] of byte;
-  JobLocOfSettler: array [0 .. nUmax - 1] of integer; // ToAssign = find job
-
-  // for Transport
-  TransportMoveStyle, TransportCapacity, nTransportLoad: integer;
-  InitComplete, HaveDestinations: boolean;
-  uixTransportLoad, TransportAvailable: array [0 .. nUmax - 1] of integer;
-  TurnsAfterLoad: array [0 .. lxmax * lymax - 1] of shortint;
-
-procedure ReplaceD(Start, Stop: pinteger; Raider, Twix: integer);
-begin
-  while Start <> Stop do
-  begin
-    if Start^ = Raider then
-      Start^ := Twix;
-    inc(Start)
+pinteger=^integer;
+
+var
+// for JobAssignment
+MaxScore: integer;
+TileJob,TileJobScore: array[0..lxmax*lymax-1] of byte;
+JobLocOfSettler: array[0..nUmax-1] of integer; // ToAssign = find job
+
+// for Transport
+TransportMoveStyle, TransportCapacity, nTransportLoad: integer;
+InitComplete, HaveDestinations: boolean;
+uixTransportLoad, TransportAvailable: array[0..nUmax-1] of integer;
+TurnsAfterLoad: array[0..lxmax*lymax-1] of shortint;
+
+
+procedure ReplaceD(Start, Stop: pinteger; Raider,Twix: integer);
+begin
+while Start<>Stop do
+  begin
+  if Start^=Raider then Start^:=Twix;
+  inc(Start)
   end;
 end;
@@ -171 +176 @@
 function NextZero(Start, Stop: pinteger; Mask: cardinal): pinteger;
 begin
-  while (Start <> Stop) and (Start^ and Mask <> 0) do
-    inc(Start);
-  result := Start;
-end;
-
-function TToolAI.CityTaxBalance(cix: integer;
-  const CityReport: TCityReport): integer;
-var
-  i: integer;
-begin
-  result := 0;
-  if (CityReport.Working - CityReport.Happy <= MyCity[cix].Size shr 1)
-  { no disorder }
-    and (MyCity[cix].Flags and chCaptured = 0) then // not captured
-  begin
-    inc(result, CityReport.Tax);
-    if (MyCity[cix].Project and (cpImp + cpIndex) = cpImp + imTrGoods) and
-      (CityReport.ProdRep > CityReport.Support) then
-      inc(result, CityReport.ProdRep - CityReport.Support);
-    if ((RO.Government = gLybertarianism) or
-      (MyCity[cix].Size >= NeedAqueductSize) and
-      (CityReport.FoodRep < CityReport.Eaten + 2)) and
-      (CityReport.FoodRep > CityReport.Eaten) then
-      inc(result, CityReport.FoodRep - CityReport.Eaten);
-  end;
-  for i := 28 to nImp - 1 do
-    if MyCity[cix].Built[i] > 0 then
-      dec(result, Imp[i].Maint);
+while (Start<>Stop) and (Start^ and Mask<>0) do inc(Start);
+result:=Start;
+end;
+
+
+function TToolAI.CenterOfEmpire: integer;
+var
+cix,Loc,x,y,sy,n: integer;
+a,su,sv: double;
+begin
+n:=0;
+sy:=0;
+su:=0;
+sv:=0;
+for cix:=0 to RO.nCity-1 do
+  begin
+  Loc:=MyCity[cix].Loc;
+  if Loc>=0 then
+    begin
+    y:=Loc div G.lx;
+    x:=Loc-y*G.lx;
+    inc(sy,y);
+    a:=2*pi*x/G.lx;
+    su:=su+cos(a);
+    sv:=sv+sin(a);
+    inc(n);
+    end;
+  end;
+a:=arctan2(sv,su);
+x:=round(G.lx*a/(2*pi));
+while x>=G.lx do
+  dec(x,G.lx);
+while x<0 do
+  inc(x,G.lx);
+result:=((2*sy+n) div (2*n))*G.lx + x;
+end;
+
+function TToolAI.CityTaxBalance(cix: integer; const CityReport: TCityReport): integer;
+var
+i: integer;
+begin
+result:=0;
+if (CityReport.Working-CityReport.Happy<=MyCity[cix].Size shr 1) {no disorder}
+  and (MyCity[cix].Flags and chCaptured=0) then // not captured
+  begin
+  inc(result, CityReport.Tax);
+  if (MyCity[cix].Project and (cpImp+cpIndex)=cpImp+imTrGoods)
+    and (CityReport.ProdRep>CityReport.Support) then
+    inc(result, CityReport.ProdRep-CityReport.Support);
+  if ((RO.Government=gLybertarianism)
+      or (MyCity[cix].Size>=NeedAqueductSize)
+      and (CityReport.FoodRep<CityReport.Eaten+2))
+    and (CityReport.FoodRep>CityReport.Eaten) then
+    inc(result, CityReport.FoodRep-CityReport.Eaten);
+  end;
+for i:=28 to nImp-1 do if MyCity[cix].Built[i]>0 then
+  dec(result, Imp[i].Maint);
 end;
 
 procedure TToolAI.SumCities(TaxRate: integer; var TaxSum, ScienceSum: integer);
 var
-  cix, p1: integer;
-  CityReport: TCityReport;
-begin
-  TaxSum := 0;
-  ScienceSum := 0;
-  if RO.Government = gAnarchy then
-    exit;
-  for p1 := 0 to nPl - 1 do
-    if RO.Tribute[p1] <= RO.TributePaid[p1] then
-    // don't rely on tribute from bankrupt nations
-      TaxSum := TaxSum + RO.Tribute[p1];
-  for cix := 0 to RO.nCity - 1 do
-    if MyCity[cix].Loc >= 0 then
-    begin
-      City_GetHypoReport(cix, -1, TaxRate, 0, CityReport);
-      if (CityReport.Working - CityReport.Happy <= MyCity[cix].Size shr 1)
-      { no disorder }
-        and (MyCity[cix].Flags and chCaptured = 0) then // not captured
-        ScienceSum := ScienceSum + CityReport.Science;
-      TaxSum := TaxSum + CityTaxBalance(cix, CityReport);
-    end;
-end;
-
-
-// ------------------------------------------------------------------------------
+cix,p1: integer;
+CityReport: TCityReport;
+begin
+TaxSum:=0; ScienceSum:=0;
+if RO.Government=gAnarchy then exit;
+for p1:=0 to nPl-1 do
+  if RO.Tribute[p1]<=RO.TributePaid[p1] then // don't rely on tribute from bankrupt nations
+    TaxSum:=TaxSum+RO.Tribute[p1];
+for cix:=0 to RO.nCity-1 do if MyCity[cix].Loc>=0 then
+  begin
+  City_GetHypoReport(cix,-1,TaxRate,0,CityReport);
+  if (CityReport.Working-CityReport.Happy<=MyCity[cix].Size shr 1) {no disorder}
+    and (MyCity[cix].Flags and chCaptured=0) then // not captured
+    ScienceSum:=ScienceSum+CityReport.Science;
+  TaxSum:=TaxSum+CityTaxBalance(cix, CityReport);
+  end;
+end;
+
+
+//------------------------------------------------------------------------------
 // City Tiles Processing
 
 const
-  pctOptimize = 0;
-  pctGetProdPotential = 1;
-  pctGetTradePotential = 2;
+pctOptimize=0; pctGetProdPotential=1; pctGetTradePotential=2;
 
 procedure TToolAI.OptimizeCityTiles;
 var
-  cix: integer;
-begin
-  for cix := 0 to RO.nCity - 1 do
-    with MyCity[cix] do
-      if Loc >= 0 then
-        City_OptimizeTiles(cix);
+cix: integer;
+begin
+for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+  City_OptimizeTiles(cix);
 end;
 
 procedure TToolAI.GetCityProdPotential;
 var
-  cix: integer;
-  Advice: TCityTileAdviceData;
-begin
-  for cix := 0 to RO.nCity - 1 do
-    with MyCity[cix] do
-      if Loc >= 0 then
-      begin
-        Advice.ResourceWeights := rwMaxProd;
-        Server(sGetCityTileAdvice, me, cix, Advice);
-        CityResult[cix] := Advice.CityReport.ProdRep;
-        // considers factory, but shouldn't
-      end;
+cix: integer;
+Advice: TCityTileAdviceData;
+begin
+for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+  begin
+  Advice.ResourceWeights:=rwMaxProd;
+  Server(sGetCityTileAdvice, me, cix, Advice);
+  CityResult[cix]:=Advice.CityReport.ProdRep; // considers factory, but shouldn't
+  end;
 end;
 
 procedure TToolAI.GetCityTradePotential;
 var
-  cix: integer;
-  Advice: TCityTileAdviceData;
-begin
-  for cix := 0 to RO.nCity - 1 do
-    with MyCity[cix] do
-      if Loc >= 0 then
-      begin
-        Advice.ResourceWeights := rwMaxScience;
-        Server(sGetCityTileAdvice, me, cix, Advice);
-        CityResult[cix] := Advice.CityReport.Trade;
-      end;
-end;
-
-
-// ------------------------------------------------------------------------------
+cix: integer;
+Advice: TCityTileAdviceData;
+begin
+for cix:=0 to RO.nCity-1 do with MyCity[cix] do if Loc>=0 then
+  begin
+  Advice.ResourceWeights:=rwMaxScience;
+  Server(sGetCityTileAdvice, me, cix, Advice);
+  CityResult[cix]:=Advice.CityReport.Trade;
+  end;
+end;
+
+
+//------------------------------------------------------------------------------
 // JobAssignment
 
 const
-  ToAssign = lxmax * lymax;
+ToAssign=lxmax*lymax;
 
 procedure TToolAI.JobAssignment_Initialize;
 begin
-  fillchar(JobLocOfSettler, RO.nUn * sizeof(integer), $FF); // -1
-  fillchar(TileJob, MapSize, jNone);
-  fillchar(TileJobScore, MapSize, 0);
-  MaxScore := 0;
+fillchar(JobLocOfSettler, RO.nUn*sizeof(integer), $FF); // -1
+fillchar(TileJob, MapSize, jNone);
+fillchar(TileJobScore, MapSize, 0);
+MaxScore:=0;
 end;
 
 procedure TToolAI.JobAssignment_AddJob(Loc, Job, Score: integer);
 begin
-  if Score > 255 then
-    Score := 255;
-  if Score > TileJobScore[Loc] then
-  begin
-    TileJob[Loc] := Job;
-    TileJobScore[Loc] := Score;
-    if Score > MaxScore then
-      MaxScore := Score
+if Score>255 then Score:=255;
+if Score>TileJobScore[Loc] then
+  begin
+  TileJob[Loc]:=Job;
+  TileJobScore[Loc]:=Score;
+  if Score>MaxScore then MaxScore:=Score
   end;
 end;
@@ -306 +324 @@
 procedure TToolAI.JobAssignment_AddUnit(uix: integer);
 begin
-  assert(MyModel[MyUnit[uix].mix].Kind in [mkSettler, mkSlaves]);
-  JobLocOfSettler[uix] := ToAssign
+assert(MyModel[MyUnit[uix].mix].Kind in [mkSettler,mkSlaves]);
+JobLocOfSettler[uix]:=ToAssign
 end;
 
 function TToolAI.JobAssignment_GotJob(uix: integer): boolean;
 begin
-  result := JobLocOfSettler[uix] >= 0;
+result:=JobLocOfSettler[uix]>=0;
 end;
 
 procedure TToolAI.JobAssignment_Go;
 const
-  DistanceScore = 4;
-  StepSizeByTerrain: array [0 .. 11] of integer = (0, 0, 1, 2, 1, 1, 0, 1,
-    0, 1, 1, 2);
-  // Oc-Sh-Gr-De-Pr-Tu-Ar-Sw-XX-Fo-Hi-Mo
-var
-  uix, BestScore, BestCount, BestLoc, BestJob, BestDistance, TestLoc, NextLoc,
-    TestDistance, V8, TestScore, StepSize, MoveResult: integer;
-  UnitsToAssign: boolean;
-  Adjacent: TVicinity8Loc;
-  SettlerOfJobLoc, DistToLoc: array [0 .. lxmax * lymax - 1] of smallint;
+DistanceScore=4;
+StepSizeByTerrain: array[0..11] of integer=
+( 0, 0, 1, 2, 1, 1, 0, 1, 0, 1, 1, 2);
+//Oc-Sh-Gr-De-Pr-Tu-Ar-Sw-XX-Fo-Hi-Mo
+var
+uix,BestScore,BestCount,BestLoc,BestJob,BestDistance,TestLoc,NextLoc,
+TestDistance,V8,TestScore,StepSize,MoveResult: integer;
+UnitsToAssign: boolean;
+Adjacent: TVicinity8Loc;
+SettlerOfJobLoc,DistToLoc: array[0..lxmax*lymax-1] of smallint;
   // DistToLoc is only defined where SettlerOfJobLoc>=0
-  TileChecked: array [0 .. lxmax * lymax - 1] of boolean;
-begin
-  fillchar(SettlerOfJobLoc, MapSize * 2, $FF); // -1
-
-  // keep up jobs that are already started
-  for uix := 0 to RO.nUn - 1 do
-    if (MyUnit[uix].Loc >= 0) and (MyUnit[uix].Job > jNone) then
-    begin
-      JobLocOfSettler[uix] := MyUnit[uix].Loc;
-      SettlerOfJobLoc[MyUnit[uix].Loc] := uix;
-      DistToLoc[MyUnit[uix].Loc] := 0
-    end;
-
-  // assign remaining jobs to remaining settlers
-  UnitsToAssign := true;
-  while UnitsToAssign do
-  begin
-    UnitsToAssign := false;
-    for uix := 0 to RO.nUn - 1 do
-      if JobLocOfSettler[uix] = ToAssign then
-      begin
-        BestJob := jNone;
-        BestScore := -999999;
-        fillchar(TileChecked, MapSize * sizeof(boolean), false);
-        Pile.Create(MapSize);
-        Pile.Put(MyUnit[uix].Loc, 0);
-        // start search for new job at current location
-        while Pile.Get(TestLoc, TestDistance) do
+TileChecked: array[0..lxmax*lymax-1] of boolean;
+begin
+fillchar(SettlerOfJobLoc, MapSize*2, $FF); // -1
+
+// keep up jobs that are already started
+for uix:=0 to RO.nUn-1 do
+  if (MyUnit[uix].Loc>=0) and (MyUnit[uix].Job>jNone) then
+    begin
+    JobLocOfSettler[uix]:=MyUnit[uix].Loc;
+    SettlerOfJobLoc[MyUnit[uix].Loc]:=uix;
+    DistToLoc[MyUnit[uix].Loc]:=0
+    end;
+
+// assign remaining jobs to remaining settlers
+UnitsToAssign:=true;
+while UnitsToAssign do
+  begin
+  UnitsToAssign:=false;
+  for uix:=0 to RO.nUn-1 do if JobLocOfSettler[uix]=ToAssign then
+    begin
+    BestJob:=jNone;
+    BestScore:=-999999;
+    FillChar(TileChecked,MapSize*sizeof(boolean),false);
+    Pile.Create(MapSize);
+    Pile.Put(MyUnit[uix].Loc,0); // start search for new job at current location
+    while Pile.Get(TestLoc,TestDistance) do
+      begin
+      // add surrounding tiles to queue, but only if there's a chance to beat BestScore
+      if MaxScore-DistanceScore*(TestDistance+1)>=BestScore then
         begin
-          // add surrounding tiles to queue, but only if there's a chance to beat BestScore
-          if MaxScore - DistanceScore * (TestDistance + 1) >= BestScore then
+        V8_to_Loc(TestLoc,Adjacent);
+        for V8:=0 to 7 do
           begin
-            V8_to_Loc(TestLoc, Adjacent);
-            for V8 := 0 to 7 do
+          NextLoc:=Adjacent[V8];
+          if (NextLoc>=0) and not TileChecked[NextLoc]
+            and (Map[NextLoc] and fTerrain<>fUNKNOWN) then
             begin
-              NextLoc := Adjacent[V8];
-              if (NextLoc >= 0) and not TileChecked[NextLoc] and
-                (Map[NextLoc] and fTerrain <> fUNKNOWN) then
-              begin
-                StepSize := StepSizeByTerrain[Map[NextLoc] and fTerrain];
-                if (StepSize > 0) // no water or arctic tile
-                  and (Map[NextLoc] and (fUnit or fOwned) <> fUnit)
-                // no foreign unit
-                  and ((RO.Territory[NextLoc] < 0) or
-                  (RO.Territory[NextLoc] = me)) // no foreign territory
-                  and (Map[TestLoc] and Map[NextLoc] and fInEnemyZoC = 0) then
-                // move not prevented by ZoC
-                  Pile.Put(NextLoc, TestDistance + StepSize)
-                  // simplification, only optimal for 150 mp units in land with no roads
-              end;
+            StepSize:=StepSizeByTerrain[Map[NextLoc] and fTerrain];
+            if (StepSize>0) // no water or arctic tile
+              and (Map[NextLoc] and (fUnit or fOwned)<>fUnit) // no foreign unit
+              and ((RO.Territory[NextLoc]<0) or (RO.Territory[NextLoc]=me)) // no foreign territory
+              and (Map[TestLoc] and Map[NextLoc] and fInEnemyZoC=0) then // move not prevented by ZoC
+              Pile.Put(NextLoc,TestDistance+StepSize)
+              // simplification, only optimal for 150 mp units in land with no roads
             end;
           end;
-
-          // check tile for job
-          if (TileJob[TestLoc] > jNone) and
-            ((MyModel[MyUnit[uix].mix].Kind <> mkSlaves) or
-            (TileJob[TestLoc] <> jCity)) and
-            ((SettlerOfJobLoc[TestLoc] < 0) or
-            (DistToLoc[TestLoc] > TestDistance)) then
+        end;
+
+      // check tile for job
+      if (TileJob[TestLoc]>jNone)
+        and ((MyModel[MyUnit[uix].mix].Kind<>mkSlaves)
+          or (TileJob[TestLoc]<>jCity))
+        and ((SettlerOfJobLoc[TestLoc]<0) or (DistToLoc[TestLoc]>TestDistance)) then
+        begin
+        TestScore:=integer(TileJobScore[TestLoc])-DistanceScore*TestDistance;
+        if TestScore>BestScore then
+          BestCount:=0;
+        if TestScore>=BestScore then
           begin
-            TestScore := integer(TileJobScore[TestLoc]) - DistanceScore *
-              TestDistance;
-            if TestScore > BestScore then
-              BestCount := 0;
-            if TestScore >= BestScore then
+          inc(BestCount);
+          if random(BestCount)=0 then
             begin
-              inc(BestCount);
-              if random(BestCount) = 0 then
-              begin
-                BestScore := TestScore;
-                BestLoc := TestLoc;
-                BestJob := TileJob[TestLoc];
-                BestDistance := TestDistance
-              end
-            end;
+            BestScore:=TestScore;
+            BestLoc:=TestLoc;
+            BestJob:=TileJob[TestLoc];
+            BestDistance:=TestDistance
+            end
           end;
-          TileChecked[TestLoc] := true;
         end;
-        Pile.Free;
-
-        if BestJob > jNone then
-        begin // new job found for this unit
-          if SettlerOfJobLoc[BestLoc] >= 0 then
-          begin // another unit was already assigned to this job, but is not as close -- reassign that unit!
-            JobLocOfSettler[SettlerOfJobLoc[BestLoc]] := ToAssign;
-            UnitsToAssign := true;
-          end;
-          JobLocOfSettler[uix] := BestLoc;
-          SettlerOfJobLoc[BestLoc] := uix;
-          DistToLoc[BestLoc] := BestDistance
-        end
-        else
-          JobLocOfSettler[uix] := -1; // no jobs for this settler
-      end; // for uix
-  end;
-
-  // move settlers and start new jobs
-  for uix := 0 to RO.nUn - 1 do
-    with MyUnit[uix] do
-      if (Loc >= 0) and (Job = jNone) and (JobLocOfSettler[uix] >= 0) then
-      begin
-        if Loc <> JobLocOfSettler[uix] then
-          repeat
-            MoveResult := Unit_Move(uix, JobLocOfSettler[uix])
-          until (MoveResult < rExecuted) or
-            (MoveResult and (rLocationReached or rMoreTurns or
-            rUnitRemoved) <> 0);
-        if (Loc = JobLocOfSettler[uix]) and (Movement >= 100) then
-          Unit_StartJob(uix, TileJob[JobLocOfSettler[uix]]);
+      TileChecked[TestLoc]:=true;
       end;
+    Pile.Free;
+
+    if BestJob>jNone then
+      begin // new job found for this unit
+      if SettlerOfJobLoc[BestLoc]>=0 then
+        begin // another unit was already assigned to this job, but is not as close -- reassign that unit!
+        JobLocOfSettler[SettlerOfJobLoc[BestLoc]]:=ToAssign;
+        UnitsToAssign:=true;
+        end;
+      JobLocOfSettler[uix]:=BestLoc;
+      SettlerOfJobLoc[BestLoc]:=uix;
+      DistToLoc[BestLoc]:=BestDistance
+      end
+    else JobLocOfSettler[uix]:=-1; // no jobs for this settler
+    end; // for uix
+  end;
+
+// move settlers and start new jobs
+for uix:=0 to RO.nUn-1 do with MyUnit[uix] do
+  if (Loc>=0) and (Job=jNone) and (JobLocOfSettler[uix]>=0) then
+    begin
+    if Loc<>JobLocOfSettler[uix] then
+      repeat
+        MoveResult:=Unit_Move(uix,JobLocOfSettler[uix])
+      until (MoveResult<rExecuted)
+        or (MoveResult and (rLocationReached or rMoreTurns or rUnitRemoved)<>0);
+    if (Loc=JobLocOfSettler[uix]) and (Movement>=100) then
+      Unit_StartJob(uix,TileJob[JobLocOfSettler[uix]]);
+    end;
 end; // JobAssignment_Go
 
 
-// ------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // Map Analysis
 
 procedure TToolAI.AnalyzeMap;
 var
-  i, j, Loc, Loc1, V8, Count, Kind, MostIndex: integer;
-  Adjacent: TVicinity8Loc;
-  IndexOfID: array [0 .. lxmax * lymax - 1] of smallint;
-  IDOfIndex: array [0 .. lxmax * lymax div 2 - 1] of smallint;
-begin
-  fillchar(District, MapSize * 4, $FF);
-  for Loc := 0 to MapSize - 1 do
-    if Map[Loc] and fTerrain = fUNKNOWN then
-      Formation[Loc] := nfUndiscovered
-    else if Map[Loc] and fTerrain = fArctic then
-      Formation[Loc] := nfPole
-    else if Map[Loc] and fPeace <> 0 then
-      Formation[Loc] := nfPeace
-    else
-    begin
-      Formation[Loc] := Loc;
-      V8_to_Loc(Loc, Adjacent);
-      for V8 := 0 to 7 do
-      begin
-        Loc1 := Adjacent[V8];
-        if (Loc1 < Loc) and (Loc1 >= 0) and (Formation[Loc1] >= 0) and
-          ((Map[Loc1] and fTerrain >= fGrass) = (Map[Loc] and fTerrain >=
-          fGrass)) then
-          if Formation[Loc] = Loc then
-            Formation[Loc] := Formation[Loc1]
-          else if Formation[Loc] < Formation[Loc1] then
-            ReplaceD(@Formation[Formation[Loc1]], @Formation[Loc + 1],
-              Formation[Loc1], Formation[Loc])
-          else if Formation[Loc] > Formation[Loc1] then
-            ReplaceD(@Formation[Formation[Loc]], @Formation[Loc + 1],
-              Formation[Loc], Formation[Loc1]);
+i,j,Loc,Loc1,V8,Count,Kind,MostIndex: integer;
+Adjacent: TVicinity8Loc;
+IndexOfID: array[0..lxmax*lymax-1] of smallint;
+IDOfIndex: array[0..lxmax*lymax div 2 -1] of smallint;
+begin
+fillchar(District, MapSize*4, $FF);
+for Loc:=0 to MapSize-1 do
+  if Map[Loc] and fTerrain=fUNKNOWN then Formation[Loc]:=nfUndiscovered
+  else if Map[Loc] and fTerrain=fArctic then Formation[Loc]:=nfPole
+  else if Map[Loc] and fPeace<>0 then Formation[Loc]:=nfPeace
+  else
+    begin
+    Formation[Loc]:=Loc;
+    V8_to_Loc(Loc, Adjacent);
+    for V8:=0 to 7 do
+      begin
+      Loc1:=Adjacent[V8];
+      if (Loc1<Loc) and (Loc1>=0) and (Formation[Loc1]>=0)
+        and ((Map[Loc1] and fTerrain>=fGrass) = (Map[Loc] and fTerrain>=fGrass)) then
+        if Formation[Loc]=Loc then Formation[Loc]:=Formation[Loc1]
+        else if Formation[Loc]<Formation[Loc1] then
+          ReplaceD(@Formation[Formation[Loc1]],@Formation[Loc+1],Formation[Loc1],Formation[Loc])
+        else if Formation[Loc]>Formation[Loc1] then
+          ReplaceD(@Formation[Formation[Loc]],@Formation[Loc+1],Formation[Loc],Formation[Loc1]);
       end;
-      if (RO.Territory[Loc] = me) and (Map[Loc] and fTerrain >= fGrass) then
-      begin
-        District[Loc] := Loc;
-        for V8 := 0 to 7 do
+    if (RO.Territory[Loc]=me) and (Map[Loc] and fTerrain>=fGrass) then
+      begin
+      District[Loc]:=Loc;
+      for V8:=0 to 7 do
         begin
-          Loc1 := Adjacent[V8];
-          if (Loc1 < Loc) and (Loc1 >= 0) and (District[Loc1] >= 0) then
-            if District[Loc] = Loc then
-              District[Loc] := District[Loc1]
-            else if District[Loc] < District[Loc1] then
-              ReplaceD(@District[District[Loc1]], @District[Loc + 1],
-                District[Loc1], District[Loc])
-            else if District[Loc] > District[Loc1] then
-              ReplaceD(@District[District[Loc]], @District[Loc + 1],
-                District[Loc], District[Loc1]);
+        Loc1:=Adjacent[V8];
+        if (Loc1<Loc) and (Loc1>=0) and (District[Loc1]>=0) then
+          if District[Loc]=Loc then District[Loc]:=District[Loc1]
+          else if District[Loc]<District[Loc1] then
+            ReplaceD(@District[District[Loc1]],@District[Loc+1],District[Loc1],District[Loc])
+          else if District[Loc]>District[Loc1] then
+            ReplaceD(@District[District[Loc]],@District[Loc+1],District[Loc],District[Loc1]);
         end
       end
     end;
 
-  // sort continents, oceans and districts by size
-  for Kind := 0 to 2 do
-  begin
-    fillchar(IndexOfID, MapSize * 2, 0);
-    case Kind of
-      0: // continents
-        for Loc := 0 to MapSize - 1 do
-          if (Formation[Loc] >= 0) and (Map[Loc] and fTerrain >= fGrass) then
-            inc(IndexOfID[Formation[Loc]]);
-      1: // oceans
-        for Loc := 0 to MapSize - 1 do
-          if (Formation[Loc] >= 0) and (Map[Loc] and fTerrain < fGrass) then
-            inc(IndexOfID[Formation[Loc]]);
-      2: // districts
-        for Loc := 0 to MapSize - 1 do
-          if District[Loc] >= 0 then
-            inc(IndexOfID[District[Loc]]);
-    end;
-
-    Count := 0;
-    for Loc := 0 to MapSize - 1 do
-      if IndexOfID[Loc] > 0 then
-      begin
-        IDOfIndex[Count] := Loc;
-        inc(Count);
+// sort continents, oceans and districts by size
+for Kind:=0 to 2 do
+  begin
+  FillChar(IndexOfID,MapSize*2,0);
+  case Kind of
+    0: // continents
+      for Loc:=0 to MapSize-1 do
+        if (Formation[Loc]>=0) and (Map[Loc] and fTerrain>=fGrass) then
+          inc(IndexOfID[Formation[Loc]]);
+    1: // oceans
+      for Loc:=0 to MapSize-1 do
+        if (Formation[Loc]>=0) and (Map[Loc] and fTerrain<fGrass) then
+          inc(IndexOfID[Formation[Loc]]);
+    2: // districts
+      for Loc:=0 to MapSize-1 do
+        if District[Loc]>=0 then
+          inc(IndexOfID[District[Loc]]);
+    end;
+
+  Count:=0;
+  for Loc:=0 to MapSize-1 do if IndexOfID[Loc]>0 then
+    begin
+    IDOfIndex[Count]:=Loc;
+    inc(Count);
+    end;
+  for i:=0 to Count-2 do
+    begin
+    MostIndex:=i;
+    for j:=i+1 to Count-1 do
+      if IndexOfID[IDOfIndex[j]]>IndexOfID[IDOfIndex[MostIndex]] then MostIndex:=j;
+    if MostIndex<>i then
+      begin
+      j:=IDOfIndex[i];
+      IDOfIndex[i]:=IDOfIndex[MostIndex];
+      IDOfIndex[MostIndex]:=j;
+      end
+    end;
+  for i:=0 to Count-1 do
+    IndexOfID[IDOfIndex[i]]:=i;
+
+  case Kind of
+    0: // continents
+      begin
+      nContinent:=Count;
+      for Loc:=0 to MapSize-1 do
+        if (Formation[Loc]>=0) and (Map[Loc] and fTerrain>=fGrass) then
+          Formation[Loc]:=IndexOfID[Formation[Loc]];
       end;
-    for i := 0 to Count - 2 do
-    begin
-      MostIndex := i;
-      for j := i + 1 to Count - 1 do
-        if IndexOfID[IDOfIndex[j]] > IndexOfID[IDOfIndex[MostIndex]] then
-          MostIndex := j;
-      if MostIndex <> i then
-      begin
-        j := IDOfIndex[i];
-        IDOfIndex[i] := IDOfIndex[MostIndex];
-        IDOfIndex[MostIndex] := j;
-      end
-    end;
-    for i := 0 to Count - 1 do
-      IndexOfID[IDOfIndex[i]] := i;
-
-    case Kind of
-      0: // continents
-        begin
-          nContinent := Count;
-          for Loc := 0 to MapSize - 1 do
-            if (Formation[Loc] >= 0) and (Map[Loc] and fTerrain >= fGrass) then
-              Formation[Loc] := IndexOfID[Formation[Loc]];
-        end;
-      1: // oceans
-        begin
-          nOcean := Count;
-          for Loc := 0 to MapSize - 1 do
-            if (Formation[Loc] >= 0) and (Map[Loc] and fTerrain < fGrass) then
-              Formation[Loc] := IndexOfID[Formation[Loc]];
-        end;
-      2: // districts
-        begin
-          nDistrict := Count;
-          for Loc := 0 to MapSize - 1 do
-            if District[Loc] >= 0 then
-              District[Loc] := IndexOfID[District[Loc]];
-        end;
+    1: // oceans
+      begin
+      nOcean:=Count;
+      for Loc:=0 to MapSize-1 do
+        if (Formation[Loc]>=0) and (Map[Loc] and fTerrain<fGrass) then
+          Formation[Loc]:=IndexOfID[Formation[Loc]];
+      end;
+    2: // districts
+      begin
+      nDistrict:=Count;
+      for Loc:=0 to MapSize-1 do
+        if District[Loc]>=0 then
+          District[Loc]:=IndexOfID[District[Loc]];
+      end;
     end
   end;
@@ -566 +562 @@
 
 
-// ------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // Path Finding
 
 const
-  // basic move styles
-  msGround = $00000000;
-  msNoGround = $10000000;
-  msAlpine = $20000000;
-  msOver = $40000000;
-  msSpy = $50000000;
-
-  // other
-  msHostile = $08000000;
-
-  // bits:   |31|30|29|28|27|26 .. 16|15|14|13|12|11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
-  // ground: |   Basic   |Ho| Speed  |       HeavyCost       |        RailCost       |
-  // other:  |   Basic   | 0| Speed  |              X X X             | MaxTerrType  |
-
-function TToolAI.GetMyMoveStyle(mix, Health: integer): integer;
-begin
-  with MyModel[mix] do
-  begin
-    result := Speed shl 16;
-    case Domain of
-      dGround:
-        begin
-          inc(result, (50 + (Speed - 150) * 13 shr 7) shl 8); // HeavyCost
-          if RO.Wonder[woShinkansen].EffectiveOwner <> me then
-            inc(result, Speed * (4 * 1311) shr 17); // RailCost
-          if RO.Wonder[woGardens].EffectiveOwner <> me then
-            inc(result, msHostile);
-          if Kind = mkDiplomat then
-            inc(result, msSpy)
-          else if Cap[mcOver] > 0 then
-            inc(result, msOver)
-          else if Cap[mcAlpine] > 0 then
-            inc(result, msAlpine)
-          else
-            inc(result, msGround);
-        end;
-      dSea:
-        begin
-          result := Speed;
-          if RO.Wonder[woMagellan].EffectiveOwner = me then
-            inc(result, 200);
-          if Health < 100 then
-            result := ((result - 250) * Health div 5000) * 50 + 250;
-          result := result shl 16;
-          inc(result, msNoGround);
-          if Cap[mcNav] > 0 then
-            inc(result);
-        end;
-      dAir:
-        inc(result, msNoGround + fUNKNOWN xor 1 - 1);
+// basic move styles
+msGround=        $00000000;
+msNoGround=      $10000000;
+msAlpine=        $20000000;
+msOver=          $40000000;
+msSpy=           $50000000;
+
+// other
+msHostile=       $08000000;
+
+// bits:   |31|30|29|28|27|26 .. 16|15|14|13|12|11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
+// ground: |   Basic   |Ho| Speed  |       HeavyCost       |        RailCost       |
+// other:  |   Basic   | 0| Speed  |              X X X             | MaxTerrType  |
+
+function TToolAI.GetMyMoveStyle(mix,Health: integer): integer;
+begin
+with MyModel[mix] do
+  begin
+  result:=Speed shl 16;
+  case Domain of
+    dGround:
+      begin
+      inc(result, (50+(Speed-150)*13 shr 7) shl 8); //HeavyCost
+      if RO.Wonder[woShinkansen].EffectiveOwner<>me then
+        inc(result, Speed*(4*1311) shr 17); // RailCost
+      if (RO.Wonder[woGardens].EffectiveOwner<>me)
+        or (Kind=mkSettler) and (Speed>=200) then
+        inc(result, msHostile);
+      if Kind=mkDiplomat then
+        inc(result,msSpy)
+      else if Cap[mcOver]>0 then
+        inc(result,msOver)
+      else if Cap[mcAlpine]>0 then
+        inc(result,msAlpine)
+      else inc(result,msGround);
+      end;
+    dSea:
+      begin
+      result:=Speed;
+      if RO.Wonder[woMagellan].EffectiveOwner=me then inc(result,200);
+      if Health<100 then result:=((result-250)*Health div 5000)*50+250;
+      result:=result shl 16;
+      inc(result,msNoGround);
+      if Cap[mcNav]>0 then inc(result);
+      end;
+    dAir:
+      inc(result,msNoGround+fUNKNOWN xor 1 -1);
     end;
   end
@@ -625 +618 @@
 
 function TToolAI.CheckStep(MoveStyle, TimeBeforeStep, CrossCorner: integer;
-  var TimeAfterStep, RecoverTurns: integer; FromTile, ToTile: integer): integer;
-var
-  MoveCost, RecoverCost: integer;
-begin
-  assert(((FromTile and fTerrain <= fMountains) or
-    (FromTile and fTerrain = fUNKNOWN)) and ((ToTile and fTerrain <= fMountains)
-    or (ToTile and fTerrain = fUNKNOWN)));
+  var TimeAfterStep, RecoverTurns: integer; FromTile, ToTile: integer; IsCapture: boolean): integer;
+var
+MoveCost,RecoverCost: integer;
+begin
+//IsCapture:=true;
+assert(((FromTile and fTerrain<=fMountains) or (FromTile and fTerrain=fUNKNOWN))
+  and ((ToTile and fTerrain<=fMountains) or (ToTile and fTerrain=fUNKNOWN)));
   // do not pass location codes for FromTile and ToTile!
-  RecoverTurns := 0;
-  if MoveStyle < msGround + $10000000 then
+RecoverTurns:=0;
+if MoveStyle<msGround+$10000000 then
   begin // common ground units
-    if (ToTile + 1) and fTerrain < fGrass + 1 then
-      result := csForbiddenTile
-    else if (ToTile and not FromTile and fPeace = 0) and
-      (ToTile and (fUnit or fOwned) <> fUnit) then
-      if (FromTile and fCity <> 0) or (ToTile and (fCity or fOwned) = fCity or
-        fOwned) or (ToTile and FromTile and (fInEnemyZoC or fOwnZoCUnit) <>
-        fInEnemyZoC) then
+  if (ToTile+1) and fTerrain<fGrass+1 then
+    result:=csForbiddenTile
+  else if (ToTile and not FromTile and fPeace=0)
+    and (ToTile and (fUnit or fOwned)<>fUnit)
+    and (IsCapture or (ToTile and (fCity or fOwned)<>fCity)) then
+    if (FromTile and fCity<>0) or (ToTile and (fCity or fOwned)=fCity or fOwned)
+      or (ToTile and FromTile and (fInEnemyZoc or fOwnZoCUnit)<>fInEnemyZoc) then
       begin // ZoC is ok
-        if (ToTile and (fRR or fCity) = 0) or (FromTile and (fRR or fCity) = 0)
-        then
+      if (ToTile and (fRR or fCity)=0) or (FromTile and (fRR or fCity)=0) then
         begin // no railroad
-          if (ToTile and (fRoad or fRR or fCity) <> 0) and
-            (FromTile and (fRoad or fRR or fCity) <> 0) or
-            (FromTile and ToTile and (fRiver or fCanal) <> 0) then
-            MoveCost := 20 // move along road, river or canal
-          else
+        if (ToTile and (fRoad or fRR or fCity)<>0)
+          and (FromTile and (fRoad or fRR or fCity)<>0)
+          or (FromTile and ToTile and (fRiver or fCanal)<>0) then
+          MoveCost:=20 //move along road, river or canal
+        else
           begin
-            case Terrain[ToTile and fTerrain].MoveCost of
-              1:
-                MoveCost := 50; // plain terrain
-              2:
-                MoveCost := MoveStyle shr 8 and $FF; // heavy terrain
+          case Terrain[ToTile and fTerrain].MoveCost of
+            1: MoveCost:=50; // plain terrain
+            2: MoveCost:=MoveStyle shr 8 and $FF; // heavy terrain
             else // mountains
               begin
-                if TimeBeforeStep and $FFF + MoveStyle shr 16 and $7FF <= $800
-                then
-                  TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800
-                else
-                  TimeAfterStep := TimeBeforeStep and $7FFFF000 + $2800;
-                // must wait for next turn
-                if (MoveStyle and msHostile <> 0) and
-                  ((FromTile and (fTerrain or fSpecial1) = fDesert) or
-                  (FromTile and fTerrain = fArctic)) and
-                  (FromTile and (fCity or fRiver or fCanal) = 0) then
+              if TimeBeforeStep and $FFF+MoveStyle shr 16 and $7FF<=$800 then
+                TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800
+              else TimeAfterStep:=TimeBeforeStep and $7FFFF000+$2800; // must wait for next turn
+              if (MoveStyle and msHostile<>0)
+                and ((FromTile and (fTerrain or fSpecial1)=fDesert)
+                  or (FromTile and fTerrain=fArctic))
+                and (FromTile and (fCity or fRiver or fCanal)=0) then
                 begin
-                  RecoverCost := ($800 - TimeBeforeStep and $FFF) * 5 shr 1;
-                  while RecoverCost > 0 do
+                RecoverCost:=($800-TimeBeforeStep and $FFF)*5 shr 1;
+                while RecoverCost>0 do
                   begin
-                    inc(RecoverTurns);
-                    dec(RecoverCost, MoveStyle shr 16 and $7FF);
+                  inc(RecoverTurns);
+                  dec(RecoverCost, MoveStyle shr 16 and $7FF);
                   end;
-                end;
-                result := csOk;
-                if ToTile and fPeace <> 0 then
-                  result := csCheckTerritory;
-                exit
+                end;  
+              result:=csOk;
+              if ToTile and fPeace<>0 then
+                result:=csCheckTerritory;
+              exit
               end;
             end
           end
         end
-        else
-          MoveCost := MoveStyle and $FF; // move along railroad
-
-        inc(MoveCost, MoveCost shl CrossCorner);
-        if (MoveStyle and msHostile = 0) or
-          (ToTile and (fTerrain or fSpecial1) <> fDesert) and
-          (ToTile and fTerrain <> fArctic) or
-          (ToTile and (fCity or fRiver or fCanal) <> 0) then
-          RecoverCost := 0
-        else
-          RecoverCost := (MoveCost * 5) shr 1;
-        // damage from movement: MoveCost*DesertThurst/NoCityRecovery
-        if (TimeBeforeStep and $FFF + MoveCost <= $800) and
-          (TimeBeforeStep and $FFF < $800) then
-          TimeAfterStep := TimeBeforeStep + MoveCost
-        else
+      else MoveCost:=MoveStyle and $FF; //move along railroad
+
+      inc(MoveCost,MoveCost shl CrossCorner);
+      if (MoveStyle and msHostile=0)
+        or (ToTile and (fTerrain or fSpecial1)<>fDesert)
+          and (ToTile and fTerrain<>fArctic)
+        or (ToTile and (fCity or fRiver or fCanal)<>0)
+        or (ToTile and fTerImp=tiBase) then
+        RecoverCost:=0
+      else RecoverCost:=(MoveCost*5) shr 1; // damage from movement: MoveCost*DesertThurst/NoCityRecovery
+      if (TimeBeforeStep and $FFF+MoveCost<=$800) and (TimeBeforeStep and $FFF<$800) then
+        TimeAfterStep:=TimeBeforeStep+MoveCost
+      else
         begin
-          TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800 -
-            MoveStyle shr 16 and $7FF + MoveCost; // must wait for next turn
-          if (MoveStyle and msHostile <> 0) and
-            ((FromTile and (fTerrain or fSpecial1) = fDesert) or
-            (FromTile and fTerrain = fArctic)) and
-            (FromTile and (fCity or fRiver or fCanal) = 0) then
-            inc(RecoverCost, ($800 - TimeBeforeStep and $FFF) * 5 shr 1);
+        TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800-MoveStyle shr 16 and $7FF+MoveCost; // must wait for next turn
+        if (MoveStyle and msHostile<>0)
+          and ((FromTile and (fTerrain or fSpecial1)=fDesert)
+            or (FromTile and fTerrain=fArctic))
+          and (FromTile and (fCity or fRiver or fCanal)=0)
+          and (FromTile and fTerImp<>tiBase) then
+          inc(RecoverCost, ($800-TimeBeforeStep and $FFF)*5 shr 1);
         end;
-        while RecoverCost > 0 do
+      while RecoverCost>0 do
         begin
-          inc(RecoverTurns);
-          dec(RecoverCost, MoveStyle shr 16 and $7FF);
+        inc(RecoverTurns);
+        dec(RecoverCost, MoveStyle shr 16 and $7FF);
         end;
-        result := csOk;
-        if ToTile and fPeace <> 0 then
-          result := csCheckTerritory
+      result:=csOk;
+      if ToTile and fPeace<>0 then
+        result:=csCheckTerritory
       end
-      else
-        result := csForbiddenStep // ZoC violation
-    else
-      result := csForbiddenTile
+    else result:=csForbiddenStep // ZoC violation
+  else result:=csForbiddenTile
   end
 
-  else if MoveStyle < msNoGround + $10000000 then
+else if MoveStyle<msNoGround+$10000000 then
   begin // ships and aircraft
-    if ((ToTile and fTerrain xor 1 > MoveStyle and fTerrain) and
-      (ToTile and (fCity or fCanal) = 0)) or
-      (ToTile and not FromTile and fPeace <> 0) or
-      (ToTile and (fUnit or fOwned) = fUnit) then
-      result := csForbiddenTile
-    else
-    begin
-      MoveCost := 50 shl CrossCorner + 50;
-      if TimeBeforeStep and $FFF + MoveCost <= $800 then
-        TimeAfterStep := TimeBeforeStep + MoveCost
-      else
-        TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800 -
-          MoveStyle shr 16 and $7FF + MoveCost; // must wait for next turn
-      result := csOk;
-      if ToTile and fPeace <> 0 then
-        result := csCheckTerritory
+  if ((ToTile and fTerrain xor 1>MoveStyle and fTerrain)
+      and (ToTile and (fCity or fCanal)=0))
+    or (ToTile and not FromTile and fPeace<>0)
+    or (ToTile and (fUnit or fOwned)=fUnit)
+    or (ToTile and (fCity or fOwned)=fCity) then
+    result:=csForbiddenTile
+  else
+    begin
+    MoveCost:=50 shl CrossCorner+50;
+    if TimeBeforeStep and $FFF+MoveCost<=$800 then
+      TimeAfterStep:=TimeBeforeStep+MoveCost
+    else TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800-MoveStyle shr 16 and $7FF+MoveCost; // must wait for next turn
+    result:=csOk;
+    if ToTile and fPeace<>0 then
+      result:=csCheckTerritory
     end
   end
 
-  else if MoveStyle < msAlpine + $10000000 then
+else if MoveStyle<msAlpine+$10000000 then
   begin // alpine
-    if (ToTile + 1) and fTerrain < fGrass + 1 then
-      result := csForbiddenTile
-    else if (ToTile and not FromTile and fPeace = 0) and
-      (ToTile and (fUnit or fOwned) <> fUnit) then
-      if (FromTile and fCity <> 0) or (ToTile and (fCity or fOwned) = fCity or
-        fOwned) or (ToTile and FromTile and (fInEnemyZoC or fOwnZoCUnit) <>
-        fInEnemyZoC) then
-      begin
-        if (ToTile and (fRR or fCity) = 0) or (FromTile and (fRR or fCity) = 0)
-        then
-          MoveCost := 20 // no railroad
-        else
-          MoveCost := MoveStyle and $FF; // move along railroad
-        inc(MoveCost, MoveCost shl CrossCorner);
-        if (TimeBeforeStep and $FFF + MoveCost <= $800) and
-          (TimeBeforeStep and $FFF < $800) then
-          TimeAfterStep := TimeBeforeStep + MoveCost
-        else
-          TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800 -
-            MoveStyle shr 16 and $7FF + MoveCost; // must wait for next turn
-        result := csOk;
-        if ToTile and fPeace <> 0 then
-          result := csCheckTerritory
+  if (ToTile+1) and fTerrain<fGrass+1 then
+    result:=csForbiddenTile
+  else if (ToTile and not FromTile and fPeace=0)
+    and (ToTile and (fUnit or fOwned)<>fUnit)
+    and (IsCapture or (ToTile and (fCity or fOwned)<>fCity)) then
+    if (FromTile and fCity<>0) or (ToTile and (fCity or fOwned)=fCity or fOwned)
+      or (ToTile and FromTile and (fInEnemyZoc or fOwnZoCUnit)<>fInEnemyZoc) then
+      begin
+      if (ToTile and (fRR or fCity)=0) or (FromTile and (fRR or fCity)=0) then
+        MoveCost:=20 // no railroad
+      else MoveCost:=MoveStyle and $FF; //move along railroad
+      inc(MoveCost,MoveCost shl CrossCorner);
+      if (TimeBeforeStep and $FFF+MoveCost<=$800) and (TimeBeforeStep and $FFF<$800) then
+        TimeAfterStep:=TimeBeforeStep+MoveCost
+      else TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800-MoveStyle shr 16 and $7FF+MoveCost; // must wait for next turn
+      result:=csOk;
+      if ToTile and fPeace<>0 then
+        result:=csCheckTerritory
       end
+    else result:=csForbiddenStep // ZoC violation
+  else result:=csForbiddenTile
+  end
+
+else if MoveStyle<msOver+$10000000 then
+  begin // overweight
+  if (ToTile+1) and fTerrain<fGrass+1 then
+    result:=csForbiddenTile
+  else if (ToTile and not FromTile and fPeace=0)
+    and (ToTile and (fUnit or fOwned)<>fUnit)
+    and (IsCapture or (ToTile and (fCity or fOwned)<>fCity)) then
+    if (FromTile and fCity<>0) or (ToTile and (fCity or fOwned)=fCity or fOwned)
+      or (ToTile and FromTile and (fInEnemyZoc or fOwnZoCUnit)<>fInEnemyZoc) then
+      begin
+      if (ToTile and (fRR or fCity)=0) or (FromTile and (fRR or fCity)=0) then
+        begin // no railroad
+        if (ToTile and (fRoad or fRR or fCity)<>0)
+          and (FromTile and (fRoad or fRR or fCity)<>0)
+          or (FromTile and ToTile and (fRiver or fCanal)<>0) then
+          MoveCost:=40 //move along road, river or canal
+        else begin result:=csForbiddenTile; exit end
+        end
+      else MoveCost:=MoveStyle and $FF; //move along railroad
+      inc(MoveCost,MoveCost shl CrossCorner);
+      if (TimeBeforeStep and $FFF+MoveCost<=$800) and (TimeBeforeStep and $FFF<$800) then
+        TimeAfterStep:=TimeBeforeStep+MoveCost
+      else TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800-MoveStyle shr 16 and $7FF+MoveCost; // must wait for next turn
+      result:=csOk;
+      if ToTile and fPeace<>0 then
+        result:=csCheckTerritory
+      end
+    else result:=csForbiddenStep // ZoC violation
+  else result:=csForbiddenTile
+  end
+
+else {if MoveStyle<msSpy+$10000000 then}
+  begin // spies
+  if (ToTile+1) and fTerrain<fGrass+1 then
+    result:=csForbiddenTile
+  else if (ToTile and (fUnit or fOwned)<>fUnit)
+    and (IsCapture or (ToTile and (fCity or fOwned)<>fCity)) then
+    begin
+    if (ToTile and (fRR or fCity)=0) or (FromTile and (fRR or fCity)=0) then
+      begin // no railroad
+      if (ToTile and (fRoad or fRR or fCity)<>0)
+        and (FromTile and (fRoad or fRR or fCity)<>0)
+        or (FromTile and ToTile and (fRiver or fCanal)<>0) then
+        MoveCost:=20 //move along road, river or canal
       else
-        result := csForbiddenStep // ZoC violation
-    else
-      result := csForbiddenTile
-  end
-
-  else if MoveStyle < msOver + $10000000 then
-  begin // overweight
-    if (ToTile + 1) and fTerrain < fGrass + 1 then
-      result := csForbiddenTile
-    else if (ToTile and not FromTile and fPeace = 0) and
-      (ToTile and (fUnit or fOwned) <> fUnit) then
-      if (FromTile and fCity <> 0) or (ToTile and (fCity or fOwned) = fCity or
-        fOwned) or (ToTile and FromTile and (fInEnemyZoC or fOwnZoCUnit) <>
-        fInEnemyZoC) then
-      begin
-        if (ToTile and (fRR or fCity) = 0) or (FromTile and (fRR or fCity) = 0)
-        then
-        begin // no railroad
-          if (ToTile and (fRoad or fRR or fCity) <> 0) and
-            (FromTile and (fRoad or fRR or fCity) <> 0) or
-            (FromTile and ToTile and (fRiver or fCanal) <> 0) then
-            MoveCost := 40 // move along road, river or canal
-          else
-          begin
-            result := csForbiddenTile;
-            exit
-          end
-        end
-        else
-          MoveCost := MoveStyle and $FF; // move along railroad
-        inc(MoveCost, MoveCost shl CrossCorner);
-        if (TimeBeforeStep and $FFF + MoveCost <= $800) and
-          (TimeBeforeStep and $FFF < $800) then
-          TimeAfterStep := TimeBeforeStep + MoveCost
-        else
-          TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800 -
-            MoveStyle shr 16 and $7FF + MoveCost; // must wait for next turn
-        result := csOk;
-        if ToTile and fPeace <> 0 then
-          result := csCheckTerritory
-      end
-      else
-        result := csForbiddenStep // ZoC violation
-    else
-      result := csForbiddenTile
-  end
-
-  else { if MoveStyle<msSpy+$10000000 then }
-  begin // spies
-    if (ToTile + 1) and fTerrain < fGrass + 1 then
-      result := csForbiddenTile
-    else if ToTile and (fUnit or fOwned) <> fUnit then
-    begin
-      if (ToTile and (fRR or fCity) = 0) or (FromTile and (fRR or fCity) = 0)
-      then
-      begin // no railroad
-        if (ToTile and (fRoad or fRR or fCity) <> 0) and
-          (FromTile and (fRoad or fRR or fCity) <> 0) or
-          (FromTile and ToTile and (fRiver or fCanal) <> 0) then
-          MoveCost := 20 // move along road, river or canal
-        else
         begin
-          case Terrain[ToTile and fTerrain].MoveCost of
-            1:
-              MoveCost := 50; // plain terrain
-            2:
-              MoveCost := MoveStyle shr 8 and $FF; // heavy terrain
+        case Terrain[ToTile and fTerrain].MoveCost of
+          1: MoveCost:=50; // plain terrain
+          2: MoveCost:=MoveStyle shr 8 and $FF; // heavy terrain
           else // mountains
             begin
-              if TimeBeforeStep and $FFF + MoveStyle shr 16 and $7FF <= $800
-              then
-                TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800
-              else
-                TimeAfterStep := TimeBeforeStep and $7FFFF000 + $2800;
-              // must wait for next turn
-              result := csOk;
-              exit
+            if TimeBeforeStep and $FFF+MoveStyle shr 16 and $7FF<=$800 then
+              TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800
+            else TimeAfterStep:=TimeBeforeStep and $7FFFF000+$2800; // must wait for next turn
+            result:=csOk;
+            exit
             end;
           end
         end
       end
-      else
-        MoveCost := MoveStyle and $FF; // move along railroad
-      inc(MoveCost, MoveCost shl CrossCorner);
-      if (TimeBeforeStep and $FFF + MoveCost <= $800) and
-        (TimeBeforeStep and $FFF < $800) then
-        TimeAfterStep := TimeBeforeStep + MoveCost
-      else
-        TimeAfterStep := TimeBeforeStep and $7FFFF000 + $1800 -
-          MoveStyle shr 16 and $7FF + MoveCost; // must wait for next turn
-      result := csOk;
+    else MoveCost:=MoveStyle and $FF; //move along railroad
+    inc(MoveCost,MoveCost shl CrossCorner);
+    if (TimeBeforeStep and $FFF+MoveCost<=$800) and (TimeBeforeStep and $FFF<$800) then
+      TimeAfterStep:=TimeBeforeStep+MoveCost
+    else TimeAfterStep:=TimeBeforeStep and $7FFFF000+$1800-MoveStyle shr 16 and $7FF+MoveCost; // must wait for next turn
+    result:=csOk;
     end
-    else
-      result := csForbiddenTile
+  else result:=csForbiddenTile
   end;
 end; // CheckStep
 
 (*
-  -------- Pathfinding Reference Implementation --------
-  var
-  MoveStyle,V8,Loc,Time,NextLoc,NextTime,RecoverTurns: integer;
-  Adjacent: TVicinity8Loc;
-  Reached: array[0..lxmax*lymax-1] of boolean;
-  begin
-  fillchar(Reached, MapSize, false);
-  MoveStyle:=GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
-  Pile.Create(MapSize);
-  Pile.Put(MyUnit[uix].Loc, $800-MyUnit[uix].Movement);
-  while Pile.Get(Loc, Time) do
+-------- Pathfinding Reference Implementation --------
+var
+MoveStyle,V8,Loc,Time,NextLoc,NextTime,RecoverTurns: integer;
+Adjacent: TVicinity8Loc;
+Reached: array[0..lxmax*lymax-1] of boolean;
+begin
+fillchar(Reached, MapSize, false);
+MoveStyle:=GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
+Pile.Create(MapSize);
+Pile.Put(MyUnit[uix].Loc, $800-MyUnit[uix].Movement);
+while Pile.Get(Loc, Time) do
   begin
   // todo: check exit condition, e.g. whether destination reached
@@ -889 +842 @@
   V8_to_Loc(Loc, Adjacent);
   for V8:=0 to 7 do
-  begin
-  NextLoc:=Adjacent[V8];
-  if (NextLoc>=0) and not Reached[NextLoc] then
-  case CheckStep(MoveStyle, Time, V8 and 1, NextTime, RecoverTurns, Map[Loc], Map[NextLoc]) of
-  csOk:
-  Pile.Put(NextLoc, NextTime+RecoverTurns*$1000);
-  csForbiddenTile:
-  Reached[NextLoc]:=true; // don't check moving there again
-  csCheckTerritory:
-  if RO.Territory[NextLoc]=RO.Territory[Loc] then
-  Pile.Put(NextLoc, NextTime+RecoverTurns*$1000);
+    begin
+    NextLoc:=Adjacent[V8];
+    if (NextLoc>=0) and not Reached[NextLoc] then
+      case CheckStep(MoveStyle, Time, V8 and 1, NextTime, RecoverTurns, Map[Loc], Map[NextLoc]) of
+        csOk:
+          Pile.Put(NextLoc, NextTime+RecoverTurns*$1000);
+        csForbiddenTile:
+          Reached[NextLoc]:=true; // don't check moving there again
+        csCheckTerritory:
+          if RO.Territory[NextLoc]=RO.Territory[Loc] then
+            Pile.Put(NextLoc, NextTime+RecoverTurns*$1000);
+        end
+    end;
+  end;
+Pile.Free;
+end;
+*)
+
+function TToolAI.Unit_MoveEx(uix,ToLoc: integer; Options: integer): integer;
+var
+Loc,NextLoc,Temp,FromLoc,EndLoc,Time,V8,MoveResult,RecoverTurns,NextTime,
+  MoveStyle: integer;
+Adjacent: TVicinity8Loc;
+PreLoc: array[0..lxmax*lymax-1] of integer;
+Reached: array[0..lxmax*lymax-1] of boolean;
+begin
+result:=eOk;
+FromLoc:=MyUnit[uix].Loc;
+if FromLoc=ToLoc then exit;
+
+FillChar(Reached,MapSize,false);
+MoveStyle:=GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
+EndLoc:=-1;
+Pile.Create(MapSize);
+Pile.Put(FromLoc, $800-MyUnit[uix].Movement);
+while Pile.Get(Loc,Time) do
+  begin
+  if (Loc=ToLoc)
+    or (ToLoc=maNextCity) and (Map[Loc] and fCity<>0)
+    and (Map[Loc] and fOwned<>0) then
+    begin EndLoc:=Loc; Break; end;
+  Reached[Loc]:=true;
+  V8_to_Loc(Loc,Adjacent);
+  for V8:=0 to 7 do
+    begin
+    NextLoc:=Adjacent[V8];
+    if NextLoc>=0 then
+      if (NextLoc=ToLoc) and (Options and mxAdjacent<>0) then
+        begin EndLoc:=Loc; Break end
+      else if not Reached[NextLoc] then
+        begin
+        case CheckStep(MoveStyle, Time, V8 and 1, NextTime, RecoverTurns,
+          Map[Loc], Map[NextLoc], NextLoc=ToLoc) of
+          csOk:
+            if Pile.Put(NextLoc, NextTime+RecoverTurns*$1000) then
+              PreLoc[NextLoc]:=Loc;
+          csForbiddenTile:
+            Reached[NextLoc]:=true; // don't check moving there again
+          csCheckTerritory:
+            if RO.Territory[NextLoc]=RO.Territory[Loc] then
+              if Pile.Put(NextLoc, NextTime+RecoverTurns*$1000) then
+                PreLoc[NextLoc]:=Loc;
+          end
+        end
+    end;
+  if EndLoc>=0 then Break;
+  end;
+Pile.Free;
+
+if EndLoc>=0 then
+  begin
+  Loc:=EndLoc;
+  NextLoc:=PreLoc[Loc];
+  while Loc<>FromLoc do
+    begin // invert meaning of PreLoc
+    Temp:=Loc;
+    Loc:=NextLoc;
+    NextLoc:=PreLoc[Loc];
+    PreLoc[Loc]:=Temp;
+    end;
+  while Loc<>EndLoc do
+    begin
+    Loc:=PreLoc[Loc];
+    MoveResult:=Unit_Step(uix, Loc);
+    if (MoveResult<>eOK) and (MoveResult<>eLoaded) then
+      begin result:=MoveResult; break end;
+    end;
   end
-  end;
-  end;
-  Pile.Free;
-  end;
-*)
-
-function TToolAI.Unit_MoveEx(uix, ToLoc: integer; Options: integer): integer;
-var
-  Loc, NextLoc, Temp, FromLoc, EndLoc, Time, V8, MoveResult, RecoverTurns,
-    NextTime, MoveStyle: integer;
-  Adjacent: TVicinity8Loc;
-  PreLoc: array [0 .. lxmax * lymax - 1] of integer;
-  Reached: array [0 .. lxmax * lymax - 1] of boolean;
-begin
-  result := eOk;
-  FromLoc := MyUnit[uix].Loc;
-  if FromLoc = ToLoc then
-    exit;
-
-  fillchar(Reached, MapSize, false);
-  MoveStyle := GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
-  EndLoc := -1;
-  Pile.Create(MapSize);
-  Pile.Put(FromLoc, $800 - MyUnit[uix].Movement);
-  while Pile.Get(Loc, Time) do
-  begin
-    if (Loc = ToLoc) or (ToLoc = maNextCity) and (Map[Loc] and fCity <> 0) and
-      (Map[Loc] and fOwned <> 0) then
-    begin
-      EndLoc := Loc;
-      Break;
-    end;
-    Reached[Loc] := true;
-    V8_to_Loc(Loc, Adjacent);
-    for V8 := 0 to 7 do
-    begin
-      NextLoc := Adjacent[V8];
-      if NextLoc >= 0 then
-        if (NextLoc = ToLoc) and (Options and mxAdjacent <> 0) then
+else result:=eNoWay;
+end;
+
+
+//------------------------------------------------------------------------------
+// Oversea Transport
+
+procedure TToolAI.SeaTransport_BeginInitialize;
+begin
+fillchar(TransportAvailable, RO.nUn*sizeof(integer), $FF); // -1
+InitComplete:=false;
+HaveDestinations:=false;
+nTransportLoad:=0;
+TransportMoveStyle:=0;
+TransportCapacity:=$100;
+Pile.Create(MapSize);
+end;
+
+procedure TToolAI.SeaTransport_AddLoad(uix: integer);
+var
+i: integer;
+begin
+assert(not InitComplete); // call order violation!
+if Map[MyUnit[uix].Loc] and fTerrain<fGrass then exit;
+for i:=0 to nTransportLoad-1 do
+  if uix=uixTransportLoad[i] then exit;
+uixTransportLoad[nTransportLoad]:=uix;
+inc(nTransportLoad);
+end;
+
+procedure TToolAI.SeaTransport_AddTransport(uix: integer);
+var
+MoveStyle: integer;
+begin
+assert(not InitComplete); // call order violation!
+assert(MyModel[MyUnit[uix].mix].Cap[mcSeaTrans]>0);
+TransportAvailable[uix]:=1;
+with MyModel[MyUnit[uix].mix] do
+  begin
+  if MTrans*Cap[mcSeaTrans]<TransportCapacity then
+    TransportCapacity:=MTrans*Cap[mcSeaTrans];
+  MoveStyle:=GetMyMoveStyle(MyUnit[uix].mix, 100);
+  if (TransportMoveStyle=0)
+    or (MoveStyle<TransportMoveStyle)
+      and (MoveStyle and not TransportMoveStyle and 1=0)
+    or (not MoveStyle and TransportMoveStyle and 1<>0) then
+    TransportMoveStyle:=MoveStyle;
+  end
+end;
+
+procedure TToolAI.SeaTransport_AddDestination(Loc: integer);
+begin
+assert(not InitComplete); // call order violation!
+Pile.Put(Loc, $800);
+HaveDestinations:=true;
+end;
+
+procedure TToolAI.SeaTransport_EndInitialize;
+var
+Loc0,Time0,V8,Loc1,ArriveTime,RecoverTurns: integer;
+Adjacent: TVicinity8Loc;
+begin
+assert(not InitComplete); // call order violation!
+InitComplete:=true;
+if HaveDestinations then
+  begin // calculate TurnsAfterLoad from destination locs
+  fillchar(TurnsAfterLoad, MapSize, $FF); // -1
+  while Pile.Get(Loc0, Time0) do
+    begin // search backward
+    if Time0=$800 then TurnsAfterLoad[Loc0]:=1
+    else TurnsAfterLoad[Loc0]:=Time0 shr 12;
+    V8_to_Loc(Loc0, Adjacent);
+    for V8:=0 to 7 do
+      begin
+      Loc1:=Adjacent[V8];
+      if (Loc1>=0) and (TurnsAfterLoad[Loc1]=-1) then
         begin
-          EndLoc := Loc;
-          Break
-        end
-        else if not Reached[NextLoc] then
-          case CheckStep(MoveStyle, Time, V8 and 1, NextTime, RecoverTurns,
-            Map[Loc], Map[NextLoc]) of
-            csOk:
-              if Pile.Put(NextLoc, NextTime + RecoverTurns * $1000) then
-                PreLoc[NextLoc] := Loc;
-            csForbiddenTile:
-              Reached[NextLoc] := true; // don't check moving there again
-            csCheckTerritory:
-              if RO.Territory[NextLoc] = RO.Territory[Loc] then
-                if Pile.Put(NextLoc, NextTime + RecoverTurns * $1000) then
-                  PreLoc[NextLoc] := Loc;
-          end
-    end;
-    if EndLoc >= 0 then
-      Break;
-  end;
-  Pile.Free;
-
-  if EndLoc >= 0 then
-  begin
-    Loc := EndLoc;
-    NextLoc := PreLoc[Loc];
-    while Loc <> FromLoc do
-    begin // invert meaning of PreLoc
-      Temp := Loc;
-      Loc := NextLoc;
-      NextLoc := PreLoc[Loc];
-      PreLoc[Loc] := Temp;
-    end;
-    while Loc <> EndLoc do
-    begin
-      Loc := PreLoc[Loc];
-      MoveResult := Unit_Step(uix, Loc);
-      if (MoveResult <> eOk) and (MoveResult <> eLoaded) then
-      begin
-        result := MoveResult;
-        Break
-      end;
-    end;
-  end
-  else
-    result := eNoWay;
-end;
-
-
-// ------------------------------------------------------------------------------
-// Oversea Transport
-
-procedure TToolAI.SeaTransport_BeginInitialize;
-begin
-  fillchar(TransportAvailable, RO.nUn * sizeof(integer), $FF); // -1
-  InitComplete := false;
-  HaveDestinations := false;
-  nTransportLoad := 0;
-  TransportMoveStyle := 0;
-  TransportCapacity := $100;
-  Pile.Create(MapSize);
-end;
-
-procedure TToolAI.SeaTransport_AddLoad(uix: integer);
-var
-  i: integer;
-begin
-  assert(not InitComplete); // call order violation!
-  if Map[MyUnit[uix].Loc] and fTerrain < fGrass then
-    exit;
-  for i := 0 to nTransportLoad - 1 do
-    if uix = uixTransportLoad[i] then
-      exit;
-  uixTransportLoad[nTransportLoad] := uix;
-  inc(nTransportLoad);
-end;
-
-procedure TToolAI.SeaTransport_AddTransport(uix: integer);
-var
-  MoveStyle: integer;
-begin
-  assert(not InitComplete); // call order violation!
-  assert(MyModel[MyUnit[uix].mix].Cap[mcSeaTrans] > 0);
-  TransportAvailable[uix] := 1;
-  with MyModel[MyUnit[uix].mix] do
-  begin
-    if MTrans * Cap[mcSeaTrans] < TransportCapacity then
-      TransportCapacity := MTrans * Cap[mcSeaTrans];
-    MoveStyle := GetMyMoveStyle(MyUnit[uix].mix, 100);
-    if (TransportMoveStyle = 0) or (MoveStyle < TransportMoveStyle) and
-      (MoveStyle and not TransportMoveStyle and 1 = 0) or
-      (not MoveStyle and TransportMoveStyle and 1 <> 0) then
-      TransportMoveStyle := MoveStyle;
-  end
-end;
-
-procedure TToolAI.SeaTransport_AddDestination(Loc: integer);
-begin
-  assert(not InitComplete); // call order violation!
-  Pile.Put(Loc, $800);
-  HaveDestinations := true;
-end;
-
-procedure TToolAI.SeaTransport_EndInitialize;
-var
-  Loc0, Time0, V8, Loc1, ArriveTime, RecoverTurns: integer;
-  Adjacent: TVicinity8Loc;
-begin
-  assert(not InitComplete); // call order violation!
-  InitComplete := true;
-  if HaveDestinations then
-  begin // calculate TurnsAfterLoad from destination locs
-    fillchar(TurnsAfterLoad, MapSize, $FF); // -1
-    while Pile.Get(Loc0, Time0) do
-    begin // search backward
-      if Time0 = $800 then
-        TurnsAfterLoad[Loc0] := 1
-      else
-        TurnsAfterLoad[Loc0] := Time0 shr 12;
-      V8_to_Loc(Loc0, Adjacent);
-      for V8 := 0 to 7 do
-      begin
-        Loc1 := Adjacent[V8];
-        if (Loc1 >= 0) and (TurnsAfterLoad[Loc1] = -1) then
-        begin
-          case CheckStep(TransportMoveStyle, Time0, V8 and 1, ArriveTime,
-            RecoverTurns, Map[Loc0], Map[Loc1]) of
-            csOk:
-              Pile.Put(Loc1, ArriveTime);
-            csForbiddenStep:
-              TurnsAfterLoad[Loc1] := -2;
+        case CheckStep(TransportMoveStyle, Time0, V8 and 1, ArriveTime,
+          RecoverTurns, Map[Loc0], Map[Loc1], false) of
+          csOk: Pile.Put(Loc1, ArriveTime);
+          csForbiddenStep: TurnsAfterLoad[Loc1]:=-2;
           end;
         end
@@ -1077 +1016 @@
     end;
   end;
-  Pile.Free;
-end;
-
-function TToolAI.SeaTransport_MakeGroupPlan(var TransportPlan
-  : TGroupTransportPlan): boolean;
-var
-  V8, i, j, iPicked, uix, Loc0, Time0, Loc1, RecoverTurns, MoveStyle,
-    TurnsLoaded, TurnCount, tuix, tuix1, ArriveTime, TotalDelay, BestTotalDelay,
-    GroupCount, BestGroupCount, BestLoadLoc, FullMovementLoc, nSelectedLoad, f,
-    OriginContinent, a, b: integer;
-  CompleteFlag, NotReachedFlag, ContinueUnit: cardinal;
-  IsComplete, ok, IsFirstLoc: boolean;
-  StartLocPtr, ArrivedEnd: pinteger;
-  Adjacent: TVicinity8Loc;
-  uixSelectedLoad: array [0 .. 15] of integer;
-  tuixSelectedLoad: array [0 .. 15] of integer;
-  Arrived: array [0 .. lxmax * lymax] of cardinal;
-  ResponsibleTransport: array [0 .. lxmax * lymax - 1] of smallint;
-  TurnsBeforeLoad: array [0 .. lxmax * lymax - 1] of shortint;
-  GroupComplete: array [0 .. lxmax * lymax - 1] of boolean;
-begin
-  assert(InitComplete); // call order violation!
-
-  if HaveDestinations and (nTransportLoad > 0) then
+Pile.Free;
+end;
+
+
+function TToolAI.SeaTransport_MakeGroupPlan(var TransportPlan: TGroupTransportPlan): boolean;
+var
+V8,i,j,iPicked,uix,Loc0,Time0,Loc1,RecoverTurns,MoveStyle, TurnsLoaded,
+  TurnCount, tuix, tuix1, ArriveTime, TotalDelay, BestTotalDelay, GroupCount,
+  BestGroupCount, BestLoadLoc, FullMovementLoc, nSelectedLoad, f,
+  OriginContinent,a,b: integer;
+CompleteFlag, NotReachedFlag, ContinueUnit: Cardinal;
+IsComplete,ok,IsFirstLoc: boolean;
+StartLocPtr, ArrivedEnd: pinteger;
+Adjacent: TVicinity8Loc;
+uixSelectedLoad: array[0..15] of integer;
+tuixSelectedLoad: array[0..15] of integer;
+Arrived: array[0..lxmax*lymax] of cardinal;
+ResponsibleTransport: array[0..lxmax*lymax-1] of smallint;
+TurnsBeforeLoad: array[0..lxmax*lymax-1] of shortint;
+GroupComplete: array[0..lxmax*lymax-1] of boolean;
+begin
+assert(InitComplete); // call order violation!
+
+if HaveDestinations and (nTransportLoad>0) then
   begin // transport and units already adjacent?
-    for uix := 0 to RO.nUn - 1 do
-      if (TransportAvailable[uix] > 0) and
-        (Map[MyUnit[uix].Loc] and fTerrain = fShore) then
-      begin
-        GroupCount := 0;
-        for tuix := 0 to nTransportLoad - 1 do
+  for uix:=0 to RO.nUn-1 do
+    if (TransportAvailable[uix]>0)
+      and (Map[MyUnit[uix].Loc] and fTerrain=fShore) then
+      begin
+      GroupCount:=0;
+      for tuix:=0 to nTransportLoad-1 do
         begin
-          Loc_to_ab(MyUnit[uix].Loc, MyUnit[uixTransportLoad[tuix]].Loc, a, b);
-          if (abs(a) <= 1) and (abs(b) <= 1) then
+        Loc_to_ab(MyUnit[uix].Loc, MyUnit[uixTransportLoad[tuix]].Loc, a, b);
+        if (abs(a)<=1) and (abs(b)<=1) then
           begin
-            assert((a <> 0) or (b <> 0));
-            inc(GroupCount);
+          assert((a<>0) or (b<>0));
+          inc(GroupCount);
           end
         end;
-        if (GroupCount = nTransportLoad) or (GroupCount >= TransportCapacity)
-        then
+      if (GroupCount=nTransportLoad) or (GroupCount>=TransportCapacity) then
         begin
-          TransportPlan.LoadLoc := MyUnit[uix].Loc;
-          TransportPlan.uixTransport := uix;
-          TransportAvailable[uix] := 0;
-          TransportPlan.TurnsEmpty := 0;
-          TransportPlan.TurnsLoaded := TurnsAfterLoad[TransportPlan.LoadLoc];
-          TransportPlan.nLoad := 0;
-          for tuix := nTransportLoad - 1 downto 0 do
+        TransportPlan.LoadLoc:=MyUnit[uix].Loc;
+        TransportPlan.uixTransport:=uix;
+        TransportAvailable[uix]:=0;
+        TransportPlan.TurnsEmpty:=0;
+        TransportPlan.TurnsLoaded:=TurnsAfterLoad[TransportPlan.LoadLoc];
+        TransportPlan.nLoad:=0;
+        for tuix:=nTransportLoad-1 downto 0 do
           begin
-            Loc_to_ab(TransportPlan.LoadLoc, MyUnit[uixTransportLoad[tuix]]
-              .Loc, a, b);
-            if (abs(a) <= 1) and (abs(b) <= 1) then
+          Loc_to_ab(TransportPlan.LoadLoc, MyUnit[uixTransportLoad[tuix]].Loc, a, b);
+          if (abs(a)<=1) and (abs(b)<=1) then
             begin
-              TransportPlan.uixLoad[TransportPlan.nLoad] :=
-                uixTransportLoad[tuix];
-              uixTransportLoad[tuix] := uixTransportLoad[nTransportLoad - 1];
-              dec(nTransportLoad);
-              inc(TransportPlan.nLoad);
-              if TransportPlan.nLoad = TransportCapacity then
-                Break;
+            TransportPlan.uixLoad[TransportPlan.nLoad]:=uixTransportLoad[tuix];
+            uixTransportLoad[tuix]:=uixTransportLoad[nTransportLoad-1];
+            dec(nTransportLoad);
+            inc(TransportPlan.nLoad);
+            if TransportPlan.nLoad=TransportCapacity then break;
             end;
           end;
-          result := true;
-          exit;
+        result:=true;
+        exit;
         end
       end
   end;
 
-  while HaveDestinations and (nTransportLoad > 0) do
-  begin
-    // select units from same continent
-    fillchar(Arrived, 4 * nContinent, 0); // misuse Arrived as counter
-    for tuix := 0 to nTransportLoad - 1 do
-    begin
-      assert(Map[MyUnit[uixTransportLoad[tuix]].Loc] and fTerrain >= fGrass);
-      f := Formation[MyUnit[uixTransportLoad[tuix]].Loc];
-      if f >= 0 then
-        inc(Arrived[f]);
-    end;
-    OriginContinent := 0;
-    for f := 1 to nContinent - 1 do
-      if Arrived[f] > Arrived[OriginContinent] then
-        OriginContinent := f;
-    nSelectedLoad := 0;
-    for tuix := 0 to nTransportLoad - 1 do
-      if Formation[MyUnit[uixTransportLoad[tuix]].Loc] = OriginContinent then
-      begin
-        tuixSelectedLoad[nSelectedLoad] := tuix;
-        uixSelectedLoad[nSelectedLoad] := uixTransportLoad[tuix];
-        inc(nSelectedLoad);
-        if nSelectedLoad = 16 then
-          Break;
+while HaveDestinations and (nTransportLoad>0) do
+  begin
+  // select units from same continent
+  fillchar(Arrived, 4*nContinent, 0); // misuse Arrived as counter
+  for tuix:=0 to nTransportLoad-1 do
+    begin
+    assert(Map[MyUnit[uixTransportLoad[tuix]].Loc] and fTerrain>=fGrass);
+    f:=Formation[MyUnit[uixTransportLoad[tuix]].Loc];
+    if f>=0 then inc(Arrived[f]);
+    end;
+  OriginContinent:=0;
+  for f:=1 to nContinent-1 do
+    if Arrived[f]>Arrived[OriginContinent] then OriginContinent:=f;
+  nSelectedLoad:=0;
+  for tuix:=0 to nTransportLoad-1 do
+    if Formation[MyUnit[uixTransportLoad[tuix]].Loc]=OriginContinent then
+      begin
+      tuixSelectedLoad[nSelectedLoad]:=tuix;
+      uixSelectedLoad[nSelectedLoad]:=uixTransportLoad[tuix];
+      inc(nSelectedLoad);
+      if nSelectedLoad=16 then break;
       end;
 
-    Pile.Create(MapSize);
-    fillchar(ResponsibleTransport, MapSize * 2, $FF); // -1
-    fillchar(TurnsBeforeLoad, MapSize, $FF); // -1
-    ok := false;
-    for uix := 0 to RO.nUn - 1 do
-      if TransportAvailable[uix] > 0 then
-      begin
-        ok := true;
-        Pile.Put(MyUnit[uix].Loc, ($800 - MyUnit[uix].Movement) shl 12 + uix);
-      end;
-    if not ok then // no transports
-    begin
-      TransportPlan.LoadLoc := -1;
-      result := false;
-      Pile.Free;
-      exit
-    end;
-    while Pile.Get(Loc0, Time0) do
-    begin
-      uix := Time0 and $FFF;
-      Time0 := Time0 shr 12;
-      ResponsibleTransport[Loc0] := uix;
-      TurnsBeforeLoad[Loc0] := Time0 shr 12;
-      V8_to_Loc(Loc0, Adjacent);
-      for V8 := 0 to 7 do
-      begin
-        Loc1 := Adjacent[V8];
-        if (Loc1 >= 0) and (ResponsibleTransport[Loc1] < 0) then
-          case CheckStep(GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health),
-            Time0, V8 and 1, ArriveTime, RecoverTurns, Map[Loc0], Map[Loc1]) of
-            csOk:
-              Pile.Put(Loc1, ArriveTime shl 12 + uix);
-            csForbiddenTile:
-              ResponsibleTransport[Loc1] := RO.nUn; // don't check again
+  Pile.Create(MapSize);
+  fillchar(ResponsibleTransport, MapSize*2, $FF); // -1
+  fillchar(TurnsBeforeLoad, MapSize, $FF); // -1
+  ok:=false;
+  for uix:=0 to RO.nUn-1 do if TransportAvailable[uix]>0 then
+    begin
+    ok:=true;
+    Pile.Put(MyUnit[uix].Loc, ($800-MyUnit[uix].Movement) shl 12 + uix);
+    end;
+  if not ok then // no transports
+    begin TransportPlan.LoadLoc:=-1; result:=false; Pile.Free; exit end;
+  while Pile.Get(Loc0, Time0) do
+    begin
+    uix:=Time0 and $FFF;
+    Time0:=Time0 shr 12;
+    ResponsibleTransport[Loc0]:=uix;
+    TurnsBeforeLoad[Loc0]:=Time0 shr 12;
+    V8_to_Loc(Loc0, Adjacent);
+    for V8:=0 to 7 do
+      begin
+      Loc1:=Adjacent[V8];
+      if (Loc1>=0) and (ResponsibleTransport[Loc1]<0) then
+        case CheckStep(GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health),
+          Time0, V8 and 1, ArriveTime, RecoverTurns, Map[Loc0], Map[Loc1], false) of
+          csOk: Pile.Put(Loc1, ArriveTime shl 12 + uix);
+          csForbiddenTile: ResponsibleTransport[Loc1]:=RO.nUn; // don't check again
           end
       end
     end;
 
-    fillchar(Arrived, MapSize * 4, $55); // set NotReachedFlag for all tiles
-    fillchar(GroupComplete, MapSize, false);
-    BestLoadLoc := -1;
-
-    // check direct loading
-    for tuix := 0 to nSelectedLoad - 1 do
-    begin
-      uix := uixSelectedLoad[tuix];
-      if MyUnit[uix].Movement = integer(MyModel[MyUnit[uix].mix].Speed) then
-      begin
-        NotReachedFlag := 1 shl (2 * tuix);
-        CompleteFlag := NotReachedFlag shl 1;
-        V8_to_Loc(MyUnit[uix].Loc, Adjacent);
-        for V8 := 0 to 7 do
+  fillchar(Arrived, MapSize*4, $55); // set NotReachedFlag for all tiles
+  fillchar(GroupComplete, MapSize, false);
+  BestLoadLoc:=-1;
+
+  // check direct loading
+  for tuix:=0 to nSelectedLoad-1 do
+    begin
+    uix:=uixSelectedLoad[tuix];
+    if MyUnit[uix].Movement=integer(MyModel[MyUnit[uix].mix].Speed) then
+      begin
+      NotReachedFlag:=1 shl (2*tuix);
+      CompleteFlag:=NotReachedFlag shl 1;
+      V8_to_Loc(MyUnit[uix].Loc, Adjacent);
+      for V8:=0 to 7 do
         begin
-          Loc1 := Adjacent[V8];
-          if (Loc1 >= 0) and (Map[Loc1] and fTerrain < fGrass) and
-            not GroupComplete[Loc1] then
+        Loc1:=Adjacent[V8];
+        if (Loc1>=0) and (Map[Loc1] and fTerrain<fGrass)
+          and not GroupComplete[Loc1] then
           begin // possible transport start location
-            Arrived[Loc1] := (Arrived[Loc1] or CompleteFlag) and
-              not NotReachedFlag;
-            if (TurnsBeforeLoad[Loc1] >= 0) and (TurnsAfterLoad[Loc1] >= 0) then
+          Arrived[Loc1]:=(Arrived[Loc1] or CompleteFlag) and not NotReachedFlag;
+          if (TurnsBeforeLoad[Loc1]>=0) and (TurnsAfterLoad[Loc1]>=0) then
             begin
-              i := 1;
-              GroupCount := 0;
-              for tuix1 := 0 to nSelectedLoad - 1 do
+            i:=1;
+            GroupCount:=0;
+            for tuix1:=0 to nSelectedLoad-1 do
               begin
-                if Arrived[Loc1] and i = 0 then
-                  inc(GroupCount);
-                i := i shl 2;
+              if Arrived[loc1] and i=0 then inc(GroupCount);
+              i:=i shl 2;
               end;
-              assert(GroupCount <= TransportCapacity);
-              if (GroupCount = TransportCapacity) or (GroupCount = nSelectedLoad)
-              then
-                GroupComplete[Loc1] := true;
-              TotalDelay := TurnsBeforeLoad[Loc1] + TurnsAfterLoad[Loc1];
-              if (BestLoadLoc < 0) or
-                (GroupCount shl 16 - TotalDelay > BestGroupCount shl 16 -
-                BestTotalDelay) then
+            assert(GroupCount<=TransportCapacity);
+            if (GroupCount=TransportCapacity) or (GroupCount=nSelectedLoad) then
+              GroupComplete[loc1]:=true;
+            TotalDelay:=TurnsBeforeLoad[Loc1]+TurnsAfterLoad[Loc1];
+            if (BestLoadLoc<0)
+              or (GroupCount shl 16-TotalDelay
+                >BestGroupCount shl 16-BestTotalDelay) then
               begin
-                BestLoadLoc := Loc1;
-                BestGroupCount := GroupCount;
-                BestTotalDelay := TotalDelay
+              BestLoadLoc:=Loc1;
+              BestGroupCount:=GroupCount;
+              BestTotalDelay:=TotalDelay
               end
             end
@@ -1260 +1181 @@
     end;
 
-    TurnCount := 0;
-    ArrivedEnd := @Arrived[MapSize];
-
-    // check moving+loading
-    ContinueUnit := 1 shl nSelectedLoad - 1;
-    while (ContinueUnit > 0) and
-      ((BestLoadLoc < 0) or (TurnCount < BestTotalDelay - 2)) do
-    begin
-      for tuix := 0 to nSelectedLoad - 1 do
-        if 1 shl tuix and ContinueUnit <> 0 then
+  TurnCount:=0;
+  ArrivedEnd:=@Arrived[MapSize];
+
+  // check moving+loading
+  ContinueUnit:=1 shl nSelectedLoad-1;
+  while (ContinueUnit>0) and ((BestLoadLoc<0) or (TurnCount<BestTotalDelay-2)) do
+    begin
+    for tuix:=0 to nSelectedLoad-1 do if 1 shl tuix and ContinueUnit<>0 then
+      begin
+      uix:=uixSelectedLoad[tuix];
+      MoveStyle:=GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
+      NotReachedFlag:=1 shl (2*tuix);
+      CompleteFlag:=NotReachedFlag shl 1;
+      FullMovementLoc:=-1;
+
+      Pile.Empty;
+      if TurnCount=0 then
         begin
-          uix := uixSelectedLoad[tuix];
-          MoveStyle := GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
-          NotReachedFlag := 1 shl (2 * tuix);
-          CompleteFlag := NotReachedFlag shl 1;
-          FullMovementLoc := -1;
-
-          Pile.Empty;
-          if TurnCount = 0 then
+        Pile.Put(MyUnit[uix].Loc, $1800-MyUnit[uix].Movement);
+        if MyUnit[uix].Movement=integer(MyModel[MyUnit[uix].mix].Speed) then
+          FullMovementLoc:=MyUnit[uix].Loc; // surrounding tiles can be loaded immediately
+        StartLocPtr:=ArrivedEnd;
+        end
+      else StartLocPtr:=@Arrived;
+      IsFirstLoc:=true;
+
+      repeat
+        if StartLocPtr<>ArrivedEnd then // search next movement start location for this turn
+          StartLocPtr:=NextZero(StartLocPtr, ArrivedEnd, CompleteFlag or NotReachedFlag);
+        if StartLocPtr<>ArrivedEnd then
           begin
-            Pile.Put(MyUnit[uix].Loc, $1800 - MyUnit[uix].Movement);
-            if MyUnit[uix].Movement = integer(MyModel[MyUnit[uix].mix].Speed)
-            then
-              FullMovementLoc := MyUnit[uix].Loc;
-            // surrounding tiles can be loaded immediately
-            StartLocPtr := ArrivedEnd;
+          Loc0:=(integer(StartLocPtr)-integer(@Arrived)) shr 2;
+          inc(StartLocPtr);
+          Time0:=$800
           end
-          else
-            StartLocPtr := @Arrived;
-          IsFirstLoc := true;
-
-          repeat
-            if StartLocPtr <> ArrivedEnd then
-            // search next movement start location for this turn
-              StartLocPtr := NextZero(StartLocPtr, ArrivedEnd, CompleteFlag or
-                NotReachedFlag);
-            if StartLocPtr <> ArrivedEnd then
+        else if not Pile.Get(Loc0, Time0) then
+          begin
+          if IsFirstLoc then ContinueUnit:=ContinueUnit and not (1 shl tuix);
+          break;
+          end;
+        IsFirstLoc:=false;
+
+        Arrived[Loc0]:=Arrived[Loc0] and not NotReachedFlag;
+        if not GroupComplete[Loc0] and (Map[Loc0] and fTerrain<>fMountains) then
+          begin // check whether group complete -- no mountains because complete flag might be faked there
+          i:=1;
+          GroupCount:=0;
+          for tuix1:=0 to nSelectedLoad-1 do 
             begin
-              Loc0 := (integer(StartLocPtr) - integer(@Arrived)) shr 2;
-              inc(StartLocPtr);
-              Time0 := $800
-            end
-            else if not Pile.Get(Loc0, Time0) then
-            begin
-              if IsFirstLoc then
-                ContinueUnit := ContinueUnit and not(1 shl tuix);
-              Break;
+            if Arrived[Loc0] and i=0 then inc(GroupCount);
+            i:=i shl 2;
             end;
-            IsFirstLoc := false;
-
-            Arrived[Loc0] := Arrived[Loc0] and not NotReachedFlag;
-            if not GroupComplete[Loc0] and (Map[Loc0] and fTerrain <> fMountains)
-            then
-            begin // check whether group complete -- no mountains because complete flag might be faked there
-              i := 1;
-              GroupCount := 0;
-              for tuix1 := 0 to nSelectedLoad - 1 do
+          assert(GroupCount<=TransportCapacity);
+          if (GroupCount=TransportCapacity) or (GroupCount=nSelectedLoad) then
+            GroupComplete[Loc0]:=true
+          end;
+
+        V8_to_Loc(Loc0, Adjacent);
+        IsComplete:=true;
+        for V8:=0 to 7 do
+          begin
+          Loc1:=Adjacent[V8];
+          if (Loc1<G.ly) or (Loc1>=MapSize-G.ly) then
+            Adjacent[V8]:=-1 // pole, don't consider moving here
+          else if Arrived[Loc1] and NotReachedFlag=0 then
+            Adjacent[V8]:=-1 // unit has already arrived this tile
+          else if GroupComplete[Loc1] then
+            Adjacent[V8]:=-1 // already other group complete
+          else if Map[Loc1] and fTerrain<fGrass then
+            begin // possible transport start location
+            Arrived[Loc1]:=(Arrived[Loc1] or CompleteFlag) and not NotReachedFlag;
+            Adjacent[V8]:=-1;
+            if (TurnsBeforeLoad[Loc1]>=0) and (TurnsAfterLoad[Loc1]>=0) then
               begin
-                if Arrived[Loc0] and i = 0 then
-                  inc(GroupCount);
-                i := i shl 2;
-              end;
-              assert(GroupCount <= TransportCapacity);
-              if (GroupCount = TransportCapacity) or (GroupCount = nSelectedLoad)
-              then
-                GroupComplete[Loc0] := true
-            end;
-
-            V8_to_Loc(Loc0, Adjacent);
-            IsComplete := true;
-            for V8 := 0 to 7 do
-            begin
-              Loc1 := Adjacent[V8];
-              if (Loc1 < G.ly) or (Loc1 >= MapSize - G.ly) then
-                Adjacent[V8] := -1 // pole, don't consider moving here
-              else if Arrived[Loc1] and NotReachedFlag = 0 then
-                Adjacent[V8] := -1 // unit has already arrived this tile
-              else if GroupComplete[Loc1] then
-                Adjacent[V8] := -1 // already other group complete
-              else if Map[Loc1] and fTerrain < fGrass then
-              begin // possible transport start location
-                Arrived[Loc1] := (Arrived[Loc1] or CompleteFlag) and
-                  not NotReachedFlag;
-                Adjacent[V8] := -1;
-                if (TurnsBeforeLoad[Loc1] >= 0) and (TurnsAfterLoad[Loc1] >= 0)
-                then
+              i:=1;
+              GroupCount:=0;
+              for tuix1:=0 to nSelectedLoad-1 do 
                 begin
-                  i := 1;
-                  GroupCount := 0;
-                  for tuix1 := 0 to nSelectedLoad - 1 do
-                  begin
-                    if Arrived[Loc1] and i = 0 then
-                      inc(GroupCount);
-                    i := i shl 2;
-                  end;
-                  assert(GroupCount <= TransportCapacity);
-                  if (GroupCount = TransportCapacity) or
-                    (GroupCount = nSelectedLoad) then
-                    GroupComplete[Loc1] := true;
-                  if TurnsBeforeLoad[Loc1] > TurnCount + 1 then
-                    TotalDelay := TurnsBeforeLoad[Loc1] + TurnsAfterLoad[Loc1]
-                  else
-                    TotalDelay := TurnCount + 1 + TurnsAfterLoad[Loc1];
-                  if (BestLoadLoc < 0) or
-                    (GroupCount shl 16 - TotalDelay > BestGroupCount shl 16 -
-                    BestTotalDelay) then
-                  begin
-                    BestLoadLoc := Loc1;
-                    BestGroupCount := GroupCount;
-                    BestTotalDelay := TotalDelay
-                  end
+                if Arrived[loc1] and i=0 then inc(GroupCount);
+                i:=i shl 2;
+                end;
+              assert(GroupCount<=TransportCapacity);
+              if (GroupCount=TransportCapacity) or (GroupCount=nSelectedLoad) then
+                GroupComplete[loc1]:=true;
+              if TurnsBeforeLoad[Loc1]>TurnCount+1 then
+                TotalDelay:=TurnsBeforeLoad[Loc1]+TurnsAfterLoad[Loc1]
+              else TotalDelay:=TurnCount+1+TurnsAfterLoad[Loc1];
+              if (BestLoadLoc<0)
+                or (GroupCount shl 16-TotalDelay
+                  >BestGroupCount shl 16-BestTotalDelay) then
+                begin
+                BestLoadLoc:=Loc1;
+                BestGroupCount:=GroupCount;
+                BestTotalDelay:=TotalDelay
                 end
               end
-              else if (Map[Loc1] and fTerrain = fMountains) and
-                ((Map[Loc0] and (fRoad or fRR or fCity) = 0) or
-                (Map[Loc1] and (fRoad or fRR or fCity) = 0)) and
-                (Map[Loc0] and Map[Loc1] and (fRiver or fCanal) = 0) then
-              begin // mountain delay too complicated for this algorithm
-                Arrived[Loc1] := (Arrived[Loc1] or CompleteFlag) and
-                  not NotReachedFlag;
-                Adjacent[V8] := -1;
-              end
-              else
-                IsComplete := false;
-            end;
-            if IsComplete then
+            end
+          else if (Map[Loc1] and fTerrain=fMountains)
+            and ((Map[Loc0] and (fRoad or fRR or fCity)=0)
+              or (Map[Loc1] and (fRoad or fRR or fCity)=0))
+            and (Map[Loc0] and Map[Loc1] and (fRiver or fCanal)=0) then
+            begin // mountain delay too complicated for this algorithm
+            Arrived[Loc1]:=(Arrived[Loc1] or CompleteFlag) and not NotReachedFlag;
+            Adjacent[V8]:=-1;
+            end
+          else IsComplete:=false;
+          end;
+        if IsComplete then
+          begin
+          Arrived[Loc0]:=(Arrived[Loc0] or CompleteFlag) and not NotReachedFlag;
+          continue
+          end;
+        IsComplete:=true;
+        for V8:=0 to 7 do
+          begin
+          Loc1:=Adjacent[V8];
+          if Loc1>=0 then
             begin
-              Arrived[Loc0] := (Arrived[Loc0] or CompleteFlag) and
-                not NotReachedFlag;
-              continue
-            end;
-            IsComplete := true;
-            for V8 := 0 to 7 do
-            begin
-              Loc1 := Adjacent[V8];
-              if Loc1 >= 0 then
-              begin
-                ok := false;
-                case CheckStep(MoveStyle, Time0, V8 and 1, ArriveTime,
-                  RecoverTurns, Map[Loc0], Map[Loc1]) of
-                  csOk:
-                    ok := true;
-                  csForbiddenTile:
-                    ; // !!! don't check moving there again
-                  csCheckTerritory:
-                    ok := RO.Territory[Loc1] = RO.Territory[Loc0];
-                end;
-                if ok and Pile.TestPut(Loc1, ArriveTime) then
-                  if ArriveTime < $2000 then
-                    Pile.Put(Loc1, ArriveTime)
-                  else
-                    IsComplete := false
-              end
-            end;
-            if IsComplete then
-              Arrived[Loc0] := (Arrived[Loc0] or CompleteFlag) and
-                not NotReachedFlag;
-          until false;
+            ok:=false;
+            case CheckStep(MoveStyle, Time0, V8 and 1, ArriveTime, RecoverTurns,
+              Map[Loc0], Map[Loc1],false) of
+              csOk: ok:=true;
+              csForbiddenTile:
+                ;// !!! don't check moving there again
+              csCheckTerritory:
+                ok:= RO.Territory[Loc1]=RO.Territory[Loc0];
+              end;
+            if ok and Pile.TestPut(Loc1, ArriveTime) then
+              if ArriveTime<$2000 then Pile.Put(Loc1, ArriveTime)
+              else IsComplete:=false
+            end
+          end;
+        if IsComplete then
+          Arrived[Loc0]:=(Arrived[Loc0] or CompleteFlag) and not NotReachedFlag;
+      until false;
+      end;
+
+    inc(TurnCount);
+    end;
+  Pile.Free;
+
+  if BestLoadLoc>=0 then
+    begin
+    TransportPlan.LoadLoc:=BestLoadLoc;
+    TransportPlan.uixTransport:=ResponsibleTransport[BestLoadLoc];
+    TransportAvailable[TransportPlan.uixTransport]:=0;
+    TransportPlan.TurnsEmpty:=BestTotalDelay-TurnsAfterLoad[BestLoadLoc];
+    TransportPlan.TurnsLoaded:=TurnsAfterLoad[BestLoadLoc];
+    TransportPlan.nLoad:=0;
+    for tuix:=nSelectedLoad-1 downto 0 do
+      if 1 shl (2*tuix) and Arrived[BestLoadLoc]=0 then
+        begin
+        assert(uixTransportLoad[tuixSelectedLoad[tuix]]=uixSelectedLoad[tuix]);
+        TransportPlan.uixLoad[TransportPlan.nLoad]:=uixSelectedLoad[tuix];
+        uixTransportLoad[tuixSelectedLoad[tuix]]:=
+          uixTransportLoad[nTransportLoad-1];
+        dec(nTransportLoad);
+        inc(TransportPlan.nLoad)
         end;
-
-      inc(TurnCount);
-    end;
-    Pile.Free;
-
-    if BestLoadLoc >= 0 then
-    begin
-      TransportPlan.LoadLoc := BestLoadLoc;
-      TransportPlan.uixTransport := ResponsibleTransport[BestLoadLoc];
-      TransportAvailable[TransportPlan.uixTransport] := 0;
-      TransportPlan.TurnsEmpty := BestTotalDelay - TurnsAfterLoad[BestLoadLoc];
-      TransportPlan.TurnsLoaded := TurnsAfterLoad[BestLoadLoc];
-      TransportPlan.nLoad := 0;
-      for tuix := nSelectedLoad - 1 downto 0 do
-        if 1 shl (2 * tuix) and Arrived[BestLoadLoc] = 0 then
-        begin
-          assert(uixTransportLoad[tuixSelectedLoad[tuix]]
-            = uixSelectedLoad[tuix]);
-          TransportPlan.uixLoad[TransportPlan.nLoad] := uixSelectedLoad[tuix];
-          uixTransportLoad[tuixSelectedLoad[tuix]] :=
-            uixTransportLoad[nTransportLoad - 1];
-          dec(nTransportLoad);
-          inc(TransportPlan.nLoad)
-        end;
-      result := true;
-      exit
-    end;
-
-    // no loading location for a single of these units -- remove all
-    // should be pretty rare case
-    for tuix := nSelectedLoad - 1 downto 0 do
-    begin
-      assert(uixTransportLoad[tuixSelectedLoad[tuix]] = uixSelectedLoad[tuix]);
-      uixTransportLoad[tuixSelectedLoad[tuix]] := uixTransportLoad
-        [nTransportLoad - 1];
-      dec(nTransportLoad);
-    end;
-  end;
-  TransportPlan.LoadLoc := -1;
-  result := false;
-end;
-
-
-// ------------------------------------------------------------------------------
+    result:=true;
+    exit
+    end;
+
+  // no loading location for a single of these units -- remove all
+  // should be pretty rare case
+  for tuix:=nSelectedLoad-1 downto 0 do
+    begin
+    assert(uixTransportLoad[tuixSelectedLoad[tuix]]=uixSelectedLoad[tuix]);
+    uixTransportLoad[tuixSelectedLoad[tuix]]:=
+      uixTransportLoad[nTransportLoad-1];
+    dec(nTransportLoad);
+    end;
+  end;
+TransportPlan.LoadLoc:=-1;
+result:=false;
+end;
+
+
+//------------------------------------------------------------------------------
+// Misc
+
+function TToolAI.CurrentMStrength(Domain: integer): integer;
+var
+i: integer;
+begin
+result:=0;
+for i:=0 to nUpgrade-1 do with upgrade[Domain,i] do
+  if (Preq=preNone)
+    or (Preq>=0) and ((RO.Tech[Preq]>=tsApplicable)
+    or (Preq in FutureTech) and (RO.Tech[Preq]>=0)) then
+    begin
+    if Preq in FutureTech then
+      inc(result,RO.Tech[Preq]*Strength)
+    else inc(result,Strength);
+    end;
+end;
+
+
+//------------------------------------------------------------------------------
 
 procedure SetAdvancedness;
 var
-  ad, j, Reduction, AgeThreshold: integer;
-  known: array [0 .. nAdv - 1] of integer;
+ad,j,Reduction,AgeThreshold: integer;
+known: array[0..nAdv-1] of integer;
   procedure MarkPreqs(ad: integer);
   var
-    i: integer;
-  begin
-    if known[ad] = 0 then
-    begin
-      known[ad] := 1;
-      for i := 0 to 2 do
-        if AdvPreq[ad, i] >= 0 then
-          MarkPreqs(AdvPreq[ad, i]);
+  i: integer;
+  begin
+  if known[ad]=0 then
+    begin
+    known[ad]:=1;
+    for i:=0 to 2 do
+      if AdvPreq[ad,i]>=0 then MarkPreqs(AdvPreq[ad,i]);
     end
   end;
-
-begin
-  fillchar(Advancedness, sizeof(Advancedness), 0);
-  for ad := 0 to nAdv - 1 do
-  begin
-    fillchar(known, sizeof(known), 0);
-    MarkPreqs(ad);
-    for j := 0 to nAdv - 1 do
-      if known[j] > 0 then
-        inc(Advancedness[ad]);
-  end;
-  AgeThreshold := Advancedness[adScience];
-  Reduction := Advancedness[adScience] div 3;
-  for ad := 0 to nAdv - 5 do
-    if Advancedness[ad] >= AgeThreshold then
-      dec(Advancedness[ad], Reduction);
-  AgeThreshold := Advancedness[adMassProduction];
-  Reduction := (Advancedness[adMassProduction] - Advancedness[adScience]) div 3;
-  for ad := 0 to nAdv - 5 do
-    if Advancedness[ad] >= AgeThreshold then
-      dec(Advancedness[ad], Reduction)
-end;
+begin
+FillChar(Advancedness,SizeOf(Advancedness),0);
+for ad:=0 to nAdv-1 do
+  begin
+  FillChar(known,SizeOf(known),0);
+  MarkPreqs(ad);
+  for j:=0 to nAdv-1 do if known[j]>0 then inc(Advancedness[ad]);
+  end;
+AgeThreshold:=Advancedness[adScience];
+Reduction:=Advancedness[adScience] div 3;
+for ad:=0 to nAdv-5 do
+  if Advancedness[ad]>=AgeThreshold then
+    dec(Advancedness[ad], Reduction);
+AgeThreshold:=Advancedness[adMassProduction];
+Reduction:=(Advancedness[adMassProduction]-Advancedness[adScience]) div 3;
+for ad:=0 to nAdv-5 do
+  if Advancedness[ad]>=AgeThreshold then
+    dec(Advancedness[ad], Reduction)
+end;
+
 
 initialization
-
 SetAdvancedness;
 
 end.
+