Changeset 465 for branches

branches/highdpi/AI/StdAI/AI.pas

-              r349
+              r465
   nResearchOrder = 46;
   ResearchOrder: array[0..1, 0..nResearchOrder - 1] of integer =
+  ResearchOrder: array[0..1, 0..nResearchOrder - 1] of Integer =
     ((adWheel, adWarriorCode, adHorsebackRiding, adCeremonialBurial, adPolytheism,
     adMonarchy, adMysticism, adPoetry, adAstronomy, adMonotheism,
 …
   // mil research
   BetterQuality: array[0..nModelCat - 1] of integer = (50, 50, 80, 80);
+  BetterQuality: array[0..nModelCat - 1] of Integer = (50, 50, 80, 80);
   MaxBuildWorseThanBestModel = 20;
   MaxExistWorseThanBestModel = 50;
 …
   nRequestedTechs = 48;
   PlayerHash: array[0..nPl - 1] of integer =
+  PlayerHash: array[0..nPl - 1] of Integer =
     (7, 6, 0, 2, 10, 8, 12, 14, 4, 1, 3, 5, 9, 11, 13);
 …
   TPersistentData = record
     LastResearchTech, BehaviorFlags, TheologyPartner: integer;
+    LastResearchTech, BehaviorFlags, TheologyPartner: Integer;
     RejectTurn: array[Suggestion, 0..15] of smallint;
     RequestedTechs: array[0..nRequestedTechs - 1] of integer;
+    RequestedTechs: array[0..nRequestedTechs - 1] of Integer;
     // ad + p shl 8 + Turn shl 16
   end;
   TAI = class(TBarbarina)
     constructor Create(Nation: integer); override;
+    constructor Create(Nation: Integer); override;
     procedure SetDataDefaults; override;
 …
     Data: ^TPersistentData;
     WarNations, BombardingNations, mixSettlers, mixCaravan, mixTownGuard,
     mixSlaves, mixMilitia, mixCruiser, OceanWithShip: integer;
+    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;
+    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;
+    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);
+    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 AttackAndPatrol;
     procedure MoveUnitsHome;
     procedure CheckAttack(uix: integer);
     procedure Patrol(uix: integer);
+    procedure CheckAttack(uix: Integer);
+    procedure Patrol(uix: Integer);
     procedure SetCityProduction;
     procedure SetAdvanceValues;
     function HavePort: boolean;
   {$IFDEF DEBUG}procedure TraceAdvanceValues(Nation: integer);{$ENDIF}
+    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;
+    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 TileWorkPlan(Loc, cix: Integer; var Value, NextJob, TotalWork: Integer);
     procedure ProcessSettlers;
     // diplomacy
     function MostWanted(Nation, adGiveAway: integer): integer;
+    function MostWanted(Nation, adGiveAway: Integer): Integer;
   end;
 …
 var
+  LeaveOutValue: array[0..nAdv - 1] of integer;
+constructor TAI.Create(Nation: integer);
+  LeaveOutValue: array[0..nAdv - 1] of Integer;
+constructor TAI.Create(Nation: Integer);
 begin
   inherited;
   Data := pointer(RO.Data);
+  Data := Pointer(RO.Data);
 {$IFDEF DEBUG}
   if Nation = 1 then
 …
   begin
     LastResearchTech := -1;
     if PlayerHash[me] > 7 then
+    if PlayerHash[Me] > 7 then
       BehaviorFlags := bFemale
     else
 …
     DebugMessage(1, 'Gender:=' + char(48 + BehaviorFlags and bGender));
     TheologyPartner := -1;
     fillchar(RejectTurn, sizeof(RejectTurn), $FF);
     Fillchar(RequestedTechs, sizeof(RequestedTechs), $FF);
+    FillChar(RejectTurn, SizeOf(RejectTurn), $FF);
+    Fillchar(RequestedTechs, SizeOf(RequestedTechs), $FF);
   end;
 end;
 function TAI.OnNegoRejected_CancelTreaty: boolean;
+function TAI.OnNegoRejected_CancelTreaty: Boolean;
 begin
   Data.RejectTurn[suContact, Opponent] := RO.Turn;
 …
 end;
 //-------------------------------
 //            RESEARCH
 //-------------------------------
 procedure TAI.RateModel(const mi: TModelInfo; var Category, Quality: integer);
+procedure TAI.RateModel(const mi: TModelInfo; var Category, Quality: Integer);
 var
   EffectiveTransport: integer;
+  EffectiveTransport: Integer;
 begin
   if mi.Kind >= mkScout then
   begin
     Category := mctNone;
     exit;
+    Exit;
   end;
   case mi.Domain of
 …
 end;
 procedure TAI.RateMyModel(mix: integer; var Category, Quality: integer);
+procedure TAI.RateMyModel(mix: Integer; var Category, Quality: Integer);
 var
   mi: TModelInfo;
 begin
   MakeModelInfo(me, mix, MyModel[mix], mi);
+  MakeModelInfo(Me, mix, MyModel[mix], mi);
   RateModel(mi, Category, Quality);
 end;
 function TAI.IsBetterModel(const mi: TModelInfo): boolean;
+function TAI.IsBetterModel(const mi: TModelInfo): Boolean;
 var
   mix, Cat, Quality, Cat1, Quality1: integer;
+  mix, Cat, Quality, Cat1, Quality1: Integer;
 begin
   RateModel(mi, Cat, Quality);
 …
       begin
         Result := False;
         exit;
+        Exit;
       end;
     end;
 …
 end;
 function TAI.ChooseResearchAdvance: integer;
+function TAI.ChooseResearchAdvance: Integer;
 var
   adNext, iad, i, ad, Count, EarliestNeeded, EarliestNeeded_NoLeaveOut,
   NewResearch, StateOfArt, mix: integer;
+  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;
+  Entry: array[0..nAdv - 1] of Boolean;
+  ok: Boolean;
+  function MarkEntry(ad: Integer): Boolean;
   begin
     if RO.Tech[ad] >= tsApplicable then
 …
   end;
   procedure OptimizeDevModel(OptimizeCaps: integer);
+  procedure OptimizeDevModel(OptimizeCaps: Integer);
   var
     f, Cat, OriginalCat, Quality, BestQuality, Best: integer;
+    F, Cat, OriginalCat, Quality, BestQuality, Best: Integer;
     mi: TModelInfo;
   begin
     MakeModelInfo(me, 0, RO.DevModel, mi);
+    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
+      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);
+            MakeModelInfo(Me, 0, RO.DevModel, mi);
             RateModel(mi, Cat, Quality);
             assert(Cat = OriginalCat);
+            Assert(Cat = OriginalCat);
             if Quality > BestQuality then
             begin
               Best := f;
+              Best := F;
               BestQuality := Quality;
             end;
             SetNewModelFeature(f, RO.DevModel.Cap[f] - 1);
+            SetNewModelFeature(F, RO.DevModel.Cap[F] - 1);
           end;
         end;
 …
   end;
   function LeaveOutsMissing(ad: integer): boolean;
+  function LeaveOutsMissing(ad: Integer): Boolean;
   var
     i: integer;
+    I: Integer;
   begin
     Result := False;
 …
         Result := True
       else
         for i := 0 to 1 do
           if AdvPreq[ad, i] >= 0 then
             Result := Result or LeaveOutsMissing(AdvPreq[ad, i]);
+        for I := 0 to 1 do
+          if AdvPreq[ad, I] >= 0 then
+            Result := Result or LeaveOutsMissing(AdvPreq[ad, I]);
   end;
 …
     Result := Barbarina_ChooseResearchAdvance;
     if Result >= 0 then
       exit;
+      Exit;
   end;
 …
       Result := ad;
   if Result >= 0 then
     exit;
+    Exit;
   if Data.BehaviorFlags and bBarbarina = 0 then
 …
       OptimizeDevModel(1 shl mcOffense + 1 shl mcDefense + 1 shl
         mcMob + 1 shl mcLongRange + 1 shl mcFanatic);
       MakeModelInfo(me, 0, RO.DevModel, mi);
+      MakeModelInfo(Me, 0, RO.DevModel, mi);
       if IsBetterModel(mi) then
       begin
         Result := adMilitary;
         exit;
+        Exit;
       end;
 …
       SetNewModelFeature(mcOffense, 1);
       OptimizeDevModel(1 shl mcOffense + 1 shl mcDefense + 1 shl mcFanatic);
       MakeModelInfo(me, 0, RO.DevModel, mi);
+      MakeModelInfo(Me, 0, RO.DevModel, mi);
       if IsBetterModel(mi) then
       begin
         Result := adMilitary;
         exit;
+        Exit;
       end;
     end;
 …
         SetNewModelFeature(mcWeapons, 0);
         SetNewModelFeature(mcDefense, 3);
         exit;
+        Exit;
       end;
     end;
 …
       OptimizeDevModel(1 shl mcDefense+1 shl mcSeaTrans+1 shl mcTurbines
         +1 shl mcAirDef);
       MakeModelInfo(me,0,RO.DevModel,mi);
+      MakeModelInfo(Me,0,RO.DevModel,mi);
       if IsBetterModel(mi) then
         begin result:=adMilitary; exit end;
+        begin Result:=adMilitary; Exit end;
       end;
 …
       OptimizeDevModel(1 shl mcOffense+1 shl mcDefense
         +1 shl mcLongRange+1 shl mcAirDef+1 shl mcRadar);
       MakeModelInfo(me,0,RO.DevModel,mi);
+      MakeModelInfo(Me,0,RO.DevModel,mi);
       if IsBetterModel(mi) then
         begin result:=adMilitary; exit end;
+        begin Result:=adMilitary; Exit end;
       end
     end;
 …
         begin
           ok := True;
           break;
+          Break;
         end;
       if not ok then
 …
         begin // 2 of 3 required
           Count := 0;
           for i := 0 to 2 do
             if RO.Tech[AdvPreq[ad, i]] >= tsApplicable then
+          for I := 0 to 2 do
+            if RO.Tech[AdvPreq[ad, I]] >= tsApplicable then
               Inc(Count);
           if Count >= 2 then
           begin
             Result := ad;
             exit;
+            Exit;
           end;
         end
 …
         begin
           Result := ad;
           exit;
+          Exit;
         end;
       end;
 …
     begin // go for future techs
       Result := -1;
       i := 0;
+      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
+          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);
+      Assert((Result < 0) or AdvanceResearchable(Result));
+      Exit;
+    end;
+  Assert(NewResearch >= 0);
+  FillChar(Entry, SizeOf(Entry), False);
   MarkEntry(NewResearch);
   Result := -1;
 …
     if Entry[ad] and ((Result < 0) or (Advancedness[ad] > Advancedness[Result])) then
       Result := ad;
   assert(Result >= 0);
+  Assert(Result >= 0);
 end;
 function TAI.ChooseStealAdvance: integer;
+function TAI.ChooseStealAdvance: Integer;
 var
   ad: integer;
+  ad: Integer;
 begin
   Result := -1;
 …
 end;
 //-------------------------------
 //         TERRAFORMING
 …
   twpAllowFarmland = $0001;
 procedure TAI.TileWorkPlan(Loc, cix: integer; var Value, NextJob, TotalWork: integer);
+procedure TAI.TileWorkPlan(Loc, cix: Integer; var Value, NextJob, TotalWork: Integer);
 var
   OldTile, TerrType: cardinal;
+  OldTile, TerrType: Cardinal;
   TileInfo: TTileInfo;
 begin
 …
   begin
     Value := 3 * 8 - 1;
     exit;
+    Exit;
   end; // better than any tile with 2 food
 …
       Map[Loc] := Map[Loc] and not fTerrain or fGrass;
       TerrType := fGrass;
       Map[Loc] := Map[Loc] or cardinal(SpecialTile(Loc, TerrType, G.lx) shl 5);
+      Map[Loc] := Map[Loc] or Cardinal(SpecialTile(Loc, TerrType, G.lx) shl 5);
     end
     else if IsResearched(adExplosives) and
 …
       Map[Loc] := Map[Loc] and not fTerrain or fGrass;
       TerrType := fGrass;
       Map[Loc] := Map[Loc] or cardinal(SpecialTile(Loc, TerrType, G.lx) shl 5);
+      Map[Loc] := Map[Loc] or Cardinal(SpecialTile(Loc, TerrType, G.lx) shl 5);
     end;
     if (Terrain[TerrType].MineEff > 0) and (RO.Government <> gDespotism) then
 …
     end;
   end;
   Server(sGetTileInfo, me, Loc, TileInfo);
+  Server(sGetTileInfo, Me, Loc, TileInfo);
   Value := TileInfo.Food * 8 + TileInfo.Prod * 2 + TileInfo.Trade;
   Map[Loc] := OldTile;
 …
 procedure TAI.ProcessSettlers;
 var
   i, uix, cix, ecix, dtr, Loc, RadiusLoc, Special, Food, Prod, Trade,
+  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;
+  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);
+  TileFood, ResourceScore, CityScore: array[0..lxmax * lymax - 1] of Integer;
+  procedure AddJob(Loc, Job, Score: Integer);
   // set Score=1 for low-priority jobs
   begin
 …
   end;
   procedure ReserveCityRadius(Loc: integer);
+  procedure ReserveCityRadius(Loc: Integer);
   var
     V21, RadiusLoc: integer;
+    V21, RadiusLoc: Integer;
     Radius: TVicinity21Loc;
   begin
 …
   procedure ScoreRoadConnections;
   var
     V8, nFragments, Loc, Loc1, History, RoadScore, a, b, FullyDeveloped,
     ConnectMask: integer;
     BridgeOk: boolean;
+    V8, nFragments, Loc, Loc1, History, RoadScore, A, B, FullyDeveloped,
+    ConnectMask: Integer;
+    BridgeOk: Boolean;
     Adjacent: TVicinity8Loc;
   begin
 …
       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
+        (RO.Territory[Loc] = Me) and (Map[Loc] and FullyDeveloped = 0) and
         (BridgeOk or (Map[Loc] and fRiver = 0)) then
       begin
 …
           Loc1 := Adjacent[V8 and 7];
           History := History shl 1;
           if (Loc1 >= 0) and (RO.Territory[Loc1] = me) and
+          if (Loc1 >= 0) and (RO.Territory[Loc1] = Me) and
             (Map[Loc1] and ConnectMask <> 0) then
           begin
 …
                   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);
+                    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);
 …
 begin
   fillchar(SettlerSurplus, sizeof(SettlerSurplus), 0);
+  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);
+    FillChar(TileFood, SizeOf(TileFood), 0);
+    FillChar(ResourceScore, SizeOf(ResourceScore), 0);
     for Loc := 0 to MapSize - 1 do
       if Map[Loc] and fTerrain <> fUNKNOWN then
 …
     // rate possible new cities
     fillchar(CityScore, MapSize * sizeof(integer), 0);
+    FillChar(CityScore, MapSize * SizeOf(Integer), 0);
     for Loc := 0 to MapSize - 1 do
     begin
 …
         ((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
+      if FoodOk and ((RO.Territory[Loc] < 0) or (RO.Territory[Loc] = Me)) then
       begin
         TestScore := 0;
 …
         if CityFood >= MinCityFood then // city is worth founding
         begin
           TestScore := (72 + 2 * TestScore) shl 8 + ((loc xor me) * 4567) mod 251;
+          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
 …
               if not (Map[RadiusLoc] and fTerrain in [fDesert, fArctic]) then
               begin
                 assert(RadiusLoc >= 0);
+                Assert(RadiusLoc >= 0);
                 TileWorkPlan(RadiusLoc, cix, Value, NextJob, TotalWork);
                 if (NextJob = jRoad) and (Built[imPalace] +
 …
             begin // tile could be exploited
               RadiusLoc := Radius[V21];
               assert(RadiusLoc >= 0);
+              Assert(RadiusLoc >= 0);
               if not (Map[RadiusLoc] and fTerrain in [fDesert, fArctic]) then
               begin
 …
   if Data.BehaviorFlags and bBarbarina = 0 then // low priority jobs
     for Loc := 0 to MapSize - 1 do
       if RO.Territory[Loc] = me then
+      if RO.Territory[Loc] = Me then
       begin
         Tile := Map[Loc];
 …
   begin
     for part := 0 to nShipPart - 1 do
       for i := 0 to ColonyShipPlan[part].nLocFoundCity - 1 do
       begin
         Loc := ColonyShipPlan[part].LocFoundCity[i];
+      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
 …
           begin
             Started := True;
             break;
+            Break;
           end;
         if not Started then
 …
             begin // settlers could be added to this city
               Happy := BasicHappy;
               for i := 0 to nWonder - 1 do
                 if Built[i] > 0 then
+              for I := 0 to nWonder - 1 do
+                if Built[I] > 0 then
                   Inc(Happy);
               if Built[imTemple] > 0 then
 …
               begin
                 Inc(Happy, 2);
                 if RO.Wonder[woBach].EffectiveOwner = me then
+                if RO.Wonder[woBach].EffectiveOwner = Me then
                   Inc(Happy, 1);
               end;
 …
         end;
       end;
+end; // ProcessSettlers
+end;
 //-------------------------------
 …
 procedure TAI.DoTurn;
 var
   emix, i, p1, TaxSum, ScienceSum, NewTaxRate: integer;
   AllHateMe: boolean;
+  emix, I, p1, TaxSum, ScienceSum, NewTaxRate: Integer;
+  AllHateMe: Boolean;
 {$IFDEF PERF}
   PF, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9: int64;
 …
 begin
 {$IFDEF DEBUG}
   fillchar(DebugMap, sizeof(DebugMap), 0);
+  FillChar(DebugMap, SizeOf(DebugMap), 0);
 {$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
+    if (p1 <> Me) and (1 shl p1 and RO.Alive <> 0) and (RO.Treaty[p1] < trPeace) then
       Inc(WarNations, 1 shl p1);
   BombardingNations := 0;
 …
     CheckGender;
   if G.Difficulty[me] < MaxDiff then // not on beginner level
+  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
+      (1 shl Me or PresenceUnknown) <> 0)) then
     begin
       Data.BehaviorFlags := Data.BehaviorFlags or bBarbarina_Hide;
 …
           begin
             AllHateMe := False;
             break;
+            Break;
           end;
       if AllHateMe then
 …
   else
   begin
     if (RO.TaxRate = 0) or (RO.Money < (TotalPopulation[me] - 4) * 2) then
+    if (RO.TaxRate = 0) or (RO.Money < (TotalPopulation[Me] - 4) * 2) then
       NewTaxRate := RO.TaxRate // don't check decreasing tax
     else
 …
     begin
       SumCities(NewTaxRate, TaxSum, ScienceSum);
       if RO.Money + TaxSum >= (TotalPopulation[me] - 4) then
         break; // enough
+      if RO.Money + TaxSum >= (TotalPopulation[Me] - 4) then
+        Break; // enough
       Inc(NewTaxRate, 10);
     end;
 …
     // research completed
     for p1 := 0 to nPl - 1 do
       if (p1 <> me) and (1 shl p1 and RO.Alive <> 0) and
+      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;
+        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
 …
   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;
+  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
 …
   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)
+  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);*)
 …
 {$IFDEF DEBUG}
 procedure TAI.TraceAdvanceValues(Nation: integer);
+procedure TAI.TraceAdvanceValues(Nation: Integer);
 var
   ad: integer;
+  ad: Integer;
 begin
   for ad := 0 to nAdv - 1 do
 …
     end;
 end;
 {$ENDIF}
 procedure TAI.CheckGender;
 var
   p1, NewGender: integer;
+  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
+    if (p1 <> Me) and (1 shl p1 and RO.Alive <> 0) and
       (RO.Treaty[p1] >= trFriendlyContact) then
       if PlayerHash[me] > PlayerHash[p1] then
+      if PlayerHash[Me] > PlayerHash[p1] then
       begin
         if NewGender = bMale then
         begin
           NewGender := -2;
           break;
+          Break;
         end; // ambiguous, don't change gender
         NewGender := bFemale;
 …
         begin
           NewGender := -2;
           break;
+          Break;
         end; // ambiguous, don't change gender
         NewGender := bMale;
 …
 end;
 procedure TAI.SetAdvanceValues;
   procedure RateResearchAdv(ad, Time: integer);
+  procedure RateResearchAdv(ad, Time: Integer);
   var
     Value: integer;
+    Value: Integer;
   begin
     if Time = 0 then
 …
   end;
   procedure SetPreqValues(ad, Value: integer);
+  procedure SetPreqValues(ad, Value: Integer);
   begin
     if (RO.Tech[ad] < tsSeen) and (ad <> RO.ResearchTech) then
 …
   end;
   procedure RateImpPreq(iix, Value: integer);
+  procedure RateImpPreq(iix, Value: Integer);
   begin
     if (Value > 0) and (Imp[iix].Preq >= 0) then
 …
 var
   emix, cix, adMissing, iad, ad, Count, i, Time, d, CurrentCost,
   CurrentStrength, MaxSize, MaxTrade: integer;
   PreView, Emergency, Bombarded: boolean;
+  emix, cix, adMissing, iad, ad, Count, I, Time, D, CurrentCost,
+  CurrentStrength, MaxSize, MaxTrade: Integer;
+  PreView, Emergency, Bombarded: Boolean;
 begin
   if AdvanceValuesSet then
     exit;
+    Exit;
   AdvanceValuesSet := True;
   fillchar(AdvanceValue, sizeof(AdvanceValue), 0);
+  FillChar(AdvanceValue, SizeOf(AdvanceValue), 0);
   // rate techs to ensure research progress
 …
       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
+        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
 …
           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);
+            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);
 …
       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
+        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);
+            RateResearchAdv(AdvPreq[ad, I], Time);
             Inc(Count);
           end;
 …
   // rate military techs
   for d := 0 to nDomains - 1 do
+  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
+      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
 …
               else
               begin // rate
                 if (i > 0) and (Trans > 0) then
+                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))
+                  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));
+                  Inc(AdvanceValue[Preq], (4 - D) * Strength * $200 div
+                    (CurrentStrength + Upgrade[D, 0].Strength));
               end;
   end;
 …
 procedure TAI.AnalyzeMap;
 var
   cix, Loc, Loc1, V8, f1, p1: integer;
+  cix, Loc, Loc1, V8, f1, p1: Integer;
   Adjacent: TVicinity8Loc;
 begin
 …
   // collect nation presence information for continents and oceans
   fillchar(ContinentPresence, sizeof(ContinentPresence), 0);
   fillchar(OceanPresence, sizeof(OceanPresence), 0);
+  FillChar(ContinentPresence, SizeOf(ContinentPresence), 0);
+  FillChar(OceanPresence, SizeOf(OceanPresence), 0);
   for Loc := 0 to MapSize - 1 do
   begin
 …
   end;
   fillchar(TotalPopulation, sizeof(TotalPopulation), 0);
   fillchar(ContinentPopulation, sizeof(ContinentPopulation), 0);
   fillchar(DistrictPopulation, 4 * nDistrict, 0);
+  FillChar(TotalPopulation, SizeOf(TotalPopulation), 0);
+  FillChar(ContinentPopulation, SizeOf(ContinentPopulation), 0);
+  FillChar(DistrictPopulation, 4 * nDistrict, 0);
   // count population
 …
       if Loc >= 0 then
       begin
         Inc(TotalPopulation[me], Size);
         assert(District[Loc] >= 0);
+        Inc(TotalPopulation[Me], Size);
+        Assert(District[Loc] >= 0);
         if District[Loc] < maxCOD then
           Inc(DistrictPopulation[District[Loc]], Size);
 …
 procedure TAI.CollectModelCatStat;
 var
   i, uix, Cat, mix, Quality: integer;
+  I, uix, Cat, mix, Quality: Integer;
 begin
   // categorize models
 …
         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);
+          I := Formation[Loc];
+          if (I >= 0) and (I < maxCOD) then
+            OceanWithShip := OceanWithShip or (1 shl I);
         end;
 end;
 procedure TAI.MoveUnitsHome;
 const
   PatrolDestination = lxmax * lymax;
   FirstSurplusLoop: array[mctGroundDefender..mctGroundAttacker] of integer = (2, 1);
+  FirstSurplusLoop: array[mctGroundDefender..mctGroundAttacker] of Integer = (2, 1);
 var
   Cat, i, mix, cix, uix, Loop, nModelOrder: integer;
+  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;
+  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;
+    Loc1, V8: Integer;
     Adjacent: TVicinity8Loc;
   begin
 …
           begin
             Result := True;
             exit;
+            Exit;
           end;
         end;
 …
   end;
   procedure TryUtilize(uix: integer);
+  procedure TryUtilize(uix: Integer);
   var
     cix, ProdCost, UtilizeCost: integer;
+    cix, ProdCost, UtilizeCost: Integer;
   begin
     if (MyUnit[uix].Health = 100) and (Map[MyUnit[uix].Loc] and
 …
           UtilizeCost := MyModel[MyUnit[uix].mix].Cost;
           if Prod < (ProdCost - UtilizeCost * 2 div 3) *
             BuildCostMod[G.Difficulty[me]] div 12 then
+            BuildCostMod[G.Difficulty[Me]] div 12 then
             Unit_Disband(uix);
         end;
 …
   end;
   procedure FindDestination(uix: integer);
+  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);
+    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
 …
         if (District[Loc1] >= 0) and (District[Loc1] < maxCOD) then
         begin
           assert(DistrictNeed[District[Loc1]] > 0);
+          Assert(DistrictNeed[District[Loc1]] > 0);
           Dec(DistrictNeed[District[Loc1]]);
         end;
         Destination[uix] := Loc1;
         break;
+        Break;
       end;
       Reached[Loc1] := True;
 …
       begin
         NextLoc := Adjacent[V8];
         if (NextLoc >= 0) and not Reached[NextLoc] and (RO.Territory[NextLoc] = me) then
+        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
 …
               Reached[NextLoc] := True; // don't check moving there again
             csCheckTerritory:
               assert(False);
+              Assert(False);
           end;
       end;
 …
           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;
+  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
 …
       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;
+        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;
 …
               TryUtilize(uix);
       fillchar(LocNeed, MapSize, 0);
       fillchar(DistrictNeed, sizeof(DistrictNeed), 0);
+      FillChar(LocNeed, MapSize, 0);
+      FillChar(DistrictNeed, SizeOf(DistrictNeed), 0);
       for cix := 0 to RO.nCity - 1 do
 …
         for uix := 0 to RO.nUn - 1 do
           with MyUnit[uix] do
             if (Loc >= 0) and (Job = jCity) and (RO.Territory[Loc] = me) then
+            if (Loc >= 0) and (Job = jCity) and (RO.Territory[Loc] = Me) then
             begin
               LocNeed[Loc] := 1;
 …
       complete := Loop >= FirstSurplusLoop[Cat];
       for i := nModelOrder - 1 downto 0 do
+      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
+              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
 …
         for uix := 0 to RO.nUn - 1 do
           with MyUnit[uix] do
             if (mix = ModelOrder[i]) and (Loc >= 0) and (Destination[uix] < 0) and
+            if (mix = ModelOrder[I]) and (Loc >= 0) and (Destination[uix] < 0) and
               (Master < 0) then
               if (District[Loc] >= 0) and (District[Loc] < maxCOD) and
 …
   // distribute obsolete settlers
   repeat
     fillchar(LocNeed, MapSize, 0);
     fillchar(DistrictNeed, sizeof(DistrictNeed), 0);
+    FillChar(LocNeed, MapSize, 0);
+    FillChar(DistrictNeed, SizeOf(DistrictNeed), 0);
     for cix := 0 to RO.nCity - 1 do
 …
   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
+      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
 …
             Dec(UnitLack[District[Loc], ModelCat[mix]])
         end;
+end; // MoveUnitsHome
+procedure TAI.CheckAttack(uix: integer);
+end;
+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;
+  MoveResult, AttackResult, MoveStyle, NextTime, RecoverTurns: Integer;
+  Tile: Cardinal;
+  Exhausted: Boolean;
   Adjacent: TVicinity8Loc;
   Reached: array[0..lxmax * lymax - 1] of boolean;
+  Reached: array[0..lxmax * lymax - 1] of Boolean;
 begin
 …
       AttackScore := -999999;
       AttackLoc := -1;
       fillchar(Reached, MapSize, False);
+      FillChar(Reached, MapSize, False);
       Pile.Create(MapSize);
       Pile.Put(Loc, $800 - Movement);
 …
         if ((Tile and fUnit) <> 0) and ((Tile and fOwned) = 0) then
         begin // enemy unit
           assert(TestTime < $1000);
+          Assert(TestTime < $1000);
           Unit_FindEnemyDefender(TestLoc, euix);
           if RO.Treaty[RO.EnemyUn[euix].Owner] < trPeace then
 …
     until Exhausted;
   end;
+end; // CheckAttack
+procedure TAI.Patrol(uix: integer);
+end;
+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;
+  TestScore, OldLoc, MoveResult, MoveStyle, NextTime, RecoverTurns: Integer;
+  Tile: Cardinal;
+  Exhausted, CaptureOnly: Boolean;
   Adjacent: TVicinity8Loc;
   AdjacentUnknown: array[0..lxmax * lymax - 1] of shortint;
+  AdjacentUnknown: array[0..lxmax * lymax - 1] of ShortInt;
 begin
 …
           // assume a score of 50 is the best achievable
           or CaptureOnly and (TestTime >= $1000) then
           break;
+          Break;
         TestScore := 0;
 …
     until Exhausted;
   end;
 end; // Patrol
+end;
 procedure TAI.AttackAndPatrol;
 const
   nAttackCatOrder = 3;
   AttackCatOrder: array[0..nAttackCatOrder - 1] of integer =
+  AttackCatOrder: array[0..nAttackCatOrder - 1] of Integer =
     (mctGroundAttacker, mctCruiser, mctGroundDefender);
 var
   iCat, uix, uix1: integer;
   IsPatrolUnit, Fortified: boolean;
+  iCat, uix, uix1: Integer;
+  IsPatrolUnit, Fortified: Boolean;
 begin
   for uix := 0 to RO.nUn - 1 do
 …
               CheckAttack(uix);
   fillchar(uixPatrol, sizeof(uixPatrol), $FF);
+  FillChar(uixPatrol, SizeOf(uixPatrol), $FF);
   for uix := 0 to RO.nUn - 1 do
     with MyUnit[uix], MyModel[mix] do
 …
           Patrol(uix);
       end;
+end; // AttackAndPatrol
+function TAI.HavePort: boolean;
+end;
+function TAI.HavePort: Boolean;
 var
   V8, cix, AdjacentLoc, f: integer;
+  V8, cix, AdjacentLoc, F: Integer;
   Adjacent: TVicinity8Loc;
 begin
 …
           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
+            F := Formation[AdjacentLoc];
+            if (F >= 0) and (F < maxCOD) and (OceanPresence[F] and
+              not (1 shl Me) <> 0) then
               Result := True;
           end;
 …
       end;
 end;
 procedure TAI.SetCityProduction;
 var
   uix, cix, iix, dtr, V8, V21, NewImprovement, AdjacentLoc, MaxSettlers,
   maxcount, cixMilAcademy: integer;
   TerrType: cardinal;
+  maxcount, cixMilAcademy: Integer;
+  TerrType: Cardinal;
   IsPort, IsNavalBase, NeedCruiser, CheckProd, Destructed, ProduceSettlers,
   ProduceMil: boolean;
+  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);
+  HomeCount, CityProdRep: array[0..nCmax - 1] of Integer;
+  MilProdCity: array[0..nCmax - 1] of Boolean;
+  procedure TryBuild(Improvement: Integer);
   begin
     if (NewImprovement = imTrGoods) // not already improvement of higher priority found
 …
   end;
   procedure TryDestruct(Improvement: integer);
+  procedure TryDestruct(Improvement: Integer);
   begin
     if Destructed or (MyCity[cix].Built[Improvement] = 0) then
       exit;
+      Exit;
     if City_CurrentImprovementProject(cix) >= 0 then
       City_RebuildImprovement(cix, Improvement)
 …
       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}
+      *BuildCostMod[G.Difficulty[Me]]>MyCity[cix].Prod*(12*3)) then}
     Destructed := True;
   end;
   function ChooseBuildModel(Cat: integer): integer;
+  function ChooseBuildModel(Cat: Integer): Integer;
   var
     Count, mix: integer;
+    Count, mix: Integer;
   begin
     Count := 0;
 …
           Result := mix;
       end;
     assert(Count > 0);
+    Assert(Count > 0);
   end;
 …
   // find military production cities
   var
     cix, Total, d, Threshold, NewThreshold, Share, SharePlus, cixWorst: integer;
   begin
     fillchar(MilProdCity, RO.nCity, 0);
+    cix, Total, D, Threshold, NewThreshold, Share, SharePlus, cixWorst: Integer;
+  begin
+    FillChar(MilProdCity, RO.nCity, 0);
     GetCityProdPotential;
     for d := 0 to maxCOD - 1 do
+    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
+          if (Loc >= 0) and (District[Loc] = D) then
             Total := Total + CityResult[cix];
       if Total = 0 then
 …
       for cix := 0 to RO.nCity - 1 do
         with MyCity[cix] do
           if (Loc >= 0) and (District[Loc] = d) and
+          if (Loc >= 0) and (District[Loc] = D) and
             (Built[imBarracks] + Built[imMilAcademy] > 0) then
           begin
 …
         for cix := 0 to RO.nCity - 1 do
           with MyCity[cix] do
             if (Loc >= 0) and (District[Loc] = d) and
+            if (Loc >= 0) and (District[Loc] = D) and
               (Built[imBarracks] + Built[imMilAcademy] = 0) and
               (Built[imObservatory] = 0) and (CityResult[cix] < Threshold) and
 …
       for cix := 0 to RO.nCity - 1 do
         with MyCity[cix] do
           if (Loc >= 0) and (District[Loc] = d) and
+          if (Loc >= 0) and (District[Loc] = D) and
             (Built[imBarracks] + Built[imMilAcademy] = 0) and
             (CityResult[cix] >= Threshold) then
 …
 {    if (cixWorst>=0)
       and (Share-CityResult[cixWorst]*2>=Total*MilProdShare div 100) then
       MilProdCity[cixWorst]:=false;}
+      MilProdCity[cixWorst]:=False;}
     end;
 …
     if cixStateImp[imPalace] >= 0 then
     begin
       d := District[MyCity[cixStateImp[imPalace]].Loc];
       if (d >= 0) and (d < maxCOD) then
+      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
+            if (Loc >= 0) and (District[Loc] = D) and
               (Built[imObservatory] + Built[imPalace] = 0) and
               ((cixMilAcademy < 0) or (CityResult[cix] > CityResult[cixMilAcademy])) then
 …
   procedure ChangeHomeCities;
   var
     uix, NewHome, HomeSupport, NewHomeSupport, SingleSupport: integer;
+    uix, NewHome, HomeSupport, NewHomeSupport, SingleSupport: Integer;
   begin
     if RO.Government in [gAnarchy, gFundamentalism] then
       exit;
+      Exit;
     for uix := 0 to RO.nUn - 1 do
       with MyUnit[uix] do
 …
 begin
   fillchar(HomeCount, 4 * RO.nCity, 0);
+  FillChar(HomeCount, 4 * RO.nCity, 0);
   for uix := 0 to RO.nUn - 1 do
     with MyUnit[uix] do
 …
                     begin
                       TryBuild(imHarbor);
                       break;
+                      Break;
                     end;
                   end;
 …
               TryBuild(imRecycling);
             if (Report.Trade - Report.Corruption >= 11) and
               (RO.Money < TotalPopulation[me] * 2) then
+              (RO.Money < TotalPopulation[Me] * 2) then
               TryBuild(imBank);
             if (RO.NatBuilt[imStockEx] = 0) and
 …
           // rebuild imps no longer needed
           if (RO.TaxRate = 0) and (RO.Money >= TotalPopulation[me] * 4) then
+          if (RO.TaxRate = 0) and (RO.Money >= TotalPopulation[Me] * 4) then
             TryDestruct(imBank)
           else if Report.Happy * 2 >= Size + 6 then
 …
   ChangeHomeCities;
+end; // SetCityProduction
+function TAI.ChooseGovernment: integer;
+end;
+function TAI.ChooseGovernment: Integer;
 begin
   if Data.BehaviorFlags and bBarbarina <> 0 then
 …
 end;
 //-------------------------------
 //           DIPLOMACY
 //-------------------------------
 function TAI.MostWanted(Nation, adGiveAway: integer): integer;
+function TAI.MostWanted(Nation, adGiveAway: Integer): Integer;
 var
   ad: integer;
+  ad: Integer;
 begin
   Result := -1;
 …
 end;
 procedure TAI.FindBestTrade(Nation: integer; var adWanted, adGiveAway: integer);
+procedure TAI.FindBestTrade(Nation: Integer; var adWanted, adGiveAway: Integer);
 var
   i, ad, ead, adTestGiveAway: integer;
+  I, ad, ead, adTestGiveAway: Integer;
 begin
   adWanted := -1;
 …
     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
+      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
 …
 end;
+function TAI.WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
+function TAI.WantNegotiation(Nation: Integer; NegoTime: TNegoTime): Boolean;
 var
   p1, Count, adWanted, adGiveAway: integer;
+  p1, Count, adWanted, adGiveAway: Integer;
 begin
   if Data.BehaviorFlags and bBarbarina = bBarbarina then
   begin
     Result := Barbarina_WantNegotiation(Nation, NegoTime);
     exit;
+    Exit;
   end;
 …
     begin
       Result := False;
       exit;
+      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
+      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;
+      Exit;
     end;
   end;
 …
 procedure TAI.DoNegotiation;
 var
   i, adWanted, adGiveAway, adToGet, Slot: integer;
   BuildFreeOffer: boolean;
+  I, adWanted, adGiveAway, adToGet, Slot: Integer;
+  BuildFreeOffer: Boolean;
 begin
   if MyLastAction = scDipOffer then
 …
   begin
     Barbarina_DoNegotiation;
     exit;
+    Exit;
   end;
 …
   begin
     Barbarina_DoCheckNegotiation;
     exit;
+    Exit;
   end;
 …
       (OppoOffer.nDeliver + OppoOffer.nCost = 1) and
       (OppoOffer.Price[0] and opMask = opTreaty) and
       (integer(OppoOffer.Price[0] - opTreaty) > RO.Treaty[Opponent]) 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.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
+      opCivilReport + Cardinal(Me) shl 16) then
       MyAction := scDipAccept // accept exchange of civil reports
     else if (OppoOffer.nDeliver = 1) and (OppoOffer.nCost = 1) and
 …
         adWanted := MostWanted(Opponent, OppoOffer.Price[1] - opTech);
         if (OppoOffer.Price[0] and opMask = opTech) and
           (cardinal(adWanted) = OppoOffer.Price[0] - opTech) then
+          (Cardinal(adWanted) = OppoOffer.Price[0] - opTech) then
           MyAction := scDipAccept // opponent's offer is already perfect
         else if adWanted >= 0 then
 …
         MyOffer.Price[1] := opTech + adWanted;
         MyAction := scDipOffer;
         for i := 0 to nRequestedTechs - 1 do
           if Data.RequestedTechs[i] < 0 then
+        for I := 0 to nRequestedTechs - 1 do
+          if Data.RequestedTechs[I] < 0 then
           begin
             Slot := i;
             break;
+            Slot := I;
+            Break;
           end
           else if (i = 0) or (Data.RequestedTechs[i] shr 16 <
+          else if (I = 0) or (Data.RequestedTechs[I] shr 16 <
             Data.RequestedTechs[Slot] shr 16) then // find most outdated entry
             Slot := i;
+            Slot := I;
         Data.RequestedTechs[Slot] := RO.Turn shl 16 + Opponent shl 8 + adWanted;
       end;
     end;
   end;
+end; // Negotiation
+end;
 procedure SetLeaveOutValue;
   procedure Process(ad: integer);
+  procedure Process(ad: Integer);
   var
     i: integer;
+    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);
+      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;
 …
 var
   ad: integer;
+  ad: Integer;
 begin
   FillChar(LeaveOutValue, SizeOf(LeaveOutValue), $FF);
 …
 initialization
   RWDataSize := sizeof(TPersistentData);
+  RWDataSize := SizeOf(TPersistentData);
   SetLeaveOutValue;

branches/highdpi/AI/StdAI/Barbarina.pas

-              r349
+              r465
 type
   TColonyShipPlan = array[0..nShipPart - 1] of record
     cixProducing: integer;
     LocResource: array[0..maxModern - 1] of integer;
     nLocResource: integer;
     LocFoundCity: array[0..maxModern - 1] of integer;
     nLocFoundCity: integer;
+    cixProducing: Integer;
+    LocResource: array[0..maxModern - 1] of Integer;
+    nLocResource: Integer;
+    LocFoundCity: array[0..maxModern - 1] of Integer;
+    nLocFoundCity: Integer;
   end;
   TBarbarina = class(TToolAI)
     constructor Create(Nation: integer); override;
+    constructor Create(Nation: Integer); override;
   protected
     ColonyShipPlan: TColonyShipPlan;
     function Barbarina_GoHidden: boolean; // whether we should prepare for barbarina mode
     function Barbarina_Go: boolean; // whether we should switch to barbarina mode now
+    function Barbarina_GoHidden: Boolean; // whether we should prepare for barbarina mode
+    function Barbarina_Go: Boolean; // whether we should switch to barbarina mode now
     procedure Barbarina_DoTurn;
     procedure Barbarina_SetCityProduction;
     function Barbarina_ChooseResearchAdvance: integer;
     function Barbarina_WantCheckNegotiation(Nation: integer): boolean;
+    function Barbarina_ChooseResearchAdvance: Integer;
+    function Barbarina_WantCheckNegotiation(Nation: Integer): Boolean;
     procedure Barbarina_DoCheckNegotiation;
     function Barbarina_WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
+    function Barbarina_WantNegotiation(Nation: Integer; NegoTime: TNegoTime): Boolean;
     procedure Barbarina_DoNegotiation;
     procedure MakeColonyShipPlan;
   private
     TurnOfMapAnalysis, Neighbours: integer;
     ContinentPresence: array[0..maxCOD - 1] of integer;
     OceanPresence: array[0..maxCOD - 1] of integer;
     ContinentSize: array[0..maxCOD - 1] of integer;
     OceanSize: array[0..maxCOD - 1] of integer;
     mixBest: array[0..nModelCategory - 1] of integer;
+    TurnOfMapAnalysis, Neighbours: Integer;
+    ContinentPresence: array[0..maxCOD - 1] of Integer;
+    OceanPresence: array[0..maxCOD - 1] of Integer;
+    ContinentSize: array[0..maxCOD - 1] of Integer;
+    OceanSize: array[0..maxCOD - 1] of Integer;
+    mixBest: array[0..nModelCategory - 1] of Integer;
     NegoCause: (CancelTreaty);
     function IsModelAvailable(rmix: integer): boolean;
+    function IsModelAvailable(rmix: Integer): Boolean;
     procedure FindBestModels;
     procedure AnalyzeMap;
     procedure RateAttack(uix: integer);
     function DoAttack(uix, AttackLoc: integer): boolean;
     function ProcessMove(uix: integer): boolean;
+    procedure RateAttack(uix: Integer);
+    function DoAttack(uix, AttackLoc: Integer): Boolean;
+    function ProcessMove(uix: Integer): Boolean;
     procedure AttackAndPatrol;
   end;
 …
 type
   TResearchModel = record
     Category, Domain, Weight, adStop, FutMStrength: integer;
     Upgrades: cardinal;
     Cap: array [0..nFeature - 1] of integer;
+    Category, Domain, Weight, adStop, FutMStrength: Integer;
+    Upgrades: Cardinal;
+    Cap: array [0..nFeature - 1] of Integer;
   end;
 …
   nResearchOrder = 40;
   ResearchOrder: array[0..nResearchOrder - 1] of integer =
+  ResearchOrder: array[0..nResearchOrder - 1] of Integer =
     (adBronzeWorking, -adMapMaking, adChivalry, adMonotheism, adIronWorking,
     adGunPowder, adTheology, adConstruction, adCodeOfLaws, -adEngineering,
 …
 var
   Moved: array[0..numax - 1] of boolean;
   UnitPresence: array[0..lxmax * lymax - 1] of byte;
+  Moved: array[0..numax - 1] of Boolean;
+  UnitPresence: array[0..lxmax * lymax - 1] of Byte;
   euixMap: array[0..lxmax * lymax - 1] of smallint;
   uixAttack: array[0..neumax - 1] of smallint;
   AttackScore: array[0..neumax - 1] of integer;
 constructor TBarbarina.Create(Nation: integer);
+  AttackScore: array[0..neumax - 1] of Integer;
+constructor TBarbarina.Create(Nation: Integer);
 begin
   inherited;
 …
 // whether one of the existing models matches a specific research model
 function TBarbarina.IsModelAvailable(rmix: integer): boolean;
+function TBarbarina.IsModelAvailable(rmix: Integer): Boolean;
 var
   i, mix, MStrength: integer;
+  I, mix, MStrength: Integer;
 begin
   Result := False;
 …
         Result := MStrength < (MyModel[mix].MStrength * 3) div 2;
         // for future techs: don't count model available if 50% stronger possible
         for i := 0 to nFeature - 1 do
           if MyModel[mix].Cap[i] < Cap[i] then
+        for I := 0 to nFeature - 1 do
+          if MyModel[mix].Cap[I] < Cap[I] then
           begin
             Result := False;
             break;
+            Break;
           end;
         if Result then
           break;
+          Break;
       end;
   end;
 end;
 function TBarbarina.Barbarina_GoHidden: boolean;
+function TBarbarina.Barbarina_GoHidden: Boolean;
 var
   V21, Loc1, cix: integer;
+  V21, Loc1, cix: Integer;
   Radius: TVicinity21Loc;
 begin
 …
 end;
 function TBarbarina.Barbarina_Go: boolean;
+function TBarbarina.Barbarina_Go: Boolean;
 begin
   if IsResearched(adMassProduction) then
 …
     Result := (RO.nCity >= 3) and IsResearched(adMapMaking) and
       IsModelAvailable(EntryModel_Base);
     exit;
+    Exit;
   end;
   Result := Result and ((RO.nUn >= RO.nCity * 3) or
     (RO.Wonder[woZeus].EffectiveOwner = me));
+    (RO.Wonder[woZeus].EffectiveOwner = Me));
 end;
 procedure TBarbarina.AnalyzeMap;
 var
   Loc, Loc1, V8, f1, p1, cix: integer;
+  Loc, Loc1, V8, f1, p1, cix: Integer;
   Adjacent: TVicinity8Loc;
 begin
   if TurnOfMapAnalysis = RO.Turn then
     exit;
+    Exit;
   // inherited;
   // collect nation presence information for continents and oceans
   fillchar(ContinentPresence, sizeof(ContinentPresence), 0);
   fillchar(OceanPresence, sizeof(OceanPresence), 0);
   fillchar(ContinentSize, sizeof(ContinentSize), 0);
   fillchar(OceanSize, sizeof(OceanSize), 0);
+  FillChar(ContinentPresence, SizeOf(ContinentPresence), 0);
+  FillChar(OceanPresence, SizeOf(OceanPresence), 0);
+  FillChar(ContinentSize, SizeOf(ContinentSize), 0);
+  FillChar(OceanSize, SizeOf(OceanSize), 0);
   for Loc := 0 to MapSize - 1 do
   begin
 …
 procedure TBarbarina.FindBestModels;
 var
   i, mix, rmix, cat: integer;
+  I, mix, rmix, cat: Integer;
 begin
   for i := 0 to nModelCategory - 1 do
     mixBest[i] := -1;
+  for I := 0 to nModelCategory - 1 do
+    mixBest[I] := -1;
   for rmix := nResearchModel - 1 downto 0 do
     with ResearchModel[rmix] do
 …
           begin
             mixBest[Category] := mix;
             for i := 0 to nFeature - 1 do
               if MyModel[mix].Cap[i] < Cap[i] then
+            for I := 0 to nFeature - 1 do
+              if MyModel[mix].Cap[I] < Cap[I] then
               begin
                 mixBest[Category] := -1;
                 break;
+                Break;
               end;
             if mixBest[Category] >= 0 then
               break;
+              Break;
           end;
   for mix := 3 to RO.nModel - 1 do
 …
       begin
         mixBest[ctSeaTrans] := mix;
         break;
+        Break;
       end;
 end;
 …
 // find one unit to destroy each known enemy unit, result in uixAttack
 procedure TBarbarina.RateAttack(uix: integer);
+procedure TBarbarina.RateAttack(uix: Integer);
 var
   MoveStyle, TestLoc, TestTime, NextLoc, NextTime, V8, RemHealth,
   RecoverTurns, Score, BestScore, euixBest, uixOld: integer;
   NextTile: cardinal;
+  RecoverTurns, Score, BestScore, euixBest, uixOld: Integer;
+  NextTile: Cardinal;
   Adjacent: TVicinity8Loc;
   Defense: ^TUnitInfo;
   Reached: array[0..lxmax * lymax - 1] of boolean;
+  Reached: array[0..lxmax * lymax - 1] of Boolean;
 begin
   with MyUnit[uix] do
 …
     begin
       BestScore := 0;
       fillchar(Reached, MapSize, False);
+      FillChar(Reached, MapSize, False);
       MoveStyle := GetMyMoveStyle(mix, Health);
       Pile.Create(MapSize);
 …
 end;
 function TBarbarina.DoAttack(uix, AttackLoc: integer): boolean;
+function TBarbarina.DoAttack(uix, AttackLoc: Integer): Boolean;
   // AttackLoc=maNextCity means bombard only
 var
   MoveResult, Kind, Temp, MoveStyle, TestLoc, TestTime, NextLoc,
   NextTime, V8, RecoverTurns, ecix: integer;
   NextTile: cardinal;
   AttackPositionReached, IsBombardment: boolean;
+  NextTime, V8, RecoverTurns, ecix: Integer;
+  NextTile: Cardinal;
+  AttackPositionReached, IsBombardment: Boolean;
   Adjacent: TVicinity8Loc;
   PreLoc: array[0..lxmax * lymax - 1] of word;
   Reached: array[0..lxmax * lymax - 1] of boolean;
+  PreLoc: array[0..lxmax * lymax - 1] of Word;
+  Reached: array[0..lxmax * lymax - 1] of Boolean;
 begin
   Result := False;
 …
     else
       Kind := 0;
     fillchar(Reached, MapSize, False);
+    FillChar(Reached, MapSize, False);
     AttackPositionReached := False;
     MoveStyle := GetMyMoveStyle(mix, Health);
 …
     begin
       if (TestTime >= $800) or (AttackLoc = maNextCity) and (TestTime > $800 - 100) then
         break;
+        Break;
       Reached[TestLoc] := True;
       V8_to_Loc(TestLoc, Adjacent);
 …
           begin
             City_FindEnemyCity(NextLoc, ecix);
             assert(ecix >= 0);
+            Assert(ecix >= 0);
             with RO.EnemyCity[ecix] do
               if (Size > 2) and (Flags and ciCoastalFort = 0) then
 …
           begin
             AttackPositionReached := True;
             break;
+            Break;
           end
           else if not Reached[NextLoc] then
 …
       begin
         PreLoc[NextLoc] := TestLoc;
         break;
+        Break;
       end;
     end;
     Pile.Free;
     if not AttackPositionReached then
       exit;
+      Exit;
     TestLoc := AttackLoc;
 …
     begin
       City_FindEnemyCity(AttackLoc, ecix);
       assert(ecix >= 0);
+      Assert(ecix >= 0);
       while (Movement >= 100) and (RO.EnemyCity[ecix].Size > 2) do
         Unit_Step(uix, AttackLoc);
 …
 end;
 function TBarbarina.ProcessMove(uix: integer): boolean;
+function TBarbarina.ProcessMove(uix: Integer): Boolean;
   // return true if no new enemy spotted
 const
 …
   PatrolScore, BestCount, PatrolLoc, TestLoc, NextLoc, TestTime, V8,
   TestScore, MoveResult, MoveStyle, NextTime, TerrOwner, Kind, Temp,
   RecoverTurns, MaxScore: integer;
   Tile, NextTile: cardinal;
   CaptureOnly, PeaceBorder, done, NextToEnemyCity: boolean;
+  RecoverTurns, MaxScore: Integer;
+  Tile, NextTile: Cardinal;
+  CaptureOnly, PeaceBorder, done, NextToEnemyCity: Boolean;
   Adjacent: TVicinity8Loc;
   AdjacentUnknown: array[0..lxmax * lymax - 1] of shortint;
   PreLoc: array[0..lxmax * lymax - 1] of word;
   MoreTurn: array[0..lxmax * lymax - 1] of byte;
+  AdjacentUnknown: array[0..lxmax * lymax - 1] of ShortInt;
+  PreLoc: array[0..lxmax * lymax - 1] of Word;
+  MoreTurn: array[0..lxmax * lymax - 1] of Byte;
 begin
 …
         if Map[Loc] and fCity = 0 then
           Unit_MoveEx(uix, maNextCity);
         exit;
+        Exit;
       end;
 …
           // assume a score of $400 is the best achievable
           or CaptureOnly and (TestTime >= $1000) then
           break;
+          Break;
         TestScore := 0;
         Tile := Map[TestLoc];
         assert(Tile and (fUnit or fOwned) <> fUnit);
+        Assert(Tile and (fUnit or fOwned) <> fUnit);
         TerrOwner := RO.Territory[TestLoc];
         AdjacentUnknown[TestLoc] := 0;
 …
               TestScore := $400 - 14
             else if AdjacentUnknown[TestLoc] > 0 then
               if PeaceBorder or (TerrOwner >= 0) and (TerrOwner <> me) and
+              if PeaceBorder or (TerrOwner >= 0) and (TerrOwner <> Me) and
                 (RO.Treaty[TerrOwner] < trPeace) then
                 TestScore := $400 - 32 + AdjacentUnknown[TestLoc]
 …
         end;
         if PatrolLoc = Loc then
           exit;
+          Exit;
         TestLoc := PatrolLoc;
         NextLoc := PreLoc[TestLoc];
 …
             Result := MoveResult and rEnemySpotted = 0;
             done := True;
             break;
           end;
           assert(Loc = NextLoc);
+            Break;
+          end;
+          Assert(Loc = NextLoc);
         end;
         if Loc >= 0 then
 …
   if Result then
     Moved[uix] := True;
 end; // ProcessMove
+end;
 procedure TBarbarina.AttackAndPatrol;
 …
   procedure SetCityDefenders;
   var
     uix, cix, V8, Loc1, Best, uixBest, det: integer;
+    uix, cix, V8, Loc1, Best, uixBest, det: Integer;
     Adjacent: TVicinity8Loc;
     IsPort: boolean;
+    IsPort: Boolean;
   begin
     for cix := 0 to RO.nCity - 1 do
 …
   procedure ProcessSeaTransport;
   var
     i, f, uix, Loc1, a, b: integer;
     ready, go: boolean;
+    I, F, uix, Loc1, A, B: Integer;
+    ready, go: Boolean;
     TransportPlan: TGroupTransportPlan;
   begin
     go := False;
     for f := 0 to maxCOD - 1 do
       if (f < nContinent) and (ContinentPresence[f] and not
         (1 shl me or PresenceUnknown) <> 0) then
+    for F := 0 to maxCOD - 1 do
+      if (F < nContinent) and (ContinentPresence[F] and not
+        (1 shl Me or PresenceUnknown) <> 0) then
         go := True; // any enemy island known?
     if not go then
       exit;
+      Exit;
     SeaTransport_BeginInitialize;
 …
             (MyModel[mix].Attack > 0) and (Map[Loc] and fTerrain >= fGrass) then
           begin
             f := Formation[Loc];
             if (f >= 0) and (f < maxCOD) and (ContinentPresence[f] and
               not (1 shl me) = 0) then
+            F := Formation[Loc];
+            if (F >= 0) and (F < maxCOD) and (ContinentPresence[F] and
+              not (1 shl Me) = 0) then
             begin
               go := True;
 …
         if Map[Loc1] and fTerrain >= fGrass then
         begin
           f := Formation[Loc1];
           if (f >= 0) and (f < maxCOD) and (ContinentPresence[f] and
             not (1 shl me or PresenceUnknown) <> 0) then
+          F := Formation[Loc1];
+          if (F >= 0) and (F < maxCOD) and (ContinentPresence[F] and
+            not (1 shl Me or PresenceUnknown) <> 0) then
             SeaTransport_AddDestination(Loc1);
         end;
 …
       end;
       if ready then
         for i := 0 to TransportPlan.nLoad - 1 do
+        for I := 0 to TransportPlan.nLoad - 1 do
         begin
           Loc_to_ab(TransportPlan.LoadLoc,
             MyUnit[TransportPlan.uixLoad[i]].Loc, a, b);
           ready := ready and (abs(a) <= 1) and (abs(b) <= 1);
+            MyUnit[TransportPlan.uixLoad[I]].Loc, A, B);
+          ready := ready and (abs(A) <= 1) and (abs(B) <= 1);
         end;
       if ready then
       begin
         for i := 0 to TransportPlan.nLoad - 1 do
         begin
           Unit_Step(TransportPlan.uixLoad[i], TransportPlan.LoadLoc);
           Moved[TransportPlan.uixLoad[i]] := True;
+        for I := 0 to TransportPlan.nLoad - 1 do
+        begin
+          Unit_Step(TransportPlan.uixLoad[I], TransportPlan.LoadLoc);
+          Moved[TransportPlan.uixLoad[I]] := True;
         end;
       end
       else
       begin
         for i := 0 to TransportPlan.nLoad - 1 do
         begin
           Unit_MoveEx(TransportPlan.uixLoad[i], TransportPlan.LoadLoc, mxAdjacent);
           Moved[TransportPlan.uixLoad[i]] := True;
+        for I := 0 to TransportPlan.nLoad - 1 do
+        begin
+          Unit_MoveEx(TransportPlan.uixLoad[I], TransportPlan.LoadLoc, mxAdjacent);
+          Moved[TransportPlan.uixLoad[I]] := True;
         end;
       end;
 …
   end;
   procedure ProcessUnload(uix: integer);
     procedure Unload(Kind, ToLoc: integer);
+  procedure ProcessUnload(uix: Integer);
+    procedure Unload(Kind, ToLoc: Integer);
     var
       uix1: integer;
+      uix1: Integer;
     begin
       for uix1 := 0 to RO.nUn - 1 do
 …
             Unit_Step(uix1, ToLoc);
             UnitPresence[ToLoc] := UnitPresence[ToLoc] or Kind;
             break;
+            Break;
           end;
     end;
 …
   var
     uix1, MoveStyle, TestLoc, TestTime, NextLoc, NextTime, V8,
     RecoverTurns, nSlow, nFast, SlowUnloadLoc, FastUnloadLoc, EndLoc, f: integer;
     NextTile: cardinal;
+    RecoverTurns, nSlow, nFast, SlowUnloadLoc, FastUnloadLoc, EndLoc, F: Integer;
+    NextTile: Cardinal;
     Adjacent: TVicinity8Loc;
     Reached: array[0..lxmax * lymax - 1] of boolean;
+    Reached: array[0..lxmax * lymax - 1] of Boolean;
   begin
     // inventory
 …
         FastUnloadLoc := -1;
         EndLoc := -1;
         fillchar(Reached, MapSize, False);
+        FillChar(Reached, MapSize, False);
         Pile.Create(MapSize);
         Pile.Put(Loc, $800 - Movement);
 …
               else if NextTile and fTerrain >= fGrass then
               begin
                 f := Formation[NextLoc];
                 if (f >= 0) and (f < maxCOD) and
                   (ContinentPresence[f] and not (1 shl me or PresenceUnknown) <> 0) and
+                F := Formation[NextLoc];
+                if (F >= 0) and (F < maxCOD) and
+                  (ContinentPresence[F] and not (1 shl Me or PresenceUnknown) <> 0) and
                   (NextTile and (fUnit or fOwned) <> fUnit) then
                 begin
 …
         if EndLoc < 0 then
           exit;
+          Exit;
         if Loc <> EndLoc then
           Unit_MoveEx(uix, EndLoc);
         if Loc <> EndLoc then
           exit;
+          Exit;
         if SlowUnloadLoc >= 0 then
         begin
 …
         begin
           Moved[uix] := False;
           exit;
+          Exit;
         end
       until False;
 …
 var
   uix, euix, Kind, euixBest, AttackLoc: integer;
   OldTile: cardinal;
   BackToStart, FirstLoop: boolean;
+  uix, euix, Kind, euixBest, AttackLoc: Integer;
+  OldTile: Cardinal;
+  BackToStart, FirstLoop: Boolean;
 begin
   fillchar(UnitPresence, MapSize, 0);
+  FillChar(UnitPresence, MapSize, 0);
   for uix := 0 to RO.nUn - 1 do
     with MyUnit[uix] do
 …
       end;
   fillchar(Moved, RO.nUn, False);
+  FillChar(Moved, RO.nUn, False);
   for uix := 0 to RO.nUn - 1 do
     if (MyUnit[uix].Master >= 0) or (MyUnit[uix].TroopLoad > 0) then
 …
       if RO.nEnemyUn > 0 then
       begin
         fillchar(euixMap, MapSize * 2, $FF);
         fillchar(AttackScore, RO.nEnemyUn * 4, 0);
+        FillChar(euixMap, MapSize * 2, $FF);
+        FillChar(AttackScore, RO.nEnemyUn * 4, 0);
         for euix := 0 to RO.nEnemyUn - 1 do
           with RO.EnemyUn[euix] do
 …
       end;
       if not BackToStart then
         break;
+        Break;
       for uix := 0 to RO.nUn - 1 do
 …
             euixBest := euix;
         if euixBest < 0 then
           break;
+          Break;
         uix := uixAttack[euixBest];
         AttackLoc := RO.EnemyUn[euixBest].Loc;
 …
             begin
               BackToStart := True;
               break;
+              Break;
             end
   until not BackToStart;
 end; // AttackAndPatrol
+end;
 procedure TBarbarina.Barbarina_SetCityProduction;
 …
 shl woMagellan + 1 shl woEiffel + 1 shl woLiberty + 1 shl woShinkansen;
   function LowPriority(cix: integer): boolean;
+  function LowPriority(cix: Integer): Boolean;
   var
     part, cixHighPriority, TestDistance: integer;
+    part, cixHighPriority, TestDistance: Integer;
   begin
     Result := False;
 …
         begin
           Result := True;
           exit;
+          Exit;
         end;
       end;
 …
   end;
   function ChooseWonderToBuild(WonderAvailable: integer; AllowCoastal: boolean): integer;
+  function ChooseWonderToBuild(WonderAvailable: Integer; AllowCoastal: Boolean): Integer;
   var
     Count, iix: integer;
+    Count, iix: Integer;
   begin
     if (WonderAvailable and PrimeWonder > 0) and (AllowCoastal or
 …
       begin
         Result := iix;
         exit;
+        Exit;
       end;
     end;
 …
 var
   i, iix, cix, mix, uix, mixProduce, mixShip, V8, V21, Loc1, TotalPop,
   AlonePop, f, f1, nTownGuard, ShipPart, ProduceShipPart, TestDistance,
   part, WonderAvailable, WonderInWork, cixNewCapital, Center, Score, BestScore: integer;
   mixCount: array[0..nmmax - 1] of integer;
+  I, iix, cix, mix, uix, mixProduce, mixShip, V8, V21, Loc1, TotalPop,
+  AlonePop, F, f1, nTownGuard, ShipPart, ProduceShipPart, TestDistance,
+  part, WonderAvailable, WonderInWork, cixNewCapital, Center, Score, BestScore: Integer;
+  mixCount: array[0..nmmax - 1] of Integer;
   //RareLoc: array[0..5] of integer;
   Adjacent: TVicinity8Loc;
   IsCoastal, IsPort, IsUnitProjectObsolete, HasSettler, SpezializeShipProduction,
   AlgaeAvailable, ProjectComplete, DoLowPriority, WillProduceColonyShip,
   ImportantCity: boolean;
+  ImportantCity: Boolean;
   Radius: TVicinity21Loc;
   Report: TCityReportNew;
 …
   FindBestModels;
   fillchar(mixCount, RO.nModel * 4, 0);
+  FillChar(mixCount, RO.nModel * 4, 0);
   for uix := 0 to RO.nUn - 1 do
     with MyUnit[uix] do
 …
       begin
         Inc(TotalPop, Size);
         f := Formation[Loc];
         if (f < 0) or (f >= maxCOD) or (ContinentPresence[f] = 1 shl me) then
+        F := Formation[Loc];
+        if (F < 0) or (F >= maxCOD) or (ContinentPresence[F] = 1 shl Me) then
           Inc(AlonePop, Size);
       end;
 …
               if (f1 >= 0) and (f1 < maxCOD) and
                 ((OceanSize[f1] >= 8) or (OceanPresence[f1] and not
                 (1 shl me) <> 0)) then
+                (1 shl Me) <> 0)) then
               begin // prefer non-coastal cities
                 Dec(Score, 18);
                 break;
+                Break;
               end;
             end;
 …
           (LowPriority(cix) = DoLowPriority) then
         begin
           f := Formation[Loc];
+          F := Formation[Loc];
           IsCoastal := False;
           IsPort := False;
 …
               f1 := Formation[Loc1];
               if (f1 >= 0) and (f1 < maxCOD) and (OceanSize[f1] >= 8) and
                 (OceanPresence[f1] and not (1 shl me) <> 0) then
+                (OceanPresence[f1] and not (1 shl Me) <> 0) then
               begin
                 IsPort := True;
                 break;
+                Break;
               end;
             end;
 …
             (RO.Model[City_CurrentUnitProject(cix)].Kind <> mkSettler) then
           begin
             i := nModelCategory - 1;
             while (i >= 0) and (City_CurrentUnitProject(cix) <> mixBest[i]) do
               Dec(i);
             IsUnitProjectObsolete := i < 0;
+            I := nModelCategory - 1;
+            while (I >= 0) and (City_CurrentUnitProject(cix) <> mixBest[I]) do
+              Dec(I);
+            IsUnitProjectObsolete := I < 0;
           end
           else
 …
               City_StartImprovement(cix,imMissileBat)}
                 else if IsPort and (not SpezializeShipProduction or
                   (f < 0) or (f >= maxCOD) or (ContinentPresence[f] = 1 shl me)) and
+                  (F < 0) or (F >= maxCOD) or (ContinentPresence[F] = 1 shl Me)) and
                   (Built[imDockyard] = 0) and City_Improvable(cix, imDockyard) then
                   City_StartImprovement(cix, imDockyard)
                 else if IsPort and (mixShip >= 0) and
                   (not SpezializeShipProduction or (f < 0) or
                   (f >= maxCOD) or (ContinentPresence[f] = 1 shl me)) then
+                  (not SpezializeShipProduction or (F < 0) or
+                  (F >= maxCOD) or (ContinentPresence[F] = 1 shl Me)) then
                   City_StartUnitProduction(cix, mixShip)
                 else if (Built[imBarracks] + Built[imMilAcademy] = 0) and
 …
           if (City_CurrentImprovementProject(cix) = imCourt) and
             (Built[imTownHall] > 0) and (prod >= imp[imCourt].cost *
             BuildCostMod[G.Difficulty[me]] div 12 -
             (imp[imTownHall].cost * BuildCostMod[G.Difficulty[me]] div 12) *
+            BuildCostMod[G.Difficulty[Me]] div 12 -
+            (imp[imTownHall].cost * BuildCostMod[G.Difficulty[Me]] div 12) *
 div 3) then
             City_RebuildImprovement(cix, imTownHall)
 …
                 if City_RebuildImprovement(cix, iix) < rExecuted then
                   City_SellImprovement(cix, iix);
                 break;
+                Break;
               end;
         end;
 end;
 function TBarbarina.Barbarina_ChooseResearchAdvance: integer;
+function TBarbarina.Barbarina_ChooseResearchAdvance: Integer;
 var
   nPreq, rmix, rmixChosen, i, MaxWeight, MaxDefense, ChosenPreq: integer;
   NeedSeaUnits, ready: boolean;
+  nPreq, rmix, rmixChosen, I, MaxWeight, MaxDefense, ChosenPreq: Integer;
+  NeedSeaUnits, ready: Boolean;
   ModelExists: set of 0..nModelCategory - 1;
   known: array[0..nAdv - 1] of integer;
   procedure ChoosePreq(ad: integer);
+  known: array[0..nAdv - 1] of Integer;
+  procedure ChoosePreq(ad: Integer);
   var
     i: integer;
     PreqOk: boolean;
+    I: Integer;
+    PreqOk: Boolean;
   begin
     assert(RO.Tech[ad] < tsApplicable);
+    Assert(RO.Tech[ad] < tsApplicable);
     if known[ad] = 0 then
     begin
 …
       PreqOk := True;
       if not (ad in [adScience, adMassProduction]) and (RO.Tech[ad] < tsSeen) then
         for i := 0 to 1 do
           if (AdvPreq[ad, i] >= 0) and (RO.Tech[AdvPreq[ad, i]] < tsApplicable) then
+        for I := 0 to 1 do
+          if (AdvPreq[ad, I] >= 0) and (RO.Tech[AdvPreq[ad, I]] < tsApplicable) then
           begin
             PreqOk := False;
             ChoosePreq(AdvPreq[ad, i]);
+            ChoosePreq(AdvPreq[ad, I]);
           end;
       if PreqOk then
 …
         ready := (MaxWeight >= Weight) and (MaxDefense >= Cap[mcDefense]);
         if ready then
           for i := 0 to nFeature - 1 do
             if (Cap[i] > 0) and (Feature[i].Preq <> preNone) and
               ((Feature[i].Preq < 0) or not IsResearched(Feature[i].Preq)) then
+          for I := 0 to nFeature - 1 do
+            if (Cap[I] > 0) and (Feature[I].Preq <> preNone) and
+              ((Feature[I].Preq < 0) or not IsResearched(Feature[I].Preq)) then
               ready := False;
         if ready then
         begin
           for i := 0 to nUpgrade - 1 do
             if (Upgrades and (1 shl i) <> 0) and not
               IsResearched(Upgrade[Domain, i].Preq) then
+          for I := 0 to nUpgrade - 1 do
+            if (Upgrades and (1 shl I) <> 0) and not
+              IsResearched(Upgrade[Domain, I].Preq) then
               ready := False;
         end;
         if ready then
         begin
           include(ModelExists, Category);
+          Include(ModelExists, Category);
           if not IsModelAvailable(rmix) then
             rmixChosen := rmix;
 …
     begin
       PrepareNewModel(Domain);
       for i := 0 to nFeature - 1 do
         if (i < 2) or (Cap[i] > 0) then
           SetNewModelFeature(i, Cap[i]);
       if RO.Wonder[woSun].EffectiveOwner = me then
+      for I := 0 to nFeature - 1 do
+        if (I < 2) or (Cap[I] > 0) then
+          SetNewModelFeature(I, Cap[I]);
+      if RO.Wonder[woSun].EffectiveOwner = Me then
       begin
         //if Cap[mcWeapons]>=2*Cap[mcArmor] then
 …
       end;
       Result := adMilitary;
       exit;
+      Exit;
     end;
   NeedSeaUnits := True;
   i := 0;
   while (i < nResearchOrder) and (not NeedSeaUnits and (ResearchOrder[i] < 0) or
       IsResearched(abs(ResearchOrder[i]))) do
     Inc(i);
   if i >= nResearchOrder then // list done, continue with future tech
+  I := 0;
+  while (I < nResearchOrder) and (not NeedSeaUnits and (ResearchOrder[I] < 0) or
+      IsResearched(abs(ResearchOrder[I]))) do
+    Inc(I);
+  if I >= nResearchOrder then // list done, continue with future tech
   begin
     if random(2) = 1 then
 …
     nPreq := 0;
     ChosenPreq := -1;
     ChoosePreq(abs(ResearchOrder[i]));
     assert(nPreq > 0);
+    ChoosePreq(abs(ResearchOrder[I]));
+    Assert(nPreq > 0);
     Result := ChosenPreq;
   end;
 end;
 function TBarbarina.Barbarina_WantCheckNegotiation(Nation: integer): boolean;
+function TBarbarina.Barbarina_WantCheckNegotiation(Nation: Integer): Boolean;
 begin
   if (RO.Tech[adTheRepublic] < tsSeen) and (RO.Tech[adTheology] >= tsApplicable) and
 …
 begin
   if RO.Tech[adTheRepublic] >= tsSeen then
     exit; // default reaction
+    Exit; // default reaction
   if MyLastAction = scContact then
   begin
 …
 end;
 function TBarbarina.Barbarina_WantNegotiation(Nation: integer;
   NegoTime: TNegoTime): boolean;
+function TBarbarina.Barbarina_WantNegotiation(Nation: Integer;
+  NegoTime: TNegoTime): Boolean;
 var
   uix, TestLoc, V8: integer;
+  uix, TestLoc, V8: Integer;
   Adjacent: TVicinity8Loc;
 begin
 …
       if RO.Turn >= RO.LastCancelTreaty[Nation] + CancelTreatyTurns then
       begin
         if (RO.Turn and 3 = (Nation + $F - me) and 3) and
+        if (RO.Turn and 3 = (Nation + $F - Me) and 3) and
           (RO.Treaty[Nation] > trPeace) then
         begin
 …
                     NegoCause := CancelTreaty;
                     Result := True;
                     exit;
+                    Exit;
                   end;
                 end;
 …
 procedure TBarbarina.MakeColonyShipPlan;
 var
   i, V21, V21C, CityLoc, Loc1, part, cix, BestValue, TestValue, FoodCount,
   ProdCount, ProdExtra, Score, BestScore: integer;
   Tile: cardinal;
   ok, check: boolean;
+  I, V21, V21C, CityLoc, Loc1, part, cix, BestValue, TestValue, FoodCount,
+  ProdCount, ProdExtra, Score, BestScore: Integer;
+  Tile: Cardinal;
+  ok, check: Boolean;
   Radius, RadiusC: TVicinity21Loc;
 begin
 …
               begin
                 part := (Tile and fModern) shr 25 - 1;
                 if RO.Ship[me].Parts[part] < ShipNeed[part] then
+                if RO.Ship[Me].Parts[part] < ShipNeed[part] then
                   // not enough of this kind already
                 begin
 …
                   if ColonyShipPlan[part].cixProducing >= 0 then
                   begin // another city is already assigned to this ship part, choose one of the two
                     TestValue := (ID and $FFF) shl 4 + ((ID shr 12) + 15 - me) and $F;
+                    TestValue := (ID and $FFF) shl 4 + ((ID shr 12) + 15 - Me) and $F;
                     BestValue :=
                       (MyCity[ColonyShipPlan[part].cixProducing].ID and $FFF) shl
 + ((MyCity[ColonyShipPlan[part].cixProducing].ID shr 12) +
 - me) and $F;
+- Me) and $F;
                     if TestValue <= BestValue then
                       ok := False;
 …
     check := False;
     for part := 0 to nShipPart - 1 do
       if (RO.Ship[me].Parts[part] < ShipNeed[part]) // not enough of this kind already
+      if (RO.Ship[Me].Parts[part] < ShipNeed[part]) // not enough of this kind already
         and (ColonyShipPlan[part].cixProducing < 0) then // no city to produce
         check := True;
 …
       end;
       for part := 0 to nShipPart - 1 do
         if (RO.Ship[me].Parts[part] < ShipNeed[part]) // not enough of this kind already
+        if (RO.Ship[Me].Parts[part] < ShipNeed[part]) // not enough of this kind already
           and (ColonyShipPlan[part].cixProducing < 0) // no city to produce
           and (ColonyShipPlan[part].nLocResource > 0) then // resource is known
         begin
           for i := 0 to ColonyShipPlan[part].nLocResource - 1 do
+          for I := 0 to ColonyShipPlan[part].nLocResource - 1 do
           begin
             BestScore := 0;
             V21_to_Loc(ColonyShipPlan[part].LocResource[i], Radius);
+            V21_to_Loc(ColonyShipPlan[part].LocResource[I], Radius);
             for V21 := 1 to 26 do
             begin // check all potential cities in range
 …
                       Dec(ProdCount, 5 - FoodCount);
                     Score := ProdCount * 4 + ProdExtra * 8 + FoodCount;
                     Score := Score shl 8 + ((CityLoc xor me) * 4567) mod 251;
+                    Score := Score shl 8 + ((CityLoc xor Me) * 4567) mod 251;
                     // some unexactness, random but always the same for this tile
                   end;

branches/highdpi/AI/StdAI/CustomAI.pas

-              r303
+              r465
   TCustomAI = class
   public
     procedure Process(Command: integer; var Data);
+    procedure Process(Command: Integer; var Data);
     // overridables
     constructor Create(Nation: integer); virtual;
+    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;
+      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
+    Me: Integer; // index of the controlled nation
     RO: ^TPlayerContext;
     Map: ^TTileList;
 …
     MyModel: ^TModelList;
     cixStateImp: array[imPalace..imSpacePort] of integer;
+    cixStateImp: array[imPalace..imSpacePort] of Integer;
     // negotiation
     Opponent: integer; // nation i'm in negotiation with, -1 indicates no-negotiation mode
     MyAction, MyLastAction, OppoAction: integer;
+    Opponent: Integer; // nation i'm in negotiation with, -1 indicates no-negotiation mode
+    MyAction, MyLastAction, OppoAction: Integer;
     MyOffer, MyLastOffer, OppoOffer: TOffer;
 …
     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;
+    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;
+    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;
+    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);
+    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;
+    function Nego_CheckMyAction: Integer;
   private
     HaveTurned: boolean;
+    HaveTurned: Boolean;
     UnwantedNego: set of 0..nPl - 1;
     Contacted: set of 0..nPl - 1;
 …
   Server: TServerCall;
   G: TNewGameData;
   RWDataSize, MapSize: integer;
   decompose24: cardinal;
   nodata: pointer;
+  RWDataSize, MapSize: Integer;
+  decompose24: Cardinal;
+  nodata: Pointer;
 const
 …
 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 V8_to_Loc(Loc0: integer; var VicinityLoc: TVicinity8Loc);
 procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
 function Distance(Loc0, Loc1: integer): 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;
 …
 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);
+  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);
+  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);
+procedure Loc_to_ab(Loc0, Loc: Integer; var A, B: Integer);
 {$IFDEF FPC}// freepascal
 var
   dx, dy: integer;
+  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;
+  A := (dx + dy) div 2;
+  B := (dy - dx) div 2;
 end;
 …
 // calculate
 push ecx
 div byte ptr [G]
+div Byte ptr [G]
 xor ebx,ebx
 mov bl,ah  // ebx:=Loc0 mod G.lx
 …
 and ecx,$000000FF // ecx:=Loc0 div G.lx
 mov eax,edx
 div byte ptr [G]
+div Byte ptr [G]
 xor edx,edx
 mov dl,ah // edx:=Loc mod G.lx
 …
 mov edx,dword ptr [G]
 cmp eax,edx
 jl @a
+jl @A
   sub eax,edx
   sub eax,edx
   jmp @ok
 @a:
+@A:
 neg edx
 cmp eax,edx
 …
 add eax,ebx
 sar edx,1 // edx:=b
 mov ebx,[b]
+mov ebx,[B]
 mov [ebx],edx
 sar eax,1 // eax:=a
 mov [a],eax
+mov [A],eax
 pop ebx
 …
 {$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;
+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;
+  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;
+  y0 := Cardinal(Loc0) * decompose24 shr 24;
   x0 := Loc0 - y0 * lx; // Loc0 mod lx;
   VicinityLoc[1] := Loc0 + lx * 2;
 …
 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;
+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;
 …
 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);
+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;
+  Loc: Integer;
 {$ENDIF}
 begin
 …
 {$IFDEF DEBUG}
   for Loc := 0 to MapSize - 1 do
     assert(cardinal(Loc) * decompose24 shr 24 = cardinal(Loc div G.lx));
+    Assert(Cardinal(Loc) * decompose24 shr 24 = Cardinal(Loc div G.lx));
 {$ENDIF}
 end;
 constructor TCustomAI.Create(Nation: integer);
+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);
+  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;
+  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
 …
     cTurn, cContinue:
     begin
       if RO.Alive and (1 shl me) = 0 then
+      if RO.Alive and (1 shl Me) = 0 then
       begin // I'm dead, huhu
         Server(sTurn, me, 0, nodata^);
         exit;
+        Server(sTurn, Me, 0, nodata^);
+        Exit;
       end;
       if Command = cTurn then
       begin
         fillchar(cixStateImp, sizeof(cixStateImp), $FF);
+        FillChar(cixStateImp, SizeOf(cixStateImp), $FF);
         for cix := 0 to RO.nCity - 1 do
           if MyCity[cix].Loc >= 0 then
 …
           NewGov := ChooseGovernment;
           if NewGov > gAnarchy then
             Server(sSetGovernment, me, NewGov, nodata^);
+            Server(sSetGovernment, Me, NewGov, nodata^);
         end;
         HaveTurned := False;
 …
         if OnNegoRejected_CancelTreaty then
           if RO.Treaty[Opponent] >= trPeace then
             if Server(sCancelTreaty, me, 0, nodata^) < rExecuted then
               assert(False);
+            if Server(sCancelTreaty, Me, 0, nodata^) < rExecuted then
+              Assert(False);
       end
       else
 …
         if RO.Government <> gAnarchy then
           for Nation := 0 to nPl - 1 do
             if (Nation <> me) and (1 shl Nation and RO.Alive <> 0) and
+            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
+              (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
+                if Server(scContact + Nation shl 4, Me, 0, nodata^) >= rExecuted then
                 begin
                   include(Contacted, Nation);
+                  Include(Contacted, Nation);
                   Opponent := Nation;
                   MyAction := scContact;
                   exit;
+                  Exit;
                 end;
               end
               else
                 include(UnwantedNego, Nation);
+                Include(UnwantedNego, Nation);
         if NegoTime = BeginOfTurn then
         begin
 …
         end
         else
           break;
+          Break;
       until False;
       if RO.Happened and phTech <> 0 then
 …
             end;
         end;
         Server(sSetResearch, me, NewResearch, nodata^);
+        Server(sSetResearch, Me, NewResearch, nodata^);
       end;
       if Server(sTurn, me, 0, nodata^) < rExecuted then
         assert(False);
+      if Server(sTurn, Me, 0, nodata^) < rExecuted then
+        Assert(False);
     end;
     scContact:
       if WantNegotiation(integer(Data), EnemyCalled) then
+      if WantNegotiation(Integer(Data), EnemyCalled) then
       begin
         if Server(scDipStart, me, 0, nodata^) < rExecuted then
           assert(False);
         Opponent := integer(Data);
+        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);
+        if Server(scReject, Me, 0, nodata^) < rExecuted then
+          Assert(False);
       end;
     scDipStart, scDipNotice, scDipAccept, scDipCancelTreaty, scDipOffer, scDipBreak:
 …
       end;
       DoNegotiation;
       assert((MyAction = scDipNotice) or (MyAction = scDipAccept) or
+      Assert((MyAction = scDipNotice) or (MyAction = scDipAccept) or
         (MyAction = scDipCancelTreaty) or (MyAction = scDipOffer) or (MyAction = scDipBreak));
       if MyAction = scDipOffer then
         Server(MyAction, me, 0, MyOffer)
+        Server(MyAction, Me, 0, MyOffer)
       else
         Server(MyAction, me, 0, nodata^);
+        Server(MyAction, Me, 0, nodata^);
     end;
     cShowEndContact:
 …
 procedure TCustomAI.OnBeforeEnemyAttack(UnitInfo: TUnitInfo;
   ToLoc, EndHealth, EndHealthDef: integer);
 begin
 end;
 procedure TCustomAI.OnBeforeEnemyCapture(UnitInfo: TUnitInfo; ToLoc: integer);
+  ToLoc, EndHealth, EndHealthDef: Integer);
+begin
+end;
+procedure TCustomAI.OnBeforeEnemyCapture(UnitInfo: TUnitInfo; ToLoc: Integer);
 begin
 end;
 …
 end;
 function TCustomAI.ChooseResearchAdvance: integer;
+function TCustomAI.ChooseResearchAdvance: Integer;
 begin
   Result := -1;
 end;
 function TCustomAI.ChooseStealAdvance: integer;
+function TCustomAI.ChooseStealAdvance: Integer;
 begin
   Result := -1;
 end;
 function TCustomAI.ChooseGovernment: integer;
+function TCustomAI.ChooseGovernment: Integer;
 begin
   Result := gDespotism;
 end;
 function TCustomAI.WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
+function TCustomAI.WantNegotiation(Nation: Integer; NegoTime: TNegoTime): Boolean;
 begin
   Result := False;
 end;
 function TCustomAI.OnNegoRejected_CancelTreaty: boolean;
+function TCustomAI.OnNegoRejected_CancelTreaty: Boolean;
 begin
   Result := False;
 …
 procedure TCustomAI.StealAdvance;
 var
   Steal, ad, Count: integer;
+  Steal, ad, Count: Integer;
 begin
   Steal := ChooseStealAdvance;
 …
   end;
   if Steal >= 0 then
     Server(sStealTech, me, Steal, nodata^);
+    Server(sStealTech, Me, Steal, nodata^);
   RO.Happened := RO.Happened and not phStealTech;
 end;
 function TCustomAI.IsResearched(Advance: integer): boolean;
+function TCustomAI.IsResearched(Advance: Integer): Boolean;
 begin
   Result := (Advance = preNone) or (Advance <> preNA) and (RO.Tech[Advance] >= tsApplicable);
 end;
 function TCustomAI.ResearchCost: integer;
 begin
   Server(sGetTechCost, me, 0, Result);
 end;
 function TCustomAI.ChangeAttitude(Nation, Attitude: integer): integer;
 begin
   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^);
 end;
 function TCustomAI.PrepareNewModel(Domain: integer): integer;
 begin
   Result := Server(sCreateDevModel, me, Domain, nodata^);
 end;
 function TCustomAI.SetNewModelFeature(F, Count: integer): integer;
 begin
   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;
 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;
 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)^);
+function TCustomAI.ResearchCost: Integer;
+begin
+  Server(sGetTechCost, Me, 0, Result);
+end;
+function TCustomAI.ChangeAttitude(Nation, Attitude: Integer): Integer;
+begin
+  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^);
+end;
+function TCustomAI.PrepareNewModel(Domain: Integer): Integer;
+begin
+  Result := Server(sCreateDevModel, Me, Domain, nodata^);
+end;
+function TCustomAI.SetNewModelFeature(F, Count: Integer): Integer;
+begin
+  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;
+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;
+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;
 …
 end;
 function TCustomAI.SetDebugMap(var DebugMap): boolean;
 begin
   Server(sSetDebugMap, me, 0, DebugMap);
+function TCustomAI.SetDebugMap(var DebugMap): Boolean;
+begin
+  Server(sSetDebugMap, Me, 0, DebugMap);
   Result := True;
 …
 end;
 procedure TCustomAI.Unit_FindMyDefender(Loc: integer; var uix: integer);
 begin
   if Server(sGetDefender, me, Loc, uix) < rExecuted then
+procedure TCustomAI.Unit_FindMyDefender(Loc: Integer; var uix: Integer);
+begin
+  if Server(sGetDefender, Me, Loc, uix) < rExecuted then
     uix := -1;
 end;
 procedure TCustomAI.Unit_FindEnemyDefender(Loc: integer; var euix: integer);
+procedure TCustomAI.Unit_FindEnemyDefender(Loc: Integer; var euix: Integer);
 begin
   euix := RO.nEnemyUn - 1;
 …
 end;
 function TCustomAI.Unit_Move(uix, ToLoc: integer): integer;
 var
   Step: integer;
   DestinationReached: boolean;
+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
+  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
+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)
+  !!!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.dx[0]:=A-B;
+  Advice.dy[0]:=A+B;
   Advice.MoreTurns:=0;
   Advice.MaxHostile_MovementLeft:=MyUnit[uix].Movement;
   result:=eOK;
+  Result:=eOK;
   end
 else}
 …
     Advice.MoreTurns := 9999;
     Advice.MaxHostile_MovementLeft := 100;
     Result := Server(sGetMoveAdvice, me, uix, Advice);
+    Result := Server(sGetMoveAdvice, Me, uix, Advice);
   end;
   if Result = eOk then
 …
         begin
           DestinationReached := True;
           break;
+          Break;
         end // stop next to destination
         else if Step = Advice.nStep then
 …
       if (Step = Advice.nStep) or (Result <> eOK) and (Result <> eLoaded) then
         break;
+        Break;
       Result := Server(sMoveUnit + (Advice.dx[Step] and 7) shl 4 +
         (Advice.dy[Step] and 7) shl 7, me, uix, nodata^);
+        (Advice.dy[Step] and 7) shl 7, Me, uix, nodata^);
       Inc(Step);
       if RO.Happened and phStealTech <> 0 then
 …
 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^);
+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
+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));
+  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^);
+  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
+    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));
+    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^);
+    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^)
+      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;
 function TCustomAI.Unit_MoveForecast(uix, ToLoc: integer;
   var RemainingMovement: integer): boolean;
+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
+  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
+  if Server(sGetMoveAdvice, Me, uix, Advice) = eOk then
   begin
     RemainingMovement := Advice.MaxHostile_MovementLeft;
 …
 // negative RemainingHealth is remaining helth of defender if lost
 function TCustomAI.Unit_AttackForecast(uix, ToLoc, AttackMovement: integer;
   var RemainingHealth: integer): boolean;
+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
+  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;
 …
     with MyUnit[uix] do
     begin
       BattleForecast.pAtt := me;
+      BattleForecast.pAtt := Me;
       BattleForecast.mixAtt := mix;
       BattleForecast.HealthAtt := Health;
 …
       BattleForecast.FlagsAtt := Flags;
       BattleForecast.Movement := AttackMovement;
       if Server(sGetBattleForecast, me, ToLoc, BattleForecast) >= rExecuted then
+      if Server(sGetBattleForecast, Me, ToLoc, BattleForecast) >= rExecuted then
       begin
         if BattleForecast.EndHealthAtt > 0 then
 …
 end;
 function TCustomAI.Unit_DefenseForecast(euix, ToLoc: integer;
   var RemainingHealth: integer): boolean;
+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
+  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;
 …
     BattleForecast.FlagsAtt := Flags;
     BattleForecast.Movement := 100;
     if Server(sGetBattleForecast, me, ToLoc, BattleForecast) >= rExecuted then
+    if Server(sGetBattleForecast, Me, ToLoc, BattleForecast) >= rExecuted then
     begin
       if BattleForecast.EndHealthDef > 0 then
 …
 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);
+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
 …
 end;
 procedure TCustomAI.City_FindEnemyCity(Loc: integer; var ecix: integer);
+procedure TCustomAI.City_FindEnemyCity(Loc: Integer; var ecix: Integer);
 begin
   if Map[Loc] and (fCity or fOwned) <> fCity then
 …
 end;
 function TCustomAI.City_HasProject(cix: integer): boolean;
+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;
+function TCustomAI.City_CurrentImprovementProject(cix: Integer): Integer;
 begin
   if MyCity[cix].Project and cpImp = 0 then
 …
 end;
 function TCustomAI.City_CurrentUnitProject(cix: integer): integer;
+function TCustomAI.City_CurrentUnitProject(cix: Integer): Integer;
 begin
   if MyCity[cix].Project and cpImp <> 0 then
 …
 end;
 function TCustomAI.City_GetTileInfo(cix, TileLoc: integer;
   var TileInfo: TTileInfo): integer;
+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;
+  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;
 function TCustomAI.City_GetHypoReport(cix, HypoTiles, HypoTax, HypoLux: integer;
   var Report: TCityReport): integer;
+  Result := Server(sGetCityReport, Me, cix, Report);
+end;
+function TCustomAI.City_GetHypoReport(cix, HypoTiles, HypoTax, HypoLux: Integer;
+  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; var Report: TCityReportNew): integer;
+  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);
+  Result := Server(sGetCityReportNew, Me, cix, Report);
 end;
 function TCustomAI.City_GetHypoReportNew(cix, HypoTiles, HypoTaxRate,
   HypoLuxuryRate: integer; var Report: TCityReportNew): integer;
+  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;
+  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;
+    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 AsConscripts then
     NewProject := NewProject or cpConscripts;
   Result := Server(sSetCityProject, me, cix, NewProject);
 end;
 function TCustomAI.City_StartImprovement(cix, iix: integer): integer;
 var
   NewProject: integer;
+  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;
+    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;
+  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);
 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: cardinal);
+  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: Cardinal);
 var
   Advice: TCityTileAdviceData;
 begin
   Advice.ResourceWeights := ResourceWeights;
   Server(sGetCityTileAdvice, me, cix, Advice);
+  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
+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)
+    Result := Server(MyAction - sExecute, Me, 0, MyOffer)
   else
     Result := Server(MyAction - sExecute, me, 0, nodata^);
+    Result := Server(MyAction - sExecute, Me, 0, nodata^);
 end;
 initialization
   nodata := pointer(0);
+  nodata := Pointer(0);
   RWDataSize := 0;

branches/highdpi/AI/StdAI/CustomAI_Reload.pas

-              r210
+              r465
 TCustomAI=class
 public
   procedure Process(Command: integer; var Data);
+  procedure Process(Command: Integer; var Data);
   // overridables
   constructor Create(Nation: integer); virtual;
+  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;
+    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
+  Me: Integer; // index of the controlled nation
   RO: ^TPlayerContext;
   Map: ^TTileList;
 …
   MyModel: ^TModelList;
   cixStateImp: array[imPalace..imSpacePort] of integer;
+  cixStateImp: array[imPalace..imSpacePort] of Integer;
   // negotiation
   Opponent: integer; // nation i'm in negotiation with, -1 indicates no-negotiation mode
   MyAction, MyLastAction, OppoAction: integer;
+  Opponent: Integer; // nation i'm in negotiation with, -1 indicates no-negotiation mode
+  MyAction, MyLastAction, OppoAction: Integer;
   MyOffer, MyLastOffer, OppoOffer: TOffer;
 …
   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;
+  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 DebugMessage(Level: integer; Text: string): boolean;
   function SetDebugMap(var DebugMap): boolean;
+  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 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_AddToCity(uix: integer): integer;
+  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_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_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_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_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;
   // negotiation
   function Nego_CheckMyAction: integer;
+  function Nego_CheckMyAction: Integer;
 private
   HaveTurned: boolean;
+  HaveTurned: Boolean;
   UnwantedNego: set of 0..nPl-1;
   Contacted: set of 0..nPl-1;
 …
 Server: TServerCall;
 G: TNewGameData;
 RWDataSize, MapSize: integer;
 decompose24: cardinal;
 nodata: pointer;
+RWDataSize, MapSize: Integer;
+decompose24: Cardinal;
+nodata: Pointer;
 const
 …
 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 V8_to_Loc(Loc0: integer; var VicinityLoc: TVicinity8Loc);
 procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
+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);
 …
 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);
+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);
+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);
+procedure Loc_to_ab(Loc0,Loc: Integer; var A,B: Integer);
 {$IFDEF FPC} // freepascal
 var
 dx,dy: integer;
+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;
+A:=(dx+dy) div 2;
+B:=(dy-dx) div 2;
 end;
 {$ELSE} // delphi
 …
 // calculate
 push ecx
 div byte ptr [G]
+div Byte ptr [G]
 xor ebx,ebx
 mov bl,ah  // ebx:=Loc0 mod G.lx
 …
 and ecx,$000000FF // ecx:=Loc0 div G.lx
 mov eax,edx
 div byte ptr [G]
+div Byte ptr [G]
 xor edx,edx
 mov dl,ah // edx:=Loc mod G.lx
 …
 mov edx,dword ptr [G]
 cmp eax,edx
 jl @a
+jl @A
   sub eax,edx
   sub eax,edx
   jmp @ok
 @a:
+@A:
 neg edx
 cmp eax,edx
 …
 add eax,ebx
 sar edx,1 // edx:=b
 mov ebx,[b]
+mov ebx,[B]
 mov [ebx],edx
 sar eax,1 // eax:=a
 mov [a],eax
+mov [A],eax
 pop ebx
 …
 {$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;
+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;
+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;
+y0:=Cardinal(Loc0)*decompose24 shr 24;
 x0:=Loc0-y0*lx; // Loc0 mod lx;
 VicinityLoc[1]:=Loc0+lx*2;
 …
 VicinityLoc[5]:=Loc0-lx*2;
 VicinityLoc[7]:=Loc0+1;
 inc(Loc0,y0 and 1);
+Inc(Loc0,y0 and 1);
 VicinityLoc[0]:=Loc0+lx;
 VicinityLoc[2]:=Loc0+lx-1;
 …
   if x0=0 then
     begin
     inc(VicinityLoc[3],lx);
+    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
 …
 else
   begin
   dec(VicinityLoc[7],lx);
+  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;
 …
 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;
+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);
+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);
 …
       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);
+      Inc(xComp);
+      if xComp>=G.lx then Dec(xComp, G.lx);
+      Inc(dst);
       bit:=bit shl 1;
       end;
     inc(yComp,G.lx);
+    Inc(yComp,G.lx);
     end
   else
     begin
     for dx:=0 to 3 do
       begin dst^:=-$1000; inc(dst); end;
+      begin dst^:=-$1000; Inc(dst); end;
     end
 end;
 …
 procedure Init(NewGameData: TNewGameData);
 {$IFDEF DEBUG}var Loc: integer;{$ENDIF}
+{$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);
+{$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);
+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;
+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
 …
   cTurn, cContinue:
     begin
     if RO.Alive and (1 shl me)=0 then
+    if RO.Alive and (1 shl Me)=0 then
       begin // I'm dead, huhu
       Server(sTurn,me,0,nodata^);
       exit
+      Server(sTurn,Me,0,nodata^);
+      Exit
       end;
     if Command=cTurn then
       begin
       fillchar(cixStateImp, sizeof(cixStateImp), $FF);
+      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
 …
         NewGov:=ChooseGovernment;
         if NewGov>gAnarchy then
           Server(sSetGovernment,me,NewGov,nodata^);
+          Server(sSetGovernment,Me,NewGov,nodata^);
         end;
       HaveTurned:=false;
+      HaveTurned:=False;
       Contacted:=[];
       end;
 …
       if OnNegoRejected_CancelTreaty then
         if RO.Treaty[Opponent]>=trPeace then
           if Server(sCancelTreaty,me,0,nodata^)<rExecuted then
             assert(false)
+          if Server(sCancelTreaty,Me,0,nodata^)<rExecuted then
+            Assert(False)
       end
     else UnwantedNego:=[];
 …
       if RO.Government<>gAnarchy then
         for Nation:=0 to nPl-1 do
            if (Nation<>me) and (1 shl Nation and RO.Alive<>0)
+           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
+             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
+               if Server(scContact + Nation shl 4, Me, 0, nodata^)>=rExecuted then
                  begin
                  include(Contacted, Nation);
+                 Include(Contacted, Nation);
                  Opponent:=Nation;
                  MyAction:=scContact;
                  exit;
+                 Exit;
                  end;
                end
              else include(UnwantedNego,Nation);
+             else Include(UnwantedNego,Nation);
       if NegoTime=BeginOfTurn then
         begin
         DoTurn;
         HaveTurned:=true;
+        HaveTurned:=True;
         Contacted:=[];
         UnwantedNego:=[];
         end
       else break;
     until false;
+      else Break;
+    until False;
     if RO.Happened and phTech<>0 then
       begin
 …
         count:=0;
         for ad:=0 to nAdv-1 do if AdvanceResearchable(ad) then
           begin inc(count); if random(count)=0 then NewResearch:=ad end
+          begin Inc(count); if random(count)=0 then NewResearch:=ad end
         end;
       Server(sSetResearch,me,NewResearch,nodata^)
+      Server(sSetResearch,Me,NewResearch,nodata^)
       end;
     if (me=1) and (RO.Turn=800) then
+    if (Me=1) and (RO.Turn=800) then
       begin
       count:=0;
       Server(sReload,me,0,count)
+      Server(sReload,Me,0,count)
       end
     else if (RO.Turn>10) and (random(1000)=0) then
       begin
       count:=RO.Turn-10;
       Server(sReload,me,0,count)
+      Server(sReload,Me,0,count)
       end
     else if Server(sTurn,me,0,nodata^)<rExecuted then
       assert(false);
+    else if Server(sTurn,Me,0,nodata^)<rExecuted then
+      Assert(False);
     end;
   scContact:
     if WantNegotiation(integer(Data), EnemyCalled) then
+    if WantNegotiation(Integer(Data), EnemyCalled) then
       begin
       if Server(scDipStart, me, 0, nodata^)<rExecuted then
         assert(false);
       Opponent:=integer(Data);
+      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);
+      if Server(scReject, Me, 0, nodata^)<rExecuted then
+        Assert(False);
       end;
   scDipStart, scDipNotice, scDipAccept, scDipCancelTreaty, scDipOffer, scDipBreak:
 …
     else begin MyAction:=scDipOffer; MyOffer.nDeliver:=0; MyOffer.nCost:=0; end;
     DoNegotiation;
     assert((MyAction=scDipNotice) or (MyAction=scDipAccept)
+    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^);
+    if MyAction=scDipOffer then Server(MyAction, Me, 0, MyOffer)
+    else Server(MyAction, Me, 0, nodata^);
     end;
   cShowEndContact:
 …
 procedure TCustomAI.OnBeforeEnemyAttack(UnitInfo: TUnitInfo; ToLoc, EndHealth,
   EndHealthDef: integer);
 begin
 end;
 procedure TCustomAI.OnBeforeEnemyCapture(UnitInfo: TUnitInfo; ToLoc: integer);
+  EndHealthDef: Integer);
+begin
+end;
+procedure TCustomAI.OnBeforeEnemyCapture(UnitInfo: TUnitInfo; ToLoc: Integer);
 begin
 end;
 …
 end;
 function TCustomAI.ChooseResearchAdvance: integer;
 begin
 result:=-1
 end;
 function TCustomAI.ChooseStealAdvance: integer;
 begin
 result:=-1
 end;
 function TCustomAI.ChooseGovernment: integer;
 begin
 result:=gDespotism
 end;
 function TCustomAI.WantNegotiation(Nation: integer; NegoTime: TNegoTime): boolean;
 begin
 result:=false;
 end;
 function TCustomAI.OnNegoRejected_CancelTreaty: boolean;
 begin
 result:=false;
+function TCustomAI.ChooseResearchAdvance: Integer;
+begin
+Result:=-1
+end;
+function TCustomAI.ChooseStealAdvance: Integer;
+begin
+Result:=-1
+end;
+function TCustomAI.ChooseGovernment: Integer;
+begin
+Result:=gDespotism
+end;
+function TCustomAI.WantNegotiation(Nation: Integer; NegoTime: TNegoTime): Boolean;
+begin
+Result:=False;
+end;
+function TCustomAI.OnNegoRejected_CancelTreaty: Boolean;
+begin
+Result:=False;
 end;
 {$HINTS ON}
 …
 procedure TCustomAI.StealAdvance;
 var
 Steal, ad, count: integer;
+Steal, ad, count: Integer;
 begin
 Steal:=ChooseStealAdvance;
 …
   count:=0;
   for ad:=0 to nAdv-1 do if AdvanceStealable(ad) then
     begin inc(count); if random(count)=0 then Steal:=ad end
+    begin Inc(count); if random(count)=0 then Steal:=ad end
   end;
 if Steal>=0 then Server(sStealTech,me,Steal,nodata^);
+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
 end;
 function TCustomAI.ResearchCost: integer;
 begin
 Server(sGetTechCost,me,0,result)
 end;
 function TCustomAI.ChangeAttitude(Nation, Attitude: integer): integer;
 begin
 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^)
 end;
 function TCustomAI.PrepareNewModel(Domain: integer): integer;
 begin
 result:=Server(sCreateDevModel,me,Domain,nodata^);
 end;
 function TCustomAI.SetNewModelFeature(F, Count: integer): integer;
 begin
 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;
 end;
 function TCustomAI.AdvanceStealable(Advance: integer): boolean;
 begin
 result:= Server(sStealTech-sExecute,me,Advance,nodata^)>=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;
+function TCustomAI.IsResearched(Advance: Integer): Boolean;
+begin
+Result:= RO.Tech[Advance]>=tsApplicable
+end;
+function TCustomAI.ResearchCost: Integer;
+begin
+Server(sGetTechCost,Me,0,Result)
+end;
+function TCustomAI.ChangeAttitude(Nation, Attitude: Integer): Integer;
+begin
+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^)
+end;
+function TCustomAI.PrepareNewModel(Domain: Integer): Integer;
+begin
+Result:=Server(sCreateDevModel,Me,Domain,nodata^);
+end;
+function TCustomAI.SetNewModelFeature(F, Count: Integer): Integer;
+begin
+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;
+end;
+function TCustomAI.AdvanceStealable(Advance: Integer): Boolean;
+begin
+Result:= Server(sStealTech-sExecute,Me,Advance,nodata^)>=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;
   // always returns true so that it can be used like
   // "assert(DebugMessage(...));" -> not compiled in release build
 end;
 function TCustomAI.SetDebugMap(var DebugMap): boolean;
 begin
 Server(sSetDebugMap, me, 0, DebugMap);
 result:=true;
+function TCustomAI.SetDebugMap(var DebugMap): Boolean;
+begin
+Server(sSetDebugMap, Me, 0, DebugMap);
+Result:=True;
   // always returns true so that it can be used like
   // "assert(SetDebugMap(...));" -> not compiled in release build
 end;
 procedure TCustomAI.Unit_FindMyDefender(Loc: integer; var uix: integer);
 begin
 if Server(sGetDefender,me,Loc,uix)<rExecuted then uix:=-1
 end;
 procedure TCustomAI.Unit_FindEnemyDefender(Loc: integer; var euix: integer);
+procedure TCustomAI.Unit_FindMyDefender(Loc: Integer; var uix: Integer);
+begin
+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;
+  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
+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
+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)
+  !!!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.dx[0]:=A-B;
+  Advice.dy[0]:=A+B;
   Advice.MoreTurns:=0;
   Advice.MaxHostile_MovementLeft:=MyUnit[uix].Movement;
   result:=eOK;
+  Result:=eOK;
   end
 else}
 …
   Advice.MoreTurns:=9999;
   Advice.MaxHostile_MovementLeft:=100;
   result:=Server(sGetMoveAdvice,me,uix,Advice);
+  Result:=Server(sGetMoveAdvice,Me,uix,Advice);
   end;
 if result=eOk then
+if Result=eOk then
   begin
   DestinationReached:=false;
+  DestinationReached:=False;
   Step:=0;
   repeat
     if result and (rExecuted or rUnitRemoved)=rExecuted then // check if destination reached
+    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
 …
           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
+        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);
+        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;
+  until False;
   if DestinationReached then
     if Advice.nStep=25 then
       result:=Unit_Move(uix,ToLoc) // Shinkansen
+      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^);
+      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
+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
+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
+  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;
+  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
+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
+if Server(sGetMoveAdvice,Me,uix,Advice)=eOk then
   begin
   RemainingMovement:=Advice.MaxHostile_MovementLeft;
   result:=true
+  Result:=True
   end
 else
   begin
   RemainingMovement:=-1;
   result:=false
   end
 end;
 function TCustomAI.Unit_AttackForecast(uix,ToLoc,AttackMovement: integer;
   var RemainingHealth: integer): boolean;
+  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
+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;
+Result:=False;
 if AttackMovement>=0 then with MyUnit[uix] do
   begin
   BattleForecast.pAtt:=me;
+  BattleForecast.pAtt:=Me;
   BattleForecast.mixAtt:=mix;
   BattleForecast.HealthAtt:=Health;
 …
   BattleForecast.FlagsAtt:=Flags;
   BattleForecast.Movement:=AttackMovement;
   if Server(sGetBattleForecast,me,ToLoc,BattleForecast)>=rExecuted then
+  if Server(sGetBattleForecast,Me,ToLoc,BattleForecast)>=rExecuted then
     begin
     if BattleForecast.EndHealthAtt>0 then
       RemainingHealth:=BattleForecast.EndHealthAtt
     else RemainingHealth:=-BattleForecast.EndHealthDef;
     result:=true
+    Result:=True
     end
   end
 end;
 function TCustomAI.Unit_DefenseForecast(euix,ToLoc: integer;
   var RemainingHealth: integer): boolean;
+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
+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;
+Result:=False;
 with RO.EnemyUn[euix] do
   begin
 …
   BattleForecast.FlagsAtt:=Flags;
   BattleForecast.Movement:=100;
   if Server(sGetBattleForecast,me,ToLoc,BattleForecast)>=rExecuted then
+  if Server(sGetBattleForecast,Me,ToLoc,BattleForecast)>=rExecuted then
     begin
     if BattleForecast.EndHealthDef>0 then
       RemainingHealth:=BattleForecast.EndHealthDef
     else RemainingHealth:=-BattleForecast.EndHealthAtt;
     result:=true
+    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;
 procedure TCustomAI.City_FindMyCity(Loc: integer; var cix: integer);
+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;
+procedure TCustomAI.City_FindMyCity(Loc: Integer; var cix: Integer);
 begin
 if Map[Loc] and (fCity or fOwned)<>fCity or fOwned 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);
+    Dec(cix);
+  end
+end;
+procedure TCustomAI.City_FindEnemyCity(Loc: Integer; var ecix: Integer);
 begin
 if Map[Loc] and (fCity or fOwned)<>fCity then
 …
   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
+    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
   end
 end;
 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;
+  Result:=MyCity[cix].Project and cpIndex;
+  if Result=imTrGoods then Result:=-1
+  end
+end;
+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;
+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;
 function TCustomAI.City_GetHypoReport(cix, HypoTiles, HypoTax, HypoLux: integer;
   var Report: TCityReport): integer;
+Result:=Server(sGetCityReport,Me,cix,Report)
+end;
+function TCustomAI.City_GetHypoReport(cix, HypoTiles, HypoTax, HypoLux: Integer;
+  var Report: TCityReport): Integer;
 begin
 Report.HypoTiles:=HypoTiles;
 Report.HypoTax:=HypoTax;
 Report.HypoLux:=HypoLux;
 result:=Server(sGetCityReport,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;
   AllowDisbandCity, AsConscripts: boolean): integer;
 var
 NewProject: integer;
+Result:=Server(sGetCityReport,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;
+  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;
+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;
+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;
+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)
 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)
+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;
 // negotiation
 function TCustomAI.Nego_CheckMyAction: integer;
 begin
 assert(Opponent>=0); // only allowed in negotiation mode
 assert((MyAction=scDipNotice) or (MyAction=scDipAccept)
+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^);
+if MyAction=scDipOffer then Result:=Server(MyAction-sExecute, Me, 0, MyOffer)
+else Result:=Server(MyAction-sExecute, Me, 0, nodata^);
 end;
 initialization
 nodata:=pointer(0);
+nodata:=Pointer(0);
 RWDataSize:=0;

branches/highdpi/AI/StdAI/Pile.pas

-              r303
+              r465
 interface
 procedure Create(Size: integer);
+procedure Create(Size: Integer);
 procedure Free;
 procedure Empty;
 function Put(Item, Value: integer): boolean;
 function TestPut(Item, Value: integer): boolean;
 function Get(var Item, Value: integer): boolean;
+function Put(Item, Value: Integer): Boolean;
+function TestPut(Item, Value: Integer): Boolean;
+function Get(var Item, Value: Integer): Boolean;
 …
 type
   TheapItem = record
     Item: integer;
     Value: integer;
+    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}
+  Ix: array[0..MaxSize - 1] of Integer;
+  N, CurrentSize: Integer;
+{$IFDEF DEBUG}InUse: Boolean;{$ENDIF}
 procedure Create(Size: integer);
+procedure Create(Size: Integer);
 begin
   {$IFDEF DEBUG}
   assert(not InUse, 'Pile is a single instance class, ' +
+  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
+  Assert(Size <= MaxSize);
+  if (N <> 0) or (Size > CurrentSize) then
   begin
     FillChar(Ix, Size * sizeOf(integer), 255);
     n := 0;
+    FillChar(Ix, Size * sizeOf(Integer), 255);
+    N := 0;
   end;
   CurrentSize := Size;
 …
 begin
         {$IFDEF DEBUG}
   assert(InUse);
+  Assert(InUse);
   InUse := False;
 {$ENDIF}
 …
 procedure Empty;
 begin
   if n <> 0 then
+  if N <> 0 then
   begin
     FillChar(Ix, CurrentSize * sizeOf(integer), 255);
     n := 0;
+    FillChar(Ix, CurrentSize * sizeOf(Integer), 255);
+    N := 0;
   end;
 end;
 //Parent(i) = (i-1)/2.
 function Put(Item, Value: integer): boolean; //O(lg(n))
+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
+  Assert(Item < CurrentSize);
+  I := Ix[Item];
+  if I >= 0 then
   begin
     if bh[i].Value <= Value then
+    if bh[I].Value <= Value then
     begin
       Result := False;
       exit;
+      Exit;
     end;
   end
   else
   begin
     i := n;
     Inc(n);
+    I := N;
+    Inc(N);
   end;
   while i > 0 do
+  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;
+    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;
+  bh[I].Value := Value;
+  bh[I].Item := Item;
+  Ix[bh[I].Item] := I;
   Result := True;
 end;
 function TestPut(Item, Value: integer): boolean;
+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))
+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
+  if N = 0 then
   begin
     Result := False;
     exit;
+    Exit;
   end;
 …
   Ix[Item] := -1;
   Dec(n);
   if n > 0 then
+  Dec(N);
+  if N > 0 then
   begin
     last := bh[n];
     i := 0;
     j := 1;
     while j < n do
+    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;
+      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
+      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;
+    bh[I] := Last;
+    Ix[Last.Item] := I;
   end;
   Result := True;
 …
 initialization
   n := 0;
+  N := 0;
   CurrentSize := 0;
         {$IFDEF DEBUG}

branches/highdpi/AI/StdAI/Protocol.pas

-              r349
+              r465
   Cost: Integer;
   Maint: Integer;
   Expiration: integer;
+  Expiration: Integer;
 end
 = ((Kind: ikWonder; Preq: adMathematics; Cost: 400; Maint: 0;
 …
   Strength: Integer;
   Trans: Integer;
   Cost: integer;
+  Cost: Integer;
 end
 = (((Preq: adWarriorCode; Strength: 4; Trans: 0; Cost: 3),
 …
   TGetCityData = record
     Owner: Integer;
     c: TCity;
+    C: TCity;
   end;
 …
   TCreateUnitData = record
     Loc: Integer;
     p: Integer;
+    P: Integer;
     mix: Integer;
   end;
 …
   TOwnerList = array [0 .. INFIN] of ShortInt;
   TByteList = array [0 .. INFIN] of Byte;
   TIntList = array [0 .. INFIN] of integer;
+  TIntList = array [0 .. INFIN] of Integer;
   TCityList = array [0 .. INFIN] of TCity;
   TUnList = array [0 .. INFIN] of TUn;
 …
 , 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)));
   SpecialModelPreq: array [0 .. nSpecialModel - 1] of integer = (preNone,
+  SpecialModelPreq: array [0 .. nSpecialModel - 1] of Integer = (preNone,
     adExplosives, preNone, preNone, (* adWri, *) adIntelligence, adTrade,
     (* adTheCorporation,adHorsebackRiding,adAutomobile,adNavigation,
 …
   DelphiRandSeed: Integer;
 procedure MakeUnitInfo(p: Integer; const u: TUn; var ui: TUnitInfo);
 procedure MakeModelInfo(p, mix: Integer; const m: TModel; var mi: TModelInfo);
+procedure MakeUnitInfo(P: Integer; const U: TUn; var ui: TUnitInfo);
+procedure MakeModelInfo(P, mix: Integer; const M: TModel; var mi: TModelInfo);
 function IsSameModel(const mi1, mi2: TModelInfo): Boolean;
 function SpecialTile(Loc, TerrType, lx: Integer): Integer;
 …
 implementation
 procedure MakeUnitInfo(p: Integer; const u: TUn; var ui: TUnitInfo);
+procedure MakeUnitInfo(P: Integer; const U: TUn; var ui: TUnitInfo);
 begin
   ui.Owner := p;
   ui.Loc := u.Loc;
   ui.Health := u.Health;
   ui.Fuel := u.Fuel;
   ui.Job := u.Job;
   ui.Exp := u.Exp;
   ui.Load := u.TroopLoad + u.AirLoad;
   ui.mix := u.mix;
   ui.Flags := u.Flags;
+  ui.Owner := P;
+  ui.Loc := U.Loc;
+  ui.Health := U.Health;
+  ui.Fuel := U.Fuel;
+  ui.Job := U.Job;
+  ui.Exp := U.Exp;
+  ui.Load := U.TroopLoad + U.AirLoad;
+  ui.mix := U.mix;
+  ui.Flags := U.Flags;
 end;
 procedure MakeModelInfo(p, mix: Integer; const m: TModel; var mi: TModelInfo);
+procedure MakeModelInfo(P, mix: Integer; const M: TModel; var mi: TModelInfo);
 var
   i: Integer;
+  I: Integer;
 begin
   mi.Owner := p;
+  mi.Owner := P;
   mi.mix := mix;
   mi.ID := m.ID;
   mi.Domain := m.Domain;
   if m.Kind = mkEnemyDeveloped then
+  mi.ID := M.ID;
+  mi.Domain := M.Domain;
+  if M.Kind = mkEnemyDeveloped then
     mi.Kind := mkSelfDeveloped // important for IsSameModel()
   else
     mi.Kind := m.Kind;
   mi.Attack := m.Attack;
   mi.Defense := m.Defense;
   mi.Speed := m.Speed;
   mi.Cost := m.Cost;
+    mi.Kind := M.Kind;
+  mi.Attack := M.Attack;
+  mi.Defense := M.Defense;
+  mi.Speed := M.Speed;
+  mi.Cost := M.Cost;
   if mi.Domain = dAir then
   begin
     mi.TTrans := m.Cap[mcAirTrans] * m.MTrans;
     mi.ATrans_Fuel := m.Cap[mcFuel];
+    mi.TTrans := M.Cap[mcAirTrans] * M.MTrans;
+    mi.ATrans_Fuel := M.Cap[mcFuel];
   end
   else
   begin
     mi.TTrans := m.Cap[mcSeaTrans] * m.MTrans;
     mi.ATrans_Fuel := m.Cap[mcCarrier] * m.MTrans;
   end;
   mi.Bombs := m.Cap[mcBombs] * m.MStrength * 2;
+    mi.TTrans := M.Cap[mcSeaTrans] * M.MTrans;
+    mi.ATrans_Fuel := M.Cap[mcCarrier] * M.MTrans;
+  end;
+  mi.Bombs := M.Cap[mcBombs] * M.MStrength * 2;
   mi.Cap := 0;
   for i := mcFirstNonCap to nFeature - 1 do
     if m.Cap[i] > 0 then
       mi.Cap := mi.Cap or (1 shl (i - mcFirstNonCap));
+  for I := mcFirstNonCap to nFeature - 1 do
+    if M.Cap[I] > 0 then
+      mi.Cap := mi.Cap or (1 shl (I - mcFirstNonCap));
   mi.MaxUpgrade := 0;
   for i := 1 to nUpgrade - 1 do
     if m.Upgrades and (1 shl i) <> 0 then
       mi.MaxUpgrade := i;
   mi.Weight := m.Weight;
+  for I := 1 to nUpgrade - 1 do
+    if M.Upgrades and (1 shl I) <> 0 then
+      mi.MaxUpgrade := I;
+  mi.Weight := M.Weight;
   mi.Lost := 0;
 end;
 …
   Compare1 := @mi1;
   Compare2 := @mi2;
   result := (Compare1[1] and $FFFF0000 = Compare2[1] and $FFFF0000) and
+  Result := (Compare1[1] and $FFFF0000 = Compare2[1] and $FFFF0000) and
     (Compare1[2] = Compare2[2]) and (Compare1[3] = Compare2[3]) and
     (Compare1[4] = Compare2[4]) and (Compare1[5] = Compare2[5])
 …
 function SpecialTile(Loc, TerrType, lx: Integer): Integer;
 var
   x, y, qx, qy, a: Integer;
+  X, Y, qx, qy, A: Integer;
 begin
   if TerrType = fOcean then
     result := 0
+    Result := 0
   else
   begin
     y := Loc div lx;
     x := Loc - y * lx;
+    Y := Loc div lx;
+    X := Loc - Y * lx;
     if TerrType = fGrass then { formula for productive grassland }
       if Odd((lymax + x - y shr 1) shr 1 + x + (y + 1) shr 1) then
         result := 1
+      if Odd((lymax + X - Y shr 1) shr 1 + X + (Y + 1) shr 1) then
+        Result := 1
       else
         result := 0
+        Result := 0
     else { formula for special resources }
     begin
       a := 4 * x - y + 9980;
       qx := a div 10;
       if (qx * 10 = a) and (qx and 3 <> 0) then
+      A := 4 * X - Y + 9980;
+      qx := A div 10;
+      if (qx * 10 = A) and (qx and 3 <> 0) then
       begin
         qy := (y + x) div 5;
+        qy := (Y + X) div 5;
         if qy and 3 <> qx shr 2 and 1 * 2 then
           if (TerrType = fArctic) or (TerrType = fSwamp) then
             result := 1
+            Result := 1
           else if TerrType = fShore then
           begin
             if (qx + qy) and 1 = 0 then
               if qx and 3 = 2 then
                 result := 2
+                Result := 2
               else
                 result := 1
+                Result := 1
             else
               result := 0
+              Result := 0
           end
           else
             result := (qx + qy) and 1 + 1
+            Result := (qx + qy) and 1 + 1
         else
           result := 0;
+          Result := 0;
       end
       else
         result := 0;
+        Result := 0;
     end
   end;

branches/highdpi/AI/StdAI/StdAI.ai.txt

-              r124
+              r465
 #PATH_WIN32 StdAI-win32.dll
 #PATH_WIN64 StdAI-win64.dll
+#PATH_LINUX32 libstdai-i386.so
+#PATH_LINUX64 libstdai-amd64.so
+#PATH_LINUX_I386 libstdai-i386.so
+#PATH_LINUX_AMD64 libstdai-amd64.so
+#PATH_LINUX_ARM32 libstdai-arm32.so
+#PATH_LINUX_ARM64 libstdai-arm64.so
 #CREDITS Standard AI by Steffen Gerlach.

branches/highdpi/AI/StdAI/StdAI.lpr

-              r303
+              r465
 var
   AIList: array[0..nPl - 1] of TCustomAI;
   Defender: integer;
+  Defender: Integer;
   procedure Client(Command, Player: integer; var Data); stdcall;
+  procedure Client(Command, Player: Integer; var Data); stdcall;
   var
     p, y0, ToLoc: integer;
+    P, y0, ToLoc: Integer;
     UnitInfo: TUnitInfo;
   begin
 …
 {$ENDIF}
         CustomAI.Init(TNewGameData(Data));
         for p := nPl - 1 downto 0 do
           if G.RO[p] <> nil then
+        for P := nPl - 1 downto 0 do
+          if G.RO[P] <> nil then
           begin
             AIList[p] := TAI.Create(p);
             AIList[p].SetDataDefaults;
+            AIList[P] := TAI.Create(P);
+            AIList[P].SetDataDefaults;
           end
           else
             AIList[p] := nil;
+            AIList[P] := nil;
         Defender := -1;
       end;
       cGetReady:
         for p := nPl - 1 downto 0 do
           if AIList[p] <> nil then
             AIList[p].SetDataRandom;
+        for P := nPl - 1 downto 0 do
+          if AIList[P] <> nil then
+            AIList[P].SetDataRandom;
       cBreakGame:
         for p := 0 to nPl - 1 do
           if AIList[p] <> nil then
             AIList[p].Free;
+        for P := 0 to nPl - 1 do
+          if AIList[P] <> nil then
+            AIList[P].Free;
       cTurn, cContinue, scContact..scDipBreak, cShowEndContact:

branches/highdpi/AI/StdAI/ToolAI.pas

-              r349
+              r465
 type
   TGroupTransportPlan = record
     LoadLoc, uixTransport, nLoad, TurnsEmpty, TurnsLoaded: integer;
     uixLoad: array[0..15] of integer;
+    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;
+  {$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;
+    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
 …
     // 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)
 …
     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;
 …
     // 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
 …
     // calculates formations and districts
     function CheckStep(MoveStyle, TimeBeforeStep, CrossCorner: integer;
       var TimeAfterStep, RecoverTurns: integer; FromTile, ToTile: integer;
       IsCapture: boolean): 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
 …
     // 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;
+    function GetMyMoveStyle(mix, Health: Integer): Integer;
+    function Unit_MoveEx(uix, ToLoc: Integer; Options: Integer = 0): Integer;
     procedure SeaTransport_BeginInitialize;
 …
     // - 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:
 …
     // function returns false if no more transports are possible
+    function CurrentMStrength(Domain: integer): integer;
+  end;
+    function CurrentMStrength(Domain: Integer): Integer;
+  end;
 const
 …
   mxAdjacent = $00000001;
+var
+  nContinent, nOcean, nDistrict: integer;
+  Formation: array[0..lxmax * lymax - 1] of integer;
+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;
+  CityResult: array[0..nCmax - 1] of Integer;
+  Advancedness: array[0..nAdv - 1] of Integer;
 // total number of prerequisites for each advance
 implementation
 …
 type
   pinteger = ^integer;
+  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
+  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);
+  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
 …
 end;
 function NextZero(Start, Stop: pinteger; Mask: cardinal): pinteger;
+function NextZero(Start, Stop: pinteger; Mask: Cardinal): pinteger;
 begin
   while (Start <> Stop) and (Start^ and Mask <> 0) do
 …
 end;
+function TToolAI.CenterOfEmpire: integer;
+var
+  cix, Loc, x, y, sy, n: integer;
+  a, su, sv: double;
+begin
+  n := 0;
+function TToolAI.CenterOfEmpire: Integer;
+var
+  cix, Loc, X, Y, sy, N: Integer;
+  A, su, sv: Double;
+begin
+  N := 0;
   sy := 0;
   su := 0;
 …
     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;
+      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;
 …
       Inc(Result, CityReport.FoodRep - CityReport.Eaten);
   end;
   for i := nWonder 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;
+  for I := nWonder 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
 …
   ScienceSum := 0;
   if RO.Government = gAnarchy then
     exit;
+    Exit;
   for p1 := 0 to nPl - 1 do
     if RO.Tribute[p1] <= RO.TributePaid[p1] then
 …
 end;
 //------------------------------------------------------------------------------
 // City Tiles Processing
 …
 procedure TToolAI.OptimizeCityTiles;
 var
   cix: integer;
+  cix: Integer;
 begin
   for cix := 0 to RO.nCity - 1 do
 …
 procedure TToolAI.GetCityProdPotential;
 var
   cix: integer;
+  cix: Integer;
   Advice: TCityTileAdviceData;
 begin
 …
       begin
         Advice.ResourceWeights := rwMaxProd;
         Server(sGetCityTileAdvice, me, cix, Advice);
+        Server(sGetCityTileAdvice, Me, cix, Advice);
         CityResult[cix] := Advice.CityReport.ProdRep; // considers factory, but shouldn't
       end;
 …
 procedure TToolAI.GetCityTradePotential;
 var
   cix: integer;
+  cix: Integer;
   Advice: TCityTileAdviceData;
 begin
 …
       begin
         Advice.ResourceWeights := rwMaxScience;
         Server(sGetCityTileAdvice, me, cix, Advice);
+        Server(sGetCityTileAdvice, Me, cix, Advice);
         CityResult[cix] := Advice.CityReport.Trade;
       end;
 end;
 //------------------------------------------------------------------------------
 …
 procedure TToolAI.JobAssignment_Initialize;
 begin
   fillchar(JobLocOfSettler, RO.nUn * sizeof(integer), $FF); // -1
   fillchar(TileJob, MapSize, jNone);
   fillchar(TileJobScore, MapSize, 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);
+procedure TToolAI.JobAssignment_AddJob(Loc, Job, Score: Integer);
 begin
   if Score > 255 then
 …
 end;
 procedure TToolAI.JobAssignment_AddUnit(uix: integer);
 begin
   assert(MyModel[MyUnit[uix].mix].Kind in [mkSettler, mkSlaves]);
+procedure TToolAI.JobAssignment_AddUnit(uix: Integer);
+begin
+  Assert(MyModel[MyUnit[uix].mix].Kind in [mkSettler, mkSlaves]);
   JobLocOfSettler[uix] := ToAssign;
 end;
 function TToolAI.JobAssignment_GotJob(uix: integer): boolean;
+function TToolAI.JobAssignment_GotJob(uix: Integer): Boolean;
 begin
   Result := JobLocOfSettler[uix] >= 0;
 …
 const
   DistanceScore = 4;
   StepSizeByTerrain: array[0..11] of integer =
+  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;
+  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
+  TileChecked: array[0..lxmax * lymax - 1] of Boolean;
+begin
+  FillChar(SettlerOfJobLoc, MapSize * 2, $FF); // -1
   // keep up jobs that are already started
 …
         BestJob := jNone;
         BestScore := -999999;
         FillChar(TileChecked, MapSize * sizeof(boolean), False);
+        FillChar(TileChecked, MapSize * SizeOf(Boolean), False);
         Pile.Create(MapSize);
         Pile.Put(MyUnit[uix].Loc, 0); // start search for new job at current location
 …
                   and (Map[NextLoc] and (fUnit or fOwned) <> fUnit) // no foreign unit
                   and ((RO.Territory[NextLoc] < 0) or
                   (RO.Territory[NextLoc] = me)) // no foreign territory
+                  (RO.Territory[NextLoc] = Me)) // no foreign territory
                   and (Map[TestLoc] and Map[NextLoc] and fInEnemyZoC = 0) then
                   // move not prevented by ZoC
 …
             ((SettlerOfJobLoc[TestLoc] < 0) or (DistToLoc[TestLoc] > TestDistance)) then
           begin
             TestScore := integer(TileJobScore[TestLoc]) - DistanceScore * TestDistance;
+            TestScore := Integer(TileJobScore[TestLoc]) - DistanceScore * TestDistance;
             if TestScore > BestScore then
               BestCount := 0;
 …
           Unit_StartJob(uix, TileJob[JobLocOfSettler[uix]]);
       end;
+end; // JobAssignment_Go
+end;
 //------------------------------------------------------------------------------
 …
 procedure TToolAI.AnalyzeMap;
 var
   i, j, Loc, Loc1, V8, Count, Kind, MostIndex: integer;
+  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);
+  FillChar(District, MapSize * 4, $FF);
   for Loc := 0 to MapSize - 1 do
     if Map[Loc] and fTerrain = fUNKNOWN then
 …
               Formation[Loc], Formation[Loc1]);
       end;
       if (RO.Territory[Loc] = me) and (Map[Loc] and fTerrain >= fGrass) then
+      if (RO.Territory[Loc] = Me) and (Map[Loc] and fTerrain >= fGrass) then
       begin
         District[Loc] := 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;
+    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
 …
   end;
 end;
 //------------------------------------------------------------------------------
 …
 // other:  |   Basic   | 0| Speed  |              X X X             | MaxTerrType  |
 function TToolAI.GetMyMoveStyle(mix, Health: integer): integer;
+function TToolAI.GetMyMoveStyle(mix, Health: Integer): Integer;
 begin
   with MyModel[mix] do
 …
       begin
         Inc(Result, (50 + (Speed - 150) * 13 shr 7) shl 8); //HeavyCost
         if RO.Wonder[woShinkansen].EffectiveOwner <> me then
+        if RO.Wonder[woShinkansen].EffectiveOwner <> Me then
           Inc(Result, Speed * (4 * 1311) shr 17); // RailCost
         if (RO.Wonder[woGardens].EffectiveOwner <> me) or
+        if (RO.Wonder[woGardens].EffectiveOwner <> Me) or
           (Kind = mkSettler) and (Speed >= 200) then
           Inc(Result, msHostile);
 …
       begin
         Result := Speed;
         if RO.Wonder[woMagellan].EffectiveOwner = me then
+        if RO.Wonder[woMagellan].EffectiveOwner = Me then
           Inc(Result, 200);
         if Health < 100 then
 …
 end;
 function TToolAI.CheckStep(MoveStyle, TimeBeforeStep, CrossCorner: integer;
   var TimeAfterStep, RecoverTurns: integer; FromTile, ToTile: integer;
   IsCapture: boolean): integer;
 var
   MoveCost, RecoverCost: integer;
+function TToolAI.CheckStep(MoveStyle, TimeBeforeStep, CrossCorner: Integer;
+  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
+  Assert(((FromTile and fTerrain <= fMountains) or (FromTile and
     fTerrain = fUNKNOWN)) and ((ToTile and fTerrain <= fMountains) or
     (ToTile and fTerrain = fUNKNOWN)));
 …
                 if ToTile and fPeace <> 0 then
                   Result := csCheckTerritory;
                 exit;
+                Exit;
               end;
             end;
 …
           begin
             Result := csForbiddenTile;
             exit;
+            Exit;
           end;
         end
 …
               // must wait for next turn
               Result := csOk;
               exit;
+              Exit;
             end;
           end;
 …
       Result := csForbiddenTile;
   end;
 end; // CheckStep
+end;
 (*
 -------- Pathfinding Reference Implementation --------
 var
 MoveStyle,V8,Loc,Time,NextLoc,NextTime,RecoverTurns: integer;
+MoveStyle,V8,Loc,Time,NextLoc,NextTime,RecoverTurns: Integer;
 Adjacent: TVicinity8Loc;
 Reached: array[0..lxmax*lymax-1] of boolean;
 begin
 fillchar(Reached, MapSize, false);
+Reached: array[0..lxmax*lymax-1] of Boolean;
+begin
+FillChar(Reached, MapSize, False);
 MoveStyle:=GetMyMoveStyle(MyUnit[uix].mix, MyUnit[uix].Health);
 Pile.Create(MapSize);
 …
   // todo: check exit condition, e.g. whether destination reached
   Reached[Loc]:=true;
+  Reached[Loc]:=True;
   V8_to_Loc(Loc, Adjacent);
   for V8:=0 to 7 do
 …
           Pile.Put(NextLoc, NextTime+RecoverTurns*$1000);
         csForbiddenTile:
           Reached[NextLoc]:=true; // don't check moving there again
+          Reached[NextLoc]:=True; // don't check moving there again
         csCheckTerritory:
           if RO.Territory[NextLoc]=RO.Territory[Loc] then
 …
 *)
 function TToolAI.Unit_MoveEx(uix, ToLoc: integer; Options: integer): integer;
+function TToolAI.Unit_MoveEx(uix, ToLoc: Integer; Options: Integer): Integer;
 var
   Loc, NextLoc, Temp, FromLoc, EndLoc, Time, V8, MoveResult, RecoverTurns,
   NextTime, MoveStyle: integer;
+  NextTime, MoveStyle: Integer;
   Adjacent: TVicinity8Loc;
   PreLoc: array[0..lxmax * lymax - 1] of integer;
   Reached: array[0..lxmax * lymax - 1] of boolean;
+  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;
+    Exit;
   FillChar(Reached, MapSize, False);
 …
       begin
         Result := MoveResult;
         break;
+        Break;
       end;
     end;
 …
 end;
 //------------------------------------------------------------------------------
 // Oversea Transport
 …
 procedure TToolAI.SeaTransport_BeginInitialize;
 begin
   fillchar(TransportAvailable, RO.nUn * sizeof(integer), $FF); // -1
+  FillChar(TransportAvailable, RO.nUn * SizeOf(Integer), $FF); // -1
   InitComplete := False;
   HaveDestinations := False;
 …
 end;
 procedure TToolAI.SeaTransport_AddLoad(uix: integer);
 var
   i: integer;
 begin
   assert(not InitComplete); // call order violation!
+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;
+    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);
+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
 …
 end;
 procedure TToolAI.SeaTransport_AddDestination(Loc: integer);
 begin
   assert(not InitComplete); // call order violation!
+procedure TToolAI.SeaTransport_AddDestination(Loc: Integer);
+begin
+  Assert(not InitComplete); // call order violation!
   Pile.Put(Loc, $800);
   HaveDestinations := True;
 …
 procedure TToolAI.SeaTransport_EndInitialize;
 var
   Loc0, Time0, V8, Loc1, ArriveTime, RecoverTurns: integer;
+  Loc0, Time0, V8, Loc1, ArriveTime, RecoverTurns: Integer;
   Adjacent: TVicinity8Loc;
 begin
   assert(not InitComplete); // call order violation!
+  Assert(not InitComplete); // call order violation!
   InitComplete := True;
   if HaveDestinations then
   begin // calculate TurnsAfterLoad from destination locs
     fillchar(TurnsAfterLoad, MapSize, $FF); // -1
+    FillChar(TurnsAfterLoad, MapSize, $FF); // -1
     while Pile.Get(Loc0, Time0) do
     begin // search backward
 …
 end;
 function TToolAI.SeaTransport_MakeGroupPlan(
   var TransportPlan: TGroupTransportPlan): boolean;
 var
   V8, i, j, iPicked, uix, Loc0, Time0, Loc1, RecoverTurns, MoveStyle,
+  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;
+  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;
+  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!
+  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
 …
         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));
+            Assert((A <> 0) or (B <> 0));
             Inc(GroupCount);
           end;
 …
           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];
 …
               Inc(TransportPlan.nLoad);
               if TransportPlan.nLoad = TransportCapacity then
                 break;
+                Break;
             end;
           end;
           Result := True;
           exit;
+          Exit;
         end;
       end;
 …
   begin
     // select units from same continent
     fillchar(Arrived, 4 * nContinent, 0); // misuse Arrived as counter
+    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]);
+      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;
+    for F := 1 to nContinent - 1 do
+      if Arrived[F] > Arrived[OriginContinent] then
+        OriginContinent := F;
     nSelectedLoad := 0;
     for tuix := 0 to nTransportLoad - 1 do
 …
         Inc(nSelectedLoad);
         if nSelectedLoad = 16 then
           break;
+          Break;
       end;
     Pile.Create(MapSize);
     fillchar(ResponsibleTransport, MapSize * 2, $FF); // -1
     fillchar(TurnsBeforeLoad, MapSize, $FF); // -1
+    FillChar(ResponsibleTransport, MapSize * 2, $FF); // -1
+    FillChar(TurnsBeforeLoad, MapSize, $FF); // -1
     ok := False;
     for uix := 0 to RO.nUn - 1 do
 …
       Result := False;
       Pile.Free;
       exit;
+      Exit;
     end;
     while Pile.Get(Loc0, Time0) do
 …
     end;
     fillchar(Arrived, MapSize * 4, $55); // set NotReachedFlag for all tiles
     fillchar(GroupComplete, MapSize, False);
+    FillChar(Arrived, MapSize * 4, $55); // set NotReachedFlag for all tiles
+    FillChar(GroupComplete, MapSize, False);
     BestLoadLoc := -1;
 …
     begin
       uix := uixSelectedLoad[tuix];
       if MyUnit[uix].Movement = integer(MyModel[MyUnit[uix].mix].Speed) then
+      if MyUnit[uix].Movement = Integer(MyModel[MyUnit[uix].mix].Speed) then
       begin
         NotReachedFlag := 1 shl (2 * tuix);
 …
             if (TurnsBeforeLoad[Loc1] >= 0) and (TurnsAfterLoad[Loc1] >= 0) then
             begin
               i := 1;
+              I := 1;
               GroupCount := 0;
               for tuix1 := 0 to nSelectedLoad - 1 do
               begin
                 if Arrived[loc1] and i = 0 then
+                if Arrived[loc1] and I = 0 then
                   Inc(GroupCount);
                 i := i shl 2;
+                I := I shl 2;
               end;
               assert(GroupCount <= TransportCapacity);
+              Assert(GroupCount <= TransportCapacity);
               if (GroupCount = TransportCapacity) or (GroupCount = nSelectedLoad) then
                 GroupComplete[loc1] := True;
 …
           begin
             Pile.Put(MyUnit[uix].Loc, $1800 - MyUnit[uix].Movement);
             if MyUnit[uix].Movement = integer(MyModel[MyUnit[uix].mix].Speed) then
+            if MyUnit[uix].Movement = Integer(MyModel[MyUnit[uix].mix].Speed) then
               FullMovementLoc := MyUnit[uix].Loc;
             // surrounding tiles can be loaded immediately
 …
             if StartLocPtr <> ArrivedEnd then
             begin
               Loc0 := (integer(StartLocPtr) - integer(@Arrived)) shr 2;
+              Loc0 := (Integer(StartLocPtr) - Integer(@Arrived)) shr 2;
               Inc(StartLocPtr);
               Time0 := $800;
 …
               if IsFirstLoc then
                 ContinueUnit := ContinueUnit and not (1 shl tuix);
               break;
+              Break;
             end;
             IsFirstLoc := False;
 …
             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;
+              I := 1;
               GroupCount := 0;
               for tuix1 := 0 to nSelectedLoad - 1 do
               begin
                 if Arrived[Loc0] and i = 0 then
+                if Arrived[Loc0] and I = 0 then
                   Inc(GroupCount);
                 i := i shl 2;
+                I := I shl 2;
               end;
               assert(GroupCount <= TransportCapacity);
+              Assert(GroupCount <= TransportCapacity);
               if (GroupCount = TransportCapacity) or (GroupCount = nSelectedLoad) then
                 GroupComplete[Loc0] := True;
 …
                 if (TurnsBeforeLoad[Loc1] >= 0) and (TurnsAfterLoad[Loc1] >= 0) then
                 begin
                   i := 1;
+                  I := 1;
                   GroupCount := 0;
                   for tuix1 := 0 to nSelectedLoad - 1 do
                   begin
                     if Arrived[loc1] and i = 0 then
+                    if Arrived[loc1] and I = 0 then
                       Inc(GroupCount);
                     i := i shl 2;
+                    I := I shl 2;
                   end;
                   assert(GroupCount <= TransportCapacity);
+                  Assert(GroupCount <= TransportCapacity);
                   if (GroupCount = TransportCapacity) or
                     (GroupCount = nSelectedLoad) then
 …
         if 1 shl (2 * tuix) and Arrived[BestLoadLoc] = 0 then
         begin
           assert(uixTransportLoad[tuixSelectedLoad[tuix]] = uixSelectedLoad[tuix]);
+          Assert(uixTransportLoad[tuixSelectedLoad[tuix]] = uixSelectedLoad[tuix]);
           TransportPlan.uixLoad[TransportPlan.nLoad] := uixSelectedLoad[tuix];
           uixTransportLoad[tuixSelectedLoad[tuix]] :=
 …
         end;
       Result := True;
       exit;
+      Exit;
     end;
 …
     for tuix := nSelectedLoad - 1 downto 0 do
     begin
       assert(uixTransportLoad[tuixSelectedLoad[tuix]] = uixSelectedLoad[tuix]);
+      Assert(uixTransportLoad[tuixSelectedLoad[tuix]] = uixSelectedLoad[tuix]);
       uixTransportLoad[tuixSelectedLoad[tuix]] :=
         uixTransportLoad[nTransportLoad - 1];
 …
 end;
 //------------------------------------------------------------------------------
 // Misc
 function TToolAI.CurrentMStrength(Domain: integer): integer;
 var
   i: integer;
+function TToolAI.CurrentMStrength(Domain: Integer): Integer;
+var
+  I: Integer;
 begin
   Result := 0;
   for i := 0 to nUpgrade - 1 do
     with upgrade[Domain, i] do
+  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
 …
 end;
 //------------------------------------------------------------------------------
 procedure SetAdvancedness;
 var
   ad, j, Reduction, AgeThreshold: integer;
   known: array[0..nAdv - 1] of integer;
   procedure MarkPreqs(ad: integer);
+  ad, J, Reduction, AgeThreshold: Integer;
+  known: array[0..nAdv - 1] of Integer;
+  procedure MarkPreqs(ad: Integer);
   var
     i: integer;
+    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]);
+      for I := 0 to 2 do
+        if AdvPreq[ad, I] >= 0 then
+          MarkPreqs(AdvPreq[ad, I]);
     end;
   end;
 …
     FillChar(known, SizeOf(known), 0);
     MarkPreqs(ad);
     for j := 0 to nAdv - 1 do
       if known[j] > 0 then
+    for J := 0 to nAdv - 1 do
+      if known[J] > 0 then
         Inc(Advancedness[ad]);
   end;

branches/highdpi/Back.lfm

-              r246
+              r465
   Caption = 'C-evo'
   Color = clBlack
+  DesignTimePPI = 144
   Font.Color = clWindowText
   Font.Height = -13
+  Font.Height = -30
   Font.Name = 'MS Sans Serif'
   OnClose = FormClose
 …
   OnPaint = FormPaint
   OnShow = FormShow
+  LCLVersion = '1.6.2.0'
+  WindowState = wsMaximized
+  PixelsPerInch = 96
+  ShowInTaskBar = stNever
+  LCLVersion = '2.2.0.4'
   Scaled = False
+  WindowState = wsFullScreen
 end

branches/highdpi/Back.pas

-              r349
+              r465
 begin
   if Assigned(Img) then
     DpiBitCanvas(Canvas, DpiScreen.Width - Img.Width - (DpiScreen.Width - 800) *
+    DpiBitBltCanvas(Canvas, DpiScreen.Width - Img.Width - (DpiScreen.Width - 800) *
 div 8, (DpiScreen.Height - 600) div 3, Img.Width, Img.Height,
       Img.Canvas, 0, 0);
 …
       if FileExists(FileName) then begin
         Img := TDpiBitmap.Create;
+        LoadGraphicFile(img, FileName);
+        LoadGraphicFile(Img, FileName);
+        Repaint;
       end;
     end;

branches/highdpi/Brain.pas

-              r464
+              r465
+unit UBrain;
+{$mode delphi}
+unit Brain;
 interface
 uses
+  UDpiControls, Classes, SysUtils, fgl, Graphics, Protocol, LazFileUtils, dynlibs;
+  UDpiControls, Classes, SysUtils, Generics.Collections, Graphics, Protocol, LazFileUtils,
+  dynlibs, Types;
 const
 …
     Picture: TDpiBitmap;
     Beginner: Boolean;
+    procedure LoadPicture;
     procedure LoadFromFile(AIFileName: string);
     constructor Create;
 …
   { TBrains }
   TBrains = class(TFPGObjectList<TBrain>)
+  TBrains = class(TObjectList<TBrain>)
     function AddNew: TBrain;
     function GetKindCount(Kind: TBrainType): Integer;
     procedure GetByKind(Kind: TBrainType; Brains: TBrains);
     function GetBeginner: TBrain;
+    procedure LoadPictures;
   end;
 …
 uses
   ScreenTools;
+  ScreenTools, Directories;
 { TBrain }
+procedure TBrain.LoadPicture;
+var
+  TextSize: TSize;
+begin
+  if not LoadGraphicFile(Picture, GetAiDir + DirectorySeparator +
+    FileName + DirectorySeparator + FileName + '.png', [gfNoError]) then begin
+    with Picture.Canvas do begin
+      Brush.Color := $904830;
+      FillRect(Rect(0, 0, 64, 64));
+      Font.Assign(UniFont[ftTiny]);
+      Font.Style := [];
+      Font.Color := $5FDBFF;
+      TextSize := TextExtent(FileName);
+      TextOut(32 - TextSize.Width div 2, 32 - TextSize.Height div 2, FileName);
+    end;
+  end;
+end;
 procedure TBrain.LoadFromFile(AIFileName: string);
 …
       DLLName := BasePath + DirectorySeparator + Value
     {$ENDIF}{$ENDIF}
+    {$IFDEF LINUX}{$IFDEF CPU32}
+    else if Key = '#PATH_LINUX32' then
+      DLLName := BasePath + DirectorySeparator + Value
+    {$ENDIF}{$ENDIF}
+    {$IFDEF LINUX}{$IFDEF CPU64}
+    else if Key = '#PATH_LINUX64' then
+    {$IFDEF UNIX}{$IFDEF CPUI386}
+    else if Key = '#PATH_LINUX_I386' then
+      DLLName := BasePath + DirectorySeparator + Value
+    {$ENDIF}{$ENDIF}
+    {$IFDEF UNIX}{$IFDEF CPUAMD64}
+    else if Key = '#PATH_LINUX_AMD64' then
+      DLLName := BasePath + DirectorySeparator + Value
+    {$ENDIF}{$ENDIF}
+    {$IFDEF UNIX}{$IFDEF CPUARM}
+    else if Key = '#PATH_LINUX_ARM32' then
+      DLLName := BasePath + DirectorySeparator + Value
+    {$ENDIF}{$ENDIF}
+    {$IFDEF UNIX}{$IFDEF CPUAARCH64}
+    else if Key = '#PATH_LINUX_ARM64' then
       DLLName := BasePath + DirectorySeparator + Value
     {$ENDIF}{$ENDIF}
 …
 end;
+procedure TBrains.LoadPictures;
+var
+  I: Integer;
+begin
+  for I := 0 to Count - 1 do
+    with Items[I] do LoadPicture;
+end;
 end.

branches/highdpi/CityProcessing.pas

-              r349
+              r465
 // Reporting
 procedure GetCityAreaInfo(p, Loc: integer; var CityAreaInfo: TCityAreaInfo);
 function CanCityGrow(p, cix: integer): boolean;
 function GetCityReport(p, cix: integer; var CityReport: TCityReport): integer;
 function GetCityReportNew(p, cix: integer;
   var CityReportNew: TCityReportNew): integer;
+procedure GetCityAreaInfo(P, Loc: Integer; var CityAreaInfo: TCityAreaInfo);
+function CanCityGrow(P, cix: Integer): Boolean;
+function GetCityReport(P, cix: Integer; var CityReport: TCityReport): Integer;
+function GetCityReportNew(P, cix: Integer;
+  var CityReportNew: TCityReportNew): Integer;
 // Internal Tile Picking
 function AddBestCityTile(p, cix: integer): boolean;
 procedure CityGrowth(p, cix: integer);
 procedure CityShrink(p, cix: integer);
 procedure Pollute(p, cix: integer);
+function AddBestCityTile(P, cix: Integer): Boolean;
+procedure CityGrowth(P, cix: Integer);
+procedure CityShrink(P, cix: Integer);
+procedure Pollute(P, cix: Integer);
 // Turn Processing
 procedure PayCityMaintenance(p, cix: integer);
 procedure CollectCityResources(p, cix: integer);
 function CityTurn(p, cix: integer): boolean;
+procedure PayCityMaintenance(P, cix: Integer);
+procedure CollectCityResources(P, cix: Integer);
+function CityTurn(P, cix: Integer): Boolean;
 // Tile Access
 function SetCityTiles(p, cix, NewTiles: integer;
   TestOnly: boolean = false): integer;
 procedure GetCityTileAdvice(p, cix: integer; var Advice: TCityTileAdviceData);
+function SetCityTiles(P, cix, NewTiles: Integer;
+  TestOnly: Boolean = False): Integer;
+procedure GetCityTileAdvice(P, cix: Integer; var Advice: TCityTileAdviceData);
 // Start/End Game
 …
 procedure ReleaseGame;
 implementation
 type
   TTradeProcessing = record
+    TaxBonus, LuxBonus, ScienceBonus, FutResBonus, ScienceDoubling,
+      HappyBase: integer;
+    RelCorr: single;
+    FlexibleLuxury: boolean;
+    TaxBonus: Integer;
+    LuxBonus: Integer;
+    ScienceBonus: Integer;
+    FutResBonus: Integer;
+    ScienceDoubling: Integer;
+    HappyBase: Integer;
+    RelCorr: Single;
+    FlexibleLuxury: Boolean;
   end;
   TProdProcessing = record
+    ProdBonus, PollBonus, FutProdBonus, PollThreshold: integer;
+    ProdBonus: Integer;
+    PollBonus: Integer;
+    FutProdBonus: Integer;
+    PollThreshold: Integer;
   end;
 …
   TCityReportEx = record
+    BaseHappiness, BaseControl, Material: integer;
+    BaseHappiness: Integer;
+    BaseControl: Integer;
+    Material: Integer;
     ProdProcessing: TProdProcessing;
     TradeProcessing: TTradeProcessing;
 …
 var
   MaxDist: integer;
+  {
     Reporting
     ____________________________________________________________________
+  }
 procedure GetCityAreaInfo(p, Loc: integer; var CityAreaInfo: TCityAreaInfo);
 var
   V21, Loc1, p1: integer;
+  MaxDist: Integer;
+{
+  Reporting
+  ____________________________________________________________________
+}
+procedure GetCityAreaInfo(P, Loc: Integer; var CityAreaInfo: TCityAreaInfo);
+var
+  V21, Loc1, p1: Integer;
   Radius: TVicinity21Loc;
 begin
 {$IFOPT O-}assert(1 shl p and InvalidTreatyMap = 0); {$ENDIF}
+{$IFOPT O-}Assert(1 shl P and InvalidTreatyMap = 0); {$ENDIF}
   with CityAreaInfo do
   begin
 …
       begin
         p1 := RealMap[Loc1] shr 27;
         if (p1 < nPl) and (p1 <> p) and (RW[p].Treaty[p1] >= trPeace) then
+        if (p1 < nPl) and (p1 <> P) and (RW[P].Treaty[p1] >= trPeace) then
           Available[V21] := faTreaty
         else if (ZoCMap[Loc1] > 0) and (Occupant[Loc1] <> p) and
           (RW[p].Treaty[Occupant[Loc1]] < trAlliance) then
+        else if (ZoCMap[Loc1] > 0) and (Occupant[Loc1] <> P) and
+          (RW[P].Treaty[Occupant[Loc1]] < trAlliance) then
           Available[V21] := faSiege
         else if (UsedByCity[Loc1] <> -1) and (UsedByCity[Loc1] <> Loc) then
           Available[V21] := faNotAvailable
         else
           Available[V21] := faAvailable
       end
     end;
   end
 end;
 function CanCityGrow(p, cix: integer): boolean;
 begin
   with RW[p].City[cix] do
     result := (Size < MaxCitySize) and
+          Available[V21] := faAvailable;
+      end;
+    end;
+  end;
+end;
+function CanCityGrow(P, cix: Integer): Boolean;
+begin
+  with RW[P].City[cix] do
+    Result := (Size < MaxCitySize) and
       ((Size < NeedAqueductSize) or (Built[imAqueduct] = 1) and
       (Size < NeedSewerSize) or (Built[imSewer] = 1));
 end;
 procedure DetermineCityProdProcessing(p, cix: integer;
+procedure DetermineCityProdProcessing(P, cix: Integer;
   var ProdProcessing: TProdProcessing);
 begin
   with RW[p].City[cix], ProdProcessing do
+  with RW[P].City[cix], ProdProcessing do
   begin
     ProdBonus := 0;
     PollBonus := 0;
     if Built[imFactory] = 1 then
       inc(ProdBonus);
+      Inc(ProdBonus);
     if Built[imMfgPlant] = 1 then
       inc(ProdBonus);
+      Inc(ProdBonus);
     if (Built[imPower] = 1) or (Built[imHydro] = 1) or (Built[imNuclear] = 1) or
       (GWonder[woHoover].EffectiveOwner = p) then
+      (GWonder[woHoover].EffectiveOwner = P) then
       ProdBonus := ProdBonus * 2;
     if Built[imFactory] = 1 then
       inc(PollBonus);
+      Inc(PollBonus);
     if Built[imMfgPlant] = 1 then
       inc(PollBonus);
+      Inc(PollBonus);
     if (Built[imFactory] + Built[imMfgPlant] > 0) then
       if (Built[imHydro] > 0) or (GWonder[woHoover].EffectiveOwner = p) then
         dec(PollBonus)
+      if (Built[imHydro] > 0) or (GWonder[woHoover].EffectiveOwner = P) then
+        Dec(PollBonus)
       else if (Built[imNuclear] = 0) and (Built[imPower] = 1) then
         inc(PollBonus);
     if (RW[p].Government <= gDespotism) or (Built[imRecycling] = 1) then
+        Inc(PollBonus);
+    if (RW[P].Government <= gDespotism) or (Built[imRecycling] = 1) then
       PollBonus := -2; // no pollution
     PollThreshold := Size;
     FutProdBonus := 0;
     if RW[p].Tech[futProductionTechnology] > 0 then
+    if RW[P].Tech[futProductionTechnology] > 0 then
     begin // future tech benefits
       if Built[imFactory] = 1 then
         inc(FutProdBonus, FactoryFutureBonus * RW[p].Tech
+        Inc(FutProdBonus, FactoryFutureBonus * RW[P].Tech
           [futProductionTechnology]);
       if Built[imMfgPlant] = 1 then
         inc(FutProdBonus, MfgPlantFutureBonus * RW[p].Tech
+        Inc(FutProdBonus, MfgPlantFutureBonus * RW[P].Tech
           [futProductionTechnology]);
     end;
 …
 end;
 procedure BoostProd(BaseProd: integer; ProdProcessing: TProdProcessing;
   var Prod, Poll: integer);
+procedure BoostProd(BaseProd: Integer; ProdProcessing: TProdProcessing;
+  var Prod, Poll: Integer);
 begin
   Poll := BaseProd * (2 + ProdProcessing.PollBonus) shr 1;
 …
     Poll := 0
   else
     dec(Poll, ProdProcessing.PollThreshold);
+    Dec(Poll, ProdProcessing.PollThreshold);
   if ProdProcessing.FutProdBonus > 0 then
     Prod := BaseProd * (100 + ProdProcessing.ProdBonus * 50 +
 …
 end;
 procedure DetermineCityTradeProcessing(p, cix, HappinessBeforeLux: integer;
+procedure DetermineCityTradeProcessing(P, cix, HappinessBeforeLux: Integer;
   var TradeProcessing: TTradeProcessing);
 var
   i, Dist: integer;
 begin
   with RW[p].City[cix], TradeProcessing do
+  I, Dist: Integer;
+begin
+  with RW[P].City[cix], TradeProcessing do
   begin
     TaxBonus := 0;
     ScienceBonus := 0;
     if Built[imMarket] = 1 then
       inc(TaxBonus, 2);
+      Inc(TaxBonus, 2);
     if Built[imBank] = 1 then
     begin
       inc(TaxBonus, 3);
       if RW[p].NatBuilt[imStockEx] = 1 then
         inc(TaxBonus, 3);
+      Inc(TaxBonus, 3);
+      if RW[P].NatBuilt[imStockEx] = 1 then
+        Inc(TaxBonus, 3);
     end;
     LuxBonus := TaxBonus;
     if Built[imLibrary] = 1 then
       inc(ScienceBonus, 2);
+      Inc(ScienceBonus, 2);
     if Built[imUniversity] = 1 then
       inc(ScienceBonus, 3);
+      Inc(ScienceBonus, 3);
     if Built[imResLab] = 1 then
       inc(ScienceBonus, 3);
+      Inc(ScienceBonus, 3);
     ScienceDoubling := 0;
     if Built[imNatObs] > 0 then
       inc(ScienceDoubling);
     if RW[p].Government = gFundamentalism then
       dec(ScienceDoubling)
     else if (GWonder[woNewton].EffectiveOwner = p) and
       (RW[p].Government = gMonarchy) then
       inc(ScienceDoubling);
     FlexibleLuxury := ((ServerVersion[p] >= $0100F1) and
       (GWonder[woLiberty].EffectiveOwner = p) or (ServerVersion[p] < $0100F1)
       and (GWonder[woMich].EffectiveOwner = p)) and
       (RW[p].Government <> gAnarchy);
+      Inc(ScienceDoubling);
+    if RW[P].Government = gFundamentalism then
+      Dec(ScienceDoubling)
+    else if (GWonder[woNewton].EffectiveOwner = P) and
+      (RW[P].Government = gMonarchy) then
+      Inc(ScienceDoubling);
+    FlexibleLuxury := ((ServerVersion[P] >= $0100F1) and
+      (GWonder[woLiberty].EffectiveOwner = P) or (ServerVersion[P] < $0100F1)
+      and (GWonder[woMich].EffectiveOwner = P)) and
+      (RW[P].Government <> gAnarchy);
     FutResBonus := 0;
     if RW[p].Tech[futResearchTechnology] > 0 then
+    if RW[P].Tech[futResearchTechnology] > 0 then
     begin // future tech benefits
       if Built[imUniversity] = 1 then
         inc(FutResBonus, UniversityFutureBonus * RW[p].Tech
+        Inc(FutResBonus, UniversityFutureBonus * RW[P].Tech
           [futResearchTechnology]);
       if Built[imResLab] = 1 then
         inc(FutResBonus, ResLabFutureBonus * RW[p].Tech[futResearchTechnology]);
     end;
     if (RW[p].NatBuilt[imPalace] > 0) or (ServerVersion[p] < $010000) then
+        Inc(FutResBonus, ResLabFutureBonus * RW[P].Tech[futResearchTechnology]);
+    end;
+    if (RW[P].NatBuilt[imPalace] > 0) or (ServerVersion[P] < $010000) then
     begin // calculate corruption
       Dist := MaxDist;
       for i := 0 to RW[p].nCity - 1 do
         if (RW[p].City[i].Loc >= 0) and (RW[p].City[i].Built[imPalace] = 1) then
           Dist := Distance(Loc, RW[p].City[i].Loc);
       if (Dist = 0) or (CorrLevel[RW[p].Government] = 0) then
+      for I := 0 to RW[P].nCity - 1 do
+        if (RW[P].City[I].Loc >= 0) and (RW[P].City[I].Built[imPalace] = 1) then
+          Dist := Distance(Loc, RW[P].City[I].Loc);
+      if (Dist = 0) or (CorrLevel[RW[P].Government] = 0) then
         RelCorr := 0.0
       else
       begin
         RelCorr := Dist / MaxDist;
         if CorrLevel[RW[p].Government] > 1 then
           RelCorr := Exp(ln(RelCorr) / CorrLevel[RW[p].Government]);
+        if CorrLevel[RW[P].Government] > 1 then
+          RelCorr := Exp(ln(RelCorr) / CorrLevel[RW[P].Government]);
         if Built[imCourt] = 1 then
           RelCorr := RelCorr / 2;
 …
       RelCorr := 1.0;
     HappyBase := Size + HappinessBeforeLux;
   end
 end;
 procedure SplitTrade(Trade, TaxRate, LuxRate, Working: integer;
+  end;
+end;
+procedure SplitTrade(Trade, TaxRate, LuxRate, Working: Integer;
   TradeProcessing: TTradeProcessing; var Corruption, Tax, Lux,
   Science: integer);
 var
   plus: integer;
+  Science: Integer);
+var
+  plus: Integer;
 begin
   Corruption := Trunc(Trade * TradeProcessing.RelCorr);
 …
 end;
 function GetProjectCost(p, cix: integer): integer;
 var
   i: integer;
 begin
   with RW[p].City[cix] do
+function GetProjectCost(P, cix: Integer): Integer;
+var
+  I: Integer;
+begin
+  with RW[P].City[cix] do
   begin
     if Project and cpImp = 0 then
     begin
       result := RW[p].Model[Project and cpIndex].Cost; { unit project }
+      Result := RW[P].Model[Project and cpIndex].Cost; { unit project }
       if Project and cpConscripts <> 0 then
       begin
         i := RW[p].Model[Project and cpIndex].MCost;
         result := result - 3 * i;
         if result <= 0 then
           result := i
+        I := RW[P].Model[Project and cpIndex].MCost;
+        Result := Result - 3 * I;
+        if Result <= 0 then
+          Result := I;
       end
       else if RW[p].Model[Project and cpIndex].Cap[mcLine] > 0 then
+      else if RW[P].Model[Project and cpIndex].Cap[mcLine] > 0 then
         if Project0 and (not cpAuto or cpRepeat) = Project and not cpAuto or cpRepeat
         then
           result := result shr 1
+          Result := Result shr 1
         else
           result := result * 2
+          Result := Result * 2;
     end
     else
     begin { improvement project }
       result := Imp[Project and cpIndex].Cost;
       if (Project and cpIndex < nWonder) and (GWonder[woColossus].EffectiveOwner = p)
+      Result := Imp[Project and cpIndex].Cost;
+      if (Project and cpIndex < nWonder) and (GWonder[woColossus].EffectiveOwner = P)
       then
         result := result * ColossusEffect div 100;
     end;
     result := result * BuildCostMod[Difficulty[p]] div 12;
   end
 end;
 function GetSmallCityReport(p, cix: integer; var CityReport: TCityReport;
   PCityReportEx: PCityReportEx = nil): integer;
 var
   i, uix, V21, Loc1, ForcedSupport, BaseHappiness, Control: integer;
+        Result := Result * ColossusEffect div 100;
+    end;
+    Result := Result * BuildCostMod[Difficulty[P]] div 12;
+  end;
+end;
+function GetSmallCityReport(P, cix: Integer; var CityReport: TCityReport;
+  PCityReportEx: PCityReportEx = nil): Integer;
+var
+  I, uix, V21, Loc1, ForcedSupport, BaseHappiness, Control: Integer;
   ProdProcessing: TProdProcessing;
   TradeProcessing: TTradeProcessing;
   Radius: TVicinity21Loc;
   UnitReport: TUnitReport;
   RareOK: array [0 .. 3] of integer;
+  RareOK: array [0 .. 3] of Integer;
   TileInfo: TTileInfo;
 begin
   with RW[p].City[cix], CityReport do
+  with RW[P].City[cix], CityReport do
   begin
     if HypoTiles <= 0 then
       HypoTiles := Tiles;
     if HypoTax < 0 then
       HypoTax := RW[p].TaxRate;
+      HypoTax := RW[P].TaxRate;
     if HypoLux < 0 then
       HypoLux := RW[p].LuxRate;
     if (Flags and chCaptured <> 0) or (RW[p].Government = gAnarchy) then
+      HypoLux := RW[P].LuxRate;
+    if (Flags and chCaptured <> 0) or (RW[P].Government = gAnarchy) then
     begin
       Working := 0;
       for V21 := 1 to 26 do
         if HypoTiles and (1 shl V21) <> 0 then
           inc(Working); // for backward compatibility
       if RW[p].Government = gFundamentalism then
+          Inc(Working); // for backward compatibility
+      if RW[P].Government = gFundamentalism then
       begin
         Happy := Size;
         Control := Size
+        Control := Size;
       end // !!! old bug, kept for compatibility
       else
       begin
         Happy := 0;
         Control := 0
+        Control := 0;
       end;
 …
           BaseHappiness := Size;
       end;
       for i := 0 to nWonder - 1 do
         if Built[i] = 1 then
+      for I := 0 to nWonder - 1 do
+        if Built[I] = 1 then
         begin
           inc(Happy);
           inc(BaseHappiness, 2)
+          Inc(Happy);
+          Inc(BaseHappiness, 2);
         end;
       if Built[imTemple] = 1 then
       begin
         inc(Happy);
         inc(BaseHappiness, 2)
+        Inc(Happy);
+        Inc(BaseHappiness, 2);
       end;
       if Built[imCathedral] = 1 then
       begin
         inc(Happy, 2);
         inc(BaseHappiness, 4);
         if GWonder[woBach].EffectiveOwner = p then
+        Inc(Happy, 2);
+        Inc(BaseHappiness, 4);
+        if GWonder[woBach].EffectiveOwner = P then
         begin
           inc(Happy);
           inc(BaseHappiness, 2)
+          Inc(Happy);
+          Inc(BaseHappiness, 2);
         end;
       end;
       if Built[imTheater] > 0 then
       begin
         inc(Happy, 2);
         inc(BaseHappiness, 4)
+        Inc(Happy, 2);
+        Inc(BaseHappiness, 4);
       end;
       // calculate unit support
 {$IFOPT O-}assert(InvalidTreatyMap = 0); {$ENDIF}
+{$IFOPT O-}Assert(InvalidTreatyMap = 0); {$ENDIF}
       Support := 0;
       ForcedSupport := 0;
       Eaten := Size * 2;
       Deployed := 0;
       for uix := 0 to RW[p].nUn - 1 do
         with RW[p].Un[uix] do
+      for uix := 0 to RW[P].nUn - 1 do
+        with RW[P].Un[uix] do
           if (Loc >= 0) and (Home = cix) then
           begin
             GetUnitReport(p, uix, UnitReport);
             inc(Eaten, UnitReport.FoodSupport);
+            GetUnitReport(P, uix, UnitReport);
+            Inc(Eaten, UnitReport.FoodSupport);
             if UnitReport.ReportFlags and urfAlwaysSupport <> 0 then
               inc(ForcedSupport, UnitReport.ProdSupport)
+              Inc(ForcedSupport, UnitReport.ProdSupport)
             else
               inc(Support, UnitReport.ProdSupport);
+              Inc(Support, UnitReport.ProdSupport);
             if UnitReport.ReportFlags and urfDeployed <> 0 then
               inc(Deployed);
+              Inc(Deployed);
           end;
       if Deployed >= Happy then
         Happy := 0
       else
         dec(Happy, Deployed);
       dec(Support, Size * SupportFree[RW[p].Government] shr 1);
+        Dec(Happy, Deployed);
+      Dec(Support, Size * SupportFree[RW[P].Government] shr 1);
       if Support < 0 then
         Support := 0;
       inc(Support, ForcedSupport);
+      Inc(Support, ForcedSupport);
       { control }
       case RW[p].Government of
+      case RW[P].Government of
         gDespotism:
           for uix := 0 to RW[p].nUn - 1 do
             if (RW[p].Un[uix].Loc = Loc) and
               (RW[p].Model[RW[p].Un[uix].mix].Kind = mkSpecial_TownGuard) then
+          for uix := 0 to RW[P].nUn - 1 do
+            if (RW[P].Un[uix].Loc = Loc) and
+              (RW[P].Model[RW[P].Un[uix].mix].Kind = mkSpecial_TownGuard) then
             begin
               inc(Happy);
               inc(Control, 2)
+              Inc(Happy);
+              Inc(Control, 2);
             end;
         gFundamentalism:
 …
             BaseHappiness := 0; // done by control
             Happy := Size;
             Control := Size
+            Control := Size;
           end;
       end;
       // collect processing parameters
       DetermineCityProdProcessing(p, cix, ProdProcessing);
       DetermineCityTradeProcessing(p, cix, BaseHappiness + Control - 2 *
+      DetermineCityProdProcessing(P, cix, ProdProcessing);
+      DetermineCityTradeProcessing(P, cix, BaseHappiness + Control - 2 *
         Deployed, TradeProcessing);
 …
           // HypoTiles go beyond map border!
           begin
             result := eInvalid;
             exit
+            Result := eInvalid;
+            Exit;
           end;
           GetTileInfo(p, cix, Loc1, TileInfo);
           inc(FoodRep, TileInfo.Food);
           inc(ProdRep, TileInfo.Prod);
           inc(Trade, TileInfo.Trade);
+          GetTileInfo(P, cix, Loc1, TileInfo);
+          Inc(FoodRep, TileInfo.Food);
+          Inc(ProdRep, TileInfo.Prod);
+          Inc(Trade, TileInfo.Trade);
           if (RealMap[Loc1] and fModern <> 0) and
             (RW[p].Tech[adMassProduction] >= tsApplicable) then
             inc(RareOK[RealMap[Loc1] shr 25 and 3]);
           inc(Working)
+            (RW[P].Tech[adMassProduction] >= tsApplicable) then
+            Inc(RareOK[RealMap[Loc1] shr 25 and 3]);
+          Inc(Working);
         end;
       if Built[imAlgae] = 1 then
         inc(FoodRep, 12);
+        Inc(FoodRep, 12);
       if PCityReportEx <> nil then
 …
     end;
   end;
   result := eOk;
 end; { GetSmallCityReport }
 function GetCityReport(p, cix: integer; var CityReport: TCityReport): integer;
 begin
   result := GetSmallCityReport(p, cix, CityReport);
   CityReport.Storage := StorageSize[Difficulty[p]];
   CityReport.ProdCost := GetProjectCost(p, cix);
 end;
 function GetCityReportNew(p, cix: integer;
   var CityReportNew: TCityReportNew): integer;
+  Result := eOk;
+end;
+function GetCityReport(P, cix: Integer; var CityReport: TCityReport): Integer;
+begin
+  Result := GetSmallCityReport(P, cix, CityReport);
+  CityReport.Storage := StorageSize[Difficulty[P]];
+  CityReport.ProdCost := GetProjectCost(P, cix);
+end;
+function GetCityReportNew(P, cix: Integer;
+  var CityReportNew: TCityReportNew): Integer;
 var
   CityReport: TCityReport;
 …
     CityReport.HypoTax := HypoTaxRate;
     CityReport.HypoLux := HypoLuxuryRate;
     result := GetSmallCityReport(p, cix, CityReport, @CityReportEx);
     FoodSupport := CityReport.Eaten - 2 * RW[p].City[cix].Size;
+    Result := GetSmallCityReport(P, cix, CityReport, @CityReportEx);
+    FoodSupport := CityReport.Eaten - 2 * RW[P].City[cix].Size;
     MaterialSupport := CityReport.Support;
     ProjectCost := GetProjectCost(p, cix);
     Storage := StorageSize[Difficulty[p]];
+    ProjectCost := GetProjectCost(P, cix);
+    Storage := StorageSize[Difficulty[P]];
     Deployed := CityReport.Deployed;
     Morale := CityReportEx.BaseHappiness;
     CollectedControl := CityReportEx.BaseControl +
       (RW[p].City[cix].Size - CityReport.Working) * 2;
+      (RW[P].City[cix].Size - CityReport.Working) * 2;
     CollectedFood := CityReport.FoodRep;
     CollectedMaterial := CityReportEx.Material;
 …
     Luxury := CityReport.Lux;
     FoodSurplus := CityReport.FoodRep - CityReport.Eaten;
     HappinessBalance := Morale + Luxury + CollectedControl - RW[p].City[cix]
+    HappinessBalance := Morale + Luxury + CollectedControl - RW[P].City[cix]
       .Size - 2 * Deployed;
   end;
 …
   ____________________________________________________________________
+}
 procedure NextBest(p, cix: integer; var SelectedLoc, SelectedV21: integer);
+procedure NextBest(P, cix: Integer; var SelectedLoc, SelectedV21: Integer);
 { best tile unused but available by city cix }
 var
   Resources, Most, Loc1, p1, V21: integer;
+  Resources, Most, Loc1, p1, V21: Integer;
   TileInfo: TTileInfo;
   Radius: TVicinity21Loc;
 begin
 {$IFOPT O-}assert(1 shl p and InvalidTreatyMap = 0); {$ENDIF}
+{$IFOPT O-}Assert(1 shl P and InvalidTreatyMap = 0); {$ENDIF}
   Most := 0;
   SelectedLoc := -1;
   SelectedV21 := -1;
   with RW[p].City[cix] do
+  with RW[P].City[cix] do
   begin
     V21_to_Loc(Loc, Radius);
 …
       begin
         p1 := RealMap[Loc1] shr 27;
         if ((p1 = nPl) or (p1 = p) or (RW[p].Treaty[p1] < trPeace)) and
           ((ZoCMap[Loc1] = 0) or (Occupant[Loc1] = p) or
           (RW[p].Treaty[Occupant[Loc1]] = trAlliance)) then
+        if ((p1 = nPl) or (p1 = P) or (RW[P].Treaty[p1] < trPeace)) and
+          ((ZoCMap[Loc1] = 0) or (Occupant[Loc1] = P) or
+          (RW[P].Treaty[Occupant[Loc1]] = trAlliance)) then
         begin
           GetTileInfo(p, cix, Loc1, TileInfo);
+          GetTileInfo(P, cix, Loc1, TileInfo);
           Resources := TileInfo.Food shl 16 + TileInfo.Prod shl 8 +
             TileInfo.Trade;
 …
             SelectedLoc := Loc1;
             SelectedV21 := V21;
             Most := Resources
           end
         end
       end
     end;
   end;
 end;
 procedure NextWorst(p, cix: integer; var SelectedLoc, SelectedV21: integer);
+            Most := Resources;
+          end;
+        end;
+      end;
+    end;
+  end;
+end;
+procedure NextWorst(P, cix: Integer; var SelectedLoc, SelectedV21: Integer);
 { worst tile used by city cix }
 var
   Resources, Least, Loc1, V21: integer;
+  Resources, Least, Loc1, V21: Integer;
   Radius: TVicinity21Loc;
   TileInfo: TTileInfo;
 …
   SelectedLoc := -1;
   SelectedV21 := -1;
   with RW[p].City[cix] do
+  with RW[P].City[cix] do
   begin
     V21_to_Loc(Loc, Radius);
 …
         if (Loc1 >= 0) and (Loc1 < MapSize) and (1 shl V21 and Tiles <> 0) then
         begin
           GetTileInfo(p, cix, Loc1, TileInfo);
+          GetTileInfo(P, cix, Loc1, TileInfo);
           Resources := TileInfo.Food shl 16 + TileInfo.Prod shl 8 +
             TileInfo.Trade;
 …
             SelectedLoc := Loc1;
             SelectedV21 := V21;
             Least := Resources
           end
         end;
       end
   end
 end;
 function NextPoll(p, cix: integer): integer;
 var
   Resources, Best, dx, dy, Loc1, Dist, BestDist, V21, pTerr: integer;
+            Least := Resources;
+          end;
+        end;
+      end;
+  end;
+end;
+function NextPoll(P, cix: Integer): Integer;
+var
+  Resources, Best, dx, dy, Loc1, Dist, BestDist, V21, pTerr: Integer;
   Radius: TVicinity21Loc;
   TileInfo: TTileInfo;
 begin
   BestDist := MaxInt;
 {$IFOPT O-}assert(1 shl p and InvalidTreatyMap = 0); {$ENDIF}
+{$IFOPT O-}Assert(1 shl P and InvalidTreatyMap = 0); {$ENDIF}
   Best := 0;
   result := -1;
   with RW[p].City[cix] do
+  Result := -1;
+  with RW[P].City[cix] do
   begin
     V21_to_Loc(Loc, Radius);
 …
         begin
           pTerr := RealMap[Loc1] shr 27;
           if (pTerr = nPl) or (pTerr = p) or (RW[p].Treaty[pTerr] < trPeace)
+          if (pTerr = nPl) or (pTerr = P) or (RW[P].Treaty[pTerr] < trPeace)
           then
           begin
             GetTileInfo(p, cix, Loc1, TileInfo);
+            GetTileInfo(P, cix, Loc1, TileInfo);
             Resources := TileInfo.Prod shl 16 + TileInfo.Trade shl 8 +
               TileInfo.Food;
 …
             then
             begin
               result := Loc1;
+              Result := Loc1;
               Best := Resources;
               BestDist := Dist;
 …
 end;
 function AddBestCityTile(p, cix: integer): boolean;
 var
   TileLoc, V21: integer;
 begin
   NextBest(p, cix, TileLoc, V21);
   result := TileLoc >= 0;
   if result then
     with RW[p].City[cix] do
     begin
       assert(1 shl V21 and Tiles = 0);
+function AddBestCityTile(P, cix: Integer): Boolean;
+var
+  TileLoc, V21: Integer;
+begin
+  NextBest(P, cix, TileLoc, V21);
+  Result := TileLoc >= 0;
+  if Result then
+    with RW[P].City[cix] do
+    begin
+      Assert(1 shl V21 and Tiles = 0);
       Tiles := Tiles or (1 shl V21);
       UsedByCity[TileLoc] := Loc
     end
 end;
 procedure CityGrowth(p, cix: integer);
 var
   TileLoc, V21: integer;
+      UsedByCity[TileLoc] := Loc;
+    end;
+end;
+procedure CityGrowth(P, cix: Integer);
+var
+  TileLoc, V21: Integer;
   AltCityReport: TCityReport;
 begin
   with RW[p].City[cix] do
+  with RW[P].City[cix] do
   begin
     inc(Size);
     NextBest(p, cix, TileLoc, V21);
+    Inc(Size);
+    NextBest(P, cix, TileLoc, V21);
     if TileLoc >= 0 then
     begin { test whether exploitation of tile would lead to disorder }
 …
       AltCityReport.HypoTax := -1;
       AltCityReport.HypoLux := -1;
       GetSmallCityReport(p, cix, AltCityReport);
+      GetSmallCityReport(P, cix, AltCityReport);
       if AltCityReport.Working - AltCityReport.Happy <= Size shr 1 then
       // !!! change to new style disorder
       begin { no disorder -- exploit tile }
         assert(1 shl V21 and Tiles = 0);
+        Assert(1 shl V21 and Tiles = 0);
         Tiles := Tiles or (1 shl V21);
         UsedByCity[TileLoc] := Loc
       end
     end;
   end
 end;
 procedure CityShrink(p, cix: integer);
 var
   TileLoc, V21, Working: integer;
+        UsedByCity[TileLoc] := Loc;
+      end;
+    end;
+  end;
+end;
+procedure CityShrink(P, cix: Integer);
+var
+  TileLoc, V21, Working: Integer;
   AltCityReport: TCityReport;
 begin
   with RW[p].City[cix] do
+  with RW[P].City[cix] do
   begin
     Working := 0;
     for V21 := 1 to 26 do
       if Tiles and (1 shl V21) <> 0 then
         inc(Working);
     dec(Size);
     if Food > StorageSize[Difficulty[p]] then
       Food := StorageSize[Difficulty[p]];
     NextWorst(p, cix, TileLoc, V21);
+        Inc(Working);
+    Dec(Size);
+    if Food > StorageSize[Difficulty[P]] then
+      Food := StorageSize[Difficulty[P]];
+    NextWorst(P, cix, TileLoc, V21);
     if Working > Size then
     begin { all citizens were working -- worst tile no longer exploited }
       assert(1 shl V21 and Tiles <> 0);
+      Assert(1 shl V21 and Tiles <> 0);
       Tiles := Tiles and not(1 shl V21);
       UsedByCity[TileLoc] := -1
+      UsedByCity[TileLoc] := -1;
     end
     else { test whether exploitation of tile would lead to disorder }
 …
       AltCityReport.HypoTax := -1;
       AltCityReport.HypoLux := -1;
       GetSmallCityReport(p, cix, AltCityReport);
+      GetSmallCityReport(P, cix, AltCityReport);
       if AltCityReport.Working - AltCityReport.Happy > Size shr 1 then
       // !!! change to new style disorder
       begin { disorder -- don't exploit tile }
         assert(1 shl V21 and Tiles <> 0);
+        Assert(1 shl V21 and Tiles <> 0);
         Tiles := Tiles and not(1 shl V21);
         UsedByCity[TileLoc] := -1
       end
     end;
   end
 end;
 procedure Pollute(p, cix: integer);
 var
   PollutionLoc: integer;
 begin
   with RW[p].City[cix] do
+        UsedByCity[TileLoc] := -1;
+      end;
+    end;
+  end;
+end;
+procedure Pollute(P, cix: Integer);
+var
+  PollutionLoc: Integer;
+begin
+  with RW[P].City[cix] do
   begin
     Pollution := Pollution - MaxPollution;
     PollutionLoc := NextPoll(p, cix);
+    PollutionLoc := NextPoll(P, cix);
     if PollutionLoc >= 0 then
     begin
       inc(Flags, chPollution);
+      Inc(Flags, chPollution);
       RealMap[PollutionLoc] := RealMap[PollutionLoc] or fPoll;
     end
+    end;
   end;
 end;
 …
   ____________________________________________________________________
+}
 procedure PayCityMaintenance(p, cix: integer);
 var
   i: integer;
 begin
   with RW[p], City[cix] do
     for i := nWonder to nImp - 1 do
       if (Built[i] > 0) and (Project0 and (cpImp or cpIndex) <> (cpImp or i))
+procedure PayCityMaintenance(P, cix: Integer);
+var
+  I: Integer;
+begin
+  with RW[P], City[cix] do
+    for I := nWonder to nImp - 1 do
+      if (Built[I] > 0) and (Project0 and (cpImp or cpIndex) <> (cpImp or I))
       then // don't pay maintenance when just completed
       begin
         dec(Money, Imp[i].Maint);
+        Dec(Money, Imp[I].Maint);
         if Money < 0 then
         begin { out of money - sell improvement }
           inc(Money, Imp[i].Cost * BuildCostMod[Difficulty[p]] div 12);
           Built[i] := 0;
           if Imp[i].Kind <> ikCommon then
+          Inc(Money, Imp[I].Cost * BuildCostMod[Difficulty[P]] div 12);
+          Built[I] := 0;
+          if Imp[I].Kind <> ikCommon then
           begin
             assert(i <> imSpacePort);
+            Assert(I <> imSpacePort);
             // never sell automatically! (solution: no maintenance)
             NatBuilt[i] := 0;
             if i = imGrWall then
               GrWallContinent[p] := -1;
+            NatBuilt[I] := 0;
+            if I = imGrWall then
+              GrWallContinent[P] := -1;
           end;
           inc(Flags, chImprovementLost)
         end
       end;
 end;
 procedure CollectCityResources(p, cix: integer);
 var
   CityStorage, CityProjectCost: integer;
+          Inc(Flags, chImprovementLost);
+        end;
+      end;
+end;
+procedure CollectCityResources(P, cix: Integer);
+var
+  CityStorage, CityProjectCost: Integer;
   CityReport: TCityReportNew;
   Disorder: boolean;
 begin
   with RW[p], City[cix], CityReport do
+  Disorder: Boolean;
+begin
+  with RW[P], City[cix], CityReport do
     if Flags and chCaptured <> 0 then
     begin
       Flags := Flags and not chDisorder;
       dec(Flags, $10000);
+      Dec(Flags, $10000);
       if Flags and chCaptured = 0 then
         Flags := Flags or chAfterCapture;
 …
       HypoTaxRate := -1;
       HypoLuxuryRate := -1;
       GetCityReportNew(p, cix, CityReport);
       CityStorage := StorageSize[Difficulty[p]];
       CityProjectCost := GetProjectCost(p, cix);
+      GetCityReportNew(P, cix, CityReport);
+      CityStorage := StorageSize[Difficulty[P]];
+      CityProjectCost := GetProjectCost(P, cix);
       Disorder := (HappinessBalance < 0);
 …
       if not Disorder and ((Government = gFuture) or (Size >= NeedAqueductSize)
         and (FoodSurplus < 2)) and (FoodSurplus > 0) then
         inc(Money, FoodSurplus)
+        Inc(Money, FoodSurplus)
       else if not(Disorder and (FoodSurplus > 0)) then
       begin { calculate new food storage }
 …
           (Project and (cpImp + cpIndex) <> cpImp + imAqueduct) and
           (Project and (cpImp + cpIndex) <> cpImp + imSewer) and
           not CanCityGrow(p, cix) then
           inc(Flags, chNoGrowthWarning);
+          not CanCityGrow(P, cix) then
+          Inc(Flags, chNoGrowthWarning);
       end;
       if Prod > CityProjectCost then
       begin
         inc(Money, Prod - CityProjectCost);
         Prod := CityProjectCost
+        Inc(Money, Prod - CityProjectCost);
+        Prod := CityProjectCost;
       end;
       if Production < 0 then
 …
       else if not Disorder and (Flags and chProductionSabotaged = 0) then
         if Project and (cpImp + cpIndex) = cpImp + imTrGoods then
           inc(Money, Production)
+          Inc(Money, Production)
         else
           inc(Prod, Production);
+          Inc(Prod, Production);
       if not Disorder then
       begin
         { sum research points and taxes }
         inc(Research, Science);
         inc(Money, Tax);
+        Inc(Research, Science);
+        Inc(Money, Tax);
         Pollution := Pollution + AddPollution;
       end;
 …
 end;
 function CityTurn(p, cix: integer): boolean;
+function CityTurn(P, cix: Integer): Boolean;
 // return value: whether city keeps existing
 var
   i, uix, cix2, p1, SizeMod, CityStorage, CityProjectCost, NewImp, Det,
     TestDet: integer;
   LackOfMaterial, CheckGrow, DoProd, IsActive: boolean;
 begin
   with RW[p], City[cix] do
+  I, uix, cix2, p1, SizeMod, CityStorage, CityProjectCost, NewImp, Det,
+    TestDet: Integer;
+  LackOfMaterial, CheckGrow, DoProd, IsActive: Boolean;
+begin
+  with RW[P], City[cix] do
   begin
     SizeMod := 0;
     CityStorage := StorageSize[Difficulty[p]];
     CityProjectCost := GetProjectCost(p, cix);
+    CityStorage := StorageSize[Difficulty[P]];
+    CityProjectCost := GetProjectCost(P, cix);
     LackOfMaterial := Flags and chUnitLost <> 0;
 …
     if CheckGrow and (GTestFlags and tfImmGrow <> 0) then { fast growth }
     begin
       if CanCityGrow(p, cix) then
         inc(SizeMod)
+      if CanCityGrow(P, cix) then
+        Inc(SizeMod);
     end
     else if CheckGrow and (Food >= CityStorage) then { normal growth }
     begin
       if CanCityGrow(p, cix) then
+      if CanCityGrow(P, cix) then
       begin
         if Built[imGranary] = 1 then
           dec(Food, CityStorage shr 1)
+          Dec(Food, CityStorage shr 1)
         else
           dec(Food, CityStorage);
         inc(SizeMod)
       end
+          Dec(Food, CityStorage);
+        Inc(SizeMod);
+      end;
     end
     else if Food < 0 then { famine }
 …
       // check if settlers or conscripts there to disband
       uix := -1;
       for i := 0 to nUn - 1 do
         if (Un[i].Loc >= 0) and (Un[i].Home = cix) and
           ((Model[Un[i].mix].Kind = mkSettler)
+      for I := 0 to nUn - 1 do
+        if (Un[I].Loc >= 0) and (Un[I].Home = cix) and
+          ((Model[Un[I].mix].Kind = mkSettler)
           { and (GWonder[woFreeSettlers].EffectiveOwner<>p) }
           or (Un[i].Flags and unConscripts <> 0)) and
           ((uix = -1) or (Model[Un[i].mix].Cost < Model[Un[uix].mix].Cost) or
           (Model[Un[i].mix].Cost = Model[Un[uix].mix].Cost) and
           (Un[i].Exp < Un[uix].Exp)) then
           uix := i;
+          or (Un[I].Flags and unConscripts <> 0)) and
+          ((uix = -1) or (Model[Un[I].mix].Cost < Model[Un[uix].mix].Cost) or
+          (Model[Un[I].mix].Cost = Model[Un[uix].mix].Cost) and
+          (Un[I].Exp < Un[uix].Exp)) then
+          uix := I;
       if uix >= 0 then
       begin
         RemoveUnit_UpdateMap(p, uix);
         inc(Flags, chUnitLost);
+        RemoveUnit_UpdateMap(P, uix);
+        Inc(Flags, chUnitLost);
       end
       else
       begin
         dec(SizeMod);
         inc(Flags, chPopDecrease)
+        Dec(SizeMod);
+        Inc(Flags, chPopDecrease);
       end
     end;
 …
         uix := -1;
         Det := MaxInt;
         for i := 0 to nUn - 1 do
           if (Un[i].Loc >= 0) and (Un[i].Home = cix) then
             with Model[Un[i].mix] do
+        for I := 0 to nUn - 1 do
+          if (Un[I].Loc >= 0) and (Un[I].Home = cix) then
+            with Model[Un[I].mix] do
             begin
               if Kind = mkSpecial_TownGuard then
                 TestDet := Un[i].Health + Un[i].Exp shl 8
+                TestDet := Un[I].Health + Un[I].Exp shl 8
                 // disband townguards first
               else
               begin
                 TestDet := Un[i].Health + Un[i].Exp shl 8 + Cost shl 16;
+                TestDet := Un[I].Health + Un[I].Exp shl 8 + Cost shl 16;
                 // value of unit
                 if Flags and mdDoubleSupport <> 0 then
 …
               if TestDet < Det then
               begin
                 uix := i;
                 Det := TestDet
+                uix := I;
+                Det := TestDet;
               end;
             end;
         if uix >= 0 then
         begin
           RemoveUnit_UpdateMap(p, uix);
           inc(Flags, chUnitLost);
         end
       end
+          RemoveUnit_UpdateMap(P, uix);
+          Inc(Flags, chUnitLost);
+        end;
+      end;
     end;
 …
       (GWonder[Project and cpIndex].CityID <> WonderNotBuiltYet) then
     begin
       inc(Flags, chOldWonder);
       DoProd := false;
+      Inc(Flags, chOldWonder);
+      DoProd := False;
     end;
 …
       (Project and cpConscripts <> 0))) then
     begin
       inc(Flags, chNoSettlerProd);
       DoProd := false;
+      Inc(Flags, chNoSettlerProd);
+      DoProd := False;
     end;
     if DoProd then
     begin { project complete }
       dec(Prod, CityProjectCost);
+      Dec(Prod, CityProjectCost);
       if Project and cpImp = 0 then { produce unit }
       begin
         if nUn < numax then
         begin
           CreateUnit(p, Project and cpIndex);
+          CreateUnit(P, Project and cpIndex);
           Un[nUn - 1].Loc := Loc;
           with Un[nUn - 1] do
 …
               Exp := ExpCost * 2; { vet }
             if Project and cpConscripts <> 0 then
               Flags := Flags or unConscripts
+              Flags := Flags or unConscripts;
           end;
           PlaceUnit(p, nUn - 1);
+          PlaceUnit(P, nUn - 1);
           UpdateUnitMap(Loc);
           if Model[Project and cpIndex].Kind = mkSettler then
             dec(SizeMod, 2) { settler produced - city shrink }
+            Dec(SizeMod, 2) { settler produced - city shrink }
           else if (Model[Project and cpIndex].Kind = mkSlaves) or
             (Project and cpConscripts <> 0) then
             dec(SizeMod); { slaves/conscripts produced - city shrink }
+            Dec(SizeMod); { slaves/conscripts produced - city shrink }
         end;
         Project0 := Project or cpRepeat or cpCompleted;
 …
       else if Imp[Project and cpIndex].Kind = ikShipPart then
       begin { produce ship parts }
         inc(GShip[p].Parts[Project and cpIndex - imShipComp]);
+        Inc(GShip[P].Parts[Project and cpIndex - imShipComp]);
         Project0 := Project or cpCompleted;
       end
 …
       begin
         NewImp := Project and cpIndex;
         inc(Money, Prod); { change rest to money }
+        Inc(Money, Prod); { change rest to money }
         Project0 := Project or cpCompleted;
         Project := cpImp + imTrGoods;
 …
         if Imp[NewImp].Kind in [ikNatLocal, ikNatGlobal] then
         begin // nat. project
           for i := 0 to nCity - 1 do
             if (City[i].Loc >= 0) and (City[i].Built[NewImp] = 1) then
+          for I := 0 to nCity - 1 do
+            if (City[I].Loc >= 0) and (City[I].Built[NewImp] = 1) then
             begin { allowed only once }
               inc(Money, Imp[NewImp].Cost * BuildCostMod[Difficulty[p]] div 12);
               City[i].Built[NewImp] := 0;
+              Inc(Money, Imp[NewImp].Cost * BuildCostMod[Difficulty[P]] div 12);
+              City[I].Built[NewImp] := 0;
             end;
           NatBuilt[NewImp] := 1;
 …
           case NewImp of
             imGrWall:
               GrWallContinent[p] := Continent[Loc];
+              GrWallContinent[P] := Continent[Loc];
           end;
         end;
 …
         begin // wonder
           GWonder[NewImp].CityID := ID;
           GWonder[NewImp].EffectiveOwner := p;
+          GWonder[NewImp].EffectiveOwner := P;
           CheckExpiration(NewImp);
 …
             woEiffel:
               begin // reactivate wonders
                 for i := 0 to nWonder - 1 do
                   if Imp[i].Expiration >= 0 then
+                for I := 0 to nWonder - 1 do
+                  if Imp[I].Expiration >= 0 then
                     for cix2 := 0 to nCity - 1 do
                       if (City[cix2].Loc >= 0) and (City[cix2].Built[i] = 1)
+                      if (City[cix2].Loc >= 0) and (City[cix2].Built[I] = 1)
                       then
                         GWonder[i].EffectiveOwner := p
+                        GWonder[I].EffectiveOwner := P;
               end;
             woLighthouse:
               CheckSpecialModels(p, preLighthouse);
+              CheckSpecialModels(P, preLighthouse);
             woLeo:
               begin
                 inc(Research, TechBaseCost(nTech[p], Difficulty[p]) +
                   TechBaseCost(nTech[p] + 2, Difficulty[p]));
                 CheckSpecialModels(p, preLeo);
+                Inc(Research, TechBaseCost(nTech[P], Difficulty[P]) +
+                  TechBaseCost(nTech[P] + 2, Difficulty[P]));
+                CheckSpecialModels(P, preLeo);
               end;
             woPyramids:
               CheckSpecialModels(p, preBuilder);
+              CheckSpecialModels(P, preBuilder);
             woMir:
               begin
                 for p1 := 0 to nPl - 1 do
                   if (p1 <> p) and (1 shl p1 and GAlive <> 0) then
+                  if (p1 <> P) and (1 shl p1 and GAlive <> 0) then
                   begin
                     if RW[p].Treaty[p1] = trNoContact then
                       IntroduceEnemy(p, p1);
                     GiveCivilReport(p, p1);
                     GiveMilReport(p, p1)
+                    if RW[P].Treaty[p1] = trNoContact then
+                      IntroduceEnemy(P, p1);
+                    GiveCivilReport(P, p1);
+                    GiveMilReport(P, p1);
                   end;
               end
+              end;
           end;
         end;
         for i := 0 to nImpReplacement - 1 do // sell obsolete buildings
           if (ImpReplacement[i].NewImp = NewImp) and
             (Built[ImpReplacement[i].OldImp] > 0) then
+        for I := 0 to nImpReplacement - 1 do // sell obsolete buildings
+          if (ImpReplacement[I].NewImp = NewImp) and
+            (Built[ImpReplacement[I].OldImp] > 0) then
           begin
             inc(RW[p].Money, Imp[ImpReplacement[i].OldImp].Cost * BuildCostMod
               [Difficulty[p]] div 12);
             Built[ImpReplacement[i].OldImp] := 0;
+            Inc(RW[P].Money, Imp[ImpReplacement[I].OldImp].Cost * BuildCostMod
+              [Difficulty[P]] div 12);
+            Built[ImpReplacement[I].OldImp] := 0;
           end;
         if NewImp in [imPower, imHydro, imNuclear] then
           for i := 0 to nImp - 1 do
             if (i <> NewImp) and (i in [imPower, imHydro, imNuclear]) and
               (Built[i] > 0) then
+          for I := 0 to nImp - 1 do
+            if (I <> NewImp) and (I in [imPower, imHydro, imNuclear]) and
+              (Built[I] > 0) then
             begin // sell obsolete power plant
               inc(RW[p].Money, Imp[i].Cost * BuildCostMod[Difficulty[p]
+              Inc(RW[P].Money, Imp[I].Cost * BuildCostMod[Difficulty[P]
                 ] div 12);
               Built[i] := 0;
+              Built[I] := 0;
             end;
 …
       end;
       Prod0 := Prod;
       inc(Flags, chProduction)
+      Inc(Flags, chProduction);
     end
     else
 …
     if SizeMod > 0 then
     begin
       CityGrowth(p, cix);
       inc(Flags, chPopIncrease);
     end;
     result := Size + SizeMod >= 2;
     if result then
+      CityGrowth(P, cix);
+      Inc(Flags, chPopIncrease);
+    end;
+    Result := Size + SizeMod >= 2;
+    if Result then
       while SizeMod < 0 do
       begin
         CityShrink(p, cix);
         inc(SizeMod)
       end;
   end
 end; // CityTurn
+        CityShrink(P, cix);
+        Inc(SizeMod);
+      end;
+  end;
+end;
+{
 …
   ____________________________________________________________________
+}
 function SetCityTiles(p, cix, NewTiles: integer;
   TestOnly: boolean = false): integer;
 var
   V21, Working, ChangeTiles, AddTiles, Loc1: integer;
+function SetCityTiles(P, cix, NewTiles: Integer;
+  TestOnly: Boolean = False): Integer;
+var
+  V21, Working, ChangeTiles, AddTiles, Loc1: Integer;
   CityAreaInfo: TCityAreaInfo;
   Radius: TVicinity21Loc;
 begin
   with RW[p].City[cix] do
+  with RW[P].City[cix] do
   begin
     ChangeTiles := NewTiles xor integer(Tiles);
+    ChangeTiles := NewTiles xor Integer(Tiles);
     AddTiles := NewTiles and not Tiles;
     if Mode = moPlaying then
 …
       if NewTiles and not $67F7F76 <> 0 then
       begin
         result := eInvalid;
         exit
+        Result := eInvalid;
+        Exit
       end; // invalid tile index included
       if NewTiles and (1 shl 13) = 0 then
       begin
         result := eViolation;
         exit
+        Result := eViolation;
+        Exit
       end; // city tile must be exploited
       if ChangeTiles = 0 then
       begin
         result := eNotChanged;
         exit
+        Result := eNotChanged;
+        Exit
       end;
       if AddTiles <> 0 then
       begin
         // check if new tiles possible
         GetCityAreaInfo(p, Loc, CityAreaInfo);
+        GetCityAreaInfo(P, Loc, CityAreaInfo);
         for V21 := 1 to 26 do
           if AddTiles and (1 shl V21) <> 0 then
             if CityAreaInfo.Available[V21] <> faAvailable then
             begin
               result := eTileNotAvailable;
               exit
+              Result := eTileNotAvailable;
+              Exit;
             end;
         // not more tiles than inhabitants
 …
         for V21 := 1 to 26 do
           if NewTiles and (1 shl V21) <> 0 then
             inc(Working);
+            Inc(Working);
         if Working > Size then
         begin
           result := eNoWorkerAvailable;
           exit
         end;
       end;
     end;
     result := eOk;
+          Result := eNoWorkerAvailable;
+          Exit;
+        end;
+      end;
+    end;
+    Result := eOk;
     if not TestOnly then
     begin
 …
         begin
           Loc1 := Radius[V21];
           assert((Loc1 >= 0) and (Loc1 < MapSize));
+          Assert((Loc1 >= 0) and (Loc1 < MapSize));
           if NewTiles and (1 shl V21) <> 0 then
             UsedByCity[Loc1] := Loc // employ tile
           else if UsedByCity[Loc1] <> Loc then
             assert(Mode < moPlaying)
+            Assert(Mode < moPlaying)
             // should only happen during loading, because of wrong sSetCityTiles command order
           else
             UsedByCity[Loc1] := -1 // unemploy tile
         end;
       Tiles := NewTiles
     end
   end;
 end;
 procedure GetCityTileAdvice(p, cix: integer; var Advice: TCityTileAdviceData);
+            UsedByCity[Loc1] := -1; // unemploy tile
+        end;
+      Tiles := NewTiles;
+    end;
+  end;
+end;
+procedure GetCityTileAdvice(P, cix: Integer; var Advice: TCityTileAdviceData);
 const
   oFood = 0;
 …
 type
   TTileData = record
+    Food, Prod, Trade, SubValue, V21: integer;
+  end;
+var
+  i, V21, Loc1, nHierarchy, iH, iT, iH_Switch, MinWorking, MaxWorking,
+    Food: Integer;
+    Prod: Integer;
+    Trade: Integer;
+    SubValue: Integer;
+    V21: Integer;
+  end;
+var
+  I, V21, Loc1, nHierarchy, iH, iT, iH_Switch, MinWorking, MaxWorking,
     WantedProd, MinFood, MinProd, count, Take, MaxTake, AreaSize, FormulaCode,
     NeedRare, RareTiles, cix1, dx, dy, BestTiles, ProdBeforeBoost, TestTiles,
     SubPlus, SuperPlus: integer;
   SuperValue, BestSuperValue, SubValue, BestSubValue: integer;
   Value, BestValue, ValuePlus: extended;
   ValueFormula_Weight: array [oFood .. oScience] of extended;
   ValueFormula_Multiply: array [oFood .. oScience] of boolean;
   Output: array [oFood .. oScience] of integer;
+    SubPlus, SuperPlus: Integer;
+  SuperValue, BestSuperValue, SubValue, BestSubValue: Integer;
+  Value, BestValue, ValuePlus: Extended;
+  ValueFormula_Weight: array [oFood .. oScience] of Extended;
+  ValueFormula_Multiply: array [oFood .. oScience] of Boolean;
+  Output: array [oFood .. oScience] of Integer;
   TileInfo, BaseTileInfo: TTileInfo;
   Radius, Radius1: TVicinity21Loc;
 …
   CityAreaInfo: TCityAreaInfo;
   Hierarchy: array [0 .. 20, 0 .. 31] of TTileData;
   nTile, nSelection: array [0 .. 20] of integer;
   SubCriterion: array [0 .. 27] of integer;
   FoodWasted, FoodToTax, ProdToTax, RareOK, NeedStep2, IsBest: boolean;
 begin
   if (RW[p].Government = gAnarchy) or (RW[p].City[cix].Flags and chCaptured <> 0)
+  nTile, nSelection: array [0 .. 20] of Integer;
+  SubCriterion: array [0 .. 27] of Integer;
+  FoodWasted, FoodToTax, ProdToTax, RareOK, NeedStep2, IsBest: Boolean;
+begin
+  if (RW[P].Government = gAnarchy) or (RW[P].City[cix].Flags and chCaptured <> 0)
   then
   begin
 …
     Advice.Tiles := 1 shl CityOwnTile;
     Advice.CityReport.HypoTiles := 1 shl CityOwnTile;
     exit;
   end;
   for i := oFood to oScience do
+    Exit;
+  end;
+  for I := oFood to oScience do
   begin // decode evaluation formula from weights parameter
     FormulaCode := Advice.ResourceWeights shr (24 - 8 * i) and $FF;
     ValueFormula_Multiply[i] := FormulaCode and $80 <> 0;
+    FormulaCode := Advice.ResourceWeights shr (24 - 8 * I) and $FF;
+    ValueFormula_Multiply[I] := FormulaCode and $80 <> 0;
     if FormulaCode and $40 <> 0 then
       ValueFormula_Weight[i] := (FormulaCode and $0F) *
+      ValueFormula_Weight[I] := (FormulaCode and $0F) *
         (1 shl (FormulaCode and $30 shr 4)) / 16
     else
       ValueFormula_Weight[i] := (FormulaCode and $0F) *
+      ValueFormula_Weight[I] := (FormulaCode and $0F) *
         (1 shl (FormulaCode and $30 shr 4));
   end;
 …
   TestReport.HypoTax := -1;
   TestReport.HypoLux := -1;
   GetSmallCityReport(p, cix, TestReport, @CityReportEx);
   with RW[p].City[cix] do
+  GetSmallCityReport(P, cix, TestReport, @CityReportEx);
+  with RW[P].City[cix] do
   begin
     V21_to_Loc(Loc, Radius);
     FoodToTax := RW[p].Government = gFuture;
+    FoodToTax := RW[P].Government = gFuture;
     ProdToTax := Project and (cpImp + cpIndex) = cpImp + imTrGoods;
     FoodWasted := not FoodToTax and (Food = StorageSize[Difficulty[p]]) and
       not CanCityGrow(p, cix);
+    FoodWasted := not FoodToTax and (Food = StorageSize[Difficulty[P]]) and
+      not CanCityGrow(P, cix);
     // sub criteria
 …
           V21 xor $15;
     end;
     for cix1 := 0 to RW[p].nCity - 1 do
+    for cix1 := 0 to RW[P].nCity - 1 do
       if cix1 <> cix then
       begin
         Loc1 := RW[p].City[cix1].Loc;
+        Loc1 := RW[P].City[cix1].Loc;
         if Loc1 >= 0 then
         begin
 …
               begin
                 dxdy(Loc, Loc1, dx, dy);
                 dec(SubCriterion[(dy + 3) shl 2 + (dx + 3) shr 1], 160);
+                Dec(SubCriterion[(dy + 3) shl 2 + (dx + 3) shr 1], 160);
               end;
             end;
 …
       end;
     GetCityAreaInfo(p, Loc, CityAreaInfo);
+    GetCityAreaInfo(P, Loc, CityAreaInfo);
     AreaSize := 0;
     for V21 := 1 to 26 do
       if CityAreaInfo.Available[V21] = faAvailable then
         inc(AreaSize);
     if RW[p].Government = gFundamentalism then
+        Inc(AreaSize);
+    if RW[P].Government = gFundamentalism then
     begin
       MinWorking := Size;
 …
       if MinWorking > Size then
         MinWorking := Size;
       if (RW[p].LuxRate = 0) and not CityReportEx.TradeProcessing.FlexibleLuxury
+      if (RW[P].LuxRate = 0) and not CityReportEx.TradeProcessing.FlexibleLuxury
       then
         MaxWorking := MinWorking
 …
         Loc1 := Radius[V21];
         if (Loc1 >= 0) and (Loc1 < MapSize) and
           (RealMap[Loc1] and fModern = cardinal(NeedRare)) then
+          (RealMap[Loc1] and fModern = Cardinal(NeedRare)) then
           RareTiles := RareTiles or (1 shl V21);
       end
+      end;
     end;
 …
       begin
         Loc1 := Radius[V21];
         assert((Loc1 >= 0) and (Loc1 < MapSize));
         GetTileInfo(p, cix, Loc1, TileInfo);
+        Assert((Loc1 >= 0) and (Loc1 < MapSize));
+        GetTileInfo(P, cix, Loc1, TileInfo);
         if V21 = CityOwnTile then
           BaseTileInfo := TileInfo
 …
               (TileInfo.Trade = Hierarchy[iH, iT].Trade) and
               (SubCriterion[V21] >= SubCriterion[Hierarchy[iH, iT].V21])) do
               inc(iT);
+              Inc(iT);
             if (iT = nTile[iH]) // new worst tile in this hierarchy
               or ((TileInfo.Food >= Hierarchy[iH, iT].Food)
 …
               and (TileInfo.Prod >= Hierarchy[iH, iT].Prod) and
               (TileInfo.Trade >= Hierarchy[iH, iT].Trade)) then
               break; // insert position found!
             inc(iH);
+              Break; // insert position found!
+            Inc(iH);
           end;
           if iH = nHierarchy then
           begin // need to start new hierarchy
             nTile[iH] := 0;
             inc(nHierarchy);
+            Inc(nHierarchy);
             iT := 0;
           end;
           move(Hierarchy[iH, iT], Hierarchy[iH, iT + 1],
+          Move(Hierarchy[iH, iT], Hierarchy[iH, iT + 1],
             (nTile[iH] - iT) * SizeOf(TTileData));
           inc(nTile[iH]);
+          Inc(nTile[iH]);
           Hierarchy[iH, iT].V21 := V21;
           Hierarchy[iH, iT].Food := TileInfo.Food;
 …
         begin
           Loc1 := Radius[V21];
           assert((V21 <> CityOwnTile) and (Loc1 >= 0) and (Loc1 < MapSize));
           GetTileInfo(p, cix, Loc1, TileInfo);
+          Assert((V21 <> CityOwnTile) and (Loc1 >= 0) and (Loc1 < MapSize));
+          GetTileInfo(P, cix, Loc1, TileInfo);
           if iH = nHierarchy then
           begin // need to start new hierarchy
             nTile[iH] := 0;
             inc(nHierarchy);
+            Inc(nHierarchy);
             iT := 0;
           end
           else
             iT := nTile[iH];
           inc(nTile[iH]);
+          Inc(nTile[iH]);
           Hierarchy[iH, iT].V21 := V21;
           Hierarchy[iH, iT].Food := TileInfo.Food; // = 0
 …
     end;
     if Built[imAlgae] > 0 then
       inc(BaseTileInfo.Food, 12);
+      Inc(BaseTileInfo.Food, 12);
     // step 2: summarize resources
     for iH := 0 to nHierarchy - 1 do
     begin
       move(Hierarchy[iH, 0], Hierarchy[iH, 1], nTile[iH] * SizeOf(TTileData));
+      Move(Hierarchy[iH, 0], Hierarchy[iH, 1], nTile[iH] * SizeOf(TTileData));
       Hierarchy[iH, 0].Food := 0;
       Hierarchy[iH, 0].Prod := 0;
 …
       for iT := 1 to nTile[iH] do
       begin
         inc(Hierarchy[iH, iT].Food, Hierarchy[iH, iT - 1].Food);
         inc(Hierarchy[iH, iT].Prod, Hierarchy[iH, iT - 1].Prod);
         inc(Hierarchy[iH, iT].Trade, Hierarchy[iH, iT - 1].Trade);
         inc(Hierarchy[iH, iT].SubValue, Hierarchy[iH, iT - 1].SubValue);
+        Inc(Hierarchy[iH, iT].Food, Hierarchy[iH, iT - 1].Food);
+        Inc(Hierarchy[iH, iT].Prod, Hierarchy[iH, iT - 1].Prod);
+        Inc(Hierarchy[iH, iT].Trade, Hierarchy[iH, iT - 1].Trade);
+        Inc(Hierarchy[iH, iT].SubValue, Hierarchy[iH, iT - 1].SubValue);
         Hierarchy[iH, iT].V21 := 1 shl Hierarchy[iH, iT].V21 +
           Hierarchy[iH, iT - 1].V21;
 …
         (ProdBeforeBoost < WantedProd)) do
       begin
         assert(nSelection[iH] = 0);
+        Assert(nSelection[iH] = 0);
         Take := MinWorking - TestReport.Working;
         if Take > nTile[iH] then
 …
           while (Take < MaxTake) and
             (TestReport.FoodRep + Hierarchy[iH, Take].Food < MinFood) do
             inc(Take);
+            Inc(Take);
           while (Take < MaxTake) and
             (ProdBeforeBoost + Hierarchy[iH, Take].Prod < MinProd) do
             inc(Take);
+            Inc(Take);
         end;
         nSelection[iH] := Take;
         inc(TestReport.Working, Take);
+        Inc(TestReport.Working, Take);
         with Hierarchy[iH, Take] do
         begin
           inc(TestReport.FoodRep, Food);
           inc(ProdBeforeBoost, Prod);
           inc(TestReport.Trade, Trade);
         end;
         inc(iH);
       end;
       assert((TestReport.Working >= MinWorking) and
+          Inc(TestReport.FoodRep, Food);
+          Inc(ProdBeforeBoost, Prod);
+          Inc(TestReport.Trade, Trade);
+        end;
+        Inc(iH);
+      end;
+      Assert((TestReport.Working >= MinWorking) and
         (TestReport.Working <= MaxWorking));
       if (TestReport.FoodRep >= MinFood) and (ProdBeforeBoost >= MinProd) then
       begin
         SplitTrade(TestReport.Trade, RW[p].TaxRate, RW[p].LuxRate,
+        SplitTrade(TestReport.Trade, RW[P].TaxRate, RW[P].LuxRate,
           TestReport.Working, CityReportEx.TradeProcessing,
           TestReport.Corruption, TestReport.Tax, TestReport.Lux,
 …
           TestReport.Deployed >= Size then
         begin // city is not in disorder -- evaluate combination
           inc(count);
+          Inc(count);
           if (MinProd < WantedProd) and (ProdBeforeBoost > MinProd) then
           begin // no combination reached wanted prod yet
 …
               then
               begin
                 inc(Output[oTax], Output[oFood]);
+                Inc(Output[oTax], Output[oFood]);
                 Output[oFood] := 0;
               end;
 …
               if NeedRare > 0 then
               begin
                 RareOK := false;
+                RareOK := False;
                 for iH := 0 to nHierarchy - 1 do
                   if Hierarchy[iH, nSelection[iH]].V21 and RareTiles <> 0 then
                     RareOK := true;
+                    RareOK := True;
                 if not RareOK then
                   TestReport.ProdRep := TestReport.Support;
 …
               if ProdToTax then
               begin
                 inc(Output[oTax], Output[oProd]);
+                Inc(Output[oTax], Output[oProd]);
                 Output[oProd] := 0;
               end;
             end;
             NeedStep2 := false;
+            NeedStep2 := False;
             Value := 0;
             for i := oFood to oScience do
               if ValueFormula_Multiply[i] then
                 NeedStep2 := true
+            for I := oFood to oScience do
+              if ValueFormula_Multiply[I] then
+                NeedStep2 := True
               else
                 Value := Value + ValueFormula_Weight[i] * Output[i];
+                Value := Value + ValueFormula_Weight[I] * Output[I];
             if NeedStep2 then
             begin
               if Value > 0 then
                 Value := ln(Value) + 123;
               for i := oFood to oScience do
                 if ValueFormula_Multiply[i] and (Output[i] > 0) then
                   Value := Value + ValueFormula_Weight[i] *
                     (ln(Output[i]) + 123);
+              for I := oFood to oScience do
+                if ValueFormula_Multiply[I] and (Output[I] > 0) then
+                  Value := Value + ValueFormula_Weight[I] *
+                    (ln(Output[I]) + 123);
             end;
 …
               for iH := 0 to nHierarchy - 1 do
               begin
                 inc(TestTiles, Hierarchy[iH, nSelection[iH]].V21);
                 inc(SubValue, Hierarchy[iH, nSelection[iH]].SubValue);
+                Inc(TestTiles, Hierarchy[iH, nSelection[iH]].V21);
+                Inc(SubValue, Hierarchy[iH, nSelection[iH]].SubValue);
               end;
               IsBest := true;
+              IsBest := True;
               if (SuperPlus = 0) and (ValuePlus = 0.0) then
               begin
                 SubPlus := SubValue - BestSubValue;
                 if SubPlus < 0 then
                   IsBest := false
+                  IsBest := False
                 else if SubPlus = 0 then
                 begin
                   assert(TestTiles <> BestTiles);
+                  Assert(TestTiles <> BestTiles);
                   IsBest := TestTiles > BestTiles
                 end
 …
                   TestReport.Lux shr 1;
                 Advice.CityReport := TestReport;
               end
             end // if (SuperPlus>0) or (ValuePlus>=0.0)
           end // if SuperPlus>=0
         end
+              end;
+            end; // if (SuperPlus>0) or (ValuePlus>=0.0)
+          end; // if SuperPlus>=0
+        end;
       end;
 …
         with Hierarchy[iH_Switch, nSelection[iH_Switch]] do
         begin
           dec(TestReport.FoodRep, Food);
           dec(ProdBeforeBoost, Prod);
           dec(TestReport.Trade, Trade);
         end;
         inc(nSelection[iH_Switch]);
         inc(TestReport.Working);
+          Dec(TestReport.FoodRep, Food);
+          Dec(ProdBeforeBoost, Prod);
+          Dec(TestReport.Trade, Trade);
+        end;
+        Inc(nSelection[iH_Switch]);
+        Inc(TestReport.Working);
         if (nSelection[iH_Switch] <= nTile[iH_Switch]) and
           (TestReport.Working <= MaxWorking) then
 …
           with Hierarchy[iH_Switch, nSelection[iH_Switch]] do
           begin
             inc(TestReport.FoodRep, Food);
             inc(ProdBeforeBoost, Prod);
             inc(TestReport.Trade, Trade);
+            Inc(TestReport.FoodRep, Food);
+            Inc(ProdBeforeBoost, Prod);
+            Inc(TestReport.Trade, Trade);
           end;
           break;
         end;
         dec(TestReport.Working, nSelection[iH_Switch]);
+          Break;
+        end;
+        Dec(TestReport.Working, nSelection[iH_Switch]);
         nSelection[iH_Switch] := 0;
         inc(iH_Switch);
+        Inc(iH_Switch);
       until iH_Switch = nHierarchy;
     until iH_Switch = nHierarchy; // everything tested -- done
   end;
   assert(BestSuperValue > 0); // advice should always be possible
+  Assert(BestSuperValue > 0); // advice should always be possible
   Advice.Tiles := BestTiles;
   Advice.CityReport.HypoTiles := BestTiles;
 end; // GetCityTileAdvice
+end;
+{
 …
 procedure InitGame;
 var
   p, i, mixTownGuard: integer;
+  P, I, mixTownGuard: Integer;
 begin
   MaxDist := Distance(0, MapSize - lx shr 1);
   for p := 0 to nPl - 1 do
     if (1 shl p and GAlive <> 0) then
       with RW[p] do
+  for P := 0 to nPl - 1 do
+    if (1 shl P and GAlive <> 0) then
+      with RW[P] do
       begin // initialize capital
         mixTownGuard := 0;
         while Model[mixTownGuard].Kind <> mkSpecial_TownGuard do
           inc(mixTownGuard);
+          Inc(mixTownGuard);
         with City[0] do
         begin
           Built[imPalace] := 1;
           Size := 4;
           for i := 2 to Size do
             AddBestCityTile(p, 0);
+          for I := 2 to Size do
+            AddBestCityTile(P, 0);
           Project := mixTownGuard;
         end;

branches/highdpi/CmdList.pas

-              r361
+              r465
 uses
   Classes;
+  Classes, SysUtils, Math;
 const
   MaxDataSize = 1024;
+  CommandDataElementSize = 4;
+  CommandDataElementCountMask = $F;
+  CommandDataMaxSize = CommandDataElementSize * CommandDataElementCountMask;
 type
 …
     constructor Create;
     destructor Destroy; override;
     procedure Get(var Command, Player, Subject: integer; var Data: pointer);
     procedure GetDataChanges(Data: pointer; DataSize: integer);
     procedure Put(Command, Player, Subject: integer; Data: pointer);
     procedure PutDataChanges(Command, Player: integer;
       OldData, NewData: pointer; DataSize: integer);
     procedure LoadFromFile(const f: TFileStream);
     procedure SaveToFile(const f: TFileStream);
     procedure AppendToFile(const f: TFileStream; const OldState: TCmdListState);
+    procedure Get(var Command, Player, Subject: Integer; var Data: Pointer);
+    procedure GetDataChanges(Data: Pointer; DataSize: Integer);
+    procedure Put(Command, Player, Subject: Integer; Data: Pointer);
+    procedure PutDataChanges(Command, Player: Integer;
+      OldData, NewData: Pointer; DataSize: Integer);
+    procedure LoadFromFile(const F: TFileStream);
+    procedure SaveToFile(const F: TFileStream);
+    procedure AppendToFile(const F: TFileStream; const OldState: TCmdListState);
     procedure Cut;
     function Progress: integer;
+    function Progress: Integer;
   private
     LogAlloc: integer; { allocated size of LogData in bytes }
+    LogAlloc: Integer; { allocated size of LogData in bytes }
     LogData: ^TLogData;
     FState: TCmdListState;
     procedure PutData(Data: pointer; Length: integer);
+    procedure PutData(Data: Pointer; Length: Integer);
     procedure CompleteMoveCode;
   public
 …
   end;
+  function CommandWithData(Command: Integer; DataSize: Byte): Integer;
+resourcestring
+  SCommandDataSizeError = 'Command data size %d out of range (0-%d).';
 implementation
 …
 type
   TData = array [0 .. MaxDataSize - 1] of Cardinal;
+  TData = array [0..MaxDataSize - 1] of Cardinal;
   PData = ^TData;
+function CommandWithData(Command: Integer; DataSize: Byte): Integer;
+var
+  DataElementCount: Byte;
+begin
+  if DataSize > CommandDataMaxSize then
+    raise Exception.Create(Format(SCommandDataSizeError, [DataSize, CommandDataMaxSize]));
+  DataElementCount := Ceil(DataSize / CommandDataElementSize);
+  Result := Command or (DataElementCount and CommandDataElementCountMask);
+end;
 constructor TCmdList.Create;
 …
 end;
 procedure TCmdList.Get(var Command, Player, Subject: integer; var Data: pointer);
+procedure TCmdList.Get(var Command, Player, Subject: Integer; var Data: Pointer);
 var
   DirCode: Cardinal;
 …
   else
   begin
     code := Cardinal((@LogData[FState.LoadPos])^);
     if code and 3 = 0 then
+    Code := Cardinal((@LogData[FState.LoadPos])^);
+    if Code and 3 = 0 then
     begin // non-clientex command
       Command := code shr 2 and $3FFF + sExecute;
       Player := code shr 16 and $F;
       Subject := code shr 20 and $FFF;
       inc(FState.LoadPos, 4);
     end
     else if code and 7 = 2 then
+      Command := Code shr 2 and $3FFF + sExecute;
+      Player := Code shr 16 and $F;
+      Subject := Code shr 20 and $FFF;
+      Inc(FState.LoadPos, 4);
+    end
+    else if Code and 7 = 2 then
     begin // clientex command
       Command := code shr 3 and $FFFF;
       Player := code shr 19 and $F;
+      Command := Code shr 3 and $FFFF;
+      Player := Code shr 19 and $F;
       Subject := 0;
       inc(FState.LoadPos, 3);
+      Inc(FState.LoadPos, 3);
     end
     else
     begin // move command shortcut
       if (code and 1 = 1) and (code and (7 shl 4) <> 6 shl 4) then
+      if (Code and 1 = 1) and (Code and (7 shl 4) <> 6 shl 4) then
       begin
         FState.LoadMoveCode := code and $FF;
         inc(FState.LoadPos);
+        FState.LoadMoveCode := Code and $FF;
+        Inc(FState.LoadPos);
       end
       else
       begin
         FState.LoadMoveCode := code and $FFFFFF;
         inc(FState.LoadPos, 3);
+        FState.LoadMoveCode := Code and $FFFFFF;
+        Inc(FState.LoadPos, 3);
       end;
       Get(Command, Player, Subject, Data);
 …
     end;
     if Command and $F = 0 then
+    if Command and CommandDataElementCountMask = 0 then
       Data := nil
     else
     begin
       Data := @LogData[FState.LoadPos];
       inc(FState.LoadPos, Command and $F * 4);
     end;
   end;
 end;
 procedure TCmdList.GetDataChanges(Data: pointer; DataSize: integer);
+      Inc(FState.LoadPos, Command and CommandDataElementCountMask * CommandDataElementSize);
+    end;
+  end;
+end;
+procedure TCmdList.GetDataChanges(Data: Pointer; DataSize: Integer);
 var
   b0, b1: integer;
+  b0, b1: Integer;
   Map0, Map1: Cardinal;
 begin
   Map0 := Cardinal((@LogData[FState.LoadPos])^);
   inc(FState.LoadPos, 4);
+  Inc(FState.LoadPos, 4);
   b0 := 0;
   while Map0 > 0 do begin
     if Map0 and 1 <> 0 then begin
       Map1 := Cardinal((@LogData[FState.LoadPos])^);
       inc(FState.LoadPos, 4);
+      Inc(FState.LoadPos, 4);
       for b1 := 0 to 31 do
         if 1 shl b1 and Map1 <> 0 then begin
           if b0 * 32 + b1 < DataSize then
             PData(Data)[b0 * 32 + b1] := Cardinal((@LogData[FState.LoadPos])^);
           inc(FState.LoadPos, 4);
+          Inc(FState.LoadPos, 4);
         end;
     end;
     inc(b0);
+    Inc(b0);
     Map0 := Map0 shr 1;
   end;
 end;
 procedure TCmdList.Put(Command, Player, Subject: integer; Data: pointer);
+procedure TCmdList.Put(Command, Player, Subject: Integer; Data: Pointer);
 var
   DirCode, code: Cardinal;
+  DirCode, Code: Cardinal;
 begin
   if Command and $FC00 = sMoveUnit then
 …
     end;
     if Subject = FState.LastMovingUnit then
       code := 1 + DirCode shl 1
     else
       code := 6 + DirCode shl 3 + Cardinal(Subject) shl 6;
+      Code := 1 + DirCode shl 1
+    else
+      Code := 6 + DirCode shl 3 + Cardinal(Subject) shl 6;
     if FState.MoveCode = 0 then
       FState.MoveCode := code
+      FState.MoveCode := Code
     else if FState.MoveCode and 1 = 1 then
     begin // FM + this
       FState.MoveCode := FState.MoveCode + code shl 4;
       if code and 1 = 1 then
+      FState.MoveCode := FState.MoveCode + Code shl 4;
+      if Code and 1 = 1 then
         PutData(@FState.MoveCode, 1) // FM + FM
       else
 …
       FState.MoveCode := 0;
     end
     else if code and 1 = 1 then
+    else if Code and 1 = 1 then
     begin // M + FM
       FState.MoveCode := FState.MoveCode + code shl 18;
+      FState.MoveCode := FState.MoveCode + Code shl 18;
       PutData(@FState.MoveCode, 3);
       FState.MoveCode := 0;
 …
     begin
       PutData(@FState.MoveCode, 3);
       FState.MoveCode := code;
+      FState.MoveCode := Code;
     end;
     FState.LastMovingUnit := Subject;
 …
     if Command >= cClientEx then
     begin
       code := 2 + Command shl 3 + Player shl 19;
       PutData(@code, 3);
     end
     else
     begin
       code := Cardinal(Command - sExecute) shl 2 + Cardinal(Player) shl 16 +
+      Code := 2 + Command shl 3 + Player shl 19;
+      PutData(@Code, 3);
+    end
+    else
+    begin
+      Code := Cardinal(Command - sExecute) shl 2 + Cardinal(Player) shl 16 +
         Cardinal(Subject) shl 20;
       PutData(@code, 4);
     end;
   end;
   if Command and $F <> 0 then
     PutData(Data, Command and $F * 4);
 end;
 procedure TCmdList.PutDataChanges(Command, Player: integer;
   OldData, NewData: pointer; DataSize: integer);
+      PutData(@Code, 4);
+    end;
+  end;
+  if Command and CommandDataElementCountMask <> 0 then
+    PutData(Data, Command and CommandDataElementCountMask * CommandDataElementSize);
+end;
+procedure TCmdList.PutDataChanges(Command, Player: Integer;
+  OldData, NewData: Pointer; DataSize: Integer);
 var
   MapPos, LogPos, b0, b1, RowEnd: integer;
   Map0, Map1, code: Cardinal;
+  MapPos, LogPos, b0, b1, RowEnd: Integer;
+  Map0, Map1, Code: Cardinal;
 begin
   if DataSize <= 0 then
     exit;
+    Exit;
   if DataSize > MaxDataSize then
     DataSize := MaxDataSize;
 …
     if LogPos + 4 * 32 > LogAlloc then
     begin
       inc(LogAlloc, LogGrow);
+      Inc(LogAlloc, LogGrow);
       ReallocMem(LogData, LogAlloc);
     end;
 …
       begin
         Cardinal((@LogData[LogPos])^) := PData(NewData)[b1];
         inc(LogPos, 4);
         inc(Map1, $80000000);
+        Inc(LogPos, 4);
+        Inc(Map1, $80000000);
       end;
     end;
 …
       Cardinal((@LogData[MapPos])^) := Map1;
       MapPos := LogPos;
       inc(LogPos, 4);
       inc(Map0, $80000000);
+      Inc(LogPos, 4);
+      Inc(Map0, $80000000);
     end;
   end;
   if Map0 = 0 then
     exit; // no changes
+    Exit; // no changes
   Map0 := Map0 shr (31 - (DataSize - 1) div 32);
   Cardinal((@LogData[FState.nLog + 4])^) := Map0;
   code := Cardinal(Command - sExecute) shl 2 + Cardinal(Player) shl 16;
   Cardinal((@LogData[FState.nLog])^) := code;
+  Code := Cardinal(Command - sExecute) shl 2 + Cardinal(Player) shl 16;
+  Cardinal((@LogData[FState.nLog])^) := Code;
   FState.nLog := MapPos;
 end;
 procedure TCmdList.PutData(Data: pointer; Length: integer);
+procedure TCmdList.PutData(Data: Pointer; Length: Integer);
 begin
   if FState.nLog + Length > LogAlloc then
   begin
     inc(LogAlloc, LogGrow);
+    Inc(LogAlloc, LogGrow);
     ReallocMem(LogData, LogAlloc);
   end;
   move(Data^, LogData[FState.nLog], Length);
   inc(FState.nLog, Length);
+  Move(Data^, LogData[FState.nLog], Length);
+  Inc(FState.nLog, Length);
 end;
 …
 end;
 procedure TCmdList.LoadFromFile(const f: TFileStream);
 begin
   f.read(FState.nLog, 4);
+procedure TCmdList.LoadFromFile(const F: TFileStream);
+begin
+  F.Read(FState.nLog, 4);
   LogData := nil;
   LogAlloc := ((FState.nLog + 2) div LogGrow + 1) * LogGrow;
   ReallocMem(LogData, LogAlloc);
   f.read(LogData^, FState.nLog);
+  F.Read(LogData^, FState.nLog);
   FState.LoadPos := 0;
 end;
 procedure TCmdList.SaveToFile(const f: TFileStream);
+procedure TCmdList.SaveToFile(const F: TFileStream);
 begin
   CompleteMoveCode;
   f.write(FState.nLog, 4);
   f.write(LogData^, FState.nLog);
 end;
 procedure TCmdList.AppendToFile(const f: TFileStream;
+  F.Write(FState.nLog, 4);
+  F.Write(LogData^, FState.nLog);
+end;
+procedure TCmdList.AppendToFile(const F: TFileStream;
   const OldState: TCmdListState);
 begin
   CompleteMoveCode;
   f.write(FState.nLog, 4);
   f.Position := f.Position + OldState.nLog;
   f.write(LogData[OldState.nLog], FState.nLog - OldState.nLog);
+  F.Write(FState.nLog, 4);
+  F.Position := F.Position + OldState.nLog;
+  F.Write(LogData[OldState.nLog], FState.nLog - OldState.nLog);
 end;
 …
 end;
 function TCmdList.Progress: integer;
+function TCmdList.Progress: Integer;
 begin
   if (FState.LoadPos = FState.nLog) and (FState.LoadMoveCode = 0) then
     result := 1000 // loading complete
+    Result := 1000 // loading complete
   else if FState.nLog > 1 shl 20 then
     result := (FState.LoadPos shr 8) * 999 div (FState.nLog shr 8)
+    Result := (FState.LoadPos shr 8) * 999 div (FState.nLog shr 8)
   else
     result := FState.LoadPos * 999 div FState.nLog;
+    Result := FState.LoadPos * 999 div FState.nLog;
 end;
 …
   Byte3    Byte2    Byte1    Byte0
   ssssssss sssspppp cccccccc cccccc00
   (c = Command-sExecute, p = Player, s = Subject)
+  (C = Command-sExecute, P = Player, S = Subject)
   ClientEx-Command:
   Byte2    Byte1    Byte0
 ppppccc cccccccc ccccc010
   (c = Command, p = Player)
+  (C = Command, P = Player)
   Single Move:
   Byte2    Byte1    Byte0
 ss ssssssss ssaaa110
   (a = Direction, s = Subject)
+  (A = Direction, S = Subject)
   Move + Follow Move:
   Byte2    Byte1    Byte0
 bbb1ss ssssssss ssaaa110
   (a = Direction 1, s = Subject 1, b = Direction 2)
+  (A = Direction 1, S = Subject 1, B = Direction 2)
   Follow Move + Move:
   Byte2    Byte1    Byte0
 ssssss ssssssbb b110aaa1
   (a = Direction 1, b = Direction 2, s = Subject 2)
+  (A = Direction 1, B = Direction 2, S = Subject 2)
   Single Follow Move:
   Byte0
 aaa1
   (a = Direction)
+  (A = Direction)
   Double Follow Move:
   Byte0
   bbb1aaa1
   (a = Direction 1, b = Direction 2)
+  (A = Direction 1, B = Direction 2)
+}

branches/highdpi/Database.pas

-              r349
+              r465
   nStartUn = 1;
   StartUn: array [0 .. nStartUn - 1] of integer = (0); // mix of start units
+  StartUn: array [0 .. nStartUn - 1] of Integer = (0); // mix of start units
   CityOwnTile = 13;
 …
   Mode: TGameMode;
   GWonder: array [0 .. nWonder - 1] of TWonderInfo;
   ServerVersion: array [0 .. nPl - 1] of integer;
   ProcessClientData: array [0 .. nPl - 1] of boolean;
+  ServerVersion: array [0 .. nPl - 1] of Integer;
+  ProcessClientData: array [0 .. nPl - 1] of Boolean;
   CL: TCmdList;
 {$IFDEF TEXTLOG}CmdInfo: string;
 …
   // map data
   RealMap: array [0 .. lxmax * lymax - 1] of Cardinal;
   Continent: array [0 .. lxmax * lymax - 1] of integer;
+  Continent: array [0 .. lxmax * lymax - 1] of Integer;
   { continent id for each tile }
   Occupant: array [0 .. lxmax * lymax - 1] of ShortInt;
 …
   ObserveLevel: array [0 .. lxmax * lymax - 1] of Cardinal;
   { Observe Level of player p in bits 2*p and 2*p+1 }
   UsedByCity: array [0 .. lxmax * lymax - 1] of integer;
+  UsedByCity: array [0 .. lxmax * lymax - 1] of Integer;
   { location of exploiting city for
     each tile, =-1 if not exploited }
 …
   // player data
   RW: array [0 .. nPl - 1] of TPlayerContext; { player data }
   Difficulty: array [0 .. nPl - 1] of integer;
+  Difficulty: array [0 .. nPl - 1] of Integer;
   GShip: array [0 .. nPl - 1] of TShipInfo;
   ResourceMask: array [0 .. nPl - 1] of Cardinal;
   Founded: array [0 .. nPl - 1] of integer; { number of cities founded }
   TerritoryCount: array [0 .. nPl] of integer;
+  Founded: array [0 .. nPl - 1] of Integer; { number of cities founded }
+  TerritoryCount: array [0 .. nPl] of Integer;
   LastValidStat, Researched, Discovered, // number of tiles discovered
   GrWallContinent: array [0 .. nPl - 1] of integer;
+  GrWallContinent: array [0 .. nPl - 1] of Integer;
   RWemix: array [0 .. nPl - 1, 0 .. nPl - 1, 0 .. nmmax - 1] of SmallInt;
   // [p1,p2,mix] -> index of p2's model mix in p1's enemy model list
   Destroyed: array [0 .. nPl - 1, 0 .. nPl - 1, 0 .. nmmax - 1] of SmallInt;
   // [p1,p2,mix] -> number of p2's units with model mix that p1 has destroyed
   nTech: array [0 .. nPl - 1] of integer; { number of known techs }
+  nTech: array [0 .. nPl - 1] of Integer; { number of known techs }
   // NewContact: array[0..nPl-1,0..nPl-1] of boolean;
 type
   TVicinity8Loc = array [0 .. 7] of integer;
   TVicinity21Loc = array [0 .. 27] of integer;
 procedure MaskD(var x: array of Cardinal; Count, Mask: Cardinal);
 procedure IntServer(Command, Player, Subject: integer; var Data);
 procedure CompactLists(p: integer);
 procedure ClearTestFlags(ClearFlags: integer);
 procedure SetTestFlags(p, SetFlags: integer);
+  TVicinity8Loc = array [0 .. 7] of Integer;
+  TVicinity21Loc = array [0 .. 27] of Integer;
+procedure MaskD(var X: array of Cardinal; Count, Mask: Cardinal);
+procedure IntServer(Command, Player, Subject: Integer; var Data);
+procedure CompactLists(P: Integer);
+procedure ClearTestFlags(ClearFlags: Integer);
+procedure SetTestFlags(P, SetFlags: Integer);
 // Tech Related Functions
 function TechBaseCost(nTech, diff: integer): integer;
 function TechCost(p: integer): integer;
 procedure CalculateModel(var m: TModel);
 procedure CheckSpecialModels(p, pre: integer);
 procedure EnableDevModel(p: integer);
 procedure SeeTech(p, ad: integer);
 procedure DiscoverTech(p, ad: integer);
 procedure CheckExpiration(Wonder: integer);
+function TechBaseCost(nTech, diff: Integer): Integer;
+function TechCost(P: Integer): Integer;
+procedure CalculateModel(var M: TModel);
+procedure CheckSpecialModels(P, pre: Integer);
+procedure EnableDevModel(P: Integer);
+procedure SeeTech(P, ad: Integer);
+procedure DiscoverTech(P, ad: Integer);
+procedure CheckExpiration(Wonder: Integer);
 // Location Navigation
 function dLoc(Loc, dx, dy: integer): integer;
 procedure dxdy(Loc0, Loc1: integer; var dx, dy: integer);
 function Distance(Loc0, Loc1: integer): integer;
 procedure V8_to_Loc(Loc0: integer; var VicinityLoc: TVicinity8Loc);
 procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
+function dLoc(Loc, dx, dy: Integer): Integer;
+procedure dxdy(Loc0, Loc1: Integer; var dx, dy: Integer);
+function Distance(Loc0, Loc1: Integer): Integer;
+procedure V8_to_Loc(Loc0: Integer; var VicinityLoc: TVicinity8Loc);
+procedure V21_to_Loc(Loc0: Integer; var VicinityLoc: TVicinity21Loc);
 // Game Initialization
 procedure InitRandomGame;
 procedure InitMapGame(Human: integer);
+procedure InitMapGame(Human: Integer);
 procedure ReleaseGame;
 // Map Editor
 function MapGeneratorAvailable: boolean;
+function MapGeneratorAvailable: Boolean;
 procedure CreateElevation;
 procedure CreateMap(preview: boolean);
+procedure CreateMap(preview: Boolean);
 procedure InitMapEditor;
 procedure ReleaseMapEditor;
 procedure EditTile(Loc, NewTile: integer);
+procedure EditTile(Loc, NewTile: Integer);
 // Map Revealing
 function GetTileInfo(p, cix, Loc: integer; var Info: TTileInfo): integer;
 procedure Strongest(Loc: integer; var uix, Strength, Bonus, Cnt: integer);
 function UnitSpeed(p, mix, Health: integer): integer;
 procedure GetUnitReport(p, uix: integer; var UnitReport: TUnitReport);
 procedure SearchCity(Loc: integer; var p, cix: integer);
 procedure TellAboutModel(p, taOwner, tamix: integer);
 function emixSafe(p, taOwner, tamix: integer): integer;
 function Discover9(Loc, p, Level: integer;
   TellAllied, EnableContact: boolean): boolean;
 function Discover21(Loc, p, AdjacentLevel: integer;
   TellAllied, EnableContact: boolean): boolean;
 procedure DiscoverAll(p, Level: integer);
 procedure DiscoverViewAreas(p: integer);
 function GetUnitStack(p, Loc: integer): integer;
 procedure UpdateUnitMap(Loc: integer; CityChange: boolean = false);
 procedure RecalcV8ZoC(p, Loc: integer);
 procedure RecalcMapZoC(p: integer);
 procedure RecalcPeaceMap(p: integer);
+function GetTileInfo(P, cix, Loc: Integer; var Info: TTileInfo): Integer;
+procedure Strongest(Loc: Integer; var uix, Strength, Bonus, Cnt: Integer);
+function UnitSpeed(P, mix, Health: Integer): Integer;
+procedure GetUnitReport(P, uix: Integer; var UnitReport: TUnitReport);
+procedure SearchCity(Loc: Integer; var P, cix: Integer);
+procedure TellAboutModel(P, taOwner, tamix: Integer);
+function emixSafe(P, taOwner, tamix: Integer): Integer;
+function Discover9(Loc, P, Level: Integer;
+  TellAllied, EnableContact: Boolean): Boolean;
+function Discover21(Loc, P, AdjacentLevel: Integer;
+  TellAllied, EnableContact: Boolean): Boolean;
+procedure DiscoverAll(P, Level: Integer);
+procedure DiscoverViewAreas(P: Integer);
+function GetUnitStack(P, Loc: Integer): Integer;
+procedure UpdateUnitMap(Loc: Integer; CityChange: Boolean = False);
+procedure RecalcV8ZoC(P, Loc: Integer);
+procedure RecalcMapZoC(P: Integer);
+procedure RecalcPeaceMap(P: Integer);
 // Territory Calculation
 procedure CheckBorders(OriginLoc: integer; PlayerLosingCity: integer = -1);
 procedure LogCheckBorders(p, cix: integer; PlayerLosingCity: integer = -1);
+procedure CheckBorders(OriginLoc: Integer; PlayerLosingCity: Integer = -1);
+procedure LogCheckBorders(P, cix: Integer; PlayerLosingCity: Integer = -1);
 // Map Processing
 procedure CreateUnit(p, mix: integer);
 procedure FreeUnit(p, uix: integer);
 procedure PlaceUnit(p, uix: integer);
 procedure RemoveUnit(p, uix: integer; Enemy: integer = -1);
 procedure RemoveUnit_UpdateMap(p, uix: integer);
 procedure RemoveAllUnits(p, Loc: integer; Enemy: integer = -1);
 procedure RemoveDomainUnits(d, p, Loc: integer);
 procedure FoundCity(p, FoundLoc: integer);
 procedure DestroyCity(p, cix: integer; SaveUnits: boolean);
 procedure ChangeCityOwner(pOld, cixOld, pNew: integer);
 procedure CompleteJob(p, Loc, Job: integer);
+procedure CreateUnit(P, mix: Integer);
+procedure FreeUnit(P, uix: Integer);
+procedure PlaceUnit(P, uix: Integer);
+procedure RemoveUnit(P, uix: Integer; Enemy: Integer = -1);
+procedure RemoveUnit_UpdateMap(P, uix: Integer);
+procedure RemoveAllUnits(P, Loc: Integer; Enemy: Integer = -1);
+procedure RemoveDomainUnits(D, P, Loc: Integer);
+procedure FoundCity(P, FoundLoc: Integer);
+procedure DestroyCity(P, cix: Integer; SaveUnits: Boolean);
+procedure ChangeCityOwner(pOld, cixOld, pNew: Integer);
+procedure CompleteJob(P, Loc, Job: Integer);
 // Diplomacy
+procedure IntroduceEnemy(p1, p2: integer);
+procedure GiveCivilReport(p, pAbout: integer);
+procedure GiveMilReport(p, pAbout: integer);
+procedure ShowPrice(pSender, pTarget, Price: integer);
+function PayPrice(pSender, pTarget, Price: integer; execute: boolean): boolean;
+procedure CancelTreaty(p, pWith: integer; DecreaseCredibility: boolean = true);
+function DoSpyMission(p, pCity, cix, Mission: integer): Cardinal;
+procedure IntroduceEnemy(p1, p2: Integer);
+procedure GiveCivilReport(P, pAbout: Integer);
+procedure GiveMilReport(P, pAbout: Integer);
+procedure ShowPrice(pSender, pTarget, Price: Integer);
+function PayPrice(pSender, pTarget, Price: Integer; execute: Boolean): Boolean;
+procedure CancelTreaty(P, pWith: Integer; DecreaseCredibility: Boolean = True);
+function DoSpyMission(P, pCity, cix, Mission: Integer): Cardinal;
 implementation
 …
 var
   UnBuilt: array [0 .. nPl - 1] of integer; { number of units built }
 procedure MaskD(var x: array of Cardinal; Count, Mask: Cardinal);
+  UnBuilt: array [0 .. nPl - 1] of Integer; { number of units built }
+procedure MaskD(var X: array of Cardinal; Count, Mask: Cardinal);
 var
   I: Integer;
 begin
   for I := 0 to Count - 1 do
     x[I] := x[I] and Mask;
 end;
 procedure CompactLists(p: integer);
 var
   uix, uix1, cix: integer;
 {$IFOPT O-}V21: integer;
+    X[I] := X[I] and Mask;
+end;
+procedure CompactLists(P: Integer);
+var
+  uix, uix1, cix: Integer;
+{$IFOPT O-}V21: Integer;
   Radius: TVicinity21Loc; {$ENDIF}
 begin
   with RW[p] do
+  with RW[P] do
   begin
     // compact unit list
 …
       if Un[uix].Loc < 0 then
       begin
         dec(nUn);
+        Dec(nUn);
         Un[uix] := Un[nUn]; { replace removed unit by last }
         if (Un[uix].TroopLoad > 0) or (Un[uix].AirLoad > 0) then
 …
       end
       else
         inc(uix);
+        Inc(uix);
     // compact city list
 …
       if City[cix].Loc < 0 then
       begin
         dec(nCity);
+        Dec(nCity);
         City[cix] := City[nCity]; { replace city by last }
         for uix1 := 0 to nUn - 1 do
 …
       end
       else
         inc(cix);
+        Inc(cix);
     // compact enemy city list
 …
       if EnemyCity[cix].Loc < 0 then
       begin
         dec(nEnemyCity);
+        Dec(nEnemyCity);
         EnemyCity[cix] := EnemyCity[nEnemyCity]; { replace city by last }
       end
       else
         inc(cix);
+        Inc(cix);
 {$IFOPT O-}
 …
         for V21 := 1 to 26 do
           if Tiles and (1 shl V21) <> 0 then
             assert(UsedByCity[Radius[V21]] = Loc);
       end
+            Assert(UsedByCity[Radius[V21]] = Loc);
+      end;
 {$ENDIF}
   end;
 end; // CompactLists
+end;
+{
 …
   ____________________________________________________________________
+}
 function TechBaseCost(nTech, diff: integer): integer;
 var
   c0: single;
+function TechBaseCost(nTech, diff: Integer): Integer;
+var
+  c0: Single;
 begin
   c0 := TechFormula_M[diff] * (nTech + 4) *
     exp((nTech + 4) / TechFormula_D[diff]);
   if c0 >= $10000000 then
     result := $10000000
+    Result := $10000000
   else
     result := trunc(c0)
 end;
 function TechCost(p: integer): integer;
 begin
   with RW[p] do
   begin
     result := TechBaseCost(nTech[p], Difficulty[p]);
+    Result := trunc(c0);
+end;
+function TechCost(P: Integer): Integer;
+begin
+  with RW[P] do
+  begin
+    Result := TechBaseCost(nTech[P], Difficulty[P]);
     if ResearchTech >= 0 then
       if (ResearchTech = adMilitary) or (Tech[ResearchTech] = tsSeen) then
         result := result shr 1
+        Result := Result shr 1
       else if ResearchTech in FutureTech then
         if Government = gFuture then
           result := result * 2
+          Result := Result * 2
         else
           result := result * 4;
   end
 end;
 procedure SetModelFlags(var m: TModel);
 begin
   m.Flags := 0;
   if (m.Domain = dGround) and (m.Kind <> mkDiplomat) then
     m.Flags := m.Flags or mdZOC;
   if (m.Kind = mkDiplomat) or (m.Attack + m.Cap[mcBombs] = 0) then
     m.Flags := m.Flags or mdCivil;
   if (m.Cap[mcOver] > 0) or (m.Domain = dSea) and (m.Weight >= 6) then
     m.Flags := m.Flags or mdDoubleSupport;
 end;
 procedure CalculateModel(var m: TModel);
+          Result := Result * 4;
+  end;
+end;
+procedure SetModelFlags(var M: TModel);
+begin
+  M.Flags := 0;
+  if (M.Domain = dGround) and (M.Kind <> mkDiplomat) then
+    M.Flags := M.Flags or mdZOC;
+  if (M.Kind = mkDiplomat) or (M.Attack + M.Cap[mcBombs] = 0) then
+    M.Flags := M.Flags or mdCivil;
+  if (M.Cap[mcOver] > 0) or (M.Domain = dSea) and (M.Weight >= 6) then
+    M.Flags := M.Flags or mdDoubleSupport;
+end;
+procedure CalculateModel(var M: TModel);
 { calculate attack, defense, cost... of a model by features }
 var
   i: integer;
 begin
   with m do
+  I: Integer;
+begin
+  with M do
   begin
     Attack := (Cap[mcOffense] + Cap[mcOver]) * MStrength;
 …
           Speed := 350 + 200 * Cap[mcNP] + 200 * Cap[mcTurbines];
           if Cap[mcNP] = 0 then
             inc(Speed, 100 * Cap[mcSE]);
+            Inc(Speed, 100 * Cap[mcSE]);
         end;
       dAir:
 …
     end;
     Cost := 0;
     for i := 0 to nFeature - 1 do
       if 1 shl Domain and Feature[i].Domains <> 0 then
         inc(Cost, Cap[i] * Feature[i].Cost);
+    for I := 0 to nFeature - 1 do
+      if 1 shl Domain and Feature[I].Domains <> 0 then
+        Inc(Cost, Cap[I] * Feature[I].Cost);
     Cost := Cost * MCost;
     Weight := 0;
     for i := 0 to nFeature - 1 do
       if 1 shl Domain and Feature[i].Domains <> 0 then
         if (Domain = dGround) and (i = mcDefense) then
           inc(Weight, Cap[i] * 2)
+    for I := 0 to nFeature - 1 do
+      if 1 shl Domain and Feature[I].Domains <> 0 then
+        if (Domain = dGround) and (I = mcDefense) then
+          Inc(Weight, Cap[I] * 2)
         else
           inc(Weight, Cap[i] * Feature[i].Weight);
   end;
   SetModelFlags(m);
 end;
 procedure CheckSpecialModels(p, pre: integer);
 var
   i, mix1: integer;
   HasAlready: boolean;
 begin
   for i := 0 to nSpecialModel -
+          Inc(Weight, Cap[I] * Feature[I].Weight);
+  end;
+  SetModelFlags(M);
+end;
+procedure CheckSpecialModels(P, pre: Integer);
+var
+  I, mix1: Integer;
+  HasAlready: Boolean;
+begin
+  for I := 0 to nSpecialModel -
 do { check whether new special model available }
     if (SpecialModelPreq[i] = pre) and (RW[p].nModel < nmmax) then
     begin
       HasAlready := false;
       for mix1 := 0 to RW[p].nModel - 1 do
         if (RW[p].Model[mix1].Kind = SpecialModel[i].Kind) and
           (RW[p].Model[mix1].Attack = SpecialModel[i].Attack) and
           (RW[p].Model[mix1].Speed = SpecialModel[i].Speed) then
           HasAlready := true;
+    if (SpecialModelPreq[I] = pre) and (RW[P].nModel < nmmax) then
+    begin
+      HasAlready := False;
+      for mix1 := 0 to RW[P].nModel - 1 do
+        if (RW[P].Model[mix1].Kind = SpecialModel[I].Kind) and
+          (RW[P].Model[mix1].Attack = SpecialModel[I].Attack) and
+          (RW[P].Model[mix1].Speed = SpecialModel[I].Speed) then
+          HasAlready := True;
       if not HasAlready then
       begin
         RW[p].Model[RW[p].nModel] := SpecialModel[i];
         SetModelFlags(RW[p].Model[RW[p].nModel]);
         with RW[p].Model[RW[p].nModel] do
+        RW[P].Model[RW[P].nModel] := SpecialModel[I];
+        SetModelFlags(RW[P].Model[RW[P].nModel]);
+        with RW[P].Model[RW[P].nModel] do
         begin
           Status := 0;
 …
           Built := 0;
           Lost := 0;
           ID := p shl 12 + RW[p].nModel;
           if (Kind = mkSpecial_Boat) and (ServerVersion[p] < $000EF0) then
+          ID := P shl 12 + RW[P].nModel;
+          if (Kind = mkSpecial_Boat) and (ServerVersion[P] < $000EF0) then
             Speed := 350; // old longboat
         end;
         inc(RW[p].nModel);
       end
     end;
 end;
 procedure EnableDevModel(p: integer);
 begin
   with RW[p] do
+        Inc(RW[P].nModel);
+      end;
+    end;
+end;
+procedure EnableDevModel(P: Integer);
+begin
+  with RW[P] do
     if nModel < nmmax then
     begin
 …
         Built := 0;
         Lost := 0;
         ID := p shl 12 + nModel
       end;
       inc(nModel);
       inc(Researched[p])
     end
 end;
 procedure SeeTech(p, ad: integer);
 begin
 {$IFDEF TEXTLOG}CmdInfo := CmdInfo + Format(' P%d:A%d', [p, ad]); {$ENDIF}
   RW[p].Tech[ad] := tsSeen;
+        ID := P shl 12 + nModel;
+      end;
+      Inc(nModel);
+      Inc(Researched[P]);
+    end;
+end;
+procedure SeeTech(P, ad: Integer);
+begin
+{$IFDEF TEXTLOG}CmdInfo := CmdInfo + Format(' P%d:A%d', [P, ad]); {$ENDIF}
+  RW[P].Tech[ad] := tsSeen;
   // inc(nTech[p]);
   inc(Researched[p])
+  Inc(Researched[P]);
 end;
 procedure FreeSlaves;
 var
   p1, uix: integer;
+  p1, uix: Integer;
 begin
   for p1 := 0 to nPl - 1 do
 …
       for uix := 0 to RW[p1].nUn - 1 do
         if RW[p1].Model[RW[p1].Un[uix].mix].Kind = mkSlaves then
           RW[p1].Un[uix].Job := jNone
 end;
 procedure DiscoverTech(p, ad: integer);
   procedure TellAboutKeyTech(p, Source: integer);
+          RW[p1].Un[uix].Job := jNone;
+end;
+procedure DiscoverTech(P, ad: Integer);
+  procedure TellAboutKeyTech(P, Source: Integer);
   var
     i, p1: integer;
   begin
     for i := 1 to 3 do
       if ad = AgePreq[i] then
+    I, p1: Integer;
+  begin
+    for I := 1 to 3 do
+      if ad = AgePreq[I] then
         for p1 := 0 to nPl - 1 do
           if (p1 <> p) and ((GAlive or GWatching) and (1 shl p1) <> 0) then
             RW[p1].EnemyReport[p].Tech[ad] := Source;
   end;
 var
   i: integer;
+          if (p1 <> P) and ((GAlive or GWatching) and (1 shl p1) <> 0) then
+            RW[p1].EnemyReport[P].Tech[ad] := Source;
+  end;
+var
+  I: Integer;
 begin
   if ad in FutureTech then
   begin
     if RW[p].Tech[ad] < tsApplicable then
       RW[p].Tech[ad] := 1
+    if RW[P].Tech[ad] < tsApplicable then
+      RW[P].Tech[ad] := 1
     else
       inc(RW[p].Tech[ad]);
+      Inc(RW[P].Tech[ad]);
     if ad <> futResearchTechnology then
       inc(nTech[p], 2);
     inc(Researched[p], 8);
     exit;
   end;
   if RW[p].Tech[ad] = tsSeen then
   begin
     inc(nTech[p]);
     inc(Researched[p]);
+      Inc(nTech[P], 2);
+    Inc(Researched[P], 8);
+    Exit;
+  end;
+  if RW[P].Tech[ad] = tsSeen then
+  begin
+    Inc(nTech[P]);
+    Inc(Researched[P]);
   end
   else
   begin
     inc(nTech[p], 2);
     inc(Researched[p], 2);
   end;
   RW[p].Tech[ad] := tsResearched;
   TellAboutKeyTech(p, tsResearched);
   CheckSpecialModels(p, ad);
+    Inc(nTech[P], 2);
+    Inc(Researched[P], 2);
+  end;
+  RW[P].Tech[ad] := tsResearched;
+  TellAboutKeyTech(P, tsResearched);
+  CheckSpecialModels(P, ad);
   if ad = adScience then
     ResourceMask[p] := ResourceMask[p] or fSpecial2;
+    ResourceMask[P] := ResourceMask[P] or fSpecial2;
   if ad = adMassProduction then
     ResourceMask[p] := ResourceMask[p] or fModern;
   for i := 0 to nWonder - 1 do { check whether wonders expired }
     if (GWonder[i].EffectiveOwner <> GWonder[woEiffel].EffectiveOwner) and
       (Imp[i].Expiration = ad) then
     begin
       GWonder[i].EffectiveOwner := -1;
       if i = woPyramids then
+    ResourceMask[P] := ResourceMask[P] or fModern;
+  for I := 0 to nWonder - 1 do { check whether wonders expired }
+    if (GWonder[I].EffectiveOwner <> GWonder[woEiffel].EffectiveOwner) and
+      (Imp[I].Expiration = ad) then
+    begin
+      GWonder[I].EffectiveOwner := -1;
+      if I = woPyramids then
         FreeSlaves;
     end;
 end;
 procedure CheckExpiration(Wonder: integer);
+procedure CheckExpiration(Wonder: Integer);
 // GWonder[Wonder].EffectiveOwner must be set before!
 var
   p: integer;
+  P: Integer;
 begin
   if (Imp[Wonder].Expiration >= 0) and
     (GWonder[woEiffel].EffectiveOwner <> GWonder[Wonder].EffectiveOwner) then
     for p := 0 to nPl - 1 do // check if already expired
       if (1 shl p and GAlive <> 0) and
         (RW[p].Tech[Imp[Wonder].Expiration] >= tsApplicable) then
+    for P := 0 to nPl - 1 do // check if already expired
+      if (1 shl P and GAlive <> 0) and
+        (RW[P].Tech[Imp[Wonder].Expiration] >= tsApplicable) then
       begin
         GWonder[Wonder].EffectiveOwner := -1;
         if Wonder = woPyramids then
           FreeSlaves
       end
+          FreeSlaves;
+      end;
 end;
 …
   ____________________________________________________________________
+}
 function dLoc(Loc, dx, dy: integer): integer;
+function dLoc(Loc, dx, dy: Integer): Integer;
 { relative location, dx in hor and dy in ver direction from Loc }
 var
   y0: integer;
+  y0: Integer;
 begin
   if not (Loc >= 0) and (Loc < MapSize) and (dx + lx >= 0) then
     raise Exception.Create('Relative location error');
   assert((Loc >= 0) and (Loc < MapSize) and (dx + lx >= 0));
+  Assert((Loc >= 0) and (Loc < MapSize) and (dx + lx >= 0));
   y0 := Loc div lx;
   result := (Loc + (dx + y0 and 1 + lx + lx) shr 1) mod lx + lx * (y0 + dy);
   if (result < 0) or (result >= MapSize) then
     result := -1;
 end;
 procedure dxdy(Loc0, Loc1: integer; var dx, dy: integer);
+  Result := (Loc + (dx + y0 and 1 + lx + lx) shr 1) mod lx + lx * (y0 + dy);
+  if (Result < 0) or (Result >= MapSize) then
+    Result := -1;
+end;
+procedure dxdy(Loc0, Loc1: Integer; var dx, dy: Integer);
 begin
   dx := ((Loc1 mod lx * 2 + Loc1 div lx and 1) -
 …
 end;
 function Distance(Loc0, Loc1: integer): integer;
 var
   dx, dy: integer;
+function Distance(Loc0, Loc1: Integer): Integer;
+var
+  dx, dy: Integer;
 begin
   dxdy(Loc0, Loc1, dx, dy);
   dx := abs(dx);
   dy := abs(dy);
   result := dx + dy + abs(dx - dy) shr 1;
 end;
 procedure V8_to_Loc(Loc0: integer; var VicinityLoc: TVicinity8Loc);
 var
   x0, y0, lx0: integer;
+  Result := dx + dy + abs(dx - dy) shr 1;
+end;
+procedure V8_to_Loc(Loc0: Integer; var VicinityLoc: TVicinity8Loc);
+var
+  x0, y0, lx0: Integer;
 begin
   lx0 := lx; // put in register!
 …
   VicinityLoc[5] := Loc0 - lx0 * 2;
   VicinityLoc[7] := Loc0 + 1;
   inc(Loc0, y0);
+  Inc(Loc0, y0);
   VicinityLoc[0] := Loc0 + lx0;
   VicinityLoc[2] := Loc0 + lx0 - 1;
 …
     if x0 = 0 then
     begin
       inc(VicinityLoc[3], lx0);
+      Inc(VicinityLoc[3], lx0);
       if y0 = 0 then
       begin
         inc(VicinityLoc[2], lx0);
         inc(VicinityLoc[4], lx0);
       end
     end
+        Inc(VicinityLoc[2], lx0);
+        Inc(VicinityLoc[4], lx0);
+      end;
+    end;
   end
   else
   begin
     dec(VicinityLoc[7], lx0);
+    Dec(VicinityLoc[7], lx0);
     if y0 = 1 then
     begin
       dec(VicinityLoc[0], lx0);
       dec(VicinityLoc[6], lx0);
     end
   end;
 end;
 procedure V21_to_Loc(Loc0: integer; var VicinityLoc: TVicinity21Loc);
 var
   dx, dy, bit, y0, xComp, yComp, xComp0, xCompSwitch: integer;
   dst: ^integer;
+      Dec(VicinityLoc[0], lx0);
+      Dec(VicinityLoc[6], lx0);
+    end;
+  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 := Loc0 div lx;
 …
   xCompSwitch := xComp0 - 1 + y0 and 1;
   if xComp0 < 0 then
     inc(xComp0, lx);
+    Inc(xComp0, lx);
   if xCompSwitch < 0 then
     inc(xCompSwitch, lx);
+    Inc(xCompSwitch, lx);
   xCompSwitch := xCompSwitch xor xComp0;
   yComp := lx * (y0 - 3);
 …
       else
         dst^ := -1;
       inc(xComp);
+      Inc(xComp);
       if xComp >= lx then
         dec(xComp, lx);
       inc(dst);
+        Dec(xComp, lx);
+      Inc(dst);
       bit := bit shl 1;
     end;
     inc(yComp, lx);
+    Inc(yComp, lx);
   end;
 end;
 …
+}
 var
   primitive: integer;
   StartLoc, StartLoc2: array [0 .. nPl - 1] of integer; { starting coordinates }
+  primitive: Integer;
+  StartLoc, StartLoc2: array [0 .. nPl - 1] of Integer; { starting coordinates }
   Elevation: array [0 .. lxmax * lymax - 1] of Byte; { map elevation }
   ElCount: array [Byte] of integer; { count of elevation occurance }
+  ElCount: array [Byte] of Integer; { count of elevation occurance }
 procedure CalculatePrimitive;
 var
   i, j: integer;
+  I, J: Integer;
 begin
   primitive := 1;
   i := 2;
   while i * i <= MapSize + 1 do // test whether prime
   begin
     if (MapSize + 1) mod i = 0 then
+  I := 2;
+  while I * I <= MapSize + 1 do // test whether prime
+  begin
+    if (MapSize + 1) mod I = 0 then
       primitive := 0;
     inc(i)
+    Inc(I);
   end;
   if primitive > 0 then
     repeat
       inc(primitive);
       i := 1;
       j := 0;
+      Inc(primitive);
+      I := 1;
+      J := 0;
       repeat
         inc(j);
         i := i * primitive mod (MapSize + 1)
       until (i = 1) or (j = MapSize + 1);
     until j = MapSize;
 end;
 function MapGeneratorAvailable: boolean;
 begin
   result := (primitive > 0) and (lx >= 20) and (ly >= 40)
+        Inc(J);
+        I := I * primitive mod (MapSize + 1);
+      until (I = 1) or (J = MapSize + 1);
+    until J = MapSize;
+end;
+function MapGeneratorAvailable: Boolean;
+begin
+  Result := (primitive > 0) and (lx >= 20) and (ly >= 40);
 end;
 procedure CreateElevation;
 const
   d = 64;
+  D = 64;
   Smooth = 0.049; { causes low amplitude of short waves }
   Detail = 0.095; { causes short period of short waves }
 …
 var
   sa, ca, f1, f2: array [1 .. d] of single;
   imerge, x, y: integer;
   v, maxv: single;
   function Value(x, y: integer): single; { elevation formula }
+  sa, ca, f1, f2: array [1 .. D] of Single;
+  imerge, X, Y: Integer;
+  V, maxv: Single;
+  function Value(X, Y: Integer): Single; { elevation formula }
   var
     i: integer;
   begin
     result := 0;
     for i := 1 to d do
       result := result + sin(f1[i] * ((x * 2 + y and 1) * sa[i] + y * 1.5 *
         ca[i])) * f2[i];
+    I: Integer;
+  begin
+    Result := 0;
+    for I := 1 to D do
+      Result := Result + sin(f1[I] * ((X * 2 + Y and 1) * sa[I] + Y * 1.5 *
+        ca[I])) * f2[I];
     { x values effectively multiplied with 2 to get 2 horizantal periods
       of the prime waves }
 …
 begin
   for x := 1 to d do { prepare formula parameters }
   begin
 {$IFNDEF SCR} if x = 1 then
       v := pi / 2 { first wave goes horizontal }
     else {$ENDIF} v := DelphiRandom * 2 * pi;
     sa[x] := sin(v) / lx;
     ca[x] := cos(v) / ly;
     f1[x] := 2 * pi * exp(Detail * (x - 1));
     f2[x] := exp(-x * Smooth)
+  for X := 1 to D do { prepare formula parameters }
+  begin
+{$IFNDEF SCR} if X = 1 then
+      V := pi / 2 { first wave goes horizontal }
+    else {$ENDIF} V := DelphiRandom * 2 * pi;
+    sa[X] := sin(V) / lx;
+    ca[X] := cos(V) / ly;
+    f1[X] := 2 * pi * exp(Detail * (X - 1));
+    f2[X] := exp(-X * Smooth);
   end;
 …
   FillChar(ElCount, SizeOf(ElCount), 0);
   maxv := 0;
   for x := 0 to lx - 1 do
     for y := 0 to ly - 1 do
     begin
       v := Value(x, y);
       if x * 2 < imerge then
         v := (x * 2 * v + (imerge - x * 2) * Value(x + lx, y)) / imerge;
       v := v - sqr(sqr(2 * y / ly - 1)); { soft cut at poles }
       if v > maxv then
         maxv := v;
       if v < -4 then
         Elevation[x + lx * y] := 0
       else if v > 8.75 then
         Elevation[x + lx * y] := 255
+  for X := 0 to lx - 1 do
+    for Y := 0 to ly - 1 do
+    begin
+      V := Value(X, Y);
+      if X * 2 < imerge then
+        V := (X * 2 * V + (imerge - X * 2) * Value(X + lx, Y)) / imerge;
+      V := V - sqr(sqr(2 * Y / ly - 1)); { soft cut at poles }
+      if V > maxv then
+        maxv := V;
+      if V < -4 then
+        Elevation[X + lx * Y] := 0
+      else if V > 8.75 then
+        Elevation[X + lx * Y] := 255
       else
         Elevation[x + lx * y] := Round((v + 4) * 20);
       inc(ElCount[Elevation[x + lx * y]])
+        Elevation[X + lx * Y] := Round((V + 4) * 20);
+      Inc(ElCount[Elevation[X + lx * Y]]);
     end;
 end;
 …
 procedure FindContinents;
   procedure ReplaceCont(a, b, Stop: integer);
+  procedure ReplaceCont(A, B, Stop: Integer);
   { replace continent name a by b }
   // make sure always continent[loc]<=loc
   var
     i: integer;
   begin
     if a < b then
     begin
       i := a;
       a := b;
       b := i
     end;
     if a > b then
       for i := a to Stop do
         if Continent[i] = a then
           Continent[i] := b
   end;
 var
   x, y, Loc, Wrong: integer;
 begin
   for y := 1 to ly - 2 do
     for x := 0 to lx - 1 do
     begin
       Loc := x + lx * y;
+    I: Integer;
+  begin
+    if A < B then
+    begin
+      I := A;
+      A := B;
+      B := I
+    end;
+    if A > B then
+      for I := A to Stop do
+        if Continent[I] = A then
+          Continent[I] := B;
+  end;
+var
+  X, Y, Loc, Wrong: Integer;
+begin
+  for Y := 1 to ly - 2 do
+    for X := 0 to lx - 1 do
+    begin
+      Loc := X + lx * Y;
       Continent[Loc] := -1;
       if RealMap[Loc] and fTerrain >= fGrass then
       begin
         if (y - 2 >= 1) and (RealMap[Loc - 2 * lx] and fTerrain >= fGrass) then
+        if (Y - 2 >= 1) and (RealMap[Loc - 2 * lx] and fTerrain >= fGrass) then
           Continent[Loc] := Continent[Loc - 2 * lx];
         if (x - 1 + y and 1 >= 0) and (y - 1 >= 1) and
           (RealMap[Loc - 1 + y and 1 - lx] and fTerrain >= fGrass) then
           Continent[Loc] := Continent[Loc - 1 + y and 1 - lx];
         if (x + y and 1 < lx) and (y - 1 >= 1) and
           (RealMap[Loc + y and 1 - lx] and fTerrain >= fGrass) then
           Continent[Loc] := Continent[Loc + y and 1 - lx];
         if (x - 1 >= 0) and (RealMap[Loc - 1] and fTerrain >= fGrass) then
+        if (X - 1 + Y and 1 >= 0) and (Y - 1 >= 1) and
+          (RealMap[Loc - 1 + Y and 1 - lx] and fTerrain >= fGrass) then
+          Continent[Loc] := Continent[Loc - 1 + Y and 1 - lx];
+        if (X + Y and 1 < lx) and (Y - 1 >= 1) and
+          (RealMap[Loc + Y and 1 - lx] and fTerrain >= fGrass) then
+          Continent[Loc] := Continent[Loc + Y and 1 - lx];
+        if (X - 1 >= 0) and (RealMap[Loc - 1] and fTerrain >= fGrass) then
           if Continent[Loc] = -1 then
             Continent[Loc] := Continent[Loc - 1]
 …
             ReplaceCont(Continent[Loc - 1], Continent[Loc], Loc);
         if Continent[Loc] = -1 then
           Continent[Loc] := Loc
       end
+          Continent[Loc] := Loc;
+      end;
     end;
   { connect continents due to round earth }
   for y := 1 to ly - 2 do
     if RealMap[lx * y] and fTerrain >= fGrass then
+  for Y := 1 to ly - 2 do
+    if RealMap[lx * Y] and fTerrain >= fGrass then
     begin
       Wrong := -1;
       if RealMap[lx - 1 + lx * y] and fTerrain >= fGrass then
         Wrong := Continent[lx - 1 + lx * y];
       if (y and 1 = 0) and (y - 1 >= 1) and
         (RealMap[lx - 1 + lx * (y - 1)] and fTerrain >= fGrass) then
         Wrong := Continent[lx - 1 + lx * (y - 1)];
       if (y and 1 = 0) and (y + 1 < ly - 1) and
         (RealMap[lx - 1 + lx * (y + 1)] and fTerrain >= fGrass) then
         Wrong := Continent[lx - 1 + lx * (y + 1)];
+      if RealMap[lx - 1 + lx * Y] and fTerrain >= fGrass then
+        Wrong := Continent[lx - 1 + lx * Y];
+      if (Y and 1 = 0) and (Y - 1 >= 1) and
+        (RealMap[lx - 1 + lx * (Y - 1)] and fTerrain >= fGrass) then
+        Wrong := Continent[lx - 1 + lx * (Y - 1)];
+      if (Y and 1 = 0) and (Y + 1 < ly - 1) and
+        (RealMap[lx - 1 + lx * (Y + 1)] and fTerrain >= fGrass) then
+        Wrong := Continent[lx - 1 + lx * (Y + 1)];
       if Wrong >= 0 then
         ReplaceCont(Wrong, Continent[lx * y], MapSize - 1)
+        ReplaceCont(Wrong, Continent[lx * Y], MapSize - 1);
     end;
 end;
 …
 // must be done after FindContinents
 var
   i, j, Cnt, x, y, dx, dy, Loc0, Loc1, xworst, yworst, totalrare, RareMaxWater,
     RareType, iBest, jbest, MinDist, xBlock, yBlock, V8: integer;
   AreaCount, RareByArea, RareAdjacent: array [0 .. 7, 0 .. 4] of integer;
   RareLoc: array [0 .. 11] of integer;
   Dist: array [0 .. 11, 0 .. 11] of integer;
+  I, J, Cnt, X, Y, dx, dy, Loc0, Loc1, xworst, yworst, totalrare, RareMaxWater,
+    RareType, iBest, jbest, MinDist, xBlock, yBlock, V8: Integer;
+  AreaCount, RareByArea, RareAdjacent: array [0 .. 7, 0 .. 4] of Integer;
+  RareLoc: array [0 .. 11] of Integer;
+  Dist: array [0 .. 11, 0 .. 11] of Integer;
   Adjacent: TVicinity8Loc;
 begin
 …
   repeat
     FillChar(AreaCount, SizeOf(AreaCount), 0);
     for y := 1 to ly - 2 do
     begin
       yBlock := y * 5 div ly;
       if yBlock = (y + 1) * 5 div ly then
         for x := 0 to lx - 1 do
         begin
           xBlock := x * 8 div lx;
           if xBlock = (x + 1) * 8 div lx then
+    for Y := 1 to ly - 2 do
+    begin
+      yBlock := Y * 5 div ly;
+      if yBlock = (Y + 1) * 5 div ly then
+        for X := 0 to lx - 1 do
+        begin
+          xBlock := X * 8 div lx;
+          if xBlock = (X + 1) * 8 div lx then
           begin
             Loc0 := x + lx * y;
+            Loc0 := X + lx * Y;
             if RealMap[Loc0] and fTerrain >= fGrass then
             begin
 …
                 if (Loc1 >= 0) and (Loc1 < MapSize) and
                   (RealMap[Loc1] and fTerrain < fGrass) then
                   inc(Cnt); // count adjacent water
+                  Inc(Cnt); // count adjacent water
               end;
               if Cnt <= RareMaxWater then // inner land
               begin
                 inc(AreaCount[xBlock, yBlock]);
+                Inc(AreaCount[xBlock, yBlock]);
                 if DelphiRandom(AreaCount[xBlock, yBlock]) = 0 then
                   RareByArea[xBlock, yBlock] := Loc0
               end
+                  RareByArea[xBlock, yBlock] := Loc0;
+              end;
             end;
           end;
         end
+        end;
     end;
     totalrare := 0;
     for x := 0 to 7 do
       for y := 0 to 4 do
         if AreaCount[x, y] > 0 then
           inc(totalrare);
     inc(RareMaxWater);
+    for X := 0 to 7 do
+      for Y := 0 to 4 do
+        if AreaCount[X, Y] > 0 then
+          Inc(totalrare);
+    Inc(RareMaxWater);
   until totalrare >= 12;
 …
   begin // remove rarebyarea resources too close to each other
     FillChar(RareAdjacent, SizeOf(RareAdjacent), 0);
     for x := 0 to 7 do
       for y := 0 to 4 do
         if AreaCount[x, y] > 0 then
         begin
           if (AreaCount[(x + 1) mod 8, y] > 0) and
             (Continent[RareByArea[x, y]] = Continent
             [RareByArea[(x + 1) mod 8, y]]) then
+    for X := 0 to 7 do
+      for Y := 0 to 4 do
+        if AreaCount[X, Y] > 0 then
+        begin
+          if (AreaCount[(X + 1) mod 8, Y] > 0) and
+            (Continent[RareByArea[X, Y]] = Continent
+            [RareByArea[(X + 1) mod 8, Y]]) then
           begin
             inc(RareAdjacent[x, y]);
             inc(RareAdjacent[(x + 1) mod 8, y]);
+            Inc(RareAdjacent[X, Y]);
+            Inc(RareAdjacent[(X + 1) mod 8, Y]);
           end;
           if y < 4 then
+          if Y < 4 then
           begin
             if (AreaCount[x, y + 1] > 0) and
               (Continent[RareByArea[x, y]] = Continent[RareByArea[x, y + 1]])
+            if (AreaCount[X, Y + 1] > 0) and
+              (Continent[RareByArea[X, Y]] = Continent[RareByArea[X, Y + 1]])
             then
             begin
               inc(RareAdjacent[x, y]);
               inc(RareAdjacent[x, y + 1]);
+              Inc(RareAdjacent[X, Y]);
+              Inc(RareAdjacent[X, Y + 1]);
             end;
             if (AreaCount[(x + 1) mod 8, y + 1] > 0) and
               (Continent[RareByArea[x, y]] = Continent[RareByArea[(x + 1) mod 8,
               y + 1]]) then
+            if (AreaCount[(X + 1) mod 8, Y + 1] > 0) and
+              (Continent[RareByArea[X, Y]] = Continent[RareByArea[(X + 1) mod 8,
+              Y + 1]]) then
             begin
               inc(RareAdjacent[x, y]);
               inc(RareAdjacent[(x + 1) mod 8, y + 1]);
+              Inc(RareAdjacent[X, Y]);
+              Inc(RareAdjacent[(X + 1) mod 8, Y + 1]);
             end;
             if (AreaCount[(x + 7) mod 8, y + 1] > 0) and
               (Continent[RareByArea[x, y]] = Continent[RareByArea[(x + 7) mod 8,
               y + 1]]) then
+            if (AreaCount[(X + 7) mod 8, Y + 1] > 0) and
+              (Continent[RareByArea[X, Y]] = Continent[RareByArea[(X + 7) mod 8,
+              Y + 1]]) then
             begin
               inc(RareAdjacent[x, y]);
               inc(RareAdjacent[(x + 7) mod 8, y + 1]);
+              Inc(RareAdjacent[X, Y]);
+              Inc(RareAdjacent[(X + 7) mod 8, Y + 1]);
             end;
           end
+          end;
         end;
     xworst := 0;
     yworst := 0;
     Cnt := 0;
     for x := 0 to 7 do
       for y := 0 to 4 do
         if AreaCount[x, y] > 0 then
         begin
           if (Cnt = 0) or (RareAdjacent[x, y] > RareAdjacent[xworst, yworst])
+    for X := 0 to 7 do
+      for Y := 0 to 4 do
+        if AreaCount[X, Y] > 0 then
+        begin
+          if (Cnt = 0) or (RareAdjacent[X, Y] > RareAdjacent[xworst, yworst])
           then
           begin
             xworst := x;
             yworst := y;
             Cnt := 1
+            xworst := X;
+            yworst := Y;
+            Cnt := 1;
           end
           else if (RareAdjacent[x, y] = RareAdjacent[xworst, yworst]) then
+          else if (RareAdjacent[X, Y] = RareAdjacent[xworst, yworst]) then
           begin
             inc(Cnt);
+            Inc(Cnt);
             if DelphiRandom(Cnt) = 0 then
             begin
               xworst := x;
               yworst := y;
             end
+              xworst := X;
+              yworst := Y;
+            end;
           end;
         end;
     AreaCount[xworst, yworst] := 0;
     dec(totalrare)
+    Dec(totalrare);
   end;
   Cnt := 0;
   for x := 0 to 7 do
     for y := 0 to 4 do
       if AreaCount[x, y] > 0 then
       begin
         RareLoc[Cnt] := RareByArea[x, y];
         inc(Cnt)
       end;
   for i := 0 to 11 do
   begin
     RealMap[RareLoc[i]] := RealMap[RareLoc[i]] and not(fTerrain or fSpecial) or
+  for X := 0 to 7 do
+    for Y := 0 to 4 do
+      if AreaCount[X, Y] > 0 then
+      begin
+        RareLoc[Cnt] := RareByArea[X, Y];
+        Inc(Cnt);
+      end;
+  for I := 0 to 11 do
+  begin
+    RealMap[RareLoc[I]] := RealMap[RareLoc[I]] and not(fTerrain or fSpecial) or
       (fDesert or fDeadLands);
     for dy := -1 to 1 do
 …
         if (dx + dy) and 1 = 0 then
         begin
           Loc1 := dLoc(RareLoc[i], dx, dy);
+          Loc1 := dLoc(RareLoc[I], dx, dy);
           if (Loc1 >= 0) and (RealMap[Loc1] and fTerrain = fMountains) then
             RealMap[Loc1] := RealMap[Loc1] and not fTerrain or fHills;
         end
   end;
   for i := 0 to 11 do
     for j := 0 to 11 do
       Dist[i, j] := Distance(RareLoc[i], RareLoc[j]);
+        end;
+  end;
+  for I := 0 to 11 do
+    for J := 0 to 11 do
+      Dist[I, J] := Distance(RareLoc[I], RareLoc[J]);
   ibest := 0;
 …
   begin
     Cnt := 0;
     for i := 0 to 11 do
       if RareLoc[i] >= 0 then
         for j := 0 to 11 do
           if RareLoc[j] >= 0 then
+    for I := 0 to 11 do
+      if RareLoc[I] >= 0 then
+        for J := 0 to 11 do
+          if RareLoc[J] >= 0 then
             if (Cnt > 0) and (Dist[iBest, jbest] >= MinDist) then
             begin
               if Dist[i, j] >= MinDist then
+              if Dist[I, J] >= MinDist then
               begin
                 inc(Cnt);
+                Inc(Cnt);
                 if DelphiRandom(Cnt) = 0 then
                 begin
                   iBest := i;
                   jbest := j
                 end
               end
+                  iBest := I;
+                  jbest := J;
+                end;
+              end;
             end
             else if (Cnt = 0) or (Dist[i, j] > Dist[iBest, jbest]) then
+            else if (Cnt = 0) or (Dist[I, J] > Dist[iBest, jbest]) then
             begin
               iBest := i;
               jbest := j;
+              iBest := I;
+              jbest := J;
               Cnt := 1;
             end;
 …
     RareLoc[jbest] := -1;
   end;
 end; // RarePositions
 function CheckShore(Loc: integer): boolean;
 var
   Loc1, OldTile, V21: integer;
+end;
+function CheckShore(Loc: Integer): Boolean;
+var
+  Loc1, OldTile, V21: Integer;
   Radius: TVicinity21Loc;
 begin
   result := false;
+  Result := False;
   OldTile := RealMap[Loc];
   if OldTile and fTerrain < fGrass then
 …
     end;
     if (RealMap[Loc] xor Cardinal(OldTile)) and fTerrain <> 0 then
       result := true;
   end;
 end;
 function ActualSpecialTile(Loc: integer): Cardinal;
 begin
   result := SpecialTile(Loc, RealMap[Loc] and fTerrain, lx);
 end;
 procedure CreateMap(preview: boolean);
+      Result := True;
+  end;
+end;
+function ActualSpecialTile(Loc: Integer): Cardinal;
+begin
+  Result := SpecialTile(Loc, RealMap[Loc] and fTerrain, lx);
+end;
+procedure CreateMap(preview: Boolean);
 const
   ShHiHills = 6; { of land }
 …
   hotunification = 50; // min. 25
   Zone: array [0 .. 3, 2 .. 9] of single = { terrain distribution }
+  Zone: array [0 .. 3, 2 .. 9] of Single = { terrain distribution }
     ((0.25, 0, 0, 0.4, 0, 0, 0, 0.35), (0.55, 0, 0.1, 0, 0, 0, 0, 0.35),
     (0.4, 0, 0.35, 0, 0, 0, 0, 0.25), (0, 0.7, 0, 0, 0, 0, 0, 0.3));
   { Grs  Dst  Pra  Tun  - - - For }
   function RndLow(y: integer): Cardinal;
+  function RndLow(Y: Integer): Cardinal;
   { random lowland appropriate to climate }
   var
     z0, i: integer;
     p, p0, ZPlus: single;
   begin
     if ly - 1 - y > y then
     begin
       z0 := 6 * y div ly;
       ZPlus := 6 * y / ly - z0;
+    z0, I: Integer;
+    P, p0, ZPlus: Single;
+  begin
+    if ly - 1 - Y > Y then
+    begin
+      z0 := 6 * Y div ly;
+      ZPlus := 6 * Y / ly - z0;
     end
     else
     begin
       z0 := 6 * (ly - 1 - y) div ly;
       ZPlus := 6 * (ly - 1 - y) / ly - z0;
+      z0 := 6 * (ly - 1 - Y) div ly;
+      ZPlus := 6 * (ly - 1 - Y) / ly - z0;
     end;
     p0 := 1;
     for i := 2 to 9 do
     begin
       p := Zone[z0, i] * (1 - ZPlus) + Zone[z0 + 1, i] * ZPlus;
+    for I := 2 to 9 do
+    begin
+      P := Zone[z0, I] * (1 - ZPlus) + Zone[z0 + 1, I] * ZPlus;
       { weight between zones z0 and z0+1 }
       if DelphiRandom * p0 < p then
       begin
         RndLow := i;
+      if DelphiRandom * p0 < P then
+      begin
+        RndLow := I;
         Break;
       end;
       p0 := p0 - p;
     end;
   end;
   function RunRiver(Loc0: integer): integer;
+      p0 := p0 - P;
+    end;
+  end;
+  function RunRiver(Loc0: Integer): Integer;
   { runs river from start point Loc0; return value: length }
   var
     Dir, T, Loc, Loc1, Cost: integer;
+    Dir, T, Loc, Loc1, Cost: Integer;
     Q: TIPQ;
     From: array [0 .. lxmax * lymax - 1] of integer;
     Time: array [0 .. lxmax * lymax - 1] of integer;
     OneTileLake: boolean;
+    From: array [0 .. lxmax * lymax - 1] of Integer;
+    Time: array [0 .. lxmax * lymax - 1] of Integer;
+    OneTileLake: Boolean;
   begin
     FillChar(Time, SizeOf(Time), 255); { -1 }
 …
       if (RealMap[Loc] and fTerrain < fGrass) then
       begin
         OneTileLake := true;
+        OneTileLake := True;
         for Dir := 0 to 3 do
         begin
           Loc1 := dLoc(Loc, Dir and 1 * 2 - 1, Dir shr 1 * 2 - 1);
           if (Loc1 >= 0) and (RealMap[Loc1] and fTerrain < fGrass) then
             OneTileLake := false;
+            OneTileLake := False;
         end;
         if not OneTileLake then
 …
     end;
     Loc1 := Loc;
     result := 0;
+    Result := 0;
     while Loc <> Loc0 do
     begin
       Loc := From[Loc];
       inc(result);
     end;
     if (result > 1) and ((result >= MinRivLen) or
+      Inc(Result);
+    end;
+    if (Result > 1) and ((Result >= MinRivLen) or
       (RealMap[Loc1] and fTerrain >= fGrass)) then
     begin
 …
     end
     else
       result := 0;
+      Result := 0;
     FreeAndNil(Q);
   end;
 var
   x, y, n, Dir, plus, Count, Loc0, Loc1, bLand, bHills, bMountains, V8: integer;
   CopyFrom: array [0 .. lxmax * lymax - 1] of integer;
+  X, Y, N, Dir, plus, Count, Loc0, Loc1, bLand, bHills, bMountains, V8: Integer;
+  CopyFrom: array [0 .. lxmax * lymax - 1] of Integer;
   Adjacent: TVicinity8Loc;
 …
   while plus < MapSize * LandMass * ShMountains div 10000 do
   begin
     dec(bMountains);
     inc(plus, ElCount[bMountains])
+    Dec(bMountains);
+    Inc(plus, ElCount[bMountains]);
   end;
   Count := plus;
 …
   while plus < MapSize * LandMass * ShHiHills div 10000 do
   begin
     dec(bHills);
     inc(plus, ElCount[bHills])
   end;
   inc(Count, plus);
+    Dec(bHills);
+    Inc(plus, ElCount[bHills]);
+  end;
+  Inc(Count, plus);
   bLand := bHills;
   while Count < MapSize * LandMass div 100 do
   begin
     dec(bLand);
     inc(Count, ElCount[bLand])
+    Dec(bLand);
+    Inc(Count, ElCount[bLand]);
   end;
 …
           (RealMap[Loc1] and fTerrain < fGrass) or
           (RealMap[Loc1] and fTerrain = fArctic) then
           inc(Count); // count adjacent water
+          Inc(Count); // count adjacent water
       end;
       if Count = 8 then
         RealMap[Loc0] := fOcean
+        RealMap[Loc0] := fOcean;
     end;
 …
       plus := MapSize;
     Loc0 := DelphiRandom(MapSize);
     for n := 0 to plus - 1 do
+    for N := 0 to plus - 1 do
     begin
       if (RealMap[Loc0] and fTerrain >= fGrass) and (Loc0 >= lx) and
 …
     CopyFrom[Loc0] := Loc0;
   for n := 0 to unification * MapSize div 100 do
   begin
     y := DelphiRandom(ly);
     if abs(y - (ly shr 1)) > ly div 4 + DelphiRandom(ly * hotunification div 100) then
       if y < ly shr 1 then
         y := ly shr 1 - y
+  for N := 0 to unification * MapSize div 100 do
+  begin
+    Y := DelphiRandom(ly);
+    if abs(Y - (ly shr 1)) > ly div 4 + DelphiRandom(ly * hotunification div 100) then
+      if Y < ly shr 1 then
+        Y := ly shr 1 - Y
       else
         y := 3 * ly shr 1 - y;
     Loc0 := lx * y + DelphiRandom(lx);
+        Y := 3 * ly shr 1 - Y;
+    Loc0 := lx * Y + DelphiRandom(lx);
     if RealMap[Loc0] and fTerrain = fGrass then
     begin
 …
         Loc1 := CopyFrom[Loc1];
       RealMap[Loc0] := RealMap[Loc0] and not fTerrain or
         RealMap[Loc1] and fTerrain
+        RealMap[Loc1] and fTerrain;
     end;
 …
           if Loc1 >= 0 then
             if RealMap[Loc1] and fTerrain < fGrass then
               inc(Count, 2)
+              Inc(Count, 2);
         end;
       end;
       if Count >= 4 then
         RealMap[Loc0] := RealMap[Loc0] and not fTerrain or fPrairie
+        RealMap[Loc0] := RealMap[Loc0] and not fTerrain or fPrairie;
     end;
 …
         if Loc1 >= 0 then
           if RealMap[Loc1] and fTerrain <> fDesert then
             inc(Count)
+            Inc(Count);
       end;
       if Count >= 4 then
         RealMap[Loc0] := RealMap[Loc0] and not fTerrain or fPrairie
+        RealMap[Loc0] := RealMap[Loc0] and not fTerrain or fPrairie;
     end;
   for Loc0 := 0 to MapSize - 1 do
     CheckShore(Loc0); // change ocean to shore
   for x := 0 to lx - 1 do
   begin
     RealMap[x + lx * 0] := fArctic;
     if RealMap[x + lx * 1] >= fGrass then
       RealMap[x + lx * 1] := RealMap[x + lx * 1] and not fTerrain or fTundra;
     if RealMap[x + lx * (ly - 2)] >= fGrass then
       RealMap[x + lx * (ly - 2)] := RealMap[x + lx * (ly - 2)] and
+  for X := 0 to lx - 1 do
+  begin
+    RealMap[X + lx * 0] := fArctic;
+    if RealMap[X + lx * 1] >= fGrass then
+      RealMap[X + lx * 1] := RealMap[X + lx * 1] and not fTerrain or fTundra;
+    if RealMap[X + lx * (ly - 2)] >= fGrass then
+      RealMap[X + lx * (ly - 2)] := RealMap[X + lx * (ly - 2)] and
         not fTerrain or fTundra;
     RealMap[x + lx * (ly - 1)] := fArctic
+    RealMap[X + lx * (ly - 1)] := fArctic;
   end;
 …
   CountGood: (cgBest, cgFlat, cgLand);
   function IsGoodTile(Loc: integer): boolean;
+  function IsGoodTile(Loc: Integer): Boolean;
   var
     xLoc, yLoc: integer;
+    xLoc, yLoc: Integer;
   begin
     xLoc := Loc mod lx;
     yLoc := Loc div lx;
     if RealMap[Loc] and fDeadLands <> 0 then
       result := false
+      Result := False
     else
       case CountGood of
         cgBest:
           result := (RealMap[Loc] and fTerrain in [fGrass, fPrairie, fTundra,
+          Result := (RealMap[Loc] and fTerrain in [fGrass, fPrairie, fTundra,
             fSwamp, fForest]) and Odd((lymax + xLoc - yLoc shr 1) shr 1 + xLoc +
             (yLoc + 1) shr 1);
         cgFlat:
           result := (RealMap[Loc] and fTerrain in [fGrass, fPrairie, fTundra,
+          Result := (RealMap[Loc] and fTerrain in [fGrass, fPrairie, fTundra,
             fSwamp, fForest]);
         cgLand:
           result := RealMap[Loc] and fTerrain >= fGrass;
+          Result := RealMap[Loc] and fTerrain >= fGrass;
       end;
   end;
 …
 var
   p1, p2, nAlive, c, Loc, Loc1, CntGood, CntGoodGrass, MinDist, i, j, n,
+  p1, p2, nAlive, C, Loc, Loc1, CntGood, CntGoodGrass, MinDist, I, J, N,
     nsc, V21, V8, BestDist, TestDist, MinGood, nIrrLoc,
     FineDistSQR, nRest: integer;
   ccount: array [0 .. lxmax * lymax - 1] of word;
   sc, StartLoc0, sccount: array [1 .. nPl] of integer;
   TestStartLoc: array [0 .. nPl - 1] of integer;
   CityLoc: array [1 .. nPl, 0 .. MaxCityLoc - 1] of integer;
   nCityLoc: array [1 .. nPl] of integer;
   RestLoc: array [0 .. MaxCityLoc - 1] of integer;
   IrrLoc: array [0 .. 20] of integer;
+    FineDistSQR, nRest: Integer;
+  ccount: array [0 .. lxmax * lymax - 1] of Word;
+  sc, StartLoc0, sccount: array [1 .. nPl] of Integer;
+  TestStartLoc: array [0 .. nPl - 1] of Integer;
+  CityLoc: array [1 .. nPl, 0 .. MaxCityLoc - 1] of Integer;
+  nCityLoc: array [1 .. nPl] of Integer;
+  RestLoc: array [0 .. MaxCityLoc - 1] of Integer;
+  IrrLoc: array [0 .. 20] of Integer;
   Radius: TVicinity21Loc;
   Adjacent: TVicinity8Loc;
   ok: boolean;
+  ok: Boolean;
 begin
 …
   for p1 := 0 to nPl - 1 do
     if 1 shl p1 and GAlive <> 0 then
       inc(nAlive);
+      Inc(nAlive);
   if nAlive = 0 then
     exit;
+    Exit;
   { count good tiles }
 …
     if RealMap[Loc] and fTerrain = fGrass then
       if ActualSpecialTile(Loc) = 1 then
         inc(ccount[Continent[Loc]], 3)
+        Inc(ccount[Continent[Loc]], 3)
       else
         inc(ccount[Continent[Loc]], 2)
+        Inc(ccount[Continent[Loc]], 2)
     else if RealMap[Loc] and fTerrain in [fPrairie, fSwamp, fForest, fHills]
     then
       inc(ccount[Continent[Loc]]);
+      Inc(ccount[Continent[Loc]]);
   Loc := 0;
   while ccount[Loc] > 0 do
     inc(Loc);
   for i := 1 to nAlive do
   begin
     sc[i] := Loc;
     sccount[i] := 1
+    Inc(Loc);
+  for I := 1 to nAlive do
+  begin
+    sc[I] := Loc;
+    sccount[I] := 1
   end;
   { init with zero size start continents, then search bigger ones }
 …
         if p1 < nAlive + 1 then
           sc[p1] := sc[p1 - 1];
         dec(p1)
+        Dec(p1);
       end;
       if p1 < nAlive + 1 then
 …
   nsc := nAlive;
   repeat
     c := 1; // search least crowded continent after smallest
     for i := 2 to nsc - 1 do
       if ccount[sc[i]] * (2 * sccount[c] + 1) > ccount[sc[c]] *
         (2 * sccount[i] + 1) then
         c := i;
     if ccount[sc[nsc]] * (2 * sccount[c] + 1) > ccount[sc[c]] then
+    C := 1; // search least crowded continent after smallest
+    for I := 2 to nsc - 1 do
+      if ccount[sc[I]] * (2 * sccount[C] + 1) > ccount[sc[C]] *
+        (2 * sccount[I] + 1) then
+        C := I;
+    if ccount[sc[nsc]] * (2 * sccount[C] + 1) > ccount[sc[C]] then
       Break; // even least crowded continent is more crowded than smallest
     inc(sccount[c]);
     dec(nsc)
+    Inc(sccount[C]);
+    Dec(nsc);
   until sccount[nsc] > 1;
 …
   CountGood := cgBest;
   repeat
     dec(MinGood);
+    Dec(MinGood);
     if (MinGood = 3) and (CountGood < cgLand) then // too demanding!
     begin
       inc(CountGood);
       MinGood := 6
+      Inc(CountGood);
+      MinGood := 6;
     end;
     FillChar(nCityLoc, SizeOf(nCityLoc), 0);
     Loc := DelphiRandom(MapSize);
     for i := 0 to MapSize - 1 do
+    for I := 0 to MapSize - 1 do
     begin
       if ((Loc >= 4 * lx) and (Loc < MapSize - 4 * lx) or (CountGood >= cgLand))
         and IsGoodTile(Loc) then
       begin
         c := nsc;
         while (c > 0) and (Continent[Loc] <> sc[c]) do
           dec(c);
         if (c > 0) and (nCityLoc[c] < MaxCityLoc) then
+        C := nsc;
+        while (C > 0) and (Continent[Loc] <> sc[C]) do
+          Dec(C);
+        if (C > 0) and (nCityLoc[C] < MaxCityLoc) then
         begin
           CntGood := 1;
 …
               Loc1 := Radius[V21];
               if (Loc1 >= 0) and (Loc1 < MapSize) and IsGoodTile(Loc1) then
                 inc(CntGood)
+                Inc(CntGood);
             end;
           if CntGood >= MinGood then
           begin
             CityLoc[c, nCityLoc[c]] := Loc;
             inc(nCityLoc[c])
+            CityLoc[C, nCityLoc[C]] := Loc;
+            Inc(nCityLoc[C]);
           end;
         end;
 …
     end;
     ok := true;
     for c := 1 to nsc do
       if nCityLoc[c] < sccount[c] * (8 - MinGood) div (7 - MinGood) then
         ok := false;
+    ok := True;
+    for C := 1 to nsc do
+      if nCityLoc[C] < sccount[C] * (8 - MinGood) div (7 - MinGood) then
+        ok := False;
   until ok;
   FineDistSQR := MapSize * LandMass * 9 div (nAlive * 100);
   p1 := 1;
   for c := 1 to nsc do
+  for C := 1 to nsc do
   begin // for all start continents
     if sccount[c] = 1 then
       StartLoc0[p1] := CityLoc[c, DelphiRandom(nCityLoc[c])]
+    if sccount[C] = 1 then
+      StartLoc0[p1] := CityLoc[C, DelphiRandom(nCityLoc[C])]
     else
     begin
       BestDist := 0;
       n := 1 shl sccount[c] * 32; // number of tries to find good distribution
       if n > 1 shl 12 then
         n := 1 shl 12;
       while (n > 0) and (BestDist * BestDist < FineDistSQR) do
+      N := 1 shl sccount[C] * 32; // number of tries to find good distribution
+      if N > 1 shl 12 then
+        N := 1 shl 12;
+      while (N > 0) and (BestDist * BestDist < FineDistSQR) do
       begin
         MinDist := MaxInt;
         nRest := nCityLoc[c];
         for i := 0 to nRest - 1 do
           RestLoc[i] := CityLoc[c, i];
         for i := 0 to sccount[c] - 1 do
+        nRest := nCityLoc[C];
+        for I := 0 to nRest - 1 do
+          RestLoc[I] := CityLoc[C, I];
+        for I := 0 to sccount[C] - 1 do
         begin
           if nRest = 0 then
             Break;
           j := DelphiRandom(nRest);
           TestStartLoc[i] := RestLoc[j];
           RestLoc[j] := RestLoc[nRest - 1];
           dec(nRest);
           for j := 0 to i - 1 do
+          J := DelphiRandom(nRest);
+          TestStartLoc[I] := RestLoc[J];
+          RestLoc[J] := RestLoc[nRest - 1];
+          Dec(nRest);
+          for J := 0 to I - 1 do
           begin
             TestDist := Distance(TestStartLoc[i], TestStartLoc[j]);
+            TestDist := Distance(TestStartLoc[I], TestStartLoc[J]);
             if TestDist < MinDist then
               MinDist := TestDist
+              MinDist := TestDist;
           end;
           if i = sccount[c] - 1 then
+          if I = sccount[C] - 1 then
           begin
             assert(MinDist > BestDist);
+            Assert(MinDist > BestDist);
             BestDist := MinDist;
             for j := 0 to sccount[c] - 1 do
               StartLoc0[p1 + j] := TestStartLoc[j];
+            for J := 0 to sccount[C] - 1 do
+              StartLoc0[p1 + J] := TestStartLoc[J];
           end
           else if BestDist > 0 then
           begin
             j := 0;
             while j < nRest do
+            J := 0;
+            while J < nRest do
             begin // remove all locs from rest which have too little distance to this one
               TestDist := Distance(TestStartLoc[i], RestLoc[j]);
+              TestDist := Distance(TestStartLoc[I], RestLoc[J]);
               if TestDist <= BestDist then
               begin
                 RestLoc[j] := RestLoc[nRest - 1];
                 dec(nRest);
+                RestLoc[J] := RestLoc[nRest - 1];
+                Dec(nRest);
               end
               else
                 inc(j);
+                Inc(J);
             end;
           end;
         end;
         dec(n)
       end;
     end;
     p1 := p1 + sccount[c]
+        Dec(N)
+      end;
+    end;
+    p1 := p1 + sccount[C]
   end;
 …
         if (Loc1 >= 0) and (Loc1 < MapSize) and IsGoodTile(Loc1) then
           if RealMap[Loc1] and fTerrain = fGrass then
             inc(CntGoodGrass)
+            Inc(CntGoodGrass)
           else
             inc(CntGood);
+            Inc(CntGood);
       end;
     for V21 := 1 to 26 do
 …
         begin
           IrrLoc[nIrrLoc] := Loc1;
           inc(nIrrLoc);
         end;
       end;
     i := 2;
     if i > nIrrLoc then
       i := nIrrLoc;
     while i > 0 do
     begin
       j := DelphiRandom(nIrrLoc);
       RealMap[IrrLoc[j]] := RealMap[IrrLoc[j]] or tiIrrigation;
       IrrLoc[j] := IrrLoc[nIrrLoc - 1];
       dec(nIrrLoc);
       dec(i);
+          Inc(nIrrLoc);
+        end;
+      end;
+    I := 2;
+    if I > nIrrLoc then
+      I := nIrrLoc;
+    while I > 0 do
+    begin
+      J := DelphiRandom(nIrrLoc);
+      RealMap[IrrLoc[J]] := RealMap[IrrLoc[J]] or tiIrrigation;
+      IrrLoc[J] := IrrLoc[nIrrLoc - 1];
+      Dec(nIrrLoc);
+      Dec(I);
     end;
   end;
 …
     begin
       repeat
         i := DelphiRandom(nAlive) + 1
       until StartLoc0[i] >= 0;
       StartLoc[p1] := StartLoc0[i];
       StartLoc0[i] := -1
+        I := DelphiRandom(nAlive) + 1
+      until StartLoc0[I] >= 0;
+      StartLoc[p1] := StartLoc0[I];
+      StartLoc0[I] := -1
     end;
   SaveMapCenterLoc := StartLoc[0];
 …
           StartLoc2[p1] := Loc1;
           BestDist := TestDist;
           n := 1;
+          N := 1;
         end
         else if TestDist = BestDist then
         begin
           inc(n);
           if DelphiRandom(n) = 0 then
+          Inc(N);
+          if DelphiRandom(N) = 0 then
             StartLoc2[p1] := Loc1;
         end;
       end;
     end;
 end; { StartPositions }
 procedure PredefinedStartPositions(Human: integer);
+end;
+procedure PredefinedStartPositions(Human: Integer);
 // use predefined nation start positions
 var
   i, p1, Loc1, nAlive, nStartLoc0, nPrefStartLoc0, imax: integer;
   StartLoc0: array [0 .. lxmax * lymax - 1] of integer;
   ishuman: boolean;
+  I, p1, Loc1, nAlive, nStartLoc0, nPrefStartLoc0, imax: Integer;
+  StartLoc0: array [0 .. lxmax * lymax - 1] of Integer;
+  ishuman: Boolean;
 begin
   nAlive := 0;
   for p1 := 0 to nPl - 1 do
     if 1 shl p1 and GAlive <> 0 then
       inc(nAlive);
+      Inc(nAlive);
   if nAlive = 0 then
     exit;
+    Exit;
   for I := 0 to Length(StartLoc0) - 1 do
 …
       StartLoc0[nStartLoc0] := StartLoc0[nPrefStartLoc0];
       StartLoc0[nPrefStartLoc0] := Loc1;
       inc(nPrefStartLoc0);
       inc(nStartLoc0);
+      Inc(nPrefStartLoc0);
+      Inc(nStartLoc0);
       RealMap[Loc1] := RealMap[Loc1] and not fPrefStartPos;
     end
 …
     begin
       StartLoc0[nStartLoc0] := Loc1;
       inc(nStartLoc0);
+      Inc(nStartLoc0);
       RealMap[Loc1] := RealMap[Loc1] and not fStartPos;
     end;
   assert(nStartLoc0 >= nAlive);
+  Assert(nStartLoc0 >= nAlive);
   StartLoc[0] := 0;
   for ishuman := true downto false do
+  for ishuman := True downto False do
     for p1 := 0 to nPl - 1 do
       if (1 shl p1 and GAlive <> 0) and ((1 shl p1 and Human <> 0) = ishuman)
       then
       begin
         dec(nStartLoc0);
+        Dec(nStartLoc0);
         imax := nStartLoc0;
         if nPrefStartLoc0 > 0 then
         begin
           dec(nPrefStartLoc0);
+          Dec(nPrefStartLoc0);
           imax := nPrefStartLoc0;
         end;
         i := DelphiRandom(imax + 1);
         StartLoc[p1] := StartLoc0[i];
         StartLoc2[p1] := StartLoc0[i];
         StartLoc0[i] := StartLoc0[imax];
+        I := DelphiRandom(imax + 1);
+        StartLoc[p1] := StartLoc0[I];
+        StartLoc2[p1] := StartLoc0[I];
+        StartLoc0[I] := StartLoc0[imax];
         StartLoc0[imax] := StartLoc0[nStartLoc0];
       end;
   SaveMapCenterLoc := StartLoc[0];
 end; { PredefinedStartPositions }
+end;
 procedure InitGame;
 var
   i, p, p1, uix, Loc1: integer;
+  I, P, p1, uix, Loc1: Integer;
 begin
   {$IFDEF FastContact}
 …
     if RealMap[Loc1] and fterrain>=fGrass then
     if Delphirandom(3)=0 then RealMap[Loc1]:=RealMap[Loc1] or fRoad
     else if Delphirandom(3)=0 then RealMap[Loc1]:=RealMap[Loc1] or fRR;
+    else if Delphirandom(3)=0 then RealMap[Loc1]:=RealMap[Loc1] or fRR;}
     {random Road and Railroad }
   { !!!for Loc1:=0 to MapSize-1 do
 …
   GTestFlags := 0;
   GInitialized := GAlive or GWatching;
   for p := 0 to nPl - 1 do
     if 1 shl p and GInitialized <> 0 then
       with RW[p] do
       begin
         Researched[p] := 0;
         Discovered[p] := 0;
         TerritoryCount[p] := 0;
         nTech[p] := 0;
         if Difficulty[p] = 0 then
           ResourceMask[p] := $FFFFFFFF
+  for P := 0 to nPl - 1 do
+    if 1 shl P and GInitialized <> 0 then
+      with RW[P] do
+      begin
+        Researched[P] := 0;
+        Discovered[P] := 0;
+        TerritoryCount[P] := 0;
+        nTech[P] := 0;
+        if Difficulty[P] = 0 then
+          ResourceMask[P] := $FFFFFFFF
         else
           ResourceMask[p] := $FFFFFFFF and not(fSpecial2 or fModern);
         GrWallContinent[p] := -1;
+          ResourceMask[P] := $FFFFFFFF and not(fSpecial2 or fModern);
+        GrWallContinent[P] := -1;
         GetMem(Map, 4 * MapSize);
 …
           if 1 shl p1 and GInitialized <> 0 then
           begin
             FillChar(RWemix[p, p1], SizeOf(RWemix[p, p1]), 255); { -1 }
             FillChar(Destroyed[p, p1], SizeOf(Destroyed[p, p1]), 0);
+            FillChar(RWemix[P, p1], SizeOf(RWemix[P, p1]), 255); { -1 }
+            FillChar(Destroyed[P, p1], SizeOf(Destroyed[P, p1]), 0);
           end;
           Attitude[p1] := atNeutral;
 …
           Tribute[p1] := 0;
           TributePaid[p1] := 0;
           if (p1 <> p) and (1 shl p1 and GAlive <> 0) then
+          if (p1 <> P) and (1 shl p1 and GAlive <> 0) then
           begin // initialize enemy report
             GetMem(EnemyReport[p1], SizeOf(TEnemyReport) - 2 *
 …
             EnemyReport[p1].Attitude := atNeutral;
             EnemyReport[p1].Government := gDespotism;
             if 1 shl p and GAlive = 0 then
+            if 1 shl P and GAlive = 0 then
               Treaty[p1] := trNone // supervisor
           end
 …
   // create initial models and units
   for p := 0 to nPl - 1 do
     if (1 shl p and GAlive <> 0) then
       with RW[p] do
+  for P := 0 to nPl - 1 do
+    if (1 shl P and GAlive <> 0) then
+      with RW[P] do
       begin
         nModel := 0;
         for i := 0 to nSpecialModel - 1 do
           if SpecialModelPreq[i] = preNone then
+        for I := 0 to nSpecialModel - 1 do
+          if SpecialModelPreq[I] = preNone then
           begin
             Model[nModel] := SpecialModel[i];
+            Model[nModel] := SpecialModel[I];
             Model[nModel].Status := 0;
             Model[nModel].IntroTurn := 0;
             Model[nModel].Built := 0;
             Model[nModel].Lost := 0;
             Model[nModel].ID := p shl 12 + nModel;
+            Model[nModel].ID := P shl 12 + nModel;
             SetModelFlags(Model[nModel]);
             inc(nModel)
+            Inc(nModel);
           end;
         nUn := 0;
         UnBuilt[p] := 0;
+        UnBuilt[P] := 0;
         for uix := 0 to nStartUn - 1 do
         begin
           CreateUnit(p, StartUn[uix]);
           dec(Model[StartUn[uix]].Built);
           Un[uix].Loc := StartLoc2[p];
           PlaceUnit(p, uix);
         end;
         FoundCity(p, StartLoc[p]); // capital
         Founded[p] := 1;
+          CreateUnit(P, StartUn[uix]);
+          Dec(Model[StartUn[uix]].Built);
+          Un[uix].Loc := StartLoc2[P];
+          PlaceUnit(P, uix);
+        end;
+        FoundCity(P, StartLoc[P]); // capital
+        Founded[P] := 1;
         with City[0] do
         begin
           ID := p shl 12;
+          ID := P shl 12;
           Flags := chFounded;
         end;
 …
   TerritoryCount[nPl] := MapSize;
   // fillchar(NewContact, sizeof(NewContact), false);
 end; // InitGame
+end;
 procedure InitRandomGame;
 …
   CalculatePrimitive;
   CreateElevation;
   CreateMap(false);
+  CreateMap(False);
   StartPositions;
   InitGame;
 end;
 procedure InitMapGame(Human: integer);
+procedure InitMapGame(Human: Integer);
 begin
   DelphiRandSeed := RND;
 …
 procedure ReleaseGame;
 var
   p1, p2: integer;
+  p1, p2: Integer;
 begin
   for p1 := 0 to nPl - 1 do
 …
 procedure InitMapEditor;
 var
   p1: integer;
+  p1: Integer;
 begin
   CalculatePrimitive;
 …
 end;
 procedure EditTile(Loc, NewTile: integer);
 var
   Loc1, V21: integer;
+procedure EditTile(Loc, NewTile: Integer);
+var
+  Loc1, V21: Integer;
   Radius: TVicinity21Loc;
 begin
 …
     if (NewTile and fTerImp = tiIrrigation) or (NewTile and fTerImp = tiFarm)
     then
       NewTile := NewTile and not fTerImp
+      NewTile := NewTile and not fTerImp;
   end;
   if (Terrain[NewTile and fTerrain].MineEff = 0) and
 …
       RealMap[Loc1] := RealMap[Loc1] or ($F shl 27);
       RW[0].Map[Loc1] := RealMap[Loc1] and $07FFFFFF or fObserved;
     end
+    end;
   end;
   // RealMap[Loc]:=RealMap[Loc] and not fSpecial;
 …
   ____________________________________________________________________
+}
 function GetTileInfo(p, cix, Loc: integer; var Info: TTileInfo): integer;
+function GetTileInfo(P, cix, Loc: Integer; var Info: TTileInfo): Integer;
 // cix>=0 - known city index of player p -- only core internal!
 // cix=-1 - search city, player unknown, only if permission for p
 // cix=-2 - don't search city, don't calculate city benefits, just government of player p
 var
   p0, Tile, special: integer;
+  p0, Tile, special: Integer;
 begin
   with Info do
   begin
     p0 := p;
+    p0 := P;
     if cix >= 0 then
       Tile := RealMap[Loc]
     else
     begin
       Tile := RW[p].Map[Loc];
+      Tile := RW[P].Map[Loc];
       if Tile and fTerrain = fUNKNOWN then
       begin
         result := eNoPreq;
         exit;
+        Result := eNoPreq;
+        Exit;
       end;
     end;
 …
     if (cix = -1) and (UsedByCity[Loc] >= 0) then
     begin // search exploiting player and city
       SearchCity(UsedByCity[Loc], p, cix);
       if not((p = p0) or (ObserveLevel[UsedByCity[Loc]] shr (2 * p0) and
+      SearchCity(UsedByCity[Loc], P, cix);
+      if not((P = p0) or (ObserveLevel[UsedByCity[Loc]] shr (2 * p0) and
 = lObserveSuper)) then
         cix := -1
 …
     if cix = -1 then
     begin
       result := eInvalid;
       exit;
+      Result := eInvalid;
+      Exit;
     end; // no city found here
     special := Tile and fSpecial and ResourceMask[p] shr 5;
+    special := Tile and fSpecial and ResourceMask[P] shr 5;
     with Terrain[Tile and fTerrain] do
     begin
 …
       Trade := TradeRes[special];
       if (special > 0) and (Tile and fTerrain <> fGrass) and
         (RW[p].NatBuilt[imSpacePort] > 0) then
+        (RW[P].NatBuilt[imSpacePort] > 0) then
       begin // GeoSat effect
         Food := 2 * Food - FoodRes[0];
 …
       if (Tile and fTerImp = tiIrrigation) or (Tile and fTerImp = tiFarm) or
         (Tile and fCity <> 0) then
         inc(Food, IrrEff); { irrigation effect }
+        Inc(Food, IrrEff); { irrigation effect }
       if Tile and fTerImp = tiMine then
         inc(Prod, MineEff); { mining effect }
       if (Tile and fRiver <> 0) and (RW[p].Tech[adMapMaking] >= tsApplicable)
+        Inc(Prod, MineEff); { mining effect }
+      if (Tile and fRiver <> 0) and (RW[P].Tech[adMapMaking] >= tsApplicable)
       then
         inc(Trade); { river effect }
+        Inc(Trade); { river effect }
       if (Tile and (fRoad or fRR) <> 0) and (MoveCost = 1) and
         (RW[p].Tech[adWheel] >= tsApplicable) then
         inc(Trade); { road effect }
+        (RW[P].Tech[adWheel] >= tsApplicable) then
+        Inc(Trade); { road effect }
       if (Tile and (fRR or fCity) <> 0) and
         (RW[p].Tech[adRailroad] >= tsApplicable) then
         inc(Prod, Prod shr 1); { railroad effect }
+        (RW[P].Tech[adRailroad] >= tsApplicable) then
+        Inc(Prod, Prod shr 1); { railroad effect }
       ExplCity := -1;
       if (cix >= 0) and (p = p0) then
+      if (cix >= 0) and (P = p0) then
         ExplCity := cix;
       if cix >= 0 then
 …
         begin
           if ((Tile and fTerImp = tiFarm) or (Tile and fCity <> 0)) and
             (RW[p].City[cix].Built[imSupermarket] > 0) then
             inc(Food, Food shr 1); { farmland effect }
+            (RW[P].City[cix].Built[imSupermarket] > 0) then
+            Inc(Food, Food shr 1); { farmland effect }
           if (Tile and (fRoad or fRR) <> 0) and (MoveCost = 1) and
             (RW[p].City[cix].Built[imHighways] > 0) then
             inc(Trade, 1); { superhighway effect }
+            (RW[P].City[cix].Built[imHighways] > 0) then
+            Inc(Trade, 1); { superhighway effect }
         end
         else
         begin
           if RW[p].City[cix].Built[imHarbor] > 0 then
             inc(Food); { harbour effect }
           if RW[p].City[cix].Built[imPlatform] > 0 then
             inc(Prod); { oil platform effect }
           if GWonder[woLighthouse].EffectiveOwner = p then
             inc(Prod);
+          if RW[P].City[cix].Built[imHarbor] > 0 then
+            Inc(Food); { harbour effect }
+          if RW[P].City[cix].Built[imPlatform] > 0 then
+            Inc(Prod); { oil platform effect }
+          if GWonder[woLighthouse].EffectiveOwner = P then
+            Inc(Prod);
         end;
     end;
     { good government influence }
     if (RW[p].Government in [gRepublic, gDemocracy, gFuture]) and (Trade > 0)
+    if (RW[P].Government in [gRepublic, gDemocracy, gFuture]) and (Trade > 0)
     then
       inc(Trade);
     if (RW[p].Government = gCommunism) and (Prod > 1) then
       inc(Prod);
     if RW[p].Government in [gAnarchy, gDespotism] then
+      Inc(Trade);
+    if (RW[P].Government = gCommunism) and (Prod > 1) then
+      Inc(Prod);
+    if RW[P].Government in [gAnarchy, gDespotism] then
     begin { bad government influence }
       if Food > 3 then
 …
     if Tile and (fTerrain or fPoll) > fPoll then
     begin { pollution - decrease ressources }
       dec(Food, Food shr 1);
       dec(Prod, Prod shr 1);
       dec(Trade, Trade shr 1);
+      Dec(Food, Food shr 1);
+      Dec(Prod, Prod shr 1);
+      Dec(Trade, Trade shr 1);
     end;
     if Tile and fCity <> 0 then
       Trade := 0
     else if (cix >= 0) and (RW[p].City[cix].Built[imCourt] + RW[p].City[cix]
+    else if (cix >= 0) and (RW[P].City[cix].Built[imCourt] + RW[P].City[cix]
       .Built[imPalace] = 0) then
       if RW[p].City[cix].Built[imTownHall] = 0 then
+      if RW[P].City[cix].Built[imTownHall] = 0 then
         Trade := 0
       else if Trade > 3 then
         Trade := 3;
   end;
   result := eOK;
 end; { GetTileInfo }
 procedure Strongest(Loc: integer; var uix, Strength, Bonus, Cnt: integer);
+  Result := eOK;
+end;
+procedure Strongest(Loc: Integer; var uix, Strength, Bonus, Cnt: Integer);
 { find strongest defender at Loc }
 var
   Defender, uix1, Det, Cost, TestStrength, TestBonus, TestDet, TestCost,
     Domain: integer;
+    Domain: Integer;
   PUn: ^TUn;
   PModel: ^TModel;
 …
     if PUn.Loc = Loc then
     begin
       inc(Cnt);
+      Inc(Cnt);
       if PUn.Master < 0 then
       begin
 …
           TestBonus := Terrain[RealMap[Loc] and fTerrain].Defense;
           if RealMap[Loc] and fTerImp = tiFort then
             inc(TestBonus, 4);
+            Inc(TestBonus, 4);
           if PUn.Flags and unFortified <> 0 then
             inc(TestBonus, 2);
+            Inc(TestBonus, 2);
           if (PModel.Kind = mkSpecial_TownGuard) and
             (RealMap[Loc] and fCity <> 0) then
             inc(TestBonus, 4);
+            Inc(TestBonus, 4);
         end
         else
           TestBonus := 4;
         inc(TestBonus, PUn.exp div ExpCost);
+        Inc(TestBonus, PUn.exp div ExpCost);
         TestStrength := PModel.Defense * TestBonus * PUn.Health;
         if (Domain = dAir) and ((RealMap[Loc] and fCity <> 0) or
 …
         if PModel.Cap[mcStealth] > 0 then
         else if PModel.Cap[mcSub] > 0 then
           inc(TestDet, 1 shl 28)
+          Inc(TestDet, 1 shl 28)
         else if (Domain = dGround) and (PModel.Cap[mcFanatic] > 0) and
           not(RW[Defender].Government in [gRepublic, gDemocracy, gFuture]) then
           inc(TestDet, 4 shl 28) // fanatic ground units always defend
+          Inc(TestDet, 4 shl 28) // fanatic ground units always defend
         else if PModel.Flags and mdZOC <> 0 then
           inc(TestDet, 3 shl 28)
+          Inc(TestDet, 3 shl 28)
         else
           inc(TestDet, 2 shl 28);
+          Inc(TestDet, 2 shl 28);
         TestCost := RW[Defender].Model[PUn.mix].Cost;
         if (TestDet > Det) or (TestDet = Det) and (TestCost < Cost) then
 …
 end;
 function UnitSpeed(p, mix, Health: integer): integer;
 begin
   with RW[p].Model[mix] do
   begin
     result := Speed;
+function UnitSpeed(P, mix, Health: Integer): Integer;
+begin
+  with RW[P].Model[mix] do
+  begin
+    Result := Speed;
     if Domain = dSea then
     begin
       if GWonder[woMagellan].EffectiveOwner = p then
         inc(result, 200);
+      if GWonder[woMagellan].EffectiveOwner = P then
+        Inc(Result, 200);
       if Health < 100 then
         result := ((result - 250) * Health div 5000) * 50 + 250;
     end
   end
 end;
 procedure GetUnitReport(p, uix: integer; var UnitReport: TUnitReport);
 var
   TerrOwner: integer;
+        Result := ((Result - 250) * Health div 5000) * 50 + 250;
+    end;
+  end;
+end;
+procedure GetUnitReport(P, uix: Integer; var UnitReport: TUnitReport);
+var
+  TerrOwner: Integer;
   PModel: ^TModel;
 begin
 …
   UnitReport.ProdSupport := 0;
   UnitReport.ReportFlags := 0;
   if RW[p].Government <> gAnarchy then
     with RW[p].Un[uix] do
     begin
       PModel := @RW[p].Model[mix];
+  if RW[P].Government <> gAnarchy then
+    with RW[P].Un[uix] do
+    begin
+      PModel := @RW[P].Model[mix];
       if (PModel.Kind = mkSettler)
       { and (GWonder[woFreeSettlers].EffectiveOwner<>p) } then
         UnitReport.FoodSupport := SettlerFood[RW[p].Government]
+        UnitReport.FoodSupport := SettlerFood[RW[P].Government]
       else if Flags and unConscripts <> 0 then
         UnitReport.FoodSupport := 1;
       if RW[p].Government <> gFundamentalism then
+      if RW[P].Government <> gFundamentalism then
       begin
         if GTestFlags and tfImmImprove = 0 then
 …
         begin
           TerrOwner := RealMap[Loc] shr 27;
           case RW[p].Government of
+          case RW[P].Government of
             gRepublic, gFuture:
               if (TerrOwner <> p) and (TerrOwner < nPl) and
                 (RW[p].Treaty[TerrOwner] < trAlliance) then
+              if (TerrOwner <> P) and (TerrOwner < nPl) and
+                (RW[P].Treaty[TerrOwner] < trAlliance) then
                 UnitReport.ReportFlags := UnitReport.ReportFlags or urfDeployed;
             gDemocracy:
               if (TerrOwner >= nPl) or (TerrOwner <> p) and
                 (RW[p].Treaty[TerrOwner] < trAlliance) then
+              if (TerrOwner >= nPl) or (TerrOwner <> P) and
+                (RW[P].Treaty[TerrOwner] < trAlliance) then
                 UnitReport.ReportFlags := UnitReport.ReportFlags or urfDeployed;
           end;
 …
 end;
 procedure SearchCity(Loc: integer; var p, cix: integer);
+procedure SearchCity(Loc: Integer; var P, cix: Integer);
 // set p to supposed owner before call
 var
   i: integer;
+  I: Integer;
 begin
   if RealMap[Loc] < nPl shl 27 then
     p := RealMap[Loc] shr 27;
   for i := 0 to nPl - 1 do
   begin
     if 1 shl p and GAlive <> 0 then
       with RW[p] do
+    P := RealMap[Loc] shr 27;
+  for I := 0 to nPl - 1 do
+  begin
+    if 1 shl P and GAlive <> 0 then
+      with RW[P] do
       begin
         cix := nCity - 1;
         while (cix >= 0) and (City[cix].Loc <> Loc) do
           dec(cix);
+          Dec(cix);
         if cix >= 0 then
           exit;
       end;
     assert(i < nPl - 1);
     p := (p + 1) mod nPl;
   end;
 end;
 procedure MakeCityInfo(p, cix: integer; var ci: TCityInfo);
 begin
   assert((p >= 0) and (p < nPl));
   assert((cix >= 0) and (cix < RW[p].nCity));
   with RW[p].City[cix] do
+          Exit;
+      end;
+    Assert(I < nPl - 1);
+    P := (P + 1) mod nPl;
+  end;
+end;
+procedure MakeCityInfo(P, cix: Integer; var ci: TCityInfo);
+begin
+  Assert((P >= 0) and (P < nPl));
+  Assert((cix >= 0) and (cix < RW[P].nCity));
+  with RW[P].City[cix] do
   begin
     ci.Loc := Loc;
     ci.ID := ID;
     ci.Owner := p;
+    ci.Owner := P;
     ci.Size := Size;
     ci.Flags := 0;
     if Built[imPalace] > 0 then
       inc(ci.Flags, ciCapital);
     if (Built[imWalls] > 0) or (Continent[Loc] = GrWallContinent[p]) then
       inc(ci.Flags, ciWalled);
+      Inc(ci.Flags, ciCapital);
+    if (Built[imWalls] > 0) or (Continent[Loc] = GrWallContinent[P]) then
+      Inc(ci.Flags, ciWalled);
     if Built[imCoastalFort] > 0 then
       inc(ci.Flags, ciCoastalFort);
+      Inc(ci.Flags, ciCoastalFort);
     if Built[imMissileBat] > 0 then
       inc(ci.Flags, ciMissileBat);
+      Inc(ci.Flags, ciMissileBat);
     if Built[imBunker] > 0 then
       inc(ci.Flags, ciBunker);
+      Inc(ci.Flags, ciBunker);
     if Built[imSpacePort] > 0 then
       inc(ci.Flags, ciSpacePort);
   end;
 end;
 procedure TellAboutModel(p, taOwner, tamix: integer);
 var
   i: integer;
 begin
   if (p = taOwner) or (Mode < moPlaying) then
     exit;
   i := 0;
   while (i < RW[p].nEnemyModel) and ((RW[p].EnemyModel[i].Owner <> taOwner) or
     (RW[p].EnemyModel[i].mix <> tamix)) do
     inc(i);
   if i = RW[p].nEnemyModel then
     IntServer(sIntTellAboutModel + p shl 4, taOwner, tamix, nil^);
 end;
 function emixSafe(p, taOwner, tamix: integer): integer;
 begin
   result := RWemix[p, taOwner, tamix];
   if result < 0 then
+      Inc(ci.Flags, ciSpacePort);
+  end;
+end;
+procedure TellAboutModel(P, taOwner, tamix: Integer);
+var
+  I: Integer;
+begin
+  if (P = taOwner) or (Mode < moPlaying) then
+    Exit;
+  I := 0;
+  while (I < RW[P].nEnemyModel) and ((RW[P].EnemyModel[I].Owner <> taOwner) or
+    (RW[P].EnemyModel[I].mix <> tamix)) do
+    Inc(I);
+  if I = RW[P].nEnemyModel then
+    IntServer(sIntTellAboutModel + P shl 4, taOwner, tamix, nil^);
+end;
+function emixSafe(P, taOwner, tamix: Integer): Integer;
+begin
+  Result := RWemix[P, taOwner, tamix];
+  if Result < 0 then
   begin // sIntTellAboutModel comes too late
     assert(Mode = moMovie);
     result := $FFFF;
   end;
 end;
 procedure IntroduceEnemy(p1, p2: integer);
+    Assert(Mode = moMovie);
+    Result := $FFFF;
+  end;
+end;
+procedure IntroduceEnemy(p1, p2: Integer);
 begin
   RW[p1].Treaty[p2] := trNone;
 …
 end;
 function DiscoverTile(Loc, p, pTell, Level: integer; EnableContact: boolean;
   euix: integer = -2): boolean;
+function DiscoverTile(Loc, P, pTell, Level: Integer; EnableContact: Boolean;
+  euix: Integer = -2): Boolean;
 // euix = -2: full discover
 // euix = -1: unit and city only, append units in EnemyUn
 // euix >= 0: unit and city only, replace EnemyUn[euix]
   procedure SetContact(p1, p2: integer);
+  procedure SetContact(p1, p2: Integer);
   begin
     if (Mode < moPlaying) or (p1 = p2) or (RW[p1].Treaty[p2] > trNoContact) then
       exit;
+      Exit;
     IntServer(sIntTellAboutNation, p1, p2, nil^);
     // NewContact[p1,p2]:=true
 …
 var
   i, uix, cix, TerrOwner, TerrOwnerTreaty, Strength, Bonus, Cnt, pFoundCity,
     cixFoundCity, MinLevel, Loc1, V8: integer;
+  I, uix, cix, TerrOwner, TerrOwnerTreaty, Strength, Bonus, Cnt, pFoundCity,
+    cixFoundCity, MinLevel, Loc1, V8: Integer;
   Tile, AddFlags: Cardinal;
   Adjacent: TVicinity8Loc;
 …
   mox: ^TModel;
 begin
   result := false;
+  Result := False;
   with RW[pTell] do
   begin
 …
         AddFlags := AddFlags or fGrWall;
       if (Mode = moPlaying) and ((Tile and (nPl shl 27) <> nPl shl 27) and
         (pTell = p)) then
+        (pTell = P)) then
       begin // set fPeace flag?
         TerrOwner := Tile shr 27;
 …
             (1 shl trPeace or 1 shl TrFriendlyContact) <> 0 then
             AddFlags := AddFlags or fPeace;
         end
+        end;
       end;
 …
           unx := @RW[Occupant[Loc]].Un[uix];
           mox := @RW[Occupant[Loc]].Model[unx.mix];
           assert((ZoCMap[Loc] <> 0) = (mox.Flags and mdZOC <> 0));
+          Assert((ZoCMap[Loc] <> 0) = (mox.Flags and mdZOC <> 0));
           if (mox.Cap[mcStealth] > 0) and (Tile and fCity = 0) and
             (Tile and fTerImp <> tiBase) then
 …
             begin
               uix := nEnemyUn;
               inc(nEnemyUn);
               assert(nEnemyUn < neumax);
+              Inc(nEnemyUn);
+              Assert(nEnemyUn < neumax);
             end;
             MakeUnitInfo(Occupant[Loc], unx^, EnemyUn[uix]);
             if Cnt > 1 then
               EnemyUn[uix].Flags := EnemyUn[uix].Flags or unMulti;
             if (mox.Flags and mdZOC <> 0) and (pTell = p) and
+            if (mox.Flags and mdZOC <> 0) and (pTell = P) and
               (Treaty[Occupant[Loc]] < trAlliance) then
             begin // set fInEnemyZoC flags of surrounding tiles
 …
                 if (Loc1 >= 0) and (Loc1 < MapSize) then
                   Map[Loc1] := Map[Loc1] or fInEnemyZoC
               end
+              end;
             end;
             if EnableContact and (mox.Domain = dGround) then
 …
             end;
             // Level:=lObserveSuper; // don't discover unit twice
             if (pTell = p) and
+            if (pTell = P) and
               ((Tile and fCity = 0) or (1 shl pTell and GAI <> 0)) then
               result := true;
+              Result := True;
           end
           else
 …
           while (cixFoundCity >= 0) and
             (RW[pFoundCity].City[cixFoundCity].Loc <> Loc) do
             dec(cixFoundCity);
           assert(cixFoundCity >= 0);
           i := 0;
           while (i < nEnemyCity) and (EnemyCity[i].Loc <> Loc) do
             inc(i);
           if i = nEnemyCity then
+            Dec(cixFoundCity);
+          Assert(cixFoundCity >= 0);
+          I := 0;
+          while (I < nEnemyCity) and (EnemyCity[I].Loc <> Loc) do
+            Inc(I);
+          if I = nEnemyCity then
           begin
             inc(nEnemyCity);
             assert(nEnemyCity < necmax);
             EnemyCity[i].Status := 0;
             EnemyCity[i].SavedStatus := 0;
             if pTell = p then
               result := true;
+            Inc(nEnemyCity);
+            Assert(nEnemyCity < necmax);
+            EnemyCity[I].Status := 0;
+            EnemyCity[I].SavedStatus := 0;
+            if pTell = P then
+              Result := True;
           end;
           MakeCityInfo(pFoundCity, cixFoundCity, EnemyCity[i]);
+          MakeCityInfo(pFoundCity, cixFoundCity, EnemyCity[I]);
         end;
       end
 …
     if Map[Loc] and fTerrain = fUNKNOWN then
       inc(Discovered[pTell]);
+      Inc(Discovered[pTell]);
     if euix >= -1 then
       Map[Loc] := Map[Loc] and not(fUnit or fCity or fOwned or fOwnZoCUnit) or
 …
       Cardinal(Level) shl (2 * pTell);
   end;
 end; // DiscoverTile
 function Discover9(Loc, p, Level: integer;
   TellAllied, EnableContact: boolean): boolean;
 var
   V9, Loc1, pTell, OldLevel: integer;
+end;
+function Discover9(Loc, P, Level: Integer;
+  TellAllied, EnableContact: Boolean): Boolean;
+var
+  V9, Loc1, pTell, OldLevel: Integer;
   Radius: TVicinity8Loc;
 begin
   assert((Mode > moLoading_Fast) or (RW[p].nEnemyUn = 0));
   result := false;
+  Assert((Mode > moLoading_Fast) or (RW[P].nEnemyUn = 0));
+  Result := False;
   V8_to_Loc(Loc, Radius);
   for V9 := 0 to 8 do
 …
       begin
         for pTell := 0 to nPl - 1 do
           if (pTell = p) or (1 shl pTell and GAlive <> 0) and
             (RW[p].Treaty[pTell] = trAlliance) then
+          if (pTell = P) or (1 shl pTell and GAlive <> 0) and
+            (RW[P].Treaty[pTell] = trAlliance) then
           begin
             OldLevel := ObserveLevel[Loc1] shr (2 * pTell) and 3;
             if Level > OldLevel then
               result := DiscoverTile(Loc1, p, pTell, Level, EnableContact)
                 or result;
+              Result := DiscoverTile(Loc1, P, pTell, Level, EnableContact)
+                or Result;
           end;
       end
       else
       begin
         OldLevel := ObserveLevel[Loc1] shr (2 * p) and 3;
+        OldLevel := ObserveLevel[Loc1] shr (2 * P) and 3;
         if Level > OldLevel then
           result := DiscoverTile(Loc1, p, p, Level, EnableContact) or result;
       end;
   end;
 end;
 function Discover21(Loc, p, AdjacentLevel: integer;
   TellAllied, EnableContact: boolean): boolean;
 var
   V21, Loc1, pTell, Level, OldLevel, AdjacentFlags: integer;
+          Result := DiscoverTile(Loc1, P, P, Level, EnableContact) or Result;
+      end;
+  end;
+end;
+function Discover21(Loc, P, AdjacentLevel: Integer;
+  TellAllied, EnableContact: Boolean): Boolean;
+var
+  V21, Loc1, pTell, Level, OldLevel, AdjacentFlags: Integer;
   Radius: TVicinity21Loc;
 begin
   assert((Mode > moLoading_Fast) or (RW[p].nEnemyUn = 0));
   result := false;
+  Assert((Mode > moLoading_Fast) or (RW[P].nEnemyUn = 0));
+  Result := False;
   AdjacentFlags := $00267620 shr 1;
   V21_to_Loc(Loc, Radius);
 …
       begin
         for pTell := 0 to nPl - 1 do
           if (pTell = p) or (1 shl pTell and GAlive <> 0) and
             (RW[p].Treaty[pTell] = trAlliance) then
+          if (pTell = P) or (1 shl pTell and GAlive <> 0) and
+            (RW[P].Treaty[pTell] = trAlliance) then
           begin
             OldLevel := ObserveLevel[Loc1] shr (2 * pTell) and 3;
             if Level > OldLevel then
               result := DiscoverTile(Loc1, p, pTell, Level, EnableContact)
                 or result;
+              Result := DiscoverTile(Loc1, P, pTell, Level, EnableContact)
+                or Result;
           end;
       end
       else
       begin
         OldLevel := ObserveLevel[Loc1] shr (2 * p) and 3;
+        OldLevel := ObserveLevel[Loc1] shr (2 * P) and 3;
         if Level > OldLevel then
           result := DiscoverTile(Loc1, p, p, Level, EnableContact) or result;
+          Result := DiscoverTile(Loc1, P, P, Level, EnableContact) or Result;
       end;
     end;
 …
 end;
 procedure DiscoverAll(p, Level: integer);
+procedure DiscoverAll(P, Level: Integer);
 { player p discovers complete playground (for supervisor) }
 var
   Loc, OldLevel: integer;
 begin
   assert((Mode > moLoading_Fast) or (RW[p].nEnemyUn = 0));
+  Loc, OldLevel: Integer;
+begin
+  Assert((Mode > moLoading_Fast) or (RW[P].nEnemyUn = 0));
   for Loc := 0 to MapSize - 1 do
   begin
     OldLevel := ObserveLevel[Loc] shr (2 * p) and 3;
+    OldLevel := ObserveLevel[Loc] shr (2 * P) and 3;
     if Level > OldLevel then
       DiscoverTile(Loc, p, p, Level, false);
   end;
 end;
 procedure DiscoverViewAreas(p: integer);
 var
   pTell, uix, cix, ecix, Loc, RealOwner: integer;
+      DiscoverTile(Loc, P, P, Level, False);
+  end;
+end;
+procedure DiscoverViewAreas(P: Integer);
+var
+  pTell, uix, cix, ecix, Loc, RealOwner: Integer;
   PModel: ^TModel;
 begin // discover unit and city view areas
   for pTell := 0 to nPl - 1 do
     if (pTell = p) or (RW[p].Treaty[pTell] = trAlliance) then
+    if (pTell = P) or (RW[P].Treaty[pTell] = trAlliance) then
     begin
       for uix := 0 to RW[pTell].nUn - 1 do
 …
             PModel := @RW[pTell].Model[mix];
             if (PModel.Kind = mkDiplomat) or (PModel.Cap[mcSpy] > 0) then
               Discover21(Loc, p, lObserveSuper, false, true)
+              Discover21(Loc, P, lObserveSuper, False, True)
             else if (PModel.Cap[mcRadar] + PModel.Cap[mcCarrier] > 0) or
               (PModel.Domain = dAir) then
               Discover21(Loc, p, lObserveAll, false, false)
+              Discover21(Loc, P, lObserveAll, False, False)
             else if (RealMap[Loc] and fTerrain = fMountains) or
               (RealMap[Loc] and fTerImp = tiFort) or
               (RealMap[Loc] and fTerImp = tiBase) or (PModel.Cap[mcAcademy] > 0)
             then
               Discover21(Loc, p, lObserveUnhidden, false,
+              Discover21(Loc, P, lObserveUnhidden, False,
                 PModel.Domain = dGround)
             else
               Discover9(Loc, p, lObserveUnhidden, false,
+              Discover9(Loc, P, lObserveUnhidden, False,
                 PModel.Domain = dGround);
           end;
       for cix := 0 to RW[pTell].nCity - 1 do
         if RW[pTell].City[cix].Loc >= 0 then
           Discover21(RW[pTell].City[cix].Loc, p, lObserveUnhidden, false, true);
+          Discover21(RW[pTell].City[cix].Loc, P, lObserveUnhidden, False, True);
       for ecix := 0 to RW[pTell].nEnemyCity - 1 do
       begin // players know territory, so no use in hiding city owner
 …
           begin
             RW[pTell].EnemyCity[ecix].Loc := -1;
             RW[pTell].Map[Loc] := RW[pTell].Map[Loc] and not fCity
+            RW[pTell].Map[Loc] := RW[pTell].Map[Loc] and not fCity;
           end;
         end;
 …
 end;
 function GetUnitStack(p, Loc: integer): integer;
 var
   uix: integer;
+function GetUnitStack(P, Loc: Integer): Integer;
+var
+  uix: Integer;
   unx: ^TUn;
 begin
   result := 0;
+  Result := 0;
   if Occupant[Loc] < 0 then
     exit;
+    Exit;
   for uix := 0 to RW[Occupant[Loc]].nUn - 1 do
   begin
 …
     if unx.Loc = Loc then
     begin
       MakeUnitInfo(Occupant[Loc], unx^, RW[p].EnemyUn[RW[p].nEnemyUn + result]);
       TellAboutModel(p, Occupant[Loc], unx.mix);
       RW[p].EnemyUn[RW[p].nEnemyUn + result].emix :=
         RWemix[p, Occupant[Loc], unx.mix];
       inc(result);
     end;
   end;
 end;
 procedure UpdateUnitMap(Loc: integer; CityChange: boolean = false);
+      MakeUnitInfo(Occupant[Loc], unx^, RW[P].EnemyUn[RW[P].nEnemyUn + Result]);
+      TellAboutModel(P, Occupant[Loc], unx.mix);
+      RW[P].EnemyUn[RW[P].nEnemyUn + Result].emix :=
+        RWemix[P, Occupant[Loc], unx.mix];
+      Inc(Result);
+    end;
+  end;
+end;
+procedure UpdateUnitMap(Loc: Integer; CityChange: Boolean = False);
 // update maps and enemy units of all players after unit change
 var
   p, euix, OldLevel: integer;
+  P, euix, OldLevel: Integer;
   AddFlags, ClearFlags: Cardinal;
 begin
   if (Mode = moLoading_Fast) and not CityChange then
     exit;
   for p := 0 to nPl - 1 do
     if 1 shl p and (GAlive or GWatching) <> 0 then
     begin
       OldLevel := ObserveLevel[Loc] shr (2 * p) and 3;
+    Exit;
+  for P := 0 to nPl - 1 do
+    if 1 shl P and (GAlive or GWatching) <> 0 then
+    begin
+      OldLevel := ObserveLevel[Loc] shr (2 * P) and 3;
       if OldLevel > lNoObserve then
       begin
         if RW[p].Map[Loc] and (fUnit or fOwned) = fUnit then
+        if RW[P].Map[Loc] and (fUnit or fOwned) = fUnit then
         begin
           // replace unit located here in EnemyUn
           // do not just set loc:=-1 because total number would be unlimited
           euix := RW[p].nEnemyUn - 1;
+          euix := RW[P].nEnemyUn - 1;
           while euix >= 0 do
           begin
             if RW[p].EnemyUn[euix].Loc = Loc then
+            if RW[P].EnemyUn[euix].Loc = Loc then
             begin
               RW[p].EnemyUn[euix].Loc := -1;
+              RW[P].EnemyUn[euix].Loc := -1;
               Break;
             end;
             dec(euix);
+            Dec(euix);
           end;
           RW[p].Map[Loc] := RW[p].Map[Loc] and not fUnit
+          RW[P].Map[Loc] := RW[P].Map[Loc] and not fUnit
         end
         else
         begin // look for empty slot in EnemyUn
           euix := RW[p].nEnemyUn - 1;
           while (euix >= 0) and (RW[p].EnemyUn[euix].Loc >= 0) do
             dec(euix);
+          euix := RW[P].nEnemyUn - 1;
+          while (euix >= 0) and (RW[P].EnemyUn[euix].Loc >= 0) do
+            Dec(euix);
         end;
         if (Occupant[Loc] < 0) and not CityChange then
 …
           if RealMap[Loc] and fCity = 0 then
             ClearFlags := ClearFlags or fOwned;
           RW[p].Map[Loc] := RW[p].Map[Loc] and not ClearFlags;
+          RW[P].Map[Loc] := RW[P].Map[Loc] and not ClearFlags;
         end
         else if (Occupant[Loc] <> p) or CityChange then
+        else if (Occupant[Loc] <> P) or CityChange then
         begin // city or enemy unit update necessary, call DiscoverTile
           ObserveLevel[Loc] := ObserveLevel[Loc] and not(3 shl (2 * p));
           DiscoverTile(Loc, p, p, OldLevel, false, euix);
+          ObserveLevel[Loc] := ObserveLevel[Loc] and not(3 shl (2 * P));
+          DiscoverTile(Loc, P, P, OldLevel, False, euix);
         end
         else { if (Occupant[Loc]=p) and not CityChange then }
 …
           else
             ClearFlags := ClearFlags or fOwnZoCUnit;
           RW[p].Map[Loc] := RW[p].Map[Loc] and not ClearFlags or AddFlags;
         end;
       end;
     end;
 end;
 procedure RecalcV8ZoC(p, Loc: integer);
+          RW[P].Map[Loc] := RW[P].Map[Loc] and not ClearFlags or AddFlags;
+        end;
+      end;
+    end;
+end;
+procedure RecalcV8ZoC(P, Loc: Integer);
 // recalculate fInEnemyZoC flags around single tile
 var
   V8, V8V8, Loc1, Loc2, p1, ObserveMask: integer;
+  V8, V8V8, Loc1, Loc2, p1, ObserveMask: Integer;
   Tile1: ^Cardinal;
   Adjacent, AdjacentAdjacent: TVicinity8Loc;
 begin
   if Mode = moLoading_Fast then
     exit;
   ObserveMask := 3 shl (2 * p);
+    Exit;
+  ObserveMask := 3 shl (2 * P);
   V8_to_Loc(Loc, Adjacent);
   for V8 := 0 to 7 do
 …
     if (Loc1 >= 0) and (Loc1 < MapSize) then
     begin
       Tile1 := @RW[p].Map[Loc1];
+      Tile1 := @RW[P].Map[Loc1];
       Tile1^ := Tile1^ and not fInEnemyZoC;
       V8_to_Loc(Loc1, AdjacentAdjacent);
 …
         begin
           p1 := Occupant[Loc2];
           assert(p1 <> nPl);
           if (p1 <> p) and (RW[p].Treaty[p1] < trAlliance) then
+          Assert(p1 <> nPl);
+          if (p1 <> P) and (RW[P].Treaty[p1] < trAlliance) then
           begin
             Tile1^ := Tile1^ or fInEnemyZoC;
             Break
+            Break;
           end;
         end;
 …
 end;
 procedure RecalcMapZoC(p: integer);
+procedure RecalcMapZoC(P: Integer);
 // recalculate fInEnemyZoC flags for the whole map
 var
   Loc, Loc1, V8, p1, ObserveMask: integer;
+  Loc, Loc1, V8, p1, ObserveMask: Integer;
   Adjacent: TVicinity8Loc;
 begin
   if Mode = moLoading_Fast then
     exit;
   MaskD(RW[p].Map^, MapSize, Cardinal(not Cardinal(fInEnemyZoC)));
   ObserveMask := 3 shl (2 * p);
+    Exit;
+  MaskD(RW[P].Map^, MapSize, Cardinal(not Cardinal(fInEnemyZoC)));
+  ObserveMask := 3 shl (2 * P);
   for Loc := 0 to MapSize - 1 do
     if (ZoCMap[Loc] > 0) and (ObserveLevel[Loc] and ObserveMask <> 0) then
     begin
       p1 := Occupant[Loc];
       assert(p1 <> nPl);
       if (p1 <> p) and (RW[p].Treaty[p1] < trAlliance) then
+      Assert(p1 <> nPl);
+      if (p1 <> P) and (RW[P].Treaty[p1] < trAlliance) then
       begin // this non-allied enemy ZoC unit is known to this player -- set flags!
         V8_to_Loc(Loc, Adjacent);
 …
           Loc1 := Adjacent[V8];
           if (Loc1 >= 0) and (Loc1 < MapSize) then
             RW[p].Map[Loc1] := RW[p].Map[Loc1] or fInEnemyZoC
         end;
       end;
     end;
 end;
 procedure RecalcPeaceMap(p: integer);
+            RW[P].Map[Loc1] := RW[P].Map[Loc1] or fInEnemyZoC;
+        end;
+      end;
+    end;
+end;
+procedure RecalcPeaceMap(P: Integer);
 // recalculate fPeace flags for the whole map
 var
   Loc, p1: integer;
   PeacePlayer: array [-1 .. nPl - 1] of boolean;
+  Loc, p1: Integer;
+  PeacePlayer: array [-1 .. nPl - 1] of Boolean;
 begin
   if Mode <> moPlaying then
     exit;
   MaskD(RW[p].Map^, MapSize, Cardinal(not Cardinal(fPeace)));
+    Exit;
+  MaskD(RW[P].Map^, MapSize, Cardinal(not Cardinal(fPeace)));
   for p1 := -1 to nPl - 1 do
     PeacePlayer[p1] := (p1 >= 0) and (p1 <> p) and (1 shl p1 and GAlive <> 0)
       and (RW[p].Treaty[p1] in [trPeace, TrFriendlyContact]);
+    PeacePlayer[p1] := (p1 >= 0) and (p1 <> P) and (1 shl p1 and GAlive <> 0)
+      and (RW[P].Treaty[p1] in [trPeace, TrFriendlyContact]);
   for Loc := 0 to MapSize - 1 do
     if PeacePlayer[RW[p].Territory[Loc]] then
       RW[p].Map[Loc] := RW[p].Map[Loc] or fPeace;
+    if PeacePlayer[RW[P].Territory[Loc]] then
+      RW[P].Map[Loc] := RW[P].Map[Loc] or fPeace;
 end;
 …
   BorderChanges: array [0 .. sIntExpandTerritory and $F - 1] of Cardinal;
 procedure ChangeTerritory(Loc, p: integer);
 var
   p1: integer;
 begin
   Assert(p >= 0); // no player's territory indicated by p=nPl
+procedure ChangeTerritory(Loc, P: Integer);
+var
+  p1: Integer;
+begin
+  Assert(P >= 0); // no player's territory indicated by p=nPl
   Dec(TerritoryCount[RealMap[Loc] shr 27]);
   Inc(TerritoryCount[p]);
   RealMap[Loc] := RealMap[Loc] and not($F shl 27) or Cardinal(p) shl 27;
   if p = $F then
     p := -1;
+  Inc(TerritoryCount[P]);
+  RealMap[Loc] := RealMap[Loc] and not($F shl 27) or Cardinal(P) shl 27;
+  if P = $F then
+    P := -1;
   for p1 := 0 to nPl - 1 do
     if 1 shl p1 and (GAlive or GWatching) <> 0 then
       if RW[p1].Map[Loc] and fTerrain <> fUNKNOWN then
       begin
         RW[p1].Territory[Loc] := p;
         if (p < nPl) and (p <> p1) and (1 shl p and GAlive <> 0) and
           (RW[p1].Treaty[p] in [trPeace, TrFriendlyContact]) then
+        RW[p1].Territory[Loc] := P;
+        if (P < nPl) and (P <> p1) and (1 shl P and GAlive <> 0) and
+          (RW[p1].Treaty[P] in [trPeace, TrFriendlyContact]) then
           RW[p1].Map[Loc] := RW[p1].Map[Loc] or fPeace
         else
 …
 end;
 procedure ExpandTerritory(OriginLoc: integer);
 var
   i, dx, dy, dxMax, dyMax, Loc, NewOwner: integer;
+procedure ExpandTerritory(OriginLoc: Integer);
+var
+  I, dx, dy, dxMax, dyMax, Loc, NewOwner: Integer;
 begin
   if OriginLoc = -1 then
     raise Exception.Create('Location error');
   i := 0;
+  I := 0;
   dyMax := 0;
   while (dyMax + 1) + (dyMax + 1) shr 1 <= CountryRadius do
     inc(dyMax);
+    Inc(dyMax);
   for dy := -dyMax to dyMax do
   begin
 …
     while abs(dy) + (dxMax + 2) + abs(abs(dy) - (dxMax + 2)) shr 1 <=
       CountryRadius do
       inc(dxMax, 2);
+      Inc(dxMax, 2);
     for dx := -dxMax to dxMax do
       if (dy + dx) and 1 = 0 then
       begin
         NewOwner := BorderChanges[i div 8] shr (i mod 8 * 4) and $F;
+        NewOwner := BorderChanges[I div 8] shr (I mod 8 * 4) and $F;
         Loc := dLoc(OriginLoc, dx, dy);
         if (Loc >= 0) and (Cardinal(NewOwner) <> RealMap[Loc] shr 27) then
           ChangeTerritory(Loc, NewOwner);
         inc(i);
       end;
   end;
 end;
 procedure CheckBorders(OriginLoc, PlayerLosingCity: integer);
+        Inc(I);
+      end;
+  end;
+end;
+procedure CheckBorders(OriginLoc, PlayerLosingCity: Integer);
 // OriginLoc: only changes in CountryRadius around this location possible,
 // -1 for complete map, -2 for double-check (no more changes allowed)
 …
 // player's territory, -1 for full border recalculation
 var
   i, r, Loc, Loc1, dx, dy, p1, p2, cix, NewDist, dxMax, dyMax, OldOwner, V8: Integer;
+  I, R, Loc, Loc1, dx, dy, p1, p2, cix, NewDist, dxMax, dyMax, OldOwner, V8: Integer;
   NewOwner: Cardinal;
   Adjacent: TVicinity8Loc;
   AtPeace: array [0 .. nPl, 0 .. nPl] of boolean;
+  AtPeace: array [0 .. nPl, 0 .. nPl] of Boolean;
   Country, FormerCountry, { to who's country a tile belongs }
   Dist, FormerDist, StolenDist: array [0 .. lxmax * lymax - 1] of ShortInt;
 …
         StolenDist[RW[PlayerLosingCity].City[cix].Loc] := 0;
     for r := 1 to CountryRadius shr 1 do
     begin
       move(StolenDist, FormerDist, MapSize);
+    for R := 1 to CountryRadius shr 1 do
+    begin
+      Move(StolenDist, FormerDist, MapSize);
       for Loc := 0 to MapSize - 1 do
         if (FormerDist[Loc] <= CountryRadius - 2)
 …
         end;
   for r := 1 to CountryRadius shr 1 do
   begin
     move(Country, FormerCountry, MapSize);
     move(Dist, FormerDist, MapSize);
+  for R := 1 to CountryRadius shr 1 do
+  begin
+    Move(Country, FormerCountry, MapSize);
+    Move(Dist, FormerDist, MapSize);
     for Loc := 0 to MapSize - 1 do
       if (FormerDist[Loc] <= CountryRadius - 2) // use same conditions as above!
 …
         (1 shl fShore + 1 shl fMountains + 1 shl fArctic) = 0) then
       begin
         assert(FormerCountry[Loc] >= 0);
+        Assert(FormerCountry[Loc] >= 0);
         V8_to_Loc(Loc, Adjacent);
         for V8 := 0 to 7 do
 …
   end;
   FillChar(AtPeace, SizeOf(AtPeace), false);
+  FillChar(AtPeace, SizeOf(AtPeace), False);
   for p1 := 0 to nPl - 1 do
     if 1 shl p1 and GAlive <> 0 then
 …
         if (p2 <> p1) and (1 shl p2 and GAlive <> 0) and
           (RW[p1].Treaty[p2] >= trPeace) then
           AtPeace[p1, p2] := true;
+          AtPeace[p1, p2] := True;
   if OriginLoc >= 0 then
   begin // update area only
     i := 0;
+    I := 0;
     FillChar(BorderChanges, SizeOf(BorderChanges), 0);
     dyMax := 0;
     while (dyMax + 1) + (dyMax + 1) shr 1 <= CountryRadius do
       inc(dyMax);
+      Inc(dyMax);
     for dy := -dyMax to dyMax do
     begin
 …
       while abs(dy) + (dxMax + 2) + abs(abs(dy) - (dxMax + 2)) shr 1 <=
         CountryRadius do
         inc(dxMax, 2);
+        Inc(dxMax, 2);
       for dx := -dxMax to dxMax do
         if (dy + dx) and 1 = 0 then
 …
               else
                 ChangeTerritory(Loc, NewOwner);
             BorderChanges[i shr 3] := BorderChanges[i shr 3] or
               ((NewOwner shl ((i and 7) * 4)) and $ffffffff);
+            BorderChanges[I shr 3] := BorderChanges[I shr 3] or
+              ((NewOwner shl ((I and 7) * 4)) and $ffffffff);
           end;
           inc(i);
+          Inc(I);
         end;
     end;
 …
       then
       begin
         assert(OriginLoc <> -2); // test if border saving works
+        Assert(OriginLoc <> -2); // test if border saving works
         ChangeTerritory(Loc, NewOwner);
       end;
 …
 {$IFOPT O-} if OriginLoc <> -2 then
     CheckBorders(-2); {$ENDIF} // check: single pass should do!
 end; // CheckBorders
 procedure LogCheckBorders(p, cix, PlayerLosingCity: integer);
 begin
   CheckBorders(RW[p].City[cix].Loc, PlayerLosingCity);
   IntServer(sIntExpandTerritory, p, cix, BorderChanges);
+end;
+procedure LogCheckBorders(P, cix, PlayerLosingCity: Integer);
+begin
+  CheckBorders(RW[P].City[cix].Loc, PlayerLosingCity);
+  IntServer(sIntExpandTerritory, P, cix, BorderChanges);
 end;
 …
+}
 procedure CreateUnit(p, mix: integer);
 begin
   with RW[p] do
+procedure CreateUnit(P, mix: Integer);
+begin
+  with RW[P] do
   begin
     Un[nUn].mix := mix;
     with Un[nUn] do
     begin
       ID := UnBuilt[p];
       inc(UnBuilt[p]);
+      ID := UnBuilt[P];
+      Inc(UnBuilt[P]);
       Status := 0;
       SavedStatus := 0;
       inc(Model[mix].Built);
+      Inc(Model[mix].Built);
       Home := -1;
       Health := 100;
 …
       begin
         Fuel := Model[mix].Cap[mcFuel];
         Flags := Flags or unBombsLoaded
+        Flags := Flags or unBombsLoaded;
       end;
       Job := jNone;
 …
       Master := -1;
     end;
     inc(nUn);
+    Inc(nUn);
   end
 end;
 procedure FreeUnit(p, uix: integer);
+procedure FreeUnit(P, uix: Integer);
 // loc or master should be set after call
 // implementation is critical for loading performance, change carefully
 var
   Loc0, uix1: integer;
   Occ, ZoC: boolean;
 begin
   with RW[p].Un[uix] do
+  Loc0, uix1: Integer;
+  Occ, ZoC: Boolean;
+begin
+  with RW[P].Un[uix] do
   begin
     Job := jNone;
     Flags := Flags and not(unFortified or unMountainDelay);
     Loc0 := Loc
+    Loc0 := Loc;
   end;
   if Occupant[Loc0] >= 0 then
   begin
     assert(Occupant[Loc0] = p);
     Occ := false;
     ZoC := false;
     for uix1 := 0 to RW[p].nUn - 1 do
       with RW[p].Un[uix1] do
+    Assert(Occupant[Loc0] = P);
+    Occ := False;
+    ZoC := False;
+    for uix1 := 0 to RW[P].nUn - 1 do
+      with RW[P].Un[uix1] do
         if (Loc = Loc0) and (Master < 0) and (uix1 <> uix) then
         begin
           Occ := true;
           if RW[p].Model[mix].Flags and mdZOC <> 0 then
+          Occ := True;
+          if RW[P].Model[mix].Flags and mdZOC <> 0 then
           begin
             ZoC := true;
             Break
           end
+            ZoC := True;
+            Break;
+          end;
         end;
     if not Occ then
 …
 end;
 procedure PlaceUnit(p, uix: integer);
 begin
   with RW[p].Un[uix] do
   begin
     Occupant[Loc] := p;
     if RW[p].Model[mix].Flags and mdZOC <> 0 then
+procedure PlaceUnit(P, uix: Integer);
+begin
+  with RW[P].Un[uix] do
+  begin
+    Occupant[Loc] := P;
+    if RW[P].Model[mix].Flags and mdZOC <> 0 then
       ZoCMap[Loc] := 1;
   end;
 end;
 procedure CountLost(p, mix, Enemy: integer);
 begin
   Inc(RW[p].Model[mix].Lost);
   TellAboutModel(Enemy, p, mix);
   Inc(Destroyed[Enemy, p, mix]);
 end;
 procedure RemoveUnit(p, uix: integer; Enemy: integer = -1);
+procedure CountLost(P, mix, Enemy: Integer);
+begin
+  Inc(RW[P].Model[mix].Lost);
+  TellAboutModel(Enemy, P, mix);
+  Inc(Destroyed[Enemy, P, mix]);
+end;
+procedure RemoveUnit(P, uix: Integer; Enemy: Integer = -1);
 // use enemy only from inside sMoveUnit if attack
 var
   uix1: integer;
 begin
   with RW[p].Un[uix] do
   begin
     assert((Loc >= 0) or (RW[p].Model[mix].Kind = mkDiplomat));
+  uix1: Integer;
+begin
+  with RW[P].Un[uix] do
+  begin
+    Assert((Loc >= 0) or (RW[P].Model[mix].Kind = mkDiplomat));
     // already freed when spy mission
     if Loc >= 0 then
       FreeUnit(p, uix);
+      FreeUnit(P, uix);
     if Master >= 0 then
       if RW[p].Model[mix].Domain = dAir then
         dec(RW[p].Un[Master].AirLoad)
+      if RW[P].Model[mix].Domain = dAir then
+        Dec(RW[P].Un[Master].AirLoad)
       else
         dec(RW[p].Un[Master].TroopLoad);
+        Dec(RW[P].Un[Master].TroopLoad);
     if (TroopLoad > 0) or (AirLoad > 0) then
       for uix1 := 0 to RW[p].nUn - 1 do
         if (RW[p].Un[uix1].Loc >= 0) and (RW[p].Un[uix1].Master = uix) then
+      for uix1 := 0 to RW[P].nUn - 1 do
+        if (RW[P].Un[uix1].Loc >= 0) and (RW[P].Un[uix1].Master = uix) then
         { unit mastered by removed unit -- remove too }
         begin
           RW[p].Un[uix1].Loc := -1;
+          RW[P].Un[uix1].Loc := -1;
           if Enemy >= 0 then
             CountLost(p, RW[p].Un[uix1].mix, Enemy);
+            CountLost(P, RW[P].Un[uix1].mix, Enemy);
         end;
     Loc := -1;
     if Enemy >= 0 then
       CountLost(p, mix, Enemy);
   end;
 end;
 procedure RemoveUnit_UpdateMap(p, uix: integer);
+      CountLost(P, mix, Enemy);
+  end;
+end;
+procedure RemoveUnit_UpdateMap(P, uix: Integer);
 var
   Loc0: Integer;
 begin
   Loc0 := RW[p].Un[uix].Loc;
   RemoveUnit(p, uix);
+  Loc0 := RW[P].Un[uix].Loc;
+  RemoveUnit(P, uix);
   if Mode > moLoading_Fast then
     UpdateUnitMap(Loc0);
 end;
 procedure RemoveAllUnits(p, Loc: integer; Enemy: integer = -1);
 var
   uix: integer;
 begin
   for uix := 0 to RW[p].nUn - 1 do
     if RW[p].Un[uix].Loc = Loc then
+procedure RemoveAllUnits(P, Loc: Integer; Enemy: Integer = -1);
+var
+  uix: Integer;
+begin
+  for uix := 0 to RW[P].nUn - 1 do
+    if RW[P].Un[uix].Loc = Loc then
     begin
       if Enemy >= 0 then
         CountLost(p, RW[p].Un[uix].mix, Enemy);
       RW[p].Un[uix].Loc := -1
+        CountLost(P, RW[P].Un[uix].mix, Enemy);
+      RW[P].Un[uix].Loc := -1;
     end;
   Occupant[Loc] := -1;
 …
 end;
 procedure RemoveDomainUnits(d, p, Loc: integer);
 var
   uix: integer;
 begin
   for uix := 0 to RW[p].nUn - 1 do
     if (RW[p].Model[RW[p].Un[uix].mix].Domain = d) and (RW[p].Un[uix].Loc = Loc)
+procedure RemoveDomainUnits(D, P, Loc: Integer);
+var
+  uix: Integer;
+begin
+  for uix := 0 to RW[P].nUn - 1 do
+    if (RW[P].Model[RW[P].Un[uix].mix].Domain = D) and (RW[P].Un[uix].Loc = Loc)
     then
       RemoveUnit(p, uix);
 end;
 procedure FoundCity(p, FoundLoc: integer);
 var
   p1, cix1, V21, dx, dy: integer;
 begin
   if RW[p].nCity = ncmax then
     exit;
   inc(RW[p].nCity);
   with RW[p].City[RW[p].nCity - 1] do
+      RemoveUnit(P, uix);
+end;
+procedure FoundCity(P, FoundLoc: Integer);
+var
+  p1, cix1, V21, dx, dy: Integer;
+begin
+  if RW[P].nCity = ncmax then
+    Exit;
+  Inc(RW[P].nCity);
+  with RW[P].City[RW[P].nCity - 1] do
   begin
     Size := 2;
 …
     if UsedByCity[FoundLoc] >= 0 then
     begin { central tile is exploited - toggle in exploiting city }
       p1 := p;
+      p1 := P;
       SearchCity(UsedByCity[FoundLoc], p1, cix1);
       dxdy(UsedByCity[FoundLoc], FoundLoc, dx, dy);
 …
       (fTerrain or fSpecial or fRiver or nPl shl 27) or fCity;
     ChangeTerritory(Loc, p)
   end;
 end;
 procedure StealCity(p, cix: integer; SaveUnits: boolean);
 var
   i, j, uix1, cix1, nearest: integer;
 begin
   for i := 0 to nWonder - 1 do
     if RW[p].City[cix].Built[i] = 1 then
     begin
       GWonder[i].EffectiveOwner := -1;
       if i = woPyramids then
+    ChangeTerritory(Loc, P);
+  end;
+end;
+procedure StealCity(P, cix: Integer; SaveUnits: Boolean);
+var
+  I, J, uix1, cix1, nearest: Integer;
+begin
+  for I := 0 to nWonder - 1 do
+    if RW[P].City[cix].Built[I] = 1 then
+    begin
+      GWonder[I].EffectiveOwner := -1;
+      if I = woPyramids then
         FreeSlaves;
       if i = woEiffel then // deactivate expired wonders
         for j := 0 to nWonder - 1 do
           if GWonder[j].EffectiveOwner = p then
             CheckExpiration(j);
     end;
   for i := nWonder to nImp - 1 do
     if (Imp[i].Kind <> ikCommon) and (RW[p].City[cix].Built[i] > 0) then
+      if I = woEiffel then // deactivate expired wonders
+        for J := 0 to nWonder - 1 do
+          if GWonder[J].EffectiveOwner = P then
+            CheckExpiration(J);
+    end;
+  for I := nWonder to nImp - 1 do
+    if (Imp[I].Kind <> ikCommon) and (RW[P].City[cix].Built[I] > 0) then
     begin { destroy national projects }
       RW[p].NatBuilt[i] := 0;
       if i = imGrWall then
         GrWallContinent[p] := -1;
     end;
   for uix1 := 0 to RW[p].nUn - 1 do
     with RW[p].Un[uix1] do
+      RW[P].NatBuilt[I] := 0;
+      if I = imGrWall then
+        GrWallContinent[P] := -1;
+    end;
+  for uix1 := 0 to RW[P].nUn - 1 do
+    with RW[P].Un[uix1] do
       if (Loc >= 0) and (Home = cix) then
         if SaveUnits then
         begin // support units by nearest other city
           nearest := -1;
           for cix1 := 0 to RW[p].nCity - 1 do
             if (cix1 <> cix) and (RW[p].City[cix1].Loc >= 0) and
               ((nearest < 0) or (Distance(RW[p].City[cix1].Loc, Loc) <
               Distance(RW[p].City[nearest].Loc, Loc))) then
+          for cix1 := 0 to RW[P].nCity - 1 do
+            if (cix1 <> cix) and (RW[P].City[cix1].Loc >= 0) and
+              ((nearest < 0) or (Distance(RW[P].City[cix1].Loc, Loc) <
+              Distance(RW[P].City[nearest].Loc, Loc))) then
               nearest := cix1;
           Home := nearest
+          Home := nearest;
         end
         else
           RemoveUnit(p, uix1); // destroy supported units
 end;
 procedure DestroyCity(p, cix: integer; SaveUnits: boolean);
 var
   i, V21: integer;
+          RemoveUnit(P, uix1); // destroy supported units
+end;
+procedure DestroyCity(P, cix: Integer; SaveUnits: Boolean);
+var
+  I, V21: Integer;
   Radius: TVicinity21Loc;
 begin
   StealCity(p, cix, SaveUnits);
   with RW[p].City[cix] do begin
     for i := 0 to nWonder - 1 do
       if Built[i] > 0 then
         GWonder[i].CityID := WonderDestroyed;
+  StealCity(P, cix, SaveUnits);
+  with RW[P].City[cix] do begin
+    for I := 0 to nWonder - 1 do
+      if Built[I] > 0 then
+        GWonder[I].CityID := WonderDestroyed;
     V21_to_Loc(Loc, Radius);
     for V21 := 1 to 26 do
 …
         UsedByCity[Radius[V21]] := -1;
     RealMap[Loc] := RealMap[Loc] and not fCity;
     Loc := -1
   end;
 end;
 procedure ChangeCityOwner(pOld, cixOld, pNew: integer);
 var
   i, j, cix1, Loc1, V21: integer;
+    Loc := -1;
+  end;
+end;
+procedure ChangeCityOwner(pOld, cixOld, pNew: Integer);
+var
+  I, J, cix1, Loc1, V21: Integer;
   Radius: TVicinity21Loc;
 begin
   inc(RW[pNew].nCity);
+  Inc(RW[pNew].nCity);
   RW[pNew].City[RW[pNew].nCity - 1] := RW[pOld].City[cixOld];
   StealCity(pOld, cixOld, false);
+  StealCity(pOld, cixOld, False);
   RW[pOld].City[cixOld].Loc := -1;
   with RW[pNew].City[(RW[pNew].nCity - 1)] do
 …
       begin
         Loc1 := Radius[V21];
         assert((Loc1 >= 0) and (Loc1 < MapSize) and (UsedByCity[Loc1] = Loc));
+        Assert((Loc1 >= 0) and (Loc1 < MapSize) and (UsedByCity[Loc1] = Loc));
         if (ZoCMap[Loc1] > 0) and (Occupant[Loc1] <> pNew) and
           (RW[pNew].Treaty[Occupant[Loc1]] < trAlliance) then
 …
     Built[imTownHall] := 0;
     Built[imCourt] := 0;
     for i := nWonder to nImp - 1 do
       if Imp[i].Kind <> ikCommon then
         Built[i] := 0; { destroy national projects }
     for i := 0 to nWonder - 1 do
       if Built[i] = 1 then
+    for I := nWonder to nImp - 1 do
+      if Imp[I].Kind <> ikCommon then
+        Built[I] := 0; { destroy national projects }
+    for I := 0 to nWonder - 1 do
+      if Built[I] = 1 then
       begin // new wonder owner!
         GWonder[i].EffectiveOwner := pNew;
         if i = woEiffel then // reactivate expired wonders
         begin
           for j := 0 to nWonder - 1 do
             if Imp[j].Expiration >= 0 then
+        GWonder[I].EffectiveOwner := pNew;
+        if I = woEiffel then // reactivate expired wonders
+        begin
+          for J := 0 to nWonder - 1 do
+            if Imp[J].Expiration >= 0 then
               for cix1 := 0 to (RW[pNew].nCity - 1) do
                 if RW[pNew].City[cix1].Built[j] = 1 then
                   GWonder[j].EffectiveOwner := pNew;
+                if RW[pNew].City[cix1].Built[J] = 1 then
+                  GWonder[J].EffectiveOwner := pNew;
         end
         else
           CheckExpiration(i);
         case i of
+          CheckExpiration(I);
+        case I of
           woLighthouse:
             CheckSpecialModels(pNew, preLighthouse);
 …
     cix1 := RW[pNew].nEnemyCity - 1;
     while (cix1 >= 0) and (RW[pNew].EnemyCity[cix1].Loc <> Loc) do
       dec(cix1);
     assert(cix1 >= 0);
+      Dec(cix1);
+    Assert(cix1 >= 0);
     RW[pNew].EnemyCity[cix1].Loc := -1;
 …
 end;
 procedure CompleteJob(p, Loc, Job: integer);
 var
   ChangedTerrain, p1: integer;
 begin
   assert(Job <> jCity);
+procedure CompleteJob(P, Loc, Job: Integer);
+var
+  ChangedTerrain, p1: Integer;
+begin
+  Assert(Job <> jCity);
   ChangedTerrain := -1;
   case Job of
 …
         if not(RealMap[Loc] and fTerrain in TerrType_Canalable) then
         begin
           RemoveDomainUnits(dSea, p, Loc);
+          RemoveDomainUnits(dSea, P, Loc);
           RealMap[Loc] := RealMap[Loc] and not fCanal;
         end;
 …
       begin
         if RealMap[Loc] and fTerImp = tiBase then
           RemoveDomainUnits(dAir, p, Loc);
+          RemoveDomainUnits(dAir, P, Loc);
         RealMap[Loc] := RealMap[Loc] and not fTerImp
       end
       else if RealMap[Loc] and fCanal <> 0 then
       begin
         RemoveDomainUnits(dSea, p, Loc);
+        RemoveDomainUnits(dSea, P, Loc);
         RealMap[Loc] := RealMap[Loc] and not fCanal
       end
 …
           fPoll) or RealMap[Loc] and (fTerrain or fSpecial or fTerImp or
           fRoad or fRR or fCanal or fPoll);
 end; // CompleteJob
+end;
+{
 …
   ____________________________________________________________________
+}
 procedure GiveCivilReport(p, pAbout: integer);
 begin
   with RW[p].EnemyReport[pAbout]^ do
+procedure GiveCivilReport(P, pAbout: Integer);
+begin
+  with RW[P].EnemyReport[pAbout]^ do
   begin
     // general info
     TurnOfCivilReport := LastValidStat[pAbout];
     move(RW[pAbout].Treaty, Treaty, SizeOf(Treaty));
+    Move(RW[pAbout].Treaty, Treaty, SizeOf(Treaty));
     Government := RW[pAbout].Government;
     Money := RW[pAbout].Money;
 …
     if ResearchDone > 100 then
       ResearchDone := 100;
     move(RW[pAbout].Tech, Tech, nAdv);
   end;
 end;
 procedure GiveMilReport(p, pAbout: integer);
 var
   uix, mix: integer;
 begin
   with RW[p].EnemyReport[pAbout]^ do
+    Move(RW[pAbout].Tech, Tech, nAdv);
+  end;
+end;
+procedure GiveMilReport(P, pAbout: Integer);
+var
+  uix, mix: Integer;
+begin
+  with RW[P].EnemyReport[pAbout]^ do
   begin
     TurnOfMilReport := LastValidStat[pAbout];
 …
     for mix := 0 to RW[pAbout].nModel - 1 do
     begin
       TellAboutModel(p, pAbout, mix);
+      TellAboutModel(P, pAbout, mix);
       UnCount[mix] := 0
     end;
     for uix := 0 to RW[pAbout].nUn - 1 do
       if RW[pAbout].Un[uix].Loc >= 0 then
         inc(UnCount[RW[pAbout].Un[uix].mix]);
   end;
 end;
 procedure ShowPrice(pSender, pTarget, Price: integer);
+        Inc(UnCount[RW[pAbout].Un[uix].mix]);
+  end;
+end;
+procedure ShowPrice(pSender, pTarget, Price: Integer);
 begin
   case Price and opMask of
 …
 end;
 function CopyCivilReport(pSender, pTarget, pAbout: integer): boolean;
 var
   i: integer;
+function CopyCivilReport(pSender, pTarget, pAbout: Integer): Boolean;
+var
+  I: Integer;
   rSender, rTarget: ^TEnemyReport;
 begin // copy third nation civil report
   result := false;
+  Result := False;
   if RW[pTarget].Treaty[pAbout] = trNoContact then
     IntroduceEnemy(pTarget, pAbout);
   rSender := pointer(RW[pSender].EnemyReport[pAbout]);
   rTarget := pointer(RW[pTarget].EnemyReport[pAbout]);
+  rSender := Pointer(RW[pSender].EnemyReport[pAbout]);
+  rTarget := Pointer(RW[pTarget].EnemyReport[pAbout]);
   if rSender.TurnOfCivilReport > rTarget.TurnOfCivilReport then
   begin // only if newer than current information
 …
     rTarget.ResearchTech := rSender.ResearchTech;
     rTarget.ResearchDone := rSender.ResearchDone;
     result := true;
   end;
   for i := 0 to nAdv - 1 do
     if rTarget.Tech[i] < rSender.Tech[i] then
     begin
       rTarget.Tech[i] := rSender.Tech[i];
       result := true;
     end;
 end;
 function CopyMilReport(pSender, pTarget, pAbout: integer): boolean;
 var
   mix: integer;
+    Result := True;
+  end;
+  for I := 0 to nAdv - 1 do
+    if rTarget.Tech[I] < rSender.Tech[I] then
+    begin
+      rTarget.Tech[I] := rSender.Tech[I];
+      Result := True;
+    end;
+end;
+function CopyMilReport(pSender, pTarget, pAbout: Integer): Boolean;
+var
+  mix: Integer;
   rSender, rTarget: ^TEnemyReport;
 begin // copy third nation military report
   result := false;
+  Result := False;
   if RW[pTarget].Treaty[pAbout] = trNoContact then
     IntroduceEnemy(pTarget, pAbout);
   rSender := pointer(RW[pSender].EnemyReport[pAbout]);
   rTarget := pointer(RW[pTarget].EnemyReport[pAbout]);
+  rSender := Pointer(RW[pSender].EnemyReport[pAbout]);
+  rTarget := Pointer(RW[pTarget].EnemyReport[pAbout]);
   if rSender.TurnOfMilReport > rTarget.TurnOfMilReport then
   begin // only if newer than current information
     rTarget.TurnOfMilReport := rSender.TurnOfMilReport;
     rTarget.nModelCounted := rSender.nModelCounted;
     move(rSender.UnCount, rTarget.UnCount, 2 * rSender.nModelCounted);
+    Move(rSender.UnCount, rTarget.UnCount, 2 * rSender.nModelCounted);
     for mix := 0 to rTarget.nModelCounted - 1 do
       TellAboutModel(pTarget, pAbout, mix);
     result := true;
   end;
 end;
 procedure CopyModel(pSender, pTarget, mix: integer);
 var
   i: integer;
+    Result := True;
+  end;
+end;
+procedure CopyModel(pSender, pTarget, mix: Integer);
+var
+  I: Integer;
   miSender, miTarget: TModelInfo;
   ok: boolean;
+  ok: Boolean;
 begin
   // only if target doesn't already have a model like this
   ok := RW[pTarget].nModel < nmmax;
   MakeModelInfo(pSender, mix, RW[pSender].Model[mix], miSender);
   for i := 0 to RW[pTarget].nModel - 1 do
   begin
     MakeModelInfo(pTarget, i, RW[pTarget].Model[i], miTarget);
+  for I := 0 to RW[pTarget].nModel - 1 do
+  begin
+    MakeModelInfo(pTarget, I, RW[pTarget].Model[I], miTarget);
     if IsSameModel(miSender, miTarget) then
       ok := false;
+      ok := False;
   end;
   if ok then
 …
       Lost := 0;
     end;
     inc(RW[pTarget].nModel);
     inc(Researched[pTarget]);
+    Inc(RW[pTarget].nModel);
+    Inc(Researched[pTarget]);
     TellAboutModel(pSender, pTarget, RW[pTarget].nModel - 1);
   end;
 end;
 procedure CopyMap(pSender, pTarget: integer);
 var
   Loc, i, cix: integer;
+procedure CopyMap(pSender, pTarget: Integer);
+var
+  Loc, I, cix: Integer;
   Tile: Cardinal;
 begin
 …
       if Tile and fCity <> 0 then
       begin
         i := 0;
         while (i < RW[pTarget].nEnemyCity) and
           (RW[pTarget].EnemyCity[i].Loc <> Loc) do
           inc(i);
         if i = RW[pTarget].nEnemyCity then
         begin
           inc(RW[pTarget].nEnemyCity);
           assert(RW[pTarget].nEnemyCity < necmax);
           RW[pTarget].EnemyCity[i].Status := 0;
           RW[pTarget].EnemyCity[i].SavedStatus := 0;
+        I := 0;
+        while (I < RW[pTarget].nEnemyCity) and
+          (RW[pTarget].EnemyCity[I].Loc <> Loc) do
+          Inc(I);
+        if I = RW[pTarget].nEnemyCity then
+        begin
+          Inc(RW[pTarget].nEnemyCity);
+          Assert(RW[pTarget].nEnemyCity < necmax);
+          RW[pTarget].EnemyCity[I].Status := 0;
+          RW[pTarget].EnemyCity[I].SavedStatus := 0;
         end;
         if Tile and fOwned <> 0 then
 …
           cix := RW[pSender].nCity - 1;
           while (cix >= 0) and (RW[pSender].City[cix].Loc <> Loc) do
             dec(cix);
           MakeCityInfo(pSender, cix, RW[pTarget].EnemyCity[i]);
+            Dec(cix);
+          MakeCityInfo(pSender, cix, RW[pTarget].EnemyCity[I]);
         end
         else // city not owned by sender -- copy old info
 …
           cix := RW[pSender].nEnemyCity - 1;
           while (cix >= 0) and (RW[pSender].EnemyCity[cix].Loc <> Loc) do
             dec(cix);
           RW[pTarget].EnemyCity[i] := RW[pSender].EnemyCity[cix];
+            Dec(cix);
+          RW[pTarget].EnemyCity[I] := RW[pSender].EnemyCity[cix];
         end;
       end
 …
       if RW[pTarget].Map[Loc] and fTerrain = fUNKNOWN then
         inc(Discovered[pTarget]);
+        Inc(Discovered[pTarget]);
       RW[pTarget].Map[Loc] := RW[pTarget].Map[Loc] and fInEnemyZoC
       // always preserve this flag!
 …
 end;
 function PayPrice(pSender, pTarget, Price: integer; execute: boolean): boolean;
 var
   pSubject, i, n, NewTreaty: integer;
 begin
   result := true;
+function PayPrice(pSender, pTarget, Price: Integer; execute: Boolean): Boolean;
+var
+  pSubject, I, N, NewTreaty: Integer;
+begin
+  Result := True;
   case Price and opMask of
     opCivilReport: // + turn + concerned player shl 16
 …
         pSubject := Price shr 16 and $F;
         if pTarget = pSubject then
           result := false
+          Result := False
         else if pSender = pSubject then
         begin
           if execute then
             GiveCivilReport(pTarget, pSender)
+            GiveCivilReport(pTarget, pSender);
         end
         else if RW[pSender].EnemyReport[pSubject].TurnOfCivilReport < 0 then
           result := false
+          Result := False
         else if execute then
           CopyCivilReport(pSender, pTarget, pSubject);
 …
         pSubject := Price shr 16 and $F;
         if pTarget = pSubject then
           result := false
+          Result := False
         else if pSender = pSubject then
         begin
           if execute then
             GiveMilReport(pTarget, pSender)
+            GiveMilReport(pTarget, pSender);
         end
         else if RW[pSender].EnemyReport[pSubject].TurnOfMilReport < 0 then
           result := false
+          Result := False
         else if execute then
           CopyMilReport(pSender, pTarget, pSubject)
+          CopyMilReport(pSender, pTarget, pSubject);
       end;
     opMap:
 …
         begin // agreed treaty end
           if execute then
             CancelTreaty(pSender, pTarget, false)
+            CancelTreaty(pSender, pTarget, False);
         end
         else
 …
             NewTreaty := trPeace;
           if NewTreaty < 0 then
             result := false
+            Result := False
           else if execute then
           begin
             assert(NewTreaty > RW[pSender].Treaty[pTarget]);
+            Assert(NewTreaty > RW[pSender].Treaty[pTarget]);
             RW[pSender].Treaty[pTarget] := NewTreaty;
             RW[pTarget].Treaty[pSender] := NewTreaty;
 …
     opShipParts: // + number + part type shl 16
       begin
         n := Price and $FFFF; // number
         i := Price shr 16 and $F; // type
         if (i < nShipPart) and (GShip[pSender].Parts[i] >= n) then
+        N := Price and $FFFF; // number
+        I := Price shr 16 and $F; // type
+        if (I < nShipPart) and (GShip[pSender].Parts[I] >= N) then
         begin
           if execute then
           begin
             dec(GShip[pSender].Parts[i], n);
             RW[pSender].Ship[pSender].Parts[i] := GShip[pSender].Parts[i];
             RW[pTarget].Ship[pSender].Parts[i] := GShip[pSender].Parts[i];
+            Dec(GShip[pSender].Parts[I], N);
+            RW[pSender].Ship[pSender].Parts[I] := GShip[pSender].Parts[I];
+            RW[pTarget].Ship[pSender].Parts[I] := GShip[pSender].Parts[I];
             if RW[pTarget].NatBuilt[imSpacePort] > 0 then
             begin // space ship control requires space port
               inc(GShip[pTarget].Parts[i], n);
               RW[pSender].Ship[pTarget].Parts[i] := GShip[pTarget].Parts[i];
               RW[pTarget].Ship[pTarget].Parts[i] := GShip[pTarget].Parts[i];
+              Inc(GShip[pTarget].Parts[I], N);
+              RW[pSender].Ship[pTarget].Parts[I] := GShip[pTarget].Parts[I];
+              RW[pTarget].Ship[pTarget].Parts[I] := GShip[pTarget].Parts[I];
             end;
           end;
         end
         else
           result := false;
+          Result := False;
       end;
     opMoney: // + value
 …
         if execute then
         begin
           dec(RW[pSender].Money, Price - opMoney);
           inc(RW[pTarget].Money, Price - opMoney);
+          Dec(RW[pSender].Money, Price - opMoney);
+          Inc(RW[pTarget].Money, Price - opMoney);
         end;
       end
       else
         result := false;
+        Result := False;
     opTribute: // + value
       if execute then
 …
       end
       else
         result := false;
+        Result := False;
     opAllTech:
       if execute then
         for i := 0 to nAdv - 1 do
           if (RW[pSender].Tech[i] >= tsApplicable) and
             (RW[pTarget].Tech[i] = tsNA) then
+        for I := 0 to nAdv - 1 do
+          if (RW[pSender].Tech[I] >= tsApplicable) and
+            (RW[pTarget].Tech[I] = tsNA) then
           begin
             SeeTech(pTarget, i);
             RW[pSender].EnemyReport[pTarget].Tech[i] := tsSeen;
             RW[pTarget].EnemyReport[pSender].Tech[i] := tsApplicable;
+            SeeTech(pTarget, I);
+            RW[pSender].EnemyReport[pTarget].Tech[I] := tsSeen;
+            RW[pTarget].EnemyReport[pSender].Tech[I] := tsApplicable;
           end;
     opModel: // + model index
 …
       begin
         if execute then
           CopyModel(pSender, pTarget, Price - opModel)
+          CopyModel(pSender, pTarget, Price - opModel);
       end
       else
         result := false;
+        Result := False;
     opAllModel:
       if execute then
         for i := 0 to RW[pSender].nModel - 1 do
         begin
           TellAboutModel(pTarget, pSender, i);
           CopyModel(pSender, pTarget, i);
+        for I := 0 to RW[pSender].nModel - 1 do
+        begin
+          TellAboutModel(pTarget, pSender, I);
+          CopyModel(pSender, pTarget, I);
         end;
     { opCity: // + city ID
       begin
       result:=false
+      Result:=False
       end; }
   end
 end;
 procedure CancelTreaty(p, pWith: integer; DecreaseCredibility: boolean);
+  end;
+end;
+procedure CancelTreaty(P, pWith: Integer; DecreaseCredibility: Boolean);
 // side effect: PeaceEnded := bitarray of players with which peace treaty was canceled
 var
   p1, OldTreaty: integer;
 begin
   OldTreaty := RW[p].Treaty[pWith];
+  p1, OldTreaty: Integer;
+begin
+  OldTreaty := RW[P].Treaty[pWith];
   PeaceEnded := 0;
   if OldTreaty >= trPeace then
     RW[p].LastCancelTreaty[pWith] := GTurn;
+    RW[P].LastCancelTreaty[pWith] := GTurn;
   if DecreaseCredibility then
   begin
 …
       trPeace:
         begin
           RW[p].Credibility := RW[p].Credibility shr 1;
           if RW[p].MaxCredibility > 0 then
             dec(RW[p].MaxCredibility, 10);
           if RW[p].Credibility > RW[p].MaxCredibility then
             RW[p].Credibility := RW[p].MaxCredibility;
+          RW[P].Credibility := RW[P].Credibility shr 1;
+          if RW[P].MaxCredibility > 0 then
+            Dec(RW[P].MaxCredibility, 10);
+          if RW[P].Credibility > RW[P].MaxCredibility then
+            RW[P].Credibility := RW[P].MaxCredibility;
         end;
       trAlliance:
         RW[p].Credibility := RW[p].Credibility * 3 div 4;
     end;
     RW[pWith].EnemyReport[p].Credibility := RW[p].Credibility;
+        RW[P].Credibility := RW[P].Credibility * 3 div 4;
+    end;
+    RW[pWith].EnemyReport[P].Credibility := RW[P].Credibility;
   end;
 …
   begin
     for p1 := 0 to nPl - 1 do
       if (p1 = pWith) or DecreaseCredibility and (p1 <> p) and
         (RW[pWith].Treaty[p1] = trAlliance) and (RW[p].Treaty[p1] >= trPeace)
+      if (p1 = pWith) or DecreaseCredibility and (p1 <> P) and
+        (RW[pWith].Treaty[p1] = trAlliance) and (RW[P].Treaty[p1] >= trPeace)
       then
       begin
         RW[p].Treaty[p1] := trNone;
         RW[p1].Treaty[p] := trNone;
         RW[p].EvaStart[p1] := -PeaceEvaTurns - 1;
         RW[p1].EvaStart[p] := -PeaceEvaTurns - 1;
         inc(PeaceEnded, 1 shl p1);
+        RW[P].Treaty[p1] := trNone;
+        RW[p1].Treaty[P] := trNone;
+        RW[P].EvaStart[p1] := -PeaceEvaTurns - 1;
+        RW[p1].EvaStart[P] := -PeaceEvaTurns - 1;
+        Inc(PeaceEnded, 1 shl p1);
       end;
     CheckBorders(-1);
     if (Mode > moLoading_Fast) and (PeaceEnded > 0) then
       RecalcMapZoC(p);
+      RecalcMapZoC(P);
   end
   else
   begin
     RW[p].Treaty[pWith] := OldTreaty - 1;
     RW[pWith].Treaty[p] := OldTreaty - 1;
+    RW[P].Treaty[pWith] := OldTreaty - 1;
+    RW[pWith].Treaty[P] := OldTreaty - 1;
     if OldTreaty = TrFriendlyContact then
     begin // necessary for loading
       GiveCivilReport(p, pWith);
       GiveCivilReport(pWith, p);
+      GiveCivilReport(P, pWith);
+      GiveCivilReport(pWith, P);
     end
     else if OldTreaty = trAlliance then
     begin // necessary for loading
       GiveMilReport(p, pWith);
       GiveMilReport(pWith, p);
+      GiveMilReport(P, pWith);
+      GiveMilReport(pWith, P);
     end;
     if (Mode > moLoading_Fast) and (OldTreaty = trAlliance) then
     begin
       RecalcMapZoC(p);
+      RecalcMapZoC(P);
       RecalcMapZoC(pWith);
     end;
 …
   if OldTreaty in [trPeace, trAlliance] then
   begin
     RecalcPeaceMap(p);
+    RecalcPeaceMap(P);
     RecalcPeaceMap(pWith);
   end;
 end;
 function DoSpyMission(p, pCity, cix, Mission: integer): Cardinal;
 var
   p1: integer;
 begin
   result := 0;
+function DoSpyMission(P, pCity, cix, Mission: Integer): Cardinal;
+var
+  p1: Integer;
+begin
+  Result := 0;
   case Mission of
     smSabotageProd:
 …
     smStealMap:
       begin
         CopyMap(pCity, p);
         RecalcPeaceMap(p);
+        CopyMap(pCity, P);
+        RecalcPeaceMap(P);
       end;
     smStealCivilReport:
       begin
         if RW[p].Treaty[pCity] = trNoContact then
           IntroduceEnemy(p, pCity);
         GiveCivilReport(p, pCity);
+        if RW[P].Treaty[pCity] = trNoContact then
+          IntroduceEnemy(P, pCity);
+        GiveCivilReport(P, pCity);
       end;
     smStealMilReport:
       begin
         if RW[p].Treaty[pCity] = trNoContact then
           IntroduceEnemy(p, pCity);
         GiveMilReport(p, pCity);
+        if RW[P].Treaty[pCity] = trNoContact then
+          IntroduceEnemy(P, pCity);
+        GiveMilReport(P, pCity);
       end;
     smStealForeignReports:
       begin
         for p1 := 0 to nPl - 1 do
           if (p1 <> p) and (p1 <> pCity) and (RW[pCity].EnemyReport[p1] <> nil)
+          if (p1 <> P) and (p1 <> pCity) and (RW[pCity].EnemyReport[p1] <> nil)
           then
           begin
             if RW[pCity].EnemyReport[p1].TurnOfCivilReport >= 0 then
               if CopyCivilReport(pCity, p, p1) then
                 result := result or (1 shl (2 * p1));
+              if CopyCivilReport(pCity, P, p1) then
+                Result := Result or (1 shl (2 * p1));
             if RW[pCity].EnemyReport[p1].TurnOfMilReport >= 0 then
               if CopyMilReport(pCity, p, p1) then
                 result := result or (2 shl (2 * p1));
+              if CopyMilReport(pCity, P, p1) then
+                Result := Result or (2 shl (2 * p1));
           end;
       end;
 …
   ____________________________________________________________________
+}
 procedure ClearTestFlags(ClearFlags: integer);
 var
   p1: integer;
+procedure ClearTestFlags(ClearFlags: Integer);
+var
+  p1: Integer;
 begin
   GTestFlags := GTestFlags and (not ClearFlags or tfTested or tfAllTechs or
 …
 end;
 procedure SetTestFlags(p, SetFlags: integer);
 var
   i, p1, p2, MoreFlags: integer;
+procedure SetTestFlags(P, SetFlags: Integer);
+var
+  I, p1, p2, MoreFlags: Integer;
 begin
   MoreFlags := SetFlags and not GTestFlags;
 …
           begin // make p1 and p2 know each other
             if RW[p1].Treaty[p2] = trNoContact then
               IntroduceEnemy(p1, p2)
+              IntroduceEnemy(p1, p2);
           end;
 …
       if 1 shl p1 and GAlive <> 0 then
       begin
         for i := 0 to nAdv - 1 do // give all techs to player p1
           if not(i in FutureTech) and (RW[p1].Tech[i] < tsApplicable) then
+        for I := 0 to nAdv - 1 do // give all techs to player p1
+          if not(I in FutureTech) and (RW[p1].Tech[I] < tsApplicable) then
           begin
             RW[p1].Tech[i] := tsCheat;
             CheckSpecialModels(p1, i);
+            RW[p1].Tech[I] := tsCheat;
+            CheckSpecialModels(p1, I);
           end;
         for p2 := 0 to nPl - 1 do
           if (p2 <> p1) and (1 shl p2 and (GAlive or GWatching) <> 0) then
             for i := 1 to 3 do
               if RW[p2].EnemyReport[p1].Tech[AgePreq[i]] < tsApplicable then
                 RW[p2].EnemyReport[p1].Tech[AgePreq[i]] := tsCheat;
+            for I := 1 to 3 do
+              if RW[p2].EnemyReport[p1].Tech[AgePreq[I]] < tsApplicable then
+                RW[p2].EnemyReport[p1].Tech[AgePreq[I]] := tsCheat;
       end;
     end;
 …
   if MoreFlags and tfUncover <> 0 then
   begin
     DiscoverAll(p, lObserveSuper);
+    DiscoverAll(P, lObserveSuper);
     for p1 := 0 to nPl - 1 do
       if 1 shl p1 and GAlive <> 0 then
       begin
         ResourceMask[p1] := $FFFFFFFF;
         if p1 <> p then
         begin
           GiveCivilReport(p, p1);
           GiveMilReport(p, p1);
+        if p1 <> P then
+        begin
+          GiveCivilReport(P, p1);
+          GiveMilReport(P, p1);
         end;
       end;
 …
   ____________________________________________________________________
+}
+procedure IntServer(Command, Player, Subject: integer; var Data);
+var
+  i, p1: integer;
+procedure IntServer(Command, Player, Subject: Integer; var Data);
+var
+  I, p1: Integer;
 begin
   if Mode = moPlaying then
 …
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('IntTellAboutNation P%d+P%d', [Player, Subject]); {$ENDIF}
         assert((Player >= 0) and (Player < nPl) and (Subject >= 0) and
+        Assert((Player >= 0) and (Player < nPl) and (Subject >= 0) and
           (Subject < nPl));
         IntroduceEnemy(Player, Subject);
 …
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('IntHaveContact P%d+P%d', [Player, Subject]); {$ENDIF}
         assert(RW[Player].Treaty[Subject] > trNoContact);
+        Assert(RW[Player].Treaty[Subject] > trNoContact);
         RW[Player].EnemyReport[Subject].TurnOfContact := GTurn;
         RW[Subject].EnemyReport[Player].TurnOfContact := GTurn;
 …
         p1 := (Command - sIntTellAboutModel) shr 4; // told player
 {$IFDEF TEXTLOG}CmdInfo := Format('IntTellAboutModel P%d about P%d Mod%d', [p1, Player, Subject]); {$ENDIF}
         assert((Player >= 0) and (Player < nPl));
         assert((Subject >= 0) and (Subject < RW[Player].nModel));
+        Assert((Player >= 0) and (Player < nPl));
+        Assert((Subject >= 0) and (Subject < RW[Player].nModel));
         MakeModelInfo(Player, Subject, RW[Player].Model[Subject],
           RW[p1].EnemyModel[RW[p1].nEnemyModel]);
         RWemix[p1, Player, Subject] := RW[p1].nEnemyModel;
         inc(RW[p1].nEnemyModel);
         assert(RW[p1].nEnemyModel < nemmax);
+        Inc(RW[p1].nEnemyModel);
+        Assert(RW[p1].nEnemyModel < nemmax);
       end;
     sIntDiscoverZOC:
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('IntDiscoverZOC P%d Loc%d', [Player, integer(Data)]); {$ENDIF}
         Discover9(integer(Data), Player, lObserveUnhidden, true, false);
+{$IFDEF TEXTLOG}CmdInfo := Format('IntDiscoverZOC P%d Loc%d', [Player, Integer(Data)]); {$ENDIF}
+        Discover9(Integer(Data), Player, lObserveUnhidden, True, False);
       end;
 …
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('IntExpandTerritory P%d Loc%d', [Player, RW[Player].City[Subject].Loc]); {$ENDIF}
         move(Data, BorderChanges, SizeOf(BorderChanges));
+        Move(Data, BorderChanges, SizeOf(BorderChanges));
         ExpandTerritory(RW[Player].City[Subject].Loc);
       end;
 …
       with RW[Player].City[Subject] do
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('IntBuyMaterial P%d Loc%d Cost%d', [Player, Loc, integer(Data)]); {$ENDIF}
         dec(RW[Player].Money, integer(Data));
+{$IFDEF TEXTLOG}CmdInfo := Format('IntBuyMaterial P%d Loc%d Cost%d', [Player, Loc, Integer(Data)]); {$ENDIF}
+        Dec(RW[Player].Money, Integer(Data));
         if (GWonder[woMich].EffectiveOwner = Player) and (Project and cpImp <> 0)
         then
           inc(Prod, integer(Data) div 2)
+          Inc(Prod, Integer(Data) div 2)
         else
           inc(Prod, integer(Data) div 4);
+          Inc(Prod, Integer(Data) div 4);
         if Project0 and not cpAuto <> Project and not cpAuto then
           Project0 := Project;
 …
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('IntPayPrices P%d+P%d', [Player, Subject]); {$ENDIF}
         for i := 0 to TOffer(Data).nDeliver - 1 do
           PayPrice(Player, Subject, TOffer(Data).Price[i], true);
         for i := 0 to TOffer(Data).nCost - 1 do
+        for I := 0 to TOffer(Data).nDeliver - 1 do
+          PayPrice(Player, Subject, TOffer(Data).Price[I], True);
+        for I := 0 to TOffer(Data).nCost - 1 do
           PayPrice(Subject, Player, TOffer(Data).Price[TOffer(Data).nDeliver
             + i], true);
         for i := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
           if TOffer(Data).Price[i] = opTreaty + trAlliance then
+            + I], True);
+        for I := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
+          if TOffer(Data).Price[I] = opTreaty + trAlliance then
           begin // add view area of allied player
             DiscoverViewAreas(Player);
             DiscoverViewAreas(Subject);
             Break
           end
+            Break;
+          end;
       end;
     sIntSetDevModel:
       if Mode < moPlaying then
         move(Data, RW[Player].DevModel.Kind, sIntSetDevModel and $F * 4);
+        Move(Data, RW[Player].DevModel.Kind, sIntSetDevModel and $F * 4);
     sIntSetModelStatus:
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetModelStatus P%d', [Player]);
         {$ENDIF}
         RW[Player].Model[Subject].Status := integer(Data);
+        RW[Player].Model[Subject].Status := Integer(Data);
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetUnitStatus P%d', [Player]);
         {$ENDIF}
         RW[Player].Un[Subject].Status := integer(Data);
+        RW[Player].Un[Subject].Status := Integer(Data);
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetCityStatus P%d', [Player]);
         {$ENDIF}
         RW[Player].City[Subject].Status := integer(Data);
+        RW[Player].City[Subject].Status := Integer(Data);
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetECityStatus P%d', [Player]);
         {$ENDIF}
+        RW[Player].EnemyCity[Subject].Status := integer(Data);
+      end;
+  end; { case command }
+end; { IntServer }
+        RW[Player].EnemyCity[Subject].Status := Integer(Data);
+      end;
+  end;
+end;
 end.

branches/highdpi/Direct.lfm

-              r246
+              r465
   Caption = 'C-evo'
   Color = clBtnFace
   DesignTimePPI = 125
+  DesignTimePPI = 144
   Font.Color = clWindowText
   Font.Height = -13
+  Font.Height = -20
   Font.Name = 'MS Sans Serif'
   FormStyle = fsStayOnTop
 …
   OnPaint = FormPaint
   OnShow = FormShow
   LCLVersion = '1.8.0.6'
   PixelsPerInch = 96
+  ShowInTaskBar = stNever
+  LCLVersion = '2.2.6.0'
   Scaled = False
 end

branches/highdpi/Direct.pas

-              r405
+              r465
   UDpiControls, Messg,
   LCLIntf, LCLType, {$IFDEF Linux}LMessages, {$ENDIF}Messages, SysUtils, Classes,
+  LCLIntf, LCLType, {$IFDEF UNIX}LMessages, {$ENDIF}Messages, SysUtils, Classes,
   Graphics, Controls, Forms, DrawDlg, GameServer;
 …
     Gone: Boolean;
     Quick: Boolean;
     procedure SetInfo(x: string);
     procedure SetState(x: integer);
+    procedure SetInfo(X: string);
+    procedure SetState(X: Integer);
     procedure OnGo(var Msg: TMessage); message WM_GO;
     procedure OnChangeClient(var Msg: TMessage); message WM_CHANGECLIENT;
 …
   DirectDlg: TDirectDlg;
 implementation
 uses
   ScreenTools, Protocol, Start, LocalPlayer, NoTerm, Back, Global, UNetworkServer,
   UNetworkClient;
+  ScreenTools, Protocol, Start, LocalPlayer, NoTerm, Back, Global, NetworkServer,
+  NetworkClient;
 {$R *.lfm}
 …
 //  hMem: Cardinal;
 //  p: pointer;
   s: string;
+  S: string;
 Begin
   case ID of
 …
       if visible then
       begin
         s := Format(Phrases.Lookup('BUSY_MOD'), [Brains[Index].Name]);
         while BiColorTextWidth(Canvas, s) + 64 > ClientWidth do
           Delete(s, Length(s), 1);
         SetInfo(s);
+        S := Format(Phrases.Lookup('BUSY_MOD'), [Brains[Index].Name]);
+        while BiColorTextWidth(Canvas, S) + 64 > ClientWidth do
+          Delete(S, Length(S), 1);
+        SetInfo(S);
       end;
     ntCreateWorld:
 …
           hMem := GlobalAlloc(GMEM_MOVEABLE or GMEM_DDESHARE,
             Length(NotifyMessage));
           p := GlobalLock(hMem);
           if p <> nil then
             move(NotifyMessage[1], p^, Length(NotifyMessage));
+          P := GlobalLock(hMem);
+          if P <> nil then
+            Move(NotifyMessage[1], P^, Length(NotifyMessage));
           GlobalUnlock(hMem);
           SetClipboardData(CF_TEXT, hMem);
 …
         State := -1;
         Show;
+        {$IFDEF LINUX}
+        // Force shown window repaint on Gtk2 widgetset
+        Sleep(1);
+        DpiApplication.ProcessMessages;
+        {$ENDIF}
+        Gtk2Fix;
         Invalidate;
         Update;
 …
   BrainTerm.Name := Phrases.Lookup('HUMAN');
   if NetworkEnabled then begin
     BrainNetworkServer.Client := UNetworkServer.Client;
+    BrainNetworkServer.Client := NetworkServer.Client;
     BrainNetworkServer.Name := Phrases.Lookup('NETWORK_SERVER');
     BrainNetworkClient.Client := UNetworkClient.Client;
+    BrainNetworkClient.Client := NetworkClient.Client;
     BrainNetworkClient.Name := Phrases.Lookup('NETWORK_CLIENT');
   end;
 …
   begin
     PostMessage(Handle, WM_GO, 0, 0);
     Gone := true;
+    Gone := True;
   end;
 end;
 …
 procedure TDirectDlg.OnGo(var Msg: TMessage);
 var
   i: integer;
   s: string;
+  I: Integer;
+  S: string;
   FileName: string;
 begin
 …
     Exit;
   end;
   Quick := false;
+  Quick := False;
   if ParamCount > 0 then
   begin
     s := ParamStr(1);
     if (s[1] = '-') {$IFDEF WINDOWS}or (s[1] = '/'){$ENDIF} then
+    S := ParamStr(1);
+    if (S[1] = '-') {$IFDEF WINDOWS}or (S[1] = '/'){$ENDIF} then
     begin // special mode
       Delete(s, 1, 1);
       for i := 1 to Length(s) do
         if s[i] in ['a' .. 'z'] then
           dec(s[i], 32);
       if s = 'MAN' then
+      Delete(S, 1, 1);
+      for I := 1 to Length(S) do
+        if S[I] in ['a' .. 'z'] then
+          Dec(S[I], 32);
+      if S = 'MAN' then
       begin
         Quick := true;
+        Quick := True;
         DirectHelp(cHelpOnly);
         Close;
 …
         Quick := True;
         if not LoadGame(ExtractFilePath(ParamStr(1)), ExtractFileName(ParamStr(1)
         ), -1, false) then begin
+        ), -1, False) then begin
           SimpleMessage(Phrases.Lookup('LOADERR'));
           Close;
 …
 procedure TDirectDlg.FormPaint(Sender: TObject);
 begin
   PaintBackground(self, 3, 3, ClientWidth - 6, ClientHeight - 6);
+  PaintBackground(Self, 3, 3, ClientWidth - 6, ClientHeight - 6);
   Frame(Canvas, 0, 0, ClientWidth - 1, ClientHeight - 1, 0, 0);
   Frame(Canvas, 1, 1, ClientWidth - 2, ClientHeight - 2,
 …
 end;
 procedure TDirectDlg.SetInfo(x: string);
 begin
   Info := x;
+procedure TDirectDlg.SetInfo(X: string);
+begin
+  Info := X;
   Invalidate;
   Update;
   {$IFDEF LINUX}
+  {$IFDEF UNIX}
   DpiApplication.ProcessMessages;
   {$ENDIF}
 end;
 procedure TDirectDlg.SetState(x: integer);
 begin
   if (x < 0) <> (State < 0) then begin
     State := x;
+procedure TDirectDlg.SetState(X: Integer);
+begin
+  if (X < 0) <> (State < 0) then begin
+    State := X;
     Invalidate;
     Update;
   end
   else if x <> State then begin
     State := x;
+  else if X <> State then begin
+    State := X;
     PaintProgressBar(Canvas, 6, ClientWidth div 2 - 64, 40, State, 128 - State,
 , MainTexture);

branches/highdpi/GameServer.pas

-              r405
+              r465
 uses
   Protocol, Database, dynlibs, Platform, dateutils, fgl, LazFileUtils,
   Graphics, UBrain, Global;
+  Protocol, Database, dynlibs, Platform, dateutils, LazFileUtils, Graphics,
+  Brain, Global;
 const
 …
   // PARAMETERS
   PlayersBrain: TBrains; { brain of the players view }
   Difficulty: array [0 .. nPl - 1] of integer absolute Database.Difficulty;
+  Difficulty: array [0 .. nPl - 1] of Integer absolute Database.Difficulty;
   { difficulty }
 …
 procedure StartNewGame(const Path, FileName, Map: string;
   Newlx, Newly, NewLandMass, NewMaxTurn: integer);
 function LoadGame(const Path, FileName: string; Turn: integer;
   MovieMode: boolean): boolean;
 procedure EditMap(const Map: string; Newlx, Newly, NewLandMass: integer);
 procedure DirectHelp(Command: integer);
+  Newlx, Newly, NewLandMass, NewMaxTurn: Integer);
+function LoadGame(const Path, FileName: string; Turn: Integer;
+  MovieMode: Boolean): Boolean;
+procedure EditMap(const Map: string; Newlx, Newly, NewLandMass: Integer);
+procedure DirectHelp(Command: Integer);
 procedure ChangeClient;
 procedure NextPlayer;
 function PreviewMap(lm: integer): pointer;
+function PreviewMap(lm: Integer): Pointer;
 …
   MapField: ^Cardinal; // predefined map
   LastOffer: TOffer;
   CCData: array [0 .. 14] of integer;
+  CCData: array [0 .. 14] of Integer;
   bix: TBrains; { brain of the players }
   DevModelTurn: array [0 .. nPl - 1] of Integer; { turn of last call to sResetModel }
   OriginalDataVersion: array [0 .. nPl - 1] of Integer;
   SavedTiles { , SavedResourceWeights } : array [0 .. ncmax - 1] of Cardinal;
   SavedData: array [0 .. nPl - 1] of pointer;
+  SavedData: array [0 .. nPl - 1] of Pointer;
   LogFileName: string;
   SavePath: string; { name of file for saving the current game }
 …
   PreviewRND = 41601260; { randseed for preview map }
 function Server(Command, Player, Subject: integer; var Data): integer;
+function Server(Command, Player, Subject: Integer; var Data): Integer;
   stdcall; forward;
 procedure CallPlayer(Command, p: integer; var Data);
+procedure CallPlayer(Command, P: Integer; var Data);
 begin
   if ((Mode <> moMovie) or (p = 0)) then
+  if ((Mode <> moMovie) or (P = 0)) then
   begin
 {$IFOPT O-}
     HandoverStack[nHandoverStack] := p;
+    HandoverStack[nHandoverStack] := P;
     HandoverStack[nHandoverStack + 1] := Command;
     inc(nHandoverStack, 2);
     bix[p].Client(Command, p, Data);
     dec(nHandoverStack, 2);
+    Inc(nHandoverStack, 2);
+    bix[P].Client(Command, P, Data);
+    Dec(nHandoverStack, 2);
 {$ELSE}
     try
       bix[p].Client(Command, p, Data);
+      bix[P].Client(Command, P, Data);
     except
       Notify(ntException + bix[p]);
+      Notify(ntException + bix[P]);
     end;
 {$ENDIF}
   end
+  end;
 end;
 …
 end;
 procedure CallClient(bix, Command: integer; var Data);
+procedure CallClient(bix, Command: Integer; var Data);
 begin
   if ((Mode <> moMovie) or (bix = Brains.IndexOf(GameServer.bix[0]))) then
 …
     HandoverStack[nHandoverStack] := bix;
     HandoverStack[nHandoverStack + 1] := Command;
     inc(nHandoverStack, 2);
+    Inc(nHandoverStack, 2);
     Brains[bix].Client(Command, -1, Data);
     dec(nHandoverStack, 2);
+    Dec(nHandoverStack, 2);
 {$ELSE}
     try
 …
 procedure Init(NotifyFunction: TNotifyFunction);
 var
   f: TSearchRec;
+  F: TSearchRec;
   BasePath: string;
   NewBrain: TBrain;
 …
 begin
   Notify := NotifyFunction;
   PreviewElevation := false;
+  PreviewElevation := False;
   PlayersBrain := TBrains.Create(False);
   PlayersBrain.Count := nPl;
 …
   end;
   if FindFirst(GetAiDir + DirectorySeparator + '*', faDirectory or faArchive or faReadOnly, f) = 0 then
+  if FindFirst(GetAiDir + DirectorySeparator + '*', faDirectory or faArchive or faReadOnly, F) = 0 then
   repeat
     BasePath := GetAiDir + DirectorySeparator + f.Name;
     if (f.Name <> '.') and (f.Name <> '..') and DirectoryExists(BasePath) then begin
+    BasePath := GetAiDir + DirectorySeparator + F.Name;
+    if (F.Name <> '.') and (F.Name <> '..') and DirectoryExists(BasePath) then begin
       NewBrain := Brains.AddNew;
       NewBrain.Kind := btAI;
 …
         end else Brains.Delete(Brains.Count - 1);
     end;
   until FindNext(f) <> 0;
+  until FindNext(F) <> 0;
   FindClose(F);
 …
 end;
 function PreviewMap(lm: integer): pointer;
+function PreviewMap(lm: Integer): Pointer;
 begin
   lx := lxmax;
 …
   begin
     CreateElevation;
     PreviewElevation := true;
+    PreviewElevation := True;
   end;
   CreateMap(true);
+  CreateMap(True);
   Result := @RealMap;
 end;
 procedure ChangeClientWhenDone(Command, Player: integer; var Data;
   DataSize: integer);
+procedure ChangeClientWhenDone(Command, Player: Integer; var Data;
+  DataSize: Integer);
 begin
   CCCommand := Command;
   CCPlayer := Player;
   if DataSize > 0 then
     move(Data, CCData, DataSize);
+    Move(Data, CCData, DataSize);
   Notify(ntChangeClient);
 end;
 procedure PutMessage(Level: integer; Text: string);
+procedure PutMessage(Level: Integer; Text: string);
 begin
   bix[0].Client(cDebugMessage, Level, pchar(Text)^);
+  bix[0].Client(cDebugMessage, Level, PChar(Text)^);
 end;
 …
 // hand over control to other client (as specified by CC...)
 var
   p: integer;
+  P: Integer;
   T: TDateTime;
 begin
 …
     [CCPlayer, bix[CCPlayer].Name]));
   if CCCommand = cTurn then
     for p := 0 to nPl - 1 do
       if (p <> CCPlayer) and (1 shl p and GWatching <> 0) then
         CallPlayer(cShowTurnChange, p, CCPlayer);
   p := CCPlayer;
+    for P := 0 to nPl - 1 do
+      if (P <> CCPlayer) and (1 shl P and GWatching <> 0) then
+        CallPlayer(cShowTurnChange, P, CCPlayer);
+  P := CCPlayer;
   CCPlayer := -1;
   CallPlayer(CCCommand, p, CCData);
   if (Mode = moPlaying) and (bix[p].Flags and aiThreaded = 0) and
+  CallPlayer(CCCommand, P, CCData);
+  if (Mode = moPlaying) and (bix[P].Flags and aiThreaded = 0) and
     (CCPlayer < 0) then
   begin
     Notify(ntDeactivationMissing, p);
+    Notify(ntDeactivationMissing, P);
     ForceClientDeactivation;
   end;
 end;
 procedure Inform(p: integer);
+procedure Inform(P: Integer);
 var
   i, p1: integer;
+  I, p1: Integer;
 begin
   RW[p].Turn := GTurn;
   if (GTurn = MaxTurn) and (p = pTurn) and (p = 0) then
     RW[p].Happened := RW[p].Happened or phTimeUp;
   if (GWinner > 0) and (p = pTurn) and (p = 0) then
     RW[p].Happened := RW[p].Happened or phShipComplete;
   RW[p].Alive := GAlive;
   move(GWonder, RW[p].Wonder, SizeOf(GWonder));
   move(GShip, RW[p].Ship, SizeOf(GShip));
+  RW[P].Turn := GTurn;
+  if (GTurn = MaxTurn) and (P = pTurn) and (P = 0) then
+    RW[P].Happened := RW[P].Happened or phTimeUp;
+  if (GWinner > 0) and (P = pTurn) and (P = 0) then
+    RW[P].Happened := RW[P].Happened or phShipComplete;
+  RW[P].Alive := GAlive;
+  Move(GWonder, RW[P].Wonder, SizeOf(GWonder));
+  Move(GShip, RW[P].Ship, SizeOf(GShip));
   for p1 := 0 to nPl - 1 do
     if (p1 <> p) and Assigned(bix[p1]) and (Difficulty[p1] > 0) then
       RW[p].EnemyReport[p1].Credibility := RW[p1].Credibility;
+    if (p1 <> P) and Assigned(bix[p1]) and (Difficulty[p1] > 0) then
+      RW[P].EnemyReport[p1].Credibility := RW[p1].Credibility;
   for p1 := 0 to nPl - 1 do
     if (p1 <> p) and (1 shl p1 and GAlive <> 0) then
+    if (p1 <> P) and (1 shl p1 and GAlive <> 0) then
     begin
       if (GTestFlags and tfUncover <> 0) or (Difficulty[p] = 0) or
         (RW[p].Treaty[p1] >= trFriendlyContact) then
         GiveCivilReport(p, p1);
       if (GTestFlags and tfUncover <> 0) or (Difficulty[p] = 0) or
         (RW[p].Treaty[p1] = trAlliance) then
         GiveMilReport(p, p1)
+      if (GTestFlags and tfUncover <> 0) or (Difficulty[P] = 0) or
+        (RW[P].Treaty[p1] >= trFriendlyContact) then
+        GiveCivilReport(P, p1);
+      if (GTestFlags and tfUncover <> 0) or (Difficulty[P] = 0) or
+        (RW[P].Treaty[p1] = trAlliance) then
+        GiveMilReport(P, p1)
     end;
   for i := 0 to RW[p].nEnemyModel - 1 do
     with RW[p].EnemyModel[i] do
       Lost := Destroyed[p, Owner, mix];
+  for I := 0 to RW[P].nEnemyModel - 1 do
+    with RW[P].EnemyModel[I] do
+      Lost := Destroyed[P, Owner, mix];
 end;
 procedure LogChanges;
 var
   p, ix: integer;
+  P, ix: Integer;
 begin
   for p := 0 to nPl - 1 do
     if (1 shl p and GWatching <> 0) and ProcessClientData[p] then
+  for P := 0 to nPl - 1 do
+    if (1 shl P and GWatching <> 0) and ProcessClientData[P] then
     begin
       // log unit status changes
       for ix := 0 to RW[p].nUn - 1 do
         with RW[p].Un[ix] do
+      for ix := 0 to RW[P].nUn - 1 do
+        with RW[P].Un[ix] do
           if (Loc >= 0) and (SavedStatus <> Status) then
           begin
             CL.Put(sIntSetUnitStatus, p, ix, @Status);
+            CL.Put(sIntSetUnitStatus, P, ix, @Status);
             SavedStatus := Status;
           end;
       // log city status changes
       for ix := 0 to RW[p].nCity - 1 do
         with RW[p].City[ix] do
+      for ix := 0 to RW[P].nCity - 1 do
+        with RW[P].City[ix] do
           if (Loc >= 0) and (SavedStatus <> Status) then
           begin
             CL.Put(sIntSetCityStatus, p, ix, @Status);
+            CL.Put(sIntSetCityStatus, P, ix, @Status);
             SavedStatus := Status;
           end;
       // log model status changes
       for ix := 0 to RW[p].nModel - 1 do
         with RW[p].Model[ix] do
+      for ix := 0 to RW[P].nModel - 1 do
+        with RW[P].Model[ix] do
           if SavedStatus <> Status then
           begin
             CL.Put(sIntSetModelStatus, p, ix, @Status);
+            CL.Put(sIntSetModelStatus, P, ix, @Status);
             SavedStatus := Status;
           end;
       // log enemy city status changes
       for ix := 0 to RW[p].nEnemyCity - 1 do
         with RW[p].EnemyCity[ix] do
+      for ix := 0 to RW[P].nEnemyCity - 1 do
+        with RW[P].EnemyCity[ix] do
           if (Loc >= 0) and (SavedStatus <> Status) then
           begin
             CL.Put(sIntSetECityStatus, p, ix, @Status);
+            CL.Put(sIntSetECityStatus, P, ix, @Status);
             SavedStatus := Status;
           end;
       // log data changes
       if bix[p].DataSize > 0 then
       begin
         CL.PutDataChanges(sIntDataChange, p, SavedData[p], RW[p].Data,
           bix[p].DataSize);
         Move(RW[p].Data^, SavedData[p]^, bix[p].DataSize * 4);
+      if bix[P].DataSize > 0 then
+      begin
+        CL.PutDataChanges(sIntDataChange, P, SavedData[P], RW[P].Data,
+          bix[P].DataSize);
+        Move(RW[P].Data^, SavedData[P]^, bix[P].DataSize * 4);
       end;
     end;
 …
 procedure NoLogChanges;
 var
   p, ix: integer;
+  P, ix: Integer;
 begin
   for p := 0 to nPl - 1 do
     if (1 shl p and GWatching <> 0) and ProcessClientData[p] then
+  for P := 0 to nPl - 1 do
+    if (1 shl P and GWatching <> 0) and ProcessClientData[P] then
     begin
       for ix := 0 to RW[p].nUn - 1 do
         with RW[p].Un[ix] do
+      for ix := 0 to RW[P].nUn - 1 do
+        with RW[P].Un[ix] do
           SavedStatus := Status;
       for ix := 0 to RW[p].nCity - 1 do
         with RW[p].City[ix] do
+      for ix := 0 to RW[P].nCity - 1 do
+        with RW[P].City[ix] do
           SavedStatus := Status;
       for ix := 0 to RW[p].nModel - 1 do
         with RW[p].Model[ix] do
+      for ix := 0 to RW[P].nModel - 1 do
+        with RW[P].Model[ix] do
           SavedStatus := Status;
       for ix := 0 to RW[p].nEnemyCity - 1 do
         with RW[p].EnemyCity[ix] do
+      for ix := 0 to RW[P].nEnemyCity - 1 do
+        with RW[P].EnemyCity[ix] do
           SavedStatus := Status;
       if bix[p].DataSize > 0 then
         Move(RW[p].Data^, SavedData[p]^, bix[p].DataSize * 4);
+      if bix[P].DataSize > 0 then
+        Move(RW[P].Data^, SavedData[P]^, bix[P].DataSize * 4);
     end;
 end;
 function HasChanges(p: integer): boolean;
+function HasChanges(P: Integer): Boolean;
 type
   TDWordList = array [0 .. INFIN] of Cardinal;
   PDWortList = ^TDWordList;
 var
   ix: integer;
+  ix: Integer;
 begin
   Result := False;
   for ix := 0 to RW[p].nUn - 1 do
     with RW[p].Un[ix] do
+  for ix := 0 to RW[P].nUn - 1 do
+    with RW[P].Un[ix] do
       if (Loc >= 0) and (SavedStatus <> Status) then
         Result := True;
   for ix := 0 to RW[p].nCity - 1 do
     with RW[p].City[ix] do
+  for ix := 0 to RW[P].nCity - 1 do
+    with RW[P].City[ix] do
       if (Loc >= 0) and (SavedStatus <> Status) then
         Result := True;
   for ix := 0 to RW[p].nModel - 1 do
     with RW[p].Model[ix] do
+  for ix := 0 to RW[P].nModel - 1 do
+    with RW[P].Model[ix] do
       if SavedStatus <> Status then
         Result := True;
   for ix := 0 to RW[p].nEnemyCity - 1 do
     with RW[p].EnemyCity[ix] do
+  for ix := 0 to RW[P].nEnemyCity - 1 do
+    with RW[P].EnemyCity[ix] do
       if (Loc >= 0) and (SavedStatus <> Status) then
         Result := True;
   if RW[p].Data <> nil then
     for ix := 0 to bix[p].DataSize - 1 do
       if PDWortList(SavedData[p])[ix] <> PDWortList(RW[p].Data)[ix] then
+  if RW[P].Data <> nil then
+    for ix := 0 to bix[P].DataSize - 1 do
+      if PDWortList(SavedData[P])[ix] <> PDWortList(RW[P].Data)[ix] then
         Result := True;
 end;
 …
   InitModuleData: TInitModuleData;
 begin
   assert(bix.Kind <> btSuperVirtual);
+  Assert(bix.Kind <> btSuperVirtual);
   with bix do begin
     if Initialized then
       exit;
+      Exit;
     if Kind = btAI then
     begin { get client function }
 …
       else
       begin
         hm := LoadLibrary(pchar(DLLName));
+        hm := LoadLibrary(PChar(DLLName));
         if hm = 0 then
         begin
 …
     if @Client <> nil then
     begin
       Initialized := true;
+      Initialized := True;
       InitModuleData.Server := @Server;
       InitModuleData.DataVersion := 0;
 …
 procedure SaveMap(FileName: string);
 var
   i: integer;
+  I: Integer;
   MapFile: TFileStream;
   s: string[255];
+  S: string[255];
 begin
   MapFile := TFileStream.Create(GetMapsDir + DirectorySeparator + FileName,
 …
   try
     MapFile.Position := 0;
     s := 'cEvoMap'#0;
     MapFile.write(s[1], 8); { file id }
     i := 0;
     MapFile.write(i, 4); { format id }
     MapFile.write(MaxTurn, 4);
     MapFile.write(lx, 4);
     MapFile.write(ly, 4);
     MapFile.write(RealMap, MapSize * 4);
+    S := 'cEvoMap'#0;
+    MapFile.Write(S[1], 8); { file id }
+    I := 0;
+    MapFile.Write(I, 4); { format id }
+    MapFile.Write(MaxTurn, 4);
+    MapFile.Write(lx, 4);
+    MapFile.Write(ly, 4);
+    MapFile.Write(RealMap, MapSize * 4);
   finally
     FreeAndNil(MapFile);
 …
 end;
 function LoadMap(FileName: string): boolean;
+function LoadMap(FileName: string): Boolean;
 var
   i, Loc1: integer;
+  I, Loc1: Integer;
   MapFile: TFileStream;
   s: string[255];
+  S: string[255];
 begin
   result := false;
+  Result := False;
   MapFile := nil;
   try
     MapFile := TFileStream.Create(FileName, fmOpenRead or fmShareExclusive);
     MapFile.Position := 0;
     MapFile.read(s[1], 8); { file id }
     MapFile.read(i, 4); { format id }
     if i = 0 then
+    MapFile.Read(S[1], 8); { file id }
+    MapFile.Read(I, 4); { format id }
+    if I = 0 then
     begin
       MapFile.read(i, 4); // MaxTurn
       MapFile.read(lx, 4);
       MapFile.read(ly, 4);
+      MapFile.Read(I, 4); // MaxTurn
+      MapFile.Read(lx, 4);
+      MapFile.Read(ly, 4);
       ly := ly and not 1;
       if lx > lxmax then
 …
         ly := lymax;
       MapSize := lx * ly;
       MapFile.read(RealMap, MapSize * 4);
+      MapFile.Read(RealMap, MapSize * 4);
       for Loc1 := 0 to MapSize - 1 do
       begin
 …
             or fDesert;
       end;
       result := true;
+      Result := True;
     end;
     FreeAndNil(MapFile);
 …
 end;
 procedure SaveGame(FileName: string; auto: boolean);
+procedure SaveGame(FileName: string; Auto: Boolean);
 var
   x, y, i, zero, Tile, nLocal: integer;
+  X, Y, I, zero, Tile, nLocal: Integer;
   LogFile: TFileStream;
   s: string[255];
+  S: string[255];
   SaveMap: array [0 .. lxmax * lymax - 1] of Byte;
 begin
   nLocal := 0;
   for i := 0 to nPl - 1 do
     if Assigned(bix[i]) and (bix[i].Kind = btTerm) then
       inc(nLocal);
+  for I := 0 to nPl - 1 do
+    if Assigned(bix[I]) and (bix[I].Kind = btTerm) then
+      Inc(nLocal);
   if Difficulty[0] = 0 then
     nLocal := 0;
   if nLocal <= 1 then
     for y := 0 to ly - 1 do
       for x := 0 to lx - 1 do
       begin
         Tile := RW[0].Map[(x + SaveMapCenterLoc + lx shr 1) mod lx + lx * y];
         SaveMap[x + lx * y] := Tile and fTerrain + Tile and
+    for Y := 0 to ly - 1 do
+      for X := 0 to lx - 1 do
+      begin
+        Tile := RW[0].Map[(X + SaveMapCenterLoc + lx shr 1) mod lx + lx * Y];
+        SaveMap[X + lx * Y] := Tile and fTerrain + Tile and
           (fCity or fUnit or fOwned) shr 16;
       end;
   if auto and AutoSaveExists then // append to existing file
+  if Auto and AutoSaveExists then // append to existing file
     LogFile := TFileStream.Create(SavePath + FileName, fmOpenReadWrite or
       fmShareExclusive)
 …
   zero := 0;
   LogFile.Position := 0;
   s := 'cEvoBook';
   LogFile.write(s[1], 8); { file id }
   i := CevoVersion;
   LogFile.write(i, 4); { c-evo version }
   LogFile.write(ExeInfo.Time, 4);
   LogFile.write(lx, 4);
   LogFile.write(ly, 4);
   LogFile.write(LandMass, 4);
+  S := 'cEvoBook';
+  LogFile.Write(S[1], 8); { file id }
+  I := CevoVersion;
+  LogFile.Write(I, 4); { c-evo version }
+  LogFile.Write(ExeInfo.Time, 4);
+  LogFile.Write(lx, 4);
+  LogFile.Write(ly, 4);
+  LogFile.Write(LandMass, 4);
   if LandMass = 0 then
     LogFile.write(MapField^, MapSize * 4);
   LogFile.write(MaxTurn, 4);
   LogFile.write(RND, 4);
   LogFile.write(GTurn, 4);
+    LogFile.Write(MapField^, MapSize * 4);
+  LogFile.Write(MaxTurn, 4);
+  LogFile.Write(RND, 4);
+  LogFile.Write(GTurn, 4);
   if nLocal > 1 then // multiplayer game -- no quick view
   begin
     i := $80;
     LogFile.write(i, 4);
+    I := $80;
+    LogFile.Write(I, 4);
   end
   else
     LogFile.write(SaveMap, ((MapSize - 1) div 4 + 1) * 4);
   for i := 0 to nPl - 1 do
     if not Assigned(bix[i]) then
       LogFile.write(zero, 4)
+    LogFile.Write(SaveMap, ((MapSize - 1) div 4 + 1) * 4);
+  for I := 0 to nPl - 1 do
+    if not Assigned(bix[I]) then
+      LogFile.Write(zero, 4)
     else
     begin
       if PlayersBrain[i].Kind in [btRandom, btAI] then
         s := bix[i].FileName
       else
         s := PlayersBrain[i].FileName;
       move(zero, s[Length(s) + 1], 4);
       LogFile.write(s, (Length(s) div 4 + 1) * 4);
       LogFile.write(OriginalDataVersion[i], 4);
       s := ''; { behavior }
       move(zero, s[Length(s) + 1], 4);
       LogFile.write(s, (Length(s) div 4 + 1) * 4);
       LogFile.write(Difficulty[i], 4);
+      if PlayersBrain[I].Kind in [btRandom, btAI] then
+        S := bix[I].FileName
+      else
+        S := PlayersBrain[I].FileName;
+      Move(zero, S[Length(S) + 1], 4);
+      LogFile.Write(S, (Length(S) div 4 + 1) * 4);
+      LogFile.Write(OriginalDataVersion[I], 4);
+      S := ''; { behavior }
+      Move(zero, S[Length(S) + 1], 4);
+      LogFile.Write(S, (Length(S) div 4 + 1) * 4);
+      LogFile.Write(Difficulty[I], 4);
     end;
   if auto and AutoSaveExists then
+  if Auto and AutoSaveExists then
     CL.AppendToFile(LogFile, AutoSaveState)
   else
     CL.SaveToFile(LogFile);
   FreeAndNil(LogFile);
   if auto then
+  if Auto then
   begin
     AutoSaveState := CL.State;
     AutoSaveExists := true;
+    AutoSaveExists := True;
   end
 end;
 …
 procedure StartGame;
 var
   i, p, p1, Human, nAlive, bixUni: integer;
+  I, P, p1, Human, nAlive, bixUni: Integer;
   Game: TNewGameData;
   // GameEx: TNewGameExData;
 …
   BrainUsed := [];
   for p := 0 to nPl - 1 do
     if Assigned(bix[p]) and ((Mode <> moMovie) or (p = 0)) then
+  for P := 0 to nPl - 1 do
+    if Assigned(bix[P]) and ((Mode <> moMovie) or (P = 0)) then
     begin { initiate selected control module }
       AIInfo[p] := bix[p].Name + #0;
       InitBrain(bix[p]);
+      AIInfo[P] := bix[P].Name + #0;
+      InitBrain(bix[P]);
       if Mode = moPlaying then
       begin // new game, this data version is original
         OriginalDataVersion[p] := bix[p].DataVersion;
         ProcessClientData[p] := true;
+        OriginalDataVersion[P] := bix[P].DataVersion;
+        ProcessClientData[P] := True;
       end
       else // loading game, compare with data version read from file
         ProcessClientData[p] := ProcessClientData[p] and
           (OriginalDataVersion[p] = bix[p].DataVersion);
       if @bix[p].Client = nil then // client function not found
+        ProcessClientData[P] := ProcessClientData[P] and
+          (OriginalDataVersion[P] = bix[P].DataVersion);
+      if @bix[P].Client = nil then // client function not found
         if bix[0].Kind = btNoTerm then
           bix[p] := nil
+          bix[P] := nil
         else
         begin
           bix[p] := BrainTerm;
           OriginalDataVersion[p] := -1;
           ProcessClientData[p] := false;
+          bix[P] := BrainTerm;
+          OriginalDataVersion[P] := -1;
+          ProcessClientData[P] := False;
         end;
       if Assigned(bix[p]) then
         include(BrainUsed, Brains.IndexOf(bix[p]));
+      if Assigned(bix[P]) then
+        Include(BrainUsed, Brains.IndexOf(bix[P]));
     end;
 …
     begin
       if Mode <> moMovie then
         inc(GWatching, 1 shl p1);
+        Inc(GWatching, 1 shl p1);
       if bix[p1].Kind = btAI then
         inc(GAI, 1 shl p1);
+        Inc(GAI, 1 shl p1);
       if Difficulty[p1] > 0 then
       begin
         inc(GAlive, 1 shl p1);
         inc(nAlive);
+        Inc(GAlive, 1 shl p1);
+        Inc(nAlive);
       end;
       ServerVersion[p1] := bix[p1].ServerVersion;
 …
   GTurn := 0;
   for i := 0 to nWonder - 1 do
     with GWonder[i] do
+  for I := 0 to nWonder - 1 do
+    with GWonder[I] do
     begin
       CityID := -1;
 …
   FillChar(GShip, SizeOf(GShip), 0);
   for p := 0 to nPl - 1 do
     if 1 shl p and (GAlive or GWatching) <> 0 then
       with RW[p] do
+  for P := 0 to nPl - 1 do
+    if 1 shl P and (GAlive or GWatching) <> 0 then
+      with RW[P] do
       begin
         Government := gDespotism;
 …
         AnarchyStart := -AnarchyTurns - 1;
         Happened := 0;
         LastValidStat[p] := -1;
         Worked[p] := 0;
         Founded[p] := 0;
         DevModelTurn[p] := -1;
+        LastValidStat[P] := -1;
+        Worked[P] := 0;
+        Founded[P] := 0;
+        DevModelTurn[P] := -1;
         OracleIncome := 0;
         if bix[p].DataSize > 0 then
+        if bix[P].DataSize > 0 then
         begin
           GetMem(SavedData[p], bix[p].DataSize * 4);
           GetMem(Data, bix[p].DataSize * 4);
           FillChar(SavedData[p]^, bix[p].DataSize * 4, 0);
           FillChar(Data^, bix[p].DataSize * 4, 0);
+          GetMem(SavedData[P], bix[P].DataSize * 4);
+          GetMem(Data, bix[P].DataSize * 4);
+          FillChar(SavedData[P]^, bix[P].DataSize * 4, 0);
+          FillChar(Data^, bix[P].DataSize * 4, 0);
         end
         else
         begin
           Data := nil;
           SavedData[p] := nil
+          SavedData[P] := nil;
         end;
         nBattleHistory := 0;
 …
           end
           else } BorderHelper := nil;
         for i := 0 to nStat - 1 do
           GetMem(Stat[i, p], 4 * (MaxTurn + 1));
         if bix[p].Flags and fDotNet <> 0 then
+        for I := 0 to nStat - 1 do
+          GetMem(Stat[I, P], 4 * (MaxTurn + 1));
+        if bix[P].Flags and fDotNet <> 0 then
         begin
           GetMem(RW[p].DefaultDebugMap, MapSize * 4);
           FillChar(RW[p].DefaultDebugMap^, MapSize * 4, 0);
           DebugMap[p] := RW[p].DefaultDebugMap;
+          GetMem(RW[P].DefaultDebugMap, MapSize * 4);
+          FillChar(RW[P].DefaultDebugMap^, MapSize * 4, 0);
+          DebugMap[P] := RW[P].DefaultDebugMap;
         end
         else
           RW[p].DefaultDebugMap := nil;
         { !!!for i:=0 to nShipPart-1 do GShip[p].Parts[i]:=Delphirandom((3-i)*2);{ }
+          RW[P].DefaultDebugMap := nil;
+        { !!!for i:=0 to nShipPart-1 do GShip[p].Parts[i]:=Delphirandom((3-i)*2); }
       end;
 …
   begin // random map
     InitRandomGame;
     PreviewElevation := false;
+    PreviewElevation := False;
     MapField := nil;
   end
 …
       LoadMap(MapFileName); // new game -- load map from file
     GetMem(MapField, MapSize * 4);
     move(RealMap, MapField^, MapSize * 4);
+    Move(RealMap, MapField^, MapSize * 4);
     Human := 0;
     for p1 := 0 to nPl - 1 do
       if Assigned(bix[p1]) and (bix[p1].Kind = btTerm) then
         inc(Human, 1 shl p1);
+        Inc(Human, 1 shl p1);
     InitMapGame(Human);
   end;
   CityProcessing.InitGame;
   UnitProcessing.InitGame;
   for p := 0 to nPl - 1 do
     if 1 shl p and (GAlive or GWatching) <> 0 then
       Inform(p);
+  for P := 0 to nPl - 1 do
+    if 1 shl P and (GAlive or GWatching) <> 0 then
+      Inform(P);
   pTurn := -1;
 …
   Game.LandMass := LandMass;
   Game.MaxTurn := MaxTurn;
   move(Difficulty, Game.Difficulty, SizeOf(Difficulty));
+  Move(Difficulty, Game.Difficulty, SizeOf(Difficulty));
   // GameEx.lx:=lx; GameEx.ly:=ly; GameEx.LandMass:=LandMass;
   // GameEx.MaxTurn:=MaxTurn; GameEx.RND:=RND;
   // move(Difficulty,GameEx.Difficulty,SizeOf(Difficulty));
   AICredits := '';
   for i := 0 to Brains.Count - 1 do
+  for I := 0 to Brains.Count - 1 do
   with Brains[I] do begin
     if Initialized then
       if i in BrainUsed then
+      if I in BrainUsed then
       begin
         if Kind = btAI then
           Notify(ntInitPlayers);
         for p := 0 to nPl - 1 do
+        for P := 0 to nPl - 1 do
         begin
           if Brains.IndexOf(bix[p]) = i then
             Game.RO[p] := @RW[p]
+          if Brains.IndexOf(bix[P]) = I then
+            Game.RO[P] := @RW[P]
           else
             Game.RO[p] := nil;
           if (Kind = btTerm) and (Difficulty[0] = 0) and Assigned(bix[p]) then
             Game.SuperVisorRO[p] := @RW[p]
+            Game.RO[P] := nil;
+          if (Kind = btTerm) and (Difficulty[0] = 0) and Assigned(bix[P]) then
+            Game.SuperVisorRO[P] := @RW[P]
           else
             Game.SuperVisorRO[p] := nil;
+            Game.SuperVisorRO[P] := nil;
         end;
         if Flags and fDotNet > 0 then
         begin
           Path := DLLName;
           move(Path[1], Game.AssemblyPath, Length(Path));
+          Move(Path[1], Game.AssemblyPath, Length(Path));
           Game.AssemblyPath[Length(Path)] := #0;
         end
 …
         case Mode of
           moLoading, moLoading_Fast:
             CallClient(i, cLoadGame, Game);
+            CallClient(I, cLoadGame, Game);
           moMovie:
             CallClient(i, cMovie, Game);
+            CallClient(I, cMovie, Game);
           moPlaying:
             CallClient(i, cNewGame, Game);
+            CallClient(I, cNewGame, Game);
         end;
         if (Kind = btAI) and (Credits <> '') then
 …
       else
       begin { module no longer used -- unload }
         CallClient(i, cReleaseModule, nil^);
+        CallClient(I, cReleaseModule, nil^);
         if Kind = btAI then
         begin
 …
           Client := nil;
         end;
         Initialized := false;
+        Initialized := False;
       end;
   end;
 …
   CheckBorders(-1);
 {$IFOPT O-}InvalidTreatyMap := 0; {$ENDIF}
   AutoSaveExists := false;
+  AutoSaveExists := False;
   pDipActive := -1;
   pTurn := 0;
 …
   if Mode >= moMovie then
     Notify(ntEndInfo);
 end; { StartGame }
+end;
 procedure EndGame;
 var
   i, p1: integer;
+  I, p1: Integer;
 begin
   if LandMass = 0 then
 …
     if Assigned(bix[p1]) then
     begin
       for i := 0 to nStat - 1 do
         FreeMem(Stat[i, p1]);
+      for I := 0 to nStat - 1 do
+        FreeMem(Stat[I, p1]);
       if RW[p1].BattleHistory <> nil then
         FreeMem(RW[p1].BattleHistory);
 …
 end;
 procedure GenerateStat(p: integer);
+procedure GenerateStat(P: Integer);
 var
   cix, uix: integer;
+  cix, uix: Integer;
 begin
   if Difficulty[p] > 0 then
     with RW[p] do
+  if Difficulty[P] > 0 then
+    with RW[P] do
     begin
       Stat[stPop, p, GTurn] := 0;
+      Stat[stPop, P, GTurn] := 0;
       for cix := 0 to nCity - 1 do
         if City[cix].Loc >= 0 then
           inc(Stat[stPop, p, GTurn], City[cix].Size);
       Stat[stScience, p, GTurn] := Researched[p] * 50;
       if (RW[p].ResearchTech >= 0) and (RW[p].ResearchTech <> adMilitary) then
         inc(Stat[stScience, p, GTurn], Research * 100 div TechBaseCost(nTech[p],
           Difficulty[p]));
       Stat[stMil, p, GTurn] := 0;
+          Inc(Stat[stPop, P, GTurn], City[cix].Size);
+      Stat[stScience, P, GTurn] := Researched[P] * 50;
+      if (RW[P].ResearchTech >= 0) and (RW[P].ResearchTech <> adMilitary) then
+        Inc(Stat[stScience, P, GTurn], Research * 100 div TechBaseCost(nTech[P],
+          Difficulty[P]));
+      Stat[stMil, P, GTurn] := 0;
       for uix := 0 to nUn - 1 do
         if Un[uix].Loc >= 0 then
 …
           begin
             if (Kind <= mkEnemyDeveloped) and (Un[uix].mix <> 1) then
               inc(Stat[stMil, p, GTurn], Weight * MStrength *
+              Inc(Stat[stMil, P, GTurn], Weight * MStrength *
                 Un[uix].Health div 100)
             else if Domain = dGround then
               inc(Stat[stMil, p, GTurn], (Attack + 2 * Defense) *
+              Inc(Stat[stMil, P, GTurn], (Attack + 2 * Defense) *
                 Un[uix].Health div 100)
             else
               inc(Stat[stMil, p, GTurn], (Attack + Defense) *
+              Inc(Stat[stMil, P, GTurn], (Attack + Defense) *
                 Un[uix].Health div 100);
             case Kind of
               mkSlaves:
                 inc(Stat[stPop, p, GTurn]);
+                Inc(Stat[stPop, P, GTurn]);
               mkSettler:
                 inc(Stat[stPop, p, GTurn], 2);
+                Inc(Stat[stPop, P, GTurn], 2);
             end;
           end;
       Stat[stMil, p, GTurn] := Stat[stMil, p, GTurn] div 16;
       Stat[stExplore, p, GTurn] := Discovered[p];
       Stat[stTerritory, p, GTurn] := TerritoryCount[p];
       Stat[stWork, p, GTurn] := Worked[p];
       LastValidStat[p] := GTurn;
+      Stat[stMil, P, GTurn] := Stat[stMil, P, GTurn] div 16;
+      Stat[stExplore, P, GTurn] := Discovered[P];
+      Stat[stTerritory, P, GTurn] := TerritoryCount[P];
+      Stat[stWork, P, GTurn] := Worked[P];
+      LastValidStat[P] := GTurn;
     end;
 end;
 …
 procedure LogCityTileChanges;
 var
   cix: integer;
+  cix: Integer;
 begin
   for cix := 0 to RW[pTurn].nCity - 1 do
 …
 procedure NoLogCityTileChanges;
 var
   cix: integer;
+  cix: Integer;
 begin
   for cix := 0 to RW[pTurn].nCity - 1 do
 …
 end;
 function HasCityTileChanges: boolean;
+function HasCityTileChanges: Boolean;
 var
   cix: integer;
+  cix: Integer;
 begin
   result := false;
+  Result := False;
   for cix := 0 to RW[pTurn].nCity - 1 do
     with RW[pTurn].City[cix] do
 …
         // if SavedResourceWeights[cix]<>ResourceWeights then result:=true;
         if SavedTiles[cix] <> Tiles then
           result := true;
+          Result := True;
       end;
 end;
 …
 procedure BeforeTurn0;
 var
   p1, uix: integer;
+  p1, uix: Integer;
 begin
   for uix := 0 to RW[pTurn].nUn - 1 do { init movement points for first turn }
 …
 end;
 function LoadGame(const Path, FileName: string; Turn: integer;
   MovieMode: boolean): boolean;
+function LoadGame(const Path, FileName: string; Turn: Integer;
+  MovieMode: Boolean): Boolean;
 var
   J: TBrain;
   i, ix, d, p1, Command, Subject: integer;
+  I, ix, D, p1, Command, Subject: Integer;
   K: Integer;
 {$IFDEF TEXTLOG}LoadPos0: integer; {$ENDIF}
   Data: pointer;
+{$IFDEF TEXTLOG}LoadPos0: Integer; {$ENDIF}
+  Data: Pointer;
   LogFile: TFileStream;
   FormerCLState: TCmdListState;
   s: string[255];
+  S: string[255];
   SaveMap: array [0 .. lxmax * lymax - 1] of Byte;
   Started, StatRequest: boolean;
+  Started, StatRequest: Boolean;
 begin
   SavePath := Path;
 …
     fmShareExclusive);
   LogFile.Position := 0;
   LogFile.Read(s[1], 8); { file id }
   LogFile.Read(i, 4); { c-evo version }
+  LogFile.Read(S[1], 8); { file id }
+  LogFile.Read(I, 4); { c-evo version }
   LogFile.Read(J, 4); { exe time }
   if (i >= FirstBookCompatibleVersion) and (i <= CevoVersion) then
+  if (I >= FirstBookCompatibleVersion) and (I <= CevoVersion) then
   begin
     result := true;
+    Result := True;
     LogFile.Read(lx, 4);
     LogFile.Read(ly, 4);
 …
     LogFile.Read(SaveMap, 4);
     if SaveMap[0] <> $80 then
       LogFile.read(SaveMap[4], ((MapSize - 1) div 4 + 1) * 4 - 4);
+      LogFile.Read(SaveMap[4], ((MapSize - 1) div 4 + 1) * 4 - 4);
     for p1 := 0 to nPl - 1 do
     begin
       LogFile.Read(s[0], 4);
       if s[0] = #0 then
+      LogFile.Read(S[0], 4);
+      if S[0] = #0 then
         PlayersBrain[p1] := nil
       else
       begin
         LogFile.Read(s[4], Byte(s[0]) div 4 * 4);
+        LogFile.Read(S[4], Byte(S[0]) div 4 * 4);
         LogFile.Read(OriginalDataVersion[p1], 4);
         LogFile.Read(d, 4); { behavior }
+        LogFile.Read(D, 4); { behavior }
         LogFile.Read(Difficulty[p1], 4);
         J := Brains.Last;
         while Assigned(J) and (AnsiCompareFileName(J.FileName, s) <> 0) do begin
+        while Assigned(J) and (AnsiCompareFileName(J.FileName, S) <> 0) do begin
           K := Brains.IndexOf(J) - 1;
           if K >= 0 then J := Brains[K]
 …
         if not Assigned(J) then
         begin // ai not found -- replace by local player
           ProcessClientData[p1] := false;
           NotifyMessage := s;
+          ProcessClientData[p1] := False;
+          NotifyMessage := S;
           Notify(ntAIError);
           J := BrainTerm;
         end
         else
           ProcessClientData[p1] := true;
         if j.Kind = btNoTerm then
           j := BrainSuperVirtual;
+          ProcessClientData[p1] := True;
+        if J.Kind = btNoTerm then
+          J := BrainSuperVirtual;
         // crashed tournament -- load as supervisor
         PlayersBrain[p1] := j;
+        PlayersBrain[p1] := J;
       end;
     end;
   end
   else
     Result := false;
+    Result := False;
   if Result then begin
 …
   end;
   FreeAndNil(LogFile);
   if not result then
+  if not Result then
     Exit;
 …
 {$IFDEF TEXTLOG}AssignFile(TextLog, SavePath + LogFileName + '.txt');
   Rewrite(TextLog); {$ENDIF}
   LoadOK := true;
+  LoadOK := True;
   StartGame;
   if MovieMode then
 …
     Notify(ntLoadBegin);
   started := false;
   StatRequest := false;
   MovieStopped := false;
+  started := False;
+  StatRequest := False;
+  MovieStopped := False;
 {$IFDEF LOADPERF}QueryPerformanceCounter(time_total0);
   time_a := 0;
 …
     begin
       GenerateStat(pTurn);
       StatRequest := false;
+      StatRequest := False;
     end;
     // complete all internal commands following an sTurn before generating statistics
 …
         CallPlayer(cMovieTurn, 0, nil^);
       end;
       StatRequest := true;
       started := true;
+      StatRequest := True;
+      started := True;
     end
     else if (Command = sTurn) and (pTurn = 0) and (GTurn = LoadTurn) then
     begin
       assert(CL.State.LoadPos = FormerCLState.LoadPos + 4); // size of sTurn
+      Assert(CL.State.LoadPos = FormerCLState.LoadPos + 4); // size of sTurn
       CL.State := FormerCLState;
       CL.Cut;
 …
     EndGame;
     Notify(ntStartGo);
     result := false;
     exit;
+    Result := False;
+    Exit;
   end;
   if StatRequest then
     GenerateStat(pTurn);
   assert(started);
+  Assert(started);
 {$IFDEF TEXTLOG}CloseFile(TextLog); {$ENDIF}
 {$IFDEF LOADPERF}QueryPerformanceCounter(time_total); { time in s is: (time_total-time_total0)/PerfFreq }{$ENDIF}
 …
   Inform(pTurn);
   ChangeClientWhenDone(cResume, 0, nil^, 0);
 end; // LoadGame
+end;
 procedure InsertTerritoryUpdateCommands;
 var
   p1, Command, Subject: integer;
   Data: pointer;
+  p1, Command, Subject: Integer;
+  Data: Pointer;
   FormerCLState: TCmdListState;
 begin
 …
 procedure StartNewGame(const Path, FileName, Map: string;
   Newlx, Newly, NewLandMass, NewMaxTurn: integer);
+  Newlx, Newly, NewLandMass, NewMaxTurn: Integer);
 var
   I: Integer;
 …
 end;
 procedure DirectHelp(Command: integer);
+procedure DirectHelp(Command: Integer);
 begin
   InitBrain(BrainTerm);
 …
 end;
 procedure EditMap(const Map: string; Newlx, Newly, NewLandMass: integer);
+procedure EditMap(const Map: string; Newlx, Newly, NewLandMass: Integer);
 var
   p1, Loc1: integer;
+  p1, Loc1: Integer;
   Game: TNewGameData;
 begin
 …
 end;
 procedure DestroySpacePort_TellPlayers(p, pCapturer: integer);
+procedure DestroySpacePort_TellPlayers(P, pCapturer: Integer);
 var
   cix, i, p1: integer;
+  cix, I, p1: Integer;
   ShowShipChange: TShowShipChange;
 begin
   // stop ship part production
   for cix := 0 to RW[p].nCity - 1 do
     with RW[p].City[cix] do
+  for cix := 0 to RW[P].nCity - 1 do
+    with RW[P].City[cix] do
       if (Loc >= 0) and (Project and cpImp <> 0) and
         ((Project and cpIndex = woMIR) or
         (Imp[Project and cpIndex].Kind = ikShipPart)) then
       begin
         inc(RW[p].Money, Prod0);
+        Inc(RW[P].Money, Prod0);
         Prod := 0;
         Prod0 := 0;
 …
   // destroy ship
   with GShip[p] do
+  with GShip[P] do
     if Parts[0] + Parts[1] + Parts[2] > 0 then
     begin
       for i := 0 to nShipPart - 1 do
       begin
         ShowShipChange.Ship1Change[i] := -Parts[i];
+      for I := 0 to nShipPart - 1 do
+      begin
+        ShowShipChange.Ship1Change[I] := -Parts[I];
         if pCapturer >= 0 then
         begin
           ShowShipChange.Ship2Change[i] := Parts[i];
           inc(GShip[pCapturer].Parts[i], Parts[i]);
+          ShowShipChange.Ship2Change[I] := Parts[I];
+          Inc(GShip[pCapturer].Parts[I], Parts[I]);
         end;
         Parts[i] := 0;
+        Parts[I] := 0;
       end;
       if Mode >= moMovie then
 …
         else
           ShowShipChange.Reason := scrDestruction;
         ShowShipChange.Ship1Owner := p;
+        ShowShipChange.Ship1Owner := P;
         ShowShipChange.Ship2Owner := pCapturer;
         for p1 := 0 to nPl - 1 do
           if 1 shl p1 and (GAlive or GWatching) <> 0 then
           begin
             move(GShip, RW[p1].Ship, SizeOf(GShip));
+            Move(GShip, RW[p1].Ship, SizeOf(GShip));
             if 1 shl p1 and GWatching <> 0 then
               CallPlayer(cShowShipChange, p1, ShowShipChange);
 …
 end;
 procedure DestroyCity_TellPlayers(p, cix: integer; SaveUnits: boolean);
+procedure DestroyCity_TellPlayers(P, cix: Integer; SaveUnits: Boolean);
 begin
   if RW[p].City[cix].built[imSpacePort] > 0 then
     DestroySpacePort_TellPlayers(p, -1);
   DestroyCity(p, cix, SaveUnits);
+  if RW[P].City[cix].built[imSpacePort] > 0 then
+    DestroySpacePort_TellPlayers(P, -1);
+  DestroyCity(P, cix, SaveUnits);
 end;
 procedure ChangeCityOwner_TellPlayers(pOld, cixOld, pNew: integer);
+procedure ChangeCityOwner_TellPlayers(pOld, cixOld, pNew: Integer);
 begin
   if RW[pOld].City[cixOld].built[imSpacePort] > 0 then
 …
 end;
 procedure CheckWin(p: integer);
+procedure CheckWin(P: Integer);
 var
   i: integer;
   ShipComplete: boolean;
+  I: Integer;
+  ShipComplete: Boolean;
 begin
   ShipComplete := true;
   for i := 0 to nShipPart - 1 do
     if GShip[p].Parts[i] < ShipNeed[i] then
       ShipComplete := false;
+  ShipComplete := True;
+  for I := 0 to nShipPart - 1 do
+    if GShip[P].Parts[I] < ShipNeed[I] then
+      ShipComplete := False;
   if ShipComplete then
     GWinner := GWinner or 1 shl p; // game won!
+    GWinner := GWinner or 1 shl P; // game won!
 end;
 procedure BeforeTurn;
 var
   i, p1, uix, cix, V21, Loc1, Cost, Job0, nAlive, nAppliers, ad, OldLoc,
     SiegedTiles, nUpdateLoc: integer;
   UpdateLoc: array [0 .. numax - 1] of integer;
+  I, p1, uix, cix, V21, Loc1, Cost, Job0, nAlive, nAppliers, ad, OldLoc,
+    SiegedTiles, nUpdateLoc: Integer;
+  UpdateLoc: array [0 .. numax - 1] of Integer;
   Radius: TVicinity21Loc;
   ShowShipChange: TShowShipChange;
   TribeExtinct, JobDone, MirBuilt: boolean;
+  TribeExtinct, JobDone, MirBuilt: Boolean;
 begin
 {$IFOPT O-}assert(1 shl pTurn and InvalidTreatyMap = 0); {$ENDIF}
   assert(1 shl pTurn and (GAlive or GWatching) <> 0);
+{$IFOPT O-}Assert(1 shl pTurn and InvalidTreatyMap = 0); {$ENDIF}
+  Assert(1 shl pTurn and (GAlive or GWatching) <> 0);
   if (1 shl pTurn and GAlive = 0) and (Difficulty[pTurn] > 0) then
     exit;
+    Exit;
   if (GWonder[woGrLibrary].EffectiveOwner = pTurn) and (GWinner = 0) then
 …
     for p1 := 0 to nPl - 1 do
       if 1 shl p1 and GAlive <> 0 then
         inc(nAlive);
+        Inc(nAlive);
     ad := 0;
     while ad <= (nAdv - 5) do begin
 …
           if (p1 <> pTurn) and (1 shl p1 and GAlive <> 0) and
             (RW[p1].Tech[ad] >= tsApplicable) then
             inc(nAppliers);
+            Inc(nAppliers);
         if nAppliers * 2 > nAlive then
         begin
           SeeTech(pTurn, ad);
           inc(nTech[pTurn]);
+          Inc(nTech[pTurn]);
           if Mode >= moMovie then
             CallPlayer(cShowGreatLibTech, pTurn, ad);
 …
   RW[pTurn].nEnemyUn := 0;
   MirBuilt := false;
+  MirBuilt := False;
   if (Difficulty[pTurn] > 0) and (GWinner = 0) then
     with RW[pTurn] do
 …
                   begin // transport unload
                     if Model[mix].Domain = dAir then
                       dec(Un[Master].AirLoad)
+                      Dec(Un[Master].AirLoad)
                     else
                       dec(Un[Master].TroopLoad);
+                      Dec(Un[Master].TroopLoad);
                     Master := -1;
                   end
 …
       if Mode >= moMovie then
         FillChar(ShowShipChange, SizeOf(ShowShipChange), 0);
       TribeExtinct := true;
+      TribeExtinct := True;
       nUpdateLoc := 0;
       for cix := 0 to nCity - 1 do
 …
               begin
                 Loc1 := Radius[V21];
                 assert((Loc1 >= 0) and (Loc1 < MapSize) and
+                Assert((Loc1 >= 0) and (Loc1 < MapSize) and
                   (UsedByCity[Loc1] = Loc));
                 p1 := RealMap[Loc1] shr 27;
 …
                   UsedByCity[Loc1] := -1;
                   Flags := Flags or chSiege;
                   inc(SiegedTiles);
+                  Inc(SiegedTiles);
                 end;
               end;
 …
               if not AddBestCityTile(pTurn, cix) then
                 Break;
               dec(SiegedTiles);
+              Dec(SiegedTiles);
             end;
 …
               if CityTurn(pTurn, cix) then
                 TribeExtinct := false
+                TribeExtinct := False
               else
               begin // city is erased
 …
                 Map[Loc] := Map[Loc] and not fCity; // !!! do this in inner core
                 UpdateLoc[nUpdateLoc] := Loc;
                 inc(nUpdateLoc);
                 DestroyCity_TellPlayers(pTurn, cix, true);
+                Inc(nUpdateLoc);
+                DestroyCity_TellPlayers(pTurn, cix, True);
               end;
 …
               begin
                 if Project0 and cpIndex = woMIR then // MIR completed
                   MirBuilt := true
+                  MirBuilt := True
                 else if Project0 and cpIndex = woManhattan then
                   GColdWarStart := GTurn
                 else if Imp[Project0 and cpIndex].Kind = ikShipPart
                 then { ship parts produced }
                   inc(ShowShipChange.Ship1Change[Project0 and cpIndex -
+                  Inc(ShowShipChange.Ship1Change[Project0 and cpIndex -
                     imShipComp]);
               end;
 …
       begin
         CheckBorders(-1, pTurn);
         for i := 0 to nUpdateLoc - 1 do
           UpdateUnitMap(UpdateLoc[i], true);
+        for I := 0 to nUpdateLoc - 1 do
+          UpdateUnitMap(UpdateLoc[I], True);
         if Mode >= moMovie then
           for p1 := 0 to nPl - 1 do
             if (1 shl p1 and GWatching <> 0) and (p1 <> pTurn) then
               for i := 0 to nUpdateLoc - 1 do
                 if ObserveLevel[UpdateLoc[i]] shr (2 * p1) and 3 >= lObserveUnhidden
+              for I := 0 to nUpdateLoc - 1 do
+                if ObserveLevel[UpdateLoc[I]] shr (2 * p1) and 3 >= lObserveUnhidden
                 then
                   CallPlayer(cShowCityChanged, p1, UpdateLoc[i]);
+                  CallPlayer(cShowCityChanged, p1, UpdateLoc[I]);
       end;
 …
               Movement := UnitSpeed(pTurn, mix, Health); { refresh movement }
             assert(Loc >= 0);
+            Assert(Loc >= 0);
             if Model[mix].Kind <> mkDiplomat then
             begin // check treaty violation
 …
               begin
                 AddBestCityTile(pTurn, RW[pTurn].nCity - 1);
                 UpdateUnitMap(Loc1, true);
+                UpdateUnitMap(Loc1, True);
                 if Mode >= moMovie then // tell enemies
                   for p1 := 0 to nPl - 1 do
 …
             end;
           end;
         exit
+        Exit;
       end;
 …
           DiscoverTech(pTurn, ResearchTech);
         dec(Research, Cost);
+        Dec(Research, Cost);
         Happened := Happened or phTech;
         ResearchTech := -1
+        ResearchTech := -1;
       end
       else if (ResearchTech = -2) and (nCity > 0) then
 …
             (Treaty[p1] >= trPeace) then
           begin
             inc(Credibility);
+            Inc(Credibility);
             Break;
           end;
 …
           if (p1 <> pTurn) and (1 shl p1 and (GAlive or GWatching) <> 0) then
           begin
             move(GShip, RW[p1].Ship, SizeOf(GShip));
+            Move(GShip, RW[p1].Ship, SizeOf(GShip));
             if 1 shl p1 and GWatching <> 0 then
               CallPlayer(cShowShipChange, p1, ShowShipChange);
           end
+          end;
       end;
       if WinOnAlone and (GAlive and not(1 shl pTurn or 1) = 0) then
 …
           if (p1 <> pTurn) and ((GAlive or GWatching) and (1 shl p1) <> 0) then
             RW[p1].EnemyReport[pTurn].Government := gDespotism;
         inc(Happened, phChangeGov)
+        Inc(Happened, phChangeGov);
       end;
     end; // if Difficulty[pTurn]>0
 …
   end;
   // CheckContact;
 end; { BeforeTurn }
+end;
 procedure AfterTurn;
 var
   cix, uix, p1, Loc1, Job0: integer;
   JobDone: boolean;
+  cix, uix, p1, Loc1, Job0: Integer;
+  JobDone: Boolean;
 begin
   with RW[pTurn] do
 …
       end;
     inc(Money, OracleIncome);
+    Inc(Money, OracleIncome);
     OracleIncome := 0;
     if GWonder[woOracle].EffectiveOwner = pTurn then
 …
             if (RW[p1].City[cix].Loc >= 0) and
               (RW[p1].City[cix].built[imTemple] > 0) then
               inc(OracleIncome);
+              Inc(OracleIncome);
     end;
 …
             begin
               AddBestCityTile(pTurn, RW[pTurn].nCity - 1);
               UpdateUnitMap(Loc1, true);
+              UpdateUnitMap(Loc1, True);
               if Mode >= moMovie then // tell enemies
                 for p1 := 0 to nPl - 1 do
 …
             else
             begin
               dec(Fuel);
+              Dec(Fuel);
               if Fuel < 0 then
               begin
 …
         Flags := Flags and not unWithdrawn;
         if (Loc >= 0) and (Model[mix].Domain = dGround) and (Master < 0) and
           ((integer(Movement) = Model[mix].Speed) or
+          ((Integer(Movement) = Model[mix].Speed) or
           (Model[mix].Cap[mcAcademy] > 0) and (Movement * 2 >= Model[mix].Speed))
         then
 …
           CheckWin(p1);
   end;
 end; // Afterturn
+end;
 procedure NextPlayer;
 …
 end;
 function ExecuteMove(p, uix, ToLoc: integer; var MoveInfo: TMoveInfo;
   ShowMove: TShowMove): integer;
+function ExecuteMove(P, uix, ToLoc: Integer; var MoveInfo: TMoveInfo;
+  ShowMove: TShowMove): Integer;
 var
   i, p1, FromLoc, uix1, nUpdateLoc: integer;
+  I, p1, FromLoc, uix1, nUpdateLoc: Integer;
   MinLevel, MissionResult: Cardinal;
   PModel: ^TModel;
   UpdateLoc: array [0 .. numax - 1] of integer;
   SeeFrom, SeeTo, ExtDiscover: boolean;
+  UpdateLoc: array [0 .. numax - 1] of Integer;
+  SeeFrom, SeeTo, ExtDiscover: Boolean;
 begin
   result := 0;
   with RW[p], Un[uix] do
+  Result := 0;
+  with RW[P], Un[uix] do
   begin
     PModel := @Model[mix];
 …
     if Master < 0 then
       FreeUnit(p, uix);
+      FreeUnit(P, uix);
     if (MoveInfo.MoveType in [mtMove, mtCapture]) and MoveInfo.MountainDelay
     then
 …
     Loc := -2;
     if TroopLoad + AirLoad > 0 then
       for i := 0 to nUn - 1 do
         if (Un[i].Loc >= 0) and (Un[i].Master = uix) then
           Un[i].Loc := -2;
+      for I := 0 to nUn - 1 do
+        if (Un[I].Loc >= 0) and (Un[I].Master = uix) then
+          Un[I].Loc := -2;
     UpdateUnitMap(FromLoc);
 …
           ShowMove.Flags := ShowMove.Flags or umShipLoading;
       for p1 := 0 to nPl - 1 do
         if (1 shl p1 and GWatching <> 0) and ((p1 <> p) or (bix[p1].Kind = btTerm))
+        if (1 shl p1 and GWatching <> 0) and ((p1 <> P) or (bix[p1].Kind = btTerm))
         then
         begin
 …
           else
             MinLevel := lObserveUnhidden;
           SeeFrom := (p1 = p) or (ObserveLevel[FromLoc] shr (2 * p1) and
+          SeeFrom := (p1 = P) or (ObserveLevel[FromLoc] shr (2 * p1) and
 >= MinLevel);
           SeeTo := (p1 = p) or (ObserveLevel[ToLoc] shr (2 * p1) and
+          SeeTo := (p1 = P) or (ObserveLevel[ToLoc] shr (2 * p1) and
 >= MinLevel);
           if SeeFrom and SeeTo then
           begin
             TellAboutModel(p1, p, mix);
             if p1 = p then
+            TellAboutModel(p1, P, mix);
+            if p1 = P then
               ShowMove.emix := -1
             else
               ShowMove.emix := emixSafe(p1, p, mix);
+              ShowMove.emix := emixSafe(p1, P, mix);
             if MoveInfo.MoveType = mtCapture then
               CallPlayer(cShowCapturing, p1, ShowMove)
 …
       Loc := ToLoc;
     if TroopLoad + AirLoad > 0 then
       for i := 0 to nUn - 1 do
         if Un[i].Loc = -2 then
           Un[i].Loc := ToLoc;
     ExtDiscover := false;
+      for I := 0 to nUn - 1 do
+        if Un[I].Loc = -2 then
+          Un[I].Loc := ToLoc;
+    ExtDiscover := False;
     nUpdateLoc := 0;
     if MoveInfo.MoveType = mtCapture then
     begin
       assert(Occupant[ToLoc] < 0);
+      Assert(Occupant[ToLoc] < 0);
       for uix1 := 0 to RW[MoveInfo.Defender].nUn - 1 do
         with RW[MoveInfo.Defender].Un[uix1] do
 …
           begin
             UpdateLoc[nUpdateLoc] := Loc;
             inc(nUpdateLoc);
+            Inc(nUpdateLoc);
           end;
       // unit will be removed -- remember position and update for all players
 …
       then
       begin // city captured
         ChangeCityOwner_TellPlayers(MoveInfo.Defender, MoveInfo.Dcix, p);
+        ChangeCityOwner_TellPlayers(MoveInfo.Defender, MoveInfo.Dcix, P);
         City[nCity - 1].Flags := CaptureTurns shl 16;
         CityShrink(p, nCity - 1);
+        CityShrink(P, nCity - 1);
         if Mode = moPlaying then
           with RW[p].City[nCity - 1] do
+          with RW[P].City[nCity - 1] do
           begin
             // SavedResourceWeights[nCity-1]:=ResourceWeights;
             SavedTiles[nCity - 1] := Tiles;
           end;
         ExtDiscover := true;
+        ExtDiscover := True;
         // Temple of Zeus effect
         if GWonder[woZeus].EffectiveOwner = p then
+        if GWonder[woZeus].EffectiveOwner = P then
         begin
           GiveCivilReport(p, MoveInfo.Defender);
           for i := 0 to nAdv - 1 do
             if not(i in FutureTech) and (RW[p].Tech[i] < tsSeen) and
               (RW[MoveInfo.Defender].Tech[i] >= tsApplicable) then
+          GiveCivilReport(P, MoveInfo.Defender);
+          for I := 0 to nAdv - 1 do
+            if not(I in FutureTech) and (RW[P].Tech[I] < tsSeen) and
+              (RW[MoveInfo.Defender].Tech[I] >= tsApplicable) then
             begin
               Happened := Happened or phStealTech;
 …
         end;
         if Mode = moPlaying then
           LogCheckBorders(p, nCity - 1, MoveInfo.Defender);
+          LogCheckBorders(P, nCity - 1, MoveInfo.Defender);
 {$IFOPT O-} if Mode < moPlaying then
           InvalidTreatyMap := not(1 shl p); {$ENDIF}
+          InvalidTreatyMap := not(1 shl P); {$ENDIF}
         // territory should not be considered for the rest of the command
         // execution, because during loading a game it's incorrect before
 …
       else // city destroyed
       begin
         DestroyCity_TellPlayers(MoveInfo.Defender, MoveInfo.Dcix, false);
+        DestroyCity_TellPlayers(MoveInfo.Defender, MoveInfo.Dcix, False);
         CheckBorders(ToLoc, MoveInfo.Defender);
       end;
       RecalcPeaceMap(p);
+      RecalcPeaceMap(P);
       if Mode >= moMovie then
         move(GWonder, Wonder, SizeOf(GWonder));
+        Move(GWonder, Wonder, SizeOf(GWonder));
     end; { if MoveInfo.MoveType=mtCapture }
     if MoveInfo.MoveType = mtSpyMission then
     begin
       MissionResult := DoSpyMission(p, MoveInfo.Defender, MoveInfo.Dcix,
+      MissionResult := DoSpyMission(P, MoveInfo.Defender, MoveInfo.Dcix,
         SpyMission);
       if (Mode = moPlaying) and (SpyMission = smStealForeignReports) then
         CallPlayer(cShowMissionResult, p, MissionResult);
+        CallPlayer(cShowMissionResult, P, MissionResult);
     end;
     Health := MoveInfo.EndHealth;
     dec(Movement, MoveInfo.Cost);
+    Dec(Movement, MoveInfo.Cost);
     // transport unload
     if Master >= 0 then
     begin
       if PModel.Domain = dAir then
         dec(Un[Master].AirLoad)
       else
       begin
         dec(Un[Master].TroopLoad);
         assert(Movement <= 0);
+        Dec(Un[Master].AirLoad)
+      else
+      begin
+        Dec(Un[Master].TroopLoad);
+        Assert(Movement <= 0);
       end;
       Master := -1;
 …
     if (Health <= 0) or (MoveInfo.MoveType = mtSpyMission) then
       RemoveUnit(p, uix) // spy mission or victim of HostileDamage
+      RemoveUnit(P, uix) // spy mission or victim of HostileDamage
     else
     begin // transport load
 …
       begin
         if PModel.Domain = dAir then
           inc(Un[MoveInfo.ToMaster].AirLoad)
+          Inc(Un[MoveInfo.ToMaster].AirLoad)
         else
           inc(Un[MoveInfo.ToMaster].TroopLoad);
+          Inc(Un[MoveInfo.ToMaster].TroopLoad);
       end
       else
         PlaceUnit(p, uix);
+        PlaceUnit(P, uix);
     end;
     if (MoveInfo.MoveType = mtCapture) and (nUpdateLoc > 0) then
       RecalcMapZoC(p);
+      RecalcMapZoC(P);
     UpdateUnitMap(ToLoc, MoveInfo.MoveType = mtCapture);
     for i := 0 to nUpdateLoc - 1 do
       UpdateUnitMap(UpdateLoc[i]);
+    for I := 0 to nUpdateLoc - 1 do
+      UpdateUnitMap(UpdateLoc[I]);
     // tell about lost units of defender
 …
         (RealMap[ToLoc] and fTerImp = tiFort) or
         (RealMap[ToLoc] and fTerImp = tiBase) then
         ExtDiscover := true;
+        ExtDiscover := True;
       if (PModel.Kind = mkDiplomat) or (PModel.Cap[mcSpy] > 0) then
         i := lObserveSuper
+        I := lObserveSuper
       else if (PModel.Domain = dAir) or
         (PModel.Cap[mcRadar] + PModel.Cap[mcCarrier] > 0) then
         i := lObserveAll
       else
         i := lObserveUnhidden;
+        I := lObserveAll
+      else
+        I := lObserveUnhidden;
       if ExtDiscover then
       begin
         if Discover21(ToLoc, p, i, true, PModel.Domain = dGround) then
           result := result or rEnemySpotted;
+        if Discover21(ToLoc, P, I, True, PModel.Domain = dGround) then
+          Result := Result or rEnemySpotted;
       end
       else
       begin
         if Discover9(ToLoc, p, i, true, PModel.Domain = dGround) then
           result := result or rEnemySpotted;
+        if Discover9(ToLoc, P, I, True, PModel.Domain = dGround) then
+          Result := Result or rEnemySpotted;
       end;
     end;
 …
     if Mode >= moMovie then { show after-move in interface modules }
       for p1 := 0 to nPl - 1 do
         if (1 shl p1 and GWatching <> 0) and ((p1 <> p) or (bix[p1].Kind = btTerm))
+        if (1 shl p1 and GWatching <> 0) and ((p1 <> P) or (bix[p1].Kind = btTerm))
         then
         begin
 …
           else
             MinLevel := lObserveUnhidden;
           SeeFrom := (p1 = p) or (ObserveLevel[FromLoc] shr (2 * p1) and
+          SeeFrom := (p1 = P) or (ObserveLevel[FromLoc] shr (2 * p1) and
 >= MinLevel);
           SeeTo := (p1 = p) or (ObserveLevel[ToLoc] shr (2 * p1) and
+          SeeTo := (p1 = P) or (ObserveLevel[ToLoc] shr (2 * p1) and
 >= MinLevel);
           if SeeTo and (MoveInfo.MoveType = mtCapture) then
 …
           else if (MoveInfo.MoveType <> mtSpyMission) and SeeTo then
             CallPlayer(cShowUnitChanged, p1, ToLoc);
           for i := 0 to nUpdateLoc - 1 do
             if ObserveLevel[UpdateLoc[i]] shr (2 * p1) and 3 >= lObserveUnhidden
+          for I := 0 to nUpdateLoc - 1 do
+            if ObserveLevel[UpdateLoc[I]] shr (2 * p1) and 3 >= lObserveUnhidden
             then
               CallPlayer(cShowUnitChanged, p1, UpdateLoc[i]);
+              CallPlayer(cShowUnitChanged, p1, UpdateLoc[I]);
         end;
   end;
 end; // ExecuteMove
 function ExecuteAttack(p, uix, ToLoc: integer; var MoveInfo: TMoveInfo;
   ShowMove: TShowMove): integer;
+end;
+function ExecuteAttack(P, uix, ToLoc: Integer; var MoveInfo: TMoveInfo;
+  ShowMove: TShowMove): Integer;
   procedure WriteBattleHistory(ToLoc, FromLoc, Attacker, Defender, mixAttacker,
     mixDefender: integer; AttackerLost, DefenderLost: boolean);
+    mixDefender: Integer; AttackerLost, DefenderLost: Boolean);
   var
     AttackerBattle, DefenderBattle: ^TBattle;
 …
         ReallocMem(BattleHistory, nBattleHistory * (2 * SizeOf(TBattle)));
       AttackerBattle := @BattleHistory[nBattleHistory];
       inc(nBattleHistory);
+      Inc(nBattleHistory);
     end;
     with RW[Defender] do
 …
         ReallocMem(BattleHistory, nBattleHistory * (2 * SizeOf(TBattle)));
       DefenderBattle := @BattleHistory[nBattleHistory];
       inc(nBattleHistory);
+      Inc(nBattleHistory);
     end;
     AttackerBattle.Enemy := Defender;
 …
 var
   i, p1, FromLoc, uix1, nUpdateLoc, ExpGain, ExpelToLoc, cix1: integer;
+  I, p1, FromLoc, uix1, nUpdateLoc, ExpGain, ExpelToLoc, cix1: Integer;
   PModel: ^TModel;
   UpdateLoc: array [0 .. numax - 1] of integer;
   LoseCityPop, CityDestroyed, SeeFrom, SeeTo, ZoCDefenderDestroyed: boolean;
+  UpdateLoc: array [0 .. numax - 1] of Integer;
+  LoseCityPop, CityDestroyed, SeeFrom, SeeTo, ZoCDefenderDestroyed: Boolean;
 begin
   result := 0;
   with RW[p].Un[uix] do
+  Result := 0;
+  with RW[P].Un[uix] do
   begin
     PModel := @RW[p].Model[mix];
+    PModel := @RW[P].Model[mix];
     FromLoc := Loc;
 …
     ShowMove.EndHealthDef := MoveInfo.EndHealthDef;
     if MoveInfo.MoveType = mtAttack then
       WriteBattleHistory(ToLoc, FromLoc, p, MoveInfo.Defender, mix,
+      WriteBattleHistory(ToLoc, FromLoc, P, MoveInfo.Defender, mix,
         RW[MoveInfo.Defender].Un[MoveInfo.Duix].mix, MoveInfo.EndHealth <= 0,
         MoveInfo.EndHealthDef <= 0);
 …
       begin
       if Mode>=moMovie then
       CallPlayer(cShowCancelTreaty,MoveInfo.Defender,p);
       CancelTreaty(p,MoveInfo.Defender)
+      CallPlayer(cShowCancelTreaty,MoveInfo.Defender,P);
+      CancelTreaty(P,MoveInfo.Defender)
       end; }
     if Mode >= moMovie then { show attack in interface modules }
       for p1 := 0 to nPl - 1 do
         if (1 shl p1 and GWatching <> 0) and ((p1 <> p) or (bix[p1].Kind = btTerm))
+        if (1 shl p1 and GWatching <> 0) and ((p1 <> P) or (bix[p1].Kind = btTerm))
         then
         begin
 …
           if SeeFrom and SeeTo then
           begin
             TellAboutModel(p1, p, mix);
             if p1 = p then
+            TellAboutModel(p1, P, mix);
+            if p1 = P then
               ShowMove.emix := -1
             else
               ShowMove.emix := emixSafe(p1, p, mix);
+              ShowMove.emix := emixSafe(p1, P, mix);
             CallPlayer(cShowAttacking, p1, ShowMove);
           end;
         end;
     LoseCityPop := false;
+    LoseCityPop := False;
     if (RealMap[ToLoc] and fCity <> 0) and
       ((MoveInfo.MoveType = mtAttack) and (MoveInfo.EndHealthDef <= 0) or
 …
     if MoveInfo.MoveType = mtBombard then
     begin
       assert(Movement >= 100);
+      Assert(Movement >= 100);
       if PModel.Attack = 0 then
         Flags := Flags and not unBombsLoaded;
       dec(Movement, 100);
+      Dec(Movement, 100);
     end
     else if MoveInfo.MoveType = mtExpel then
     begin
       assert(Movement >= 100);
+      Assert(Movement >= 100);
       Job := jNone;
       Flags := Flags and not unFortified;
       dec(Movement, 100);
+      Dec(Movement, 100);
     end
     else
     begin
       assert(MoveInfo.MoveType = mtAttack);
+      Assert(MoveInfo.MoveType = mtAttack);
       if MoveInfo.EndHealth = 0 then
         RemoveUnit(p, uix, MoveInfo.Defender) // destroy attacker
+        RemoveUnit(P, uix, MoveInfo.Defender) // destroy attacker
       else
       begin // update attacker
 …
           Exp := (nExp - 1) * ExpCost
         else
           inc(Exp, ExpGain);
+          Inc(Exp, ExpGain);
         Health := MoveInfo.EndHealth;
         Job := jNone;
 …
         Flags := Flags and not unFortified;
         if Movement > 100 then
           dec(Movement, 100)
+          Dec(Movement, 100)
         else
           Movement := 0;
 …
     end;
     ZoCDefenderDestroyed := false;
+    ZoCDefenderDestroyed := False;
     nUpdateLoc := 0;
     if MoveInfo.MoveType = mtExpel then
 …
           PlaceUnit(MoveInfo.Defender, MoveInfo.Duix);
           UpdateLoc[nUpdateLoc] := Loc;
           inc(nUpdateLoc);
+          Inc(nUpdateLoc);
           Flags := Flags or unWithdrawn;
         end;
 …
           Exp := (nExp - 1) * ExpCost
         else
           inc(Exp, ExpGain);
+          Inc(Exp, ExpGain);
         Health := MoveInfo.EndHealthDef;
       end
 …
           (RealMap[ToLoc] and fTerImp <> tiFort)) or LoseCityPop and
           (RW[MoveInfo.Defender].City[MoveInfo.Dcix].Size = 2) then
           RemoveAllUnits(MoveInfo.Defender, ToLoc, p)
+          RemoveAllUnits(MoveInfo.Defender, ToLoc, P)
           { no city, base or fortress }
         else
           RemoveUnit(MoveInfo.Defender, MoveInfo.Duix, p);
+          RemoveUnit(MoveInfo.Defender, MoveInfo.Duix, P);
       end;
 …
               begin
                 UpdateLoc[nUpdateLoc] := Loc;
                 inc(nUpdateLoc);
+                Inc(nUpdateLoc);
               end;
           // unit will be removed -- remember position and update for all players
           DestroyCity_TellPlayers(MoveInfo.Defender, MoveInfo.Dcix, false);
+          DestroyCity_TellPlayers(MoveInfo.Defender, MoveInfo.Dcix, False);
           CheckBorders(ToLoc, MoveInfo.Defender);
           RecalcPeaceMap(p);
+          RecalcPeaceMap(P);
         end;
     end;
     if CityDestroyed and (nUpdateLoc > 0) then
       RecalcMapZoC(p)
+      RecalcMapZoC(P)
     else if ZoCDefenderDestroyed then
       RecalcV8ZoC(p, ToLoc);
+      RecalcV8ZoC(P, ToLoc);
     UpdateUnitMap(FromLoc);
     UpdateUnitMap(ToLoc, LoseCityPop);
     for i := 0 to nUpdateLoc - 1 do
       UpdateUnitMap(UpdateLoc[i]);
+    for I := 0 to nUpdateLoc - 1 do
+      UpdateUnitMap(UpdateLoc[I]);
     // tell about lost units of defender
     if Mode >= moMovie then
     begin
       for i := 0 to RW[p].nEnemyModel - 1 do
         with RW[p].EnemyModel[i] do
           Lost := Destroyed[p, Owner, mix];
+      for I := 0 to RW[P].nEnemyModel - 1 do
+        with RW[P].EnemyModel[I] do
+          Lost := Destroyed[P, Owner, mix];
       for p1 := 0 to nPl - 1 do { show after-attack in interface modules }
         if (1 shl p1 and GWatching <> 0) and ((p1 <> p) or (bix[p1].Kind = btTerm))
+        if (1 shl p1 and GWatching <> 0) and ((p1 <> P) or (bix[p1].Kind = btTerm))
         then
         begin
 …
     end;
   end;
 end; // ExecuteAttack
 function MoveUnit(p, uix, dx, dy: integer; TestOnly: boolean): integer;
+end;
+function MoveUnit(P, uix, dx, dy: Integer; TestOnly: Boolean): Integer;
 var
   ToLoc: integer;
+  ToLoc: Integer;
   MoveInfo: TMoveInfo;
   ShowMove: TShowMove;
 begin
 {$IFOPT O-}assert(1 shl p and InvalidTreatyMap = 0); {$ENDIF}
   with RW[p].Un[uix] do
+{$IFOPT O-}Assert(1 shl P and InvalidTreatyMap = 0); {$ENDIF}
+  with RW[P].Un[uix] do
   begin
     ToLoc := dLoc(Loc, dx, dy);
     if (ToLoc < 0) or (ToLoc >= MapSize) then
     begin
       result := eInvalid;
       exit;
+      Result := eInvalid;
+      Exit;
     end;
     result := CalculateMove(p, uix, ToLoc, 3 - dy and 1, TestOnly, MoveInfo);
     if result = eZOC_EnemySpotted then
+    Result := CalculateMove(P, uix, ToLoc, 3 - dy and 1, TestOnly, MoveInfo);
+    if Result = eZOC_EnemySpotted then
       ZOCTile := ToLoc;
     if (result >= rExecuted) and not TestOnly then
+    if (Result >= rExecuted) and not TestOnly then
     begin
       ShowMove.dx := dx;
 …
       ShowMove.Exp := Exp;
       ShowMove.Load := TroopLoad + AirLoad;
       ShowMove.Owner := p;
+      ShowMove.Owner := P;
       if (TroopLoad > 0) or (AirLoad > 0) then
         ShowMove.Flags := unMulti
 …
       case MoveInfo.MoveType of
         mtMove, mtCapture, mtSpyMission:
           result := ExecuteMove(p, uix, ToLoc, MoveInfo, ShowMove) or result;
+          Result := ExecuteMove(P, uix, ToLoc, MoveInfo, ShowMove) or Result;
         mtAttack, mtBombard, mtExpel:
           result := ExecuteAttack(p, uix, ToLoc, MoveInfo, ShowMove) or result;
+          Result := ExecuteAttack(P, uix, ToLoc, MoveInfo, ShowMove) or Result;
       end;
     end;
   end; // with
 end; { MoveUnit }
 function Server(Command, Player, Subject: integer; var Data): integer; stdcall;
   function CountPrice(const Offer: TOffer; PriceType: integer): integer;
+  end;
+end;
+function Server(Command, Player, Subject: Integer; var Data): Integer; stdcall;
+  function CountPrice(const Offer: TOffer; PriceType: Integer): Integer;
   var
     i: integer;
+    I: Integer;
   begin
     result := 0;
     for i := 0 to Offer.nDeliver + Offer.nCost - 1 do
       if Offer.Price[i] and $FFFF0000 = Cardinal(PriceType) then
         inc(result);
+    Result := 0;
+    for I := 0 to Offer.nDeliver + Offer.nCost - 1 do
+      if Offer.Price[I] and $FFFF0000 = Cardinal(PriceType) then
+        Inc(Result);
   end;
 { procedure UpdateBorderHelper;
   var
   x, y, Loc, Loc1, dx, dy, ObserveMask: integer;
+  X, Y, Loc, Loc1, dx, dy, ObserveMask: Integer;
   begin
   ObserveMask:=3 shl (2*pTurn);
   for x:=0 to lx-1 do for y:=0 to ly shr 1-1 do
+  for X:=0 to lx-1 do for Y:=0 to ly shr 1-1 do
   begin
   Loc:=lx*(y*2)+x;
+  Loc:=lx*(Y*2)+X;
   if ObserveLevel[Loc] and ObserveMask<>0 then
   begin
   for dy:=0 to 1 do for dx:=0 to 1 do
   begin
   Loc1:=(Loc+dx-1+lx) mod lx +lx*((y+dy)*2-1);
+  Loc1:=(Loc+dx-1+lx) mod lx +lx*((Y+dy)*2-1);
   if (Loc1>=0) and (Loc1<MapSize)
   and (ObserveLevel[Loc1] and ObserveMask<>0) then
 …
   ptInvalid = 8;
   function ProjectType(Project: integer): integer;
+  function ProjectType(Project: Integer): Integer;
   begin
     if Project and cpCompleted <> 0 then
       result := ptSelect
+      Result := ptSelect
     else if Project and (cpImp + cpIndex) = cpImp + imTrGoods then
       result := ptTrGoods
+      Result := ptTrGoods
     else if Project and cpImp = 0 then
       if RW[Player].Model[Project and cpIndex].Kind = mkCaravan then
         result := ptCaravan
       else
         result := ptUn
+        Result := ptCaravan
+      else
+        Result := ptUn
     else if Project and cpIndex >= nImp then
       result := ptInvalid
+      Result := ptInvalid
     else if Imp[Project and cpIndex].Kind = ikWonder then
       result := ptWonder
+      Result := ptWonder
     else if Imp[Project and cpIndex].Kind = ikShipPart then
       result := ptShip
+      Result := ptShip
     else
       result := ptImp;
+      Result := ptImp;
   end;
 var
   d, i, j, p1, p2, pt0, pt1, uix1, cix1, Loc0, Loc1, dx, dy, NewCap, MinCap,
+  D, I, J, p1, p2, pt0, pt1, uix1, cix1, Loc0, Loc1, dx, dy, NewCap, MinCap,
     MaxCap, CapWeight, Cost, NextProd, Preq, TotalFood, TotalProd, CheckSum,
     StopTurn, FutureMCost, NewProject, OldImp, mix, V8, V21, AStr, DStr,
     ABaseDamage, DBaseDamage: integer;
+    ABaseDamage, DBaseDamage: Integer;
   CityReport: TCityReport;
   FormerCLState: TCmdListState;
 …
   ShowShipChange: TShowShipChange;
   ShowNegoData: TShowNegoData;
+  logged, ok, HasShipChanged, AllHumansDead, OfferFullySupported: boolean;
+begin { >>>server }
+  logged, ok, HasShipChanged, AllHumansDead, OfferFullySupported: Boolean;
+begin
   if Command = sTurn then
   begin
 …
   end;
   assert(MapSize = lx * ly);
   assert(Command and (sctMask or sExecute) <> sctInternal or sExecute);
+  Assert(MapSize = lx * ly);
+  Assert(Command and (sctMask or sExecute) <> sctInternal or sExecute);
   // not for internal commands
   if (Command < 0) or (Command >= $10000) then
   begin
     result := eUnknown;
     exit;
+    Result := eUnknown;
+    Exit;
   end;
 …
     ((Subject < 0) or (Subject >= $1000))) then
   begin
     result := eInvalid;
     exit;
+    Result := eInvalid;
+    Exit;
   end;
 …
   begin
     PutMessage(1 shl 16 + 1, Format('NOT Alive: %d', [Player]));
     result := eNoTurn;
     exit;
+    Result := eNoTurn;
+    Exit;
   end;
   result := eOK;
+  Result := eOK;
   // check if command allowed now
 …
     PutMessage(1 shl 16 + 1, Format('No Turn: %d calls %x',
       [Player, Command shr 4]));
     result := eNoTurn;
     exit;
+    Result := eNoTurn;
+    Exit;
   end;
 …
   HandoverStack[nHandoverStack] := Player + $1000;
   HandoverStack[nHandoverStack + 1] := Command;
   inc(nHandoverStack, 2);
+  Inc(nHandoverStack, 2);
   InvalidTreatyMap := 0;
 …
     FormerCLState := CL.State;
     CL.Put(Command, Player, Subject, @Data);
     logged := true;
+    logged := True;
   end
   else
     logged := false;
+    logged := False;
   case Command of
 …
     sGetDebugMap:
       pointer(Data) := DebugMap[Subject];
+      Pointer(Data) := DebugMap[Subject];
     { sChangeSuperView:
       if Difficulty[Player]=0 then
       begin
       for i:=0 to nBrain-1 do if Brain[i].Initialized then
       CallClient(i, cShowSuperView, Subject)
+      for I:=0 to nBrain-1 do if Brain[I].Initialized then
+      CallClient(I, cShowSuperView, Subject)
       end
       else result:=eInvalid; }
+      else Result:=eInvalid; }
     sRefreshDebugMap:
 …
           else
             StopTurn := RW[Player].EnemyReport[Subject].TurnOfCivilReport + 1;
         move(Stat[Command shr 4 and $F, Subject]^, Data,
           StopTurn * SizeOf(integer));
+        Move(Stat[Command shr 4 and $F, Subject]^, Data,
+          StopTurn * SizeOf(Integer));
         FillChar(TChart(Data)[StopTurn], (GTurn - StopTurn) *
           SizeOf(integer), 0);
+          SizeOf(Integer), 0);
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetTechCost:
       integer(Data) := TechCost(Player);
+      Integer(Data) := TechCost(Player);
     sGetAIInfo:
       if AIInfo[Subject] = '' then
         pchar(Data) := nil
       else
         pchar(Data) := @AIInfo[Subject][1];
+        PChar(Data) := nil
+      else
+        PChar(Data) := @AIInfo[Subject][1];
     sGetAICredits:
       if AICredits = '' then
         pchar(Data) := nil
       else
         pchar(Data) := @AICredits[1];
+        PChar(Data) := nil
+      else
+        PChar(Data) := @AICredits[1];
     sGetVersion:
       integer(Data) := CevoVersion;
+      Integer(Data) := CevoVersion;
     sGetGameChanged:
       if Player <> 0 then
         result := eInvalid
+        Result := eInvalid
       else if (CL <> nil) and (CL.State.nLog = nLogOpened) and
         (CL.State.MoveCode = 0) and not HasCityTileChanges and
         not HasChanges(Player) then
         result := eNotChanged;
+        Result := eNotChanged;
     sGetTileInfo:
       if (Subject >= 0) and (Subject < MapSize) then
         result := GetTileInfo(Player, -2, Subject, TTileInfo(Data))
       else
         result := eInvalid;
+        Result := GetTileInfo(Player, -2, Subject, TTileInfo(Data))
+      else
+        Result := eInvalid;
     sGetCityTileInfo:
       if (Subject >= 0) and (Subject < MapSize) then
         result := GetTileInfo(Player, -1, Subject, TTileInfo(Data))
       else
         result := eInvalid;
+        Result := GetTileInfo(Player, -1, Subject, TTileInfo(Data))
+      else
+        Result := eInvalid;
     sGetHypoCityTileInfo:
 …
         if (TTileInfo(Data).ExplCity < 0) or
           (TTileInfo(Data).ExplCity >= RW[Player].nCity) then
           result := eInvalid
+          Result := eInvalid
         else if ObserveLevel[Subject] shr (Player * 2) and 3 = 0 then
           result := eNoPreq
+          Result := eNoPreq
         else
           result := GetTileInfo(Player, TTileInfo(Data).ExplCity, Subject,
+          Result := GetTileInfo(Player, TTileInfo(Data).ExplCity, Subject,
             TTileInfo(Data));
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetJobProgress:
 …
       begin
         if ObserveLevel[Subject] shr (Player * 2) and 3 = 0 then
           result := eNoPreq
+          Result := eNoPreq
         else
           result := GetJobProgress(Player, Subject, TJobProgressData(Data));
+          Result := GetJobProgress(Player, Subject, TJobProgressData(Data));
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetModels:
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetUnits:
       if (Subject >= 0) and (Subject < MapSize) and
         (ObserveLevel[Subject] shr (Player * 2) and 3 = lObserveSuper) then
         integer(Data) := GetUnitStack(Player, Subject)
       else
         result := eNoPreq;
+        Integer(Data) := GetUnitStack(Player, Subject)
+      else
+        Result := eNoPreq;
     sGetDefender:
       if (Subject >= 0) and (Subject < MapSize) and (Occupant[Subject] = Player)
       then
         Strongest(Subject, integer(Data), d, i, j)
       else
         result := eInvalid;
+        Strongest(Subject, Integer(Data), D, I, J)
+      else
+        Result := eInvalid;
     sGetBattleForecast, sGetBattleForecastEx:
 …
             ((pAtt = Player) or (RWemix[Player, pAtt, mixAtt] >= 0)) then
           begin
             result := GetBattleForecast(Subject, TBattleForecast(Data), uix1,
+            Result := GetBattleForecast(Subject, TBattleForecast(Data), uix1,
               cix1, AStr, DStr, ABaseDamage, DBaseDamage);
             if Command = sGetBattleForecastEx then
 …
               TBattleForecastEx(Data).DBaseDamage := DBaseDamage;
             end;
             if result = eOK then
               result := eInvalid; // no enemy unit there!
+            if Result = eOK then
+              Result := eInvalid; // no enemy unit there!
           end
           else
             result := eInvalid
       else
         result := eInvalid;
+            Result := eInvalid
+      else
+        Result := eInvalid;
     sGetUnitReport:
       if (Subject < 0) or (Subject >= RW[Player].nUn) or
         (RW[Player].Un[Subject].Loc < 0) then
         result := eInvalid
+        Result := eInvalid
       else
         GetUnitReport(Player, Subject, TUnitReport(Data));
 …
       if (Subject < 0) or (Subject >= RW[Player].nUn) or
         (RW[Player].Un[Subject].Loc < 0) then
         result := eInvalid
       else
         result := GetMoveAdvice(Player, Subject, TMoveAdviceData(Data));
+        Result := eInvalid
+      else
+        Result := GetMoveAdvice(Player, Subject, TMoveAdviceData(Data));
     sGetPlaneReturn:
 …
         (RW[Player].Un[Subject].Loc < 0) or
         (RW[Player].Model[RW[Player].Un[Subject].mix].Domain <> dAir) then
         result := eInvalid
+        Result := eInvalid
       else
       begin
         if CanPlaneReturn(Player, Subject, TPlaneReturnData(Data)) then
           result := eOK
+          Result := eOK
         else
           result := eNoWay;
+          Result := eNoWay;
       end;
 …
           Owner := Player;
           SearchCity(Subject, Owner, cix1);
           c := RW[Owner].City[cix1];
           if (Owner <> Player) and (c.Project and cpImp = 0) then
             TellAboutModel(Player, Owner, c.Project and cpIndex);
+          C := RW[Owner].City[cix1];
+          if (Owner <> Player) and (C.Project and cpImp = 0) then
+            TellAboutModel(Player, Owner, C.Project and cpIndex);
         end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetCityReport:
       if (Subject < 0) or (Subject >= RW[Player].nCity) or
         (RW[Player].City[Subject].Loc < 0) then
         result := eInvalid
       else
         result := GetCityReport(Player, Subject, TCityReport(Data));
+        Result := eInvalid
+      else
+        Result := GetCityReport(Player, Subject, TCityReport(Data));
     sGetCityReportNew:
       if (Subject < 0) or (Subject >= RW[Player].nCity) or
         (RW[Player].City[Subject].Loc < 0) then
         result := eInvalid
+        Result := eInvalid
       else
         GetCityReportNew(Player, Subject, TCityReportNew(Data));
 …
       if (Subject < 0) or (Subject >= RW[Player].nCity) or
         (RW[Player].City[Subject].Loc < 0) then
         result := eInvalid
+        Result := eInvalid
       else
         GetCityAreaInfo(Player, RW[Player].City[Subject].Loc,
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetEnemyCityReportNew:
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetEnemyCityAreaInfo:
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sGetCityTileAdvice:
       if (Subject < 0) or (Subject >= RW[Player].nCity) or
         (RW[Player].City[Subject].Loc < 0) then
         result := eInvalid
+        Result := eInvalid
       else
         GetCityTileAdvice(Player, Subject, TCityTileAdviceData(Data));
 …
           EditTile(Loc, NewTile)
       else
         result := eInvalid;
+        Result := eInvalid;
     sRandomMap:
 …
       begin
         CreateElevation;
         PreviewElevation := false;
         CreateMap(false);
+        PreviewElevation := False;
+        CreateMap(False);
         FillChar(ObserveLevel, MapSize * 4, 0);
         DiscoverAll(Player, lObserveSuper);
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sMapGeneratorRequest:
       if not MapGeneratorAvailable then
         result := eInvalid;
+        Result := eInvalid;
+    {
 …
     sTurn, sTurn - sExecute:
       begin
         AllHumansDead := true;
+        AllHumansDead := True;
         for p1 := 0 to nPl - 1 do
           if (1 shl p1 and GAlive <> 0) and (bix[p1].Kind = btTerm) then
             AllHumansDead := false;
+            AllHumansDead := False;
         if (pDipActive >= 0) // still in negotiation mode
           or (pTurn = 0) and ((GWinner > 0) or (GTurn = MaxTurn) or
           (Difficulty[0] > 0) and AllHumansDead) then // game end reached
           result := eViolation
+          Result := eViolation
         else if Command >= sExecute then
         begin
 …
             begin
               LogChanges;
               SaveGame('~' + LogFileName, true);
+              SaveGame('~' + LogFileName, True);
             end;
 {$ENDIF}
 …
             TotalFood := 0;
             TotalProd := 0;
             for i := 0 to RW[pTurn].nCity - 1 do
               if RW[pTurn].City[i].Loc >= 0 then
+            for I := 0 to RW[pTurn].nCity - 1 do
+              if RW[pTurn].City[I].Loc >= 0 then
               begin
                 inc(TotalFood, RW[pTurn].City[i].Food);
                 inc(TotalProd, RW[pTurn].City[i].Prod);
+                Inc(TotalFood, RW[pTurn].City[I].Food);
+                Inc(TotalProd, RW[pTurn].City[I].Prod);
               end;
             CheckSum := TotalFood and 7 + TotalProd and 7 shl 3 +
 …
           begin
             if CheckSum <> Subject then
               LoadOK := false;
+              LoadOK := False;
           end
           else // save checksum
 …
             pTurn := (pTurn + 1) mod nPl;
             if pTurn = 0 then
               inc(GTurn);
+              Inc(GTurn);
             if Assigned(bix[pTurn]) and ((1 shl pTurn) and GAlive = 0) then
             begin // already made extinct -- continue statistics
 …
     sBreak, sResign, sNextRound, sReload:
       if Mode = moMovie then
         MovieStopped := true
+        MovieStopped := True
       else
       begin
 …
         begin
           ok := (Difficulty[0] = 0) and (bix[0].Kind <> btNoTerm) and
             (integer(Data) >= 0) and (integer(Data) < GTurn);
+            (Integer(Data) >= 0) and (Integer(Data) < GTurn);
           for p1 := 1 to nPl - 1 do
             if bix[p1].Kind = btTerm then
               ok := false;
+              ok := False;
           // allow reload in AI-only games only
         end
 …
           if (Command = sBreak) or (Command = sResign) then
             Notify(ntBackOn);
           for i := 0 to Brains.Count - 1 do
             if Brains[i].Initialized then
+          for I := 0 to Brains.Count - 1 do
+            if Brains[I].Initialized then
             begin
               if Brains[i].Kind = btAI then
                 Notify(ntDeinitModule, i);
               CallClient(i, cBreakGame, nil^);
+              if Brains[I].Kind = btAI then
+                Notify(ntDeinitModule, I);
+              CallClient(I, cBreakGame, nil^);
             end;
           Notify(ntEndInfo);
 …
             LogCityTileChanges;
             LogChanges;
             SaveGame(LogFileName, false);
+            SaveGame(LogFileName, False);
           end;
           DeleteFile(SavePath + '~' + LogFileName);
 …
                 LandMass, MaxTurn);
             sReload:
               LoadGame(SavePath, LogFileName, integer(Data), false);
+              LoadGame(SavePath, LogFileName, Integer(Data), False);
           end;
         end
         else
           result := eInvalid;
+          Result := eInvalid;
       end;
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     scContact .. scContact + (nPl - 1) shl 4, scContact - sExecute .. scContact
       - sExecute + (nPl - 1) shl 4:
       if (pDipActive >= 0) or (1 shl (Command shr 4 and $F) and GAlive = 0) then
         result := eInvalid
+        Result := eInvalid
       else if GWinner > 0 then
         result := eViolation // game end reached
+        Result := eViolation // game end reached
       else if RW[Player].Treaty[Command shr 4 and $F] = trNoContact then
         result := eNoPreq
+        Result := eNoPreq
       else if GTurn < GColdWarStart + ColdWarTurns then
         result := eColdWar
+        Result := eColdWar
       else if RW[Player].Government = gAnarchy then
         result := eAnarchy
+        Result := eAnarchy
       else if RW[Command shr 4 and $F].Government = gAnarchy then
       begin
         result := eAnarchy;
+        Result := eAnarchy;
         LastEndClientCommand := scReject; // enable cancel treaty
         pContacted := Command shr 4 and $F;
 …
         pContacted := Command shr 4 and $F;
         pDipActive := pContacted;
         assert(Mode = moPlaying);
+        Assert(Mode = moPlaying);
         Inform(pDipActive);
         ChangeClientWhenDone(scContact, pDipActive, pTurn, 4);
 …
         begin // contact requested and not accepted yet
           pDipActive := -1;
           assert(Mode = moPlaying);
+          Assert(Mode = moPlaying);
           ChangeClientWhenDone(cContinue, pTurn, nil^, 0);
         end;
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     scDipStart, scDipStart - sExecute:
 …
             RW[pTurn].Credibility;
           pDipActive := pTurn;
           assert(Mode = moPlaying);
+          Assert(Mode = moPlaying);
           IntServer(sIntHaveContact, pTurn, pContacted, nil^);
           ChangeClientWhenDone(scDipStart, pDipActive, nil^, 0);
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     scDipNotice, scDipAccept, scDipCancelTreaty, scDipBreak,
 …
       if pDipActive >= 0 then
       begin
         assert(Mode = moPlaying);
+        Assert(Mode = moPlaying);
         if pDipActive = pTurn then
           p1 := pContacted
 …
             // check if offer can be accepted
             if nDeliver + nCost = 0 then
               result := eOfferNotAcceptable;
             for i := 0 to nDeliver + nCost - 1 do
               if Price[i] = opChoose then
                 result := eOfferNotAcceptable;
             for i := 0 to nCost - 1 do
               if not PayPrice(pDipActive, p1, Price[nDeliver + i], false) then
                 result := eOfferNotAcceptable;
             if (Command >= sExecute) and (result >= rExecuted) then
+              Result := eOfferNotAcceptable;
+            for I := 0 to nDeliver + nCost - 1 do
+              if Price[I] = opChoose then
+                Result := eOfferNotAcceptable;
+            for I := 0 to nCost - 1 do
+              if not PayPrice(pDipActive, p1, Price[nDeliver + I], False) then
+                Result := eOfferNotAcceptable;
+            if (Command >= sExecute) and (Result >= rExecuted) then
             begin
               IntServer(sIntPayPrices + nDeliver + nCost, p1, pDipActive,
 …
               // tell other players about ship part trades
               HasShipChanged := false;
+              HasShipChanged := False;
               FillChar(ShowShipChange, SizeOf(ShowShipChange), 0);
               for i := 0 to nDeliver + nCost - 1 do
                 if Price[i] and opMask = opShipParts then
+              for I := 0 to nDeliver + nCost - 1 do
+                if Price[I] and opMask = opShipParts then
                 begin
                   HasShipChanged := true;
                   if i >= nDeliver then
+                  HasShipChanged := True;
+                  if I >= nDeliver then
                   begin // p1 has demanded from pDipActive
                     ShowShipChange.Ship1Change[Price[i] shr 16 and 3] :=
                       +integer(Price[i] and $FFFF);
                     ShowShipChange.Ship2Change[Price[i] shr 16 and 3] :=
                       -integer(Price[i] and $FFFF);
+                    ShowShipChange.Ship1Change[Price[I] shr 16 and 3] :=
+                      +Integer(Price[I] and $FFFF);
+                    ShowShipChange.Ship2Change[Price[I] shr 16 and 3] :=
+                      -Integer(Price[I] and $FFFF);
                   end
                   else
                   begin // p1 has delivered to pDipActive
                     ShowShipChange.Ship1Change[Price[i] shr 16 and 3] :=
                       -integer(Price[i] and $FFFF);
                     ShowShipChange.Ship2Change[Price[i] shr 16 and 3] :=
                       +integer(Price[i] and $FFFF);
+                    ShowShipChange.Ship1Change[Price[I] shr 16 and 3] :=
+                      -Integer(Price[I] and $FFFF);
+                    ShowShipChange.Ship2Change[Price[I] shr 16 and 3] :=
+                      +Integer(Price[I] and $FFFF);
                   end;
                 end;
 …
                     (1 shl p2 and (GAlive or GWatching) <> 0) then
                   begin
                     move(GShip, RW[p2].Ship, SizeOf(GShip));
+                    Move(GShip, RW[p2].Ship, SizeOf(GShip));
                     if 1 shl p2 and GWatching <> 0 then
                       CallPlayer(cShowShipChange, p2, ShowShipChange);
 …
             (GTurn < RW[pDipActive].LastCancelTreaty[p1] + CancelTreatyTurns)
           then
             result := eCancelTreatyRush
+            Result := eCancelTreatyRush
           else if Command >= sExecute then
           begin
 …
               if (p2 <> p1) and (1 shl p2 and PeaceEnded <> 0) then
               begin
                 i := p1 shl 4 + pDipActive;
                 CallPlayer(cShowSupportAllianceAgainst, p2, i);
+                I := p1 shl 4 + pDipActive;
+                CallPlayer(cShowSupportAllianceAgainst, p2, I);
               end;
             for p2 := 0 to nPl - 1 do
               if (p2 <> p1) and (1 shl p2 and PeaceEnded <> 0) then
               begin
                 i := p2;
                 CallPlayer(cShowCancelTreatyByAlliance, pDipActive, i);
+                I := p2;
+                CallPlayer(cShowCancelTreatyByAlliance, pDipActive, I);
               end;
           end;
         end
         else
           result := eInvalid;
         if (Command >= sExecute) and (result >= rExecuted) then
+          Result := eInvalid;
+        if (Command >= sExecute) and (Result >= rExecuted) then
           if LastEndClientCommand = scDipBreak then
           begin // break negotiation
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     scDipOffer, scDipOffer - sExecute:
 …
             pDipActive := -1;
             CallPlayer(cShowEndContact, pContacted, nil^);
             assert(Mode = moPlaying);
+            Assert(Mode = moPlaying);
             ChangeClientWhenDone(cContinue, pTurn, nil^, 0);
           end;
 …
           if RW[pDipActive].Treaty[p1] < trPeace then
           begin // no tribute allowed!
             for i := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
               if (TOffer(Data).Price[i] and opMask = opTribute) then
                 result := eInvalidOffer;
             for i := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
               if (TOffer(Data).Price[i] = opTreaty + trPeace) then
                 result := eOK;
+            for I := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
+              if (TOffer(Data).Price[I] and opMask = opTribute) then
+                Result := eInvalidOffer;
+            for I := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
+              if (TOffer(Data).Price[I] = opTreaty + trPeace) then
+                Result := eOK;
           end;
           for i := 0 to TOffer(Data).nDeliver - 1 do
             if (TOffer(Data).Price[i] <> opChoose) and
               not PayPrice(pDipActive, p1, TOffer(Data).Price[i], false) then
               result := eInvalidOffer;
+          for I := 0 to TOffer(Data).nDeliver - 1 do
+            if (TOffer(Data).Price[I] <> opChoose) and
+              not PayPrice(pDipActive, p1, TOffer(Data).Price[I], False) then
+              Result := eInvalidOffer;
           if CountPrice(TOffer(Data), opTreaty) > 1 then
             result := eInvalidOffer;
           for i := 0 to nShipPart - 1 do
             if CountPrice(TOffer(Data), opShipParts + i shl 16) > 1 then
               result := eInvalidOffer;
+            Result := eInvalidOffer;
+          for I := 0 to nShipPart - 1 do
+            if CountPrice(TOffer(Data), opShipParts + I shl 16) > 1 then
+              Result := eInvalidOffer;
           if CountPrice(TOffer(Data), opMoney) > 1 then
             result := eInvalidOffer;
+            Result := eInvalidOffer;
           if CountPrice(TOffer(Data), opTribute) > 1 then
             result := eInvalidOffer;
+            Result := eInvalidOffer;
           case CountPrice(TOffer(Data), opChoose) of
 :
 …
 :
               if (TOffer(Data).nCost = 0) or (TOffer(Data).nDeliver = 0) then
                 result := eInvalidOffer;
+                Result := eInvalidOffer;
           else
             result := eInvalidOffer;
+            Result := eInvalidOffer;
           end;
           // !!! check here if cost can be demanded
           if (Command >= sExecute) and (result >= rExecuted) then
+          if (Command >= sExecute) and (Result >= rExecuted) then
           begin
             OfferFullySupported := (TOffer(Data).nDeliver <= 2) and
               (TOffer(Data).nCost <= 2); // >2 no more allowed
             for i := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
+            for I := 0 to TOffer(Data).nDeliver + TOffer(Data).nCost - 1 do
             begin
               if TOffer(Data).Price[i] and opMask = opTribute then
                 OfferFullySupported := false;
+              if TOffer(Data).Price[I] and opMask = opTribute then
+                OfferFullySupported := False;
               // tribute no more part of the game
               if (TOffer(Data).Price[i] and opMask = opTreaty) and
                 (TOffer(Data).Price[i] - opTreaty <= RW[pDipActive].Treaty[p1])
+              if (TOffer(Data).Price[I] and opMask = opTreaty) and
+                (TOffer(Data).Price[I] - opTreaty <= RW[pDipActive].Treaty[p1])
               then
                 OfferFullySupported := false;
+                OfferFullySupported := False;
               // agreed treaty end no more part of the game
               if TOffer(Data).Price[i] = opTreaty + trCeaseFire then
                 OfferFullySupported := false;
+              if TOffer(Data).Price[I] = opTreaty + trCeaseFire then
+                OfferFullySupported := False;
               // ceasefire no more part of the game
             end;
 …
               LastOffer := TOffer(Data);
               // show offered things to receiver
               for i := 0 to LastOffer.nDeliver - 1 do
                 ShowPrice(pDipActive, p1, LastOffer.Price[i]);
+              for I := 0 to LastOffer.nDeliver - 1 do
+                ShowPrice(pDipActive, p1, LastOffer.Price[I]);
               pDipActive := p1;
               assert(Mode = moPlaying);
+              Assert(Mode = moPlaying);
               ChangeClientWhenDone(scDipOffer, pDipActive, LastOffer,
                 SizeOf(LastOffer));
             end
           end
+            end;
+          end;
         end
       else
         result := eInvalid;
+        Result := eInvalid;
+    {
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sSetTestFlag:
 …
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sSetGovernment, sSetGovernment - sExecute:
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('SetGovernment P%d: %d', [Player, Subject]); {$ENDIF}
         if RW[Player].Happened and phChangeGov = 0 then
           result := eViolation
+          Result := eViolation
         else if RW[Player].Government = Subject then
           result := eNotChanged
+          Result := eNotChanged
         else if (Subject >= nGov) then
           result := eInvalid
+          Result := eInvalid
         else if (Subject >= gMonarchy) and
           (RW[Player].Tech[GovPreq[Subject]] < tsApplicable) then
           result := eNoPreq
+          Result := eNoPreq
         else if Command >= sExecute then
         begin
 …
             then
               RW[p1].EnemyReport[Player].Government := Subject;
         end
+        end;
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('SetRates P%d: %d/%d', [Player, Subject and $F * 10, Subject shr 4 * 10]); {$ENDIF}
         if Subject and $F + Subject shr 4 > 10 then
           result := eInvalid
+          Result := eInvalid
         else if (RW[Player].TaxRate = Subject and $F * 10) and
           (RW[Player].LuxRate = Subject shr 4 * 10) then
           result := eNotChanged
+          Result := eNotChanged
         else if Command >= sExecute then
         begin
           RW[Player].TaxRate := Subject and $F * 10;
           RW[Player].LuxRate := Subject shr 4 * 10;
         end
+        end;
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('Revolution P%d', [Player]); {$ENDIF}
         if RW[Player].Government = gAnarchy then
           result := eInvalid
+          Result := eInvalid
         else
         begin
 …
           if (Mode = moPlaying) and (Subject = adMilitary) and
             (DevModelTurn[Player] <> GTurn) then
             result := eNoModel
+            Result := eNoModel
           else if Subject <> adMilitary then
           begin
 …
             begin
               if Tech[Subject] >= MaxFutureTech_Computing then
                 result := eInvalid;
+                Result := eInvalid;
             end
             else if Subject in FutureTech then
             begin
               if Tech[Subject] >= MaxFutureTech then
                 result := eInvalid;
+                Result := eInvalid;
             end
             else if Tech[Subject] >= tsApplicable then
               result := eInvalid; // already discovered
+              Result := eInvalid; // already discovered
             if Tech[Subject] <> tsSeen then // look if preqs met
               if AdvPreq[Subject, 2] <> preNone then
               begin // 2 of 3 required
                 i := 0;
                 for j := 0 to 2 do
                   if Tech[AdvPreq[Subject, j]] >= tsApplicable then
                     inc(i);
                 if i < 2 then
                   result := eNoPreq;
+                I := 0;
+                for J := 0 to 2 do
+                  if Tech[AdvPreq[Subject, J]] >= tsApplicable then
+                    Inc(I);
+                if I < 2 then
+                  Result := eNoPreq;
               end
               else if (AdvPreq[Subject, 0] <> preNone) and
 …
                 (AdvPreq[Subject, 1] <> preNone) and
                 (Tech[AdvPreq[Subject, 1]] < tsApplicable) then
                 result := eNoPreq;
+                Result := eNoPreq;
           end;
           if (result = eOK) and (Command >= sExecute) then
+          if (Result = eOK) and (Command >= sExecute) then
           begin
             if (Mode = moPlaying) and (Subject = adMilitary) then
 …
         end
         else
           result := eViolation;
+          Result := eViolation;
       end;
 …
         {$ENDIF}
         if RW[Player].Happened and phStealTech = 0 then
           result := eInvalid
+          Result := eInvalid
         else if (Subject >= nAdv) or (Subject in FutureTech) or
           (RW[Player].Tech[Subject] >= tsSeen) or
           (RW[GStealFrom].Tech[Subject] < tsApplicable) then
           result := eInvalid
+          Result := eInvalid
         else if Command >= sExecute then
         begin
           SeeTech(Player, Subject);
           dec(RW[Player].Happened, phStealTech);
+          Dec(RW[Player].Happened, phStealTech);
         end;
       end;
 …
         if (Subject >= nAttitude) or (p1 >= nPl) or
           (RW[Player].EnemyReport[p1] = nil) then
           result := eInvalid
+          Result := eInvalid
         else if RW[Player].Treaty[p1] = trNoContact then
           result := eNoPreq
+          Result := eNoPreq
         else if RW[Player].Attitude[p1] = Subject then
           result := eNotChanged
+          Result := eNotChanged
         else if Command >= sExecute then
         begin
 …
       if (LastEndClientCommand <> scReject) or
         (RW[Player].Treaty[pContacted] < trPeace) then
         result := eInvalid
+        Result := eInvalid
       else if (ServerVersion[Player] >= $010100) and
         (GTurn < RW[Player].LastCancelTreaty[pContacted] + CancelTreatyTurns)
       then
         result := eCancelTreatyRush
+        Result := eCancelTreatyRush
       else if Command >= sExecute then
       begin
 …
           if (p2 <> pContacted) and (1 shl p2 and PeaceEnded <> 0) then
           begin
             i := pContacted shl 4 + Player;
             CallPlayer(cShowSupportAllianceAgainst, p2, i);
+            I := pContacted shl 4 + Player;
+            CallPlayer(cShowSupportAllianceAgainst, p2, I);
           end;
         for p2 := 0 to nPl - 1 do
           if (p2 <> pContacted) and (1 shl p2 and PeaceEnded <> 0) then
           begin
             i := p2;
             CallPlayer(cShowCancelTreatyByAlliance, Player, i);
+            I := p2;
+            CallPlayer(cShowCancelTreatyByAlliance, Player, I);
           end;
         LastEndClientCommand := sTurn;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('CreateDevModel P%d', [Player]); {$ENDIF}
         if Subject >= 4 then
           result := eInvalid
+          Result := eInvalid
         else if (upgrade[Subject, 0].Preq <> preNone) and
           (RW[Player].Tech[upgrade[Subject, 0].Preq] < tsApplicable) then
           result := eNoPreq
+          Result := eNoPreq
         else if Command >= sExecute then
         begin
 …
             Upgrades := 0;
             FutureMCost := 0;
             for i := 0 to nUpgrade - 1 do
               with upgrade[Domain, i] do
+            for I := 0 to nUpgrade - 1 do
+              with upgrade[Domain, I] do
                 if (Preq = preNone) or (Preq >= 0) and
                   ((RW[Player].Tech[Preq] >= tsApplicable) or
 …
                   if Preq in FutureTech then
                   begin
                     j := RW[Player].Tech[Preq];
                     inc(FutureMCost, j * Cost);
+                    J := RW[Player].Tech[Preq];
+                    Inc(FutureMCost, J * Cost);
                   end
                   else
                   begin
                     j := 1;
+                    J := 1;
                     if Cost > MCost then
                       MCost := Cost;
                   end;
                   inc(Upgrades, 1 shl i);
                   inc(MStrength, j * Strength);
                   inc(MTrans, j * Trans);
+                  Inc(Upgrades, 1 shl I);
+                  Inc(MStrength, J * Strength);
+                  Inc(MTrans, J * Trans);
                 end;
             inc(MCost, FutureMCost);
+            Inc(MCost, FutureMCost);
             FillChar(Cap, SizeOf(Cap), 0);
             Cap[mcOffense] := 2;
             Cap[mcDefense] := 1;
             for i := 0 to nFeature - 1 do
               with Feature[i] do
+            for I := 0 to nFeature - 1 do
+              with Feature[I] do
                 if (1 shl Domain and Domains <> 0) and
                   ((Preq = preNone) or (Preq = preSun) and
                   (GWonder[woSun].EffectiveOwner = Player) or (Preq >= 0) and
                   (RW[Player].Tech[Preq] >= tsApplicable)) and (i in AutoFeature)
+                  (RW[Player].Tech[Preq] >= tsApplicable)) and (I in AutoFeature)
                 then
                   Cap[i] := 1;
+                  Cap[I] := 1;
             MaxWeight := 5;
             if (WeightPreq7[Domain] <> preNA) and
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('SetDevModelCap P%d', [Player]); {$ENDIF}
         if Subject >= nFeature then
           result := eInvalid
+          Result := eInvalid
         else if DevModelTurn[Player] = GTurn then
         begin
 …
           with RW[Player].DevModel do
             if 1 shl Domain and Feature[Subject].Domains = 0 then
               result := eDomainMismatch
+              Result := eDomainMismatch
             else if not((Feature[Subject].Preq = preNone) or
               (Feature[Subject].Preq = preSun) and
 …
               (Feature[Subject].Preq >= 0) and
               (RW[Player].Tech[Feature[Subject].Preq] >= tsApplicable)) then
               result := eNoPreq
+              Result := eNoPreq
             else
             begin
 …
                   MaxCap := 3;
                 if RW[Player].Tech[adSteel] >= tsApplicable then
                   inc(MaxCap);
+                  Inc(MaxCap);
               end
               else
 …
               if (NewCap < MinCap) or (NewCap > MaxCap) or
                 (Weight + (NewCap - Cap[Subject]) * CapWeight > MaxWeight) then
                 result := eViolation
+                Result := eViolation
               else if Command >= sExecute then
               begin
 …
         end
         else
           result := eNoModel;
+          Result := eNoModel;
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('RemoveUnit P%d Mod%d Loc%d', [Player, RW[Player].Un[Subject].mix, RW[Player].Un[Subject].Loc]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
           result := eInvalid
+          Result := eInvalid
         else
         begin
           result := eRemoved;
+          Result := eRemoved;
           Loc0 := RW[Player].Un[Subject].Loc;
           if RealMap[Loc0] and fCity <> 0 then { check utilize }
 …
                 (Project and cpImp = 0) and
                 (RW[Player].Model[Project and cpIndex].Kind <> mkCaravan) then
                 result := eUtilized;
+                Result := eUtilized;
               if Command >= sExecute then
               begin
                 if result = eUtilized then
+                if Result = eUtilized then
                 begin
                   with RW[Player].Un[Subject] do
                   begin
                     Cost := integer(RW[Player].Model[mix].Cost) * Health *
+                    Cost := Integer(RW[Player].Model[mix].Cost) * Health *
                       BuildCostMod[Difficulty[Player]] div 1200;
                     if RW[Player].Model[mix].Cap[mcLine] > 0 then
 …
                   end;
                   if Project and (cpImp + cpIndex) = cpImp + imTrGoods then
                     inc(RW[Player].Money, Cost)
+                    Inc(RW[Player].Money, Cost)
                   else
                   begin
                     inc(Prod, Cost * 2 div 3);
+                    Inc(Prod, Cost * 2 div 3);
                     Project0 := Project0 and not cpCompleted;
                     if Project0 and not cpAuto <> Project and not cpAuto then
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('SetUnitHome P%d Mod%d Loc%d', [Player, RW[Player].Un[Subject].mix, RW[Player].Un[Subject].Loc]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
           result := eInvalid
+          Result := eInvalid
         else
         begin
           Loc0 := RW[Player].Un[Subject].Loc;
           if RealMap[Loc0] and fCity = 0 then
             result := eInvalid
+            Result := eInvalid
           else
           begin
             SearchCity(Loc0, Player, cix1);
             if RW[Player].City[cix1].Flags and chCaptured <> 0 then
               result := eViolation
+              Result := eViolation
             else if Command >= sExecute then
               RW[Player].Un[Subject].Home := cix1;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('LoadUnit P%d Mod%d Loc%d', [Player, RW[Player].Un[Subject].mix, RW[Player].Un[Subject].Loc]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
           result := eInvalid
+          Result := eInvalid
         else
           result := LoadUnit(Player, Subject, Command < sExecute);
+          Result := LoadUnit(Player, Subject, Command < sExecute);
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('UnloadUnit P%d Mod%d Loc%d', [Player, RW[Player].Un[Subject].mix, RW[Player].Un[Subject].Loc]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
           result := eInvalid
+          Result := eInvalid
         else
           result := UnloadUnit(Player, Subject, Command < sExecute);
+          Result := UnloadUnit(Player, Subject, Command < sExecute);
       end;
     sSelectTransport, sSelectTransport - sExecute:
       if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
         result := eInvalid
+        Result := eInvalid
       else
         with RW[Player].Model[RW[Player].Un[Subject].mix] do
         begin
           if Cap[mcSeaTrans] + Cap[mcAirTrans] + Cap[mcCarrier] = 0 then
             result := eInvalid
+            Result := eInvalid
           else if Command >= sExecute then
             uixSelectedTransport := Subject;
 …
       begin
         p1 := Command shr 4 and $F;
         Loc1 := integer(Data);
+        Loc1 := Integer(Data);
         if (Occupant[Loc1] >= 0) and (p1 <> Occupant[Loc1]) or
           (RealMap[Loc1] and fCity <> 0) and
           (RealMap[Loc1] shr 27 <> Cardinal(p1)) or
           (RW[p1].Model[Subject].Domain < dAir) and
           ((RW[p1].Model[Subject].Domain = dSea) <> (RealMap[integer(Data)] and
+          ((RW[p1].Model[Subject].Domain = dSea) <> (RealMap[Integer(Data)] and
           fTerrain < fGrass)) then
           result := eViolation
+          Result := eViolation
         else if Command >= sExecute then
         begin
           CreateUnit(p1, Subject);
           RW[p1].Un[RW[p1].nUn - 1].Loc := integer(Data);
+          RW[p1].Un[RW[p1].nUn - 1].Loc := Integer(Data);
           PlaceUnit(p1, RW[p1].nUn - 1);
           UpdateUnitMap(integer(Data));
+          UpdateUnitMap(Integer(Data));
         end;
       end
       else
         result := eInvalid;
+        Result := eInvalid;
     sMoveUnit + (0 + 6 * 8) * 16, sMoveUnit + (1 + 7 * 8) * 16,
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('MoveUnit P%d I%d Mod%d Loc%d (%d,%d)', [Player, Subject, RW[Player].Un[Subject].mix, RW[Player].Un[Subject].Loc, dx, dy]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
           result := eInvalid
+          Result := eInvalid
         else
           result := MoveUnit(Player, Subject, dx, dy, Command < sExecute);
+          Result := MoveUnit(Player, Subject, dx, dy, Command < sExecute);
       end;
 …
 {$IFDEF TEXTLOG}CmdInfo := Format('AddToCity P%d Mod%d Loc%d', [Player, RW[Player].Un[Subject].mix, RW[Player].Un[Subject].Loc]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (RW[Player].Un[Subject].Loc < 0) then
           result := eInvalid
+          Result := eInvalid
         else if not(RW[Player].Model[RW[Player].Un[Subject].mix].Kind
           in [mkSettler, mkSlaves]) and
           (RW[Player].Un[Subject].Flags and unConscripts = 0) then
           result := eViolation
+          Result := eViolation
         else
         begin
           Loc0 := RW[Player].Un[Subject].Loc;
           if RealMap[Loc0] and fCity = 0 then
             result := eInvalid
+            Result := eInvalid
           else
           begin
 …
             with RW[Player].City[cix1] do
               if not CanCityGrow(Player, cix1) then
                 result := eMaxSize
+                Result := eMaxSize
               else if Command >= sExecute then
               begin { add to city }
 …
       begin
         Loc0 := RW[Player].Un[Subject].Loc;
         i := Command shr 4 and $3F; // new job
 {$IFDEF TEXTLOG}CmdInfo := Format('StartJob P%d Mod%d Loc%d: %d', [Player, RW[Player].Un[Subject].mix, Loc0, i]); {$ENDIF}
+        I := Command shr 4 and $3F; // new job
+{$IFDEF TEXTLOG}CmdInfo := Format('StartJob P%d Mod%d Loc%d: %d', [Player, RW[Player].Un[Subject].mix, Loc0, I]); {$ENDIF}
         if (Subject >= RW[Player].nUn) or (Loc0 < 0) then
           result := eInvalid
         else if i >= nJob then
           result := eInvalid
+          Result := eInvalid
+        else if I >= nJob then
+          Result := eInvalid
         else
         begin
           result := StartJob(Player, Subject, i, Command < sExecute);
           if result = eCity then
+          Result := StartJob(Player, Subject, I, Command < sExecute);
+          if Result = eCity then
           begin // new city
             cix1 := RW[Player].nCity - 1;
 …
     sSetCityProject, sSetCityProject - sExecute:
       begin
         NewProject := integer(Data) and not cpAuto;
+        NewProject := Integer(Data) and not cpAuto;
 {$IFDEF TEXTLOG}CmdInfo := Format('SetCityProject P%d Loc%d: %d', [Player, RW[Player].City[Subject].Loc, NewProject]); {$ENDIF}
         if (Subject >= RW[Player].nCity) or (RW[Player].City[Subject].Loc < 0)
         then
           result := eInvalid
+          Result := eInvalid
         else
           with RW[Player].City[Subject] do
           begin
             if NewProject = Project then
               result := eNotChanged
+              Result := eNotChanged
             else
             begin
 …
               begin
                 if NewProject and cpIndex >= RW[Player].nModel then
                   result := eInvalid
+                  Result := eInvalid
                 else if (NewProject and cpConscripts <> 0) and
                   not((RW[Player].Tech[adConscription] >= tsApplicable) and
 …
                   and (RW[Player].Model[NewProject and cpIndex].Kind < mkScout))
                 then
                   result := eViolation
+                  Result := eViolation
                   // else if (RW[Player].Model[NewProject and cpIndex].Kind=mkSlaves)
                   // and (GWonder[woPyramids].EffectiveOwner<>Player) then
 …
               end
               else if NewProject and cpIndex >= nImp then
                 result := eInvalid
+                Result := eInvalid
               else
               begin
                 Preq := Imp[NewProject and cpIndex].Preq;
                 for i := 0 to nImpReplacement - 1 do
                   if (ImpReplacement[i].OldImp = NewProject and cpIndex) and
                     (built[ImpReplacement[i].NewImp] > 0) then
                     result := eObsolete;
                 if result = eObsolete then
+                for I := 0 to nImpReplacement - 1 do
+                  if (ImpReplacement[I].OldImp = NewProject and cpIndex) and
+                    (built[ImpReplacement[I].NewImp] > 0) then
+                    Result := eObsolete;
+                if Result = eObsolete then
                 else if Preq = preNA then
                   result := eInvalid
+                  Result := eInvalid
                 else if (Preq >= 0) and (RW[Player].Tech[Preq] < tsApplicable)
                 then
                   result := eNoPreq
+                  Result := eNoPreq
                 else if built[NewProject and cpIndex] > 0 then
                   result := eInvalid
+                  Result := eInvalid
                 else if (NewProject and cpIndex < nWonder) and
                   (GWonder[NewProject and cpIndex].CityID <> WonderNotBuiltYet) then
                   result := eViolation // wonder already exists
+                  Result := eViolation // wonder already exists
                 else if (NewProject and cpIndex = imSpacePort) and
                   (RW[Player].NatBuilt[imSpacePort] > 0) then
                   result := eViolation // space port already exists
+                  Result := eViolation // space port already exists
                 else if (NewProject = cpImp + imBank) and (built[imMarket] = 0)
                   or (NewProject = cpImp + imUniversity) and
 …
                   (built[imUniversity] = 0) or (NewProject = cpImp + imMfgPlant)
                   and (built[imFactory] = 0) then
                   result := eNoPreq;
+                  Result := eNoPreq;
                 case NewProject - cpImp of
                   woLighthouse, woMagellan, imCoastalFort, imHarbor, imPlatform:
 …
                         if (Loc1 >= 0) and (Loc1 < MapSize) and
                           (RealMap[Loc1] and fTerrain = fShore) then
                           inc(Preq);
+                          Inc(Preq);
                       end;
                       if Preq = 0 then
                         result := eNoPreq;
+                        Result := eNoPreq;
                     end;
                   woHoover, imHydro:
 …
                           ((RealMap[Loc1] and fTerrain = fMountains) or
                           (RealMap[Loc1] and fRiver <> 0)) then
                           inc(Preq);
+                          Inc(Preq);
                       end;
                       if Preq = 0 then
                         result := eNoPreq;
+                        Result := eNoPreq;
                     end;
                   woMIR, imShipComp, imShipPow, imShipHab:
                     if RW[Player].NatBuilt[imSpacePort] = 0 then
                       result := eNoPreq;
+                      Result := eNoPreq;
                 end;
                 if (GTestFlags and tfNoRareNeed = 0) and
                   (Imp[NewProject and cpIndex].Kind = ikShipPart) then
                   if RW[Player].Tech[adMassProduction] < tsApplicable then
                     result := eNoPreq
+                    Result := eNoPreq
                   else
                   begin // check for rare resources
                     if NewProject and cpIndex = imShipComp then
                       j := 1
+                      J := 1
                     else if NewProject and cpIndex = imShipPow then
                       j := 2
+                      J := 2
                     else { if NewProject and cpIndex=imShipHab then }
                       j := 3;
+                      J := 3;
                     // j = rare resource required
                     Preq := 0;
 …
                       Loc1 := Radius[V21];
                       if (Loc1 >= 0) and (Loc1 < MapSize) and
                         (RealMap[Loc1] shr 25 and 3 = Cardinal(j)) then
                         inc(Preq);
+                        (RealMap[Loc1] shr 25 and 3 = Cardinal(J)) then
+                        Inc(Preq);
                     end;
                     if Preq = 0 then
                       result := eNoPreq;
+                      Result := eNoPreq;
                   end;
               end;
               if (Command >= sExecute) and (result >= rExecuted) then
+              if (Command >= sExecute) and (Result >= rExecuted) then
               begin
                 if pt0 <> ptSelect then
 …
                     and (pt0 <> ptCaravan) then
                   begin
                     inc(RW[Player].Money, Prod0);
+                    Inc(RW[Player].Money, Prod0);
                     Prod := 0;
                     Prod0 := 0;
 …
                   else
                     Prod := Prod0 * 2 div 3;
                 Project := NewProject
+                Project := NewProject;
               end;
             end;
 …
         if (Subject >= RW[Player].nCity) or (RW[Player].City[Subject].Loc < 0)
         then
           result := eInvalid
+          Result := eInvalid
         else
           with RW[Player].City[Subject] do
             if (RW[Player].Government = gAnarchy) or (Flags and chCaptured <> 0)
             then
               result := eOutOfControl
+              Result := eOutOfControl
             else if (Project and cpImp <> 0) and
               ((Project and cpIndex = imTrGoods) or
               (Imp[Project and cpIndex].Kind = ikShipPart)) then
               result := eInvalid // don't buy colony ship
+              Result := eInvalid // don't buy colony ship
             else
             begin
 …
                 Cost := Cost * 4;
               if Cost <= 0 then
                 result := eNotChanged
+                Result := eNotChanged
               else if Cost > RW[Player].Money then
                 result := eViolation
+                Result := eViolation
               else if Command >= sExecute then
                 IntServer(sIntBuyMaterial, Player, Subject, Cost);
 …
         if (Subject >= RW[Player].nCity) or (RW[Player].City[Subject].Loc < 0)
         then
           result := eInvalid
+          Result := eInvalid
         else if Command >= sExecute then
           with RW[Player].City[Subject] do
           begin
             inc(RW[Player].Money, Prod0);
+            Inc(RW[Player].Money, Prod0);
             Prod := 0;
             Prod0 := 0;
 …
     sSellCityImprovement, sSellCityImprovement - sExecute:
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('SellCityImprovement P%d Loc%d: %d', [Player, RW[Player].City[Subject].Loc, integer(Data)]); {$ENDIF}
+{$IFDEF TEXTLOG}CmdInfo := Format('SellCityImprovement P%d Loc%d: %d', [Player, RW[Player].City[Subject].Loc, Integer(Data)]); {$ENDIF}
         if (Subject >= RW[Player].nCity) or (RW[Player].City[Subject].Loc < 0)
         then
           result := eInvalid
+          Result := eInvalid
         else
           with RW[Player].City[Subject] do
             if built[integer(Data)] = 0 then
               result := eInvalid
+            if built[Integer(Data)] = 0 then
+              Result := eInvalid
             else if (RW[Player].Government = gAnarchy) or
               (Flags and chCaptured <> 0) then
               result := eOutOfControl
+              Result := eOutOfControl
             else if Flags and chImprovementSold <> 0 then
               result := eOnlyOnce
+              Result := eOnlyOnce
             else if Command >= sExecute then
             begin
               inc(RW[Player].Money, Imp[integer(Data)].Cost * BuildCostMod
+              Inc(RW[Player].Money, Imp[Integer(Data)].Cost * BuildCostMod
                 [Difficulty[Player]] div 12);
               built[integer(Data)] := 0;
               if Imp[integer(Data)].Kind in [ikNatLocal, ikNatGlobal] then
+              built[Integer(Data)] := 0;
+              if Imp[Integer(Data)].Kind in [ikNatLocal, ikNatGlobal] then
               begin
                 RW[Player].NatBuilt[integer(Data)] := 0;
                 case integer(Data) of
+                RW[Player].NatBuilt[Integer(Data)] := 0;
+                case Integer(Data) of
                   imGrWall:
                     GrWallContinent[Player] := -1;
 …
                 end;
               end;
               inc(Flags, chImprovementSold);
+              Inc(Flags, chImprovementSold);
             end;
       end;
 …
     sRebuildCityImprovement, sRebuildCityImprovement - sExecute:
       begin
         OldImp := integer(Data);
+        OldImp := Integer(Data);
 {$IFDEF TEXTLOG}CmdInfo := Format('RebuildCityImprovement P%d Loc%d: %d', [Player, RW[Player].City[Subject].Loc, OldImp]); {$ENDIF}
         if (Subject >= RW[Player].nCity) or (RW[Player].City[Subject].Loc < 0)
         then
           result := eInvalid
+          Result := eInvalid
         else
         begin
           if (OldImp < 0) or (OldImp >= nImp) or
             not(Imp[OldImp].Kind in [ikCommon, ikNatLocal, ikNatGlobal]) then
             result := eInvalid
+            Result := eInvalid
           else
             with RW[Player].City[Subject] do
 …
                 not(Imp[Project and cpIndex].Kind in [ikCommon, ikNatLocal,
                 ikNatGlobal]) then
                 result := eInvalid
+                Result := eInvalid
               else if (RW[Player].Government = gAnarchy) or
                 (Flags and chCaptured <> 0) then
                 result := eOutOfControl
+                Result := eOutOfControl
               else if Flags and chImprovementSold <> 0 then
                 result := eOnlyOnce
+                Result := eOnlyOnce
               else if Command >= sExecute then
               begin
                 inc(Prod, Imp[OldImp].Cost * BuildCostMod[Difficulty[Player]]
+                Inc(Prod, Imp[OldImp].Cost * BuildCostMod[Difficulty[Player]]
                   div 12 * 2 div 3);
                 Project0 := Project0 and not cpCompleted;
 …
                   end;
                 end;
                 inc(Flags, chImprovementSold);
+                Inc(Flags, chImprovementSold);
               end;
         end;
 …
     sSetCityTiles, sSetCityTiles - sExecute:
       begin
 {$IFDEF TEXTLOG}CmdInfo := Format('SetCityTiles P%d Loc%d: %x', [Player, RW[Player].City[Subject].Loc, integer(Data)]); {$ENDIF}
+{$IFDEF TEXTLOG}CmdInfo := Format('SetCityTiles P%d Loc%d: %x', [Player, RW[Player].City[Subject].Loc, Integer(Data)]); {$ENDIF}
         if (Subject >= RW[Player].nCity) or (RW[Player].City[Subject].Loc < 0)
         then
           result := eInvalid
+          Result := eInvalid
         else
           result := SetCityTiles(Player, Subject, integer(Data),
+          Result := SetCityTiles(Player, Subject, Integer(Data),
             Command < sExecute);
       end;
 …
     end
     else
       result := eUnknown;
+      Result := eUnknown;
   end; { case command }
   // do not log invalid and non-relevant commands
   if result = eZOC_EnemySpotted then
+  if Result = eZOC_EnemySpotted then
   begin
     assert(Mode = moPlaying);
+    Assert(Mode = moPlaying);
     CL.State := FormerCLState;
     IntServer(sIntDiscoverZOC, Player, 0, ZOCTile);
   end
   else if result and rEffective = 0 then
+  else if Result and rEffective = 0 then
     if Mode < moPlaying then
     begin
 {$IFDEF TEXTLOG}CmdInfo := Format('***ERROR (%x) ', [result]) + CmdInfo;
+{$IFDEF TEXTLOG}CmdInfo := Format('***ERROR (%x) ', [Result]) + CmdInfo;
       {$ENDIF}
       LoadOK := false;
+      LoadOK := False;
     end
     else
 …
       if logged then
         CL.State := FormerCLState;
       if (result < rExecuted) and (Command >= sExecute) then
+      if (Result < rExecuted) and (Command >= sExecute) then
         PutMessage(1 shl 16 + 1, Format('INVALID: %d calls %x (%d)',
           [Player, Command, Subject]));
 …
   if (Command and (cClientEx or sExecute or sctMask) = sExecute or sctEndClient)
     and (result >= rExecuted) then
+    and (Result >= rExecuted) then
     LastEndClientCommand := Command;
 {$IFOPT O-}dec(nHandoverStack, 2); {$ENDIF}
 end; { <<<server }
+{$IFOPT O-}Dec(nHandoverStack, 2); {$ENDIF}
+end;

branches/highdpi/Global.pas

-              r412
+              r465
     ((CevoVersionBugFix and $ff) shl 0);
 implementation
 end.

branches/highdpi/Graphics/System2.grs

-              r349
+              r465
       <Height>26</Height>
     </Item>
+    <Item>
+      <Name>BrainNoTerm</Name>
+      <Left>1</Left>
+      <Top>111</Top>
+      <Width>64</Width>
+      <Height>64</Height>
+    </Item>
+    <Item>
+      <Name>BrainSuperVirtual</Name>
+      <Left>66</Left>
+      <Top>111</Top>
+      <Width>64</Width>
+      <Height>64</Height>
+    </Item>
+    <Item>
+      <Name>BrainTerm</Name>
+      <Left>131</Left>
+      <Top>111</Top>
+      <Width>64</Width>
+      <Height>64</Height>
+    </Item>
+    <Item>
+      <Name>BrainRandom</Name>
+      <Left>131</Left>
+      <Top>46</Top>
+      <Width>64</Width>
+      <Height>64</Height>
+    </Item>
   </Items>
 </GraphicSet>

branches/highdpi/IPQ.pas

-              r303
+              r465
 { binary heap priority queue
   code contributed by Rassim Eminli }
+  Code contributed by Rassim Eminli }
 {$INCLUDE Switches.inc}
 …
 type
+  TIntegerArray = array [0 .. $40000000 div sizeof(integer)] of integer;
+  TIntegerArray = array [0 .. $40000000 div SizeOf(Integer)] of Integer;
   PIntegerArray = ^TIntegerArray;
   TheapItem = record
     Item: integer;
     Value: integer;
+    Item: Integer;
+    Value: Integer;
   end;
   TItemArray = array [0 .. $40000000 div sizeof(TheapItem)] of TheapItem;
+  TItemArray = array [0 .. $40000000 div SizeOf(TheapItem)] of TheapItem;
   PItemArray = ^TItemArray;
   TIPQ = class
     constructor Create(max: integer);
+    constructor Create(Max: Integer);
     destructor Destroy; override;
     procedure Empty;
     function Put(Item, Value: integer): boolean;
     function TestPut(Item, Value: integer): boolean;
     function Get(var Item, Value: integer): boolean;
+    function Put(Item, Value: Integer): Boolean;
+    function TestPut(Item, Value: Integer): Boolean;
+    function Get(var Item, Value: Integer): Boolean;
   private
     // n - is the size of the heap.
     // fmax - is the max size of the heap.
     n, fmax: integer;
+    N, fmax: Integer;
     // bh - stores (Value, Item) pairs of the heap.
 …
 implementation
 constructor TIPQ.Create(max: integer);
+constructor TIPQ.Create(Max: Integer);
 begin
   inherited Create;
   fmax := max;
   GetMem(bh, fmax * sizeof(TheapItem));
   GetMem(Ix, fmax * sizeof(integer));
   n := -1;
+  fmax := Max;
+  GetMem(bh, fmax * SizeOf(TheapItem));
+  GetMem(Ix, fmax * SizeOf(Integer));
+  N := -1;
   Empty;
 end;
 …
 procedure TIPQ.Empty;
 begin
   if n <> 0 then
+  if N <> 0 then
   begin
     FillChar(Ix^, fmax * sizeof(integer), 255);
     n := 0;
+    FillChar(Ix^, fmax * SizeOf(Integer), 255);
+    N := 0;
   end;
 end;
 // Parent(i) = (i-1)/2.
 function TIPQ.Put(Item, Value: integer): boolean; // O(lg(n))
+function TIPQ.Put(Item, Value: Integer): Boolean; // O(lg(n))
 var
   i, j: integer;
+  I, J: Integer;
   lbh: PItemArray;
   lIx: PIntegerArray;
 …
   lIx := Ix;
   lbh := bh;
   i := lIx[Item];
   if i >= 0 then
+  I := lIx[Item];
+  if I >= 0 then
   begin
     if lbh[i].Value <= Value then
+    if lbh[I].Value <= Value then
     begin
       result := False;
       exit;
+      Result := False;
+      Exit;
     end;
   end
   else
   begin
     i := n;
     Inc(n);
+    I := N;
+    Inc(N);
   end;
   while i > 0 do
+  while I > 0 do
   begin
     j := (i - 1) shr 1; // Parent(i) = (i-1)/2
     if Value >= lbh[j].Value then
       break;
     lbh[i] := lbh[j];
     lIx[lbh[i].Item] := i;
     i := j;
+    J := (I - 1) shr 1; // Parent(i) = (i-1)/2
+    if Value >= lbh[J].Value then
+      Break;
+    lbh[I] := lbh[J];
+    lIx[lbh[I].Item] := I;
+    I := J;
   end;
   // Insert the new Item at the insertion point found.
   lbh[i].Value := Value;
   lbh[i].Item := Item;
   lIx[lbh[i].Item] := i;
   result := True;
+  lbh[I].Value := Value;
+  lbh[I].Item := Item;
+  lIx[lbh[I].Item] := I;
+  Result := True;
 end;
 function TIPQ.TestPut(Item, Value: integer): boolean;
+function TIPQ.TestPut(Item, Value: Integer): Boolean;
 var
   i: integer;
+  I: Integer;
 begin
   i := Ix[Item];
   result := (i < 0) or (bh[i].Value > Value);
+  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 TIPQ.Get(var Item, Value: integer): boolean; // O(lg(n))
+function TIPQ.Get(var Item, Value: Integer): Boolean; // O(lg(n))
 var
   i, j: integer;
   last: TheapItem;
+  I, J: Integer;
+  Last: TheapItem;
   lbh: PItemArray;
 begin
   if n = 0 then
+  if N = 0 then
   begin
     result := False;
     exit;
+    Result := False;
+    Exit;
   end;
 …
   Ix[Item] := -1;
   dec(n);
   if n > 0 then
+  Dec(N);
+  if N > 0 then
   begin
     last := lbh[n];
     i := 0;
     j := 1;
     while j < n do
+    Last := lbh[N];
+    I := 0;
+    J := 1;
+    while J < N do
     begin
       // Right(i) = Left(i)+1
       if (j < n - 1) and (lbh[j].Value > lbh[j + 1].Value) then
         Inc(j);
       if last.Value <= lbh[j].Value then
         break;
+      if (J < N - 1) and (lbh[J].Value > lbh[J + 1].Value) then
+        Inc(J);
+      if Last.Value <= lbh[J].Value then
+        Break;
       lbh[i] := lbh[j];
       Ix[lbh[i].Item] := i;
       i := j;
       j := j shl 1 + 1; // Left(j) = 2*j+1
+      lbh[I] := lbh[J];
+      Ix[lbh[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.
     lbh[i] := last;
     Ix[last.Item] := i;
+    lbh[I] := Last;
+    Ix[Last.Item] := I;
   end;
   result := True
+  Result := True;
 end;

branches/highdpi/Inp.pas

-              r412
+              r465
     procedure CenterToRect(Rect: TRect);
   private
     Center: boolean;
+    Center: Boolean;
   end;
 var
   InputDlg: TInputDlg;
 implementation
 …
 , Caption);
   { Corner(canvas,1,1,0,MainTexture);
     Corner(canvas,ClientWidth-9,1,1,MainTexture);
     Corner(canvas,1,ClientHeight-9,2,MainTexture);
     Corner(canvas,ClientWidth-9,ClientHeight-9,3,MainTexture); }
+    Corner(Canvas,ClientWidth-9,1,1,MainTexture);
+    Corner(Canvas,1,ClientHeight-9,2,MainTexture);
+    Corner(Canvas,ClientWidth-9,ClientHeight-9,3,MainTexture); }
 end;

branches/highdpi/Install/rpm/c-evo.spec

-              r405
+              r465
 Requires:       sox
+#BuildRequires:  lazarus
+BuildRequires:  lazarus >= 2.0.12
 %description
 Turn-based empire building game inspired by Civilization.
+A turn-based empire building game inspired by Civilization.
 %global debug_package %{nil}
 …
 /usr/bin/c-evo
 /usr/share/applications/c-evo.desktop
 /usr/share/c-evo/*
+/usr/share/c-evo/
 /usr/share/pixmaps/c-evo.png

branches/highdpi/Install/snap/local/build.sh

r405	r465
4	4
5	5	pushd ../../..
6		snapcraft --debug --use-lxd
	6	snapcraft --debug --use-lxd $@
7	7	popd
8	8

branches/highdpi/Install/snap/snapcraft.yaml

-              r405
+              r465
 description: |
   This is a fork and Lazarus/FPC port of the original C-evo 1.2.0 game.
   Now it is finally possible to play C-evo natively on Linux.
+  Now it is finally possible to play C-evo natively on Linux.
   * Zoomable map by mouse wheel with three tile sizes
   * Many sample maps included
+  * All available localizations include
+  * Multiple localizations included
+  * Support for user defined key mapping
   * Many other small improvements
 confinement: strict
 base: core20
+confinement: devmode
+base: core22
 grade: stable
 icon: Graphics/c-evo_64x64.png
 license: NLPL
 environment:
   LD_LIBRARY_PATH: $SNAP/usr/lib/$SNAPCRAFT_ARCH_TRIPLET/pulseaudio
+environment:
+  LD_LIBRARY_PATH: $SNAP_LIBRARY_PATH:$SNAP/lib:$SNAP/usr/lib:$SNAP/usr/lib/x86_64-linux-gnu:$SNAP/usr/lib/$SNAPCRAFT_ARCH_TRIPLET/pulseaudio
   PULSE_SERVER: unix:/run/user/1000/pulse/native
 layout:
   /usr/lib/$SNAPCRAFT_ARCH_TRIPLET/sox:
     bind: $SNAP/usr/lib/$SNAPCRAFT_ARCH_TRIPLET/sox
+    bind: $SNAP/usr/lib/$SNAPCRAFT_ARCH_TRIPLET/sox
 parts:
 …
     source: .
     source-type: local
+    build-packages:
+    - fpc
+    - lazarus
+    - lcl
+    - lcl-utils
+    stage-packages:
+    after: [lazarus]
+    stage-packages:
     - sox
     - libsox-fmt-mp3
 …
     override-build: |
       snapcraftctl build
       (cd AI/StdAI &&lazbuild --build-mode=Release StdAI.lpi)
+      (cd AI/StdAI &&lazbuild --build-mode=Debug StdAI.lpi)
       mv AI/StdAI/libstdai.so AI/StdAI/libstdai-amd64.so
+      lazbuild --build-mode=Release Integrated.lpi
+      ROOT=/root/parts/c-evo/install
+      install -d -m 755 $ROOT/usr/share/c-evo
+      install -s -m 755 c-evo $ROOT/usr/share/c-evo
+      install -m 644 Language.txt $ROOT/usr/share/c-evo
+      install -m 644 Language2.txt $ROOT/usr/share/c-evo
+      install -m 644 Fonts.txt $ROOT/usr/share/c-evo
+      install -d -m 755 $ROOT/usr/share/applications
+      install -m 755 Install/deb/c-evo.desktop $ROOT/usr/share/applications
+      install -d -m 755 $ROOT/usr/share/mime/packages
+      install -m 755 Install/deb/c-evo.xml $ROOT/usr/share/mime/packages
+      install -d -m 755 $ROOT/usr/share/pixmaps
+      install -m 644 Graphics/c-evo_64x64.png $ROOT/usr/share/pixmaps/c-evo.png
+      install -m 644 Graphics/c-evo_64x64.png $ROOT/usr/share/pixmaps/application-cevo.png
+      install -m 644 Graphics/c-evo_64x64.png $ROOT/usr/share/pixmaps/application-cevomap.png
+      install -d -m 755 $ROOT/usr/share/c-evo/AI/StdAI
+      install -m 644 AI/StdAI/libstdai-amd64.so $ROOT/usr/share/c-evo/AI/StdAI
+      install -m 644 AI/StdAI/StdAI.ai.txt $ROOT/usr/share/c-evo/AI/StdAI
+      install -m 644 AI/StdAI/StdAI.png $ROOT/usr/share/c-evo/AI/StdAI
+      cp -r Graphics $ROOT/usr/share/c-evo
+      cp -r Help $ROOT/usr/share/c-evo
+      cp -r Sounds $ROOT/usr/share/c-evo
+      cp -r Tribes $ROOT/usr/share/c-evo
+      cp -r Localization $ROOT/usr/share/c-evo
+      cp -r Maps $ROOT/usr/share/c-evo
+      cp -r Saved $ROOT/usr/share/c-evo
+      cp -r "AI Template" $ROOT/usr/share/c-evo
+      lazbuild --build-mode=Debug Integrated.lpi
+      install -d -m 755 $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      install -s -m 755 c-evo $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      install -m 644 Language.txt $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      install -m 644 Language2.txt $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      install -m 644 Fonts.txt $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      install -d -m 755 $SNAPCRAFT_PART_INSTALL/usr/share/applications
+      install -m 755 Install/deb/c-evo.desktop $SNAPCRAFT_PART_INSTALL/usr/share/applications
+      install -d -m 755 $SNAPCRAFT_PART_INSTALL/usr/share/mime/packages
+      install -m 644 Install/deb/c-evo.xml $SNAPCRAFT_PART_INSTALL/usr/share/mime/packages
+      install -d -m 755 $SNAPCRAFT_PART_INSTALL/usr/share/pixmaps
+      install -m 644 Graphics/c-evo_64x64.png $SNAPCRAFT_PART_INSTALL/usr/share/pixmaps/c-evo.png
+      install -m 644 Graphics/c-evo_64x64.png $SNAPCRAFT_PART_INSTALL/usr/share/pixmaps/application-cevo.png
+      install -m 644 Graphics/c-evo_64x64.png $SNAPCRAFT_PART_INSTALL/usr/share/pixmaps/application-cevomap.png
+      install -d -m 755 $SNAPCRAFT_PART_INSTALL/usr/share/c-evo/AI/StdAI
+      install -m 644 AI/StdAI/libstdai-amd64.so $SNAPCRAFT_PART_INSTALL/usr/share/c-evo/AI/StdAI
+      install -m 644 AI/StdAI/StdAI.ai.txt $SNAPCRAFT_PART_INSTALL/usr/share/c-evo/AI/StdAI
+      install -m 644 AI/StdAI/StdAI.png $SNAPCRAFT_PART_INSTALL/usr/share/c-evo/AI/StdAI
+      cp -r Graphics $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r Help $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r Sounds $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r Tribes $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r Localization $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r Maps $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r Saved $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
+      cp -r "AI Template" $SNAPCRAFT_PART_INSTALL/usr/share/c-evo
     stage:
       - etc
 …
       - usr/share/applications/c-evo.desktop
       - usr/share/mime/packages/c-evo.xml
+  lazarus:
+    plugin: nil
+    source: .
+    source-type: local
+    build-packages:
+    - wget
+    - libgtk2.0-dev
+    override-build: |
+      wget -nc https://downloads.sourceforge.net/project/lazarus/Lazarus%20Linux%20amd64%20DEB/Lazarus%202.2.2/lazarus-project_2.2.2-0_amd64.deb
+      wget -nc https://downloads.sourceforge.net/project/lazarus/Lazarus%20Linux%20amd64%20DEB/Lazarus%202.2.2/fpc-laz_3.2.2-210709_amd64.deb
+      wget -nc https://downloads.sourceforge.net/project/lazarus/Lazarus%20Linux%20amd64%20DEB/Lazarus%202.2.2/fpc-src_3.2.2-210709_amd64.deb
+      apt install ./lazarus-project_2.2.2-0_amd64.deb ./fpc-laz_3.2.2-210709_amd64.deb ./fpc-src_3.2.2-210709_amd64.deb
+    stage: [-*]
+    prime: [-*]
 apps:
   c-evo:
     command: usr/share/c-evo/c-evo
     desktop: usr/share/applications/c-evo.desktop
+    desktop: usr/share/applications/c-evo.desktop
     plugs:
       - home

branches/highdpi/Integrated.lpi

-              r405
+              r465
 <CONFIG>
   <ProjectOptions>
     <Version Value="11"/>
+    <Version Value="12"/>
     <PathDelim Value="\"/>
     <General>
 …
         <MainUnitHasCreateFormStatements Value="False"/>
         <MainUnitHasTitleStatement Value="False"/>
+        <CompatibilityMode Value="True"/>
       </Flags>
       <SessionStorage Value="InProjectDir"/>
-      <MainUnit Value="0"/>
       <Title Value="Integrated"/>
       <UseAppBundle Value="False"/>
 …
             <Debugging>
               <GenerateDebugInfo Value="False"/>
+              <DebugInfoType Value="dsDwarf2Set"/>
             </Debugging>
             <LinkSmart Value="True"/>
 …
       </Item4>
     </RequiredPackages>
     <Units Count="48">
+    <Units Count="47">
       <Unit0>
         <Filename Value="Integrated.lpr"/>
 …
       </Unit40>
       <Unit41>
         <Filename Value="LocalPlayer\UKeyBindings.pas"/>
+        <Filename Value="LocalPlayer\KeyBindings.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit41>
       <Unit42>
         <Filename Value="UMiniMap.pas"/>
+        <Filename Value="MiniMap.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit42>
       <Unit43>
         <Filename Value="UBrain.pas"/>
+        <Filename Value="Brain.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit43>
       <Unit44>
         <Filename Value="Network\UNetworkServer.pas"/>
+        <Filename Value="Network\NetworkServer.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit44>
       <Unit45>
         <Filename Value="Network\UNetworkClient.pas"/>
+        <Filename Value="Network\NetworkClient.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit45>
       <Unit46>
         <Filename Value="Network\UNetworkCommon.pas"/>
+        <Filename Value="Network\NetworkCommon.pas"/>
         <IsPartOfProject Value="True"/>
       </Unit46>
-      <Unit47>
-        <Filename Value="ULanguages.pas"/>
-        <IsPartOfProject Value="True"/>
-      </Unit47>
     </Units>
   </ProjectOptions>
 …
     <Linking>
       <Debugging>
+        <DebugInfoType Value="dsDwarf2Set"/>
+        <UseHeaptrc Value="True"/>
         <UseExternalDbgSyms Value="True"/>
       </Debugging>

branches/highdpi/Integrated.lpr

-              r405
+              r465
   cthreads, clocale,
   {$ENDIF}
   UDpiControls, Forms, Interfaces, SysUtils, Protocol, GameServer, Direct, Start, Messg, Inp,
+  Forms, Interfaces, SysUtils, Protocol, GameServer, Direct, Start, Messg, Inp,
   Back, Log, LocalPlayer, ClientTools, Tribes, IsoEngine, Term, CityScreen, Nego,
   NoTerm, ScreenTools, Directories;
+  NoTerm, ScreenTools, Directories, UDpiControls;
 {$if declared(UseHeapTrace)}
 …
   DotNetClient := nil;
   DpiApplication.Initialize;
+  DpiApplication.Title := 'c-evo';
+  DpiApplication.Title := 'C-evo';
+  DpiApplication.TaskBarBehavior := tbMultiButton;
   Directories.UnitInit;
   ScreenTools.UnitInit;

branches/highdpi/Language.txt

r405	r465
140	140	#TITLE_SPYMISSION Covert Operation
141	141	#TITLE_SUICIDE Suicide Mission
	142	#TITLE_MESSAGE Message
142	143	#FRMILREP Military Report
143	144

branches/highdpi/LocalPlayer/Battle.pas

-              r361
+              r465
     uix, ToLoc: Integer;
     Forecast: TBattleForecastEx;
+    IsSuicideQuery: boolean;
+  end;
+var
+  BattleDlg: TBattleDlg;
+    IsSuicideQuery: Boolean;
+  end;
 implementation
 …
   TextSize: TSize;
   LabelText: string;
   FirstStrike: boolean;
+  FirstStrike: Boolean;
 begin
   MaxBar := 65;
 …
     VLightGradient(ca, xm - 8, ym + 8 + LABaseDamage, LADamage - LABaseDamage,
       FanaticColor);
   DpiBitCanvas(ca, xm - 12, ym - 12, 24, 24,
+  DpiBitBltCanvas(ca, xm - 12, ym - 12, 24, 24,
     HGrSystem.Mask.Canvas, 26, 146, SRCAND);
   DpiBitCanvas(ca, xm - 12, ym - 12, 24, 24,
+  DpiBitBltCanvas(ca, xm - 12, ym - 12, 24, 24,
     HGrSystem.Data.Canvas, 26, 146, SRCPAINT);
 …
   if Forecast.EndHealthDef <= 0 then
   begin
     DpiBitCanvas(ca, xm + 9 + LDDamage - 7, ym - 6, 14, 17,
+    DpiBitBltCanvas(ca, xm + 9 + LDDamage - 7, ym - 6, 14, 17,
       HGrSystem.Mask.Canvas, 51, 153, SRCAND);
     DpiBitCanvas(ca, xm + 8 + LDDamage - 7, ym - 7, 14, 17,
+    DpiBitBltCanvas(ca, xm + 8 + LDDamage - 7, ym - 7, 14, 17,
       HGrSystem.Mask.Canvas, 51, 153, SRCAND);
     DpiBitCanvas(ca, xm + 8 + LDDamage - 7, ym - 7, 14, 17,
+    DpiBitBltCanvas(ca, xm + 8 + LDDamage - 7, ym - 7, 14, 17,
       HGrSystem.Data.Canvas, 51, 153, SRCPAINT);
   end;
 …
   begin
     if Forecast.EndHealthDef > 0 then
       RisedTextOut(ca, xm + 10, ym - (TextSize.cy + 1) div 2, LabelText)
+      RisedTextOut(ca, xm + 10, ym - (TextSize.cy + 1) div 2, LabelText);
   end
   else
 …
   if Forecast.EndHealthAtt <= 0 then
   begin
     DpiBitCanvas(ca, xm - 6, ym + 9 + LADamage - 7, 14, 17,
+    DpiBitBltCanvas(ca, xm - 6, ym + 9 + LADamage - 7, 14, 17,
       HGrSystem.Mask.Canvas, 51, 153, SRCAND);
     DpiBitCanvas(ca, xm - 7, ym + 8 + LADamage - 7, 14, 17,
+    DpiBitBltCanvas(ca, xm - 7, ym + 8 + LADamage - 7, 14, 17,
       HGrSystem.Mask.Canvas, 51, 153, SRCAND);
     DpiBitCanvas(ca, xm - 7, ym + 8 + LADamage - 7, 14, 17,
+    DpiBitBltCanvas(ca, xm - 7, ym + 8 + LADamage - 7, 14, 17,
       HGrSystem.Data.Canvas, 51, 153, SRCPAINT);
   end;
 …
     if Forecast.EndHealthAtt > 0 then
       RisedTextOut(ca, xm - (TextSize.cx + 1) div 2, ym + 8 + LAAvoidedDamage,
         LabelText)
+        LabelText);
   end
   else
 …
   IsoMap.SetOutput(Buffer);
   DpiBitCanvas(Buffer.Canvas, 0, 0, 66, 48, ca, xm + 8 + 4,
+  DpiBitBltCanvas(Buffer.Canvas, 0, 0, 66, 48, ca, xm + 8 + 4,
     ym - 8 - 12 - 48);
   { if TerrType<fForest then
 …
     end; }
   IsoMap.PaintUnit(1, 0, UnitInfo, 0);
   DpiBitCanvas(ca, xm + 8 + 4, ym - 8 - 12 - 48, 66, 48, Buffer.Canvas,
+  DpiBitBltCanvas(ca, xm + 8 + 4, ym - 8 - 12 - 48, 66, 48, Buffer.Canvas,
 , 0);
   DpiBitCanvas(Buffer.Canvas, 0, 0, 66, 48, ca, xm - 8 - 4 - 66,
+  DpiBitBltCanvas(Buffer.Canvas, 0, 0, 66, 48, ca, xm - 8 - 4 - 66,
     ym + 8 + 12);
   MakeUnitInfo(me, MyUn[uix], UnitInfo);
+  MakeUnitInfo(Me, MyUn[uix], UnitInfo);
   UnitInfo.Flags := UnitInfo.Flags and not unFortified;
   IsoMap.PaintUnit(1, 0, UnitInfo, 0);
   DpiBitCanvas(ca, xm - 8 - 4 - 66, ym + 8 + 12, 66, 48, Buffer.Canvas, 0, 0);
 end; { PaintBattleOutcome }
+  DpiBitBltCanvas(ca, xm - 8 - 4 - 66, ym + 8 + 12, 66, 48, Buffer.Canvas, 0, 0);
+end;
 procedure TBattleDlg.FormCreate(Sender: TObject);
 …
     ClientWidth := 300;
     ClientHeight := 288;
     OKBtn.Visible := true;
     CancelBtn.Visible := true;
+    OKBtn.Visible := True;
+    CancelBtn.Visible := True;
     Left := (DpiScreen.Width - ClientWidth) div 2; // center on screen
     Top := (DpiScreen.Height - ClientHeight) div 2;
 …
     ClientWidth := 178;
     ClientHeight := 178;
     OKBtn.Visible := false;
     CancelBtn.Visible := false;
+    OKBtn.Visible := False;
+    CancelBtn.Visible := False;
   end;
 end;
 …
 procedure TBattleDlg.FormPaint(Sender: TObject);
 var
   ym, cix, p: Integer;
   s, s1: string;
+  ym, cix, P: Integer;
+  S, s1: string;
 begin
   with Canvas do
 …
     Brush.Style := bsClear;
     PaintBackground(self, 3 + Border, 3 + Border,
       ClientWidth - (6 + 2 * Border), ClientHeight - (6 + 2 * Border))
+      ClientWidth - (6 + 2 * Border), ClientHeight - (6 + 2 * Border));
   end;
   Frame(Canvas, Border + 1, Border + 1, ClientWidth - (2 + Border),
 …
   begin
     Canvas.Font.Assign(UniFont[ftCaption]);
     s := Phrases.Lookup('TITLE_SUICIDE');
     RisedTextOut(Canvas, (ClientWidth - BiColorTextWidth(Canvas, s)) div 2,
 + Border, s);
+    S := Phrases.Lookup('TITLE_SUICIDE');
+    RisedTextOut(Canvas, (ClientWidth - BiColorTextWidth(Canvas, S)) div 2,
++ Border, S);
     Canvas.Font.Assign(UniFont[ftNormal]);
     s := Phrases.Lookup('SUICIDE');
     p := pos('\', s);
     if p = 0 then
       RisedTextOut(Canvas, (ClientWidth - BiColorTextWidth(Canvas, s))
         div 2, 205, s)
+    S := Phrases.Lookup('SUICIDE');
+    P := Pos('\', S);
+    if P = 0 then
+      RisedTextOut(Canvas, (ClientWidth - BiColorTextWidth(Canvas, S))
+        div 2, 205, S)
     else
     begin
       s1 := copy(s, 1, p - 1);
+      s1 := Copy(S, 1, P - 1);
       RisedTextOut(Canvas, (ClientWidth - BiColorTextWidth(Canvas, s1)) div 2,
 - MessageLineSpacing div 2, s1);
       s1 := copy(s, p + 1, 255);
+      s1 := Copy(S, P + 1, 255);
       RisedTextOut(Canvas, (ClientWidth - BiColorTextWidth(Canvas, s1)) div 2,
 + (MessageLineSpacing - MessageLineSpacing div 2), s1);
     end;
     ym := 110
+    ym := 110;
   end
   else
 …
 begin
   if not IsSuicideQuery then
     Close
+    Close;
 end;
 …
     if Key <> VK_ESCAPE then
       MainScreen.FormKeyDown(Sender, Key, Shift);
   end
+  end;
 end;

branches/highdpi/LocalPlayer/CityScreen.pas

-              r405
+              r465
 uses
   UDpiControls, {$IFDEF LINUX}LMessages,{$ENDIF}
   Protocol, ClientTools, Term, ScreenTools, IsoEngine, BaseWin,
   LCLIntf, LCLType, Messages, SysUtils, Classes, Graphics, Controls, Forms, ExtCtrls,
   ButtonA, ButtonC, Area, GraphType, UTexture;
+  UDpiControls, {$IFDEF UNIX}LMessages,{$ENDIF}
+  Protocol, ClientTools, ScreenTools, IsoEngine, BaseWin, LCLIntf, LCLType,
+  Messages, SysUtils, Classes, Graphics, Controls, Forms, ExtCtrls, ButtonA,
+  ButtonC, Area, GraphType, Texture;
 const
 …
     procedure FormDestroy(Sender: TObject);
     procedure FormMouseDown(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; x, y: integer);
+      Shift: TShiftState; X, Y: Integer);
     procedure BuyClick(Sender: TObject);
     procedure CloseBtnClick(Sender: TObject);
 …
     procedure PrevCityBtnClick(Sender: TObject);
     procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
-    // procedure AdviceBtnClick(Sender: TObject);
     procedure PageUpBtnClick(Sender: TObject);
     procedure PageDownBtnClick(Sender: TObject);
   private
     c: TCity;
+    C: TCity;
     Report: TCityReportNew;
     cOwner: Integer;
 …
     Optimize_cixTileChange: Integer;
     Optimize_TilesBeforeChange: Integer;
     Happened: cardinal;
     imix: array [0 .. 15] of integer;
+    Happened: Cardinal;
+    imix: array [0 .. 15] of Integer;
     CityAreaInfo: TCityAreaInfo;
     AreaMap: TIsoMap;
 …
     procedure InitZoomCityMap;
     procedure ChooseProject;
     procedure ChangeCity(d: integer);
     procedure ChangeResourceWeights(iResourceWeights: integer);
+    procedure ChangeCity(D: Integer);
+    procedure ChangeResourceWeights(iResourceWeights: Integer);
     procedure OnPlaySound(var Msg: TMessage); message WM_PLAYSOUND;
   public
     RestoreUnFocus: integer;
+    RestoreUnFocus: Integer;
     CloseAction: TCityCloseAction;
     procedure OffscreenPaint; override;
     procedure ShowNewContent(NewMode, Loc: integer; ShowEvent: cardinal);
+    procedure ShowNewContent(NewMode: TWindowMode; Loc: Integer; ShowEvent: Cardinal);
     procedure Reset;
     procedure CheckAge;
   end;
-var
-  CityDlg: TCityDlg;
 implementation
 uses
   Select, Messg, MessgEx, Help, Tribes, Directories, Math, Sound;
+  Select, Messg, MessgEx, Help, Tribes, Directories, Math, Sound, Term;
 {$R *.lfm}
 …
   wZoomEnvironment = 68;
+  ImpPosition: array [28 .. nImp - 1] of integer = (-1, // imTrGoods
+  ImpPosition: array [28 .. nImp - 1] of Integer = (
+    -1, // imTrGoods
 , // imBarracks
 , // imGranary
 …
 var
   ImpSorted: array [0 .. nImp - 1] of integer;
+  ImpSorted: array [0 .. nImp - 1] of Integer;
 procedure TCityDlg.FormCreate(Sender: TObject);
 …
   NoMap := TIsoMap.Create;
   AreaMap := TIsoMap.Create;
   AreaMap.SetOutput(offscreen);
+  AreaMap.SetOutput(Offscreen);
   AreaMap.SetPaintBounds(xmArea - 192, ymArea - 96 - 32, xmArea + 192,
     ymArea + 96);
+  SmallMapMode := smImprovements;
+  ZoomArea := 1;
+  ProdHint := false;
+  Reset;
+  ProdHint := False;
   RestoreUnFocus := -1;
   OpenSoundEvent := -1;
 …
     UnshareBitmap(Back);
     DpiBitCanvas(Back.Canvas, 0, 0, ClientWidth, ClientHeight,
+    DpiBitBltCanvas(Back.Canvas, 0, 0, ClientWidth, ClientHeight,
       MainTexture.Image.Canvas, 0, 0);
     ImageOp_B(Back, Template, 0, 0, 0, 0, ClientWidth, ClientHeight);
 …
 procedure TCityDlg.InitSmallCityMap;
 var
   i, iix, cli1, Color0, Color1, Color2: integer;
+  I, iix, cli1, Color0, Color1, Color2: Integer;
 begin
   if cix >= 0 then
     c := MyCity[cix];
+    C := MyCity[cix];
   case MyMap[cLoc] and fTerrain of
     fPrairie: cli1 := cliPrairie;
 …
   Color2 := Colors.Canvas.Pixels[clkAge0 + Age, cliHouse];
   SmallCityMap.Canvas.FillRect(0, 0, SmallCityMap.Width, SmallCityMap.Height);
   DpiBitCanvas(SmallCityMap.Canvas, 0, 0, 83, hSmallMap,
+  DpiBitBltCanvas(SmallCityMap.Canvas, 0, 0, 83, hSmallMap,
     SmallCityMapTemplate.Canvas, 83 * SizeClass, 0);
   if IsPort then
   begin
     DpiBitCanvas(SmallCityMap.Canvas, 83, 0, 15, hSmallMap,
+    DpiBitBltCanvas(SmallCityMap.Canvas, 83, 0, 15, hSmallMap,
       SmallCityMapTemplate.Canvas, 332 + 15, 0);
     ImageOp_CCC(SmallCityMap, 0, 0, 83, hSmallMap, Color0, Color1, Color2);
 …
   else
   begin
     DpiBitCanvas(SmallCityMap.Canvas, 83, 0, 15, hSmallMap,
+    DpiBitBltCanvas(SmallCityMap.Canvas, 83, 0, 15, hSmallMap,
       SmallCityMapTemplate.Canvas, 332, 0);
     ImageOp_CCC(SmallCityMap, 0, 0, wSmallMap, hSmallMap, Color0,
 …
   begin
     Brush.Color := ScreenTools.Colors.Canvas.Pixels[clkAge0 + Age, cliImp];
     for i := 0 to 29 do
+    for I := 0 to 29 do
     begin
       for iix := nWonder to nImp - 1 do
         if (ImpPosition[iix] = i) and (c.Built[iix] > 0) then
+        if (ImpPosition[iix] = I) and (C.Built[iix] > 0) then
         begin
           FillRect(Rect(5 + 16 * (i mod 3) + 48 * (i div 18),
 + 12 * (i mod 18 div 3), 13 + 16 * (i mod 3) + 48 * (i div 18),
 + 12 * (i mod 18 div 3)));
           break;
+          FillRect(Rect(5 + 16 * (I mod 3) + 48 * (I div 18),
++ 12 * (I mod 18 div 3), 13 + 16 * (I mod 3) + 48 * (I div 18),
++ 12 * (I mod 18 div 3)));
+          Break;
         end;
     end;
     i := 30;
+    I := 30;
     for iix := 0 to nImp do
       if (c.Built[iix] > 0) and ((iix < nWonder) or (ImpPosition[iix] < 0)) then
+      if (C.Built[iix] > 0) and ((iix < nWonder) or (ImpPosition[iix] < 0)) then
       begin
         FillRect(Rect(5 + 16 * (i mod 3) + 48 * (i div 18),
 + 12 * (i mod 18 div 3), 13 + 16 * (i mod 3) + 48 * (i div 18),
 + 12 * (i mod 18 div 3)));
         inc(i);
         if i = 36 then
           break; // area is full
+        FillRect(Rect(5 + 16 * (I mod 3) + 48 * (I div 18),
++ 12 * (I mod 18 div 3), 13 + 16 * (I mod 3) + 48 * (I div 18),
++ 12 * (I mod 18 div 3)));
+        Inc(I);
+        if I = 36 then
+          Break; // area is full
       end;
     if c.Project and cpImp <> 0 then
     begin
       iix := c.Project and cpIndex;
+    if C.Project and cpImp <> 0 then
+    begin
+      iix := C.Project and cpIndex;
       if iix <> imTrGoods then
       begin
         if (iix >= nWonder) and (ImpPosition[iix] >= 0) then
           i := ImpPosition[iix];
         if i < 36 then
+          I := ImpPosition[iix];
+        if I < 36 then
         begin
           brush.Color := ScreenTools.Colors.Canvas.Pixels[clkAge0 + Age, cliImpProject];
           FillRect(Rect(5 + 16 * (i mod 3) + 48 * (i div 18),
 + 12 * (i mod 18 div 3), 13 + 16 * (i mod 3) + 48 * (i div 18),
 + 12 * (i mod 18 div 3)));
+          Brush.Color := ScreenTools.Colors.Canvas.Pixels[clkAge0 + Age, cliImpProject];
+          FillRect(Rect(5 + 16 * (I mod 3) + 48 * (I div 18),
++ 12 * (I mod 18 div 3), 13 + 16 * (I mod 3) + 48 * (I div 18),
++ 12 * (I mod 18 div 3)));
         end;
       end;
     end;
     brush.style := bsClear;
+    Brush.style := bsClear;
   end;
 end;
 …
 begin
   UnshareBitmap(ZoomCityMap);
   DpiBitCanvas(ZoomCityMap.Canvas, 0, 0, wZoomMap, hZoomMap,
+  DpiBitBltCanvas(ZoomCityMap.Canvas, 0, 0, wZoomMap, hZoomMap,
     Back.Canvas, xZoomMap, yZoomMap);
   if SmallMapMode = smImprovements then begin
 …
 * (ZoomArea - 3), wZoomMap - wZoomEnvironment, hZoomMap);
       ImageOp_B(ZoomCityMap, CityMapTemplate, wZoomMap - wZoomEnvironment, 0,
 + wZoomEnvironment * byte(IsPort), 112 * (ZoomArea - 3),
++ wZoomEnvironment * Byte(IsPort), 112 * (ZoomArea - 3),
         wZoomEnvironment, hZoomMap);
     end;
 …
 procedure TCityDlg.OffscreenPaint;
   procedure FillBar(x, y, pos, Growth, max, Kind: integer;
     IndicateComplete: boolean);
+  procedure FillBar(X, Y, Pos, Growth, Max, Kind: Integer;
+    IndicateComplete: Boolean);
   begin
     BarTex.Assign(MainTexture);
 …
       BarTex.ColorBevelShade := BarTex.ColorBevelLight;
     end;
     PaintRelativeProgressBar(offscreen.Canvas, Kind, x - 3, y, wBar - 4, pos,
       Growth, max, IndicateComplete, BarTex);
   end;
   procedure PaintResources(x, y, Loc: integer; Add4Happy: boolean);
+    PaintRelativeProgressBar(Offscreen.Canvas, Kind, X - 3, Y, wBar - 4, Pos,
+      Growth, Max, IndicateComplete, BarTex);
+  end;
+  procedure PaintResources(X, Y, Loc: Integer; Add4Happy: Boolean);
   var
     d, i, Total, xGr, yGr: integer;
+    D, I, Total, xGr, yGr: Integer;
     TileInfo: TTileInfo;
     rare: boolean;
+    rare: Boolean;
   begin
     with AreaMap do begin
     if Server(sGetCityTileInfo, me, Loc, TileInfo) <> eOk then
     begin
       assert(cix < 0);
       exit
+    if Server(sGetCityTileInfo, Me, Loc, TileInfo) <> eOk then
+    begin
+      Assert(cix < 0);
+      Exit
     end;
     Total := TileInfo.Food + TileInfo.Prod + TileInfo.Trade;
     rare := MyMap[Loc] and $06000000 > 0;
     if rare then
       inc(Total);
+      Inc(Total);
     if Add4Happy then
       inc(Total, 4);
+      Inc(Total, 4);
     if Total > 1 then
       d := (xxt - 11) div (Total - 1);
     if d < 1 then
       d := 1;
     if d > 4 then
       d := 4;
     for i := 0 to Total - 1 do
+      D := (xxt - 11) div (Total - 1);
+    if D < 1 then
+      D := 1;
+    if D > 4 then
+      D := 4;
+    for I := 0 to Total - 1 do
     begin
       yGr := 115;
       if Add4Happy and (i >= Total - 4) then
+      if Add4Happy and (I >= Total - 4) then
       begin
         xGr := 132;
         yGr := 126
       end
       else if rare and (i = Total - 1) then
+      else if rare and (I = Total - 1) then
         xGr := 66 + 110
       else if i >= TileInfo.Food + TileInfo.Prod then
+      else if I >= TileInfo.Food + TileInfo.Prod then
         xGr := 66 + 44
       else if i >= TileInfo.Prod then
+      else if I >= TileInfo.Prod then
         xGr := 66
       else
         xGr := 66 + 22;
       Sprite(offscreen, HGrSystem, x + xxt - 5 + d * (2 * i + 1 - Total),
         y + yyt - 5, 10, 10, xGr, yGr);
+      Sprite(Offscreen, HGrSystem, X + xxt - 5 + D * (2 * I + 1 - Total),
+        Y + yyt - 5, 10, 10, xGr, yGr);
     end;
     end;
   end;
 var
   line, MessageCount: integer;
   procedure CheckMessage(Flag: integer);
+  Line, MessageCount: Integer;
+  procedure CheckMessage(Flag: Integer);
   var
     i, test: integer;
     s: string;
+    I, Test: Integer;
+    S: string;
   begin
     if Happened and Flag <> 0 then
     begin
       i := 0;
       test := 1;
       while test < Flag do
+      I := 0;
+      Test := 1;
+      while Test < Flag do
       begin
         inc(i);
         inc(test, test)
+        Inc(I);
+        Inc(Test, Test);
       end;
       if AllowChange and (Sounds <> nil) and (OpenSoundEvent = -1) then
       begin
         s := CityEventSoundItem[i];
         if s <> '' then
           s := Sounds.Lookup(s);
         if (Flag = chProduction) or (s <> '') and (s[1] <> '*') and (s[1] <> '[')
+        S := CityEventSoundItem[I];
+        if S <> '' then
+          S := Sounds.Lookup(S);
+        if (Flag = chProduction) or (S <> '') and (S[1] <> '*') and (S[1] <> '[')
         then
           OpenSoundEvent := i
+          OpenSoundEvent := I;
       end;
       s := CityEventName(i);
+      S := CityEventName(I);
       { if Flag=chNoGrowthWarning then
         if c.Built[imAqueduct]=0 then
         s:=Format(s,[Phrases.Lookup('IMPROVEMENTS',imAqueduct)])
         else s:=Format(s,[Phrases.Lookup('IMPROVEMENTS',imSewer)]); }
       RisedTextOut(offscreen.Canvas, xmOpt + 40, ymOpt - 1 - 8 * MessageCount +
 * line, s);
       inc(line)
+        if C.Built[imAqueduct]=0 then
+        S:=Format(S,[Phrases.Lookup('IMPROVEMENTS',imAqueduct)])
+        else S:=Format(S,[Phrases.Lookup('IMPROVEMENTS',imSewer)]); }
+      RisedTextOut(Offscreen.Canvas, xmOpt + 40, ymOpt - 1 - 8 * MessageCount +
+* Line, S);
+      Inc(Line);
     end;
   end;
 var
   x, y, xGr, i, j, iix, d, dx, dy, PrCost, Cnt, Loc1, FreeSupp, Paintiix,
     HappyGain, OptiType, rx, ry, TrueFood, TrueProd, TruePoll: integer;
   av: integer;
   PrName, s: string;
+  X, Y, xGr, I, J, iix, D, dx, dy, PrCost, Cnt, Loc1, FreeSupp, Paintiix,
+    HappyGain, OptiType, rx, ry, TrueFood, TrueProd, TruePoll: Integer;
+  av: Integer;
+  PrName, S: string;
   UnitInfo: TUnitInfo;
   UnitReport: TUnitReport;
   IsCityAlive, CanGrow: boolean;
+  IsCityAlive, CanGrow: Boolean;
 begin
   inherited;
   if cix >= 0 then
     c := MyCity[cix];
+    C := MyCity[cix];
   Report.HypoTiles := -1;
   Report.HypoTaxRate := -1;
   Report.HypoLuxuryRate := -1;
   if cix >= 0 then
     Server(sGetCityReportNew, me, cix, Report) // own city
+    Server(sGetCityReportNew, Me, cix, Report) // own city
   else
     Server(sGetEnemyCityReportNew, me, cLoc, Report); // enemy city
   TrueFood := c.Food;
   TrueProd := c.Prod;
   TruePoll := c.Pollution;
   if supervising or (cix < 0) then
+    Server(sGetEnemyCityReportNew, Me, cLoc, Report); // enemy city
+  TrueFood := C.Food;
+  TrueProd := C.Prod;
+  TruePoll := C.Pollution;
+  if Supervising or (cix < 0) then
   begin // normalize city from after-turn state
     dec(TrueFood, Report.FoodSurplus);
+    Dec(TrueFood, Report.FoodSurplus);
     if TrueFood < 0 then
       TrueFood := 0; // shouldn't happen
     dec(TrueProd, Report.Production);
+    Dec(TrueProd, Report.Production);
     if TrueProd < 0 then
       TrueProd := 0; // shouldn't happen
     dec(TruePoll, Report.AddPollution);
+    Dec(TruePoll, Report.AddPollution);
     if TruePoll < 0 then
       TruePoll := 0; // shouldn't happen
   end;
   IsCityAlive := (cGov <> gAnarchy) and (c.Flags and chCaptured = 0);
+  IsCityAlive := (cGov <> gAnarchy) and (C.Flags and chCaptured = 0);
   if not IsCityAlive then
     Report.Working := c.Size;
+    Report.Working := C.Size;
   RedTex.Assign(MainTexture);
 …
   RedTex.ColorTextShade := $0000FF;
   DpiBitCanvas(offscreen.Canvas, 0, 0, 640, 480, Back.Canvas, 0, 0);
+  DpiBitBltCanvas(Offscreen.Canvas, 0, 0, 640, 480, Back.Canvas, 0, 0);
   Offscreen.Canvas.Font.Assign(UniFont[ftCaption]);
   RisedTextOut(offscreen.Canvas, 42, 7, Caption);
   with offscreen.Canvas do
+  RisedTextOut(Offscreen.Canvas, 42, 7, Caption);
+  with Offscreen.Canvas do
   begin // city size
     brush.Color := $000000;
+    Brush.Color := $000000;
     FillRect(Rect(8 + 1, 7 + 1, 36 + 1, 32 + 1));
     brush.Color := $FFFFFF;
+    Brush.Color := $FFFFFF;
     FillRect(Rect(8, 7, 36, 32));
     brush.style := bsClear;
+    Brush.style := bsClear;
     Font.Color := $000000;
     s := inttostr(c.Size);
     TextOut(8 + 14 - textwidth(s) div 2, 7, s);
+    S := IntToStr(C.Size);
+    TextOut(8 + 14 - TextWidth(S) div 2, 7, S);
   end;
   Offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
 …
     MakeRed(Offscreen, 18, 280, 298, 40);
     if cGov = gAnarchy then
       s := Phrases.Lookup('GOVERNMENT', gAnarchy)
+      S := Phrases.Lookup('GOVERNMENT', gAnarchy)
     else { if c.Flags and chCaptured<>0 then }
       s := Phrases.Lookup('CITYEVENTS', 14);
     RisedTextOut(offscreen.Canvas, 167 - BiColorTextWidth(offscreen.Canvas, s)
       div 2, ymOpt - 9, s);
+      S := Phrases.Lookup('CITYEVENTS', 14);
+    RisedTextOut(Offscreen.Canvas, 167 - BiColorTextWidth(Offscreen.Canvas, S)
+      div 2, ymOpt - 9, S);
   end
   else if AllowChange then
   begin
     OptiType := c.Status shr 4 and $0F;
     Sprite(offscreen, HGrSystem2, xmOpt - 32, ymOpt - 32, 64, 64,
+    OptiType := C.Status shr 4 and $0F;
+    Sprite(Offscreen, HGrSystem2, xmOpt - 32, ymOpt - 32, 64, 64,
 + OptiType mod 3 * 64, 217 + OptiType div 3 * 64);
     { display messages now }
     MessageCount := 0;
     for i := 0 to 31 do
       if Happened and ($FFFFFFFF - chCaptured) and (1 shl i) <> 0 then
         inc(MessageCount);
+    for I := 0 to 31 do
+      if Happened and ($FFFFFFFF - chCaptured) and (1 shl I) <> 0 then
+        Inc(MessageCount);
     if MessageCount > 3 then
       MessageCount := 3;
     if MessageCount > 0 then
     begin
       MakeBlue(offscreen, 74, 280, 242, 40);
       line := 0;
       for i := 0 to nCityEventPriority - 1 do
         if line < MessageCount then
           CheckMessage(CityEventPriority[i]);
+      MakeBlue(Offscreen, 74, 280, 242, 40);
+      Line := 0;
+      for I := 0 to nCityEventPriority - 1 do
+        if Line < MessageCount then
+          CheckMessage(CityEventPriority[I]);
     end
     else
     begin
       s := Phrases.Lookup('CITYMANAGETYPE', OptiType);
       j := pos('\', s);
       if j = 0 then
         LoweredTextout(offscreen.Canvas, -1, MainTexture, xmOpt + 40,
           ymOpt - 9, s)
+      S := Phrases.Lookup('CITYMANAGETYPE', OptiType);
+      J := Pos('\', S);
+      if J = 0 then
+        LoweredTextout(Offscreen.Canvas, -1, MainTexture, xmOpt + 40,
+          ymOpt - 9, S)
       else
       begin
         LoweredTextout(offscreen.Canvas, -1, MainTexture, xmOpt + 40,
           ymOpt - 17, copy(s, 1, j - 1));
         LoweredTextout(offscreen.Canvas, -1, MainTexture, xmOpt + 40, ymOpt - 1,
           copy(s, j + 1, 255));
+        LoweredTextout(Offscreen.Canvas, -1, MainTexture, xmOpt + 40,
+          ymOpt - 17, Copy(S, 1, J - 1));
+        LoweredTextout(Offscreen.Canvas, -1, MainTexture, xmOpt + 40, ymOpt - 1,
+          Copy(S, J + 1, 255));
       end;
     end;
 …
     AreaMap.Paint(xmArea - xxt * 2 * rx, ymArea - yyt * 2 * ry - 3 * yyt,
       dLoc(cLoc, -2 * rx + 1, -2 * ry - 1), 4 * rx - 1, 4 * ry + 1, cLoc, cOwner,
       false, AllowChange and IsCityAlive and
       (c.Status and csResourceWeightsMask = 0));
     DpiBitCanvas(offscreen.Canvas, xmArea + 102, 42, 90, 33, Back.Canvas,
+      False, AllowChange and IsCityAlive and
+      (C.Status and csResourceWeightsMask = 0));
+    DpiBitBltCanvas(Offscreen.Canvas, xmArea + 102, 42, 90, 33, Back.Canvas,
       xmArea + 102, 42);
 …
               ((Loc1 < 0) or (Loc1 >= G.lx * G.ly) or (MyMap[Loc1] and fCity = 0))
             then
               Sprite(offscreen, HGrTerrain, xmArea - xxt + xxt * dx,
+              Sprite(Offscreen, HGrTerrain, xmArea - xxt + xxt * dx,
                 ymArea - yyt + yyt * dy, xxt * 2, yyt * 2, 1 + 5 * (xxt * 2 + 1),
 + yyt + 15 * (yyt * 3 + 1));
             if (1 shl ((dy + 3) shl 2 + (dx + 3) shr 1) and c.Tiles <> 0) then
+            if (1 shl ((dy + 3) shl 2 + (dx + 3) shr 1) and C.Tiles <> 0) then
               PaintResources(xmArea - xxt + xxt * dx, ymArea - yyt + yyt * dy,
                 Loc1, (dx = 0) and (dy = 0));
 …
   if Report.Working > 1 then
     d := (xService - (xmArea - 192) - 8 - 32) div (Report.Working - 1);
   if d > 28 then
     d := 28;
   for i := Report.Working - 1 downto 0 do
+    D := (xService - (xmArea - 192) - 8 - 32) div (Report.Working - 1);
+  if D > 28 then
+    D := 28;
+  for I := Report.Working - 1 downto 0 do
   begin
     if IsCityAlive then
 …
     else
       xGr := 141;
     DpiBitCanvas(offscreen.Canvas, xmArea - 192 + 5 + i * d, ymArea - 96 - 29,
+    DpiBitBltCanvas(Offscreen.Canvas, xmArea - 192 + 5 + I * D, ymArea - 96 - 29,
 , 30, HGrSystem.Mask.Canvas, xGr, 171, SRCAND); { shadow }
     Sprite(offscreen, HGrSystem, xmArea - 192 + 4 + i * d, ymArea - 96 - 30, 27,
+    Sprite(Offscreen, HGrSystem, xmArea - 192 + 4 + I * D, ymArea - 96 - 30, 27,
 , xGr, 171);
   end;
   if c.Size - Report.Working > 1 then
     d := (xmArea + 192 - xService - 32) div (c.Size - Report.Working - 1);
   if d > 28 then
     d := 28;
   for i := 0 to c.Size - Report.Working - 1 do
+  if C.Size - Report.Working > 1 then
+    D := (xmArea + 192 - xService - 32) div (C.Size - Report.Working - 1);
+  if D > 28 then
+    D := 28;
+  for I := 0 to C.Size - Report.Working - 1 do
   begin
     xGr := 1 + 112;
     DpiBitCanvas(offscreen.Canvas, xmArea + 192 - 27 + 1 - i * d, 29 + 1, 27,
+    DpiBitBltCanvas(Offscreen.Canvas, xmArea + 192 - 27 + 1 - I * D, 29 + 1, 27,
 , HGrSystem.Mask.Canvas, xGr, 171, SRCAND); { shadow }
     Sprite(offscreen, HGrSystem, xmArea + 192 - 27 - i * d, 29, 27, 30,
+    Sprite(Offscreen, HGrSystem, xmArea + 192 - 27 - I * D, 29, 27, 30,
       xGr, 171);
     Sprite(offscreen, HGrSystem, xmArea + 192 - 27 + 4 - i * d, 29 + 32, 10,
+    Sprite(Offscreen, HGrSystem, xmArea + 192 - 27 + 4 - I * D, 29 + 32, 10,
 , 121, 126);
     Sprite(offscreen, HGrSystem, xmArea + 192 - 27 + 13 - i * d, 29 + 32, 10,
+    Sprite(Offscreen, HGrSystem, xmArea + 192 - 27 + 13 - I * D, 29 + 32, 10,
 , 121, 126);
     // Sprite(offscreen,HGrSystem,xmArea+192-31+18-i*d,ymArea-96-80+32,10,10,88,115);
   end;
   if c.Project and cpImp = 0 then
     PrName := Tribe[cOwner].ModelName[c.Project and cpIndex]
+  if C.Project and cpImp = 0 then
+    PrName := Tribe[cOwner].ModelName[C.Project and cpIndex]
   else
     PrName := Phrases.Lookup('IMPROVEMENTS', c.Project and cpIndex);
+    PrName := Phrases.Lookup('IMPROVEMENTS', C.Project and cpIndex);
   PrCost := Report.ProjectCost;
 …
   begin
     if cGov = gFundamentalism then
       CountBar(offscreen, xHapp, yHapp + dyBar, wBar, 17,
+      CountBar(Offscreen, xHapp, yHapp + dyBar, wBar, 17,
         Phrases.Lookup('FAITH'), Report.CollectedControl, MainTexture)
     else
     begin
       CountBar(offscreen, xHapp, yHapp + dyBar, wBar, 17,
+      CountBar(Offscreen, xHapp, yHapp + dyBar, wBar, 17,
         Phrases.Lookup('HAPPINESS'), Report.Morale, MainTexture);
       CountBar(offscreen, xHapp, yHapp + 2 * dyBar, wBar, 16,
+      CountBar(Offscreen, xHapp, yHapp + 2 * dyBar, wBar, 16,
         Phrases.Lookup('CONTROL'), Report.CollectedControl, MainTexture);
     end;
     CountBar(offscreen, xHapp, yHapp, wBar, 8, Phrases.Lookup('LUX'),
+    CountBar(Offscreen, xHapp, yHapp, wBar, 8, Phrases.Lookup('LUX'),
       Report.Luxury, MainTexture);
     CountBar(offscreen, xHapp + dxBar, yHapp, wBar, 19,
+    CountBar(Offscreen, xHapp + dxBar, yHapp, wBar, 19,
       Phrases.Lookup('UNREST'), 2 * Report.Deployed, MainTexture);
     CountBar(offscreen, xHapp + dxBar, yHapp + dyBar, wBar, 17,
       Phrases.Lookup('HAPPINESSDEMAND'), c.Size, MainTexture);
+    CountBar(Offscreen, xHapp + dxBar, yHapp + dyBar, wBar, 17,
+      Phrases.Lookup('HAPPINESSDEMAND'), C.Size, MainTexture);
     if Report.HappinessBalance >= 0 then
       CountBar(offscreen, xHapp + dxBar, yHapp + 2 * dyBar, wBar, 17,
+      CountBar(Offscreen, xHapp + dxBar, yHapp + 2 * dyBar, wBar, 17,
         Phrases.Lookup('HAPPINESSPLUS'), Report.HappinessBalance, MainTexture)
     else
     begin
       MakeRed(Offscreen, xHapp + dxBar - 6, yHapp + 2 * dyBar, wBar + 10, 38);
       CountBar(offscreen, xHapp + dxBar, yHapp + 2 * dyBar, wBar, 18,
+      CountBar(Offscreen, xHapp + dxBar, yHapp + 2 * dyBar, wBar, 18,
         Phrases.Lookup('LACK'), -Report.HappinessBalance, RedTex);
     end;
 …
   if IsCityAlive then
   begin
     CountBar(offscreen, xFood, yFood + dyBar div 2, wBar, 0,
+    CountBar(Offscreen, xFood, yFood + dyBar div 2, wBar, 0,
       Phrases.Lookup('FOOD'), Report.CollectedFood, MainTexture);
     CountBar(offscreen, xFood + dxBar, yFood + dyBar, wBar, 0,
       Phrases.Lookup('DEMAND'), 2 * c.Size, MainTexture);
     CountBar(offscreen, xFood + dxBar, yFood, wBar, 0,
+    CountBar(Offscreen, xFood + dxBar, yFood + dyBar, wBar, 0,
+      Phrases.Lookup('DEMAND'), 2 * C.Size, MainTexture);
+    CountBar(Offscreen, xFood + dxBar, yFood, wBar, 0,
       Phrases.Lookup('SUPPORT'), Report.FoodSupport, MainTexture);
     if Report.FoodSurplus >= 0 then
       if (cGov = gFuture) or (c.Size >= NeedAqueductSize) and
+      if (cGov = gFuture) or (C.Size >= NeedAqueductSize) and
         (Report.FoodSurplus < 2) then
         CountBar(offscreen, xFood + dxBar, yFood + 2 * dyBar, wBar, 6,
+        CountBar(Offscreen, xFood + dxBar, yFood + 2 * dyBar, wBar, 6,
           Phrases.Lookup('PROFIT'), Report.FoodSurplus, MainTexture)
       else
         CountBar(offscreen, xFood + dxBar, yFood + 2 * dyBar, wBar, 0,
+        CountBar(Offscreen, xFood + dxBar, yFood + 2 * dyBar, wBar, 0,
           Phrases.Lookup('SURPLUS'), Report.FoodSurplus, MainTexture)
     else
     begin
       MakeRed(Offscreen, xFood + dxBar - 6, yFood + 2 * dyBar, wBar + 10, 38);
       CountBar(offscreen, xFood + dxBar, yFood + 2 * dyBar, wBar, 1,
+      CountBar(Offscreen, xFood + dxBar, yFood + 2 * dyBar, wBar, 1,
         Phrases.Lookup('LACK'), -Report.FoodSurplus, RedTex);
     end;
   end;
   CanGrow := (c.Size < MaxCitySize) and (cGov <> gFuture) and
     (Report.FoodSurplus > 0) and ((c.Size < NeedAqueductSize) or
     (c.Built[imAqueduct] = 1) and (c.Size < NeedSewerSize) or
     (c.Built[imSewer] = 1));
+  CanGrow := (C.Size < MaxCitySize) and (cGov <> gFuture) and
+    (Report.FoodSurplus > 0) and ((C.Size < NeedAqueductSize) or
+    (C.Built[imAqueduct] = 1) and (C.Size < NeedSewerSize) or
+    (C.Built[imSewer] = 1));
   FillBar(xFood + 3, yFood + 102, TrueFood,
     CutCityFoodSurplus(Report.FoodSurplus, IsCityAlive, cGov, c.Size),
+    CutCityFoodSurplus(Report.FoodSurplus, IsCityAlive, cGov, C.Size),
     Report.Storage, 1, CanGrow);
   LoweredTextout(offscreen.Canvas, -1, MainTexture, xFood + 3 - 5,
+  LoweredTextout(Offscreen.Canvas, -1, MainTexture, xFood + 3 - 5,
     yFood + 102 - 20, Format('%d/%d', [TrueFood, Report.Storage]));
   LoweredTextout(offscreen.Canvas, -1, MainTexture, xFood - 2, yFood + 66,
+  LoweredTextout(Offscreen.Canvas, -1, MainTexture, xFood - 2, yFood + 66,
     Phrases.Lookup('STORAGE'));
 …
   if IsCityAlive then
   begin
     CountBar(offscreen, xProd, yProd, wBar, 2, Phrases.Lookup('MATERIAL'),
+    CountBar(Offscreen, xProd, yProd, wBar, 2, Phrases.Lookup('MATERIAL'),
       Report.CollectedMaterial, MainTexture);
     CountBar(offscreen, xProd + dxBar, yProd, wBar, 2,
+    CountBar(Offscreen, xProd + dxBar, yProd, wBar, 2,
       Phrases.Lookup('SUPPORT'), Report.MaterialSupport, MainTexture);
     if Report.Production >= 0 then
       if c.Project and (cpImp + cpIndex) = cpImp + imTrGoods then
         CountBar(offscreen, xProd + dxBar, yProd + dyBar + 16, wBar, 6,
+      if C.Project and (cpImp + cpIndex) = cpImp + imTrGoods then
+        CountBar(Offscreen, xProd + dxBar, yProd + dyBar + 16, wBar, 6,
           Phrases.Lookup('PROFIT'), Report.Production, MainTexture)
       else
         CountBar(offscreen, xProd + dxBar, yProd + dyBar + 16, wBar, 2,
+        CountBar(Offscreen, xProd + dxBar, yProd + dyBar + 16, wBar, 2,
           Phrases.Lookup('PROD'), Report.Production, MainTexture)
     else
     begin
       MakeRed(Offscreen, xProd + dxBar - 6, yProd + dyBar + 17, wBar + 10, 38);
       CountBar(offscreen, xProd + dxBar, yProd + dyBar + 16, wBar, 3,
+      CountBar(Offscreen, xProd + dxBar, yProd + dyBar + 16, wBar, 3,
         Phrases.Lookup('LACK'), -Report.Production, RedTex);
     end;
   end;
   if c.Project and (cpImp + cpIndex) <> cpImp + imTrGoods then
     with offscreen.Canvas do
     begin
       i := Report.Production;
       if (i < 0) or not IsCityAlive then
         i := 0;
       FillBar(xProd + 3, yProd + 16 + 63, TrueProd, i, PrCost, 4, true);
       LoweredTextout(offscreen.Canvas, -1, MainTexture, xProd + 3 - 5,
+  if C.Project and (cpImp + cpIndex) <> cpImp + imTrGoods then
+    with Offscreen.Canvas do
+    begin
+      I := Report.Production;
+      if (I < 0) or not IsCityAlive then
+        I := 0;
+      FillBar(xProd + 3, yProd + 16 + 63, TrueProd, I, PrCost, 4, True);
+      LoweredTextout(Offscreen.Canvas, -1, MainTexture, xProd + 3 - 5,
         yProd + 16 + 43, Format('%d/%d', [TrueProd, PrCost]));
       if BiColorTextWidth(offscreen.Canvas, PrName) > wBar + dxBar then
+      if BiColorTextWidth(Offscreen.Canvas, PrName) > wBar + dxBar then
       begin
         repeat
           Delete(PrName, length(PrName), 1)
         until BiColorTextWidth(offscreen.Canvas, PrName) <= wBar + dxBar;
+          Delete(PrName, Length(PrName), 1)
+        until BiColorTextWidth(Offscreen.Canvas, PrName) <= wBar + dxBar;
         PrName := PrName + '.'
       end;
     end;
   RisedTextOut(offscreen.Canvas, xProd - 2, yProd + 36, PrName);
+  RisedTextOut(Offscreen.Canvas, xProd - 2, yProd + 36, PrName);
   // pollution section
 …
   begin
     FillBar(xPoll + 3, yPoll + 20, TruePoll, Report.AddPollution,
       MaxPollution, 3, true);
     RisedTextOut(offscreen.Canvas, xPoll + 3 - 5, yPoll + 20 - 20,
+      MaxPollution, 3, True);
+    RisedTextOut(Offscreen.Canvas, xPoll + 3 - 5, yPoll + 20 - 20,
       Phrases.Lookup('POLL'));
   end;
 …
   if IsCityAlive and (Report.CollectedTrade > 0) then
   begin
     CountBar(offscreen, xTrade, yTrade + dyBar div 2, wBar, 4,
+    CountBar(Offscreen, xTrade, yTrade + dyBar div 2, wBar, 4,
       Phrases.Lookup('TRADE'), Report.CollectedTrade, MainTexture);
     CountBar(offscreen, xTrade + dxBar, yTrade + 2 * dyBar, wBar, 5,
+    CountBar(Offscreen, xTrade + dxBar, yTrade + 2 * dyBar, wBar, 5,
       Phrases.Lookup('CORR'), Report.Corruption, MainTexture);
     CountBar(offscreen, xTrade + dxBar, yTrade, wBar, 6, Phrases.Lookup('TAX'),
+    CountBar(Offscreen, xTrade + dxBar, yTrade, wBar, 6, Phrases.Lookup('TAX'),
       Report.Tax, MainTexture);
     CountBar(offscreen, xTrade + dxBar, yTrade + dyBar, wBar, 12,
+    CountBar(Offscreen, xTrade + dxBar, yTrade + dyBar, wBar, 12,
       Phrases.Lookup('SCIENCE'), Report.Science, MainTexture);
   end;
   // small map
   DpiBitCanvas(offscreen.Canvas, xSmallMap, ySmallMap, wSmallMap, hSmallMap,
+  DpiBitBltCanvas(Offscreen.Canvas, xSmallMap, ySmallMap, wSmallMap, hSmallMap,
     SmallCityMap.Canvas, 0, 0);
   if SmallMapMode = smImprovements then
     Frame(offscreen.Canvas, xSmallMap + 48 * (ZoomArea div 3),
+    Frame(Offscreen.Canvas, xSmallMap + 48 * (ZoomArea div 3),
       ySmallMap + 24 * (ZoomArea mod 3), xSmallMap + 48 * (ZoomArea div 3) + 49,
       ySmallMap + 24 * (ZoomArea mod 3) + 25, MainTexture.ColorMark,
       MainTexture.ColorMark);
   Frame(offscreen.Canvas, xSmallMap - 1, ySmallMap - 1, xSmallMap + wSmallMap,
+  Frame(Offscreen.Canvas, xSmallMap - 1, ySmallMap - 1, xSmallMap + wSmallMap,
     ySmallMap + hSmallMap, $B0B0B0, $FFFFFF);
   RFrame(offscreen.Canvas, xSmallMap - 2, ySmallMap - 2, xSmallMap + wSmallMap +
+  RFrame(Offscreen.Canvas, xSmallMap - 2, ySmallMap - 2, xSmallMap + wSmallMap +
 , ySmallMap + hSmallMap + 1, $FFFFFF, $B0B0B0);
   Frame(offscreen.Canvas, xSupport - 1, ySupport - 1, xSupport + wSupport,
+  Frame(Offscreen.Canvas, xSupport - 1, ySupport - 1, xSupport + wSupport,
     ySupport + hSupport, $B0B0B0, $FFFFFF);
   RFrame(offscreen.Canvas, xSupport - 2, ySupport - 2, xSupport + wSupport + 1,
+  RFrame(Offscreen.Canvas, xSupport - 2, ySupport - 2, xSupport + wSupport + 1,
     ySupport + hSupport + 1, $FFFFFF, $B0B0B0);
   x := xSupport + wSupport div 2;
   y := ySupport + hSupport div 2;
+  X := xSupport + wSupport div 2;
+  Y := ySupport + hSupport div 2;
   if SmallMapMode = smSupportedUnits then
   begin
     offscreen.Canvas.brush.Color := MainTexture.ColorMark;
     offscreen.Canvas.FillRect(Rect(x - 27, y - 6, x + 27, y + 6));
     offscreen.Canvas.brush.style := bsClear;
   end;
   Sprite(offscreen, HGrSystem, x - 16, y - 5, 10, 10, 88, 115);
   Sprite(offscreen, HGrSystem, x - 5, y - 5, 10, 10, 66, 115);
   Sprite(offscreen, HGrSystem, x + 6, y - 5, 10, 10, 154, 126);
   DpiBitCanvas(offscreen.Canvas, xZoomMap, yZoomMap, wZoomMap, hZoomMap,
+    Offscreen.Canvas.Brush.Color := MainTexture.ColorMark;
+    Offscreen.Canvas.FillRect(Rect(X - 27, Y - 6, X + 27, Y + 6));
+    Offscreen.Canvas.Brush.style := bsClear;
+  end;
+  Sprite(Offscreen, HGrSystem, X - 16, Y - 5, 10, 10, 88, 115);
+  Sprite(Offscreen, HGrSystem, X - 5, Y - 5, 10, 10, 66, 115);
+  Sprite(Offscreen, HGrSystem, X + 6, Y - 5, 10, 10, 154, 126);
+  DpiBitBltCanvas(Offscreen.Canvas, xZoomMap, yZoomMap, wZoomMap, hZoomMap,
     ZoomCityMap.Canvas, 0, 0);
   for i := 0 to 5 do
     imix[i] := -1;
+  for I := 0 to 5 do
+    imix[I] := -1;
   if SmallMapMode = smImprovements then
   begin
 …
       Cnt := 0;
       for iix := 0 to nImp - 1 do
         if ((iix < nWonder) or (ImpPosition[iix] < 0)) and (c.Built[iix] > 0) then
+        if ((iix < nWonder) or (ImpPosition[iix] < 0)) and (C.Built[iix] > 0) then
         begin
           i := Cnt - Page * 6;
           if (i >= 0) and (i < 6) then
             imix[i] := iix;
           inc(Cnt);
+          I := Cnt - Page * 6;
+          if (I >= 0) and (I < 6) then
+            imix[I] := iix;
+          Inc(Cnt);
         end;
       PageCount := (Cnt + 5) div 6;
 …
       for iix := nWonder to nImp - 1 do
       begin
         i := ImpPosition[iix] - 6 * ZoomArea;
         if (i >= 0) and (i < 6) and (c.Built[iix] > 0) then
           imix[i] := iix;
+        I := ImpPosition[iix] - 6 * ZoomArea;
+        if (I >= 0) and (I < 6) and (C.Built[iix] > 0) then
+          imix[I] := iix;
       end;
       PageCount := 0;
     end;
     for i := 0 to 5 do
       if imix[i] >= 0 then
+    for I := 0 to 5 do
+      if imix[I] >= 0 then
       begin
         iix := imix[i];
         x := xZoomMap + 14 + 72 * (i mod 3);
         y := yZoomMap + 14 + 56 * (i div 3);
         ImpImage(offscreen.Canvas, x, y, iix, cGov, AllowChange and
+        iix := imix[I];
+        X := xZoomMap + 14 + 72 * (I mod 3);
+        Y := yZoomMap + 14 + 56 * (I div 3);
+        ImpImage(Offscreen.Canvas, X, Y, iix, cGov, AllowChange and
           (ClientMode < scContact));
         if IsCityAlive then
 …
           if iix = imColosseum then
           begin
             Sprite(offscreen, HGrSystem, x + 46, y, 14, 14, 82, 100);
+            Sprite(Offscreen, HGrSystem, X + 46, Y, 14, 14, 82, 100);
           end
           else
 …
             if HappyGain > 1 then
             begin
               d := 30 div (HappyGain - 1);
               if d > 10 then
                 d := 10
+              D := 30 div (HappyGain - 1);
+              if D > 10 then
+                D := 10
             end;
             for j := 0 to HappyGain - 1 do
               Sprite(offscreen, HGrSystem, x + 50, y + d * j, 10, 10, 132, 126);
+            for J := 0 to HappyGain - 1 do
+              Sprite(Offscreen, HGrSystem, X + 50, Y + D * J, 10, 10, 132, 126);
           end;
           for j := 0 to Imp[iix].Maint - 1 do
             Sprite(offscreen, HGrSystem, x - 4, y + 29 - 3 * j, 10, 10,
+          for J := 0 to Imp[iix].Maint - 1 do
+            Sprite(Offscreen, HGrSystem, X - 4, Y + 29 - 3 * J, 10, 10,
 , 115);
         end
 …
   else { if SmallMapMode = smSupportedUnits then }
   begin
     LoweredTextout(offscreen.Canvas, -1, MainTexture, xZoomMap + 6,
+    LoweredTextout(Offscreen.Canvas, -1, MainTexture, xZoomMap + 6,
       yZoomMap + 2, Phrases.Lookup('SUPUNITS'));
     FreeSupp := c.Size * SupportFree[cGov] shr 1;
+    FreeSupp := C.Size * SupportFree[cGov] shr 1;
     Cnt := 0;
     for i := 0 to MyRO.nUn - 1 do
       if (MyUn[i].Loc >= 0) and (MyUn[i].Home = cix) then
         with MyModel[MyUn[i].mix] do
+    for I := 0 to MyRO.nUn - 1 do
+      if (MyUn[I].Loc >= 0) and (MyUn[I].Home = cix) then
+        with MyModel[MyUn[I].mix] do
         begin
           Server(sGetUnitReport, me, i, UnitReport);
+          Server(sGetUnitReport, Me, I, UnitReport);
           if (Cnt >= 6 * Page) and (Cnt < 6 * (Page + 1)) then
           begin // unit visible in display
             imix[Cnt - 6 * Page] := i;
             x := ((Cnt - 6 * Page) mod 3) * 64 + xZoomMap;
             y := ((Cnt - 6 * Page) div 3) * 52 + yZoomMap + 20;
             MakeUnitInfo(me, MyUn[i], UnitInfo);
             NoMap.SetOutput(offscreen);
             NoMap.PaintUnit(x, y, UnitInfo, MyUn[i].Status);
             for j := 0 to UnitReport.FoodSupport - 1 do
               Sprite(offscreen, HGrSystem, x + 38 + 11 * j, y + 40, 10,
+            imix[Cnt - 6 * Page] := I;
+            X := ((Cnt - 6 * Page) mod 3) * 64 + xZoomMap;
+            Y := ((Cnt - 6 * Page) div 3) * 52 + yZoomMap + 20;
+            MakeUnitInfo(Me, MyUn[I], UnitInfo);
+            NoMap.SetOutput(Offscreen);
+            NoMap.PaintUnit(X, Y, UnitInfo, MyUn[I].Status);
+            for J := 0 to UnitReport.FoodSupport - 1 do
+              Sprite(Offscreen, HGrSystem, X + 38 + 11 * J, Y + 40, 10,
 , 66, 115);
             for j := 0 to UnitReport.ProdSupport - 1 do
+            for J := 0 to UnitReport.ProdSupport - 1 do
             begin
               if (FreeSupp > 0) and
                 (UnitReport.ReportFlags and urfAlwaysSupport = 0) then
               begin
                 Sprite(offscreen, HGrSystem, x + 16 - 11 * j, y + 40, 10,
+                Sprite(Offscreen, HGrSystem, X + 16 - 11 * J, Y + 40, 10,
 , 143, 115);
                 dec(FreeSupp);
+                Dec(FreeSupp);
               end
               else
                 Sprite(offscreen, HGrSystem, x + 16 - 11 * j, y + 40, 10,
+                Sprite(Offscreen, HGrSystem, X + 16 - 11 * J, Y + 40, 10,
 , 88, 115);
             end;
             if UnitReport.ReportFlags and urfDeployed <> 0 then
               for j := 0 to 1 do
                 Sprite(offscreen, HGrSystem, x + 27 + 11 * j, y + 40, 10,
+              for J := 0 to 1 do
+                Sprite(Offscreen, HGrSystem, X + 27 + 11 * J, Y + 40, 10,
 , 154, 126)
           end // unit visible in display
           else
             dec(FreeSupp, UnitReport.ProdSupport);
           inc(Cnt);
+            Dec(FreeSupp, UnitReport.ProdSupport);
+          Inc(Cnt);
         end;
     PageCount := (Cnt + 5) div 6;
 …
   PageDownBtn.Visible := PageCount > 1;
   with offscreen.Canvas do
+  with Offscreen.Canvas do
   begin
     { display project now }
     DLine(offscreen.Canvas, xView + 9 + xSizeBig, xProd + 2 * wBar + 10,
+    DLine(Offscreen.Canvas, xView + 9 + xSizeBig, xProd + 2 * wBar + 10,
       yProd + dyBar + 16, $FFFFFF, $B0B0B0);
     if ProdHint then
     begin
       ScreenTools.Frame(offscreen.Canvas, xView + 9 - 1, yView + 5 - 1,
+      ScreenTools.Frame(Offscreen.Canvas, xView + 9 - 1, yView + 5 - 1,
         xView + 9 + xSizeBig, yView + 5 + ySizeBig, $B0B0B0, $FFFFFF);
       RFrame(offscreen.Canvas, xView + 9 - 2, yView + 5 - 2,
+      RFrame(Offscreen.Canvas, xView + 9 - 2, yView + 5 - 2,
         xView + 9 + xSizeBig + 1, yView + 5 + ySizeBig + 1, $FFFFFF, $B0B0B0);
       with offscreen.Canvas do
+      with Offscreen.Canvas do
       begin
         brush.Color := $000000;
+        Brush.Color := $000000;
         FillRect(Rect(xView + 9, yView + 5, xView + 1 + 72 - 8,
           yView + 5 + 40));
         brush.style := bsClear;
+        Brush.style := bsClear;
       end;
     end
     else if AllowChange and (c.Status and 7 <> 0) then
+    else if AllowChange and (C.Status and 7 <> 0) then
     begin // city type autobuild
       FrameImage(offscreen.Canvas, bigimp, xView + 9, yView + 5, xSizeBig,
         ySizeBig, (c.Status and 7 - 1 + 3) * xSizeBig, 0, (cix >= 0) and
+      FrameImage(Offscreen.Canvas, bigimp, xView + 9, yView + 5, xSizeBig,
+        ySizeBig, (C.Status and 7 - 1 + 3) * xSizeBig, 0, (cix >= 0) and
         (ClientMode < scContact));
     end
     else if c.Project and cpImp = 0 then
+    else if C.Project and cpImp = 0 then
     begin // project is unit
       FrameImage(offscreen.Canvas, bigimp, xView + 9, yView + 5, xSizeBig,
+      FrameImage(Offscreen.Canvas, bigimp, xView + 9, yView + 5, xSizeBig,
         ySizeBig, 0, 0, AllowChange and (ClientMode < scContact));
       with Tribe[cOwner].ModelPicture[c.Project and cpIndex] do
         Sprite(offscreen, HGr, xView + 5, yView + 1, 64, 44,
+      with Tribe[cOwner].ModelPicture[C.Project and cpIndex] do
+        Sprite(Offscreen, HGr, xView + 5, yView + 1, 64, 44,
           pix mod 10 * 65 + 1, pix div 10 * 49 + 1);
     end
 …
     begin // project is building
       if ProdHint then
         Paintiix := c.Project0 and cpIndex
+        Paintiix := C.Project0 and cpIndex
       else
         Paintiix := c.Project and cpIndex;
       ImpImage(offscreen.Canvas, xView + 9, yView + 5, Paintiix, cGov,
+        Paintiix := C.Project and cpIndex;
+      ImpImage(Offscreen.Canvas, xView + 9, yView + 5, Paintiix, cGov,
         AllowChange and (ClientMode < scContact));
     end;
 …
   if AllowChange and (ClientMode < scContact) then
   begin
     i := Server(sBuyCityProject - sExecute, me, cix, nil^);
     BuyBtn.Visible := (i = eOk) or (i = eViolation);
+    I := Server(sBuyCityProject - sExecute, Me, cix, nil^);
+    BuyBtn.Visible := (I = eOk) or (I = eViolation);
   end
   else
     BuyBtn.Visible := false;
+    BuyBtn.Visible := False;
   MarkUsedOffscreen(ClientWidth, ClientHeight);
 end; { OffscreenPaint }
+end;
 procedure TCityDlg.FormShow(Sender: TObject);
 var
   dx, dy, Loc1: integer;
+  dx, dy, Loc1: Integer;
   GetCityData: TGetCityData;
 begin
 …
   if cix >= 0 then
   begin { own city }
     c := MyCity[cix];
     cOwner := me;
+    C := MyCity[cix];
+    cOwner := Me;
     cGov := MyRO.Government;
     ProdHint := (cGov <> gAnarchy) and
       (Happened and (chProduction or chFounded or chCaptured or
       chAllImpsMade) <> 0);
     Server(sGetCityAreaInfo, me, cix, CityAreaInfo);
+    Server(sGetCityAreaInfo, Me, cix, CityAreaInfo);
     NextCityBtn.Visible := WindowMode = wmPersistent;
     PrevCityBtn.Visible := WindowMode = wmPersistent;
 …
   begin
     SmallMapMode := smImprovements;
     Server(sGetCity, me, cLoc, GetCityData);
     c := GetCityData.c;
+    Server(sGetCity, Me, cLoc, GetCityData);
+    C := GetCityData.C;
     cOwner := GetCityData.Owner;
     cGov := MyRO.EnemyReport[cOwner].Government;
     Happened := c.Flags and $7FFFFFFF;
     ProdHint := false;
     Server(sGetEnemyCityAreaInfo, me, cLoc, CityAreaInfo);
     if c.Project and cpImp = 0 then
+    Happened := C.Flags and $7FFFFFFF;
+    ProdHint := False;
+    Server(sGetEnemyCityAreaInfo, Me, cLoc, CityAreaInfo);
+    if C.Project and cpImp = 0 then
     begin
       emix := MyRO.nEnemyModel - 1;
       while (emix > 0) and ((MyRO.EnemyModel[emix].Owner <> cOwner) or
         (integer(MyRO.EnemyModel[emix].mix) <> c.Project and cpIndex)) do
         dec(emix);
       if not Assigned(Tribe[cOwner].ModelPicture[c.Project and cpIndex].HGr) then
+        (Integer(MyRO.EnemyModel[emix].mix) <> C.Project and cpIndex)) do
+        Dec(emix);
+      if not Assigned(Tribe[cOwner].ModelPicture[C.Project and cpIndex].HGr) then
         InitEnemyModel(emix);
     end;
     NextCityBtn.Visible := false;
     PrevCityBtn.Visible := false;
+    NextCityBtn.Visible := False;
+    PrevCityBtn.Visible := False;
   end;
   Page := 0;
   if c.Size < 5 then
+  if C.Size < 5 then
     SizeClass := 0
   else if c.Size < 9 then
+  else if C.Size < 9 then
     SizeClass := 1
   else if c.Size < 13 then
+  else if C.Size < 13 then
     SizeClass := 2
   else
 …
   // check if port
   IsPort := false;
+  IsPort := False;
   for dx := -2 to 2 do
     for dy := -2 to 2 do
       if abs(dx) + abs(dy) = 2 then
+      if Abs(dx) + Abs(dy) = 2 then
       begin
         Loc1 := dLoc(cLoc, dx, dy);
         if (Loc1 >= 0) and (Loc1 < G.lx * G.ly) and
           (MyMap[Loc1] and fTerrain < fGrass) then
           IsPort := true;
+          IsPort := True;
       end;
 …
   end;
   Caption := CityName(c.ID);
+  Caption := CityName(C.ID);
   InitSmallCityMap;
 …
   OpenSoundEvent := -1;
   OffscreenPaint;
   Timer1.Enabled := true;
 end;
 procedure TCityDlg.ShowNewContent(NewMode, Loc: integer; ShowEvent: cardinal);
+  Timer1.Enabled := True;
+end;
+procedure TCityDlg.ShowNewContent(NewMode: TWindowMode; Loc: Integer; ShowEvent: Cardinal);
 begin
   if MyMap[Loc] and fOwned <> 0 then
 …
     cix := MyRO.nCity - 1;
     while (cix >= 0) and (MyCity[cix].Loc <> Loc) do
       dec(cix);
     assert(cix >= 0);
+      Dec(cix);
+    Assert(cix >= 0);
     if (Optimize_cixTileChange >= 0) and
       (Optimize_TilesBeforeChange and not MyCity[Optimize_cixTileChange].Tiles
 …
   else
     cix := -1;
   AllowChange := not supervising and (cix >= 0);
+  AllowChange := not Supervising and (cix >= 0);
   cLoc := Loc;
   Happened := ShowEvent;
 …
 procedure TCityDlg.FormMouseDown(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; x, y: integer);
+  Shift: TShiftState; X, Y: Integer);
 var
   i, qx, qy, dx, dy, fix, NewTiles, Loc1, iix, SellResult: integer;
   Rebuild: boolean;
 begin
   if (ssLeft in Shift) and (x >= xSmallMap) and (x < xSmallMap + wSmallMap) and
     (y >= ySmallMap) and (y < ySmallMap + hSmallMap) then
+  I, qx, qy, dx, dy, fix, NewTiles, Loc1, iix, SellResult: Integer;
+  Rebuild: Boolean;
+begin
+  if (ssLeft in Shift) and (X >= xSmallMap) and (X < xSmallMap + wSmallMap) and
+    (Y >= ySmallMap) and (Y < ySmallMap + hSmallMap) then
   begin
     SmallMapMode := smImprovements;
     ZoomArea := (y - ySmallMap) * 3 div hSmallMap + 3 *
       ((x - xSmallMap) * 2 div wSmallMap);
+    ZoomArea := (Y - ySmallMap) * 3 div hSmallMap + 3 *
+      ((X - xSmallMap) * 2 div wSmallMap);
     Page := 0;
     InitZoomCityMap;
     SmartUpdateContent;
     exit;
   end;
   if (ssLeft in Shift) and (x >= xSupport) and (x < xSupport + wSupport) and
     (y >= ySupport) and (y < ySupport + hSupport) then
+    Exit;
+  end;
+  if (ssLeft in Shift) and (X >= xSupport) and (X < xSupport + wSupport) and
+    (Y >= ySupport) and (Y < ySupport + hSupport) then
   begin
     SmallMapMode := smSupportedUnits;
 …
     InitZoomCityMap;
     SmartUpdateContent;
     exit;
+    Exit;
   end;
   if not AllowChange then
     exit; // not an own city
+    Exit; // Not an own city
   if (ssLeft in Shift) then
     if (ClientMode < scContact) and (x >= xView) and (y >= yView) and
       (x < xView + 73) and (y < yView + 50) then
+    if (ClientMode < scContact) and (X >= xView) and (Y >= yView) and
+      (X < xView + 73) and (Y < yView + 50) then
       if cGov = gAnarchy then
         with MessgExDlg do
+        with MainScreen.MessgExDlg do
         begin
           { MessgText:=Phrases.Lookup('OUTOFCONTROL');
             if c.Project and cpImp=0 then
             MessgText:=Format(MessgText,[Tribe[cOwner].ModelName[c.Project and cpIndex]])
             else MessgText:=Format(MessgText,[Phrases.Lookup('IMPROVEMENTS',c.Project and cpIndex)]); }
+            if C.Project and cpImp=0 then
+            MessgText:=Format(MessgText,[Tribe[cOwner].ModelName[C.Project and cpIndex]])
+            else MessgText:=Format(MessgText,[Phrases.Lookup('IMPROVEMENTS',C.Project and cpIndex)]); }
           MessgText := Phrases.Lookup('NOCHANGEINANARCHY');
           Kind := mkOk;
 …
         if ProdHint then
         begin
           ProdHint := false;
+          ProdHint := False;
           SmartUpdateContent
         end;
         ChooseProject;
       end
     else if (SmallMapMode = smImprovements) and (x >= xZoomMap) and (x < xZoomMap + wZoomMap) and
       (y >= yZoomMap) and (y < yZoomMap + hZoomMap) then
     begin
       i := 5;
       while (i >= 0) and not((x >= xZoomMap + 14 + 72 * (i mod 3)) and
         (x < xZoomMap + 14 + 56 + 72 * (i mod 3)) and
         (y >= yZoomMap + 14 + 56 * (i div 3)) and
         (y < yZoomMap + 14 + 40 + 56 * (i div 3))) do
         dec(i);
       if i >= 0 then
+    else if (SmallMapMode = smImprovements) and (X >= xZoomMap) and (X < xZoomMap + wZoomMap) and
+      (Y >= yZoomMap) and (Y < yZoomMap + hZoomMap) then
+    begin
+      I := 5;
+      while (I >= 0) and not((X >= xZoomMap + 14 + 72 * (I mod 3)) and
+        (X < xZoomMap + 14 + 56 + 72 * (I mod 3)) and
+        (Y >= yZoomMap + 14 + 56 * (I div 3)) and
+        (Y < yZoomMap + 14 + 40 + 56 * (I div 3))) do
+        Dec(I);
+      if I >= 0 then
       begin
         iix := imix[i];
+        iix := imix[I];
         if iix >= 0 then
           if ssShift in Shift then
             HelpDlg.ShowNewContent(FWindowMode or wmPersistent, hkImp, iix)
+            MainScreen.HelpDlg.ShowNewContent(WindowModeMakePersistent(FWindowMode), hkImp, iix)
           else if (ClientMode < scContact) then
             with MessgExDlg do
+            with MainScreen.MessgExDlg do
             begin
               IconKind := mikImp;
 …
               else
               begin
                 SellResult := Server(sSellCityImprovement - sExecute, me,
+                SellResult := Server(sSellCityImprovement - sExecute, Me,
                   cix, iix);
                 if SellResult < rExecuted then
 …
                 else
                 begin
                   if Server(sRebuildCityImprovement - sExecute, me, cix, iix) < rExecuted
+                  if Server(sRebuildCityImprovement - sExecute, Me, cix, iix) < rExecuted
                   then
                   begin // no rebuild possible, ask for sell only
                     Rebuild := false;
+                    Rebuild := False;
                     MessgText := Phrases.Lookup('IMPROVEMENTS', iix);
                     if not Phrases2FallenBackToEnglish then
                       MessgText := Format(Phrases2.Lookup('SELL2'),
                         [MessgText, Imp[iix].Cost * BuildCostMod
                         [G.Difficulty[me]] div 12])
+                        [G.Difficulty[Me]] div 12])
                     else
                       MessgText := Format(Phrases.Lookup('SELL'), [MessgText]);
                     if iix = imSpacePort then
                       with MyRO.Ship[me] do
+                      with MyRO.Ship[Me] do
                         if Parts[0] + Parts[1] + Parts[2] > 0 then
                           MessgText := MessgText + ' ' +
 …
                   else
                   begin
                     Rebuild := true;
+                    Rebuild := True;
                     MessgText := Phrases.Lookup('IMPROVEMENTS', iix);
                     if not Phrases2FallenBackToEnglish then
                       MessgText := Format(Phrases2.Lookup('DISPOSE2'),
                         [MessgText, Imp[iix].Cost * BuildCostMod
                         [G.Difficulty[me]] div 12 * 2 div 3])
+                        [G.Difficulty[Me]] div 12 * 2 div 3])
                     else
                       MessgText := Format(Phrases.Lookup('DISPOSE'),
                         [MessgText]);
                     if iix = imSpacePort then
                       with MyRO.Ship[me] do
+                      with MyRO.Ship[Me] do
                         if Parts[0] + Parts[1] + Parts[2] > 0 then
                           MessgText := MessgText + ' ' +
 …
                     begin
                       Play('CITY_REBUILDIMP');
                       Server(sRebuildCityImprovement, me, cix, iix);
+                      Server(sRebuildCityImprovement, Me, cix, iix);
                     end
                     else
                     begin
                       Play('CITY_SELLIMP');
                       Server(sSellCityImprovement, me, cix, iix);
+                      Server(sSellCityImprovement, Me, cix, iix);
                     end;
                     CityOptimizer_CityChange(cix);
 …
       end;
     end
     else if (SmallMapMode = smSupportedUnits) and (x >= xZoomMap) and (x < xZoomMap + wZoomMap) and
       (y >= yZoomMap) and (y < yZoomMap + hZoomMap) then
     begin
       i := 5;
       while (i >= 0) and not((x >= xZoomMap + 64 * (i mod 3)) and
         (x < xZoomMap + 64 + 64 * (i mod 3)) and
         (y >= yZoomMap + 20 + 48 * (i div 3)) and
         (y < yZoomMap + 20 + 52 + 48 * (i div 3))) do
         dec(i);
       if (i >= 0) and (imix[i] >= 0) then
+    else if (SmallMapMode = smSupportedUnits) and (X >= xZoomMap) and (X < xZoomMap + wZoomMap) and
+      (Y >= yZoomMap) and (Y < yZoomMap + hZoomMap) then
+    begin
+      I := 5;
+      while (I >= 0) and not((X >= xZoomMap + 64 * (I mod 3)) and
+        (X < xZoomMap + 64 + 64 * (I mod 3)) and
+        (Y >= yZoomMap + 20 + 48 * (I div 3)) and
+        (Y < yZoomMap + 20 + 52 + 48 * (I div 3))) do
+        Dec(I);
+      if (I >= 0) and (imix[I] >= 0) then
         if ssShift in Shift then
         else if (cix >= 0) and (ClientMode < scContact) and
 …
           CloseAction := None;
           Close;
           MainScreen.CityClosed(imix[i], false, true);
+          MainScreen.CityClosed(imix[I], False, True);
         end;
     end
     else if (x >= xmArea - 192) and (x < xmArea + 192) and (y >= ymArea - 96)
       and (y < ymArea + 96) then
+    else if (X >= xmArea - 192) and (X < xmArea + 192) and (Y >= ymArea - 96)
+      and (Y < ymArea + 96) then
     with AreaMap do begin
       qx := ((4000 * xxt * yyt) + (x - xmArea) * (yyt * 2) + (y - ymArea + yyt)
+      qx := ((4000 * xxt * yyt) + (X - xmArea) * (yyt * 2) + (Y - ymArea + yyt)
         * (xxt * 2)) div (xxt * yyt * 4) - 1000;
       qy := ((4000 * xxt * yyt) + (y - ymArea + yyt) * (xxt * 2) - (x - xmArea)
+      qy := ((4000 * xxt * yyt) + (Y - ymArea + yyt) * (xxt * 2) - (X - xmArea)
         * (yyt * 2)) div (xxt * yyt * 4) - 1000;
       dx := qx - qy;
 …
           Loc1 := dLoc(cLoc, dx, dy);
           if (Loc1 >= 0) and (Loc1 < G.lx * G.ly) then
             HelpOnTerrain(Loc1, FWindowMode or wmPersistent)
+            HelpOnTerrain(Loc1, WindowModeMakePersistent(FWindowMode))
         end
         else if (ClientMode < scContact) and (cGov <> gAnarchy) and
           (c.Flags and chCaptured = 0) then
+          (C.Flags and chCaptured = 0) then
         begin // toggle exploitation
           assert(not supervising);
           if c.Status and csResourceWeightsMask <> 0 then
+          Assert(not Supervising);
+          if C.Status and csResourceWeightsMask <> 0 then
           begin
             with MessgExDlg do
+            with MainScreen.MessgExDlg do
             begin
               MessgText := Phrases.Lookup('CITYMANAGEOFF');
 …
               ShowModal;
             end;
             if MessgExDlg.ModalResult = mrOK then
+            if MainScreen.MessgExDlg.ModalResult = mrOK then
             begin
               MyCity[cix].Status := MyCity[cix].Status and
                 not csResourceWeightsMask; // off
               c.Status := MyCity[cix].Status;
+              C.Status := MyCity[cix].Status;
               SmartUpdateContent;
             end;
             exit;
+            Exit;
           end;
           fix := (dy + 3) shl 2 + (dx + 3) shr 1;
           NewTiles := MyCity[cix].Tiles xor (1 shl fix);
           if Server(sSetCityTiles, me, cix, NewTiles) >= rExecuted then
+          if Server(sSetCityTiles, Me, cix, NewTiles) >= rExecuted then
           begin
             SmartUpdateContent;
 …
     end
     else if (ClientMode < scContact) and (cGov <> gAnarchy) and
       (c.Flags and chCaptured = 0) and (x >= xmOpt - 32) and (x < xmOpt + 32)
       and (y >= ymOpt - 32) and (y < ymOpt + 32) then
     begin
       i := sqr(x - xmOpt) + sqr(y - ymOpt); // click radius
       if i <= 32 * 32 then
+      (C.Flags and chCaptured = 0) and (X >= xmOpt - 32) and (X < xmOpt + 32)
+      and (Y >= ymOpt - 32) and (Y < ymOpt + 32) then
+    begin
+      I := sqr(X - xmOpt) + sqr(Y - ymOpt); // click radius
+      if I <= 32 * 32 then
       begin
         if i < 16 * 16 then // inner area clicked
           if c.Status and csResourceWeightsMask <> 0 then
             i := (c.Status shr 4 and $0F) mod 5 + 1 // rotate except off
+        if I < 16 * 16 then // inner area clicked
+          if C.Status and csResourceWeightsMask <> 0 then
+            I := (C.Status shr 4 and $0F) mod 5 + 1 // rotate except off
           else
             i := 3 // rwGrowth
+            I := 3 // rwGrowth
         else
           case trunc(arctan2(x - xmOpt, ymOpt - y) * 180 / pi) of
+          case trunc(arctan2(X - xmOpt, ymOpt - Y) * 180 / pi) of
             - 25 - 52 * 2 .. -26 - 52:
               i := 1;
+              I := 1;
             -25 - 52 .. -26:
               i := 2;
+              I := 2;
             -25 .. 25:
               i := 3;
+              I := 3;
 .. 25 + 52:
               i := 4;
+              I := 4;
 + 52 .. 25 + 52 * 2:
               i := 5;
+              I := 5;
 - 26 .. 180, -180 .. -180 + 26:
               i := 0;
+              I := 0;
           else
             i := -1;
+            I := -1;
           end;
         if i >= 0 then
+        if I >= 0 then
         begin
           ChangeResourceWeights(i);
+          ChangeResourceWeights(I);
           SmartUpdateContent;
           if WindowMode <> wmModal then
 …
       end;
     end;
 end; { FormMouseDown }
+end;
 procedure TCityDlg.ChooseProject;
 …
   );
   function ProjectType(Project: integer): TProjectType;
+  function ProjectType(Project: Integer): TProjectType;
   begin
     if Project and cpCompleted <> 0 then
 …
 var
   NewProject, OldMoney, cix1: integer;
+  NewProject, OldMoney, cix1: Integer;
   pt0, pt1: TProjectType;
   QueryOk: boolean;
 begin
   Assert(not supervising);
   ModalSelectDlg.ShowNewContent_CityProject(wmModal, cix);
   if ModalSelectDlg.result <> -1 then
   begin
     if ModalSelectDlg.result and cpType <> 0 then
+  QueryOk: Boolean;
+begin
+  Assert(not Supervising);
+  MainScreen.ModalSelectDlg.ShowNewContent_CityProject(wmModal, cix);
+  if MainScreen.ModalSelectDlg.Result <> -1 then
+  begin
+    if MainScreen.ModalSelectDlg.Result and cpType <> 0 then
     begin
       MyCity[cix].Status := MyCity[cix].Status and not 7 or
         (1 + ModalSelectDlg.result and cpIndex);
       AutoBuild(cix, MyData.ImpOrder[ModalSelectDlg.result and cpIndex]);
+        (1 + MainScreen.ModalSelectDlg.Result and cpIndex);
+      AutoBuild(cix, MyData.ImpOrder[MainScreen.ModalSelectDlg.Result and cpIndex]);
     end
     else
     begin
       NewProject := ModalSelectDlg.Result;
+      NewProject := MainScreen.ModalSelectDlg.Result;
       QueryOk := True;
       if (NewProject and cpImp <> 0) and (NewProject and cpIndex >= 28) and
         (MyRO.NatBuilt[NewProject and cpIndex] > 0) then
         with MessgExDlg do
+        with MainScreen.MessgExDlg do
         begin
           cix1 := MyRO.nCity - 1;
 …
         then
           NewProject := NewProject or cpDisbandCity;
       Server(sSetCityProject, me, cix, NewProject);
       c.Project := MyCity[cix].Project;
+      Server(sSetCityProject, Me, cix, NewProject);
+      C.Project := MyCity[cix].Project;
       if MyRO.Money > OldMoney then
         Play('CITY_SELLIMP');
 …
 procedure TCityDlg.BuyClick(Sender: TObject);
 var
   NextProd, Cost: integer;
+  NextProd, Cost: Integer;
 begin
   if (cix < 0) or (ClientMode >= scContact) then
     exit;
   with MyCity[cix], MessgExDlg do
+    Exit;
+  with MyCity[cix], MainScreen.MessgExDlg do
   begin
     Cost := Report.ProjectCost;
 …
       NextProd := 0;
     Cost := Cost - Prod - NextProd;
     if (MyRO.Wonder[woMich].EffectiveOwner = me) and (Project and cpImp <> 0)
+    if (MyRO.Wonder[woMich].EffectiveOwner = Me) and (Project and cpImp <> 0)
     then
       Cost := Cost * 2
 …
     if (Kind = mkYesNo) and (ModalResult = mrOK) then
     begin
       if Server(sBuyCityProject, me, cix, nil^) >= rExecuted then
+      if Server(sBuyCityProject, Me, cix, nil^) >= rExecuted then
       begin
         Play('CITY_BUYPROJECT');
 …
 procedure TCityDlg.FormClose(Sender: TObject; var Action: TCloseAction);
 begin
   Timer1.Enabled := false;
   ProdHint := false;
+  Timer1.Enabled := False;
+  ProdHint := False;
   MarkCityLoc := -1;
   if Optimize_cixTileChange >= 0 then
 …
       with Canvas do
       begin
         DpiBitCanvas(Canvas, xView + 5, yView + 1, 64, 2, Back.Canvas,
+        DpiBitBltCanvas(Canvas, xView + 5, yView + 1, 64, 2, Back.Canvas,
           xView + 5, yView + 1);
         DpiBitCanvas(Canvas, xView + 5, yView + 3, 2, 42, Back.Canvas,
+        DpiBitBltCanvas(Canvas, xView + 5, yView + 3, 2, 42, Back.Canvas,
           xView + 5, yView + 3);
         DpiBitCanvas(Canvas, xView + 5 + 62, yView + 3, 2, 42,
+        DpiBitBltCanvas(Canvas, xView + 5 + 62, yView + 3, 2, 42,
           Back.Canvas, xView + 5 + 62, yView + 3);
         ScreenTools.Frame(Canvas, xView + 9 - 1, yView + 5 - 1, xView + 9 + xSizeBig,
 …
     else if BlinkTime = 6 then
     begin
       if AllowChange and (c.Status and 7 <> 0) then
+      if AllowChange and (C.Status and 7 <> 0) then
       begin // city type autobuild
         FrameImage(Canvas, bigimp, xView + 9, yView + 5, xSizeBig, ySizeBig,
           (c.Status and 7 - 1 + 3) * xSizeBig, 0, true);
+          (C.Status and 7 - 1 + 3) * xSizeBig, 0, True);
       end
       else if c.Project and cpImp = 0 then
+      else if C.Project and cpImp = 0 then
       begin // project is unit
         DpiBitCanvas(Canvas, xView + 9, yView + 5, xSizeBig, ySizeBig,
+        DpiBitBltCanvas(Canvas, xView + 9, yView + 5, xSizeBig, ySizeBig,
           Bigimp.Canvas, 0, 0);
         with Tribe[cOwner].ModelPicture[c.Project and cpIndex] do
+        with Tribe[cOwner].ModelPicture[C.Project and cpIndex] do
           Sprite(Canvas, HGr, xView + 5, yView + 1, 64, 44, pix mod 10 * 65 + 1,
             pix div 10 * 49 + 1);
       end
       else
         ImpImage(Canvas, xView + 9, yView + 5, c.Project0 and cpIndex,
           cGov, true);
+        ImpImage(Canvas, xView + 9, yView + 5, C.Project0 and cpIndex,
+          cGov, True);
     end;
   end;
 …
   if 1 shl OpenSoundEvent = chProduction then
   begin
     if c.Project0 and cpImp <> 0 then
     begin
       if c.Project0 and cpIndex >= 28 then
+    if C.Project0 and cpImp <> 0 then
+    begin
+      if C.Project0 and cpIndex >= 28 then
       // wonders have already extra message with sound
         if Imp[c.Project0 and cpIndex].Kind = ikShipPart then
+        if Imp[C.Project0 and cpIndex].Kind = ikShipPart then
           Play('SHIP_BUILT')
         else
 …
 end;
 function Prio(iix: integer): integer;
+function Prio(iix: Integer): Integer;
 begin
   case Imp[iix].Kind of
     ikWonder:
       result := iix + 10000;
+      Result := iix + 10000;
     ikNatLocal, ikNatGlobal:
       case iix of
         imPalace:
           result := 0;
+          Result := 0;
       else
         result := iix + 20000;
+        Result := iix + 20000;
       end;
   else
     case iix of
       imTownHall, imCourt:
         result := iix + 30000;
+        Result := iix + 30000;
       imAqueduct, imSewer:
         result := iix + 40000;
+        Result := iix + 40000;
       imTemple, imTheater, imCathedral:
         result := iix + 50000;
     else
       result := iix + 90000;
+        Result := iix + 50000;
+    else
+      Result := iix + 90000;
     end;
   end;
 …
 end;
 procedure TCityDlg.ChangeCity(d: integer);
+procedure TCityDlg.ChangeCity(D: Integer);
 var
   cixNew: integer;
+  cixNew: Integer;
 begin
   cixNew := cix;
   repeat
     cixNew := (cixNew + MyRO.nCity + d) mod MyRO.nCity;
+    cixNew := (cixNew + MyRO.nCity + D) mod MyRO.nCity;
   until (MyCity[cixNew].Loc >= 0) or (cixNew = cix);
   if cixNew <> cix then
 …
 end;
-{ procedure TCityDlg.AdviceBtnClick(Sender: TObject);
-  begin
-  AdvisorDlg.GiveCityAdvice(cix);
-  end; }
 procedure TCityDlg.PageUpBtnClick(Sender: TObject);
 begin
   if Page > 0 then
   begin
     dec(Page);
+    Dec(Page);
     SmartUpdateContent;
   end;
 …
   if Page < PageCount - 1 then
   begin
     inc(Page);
+    Inc(Page);
     SmartUpdateContent;
   end;
 end;
 procedure TCityDlg.ChangeResourceWeights(iResourceWeights: integer);
+procedure TCityDlg.ChangeResourceWeights(iResourceWeights: Integer);
 var
   Advice: TCityTileAdviceData;
 begin
   assert(not supervising);
   assert(cix >= 0);
+  Assert(not Supervising);
+  Assert(cix >= 0);
   MyCity[cix].Status := MyCity[cix].Status and not csResourceWeightsMask or
     (iResourceWeights shl 4);
   c.Status := MyCity[cix].Status;
+  C.Status := MyCity[cix].Status;
   if iResourceWeights > 0 then
   begin
     Advice.ResourceWeights := OfferedResourceWeights[iResourceWeights];
     Server(sGetCityTileAdvice, me, cix, Advice);
+    Server(sGetCityTileAdvice, Me, cix, Advice);
     if Advice.Tiles <> MyCity[cix].Tiles then
       Server(sSetCityTiles, me, cix, Advice.Tiles);
+      Server(sSetCityTiles, Me, cix, Advice.Tiles);
   end;
 end;
 …
 procedure SortImprovements;
 var
   i, j, k: integer;
 begin
   for i := 0 to nImp - 1 do
     ImpSorted[i] := i;
   for i := 0 to nImp - 2 do
     for j := i + 1 to nImp - 1 do
       if Prio(ImpSorted[i]) > Prio(ImpSorted[j]) then begin
         k := ImpSorted[i];
         ImpSorted[i] := ImpSorted[j];
         ImpSorted[j] := k;
+  I, J, K: Integer;
+begin
+  for I := 0 to nImp - 1 do
+    ImpSorted[I] := I;
+  for I := 0 to nImp - 2 do
+    for J := I + 1 to nImp - 1 do
+      if Prio(ImpSorted[I]) > Prio(ImpSorted[J]) then begin
+        K := ImpSorted[I];
+        ImpSorted[I] := ImpSorted[J];
+        ImpSorted[J] := K;
       end;
 end;

branches/highdpi/LocalPlayer/CityType.pas

-              r361
+              r465
 uses
+  UDpiControls, Protocol, ClientTools, Term, ScreenTools, BaseWin, LCLIntf, LCLType,
+  SysUtils, Classes, Graphics, Controls, Forms,
+  ButtonB, ExtCtrls;
+  UDpiControls, Protocol, ClientTools, ScreenTools, BaseWin, LCLIntf, LCLType,
+  SysUtils, Classes, Graphics, Controls, Forms, ButtonB, ExtCtrls;
 type
 …
     procedure FormShow(Sender: TObject);
     procedure PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; x, y: integer);
+      Shift: TShiftState; X, Y: Integer);
     procedure PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; x, y: integer);
+      Shift: TShiftState; X, Y: Integer);
     procedure FormClose(Sender: TObject; var Action: TCloseAction);
     procedure DeleteBtnClick(Sender: TObject);
   public
     procedure ShowNewContent(NewMode: integer);
+    procedure ShowNewContent(NewMode: TWindowMode);
   protected
     procedure OffscreenPaint; override;
   private
     nPool, dragiix, ctype: integer;
     Pooliix: array [0 .. nImp - 1] of integer;
+    nPool, dragiix, ctype: Integer;
+    Pooliix: array [0 .. nImp - 1] of Integer;
     listed: Set of 0 .. nImp;
     Changed: boolean;
     procedure LoadType(NewType: integer);
+    Changed: Boolean;
+    procedure LoadType(NewType: Integer);
     procedure SaveType;
   end;
-var
-  CityTypeDlg: TCityTypeDlg;
 implementation
+uses Help;
+uses
+  Help, Term;
 {$R *.lfm}
 …
 procedure TCityTypeDlg.OffscreenPaint;
 var
   i, iix: integer;
   s: string;
+  I, iix: Integer;
+  S: string;
 begin
   inherited;
   offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
+  Offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
   FillOffscreen(xList - 7, yList, 42 * nListCol + 14, 32 * nListRow);
   FillOffscreen(xPool - 7, yPool, 42 * nPoolCol + 14, 32 * nPoolRow);
 …
     yPool - yList - 32 * nListRow);
   Frame(offscreen.Canvas, 0, yList + 32 * nListRow, InnerWidth - 255,
+  Frame(Offscreen.Canvas, 0, yList + 32 * nListRow, InnerWidth - 255,
     yPool - 23, MainTexture.ColorBevelLight, MainTexture.ColorBevelShade);
   Frame(offscreen.Canvas, InnerWidth - 254, yList + 32 * nListRow,
+  Frame(Offscreen.Canvas, InnerWidth - 254, yList + 32 * nListRow,
     InnerWidth - 89, yPool - 23, MainTexture.ColorBevelLight,
     MainTexture.ColorBevelShade);
   Frame(offscreen.Canvas, InnerWidth - 88, yList + 32 * nListRow,
+  Frame(Offscreen.Canvas, InnerWidth - 88, yList + 32 * nListRow,
     InnerWidth - 1, yPool - 23, MainTexture.ColorBevelLight,
     MainTexture.ColorBevelShade);
   Frame(offscreen.Canvas, 0, yPool - 22, InnerWidth - 1, yPool - 1,
+  Frame(Offscreen.Canvas, 0, yPool - 22, InnerWidth - 1, yPool - 1,
     MainTexture.ColorBevelLight, MainTexture.ColorBevelShade);
   for i := 0 to nCityType - 1 do
   begin
     RFrame(offscreen.Canvas, xSwitch + i * 42, ySwitch, xSwitch + 39 + i * 42,
+  for I := 0 to nCityType - 1 do
+  begin
+    RFrame(Offscreen.Canvas, xSwitch + I * 42, ySwitch, xSwitch + 39 + I * 42,
       ySwitch + 23, MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
     if i = ctype then
       Frame(offscreen.Canvas, xSwitch + 1 + i * 42, ySwitch + 1,
         xSwitch + 38 + i * 42, ySwitch + 22, MainTexture.ColorBevelShade,
+    if I = ctype then
+      Frame(Offscreen.Canvas, xSwitch + 1 + I * 42, ySwitch + 1,
+        xSwitch + 38 + I * 42, ySwitch + 22, MainTexture.ColorBevelShade,
         MainTexture.ColorBevelLight)
     else
       Frame(offscreen.Canvas, xSwitch + 1 + i * 42, ySwitch + 1,
         xSwitch + 38 + i * 42, ySwitch + 22, MainTexture.ColorBevelLight,
+      Frame(Offscreen.Canvas, xSwitch + 1 + I * 42, ySwitch + 1,
+        xSwitch + 38 + I * 42, ySwitch + 22, MainTexture.ColorBevelLight,
         MainTexture.ColorBevelShade);
     DpiBitCanvas(offscreen.Canvas, xSwitch + 2 + i * 42, ySwitch + 2,
       xSizeSmall, ySizeSmall, SmallImp.Canvas, (i + 3) * xSizeSmall, 0);
   end;
   RisedTextOut(offscreen.Canvas, 8, yList + 32 * nListRow + 2,
+    DpiBitBltCanvas(Offscreen.Canvas, xSwitch + 2 + I * 42, ySwitch + 2,
+      xSizeSmall, ySizeSmall, SmallImp.Canvas, (I + 3) * xSizeSmall, 0);
+  end;
+  RisedTextOut(Offscreen.Canvas, 8, yList + 32 * nListRow + 2,
     Phrases.Lookup('BUILDORDER'));
   RisedTextOut(offscreen.Canvas, 8, ySwitch + 26,
+  RisedTextOut(Offscreen.Canvas, 8, ySwitch + 26,
     Phrases.Lookup('CITYTYPE', ctype));
   s := Phrases.Lookup('BUILDREST');
   RisedTextOut(offscreen.Canvas,
     (InnerWidth - BiColorTextWidth(offscreen.Canvas, s)) div 2,
     yList + 72 + 32 * nListRow, s);
   with offscreen.Canvas do
   begin
     for i := 1 to nListRow - 1 do
       DLine(offscreen.Canvas, xList - 5, xList + 4 + 42 * nListCol,
         yList - 1 + 32 * i, MainTexture.ColorBevelLight, MainTexture.ColorBevelShade);
     for i := 0 to nListCol * nListRow - 1 do
     begin
       s := IntToStr(i + 1);
+  S := Phrases.Lookup('BUILDREST');
+  RisedTextOut(Offscreen.Canvas,
+    (InnerWidth - BiColorTextWidth(Offscreen.Canvas, S)) div 2,
+    yList + 72 + 32 * nListRow, S);
+  with Offscreen.Canvas do
+  begin
+    for I := 1 to nListRow - 1 do
+      DLine(Offscreen.Canvas, xList - 5, xList + 4 + 42 * nListCol,
+        yList - 1 + 32 * I, MainTexture.ColorBevelLight, MainTexture.ColorBevelShade);
+    for I := 0 to nListCol * nListRow - 1 do
+    begin
+      S := IntToStr(I + 1);
       Font.Color := MainTexture.ColorTextLight;
       Textout(xList + 20 + i mod nListCol * 42 - TextWidth(s) div 2,
         yList + 15 + i div nListCol * 32 - TextHeight(s) div 2, s);
     end;
   end;
   i := 0;
   while MyData.ImpOrder[ctype, i] >= 0 do
   begin
     RFrame(offscreen.Canvas, xList + 20 - xSizeSmall div 2 + i mod nListCol *
 , yList + 15 - ySizeSmall div 2 + i div nListCol * 32,
       xList + 21 + xSizeSmall div 2 + i mod nListCol * 42,
       yList + 16 + ySizeSmall div 2 + i div nListCol * 32,
+      Textout(xList + 20 + I mod nListCol * 42 - TextWidth(S) div 2,
+        yList + 15 + I div nListCol * 32 - TextHeight(S) div 2, S);
+    end;
+  end;
+  I := 0;
+  while MyData.ImpOrder[ctype, I] >= 0 do
+  begin
+    RFrame(Offscreen.Canvas, xList + 20 - xSizeSmall div 2 + I mod nListCol *
+, yList + 15 - ySizeSmall div 2 + I div nListCol * 32,
+      xList + 21 + xSizeSmall div 2 + I mod nListCol * 42,
+      yList + 16 + ySizeSmall div 2 + I div nListCol * 32,
       MainTexture.ColorBevelLight, MainTexture.ColorBevelShade);
     DpiBitCanvas(offscreen.Canvas, xList + 21 - xSizeSmall div 2 +
       i mod nListCol * 42, yList + 16 - ySizeSmall div 2 + i div nListCol * 32,
+    DpiBitBltCanvas(Offscreen.Canvas, xList + 21 - xSizeSmall div 2 +
+      I mod nListCol * 42, yList + 16 - ySizeSmall div 2 + I div nListCol * 32,
       xSizeSmall, ySizeSmall, SmallImp.Canvas,
       MyData.ImpOrder[ctype, i] mod 7 * xSizeSmall,
       (MyData.ImpOrder[ctype, i] + SystemIconLines * 7) div 7 *
+      MyData.ImpOrder[ctype, I] mod 7 * xSizeSmall,
+      (MyData.ImpOrder[ctype, I] + SystemIconLines * 7) div 7 *
       ySizeSmall);
     inc(i);
+    Inc(I);
   end;
 …
     begin
       Pooliix[nPool] := iix;
       RFrame(offscreen.Canvas, xPool + 20 - xSizeSmall div 2 +
+      RFrame(Offscreen.Canvas, xPool + 20 - xSizeSmall div 2 +
         nPool mod nPoolCol * 42, yPool + 15 - ySizeSmall div 2 +
         nPool div nPoolCol * 32, xPool + 21 + xSizeSmall div 2 +
 …
         nPool div nPoolCol * 32, MainTexture.ColorBevelLight,
         MainTexture.ColorBevelShade);
       DpiBitCanvas(offscreen.Canvas, xPool + 21 - xSizeSmall div 2 +
+      DpiBitBltCanvas(Offscreen.Canvas, xPool + 21 - xSizeSmall div 2 +
         nPool mod nPoolCol * 42, yPool + 16 - ySizeSmall div 2 +
         nPool div nPoolCol * 32, xSizeSmall, ySizeSmall, SmallImp.Canvas,
         iix mod 7 * xSizeSmall, (iix + SystemIconLines * 7) div 7 *
         ySizeSmall);
       inc(nPool);
+      Inc(nPool);
     end;
   DeleteBtn.Visible := MyData.ImpOrder[ctype, 0] >= 0;
 …
   if dragiix >= 0 then
   begin
     ImpImage(offscreen.Canvas, xView + 9, yView + 5, dragiix);
     s := Phrases.Lookup('IMPROVEMENTS', dragiix);
     RisedTextOut(offscreen.Canvas,
       xView + 36 - BiColorTextWidth(offscreen.Canvas, s) div 2,
       ySwitch + 26, s);
+    ImpImage(Offscreen.Canvas, xView + 9, yView + 5, dragiix);
+    S := Phrases.Lookup('IMPROVEMENTS', dragiix);
+    RisedTextOut(Offscreen.Canvas,
+      xView + 36 - BiColorTextWidth(Offscreen.Canvas, S) div 2,
+      ySwitch + 26, S);
   end;
   MarkUsedOffscreen(InnerWidth, InnerHeight);
 end; { MainPaint }
 procedure TCityTypeDlg.LoadType(NewType: integer);
 var
   i: integer;
+end;
+procedure TCityTypeDlg.LoadType(NewType: Integer);
+var
+  I: Integer;
 begin
   ctype := NewType;
   listed := [];
   i := 0;
   while MyData.ImpOrder[ctype, i] >= 0 do
   begin
     include(listed, MyData.ImpOrder[ctype, i]);
     inc(i);
   end;
   Changed := false;
+  I := 0;
+  while MyData.ImpOrder[ctype, I] >= 0 do
+  begin
+    Include(listed, MyData.ImpOrder[ctype, I]);
+    Inc(I);
+  end;
+  Changed := False;
 end;
 procedure TCityTypeDlg.SaveType;
 var
   cix: integer;
+  cix: Integer;
 begin
   if Changed then
 …
       if (MyCity[cix].Loc >= 0) and (MyCity[cix].Status and 7 = ctype + 1) then
         AutoBuild(cix, MyData.ImpOrder[ctype]);
     Changed := false;
+    Changed := False;
   end;
 end;
 …
 end;
 procedure TCityTypeDlg.ShowNewContent(NewMode: integer);
+procedure TCityTypeDlg.ShowNewContent(NewMode: TWindowMode);
 begin
   inherited ShowNewContent(NewMode);
 …
 procedure TCityTypeDlg.PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; x, y: integer);
 var
   i: integer;
 begin
   x := x - SideFrame;
   y := y - WideFrame;
   i := (x - xList) div 42 + (y - yList) div 32 * nListCol;
   if (i < nImp) and (MyData.ImpOrder[ctype, i] >= 0) and
     (x > xList + 2 + i mod nListCol * 42) and
     (y > yList + 5 + i div nListCol * 32) and
     (x < xList + 3 + 36 + i mod nListCol * 42) and
     (y < yList + 6 + 20 + i div nListCol * 32) then
+  Shift: TShiftState; X, Y: Integer);
+var
+  I: Integer;
+begin
+  X := X - SideFrame;
+  Y := Y - WideFrame;
+  I := (X - xList) div 42 + (Y - yList) div 32 * nListCol;
+  if (I < nImp) and (MyData.ImpOrder[ctype, I] >= 0) and
+    (X > xList + 2 + I mod nListCol * 42) and
+    (Y > yList + 5 + I div nListCol * 32) and
+    (X < xList + 3 + 36 + I mod nListCol * 42) and
+    (Y < yList + 6 + 20 + I div nListCol * 32) then
   begin
     if ssShift in Shift then
       HelpDlg.ShowNewContent(FWindowMode or wmPersistent, hkImp,
         MyData.ImpOrder[ctype, i])
+      MainScreen.HelpDlg.ShowNewContent(WindowModeMakePersistent(FWindowMode), hkImp,
+        MyData.ImpOrder[ctype, I])
     else
     begin
       dragiix := MyData.ImpOrder[ctype, i];
+      dragiix := MyData.ImpOrder[ctype, I];
       DpiScreen.Cursor := crImpDrag;
       SmartUpdateContent;
     end;
     exit;
   end;
   i := (x - xPool) div 42 + (y - yPool) div 32 * nPoolCol;
   if (i < nPool) and (x > xPool + 2 + i mod nPoolCol * 42) and
     (y > yPool + 5 + i div nPoolCol * 32) and
     (x < xPool + 3 + 36 + i mod nPoolCol * 42) and
     (y < yPool + 6 + 20 + i div nPoolCol * 32) then
+    Exit;
+  end;
+  I := (X - xPool) div 42 + (Y - yPool) div 32 * nPoolCol;
+  if (I < nPool) and (X > xPool + 2 + I mod nPoolCol * 42) and
+    (Y > yPool + 5 + I div nPoolCol * 32) and
+    (X < xPool + 3 + 36 + I mod nPoolCol * 42) and
+    (Y < yPool + 6 + 20 + I div nPoolCol * 32) then
   begin
     if ssShift in Shift then
       HelpDlg.ShowNewContent(FWindowMode or wmPersistent, hkImp, Pooliix[i])
+      MainScreen.HelpDlg.ShowNewContent(WindowModeMakePersistent(FWindowMode), hkImp, Pooliix[I])
     else
     begin
       dragiix := Pooliix[i];
+      dragiix := Pooliix[I];
       DpiScreen.Cursor := crImpDrag;
       SmartUpdateContent;
     end;
     exit;
   end;
   i := (x - xSwitch) div 42;
   if (i < nCityType) and (x > xSwitch + 2 + i * 42) and
     (x < xSwitch + 3 + 36 + i * 42) and (y >= ySwitch + 2) and (y < ySwitch + 22)
+    Exit;
+  end;
+  I := (X - xSwitch) div 42;
+  if (I < nCityType) and (X > xSwitch + 2 + I * 42) and
+    (X < xSwitch + 3 + 36 + I * 42) and (Y >= ySwitch + 2) and (Y < ySwitch + 22)
   then
   begin
     SaveType;
     LoadType(i);
+    LoadType(I);
     SmartUpdateContent;
   end;
 …
 procedure TCityTypeDlg.PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; x, y: integer);
   procedure UnList(iix: integer);
+  Shift: TShiftState; X, Y: Integer);
+  procedure UnList(iix: Integer);
   var
     i: integer;
   begin
     i := 0;
     while (MyData.ImpOrder[ctype, i] >= 0) and
       (MyData.ImpOrder[ctype, i] <> iix) do
       inc(i);
     assert(MyData.ImpOrder[ctype, i] = iix);
     move(MyData.ImpOrder[ctype, i + 1], MyData.ImpOrder[ctype, i], nImp - i);
+    I: Integer;
+  begin
+    I := 0;
+    while (MyData.ImpOrder[ctype, I] >= 0) and
+      (MyData.ImpOrder[ctype, I] <> iix) do
+      Inc(I);
+    Assert(MyData.ImpOrder[ctype, I] = iix);
+    Move(MyData.ImpOrder[ctype, I + 1], MyData.ImpOrder[ctype, I], nImp - I);
     Exclude(listed, iix);
   end;
 var
   i: integer;
 begin
   x := x - SideFrame;
   y := y - WideFrame;
+  I: Integer;
+begin
+  X := X - SideFrame;
+  Y := Y - WideFrame;
   if dragiix >= 0 then
   begin
     if (x >= xList) and (x < xList + nListCol * 42) and (y >= yList) and
       (y < yList + nListRow * 32) then
+    if (X >= xList) and (X < xList + nListCol * 42) and (Y >= yList) and
+      (Y < yList + nListRow * 32) then
     begin
       if dragiix in listed then
         UnList(dragiix);
       i := (x - xList) div 42 + (y - yList) div 32 * nListCol;
       while (i > 0) and (MyData.ImpOrder[ctype, i - 1] < 0) do
         dec(i);
       move(MyData.ImpOrder[ctype, i], MyData.ImpOrder[ctype, i + 1],
         nImp - i - 1);
       MyData.ImpOrder[ctype, i] := dragiix;
       include(listed, dragiix);
       Changed := true;
+      I := (X - xList) div 42 + (Y - yList) div 32 * nListCol;
+      while (I > 0) and (MyData.ImpOrder[ctype, I - 1] < 0) do
+        Dec(I);
+      Move(MyData.ImpOrder[ctype, I], MyData.ImpOrder[ctype, I + 1],
+        nImp - I - 1);
+      MyData.ImpOrder[ctype, I] := dragiix;
+      Include(listed, dragiix);
+      Changed := True;
     end
     else if (dragiix in listed) and (x >= xPool) and (x < xPool + nPoolCol * 42)
       and (y >= yPool) and (y < yPool + nPoolRow * 32) then
+    else if (dragiix in listed) and (X >= xPool) and (X < xPool + nPoolCol * 42)
+      and (Y >= yPool) and (Y < yPool + nPoolRow * 32) then
     begin
       UnList(dragiix);
       Changed := true;
+      Changed := True;
     end;
     dragiix := -1;
 …
 procedure TCityTypeDlg.DeleteBtnClick(Sender: TObject);
 begin
   fillchar(MyData.ImpOrder[ctype], sizeof(MyData.ImpOrder[ctype]), Byte(-1));
+  FillChar(MyData.ImpOrder[ctype], SizeOf(MyData.ImpOrder[ctype]), Byte(-1));
   listed := [];
   Changed := true;
+  Changed := True;
   SmartUpdateContent;
 end;

branches/highdpi/LocalPlayer/ClientTools.pas

-              r405
+              r465
 const
   nOfferedResourceWeights = 6;
   OfferedResourceWeights: array [0 .. nOfferedResourceWeights - 1] of cardinal =
+  OfferedResourceWeights: array [0 .. nOfferedResourceWeights - 1] of Cardinal =
     (rwOff, rwMaxScience, rwForceScience, rwMaxGrowth, rwForceProd, rwMaxProd);
 type
   TImpOrder = array [0 .. (nImp + 4) div 4 * 4 - 1] of shortint;
   TEnhancementJobs = array [0 .. 11, 0 .. 7] of byte;
+  TImpOrder = array [0 .. (nImp + 4) div 4 * 4 - 1] of ShortInt;
+  TEnhancementJobs = array [0 .. 11, 0 .. 7] of Byte;
   JobResultSet = set of 0 .. 39;
 …
   Server: TServerCall;
   G: TNewGameData;
   me: integer;
+  Me: Integer;
   MyRO: ^TPlayerContext;
   MyMap: ^TTileList;
 …
   MyModel: ^TModelList;
   AdvValue: array [0 .. nAdv - 1] of integer;
 function dLoc(Loc, dx, dy: integer): integer;
 function Distance(Loc0, Loc1: integer): integer;
 function UnrestAtLoc(uix, Loc: integer): boolean;
 function GetMoveAdvice(uix, ToLoc: integer;
   var MoveAdviceData: TMoveAdviceData): integer;
 function ColorOfHealth(Health: integer): integer;
 function IsMultiPlayerGame: boolean;
 procedure ItsMeAgain(p: integer);
 function GetAge(p: integer): integer;
 function IsCivilReportNew(Enemy: integer): boolean;
 function IsMilReportNew(Enemy: integer): boolean;
 function CutCityFoodSurplus(FoodSurplus: integer; IsCityAlive: boolean;
   gov, size: integer): integer;
 function CityTaxBalance(cix: integer; const CityReport: TCityReportNew): integer;
 procedure SumCities(var TaxSum, ScienceSum: integer);
 function JobTest(uix, Job: integer; IgnoreResults: JobResultSet = []): boolean;
 procedure GetUnitInfo(Loc: integer; var uix: integer; var UnitInfo: TUnitInfo);
 procedure GetCityInfo(Loc: integer; var cix: integer; var CityInfo: TCityInfo);
 function UnitExhausted(uix: integer): boolean;
 function ModelHash(const ModelInfo: TModelInfo): integer;
 function ProcessEnhancement(uix: integer; const Jobs: TEnhancementJobs): integer;
 function AutoBuild(cix: integer; const ImpOrder: TImpOrder): boolean;
 procedure DebugMessage(Level: integer; Text: string);
+  AdvValue: array [0 .. nAdv - 1] of Integer;
+function dLoc(Loc, dx, dy: Integer): Integer;
+function Distance(Loc0, Loc1: Integer): Integer;
+function UnrestAtLoc(uix, Loc: Integer): Boolean;
+function GetMoveAdvice(uix, ToLoc: Integer;
+  var MoveAdviceData: TMoveAdviceData): Integer;
+function ColorOfHealth(Health: Integer): Integer;
+function IsMultiPlayerGame: Boolean;
+procedure ItsMeAgain(P: Integer);
+function GetAge(P: Integer): Integer;
+function IsCivilReportNew(Enemy: Integer): Boolean;
+function IsMilReportNew(Enemy: Integer): Boolean;
+function CutCityFoodSurplus(FoodSurplus: Integer; IsCityAlive: Boolean;
+  gov, size: Integer): Integer;
+function CityTaxBalance(cix: Integer; const CityReport: TCityReportNew): Integer;
+procedure SumCities(var TaxSum, ScienceSum: Integer);
+function JobTest(uix, Job: Integer; IgnoreResults: JobResultSet = []): Boolean;
+procedure GetUnitInfo(Loc: Integer; var uix: Integer; var UnitInfo: TUnitInfo);
+procedure GetCityInfo(Loc: Integer; var cix: Integer; var CityInfo: TCityInfo);
+function UnitExhausted(uix: Integer): Boolean;
+function ModelHash(const ModelInfo: TModelInfo): Integer;
+function ProcessEnhancement(uix: Integer; const Jobs: TEnhancementJobs): Integer;
+function AutoBuild(cix: Integer; const ImpOrder: TImpOrder): Boolean;
+procedure DebugMessage(Level: Integer; Text: string);
 procedure CityOptimizer_BeginOfTurn;
 procedure CityOptimizer_CityChange(cix: integer);
 procedure CityOptimizer_TileBecomesAvailable(Loc: integer);
 procedure CityOptimizer_ReleaseCityTiles(cix, ReleasedTiles: integer);
 procedure CityOptimizer_BeforeRemoveUnit(uix: integer);
+procedure CityOptimizer_CityChange(cix: Integer);
+procedure CityOptimizer_TileBecomesAvailable(Loc: Integer);
+procedure CityOptimizer_ReleaseCityTiles(cix, ReleasedTiles: Integer);
+procedure CityOptimizer_BeforeRemoveUnit(uix: Integer);
 procedure CityOptimizer_AfterRemoveUnit;
 procedure CityOptimizer_EndOfTurn;
 …
 var
   CityNeedsOptimize: array [0 .. ncmax - 1] of boolean;
 function dLoc(Loc, dx, dy: integer): integer;
 var
   y0: integer;
+  CityNeedsOptimize: array [0 .. ncmax - 1] of Boolean;
+function dLoc(Loc, dx, dy: Integer): Integer;
+var
+  y0: Integer;
 begin
   y0 := (Loc + G.lx * 1024) div G.lx - 1024;
 …
 end;
 function Distance(Loc0, Loc1: integer): integer;
 var
   dx, dy: integer;
+function Distance(Loc0, Loc1: Integer): Integer;
+var
+  dx, dy: Integer;
 begin
   Inc(Loc0, G.lx * 1024);
 …
 end;
 function UnrestAtLoc(uix, Loc: integer): boolean;
 var
   uix1: integer;
+function UnrestAtLoc(uix, Loc: Integer): Boolean;
+var
+  uix1: Integer;
 begin
   Result := False;
 …
     case MyRO.Government of
       gRepublic, gFuture:
         Result := (MyRO.Territory[Loc] >= 0) and (MyRO.Territory[Loc] <> me) and
+        Result := (MyRO.Territory[Loc] >= 0) and (MyRO.Territory[Loc] <> Me) and
           (MyRO.Treaty[MyRO.Territory[Loc]] < trAlliance);
       gDemocracy:
         Result := (MyRO.Territory[Loc] < 0) or (MyRO.Territory[Loc] <> me) and
+        Result := (MyRO.Territory[Loc] < 0) or (MyRO.Territory[Loc] <> Me) and
           (MyRO.Treaty[MyRO.Territory[Loc]] < trAlliance);
     end;
 …
 end;
 function GetMoveAdvice(uix, ToLoc: integer;
   var MoveAdviceData: TMoveAdviceData): integer;
 var
   MinEndHealth: integer;
+function GetMoveAdvice(uix, ToLoc: Integer;
+  var MoveAdviceData: TMoveAdviceData): Integer;
+var
+  MinEndHealth: Integer;
 begin
   if MyModel[MyUn[uix].mix].Domain = dGround then
 …
       MoveAdviceData.MoreTurns := 999;
       MoveAdviceData.MaxHostile_MovementLeft := MyUn[uix].Health - MinEndHealth;
       Result := Server(sGetMoveAdvice, me, uix, MoveAdviceData);
+      Result := Server(sGetMoveAdvice, Me, uix, MoveAdviceData);
       if (MinEndHealth <= 1) or (Result <> eNoWay) then
         exit;
+        Exit;
     end;
     case MinEndHealth of
 …
 end;
 function ColorOfHealth(Health: integer): integer;
 var
   red, green: integer;
 begin
   green := 400 * Health div 100;
   if green > 200 then
     green := 200;
   red := 510 * (100 - Health) div 100;
   if red > 255 then
     red := 255;
   Result := green shl 8 + red;
 end;
 function IsMultiPlayerGame: boolean;
 var
   p1: integer;
+function ColorOfHealth(Health: Integer): Integer;
+var
+  Red, Green: Integer;
+begin
+  Green := 400 * Health div 100;
+  if Green > 200 then
+    Green := 200;
+  Red := 510 * (100 - Health) div 100;
+  if Red > 255 then
+    Red := 255;
+  Result := Green shl 8 + Red;
+end;
+function IsMultiPlayerGame: Boolean;
+var
+  p1: Integer;
 begin
   Result := False;
 …
 end;
 procedure ItsMeAgain(p: integer);
 begin
   if G.RO[p] <> nil then
     MyRO := pointer(G.RO[p])
   else if G.SuperVisorRO[p] <> nil then
     MyRO := pointer(G.SuperVisorRO[p])
+procedure ItsMeAgain(P: Integer);
+begin
+  if G.RO[P] <> nil then
+    MyRO := Pointer(G.RO[P])
+  else if G.SuperVisorRO[P] <> nil then
+    MyRO := Pointer(G.SuperVisorRO[P])
   else
     exit;
   me := p;
   MyMap := pointer(MyRO.Map);
   MyUn := pointer(MyRO.Un);
   MyCity := pointer(MyRO.City);
   MyModel := pointer(MyRO.Model);
 end;
 function GetAge(p: integer): integer;
 var
   i: integer;
 begin
   if p = me then begin
+    Exit;
+  Me := P;
+  MyMap := Pointer(MyRO.Map);
+  MyUn := Pointer(MyRO.Un);
+  MyCity := Pointer(MyRO.City);
+  MyModel := Pointer(MyRO.Model);
+end;
+function GetAge(P: Integer): Integer;
+var
+  I: Integer;
+begin
+  if P = Me then begin
     Result := 0;
     for i := 1 to 3 do
       if MyRO.Tech[AgePreq[i]] >= tsApplicable then
         Result := i;
+    for I := 1 to 3 do
+      if MyRO.Tech[AgePreq[I]] >= tsApplicable then
+        Result := I;
   end else begin
     Result := 0;
     for i := 1 to 3 do
       if MyRO.EnemyReport[p].Tech[AgePreq[i]] >= tsApplicable then
         Result := i;
   end;
 end;
 function IsCivilReportNew(Enemy: integer): boolean;
 var
   i: integer;
 begin
   assert(Enemy <> me);
   i := MyRO.EnemyReport[Enemy].TurnOfCivilReport;
   Result := (i = MyRO.Turn) or (i = MyRO.Turn - 1) and (Enemy > me);
 end;
 function IsMilReportNew(Enemy: integer): boolean;
 var
   i: integer;
 begin
   assert(Enemy <> me);
   i := MyRO.EnemyReport[Enemy].TurnOfMilReport;
   Result := (i = MyRO.Turn) or (i = MyRO.Turn - 1) and (Enemy > me);
 end;
 function CutCityFoodSurplus(FoodSurplus: integer; IsCityAlive: boolean;
   gov, size: integer): integer;
+    for I := 1 to 3 do
+      if MyRO.EnemyReport[P].Tech[AgePreq[I]] >= tsApplicable then
+        Result := I;
+  end;
+end;
+function IsCivilReportNew(Enemy: Integer): Boolean;
+var
+  I: Integer;
+begin
+  Assert(Enemy <> Me);
+  I := MyRO.EnemyReport[Enemy].TurnOfCivilReport;
+  Result := (I = MyRO.Turn) or (I = MyRO.Turn - 1) and (Enemy > Me);
+end;
+function IsMilReportNew(Enemy: Integer): Boolean;
+var
+  I: Integer;
+begin
+  Assert(Enemy <> Me);
+  I := MyRO.EnemyReport[Enemy].TurnOfMilReport;
+  Result := (I = MyRO.Turn) or (I = MyRO.Turn - 1) and (Enemy > Me);
+end;
+function CutCityFoodSurplus(FoodSurplus: Integer; IsCityAlive: Boolean;
+  gov, size: Integer): Integer;
 begin
   Result := FoodSurplus;
 …
 end;
 function CityTaxBalance(cix: integer; const CityReport: TCityReportNew): integer;
 var
   i: integer;
+function CityTaxBalance(cix: Integer; const CityReport: TCityReportNew): Integer;
+var
+  I: Integer;
 begin
   Result := 0;
 …
       Inc(Result, CityReport.FoodSurplus);
   end;
   for i := nWonder to nImp - 1 do
     if MyCity[cix].Built[i] > 0 then
       Dec(Result, Imp[i].Maint);
 end;
 procedure SumCities(var TaxSum, ScienceSum: integer);
 var
   cix: integer;
+  for I := nWonder to nImp - 1 do
+    if MyCity[cix].Built[I] > 0 then
+      Dec(Result, Imp[I].Maint);
+end;
+procedure SumCities(var TaxSum, ScienceSum: Integer);
+var
+  cix: Integer;
   CityReport: TCityReportNew;
 begin
 …
   ScienceSum := 0;
   if MyRO.Government = gAnarchy then
     exit;
+    Exit;
   for cix := 0 to MyRO.nCity - 1 do
     if MyCity[cix].Loc >= 0 then
 …
       CityReport.HypoTaxRate := -1;
       CityReport.HypoLuxuryRate := -1;
       Server(sGetCityReportNew, me, cix, CityReport);
+      Server(sGetCityReportNew, Me, cix, CityReport);
       if (CityReport.HappinessBalance >= 0) { no disorder } and
         (MyCity[cix].Flags and chCaptured = 0) then // not captured
 …
 end;
 function JobTest(uix, Job: integer; IgnoreResults: JobResultSet): boolean;
 var
   Test: integer;
 begin
   Test := Server(sStartJob + Job shl 4 - sExecute, me, uix, nil^);
+function JobTest(uix, Job: Integer; IgnoreResults: JobResultSet): Boolean;
+var
+  Test: Integer;
+begin
+  Test := Server(sStartJob + Job shl 4 - sExecute, Me, uix, nil^);
   Result := (Test >= rExecuted) or (Test in IgnoreResults);
 end;
 procedure GetUnitInfo(Loc: integer; var uix: integer; var UnitInfo: TUnitInfo);
 var
   i, Cnt: integer;
+procedure GetUnitInfo(Loc: Integer; var uix: Integer; var UnitInfo: TUnitInfo);
+var
+  I, Cnt: Integer;
 begin
   if MyMap[Loc] and fOwned <> 0 then
   begin
     Server(sGetDefender, me, Loc, uix);
+    Server(sGetDefender, Me, Loc, uix);
     Cnt := 0;
     for i := 0 to MyRO.nUn - 1 do
       if MyUn[i].Loc = Loc then
+    for I := 0 to MyRO.nUn - 1 do
+      if MyUn[I].Loc = Loc then
         Inc(Cnt);
     MakeUnitInfo(me, MyUn[uix], UnitInfo);
+    MakeUnitInfo(Me, MyUn[uix], UnitInfo);
     if Cnt > 1 then
       UnitInfo.Flags := UnitInfo.Flags or unMulti;
 …
     UnitInfo := MyRO.EnemyUn[uix];
   end;
 end; { GetUnitInfo }
 procedure GetCityInfo(Loc: integer; var cix: integer; var CityInfo: TCityInfo);
+end;
+procedure GetCityInfo(Loc: Integer; var cix: Integer; var CityInfo: TCityInfo);
 begin
   if MyMap[Loc] and fOwned <> 0 then
 …
     with CityInfo do
     begin
       Owner := me;
+      Owner := Me;
       ID := MyCity[cix].ID;
       size := MyCity[cix].size;
 …
 end;
 function UnitExhausted(uix: integer): boolean;
+function UnitExhausted(uix: Integer): Boolean;
   // check if another move of this unit is still possible
 var
   dx, dy: integer;
+  dx, dy: Integer;
 begin
   Result := True;
   if (MyUn[uix].Movement > 0) or
     (MyRO.Wonder[woShinkansen].EffectiveOwner = me) then
+    (MyRO.Wonder[woShinkansen].EffectiveOwner = Me) then
     if (MyUn[uix].Movement >= 100) or
       ((MyModel[MyUn[uix].mix].Kind = mkCaravan) and
 …
           if abs(dx) + abs(dy) = 2 then
             if Server(sMoveUnit - sExecute + dx and 7 shl 4 + dy and
 shl 7, me, uix, nil^) >= rExecuted then
+shl 7, Me, uix, nil^) >= rExecuted then
               Result := False;
 end;
 function ModelHash(const ModelInfo: TModelInfo): integer;
 var
   i, FeatureCode, Hash1, Hash2, Hash2r, d: cardinal;
+function ModelHash(const ModelInfo: TModelInfo): Integer;
+var
+  I, FeatureCode, Hash1, Hash2, Hash2r, D: Cardinal;
 begin
   with ModelInfo do
     if Kind > mkEnemyDeveloped then
       Result := integer($C0000000 + Speed div 50 + Kind shl 8)
+      Result := Integer($C0000000 + Speed div 50 + Kind shl 8)
     else
     begin
       FeatureCode := 0;
       for i := mcFirstNonCap to nFeature - 1 do
         if 1 shl Domain and Feature[i].Domains <> 0 then
+      for I := mcFirstNonCap to nFeature - 1 do
+        if 1 shl Domain and Feature[I].Domains <> 0 then
         begin
           FeatureCode := FeatureCode * 2;
           if 1 shl (i - mcFirstNonCap) <> 0 then
+          if 1 shl (I - mcFirstNonCap) <> 0 then
             Inc(FeatureCode);
         end;
 …
         dGround:
         begin
           assert(FeatureCode < 1 shl 8);
           assert(Attack < 5113);
           assert(Defense < 2273);
           assert(Cost < 1611);
+          Assert(FeatureCode < 1 shl 8);
+          Assert(Attack < 5113);
+          Assert(Defense < 2273);
+          Assert(Cost < 1611);
           Hash1 := (Attack * 2273 + Defense) * 9 + (Speed - 150) div 50;
           Hash2 := FeatureCode * 1611 + Cost;
 …
         dSea:
         begin
           assert(FeatureCode < 1 shl 9);
           assert(Attack < 12193);
           assert(Defense < 6097);
           assert(Cost < 4381);
+          Assert(FeatureCode < 1 shl 9);
+          Assert(Attack < 12193);
+          Assert(Defense < 6097);
+          Assert(Cost < 4381);
           Hash1 := ((Attack * 6097 + Defense) * 5 +
             (Speed - 350) div 100) * 2;
 …
         dAir:
         begin
           assert(FeatureCode < 1 shl 5);
           assert(Attack < 2407);
           assert(Defense < 1605);
           assert(Bombs < 4813);
           assert(Cost < 2089);
+          Assert(FeatureCode < 1 shl 5);
+          Assert(Attack < 2407);
+          Assert(Defense < 1605);
+          Assert(Bombs < 4813);
+          Assert(Cost < 2089);
           Hash1 := (Attack * 1605 + Defense) shl 5 + FeatureCode;
           Hash2 := ((Bombs * 7 + ATrans_Fuel) * 4 + TTrans) * 2089 + Cost;
 …
       end;
       Hash2r := 0;
       for i := 0 to 7 do
+      for I := 0 to 7 do
       begin
         Hash2r := Hash2r * 13;
         d := Hash2 div 13;
         Inc(Hash2r, Hash2 - d * 13);
         Hash2 := d;
+        D := Hash2 div 13;
+        Inc(Hash2r, Hash2 - D * 13);
+        Hash2 := D;
       end;
       Result := integer(Domain shl 30 + Hash1 xor Hash2r);
+      Result := Integer(Domain shl 30 + Hash1 xor Hash2r);
     end;
 end;
 function ProcessEnhancement(uix: integer; const Jobs: TEnhancementJobs): integer;
+function ProcessEnhancement(uix: Integer; const Jobs: TEnhancementJobs): Integer;
   { return values:
     eJobDone - all applicable jobs done
 …
     eDied - job done and died (thurst) }
 var
   stage, NextJob, Tile: integer;
+  stage, NextJob, Tile: Integer;
   Done: set of jNone .. jPoll;
 begin
 …
   Tile := MyMap[MyUn[uix].Loc];
   if Tile and fRoad <> 0 then
     include(Done, jRoad);
+    Include(Done, jRoad);
   if Tile and fRR <> 0 then
     include(Done, jRR);
+    Include(Done, jRR);
   if (Tile and fTerImp = tiIrrigation) or (Tile and fTerImp = tiFarm) then
     include(Done, jIrr);
+    Include(Done, jIrr);
   if Tile and fTerImp = tiFarm then
     include(Done, jFarm);
+    Include(Done, jFarm);
   if Tile and fTerImp = tiMine then
     include(Done, jMine);
+    Include(Done, jMine);
   if Tile and fPoll = 0 then
     include(Done, jPoll);
+    Include(Done, jPoll);
   if MyUn[uix].Job = jNone then
 …
       Break;
     end; // tile enhancement complete
     Result := Server(sStartJob + NextJob shl 4, me, uix, nil^);
     include(Done, NextJob);
   end;
 end;
 function AutoBuild(cix: integer; const ImpOrder: TImpOrder): boolean;
 var
   i, NewProject: integer;
+    Result := Server(sStartJob + NextJob shl 4, Me, uix, nil^);
+    Include(Done, NextJob);
+  end;
+end;
+function AutoBuild(cix: Integer; const ImpOrder: TImpOrder): Boolean;
+var
+  I, NewProject: Integer;
 begin
   Result := False;
 …
     (MyCity[cix].Flags and chProduction <> 0) then
   begin
     i := 0;
+    I := 0;
     repeat
       while (ImpOrder[i] >= 0) and (MyCity[cix].Built[ImpOrder[i]] > 0) do
         Inc(i);
       if ImpOrder[i] < 0 then
+      while (ImpOrder[I] >= 0) and (MyCity[cix].Built[ImpOrder[I]] > 0) do
+        Inc(I);
+      if ImpOrder[I] < 0 then
         Break;
       assert(i < nImp);
       NewProject := cpImp + ImpOrder[i];
       if Server(sSetCityProject, me, cix, NewProject) >= rExecuted then
+      Assert(I < nImp);
+      NewProject := cpImp + ImpOrder[I];
+      if Server(sSetCityProject, Me, cix, NewProject) >= rExecuted then
       begin
         Result := True;
 …
         Break;
       end;
       Inc(i);
+      Inc(I);
     until False;
   end;
 …
 procedure CalculateAdvValues;
 var
   i, j: integer;
   known: array [0 .. nAdv - 1] of integer;
   procedure MarkPreqs(i: integer);
   begin
     if known[i] = 0 then
+  I, J: Integer;
+  known: array [0 .. nAdv - 1] of Integer;
+  procedure MarkPreqs(I: Integer);
+  begin
+    if known[I] = 0 then
     begin
       known[i] := 1;
       if (i <> adScience) and (i <> adMassProduction) then
+      known[I] := 1;
+      if (I <> adScience) and (I <> adMassProduction) then
       begin
         if (AdvPreq[i, 0] >= 0) then
           MarkPreqs(AdvPreq[i, 0]);
         if (AdvPreq[i, 1] >= 0) then
           MarkPreqs(AdvPreq[i, 1]);
+        if (AdvPreq[I, 0] >= 0) then
+          MarkPreqs(AdvPreq[I, 0]);
+        if (AdvPreq[I, 1] >= 0) then
+          MarkPreqs(AdvPreq[I, 1]);
       end;
     end;
 …
 begin
   FillChar(AdvValue, SizeOf(AdvValue), 0);
   for i := 0 to nAdv - 1 do
+  for I := 0 to nAdv - 1 do
   begin
     FillChar(known, SizeOf(known), 0);
     MarkPreqs(i);
     for j := 0 to nAdv - 1 do
       if known[j] > 0 then
         Inc(AdvValue[i]);
     if i in FutureTech then
       Inc(AdvValue[i], 3000)
+    MarkPreqs(I);
+    for J := 0 to nAdv - 1 do
+      if known[J] > 0 then
+        Inc(AdvValue[I]);
+    if I in FutureTech then
+      Inc(AdvValue[I], 3000)
     else if known[adMassProduction] > 0 then
       Inc(AdvValue[i], 2000)
+      Inc(AdvValue[I], 2000)
     else if known[adScience] > 0 then
       Inc(AdvValue[i], 1000);
   end;
 end;
 procedure DebugMessage(Level: integer; Text: string);
 begin
   Server(sMessage, me, Level, PChar(Text)^);
 end;
 function MarkCitiesAround(Loc, cixExcept: integer): boolean;
+      Inc(AdvValue[I], 1000);
+  end;
+end;
+procedure DebugMessage(Level: Integer; Text: string);
+begin
+  Server(sMessage, Me, Level, PChar(Text)^);
+end;
+function MarkCitiesAround(Loc, cixExcept: Integer): Boolean;
   // return whether a city was marked
 var
   cix: integer;
+  cix: Integer;
 begin
   Result := False;
 …
 end;
 procedure OptimizeCities(CheckOnly: boolean);
 var
   cix, fix, dx, dy, Loc1, OptiType: integer;
   Done: boolean;
+procedure OptimizeCities(CheckOnly: Boolean);
+var
+  cix, fix, dx, dy, Loc1, OptiType: Integer;
+  Done: Boolean;
   Advice: TCityTileAdviceData;
 begin
 …
         begin
           Advice.ResourceWeights := OfferedResourceWeights[OptiType];
           Server(sGetCityTileAdvice, me, cix, Advice);
+          Server(sGetCityTileAdvice, Me, cix, Advice);
           if Advice.Tiles <> MyCity[cix].Tiles then
             if CheckOnly then
 …
                     Done := False;
                 end;
               Server(sSetCityTiles, me, cix, Advice.Tiles);
+              Server(sSetCityTiles, Me, cix, Advice.Tiles);
             end;
         end;
 …
 procedure CityOptimizer_BeginOfTurn;
 var
   cix: integer;
+  cix: Integer;
 begin
   FillChar(CityNeedsOptimize, MyRO.nCity - 1, 0); // false
 …
 end;
 procedure CityOptimizer_CityChange(cix: integer);
+procedure CityOptimizer_CityChange(cix: Integer);
 begin
   if (MyRO.Government <> gAnarchy) and (cix <> -1) and (MyCity[cix].Flags and
 …
 end;
 procedure CityOptimizer_TileBecomesAvailable(Loc: integer);
+procedure CityOptimizer_TileBecomesAvailable(Loc: Integer);
 begin
   if (MyRO.Government <> gAnarchy) and MarkCitiesAround(Loc, -1) then
 …
 end;
 procedure CityOptimizer_ReleaseCityTiles(cix, ReleasedTiles: integer);
 var
   fix, dx, dy, Loc1: integer;
   Done: boolean;
+procedure CityOptimizer_ReleaseCityTiles(cix, ReleasedTiles: Integer);
+var
+  fix, dx, dy, Loc1: Integer;
+  Done: Boolean;
 begin
   if (MyRO.Government <> gAnarchy) and (ReleasedTiles <> 0) then
 …
 end;
 procedure CityOptimizer_BeforeRemoveUnit(uix: integer);
 var
   uix1: integer;
+procedure CityOptimizer_BeforeRemoveUnit(uix: Integer);
+var
+  uix1: Integer;
 begin
   if MyRO.Government <> gAnarchy then
 …
 // all cities should already be optimized here -- only check this
 var
   cix: integer;
+  cix: Integer;
 begin
 {$IFOPT O-}

branches/highdpi/LocalPlayer/Diagram.pas

-              r361
+              r465
 type
+  TDiagramKind = (dkChart, dkShip);
   TDiaDlg = class(TFramedDlg)
     CloseBtn: TButtonB;
 …
     procedure ToggleBtnClick(Sender: TObject);
     procedure PlayerClick(Sender: TObject);
+    procedure FormKeyDown(Sender: TObject; var Key: word; Shift: TShiftState);
+    procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
   public
     procedure OffscreenPaint; override;
+    procedure ShowNewContent_Charts(NewMode: integer);
+    procedure ShowNewContent_Ship(NewMode: integer; p: integer = -1);
+    procedure ShowNewContent_Charts(NewMode: TWindowMode);
+    procedure ShowNewContent_Ship(NewMode: TWindowMode; P: Integer = -1);
   private
+    Kind: (dkChart, dkShip);
+    Player, Mode: integer;
+  end;
+var
+  DiaDlg: TDiaDlg;
+procedure PaintColonyShip(canvas: TDpiCanvas; Player, Left, Width, Top: integer);
+    Kind: TDiagramKind;
+    Player: Integer;
+    Mode: Integer;
+  end;
+procedure PaintColonyShip(Canvas: TDpiCanvas; Player, Left, Width, Top: Integer);
 implementation
 …
 const
   Border = 24;
   RoundPixels: array [0 .. nStat - 1] of integer = (0, 0, 0, 5, 5, 5);
+  RoundPixels: array [0 .. nStat - 1] of Integer = (0, 0, 0, 5, 5, 5);
   yArea = 48;
   xComp: array [0 .. 5] of integer = (-60, -28, 4, 4, 36, 68);
   yComp: array [0 .. 5] of integer = (-40, -40, -79, -1, -40, -40);
   xPow: array [0 .. 3] of integer = (-116, -116, -116, -116);
   yPow: array [0 .. 3] of integer = (-28, 0, -44, 16);
   xHab: array [0 .. 1] of integer = (23, 23);
   yHab: array [0 .. 1] of integer = (-81, 1);
 procedure PaintColonyShip(canvas: TDpiCanvas; Player, Left, Width, Top: integer);
+  xComp: array [0 .. 5] of Integer = (-60, -28, 4, 4, 36, 68);
+  yComp: array [0 .. 5] of Integer = (-40, -40, -79, -1, -40, -40);
+  xPow: array [0 .. 3] of Integer = (-116, -116, -116, -116);
+  yPow: array [0 .. 3] of Integer = (-28, 0, -44, 16);
+  xHab: array [0 .. 1] of Integer = (23, 23);
+  yHab: array [0 .. 1] of Integer = (-81, 1);
+procedure PaintColonyShip(Canvas: TDpiCanvas; Player, Left, Width, Top: Integer);
 var
   i, x, r, nComp, nPow, nHab: integer;
+  I, X, R, nComp, nPow, nHab: Integer;
 begin
   Canvas.Brush.Color := $000000;
   Canvas.FillRect(Rect(Left, Top, Left + Width, Top + 200));
   Canvas.Brush.Style := bsClear;
     ScreenTools.Frame(canvas, Left - 1, Top - 1, Left + Width, Top + 200,
+    ScreenTools.Frame(Canvas, Left - 1, Top - 1, Left + Width, Top + 200,
       MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
     RFrame(canvas, Left - 2, Top - 2, Left + Width + 1, Top + 200 + 1,
+    RFrame(Canvas, Left - 2, Top - 2, Left + Width + 1, Top + 200 + 1,
       MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
     // stars
     DelphiRandSeed := Player * 11111;
     for i := 1 to Width - 16 do
+    for I := 1 to Width - 16 do
     begin
       x := DelphiRandom((Width - 16) * 200);
       r := DelphiRandom(13) + 28;
       Canvas.Pixels[x div 200 + 8, x mod 200 + Top] :=
         (r * r * r * r div 10001) * $10101;
+      X := DelphiRandom((Width - 16) * 200);
+      R := DelphiRandom(13) + 28;
+      Canvas.Pixels[X div 200 + 8, X mod 200 + Top] :=
+        (R * R * R * R div 10001) * $10101;
     end;
 …
     if nHab > 2 then
       nHab := 2;
     for i := 0 to nHab - 1 do
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xHab[i],
         Top + 100 + yHab[i], 80, 80, 34, 1);
     for i := 0 to nComp - 1 do
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[i],
         Top + 100 + yComp[i], 32, 80, 1, 1);
+    for I := 0 to nHab - 1 do
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xHab[I],
+        Top + 100 + yHab[I], 80, 80, 34, 1);
+    for I := 0 to nComp - 1 do
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[I],
+        Top + 100 + yComp[I], 32, 80, 1, 1);
     if nComp > 0 then
       for i := 3 downto nPow do
         Sprite(canvas, HGrSystem2, Left + Width div 2 + xPow[i] + 40,
           Top + 100 + yPow[i], 16, 27, 1, 82);
     for i := nPow - 1 downto 0 do
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xPow[i],
         Top + 100 + yPow[i], 56, 28, 58, 82);
+      for I := 3 downto nPow do
+        Sprite(Canvas, HGrSystem2, Left + Width div 2 + xPow[I] + 40,
+          Top + 100 + yPow[I], 16, 27, 1, 82);
+    for I := nPow - 1 downto 0 do
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xPow[I],
+        Top + 100 + yPow[I], 56, 28, 58, 82);
     if (nComp < 3) and (nHab >= 1) then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[2] + 32 - 16,
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[2] + 32 - 16,
         Top + 100 + 7 + yComp[2], 16, 27, 1, 82);
     if (nComp >= 3) and (nHab < 1) then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[2] + 32,
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[2] + 32,
         Top + 100 + 7 + yComp[2], 16, 27, 18, 82);
     if (nComp < 4) and (nHab >= 2) then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[3] + 32 - 16,
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[3] + 32 - 16,
         Top + 100 + 46 + yComp[3], 16, 27, 1, 82);
     if (nComp >= 4) and (nHab < 2) then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[3] + 32,
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[3] + 32,
         Top + 100 + 46 + yComp[3], 16, 27, 18, 82);
     if (nComp <> 6) and (nComp <> 2) and not((nComp = 0) and (nPow < 1)) then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[nComp],
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[nComp],
         Top + 100 + 7 + yComp[nComp], 16, 27, 18, 82);
     if (nComp <> 6) and (nComp <> 3) and not((nComp = 0) and (nPow < 2)) then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[nComp],
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[nComp],
         Top + 100 + 46 + yComp[nComp], 16, 27, 18, 82);
     if nComp = 2 then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[3],
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[3],
         Top + 100 + 7 + yComp[3], 16, 27, 18, 82);
     if nComp = 3 then
       Sprite(canvas, HGrSystem2, Left + Width div 2 + xComp[4],
+      Sprite(Canvas, HGrSystem2, Left + Width div 2 + xComp[4],
         Top + 100 + 7 + yComp[4], 16, 27, 18, 82);
 end;
 …
 procedure TDiaDlg.OffscreenPaint;
 var
   p, T, max, x, y, y0, Stop, r, RoundRange, LineStep: integer;
   s: string;
+  P, T, Max, X, Y, y0, Stop, R, RoundRange, LineStep: Integer;
+  S: string;
   List: ^TChart;
   function Round(T: integer): integer;
+  function Round(T: Integer): Integer;
   var
     n, i: integer;
+    N, I: Integer;
   begin
     if T < RoundRange then
       n := T
+      N := T
     else
       n := RoundRange;
     result := 0;
     for i := T - n to T do
       inc(result, List[i]);
     result := result div (n + 1);
   end;
   procedure ShareBar(x, y: integer; Cap: string; val0, val1: integer);
   begin
     LoweredTextOut(offscreen.canvas, -1, MainTexture, x - 2, y, Cap);
     DLine(offscreen.canvas, x - 2, x + 169, y + 16, MainTexture.ColorTextShade,
+      N := RoundRange;
+    Result := 0;
+    for I := T - N to T do
+      Inc(Result, List[I]);
+    Result := Result div (N + 1);
+  end;
+  procedure ShareBar(X, Y: Integer; Cap: string; val0, val1: Integer);
+  begin
+    LoweredTextOut(Offscreen.Canvas, -1, MainTexture, X - 2, Y, Cap);
+    DLine(Offscreen.Canvas, X - 2, X + 169, Y + 16, MainTexture.ColorTextShade,
       MainTexture.ColorTextLight);
     if val0 > 0 then
       s := Format(Phrases.Lookup('SHARE'), [val0, val1])
+      S := Format(Phrases.Lookup('SHARE'), [val0, val1])
     else
       s := '0';
     RisedTextOut(offscreen.canvas,
       x + 170 - BiColorTextWidth(offscreen.canvas, s), y, s);
+      S := '0';
+    RisedTextOut(Offscreen.Canvas,
+      X + 170 - BiColorTextWidth(Offscreen.Canvas, S), Y, S);
   end;
 …
   inherited;
   if Kind = dkChart then
     with offscreen.canvas do
+    with Offscreen.Canvas do
     begin
       Font.Assign(UniFont[ftTiny]);
 …
       GetMem(List, 4 * (MyRO.Turn + 2));
       if Mode = stExplore then
         max := G.lx * G.ly
+        Max := G.lx * G.ly
       else
       begin
         max := -1;
         for p := 0 to nPl - 1 do
           if (G.Difficulty[p] > 0) and
             (Server(sGetChart + Mode shl 4, me, p, List^) >= rExecuted) then
+        Max := -1;
+        for P := 0 to nPl - 1 do
+          if (G.Difficulty[P] > 0) and
+            (Server(sGetChart + Mode shl 4, Me, P, List^) >= rExecuted) then
             for T := 0 to MyRO.Turn - 1 do
             begin
               r := Round(T);
               if r > max then
                 max := r;
+              R := Round(T);
+              if R > Max then
+                Max := R;
             end;
       end;
 …
       for T := 0 to (MyRO.Turn - 1) div LineStep do
       begin
         x := Border + (InnerWidth - 2 * Border) * T *
+        X := Border + (InnerWidth - 2 * Border) * T *
           LineStep div (MyRO.Turn - 1);
         MoveTo(x, Border);
         LineTo(x, InnerHeight - Border);
         s := IntToStr(abs(TurnToYear(T * LineStep)));
         Textout(x - TextWidth(s) div 2, Border - 16, s);
+        MoveTo(X, Border);
+        LineTo(X, InnerHeight - Border);
+        S := IntToStr(abs(TurnToYear(T * LineStep)));
+        Textout(X - TextWidth(S) div 2, Border - 16, S);
       end;
       y0 := 0;
       if max > 0 then
+      if Max > 0 then
       begin
         for p := 0 to nPl - 1 do
           if (G.Difficulty[p] > 0) and
             (Server(sGetChart + Mode shl 4, me, p, List^) >= rExecuted) then
+        for P := 0 to nPl - 1 do
+          if (G.Difficulty[P] > 0) and
+            (Server(sGetChart + Mode shl 4, Me, P, List^) >= rExecuted) then
           begin
             Pen.Color := Tribe[p].Color;
+            Pen.Color := Tribe[P].Color;
             Stop := MyRO.Turn - 1;
             while (Stop > 0) and (List[Stop] = 0) do
               dec(Stop);
+              Dec(Stop);
             for T := 0 to Stop do
             begin
               r := Round(T);
               x := Border + (InnerWidth - 2 * Border) * T div (MyRO.Turn - 1);
               y := InnerHeight - Border - (InnerHeight - 2 * Border) *
                 r div max;
+              R := Round(T);
+              X := Border + (InnerWidth - 2 * Border) * T div (MyRO.Turn - 1);
+              Y := InnerHeight - Border - (InnerHeight - 2 * Border) *
+                R div Max;
               if T = 0 then
                 MoveTo(x, y)
+                MoveTo(X, Y)
                 // else if Mode=stTerritory then
                 // begin LineTo(x,y0); LineTo(x,y) end
               else if RoundPixels[Mode] = 0 then
               begin
                 if (y <> y0) or (T = Stop) then
                   LineTo(x, y)
+                if (Y <> y0) or (T = Stop) then
+                  LineTo(X, Y)
               end
               else
                 LineTo(x, y);
               y0 := y;
+                LineTo(X, Y);
+              y0 := Y;
             end;
           end;
 …
     end
   else
     with offscreen.canvas do
+    with Offscreen.Canvas do
     begin
       Font.Assign(UniFont[ftSmall]);
       FillOffscreen(0, 0, InnerWidth, InnerHeight);
       PaintColonyShip(offscreen.canvas, Player, 8, InnerWidth - 16, yArea);
+      PaintColonyShip(Offscreen.Canvas, Player, 8, InnerWidth - 16, yArea);
       ShareBar(InnerWidth div 2 - 85, InnerHeight - 62,
 …
     end;
   MarkUsedOffscreen(InnerWidth, InnerHeight);
 end; // OffscreenPaint
+end;
 procedure TDiaDlg.FormPaint(Sender: TObject);
 var
   s: string;
+  S: string;
 begin
   inherited;
   canvas.Font.Assign(UniFont[ftNormal]);
+  Canvas.Font.Assign(UniFont[ftNormal]);
   if Kind = dkChart then
     s := Phrases.Lookup('DIAGRAM', Mode)
   else
     s := Tribe[Player].TPhrase('SHORTNAME');
   LoweredTextOut(canvas, -1, MainTexture,
     (ClientWidth - BiColorTextWidth(canvas, s)) div 2, 31, s);
+    S := Phrases.Lookup('DIAGRAM', Mode)
+  else
+    S := Tribe[Player].TPhrase('SHORTNAME');
+  LoweredTextOut(Canvas, -1, MainTexture,
+    (ClientWidth - BiColorTextWidth(Canvas, S)) div 2, 31, S);
 end;
 …
 end;
 procedure TDiaDlg.ShowNewContent_Charts(NewMode: integer);
+procedure TDiaDlg.ShowNewContent_Charts(NewMode: TWindowMode);
 begin
   Kind := dkChart;
 …
 end;
 procedure TDiaDlg.ShowNewContent_Ship(NewMode, p: integer);
+procedure TDiaDlg.ShowNewContent_Ship(NewMode: TWindowMode; P: Integer);
 begin
   Kind := dkShip;
   if p < 0 then
   begin
     Player := me;
+  if P < 0 then
+  begin
+    Player := Me;
     while MyRO.Ship[Player].Parts[spComp] + MyRO.Ship[Player].Parts[spPow] +
       MyRO.Ship[Player].Parts[spHab] = 0 do
 …
   end
   else
     Player := p;
+    Player := P;
   ToggleBtn.ButtonIndex := 28;
   ToggleBtn.Hint := Phrases.Lookup('BTN_SELECT');
 …
 procedure TDiaDlg.ToggleBtnClick(Sender: TObject);
 var
   p1: integer;
   m: TDpiMenuItem;
+  p1: Integer;
+  M: TDpiMenuItem;
 begin
   if Kind = dkChart then
 …
         MyRO.Ship[p1].Parts[spHab] > 0 then
       begin
         m := TDpiMenuItem.Create(Popup);
         m.RadioItem := true;
         m.Caption := Tribe[p1].TPhrase('SHORTNAME');
         m.Tag := p1;
         m.OnClick := PlayerClick;
+        M := TDpiMenuItem.Create(Popup);
+        M.RadioItem := True;
+        M.Caption := Tribe[p1].TPhrase('SHORTNAME');
+        M.Tag := p1;
+        M.OnClick := PlayerClick;
         if p1 = Player then
           m.Checked := true;
         Popup.Items.Add(m);
+          M.Checked := True;
+        Popup.Items.Add(M);
       end;
     Popup.Popup(Left + ToggleBtn.Left, Top + ToggleBtn.Top + ToggleBtn.Height);
 …
 end;
 procedure TDiaDlg.FormKeyDown(Sender: TObject; var Key: word;
+procedure TDiaDlg.FormKeyDown(Sender: TObject; var Key: Word;
   Shift: TShiftState);
 begin

branches/highdpi/LocalPlayer/Diplomacy.pas

-              r210
+              r465
 function DipCommandToString(pSender, pTarget, Treaty, OppCommand,
   Command: integer; const OppOffer, Offer: TOffer): string;
+  Command: Integer; const OppOffer, Offer: TOffer): string;
 implementation
 …
 function DipCommandToString;
   function PriceToString(p, Price: integer): string;
+  function PriceToString(P, Price: Integer): string;
   begin
     case Price and opMask of
       opChoose:
         result := Phrases.Lookup('PRICE_CHOOSE');
+        Result := Phrases.Lookup('PRICE_CHOOSE');
       opCivilReport:
         result := Tribe[p].TPhrase('PRICE_CIVIL');
+        Result := Tribe[P].TPhrase('PRICE_CIVIL');
       opMilReport:
         result := Tribe[p].TPhrase('PRICE_MIL');
+        Result := Tribe[P].TPhrase('PRICE_MIL');
       opMap:
         result := Tribe[p].TPhrase('PRICE_MAP');
+        Result := Tribe[P].TPhrase('PRICE_MAP');
       opTreaty:
         { if Price-opTreaty<Treaty then
           case Treaty of
           trPeace: result:=Phrases.Lookup('FRENDTREATY_PEACE');
           trFriendlyContact: result:=Phrases.Lookup('FRENDTREATY_FRIENDLY');
           trAlliance: result:=Phrases.Lookup('FRENDTREATY_ALLIANCE');
           end
           else } result := Phrases.Lookup('TREATY', Price - opTreaty);
+          trPeace: Result:=Phrases.Lookup('FRENDTREATY_PEACE');
+          trFriendlyContact: Result:=Phrases.Lookup('FRENDTREATY_FRIENDLY');
+          trAlliance: Result:=Phrases.Lookup('FRENDTREATY_ALLIANCE');
+          end
+          else } Result := Phrases.Lookup('TREATY', Price - opTreaty);
       opShipParts:
         case Price shr 16 and $F of
 :
             result := Format(Phrases.Lookup('PRICE_SHIPCOMP'),
+            Result := Format(Phrases.Lookup('PRICE_SHIPCOMP'),
               [Price and $FFFF]);
 :
             result := Format(Phrases.Lookup('PRICE_SHIPPOW'),
+            Result := Format(Phrases.Lookup('PRICE_SHIPPOW'),
               [Price and $FFFF]);
 :
             result := Format(Phrases.Lookup('PRICE_SHIPHAB'),
+            Result := Format(Phrases.Lookup('PRICE_SHIPHAB'),
               [Price and $FFFF]);
         end;
       opMoney:
         result := Format('%d%%c', [Price - opMoney]);
+        Result := Format('%d%%c', [Price - opMoney]);
       opTribute:
         result := Format(Phrases.Lookup('PRICE_TRIBUTE'), [Price - opTribute]);
+        Result := Format(Phrases.Lookup('PRICE_TRIBUTE'), [Price - opTribute]);
       opTech:
         result := Phrases.Lookup('ADVANCES', Price - opTech);
+        Result := Phrases.Lookup('ADVANCES', Price - opTech);
       opAllTech:
         result := Tribe[p].TPhrase('PRICE_ALLTECH');
+        Result := Tribe[P].TPhrase('PRICE_ALLTECH');
       opModel:
         result := Tribe[p].ModelName[Price - opModel];
+        Result := Tribe[P].ModelName[Price - opModel];
       opAllModel:
         result := Tribe[p].TPhrase('PRICE_ALLMODEL');
+        Result := Tribe[P].TPhrase('PRICE_ALLMODEL');
       { opCity:
         result:=Format(TPhrase('PRICE_CITY',p),[CityName(Price-opCity)]); }
+        Result:=Format(TPhrase('PRICE_CITY',P),[CityName(Price-opCity)]); }
     end
   end;
 var
   i: integer;
+  I: Integer;
   sAdd, sDeliver, sCost: string;
   DoIntro: boolean;
+  DoIntro: Boolean;
 begin
   DoIntro := OppCommand = scDipStart;
 …
         case Treaty of
           trPeace:
             result := Phrases.Lookup('FRCANCELTREATY_PEACE');
+            Result := Phrases.Lookup('FRCANCELTREATY_PEACE');
           trFriendlyContact:
             result := Phrases.Lookup('FRCANCELTREATY_FRIENDLY');
+            Result := Phrases.Lookup('FRCANCELTREATY_FRIENDLY');
           trAlliance:
             result := Phrases.Lookup('FRCANCELTREATY_ALLIANCE');
         end;
         DoIntro := false;
+            Result := Phrases.Lookup('FRCANCELTREATY_ALLIANCE');
+        end;
+        DoIntro := False;
       end;
     scDipNotice:
       result := Phrases.Lookup('FRNOTICE');
+      Result := Phrases.Lookup('FRNOTICE');
     scDipAccept:
       begin
         if (OppOffer.nDeliver + OppOffer.nCost = 1) and
           (OppOffer.Price[0] and opMask = opTreaty) and
           (integer(OppOffer.Price[0] - opTreaty) > Treaty) then
+          (Integer(OppOffer.Price[0] - opTreaty) > Treaty) then
         // simple treaty offer
           { if OppOffer.Price[0]-opTreaty=trCeaseFire then
             result:=Tribe[pTarget].TPhrase('FRACCEPTCEASEFIRE')
             else } result := Tribe[pTarget].TPhrase('FRACCEPTTREATY')
+            Result:=Tribe[pTarget].TPhrase('FRACCEPTCEASEFIRE')
+            else } Result := Tribe[pTarget].TPhrase('FRACCEPTTREATY')
         else if OppOffer.nDeliver = 0 then
           result := Tribe[pSender].TPhrase('FRACCEPTDEMAND_STRONG')
+          Result := Tribe[pSender].TPhrase('FRACCEPTDEMAND_STRONG')
         else if OppOffer.nCost = 0 then
           result := Tribe[pSender].TPhrase('FRACCEPTPRESENT')
+          Result := Tribe[pSender].TPhrase('FRACCEPTPRESENT')
         else
           result := Tribe[pSender].TPhrase('FRACCEPTOFFER');
+          Result := Tribe[pSender].TPhrase('FRACCEPTOFFER');
       end;
     scDipBreak:
       begin
         result := Tribe[pTarget].TPhrase('FRBREAK');
         DoIntro := false;
+        Result := Tribe[pTarget].TPhrase('FRBREAK');
+        DoIntro := False;
       end;
     scDipOffer:
       begin
         result := '';
+        Result := '';
         if (OppCommand = scDipOffer) and
           ((OppOffer.nDeliver > 0) or (OppOffer.nCost > 0)) and
 …
           if (OppOffer.nDeliver + OppOffer.nCost = 1) and
             (OppOffer.Price[0] and opMask = opTreaty) and
             (integer(OppOffer.Price[0] - opTreaty) > Treaty) then
+            (Integer(OppOffer.Price[0] - opTreaty) > Treaty) then
           // simple treaty offer
             result := Tribe[pSender].TPhrase('FRNOTACCEPTTREATY') + '\'
+            Result := Tribe[pSender].TPhrase('FRNOTACCEPTTREATY') + '\'
           else if OppOffer.nDeliver = 0 then
             result := Tribe[pSender].TPhrase('FRNOTACCEPTDEMAND_STRONG') + '\'
+            Result := Tribe[pSender].TPhrase('FRNOTACCEPTDEMAND_STRONG') + '\'
           else if OppOffer.nCost = 0 then
             result := Tribe[pSender].TPhrase('FRNOTACCEPTPRESENT') + '\';
+            Result := Tribe[pSender].TPhrase('FRNOTACCEPTPRESENT') + '\';
         end;
         sDeliver := '';
         for i := 0 to Offer.nDeliver - 1 do
         begin
           sAdd := PriceToString(pSender, Offer.Price[i]);
           if i = 0 then
+        for I := 0 to Offer.nDeliver - 1 do
+        begin
+          sAdd := PriceToString(pSender, Offer.Price[I]);
+          if I = 0 then
             sDeliver := sAdd
           else
 …
         end;
         sCost := '';
         for i := 0 to Offer.nCost - 1 do
         begin
           sAdd := PriceToString(pTarget, Offer.Price[Offer.nDeliver + i]);
           if i = 0 then
+        for I := 0 to Offer.nCost - 1 do
+        begin
+          sAdd := PriceToString(pTarget, Offer.Price[Offer.nDeliver + I]);
+          if I = 0 then
             sCost := sAdd
           else
 …
           if (OppCommand = scDipOffer) and
             ((OppOffer.nDeliver = 0) and (OppOffer.nCost = 0)) then
             result := Tribe[pTarget].TPhrase('FRBYE')
+            Result := Tribe[pTarget].TPhrase('FRBYE')
           else
           begin
             if (result = '') and (OppCommand = scDipOffer) and
+            if (Result = '') and (OppCommand = scDipOffer) and
               ((OppOffer.nDeliver > 0) or (OppOffer.nCost > 0)) then
             begin
               if (OppOffer.nDeliver = 1) and (OppOffer.Price[0] = opChoose) and
                 not Phrases2FallenBackToEnglish then
                 result := Tribe[pSender].TString
+                Result := Tribe[pSender].TString
                   (Phrases2.Lookup('FRNOTACCEPTANYOFFER')) + ' '
               else if (OppOffer.nCost = 1) and
                 (OppOffer.Price[OppOffer.nDeliver] = opChoose) and not Phrases2FallenBackToEnglish
               then
                 result := Tribe[pSender].TString
+                Result := Tribe[pSender].TString
                   (Phrases2.Lookup('FRNOTACCEPTANYWANT')) + ' '
               else
                 result := Tribe[pSender].TPhrase('FRNOTACCEPTOFFER') + ' ';
+                Result := Tribe[pSender].TPhrase('FRNOTACCEPTOFFER') + ' ';
             end;
             result := result + Phrases.Lookup('FRDONE');
             DoIntro := false
+            Result := Result + Phrases.Lookup('FRDONE');
+            DoIntro := False
           end
         end
         else if (Offer.nDeliver + Offer.nCost = 1) and
           (Offer.Price[0] and opMask = opTreaty) and
           (integer(Offer.Price[0] - opTreaty) > Treaty) then
+          (Integer(Offer.Price[0] - opTreaty) > Treaty) then
         // simple treaty offer
         begin
 …
             // trCeaseFire: result:=result+Tribe[pTarget].TPhrase('FRCEASEFIRE');
             trPeace:
               result := result + Tribe[pTarget].TPhrase('FRPEACE');
+              Result := Result + Tribe[pTarget].TPhrase('FRPEACE');
             trFriendlyContact:
               result := result + Tribe[pTarget].TPhrase('FRFRIENDLY');
+              Result := Result + Tribe[pTarget].TPhrase('FRFRIENDLY');
             trAlliance:
               result := result + Tribe[pTarget].TPhrase('FRALLIANCE');
+              Result := Result + Tribe[pTarget].TPhrase('FRALLIANCE');
           end
         end
 …
           if (Treaty >= trFriendlyContact) and not Phrases2FallenBackToEnglish
           then
             result := result +
+            Result := Result +
               Format(Tribe[pTarget].TString(Phrases2.Lookup('FRDEMAND_SOFT')
               ), [sCost])
           else
           begin
             result := result +
+            Result := Result +
               Format(Tribe[pTarget].TPhrase('FRDEMAND_STRONG'), [sCost]);
             DoIntro := false
+            DoIntro := False
           end
         end
         else if Offer.nCost = 0 then // present
           result := result + Format(Tribe[pTarget].TPhrase('FRPRESENT'),
+          Result := Result + Format(Tribe[pTarget].TPhrase('FRPRESENT'),
             [sDeliver])
         else if (Offer.nDeliver = 1) and (Offer.Price[0] = opChoose) then
           result := result + Format(Phrases.Lookup('FRDELCHOICE'), [sCost])
+          Result := Result + Format(Phrases.Lookup('FRDELCHOICE'), [sCost])
         else if (Offer.nCost = 1) and (Offer.Price[Offer.nDeliver] = opChoose)
         then
           result := result + Format(Phrases.Lookup('FRCOSTCHOICE'), [sDeliver])
+          Result := Result + Format(Phrases.Lookup('FRCOSTCHOICE'), [sDeliver])
         else
           result := result + Format(Phrases.Lookup('FROFFER'),
+          Result := Result + Format(Phrases.Lookup('FROFFER'),
             [sDeliver, sCost]);
       end;
 …
   if DoIntro then
     if Treaty < trPeace then
       result := Tribe[pSender].TPhrase('FRSTART_NOTREATY') + ' ' + result
+      Result := Tribe[pSender].TPhrase('FRSTART_NOTREATY') + ' ' + Result
     else
       result := Tribe[pSender].TPhrase('FRSTART_PEACE') + ' ' + result
+      Result := Tribe[pSender].TPhrase('FRSTART_PEACE') + ' ' + Result
 end;

branches/highdpi/LocalPlayer/Draft.pas

-              r361
+              r465
 uses
+  UDpiControls, Protocol, ClientTools, Term, ScreenTools, BaseWin,
+  LCLIntf, LCLType, SysUtils, Classes, Graphics, Controls, Forms, ExtCtrls,
+  ButtonA,
+  ButtonB, Area;
+  UDpiControls, Protocol, ClientTools, ScreenTools, BaseWin, LCLIntf, LCLType, SysUtils,
+  Classes, Graphics, Controls, Forms, ExtCtrls, ButtonA, ButtonB, Area;
 type
 …
     procedure CloseBtnClick(Sender: TObject);
     procedure PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; x, y: integer);
+      Shift: TShiftState; X, Y: Integer);
     procedure OKBtnClick(Sender: TObject);
     procedure PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; x, y: integer);
+      Shift: TShiftState; X, Y: Integer);
   public
     procedure ShowNewContent(NewMode: integer);
+    procedure ShowNewContent(NewMode: TWindowMode);
   protected
     procedure OffscreenPaint; override;
   private
     Domain, MaxLines, Lines, Cut, yDomain, yFeature, yWeight, yTotal, yView,
       IncCap, DecCap: integer;
     code: array [0 .. nFeature - 1] of integer;
+      IncCap, DecCap: Integer;
+    Code: array [0 .. nFeature - 1] of Integer;
     Template, Back: TDpiBitmap;
+    function IsFeatureInList(d, i: integer): boolean;
+    procedure SetDomain(d: integer);
+  end;
+var
+  DraftDlg: TDraftDlg;
+    function IsFeatureInList(D, I: Integer): Boolean;
+    procedure SetDomain(D: Integer);
+  end;
 implementation
+uses Help, Tribes, Directories;
+uses
+  Term, Help, Tribes, Directories;
 {$R *.lfm}
 …
 procedure TDraftDlg.OffscreenPaint;
   function DomainAvailable(d: integer): boolean;
   begin
     result := (upgrade[d, 0].Preq = preNone) or
       (MyRO.Tech[upgrade[d, 0].Preq] >= tsApplicable);
+  function DomainAvailable(D: Integer): Boolean;
+  begin
+    Result := (upgrade[D, 0].Preq = preNone) or
+      (MyRO.Tech[upgrade[D, 0].Preq] >= tsApplicable);
   end;
   procedure PaintTotalBars;
   var
     i, y, dx, num, w: integer;
     s: string;
   begin
     with offscreen.Canvas do
+    I, Y, dx, num, W: Integer;
+    S: string;
+  begin
+    with Offscreen.Canvas do
     begin
       // strength bar
       y := yTotal;
       DarkGradient(offscreen.Canvas, xTotal - 6, y + 1, 184, 2);
       DarkGradient(offscreen.Canvas, xTotal2 + 172, y + 1, 95, 2);
       RisedTextOut(offscreen.Canvas, xTotal - 2, y,
+      Y := yTotal;
+      DarkGradient(Offscreen.Canvas, xTotal - 6, Y + 1, 184, 2);
+      DarkGradient(Offscreen.Canvas, xTotal2 + 172, Y + 1, 95, 2);
+      RisedTextOut(Offscreen.Canvas, xTotal - 2, Y,
         Phrases.Lookup('UNITSTRENGTH'));
       RisedTextOut(offscreen.Canvas, xTotal + 112 + 30, y,
+      RisedTextOut(Offscreen.Canvas, xTotal + 112 + 30, Y,
         'x' + IntToStr(MyRO.DevModel.MStrength));
       RisedTextOut(offscreen.Canvas, xTotal2 + 148 + 30, y, '=');
       s := IntToStr(MyRO.DevModel.Attack) + '/' +
+      RisedTextOut(Offscreen.Canvas, xTotal2 + 148 + 30, Y, '=');
+      S := IntToStr(MyRO.DevModel.Attack) + '/' +
         IntToStr(MyRO.DevModel.Defense);
       RisedTextOut(offscreen.Canvas, xTotal2 + 170 + 64 + 30 -
         BiColorTextWidth(offscreen.Canvas, s), y, s);
+      RisedTextOut(Offscreen.Canvas, xTotal2 + 170 + 64 + 30 -
+        BiColorTextWidth(Offscreen.Canvas, S), Y, S);
       // transport bar
       if MyRO.DevModel.MTrans > 0 then
       begin
         y := yTotal + 19;
         DarkGradient(offscreen.Canvas, xTotal - 6, y + 1, 184, 1);
         DarkGradient(offscreen.Canvas, xTotal2 + 172, y + 1, 95, 1);
         RisedTextOut(offscreen.Canvas, xTotal - 2, y,
+        Y := yTotal + 19;
+        DarkGradient(Offscreen.Canvas, xTotal - 6, Y + 1, 184, 1);
+        DarkGradient(Offscreen.Canvas, xTotal2 + 172, Y + 1, 95, 1);
+        RisedTextOut(Offscreen.Canvas, xTotal - 2, Y,
           Phrases.Lookup('UNITTRANSPORT'));
         RisedTextOut(offscreen.Canvas, xTotal + 112 + 30, y,
+        RisedTextOut(Offscreen.Canvas, xTotal + 112 + 30, Y,
           'x' + IntToStr(MyRO.DevModel.MTrans));
         RisedTextOut(offscreen.Canvas, xTotal2 + 148 + 30, y, '=');
+        RisedTextOut(Offscreen.Canvas, xTotal2 + 148 + 30, Y, '=');
         Font.Color := $000000;
         dx := -237 - 30;
         for i := mcFirstNonCap - 1 downto 3 do
           if i in [mcSeaTrans, mcCarrier, mcAirTrans] then
+        for I := mcFirstNonCap - 1 downto 3 do
+          if I in [mcSeaTrans, mcCarrier, mcAirTrans] then
           begin
             num := MyRO.DevModel.Cap[i] * MyRO.DevModel.MTrans;
+            num := MyRO.DevModel.Cap[I] * MyRO.DevModel.MTrans;
             if num > 0 then
             begin
               inc(dx, 15);
+              Inc(dx, 15);
               Brush.Color := $C0C0C0;
               FrameRect(Rect(xTotal2 - 3 - dx, y + 2,
                 xTotal2 + 11 - dx, y + 16));
+              FrameRect(Rect(xTotal2 - 3 - dx, Y + 2,
+                xTotal2 + 11 - dx, Y + 16));
               Brush.Style := bsClear;
               Sprite(offscreen, HGrSystem, xTotal2 - 1 - dx, y + 4, 10, 10,
 + i mod 11 * 11, 137 + i div 11 * 11);
+              Sprite(Offscreen, HGrSystem, xTotal2 - 1 - dx, Y + 4, 10, 10,
++ I mod 11 * 11, 137 + I div 11 * 11);
               if num > 1 then
               begin
                 s := IntToStr(num);
                 w := TextWidth(s);
                 inc(dx, w + 1);
+                S := IntToStr(num);
+                W := TextWidth(S);
+                Inc(dx, W + 1);
                 Brush.Color := $FFFFFF;
                 FillRect(Rect(xTotal2 - 3 - dx, y + 2,
                   xTotal2 + w - 1 - dx, y + 16));
+                FillRect(Rect(xTotal2 - 3 - dx, Y + 2,
+                  xTotal2 + W - 1 - dx, Y + 16));
                 Brush.Style := bsClear;
                 Textout(xTotal2 - 3 - dx + 1, y, s);
+                Textout(xTotal2 - 3 - dx + 1, Y, S);
               end;
             end;
           end
+          end;
       end;
       // speed bar
       y := yTotal + 38;
       LoweredTextOut(offscreen.Canvas, -1, MainTexture, xTotal - 2, y,
+      Y := yTotal + 38;
+      LoweredTextOut(Offscreen.Canvas, -1, MainTexture, xTotal - 2, Y,
         Phrases.Lookup('UNITSPEED'));
       DLine(offscreen.Canvas, xTotal - 2, xTotal + 174, y + 16,
+      DLine(Offscreen.Canvas, xTotal - 2, xTotal + 174, Y + 16,
         MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
       DLine(offscreen.Canvas, xTotal2 + 176, xTotal2 + 263, y + 16,
+      DLine(Offscreen.Canvas, xTotal2 + 176, xTotal2 + 263, Y + 16,
         MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
       s := MovementToString(MyRO.DevModel.Speed);
       RisedTextOut(offscreen.Canvas, xTotal2 + 170 + 64 + 30 -
         TextWidth(s), y, s);
+      S := MovementToString(MyRO.DevModel.Speed);
+      RisedTextOut(Offscreen.Canvas, xTotal2 + 170 + 64 + 30 -
+        TextWidth(S), Y, S);
       // cost bar
       y := yTotal + 57;
       LoweredTextOut(offscreen.Canvas, -1, MainTexture, xTotal - 2, y,
+      Y := yTotal + 57;
+      LoweredTextOut(Offscreen.Canvas, -1, MainTexture, xTotal - 2, Y,
         Phrases.Lookup('UNITCOST'));
       LoweredTextOut(offscreen.Canvas, -1, MainTexture, xTotal + 112 + 30, y,
+      LoweredTextOut(Offscreen.Canvas, -1, MainTexture, xTotal + 112 + 30, Y,
         'x' + IntToStr(MyRO.DevModel.MCost));
       LoweredTextOut(offscreen.Canvas, -1, MainTexture,
         xTotal2 + 148 + 30, y, '=');
       DLine(offscreen.Canvas, xTotal - 2, xTotal + 174, y + 16,
+      LoweredTextOut(Offscreen.Canvas, -1, MainTexture,
+        xTotal2 + 148 + 30, Y, '=');
+      DLine(Offscreen.Canvas, xTotal - 2, xTotal + 174, Y + 16,
         MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
       DLine(offscreen.Canvas, xTotal2 + 176, xTotal2 + 263, y + 16,
+      DLine(Offscreen.Canvas, xTotal2 + 176, xTotal2 + 263, Y + 16,
         MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
       s := IntToStr(MyRO.DevModel.Cost);
       RisedTextOut(offscreen.Canvas, xTotal2 + 170 + 64 + 30 - 12 -
         TextWidth(s), y, s);
       Sprite(offscreen, HGrSystem, xTotal2 + 170 + 54 + 30, y + 4, 10,
+      S := IntToStr(MyRO.DevModel.Cost);
+      RisedTextOut(Offscreen.Canvas, xTotal2 + 170 + 64 + 30 - 12 -
+        TextWidth(S), Y, S);
+      Sprite(Offscreen, HGrSystem, xTotal2 + 170 + 54 + 30, Y + 4, 10,
 , 88, 115);
       if G.Difficulty[me] <> 2 then
+      if G.Difficulty[Me] <> 2 then
       begin // corrected cost bar
         y := yTotal + 76;
         LoweredTextOut(offscreen.Canvas, -1, MainTexture, xTotal - 2, y,
           Phrases.Lookup('COSTDIFF' + char(48 + G.Difficulty[me])));
         LoweredTextOut(offscreen.Canvas, -1, MainTexture,
           xTotal2 + 148 + 30, y, '=');
         DLine(offscreen.Canvas, xTotal - 2, xTotal + 174, y + 16,
+        Y := yTotal + 76;
+        LoweredTextOut(Offscreen.Canvas, -1, MainTexture, xTotal - 2, Y,
+          Phrases.Lookup('COSTDIFF' + char(48 + G.Difficulty[Me])));
+        LoweredTextOut(Offscreen.Canvas, -1, MainTexture,
+          xTotal2 + 148 + 30, Y, '=');
+        DLine(Offscreen.Canvas, xTotal - 2, xTotal + 174, Y + 16,
           MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
         DLine(offscreen.Canvas, xTotal2 + 176, xTotal2 + 263, y + 16,
+        DLine(Offscreen.Canvas, xTotal2 + 176, xTotal2 + 263, Y + 16,
           MainTexture.ColorBevelShade, MainTexture.ColorBevelLight);
         s := IntToStr(MyRO.DevModel.Cost * BuildCostMod
           [G.Difficulty[me]] div 12);
         RisedTextOut(offscreen.Canvas, xTotal2 + 170 + 64 + 30 - 12 -
           TextWidth(s), y, s);
         Sprite(offscreen, HGrSystem, xTotal2 + 170 + 54 + 30, y + 4, 10,
+        S := IntToStr(MyRO.DevModel.Cost * BuildCostMod
+          [G.Difficulty[Me]] div 12);
+        RisedTextOut(Offscreen.Canvas, xTotal2 + 170 + 64 + 30 - 12 -
+          TextWidth(S), Y, S);
+        Sprite(Offscreen, HGrSystem, xTotal2 + 170 + 54 + 30, Y + 4, 10,
 , 88, 115);
       end;
 …
 var
   i, j, x, d, n, TextColor, CapWeight, DomainCount: integer;
+  I, J, X, D, N, TextColor, CapWeight, DomainCount: Integer;
 begin
   inherited;
 …
   // assemble background from 2 texture tiles
   begin
     DpiBitCanvas(Back.Canvas, 0, 0, ClientWidth, 64,
+    DpiBitBltCanvas(Back.Canvas, 0, 0, ClientWidth, 64,
       MainTexture.Image.Canvas, (MainTexture.Width - ClientWidth) div 2,
       MainTexture.Height - 64);
     DpiBitCanvas(Back.Canvas, 0, 64, ClientWidth, ClientHeight - 64,
+    DpiBitBltCanvas(Back.Canvas, 0, 64, ClientWidth, ClientHeight - 64,
       MainTexture.Image.Canvas, (MainTexture.Width - ClientWidth) div 2,
 );
   end
   else
     DpiBitCanvas(Back.Canvas, 0, 0, ClientWidth, ClientHeight,
+    DpiBitBltCanvas(Back.Canvas, 0, 0, ClientWidth, ClientHeight,
       MainTexture.Image.Canvas, (MainTexture.Width - ClientWidth) div 2,
       (MainTexture.Height - ClientHeight) div 2);
 …
     Template.Height - 64 - Cut);
   DpiBitCanvas(offscreen.Canvas, 0, 0, ClientWidth, ClientHeight,
+  DpiBitBltCanvas(Offscreen.Canvas, 0, 0, ClientWidth, ClientHeight,
     Back.Canvas, 0, 0);
   offscreen.Canvas.Font.Assign(UniFont[ftCaption]);
   RisedTextOut(offscreen.Canvas, 10, 7, Caption);
   offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
+  Offscreen.Canvas.Font.Assign(UniFont[ftCaption]);
+  RisedTextOut(Offscreen.Canvas, 10, 7, Caption);
+  Offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
   with MyRO.DevModel do
   begin
     DomainCount := 0;
     for d := 0 to nDomains - 1 do
       if DomainAvailable(d) then
         inc(DomainCount);
+    for D := 0 to nDomains - 1 do
+      if DomainAvailable(D) then
+        Inc(DomainCount);
     if DomainCount > 1 then
     begin
       for d := 0 to nDomains - 1 do
         if DomainAvailable(d) then
+      for D := 0 to nDomains - 1 do
+        if DomainAvailable(D) then
         begin
           x := xDomain + d * DomainPitch;
           if d = Domain then
             ImageOp_BCC(offscreen, Templates.Data, x, yDomain, 142, 246 + 37 * d, 36,
+          X := xDomain + D * DomainPitch;
+          if D = Domain then
+            ImageOp_BCC(Offscreen, Templates.Data, X, yDomain, 142, 246 + 37 * D, 36,
 , 0, $00C0FF)
           else
             ImageOp_BCC(offscreen, Templates.Data, x, yDomain, 142, 246 + 37 * d, 36,
+            ImageOp_BCC(Offscreen, Templates.Data, X, yDomain, 142, 246 + 37 * D, 36,
 , 0, $606060);
         end;
       Frame(offscreen.Canvas, xDomain - 11, yDomain - 3,
+      Frame(Offscreen.Canvas, xDomain - 11, yDomain - 3,
         xDomain + 2 * DomainPitch + 46, yDomain + 38, $B0B0B0, $FFFFFF);
       RFrame(offscreen.Canvas, xDomain - 12, yDomain - 4,
+      RFrame(Offscreen.Canvas, xDomain - 12, yDomain - 4,
         xDomain + 2 * DomainPitch + 47, yDomain + 39, $FFFFFF, $B0B0B0);
     end;
 …
     // display weight
     with offscreen.Canvas do
     begin
       for i := 0 to MaxWeight - 1 do
         if i < Weight then
           ImageOp_BCC(offscreen, Templates.Data, Point(xWeight + 20 * i, yWeight),
+    with Offscreen.Canvas do
+    begin
+      for I := 0 to MaxWeight - 1 do
+        if I < Weight then
+          ImageOp_BCC(Offscreen, Templates.Data, Point(xWeight + 20 * I, yWeight),
             WeightOn.BoundsRect, 0, $949494)
         else
           ImageOp_BCC(offscreen, Templates.Data, Point(xWeight + 20 * i, yWeight),
+          ImageOp_BCC(Offscreen, Templates.Data, Point(xWeight + 20 * I, yWeight),
             WeightOff.BoundsRect, 0, $949494);
     end;
     with offscreen.Canvas do
       for i := 0 to Lines - 1 do
+    with Offscreen.Canvas do
+      for I := 0 to Lines - 1 do
       begin
         if not(code[i] in AutoFeature) then
+        if not(Code[I] in AutoFeature) then
         begin
           // paint +/- butttons
           if code[i] < mcFirstNonCap then
+          if Code[I] < mcFirstNonCap then
           begin
             Dump(offscreen, HGrSystem, xFeature - 21, yFeature + 2 + LinePitch *
               i, 12, 12, 169, 172);
             Dump(offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
               i, 12, 12, 169, 159);
             RFrame(offscreen.Canvas, xFeature - (21 + 1),
               yFeature + 2 + LinePitch * i - 1, xFeature - (21 - 24),
               yFeature + 2 + LinePitch * i + 12, MainTexture.ColorBevelShade,
+            Dump(Offscreen, HGrSystem, xFeature - 21, yFeature + 2 + LinePitch *
+              I, 12, 12, 169, 172);
+            Dump(Offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
+              I, 12, 12, 169, 159);
+            RFrame(Offscreen.Canvas, xFeature - (21 + 1),
+              yFeature + 2 + LinePitch * I - 1, xFeature - (21 - 24),
+              yFeature + 2 + LinePitch * I + 12, MainTexture.ColorBevelShade,
               MainTexture.ColorBevelLight);
           end
           else
           begin
             Dump(offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
               i, 12, 12, 169, 185 + 13 * MyRO.DevModel.Cap[code[i]]);
             RFrame(offscreen.Canvas, xFeature - (9 + 1),
               yFeature + 2 + LinePitch * i - 1, xFeature - (21 - 24),
               yFeature + 2 + LinePitch * i + 12, MainTexture.ColorBevelShade,
+            Dump(Offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
+              I, 12, 12, 169, 185 + 13 * MyRO.DevModel.Cap[Code[I]]);
+            RFrame(Offscreen.Canvas, xFeature - (9 + 1),
+              yFeature + 2 + LinePitch * I - 1, xFeature - (21 - 24),
+              yFeature + 2 + LinePitch * I + 12, MainTexture.ColorBevelShade,
               MainTexture.ColorBevelLight);
           end;
           // paint cost
           LightGradient(offscreen.Canvas, xFeature + 34,
             yFeature + LinePitch * i, 50, HGrSystem.Data.Canvas.Pixels
+          LightGradient(Offscreen.Canvas, xFeature + 34,
+            yFeature + LinePitch * I, 50, HGrSystem.Data.Canvas.Pixels
             [187, 137]);
           if (Domain = dGround) and (code[i] = mcDefense) then
+          if (Domain = dGround) and (Code[I] = mcDefense) then
             CapWeight := 2
           else
             CapWeight := Feature[code[i]].Weight;
           n := CapWeight + Feature[code[i]].Cost;
           d := 6;
           while (n - 1) * d * 2 > 48 - 10 do
             dec(d);
           for j := 0 to n - 1 do
             if j < CapWeight then
               Sprite(offscreen, HGrSystem, xFeature + 54 + (j * 2 + 1 - n) * d,
                 yFeature + 2 + LinePitch * i + 1, 10, 10, 88, 126)
+            CapWeight := Feature[Code[I]].Weight;
+          N := CapWeight + Feature[Code[I]].Cost;
+          D := 6;
+          while (N - 1) * D * 2 > 48 - 10 do
+            Dec(D);
+          for J := 0 to N - 1 do
+            if J < CapWeight then
+              Sprite(Offscreen, HGrSystem, xFeature + 54 + (J * 2 + 1 - N) * D,
+                yFeature + 2 + LinePitch * I + 1, 10, 10, 88, 126)
             else
               Sprite(offscreen, HGrSystem, xFeature + 54 + (j * 2 + 1 - n) * d,
                 yFeature + 2 + LinePitch * i + 1, 10, 10, 88, 115);
+              Sprite(Offscreen, HGrSystem, xFeature + 54 + (J * 2 + 1 - N) * D,
+                yFeature + 2 + LinePitch * I + 1, 10, 10, 88, 115);
         end; // if not (code[i] in AutoFeature)
         DarkGradient(offscreen.Canvas, xFeature + 17,
           yFeature + LinePitch * i, 16, 1);
         ScreenTools.Frame(offscreen.Canvas, xFeature + 18, yFeature + 1 + LinePitch * i,
           xFeature + 20 - 2 + 13, yFeature + 2 + 1 - 2 + 13 + LinePitch * i,
+        DarkGradient(Offscreen.Canvas, xFeature + 17,
+          yFeature + LinePitch * I, 16, 1);
+        ScreenTools.Frame(Offscreen.Canvas, xFeature + 18, yFeature + 1 + LinePitch * I,
+          xFeature + 20 - 2 + 13, yFeature + 2 + 1 - 2 + 13 + LinePitch * I,
           $C0C0C0, $C0C0C0);
         Sprite(offscreen, HGrSystem, xFeature + 20, yFeature + 2 + 1 + LinePitch
           * i, 10, 10, 66 + code[i] mod 11 * 11, 137 + code[i] div 11 * 11);
         if MyRO.DevModel.Cap[code[i]] > 0 then
+        Sprite(Offscreen, HGrSystem, xFeature + 20, yFeature + 2 + 1 + LinePitch
+          * I, 10, 10, 66 + Code[I] mod 11 * 11, 137 + Code[I] div 11 * 11);
+        if MyRO.DevModel.Cap[Code[I]] > 0 then
           TextColor := MainTexture.ColorLitText
         else
           TextColor := -1;
         if code[i] < mcFirstNonCap then
           LoweredTextOut(offscreen.Canvas, TextColor, MainTexture, xFeature + 7,
             yFeature + LinePitch * i - 1, IntToStr(MyRO.DevModel.Cap[code[i]]));
         LoweredTextOut(offscreen.Canvas, TextColor, MainTexture, xFeature + 88,
           yFeature + LinePitch * i - 1, Phrases.Lookup('FEATURES', code[i]));
+        if Code[I] < mcFirstNonCap then
+          LoweredTextOut(Offscreen.Canvas, TextColor, MainTexture, xFeature + 7,
+            yFeature + LinePitch * I - 1, IntToStr(MyRO.DevModel.Cap[Code[I]]));
+        LoweredTextOut(Offscreen.Canvas, TextColor, MainTexture, xFeature + 88,
+          yFeature + LinePitch * I - 1, Phrases.Lookup('FEATURES', Code[I]));
       end;
   end;
   // free features
   j := 0;
   for i := 0 to nFeature - 1 do
     if (i in AutoFeature) and (1 shl Domain and Feature[i].Domains <> 0) and
       (Feature[i].Preq <> preNA) and
       ((Feature[i].Preq = preSun) and (MyRO.Wonder[woSun].EffectiveOwner = me)
       or (Feature[i].Preq >= 0) and (MyRO.Tech[Feature[i].Preq] >= tsApplicable)
       ) and not((Feature[i].Preq = adSteamEngine) and
+  J := 0;
+  for I := 0 to nFeature - 1 do
+    if (I in AutoFeature) and (1 shl Domain and Feature[I].Domains <> 0) and
+      (Feature[I].Preq <> preNA) and
+      ((Feature[I].Preq = preSun) and (MyRO.Wonder[woSun].EffectiveOwner = Me)
+      or (Feature[I].Preq >= 0) and (MyRO.Tech[Feature[I].Preq] >= tsApplicable)
+      ) and not((Feature[I].Preq = adSteamEngine) and
       (MyRO.Tech[adNuclearPower] >= tsApplicable)) then
     begin
       DarkGradient(offscreen.Canvas, xWeight + 4, yWeight + 32 + LinePitch
         * j, 16, 1);
       Frame(offscreen.Canvas, xWeight + 5, yWeight + 33 + LinePitch * j,
         xWeight + 18, yWeight + 47 + LinePitch * j, $C0C0C0, $C0C0C0);
       Sprite(offscreen, HGrSystem, xWeight + 7, yWeight + 36 + LinePitch * j,
 , 10, 66 + i mod 11 * 11, 137 + i div 11 * 11);
       LoweredTextOut(offscreen.Canvas, -1, MainTexture, xWeight + 26,
         yWeight + 31 + LinePitch * j, Phrases.Lookup('FEATURES', i));
       inc(j);
     end;
   with Tribe[me].ModelPicture[MyRO.nModel] do
   begin
     FrameImage(offscreen.Canvas, BigImp, xView + 4, yView + 4, xSizeBig,
+      DarkGradient(Offscreen.Canvas, xWeight + 4, yWeight + 32 + LinePitch
+        * J, 16, 1);
+      Frame(Offscreen.Canvas, xWeight + 5, yWeight + 33 + LinePitch * J,
+        xWeight + 18, yWeight + 47 + LinePitch * J, $C0C0C0, $C0C0C0);
+      Sprite(Offscreen, HGrSystem, xWeight + 7, yWeight + 36 + LinePitch * J,
+, 10, 66 + I mod 11 * 11, 137 + I div 11 * 11);
+      LoweredTextOut(Offscreen.Canvas, -1, MainTexture, xWeight + 26,
+        yWeight + 31 + LinePitch * J, Phrases.Lookup('FEATURES', I));
+      Inc(J);
+    end;
+  with Tribe[Me].ModelPicture[MyRO.nModel] do
+  begin
+    FrameImage(Offscreen.Canvas, BigImp, xView + 4, yView + 4, xSizeBig,
       ySizeBig, 0, 0);
     Sprite(offscreen, HGr, xView, yView, 64, 44, pix mod 10 * 65 + 1,
+    Sprite(Offscreen, HGr, xView, yView, 64, 44, pix mod 10 * 65 + 1,
       pix div 10 * 49 + 1);
   end;
   MarkUsedOffscreen(ClientWidth, ClientHeight);
 end; { MainPaint }
 procedure TDraftDlg.SetDomain(d: integer);
   function Prio(fix: integer): integer;
+end;
+procedure TDraftDlg.SetDomain(D: Integer);
+  function Prio(fix: Integer): Integer;
   var
     FeaturePreq: integer;
+    FeaturePreq: Integer;
   begin
     FeaturePreq := Feature[fix].Preq;
     assert(FeaturePreq <> preNA);
+    Assert(FeaturePreq <> preNA);
     if fix < mcFirstNonCap then
       result := 10000 + fix
+      Result := 10000 + fix
     else if FeaturePreq = preNone then
       result := 20000
+      Result := 20000
     else if FeaturePreq < 0 then
       result := 40000
+      Result := 40000
     else
       result := 30000 + AdvValue[FeaturePreq];
+      Result := 30000 + AdvValue[FeaturePreq];
     if not(fix in AutoFeature) then
       inc(result, 90000);
+      Inc(Result, 90000);
   end;
 var
   i, j, x: integer;
 begin
   Domain := d;
+  I, J, X: Integer;
+begin
+  Domain := D;
   Lines := 0;
   for i := 0 to nFeature - 1 do
     if IsFeatureInList(Domain, i) then
     begin
       code[Lines] := i;
       inc(Lines)
+  for I := 0 to nFeature - 1 do
+    if IsFeatureInList(Domain, I) then
+    begin
+      Code[Lines] := I;
+      Inc(Lines);
     end;
   yFeature := yFeature0 + (MaxLines - Lines) * LinePitch div 2;
   // sort features
   for i := 0 to Lines - 2 do
     for j := i + 1 to Lines - 1 do
       if Prio(code[i]) > Prio(code[j]) then
+  for I := 0 to Lines - 2 do
+    for J := I + 1 to Lines - 1 do
+      if Prio(Code[I]) > Prio(Code[J]) then
       begin // exchange
         x := code[i];
         code[i] := code[j];
         code[j] := x
+        X := Code[I];
+        Code[I] := Code[J];
+        Code[J] := X;
       end;
 end;
 function TDraftDlg.IsFeatureInList(d, i: integer): boolean;
 begin
   result := not(i in AutoFeature) and (1 shl d and Feature[i].Domains <> 0) and
     (Feature[i].Preq <> preNA) and
     ((Feature[i].Preq = preNone) or (Feature[i].Preq = preSun) and
     (MyRO.Wonder[woSun].EffectiveOwner = me) or (Feature[i].Preq >= 0) and
     (MyRO.Tech[Feature[i].Preq] >= tsApplicable));
+function TDraftDlg.IsFeatureInList(D, I: Integer): Boolean;
+begin
+  Result := not(I in AutoFeature) and (1 shl D and Feature[I].Domains <> 0) and
+    (Feature[I].Preq <> preNA) and
+    ((Feature[I].Preq = preNone) or (Feature[I].Preq = preSun) and
+    (MyRO.Wonder[woSun].EffectiveOwner = Me) or (Feature[I].Preq >= 0) and
+    (MyRO.Tech[Feature[I].Preq] >= tsApplicable));
 end;
 procedure TDraftDlg.FormShow(Sender: TObject);
 var
   count, d, i: integer;
+  count, D, I: Integer;
 begin
   Domain := dGround;
   while (Domain < dAir) and (upgrade[Domain, 0].Preq <> preNone) and
     (MyRO.Tech[upgrade[Domain, 0].Preq] < tsApplicable) do
     inc(Domain);
+    Inc(Domain);
   // count max number of features in any domain
   MaxLines := 0;
   for d := 0 to nDomains - 1 do
     if (upgrade[d, 0].Preq = preNone) or
       (MyRO.Tech[upgrade[d, 0].Preq] >= tsApplicable) then
+  for D := 0 to nDomains - 1 do
+    if (upgrade[D, 0].Preq = preNone) or
+      (MyRO.Tech[upgrade[D, 0].Preq] >= tsApplicable) then
     begin
       count := 0;
       for i := 0 to nFeature - 1 do
         if IsFeatureInList(d, i) then
           inc(count);
+      for I := 0 to nFeature - 1 do
+        if IsFeatureInList(D, I) then
+          Inc(count);
       if count > MaxLines then
         MaxLines := count;
 …
   SetDomain(Domain);
   Server(sCreateDevModel, me, Domain, nil^);
+  Server(sCreateDevModel, Me, Domain, nil^);
   MyModel[MyRO.nModel] := MyRO.DevModel;
   InitMyModel(MyRO.nModel, false);
+  InitMyModel(MyRO.nModel, False);
   OffscreenPaint;
   IncCap := -1;
 …
 end;
 procedure TDraftDlg.ShowNewContent(NewMode: integer);
+procedure TDraftDlg.ShowNewContent(NewMode: TWindowMode);
 begin
   inherited ShowNewContent(NewMode);
 …
 procedure TDraftDlg.PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; x, y: integer);
+  Shift: TShiftState; X, Y: Integer);
 var
   i, d: integer;
+  I, D: Integer;
 begin
   if Button = mbLeft then
   begin
     for d := 0 to nDomains - 1 do
       if (d <> Domain) and ((upgrade[d, 0].Preq = preNone) or
         (MyRO.Tech[upgrade[d, 0].Preq] >= tsApplicable)) and
         (x >= xDomain + d * DomainPitch) and
         (x < xDomain + d * DomainPitch + 36) and (y >= yDomain) and
         (y < yDomain + 36) then
+    for D := 0 to nDomains - 1 do
+      if (D <> Domain) and ((upgrade[D, 0].Preq = preNone) or
+        (MyRO.Tech[upgrade[D, 0].Preq] >= tsApplicable)) and
+        (X >= xDomain + D * DomainPitch) and
+        (X < xDomain + D * DomainPitch + 36) and (Y >= yDomain) and
+        (Y < yDomain + 36) then
       begin
         SetDomain(d);
         Server(sCreateDevModel, me, Domain, nil^);
+        SetDomain(D);
+        Server(sCreateDevModel, Me, Domain, nil^);
         MyModel[MyRO.nModel] := MyRO.DevModel;
         InitMyModel(MyRO.nModel, false);
+        InitMyModel(MyRO.nModel, False);
         SmartUpdateContent;
       end;
     if (y >= yFeature) and (y < yFeature + LinePitch * Lines) then
     begin
       i := (y - yFeature) div LinePitch;
       if (x >= xFeature - 21) and (x < ClientWidth) and (ssShift in Shift) then
         HelpDlg.ShowNewContent(FWindowMode or wmPersistent, hkFeature, code[i])
       else if not(code[i] in AutoFeature) then
+    if (Y >= yFeature) and (Y < yFeature + LinePitch * Lines) then
+    begin
+      I := (Y - yFeature) div LinePitch;
+      if (X >= xFeature - 21) and (X < ClientWidth) and (ssShift in Shift) then
+        MainScreen.HelpDlg.ShowNewContent(WindowModeMakePersistent(FWindowMode), hkFeature, Code[I])
+      else if not(Code[I] in AutoFeature) then
       begin
         if (code[i] < mcFirstNonCap) and (x >= xFeature - 21) and
           (x < xFeature - 21 + 12) then
+        if (Code[I] < mcFirstNonCap) and (X >= xFeature - 21) and
+          (X < xFeature - 21 + 12) then
         begin
           IncCap := code[i];
           Dump(offscreen, HGrSystem, xFeature - 21, yFeature + 2 + LinePitch *
             i, 12, 12, 182, 172);
+          IncCap := Code[I];
+          Dump(Offscreen, HGrSystem, xFeature - 21, yFeature + 2 + LinePitch *
+            I, 12, 12, 182, 172);
           SmartInvalidate;
         end
         else if (x >= xFeature - 9) and (x < xFeature - 9 + 12) then
+        else if (X >= xFeature - 9) and (X < xFeature - 9 + 12) then
         begin
           DecCap := code[i];
           if code[i] < mcFirstNonCap then
             Dump(offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
               i, 12, 12, 182, 159)
+          DecCap := Code[I];
+          if Code[I] < mcFirstNonCap then
+            Dump(Offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
+              I, 12, 12, 182, 159)
           else
             Dump(offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
               i, 12, 12, 182, 185 + 13 * MyRO.DevModel.Cap[code[i]]);
+            Dump(Offscreen, HGrSystem, xFeature - 9, yFeature + 2 + LinePitch *
+              I, 12, 12, 182, 185 + 13 * MyRO.DevModel.Cap[Code[I]]);
           SmartInvalidate;
         end;
       end
     end
   end
+      end;
+    end;
+  end;
 end;
 procedure TDraftDlg.PaintBox1MouseUp(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; x, y: integer);
+  Shift: TShiftState; X, Y: Integer);
 var
   NewValue: integer;
+  NewValue: Integer;
 begin
   if IncCap >= 0 then
   begin
     NewValue := MyRO.DevModel.Cap[IncCap] + 1;
     Server(sSetDevModelCap + NewValue shl 4, me, IncCap, nil^);
+    Server(sSetDevModelCap + NewValue shl 4, Me, IncCap, nil^);
     MyModel[MyRO.nModel] := MyRO.DevModel;
     InitMyModel(MyRO.nModel, false);
+    InitMyModel(MyRO.nModel, False);
     SmartUpdateContent;
     IncCap := -1;
 …
       if DecCap >= mcFirstNonCap then
         NewValue := -NewValue;
       Server(sSetDevModelCap + NewValue shl 4, me, DecCap, nil^);
+      Server(sSetDevModelCap + NewValue shl 4, Me, DecCap, nil^);
       MyModel[MyRO.nModel] := MyRO.DevModel;
       InitMyModel(MyRO.nModel, false);
+      InitMyModel(MyRO.nModel, False);
     end;
     SmartUpdateContent;

branches/highdpi/LocalPlayer/Enhance.pas

-              r361
+              r465
 uses
+  UDpiControls, ScreenTools, BaseWin, Protocol, ClientTools, Term, LCLIntf, LCLType,
+  SysUtils, Classes, Graphics, Controls, Forms, IsoEngine,
+  ButtonB, ButtonC, Menus;
+  UDpiControls, ScreenTools, BaseWin, Protocol, ClientTools, LCLIntf, LCLType, SysUtils,
+  Classes, Graphics, Controls, Forms, IsoEngine, ButtonB, ButtonC, Menus;
 type
 …
     NoMap: TIsoMap;
   public
     procedure ShowNewContent(NewMode: integer; TerrType: integer = -1);
+    procedure ShowNewContent(NewMode: TWindowMode; TerrType: Integer = -1);
   protected
     Page: integer;
+    Page: Integer;
     procedure OffscreenPaint; override;
   end;
-var
-  EnhanceDlg: TEnhanceDlg;
 implementation
 uses
   Help, UKeyBindings;
+  Help, KeyBindings, Term;
 {$R *.lfm}
 …
 procedure TEnhanceDlg.FormCreate(Sender: TObject);
 var
   TerrType: integer;
   m: TDpiMenuItem;
+  TerrType: Integer;
+  M: TDpiMenuItem;
 begin
   inherited;
 …
     if TerrType <> fJungle then
     begin
       m := TDpiMenuItem.Create(Popup);
       m.RadioItem := true;
+      M := TDpiMenuItem.Create(Popup);
+      M.RadioItem := True;
       if TerrType = fGrass then
         m.Caption := Format(Phrases.Lookup('TWOTERRAINS'),
+        M.Caption := Format(Phrases.Lookup('TWOTERRAINS'),
           [Phrases.Lookup('TERRAIN', fGrass), Phrases.Lookup('TERRAIN',
           fGrass + 12)])
       else if TerrType = fForest then
         m.Caption := Format(Phrases.Lookup('TWOTERRAINS'),
+        M.Caption := Format(Phrases.Lookup('TWOTERRAINS'),
           [Phrases.Lookup('TERRAIN', fForest), Phrases.Lookup('TERRAIN',
           fJungle)])
       else
         m.Caption := Phrases.Lookup('TERRAIN', TerrType);
       m.Tag := TerrType;
       m.OnClick := TerrClick;
       Popup.Items.Add(m);
+        M.Caption := Phrases.Lookup('TERRAIN', TerrType);
+      M.Tag := TerrType;
+      M.OnClick := TerrClick;
+      Popup.Items.Add(M);
     end;
 end;
 …
 procedure TEnhanceDlg.FormPaint(Sender: TObject);
 var
   i: integer;
+  I: Integer;
 begin
   inherited;
 …
   BtnFrame(Canvas, Rect(job3.Left, job3.Top, job9.Left + job9.Width,
     job3.Top + job3.Height), MainTexture);
   for i := 0 to ControlCount - 1 do
     if Controls[i] is TButtonC then
       DpiBitCanvas(Canvas, Controls[i].Left + 2, Controls[i].Top - 11, 8, 8,
         HGrSystem.Data.Canvas, 121 + Controls[i].Tag mod 7 * 9,
 + Controls[i].Tag div 7 * 9);
+  for I := 0 to ControlCount - 1 do
+    if Controls[I] is TButtonC then
+      DpiBitBltCanvas(Canvas, Controls[I].Left + 2, Controls[I].Top - 11, 8, 8,
+        HGrSystem.Data.Canvas, 121 + Controls[I].Tag mod 7 * 9,
++ Controls[I].Tag div 7 * 9);
 end;
 …
 end;
 procedure TEnhanceDlg.ShowNewContent(NewMode, TerrType: integer);
+procedure TEnhanceDlg.ShowNewContent(NewMode: TWindowMode; TerrType: Integer);
 begin
   if (TerrType < fGrass) or (TerrType > fMountains) then
 …
 procedure TEnhanceDlg.OffscreenPaint;
 var
   i, stage, TerrType, TileImp, x, EndStage, Cost, LastJob: integer;
   s: string;
   Done: Set of jNone .. jTrans;
   TypeChanged: boolean;
+  I, stage, TerrType, TileImp, X, EndStage, Cost, LastJob: Integer;
+  S: string;
+  Done: set of jNone .. jTrans;
+  TypeChanged: Boolean;
 begin
   OffscreenUser := self;
   offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
+  Offscreen.Canvas.Font.Assign(UniFont[ftSmall]);
   FillOffscreen(0, 0, InnerWidth, InnerHeight);
   EndStage := 0;
   while (EndStage < 5) and (MyData.EnhancementJobs[Page, EndStage] <> jNone) do
     inc(EndStage);
+    Inc(EndStage);
   with NoMap do
     x := InnerWidth div 2 - xxt - (xxt + 3) * EndStage;
+    X := InnerWidth div 2 - xxt - (xxt + 3) * EndStage;
   TerrType := Page;
 …
     if stage > 0 then
     begin
       Sprite(offscreen, HGrSystem, x - 10, 66, 14, 14, 80, 1);
+      Sprite(Offscreen, HGrSystem, X - 10, 66, 14, 14, 80, 1);
       case MyData.EnhancementJobs[Page, stage - 1] of
         jRoad:
           begin
             inc(Cost, Terrain[TerrType].MoveCost * RoadWork);
+            Inc(Cost, Terrain[TerrType].MoveCost * RoadWork);
             TileImp := TileImp or fRoad;
           end;
         jRR:
           begin
             inc(Cost, Terrain[TerrType].MoveCost * RRWork);
+            Inc(Cost, Terrain[TerrType].MoveCost * RRWork);
             TileImp := TileImp or fRR;
           end;
         jIrr:
           begin
             inc(Cost, Terrain[TerrType].IrrClearWork);
+            Inc(Cost, Terrain[TerrType].IrrClearWork);
             TileImp := TileImp and not fTerImp or tiIrrigation;
           end;
         jFarm:
           begin
             inc(Cost, Terrain[TerrType].IrrClearWork * FarmWork);
+            Inc(Cost, Terrain[TerrType].IrrClearWork * FarmWork);
             TileImp := TileImp and not fTerImp or tiFarm;
           end;
         jMine:
           begin
             inc(Cost, Terrain[TerrType].MineAfforestWork);
+            Inc(Cost, Terrain[TerrType].MineAfforestWork);
             TileImp := TileImp and not fTerImp or tiMine;
           end;
         jClear:
           begin
             inc(Cost, Terrain[TerrType].IrrClearWork);
+            Inc(Cost, Terrain[TerrType].IrrClearWork);
             TerrType := Terrain[TerrType].ClearTerrain;
           end;
         jAfforest:
           begin
             inc(Cost, Terrain[TerrType].MineAfforestWork);
+            Inc(Cost, Terrain[TerrType].MineAfforestWork);
             TerrType := Terrain[TerrType].AfforestTerrain;
           end;
         jTrans:
           begin
             inc(Cost, Terrain[TerrType].TransWork);
+            Inc(Cost, Terrain[TerrType].TransWork);
             TerrType := Terrain[TerrType].TransTerrain;
           end;
       end;
       include(Done, MyData.EnhancementJobs[Page, stage - 1]);
+      Include(Done, MyData.EnhancementJobs[Page, stage - 1]);
     end;
     with NoMap do begin
       if TerrType < fForest then
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + TerrType * (xxt * 2 + 1), 1 + yyt)
       else
       begin
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 2 * (xxt * 2 + 1), 1 + yyt + 2 * (yyt * 3 + 1));
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 7 * (xxt * 2 + 1), 1 + yyt + 2 * (2 + TerrType - fForest) *
           (yyt * 3 + 1));
       end;
       if TileImp and fTerImp = tiFarm then
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + (xxt * 2 + 1), 1 + yyt + 12 * (yyt * 3 + 1))
       else if TileImp and fTerImp = tiIrrigation then
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2, 1,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2, 1,
 + yyt + 12 * (yyt * 3 + 1));
       if TileImp and fRR <> 0 then
       begin
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 6 * (xxt * 2 + 1), 1 + yyt + 10 * (yyt * 3 + 1));
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 2 * (xxt * 2 + 1), 1 + yyt + 10 * (yyt * 3 + 1));
       end
       else if TileImp and fRoad <> 0 then
       begin
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 6 * (xxt * 2 + 1), 1 + yyt + 9 * (yyt * 3 + 1));
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 2 * (xxt * 2 + 1), 1 + yyt + 9 * (yyt * 3 + 1));
       end;
       if TileImp and fTerImp = tiMine then
         Sprite(offscreen, HGrTerrain, x, 64 - yyt, xxt * 2, yyt * 2,
+        Sprite(Offscreen, HGrTerrain, X, 64 - yyt, xxt * 2, yyt * 2,
 + 2 * (xxt * 2 + 1), 1 + yyt + 12 * (yyt * 3 + 1));
       inc(x, xxt * 2 + 6);
     end;
   end;
   for i := 0 to Popup.Items.Count - 1 do
     if Popup.Items[i].Tag = Page then
       s := Popup.Items[i].Caption;
+      Inc(X, xxt * 2 + 6);
+    end;
+  end;
+  for I := 0 to Popup.Items.Count - 1 do
+    if Popup.Items[I].Tag = Page then
+      S := Popup.Items[I].Caption;
   if Cost > 0 then
     s := Format(Phrases.Lookup('ENHANCE'), [s, MovementToString(Cost)]);
   LoweredTextOut(offscreen.Canvas, -1, MainTexture,
     (InnerWidth - BiColorTextWidth(offscreen.Canvas, s)) div 2, 12, s);
+    S := Format(Phrases.Lookup('ENHANCE'), [S, MovementToString(Cost)]);
+  LoweredTextOut(Offscreen.Canvas, -1, MainTexture,
+    (InnerWidth - BiColorTextWidth(Offscreen.Canvas, S)) div 2, 12, S);
   if EndStage > 0 then
 …
     (Terrain[TerrType].MineEff > 0);
   job3.Visible := not TypeChanged and (Terrain[TerrType].ClearTerrain >= 0) and
     ((TerrType <> fDesert) or (MyRO.Wonder[woGardens].EffectiveOwner = me)) or
+    ((TerrType <> fDesert) or (MyRO.Wonder[woGardens].EffectiveOwner = Me)) or
     (LastJob = jClear);
   job6.Visible := not TypeChanged and (Terrain[TerrType].AfforestTerrain >= 0)
 …
   MarkUsedOffscreen(InnerWidth, InnerHeight);
 end; { OffscreenPaint }
+end;
 procedure TEnhanceDlg.CloseBtnClick(Sender: TObject);
 …
 procedure TEnhanceDlg.ToggleBtnClick(Sender: TObject);
 var
   i: integer;
 begin
   for i := 0 to Popup.Items.Count - 1 do
     Popup.Items[i].Checked := Popup.Items[i].Tag = Page;
+  I: Integer;
+begin
+  for I := 0 to Popup.Items.Count - 1 do
+    Popup.Items[I].Checked := Popup.Items[I].Tag = Page;
   Popup.Popup(Left + ToggleBtn.Left, Top + ToggleBtn.Top + ToggleBtn.Height);
 end;
 …
 procedure TEnhanceDlg.JobClick(Sender: TObject);
 var
   stage, NewJob: integer;
+  Stage, NewJob: Integer;
   Done: Set of jNone .. jTrans;
   procedure RemoveJob(j: integer);
+  procedure RemoveJob(J: Integer);
   begin // remove job
     stage := 0;
     while (stage < 5) and (MyData.EnhancementJobs[Page, stage] <> jNone) do
     begin
       if (MyData.EnhancementJobs[Page, stage] = j) or (j = jRoad) and
         (MyData.EnhancementJobs[Page, stage] = jRR) or (j = jIrr) and
         (MyData.EnhancementJobs[Page, stage] = jFarm) then
+    Stage := 0;
+    while (Stage < 5) and (MyData.EnhancementJobs[Page, Stage] <> jNone) do
+    begin
+      if (MyData.EnhancementJobs[Page, Stage] = J) or (J = jRoad) and
+        (MyData.EnhancementJobs[Page, Stage] = jRR) or (J = jIrr) and
+        (MyData.EnhancementJobs[Page, Stage] = jFarm) then
       begin
         if stage < 4 then
           move(MyData.EnhancementJobs[Page, stage + 1],
             MyData.EnhancementJobs[Page, stage], 4 - stage);
+        if Stage < 4 then
+          Move(MyData.EnhancementJobs[Page, Stage + 1],
+            MyData.EnhancementJobs[Page, Stage], 4 - Stage);
         MyData.EnhancementJobs[Page, 4] := jNone;
       end
       else
         inc(stage);
+        Inc(Stage);
     end;
   end;
 …
   NewJob := TButtonC(Sender).Tag;
   Done := [];
   stage := 0;
   while (stage < 5) and (MyData.EnhancementJobs[Page, stage] <> jNone) do
+  Stage := 0;
+  while (Stage < 5) and (MyData.EnhancementJobs[Page, Stage] <> jNone) do
   begin
     include(Done, MyData.EnhancementJobs[Page, stage]);
     inc(stage);
+    Include(Done, MyData.EnhancementJobs[Page, Stage]);
+    Inc(Stage);
   end;
   if NewJob in Done then
 …
     if (NewJob = jRR) and not(jRoad in Done) then
     begin
       MyData.EnhancementJobs[Page, stage] := jRoad;
       inc(stage);
+      MyData.EnhancementJobs[Page, Stage] := jRoad;
+      Inc(Stage);
     end;
     if (NewJob = jFarm) and not(jIrr in Done) then
     begin
       MyData.EnhancementJobs[Page, stage] := jIrr;
       inc(stage);
     end;
     MyData.EnhancementJobs[Page, stage] := NewJob;
+      MyData.EnhancementJobs[Page, Stage] := jIrr;
+      Inc(Stage);
+    end;
+    MyData.EnhancementJobs[Page, Stage] := NewJob;
   end;
   SmartUpdateContent;
 …
   ShortCut := KeyToShortCut(Key, Shift);
   if BHelp.Test(ShortCut) then
     HelpDlg.ShowNewContent(FWindowMode or wmPersistent, hkText,
       HelpDlg.TextIndex('MACRO'))
+    MainScreen.HelpDlg.ShowNewContent(WindowModeMakePersistent(FWindowMode), hkText,
+      MainScreen.HelpDlg.TextIndex('MACRO'))
 end;

branches/highdpi/LocalPlayer/Help.pas

-              r412
+              r465
   UDpiControls, Protocol, ScreenTools, BaseWin, StringTables, Math, LCLIntf, LCLType,
   Messages, SysUtils, Classes, Graphics, Controls, Forms, ExtCtrls,
   ButtonB, PVSB, Types, fgl, IsoEngine;
+  ButtonB, PVSB, Types, Generics.Collections, IsoEngine;
 const
   MaxHist = 16;
+  { link categories }
+  hkNoLink = 0;
+  hkAdv = 1;
+  hkImp = 2;
+  hkTer = 3;
+  hkFeature = 4;
+  hkInternet = 5;
+  hkModel = 6;
+  hkMisc = 7;
+  hkCrossLink = $40;
+  hkText = $80;
+  liInvalid = $3FFF; // link index indicates invalid link
+  { link indices for category hkMisc }
+  miscMain = 0;
+  miscCredits = 1;
+  miscGovList = 2;
+  miscJobList = 3;
+  miscSearchResult = 7;
+  fJungle = 8; // pseudo terrain
+  fJungle = 8; // Pseudo terrain
 type
+  { Link categories }
+  TLinkCategory = (
+    hkNoLink,
+    hkAdv,
+    hkImp,
+    hkTer,
+    hkFeature ,
+    hkInternet,
+    hkModel,
+    hkMisc,
+    hkText);
+  { Link indices for category hkMisc }
+  TMiscLinkIndex = (
+    miscMain,
+    miscCredits,
+    miscGovList,
+    miscJobList,
+    miscSearchResult);
+  TTextFormat = (
+    pkNormal,
+    pkCaption,
+    pkSmallIcon,
+    pkBigIcon,
+    pkAdvIcon,
+    pkTer,
+    pkBigTer,
+    pkFeature,
+    pkDot,
+    pkNormal_Dot,
+    pkDomain,
+    pkSection,
+    pkBigFeature,
+    pkExp,
+    pkAITStat,
+    pkExternal,
+    pkModel,
+    pkNormal_64,
+    pkIllu,
+    pkLogo,
+    pkTerImp,
+    pkRightIcon,
+    pkAdvIcon_AsPreq,
+    pkSmallIcon_AsPreq,
+    pkSpecialIcon,
+    pkGov);
   { THyperText }
 …
   THyperText = class(TStringList)
   public
     procedure AddLine(s: String = ''; Format: integer = 0; Picpix: Integer = 0;
       LinkCategory: integer = 0; LinkIndex: integer = 0);
+    procedure AddLine(S: String = ''; Format: TTextFormat = pkNormal; Picpix: Integer = 0;
+      LinkCategory: TLinkCategory = hkNoLink; LinkIndex: Integer = 0; CrossLink: Boolean = False);
     procedure LineFeed;
     procedure AppendList(Source: THyperText);
-    destructor Destroy; override;
   end;
 …
   THistItem = class
     Kind: Integer;
+    Kind: TLinkCategory;
     No: Integer;
     Pos: Integer;
 …
   { THistItems }
   THistItems = class(TFPGObjectList<THistItem>)
     function AddNew(Kind, No, Pos: Integer; SearchContent: string): THistItem;
+  THistItems = class(TObjectList<THistItem>)
+    function AddNew(Kind: TLinkCategory; No, Pos: Integer; SearchContent: string): THistItem;
   end;
 …
     procedure CloseBtnClick(Sender: TObject);
     procedure PaintBox1MouseMove(Sender: TObject; Shift: TShiftState;
       x, y: integer);
+      X, Y: Integer);
     procedure PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
       Shift: TShiftState; x, y: integer);
+      Shift: TShiftState; X, Y: Integer);
     procedure BackBtnClick(Sender: TObject);
     procedure TopBtnClick(Sender: TObject);
 …
     procedure OffscreenPaint; override;
   private
     Kind: Integer;
     no: Integer;
+    Kind: TLinkCategory;
+    No: Integer;
     Sel: Integer;
     CaptionColor: Integer;
 …
     SearchResult: THyperText;
     HelpText: TStringTable;
+    ExtPic, TerrIcon: TDpiBitmap;
+    ExtPic: TDpiBitmap;
+    TerrIcon: TDpiBitmap;
     ScrollBar: TPVScrollbar;
     NoMap: TIsoMap;
     x0: array [-2..180] of Integer;
     procedure PaintTerrIcon(x, y, xSrc, ySrc: Integer);
+    procedure PaintTerrIcon(X, Y, xSrc, ySrc: Integer);
     procedure ScrollBarUpdate(Sender: TObject);
     procedure Line(ca: TDpiCanvas; i: Integer; lit: Boolean);
+    procedure Line(ACanvas: TDpiCanvas; I: Integer; Lit: Boolean);
     procedure Prepare(sbPos: Integer = 0);
     procedure ShowNewContentProcExecute(NewMode: Integer; HelpContext: string);
+    procedure ShowNewContentProcExecute(NewMode: TWindowMode; HelpContext: string);
     procedure WaterSign(x0, y0, iix: Integer);
     procedure Search(SearchString: string);
 …
     Difficulty: Integer;
     procedure ClearHistory;
     procedure ShowNewContent(NewMode, Category, Index: Integer);
+    procedure ShowNewContent(NewMode: TWindowMode; Category: TLinkCategory; Index: Integer);
     function TextIndex(Item: string): Integer;
   end;
-var
-  HelpDlg: THelpDlg;
 implementation
 uses
   Directories, ClientTools, Term, Tribes, Inp, Messg, UPixelPointer, Global,
   UKeyBindings;
+  Directories, ClientTools, Term, Tribes, Inp, Messg, PixelPointer, Global,
+  KeyBindings;
 {$R *.lfm}
 …
   THelpLineInfo = class
     Format: Byte;
+    Format: TTextFormat;
     Picpix: Byte;
+    Link: Word;
+    Category: TLinkCategory;
+    Index: Integer;
+    CrossLink: Boolean;
     procedure Assign(Source: THelpLineInfo);
   end;
+{ THelpLineInfo }
+procedure THelpLineInfo.Assign(Source: THelpLineInfo);
+begin
+  Format := Source.Format;
+  PicPix := Source.PicPix;
+  Link := Source.Link;
+end;
+{ THistItem }
+procedure THistItem.Assign(Source: THistItem);
+begin
+  Kind := Source.Kind;
+  No := Source.No;
+  Pos := Source.Pos;
+  SearchContent := Source.SearchContent;
+end;
+{ THistItems }
+function THistItems.AddNew(Kind, No, Pos: Integer; SearchContent: string
+  ): THistItem;
+begin
+  Result := THistItem.Create;
+  Result.Kind := Kind;
+  Result.No := No;
+  Result.Pos := Pos;
+  Result.SearchContent := SearchContent;
+  Add(Result);
+end;
+procedure THyperText.AddLine(s: String; Format: integer; Picpix: integer;
+  LinkCategory: integer; LinkIndex: integer);
+var
+  HelpLineInfo: THelpLineInfo;
+begin
+  HelpLineInfo := THelpLineInfo.Create;
+  if LinkIndex < 0 then
+    LinkIndex := liInvalid;
+  HelpLineInfo.Format := Format;
+  HelpLineInfo.Picpix := Picpix;
+  HelpLineInfo.Link := LinkCategory shl 8 + LinkIndex;
+  AddObject(s, TObject(HelpLineInfo));
+end;
+procedure THyperText.LineFeed;
+begin
+  AddLine;
+end;
+procedure THyperText.AppendList(Source: THyperText);
+var
+  I: Integer;
+  HelpLineInfo: THelpLineInfo;
+begin
+  for I := 0 to Source.Count - 1 do begin
+    HelpLineInfo := THelpLineInfo.Create;
+    HelpLineInfo.Assign(THelpLineInfo(Source.Objects[I]));
+    AddObject(Source.Strings[I], HelpLineInfo);
+  end;
+end;
+destructor THyperText.Destroy;
+begin
+  inherited;
+end;
+  TSeeAlso = record
+    Kind: TLinkCategory;
+    No: Integer;
+    SeeKind: TLinkCategory;
+    SeeNo: Integer;
+  end;
 const
+  { text formats }
+  pkNormal = 0;
+  pkCaption = 1;
+  pkSmallIcon = 2;
+  pkBigIcon = 3;
+  pkAdvIcon = 4;
+  pkTer = 5;
+  pkBigTer = 6;
+  pkFeature = 7;
+  pkDot = 8;
+  pkNormal_Dot = 9;
+  pkDomain = 10;
+  pkSection = 11;
+  pkBigFeature = 12;
+  pkExp = 13;
+  pkAITStat = 14;
+  pkExternal = 15;
+  pkModel = 16;
+  pkNormal_64 = 17;
+  pkIllu = 18;
+  pkLogo = 19;
+  pkTerImp = 20;
+  pkRightIcon = 21;
+  pkAdvIcon_AsPreq = 22;
+  pkSmallIcon_AsPreq = 23;
+  pkSpecialIcon = 24;
+  pkGov = 25;
+  nSeeAlso = 14;
+  SeeAlso: array [0 .. nSeeAlso - 1] of record
+    Kind: Integer;
+    no: Integer;
+    SeeKind: Integer;
+    SeeNo: Integer;
+  end = ((Kind: hkImp; no: imWalls; SeeKind: hkFeature;
+  SeeAlso: array[0..13] of TSeeAlso = ((Kind: hkImp; no: imWalls; SeeKind: hkFeature;
     SeeNo: mcArtillery), (Kind: hkImp; no: imHydro; SeeKind: hkImp;
     SeeNo: woHoover), (Kind: hkImp; no: imWalls; SeeKind: hkImp;
 …
     SeeKind: hkFeature; SeeNo: mcDefense));
+  nTerrainHelp = 14;
+  TerrainHelp: array [0 .. nTerrainHelp - 1] of integer = (fGrass, fGrass + 12,
+  TerrainHelp: array[0..13] of Integer = (fGrass, fGrass + 12,
     fPrairie, fForest, fJungle, fHills, fMountains, fSwamp, fTundra, fArctic,
+    fDesert, 3 * 12 { DeadLands } , fShore, fOcean);
+  nJobHelp = 8;
+  JobHelp: array [0 .. nJobHelp - 1] of integer = (jRoad, jRR, jCanal, jIrr,
+    fDesert, 3 * 12 { DeadLands }, fShore, fOcean);
+  JobHelp: array[0..7] of Integer = (jRoad, jRR, jCanal, jIrr,
     jFarm, jMine, jFort, jBase);
+{ THelpLineInfo }
+procedure THelpLineInfo.Assign(Source: THelpLineInfo);
+begin
+  Format := Source.Format;
+  PicPix := Source.PicPix;
+  Category := Source.Category;
+  Index := Source.Index;
+end;
+{ THistItem }
+procedure THistItem.Assign(Source: THistItem);
+begin
+  Kind := Source.Kind;
+  No := Source.No;
+  Pos := Source.Pos;
+  SearchContent := Source.SearchContent;
+end;
+{ THistItems }
+function THistItems.AddNew(Kind: TLinkCategory; No, Pos: Integer; SearchContent: string
+  ): THistItem;
+begin
+  Result := THistItem.Create;
+  Result.Kind := Kind;
+  Result.No := No;
+  Result.Pos := Pos;
+  Result.SearchContent := SearchContent;
+  Add(Result);
+end;
+procedure THyperText.AddLine(S: String; Format: TTextFormat; Picpix: Integer;
+  LinkCategory: TLinkCategory = hkNoLink; LinkIndex: Integer = 0;
+  CrossLink: Boolean = False);
+var
+  HelpLineInfo: THelpLineInfo;
+begin
+  HelpLineInfo := THelpLineInfo.Create;
+  HelpLineInfo.Format := Format;
+  HelpLineInfo.Picpix := Picpix;
+  HelpLineInfo.Category := LinkCategory;
+  HelpLineInfo.Index := LinkIndex;
+  HelpLineInfo.CrossLink := CrossLink;
+  AddObject(S, HelpLineInfo);
+end;
+procedure THyperText.LineFeed;
+begin
+  AddLine;
+end;
+procedure THyperText.AppendList(Source: THyperText);
+var
+  I: Integer;
+  HelpLineInfo: THelpLineInfo;
+begin
+  for I := 0 to Source.Count - 1 do begin
+    HelpLineInfo := THelpLineInfo.Create;
+    HelpLineInfo.Assign(THelpLineInfo(Source.Objects[I]));
+    AddObject(Source.Strings[I], HelpLineInfo);
+  end;
+end;
 procedure THelpDlg.FormCreate(Sender: TObject);
 begin
-  inherited;
   NoMap := TIsoMap.Create;
 …
   CaptionLeft := BackBtn.Left + BackBtn.Width;
   CaptionRight := SearchBtn.Left;
   inc(ModalFrameIndent, 29);
+  Inc(ModalFrameIndent, 29);
   MainText := THyperText.Create;
   MainText.OwnsObjects := True;
 …
   HelpText := TStringTable.Create;
   HelpText.LoadFromFile(LocalizedFilePath('Help' + DirectorySeparator + 'help.txt'));
+  HelpText.LoadFromFile(LocalizedFilePath('Help' + DirectorySeparator + 'Help.txt'));
   hADVHELP := HelpText.Gethandle('ADVHELP');
   hIMPHELP := HelpText.Gethandle('IMPHELP');
 …
 end;
 procedure THelpDlg.ShowNewContentProcExecute(NewMode: Integer;
+procedure THelpDlg.ShowNewContentProcExecute(NewMode: TWindowMode;
   HelpContext: string);
 begin
+  HelpDlg.ShowNewContent(NewMode, hkText,
+    HelpDlg.TextIndex(HelpContext))
+  ShowNewContent(NewMode, hkText, TextIndex(HelpContext));
 end;
 …
   if ScrollBar.Process(Msg) then begin
     Sel := -1;
     SmartUpdateContent(true)
+    SmartUpdateContent(True)
   end;
+  }
 …
 begin
   if Sel <> -1 then begin
     Line(Canvas, Sel, false);
     Sel := -1
+    Line(Canvas, Sel, False);
+    Sel := -1;
   end;
 end;
 …
 end;
 procedure THelpDlg.Line(ca: TDpiCanvas; i: Integer; lit: Boolean);
+procedure THelpDlg.Line(ACanvas: TDpiCanvas; I: Integer; Lit: Boolean);
 var
+  TextColor, x, y: Integer;
+  TextColor: TColor;
+  X, Y: Integer;
   TextSize: TSize;
   s: string;
 begin
   s := MainText[ScrollBar.Position + i];
   if s = '' then
+  S: string;
+begin
+  S := MainText[ScrollBar.Position + I];
+  if S = '' then
     Exit;
   x := x0[i];
   y := 2 + i * 24;
   if ca = Canvas then
   begin
     x := x + SideFrame;
     y := y + WideFrame
   end;
   if THelpLineInfo(MainText.Objects[ScrollBar.Position + i]).Format
+  X := x0[I];
+  Y := 2 + I * 24;
+  if ACanvas = Canvas then
+  begin
+    X := X + SideFrame;
+    Y := Y + WideFrame;
+  end;
+  if THelpLineInfo(MainText.Objects[ScrollBar.Position + I]).Format
     in [pkCaption, pkBigTer, pkRightIcon, pkBigFeature] then
   begin
     ca.Font.Assign(CaptionFont);
     { ca.brush.color:=CaptionColor;
       ca.FillRect(rect(x,i*24,x+24,i*24+24));
       ca.brush.color:=$FFFFFF;
       ca.FrameRect(rect(x+1,i*24+1,x+24-1,i*24+24-1));
       ca.Brush.Style:=bsClear; }
     DpiBitCanvas(ca, x, y - 4, 24, 24, HGrSystem.Data.Canvas, 1,
+    ACanvas.Font.Assign(CaptionFont);
+    { ACanvas.brush.color:=CaptionColor;
+      ACanvas.FillRect(rect(X,I*24,X+24,I*24+24));
+      ACanvas.Brush.Color:=$FFFFFF;
+      ACanvas.FrameRect(rect(X+1,I*24+1,X+24-1,I*24+24-1));
+      ACanvas.Brush.Style:=bsClear; }
+    DpiBitBltCanvas(ACanvas, X, Y - 4, 24, 24, HGrSystem.Data.Canvas, 1,
 );
     BiColorTextOut(ca, $FFFFFF, $7F007F, x + 10 - ca.Textwidth(s[1]) div 2,
       y - 3, s[1]);
     BiColorTextOut(ca, CaptionColor, $7F007F, x + 24, y - 3, copy(s, 2, 255));
     ca.Font.Assign(UniFont[ftNormal]);
+    BiColorTextOut(ACanvas, $FFFFFF, $7F007F, X + 10 - ACanvas.Textwidth(S[1]) div 2,
+      Y - 3, S[1]);
+    BiColorTextOut(ACanvas, CaptionColor, $7F007F, X + 24, Y - 3, Copy(S, 2, 255));
+    ACanvas.Font.Assign(UniFont[ftNormal]);
   end
+  else if THelpLineInfo(MainText.Objects[ScrollBar.Position + i]).Format = pkSection
+  then
+  begin
+    ca.Font.Assign(CaptionFont);
+    BiColorTextOut(ca, CaptionColor, $7F007F, x, y - 3, s);
+    ca.Font.Assign(UniFont[ftNormal]);
+  else if THelpLineInfo(MainText.Objects[ScrollBar.Position + I]).Format = pkSection then
+  begin
+    ACanvas.Font.Assign(CaptionFont);
+    BiColorTextOut(ACanvas, CaptionColor, $7F007F, X, Y - 3, S);
+    ACanvas.Font.Assign(UniFont[ftNormal]);
   end
   else
   begin
     if (Kind = hkMisc) and (no = miscMain) then
       ca.Font.Assign(CaptionFont);
+    if (Kind = hkMisc) and (No = Integer(miscMain)) then
+      ACanvas.Font.Assign(CaptionFont);
     TextColor := Colors.Canvas.Pixels[clkMisc, cliPaperText];
     if ca = Canvas then
+    if ACanvas = Canvas then
     begin
       TextSize.cx := BiColorTextWidth(ca, s);
       TextSize.cy := ca.TextHeight(s);
       if y + TextSize.cy >= WideFrame + InnerHeight then
         TextSize.cy := WideFrame + InnerHeight - y;
       FillSeamless(ca, x, y, TextSize.cx, TextSize.cy, -SideFrame,
+      TextSize.cx := BiColorTextWidth(ACanvas, S);
+      TextSize.cy := ACanvas.TextHeight(S);
+      if Y + TextSize.cy >= WideFrame + InnerHeight then
+        TextSize.cy := WideFrame + InnerHeight - Y;
+      FillSeamless(ACanvas, X, Y, TextSize.cx, TextSize.cy, -SideFrame,
         ScrollBar.Position * 24 - WideFrame, Paper);
     end;
     BiColorTextOut(ca, TextColor, $7F007F, x, y, s);
+    BiColorTextOut(ACanvas, TextColor, $7F007F, X, Y, S);
     if lit then
       with ca do
+      with ACanvas do
       begin
         Assert(ca = Canvas);
+        Assert(ACanvas = Canvas);
         Pen.Color := TextColor;
         MoveTo(x + 1, y + TextSize.cy - 2);
         LineTo(x + TextSize.cx, y + TextSize.cy - 2);
+        MoveTo(X + 1, Y + TextSize.cy - 2);
+        LineTo(X + TextSize.cx, Y + TextSize.cy - 2);
       end;
     if (Kind = hkMisc) and (no = miscMain) then
       ca.Font.Assign(UniFont[ftNormal]);
   end;
 end;
 procedure THelpDlg.WaterSign(x0, y0, iix: integer);
+    if (Kind = hkMisc) and (No = Integer(miscMain)) then
+      ACanvas.Font.Assign(UniFont[ftNormal]);
+  end;
+end;
+procedure THelpDlg.WaterSign(x0, y0, iix: Integer);
 const
   nHeaven = 28;
   MaxSum = 9 * 9 * 255 * 75 div 100;
 var
   x, y, dx, dy, xSrc, ySrc, Sum, xx: integer;
   Heaven: array [0..nHeaven] of integer;
+  X, Y, dx, dy, xSrc, ySrc, Sum, xx: Integer;
+  Heaven: array [0..nHeaven] of Integer;
   PaintPtr: TPixelPointer;
   CoalPtr: TPixelPointer;
 …
   xSrc := iix mod 7 * xSizeBig;
   ySrc := (iix div 7 + 1) * ySizeBig;
   PaintPtr := PixelPointer(OffScreen, ScaleToNative(x0), ScaleToNative(y0));
   CoalPtr := PixelPointer(Templates.Data, ScaleToNative(xCoal), ScaleToNative(yCoal));
+  PaintPtr := TPixelPointer.Create(OffScreen, ScaleToNative(x0), ScaleToNative(y0));
+  CoalPtr := TPixelPointer.Create(Templates.Data, ScaleToNative(xCoal), ScaleToNative(yCoal));
   for dy := -1 to 1 do
     ImpPtr[dy] := PixelPointer(BigImp, ScaleToNative(xSrc), ScaleToNative(ySrc));
   for y := 0 to ScaleToNative(ySizeBig) * 2 - 1 do begin
     if ((ScaleToNative(y0) + y) >= 0) and ((ScaleToNative(y0) + y) < ScaleToNative(InnerHeight)) then begin
+    ImpPtr[dy] := TPixelPointer.Create(BigImp, ScaleToNative(xSrc), ScaleToNative(ySrc));
+  for Y := 0 to ScaleToNative(ySizeBig) * 2 - 1 do begin
+    if ((ScaleToNative(y0) + Y) >= 0) and ((ScaleToNative(y0) + Y) < ScaleToNative(InnerHeight)) then begin
       for dy := -1 to 1 do
         if ((Max(y + ScaleToNative(dy), 0) shr 1) >= 0) and ((Max(y + ScaleToNative(dy), 0) shr 1) < ScaleToNative(ySizeBig)) then
           ImpPtr[dy].SetXY(0, Max(y + ScaleToNative(dy), 0) shr 1);
       for x := 0 to ScaleToNative(xSizeBig * 2) - 1 do begin
+        if ((Max(Y + ScaleToNative(dy), 0) shr 1) >= 0) and ((Max(Y + ScaleToNative(dy), 0) shr 1) < ScaleToNative(ySizeBig)) then
+          ImpPtr[dy].SetXY(0, Max(Y + ScaleToNative(dy), 0) shr 1);
+      for X := 0 to ScaleToNative(xSizeBig * 2) - 1 do begin
         Sum := 0;
         for dx := -1 to 1 do begin
           xx := Max((x + ScaleToNative(dx)), 0) shr 1;
+          xx := Max((X + ScaleToNative(dx)), 0) shr 1;
           for dy := -1 to 1 do begin
             ImpPtr[dy].SetX(xx);
             if ((y + ScaleToNative(dy)) shr 1 < 0) or ((y + ScaleToNative(dy)) shr 1 >= ScaleToNative(ySizeBig)) or
               ((x + ScaleToNative(dx)) shr 1 < 0) or ((x + ScaleToNative(dx)) shr 1 >= ScaleToNative(xSizeBig)) or
               ((y + ScaleToNative(dy)) shr 1 < ScaleToNative(nHeaven)) and
+            if ((Y + ScaleToNative(dy)) shr 1 < 0) or ((Y + ScaleToNative(dy)) shr 1 >= ScaleToNative(ySizeBig)) or
+              ((X + ScaleToNative(dx)) shr 1 < 0) or ((X + ScaleToNative(dx)) shr 1 >= ScaleToNative(xSizeBig)) or
+              ((Y + ScaleToNative(dy)) shr 1 < ScaleToNative(nHeaven)) and
               (ImpPtr[dy].Pixel^.B shl 16 + ImpPtr[dy].Pixel^.G shl 8 +
               ImpPtr[dy].Pixel^.R = Heaven[(ScaleFromNative(y + ScaleToNative(dy))) shr 1]) then
+              ImpPtr[dy].Pixel^.R = Heaven[(ScaleFromNative(Y + ScaleToNative(dy))) shr 1]) then
               Sum := Sum + 9 * 255
             else
 …
           end;
         end;
         if Sum < MaxSum then begin // no saturation
+        if Sum < MaxSum then begin // No saturation
           Sum := 1 shl 22 - (MaxSum - Sum) * (256 - CoalPtr.Pixel^.B * 2);
           PaintPtr.Pixel^.B := Min(PaintPtr.Pixel^.B * Sum shr 22, 255);
 …
 end;
 procedure THelpDlg.PaintTerrIcon(x, y, xSrc, ySrc: integer);
+procedure THelpDlg.PaintTerrIcon(X, Y, xSrc, ySrc: Integer);
 begin
   with NoMap do begin
     Frame(OffScreen.Canvas, x - 1, y - 1, x + xSizeBig, y + ySizeBig,
+    Frame(OffScreen.Canvas, X - 1, Y - 1, X + xSizeBig, Y + ySizeBig,
       $000000, $000000);
     if 2 * yyt < 40 then begin
       Sprite(OffScreen, HGrTerrain, x, y, 56, 2 * yyt, xSrc, ySrc);
       Sprite(OffScreen, HGrTerrain, x, y + 2 * yyt, 56, 40 - 2 * yyt,
+      Sprite(OffScreen, HGrTerrain, X, Y, 56, 2 * yyt, xSrc, ySrc);
+      Sprite(OffScreen, HGrTerrain, X, Y + 2 * yyt, 56, 40 - 2 * yyt,
         xSrc, ySrc);
     end else
       Sprite(OffScreen, HGrTerrain, x, y, 56, 40, xSrc, ySrc);
     Sprite(OffScreen, HGrTerrain, x, y, xxt, yyt, xSrc + xxt, ySrc + yyt);
     Sprite(OffScreen, HGrTerrain, x, y + yyt, xxt, 40 - yyt, xSrc + xxt, ySrc);
     Sprite(OffScreen, HGrTerrain, x + xxt, y, 56 - xxt, yyt, xSrc, ySrc + yyt);
     Sprite(OffScreen, HGrTerrain, x + xxt, y + yyt, 56 - xxt, 40 - yyt,
+      Sprite(OffScreen, HGrTerrain, X, Y, 56, 40, xSrc, ySrc);
+    Sprite(OffScreen, HGrTerrain, X, Y, xxt, yyt, xSrc + xxt, ySrc + yyt);
+    Sprite(OffScreen, HGrTerrain, X, Y + yyt, xxt, 40 - yyt, xSrc + xxt, ySrc);
+    Sprite(OffScreen, HGrTerrain, X + xxt, Y, 56 - xxt, yyt, xSrc, ySrc + yyt);
+    Sprite(OffScreen, HGrTerrain, X + xxt, Y + yyt, 56 - xxt, 40 - yyt,
       xSrc, ySrc);
   end;
 …
 procedure THelpDlg.OffscreenPaint;
 var
   i, j, yl, srcno, ofs, cnt, y: Integer;
   s: string;
+  I, J, yl, srcno, ofs, cnt, Y: Integer;
+  S: string;
   HelpLineInfo: THelpLineInfo;
 begin
 …
   begin
     Font.Assign(UniFont[ftNormal]);
     for i := -ScrollBar.Position to InnerHeight div 24 do
       if ScrollBar.Position + i < MainText.Count then
+    for I := -ScrollBar.Position to InnerHeight div 24 do
+      if ScrollBar.Position + I < MainText.Count then
       begin
         HelpLineInfo := THelpLineInfo(MainText.Objects[ScrollBar.Position + i]);
+        HelpLineInfo := THelpLineInfo(MainText.Objects[ScrollBar.Position + I]);
         if HelpLineInfo.Format = pkExternal then
         begin
           yl := ExtPic.Height;
           if 4 + i * 24 + yl > InnerHeight then
             yl := InnerHeight - (4 + i * 24);
           DpiBitCanvas(OffScreen.Canvas, 8, 4 + i * 24, ExtPic.Width, yl, ExtPic.Canvas,
+          if 4 + I * 24 + yl > InnerHeight then
+            yl := InnerHeight - (4 + I * 24);
+          DpiBitBltCanvas(OffScreen.Canvas, 8, 4 + I * 24, ExtPic.Width, yl, ExtPic.Canvas,
 , 0);
         end;
       end;
     for i := -2 to InnerHeight div 24 do
       if (ScrollBar.Position + i >= 0) and (ScrollBar.Position + i < MainText.Count) then
+    for I := -2 to InnerHeight div 24 do
+      if (ScrollBar.Position + I >= 0) and (ScrollBar.Position + I < MainText.Count) then
       begin
         HelpLineInfo := THelpLineInfo(MainText.Objects[ScrollBar.Position + i]);
         if HelpLineInfo.Link <> 0 then
+        HelpLineInfo := THelpLineInfo(MainText.Objects[ScrollBar.Position + I]);
+        if (HelpLineInfo.Category <> hkNoLink) or (HelpLineInfo.Index <> 0) then
         begin
           if (Kind = hkMisc) and (no = miscSearchResult) then
             Sprite(OffScreen, HGrSystem, 18, 9 + i * 24, 8, 8, 90, 16)
+          if (Kind = hkMisc) and (No = Integer(miscSearchResult)) then
+            Sprite(OffScreen, HGrSystem, 18, 9 + I * 24, 8, 8, 90, 16)
           else if HelpLineInfo.Format in [pkSmallIcon_AsPreq, pkAdvIcon_AsPreq]
           then
             Sprite(OffScreen, HGrSystem, 12, i * 24 + 5, 14, 14, 65, 20)
           else if HelpLineInfo.Link and (hkCrossLink shl 8) <> 0 then
             Sprite(OffScreen, HGrSystem, 12, i * 24 + 5, 14, 14, 80, 1)
           else if not((Kind = hkMisc) and (no = miscMain)) then
             Sprite(OffScreen, HGrSystem, 10, i * 24 + 6, 14, 14, 65, 1);
           x0[i] := 24;
+            Sprite(OffScreen, HGrSystem, 12, I * 24 + 5, 14, 14, 65, 20)
+          else if HelpLineInfo.CrossLink then
+            Sprite(OffScreen, HGrSystem, 12, I * 24 + 5, 14, 14, 80, 1)
+          else if not((Kind = hkMisc) and (No = Integer(miscMain))) then
+            Sprite(OffScreen, HGrSystem, 10, I * 24 + 6, 14, 14, 65, 1);
+          x0[I] := 24;
         end
         else
           x0[i] := 0;
+          x0[I] := 0;
         case HelpLineInfo.Format of
           pkLogo:
             begin
               Server(sGetVersion, 0, 0, j);
               s := Format('%d.%d.%d', [j shr 16 and $FF, j shr 8 and $FF,
                 j and $FF]);
               PaintLogo(OffScreen.Canvas, (InnerWidth - 122) div 2, i * 24 + 1,
+              Server(sGetVersion, 0, 0, J);
+              S := Format('%d.%d.%d', [J shr 16 and $FF, J shr 8 and $FF,
+                J and $FF]);
+              PaintLogo(OffScreen.Canvas, (InnerWidth - 122) div 2, I * 24 + 1,
                 HGrSystem.Data.Canvas.Pixels[95, 1], $000000);
               Font.Assign(UniFont[ftSmall]);
               BiColorTextOut(OffScreen.Canvas, $000000, $7F007F,
                 (InnerWidth - Textwidth(s)) div 2, i * 24 + 26, s);
+                (InnerWidth - Textwidth(S)) div 2, I * 24 + 26, S);
               Font.Assign(UniFont[ftNormal]);
             end;
           pkSmallIcon, pkSmallIcon_AsPreq:
             begin
               ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[i], 2 - 1 + i * 24,
 + xSizeSmall + x0[i], 2 + 20 + i * 24, $000000, $000000);
+              ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[I], 2 - 1 + I * 24,
++ xSizeSmall + x0[I], 2 + 20 + I * 24, $000000, $000000);
               if HelpLineInfo.Picpix = imPalace then
                 DpiBitCanvas(OffScreen.Canvas, 8 + x0[i], 2 + i * 24,
+                DpiBitBltCanvas(OffScreen.Canvas, 8 + x0[I], 2 + I * 24,
                   xSizeSmall, ySizeSmall, SmallImp.Canvas,
 * xSizeSmall, 1 * ySizeSmall)
               else
                 DpiBitCanvas(OffScreen.Canvas, 8 + x0[i], 2 + i * 24,
+                DpiBitBltCanvas(OffScreen.Canvas, 8 + x0[I], 2 + I * 24,
                   xSizeSmall, ySizeSmall, SmallImp.Canvas,
                   HelpLineInfo.Picpix mod 7 * xSizeSmall,
                   (HelpLineInfo.Picpix + SystemIconLines * 7) div 7 *
                   ySizeSmall);
               x0[i] := x0[i] + (8 + 8 + 36);
+              x0[I] := x0[I] + (8 + 8 + 36);
             end;
           pkBigIcon:
             begin
               FrameImage(OffScreen.Canvas, BigImp, x0[i] + 12, i * 24 - 7, 56,
+              FrameImage(OffScreen.Canvas, BigImp, x0[I] + 12, I * 24 - 7, 56,
 , HelpLineInfo.Picpix mod 7 * xSizeBig,
                 HelpLineInfo.Picpix div 7 * ySizeBig);
               x0[i] := 64 + 8 + 8 + x0[i];
+              x0[I] := 64 + 8 + 8 + x0[I];
             end;
           pkSpecialIcon:
 …
 :
                   FrameImage(OffScreen.Canvas, HGrSystem2.Data,
 + x0[i], -7 + i * 24, 56, 40, 137, 127);
++ x0[I], -7 + I * 24, 56, 40, 137, 127);
 :
                   with NoMap do begin
                     PaintTerrIcon(12 + x0[i], -7 + i * 24,
+                    PaintTerrIcon(12 + x0[I], -7 + I * 24,
 + 3 * (xxt * 2 + 1), 1 + yyt);
                     if 2 * yyt < 40 then
                       Sprite(OffScreen, HGrTerrain, 12 + x0[i], -7 + 4 + i * 24,
+                      Sprite(OffScreen, HGrTerrain, 12 + x0[I], -7 + 4 + I * 24,
 , 2 * yyt, 1 + 3 * (xxt * 2 + 1) + xxt - 28,
 + yyt + 1 * (yyt * 3 + 1))
                     else
                       Sprite(OffScreen, HGrTerrain, 12 + x0[i],
                         -7 + 4 + i * 24 - 4, 56, 40, 1 + 3 * (xxt * 2 + 1) + xxt
+                      Sprite(OffScreen, HGrTerrain, 12 + x0[I],
+                        -7 + 4 + I * 24 - 4, 56, 40, 1 + 3 * (xxt * 2 + 1) + xxt
                         - 28, 1 + yyt + 1 * (yyt * 3 + 1) + yyt - 20);
                   end;
 :
                   with NoMap do begin
                     PaintTerrIcon(12 + x0[i], -7 + i * 24,
+                    PaintTerrIcon(12 + x0[I], -7 + I * 24,
 + 7 * (xxt * 2 + 1), 1 + yyt + 4 * (yyt * 3 + 1));
                     if 2 * yyt < 40 then
                       Sprite(OffScreen, HGrTerrain, 12 + x0[i], -7 + 4 + i * 24,
+                      Sprite(OffScreen, HGrTerrain, 12 + x0[I], -7 + 4 + I * 24,
 , 32, 1 + 4 * (xxt * 2 + 1) + xxt - 28,
 + yyt + 12 * (yyt * 3 + 1) + yyt - 16)
                     else
                       Sprite(OffScreen, HGrTerrain, 12 + x0[i], -7 + 4 + i * 24,
+                      Sprite(OffScreen, HGrTerrain, 12 + x0[I], -7 + 4 + I * 24,
 , 32, 1 + 4 * (xxt * 2 + 1) + xxt - 28,
 + yyt + 12 * (yyt * 3 + 1) + yyt - 16)
                   end;
               end;
               x0[i] := 64 + 8 + 8 + x0[i];
+              x0[I] := 64 + 8 + 8 + x0[I];
             end;
           pkDomain:
             begin
               ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[i], 2 - 1 + i * 24,
 + 36 + x0[i], 2 + 20 + i * 24, $000000, $000000);
               Dump(OffScreen, HGrSystem, 8 + x0[i], 2 + i * 24, 36, 20,
+              ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[I], 2 - 1 + I * 24,
++ 36 + x0[I], 2 + 20 + I * 24, $000000, $000000);
+              Dump(OffScreen, HGrSystem, 8 + x0[I], 2 + I * 24, 36, 20,
 + HelpLineInfo.Picpix * 37, 295);
               x0[i] := x0[i] + (8 + 8 + 36);
+              x0[I] := x0[I] + (8 + 8 + 36);
             end;
           pkAdvIcon, pkAdvIcon_AsPreq:
             begin
               ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[i], 2 - 1 + i * 24,
 + xSizeSmall + x0[i], 2 + ySizeSmall + i * 24,
+              ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[I], 2 - 1 + I * 24,
++ xSizeSmall + x0[I], 2 + ySizeSmall + I * 24,
                 $000000, $000000);
               if AdvIcon[HelpLineInfo.Picpix] < 84 then
                 DpiBitCanvas(OffScreen.Canvas, 8 + x0[i], 2 + i * 24,
+                DpiBitBltCanvas(OffScreen.Canvas, 8 + x0[I], 2 + I * 24,
                   xSizeSmall, ySizeSmall, SmallImp.Canvas,
                   (AdvIcon[HelpLineInfo.Picpix] + SystemIconLines * 7) mod 7 *
 …
 ) div 7 * ySizeSmall)
               else
                 Dump(OffScreen, HGrSystem, 8 + x0[i], 2 + i * 24, 36, 20,
+                Dump(OffScreen, HGrSystem, 8 + x0[I], 2 + I * 24, 36, 20,
 + (AdvIcon[HelpLineInfo.Picpix] - 84) mod 8 * 37,
 + (AdvIcon[HelpLineInfo.Picpix] - 84) div 8 * 21);
               j := AdvValue[HelpLineInfo.Picpix] div 1000;
               DpiBitCanvas(OffScreen.Canvas, x0[i] + 4, 4 + i * 24, 14, 14,
                 HGrSystem.Mask.Canvas, 127 + j * 15, 85, SRCAND);
               Sprite(OffScreen, HGrSystem, x0[i] + 3, 3 + i * 24, 14, 14,
 + j * 15, 85);
               x0[i] := x0[i] + (8 + 8 + 36);
+              J := AdvValue[HelpLineInfo.Picpix] div 1000;
+              DpiBitBltCanvas(OffScreen.Canvas, x0[I] + 4, 4 + I * 24, 14, 14,
+                HGrSystem.Mask.Canvas, 127 + J * 15, 85, SRCAND);
+              Sprite(OffScreen, HGrSystem, x0[I] + 3, 3 + I * 24, 14, 14,
++ J * 15, 85);
+              x0[I] := x0[I] + (8 + 8 + 36);
             end;
           pkRightIcon:
             begin
               if Imp[HelpLineInfo.Picpix].Kind <> ikWonder then
                 ImpImage(OffScreen.Canvas, InnerWidth - (40 + xSizeBig), i * 24,
+                ImpImage(OffScreen.Canvas, InnerWidth - (40 + xSizeBig), I * 24,
                   HelpLineInfo.Picpix, gDespotism)
               else
                 WaterSign(InnerWidth - (40 + 2 * xSizeBig), i * 24 - 8,
+                WaterSign(InnerWidth - (40 + 2 * xSizeBig), I * 24 - 8,
                   HelpLineInfo.Picpix + 7);
               x0[i] := x0[i] + 8;
+              x0[I] := x0[I] + 8;
             end;
           pkIllu:
             WaterSign(8, i * 24 - 8, HelpLineInfo.Picpix);
+            WaterSign(8, I * 24 - 8, HelpLineInfo.Picpix);
           pkBigFeature:
             begin
               cnt := 0;
               for j := nDomains - 1 downto 0 do
                 if 1 shl j and Feature[HelpLineInfo.Picpix].Domains <> 0 then
+              for J := nDomains - 1 downto 0 do
+                if 1 shl J and Feature[HelpLineInfo.Picpix].Domains <> 0 then
                 begin
                   inc(cnt);
+                  Inc(cnt);
                   Dump(OffScreen, HGrSystem, InnerWidth - 38 - 38 * cnt,
                     i * 24 + 1, 36, 20, 75 + j * 37, 295);
                   ScreenTools.Frame(OffScreen.Canvas, InnerWidth - 39 - 38 * cnt, i * 24,
                     InnerWidth - 2 - 38 * cnt, i * 24 + 21, $000000, $000000);
+                    I * 24 + 1, 36, 20, 75 + J * 37, 295);
+                  ScreenTools.Frame(OffScreen.Canvas, InnerWidth - 39 - 38 * cnt, I * 24,
+                    InnerWidth - 2 - 38 * cnt, I * 24 + 21, $000000, $000000);
                 end;
               DarkGradient(OffScreen.Canvas, InnerWidth - 38 - 38 * cnt,
                 i * 24 + 23, cnt * 38 - 2, 1);
+                I * 24 + 23, cnt * 38 - 2, 1);
               ofs := InnerWidth - (39 + 7) - 19 * cnt;
               with OffScreen.Canvas do
               begin
                 Brush.color := $C0C0C0;
                 FrameRect(Rect(ofs, 1 + 23 + i * 24, ofs + 14,
 + 23 + i * 24));
+                Brush.Color := $C0C0C0;
+                FrameRect(Rect(ofs, 1 + 23 + I * 24, ofs + 14,
++ 23 + I * 24));
                 Brush.Style := bsClear;
                 Sprite(OffScreen, HGrSystem, ofs + 2, 3 + 23 + i * 24, 10, 10,
+                Sprite(OffScreen, HGrSystem, ofs + 2, 3 + 23 + I * 24, 10, 10,
 + HelpLineInfo.Picpix mod 11 * 11,
 + HelpLineInfo.Picpix div 11 * 11);
               end;
               x0[i] := x0[i] + 8;
+              x0[I] := x0[I] + 8;
             end;
           pkTer, pkBigTer:
             with NoMap do begin
               if HelpLineInfo.Format = pkBigTer then
                 y := i * 24 - 3 + yyt
+                Y := I * 24 - 3 + yyt
               else
                 y := i * 24 + 13;
+                Y := I * 24 + 13;
               if HelpLineInfo.Picpix >= 3 * 12 then
                 srcno := 2 * 9 + 6
 …
               if HelpLineInfo.Format = pkTer then
               begin
                 ofs := x0[i] + 8;
                 x0[i] := 2 * xxt + 8 + ofs;
+                ofs := x0[I] + 8;
+                x0[I] := 2 * xxt + 8 + ofs;
               end
               else
               begin
                 ofs := InnerWidth - (2 * xxt + 38);
                 x0[i] := x0[i] + 8;
+                x0[I] := x0[I] + 8;
               end;
               if srcno >= fJungle then
               begin
                 Sprite(OffScreen, HGrTerrain, ofs + 4, y - yyt + 2, xxt * 2 - 8,
+                Sprite(OffScreen, HGrTerrain, ofs + 4, Y - yyt + 2, xxt * 2 - 8,
                   yyt * 2 - 4, 5 + 2 * (xxt * 2 + 1),
 + yyt + 2 * (yyt * 3 + 1));
                 Sprite(OffScreen, HGrTerrain, ofs, y - 2 * yyt, xxt * 2,
+                Sprite(OffScreen, HGrTerrain, ofs, Y - 2 * yyt, xxt * 2,
                   yyt * 3 - 2, 1 + srcno mod 9 * (xxt * 2 + 1),
 + srcno div 9 * (yyt * 3 + 1));
               end
               else
                 Sprite(OffScreen, HGrTerrain, ofs + 4, y - yyt + 2, xxt * 2 - 8,
+                Sprite(OffScreen, HGrTerrain, ofs + 4, Y - yyt + 2, xxt * 2 - 8,
                   yyt * 2 - 4, 5 + srcno mod 9 * (xxt * 2 + 1),
 + yyt + srcno div 9 * (yyt * 3 + 1));
               if HelpLineInfo.Picpix >= 3 * 12 then { rare resource }
                 Sprite(OffScreen, HGrTerrain, ofs, y - 2 * yyt, xxt * 2,
+                Sprite(OffScreen, HGrTerrain, ofs, Y - 2 * yyt, xxt * 2,
                   yyt * 3, 1 + 8 * (xxt * 2 + 1),
 + (HelpLineInfo.Picpix - 2 * 12) * (yyt * 3 + 1))
 …
                   srcno := 18 + 8 + (HelpLineInfo.Picpix mod 12 - 9) * 18;
                 srcno := srcno + HelpLineInfo.Picpix div 12 * 9;
                 Sprite(OffScreen, HGrTerrain, ofs, y - 2 * yyt, xxt * 2,
+                Sprite(OffScreen, HGrTerrain, ofs, Y - 2 * yyt, xxt * 2,
                   yyt * 3, 1 + srcno mod 9 * (xxt * 2 + 1),
 + srcno div 9 * (yyt * 3 + 1));
 …
               if HelpLineInfo.Picpix = 5 then
               begin // display mine on hills
                 Sprite(OffScreen, HGrTerrain, ofs + 4, i * 24 + 13 - yyt,
+                Sprite(OffScreen, HGrTerrain, ofs + 4, I * 24 + 13 - yyt,
                   xxt * 2 - 8, yyt * 2 - 4, 5 + 2 * (xxt * 2 + 1),
 + yyt + 2 * (yyt * 3 + 1));
 …
               else
                 srcno := fPrairie; // display on prairie
               Sprite(OffScreen, HGrTerrain, ofs + 4, i * 24 + 13 - yyt,
+              Sprite(OffScreen, HGrTerrain, ofs + 4, I * 24 + 13 - yyt,
                 xxt * 2 - 8, yyt * 2 - 4, 5 + srcno mod 9 * (xxt * 2 + 1),
 + yyt + srcno div 9 * (yyt * 3 + 1));
               if HelpLineInfo.Picpix = 12 then { river }
                 Sprite(OffScreen, HGrTerrain, ofs, i * 24 + 11 - yyt, xxt * 2,
+                Sprite(OffScreen, HGrTerrain, ofs, I * 24 + 11 - yyt, xxt * 2,
                   yyt * 2, 1 + 5 * (xxt * 2 + 1), 1 + yyt + 13 * (yyt * 3 + 1))
               else if HelpLineInfo.Picpix >= 3 then { improvement 2 }
               begin
                 if HelpLineInfo.Picpix = 6 then
                   Sprite(OffScreen, HGrTerrain, ofs, i * 24 + 11 - 2 * yyt,
+                  Sprite(OffScreen, HGrTerrain, ofs, I * 24 + 11 - 2 * yyt,
                     xxt * 2, yyt * 3, 1 + 7 * (xxt * 2 + 1),
 + 12 * (yyt * 3 + 1));
                 Sprite(OffScreen, HGrTerrain, ofs, i * 24 + 11 - 2 * yyt,
+                Sprite(OffScreen, HGrTerrain, ofs, I * 24 + 11 - 2 * yyt,
                   xxt * 2, yyt * 3, 1 + (HelpLineInfo.Picpix - 3) *
                   (xxt * 2 + 1), 1 + 12 * (yyt * 3 + 1))
 …
               else { improvement 1 }
               begin
                 Sprite(OffScreen, HGrTerrain, ofs, i * 24 + 11 - 2 * yyt,
+                Sprite(OffScreen, HGrTerrain, ofs, I * 24 + 11 - 2 * yyt,
                   xxt * 2, yyt * 3, 1 + 2 * (xxt * 2 + 1),
 + (9 + HelpLineInfo.Picpix) * (yyt * 3 + 1));
                 Sprite(OffScreen, HGrTerrain, ofs, i * 24 + 11 - 2 * yyt,
+                Sprite(OffScreen, HGrTerrain, ofs, I * 24 + 11 - 2 * yyt,
                   xxt * 2, yyt * 3, 1 + 5 * (xxt * 2 + 1),
 + (9 + HelpLineInfo.Picpix) * (yyt * 3 + 1))
               end;
               x0[i] := x0[i] + 8;
+              x0[I] := x0[I] + 8;
             end;
           pkModel:
             begin
               FrameImage(OffScreen.Canvas, BigImp, x0[i] + 12, i * 24 - 7,
+              FrameImage(OffScreen.Canvas, BigImp, x0[I] + 12, I * 24 - 7,
 , 40, 0, 0);
               Sprite(OffScreen, HGrStdUnits, x0[i] + 8, i * 24 - 11, 64, 44,
+              Sprite(OffScreen, HGrStdUnits, x0[I] + 8, I * 24 - 11, 64, 44,
 + HelpLineInfo.Picpix mod 10 * 65,
 + HelpLineInfo.Picpix div 10 * 49);
               x0[i] := 64 + 8 + 8 + x0[i];
+              x0[I] := 64 + 8 + 8 + x0[I];
             end;
           pkFeature:
             begin
               DarkGradient(OffScreen.Canvas, x0[i] + 8 - 1,
 + i * 24 - 3, 16, 1);
               ScreenTools.Frame(OffScreen.Canvas, x0[i] + 8, 7 + i * 24 - 2, x0[i] + 8 + 13,
 + i * 24 - 2 + 13, $C0C0C0, $C0C0C0);
               Sprite(OffScreen, HGrSystem, x0[i] + 8 + 2, 7 + i * 24, 10, 10,
+              DarkGradient(OffScreen.Canvas, x0[I] + 8 - 1,
++ I * 24 - 3, 16, 1);
+              ScreenTools.Frame(OffScreen.Canvas, x0[I] + 8, 7 + I * 24 - 2, x0[I] + 8 + 13,
++ I * 24 - 2 + 13, $C0C0C0, $C0C0C0);
+              Sprite(OffScreen, HGrSystem, x0[I] + 8 + 2, 7 + I * 24, 10, 10,
 + HelpLineInfo.Picpix mod 11 * 11,
 + HelpLineInfo.Picpix div 11 * 11);
               x0[i] := x0[i] + 8 + 8 + 2 + 13;
+              x0[I] := x0[I] + 8 + 8 + 2 + 13;
             end;
           pkExp:
             begin
               ScreenTools.Frame(OffScreen.Canvas, 20 - 1, 8 - 4 + i * 24, 20 + 12,
 + 11 + i * 24, $000000, $000000);
               Dump(OffScreen, HGrSystem, 20, 8 - 3 + i * 24, 12, 14,
+              ScreenTools.Frame(OffScreen.Canvas, 20 - 1, 8 - 4 + I * 24, 20 + 12,
++ 11 + I * 24, $000000, $000000);
+              Dump(OffScreen, HGrSystem, 20, 8 - 3 + I * 24, 12, 14,
 + HelpLineInfo.Picpix * 13, 28);
               x0[i] := 20 + 8 + 11;
+              x0[I] := 20 + 8 + 11;
             end;
           pkAITStat:
             begin
               Sprite(OffScreen, HGrSystem, 20, 6 + i * 24, 14, 14,
+              Sprite(OffScreen, HGrSystem, 20, 6 + I * 24, 14, 14,
 + HelpLineInfo.Picpix * 15, 316);
               x0[i] := 20 + 8 + 11;
+              x0[I] := 20 + 8 + 11;
             end;
           pkGov:
             begin
               ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[i], 2 - 1 + i * 24,
 + xSizeSmall + x0[i], 2 + 20 + i * 24, $000000, $000000);
               DpiBitCanvas(OffScreen.Canvas, 8 + x0[i], 2 + i * 24, xSizeSmall,
+              ScreenTools.Frame(OffScreen.Canvas, 8 - 1 + x0[I], 2 - 1 + I * 24,
++ xSizeSmall + x0[I], 2 + 20 + I * 24, $000000, $000000);
+              DpiBitBltCanvas(OffScreen.Canvas, 8 + x0[I], 2 + I * 24, xSizeSmall,
                 ySizeSmall, SmallImp.Canvas, (HelpLineInfo.Picpix - 1) *
                 xSizeSmall, ySizeSmall);
               x0[i] := x0[i] + (8 + 8 + 36);
+              x0[I] := x0[I] + (8 + 8 + 36);
             end;
           pkDot:
             begin
               Sprite(OffScreen, HGrSystem, x0[i] + 18, 9 + i * 24, 8,
+              Sprite(OffScreen, HGrSystem, x0[I] + 18, 9 + I * 24, 8,
 , 81, 16);
               x0[i] := 20 + 8 + 4;
+              x0[I] := 20 + 8 + 4;
             end;
           pkNormal_Dot:
             x0[i] := 20 + 8 + 4;
+            x0[I] := 20 + 8 + 4;
           pkNormal_64:
             x0[i] := 64 + 8 + 8;
+            x0[I] := 64 + 8 + 8;
         else
           x0[i] := x0[i] + 8;
+          x0[I] := x0[I] + 8;
         end;
         Self.Line(OffScreen.Canvas, i, False)
+        Self.Line(OffScreen.Canvas, I, False)
       end;
   end;
 …
 begin
   Sel := -1;
   SmartUpdateContent(true)
 end;
 procedure THelpDlg.Prepare(sbPos: integer = 0);
+  SmartUpdateContent(True);
+end;
+procedure THelpDlg.Prepare(sbPos: Integer = 0);
 var
   i, j, Special, Domain, Headline, TerrType, TerrSubType: integer;
   s: string;
   ps: pchar;
+  I, J, Special, Domain, Headline, TerrType, TerrSubType: Integer;
+  S: string;
+  ps: PChar;
   List: THyperText;
   CheckSeeAlso: Boolean;
   procedure AddAdvance(i: integer);
   begin
     MainText.AddLine(Phrases.Lookup('ADVANCES', i), pkAdvIcon, i,
       hkAdv + hkCrossLink, i);
   end;
   procedure AddPreqAdv(i: integer);
   begin
     MainText.AddLine(Phrases.Lookup('ADVANCES', i), pkAdvIcon_AsPreq, i,
       hkAdv + hkCrossLink, i);
   end;
   procedure AddImprovement(i: integer);
   begin
     MainText.AddLine(Phrases.Lookup('IMPROVEMENTS', i), pkSmallIcon, i,
       hkImp + hkCrossLink, i);
   end;
   procedure AddPreqImp(i: integer);
   begin
     MainText.AddLine(Phrases.Lookup('IMPROVEMENTS', i), pkSmallIcon_AsPreq, i,
       hkImp + hkCrossLink, i);
   end;
   procedure AddTerrain(i: integer);
+  procedure AddAdvance(I: Integer);
+  begin
+    MainText.AddLine(Phrases.Lookup('ADVANCES', I), pkAdvIcon, I,
+      hkAdv, I, True);
+  end;
+  procedure AddPreqAdv(I: Integer);
+  begin
+    MainText.AddLine(Phrases.Lookup('ADVANCES', I), pkAdvIcon_AsPreq, I,
+      hkAdv, I, True);
+  end;
+  procedure AddImprovement(I: Integer);
+  begin
+    MainText.AddLine(Phrases.Lookup('IMPROVEMENTS', I), pkSmallIcon, I,
+      hkImp, I, True);
+  end;
+  procedure AddPreqImp(I: Integer);
+  begin
+    MainText.AddLine(Phrases.Lookup('IMPROVEMENTS', I), pkSmallIcon_AsPreq, I,
+      hkImp, I, True);
+  end;
+  procedure AddTerrain(I: Integer);
   begin
     if MainText.Count > 1 then
 …
       MainText.LineFeed;
     end;
     MainText.AddLine(Phrases.Lookup('TERRAIN', i), pkTer, i, hkTer, i);
   end;
   procedure AddFeature(i: integer);
   begin
     MainText.AddLine(Phrases.Lookup('FEATURES', i), pkFeature, i,
       hkFeature + hkCrossLink, i);
   end;
   procedure AddModel(i: integer);
+    MainText.AddLine(Phrases.Lookup('TERRAIN', I), pkTer, I, hkTer, I);
+  end;
+  procedure AddFeature(I: Integer);
+  begin
+    MainText.AddLine(Phrases.Lookup('FEATURES', I), pkFeature, I,
+      hkFeature, I, True);
+  end;
+  procedure AddModel(I: Integer);
   var
     pix: integer;
+    pix: Integer;
     Name: string;
   begin
     if MainText.Count > 1 then
       MainText.LineFeed;
     FindStdModelPicture(SpecialModelPictureCode[i], pix, Name);
     MainText.AddLine(Name, pkModel, pix, hkModel + hkCrossLink, i)
+    FindStdModelPicture(SpecialModelPictureCode[I], pix, Name);
+    MainText.AddLine(Name, pkModel, pix, hkModel, I, True);
   end;
   procedure AddStandardBlock(Item: string);
   var
     i: integer;
+    I: Integer;
   begin
     with MainText do
 …
       else if Item = 'TECHFORMULA' then
       begin
         i := Difficulty;
         if i = 0 then
           i := 2;
         AddLine(Format(HelpText.Lookup('TECHFORMULA'), [TechFormula_M[i],
           TechFormula_D[i]]))
+        I := Difficulty;
+        if I = 0 then
+          I := 2;
+        AddLine(Format(HelpText.Lookup('TECHFORMULA'), [TechFormula_M[I],
+          TechFormula_D[I]]));
       end
       else if Item = 'EXPERIENCE' then
         for i := 0 to nExp - 1 do
           AddLine(Phrases.Lookup('EXPERIENCE', i), pkExp, i)
+        for I := 0 to nExp - 1 do
+          AddLine(Phrases.Lookup('EXPERIENCE', I), pkExp, I)
       else if Item = 'MODERN' then
         for i := 1 to 3 do
+        for I := 1 to 3 do
         begin
           LineFeed;
           AddLine(Phrases.Lookup('TERRAIN', 3 * 12 + i), pkTer, 3 * 12 + i);
+          AddLine(Phrases.Lookup('TERRAIN', 3 * 12 + I), pkTer, 3 * 12 + I);
         end
       else if Item = 'SAVED' then
         AddLine(DataDir + 'Saved', pkNormal)
       else if Item = 'AITSTAT' then
         for i := 0 to 3 do
           AddLine(Phrases2.Lookup('AITSTAT', i), pkAITStat, i)
     end
   end;
   procedure DecodeItem(s: string; var Category, Index: Integer);
+        for I := 0 to 3 do
+          AddLine(Phrases2.Lookup('AITSTAT', I), pkAITStat, I)
+    end;
+  end;
+  procedure DecodeItem(S: string; var Category: TLinkCategory; var Index: Integer);
   var
     i: Integer;
   begin
     if (Length(s) > 0) and (s[1] = ':') then begin
+    I: Integer;
+  begin
+    if (Length(S) > 0) and (S[1] = ':') then begin
       Category := hkMisc;
       Index := 0;
       for i := 3 to length(s) do
         Index := Index * 10 + Ord(s[i]) - 48;
       case s[2] of
+      for I := 3 to Length(S) do
+        Index := Index * 10 + Ord(S[I]) - 48;
+      case S[2] of
         'A': Category := hkAdv;
         'B': Category := hkImp;
 …
         'E': Category := hkInternet;
         'S': Category := hkModel;
         'C': Index := miscCredits;
         'J': Index := miscJobList;
         'G': Index := miscGovList;
+        'C': Index := Integer(miscCredits);
+        'J': Index := Integer(miscJobList);
+        'G': Index := Integer(miscGovList);
       end;
       if (Category <> hkMisc) and (Index = 0) then
 …
     end else begin
       Category := hkText;
       Index := HelpText.Gethandle(Copy(s, 1, 255));
+      Index := HelpText.GetHandle(Copy(S, 1, 255));
     end;
   end;
   procedure AddTextual(s: string);
+  procedure AddTextual(S: string);
   var
     i: Integer;
     p: Integer;
     l: Integer;
+    I: Integer;
+    P: Integer;
+    L: Integer;
     ofs: Integer;
     CurrentFormat: Integer;
     FollowFormat: Integer;
+    CurrentFormat: TTextFormat;
+    FollowFormat: TTextFormat;
     Picpix: Integer;
+    LinkCategory: Integer;
+    LinkCategory: TLinkCategory;
+    CrossLink: Boolean;
     LinkIndex: Integer;
     RightMargin: Integer;
 …
     Text: string;
   begin
+    CrossLink := False;
     RightMargin := InnerWidth - 16 - DpiGetSystemMetrics(SM_CXVSCROLL);
     FollowFormat := pkNormal;
     while s <> '' do
+    while S <> '' do
     begin
       Picpix := 0;
       LinkCategory := 0;
+      LinkCategory := hkNoLink;
       LinkIndex := 0;
       if s[1] = '$' then
       begin // window caption
         p := 1;
+      if S[1] = '$' then
+      begin // Window caption
+        P := 1;
         repeat
           inc(p)
         until (p > Length(s)) or (s[p] = '\');
         Caption := Copy(s, 2, p - 2);
         Delete(s, 1, p);
+          Inc(P);
+        until (P > Length(S)) or (S[P] = '\');
+        Caption := Copy(S, 2, P - 2);
+        Delete(S, 1, P);
       end
       else if s[1] = '&' then
       begin // standard block
         p := 1;
+      else if S[1] = '&' then
+      begin // Standard block
+        P := 1;
         repeat
           inc(p)
         until (p > Length(s)) or (s[p] = '\');
         AddStandardBlock(Copy(s, 2, p - 2));
         Delete(s, 1, p);
+          Inc(P);
+        until (P > Length(S)) or (S[P] = '\');
+        AddStandardBlock(Copy(S, 2, P - 2));
+        Delete(S, 1, P);
       end
       else if s[1] = '@' then
       begin // image
         if (Length(s) >= 2) and (s[2] = '@') then
         begin // generate from icon
+      else if S[1] = '@' then
+      begin // Image
+        if (Length(S) >= 2) and (S[2] = '@') then
+        begin // Generate from icon
           Picpix := 0;
           p := 3;
           while (p <= Length(s)) and (s[p] <> '\') do
+          P := 3;
+          while (P <= Length(S)) and (S[P] <> '\') do
           begin
             Picpix := Picpix * 10 + Ord(s[p]) - 48;
             inc(p)
+            Picpix := Picpix * 10 + Ord(S[P]) - 48;
+            Inc(P);
           end;
           if (Picpix < 0) or (Picpix >= nImp) then
 …
         else
         begin // external image
           p := 1;
+          P := 1;
           repeat
             Inc(p)
           until (p > Length(s)) or (s[p] = '\');
+            Inc(P);
+          until (P > Length(S)) or (S[P] = '\');
           if LoadGraphicFile(ExtPic, LocalizedFilePath('Help' +
             DirectorySeparator + Copy(s, 2, p - 2)) + '.png') then
+            DirectorySeparator + Copy(S, 2, P - 2)) + '.png') then
           begin
             MainText.AddLine('', pkExternal);
             for i := 0 to (ExtPic.Height - 12) div 24 do
+            for I := 0 to (ExtPic.Height - 12) div 24 do
               MainText.LineFeed;
           end;
         end;
         Delete(s, 1, p);
+        Delete(S, 1, P);
       end
       else
       begin
         case s[1] of
+        case S[1] of
           ':', ';':
             begin // link
               p := 1;
+              P := 1;
               repeat
                 inc(p)
               until (p > Length(s)) or (s[p] = '\') or (s[p] = ' ');
               DecodeItem(Copy(s, 2, p - 2), LinkCategory, LinkIndex);
               CurrentFormat := 0;
+                Inc(P);
+              until (P > Length(S)) or (S[P] = '\') or (S[P] = ' ');
+              DecodeItem(Copy(S, 2, P - 2), LinkCategory, LinkIndex);
+              CurrentFormat := pkNormal;
               if (LinkCategory <> hkText) and (LinkIndex < 200) then
               // show icon
 …
                     begin
                       CurrentFormat := pkAdvIcon;
                       Picpix := LinkIndex
+                      Picpix := LinkIndex;
                     end;
                   hkImp:
                     begin
                       CurrentFormat := pkSmallIcon;
                       Picpix := LinkIndex
+                      Picpix := LinkIndex;
                     end;
                   hkTer:
 …
                     begin
                       CurrentFormat := pkFeature;
                       Picpix := LinkIndex
+                      Picpix := LinkIndex;
                     end;
                   hkModel:
 …
                     end;
                 end;
               if s[1] = ':' then
                 LinkCategory := LinkCategory + hkCrossLink;
               if (p > Length(s)) or (s[p] = ' ') then
                 Delete(s, 1, p)
+              if S[1] = ':' then
+                CrossLink := True;
+              if (P > Length(S)) or (S[P] = ' ') then
+                Delete(S, 1, P)
               else
                 Delete(s, 1, p - 1)
             end;
           '!': // highlited
             if (Length(s) >= 2) and (s[2] = '!') then
+                Delete(S, 1, P - 1)
+            end;
+          '!': // highlighted
+            if (Length(S) >= 2) and (S[2] = '!') then
             begin
               if MainText.Count > 1 then
 …
               FollowFormat := pkCaption;
               CurrentFormat := pkCaption;
               Delete(s, 1, 2);
+              Delete(S, 1, 2);
             end
             else
 …
               FollowFormat := pkSection;
               CurrentFormat := pkSection;
               Delete(s, 1, 1);
+              Delete(S, 1, 1);
             end;
           '-':
 …
               FollowFormat := pkNormal_Dot;
               CurrentFormat := pkDot;
               Delete(s, 1, 1);
+              Delete(S, 1, 1);
             end;
         else
 …
         else
           ofs := 8;
         p := 0;
+        P := 0;
         repeat
           repeat
             Inc(p)
           until (p > Length(s)) or (s[p] = ' ') or (s[p] = '\');
           if (BiColorTextWidth(OffScreen.Canvas, Copy(s, 1, p - 1)) <=
+            Inc(P)
+          until (P > Length(S)) or (S[P] = ' ') or (S[P] = '\');
+          if (BiColorTextWidth(OffScreen.Canvas, Copy(S, 1, P - 1)) <=
             RightMargin - ofs) then
             l := p - 1
+            L := P - 1
           else
             Break;
         until (p >= Length(s)) or (s[l + 1] = '\');
         Text := Copy(s, 1, l);
         if LinkCategory and $3f = hkInternet then begin
+        until (P >= Length(S)) or (S[L + 1] = '\');
+        Text := Copy(S, 1, L);
+        if LinkCategory = hkInternet then begin
           if LinkIndex = 1 then Text := AITemplateManual
           else if LinkIndex = 2 then Text := CevoHomepageShort
 …
         end;
         MainText.AddLine(Text, CurrentFormat, Picpix, LinkCategory,
           LinkIndex);
         if (l < Length(s)) and (s[l + 1] = '\') then
+          LinkIndex, CrossLink);
+        if (L < Length(S)) and (S[L + 1] = '\') then
           FollowFormat := pkNormal;
         Delete(s, 1, l + 1);
       end
     end
+        Delete(S, 1, L + 1);
+      end;
+    end;
   end;
 …
   end;
   procedure AddModelText(i: Integer);
+  procedure AddModelText(I: Integer);
   var
     pix: Integer;
     s: string;
+    S: string;
   begin
     with MainText do begin
 …
         LineFeed;
       end;
       FindStdModelPicture(SpecialModelPictureCode[i], pix, s);
       AddLine(s, pkSection);
       AddLine(Format(HelpText.Lookup('STRENGTH'), [SpecialModel[i].Attack,
         SpecialModel[i].Defense]), pkNormal_64);
+      FindStdModelPicture(SpecialModelPictureCode[I], pix, S);
+      AddLine(S, pkSection);
+      AddLine(Format(HelpText.Lookup('STRENGTH'), [SpecialModel[I].Attack,
+        SpecialModel[I].Defense]), pkNormal_64);
       AddLine(Format(HelpText.Lookup('SPEED'),
         [MovementToString(SpecialModel[i].Speed)]), pkModel, pix);
+        [MovementToString(SpecialModel[I].Speed)]), pkModel, pix);
       if Difficulty = 0 then
         AddLine(Format(HelpText.Lookup('BUILDCOST'), [SpecialModel[i].Cost]),
+        AddLine(Format(HelpText.Lookup('BUILDCOST'), [SpecialModel[I].Cost]),
           pkNormal_64)
       else
         AddLine(Format(HelpText.Lookup('BUILDCOST'),
           [SpecialModel[i].Cost * BuildCostMod[Difficulty] div 12]),
+          [SpecialModel[I].Cost * BuildCostMod[Difficulty] div 12]),
           pkNormal_64);
       s := HelpText.LookupByHandle(hSPECIALMODEL, i);
       if (s <> '') and (s <> '*') then
         AddTextual(s);
       if SpecialModelPreq[i] >= 0 then
         AddPreqAdv(SpecialModelPreq[i])
       else if SpecialModelPreq[i] = preLighthouse then
+      S := HelpText.LookupByHandle(hSPECIALMODEL, I);
+      if (S <> '') and (S <> '*') then
+        AddTextual(S);
+      if SpecialModelPreq[I] >= 0 then
+        AddPreqAdv(SpecialModelPreq[I])
+      else if SpecialModelPreq[I] = preLighthouse then
         AddPreqImp(woLighthouse)
       else if SpecialModelPreq[i] = preBuilder then
+      else if SpecialModelPreq[I] = preBuilder then
         AddPreqImp(woPyramids)
       else if SpecialModelPreq[i] = preLeo then
+      else if SpecialModelPreq[I] = preLeo then
         AddPreqImp(woLeo);
       if SpecialModelPreq[i] <> preNone then
+      if SpecialModelPreq[I] <> preNone then
         MainText[Count - 1] := Format(HelpText.Lookup('REQUIRED'),
           [MainText[Count - 1]]);
 …
   procedure AddJobList;
   var
     i, JobCost: Integer;
+    I, JobCost: Integer;
   begin
     with MainText do begin
       for i := 0 to nJobHelp - 1 do begin
         if i > 0 then begin
+      for I := 0 to Length(JobHelp) - 1 do begin
+        if I > 0 then begin
           LineFeed;
           LineFeed;
         end;
         AddLine(Phrases.Lookup('JOBRESULT', JobHelp[i]), pkSection);
+        AddLine(Phrases.Lookup('JOBRESULT', JobHelp[I]), pkSection);
         AddLine;
         AddLine('', pkTerImp, i);
+        AddLine('', pkTerImp, I);
         AddLine;
         AddTextual(HelpText.LookupByHandle(hJOBHELP, i));
+        AddTextual(HelpText.LookupByHandle(hJOBHELP, I));
         JobCost := -1;
         case JobHelp[i] of
+        case JobHelp[I] of
           jCanal: JobCost := CanalWork;
           jFort: JobCost := FortWork;
 …
         else
           AddTextual(HelpText.Lookup('JOBCOSTVAR'));
         if JobPreq[JobHelp[i]] <> preNone then begin
           AddPreqAdv(JobPreq[JobHelp[i]]);
+        if JobPreq[JobHelp[I]] <> preNone then begin
+          AddPreqAdv(JobPreq[JobHelp[I]]);
           MainText[Count - 1] := Format(HelpText.Lookup('REQUIRED'),
             [MainText[Count - 1]]);
 …
   procedure AddGraphicCredits;
   var
     i: Integer;
     s: string;
+    I: Integer;
+    S: string;
     sr: TSearchRec;
     List, Plus: TStringList;
 …
     List.Sort;
     i := 1;
     while i < List.Count do
       if List[i] = List[i - 1] then
         List.Delete(i)
+    I := 1;
+    while I < List.Count do
+      if List[I] = List[I - 1] then
+        List.Delete(I)
       else
         Inc(i);
     for i := 0 to List.Count - 1 do begin
       s := List[i];
       while BiColorTextWidth(OffScreen.Canvas, s) > InnerWidth - 16 -
+        Inc(I);
+    for I := 0 to List.Count - 1 do begin
+      S := List[I];
+      while BiColorTextWidth(OffScreen.Canvas, S) > InnerWidth - 16 -
         DpiGetSystemMetrics(SM_CXVSCROLL) do
         Delete(s, length(s), 1);
       MainText.AddLine(s);
+        Delete(S, Length(S), 1);
+      MainText.AddLine(S);
     end;
     FreeAndNil(List);
 …
   procedure AddSoundCredits;
   var
     i: Integer;
     s: string;
+    I: Integer;
+    S: string;
     List: TStringList;
   begin
     List := TStringList.Create;
     List.LoadFromFile(GetSoundsDir + DirectorySeparator + 'sound.credits.txt');
     for i := 0 to List.Count - 1 do begin
       s := List[i];
       while BiColorTextWidth(OffScreen.Canvas, s) > InnerWidth - 16 -
+    for I := 0 to List.Count - 1 do begin
+      S := List[I];
+      while BiColorTextWidth(OffScreen.Canvas, S) > InnerWidth - 16 -
         DpiGetSystemMetrics(SM_CXVSCROLL) do
         Delete(s, length(s), 1);
       MainText.AddLine(s);
+        Delete(S, Length(S), 1);
+      MainText.AddLine(S);
     end;
     FreeAndNil(List);
 …
     Clear;
     Headline := -1;
     if (no >= 200) or not(Kind in [hkAdv, hkImp, hkTer, hkFeature]) then
+    if (No >= 200) or not (Kind in [hkAdv, hkImp, hkTer, hkFeature]) then
       LineFeed;
     case Kind of
       hkText:
         AddTextual(HelpText.LookupByHandle(no));
+        AddTextual(HelpText.LookupByHandle(No));
       hkMisc:
         begin
           case no of
             miscMain:
+          case No of
+            Integer(miscMain):
               begin
                 Caption := HelpText.Lookup('HELPTITLE_MAIN');
                 AddLine(HelpText.Lookup('HELPTITLE_QUICKSTART'), pkSpecialIcon,
 , { pkBigIcon,22, } hkText, HelpText.Gethandle('QUICK'));
+, { pkBigIcon,22, } hkText, HelpText.GetHandle('QUICK'));
                 LineFeed;
                 AddLine(HelpText.Lookup('HELPTITLE_CONCEPTS'), pkBigIcon, 6,
 …
                 LineFeed;
                 AddLine(HelpText.Lookup('HELPTITLE_JOBLIST'), pkSpecialIcon, 2,
                   hkMisc, miscJobList);
+                  hkMisc, Integer(miscJobList));
                 LineFeed;
                 AddLine(HelpText.Lookup('HELPTITLE_TECHLIST'), pkBigIcon, 39,
                   hkAdv, 200);
                 LineFeed;
                 FindStdModelPicture(SpecialModelPictureCode[6], i, s);
                 AddLine(HelpText.Lookup('HELPTITLE_MODELLIST'), pkModel, i,
+                FindStdModelPicture(SpecialModelPictureCode[6], I, S);
+                AddLine(HelpText.Lookup('HELPTITLE_MODELLIST'), pkModel, I,
                   hkModel, 0);
                 LineFeed;
 …
                 LineFeed;
                 AddLine(HelpText.Lookup('HELPTITLE_GOVLIST'), pkBigIcon,
                   gDemocracy + 6, hkMisc, miscGovList);
+                  gDemocracy + 6, hkMisc, Integer(miscGovList));
                 LineFeed;
                 AddLine(HelpText.Lookup('HELPTITLE_KEYS'), pkBigIcon, 2, hkText,
 …
                 LineFeed;
                 AddLine(HelpText.Lookup('HELPTITLE_CREDITS'), pkBigIcon, 22,
                   hkMisc, miscCredits);
+                  hkMisc, Integer(miscCredits));
               end;
             miscCredits:
+            Integer(miscCredits):
               begin
                 AddItem('CREDITS');
 …
                 AddItem('AUTHOR');
               end;
             miscJobList:
+            Integer(miscJobList):
               begin
                 Caption := HelpText.Lookup('HELPTITLE_JOBLIST');
 …
                 AddItem('TERIMPCITY');
               end;
             miscGovList:
+            Integer(miscGovList):
               begin
                 Caption := HelpText.Lookup('HELPTITLE_GOVLIST');
                 for i := 1 to nGov do
+                for I := 1 to nGov do
                 begin
                   AddLine(Phrases.Lookup('GOVERNMENT', i mod nGov), pkSection);
+                  AddLine(Phrases.Lookup('GOVERNMENT', I mod nGov), pkSection);
                   LineFeed;
                   if i = nGov then
+                  if I = nGov then
                     AddLine('', pkBigIcon, 7 * SystemIconLines + imPalace)
                   else
                     AddLine('', pkBigIcon, i + 6);
+                    AddLine('', pkBigIcon, I + 6);
                   LineFeed;
                   AddTextual(HelpText.LookupByHandle(hGOVHELP, i mod nGov));
                   if i mod nGov >= 2 then
+                  AddTextual(HelpText.LookupByHandle(hGOVHELP, I mod nGov));
+                  if I mod nGov >= 2 then
                   begin
                     AddPreqAdv(GovPreq[i mod nGov]);
+                    AddPreqAdv(GovPreq[I mod nGov]);
                     MainText[Count - 1] := Format(HelpText.Lookup('REQUIRED'),
                       [MainText[Count - 1]]);
                   end;
                   if i < nGov then
+                  if I < nGov then
                   begin
                     LineFeed;
 …
                 end;
               end;
             miscSearchResult:
+            Integer(miscSearchResult):
               begin
                 Caption := HelpText.Lookup('HELPTITLE_SEARCHRESULTS');
 …
                 MainText.AppendList(SearchResult);
               end;
           end; // case no
+          end; // case No
         end;
       hkAdv:
         if no = 200 then
+        if No = 200 then
         begin // complete advance list
           Caption := HelpText.Lookup('HELPTITLE_TECHLIST');
           List := THyperText.Create;
           List.OwnsObjects := True;
           for j := 0 to 3 do
+          for J := 0 to 3 do
           begin
             if j > 0 then
+            if J > 0 then
             begin
               LineFeed;
               LineFeed;
             end;
             AddLine(HelpText.Lookup('TECHAGE', j), pkSection);
             if j = 1 then
+            AddLine(HelpText.Lookup('TECHAGE', J), pkSection);
+            if J = 1 then
               AddLine(Phrases.Lookup('ADVANCES', adScience) + ' ' +
                 HelpText.Lookup('BASETECH'), pkAdvIcon, adScience, hkAdv,
                 adScience);
             if j = 2 then
+            if J = 2 then
               AddLine(Phrases.Lookup('ADVANCES', adMassProduction) + ' ' +
                 HelpText.Lookup('BASETECH'), pkAdvIcon, adMassProduction, hkAdv,
                 adMassProduction);
             List.Clear;
             for i := 0 to nAdv - 1 do
               if (i <> adScience) and (i <> adMassProduction) and
                 (AdvValue[i] div 1000 = j) then
                 List.AddLine(Phrases.Lookup('ADVANCES', i), pkAdvIcon, i,
                   hkAdv, i);
+            for I := 0 to nAdv - 1 do
+              if (I <> adScience) and (I <> adMassProduction) and
+                (AdvValue[I] div 1000 = J) then
+                List.AddLine(Phrases.Lookup('ADVANCES', I), pkAdvIcon, I,
+                  hkAdv, I);
             List.Sort;
             AppendList(List);
 …
         else // single advance
         begin
           Caption := Phrases.Lookup('ADVANCES', no);
+          Caption := Phrases.Lookup('ADVANCES', No);
           LineFeed;
           AddLine(Phrases.Lookup('ADVANCES', no), pkCaption);
           if no in FutureTech then
+          AddLine(Phrases.Lookup('ADVANCES', No), pkCaption);
+          if No in FutureTech then
           begin
             AddLine(HelpText.Lookup('HELPSPEC_FUTURE'));
             LineFeed;
             if no = futResearchTechnology then
+            if No = futResearchTechnology then
               AddItem('FUTURETECHHELP100')
             else
 …
           else
             AddLine(HelpText.Lookup('HELPSPEC_ADV'));
           if AdvPreq[no, 2] <> preNone then
+          if AdvPreq[No, 2] <> preNone then
             NextSection('PREREQALT')
           else
             NextSection('PREREQ');
           for i := 0 to 2 do
             if AdvPreq[no, i] <> preNone then
               AddPreqAdv(AdvPreq[no, i]);
+          for I := 0 to 2 do
+            if AdvPreq[No, I] <> preNone then
+              AddPreqAdv(AdvPreq[No, I]);
           NextSection('GOVALLOW');
           for i := 2 to nGov - 1 do
             if GovPreq[i] = no then
               AddLine(Phrases.Lookup('GOVERNMENT', i), pkGov, i,
                 hkMisc + hkCrossLink, miscGovList);
+          for I := 2 to nGov - 1 do
+            if GovPreq[I] = No then
+              AddLine(Phrases.Lookup('GOVERNMENT', I), pkGov, I,
+                hkMisc, Integer(miscGovList), True);
           NextSection('BUILDALLOW');
           for i := 0 to nWonder - 1 do
             if Imp[i].Preq = no then
               AddImprovement(i);
           for i := nWonder to nImp - 1 do
             if (Imp[i].Preq = no) and (Imp[i].Kind <> ikCommon) then
               AddImprovement(i);
           for i := nWonder to nImp - 1 do
             if (Imp[i].Preq = no) and (Imp[i].Kind = ikCommon) then
               AddImprovement(i);
+          for I := 0 to nWonder - 1 do
+            if Imp[I].Preq = No then
+              AddImprovement(I);
+          for I := nWonder to nImp - 1 do
+            if (Imp[I].Preq = No) and (Imp[I].Kind <> ikCommon) then
+              AddImprovement(I);
+          for I := nWonder to nImp - 1 do
+            if (Imp[I].Preq = No) and (Imp[I].Kind = ikCommon) then
+              AddImprovement(I);
           NextSection('MODELALLOW');
           for i := 0 to nSpecialModel - 1 do
             if SpecialModelPreq[i] = no then
               AddModel(i);
+          for I := 0 to nSpecialModel - 1 do
+            if SpecialModelPreq[I] = No then
+              AddModel(I);
           NextSection('FEATALLOW');
           for i := 0 to nFeature - 1 do
             if Feature[i].Preq = no then
               AddFeature(i);
+          for I := 0 to nFeature - 1 do
+            if Feature[I].Preq = No then
+              AddFeature(I);
           NextSection('FOLLOWADV');
           for i := 0 to nAdv - 1 do
             if (AdvPreq[i, 0] = no) or (AdvPreq[i, 1] = no) or
               (AdvPreq[i, 2] = no) then
               AddAdvance(i);
+          for I := 0 to nAdv - 1 do
+            if (AdvPreq[I, 0] = No) or (AdvPreq[I, 1] = No) or
+              (AdvPreq[I, 2] = No) then
+              AddAdvance(I);
           NextSection('UPGRADEALLOW');
           for Domain := 0 to nDomains - 1 do
             for i := 1 to nUpgrade - 1 do
               if upgrade[Domain, i].Preq = no then
+            for I := 1 to nUpgrade - 1 do
+              if upgrade[Domain, I].Preq = No then
               begin
                 if upgrade[Domain, i].Strength > 0 then
+                if upgrade[Domain, I].Strength > 0 then
                   AddLine(Format(HelpText.Lookup('STRENGTHUP'),
                     [Phrases.Lookup('DOMAIN', Domain), upgrade[Domain,
                     i].Strength]), pkDomain, Domain);
                 if upgrade[Domain, i].Trans > 0 then
+                    I].Strength]), pkDomain, Domain);
+                if upgrade[Domain, I].Trans > 0 then
                   AddLine(Format(HelpText.Lookup('TRANSUP'),
                     [Phrases.Lookup('DOMAIN', Domain), upgrade[Domain, i].Trans]
+                    [Phrases.Lookup('DOMAIN', Domain), upgrade[Domain, I].Trans]
                     ), pkDomain, Domain);
                 if no in FutureTech then
+                if No in FutureTech then
                   AddLine(Format(HelpText.Lookup('COSTUP'),
                     [upgrade[Domain, i].Cost]), pkNormal_Dot)
+                    [upgrade[Domain, I].Cost]), pkNormal_Dot)
                 else
                   AddLine(Format(HelpText.Lookup('COSTMIN'),
                     [upgrade[Domain, i].Cost]), pkNormal_Dot)
+                    [upgrade[Domain, I].Cost]), pkNormal_Dot)
               end;
           NextSection('EXPIRATION');
           for i := 0 to nWonder - 1 do
             if (Imp[i].Preq <> preNA) and (Imp[i].Expiration = no) then
               AddImprovement(i);
+          for I := 0 to nWonder - 1 do
+            if (Imp[I].Preq <> preNA) and (Imp[I].Expiration = No) then
+              AddImprovement(I);
           NextSection('ADVEFFECT');
           s := HelpText.LookupByHandle(hADVHELP, no);
           if s <> '*' then
             AddTextual(s);
+          S := HelpText.LookupByHandle(hADVHELP, No);
+          if S <> '*' then
+            AddTextual(S);
           NextSection('SEEALSO');
           CheckSeeAlso := true
+          CheckSeeAlso := True;
         end;
       hkImp:
         if no = 200 then
+        if No = 200 then
         begin // complete city improvement list
           Caption := HelpText.Lookup('HELPTITLE_IMPLIST');
 …
           List := THyperText.Create;
           List.OwnsObjects := True;
           for i := nWonder to nImp - 1 do
             if (i <> imTrGoods) and (Imp[i].Preq <> preNA) and
               (Imp[i].Kind = ikCommon) then
               List.AddLine(Phrases.Lookup('IMPROVEMENTS', i), pkSmallIcon,
                 i, hkImp, i);
+          for I := nWonder to nImp - 1 do
+            if (I <> imTrGoods) and (Imp[I].Preq <> preNA) and
+              (Imp[I].Kind = ikCommon) then
+              List.AddLine(Phrases.Lookup('IMPROVEMENTS', I), pkSmallIcon,
+                I, hkImp, I);
           List.Sort;
           AppendList(List);
           FreeAndNil(List);
         end
         else if no = 201 then
+        else if No = 201 then
         begin // complete nat. project list
           Caption := HelpText.Lookup('HELPTITLE_UNIQUELIST');
           // AddLine(HelpText.Lookup('HELPTITLE_UNIQUELIST'),pkSection);
           for i := nWonder to nImp - 1 do
             if (Imp[i].Preq <> preNA) and
               ((Imp[i].Kind = ikNatLocal) or (Imp[i].Kind = ikNatGlobal)) then
               AddLine(Phrases.Lookup('IMPROVEMENTS', i), pkSmallIcon, i,
                 hkImp, i);
+          for I := nWonder to nImp - 1 do
+            if (Imp[I].Preq <> preNA) and
+              ((Imp[I].Kind = ikNatLocal) or (Imp[I].Kind = ikNatGlobal)) then
+              AddLine(Phrases.Lookup('IMPROVEMENTS', I), pkSmallIcon, I,
+                hkImp, I);
           { LineFeed;
             LineFeed;
             AddLine(HelpText.Lookup('HELPTITLE_SHIPPARTLIST'),pkSection);
             for i:= nWonder to nImp-1 do
             if (Imp[i].Preq<>preNA) and (Imp[i].Kind=ikShipPart) then
             AddLine(Phrases.Lookup('IMPROVEMENTS',i),pkSmallIcon,i,hkImp,i); }
+            for I:= nWonder to nImp-1 do
+            if (Imp[I].Preq<>preNA) and (Imp[I].Kind=ikShipPart) then
+            AddLine(Phrases.Lookup('IMPROVEMENTS',I),pkSmallIcon,I,hkImp,I); }
         end
         else if no = 202 then
+        else if No = 202 then
         begin // complete wonder list
           Caption := HelpText.Lookup('HELPTITLE_WONDERLIST');
           // AddLine(HelpText.Lookup('HELPTITLE_WONDERLIST'),pkSection);
           for i := 0 to nWonder - 1 do
             if Imp[i].Preq <> preNA then
               AddLine(Phrases.Lookup('IMPROVEMENTS', i), pkSmallIcon, i,
                 hkImp, i);
+          for I := 0 to nWonder - 1 do
+            if Imp[I].Preq <> preNA then
+              AddLine(Phrases.Lookup('IMPROVEMENTS', I), pkSmallIcon, I,
+                hkImp, I);
         end
         else
         begin // single building
           Caption := Phrases.Lookup('IMPROVEMENTS', no);
+          Caption := Phrases.Lookup('IMPROVEMENTS', No);
           LineFeed;
           AddLine(Phrases.Lookup('IMPROVEMENTS', no), pkRightIcon, no);
           case Imp[no].Kind of
+          AddLine(Phrases.Lookup('IMPROVEMENTS', No), pkRightIcon, No);
+          case Imp[No].Kind of
             ikWonder: AddLine(HelpText.Lookup('HELPSPEC_WONDER'));
             ikCommon: AddLine(HelpText.Lookup('HELPSPEC_IMP'));
 …
             AddLine(HelpText.Lookup('HELPSPEC_NAT'))
           end;
           if Imp[no].Kind <> ikShipPart then begin
+          if Imp[No].Kind <> ikShipPart then begin
             NextSection('EFFECT');
             AddTextual(HelpText.LookupByHandle(hIMPHELP, no));
+            AddTextual(HelpText.LookupByHandle(hIMPHELP, No));
           end;
           if no = woSun then begin
+          if No = woSun then begin
             AddFeature(mcFirst);
             AddFeature(mcWill);
             AddFeature(mcAcademy);
           end;
           if (no < nWonder) and not Phrases2FallenBackToEnglish then
+          if (No < nWonder) and not Phrases2FallenBackToEnglish then
           begin
             LineFeed;
             if Imp[no].Expiration >= 0 then
+            if Imp[No].Expiration >= 0 then
               AddTextual(Phrases2.Lookup('HELP_WONDERMORALE1'))
             else
               AddTextual(Phrases2.Lookup('HELP_WONDERMORALE2'));
           end;
           if Imp[no].Preq <> preNone then
+          if Imp[No].Preq <> preNone then
           begin
             NextSection('PREREQ');
             AddPreqAdv(Imp[no].Preq);
+            AddPreqAdv(Imp[No].Preq);
           end;
           NextSection('COSTS');
           if Difficulty = 0 then
             s := Format(HelpText.Lookup('BUILDCOST'), [Imp[no].Cost])
+            S := Format(HelpText.Lookup('BUILDCOST'), [Imp[No].Cost])
           else
             s := Format(HelpText.Lookup('BUILDCOST'),
               [Imp[no].Cost * BuildCostMod[Difficulty] div 12]);
           AddLine(s);
           if Imp[no].Maint > 0 then
             AddLine(Format(HelpText.Lookup('MAINTCOST'), [Imp[no].Maint]));
           j := 0;
           for i := 0 to nImpReplacement - 1 do
             if ImpReplacement[i].NewImp = no then
             begin
               if j = 0 then
+            S := Format(HelpText.Lookup('BUILDCOST'),
+              [Imp[No].Cost * BuildCostMod[Difficulty] div 12]);
+          AddLine(S);
+          if Imp[No].Maint > 0 then
+            AddLine(Format(HelpText.Lookup('MAINTCOST'), [Imp[No].Maint]));
+          J := 0;
+          for I := 0 to nImpReplacement - 1 do
+            if ImpReplacement[I].NewImp = No then
+            begin
+              if J = 0 then
               begin
                 NextSection('REPLACE');
                 AddItem('REPLACETEXT');
                 j := 1;
+                J := 1;
               end;
               AddImprovement(ImpReplacement[i].OldImp);
             end;
           if Imp[no].Kind = ikShipPart then
+              AddImprovement(ImpReplacement[I].OldImp);
+            end;
+          if Imp[No].Kind = ikShipPart then
           begin
             LineFeed;
             if no = imShipComp then
               i := 1
             else if no = imShipPow then
               i := 2
             else { if no=imShipHab then }
               i := 3;
+            if No = imShipComp then
+              I := 1
+            else if No = imShipPow then
+              I := 2
+            else { if No=imShipHab then }
+              I := 3;
             AddLine(Format(HelpText.Lookup('RAREREQUIRED'),
               [Phrases.Lookup('TERRAIN', 3 * 12 + i)]), pkTer, 3 * 12 + i);
+              [Phrases.Lookup('TERRAIN', 3 * 12 + I)]), pkTer, 3 * 12 + I);
           end;
           if (no < nWonder) and (Imp[no].Expiration >= 0) then
+          if (No < nWonder) and (Imp[No].Expiration >= 0) then
           begin
             NextSection('EXPIRATION');
             s := Format(HelpText.Lookup('EXPWITH'),
               [Phrases.Lookup('ADVANCES', Imp[no].Expiration)]);
             if no = woPyramids then
               s := s + ' ' + HelpText.Lookup('EXPSLAVE');
             AddTextual(s);
+            S := Format(HelpText.Lookup('EXPWITH'),
+              [Phrases.Lookup('ADVANCES', Imp[No].Expiration)]);
+            if No = woPyramids then
+              S := S + ' ' + HelpText.Lookup('EXPSLAVE');
+            AddTextual(S);
           end;
           NextSection('SEEALSO');
           if (no < nWonder) and (Imp[no].Expiration >= 0) then
+          if (No < nWonder) and (Imp[No].Expiration >= 0) then
             AddImprovement(woEiffel);
           for i := 0 to nImpReplacement - 1 do
             if ImpReplacement[i].OldImp = no then
               AddImprovement(ImpReplacement[i].NewImp);
           if no = imSupermarket then
+          for I := 0 to nImpReplacement - 1 do
+            if ImpReplacement[I].OldImp = No then
+              AddImprovement(ImpReplacement[I].NewImp);
+          if No = imSupermarket then
             AddLine(HelpText.Lookup('HELPTITLE_JOBLIST'), pkNormal, 0,
               hkMisc + hkCrossLink, miscJobList);
           CheckSeeAlso := true;
+              hkMisc, Integer(miscJobList), True);
+          CheckSeeAlso := True;
         end;
       hkTer:
         if no = 200 then
+        if No = 200 then
         begin // complete terrain type list
           Caption := HelpText.Lookup('HELPTITLE_TERLIST');
           // AddLine(HelpText.Lookup('HELPTITLE_TERLIST'),pkSection);
           for i := 0 to nTerrainHelp - 1 do
             AddTerrain(TerrainHelp[i]);
+          for I := 0 to Length(TerrainHelp) - 1 do
+            AddTerrain(TerrainHelp[I]);
         end
         else
         begin // sigle terrain type
           TerrType := no mod 12;
+          TerrType := No mod 12;
           if TerrType = fJungle then
             TerrType := fForest;
           TerrSubType := no div 12;
           if no = 3 * 12 then
+          TerrSubType := No div 12;
+          if No = 3 * 12 then
           begin
             TerrType := fDesert;
 …
           with Terrain[TerrType] do
           begin
             Caption := Phrases.Lookup('TERRAIN', no);
+            Caption := Phrases.Lookup('TERRAIN', No);
             LineFeed;
             AddLine(Phrases.Lookup('TERRAIN', no), pkBigTer, no);
+            AddLine(Phrases.Lookup('TERRAIN', No), pkBigTer, No);
             AddLine(HelpText.Lookup('HELPSPEC_TER'));
             LineFeed;
 …
               AddLine(Format(HelpText.Lookup('RESPROD'),
                 [ProdRes[TerrSubType]]));
             if (no < 3 * 12) and (MineEff > 0) then
+            if (No < 3 * 12) and (MineEff > 0) then
               MainText[Count - 1] := MainText[Count - 1] + ' ' +
                 Format(HelpText.Lookup('MOREMINE'), [MineEff]);
 …
               AddLine(Format(HelpText.Lookup('RESFOOD'),
                 [FoodRes[TerrSubType]]));
             if (no < 3 * 12) and (IrrEff > 0) then
+            if (No < 3 * 12) and (IrrEff > 0) then
               MainText[Count - 1] := MainText[Count - 1] + ' ' +
                 Format(HelpText.Lookup('MOREIRR'), [IrrEff]);
 …
               else
                 AddLine(HelpText.Lookup('MOVEPLAIN'));
             if no = 3 * 12 then
+            if No = 3 * 12 then
             begin
               LineFeed;
               AddTextual(HelpText.Lookup('DEADLANDS'));
             end;
             if (TerrType = fDesert) and (no <> fDesert + 12) then
+            if (TerrType = fDesert) and (No <> fDesert + 12) then
             begin
               LineFeed;
 …
               AddTextual(Format(HelpText.Lookup('HOSTILE'), [ArcticThurst]));
             end;
             if (no < 3 * 12) and (TransTerrain >= 0) then
+            if (No < 3 * 12) and (TransTerrain >= 0) then
             begin
               LineFeed;
               i := TransTerrain;
               if (TerrType <> fGrass) and (i <> fGrass) then
                 i := i + TerrSubType * 12;
+              I := TransTerrain;
+              if (TerrType <> fGrass) and (I <> fGrass) then
+                I := I + TerrSubType * 12;
               // trafo to same Special resource group
               AddLine(Format(HelpText.Lookup('TRAFO'),
                 [Phrases.Lookup('TERRAIN', i)]), pkTer, i,
                 hkTer + hkCrossLink, i);
               if no = fSwamp + 12 then
+                [Phrases.Lookup('TERRAIN', I)]), pkTer, I,
+                hkTer, I, True);
+              if No = fSwamp + 12 then
               begin
                 LineFeed;
                 AddLine(Format(HelpText.Lookup('TRAFO'),
                   [Phrases.Lookup('TERRAIN', TransTerrain + 24)]), pkTer,
                   TransTerrain + 24, hkTer + hkCrossLink, TransTerrain + 24);
+                  TransTerrain + 24, hkTer, TransTerrain + 24, True);
               end
               else if i = fGrass then
+              else if I = fGrass then
               begin
                 LineFeed;
                 AddLine(Format(HelpText.Lookup('TRAFO'),
                   [Phrases.Lookup('TERRAIN', fGrass + 12)]), pkTer, fGrass + 12,
                   hkTer + hkCrossLink, fGrass + 12);
+                  hkTer, fGrass + 12, True);
               end;
             end;
             NextSection('SPECIAL');
             if no = 3 * 12 then
+            if No = 3 * 12 then
             begin
               LineFeed;
 …
               end;
             end
             else if (no < 12) and (no <> fGrass) and (no <> fOcean) then
+            else if (No < 12) and (No <> fGrass) and (No <> fOcean) then
             begin
               LineFeed;
               for Special := 1 to 2 do
                 if (no <> fArctic) and (no <> fSwamp) or (Special < 2) then
+                if (No <> fArctic) and (No <> fSwamp) or (Special < 2) then
                 begin
                   if Special > 1 then
                     LineFeed;
                   AddLine(Phrases.Lookup('TERRAIN', no + Special * 12), pkTer,
                     no + Special * 12);
                   i := FoodRes[Special] - FoodRes[0];
                   if i <> 0 then
+                  AddLine(Phrases.Lookup('TERRAIN', No + Special * 12), pkTer,
+                    No + Special * 12);
+                  I := FoodRes[Special] - FoodRes[0];
+                  if I <> 0 then
                     MainText[Count - 1] := MainText[Count - 1] +
                       Format(HelpText.Lookup('SPECIALFOOD'), [i]);
                   i := ProdRes[Special] - ProdRes[0];
                   if i <> 0 then
+                      Format(HelpText.Lookup('SPECIALFOOD'), [I]);
+                  I := ProdRes[Special] - ProdRes[0];
+                  if I <> 0 then
                     MainText[Count - 1] := MainText[Count - 1] +
                       Format(HelpText.Lookup('SPECIALPROD'), [i]);
                   i := TradeRes[Special] - TradeRes[0];
                   if i <> 0 then
+                      Format(HelpText.Lookup('SPECIALPROD'), [I]);
+                  I := TradeRes[Special] - TradeRes[0];
+                  if I <> 0 then
                     MainText[Count - 1] := MainText[Count - 1] +
                       Format(HelpText.Lookup('SPECIALTRADE'), [i]);
+                      Format(HelpText.Lookup('SPECIALTRADE'), [I]);
                 end;
             end;
             if no = 3 * 12 then
+            if No = 3 * 12 then
             begin
               LineFeed;
               AddTextual(HelpText.Lookup('RARE'));
             end;
             if (no < 3 * 12) and (TerrType in [fDesert, fArctic]) then
+            if (No < 3 * 12) and (TerrType in [fDesert, fArctic]) then
             begin
               NextSection('SEEALSO');
               AddImprovement(woGardens);
               CheckSeeAlso := true
+              CheckSeeAlso := True;
             end;
           end;
 …
       hkFeature:
         if no = 200 then
+        if No = 200 then
         begin // complete feature list
           Caption := HelpText.Lookup('HELPTITLE_FEATURELIST');
 …
             end;
             List.Clear;
             for i := 0 to nFeature - 1 do
               if Feature[i].Preq <> preNA then
+            for I := 0 to nFeature - 1 do
+              if Feature[I].Preq <> preNA then
               begin
                 if i < mcFirstNonCap then
                   j := 0
                 else if i in AutoFeature then
                   j := 2
+                if I < mcFirstNonCap then
+                  J := 0
+                else if I in AutoFeature then
+                  J := 2
                 else
                   j := 1;
                 if j = Special then
                   List.AddLine(Phrases.Lookup('FEATURES', i), pkFeature, i,
                     hkFeature, i);
+                  J := 1;
+                if J = Special then
+                  List.AddLine(Phrases.Lookup('FEATURES', I), pkFeature, I,
+                    hkFeature, I);
               end;
             List.Sort;
 …
         else
         begin // single feature
           Caption := Phrases.Lookup('FEATURES', no);
+          Caption := Phrases.Lookup('FEATURES', No);
           LineFeed;
           AddLine(Phrases.Lookup('FEATURES', no), pkBigFeature, no);
           if no < mcFirstNonCap then
+          AddLine(Phrases.Lookup('FEATURES', No), pkBigFeature, No);
+          if No < mcFirstNonCap then
             AddLine(HelpText.Lookup('HELPSPEC_CAP'))
           else if no in AutoFeature then
+          else if No in AutoFeature then
             AddLine(HelpText.Lookup('HELPSPEC_STANDARD'))
           else
             AddLine(HelpText.Lookup('HELPSPEC_FEATURE'));
           NextSection('EFFECT');
           AddTextual(HelpText.LookupByHandle(hFEATUREHELP, no));
           if (Feature[no].Weight <> 0) or (Feature[no].Cost <> 0) then
+          AddTextual(HelpText.LookupByHandle(hFEATUREHELP, No));
+          if (Feature[No].Weight <> 0) or (Feature[No].Cost <> 0) then
           begin
             NextSection('COSTS');
             s := IntToStr(Feature[no].Cost);
             if Feature[no].Cost >= 0 then
               s := '+' + s;
             AddLine(Format(HelpText.Lookup('COSTBASE'), [s]));
             if Feature[no].Weight > 0 then
+            S := IntToStr(Feature[No].Cost);
+            if Feature[No].Cost >= 0 then
+              S := '+' + S;
+            AddLine(Format(HelpText.Lookup('COSTBASE'), [S]));
+            if Feature[No].Weight > 0 then
             begin
               AddLine(Format(HelpText.Lookup('WEIGHT'),
                 ['+' + IntToStr(Feature[no].Weight)]));
               if no = mcDefense then
+                ['+' + IntToStr(Feature[No].Weight)]));
+              if No = mcDefense then
                 AddLine(Format(HelpText.Lookup('WEIGHT'), ['+2']),
                   pkDomain, dGround);
             end;
           end;
           if Feature[no].Preq <> preNone then
+          if Feature[No].Preq <> preNone then
           begin
             LineFeed;
             if Feature[no].Preq = preSun then
+            if Feature[No].Preq = preSun then
               AddPreqImp(woSun) // sun tsu feature
             else
               AddPreqAdv(Feature[no].Preq);
+              AddPreqAdv(Feature[No].Preq);
             MainText[Count - 1] := Format(HelpText.Lookup('REQUIRED'),
               [MainText[Count - 1]]);
 …
         begin
           Caption := HelpText.Lookup('HELPTITLE_MODELLIST');
           for i := 0 to nSpecialModel - 1 do
             if i <> 2 then
               AddModelText(i);
+          for I := 0 to nSpecialModel - 1 do
+            if I <> 2 then
+              AddModelText(I);
           LineFeed;
           AddItem('MODELNOTE');
 …
     end;
     if CheckSeeAlso then
       for i := 0 to nSeeAlso - 1 do
         if (SeeAlso[i].Kind = Kind) and (SeeAlso[i].no = no) then
           case SeeAlso[i].SeeKind of
             hkImp: AddImprovement(SeeAlso[i].SeeNo);
             hkAdv: AddAdvance(SeeAlso[i].SeeNo);
             hkFeature: AddFeature(SeeAlso[i].SeeNo);
+      for I := 0 to Length(SeeAlso) - 1 do
+        if (SeeAlso[I].Kind = Kind) and (SeeAlso[I].No = No) then
+          case SeeAlso[I].SeeKind of
+            hkImp: AddImprovement(SeeAlso[I].SeeNo);
+            hkAdv: AddAdvance(SeeAlso[I].SeeNo);
+            hkFeature: AddFeature(SeeAlso[I].SeeNo);
           end;
     if (Headline >= 0) and (Count = Headline + 1) then
 …
     ScrollBar.SetPos(sbPos);
     BackBtn.Visible := HistItems.Count > 1;
     TopBtn.Visible := (HistItems.Count > 1) or (Kind <> hkMisc) or (no <> miscMain);
+    TopBtn.Visible := (HistItems.Count > 1) or (Kind <> hkMisc) or (No <> Integer(miscMain));
     Sel := -1;
   end; // with MainText
 end;
+procedure THelpDlg.ShowNewContent(NewMode, Category, Index: Integer);
+begin
+  if (Category <> Kind) or (Index <> no) or (Category = hkMisc) and
+    (Index = miscSearchResult) then begin
+procedure THelpDlg.ShowNewContent(NewMode: TWindowMode; Category: TLinkCategory;
+  Index: Integer);
+begin
+  if (Category <> Kind) or (Index <> No) or (Category = hkMisc) and
+    (Index = Integer(miscSearchResult)) then begin
     if HistItems.Count = MaxHist then HistItems.Delete(0);
     if HistItems.Count = 0 then
 …
   end;
   Kind := Category;
   no := Index;
+  No := Index;
   SearchContent := NewSearchContent;
   Prepare;
 …
 procedure THelpDlg.PaintBox1MouseMove(Sender: TObject; Shift: TShiftState;
   x, y: integer);
+  X, Y: Integer);
 var
   i0, Sel0: Integer;
 begin
   y := y - WideFrame;
+  Y := Y - WideFrame;
   i0 := ScrollBar.Position;
   Sel0 := Sel;
   if (x >= SideFrame) and (x < SideFrame + InnerWidth) and (y >= 0) and
     (y < InnerHeight) and (y mod 24 >= 8) then
     Sel := y div 24
+  if (X >= SideFrame) and (X < SideFrame + InnerWidth) and (Y >= 0) and
+    (Y < InnerHeight) and (Y mod 24 >= 8) then
+    Sel := Y div 24
   else
     Sel := -1;
   if (Sel + i0 >= MainText.Count) or (Sel >= 0) and
+    (THelpLineInfo(MainText.Objects[Sel + i0]).Link = 0) then
+    (THelpLineInfo(MainText.Objects[Sel + i0]).Category = hkNoLink) and
+    (THelpLineInfo(MainText.Objects[Sel + i0]).Index = 0)then
     Sel := -1;
   if Sel <> Sel0 then
 …
 procedure THelpDlg.PaintBox1MouseDown(Sender: TObject; Button: TMouseButton;
   Shift: TShiftState; x, y: integer);
+  Shift: TShiftState; X, Y: Integer);
 begin
   if Sel >= 0 then
     with THelpLineInfo(MainText.Objects[Sel + ScrollBar.Position]) do
       if Link shr 8 and $3F = hkInternet then
         case Link and $FF of
+      if Category = hkInternet then
+        case Index of
 : OpenDocument(HomeDir + AITemplateFileName);
 : OpenURL(CevoHomepage);
 …
       else
       begin
+        if (Link >= $8000) and (Link and $3FFF = liInvalid) then
+          exit; // invalid link;
+        if Link >= $8000 then
+          ShowNewContent(FWindowMode, hkText, Link and $3FFF)
+        else
+          ShowNewContent(FWindowMode, Link shr 8 and $3F, Link and $FF);
+        if Index < 0 then Exit; // invalid link;
+        ShowNewContent(FWindowMode, Category, Index);
       end;
 end;
 …
     HistItem.Assign(HistItems.Last);
     HistItems.Delete(HistItems.Count - 1);
     if (HistItem.Kind = hkMisc) and (HistItem.No = miscSearchResult) and
+    if (HistItem.Kind = hkMisc) and (HistItem.No = Integer(miscSearchResult)) and
       (HistItem.SearchContent <> SearchContent) then
     begin
 …
     end;
     Kind := HistItem.Kind;
     no := HistItem.No;
+    No := HistItem.No;
     Prepare(HistItem.Pos);
     OffscreenPaint;
 …
   while HistItems.Count > 1 do HistItems.Delete(HistItems.Count - 1);
   Kind := hkMisc;
   no := miscMain;
+  No := Integer(miscMain);
   Prepare;
   OffscreenPaint;
 …
 function THelpDlg.TextIndex(Item: string): Integer;
 begin
   Result := HelpText.Gethandle(Item);
+  Result := HelpText.GetHandle(Item);
 end;
 …
 :
         with THelpLineInfo(SearchResult.Objects[0]) do
+          if Link >= $8000 then
+            ShowNewContent(FWindowMode, hkText, Link and $3FFF)
+          else
+            ShowNewContent(FWindowMode, Link shr 8 and $3F, Link and $FF);
+    else
+      begin
+          ShowNewContent(FWindowMode, Category, Index);
+      else begin
         NewSearchContent := InputDlg.EInput.Text;
         ShowNewContent(FWindowMode, hkMisc, miscSearchResult);
+        ShowNewContent(FWindowMode, hkMisc, Integer(miscSearchResult));
       end;
     end;
 …
 procedure THelpDlg.Search(SearchString: string);
 var
   h, i, PrevHandle, PrevIndex, p, RightMargin: Integer;
   s: string;
   mADVHELP, mIMPHELP, mFEATUREHELP: set of 0 .. 255;
+  H, I, PrevHandle, PrevIndex, P, RightMargin: Integer;
+  S: string;
+  mADVHELP, mIMPHELP, mFEATUREHELP: set of 0..255;
   bGOVHELP, bSPECIALMODEL, bJOBHELP: Boolean;
 begin
 …
   bJOBHELP := False;
   // search in generic reference
+  // Search in generic reference
   SearchString := UpperCase(SearchString);
   for i := 0 to 35 + 4 do begin
     s := Phrases.Lookup('TERRAIN', i);
     if pos(SearchString, UpperCase(s)) > 0 then
       if i < 36 then
         SearchResult.AddLine(s + ' ' + HelpText.Lookup('HELPSPEC_TER'),
           pkNormal, 0, hkTer + hkCrossLink, i)
+  for I := 0 to 35 + 4 do begin
+    S := Phrases.Lookup('TERRAIN', I);
+    if Pos(SearchString, UpperCase(S)) > 0 then
+      if I < 36 then
+        SearchResult.AddLine(S + ' ' + HelpText.Lookup('HELPSPEC_TER'),
+          pkNormal, 0, hkTer, I, True)
       else
       begin
         SearchResult.AddLine(Phrases.Lookup('TERRAIN', 36) + ' ' +
           HelpText.Lookup('HELPSPEC_TER'), pkNormal, 0,
           hkTer + hkCrossLink, 36);
         if i > 36 then
+          hkTer, 36, True);
+        if I > 36 then
           SearchResult.AddLine(Phrases.Lookup('IMPROVEMENTS',
             imShipComp + i - 37) + ' ' + HelpText.Lookup('HELPSPEC_SHIPPART'),
             pkNormal, 0, hkImp + hkCrossLink, imShipComp + i - 37);
+            imShipComp + I - 37) + ' ' + HelpText.Lookup('HELPSPEC_SHIPPART'),
+            pkNormal, 0, hkImp, imShipComp + I - 37, True);
         Break;
       end;
   end;
   for i := 0 to nJobHelp - 1 do
     if pos(SearchString, UpperCase(Phrases.Lookup('JOBRESULT', JobHelp[i]))) > 0
+  for I := 0 to Length(JobHelp) - 1 do
+    if Pos(SearchString, UpperCase(Phrases.Lookup('JOBRESULT', JobHelp[I]))) > 0
     then
     begin
       SearchResult.AddLine(HelpText.Lookup('HELPTITLE_JOBLIST'), pkNormal, 0,
         hkMisc + hkCrossLink, miscJobList);
+        hkMisc, Integer(miscJobList), True);
       bJOBHELP := True;
       Break;
     end;
   for i := 0 to nAdv - 1 do
   begin
     s := Phrases.Lookup('ADVANCES', i);
     if pos(SearchString, UpperCase(s)) > 0 then
+  for I := 0 to nAdv - 1 do
+  begin
+    S := Phrases.Lookup('ADVANCES', I);
+    if Pos(SearchString, UpperCase(S)) > 0 then
     begin
       if i in FutureTech then
         s := s + ' ' + HelpText.Lookup('HELPSPEC_FUTURE')
+      if I in FutureTech then
+        S := S + ' ' + HelpText.Lookup('HELPSPEC_FUTURE')
       else
         s := s + ' ' + HelpText.Lookup('HELPSPEC_ADV');
       SearchResult.AddLine(s, pkNormal, 0, hkAdv + hkCrossLink, i);
       include(mADVHELP, i);
+        S := S + ' ' + HelpText.Lookup('HELPSPEC_ADV');
+      SearchResult.AddLine(S, pkNormal, 0, hkAdv, I, True);
+      Include(mADVHELP, I);
     end;
   end;
   for i := 0 to nSpecialModel - 1 do
   begin
     FindStdModelPicture(SpecialModelPictureCode[i], h, s);
     if pos(SearchString, UpperCase(s)) > 0 then
+  for I := 0 to nSpecialModel - 1 do
+  begin
+    FindStdModelPicture(SpecialModelPictureCode[I], H, S);
+    if Pos(SearchString, UpperCase(S)) > 0 then
     begin
       SearchResult.AddLine(HelpText.Lookup('HELPTITLE_MODELLIST'), pkNormal, 0,
         hkModel + hkCrossLink, 0);
+        hkModel, 0, True);
       bSPECIALMODEL := True;
       Break;
     end;
   end;
   for i := 0 to nFeature - 1 do
   begin
     s := Phrases.Lookup('FEATURES', i);
     if Pos(SearchString, UpperCase(s)) > 0 then
+  for I := 0 to nFeature - 1 do
+  begin
+    S := Phrases.Lookup('FEATURES', I);
+    if Pos(SearchString, UpperCase(S)) > 0 then
     begin
       if i < mcFirstNonCap then
         s := s + ' ' + HelpText.Lookup('HELPSPEC_CAP')
       else if i in AutoFeature then
         s := s + ' ' + HelpText.Lookup('HELPSPEC_STANDARD')
+      if I < mcFirstNonCap then
+        S := S + ' ' + HelpText.Lookup('HELPSPEC_CAP')
+      else if I in AutoFeature then
+        S := S + ' ' + HelpText.Lookup('HELPSPEC_STANDARD')
       else
         s := s + ' ' + HelpText.Lookup('HELPSPEC_FEATURE');
       SearchResult.AddLine(s, pkNormal, 0, hkFeature + hkCrossLink, i);
       Include(mFEATUREHELP, i);
+        S := S + ' ' + HelpText.Lookup('HELPSPEC_FEATURE');
+      SearchResult.AddLine(S, pkNormal, 0, hkFeature, I, True);
+      Include(mFEATUREHELP, I);
     end;
   end;
   for i := 0 to nImp - 1 do
   begin
     s := Phrases.Lookup('IMPROVEMENTS', i);
     if Pos(SearchString, UpperCase(s)) > 0 then
+  for I := 0 to nImp - 1 do
+  begin
+    S := Phrases.Lookup('IMPROVEMENTS', I);
+    if Pos(SearchString, UpperCase(S)) > 0 then
     begin
       case Imp[i].Kind of
+      case Imp[I].Kind of
         ikWonder:
           s := s + ' ' + HelpText.Lookup('HELPSPEC_WONDER');
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_WONDER');
         ikCommon:
           s := s + ' ' + HelpText.Lookup('HELPSPEC_IMP');
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_IMP');
         ikShipPart:
           s := s + ' ' + HelpText.Lookup('HELPSPEC_SHIPPART');
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_SHIPPART');
       else
         s := s + ' ' + HelpText.Lookup('HELPSPEC_NAT')
+        S := S + ' ' + HelpText.Lookup('HELPSPEC_NAT')
       end;
       SearchResult.AddLine(s, pkNormal, 0, hkImp + hkCrossLink, i);
       Include(mIMPHELP, i);
+      SearchResult.AddLine(S, pkNormal, 0, hkImp, I, True);
+      Include(mIMPHELP, I);
     end
   end;
   for i := 0 to nGov - 1 do
     if Pos(SearchString, UpperCase(Phrases.Lookup('GOVERNMENT', i))) > 0 then
+  for I := 0 to nGov - 1 do
+    if Pos(SearchString, UpperCase(Phrases.Lookup('GOVERNMENT', I))) > 0 then
     begin
       SearchResult.AddLine(HelpText.Lookup('HELPTITLE_GOVLIST'), pkNormal, 0,
         hkMisc + hkCrossLink, miscGovList);
+        hkMisc, Integer(miscGovList), True);
       bGOVHELP := True;
       Break;
     end;
   // full text search
   h := -1;
+  // Full text search
+  H := -1;
   repeat
     PrevHandle := h;
     PrevIndex := i;
     if not HelpText.Search(SearchString, h, i) then
+    PrevHandle := H;
+    PrevIndex := I;
+    if not HelpText.Search(SearchString, H, I) then
       Break;
     if h = hADVHELP then
+    if H = hADVHELP then
     begin
       if (i >= 0) and ((i <> PrevIndex) or (h <> PrevHandle)) and
         not(i in mADVHELP) then
+      if (I >= 0) and ((I <> PrevIndex) or (H <> PrevHandle)) and
+        not(I in mADVHELP) then
       begin
         s := Phrases.Lookup('ADVANCES', i);
         if i in FutureTech then
           s := s + ' ' + HelpText.Lookup('HELPSPEC_FUTURE')
+        S := Phrases.Lookup('ADVANCES', I);
+        if I in FutureTech then
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_FUTURE')
         else
           s := s + ' ' + HelpText.Lookup('HELPSPEC_ADV');
         SearchResult.AddLine(s, pkNormal, 0, hkAdv + hkCrossLink, i)
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_ADV');
+        SearchResult.AddLine(S, pkNormal, 0, hkAdv, I, True);
       end;
     end
     else if h = hIMPHELP then
+    else if H = hIMPHELP then
     begin
       if (i >= 0) and ((i <> PrevIndex) or (h <> PrevHandle)) and
         not(i in mIMPHELP) then
+      if (I >= 0) and ((I <> PrevIndex) or (H <> PrevHandle)) and
+        not(I in mIMPHELP) then
       begin
         s := Phrases.Lookup('IMPROVEMENTS', i);
         case Imp[i].Kind of
+        S := Phrases.Lookup('IMPROVEMENTS', I);
+        case Imp[I].Kind of
           ikWonder:
             s := s + ' ' + HelpText.Lookup('HELPSPEC_WONDER');
+            S := S + ' ' + HelpText.Lookup('HELPSPEC_WONDER');
           ikCommon:
             s := s + ' ' + HelpText.Lookup('HELPSPEC_IMP');
+            S := S + ' ' + HelpText.Lookup('HELPSPEC_IMP');
           ikShipPart:
             s := s + ' ' + HelpText.Lookup('HELPSPEC_SHIPPART');
+            S := S + ' ' + HelpText.Lookup('HELPSPEC_SHIPPART');
         else
           s := s + ' ' + HelpText.Lookup('HELPSPEC_NAT')
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_NAT')
         end;
         SearchResult.AddLine(s, pkNormal, 0, hkImp + hkCrossLink, i)
+        SearchResult.AddLine(S, pkNormal, 0, hkImp, I, True);
       end;
     end
     else if h = hFEATUREHELP then
+    else if H = hFEATUREHELP then
     begin
       if (i >= 0) and ((i <> PrevIndex) or (h <> PrevHandle)) and
         not(i in mFEATUREHELP) then
+      if (I >= 0) and ((I <> PrevIndex) or (H <> PrevHandle)) and
+        not(I in mFEATUREHELP) then
       begin
         s := Phrases.Lookup('FEATURES', i);
         if i < mcFirstNonCap then
           s := s + ' ' + HelpText.Lookup('HELPSPEC_CAP')
         else if i in AutoFeature then
           s := s + ' ' + HelpText.Lookup('HELPSPEC_STANDARD')
+        S := Phrases.Lookup('FEATURES', I);
+        if I < mcFirstNonCap then
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_CAP')
+        else if I in AutoFeature then
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_STANDARD')
         else
           s := s + ' ' + HelpText.Lookup('HELPSPEC_FEATURE');
         SearchResult.AddLine(s, pkNormal, 0, hkFeature + hkCrossLink, i);
+          S := S + ' ' + HelpText.Lookup('HELPSPEC_FEATURE');
+        SearchResult.AddLine(S, pkNormal, 0, hkFeature, I, True);
       end;
     end
     else if h = hGOVHELP then
+    else if H = hGOVHELP then
     begin
       if (i >= 0) and (h <> PrevHandle) and not bGOVHELP then
+      if (I >= 0) and (H <> PrevHandle) and not bGOVHELP then
         SearchResult.AddLine(HelpText.Lookup('HELPTITLE_GOVLIST'), pkNormal, 0,
           hkMisc + hkCrossLink, miscGovList)
+          hkMisc, Integer(miscGovList), True);
     end
     else if h = hSPECIALMODEL then
+    else if H = hSPECIALMODEL then
     begin
       if (i >= 0) and (h <> PrevHandle) and not bSPECIALMODEL then
+      if (I >= 0) and (H <> PrevHandle) and not bSPECIALMODEL then
         SearchResult.AddLine(HelpText.Lookup('HELPTITLE_MODELLIST'), pkNormal,
 , hkModel + hkCrossLink, 0)
+, hkModel, 0, True);
     end
     else if h = hJOBHELP then
+    else if H = hJOBHELP then
     begin
       if (i >= 0) and (h <> PrevHandle) and not bJOBHELP then
+      if (I >= 0) and (H <> PrevHandle) and not bJOBHELP then
         SearchResult.AddLine(HelpText.Lookup('HELPTITLE_JOBLIST'), pkNormal, 0,
           hkMisc + hkCrossLink, miscJobList)
+          hkMisc, Integer(miscJobList), True);
     end
     else if { (h<>hMAIN) and } (h <> PrevHandle) then
+    else if { (h<>hMAIN) and } (H <> PrevHandle) then
     begin
       s := HelpText.LookupByHandle(h);
       p := Pos('$', s);
       if p > 0 then
+      S := HelpText.LookupByHandle(H);
+      P := Pos('$', S);
+      if P > 0 then
       begin
         s := Copy(s, p + 1, maxint);
         p := Pos('\', s);
         if p > 0 then
           s := Copy(s, 1, p - 1);
         SearchResult.AddLine(s, pkNormal, 0, hkText + hkCrossLink, h);
+        S := Copy(S, P + 1, MaxInt);
+        P := Pos('\', S);
+        if P > 0 then
+          S := Copy(S, 1, P - 1);
+        SearchResult.AddLine(S, pkNormal, 0, hkText, H, True);
       end;
     end;
     until False;
     // cut lines to fit to window
     RightMargin := InnerWidth - 16 - DpiGetSystemMetrics(SM_CXVSCROLL);
     OffScreen.Canvas.Font.Assign(UniFont[ftNormal]);
     for i := 0 to SearchResult.Count - 1 do
     begin
       while BiColorTextWidth(OffScreen.Canvas, SearchResult[i]) >
         RightMargin - 32 do
         SearchResult[i] := copy(SearchResult[i], 1, length(SearchResult[i]) - 1)
     end;
   end;
+  until False;
+  // Cut lines to fit to window
+  RightMargin := InnerWidth - 16 - DpiGetSystemMetrics(SM_CXVSCROLL);
+  OffScreen.Canvas.Font.Assign(UniFont[ftNormal]);
+  for I := 0 to SearchResult.Count - 1 do
+  begin
+    while BiColorTextWidth(OffScreen.Canvas, SearchResult[I]) >
+      RightMargin - 32 do
+      SearchResult[I] := Copy(SearchResult[I], 1, Length(SearchResult[I]) - 1)
+  end;
+end;
 end.

branches/highdpi/LocalPlayer/IsoEngine.pas

-              r405
+              r465
 uses
   UDpiControls, Protocol, ClientTools, ScreenTools, Tribes,
   LCLIntf, LCLType, SysUtils, Classes, Graphics, UPixelPointer, UGraphicSet;
+  UDpiControls, Protocol, ClientTools, ScreenTools, Tribes, LCLIntf, LCLType, SysUtils,
+  Classes, Graphics, PixelPointer, GraphicSet;
 const
 …
 type
   TInitEnemyModelEvent = function(emix: integer): boolean;
+  TInitEnemyModelEvent = function(emix: Integer): Boolean;
   TTileSize = (tsSmall, tsMedium, tsBig);
 …
       Dirx: array [0..7] of Integer = (1, 2, 1, 0, -1, -2, -1, 0);
       Diry: array [0..7] of Integer = (-1, 0, 1, 2, 1, 0, -1, -2);
     procedure CityGrid(xm, ym: integer; CityAllowClick: Boolean);
     function IsShoreTile(Loc: integer): boolean;
+    procedure CityGrid(xm, ym: Integer; CityAllowClick: Boolean);
+    function IsShoreTile(Loc: Integer): Boolean;
     procedure MakeDark(Line: PPixelPointer; Length: Integer);
     procedure SetTileSize(AValue: TTileSize);
     procedure ShadeOutside(x0, y0, Width, Height, xm, ym: integer);
+    procedure ShadeOutside(x0, y0, Width, Height, xm, ym: Integer);
   protected
     FOutput: TDpiBitmap;
 …
     ShowDebug: Boolean;
     FoW: Boolean;
     function Connection4(Loc, Mask, Value: integer): integer;
     function Connection8(Loc, Mask: integer): integer;
     function OceanConnection(Loc: integer): integer;
     procedure PaintShore(x, y, Loc: integer);
     procedure PaintTileExtraTerrain(x, y, Loc: integer);
     procedure PaintTileObjects(x, y, Loc, CityLoc, CityOwner: integer;
       UseBlink: boolean);
     procedure PaintGrid(x, y, nx, ny: integer);
     procedure FillRect(x, y, Width, Height, Color: integer);
     procedure Textout(x, y, Color: integer; const s: string);
     procedure Sprite(HGr: TGraphicSet; xDst, yDst, Width, Height, xGr, yGr: integer);
     procedure TSprite(xDst, yDst, grix: integer; PureBlack: boolean = false);
+    function Connection4(Loc, Mask, Value: Integer): Integer;
+    function Connection8(Loc, Mask: Integer): Integer;
+    function OceanConnection(Loc: Integer): Integer;
+    procedure PaintShore(X, Y, Loc: Integer);
+    procedure PaintTileExtraTerrain(X, Y, Loc: Integer);
+    procedure PaintTileObjects(X, Y, Loc, CityLoc, CityOwner: Integer;
+      UseBlink: Boolean);
+    procedure PaintGrid(X, Y, nx, ny: Integer);
+    procedure FillRect(X, Y, Width, Height, Color: Integer);
+    procedure Textout(X, Y, Color: Integer; const S: string);
+    procedure Sprite(HGr: TGraphicSet; xDst, yDst, Width, Height, xGr, yGr: Integer);
+    procedure TSprite(xDst, yDst, grix: Integer; PureBlack: Boolean = False);
     procedure ApplyTileSize(ATileSize: TTileSize);
   public
 …
     procedure Reset;
     procedure SetOutput(Output: TDpiBitmap);
     procedure SetPaintBounds(Left, Top, Right, Bottom: integer);
     procedure Paint(x, y, Loc, nx, ny, CityLoc, CityOwner: integer;
       UseBlink: boolean = false; CityAllowClick: boolean = false);
     procedure PaintUnit(x, y: integer; const UnitInfo: TUnitInfo;
       Status: integer);
     procedure PaintCity(x, y: integer; const CityInfo: TCityInfo;
       accessory: boolean = true);
     procedure BitBltBitmap(Src: TDpiBitmap; x, y, Width, Height, xSrc, ySrc,
       Rop: integer);
+    procedure SetPaintBounds(Left, Top, Right, Bottom: Integer);
+    procedure Paint(X, Y, Loc, nx, ny, CityLoc, CityOwner: Integer;
+      UseBlink: Boolean = False; CityAllowClick: Boolean = False);
+    procedure PaintUnit(X, Y: Integer; const UnitInfo: TUnitInfo;
+      Status: Integer);
+    procedure PaintCity(X, Y: Integer; const CityInfo: TCityInfo;
+      accessory: Boolean = True);
+    procedure BitBltBitmap(Src: TDpiBitmap; X, Y, Width, Height, xSrc, ySrc,
+      Rop: Integer);
     procedure AttackBegin(const ShowMove: TShowMove);
     procedure AttackEffect(const ShowMove: TShowMove);
     procedure AttackEnd;
     procedure ReduceTerrainIconsSize;
     property AdviceLoc: integer read FAdviceLoc write FAdviceLoc;
+    property AdviceLoc: Integer read FAdviceLoc write FAdviceLoc;
     property TileSize: TTileSize read FTileSize write SetTileSize;
   end;
 …
     (X: 72; Y: 36));
 function IsJungle(y: integer): boolean;
+function IsJungle(Y: Integer): Boolean;
 procedure Init(InitEnemyModelHandler: TInitEnemyModelEvent);
 …
   IsoMapCache: array[TTileSize] of TIsoMapCache;
 function IsJungle(y: integer): boolean;
 begin
   result := (y > (G.ly - 2) div 4) and (G.ly - 1 - y > (G.ly - 2) div 4)
+function IsJungle(Y: Integer): Boolean;
+begin
+  Result := (Y > (G.ly - 2) div 4) and (G.ly - 1 - Y > (G.ly - 2) div 4)
 end;
 …
   Mask24.BeginUpdate;
   for ySrc := 0 to TerrainIconLines - 1 do begin
     for i := 0 to yyt * 3 - 1 do
       MaskLine[i] := PixelPointer(Mask24, ScaleToNative(0),
         ScaleToNative(1 + ySrc * (yyt * 3 + 1) + i));
+    for I := 0 to yyt * 3 - 1 do
+      MaskLine[I] := TPixelPointer.Create(Mask24, ScaleToNative(0),
+        ScaleToNative(1 + ySrc * (yyt * 3 + 1) + I));
     for xSrc := 0 to TerrainIconCols - 1 do begin
       i := ySrc * 9 + xSrc;
       TSpriteSize[i].Left := 0;
+      I := ySrc * 9 + xSrc;
+      TSpriteSize[I].Left := 0;
       repeat
         Border := true;
         for y := 0 to yyt * 3 - 1 do begin
           MaskLine[y].SetX(ScaleToNative(1 + xSrc * (xxt * 2 + 1) + TSpriteSize[i].Left));
           if MaskLine[y].Pixel^.B = 0 then Border := false;
+        Border := True;
+        for Y := 0 to yyt * 3 - 1 do begin
+          MaskLine[Y].SetX(ScaleToNative(1 + xSrc * (xxt * 2 + 1) + TSpriteSize[I].Left));
+          if MaskLine[Y].Pixel^.B = 0 then Border := False;
         end;
         if Border then Inc(TSpriteSize[i].Left);
       until not Border or (TSpriteSize[i].Left = xxt * 2 - 1);
       TSpriteSize[i].Top := 0;
+        if Border then Inc(TSpriteSize[I].Left);
+      until not Border or (TSpriteSize[I].Left = xxt * 2 - 1);
+      TSpriteSize[I].Top := 0;
       repeat
         Border := true;
         for x := 0 to xxt * 2 - 1 do begin
           MaskLine[TSpriteSize[i].Top].SetX(ScaleToNative(1 + xSrc * (xxt * 2 + 1) + x));
           if MaskLine[TSpriteSize[i].Top].Pixel^.B = 0 then Border := false;
+        Border := True;
+        for X := 0 to xxt * 2 - 1 do begin
+          MaskLine[TSpriteSize[I].Top].SetX(ScaleToNative(1 + xSrc * (xxt * 2 + 1) + X));
+          if MaskLine[TSpriteSize[I].Top].Pixel^.B = 0 then Border := False;
         end;
         if Border then inc(TSpriteSize[i].Top);
       until not Border or (TSpriteSize[i].Top = yyt * 3 - 1);
       TSpriteSize[i].Right := xxt * 2;
+        if Border then Inc(TSpriteSize[I].Top);
+      until not Border or (TSpriteSize[I].Top = yyt * 3 - 1);
+      TSpriteSize[I].Right := xxt * 2;
       repeat
         Border := true;
         for y := 0 to yyt * 3 - 1 do begin
           MaskLine[y].SetX(ScaleToNative(xSrc * (xxt * 2 + 1) + TSpriteSize[i].Right));
           if MaskLine[y].Pixel^.B = 0 then Border := false;
+        Border := True;
+        for Y := 0 to yyt * 3 - 1 do begin
+          MaskLine[Y].SetX(ScaleToNative(xSrc * (xxt * 2 + 1) + TSpriteSize[I].Right));
+          if MaskLine[Y].Pixel^.B = 0 then Border := False;
         end;
         if Border then Dec(TSpriteSize[i].Right);
       until not Border or (TSpriteSize[i].Right = TSpriteSize[i].Left);
       TSpriteSize[i].Bottom := yyt * 3;
+        if Border then Dec(TSpriteSize[I].Right);
+      until not Border or (TSpriteSize[I].Right = TSpriteSize[I].Left);
+      TSpriteSize[I].Bottom := yyt * 3;
       repeat
         Border := true;
         for x := 0 to xxt * 2 - 1 do begin
           MaskLine[TSpriteSize[i].Bottom - 1].SetX(ScaleToNative(1 + xSrc * (xxt * 2 + 1) + x));
           if MaskLine[TSpriteSize[i].Bottom - 1].Pixel^.B = 0 then Border := false;
+        Border := True;
+        for X := 0 to xxt * 2 - 1 do begin
+          MaskLine[TSpriteSize[I].Bottom - 1].SetX(ScaleToNative(1 + xSrc * (xxt * 2 + 1) + X));
+          if MaskLine[TSpriteSize[I].Bottom - 1].Pixel^.B = 0 then Border := False;
         end;
         if Border then Dec(TSpriteSize[i].Bottom);
       until not Border or (TSpriteSize[i].Bottom = TSpriteSize[i].Top);
+        if Border then Dec(TSpriteSize[I].Bottom);
+      until not Border or (TSpriteSize[I].Bottom = TSpriteSize[I].Top);
     end;
   end;
 …
 procedure TIsoMap.ApplyTileSize(ATileSize: TTileSize);
 var
   x: Integer;
   y: Integer;
+  X: Integer;
+  Y: Integer;
   xSrc: Integer;
   ySrc: Integer;
 …
   DitherMask.SetSize(xxt * 2, yyt * 2);
   DitherMask.Canvas.FillRect(0, 0, DitherMask.Width, DitherMask.Height);
   DpiBitCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt * 2,
+  DpiBitBltCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt * 2,
     HGrTerrain.Mask.Canvas, 1 + 7 * (xxt * 2 + 1),
 + yyt + 15 * (yyt * 3 + 1), SRCAND);
   for x := -1 to 6 do begin
     if x = -1 then begin
+  for X := -1 to 6 do begin
+    if X = -1 then begin
       xSrc := ShoreDither * (xxt * 2 + 1) + 1;
       ySrc := 1 + yyt;
     end
     else if x = 6 then begin
+    else if X = 6 then begin
       xSrc := 1 + (xxt * 2 + 1) * 2;
       ySrc := 1 + yyt + (yyt * 3 + 1) * 2;
     end else begin
       xSrc := (x + 2) * (xxt * 2 + 1) + 1;
+      xSrc := (X + 2) * (xxt * 2 + 1) + 1;
       ySrc := 1 + yyt;
     end;
     for y := -1 to 6 do
       DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2), (y + 2) * yyt,
+    for Y := -1 to 6 do
+      DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2), (Y + 2) * yyt,
         xxt * 2, yyt, HGrTerrain.Data.Canvas, xSrc, ySrc);
     for y := -2 to 6 do
       DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2), (y + 2) * yyt, xxt,
+    for Y := -2 to 6 do
+      DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2), (Y + 2) * yyt, xxt,
         yyt, HGrTerrain.Data.Canvas, xSrc + xxt, ySrc + yyt,
         SRCPAINT);
     for y := -2 to 6 do
       DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2) + xxt, (y + 2) * yyt,
+    for Y := -2 to 6 do
+      DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2) + xxt, (Y + 2) * yyt,
         xxt, yyt, HGrTerrain.Data.Canvas, xSrc, ySrc + yyt,
         SRCPAINT);
     for y := -2 to 6 do
       DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2), (y + 2) * yyt, xxt,
+    for Y := -2 to 6 do
+      DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2), (Y + 2) * yyt, xxt,
         yyt, DitherMask.Canvas, xxt, yyt, SRCAND);
     for y := -2 to 6 do
       DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2) + xxt, (y + 2) * yyt,
+    for Y := -2 to 6 do
+      DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2) + xxt, (Y + 2) * yyt,
         xxt, yyt, DitherMask.Canvas, 0, yyt, SRCAND);
   end;
   for y := -1 to 6 do begin
     if y = -1 then begin
+  for Y := -1 to 6 do begin
+    if Y = -1 then begin
       xSrc := ShoreDither * (xxt * 2 + 1) + 1;
       ySrc := 1 + yyt;
     end
     else if y = 6 then begin
+    else if Y = 6 then begin
       xSrc := 1 + 2 * (xxt * 2 + 1);
       ySrc := 1 + yyt + 2 * (yyt * 3 + 1);
     end else begin
       xSrc := (y + 2) * (xxt * 2 + 1) + 1;
+      xSrc := (Y + 2) * (xxt * 2 + 1) + 1;
       ySrc := 1 + yyt;
     end;
     for x := -2 to 6 do
       DpiBitCanvas(LandMore.Canvas, (x + 2) * (xxt * 2), (y + 2) * yyt,
+    for X := -2 to 6 do
+      DpiBitBltCanvas(LandMore.Canvas, (X + 2) * (xxt * 2), (Y + 2) * yyt,
         xxt * 2, yyt, HGrTerrain.Data.Canvas, xSrc, ySrc);
     DpiBitCanvas(LandMore.Canvas, xxt * 2, (y + 2) * yyt, xxt, yyt,
+    DpiBitBltCanvas(LandMore.Canvas, xxt * 2, (Y + 2) * yyt, xxt, yyt,
       HGrTerrain.Data.Canvas, xSrc + xxt, ySrc + yyt, SRCPAINT);
     for x := 0 to 7 do
       DpiBitCanvas(LandMore.Canvas, (x + 2) * (xxt * 2) - xxt, (y + 2) * yyt,
+    for X := 0 to 7 do
+      DpiBitBltCanvas(LandMore.Canvas, (X + 2) * (xxt * 2) - xxt, (Y + 2) * yyt,
         xxt * 2, yyt, HGrTerrain.Data.Canvas, xSrc, ySrc + yyt,
         SRCPAINT);
     for x := -2 to 6 do
       DpiBitCanvas(LandMore.Canvas, (x + 2) * (xxt * 2), (y + 2) * yyt,
+    for X := -2 to 6 do
+      DpiBitBltCanvas(LandMore.Canvas, (X + 2) * (xxt * 2), (Y + 2) * yyt,
         xxt * 2, yyt, DitherMask.Canvas, 0, 0, SRCAND);
   end;
   for x := 0 to 3 do begin
     for y := 0 to 3 do begin
       if (x = 1) and (y = 1) then xSrc := 1
+  for X := 0 to 3 do begin
+    for Y := 0 to 3 do begin
+      if (X = 1) and (Y = 1) then xSrc := 1
       else
         xSrc := (x mod 2) * (xxt * 2 + 1) + 1;
+        xSrc := (X mod 2) * (xxt * 2 + 1) + 1;
       ySrc := 1 + yyt;
       if (x >= 1) = (y >= 2) then
         DpiBitCanvas(OceanPatch.Canvas, x * (xxt * 2), y * yyt, xxt * 2, yyt,
+      if (X >= 1) = (Y >= 2) then
+        DpiBitBltCanvas(OceanPatch.Canvas, X * (xxt * 2), Y * yyt, xxt * 2, yyt,
           HGrTerrain.Data.Canvas, xSrc, ySrc);
       if (x >= 1) and ((y < 2) or (x >= 2)) then
+      if (X >= 1) and ((Y < 2) or (X >= 2)) then
       begin
         DpiBitCanvas(OceanPatch.Canvas, x * (xxt * 2), y * yyt, xxt, yyt,
+        DpiBitBltCanvas(OceanPatch.Canvas, X * (xxt * 2), Y * yyt, xxt, yyt,
           HGrTerrain.Data.Canvas, xSrc + xxt, ySrc + yyt,
           SRCPAINT);
         DpiBitCanvas(OceanPatch.Canvas, x * (xxt * 2) + xxt, y * yyt, xxt, yyt,
+        DpiBitBltCanvas(OceanPatch.Canvas, X * (xxt * 2) + xxt, Y * yyt, xxt, yyt,
           HGrTerrain.Data.Canvas, xSrc, ySrc + yyt, SRCPAINT);
       end;
       DpiBitCanvas(OceanPatch.Canvas, x * (xxt * 2), y * yyt, xxt, yyt,
+      DpiBitBltCanvas(OceanPatch.Canvas, X * (xxt * 2), Y * yyt, xxt, yyt,
         DitherMask.Canvas, xxt, yyt, SRCAND);
       DpiBitCanvas(OceanPatch.Canvas, x * (xxt * 2) + xxt, y * yyt, xxt, yyt,
+      DpiBitBltCanvas(OceanPatch.Canvas, X * (xxt * 2) + xxt, Y * yyt, xxt, yyt,
         DitherMask.Canvas, 0, yyt, SRCAND);
     end;
   end;
   for y := 0 to 3 do begin
     for x := 0 to 3 do begin
       if (x = 1) and (y = 1) then xSrc := 1
+  for Y := 0 to 3 do begin
+    for X := 0 to 3 do begin
+      if (X = 1) and (Y = 1) then xSrc := 1
       else
         xSrc := (y mod 2) * (xxt * 2 + 1) + 1;
+        xSrc := (Y mod 2) * (xxt * 2 + 1) + 1;
       ySrc := 1 + yyt;
       if (x < 1) or (y >= 2) then
         DpiBitCanvas(OceanMore.Canvas, x * (xxt * 2), y * yyt, xxt * 2, yyt,
+      if (X < 1) or (Y >= 2) then
+        DpiBitBltCanvas(OceanMore.Canvas, X * (xxt * 2), Y * yyt, xxt * 2, yyt,
           HGrTerrain.Data.Canvas, xSrc, ySrc);
       if (x = 1) and (y < 2) or (x >= 2) and (y >= 1) then
+      if (X = 1) and (Y < 2) or (X >= 2) and (Y >= 1) then
       begin
         DpiBitCanvas(OceanMore.Canvas, x * (xxt * 2), y * yyt, xxt, yyt,
+        DpiBitBltCanvas(OceanMore.Canvas, X * (xxt * 2), Y * yyt, xxt, yyt,
           HGrTerrain.Data.Canvas, xSrc + xxt, ySrc + yyt,
           SRCPAINT);
         DpiBitCanvas(OceanMore.Canvas, x * (xxt * 2) + xxt, y * yyt, xxt, yyt,
+        DpiBitBltCanvas(OceanMore.Canvas, X * (xxt * 2) + xxt, Y * yyt, xxt, yyt,
           HGrTerrain.Data.Canvas, xSrc, ySrc + yyt, SRCPAINT);
       end;
       DpiBitCanvas(OceanMore.Canvas, x * (xxt * 2), y * yyt, xxt * 2, yyt,
+      DpiBitBltCanvas(OceanMore.Canvas, X * (xxt * 2), Y * yyt, xxt * 2, yyt,
         DitherMask.Canvas, 0, 0, SRCAND);
     end;
   end;
   DpiBitCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt * 2,
+  DpiBitBltCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt * 2,
     DitherMask.Canvas, 0, 0, DSTINVERT); { invert dither mask }
   DpiBitCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt * 2,
+  DpiBitBltCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt * 2,
     HGrTerrain.Mask.Canvas, 1, 1 + yyt, SRCPAINT);
   for x := -1 to 6 do
     for y := -2 to 6 do
       DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2), (y + 2) * yyt,
+  for X := -1 to 6 do
+    for Y := -2 to 6 do
+      DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2), (Y + 2) * yyt,
         xxt * 2, yyt, DitherMask.Canvas, 0, 0, SRCAND);
   for y := -1 to 6 do
     for x := -2 to 7 do
       DpiBitCanvas(LandMore.Canvas, (x + 2) * (xxt * 2) - xxt, (y + 2) * yyt,
+  for Y := -1 to 6 do
+    for X := -2 to 7 do
+      DpiBitBltCanvas(LandMore.Canvas, (X + 2) * (xxt * 2) - xxt, (Y + 2) * yyt,
         xxt * 2, yyt, DitherMask.Canvas, 0, yyt, SRCAND);
   DpiBitCanvas(LandPatch.Canvas, 0, 0, (xxt * 2) * 9, yyt * 9,
+  DpiBitBltCanvas(LandPatch.Canvas, 0, 0, (xxt * 2) * 9, yyt * 9,
     LandMore.Canvas, 0, 0, SRCPAINT);
   for x := 0 to 3 do
     for y := 0 to 3 do
       DpiBitCanvas(OceanPatch.Canvas, x * (xxt * 2), y * yyt, xxt * 2, yyt,
+  for X := 0 to 3 do
+    for Y := 0 to 3 do
+      DpiBitBltCanvas(OceanPatch.Canvas, X * (xxt * 2), Y * yyt, xxt * 2, yyt,
         DitherMask.Canvas, 0, 0, SRCAND);
   for y := 0 to 3 do
     for x := 0 to 4 do
       DpiBitCanvas(OceanMore.Canvas, x * (xxt * 2) - xxt, y * yyt, xxt * 2,
+  for Y := 0 to 3 do
+    for X := 0 to 4 do
+      DpiBitBltCanvas(OceanMore.Canvas, X * (xxt * 2) - xxt, Y * yyt, xxt * 2,
         yyt, DitherMask.Canvas, 0, yyt, SRCAND);
   DpiBitCanvas(OceanPatch.Canvas, 0, 0, (xxt * 2) * 4, yyt * 4,
+  DpiBitBltCanvas(OceanPatch.Canvas, 0, 0, (xxt * 2) * 4, yyt * 4,
     OceanMore.Canvas, 0, 0, SRCPAINT);
 …
     FillRect(Rect(0, 0, xxt * 2, yyt));
   end;
   DpiBitCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt,
+  DpiBitBltCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt,
     HGrTerrain.Mask.Canvas, 1, 1 + yyt);
   for x := 0 to 6 do
     DpiBitCanvas(LandPatch.Canvas, (x + 2) * (xxt * 2), yyt, xxt * 2, yyt,
+  for X := 0 to 6 do
+    DpiBitBltCanvas(LandPatch.Canvas, (X + 2) * (xxt * 2), yyt, xxt * 2, yyt,
       DitherMask.Canvas, 0, 0, SRCAND);
   DpiBitCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt, DitherMask.Canvas,
+  DpiBitBltCanvas(DitherMask.Canvas, 0, 0, xxt * 2, yyt, DitherMask.Canvas,
 , 0, DSTINVERT);
   for y := 0 to 6 do
     DpiBitCanvas(LandPatch.Canvas, xxt * 2, (y + 2) * yyt, xxt * 2, yyt,
+  for Y := 0 to 6 do
+    DpiBitBltCanvas(LandPatch.Canvas, xxt * 2, (Y + 2) * yyt, xxt * 2, yyt,
       DitherMask.Canvas, 0, 0, SRCAND);
 …
 end;
 procedure TIsoMap.SetPaintBounds(Left, Top, Right, Bottom: integer);
+procedure TIsoMap.SetPaintBounds(Left, Top, Right, Bottom: Integer);
 begin
   FLeft := Left;
 …
 end;
 procedure TIsoMap.FillRect(x, y, Width, Height, Color: integer);
 begin
   if x < FLeft then
   begin
     Width := Width - (FLeft - x);
     x := FLeft;
   end;
   if y < FTop then
   begin
     Height := Height - (FTop - y);
     y := FTop;
   end;
   if x + Width >= FRight then
     Width := FRight - x;
   if y + Height >= FBottom then
     Height := FBottom - y;
+procedure TIsoMap.FillRect(X, Y, Width, Height, Color: Integer);
+begin
+  if X < FLeft then
+  begin
+    Width := Width - (FLeft - X);
+    X := FLeft;
+  end;
+  if Y < FTop then
+  begin
+    Height := Height - (FTop - Y);
+    Y := FTop;
+  end;
+  if X + Width >= FRight then
+    Width := FRight - X;
+  if Y + Height >= FBottom then
+    Height := FBottom - Y;
   if (Width <= 0) or (Height <= 0) then
     exit;
+    Exit;
   FOutput.Canvas.Brush.Color := Color;
   FOutput.Canvas.FillRect(Rect(x, y, x + Width, y + Height));
+  FOutput.Canvas.FillRect(Rect(X, Y, X + Width, Y + Height));
   FOutput.Canvas.Brush.Style := bsClear;
 end;
 procedure TIsoMap.Textout(x, y, Color: integer; const s: string);
+procedure TIsoMap.Textout(X, Y, Color: Integer; const S: string);
 begin
   FOutput.Canvas.Font.Color := Color;
   FOutput.Canvas.TextRect(Rect(FLeft, FTop, FRight, FBottom), x, y, s)
 end;
 procedure TIsoMap.BitBltBitmap(Src: TDpiBitmap; x, y, Width, Height, xSrc, ySrc,
   Rop: integer);
 begin
   if x < FLeft then
   begin
     Width := Width - (FLeft - x);
     xSrc := xSrc + (FLeft - x);
     x := FLeft;
   end;
   if y < FTop then
   begin
     Height := Height - (FTop - y);
     ySrc := ySrc + (FTop - y);
     y := FTop;
   end;
   if x + Width >= FRight then
     Width := FRight - x;
   if y + Height >= FBottom then
     Height := FBottom - y;
+  FOutput.Canvas.TextRect(Rect(FLeft, FTop, FRight, FBottom), X, Y, S)
+end;
+procedure TIsoMap.BitBltBitmap(Src: TDpiBitmap; X, Y, Width, Height, xSrc, ySrc,
+  Rop: Integer);
+begin
+  if X < FLeft then
+  begin
+    Width := Width - (FLeft - X);
+    xSrc := xSrc + (FLeft - X);
+    X := FLeft;
+  end;
+  if Y < FTop then
+  begin
+    Height := Height - (FTop - Y);
+    ySrc := ySrc + (FTop - Y);
+    Y := FTop;
+  end;
+  if X + Width >= FRight then
+    Width := FRight - X;
+  if Y + Height >= FBottom then
+    Height := FBottom - Y;
   if (Width <= 0) or (Height <= 0) then
     exit;
   DpiBitCanvas(FOutput.Canvas, x, y, Width, Height, Src.Canvas, xSrc, ySrc, Rop);
 end;
 procedure TIsoMap.Sprite(HGr: TGraphicSet; xDst, yDst, Width, Height, xGr, yGr: integer);
+    Exit;
+  DpiBitBltCanvas(FOutput.Canvas, X, Y, Width, Height, Src.Canvas, xSrc, ySrc, Rop);
+end;
+procedure TIsoMap.Sprite(HGr: TGraphicSet; xDst, yDst, Width, Height, xGr, yGr: Integer);
 begin
   BitBltBitmap(HGr.Mask, xDst, yDst, Width, Height, xGr, yGr, SRCAND);
 …
 end;
 procedure TIsoMap.TSprite(xDst, yDst, grix: integer;
   PureBlack: boolean = false);
+procedure TIsoMap.TSprite(xDst, yDst, grix: Integer;
+  PureBlack: Boolean = False);
 var
   Width: Integer;
   Height: Integer;
   xSrc: Integer;
   ySrc: integer;
+  ySrc: Integer;
 begin
   Width := TSpriteSize[grix].Right - TSpriteSize[grix].Left;
 …
     Height := FBottom - yDst;
   if (Width <= 0) or (Height <= 0) then
     exit;
   DpiBitCanvas(FOutput.Canvas, xDst, yDst, Width, Height, MaskCanvas, xSrc, ySrc, SRCAND);
+    Exit;
+  DpiBitBltCanvas(FOutput.Canvas, xDst, yDst, Width, Height, MaskCanvas, xSrc, ySrc, SRCAND);
   if not PureBlack then
     DpiBitCanvas(FOutput.Canvas, xDst, yDst, Width, Height, DataCanvas, xSrc, ySrc, SRCPAINT);
 end;
 procedure TIsoMap.PaintUnit(x, y: integer; const UnitInfo: TUnitInfo;
   Status: integer);
 var
   xsh, ysh, xGr, yGr, j, mixShow: integer;
+    DpiBitBltCanvas(FOutput.Canvas, xDst, yDst, Width, Height, DataCanvas, xSrc, ySrc, SRCPAINT);
+end;
+procedure TIsoMap.PaintUnit(X, Y: Integer; const UnitInfo: TUnitInfo;
+  Status: Integer);
+var
+  xsh, ysh, xGr, yGr, J, mixShow: Integer;
 begin
   with UnitInfo do
     if (Owner = me) or (emix <> $FFFF) then
+    if (Owner = Me) or (emix <> $FFFF) then
     begin
       if Job = jCity then
 …
         (@OnInitEnemyModel <> nil) then
         if not OnInitEnemyModel(emix) then
           exit;
+          Exit;
       xsh := Tribe[Owner].ModelPicture[mixShow].xShield;
       ysh := Tribe[Owner].ModelPicture[mixShow].yShield;
 {$IFNDEF SCR} if Status and usStay <> 0 then
         j := 19
+        J := 19
       else if Status and usRecover <> 0 then
         j := 16
+        J := 16
       else if Status and (usGoto or usEnhance) = usGoto or usEnhance then
         j := 18
+        J := 18
       else if Status and usEnhance <> 0 then
         j := 17
+        J := 17
       else if Status and usGoto <> 0 then
         j := 20
+        J := 20
       else {$ENDIF} if Job = jCity then
           j := jNone
+          J := jNone
         else
           j := Job;
+          J := Job;
       if Flags and unMulti <> 0 then
         Sprite(Tribe[Owner].symHGr, x + xsh - 1 + 4, y + ysh - 2, 14, 12,
+        Sprite(Tribe[Owner].symHGr, X + xsh - 1 + 4, Y + ysh - 2, 14, 12,
 + Tribe[Owner].sympix mod 10 * 65,
 + Tribe[Owner].sympix div 10 * 49);
       Sprite(Tribe[Owner].symHGr, x + xsh - 1, y + ysh - 2, 14, 12,
+      Sprite(Tribe[Owner].symHGr, X + xsh - 1, Y + ysh - 2, 14, 12,
 + Tribe[Owner].sympix mod 10 * 65,
 + Tribe[Owner].sympix div 10 * 49);
       FillRect(x + xsh, y + ysh + 5, 1 + Health * 11 div 100, 3,
+      FillRect(X + xsh, Y + ysh + 5, 1 + Health * 11 div 100, 3,
         ColorOfHealth(Health));
       if j > 0 then
+      if J > 0 then
       begin
         xGr := 121 + j mod 7 * 9;
         yGr := 1 + j div 7 * 9;
         BitBltBitmap(HGrSystem.Mask, x + xsh + 3, y + ysh + 9, 8, 8, xGr,
+        xGr := 121 + J mod 7 * 9;
+        yGr := 1 + J div 7 * 9;
+        BitBltBitmap(HGrSystem.Mask, X + xsh + 3, Y + ysh + 9, 8, 8, xGr,
           yGr, SRCAND);
         Sprite(HGrSystem, x + xsh + 2, y + ysh + 8, 8, 8, xGr, yGr);
+        Sprite(HGrSystem, X + xsh + 2, Y + ysh + 8, 8, 8, xGr, yGr);
       end;
       with Tribe[Owner].ModelPicture[mixShow] do
         Sprite(HGr, x, y, 64, 48, pix mod 10 * 65 + 1, pix div 10 * 49 + 1);
+        Sprite(HGr, X, Y, 64, 48, pix mod 10 * 65 + 1, pix div 10 * 49 + 1);
       if Flags and unFortified <> 0 then
       begin
         { DataCanvas:=HGrTerrain.Data.Canvas;
           MaskCanvas:=HGrTerrain.Mask.Canvas;
           TSprite(x,y+16,12*9+7); }
         Sprite(HGrStdUnits, x, y, xxu * 2, yyu * 2, 1 + 6 * (xxu * 2 + 1), 1);
+          TSprite(X,Y+16,12*9+7); }
+        Sprite(HGrStdUnits, X, Y, xxu * 2, yyu * 2, 1 + 6 * (xxu * 2 + 1), 1);
       end;
     end;
 end; { PaintUnit }
 procedure TIsoMap.PaintCity(x, y: integer; const CityInfo: TCityInfo;
   accessory: boolean);
+end;
+procedure TIsoMap.PaintCity(X, Y: Integer; const CityInfo: TCityInfo;
+  accessory: Boolean);
 var
   age: Integer;
 …
   LabelLength: Integer;
   cpic: TCityPicture;
   s: string;
+  S: string;
 begin
   age := GetAge(CityInfo.Owner);
 …
       (cHGr.Data.Canvas.Pixels[(xGr + 4) * 65, cpix * 49 + 48] = $00FFFF)
     then
       Sprite(cHGr, x - xxc, y - 2 * yyc, xxc * 2, yyc * 3,
+      Sprite(cHGr, X - xxc, Y - 2 * yyc, xxc * 2, yyc * 3,
         xGr * (xxc * 2 + 1) + 1, 1 + cpix * (yyc * 3 + 1));
     if ciWalled and CityInfo.Flags <> 0 then
       Sprite(cHGr, x - xxc, y - 2 * yyc, xxc * 2, yyc * 3,
+      Sprite(cHGr, X - xxc, Y - 2 * yyc, xxc * 2, yyc * 3,
         (xGr + 4) * (xxc * 2 + 1) + 1, 1 + cpix * (yyc * 3 + 1));
   end
 …
   begin
     if ciWalled and CityInfo.Flags <> 0 then
       Sprite(HGrCities, x - xxt, y - 2 * yyt, 2 * xxt, 3 * yyt,
+      Sprite(HGrCities, X - xxt, Y - 2 * yyt, 2 * xxt, 3 * yyt,
         (xGr + 4) * (2 * xxt + 1) + 1, 1 + (age - 2) * (3 * yyt + 1))
     else
       Sprite(HGrCities, x - xxt, y - 2 * yyt, 2 * xxt, 3 * yyt,
+      Sprite(HGrCities, X - xxt, Y - 2 * yyt, 2 * xxt, 3 * yyt,
         xGr * (2 * xxt + 1) + 1, 1 + (age - 2) * (3 * yyt + 1));
   end;
   if not accessory then
     exit;
+    Exit;
   { if ciCapital and CityInfo.Flags<>0 then
     Sprite(Tribe[CityInfo.Owner].symHGr,x+cpic.xf,y-13+cpic.yf,13,14,
+    Sprite(Tribe[CityInfo.Owner].symHGr,X+cpic.xf,Y-13+cpic.yf,13,14,
 +Tribe[CityInfo.Owner].sympix mod 10 *65,
 +Tribe[CityInfo.Owner].sympix div 10 *49); {capital -- paint flag }
 …
     begin
       cpic := Tribe[CityInfo.Owner].CityPicture[xGr];
       xShield := x - xxc + cpic.xShield;
       yShield := y - 2 * yyc + cpic.yShield;
+      xShield := X - xxc + cpic.xShield;
+      yShield := Y - 2 * yyc + cpic.yShield;
     end
     else
     begin
       cpic := CitiesPictures.Pictures[age, xGr];
       xShield := x - xxt + cpic.xShield;
       yShield := y - 2 * yyt + cpic.yShield;
+      xShield := X - xxt + cpic.xShield;
+      yShield := Y - 2 * yyt + cpic.yShield;
     end;
     s := IntToStr(CityInfo.size);
     LabelLength := FOutput.Canvas.TextWidth(s);
+    S := IntToStr(CityInfo.size);
+    LabelLength := FOutput.Canvas.TextWidth(S);
     FillRect(xShield, yShield, LabelLength + 4, 16, $000000);
     if MyMap[CityInfo.Loc] and (fUnit or fObserved) = fObserved then
 …
       LabelTextColor := $000000;
     end;
     Textout(xShield + 2, yShield - 1, LabelTextColor, s);
   end;
 end; { PaintCity }
 function PoleTile(Loc: integer): integer;
+    Textout(xShield + 2, yShield - 1, LabelTextColor, S);
+  end;
+end;
+function PoleTile(Loc: Integer): Integer;
 begin { virtual pole tile }
   result := fUNKNOWN;
+  Result := fUNKNOWN;
   if Loc < -2 * G.lx then
   else if Loc < -G.lx then
 …
       (MyMap[dLoc(Loc, -2, 2)] and fTerrain <> fUNKNOWN) and
       (MyMap[dLoc(Loc, 2, 2)] and fTerrain <> fUNKNOWN) then
       result := fArctic;
+      Result := fArctic;
     if (MyMap[dLoc(Loc, 0, 2)] and fObserved <> 0) and
       (MyMap[dLoc(Loc, -2, 2)] and fObserved <> 0) and
       (MyMap[dLoc(Loc, 2, 2)] and fObserved <> 0) then
       result := result or fObserved;
+      Result := Result or fObserved;
   end
   else if Loc < 0 then
 …
     if (MyMap[dLoc(Loc, -1, 1)] and fTerrain <> fUNKNOWN) and
       (MyMap[dLoc(Loc, 1, 1)] and fTerrain <> fUNKNOWN) then
       result := fArctic;
+      Result := fArctic;
     if (MyMap[dLoc(Loc, -1, 1)] and fObserved <> 0) and
       (MyMap[dLoc(Loc, 1, 1)] and fObserved <> 0) then
       result := result or fObserved;
+      Result := Result or fObserved;
   end
   else if Loc < G.lx * (G.ly + 1) then
 …
     if (MyMap[dLoc(Loc, -1, -1)] and fTerrain <> fUNKNOWN) and
       (MyMap[dLoc(Loc, 1, -1)] and fTerrain <> fUNKNOWN) then
       result := fArctic;
+      Result := fArctic;
     if (MyMap[dLoc(Loc, -1, -1)] and fObserved <> 0) and
       (MyMap[dLoc(Loc, 1, -1)] and fObserved <> 0) then
       result := result or fObserved;
+      Result := Result or fObserved;
   end
   else if Loc < G.lx * (G.ly + 2) then
 …
       (MyMap[dLoc(Loc, -2, -2)] and fTerrain <> fUNKNOWN) and
       (MyMap[dLoc(Loc, 2, -2)] and fTerrain <> fUNKNOWN) then
       result := fArctic;
+      Result := fArctic;
     if (MyMap[dLoc(Loc, 0, -2)] and fObserved <> 0) and
       (MyMap[dLoc(Loc, -2, -2)] and fObserved <> 0) and
       (MyMap[dLoc(Loc, 2, -2)] and fObserved <> 0) then
       result := result or fObserved;
   end;
 end;
 function TIsoMap.Connection4(Loc, Mask, Value: integer): integer;
 begin
   result := 0;
+      Result := Result or fObserved;
+  end;
+end;
+function TIsoMap.Connection4(Loc, Mask, Value: Integer): Integer;
+begin
+  Result := 0;
   if dLoc(Loc, 1, -1) >= 0 then
   begin
     if MyMap[dLoc(Loc, 1, -1)] and Mask = Cardinal(Value) then
       inc(result, 1);
+      Inc(Result, 1);
     if MyMap[dLoc(Loc, -1, -1)] and Mask = Cardinal(Value) then
       inc(result, 8);
+      Inc(Result, 8);
   end;
   if dLoc(Loc, 1, 1) < G.lx * G.ly then
   begin
     if MyMap[dLoc(Loc, 1, 1)] and Mask = Cardinal(Value) then
       inc(result, 2);
+      Inc(Result, 2);
     if MyMap[dLoc(Loc, -1, 1)] and Mask = Cardinal(Value) then
       inc(result, 4);
   end;
 end;
 function TIsoMap.Connection8(Loc, Mask: integer): integer;
+      Inc(Result, 4);
+  end;
+end;
+function TIsoMap.Connection8(Loc, Mask: Integer): Integer;
 var
   Dir: Integer;
   ConnLoc: Integer;
 begin
   result := 0;
+  Result := 0;
   for Dir := 0 to 7 do
   begin
 …
     if (ConnLoc >= 0) and (ConnLoc < G.lx * G.ly) and
       (MyMap[ConnLoc] and Mask <> 0) then
       inc(result, 1 shl Dir);
   end;
 end;
 function TIsoMap.OceanConnection(Loc: integer): integer;
+      Inc(Result, 1 shl Dir);
+  end;
+end;
+function TIsoMap.OceanConnection(Loc: Integer): Integer;
 var
   Dir: Integer;
   ConnLoc: Integer;
 begin
   result := 0;
+  Result := 0;
   for Dir := 0 to 7 do
   begin
 …
     if (ConnLoc < 0) or (ConnLoc >= G.lx * G.ly) or
       ((MyMap[ConnLoc] - 2) and fTerrain < 13) then
       inc(result, 1 shl Dir);
   end;
 end;
 procedure TIsoMap.PaintShore(x, y, Loc: integer);
+      Inc(Result, 1 shl Dir);
+  end;
+end;
+procedure TIsoMap.PaintShore(X, Y, Loc: Integer);
 var
   Conn: Integer;
   Tile: Integer;
 begin
   if (y <= FTop - yyt * 2) or (y > FBottom) or (x <= FLeft - xxt * 2) or
     (x > FRight) then
     exit;
+  if (Y <= FTop - yyt * 2) or (Y > FBottom) or (X <= FLeft - xxt * 2) or
+    (X > FRight) then
+    Exit;
   if (Loc < 0) or (Loc >= G.lx * G.ly) then
     exit;
+    Exit;
   Tile := MyMap[Loc];
   if Tile and fTerrain >= fGrass then
     exit;
+    Exit;
   Conn := OceanConnection(Loc);
   if Conn = 0 then
     exit;
   BitBltBitmap(HGrTerrain.Data, x + xxt div 2, y, xxt, yyt,
+    Exit;
+  BitBltBitmap(HGrTerrain.Data, X + xxt div 2, Y, xxt, yyt,
 + (Conn shr 6 + Conn and 1 shl 2) * (xxt * 2 + 1),
 + yyt + (16 + Tile and fTerrain) * (yyt * 3 + 1), SRCPAINT);
   BitBltBitmap(HGrTerrain.Data, x + xxt, y + yyt div 2, xxt, yyt,
+  BitBltBitmap(HGrTerrain.Data, X + xxt, Y + yyt div 2, xxt, yyt,
 + (Conn and 7) * (xxt * 2 + 1) + xxt,
 + yyt * 2 + (16 + Tile and fTerrain) * (yyt * 3 + 1), SRCPAINT);
   BitBltBitmap(HGrTerrain.Data, x + xxt div 2, y + yyt, xxt, yyt,
+  BitBltBitmap(HGrTerrain.Data, X + xxt div 2, Y + yyt, xxt, yyt,
 + (Conn shr 2 and 7) * (xxt * 2 + 1) + xxt,
 + yyt + (16 + Tile and fTerrain) * (yyt * 3 + 1), SRCPAINT);
   BitBltBitmap(HGrTerrain.Data, x, y + yyt div 2, xxt, yyt,
+  BitBltBitmap(HGrTerrain.Data, X, Y + yyt div 2, xxt, yyt,
 + (Conn shr 4 and 7) * (xxt * 2 + 1),
 + yyt * 2 + (16 + Tile and fTerrain) * (yyt * 3 + 1), SRCPAINT);
   Conn := Connection4(Loc, fTerrain, fUNKNOWN); { dither to black }
   if Conn and 1 <> 0 then
     BitBltBitmap(HGrTerrain.Mask, x + xxt, y, xxt, yyt, 1 + 7 * (xxt * 2 + 1) +
+    BitBltBitmap(HGrTerrain.Mask, X + xxt, Y, xxt, yyt, 1 + 7 * (xxt * 2 + 1) +
       xxt, 1 + yyt + 15 * (yyt * 3 + 1), SRCAND);
   if Conn and 2 <> 0 then
     BitBltBitmap(HGrTerrain.Mask, x + xxt, y + yyt, xxt, yyt,
+    BitBltBitmap(HGrTerrain.Mask, X + xxt, Y + yyt, xxt, yyt,
 + 7 * (xxt * 2 + 1) + xxt, 1 + yyt * 2 + 15 * (yyt * 3 + 1), SRCAND);
   if Conn and 4 <> 0 then
     BitBltBitmap(HGrTerrain.Mask, x, y + yyt, xxt, yyt, 1 + 7 * (xxt * 2 + 1),
+    BitBltBitmap(HGrTerrain.Mask, X, Y + yyt, xxt, yyt, 1 + 7 * (xxt * 2 + 1),
 + yyt * 2 + 15 * (yyt * 3 + 1), SRCAND);
   if Conn and 8 <> 0 then
     BitBltBitmap(HGrTerrain.Mask, x, y, xxt, yyt, 1 + 7 * (xxt * 2 + 1),
+    BitBltBitmap(HGrTerrain.Mask, X, Y, xxt, yyt, 1 + 7 * (xxt * 2 + 1),
 + yyt + 15 * (yyt * 3 + 1), SRCAND);
 end;
 procedure TIsoMap.PaintTileExtraTerrain(x, y, Loc: integer);
 var
   Dir, Conn, RRConn, yGr, Tile, yLoc: integer;
 begin
   if (Loc < 0) or (Loc >= G.lx * G.ly) or (y <= -yyt * 2) or
     (y > FOutput.Height) or (x <= -xxt * 2) or (x > FOutput.Width) then
     exit;
+procedure TIsoMap.PaintTileExtraTerrain(X, Y, Loc: Integer);
+var
+  Dir, Conn, RRConn, yGr, Tile, yLoc: Integer;
+begin
+  if (Loc < 0) or (Loc >= G.lx * G.ly) or (Y <= -yyt * 2) or
+    (Y > FOutput.Height) or (X <= -xxt * 2) or (X > FOutput.Width) then
+    Exit;
   Tile := MyMap[Loc];
   if Tile and fTerrain = fForest then
 …
     then
       Conn := Conn and not 9; // no connection to north
     TSprite(x, y, yGr + Conn mod 8 + (Conn div 8) * TerrainIconCols);
+    TSprite(X, Y, yGr + Conn mod 8 + (Conn div 8) * TerrainIconCols);
   end
   else if Tile and fTerrain in [fHills, fMountains, fForest] then
 …
     yGr := 3 + 2 * (Tile and fTerrain - fForest);
     Conn := Connection4(Loc, fTerrain, Tile and fTerrain);
     TSprite(x, y, Conn mod 8 + (yGr + Conn div 8) * TerrainIconCols);
+    TSprite(X, Y, Conn mod 8 + (yGr + Conn div 8) * TerrainIconCols);
   end
   else if Tile and fDeadLands <> 0 then
     TSprite(x, y, spRow2);
+    TSprite(X, Y, spRow2);
   if ShowObjects then
   begin
     if Tile and fTerImp = tiFarm then
       TSprite(x, y, spFarmLand)
+      TSprite(X, Y, spFarmLand)
     else if Tile and fTerImp = tiIrrigation then
       TSprite(x, y, spIrrigation);
+      TSprite(X, Y, spIrrigation);
   end;
   if Tile and fRiver <> 0 then
 …
       Connection4(Loc, fTerrain, fShore) or Connection4(Loc, fTerrain,
       fUNKNOWN);
     TSprite(x, y, spRiver + Conn mod 8 + (Conn div 8) * TerrainIconCols);
+    TSprite(X, Y, spRiver + Conn mod 8 + (Conn div 8) * TerrainIconCols);
   end;
 …
     for Dir := 0 to 3 do
       if Conn and (1 shl Dir) <> 0 then { river mouths }
         TSprite(x, y, spRiverMouths + Dir);
+        TSprite(X, Y, spRiverMouths + Dir);
     if ShowObjects then
     begin
 …
       for Dir := 0 to 7 do
         if Conn and (1 shl Dir) <> 0 then { canal mouths }
           TSprite(x, y, spCanalMouths + 1 + Dir);
+          TSprite(X, Y, spCanalMouths + 1 + Dir);
     end;
   end;
 …
       if Conn = 0 then begin
         if Tile and fCanal <> 0 then
           TSprite(x, y, spCanal);
+          TSprite(X, Y, spCanal);
       end
       else
         for Dir := 0 to 7 do
           if (1 shl Dir) and Conn <> 0 then
             TSprite(x, y, spCanal + 1 + Dir);
+            TSprite(X, Y, spCanal + 1 + Dir);
     end;
 …
       Conn := Connection8(Loc, fRoad or fRR or fCity) and not RRConn;
       if (Conn = 0) and (Tile and (fRR or fCity) = 0) then
         TSprite(x, y, spRoad)
+        TSprite(X, Y, spRoad)
       else if Conn > 0 then
         for Dir := 0 to 7 do
           if (1 shl Dir) and Conn <> 0 then
             TSprite(x, y, spRoad + 1 + Dir);
+            TSprite(X, Y, spRoad + 1 + Dir);
     end;
     // Paint railroad connections
     if (Tile and fRR <> 0) and (RRConn = 0) then
       TSprite(x, y, spRailRoad)
+      TSprite(X, Y, spRailRoad)
     else if RRConn > 0 then begin
       for Dir := 0 to 7 do
         if (1 shl Dir) and RRConn <> 0 then
           TSprite(x, y, spRailRoad + 1 + Dir);
+          TSprite(X, Y, spRailRoad + 1 + Dir);
     end;
   end;
 …
 // (x,y) is top left pixel of (2*xxt,3*yyt) rectangle
 procedure TIsoMap.PaintTileObjects(x, y, Loc, CityLoc, CityOwner: integer;
   UseBlink: boolean);
 var
   p1, p2, uix, cix, dy, Loc1, Tile, Multi, Destination: integer;
+procedure TIsoMap.PaintTileObjects(X, Y, Loc, CityLoc, CityOwner: Integer;
+  UseBlink: Boolean);
+var
+  p1, p2, uix, cix, dy, Loc1, Tile, Multi, Destination: Integer;
   CityInfo: TCityInfo;
   UnitInfo: TUnitInfo;
   fog: boolean;
+  fog: Boolean;
   SpecialRow: Integer;
   SpecialCol: Integer;
 …
   procedure NameCity;
   var
     cix, xs, w: integer;
+    cix, xs, W: Integer;
     BehindCityInfo: TCityInfo;
     s: string;
     IsCapital: boolean;
+    S: string;
+    IsCapital: Boolean;
   begin
     BehindCityInfo.Loc := Loc - 2 * G.lx;
 …
       IsCapital := BehindCityInfo.Flags and ciCapital <> 0;
       { if Showuix and (cix>=0) then s:=IntToStr(cix)
         else } s := CityName(BehindCityInfo.ID);
       w := FOutput.Canvas.TextWidth(s);
       xs := x + xxt - (w + 1) div 2;
+        else } S := CityName(BehindCityInfo.ID);
+      W := FOutput.Canvas.TextWidth(S);
+      xs := X + xxt - (W + 1) div 2;
       if IsCapital then
         FOutput.Canvas.Font.Style := FOutput.Canvas.Font.Style + [fsUnderline];
       Textout(xs + 1, y - 9, $000000, s);
       Textout(xs, y - 10, $FFFFFF, s);
+      Textout(xs + 1, Y - 9, $000000, S);
+      Textout(xs, Y - 10, $FFFFFF, S);
       if IsCapital then
         FOutput.Canvas.Font.Style := FOutput.Canvas.Font.Style - [fsUnderline];
 …
     if ShowObjects and not (moEditMode in MapOptions) and
       (Tile and fCity <> 0) and (CityInfo.Flags and ciSpacePort <> 0) then
       TSprite(x + xxt, y - 6, spSpacePort);
+      TSprite(X + xxt, Y - 6, spSpacePort);
   end;
   procedure PaintBorder;
   var
     dx, dy: integer;
+    dx, dy: Integer;
   begin
     if ShowBorder and (Loc >= 0) and (Loc < G.lx * G.ly) and
       (Tile and fTerrain <> fUNKNOWN) then begin
       p1 := MyRO.Territory[Loc];
       if (p1 >= 0) and (ShowMyBorder or (p1 <> me)) then begin
+      if (p1 >= 0) and (ShowMyBorder or (p1 <> Me)) then begin
         if BordersOK^ and (1 shl p1) = 0 then begin
           UnshareBitmap(Borders);
           DpiBitCanvas(Borders.Canvas, 0, p1 * (yyt * 2), xxt * 2,
+          DpiBitBltCanvas(Borders.Canvas, 0, p1 * (yyt * 2), xxt * 2,
             yyt * 2, HGrTerrain.Data.Canvas,
 + 8 * (xxt * 2 + 1), 1 + yyt + 16 * (yyt * 3 + 1));
 …
               if p2 <> p1 then
               begin
                 BitBltBitmap(HGrTerrain.Mask, x + dx * xxt, y + dy * yyt, xxt,
+                BitBltBitmap(HGrTerrain.Mask, X + dx * xxt, Y + dy * yyt, xxt,
                   yyt, 1 + 8 * (xxt * 2 + 1) + dx * xxt,
 + yyt + 16 * (yyt * 3 + 1) + dy * yyt, SRCAND);
                 BitBltBitmap(Borders, x + dx * xxt, y + dy * yyt, xxt, yyt, dx * xxt,
+                BitBltBitmap(Borders, X + dx * xxt, Y + dy * yyt, xxt, yyt, dx * xxt,
                   p1 * (yyt * 2) + dy * yyt, SRCPAINT);
               end;
 …
     (Tile and fCity <> 0) then
     GetCityInfo(Loc, cix, CityInfo);
   if (y <= FTop - yyt * 2) or (y > FBottom) or (x <= FLeft - xxt * 2) or
     (x > FRight) then
+  if (Y <= FTop - yyt * 2) or (Y > FBottom) or (X <= FLeft - xxt * 2) or
+    (X > FRight) then
   begin
     NameCity;
     ShowSpacePort;
     exit;
+    Exit;
   end;
   if Tile and fTerrain = fUNKNOWN then
 …
     NameCity;
     ShowSpacePort;
     exit;
+    Exit;
   end; { square not discovered }
 …
   if (Loc >= 0) and (Loc < G.lx * G.ly) and (Loc = FAdviceLoc) then
     TSprite(x, y, spPlain);
+    TSprite(X, Y, spPlain);
   if (Loc >= 0) and (Loc < G.lx * G.ly) and (Tile and fSpecial <> 0)
 …
     SpecialRow := Tile and fSpecial shr 5;
     if SpecialCol < fForest then
       TSprite(x, y, SpecialCol + SpecialRow * TerrainIconCols)
+      TSprite(X, Y, SpecialCol + SpecialRow * TerrainIconCols)
     else if (SpecialCol = fForest) and IsJungle(dy) then
       TSprite(x, y, spJungle - 1 + SpecialRow * TerrainIconCols)
+      TSprite(X, Y, spJungle - 1 + SpecialRow * TerrainIconCols)
     else
       TSprite(x, y, spForest - 1 + ((SpecialCol - fForest) * 2 + SpecialRow) * TerrainIconCols);
+      TSprite(X, Y, spForest - 1 + ((SpecialCol - fForest) * 2 + SpecialRow) * TerrainIconCols);
   end;
 …
   begin
     if Tile and fTerImp = tiMine then
       TSprite(x, y, spMine);
+      TSprite(X, Y, spMine);
     if Tile and fTerImp = tiBase then
       TSprite(x, y, spBase);
+      TSprite(X, Y, spBase);
     if Tile and fPoll <> 0 then
       TSprite(x, y, spPollution);
+      TSprite(X, Y, spPollution);
     if Tile and fTerImp = tiFort then
     begin
       TSprite(x, y, spFortBack);
+      TSprite(X, Y, spFortBack);
       if Tile and fObserved = 0 then
         TSprite(x, y, spFortFront);
+        TSprite(X, Y, spFortFront);
     end;
   end;
   if (Tile and fDeadLands) <> 0 then
     TSprite(x, y, spMinerals + (Tile shr 25 and 3) * TerrainIconCols);
+    TSprite(X, Y, spMinerals + (Tile shr 25 and 3) * TerrainIconCols);
   if moEditMode in MapOptions then
 …
   if fog and ShowObjects then
     if Loc < -G.lx then
       Sprite(HGrTerrain, x, y + yyt, xxt * 2, yyt, 1 + 6 * (xxt * 2 + 1),
+      Sprite(HGrTerrain, X, Y + yyt, xxt * 2, yyt, 1 + 6 * (xxt * 2 + 1),
 + yyt * 2 + 15 * (yyt * 3 + 1))
     else if Loc >= G.lx * (G.ly + 1) then
       Sprite(HGrTerrain, x, y, xxt * 2, yyt, 1 + 6 * (xxt * 2 + 1),
+      Sprite(HGrTerrain, X, Y, xxt * 2, yyt, 1 + 6 * (xxt * 2 + 1),
 + yyt + 15 * (yyt * 3 + 1))
     else
       TSprite(x, y, spGrid, xxt <> 33);
+      TSprite(X, Y, spGrid, xxt <> 33);
   if FoW and (Tile and fObserved = 0) then
 …
     if (Destination = Loc) and (Destination <> MyUn[UnFocus].Loc) then
       if not UseBlink or BlinkOn then
         TSprite(x, y, spBlink1)
+        TSprite(X, Y, spBlink1)
       else
         TSprite(x, y, spBlink2)
+        TSprite(X, Y, spBlink2)
   end;
 {$ENDIF}
 …
   begin
     if Tile and fPrefStartPos <> 0 then
       TSprite(x, y, spPrefStartPos)
+      TSprite(X, Y, spPrefStartPos)
     else if Tile and fStartPos <> 0 then
       TSprite(x, y, spStartPos);
+      TSprite(X, Y, spStartPos);
   end
   else if ShowObjects then
   begin
     { if (CityLoc<0) and (UnFocus>=0) and (Loc=MyUn[UnFocus].Loc) then
       if BlinkOn then TSprite(x,y,8+9*0)
       else TSprite(x,y,8+9*1); }
+      if BlinkOn then TSprite(X,Y,8+9*0)
+      else TSprite(X,Y,8+9*1); }
     NameCity;
     ShowSpacePort;
     if Tile and fCity <> 0 then
       PaintCity(x + xxt, y + yyt, CityInfo, CityOwner < 0);
+      PaintCity(X + xxt, Y + yyt, CityInfo, CityOwner < 0);
     if (Tile and fUnit <> 0) and (Loc <> AttLoc) and
 …
         UnitInfo.Health := DefHealth;
       if (UnitInfo.Owner <> CityOwner) and
         not((CityOwner = me) and (MyRO.Treaty[UnitInfo.Owner] = trAlliance))
+        not((CityOwner = Me) and (MyRO.Treaty[UnitInfo.Owner] = trAlliance))
       then
 {$IFNDEF SCR} if (UnFocus >= 0) and (Loc = MyUn[UnFocus].Loc) then { active unit }
         begin
           Multi := UnitInfo.Flags and unMulti;
           MakeUnitInfo(me, MyUn[UnFocus], UnitInfo);
+          MakeUnitInfo(Me, MyUn[UnFocus], UnitInfo);
           UnitInfo.Flags := UnitInfo.Flags or Multi;
           PaintUnit(x + (xxt - xxu), y + (yyt - yyu_anchor), UnitInfo,
+          PaintUnit(X + (xxt - xxu), Y + (yyt - yyu_anchor), UnitInfo,
             MyUn[UnFocus].Status);
         end
         else if UnitInfo.Owner = me then
+        else if UnitInfo.Owner = Me then
         begin
           if ClientMode = cMovieTurn then
             PaintUnit(x + (xxt - xxu), y + (yyt - yyu_anchor), UnitInfo, 0)
+            PaintUnit(X + (xxt - xxu), Y + (yyt - yyu_anchor), UnitInfo, 0)
             // status is not set with precise timing during loading
           else
             PaintUnit(x + (xxt - xxu), y + (yyt - yyu_anchor), UnitInfo,
+            PaintUnit(X + (xxt - xxu), Y + (yyt - yyu_anchor), UnitInfo,
               MyUn[uix].Status);
           // if Showuix then Textout(x+16,y+5,$80FF00,IntToStr(uix));
         end
         else {$ENDIF} PaintUnit(x + (xxt - xxu), y + (yyt - yyu_anchor), UnitInfo, 0);
+        else {$ENDIF} PaintUnit(X + (xxt - xxu), Y + (yyt - yyu_anchor), UnitInfo, 0);
     end
     else if Tile and fHiddenUnit <> 0 then
       Sprite(HGrStdUnits, x + (xxt - xxu), y + (yyt - yyu_anchor), xxu * 2,
+      Sprite(HGrStdUnits, X + (xxt - xxu), Y + (yyt - yyu_anchor), xxu * 2,
         yyu * 2, 1 + 5 * (xxu * 2 + 1), 1)
     else if Tile and fStealthUnit <> 0 then
       Sprite(HGrStdUnits, x + (xxt - xxu), y + (yyt - yyu_anchor), xxu * 2,
+      Sprite(HGrStdUnits, X + (xxt - xxu), Y + (yyt - yyu_anchor), xxu * 2,
         yyu * 2, 1 + 5 * (xxu * 2 + 1), 1 + 1 * (yyu * 2 + 1))
   end;
 …
   if ShowObjects and (Tile and fTerImp = tiFort) and (Tile and fObserved <> 0)
   then
     TSprite(x, y, spFortFront);
+    TSprite(X, Y, spFortFront);
   if (Loc >= 0) and (Loc < G.lx * G.ly) then
     if ShowLoc then
       Textout(x + xxt - 16, y + yyt - 9, $FFFF00, IntToStr(Loc))
+      Textout(X + xxt - 16, Y + yyt - 9, $FFFF00, IntToStr(Loc))
     else if ShowDebug and (DebugMap <> nil) and (Loc >= 0) and
       (Loc < G.lx * G.ly) and (DebugMap[Loc] <> 0) then
       Textout(x + xxt - 16, y + yyt - 9, $00E0FF,
         IntToStr(integer(DebugMap[Loc])))
 end; { PaintTileObjects }
 procedure TIsoMap.PaintGrid(x, y, nx, ny: integer);
   procedure ClippedLine(dx0, dy0: integer; mirror: boolean);
+      Textout(X + xxt - 16, Y + yyt - 9, $00E0FF,
+        IntToStr(Integer(DebugMap[Loc])))
+end;
+procedure TIsoMap.PaintGrid(X, Y, nx, ny: Integer);
+  procedure ClippedLine(dx0, dy0: Integer; mirror: Boolean);
   var
     x0, x1, dxmin, dymin, dxmax, dymax, n: integer;
+    x0, x1, dxmin, dymin, dxmax, dymax, N: Integer;
   begin
     with FOutput.Canvas do
     begin
       dxmin := (FLeft - x) div xxt;
       dymin := (RealTop - y) div yyt;
       dxmax := (FRight - x - 1) div xxt + 1;
       dymax := (RealBottom - y - 1) div yyt + 1;
       n := dymax - dy0;
+      dxmin := (FLeft - X) div xxt;
+      dymin := (RealTop - Y) div yyt;
+      dxmax := (FRight - X - 1) div xxt + 1;
+      dymax := (RealBottom - Y - 1) div yyt + 1;
+      N := dymax - dy0;
       if mirror then
       begin
         if dx0 - dxmin < n then
           n := dx0 - dxmin;
+        if dx0 - dxmin < N then
+          N := dx0 - dxmin;
         if dx0 > dxmax then
         begin
           n := n - (dx0 - dxmax);
+          N := N - (dx0 - dxmax);
           dy0 := dy0 + (dx0 - dxmax);
           dx0 := dxmax
 …
         if dy0 < dymin then
         begin
           n := n - (dymin - dy0);
+          N := N - (dymin - dy0);
           dx0 := dx0 - (dymin - dy0);
           dy0 := dymin
 …
       else
       begin
         if dxmax - dx0 < n then
           n := dxmax - dx0;
+        if dxmax - dx0 < N then
+          N := dxmax - dx0;
         if dx0 < dxmin then
         begin
           n := n - (dxmin - dx0);
+          N := N - (dxmin - dx0);
           dy0 := dy0 + (dxmin - dx0);
           dx0 := dxmin
 …
         if dy0 < dymin then
         begin
           n := n - (dymin - dy0);
+          N := N - (dymin - dy0);
           dx0 := dx0 + (dymin - dy0);
           dy0 := dymin
         end;
       end;
       if n <= 0 then
         exit;
+      if N <= 0 then
+        Exit;
       if mirror then
       begin
         x0 := x + dx0 * xxt - 1;
         x1 := x + (dx0 - n) * xxt - 1;
+        x0 := X + dx0 * xxt - 1;
+        x1 := X + (dx0 - N) * xxt - 1;
       end
       else
       begin
         x0 := x + dx0 * xxt;
         x1 := x + (dx0 + n) * xxt;
+        x0 := X + dx0 * xxt;
+        x1 := X + (dx0 + N) * xxt;
       end;
       moveto(x0, y + dy0 * yyt);
       lineto(x1, y + (dy0 + n) * yyt);
+      moveto(x0, Y + dy0 * yyt);
+      lineto(x1, Y + (dy0 + N) * yyt);
     end;
   end;
 var
   i: integer;
+  I: Integer;
 begin
   FOutput.Canvas.pen.Color := $000000; // $FF shl (8*random(3));
   for i := 0 to nx div 2 do
     ClippedLine(i * 2, 0, false);
   for i := 1 to (nx + 1) div 2 do
     ClippedLine(i * 2, 0, true);
   for i := 0 to ny div 2 do
   begin
     ClippedLine(0, 2 * i + 2, false);
     ClippedLine(nx + 1, 2 * i + 1 + nx and 1, true);
   end;
 end;
 function TIsoMap.IsShoreTile(Loc: integer): boolean;
+  for I := 0 to nx div 2 do
+    ClippedLine(I * 2, 0, False);
+  for I := 1 to (nx + 1) div 2 do
+    ClippedLine(I * 2, 0, True);
+  for I := 0 to ny div 2 do
+  begin
+    ClippedLine(0, 2 * I + 2, False);
+    ClippedLine(nx + 1, 2 * I + 1 + nx and 1, True);
+  end;
+end;
+function TIsoMap.IsShoreTile(Loc: Integer): Boolean;
 var
   Dir: Integer;
   ConnLoc: integer;
 begin
   result := false;
+  ConnLoc: Integer;
+begin
+  Result := False;
   for Dir := 0 to 7 do
   begin
 …
     if (ConnLoc < 0) or (ConnLoc >= G.lx * G.ly) or
       ((MyMap[ConnLoc] - 2) and fTerrain < 13) then
       result := true;
+      Result := True;
   end;
 end;
 …
 begin
   for I := 0 to Length - 1 do begin
     Line^.Pixel^.B := (Line^.Pixel^.B shr 1) and $7f;
     Line^.Pixel^.G := (Line^.Pixel^.G shr 1) and $7f;
     Line^.Pixel^.R := (Line^.Pixel^.R shr 1) and $7f;
+    Line^.Pixel^.B := (Line^.Pixel^.B shr 1) and $7F;
+    Line^.Pixel^.G := (Line^.Pixel^.G shr 1) and $7F;
+    Line^.Pixel^.R := (Line^.Pixel^.R shr 1) and $7F;
     Line^.NextPixel;
   end;
 …
 end;
 procedure TIsoMap.ShadeOutside(x0, y0, Width, Height, xm, ym: integer);
+procedure TIsoMap.ShadeOutside(x0, y0, Width, Height, xm, ym: Integer);
 const
   rShade = 3.75;
 var
   y, wBright: integer;
   y_n, w_n: single;
+  Y, wBright: Integer;
+  y_n, w_n: Single;
   Line: TPixelPointer;
 begin
   FOutput.BeginUpdate;
   Line := PixelPointer(FOutput, ScaleToNative(x0), ScaleToNative(y0));
   for y := 0 to ScaleToNative(Height) - 1 do begin
     y_n := (ScaleFromNative(y) + y0 - ym) / yyt;
+  Line := TPixelPointer.Create(FOutput, ScaleToNative(x0), ScaleToNative(y0));
+  for Y := 0 to ScaleToNative(Height) - 1 do begin
+    y_n := (ScaleFromNative(Y) + y0 - ym) / yyt;
     if abs(y_n) < rShade then begin
       // Darken left and right parts of elipsis
 …
 end;
 procedure TIsoMap.CityGrid(xm, ym: integer; CityAllowClick: Boolean);
 var
   i: integer;
+procedure TIsoMap.CityGrid(xm, ym: Integer; CityAllowClick: Boolean);
+var
+  I: Integer;
 begin
   with FOutput.Canvas do
 …
       pen.Color := $000000;
     pen.Width := 1;
     for i := 0 to 3 do
+    for I := 0 to 3 do
     begin
       moveto(xm - xxt * (4 - i), ym + yyt * (1 + i));
       lineto(xm + xxt * (1 + i), ym - yyt * (4 - i));
       moveto(xm - xxt * (4 - i), ym - yyt * (1 + i));
       lineto(xm + xxt * (1 + i), ym + yyt * (4 - i));
+      moveto(xm - xxt * (4 - I), ym + yyt * (1 + I));
+      lineto(xm + xxt * (1 + I), ym - yyt * (4 - I));
+      moveto(xm - xxt * (4 - I), ym - yyt * (1 + I));
+      lineto(xm + xxt * (1 + I), ym + yyt * (4 - I));
     end;
     moveto(xm - xxt * 4, ym + yyt * 1);
 …
 end;
 procedure TIsoMap.Paint(x, y, Loc, nx, ny, CityLoc, CityOwner: integer;
   UseBlink: boolean; CityAllowClick: boolean);
 var
   dx, dy, xm, ym, ALoc, BLoc, ATer, BTer, Aix, bix: integer;
 begin
   FoW := true;
+procedure TIsoMap.Paint(X, Y, Loc, nx, ny, CityLoc, CityOwner: Integer;
+  UseBlink: Boolean; CityAllowClick: Boolean);
+var
+  dx, dy, xm, ym, ALoc, BLoc, ATer, BTer, Aix, bix: Integer;
+begin
+  FoW := True;
   ShowLoc := moLocCodes in MapOptions;
   ShowDebug := pDebugMap >= 0;
 …
   ShowCityNames := ShowObjects and (CityOwner < 0) and
     (moCityNames in MapOptions);
   ShowBorder := true;
+  ShowBorder := True;
   ShowMyBorder := CityOwner < 0;
   ShowGrWall := (CityOwner < 0) and (moGreatWall in MapOptions);
   if ShowDebug then
     Server(sGetDebugMap, me, pDebugMap, DebugMap)
+    Server(sGetDebugMap, Me, pDebugMap, DebugMap)
   else
     DebugMap := nil;
   with FOutput.Canvas do
   begin
     RealTop := y - ((Loc + 12345 * G.lx) div G.lx - 12345) * yyt;
     RealBottom := y + (G.ly - ((Loc + 12345 * G.lx) div G.lx - 12345) +
+    RealTop := Y - ((Loc + 12345 * G.lx) div G.lx - 12345) * yyt;
+    RealBottom := Y + (G.ly - ((Loc + 12345 * G.lx) div G.lx - 12345) +
 ) * yyt;
     Brush.Color := EmptySpaceColor;
 …
                   bix := 0;
                 end;
               BitBltBitmap(OceanPatch, x + dx * xxt, y + dy * yyt, xxt, yyt,
+              BitBltBitmap(OceanPatch, X + dx * xxt, Y + dy * yyt, xxt, yyt,
                 Aix * (xxt * 2) + (dx + dy + 1) and 1 * xxt, bix * yyt, SRCCOPY)
             end
 …
                 bix := Aix;
             if Aix = -1 then
               BitBltBitmap(HGrTerrain.Data, x + dx * xxt, y + dy * yyt, xxt,
+              BitBltBitmap(HGrTerrain.Data, X + dx * xxt, Y + dy * yyt, xxt,
                 yyt, 1 + 6 * (xxt * 2 + 1) + (dx + dy + 1) and 1 * xxt, 1 + yyt,
                 SRCCOPY) // arctic <-> ocean
             else if bix = -1 then
               BitBltBitmap(HGrTerrain.Data, x + dx * xxt, y + dy * yyt, xxt,
+              BitBltBitmap(HGrTerrain.Data, X + dx * xxt, Y + dy * yyt, xxt,
                 yyt, 1 + 6 * (xxt * 2 + 1) + xxt - (dx + dy + 1) and 1 * xxt,
 + yyt * 2, SRCCOPY) // arctic <-> ocean
             else
               BitBltBitmap(LandPatch, x + dx * xxt, y + dy * yyt, xxt, yyt,
+              BitBltBitmap(LandPatch, X + dx * xxt, Y + dy * yyt, xxt, yyt,
                 Aix * (xxt * 2) + (dx + dy + 1) and 1 * xxt, bix * yyt, SRCCOPY)
           end;
 …
     for dx := -1 to nx do
       if (dx + dy) and 1 = 0 then
         PaintShore(x + xxt * dx, y + yyt + yyt * dy, dLoc(Loc, dx, dy));
+        PaintShore(X + xxt * dx, Y + yyt + yyt * dy, dLoc(Loc, dx, dy));
   for dy := -2 to ny + 1 do
     for dx := -1 to nx do
       if (dx + dy) and 1 = 0 then
         PaintTileExtraTerrain(x + xxt * dx, y + yyt + yyt * dy,
+        PaintTileExtraTerrain(X + xxt * dx, Y + yyt + yyt * dy,
           dLoc(Loc, dx, dy));
   if CityOwner >= 0 then
 …
           ALoc := dLoc(Loc, dx, dy);
           if Distance(ALoc, CityLoc) > 5 then
             PaintTileObjects(x + xxt * dx, y + yyt + yyt * dy, ALoc, CityLoc,
+            PaintTileObjects(X + xxt * dx, Y + yyt + yyt * dy, ALoc, CityLoc,
               CityOwner, UseBlink);
         end;
 …
       * G.lx) mod (2 * G.lx) - G.lx;
     dy := CityLoc div G.lx - (Loc + 666 * G.lx) div G.lx + 666;
     xm := x + (dx + 1) * xxt;
     ym := y + (dy + 1) * yyt + yyt;
+    xm := X + (dx + 1) * xxt;
+    ym := Y + (dy + 1) * yyt + yyt;
     ShadeOutside(FLeft, FTop, FRight - FLeft, FBottom - FTop, xm, ym);
     CityGrid(xm, ym, CityAllowClick);
 …
           ALoc := dLoc(Loc, dx, dy);
           if Distance(ALoc, CityLoc) <= 5 then
             PaintTileObjects(x + xxt * dx, y + yyt + yyt * dy, ALoc, CityLoc,
+            PaintTileObjects(X + xxt * dx, Y + yyt + yyt * dy, ALoc, CityLoc,
               CityOwner, UseBlink);
         end;
 …
     if ShowLoc or (moEditMode in MapOptions) or
       (moGrid in MapOptions) then
       PaintGrid(x, y, nx, ny);
+      PaintGrid(X, Y, nx, ny);
     for dy := -2 to ny + 1 do
       for dx := -2 to nx + 1 do
         if (dx + dy) and 1 = 0 then
           PaintTileObjects(x + xxt * dx, y + yyt + yyt * dy, dLoc(Loc, dx, dy),
+          PaintTileObjects(X + xxt * dx, Y + yyt + yyt * dy, dLoc(Loc, dx, dy),
             CityLoc, CityOwner, UseBlink);
   end;
   // frame(FOutput.Canvas,x+1,y+1,x+nx*33+33-2,y+ny*16+32-2,$FFFF,$FFFF);
 end; { Paint }
+end;
 procedure TIsoMap.AttackBegin(const ShowMove: TShowMove);

branches/highdpi/LocalPlayer/KeyBindings.pas

-              r464
+              r465
+unit UKeyBindings;
+{$mode delphi}
+unit KeyBindings;
 interface
 uses
+  Classes, SysUtils, fgl, LCLProc, LCLType, Menus, Registry;
+  Classes, SysUtils, Generics.Collections, Generics.Defaults, LCLProc, LCLType,
+  Menus, Registry;
 type
 …
   { TKeyBindings }
   TKeyBindings = class(TFPGObjectList<TKeyBinding>)
+  TKeyBindings = class(TObjectList<TKeyBinding>)
   private
   public
 …
     procedure ResetToDefault;
     procedure RemoveShortCut(ShortCut: TShortCut);
+    procedure SortAlpha;
   end;
 …
   Text: string;
 begin
+  Strings.Clear;
+  for I := 0 to Count - 1 do begin
+    Text:= '';
+    if Items[I].ShortCut <> 0 then
+      Text:= Text + ShortCutToText(Items[I].ShortCut);
+    if Items[I].ShortCut2 <> 0 then begin
+      if Text <> '' then Text := Text + ', ';
+      Text:= Text + ShortCutToText(Items[I].ShortCut2);
+  Strings.BeginUpdate;
+  try
+    Strings.Clear;
+    for I := 0 to Count - 1 do begin
+      Text := '';
+      if Items[I].ShortCut <> 0 then
+        Text := Text + ShortCutToText(Items[I].ShortCut);
+      if Items[I].ShortCut2 <> 0 then begin
+        if Text <> '' then Text := Text + ', ';
+        Text := Text + ShortCutToText(Items[I].ShortCut2);
+      end;
+      if Text <> '' then Text := Items[I].FullName + ' (' + Text + ')'
+        else Text := Items[I].FullName;
+      Strings.Add(Text);
     end;
+    if Text <> '' then Text := Items[I].FullName + ' (' + Text + ')'
+      else Text := Items[I].FullName;
+    Strings.Add(Text);
+  finally
+    Strings.EndUpdate;
   end;
 end;
 …
     if Items[I].ShortCut2 = ShortCut then Items[I].ShortCut2 := 0;
   end;
+end;
+function CompareAlpha(constref Item1, Item2: TKeyBinding): Integer;
+begin
+  Result := CompareStr(Item1.FullName, Item2.FullName);
+end;
+procedure TKeyBindings.SortAlpha;
+begin
+  Sort(TComparer<TKeyBinding>.Construct(CompareAlpha));
 end;
 …
   BMoveLeftUp := AddItem('MoveLeftUp', 'Move unit left-up', 'Num7', 'Home');
   BMoveLeft := AddItem('MoveLeft', 'Move unit left', 'Num4', 'Left');
+  SortAlpha;
 end;
 …
 end.

branches/highdpi/LocalPlayer/LocalPlayer.pas

-              r378
+              r465
 interface
 procedure Client(Command, Player: integer; var Data); stdcall;
 procedure SetAIName(p: integer; Name: string);
+procedure Client(Command, Player: Integer; var Data); stdcall;
+procedure SetAIName(P: Integer; Name: string);
 implementation
 uses
+  UDpiControls, Term, CityScreen, Draft, MessgEx, Select, CityType, Help, UnitStat, Diagram,
+  NatStat, Wonders, Nego, Enhance, BaseWin, Battle, Rates, TechTree, Forms;
+  UDpiControls, Term, CityScreen, Nego, BaseWin, Forms;
 var
   FormsCreated: boolean;
+  FormsCreated: Boolean;
 procedure Client(Command, Player: integer; var Data);
+procedure Client(Command, Player: Integer; var Data);
 begin
   if not FormsCreated then
   begin
     FormsCreated := true;
+    FormsCreated := True;
     // TODO: Changing application name in runtime will cause change of Linux XML registry file path
 //    DpiApplication.MainForm := MainScreen;
+//    Application.MainForm := MainScreen;
     DpiApplication.CreateForm(TMainScreen, MainScreen);
-    DpiApplication.CreateForm(TCityDlg, CityDlg);
-    DpiApplication.CreateForm(TModalSelectDlg, ModalSelectDlg);
-    DpiApplication.CreateForm(TListDlg, ListDlg);
-    DpiApplication.CreateForm(TMessgExDlg, MessgExDlg);
-    DpiApplication.CreateForm(TDraftDlg, DraftDlg);
-    DpiApplication.CreateForm(TCityTypeDlg, CityTypeDlg);
-    DpiApplication.CreateForm(THelpDlg, HelpDlg);
-    DpiApplication.CreateForm(TUnitStatDlg, UnitStatDlg);
-    DpiApplication.CreateForm(TDiaDlg, DiaDlg);
-    DpiApplication.CreateForm(TNatStatDlg, NatStatDlg);
-    DpiApplication.CreateForm(TWondersDlg, WondersDlg);
-    DpiApplication.CreateForm(TNegoDlg, NegoDlg);
-    DpiApplication.CreateForm(TEnhanceDlg, EnhanceDlg);
-    DpiApplication.CreateForm(TBattleDlg, BattleDlg);
-    // DpiApplication.CreateForm(TAdvisorDlg, AdvisorDlg);
-    DpiApplication.CreateForm(TRatesDlg, RatesDlg);
-    DpiApplication.CreateForm(TTechTreeDlg, TechTreeDlg);
   end;
   MainScreen.Client(Command, Player, Data);
 end;
 procedure SetAIName(p: integer; Name: string);
+procedure SetAIName(P: Integer; Name: string);
 begin
   MainScreen.SetAIName(p, Name);
+  MainScreen.SetAIName(P, Name);
 end;
 initialization
 FormsCreated := false;
+FormsCreated := False;
 end.

branches/highdpi/LocalPlayer/MessgEx.lfm

-              r349
+              r465
   BorderIcons = []
   BorderStyle = bsNone
   Caption = 'C-evo'
+  Caption = 'Message'
   ClientHeight = 134
   ClientWidth = 418
 …
   DesignTimePPI = 144
   Font.Color = clWindowText
   Font.Height = -13
+  Font.Height = -20
   Font.Name = 'MS Sans Serif'
   FormStyle = fsStayOnTop
 …
   OnPaint = FormPaint
   OnShow = FormShow
   LCLVersion = '2.0.12.0'
+  LCLVersion = '2.2.2.0'
   Scaled = False
   object Button1: TButtonA
 …
   object EInput: TDpiEdit
     Left = 125
     Height = 26
+    Height = 27
     Top = 64
     Width = 168

branches/highdpi/LocalPlayer/MessgEx.pas

-              r412
+              r465
 uses
   UDpiControls, Messg, Protocol, ScreenTools, Platform, DateUtils,
   LCLIntf, LCLType, Messages, SysUtils, Classes, Graphics, Controls, Forms, ButtonA,
   ButtonB, StdCtrls, DrawDlg;
+  UDpiControls, Messg, Protocol, ScreenTools, Platform, DateUtils, LCLIntf, LCLType, Messages,
+  SysUtils, Classes, Graphics, Controls, Forms, ButtonA, ButtonB, StdCtrls,
+  DrawDlg, Help;
 type
 …
     mikPureIcon, mikMyArmy, mikEnemyArmy, mikFullControl, mikShip, mikBigIcon,
     mikEnemyShipComplete);
+  { TMessgExDlg }
   TMessgExDlg = class(TBaseMessgDlg)
 …
     Kind: TMessageKind;
     IconIndex: Integer;
     HelpKind: Integer;
+    HelpKind: TLinkCategory;
     HelpNo: Integer;
     CenterTo: Integer;
     IconKind: TMessageIconKind;
     OpenSound: string;
     function ShowModal: integer; override;
+    function ShowModal: Integer; override;
     procedure CancelMovie;
   private
     MovieCancelled: boolean;
     procedure PaintBook(ca: TDpiCanvas; x, y, clPage, clCover: integer);
+    MovieCancelled: Boolean;
+    procedure PaintBook(ca: TDpiCanvas; X, Y, clPage, clCover: Integer);
     procedure PaintMyArmy;
     procedure PaintEnemyArmy;
 …
   end;
-var
-  MessgExDlg: TMessgExDlg;
 procedure SoundMessageEx(SimpleText, SoundItem: string);
 procedure TribeMessage(p: integer; SimpleText, SoundItem: string);
+procedure TribeMessage(P: Integer; SimpleText, SoundItem: string);
 function SimpleQuery(QueryKind: TMessageKind; SimpleText, SoundItem: string)
   : integer;
+  : Integer;
 procedure ContextMessage(SimpleText, SoundItem: string;
+  ContextKind, ContextNo: integer);
+  ContextKind: TLinkCategory; ContextNo: Integer);
 implementation
 uses
   ClientTools, BaseWin, Term, Help, UnitStat, Tribes, UPixelPointer,
   IsoEngine, Diagram, Sound;
+  ClientTools, BaseWin, Term, UnitStat, Tribes, PixelPointer,
+  Diagram, Sound;
 {$R *.lfm}
 …
 procedure TMessgExDlg.FormShow(Sender: TObject);
 var
   i: integer;
+  I: Integer;
 begin
   if IconKind = mikEnemyArmy then
 …
   end;
   SplitText(true);
+  SplitText(True);
   ClientHeight := 72 + Border + TopSpace + Lines * MessageLineSpacing;
   if GameMode = cMovie then
 …
       end;
   end;
   for i := 0 to ControlCount - 1 do
     Controls[i].Top := ClientHeight - (34 + Border);
+  for I := 0 to ControlCount - 1 do
+    Controls[I].Top := ClientHeight - (34 + Border);
   if Kind = mkModel then
     EInput.Top := ClientHeight - (76 + Border);
 end;
 function TMessgExDlg.ShowModal: integer;
+function TMessgExDlg.ShowModal: Integer;
 var
   Ticks0: TDateTime;
   Ticks: TDateTime;
 begin
+  Caption := Phrases.Lookup('TITLE_MESSAGE');
   if GameMode = cMovie then
   begin
     if not((GameMode = cMovie) and (MovieSpeed = 4)) then
     begin
       MovieCancelled := false;
+      MovieCancelled := False;
       Show;
       Ticks0 := NowPrecise;
 …
       Hide;
     end;
     result := mrOk;
+    Result := mrOk;
   end
   else
+    result := inherited;
+    Result := inherited;
+  //Gtk2Fix;
 end;
 procedure TMessgExDlg.CancelMovie;
 begin
   MovieCancelled := true;
 end;
 procedure TMessgExDlg.PaintBook(ca: TDpiCanvas; x, y, clPage, clCover: integer);
+  MovieCancelled := True;
+end;
+procedure TMessgExDlg.PaintBook(ca: TDpiCanvas; X, Y, clPage, clCover: Integer);
 const
   xScrewed = 77;
 …
   wScrewed = 43;
   hScrewed = 27;
+type
+  TScrewed = array [0 .. wScrewed - 1, 0 .. hScrewed - 1, 0 .. 3] of Single;
 var
   ix, iy, xDst, yDst, dx, dy, xIcon, yIcon: integer;
+  ix, iy, xDst, yDst, dx, dy, xIcon, yIcon: Integer;
   BookRect: TRect;
   x1, xR, yR, share: single;
   Screwed: array [0 .. wScrewed - 1, 0 .. hScrewed - 1, 0 .. 3] of single;
+  x1, xR, yR, share: Single;
+  Screwed: TScrewed;
   SrcPtr: TPixelPointer;
   Width: Integer;
 …
     yIcon := (IconIndex + SystemIconLines * 7) div 7 * ySizeBig;
     // prepare screwed icon
     FillChar(Screwed, sizeof(Screwed), 0);
+    Screwed := Default(TScrewed);
     BigImp.BeginUpdate;
     SrcPtr := PixelPointer(BigImp, ScaleToNative(xIcon), ScaleToNative(yIcon));
+    SrcPtr := TPixelPointer.Create(BigImp, ScaleToNative(xIcon), ScaleToNative(yIcon));
     for iy := 0 to ScaleToNative(Height) - 1 do begin
       for ix := 0 to ScaleToNative(Width) - 1 do begin
 …
     BookRect := SmallBook.BoundsRect;
   end;
   x := x - BookRect.Width div 2;
+  X := X - BookRect.Width div 2;
   // paint
   UnshareBitmap(LogoBuffer);
   DpiBitCanvas(LogoBuffer.Canvas, 0, 0, BookRect.Width, BookRect.Height, ca, x, y);
+  DpiBitBltCanvas(LogoBuffer.Canvas, 0, 0, BookRect.Width, BookRect.Height, ca, X, Y);
   if IconIndex >= 0 then
 …
   ImageOp_BCC(LogoBuffer, Templates.Data, Point(0, 0), BookRect, clCover, clPage);
   DpiBitCanvas(ca, x, y, BookRect.Width, BookRect.Height, LogoBuffer.Canvas, 0, 0);
+  DpiBitBltCanvas(ca, X, Y, BookRect.Width, BookRect.Height, LogoBuffer.Canvas, 0, 0);
 end;
 …
 procedure TMessgExDlg.PaintEnemyArmy;
 var
   emix, ix, iy, x, y, count, UnitsInLine: integer;
+  emix, ix, iy, X, Y, count, UnitsInLine: Integer;
 begin
   ix := 0;
 …
     for count := 0 to LostArmy[emix] - 1 do
     begin
       x := ClientWidth div 2 + ix * 64 - UnitsInLine * 32;
       y := 26 + Border + TopSpace + Lines * MessageLineSpacing + iy * 48;
+      X := ClientWidth div 2 + ix * 64 - UnitsInLine * 32;
+      Y := 26 + Border + TopSpace + Lines * MessageLineSpacing + iy * 48;
       with MyRO.EnemyModel[emix], Tribe[Owner].ModelPicture[mix] do
       begin
         DpiBitCanvas(Canvas, x, y, 64, 48, HGr.Mask.Canvas,
+        DpiBitBltCanvas(Canvas, X, Y, 64, 48, HGr.Mask.Canvas,
           pix mod 10 * 65 + 1, pix div 10 * 49 + 1, SRCAND);
         DpiBitCanvas(Canvas, x, y, 64, 48, HGr.Data.Canvas,
+        DpiBitBltCanvas(Canvas, X, Y, 64, 48, HGr.Data.Canvas,
           pix mod 10 * 65 + 1, pix div 10 * 49 + 1, SRCPAINT);
       end;
       // next position
       inc(ix);
+      Inc(ix);
       if ix = LostUnitsPerLine then
       begin // next line
         ix := 0;
         inc(iy);
+        Inc(iy);
         if iy = 6 then
           exit;
+          Exit;
         UnitsInLine := nLostArmy - LostUnitsPerLine * iy;
         if UnitsInLine > LostUnitsPerLine then
 …
 procedure TMessgExDlg.FormPaint(Sender: TObject);
 var
   p1, clSaveTextLight, clSaveTextShade: integer;
+  p1, clSaveTextLight, clSaveTextShade: Integer;
 begin
   if (IconKind = mikImp) and (IconIndex = 27) then
 …
         p1 := MyRO.Wonder[IconIndex].EffectiveOwner;
         UnshareBitmap(Buffer);
         DpiBitCanvas(Buffer.Canvas, 0, 0, xSizeBig + 2 * GlowRange,
+        DpiBitBltCanvas(Buffer.Canvas, 0, 0, xSizeBig + 2 * GlowRange,
           ySizeBig + 2 * GlowRange, Canvas,
           ClientWidth div 2 - (28 + GlowRange), 24 - GlowRange);
         DpiBitCanvas(Buffer.Canvas, GlowRange, GlowRange, xSizeBig, ySizeBig,
+        DpiBitBltCanvas(Buffer.Canvas, GlowRange, GlowRange, xSizeBig, ySizeBig,
           BigImp.Canvas, IconIndex mod 7 * xSizeBig,
           (IconIndex + SystemIconLines * 7) div 7 * ySizeBig);
 …
           GlowFrame(Buffer, GlowRange, GlowRange, xSizeBig, ySizeBig,
             Tribe[p1].Color);
         DpiBitCanvas(Canvas, ClientWidth div 2 - (28 + GlowRange),
+        DpiBitBltCanvas(Canvas, ClientWidth div 2 - (28 + GlowRange),
 - GlowRange, xSizeBig + 2 * GlowRange, ySizeBig + 2 * GlowRange,
           Buffer.Canvas, 0, 0);
 …
       end;
     mikModel:
       with Tribe[me].ModelPicture[IconIndex] do
+      with Tribe[Me].ModelPicture[IconIndex] do
       begin
         FrameImage(Canvas, BigImp, ClientWidth div 2 - 28, 24, xSizeBig,
           ySizeBig, 0, 0);
         DpiBitCanvas(Canvas, ClientWidth div 2 - 32, 20, 64, 44,
+        DpiBitBltCanvas(Canvas, ClientWidth div 2 - 32, 20, 64, 44,
           HGr.Mask.Canvas, pix mod 10 * 65 + 1,
           pix div 10 * 49 + 1, SRCAND);
         DpiBitCanvas(Canvas, ClientWidth div 2 - 32, 20, 64, 44,
+        DpiBitBltCanvas(Canvas, ClientWidth div 2 - 32, 20, 64, 44,
           HGr.Data.Canvas, pix mod 10 * 65 + 1,
           pix div 10 * 49 + 1, SRCPAINT);
 …
         Frame(Canvas, ClientWidth div 2 - 32 - 1, 24 - 1,
           ClientWidth div 2 + 32, 24 + 48, $000000, $000000);
         DpiBitCanvas(Canvas, ClientWidth div 2 - 32, 24, 64, 48,
+        DpiBitBltCanvas(Canvas, ClientWidth div 2 - 32, 24, 64, 48,
           Tribe[IconIndex].faceHGr.Data.Canvas,
 + Tribe[IconIndex].facepix mod 10 * 65,
 …
     mikEnemyShipComplete:
       begin
         DpiBitCanvas(Buffer.Canvas, 0, 0, 140, 120, Canvas,
+        DpiBitBltCanvas(Buffer.Canvas, 0, 0, 140, 120, Canvas,
           (ClientWidth - 140) div 2, 24);
         ImageOp_BCC(Buffer, Templates.Data, Point(0, 0), StarshipDeparted.BoundsRect, 0, $FFFFFF);
         DpiBitCanvas(Canvas, (ClientWidth - 140) div 2, 24, 140, 120,
+        DpiBitBltCanvas(Canvas, (ClientWidth - 140) div 2, 24, 140, 120,
           Buffer.Canvas, 0, 0);
       end;
 …
 begin
   if Kind = mkOkHelp then
     HelpDlg.ShowNewContent(wmSubmodal, HelpKind, HelpNo)
+    MainScreen.HelpDlg.ShowNewContent(wmSubmodal, HelpKind, HelpNo)
   else if Kind = mkModel then
     UnitStatDlg.ShowNewContent_OwnModel(wmSubmodal, IconIndex)
+    MainScreen.UnitStatDlg.ShowNewContent_OwnModel(wmSubmodal, IconIndex)
   else
     ModalResult := mrIgnore;
 …
 // because Messg.SoundMessage not capable of movie mode
 begin
   with MessgExDlg do
+  with MainScreen.MessgExDlg do
   begin
     MessgText := SimpleText;
 …
 end;
 procedure TribeMessage(p: integer; SimpleText, SoundItem: string);
 begin
   with MessgExDlg do
+procedure TribeMessage(P: Integer; SimpleText, SoundItem: string);
+begin
+  with MainScreen.MessgExDlg do
   begin
     OpenSound := SoundItem;
 …
     Kind := mkOk;
     IconKind := mikTribe;
     IconIndex := p;
+    IconIndex := P;
     ShowModal;
   end;
 …
 function SimpleQuery(QueryKind: TMessageKind; SimpleText, SoundItem: string)
   : integer;
 begin
   with MessgExDlg do
+  : Integer;
+begin
+  with MainScreen.MessgExDlg do
   begin
     MessgText := SimpleText;
 …
     Kind := QueryKind;
     ShowModal;
     result := ModalResult;
+    Result := ModalResult;
   end;
 end;
 procedure ContextMessage(SimpleText, SoundItem: string;
   ContextKind, ContextNo: integer);
 begin
   with MessgExDlg do
+  ContextKind: TLinkCategory; ContextNo: Integer);
+begin
+  with MainScreen.MessgExDlg do
   begin
     MessgText := SimpleText;
 …
 end;
-initialization
 end.

branches/highdpi/LocalPlayer/NatStat.pas

-              r361
+              r465
 uses
+  UDpiControls, Protocol, ClientTools, Term, ScreenTools, BaseWin,
+  LCLIntf, LCLType, SysUtils, Classes, Graphics, Controls, Forms,
+  ButtonB, ButtonC, Menus, EOTButton;
+  UDpiControls, Protocol, ClientTools, ScreenTools, BaseWin, LCLIntf, LCLType, SysUtils,
+  Classes, Graphics, Controls, Forms, ButtonB, ButtonC, Menus, EOTButton;
 type
 …
     procedure ToggleBtnClick(Sender: TObject);
     procedure PlayerClick(Sender: TObject);
     procedure FormKeyDown(Sender: TObject; var Key: word; Shift: TShiftState);
+    procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
     procedure FormDestroy(Sender: TObject);
     procedure ScrollUpBtnClick(Sender: TObject);
     procedure ScrollDownBtnClick(Sender: TObject);
     procedure TellAIBtnClick(Sender: TObject);
   public
     procedure CheckAge;
     procedure ShowNewContent(NewMode: integer; p: integer = -1);
+    procedure ShowNewContent(NewMode: TWindowMode; P: Integer = -1);
     procedure EcoChange;
   protected
     procedure OffscreenPaint; override;
   private
+    pView, AgePrepared, LinesDown: integer;
+    SelfReport, CurrentReport: PEnemyReport;
+    ShowContact, ContactEnabled: boolean;
+    Back, Template: TDpiBitmap;
+    pView: Integer;
+    AgePrepared: Integer;
+    LinesDown: Integer;
+    SelfReport: PEnemyReport;
+    CurrentReport: PEnemyReport;
+    ShowContact: Boolean;
+    ContactEnabled: Boolean;
+    Back: TDpiBitmap;
+    Template: TDpiBitmap;
     ReportText: TStringList;
     procedure GenerateReportText;
   end;
-var
-  NatStatDlg: TNatStatDlg;
 implementation
 …
 uses
   Messg, Tribes, Directories;
+  Term, Messg, Tribes, Directories;
 const
 …
   if MainTexture.Age <> AgePrepared then begin
     AgePrepared := MainTexture.Age;
     DpiBitCanvas(Back.Canvas, 0, 0, ClientWidth, ClientHeight,
+    DpiBitBltCanvas(Back.Canvas, 0, 0, ClientWidth, ClientHeight,
       MainTexture.Image.Canvas, (MainTexture.Width - ClientWidth) div 2,
       (MainTexture.Height - ClientHeight) div 2);
 …
 procedure TNatStatDlg.FormShow(Sender: TObject);
 begin
   if pView = me then
+  if pView = Me then
   begin
     SelfReport.TurnOfCivilReport := MyRO.Turn;
     SelfReport.TurnOfMilReport := MyRO.Turn;
     move(MyRO.Treaty, SelfReport.Treaty, SizeOf(SelfReport.Treaty));
+    Move(MyRO.Treaty, SelfReport.Treaty, SizeOf(SelfReport.Treaty));
     SelfReport.Government := MyRO.Government;
     SelfReport.Money := MyRO.Money;
     CurrentReport := pointer(SelfReport);
+    CurrentReport := Pointer(SelfReport);
   end
   else
     CurrentReport := pointer(MyRO.EnemyReport[pView]);
+    CurrentReport := Pointer(MyRO.EnemyReport[pView]);
   if CurrentReport.TurnOfCivilReport >= 0 then
     GenerateReportText;
   ShowContact := (pView <> me) and (not supervising or (me <> 0));
   ContactEnabled := ShowContact and not supervising and
+  ShowContact := (pView <> Me) and (not Supervising or (Me <> 0));
+  ContactEnabled := ShowContact and not Supervising and
     (1 shl pView and MyRO.Alive <> 0);
   ContactBtn.Visible := ContactEnabled and (MyRO.Happened and phGameEnd = 0) and
 …
 end;
 procedure TNatStatDlg.ShowNewContent(NewMode, p: integer);
 begin
   if p < 0 then
+procedure TNatStatDlg.ShowNewContent(NewMode: TWindowMode; P: Integer);
+begin
+  if P < 0 then
     if ClientMode >= scContact then
       pView := DipMem[me].pContact
+      pView := DipMem[Me].pContact
     else
     begin
 …
       while (pView < nPl) and ((MyRO.Treaty[pView] < trNone) or
         (1 shl pView and MyRO.Alive = 0)) do
         inc(pView);
+        Inc(pView);
       if pView >= nPl then
         pView := me;
+        pView := Me;
     end
   else
     pView := p;
+    pView := P;
   inherited ShowNewContent(NewMode);
 end;
 …
   List: ^TChart;
   function StatText(no: integer): string;
+  function StatText(no: Integer): string;
   var
     i: integer;
+    I: Integer;
   begin
     if (CurrentReport.TurnOfCivilReport >= 0) and
       (Server(sGetChart + no shl 4, me, pView, List^) >= rExecuted) then
+      (Server(sGetChart + no shl 4, Me, pView, List^) >= rExecuted) then
     begin
       i := List[CurrentReport.TurnOfCivilReport];
+      I := List[CurrentReport.TurnOfCivilReport];
       case no of
         stPop:
           result := Format(Phrases.Lookup('FRSTATPOP'), [i]);
+          Result := Format(Phrases.Lookup('FRSTATPOP'), [I]);
         stTerritory:
           result := Format(Phrases.Lookup('FRSTATTER'), [i]);
+          Result := Format(Phrases.Lookup('FRSTATTER'), [I]);

Context Navigation

Legend: