Changeset 465 for branches/highdpi/Database.pas

Timestamp:

Nov 30, 2023, 10:16:14 PM (12 months ago)

Author:

chronos

Message:

• Modified: Updated high dpi branch from trunk.
• Modified: Use generics.collections instead of fgl.
• Modified: Compile with Delphi syntax.

File:

• branches/highdpi/Database.pas (modified) (184 diffs)

branches/highdpi/Database.pas

@@ -26 +26 @@
 
   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;
@@ -50 +50 @@
   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;
@@ -58 +58 @@
   // 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;
@@ -65 +65 @@
   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 }
@@ -71 +71 @@
   // 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
@@ -179 +180 @@
 
 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
@@ -202 +203 @@
       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
@@ -211 +212 @@
       end
       else
-        inc(uix);
+        Inc(uix);
 
     // compact city list
@@ -218 +219 @@
       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
@@ -226 +227 @@
       end
       else
-        inc(cix);
+        Inc(cix);
 
     // compact enemy city list
@@ -233 +234 @@
       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-}
@@ -246 +247 @@
         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;
 
 {
@@ -256 +257 @@
   ____________________________________________________________________
 }
-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;
@@ -311 +312 @@
           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:
@@ -317 +318 @@
     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 -
     1 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;
@@ -358 +359 @@
           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
@@ -380 +381 @@
         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
@@ -403 +404 @@
       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;
 
@@ -483 +484 @@
   ____________________________________________________________________
 }
-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) -
@@ -504 +505 @@
 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!
@@ -526 +527 @@
   VicinityLoc[5] := Loc0 - lx0 * 2;
   VicinityLoc[7] := Loc0 + 1;
-  inc(Loc0, y0);
+  Inc(Loc0, y0);
   VicinityLoc[0] := Loc0 + lx0;
   VicinityLoc[2] := Loc0 + lx0 - 1;
@@ -537 +538 @@
     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;
@@ -565 +566 @@
   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);
@@ -582 +583 @@
       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;
@@ -597 +598 @@
 }
 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 }
@@ -641 +642 @@
 
 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 }
@@ -658 +659 @@
 
 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;
 
@@ -672 +673 @@
   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;
@@ -694 +695 @@
 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]
@@ -736 +737 @@
             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;
@@ -762 +763 @@
 // 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
@@ -772 +773 @@
   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
@@ -791 +792 @@
                 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;
 
@@ -814 +815 @@
   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
@@ -894 +895 @@
         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;
@@ -909 +910 @@
   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;
@@ -938 +939 @@
     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
@@ -960 +961 @@
     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 }
@@ -980 +981 @@
   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 }
@@ -1031 +1032 @@
       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
@@ -1061 +1062 @@
     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
@@ -1081 +1082 @@
     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;
 
@@ -1096 +1097 @@
   while plus < MapSize * LandMass * ShMountains div 10000 do
   begin
-    dec(bMountains);
-    inc(plus, ElCount[bMountains])
+    Dec(bMountains);
+    Inc(plus, ElCount[bMountains]);
   end;
   Count := plus;
@@ -1104 +1105 @@
   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;
 
@@ -1135 +1136 @@
           (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;
 
@@ -1147 +1148 @@
       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
@@ -1164 +1165 @@
     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
@@ -1202 +1203 @@
         Loc1 := CopyFrom[Loc1];
       RealMap[Loc0] := RealMap[Loc0] and not fTerrain or
-        RealMap[Loc1] and fTerrain
+        RealMap[Loc1] and fTerrain;
     end;
 
@@ -1225 +1226 @@
           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;
 
@@ -1241 +1242 @@
         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;
 
@@ -1278 +1279 @@
   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;
@@ -1304 +1305 @@
 
 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
@@ -1322 +1323 @@
   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 }
@@ -1331 +1332 @@
     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 }
@@ -1355 +1356 @@
         if p1 < nAlive + 1 then
           sc[p1] := sc[p1 - 1];
-        dec(p1)
+        Dec(p1);
       end;
       if p1 < nAlive + 1 then
@@ -1362 +1363 @@
   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;
 
@@ -1376 +1377 @@
   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;
@@ -1401 +1402 @@
               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;
@@ -1413 +1414 @@
     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;
 
@@ -1494 +1495 @@
         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
@@ -1528 +1529 @@
         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;
@@ -1549 +1550 @@
     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];
@@ -1585 +1586 @@
           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
@@ -1622 +1623 @@
       StartLoc0[nStartLoc0] := StartLoc0[nPrefStartLoc0];
       StartLoc0[nPrefStartLoc0] := Loc1;
-      inc(nPrefStartLoc0);
-      inc(nStartLoc0);
+      Inc(nPrefStartLoc0);
+      Inc(nStartLoc0);
       RealMap[Loc1] := RealMap[Loc1] and not fPrefStartPos;
     end
@@ -1629 +1630 @@
     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}
@@ -1670 +1671 @@
     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
@@ -1682 +1683 @@
   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);
@@ -1712 +1713 @@
           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;
@@ -1721 +1722 @@
           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 *
@@ -1731 +1732 @@
             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
@@ -1753 +1754 @@
 
   // 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;
@@ -1790 +1791 @@
   TerritoryCount[nPl] := MapSize;
   // fillchar(NewContact, sizeof(NewContact), false);
-end; // InitGame
+end;
 
 procedure InitRandomGame;
@@ -1797 +1798 @@
   CalculatePrimitive;
   CreateElevation;
-  CreateMap(false);
+  CreateMap(False);
   StartPositions;
   InitGame;
 end;
 
-procedure InitMapGame(Human: integer);
+procedure InitMapGame(Human: Integer);
 begin
   DelphiRandSeed := RND;
@@ -1812 +1813 @@
 procedure ReleaseGame;
 var
-  p1, p2: integer;
+  p1, p2: Integer;
 begin
   for p1 := 0 to nPl - 1 do
@@ -1834 +1835 @@
 procedure InitMapEditor;
 var
-  p1: integer;
+  p1: Integer;
 begin
   CalculatePrimitive;
@@ -1871 +1872 @@
 end;
 
-procedure EditTile(Loc, NewTile: integer);
-var
-  Loc1, V21: integer;
+procedure EditTile(Loc, NewTile: Integer);
+var
+  Loc1, V21: Integer;
   Radius: TVicinity21Loc;
 begin
@@ -1897 +1898 @@
     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
@@ -1921 +1922 @@
       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;
@@ -1931 +1932 @@
   ____________________________________________________________________
 }
-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;
@@ -1955 +1956 @@
     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
         3 = lObserveSuper)) then
         cix := -1
@@ -1962 +1963 @@
     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
@@ -1973 +1974 @@
       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];
@@ -1982 +1983 @@
       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
@@ -2002 +2003 @@
         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
@@ -2038 +2039 @@
     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;
@@ -2077 +2078 @@
     if PUn.Loc = Loc then
     begin
-      inc(Cnt);
+      Inc(Cnt);
       if PUn.Master < 0 then
       begin
@@ -2084 +2085 @@
           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
@@ -2103 +2104 @@
         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
@@ -2125 +2126 @@
 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
@@ -2148 +2149 @@
   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
@@ -2173 +2174 @@
         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;
@@ -2188 +2189 @@
 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;
@@ -2267 +2268 @@
 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
@@ -2282 +2283 @@
 
 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;
@@ -2289 +2290 @@
   mox: ^TModel;
 begin
-  result := false;
+  Result := False;
   with RW[pTell] do
   begin
@@ -2305 +2306 @@
         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;
@@ -2314 +2315 @@
             (1 shl trPeace or 1 shl TrFriendlyContact) <> 0 then
             AddFlags := AddFlags or fPeace;
-        end
+        end;
       end;
 
@@ -2332 +2333 @@
           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
@@ -2348 +2349 @@
             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
@@ -2363 +2364 @@
                 if (Loc1 >= 0) and (Loc1 < MapSize) then
                   Map[Loc1] := Map[Loc1] or fInEnemyZoC
-              end
+              end;
             end;
             if EnableContact and (mox.Domain = dGround) then
@@ -2373 +2374 @@
             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
@@ -2397 +2398 @@
           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
@@ -2420 +2421 @@
 
     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
@@ -2437 +2438 @@
       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
@@ -2458 +2459 @@
       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);
@@ -2498 +2499 @@
       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;
@@ -2518 +2519 @@
 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
@@ -2546 +2547 @@
             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
@@ -2574 +2575 @@
           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;
@@ -2581 +2582 @@
 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
@@ -2594 +2595 @@
     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
@@ -2644 +2645 @@
           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 }
@@ -2659 +2660 @@
           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
@@ -2681 +2682 @@
     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);
@@ -2691 +2692 @@
         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;
@@ -2703 +2704 @@
 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);
@@ -2725 +2726 @@
           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;
 
@@ -2755 +2756 @@
   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
@@ -2778 +2779 @@
 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
@@ -2793 +2794 @@
     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)
@@ -2812 +2813 @@
 // 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;
@@ -2827 +2828 @@
         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)
@@ -2861 +2862 @@
         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!
@@ -2870 +2871 @@
         (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
@@ -2885 +2886 @@
   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
@@ -2891 +2892 @@
         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
@@ -2905 +2906 @@
       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
@@ -2921 +2922 @@
               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;
@@ -2937 +2938 @@
       then
       begin
-        assert(OriginLoc <> -2); // test if border saving works
+        Assert(OriginLoc <> -2); // test if border saving works
         ChangeTerritory(Loc, NewOwner);
       end;
@@ -2944 +2945 @@
 {$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;
 
@@ -2957 +2958 @@
 }
 
-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;
@@ -2976 +2977 @@
       begin
         Fuel := Model[mix].Cap[mcFuel];
-        Flags := Flags or unBombsLoaded
+        Flags := Flags or unBombsLoaded;
       end;
       Job := jNone;
@@ -2984 +2985 @@
       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
@@ -3024 +3025 @@
 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;
@@ -3097 +3098 @@
 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;
@@ -3130 +3131 @@
     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);
@@ -3141 +3142 @@
       (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
@@ -3200 +3201 @@
         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
@@ -3230 +3231 @@
       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
@@ -3242 +3243 @@
     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);
@@ -3273 +3274 @@
     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;
 
@@ -3281 +3282 @@
 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
@@ -3327 +3328 @@
         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;
@@ -3339 +3340 @@
       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
@@ -3374 +3375 @@
           fPoll) or RealMap[Loc] and (fTerrain or fSpecial or fTerImp or
           fRoad or fRR or fCanal or fPoll);
-end; // CompleteJob
+end;
 
 {
@@ -3380 +3381 @@
   ____________________________________________________________________
 }
-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;
@@ -3395 +3396 @@
     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];
@@ -3409 +3410 @@
     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
@@ -3433 +3434 @@
 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
@@ -3451 +3452 @@
     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
@@ -3510 +3511 @@
       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
@@ -3528 +3529 @@
       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
@@ -3543 +3544 @@
           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
@@ -3550 +3551 @@
           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
@@ -3565 +3566 @@
 
       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!
@@ -3581 +3582 @@
 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
@@ -3591 +3592 @@
         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);
@@ -3606 +3607 @@
         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:
@@ -3628 +3629 @@
         begin // agreed treaty end
           if execute then
-            CancelTreaty(pSender, pTarget, false)
+            CancelTreaty(pSender, pTarget, False);
         end
         else
@@ -3639 +3640 @@
             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;
@@ -3671 +3672 @@
     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
@@ -3697 +3698 @@
         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
@@ -3717 +3718 @@
       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
@@ -3732 +3733 @@
       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
@@ -3764 +3765 @@
       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;
 
@@ -3779 +3780 @@
   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;
@@ -3815 +3816 @@
   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:
@@ -3831 +3832 @@
     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;
@@ -3867 +3868 @@
   ____________________________________________________________________
 }
-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
@@ -3878 +3879 @@
 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;
@@ -3895 +3896 @@
           begin // make p1 and p2 know each other
             if RW[p1].Treaty[p2] = trNoContact then
-              IntroduceEnemy(p1, p2)
+              IntroduceEnemy(p1, p2);
           end;
 
@@ -3904 +3905 @@
       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;
@@ -3920 +3921 @@
   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;
@@ -3938 +3939 @@
   ____________________________________________________________________
 }
-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
@@ -3951 +3951 @@
       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);
@@ -3959 +3959 @@
       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;
@@ -3981 +3981 @@
         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;
 
@@ -4000 +4000 @@
       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;
@@ -4007 +4007 @@
       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;
@@ -4022 +4022 @@
       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:
@@ -4045 +4045 @@
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetModelStatus P%d', [Player]);
         {$ENDIF}
-        RW[Player].Model[Subject].Status := integer(Data);
+        RW[Player].Model[Subject].Status := Integer(Data);
       end;
 
@@ -4053 +4053 @@
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetUnitStatus P%d', [Player]);
         {$ENDIF}
-        RW[Player].Un[Subject].Status := integer(Data);
+        RW[Player].Un[Subject].Status := Integer(Data);
       end;
 
@@ -4061 +4061 @@
 {$IFDEF TEXTLOG}CmdInfo := Format('IntSetCityStatus P%d', [Player]);
         {$ENDIF}
-        RW[Player].City[Subject].Status := integer(Data);
+        RW[Player].City[Subject].Status := Integer(Data);
       end;
 
@@ -4069 +4069 @@
 {$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.