Changeset 447 for trunk/CityProcessing.pas

Timestamp:

May 19, 2022, 10:39:34 PM (2 years ago)

Author:

chronos

Message:

• Modified: Use first capital letter in identifiers.

File:

• trunk/CityProcessing.pas (modified) (83 diffs)

trunk/CityProcessing.pas

@@ -8 +8 @@
 
 // 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
@@ -67 +67 @@
 
 var
-  MaxDist: integer;
+  MaxDist: Integer;
 
 {
@@ -73 +73 @@
   ____________________________________________________________________
 }
-procedure GetCityAreaInfo(p, Loc: integer; var CityAreaInfo: TCityAreaInfo);
-var
-  V21, Loc1, p1: integer;
+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
@@ -90 +90 @@
       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
@@ -104 +104 @@
 end;
 
-function CanCityGrow(p, cix: integer): boolean;
-begin
-  with RW[p].City[cix] do
-    result := (Size < MaxCitySize) and
+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;
@@ -151 +151 @@
 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;
@@ -158 +158 @@
     Poll := 0
   else
-    dec(Poll, ProdProcessing.PollThreshold);
+    Dec(Poll, ProdProcessing.PollThreshold);
   if ProdProcessing.FutProdBonus > 0 then
     Prod := BaseProd * (100 + ProdProcessing.ProdBonus * 50 +
@@ -166 +166 @@
 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;
@@ -237 +237 @@
 end;
 
-procedure SplitTrade(Trade, TaxRate, LuxRate, Working: integer;
+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);
@@ -276 +276 @@
 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;
@@ -380 +380 @@
           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:
@@ -454 +454 @@
 
       // 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);
 
@@ -472 +472 @@
           // 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
@@ -510 +510 @@
     end;
   end;
-  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;
+  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;
@@ -531 +531 @@
     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;
@@ -551 +551 @@
     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;
@@ -560 +560 @@
   ____________________________________________________________________
 }
-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);
@@ -580 +580 @@
       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;
@@ -600 +600 @@
 end;
 
-procedure NextWorst(p, cix: integer; var SelectedLoc, SelectedV21: integer);
+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;
@@ -610 +610 @@
   SelectedLoc := -1;
   SelectedV21 := -1;
-  with RW[p].City[cix] do
+  with RW[P].City[cix] do
   begin
     V21_to_Loc(Loc, Radius);
@@ -619 +619 @@
         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;
@@ -634 +634 @@
 end;
 
-function NextPoll(p, cix: integer): integer;
-var
-  Resources, Best, dx, dy, Loc1, Dist, BestDist, V21, pTerr: integer;
+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);
@@ -656 +656 @@
         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;
@@ -669 +669 @@
             then
             begin
-              result := Loc1;
+              Result := Loc1;
               Best := Resources;
               BestDist := Dist;
@@ -679 +679 @@
 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;
@@ -694 +694 @@
 end;
 
-procedure CityGrowth(p, cix: integer);
-var
-  TileLoc, V21: integer;
+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 }
@@ -708 +708 @@
       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;
@@ -720 +720 @@
 end;
 
-procedure CityShrink(p, cix: integer);
-var
-  TileLoc, V21, Working: integer;
+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;
@@ -746 +746 @@
       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;
@@ -758 +758 @@
 end;
 
-procedure Pollute(p, cix: integer);
-var
-  PollutionLoc: integer;
-begin
-  with RW[p].City[cix] do
+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;
@@ -778 +778 @@
   ____________________________________________________________________
 }
-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;
@@ -826 +826 @@
       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);
@@ -840 +840 @@
       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 }
@@ -849 +849 @@
           (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);
+        Inc(Money, Prod - CityProjectCost);
         Prod := CityProjectCost;
       end;
@@ -862 +862 @@
       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;
@@ -876 +876 @@
 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;
@@ -897 +897 @@
     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);
+          Dec(Food, CityStorage);
+        Inc(SizeMod);
       end;
     end
@@ -916 +916 @@
       // 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;
@@ -946 +946 @@
         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
@@ -963 +963 @@
               if TestDet < Det then
               begin
-                uix := i;
+                uix := I;
                 Det := TestDet;
               end;
@@ -969 +969 @@
         if uix >= 0 then
         begin
-          RemoveUnit_UpdateMap(p, uix);
-          inc(Flags, chUnitLost);
+          RemoveUnit_UpdateMap(P, uix);
+          Inc(Flags, chUnitLost);
         end;
       end;
@@ -984 +984 @@
       (GWonder[Project and cpIndex].CityID <> WonderNotBuiltYet) then
     begin
-      inc(Flags, chOldWonder);
-      DoProd := false;
+      Inc(Flags, chOldWonder);
+      DoProd := False;
     end;
 
@@ -995 +995 @@
       (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
@@ -1020 +1020 @@
               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;
@@ -1032 +1032 @@
       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
@@ -1038 +1038 @@
       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;
@@ -1045 +1045 @@
         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;
@@ -1056 +1056 @@
           case NewImp of
             imGrWall:
-              GrWallContinent[p] := Continent[Loc];
+              GrWallContinent[P] := Continent[Loc];
           end;
         end;
@@ -1063 +1063 @@
         begin // wonder
           GWonder[NewImp].CityID := ID;
-          GWonder[NewImp].EffectiveOwner := p;
+          GWonder[NewImp].EffectiveOwner := P;
           CheckExpiration(NewImp);
 
@@ -1070 +1070 @@
             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;
@@ -1101 +1101 @@
         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;
 
@@ -1123 +1123 @@
       end;
       Prod0 := Prod;
-      inc(Flags, chProduction);
+      Inc(Flags, chProduction);
     end
     else
@@ -1135 +1135 @@
     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);
+        CityShrink(P, cix);
+        Inc(SizeMod);
       end;
   end;
@@ -1152 +1152 @@
   ____________________________________________________________________
 }
-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
@@ -1167 +1167 @@
       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
@@ -1195 +1195 @@
         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
@@ -1211 +1211 @@
         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
@@ -1225 +1225 @@
 end;
 
-procedure GetCityTileAdvice(p, cix: integer; var Advice: TCityTileAdviceData);
+procedure GetCityTileAdvice(P, cix: Integer; var Advice: TCityTileAdviceData);
 const
   oFood = 0;
@@ -1240 +1240 @@
   end;
 var
-  i, V21, Loc1, nHierarchy, iH, iT, iH_Switch, MinWorking, MaxWorking,
+  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;
@@ -1255 +1255 @@
   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
@@ -1265 +1265 @@
     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;
@@ -1283 +1283 @@
   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
@@ -1300 +1300 @@
           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
@@ -1316 +1316 @@
               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;
@@ -1323 +1323 @@
       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;
@@ -1339 +1339 @@
       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
@@ -1376 +1376 @@
         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;
@@ -1388 +1388 @@
       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
@@ -1405 +1405 @@
               (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)
@@ -1411 +1411 @@
               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;
@@ -1438 +1438 @@
         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
@@ -1457 +1457 @@
     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;
@@ -1470 +1470 @@
       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;
@@ -1501 +1501 @@
         (ProdBeforeBoost < WantedProd)) do
       begin
-        assert(nSelection[iH] = 0);
+        Assert(nSelection[iH] = 0);
         Take := MinWorking - TestReport.Working;
         if Take > nTile[iH] then
@@ -1514 +1514 @@
           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,
@@ -1543 +1543 @@
           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
@@ -1591 +1591 @@
               then
               begin
-                inc(Output[oTax], Output[oFood]);
+                Inc(Output[oTax], Output[oFood]);
                 Output[oFood] := 0;
               end;
@@ -1603 +1603 @@
               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;
@@ -1613 +1613 @@
               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;
 
@@ -1643 +1643 @@
               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
@@ -1679 +1679 @@
         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
@@ -1690 +1690 @@
           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;
@@ -1713 +1713 @@
 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;