Changeset 447 for trunk/UnitProcessing.pas

Timestamp:

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

Author:

chronos

Message:

• Modified: Use first capital letter in identifiers.

File:

• trunk/UnitProcessing.pas (modified) (64 diffs)

trunk/UnitProcessing.pas

@@ -13 +13 @@
   TMoveInfo = record
     MoveType: TMoveType;
-    Cost, ToMaster, EndHealth, Defender, Dcix, Duix, EndHealthDef: integer;
-    MountainDelay: boolean;
+    Cost, ToMaster, EndHealth, Defender, Dcix, Duix, EndHealthDef: Integer;
+    MountainDelay: Boolean;
   end;
 
 var
-  uixSelectedTransport: integer;
-  Worked: array [0 .. nPl - 1] of integer; { settler work statistics }
+  uixSelectedTransport: Integer;
+  Worked: array [0 .. nPl - 1] of Integer; { settler work statistics }
 
   // Moving/Combat
-function HostileDamage(p, mix, Loc, MP: integer): integer;
-function CalculateMove(p, uix, ToLoc, MoveLength: integer; TestOnly: boolean;
-  var MoveInfo: TMoveInfo): integer;
-function GetBattleForecast(Loc: integer; var BattleForecast: TBattleForecast;
-  var Duix, Dcix, AStr, DStr, ABaseDamage, DBaseDamage: integer): integer;
-function LoadUnit(p, uix: integer; TestOnly: boolean): integer;
-function UnloadUnit(p, uix: integer; TestOnly: boolean): integer;
-procedure Recover(p, uix: integer);
-function GetMoveAdvice(p, uix: integer; var a: TMoveAdviceData): integer;
-function CanPlaneReturn(p, uix: integer;
-  PlaneReturnData: TPlaneReturnData): boolean;
+function HostileDamage(P, mix, Loc, MP: Integer): Integer;
+function CalculateMove(P, uix, ToLoc, MoveLength: Integer; TestOnly: Boolean;
+  var MoveInfo: TMoveInfo): Integer;
+function GetBattleForecast(Loc: Integer; var BattleForecast: TBattleForecast;
+  var Duix, Dcix, AStr, DStr, ABaseDamage, DBaseDamage: Integer): Integer;
+function LoadUnit(P, uix: Integer; TestOnly: Boolean): Integer;
+function UnloadUnit(P, uix: Integer; TestOnly: Boolean): Integer;
+procedure Recover(P, uix: Integer);
+function GetMoveAdvice(P, uix: Integer; var A: TMoveAdviceData): Integer;
+function CanPlaneReturn(P, uix: Integer;
+  PlaneReturnData: TPlaneReturnData): Boolean;
 
 // Terrain Improvement
-function StartJob(p, uix, NewJob: integer; TestOnly: boolean): integer;
-function Work(p, uix: integer): boolean;
-function GetJobProgress(p, Loc: integer;
-  var JobProgressData: TJobProgressData): integer;
+function StartJob(P, uix, NewJob: Integer; TestOnly: Boolean): Integer;
+function Work(P, uix: Integer): Boolean;
+function GetJobProgress(P, Loc: Integer;
+  var JobProgressData: TJobProgressData): Integer;
 
 // Start/End Game
@@ -74 +74 @@
 
 type
-  TToWorkList = array [0 .. INFIN, 0 .. nJob - 1] of word;
+  TToWorkList = array [0 .. INFIN, 0 .. nJob - 1] of Word;
 
 var
@@ -83 +83 @@
     ____________________________________________________________________
   }
-function HostileDamage(p, mix, Loc, MP: integer): integer;
-var
-  Tile: integer;
+function HostileDamage(P, mix, Loc, MP: Integer): Integer;
+var
+  Tile: Integer;
 begin
   Tile := RealMap[Loc];
-  if (RW[p].Model[mix].Domain >= dSea) or (RW[p].Model[mix].Kind = mkSettler)
-    and (RW[p].Model[mix].Speed >= 200) or
+  if (RW[P].Model[mix].Domain >= dSea) or (RW[P].Model[mix].Kind = mkSettler)
+    and (RW[P].Model[mix].Speed >= 200) or
     (Tile and (fCity or fRiver or fCanal) <> 0) or (Tile and fTerImp = tiBase)
-    or (GWonder[woGardens].EffectiveOwner = p) then
-    result := 0
+    or (GWonder[woGardens].EffectiveOwner = P) then
+    Result := 0
   else if (Tile and fTerrain = fDesert) and
     (Tile and fSpecial <> fSpecial1 { Oasis } ) then
   begin
-    assert((Tile and fTerImp <> tiIrrigation) and (Tile and fTerImp <> tiFarm));
-    result := (DesertThurst * MP - 1) div RW[p].Model[mix].Speed + 1
+    Assert((Tile and fTerImp <> tiIrrigation) and (Tile and fTerImp <> tiFarm));
+    Result := (DesertThurst * MP - 1) div RW[P].Model[mix].Speed + 1
   end
   else if Tile and fTerrain = fArctic then
   begin
-    assert((Tile and fTerImp <> tiIrrigation) and (Tile and fTerImp <> tiFarm));
-    result := (ArcticThurst * MP - 1) div RW[p].Model[mix].Speed + 1
+    Assert((Tile and fTerImp <> tiIrrigation) and (Tile and fTerImp <> tiFarm));
+    Result := (ArcticThurst * MP - 1) div RW[P].Model[mix].Speed + 1
   end
   else
-    result := 0
-end;
-
-function Controlled(p, Loc: integer; IsDest: boolean): integer;
+    Result := 0;
+end;
+
+function Controlled(P, Loc: Integer; IsDest: Boolean): Integer;
 { whether tile at Loc is in control zone of enemy unit
   returns combination of tile control flags }
 var
-  Loc1, V8: integer;
+  Loc1, V8: Integer;
   Adjacent: TVicinity8Loc;
 begin
-  result := 0;
-  if IsDest and (Occupant[Loc] = p) and (ZoCMap[Loc] > 0) then
-    exit;
+  Result := 0;
+  if IsDest and (Occupant[Loc] = P) and (ZoCMap[Loc] > 0) then
+    Exit;
   // destination tile, not controlled if already occupied
 
-  if (RealMap[Loc] and fCity = 0) or (integer(RealMap[Loc] shr 27) <> p) and
-    (ServerVersion[p] >= $000EF0) then
+  if (RealMap[Loc] and fCity = 0) or (Integer(RealMap[Loc] shr 27) <> P) and
+    (ServerVersion[P] >= $000EF0) then
   begin // not own city
     V8_to_Loc(Loc, Adjacent);
@@ -128 +128 @@
       Loc1 := Adjacent[V8];
       if (Loc1 >= 0) and (Loc1 < MapSize) and (ZoCMap[Loc1] > 0) and
-        (Occupant[Loc1] >= 0) and (Occupant[Loc1] <> p) and
-        (RW[p].Treaty[Occupant[Loc1]] < trAlliance) then
-        if ObserveLevel[Loc1] and (3 shl (p * 2)) > 0 then
+        (Occupant[Loc1] >= 0) and (Occupant[Loc1] <> P) and
+        (RW[P].Treaty[Occupant[Loc1]] < trAlliance) then
+        if ObserveLevel[Loc1] and (3 shl (P * 2)) > 0 then
         begin // p observes tile
-          result := coKnown or coTrue;
-          exit;
+          Result := coKnown or coTrue;
+          Exit;
         end
         else
-          result := coTrue; // p does not observe tile
+          Result := coTrue; // p does not observe tile
     end;
   end;
 end;
 
-function GetMoveCost(p, mix, FromLoc, ToLoc, MoveLength: integer;
-  var MoveCost: integer): integer;
+function GetMoveCost(P, mix, FromLoc, ToLoc, MoveLength: Integer;
+  var MoveCost: Integer): Integer;
 // MoveLength - 2 for short move, 3 for long move
 var
-  FromTile, ToTile: integer;
-begin
-  result := eOK;
+  FromTile, ToTile: Integer;
+begin
+  Result := eOK;
   FromTile := RealMap[FromLoc];
   ToTile := RealMap[ToLoc];
-  with RW[p].Model[mix] do
+  with RW[P].Model[mix] do
   begin
     case Domain of
@@ -160 +160 @@
           if (FromTile and (fRR or fCity) <> 0) and
             (ToTile and (fRR or fCity) <> 0) then
-            if GWonder[woShinkansen].EffectiveOwner = p then
+            if GWonder[woShinkansen].EffectiveOwner = P then
               MoveCost := 0
             else
@@ -174 +174 @@
               MoveCost := 20
           else if Cap[mcOver] > 0 then
-            result := eNoRoad
+            Result := eNoRoad
           else
             case Terrain[ToTile and fTerrain].MoveCost of
@@ -181 +181 @@
               2:
                 begin
-                  assert(Speed - 150 <= 600);
+                  Assert(Speed - 150 <= 600);
                   MoveCost := 50 + (Speed - 150) * 13 shr 7; // heavy terrain
                 end;
@@ -187 +187 @@
                 begin
                   MoveCost := Speed;
-                  result := eMountains;
-                  exit;
+                  Result := eMountains;
+                  Exit;
                 end;
             end;
@@ -194 +194 @@
         end
         else
-          result := eDomainMismatch;
+          Result := eDomainMismatch;
 
       dSea:
@@ -202 +202 @@
             MoveCost := 50 * MoveLength { valid move }
           else
-            result := eNoNav { navigation required for open sea }
-        else
-          result := eDomainMismatch;
+            Result := eNoNav { navigation required for open sea }
+        else
+          Result := eDomainMismatch;
 
       dAir:
@@ -212 +212 @@
 end;
 
-function CalculateMove(p, uix, ToLoc, MoveLength: integer; TestOnly: boolean;
-  var MoveInfo: TMoveInfo): integer;
+function CalculateMove(P, uix, ToLoc, MoveLength: Integer; TestOnly: Boolean;
+  var MoveInfo: TMoveInfo): Integer;
 var
   uix1, p1, FromLoc, DestControlled, AStr, DStr, ABaseDamage,
-    DBaseDamage: integer;
+    DBaseDamage: Integer;
   PModel: ^TModel;
   BattleForecast: TBattleForecast;
 begin
-  with RW[p], Un[uix] do
+  with RW[P], Un[uix] do
   begin
     PModel := @Model[mix];
     FromLoc := Loc;
 
-    BattleForecast.pAtt := p;
+    BattleForecast.pAtt := P;
     BattleForecast.mixAtt := mix;
     BattleForecast.HealthAtt := Health;
@@ -231 +231 @@
     BattleForecast.FlagsAtt := Flags;
     BattleForecast.Movement := Movement;
-    result := GetBattleForecast(ToLoc, BattleForecast, MoveInfo.Duix,
+    Result := GetBattleForecast(ToLoc, BattleForecast, MoveInfo.Duix,
       MoveInfo.Dcix, AStr, DStr, ABaseDamage, DBaseDamage);
 
-    if result = eHiddenUnit then
+    if Result = eHiddenUnit then
       if TestOnly then
-        result := eOK // behave just like unit was moving
+        Result := eOK // behave just like unit was moving
       else if Mode > moLoading_Fast then
         Map[ToLoc] := Map[ToLoc] or fHiddenUnit;
-    if result = eStealthUnit then
+    if Result = eStealthUnit then
       if TestOnly then
-        result := eOK // behave just like unit was moving
+        Result := eOK // behave just like unit was moving
       else if Mode > moLoading_Fast then
         Map[ToLoc] := Map[ToLoc] or fStealthUnit;
-    if result < rExecuted then
-      exit;
-
-    case result of
+    if Result < rExecuted then
+      Exit;
+
+    case Result of
       eOK:
         MoveInfo.MoveType := mtMove;
@@ -261 +261 @@
       begin
         p1 := RealMap[ToLoc] shr 27;
-        if (p1 < nPl) and (p1 <> p) and
+        if (p1 < nPl) and (p1 <> P) and
           ((RealMap[Loc] shr 27 <> Cardinal(p1)) and (PModel.Kind <> mkDiplomat)
           and (Treaty[p1] >= trPeace) and (Treaty[p1] < trAlliance) or
           (RealMap[ToLoc] and fCity <> 0) and (Treaty[p1] >= trPeace)) then
         begin
-          result := eTreaty;
-          exit;
+          Result := eTreaty;
+          Exit;
         end; // keep peace treaty!
       end;
       if (RealMap[ToLoc] and fCity <> 0) and
-        (RealMap[ToLoc] shr 27 <> Cardinal(p)) then // empty enemy city
+        (RealMap[ToLoc] shr 27 <> Cardinal(P)) then // empty enemy city
         if PModel.Kind = mkDiplomat then
         begin
@@ -280 +280 @@
           if PModel.Flags and mdCivil <> 0 then
           begin
-            result := eNoCapturer;
-            exit;
+            Result := eNoCapturer;
+            Exit;
           end;
           MoveInfo.MoveType := mtCapture;
@@ -289 +289 @@
           if (PModel.Domain = dSea) and (PModel.Cap[mcArtillery] = 0) then
           begin
-            result := eDomainMismatch;
-            exit;
+            Result := eDomainMismatch;
+            Exit;
           end
           else if (PModel.Attack = 0) and
@@ -296 +296 @@
           then
           begin
-            result := eNoBombarder;
-            exit;
+            Result := eNoBombarder;
+            Exit;
           end
           else if Movement < 100 then
           begin
-            result := eNoTime_Bombard;
-            exit;
+            Result := eNoTime_Bombard;
+            Exit;
           end;
           MoveInfo.MoveType := mtBombard;
-          result := eBombarded;
-        end;
-    end;
-
-    MoveInfo.MountainDelay := false;
+          Result := eBombarded;
+        end;
+    end;
+
+    MoveInfo.MountainDelay := False;
     if MoveInfo.MoveType in [mtAttack, mtBombard, mtExpel] then
     begin
@@ -317 +317 @@
       then
       begin
-        result := eViolation;
-        exit
+        Result := eViolation;
+        Exit;
       end;
       if MoveInfo.MoveType = mtBombard then
@@ -337 +337 @@
         MoveInfo.Cost := PModel.Speed;
         if RealMap[ToLoc] and fTerrain < fGrass then
-          result := eDomainMismatch;
+          Result := eDomainMismatch;
       end
       else
       begin
-        result := GetMoveCost(p, mix, FromLoc, ToLoc, MoveLength,
+        Result := GetMoveCost(P, mix, FromLoc, ToLoc, MoveLength,
           MoveInfo.Cost);
-        if result = eMountains then
-        begin
-          result := eOK;
-          MoveInfo.MountainDelay := true
+        if Result = eMountains then
+        begin
+          Result := eOK;
+          MoveInfo.MountainDelay := True
         end;
       end;
-      if (result >= rExecuted) and (MoveInfo.MoveType = mtSpyMission) then
-        result := eMissionDone;
+      if (Result >= rExecuted) and (MoveInfo.MoveType = mtSpyMission) then
+        Result := eMissionDone;
 
       MoveInfo.ToMaster := -1;
-      if (result = eDomainMismatch) and (PModel.Domain < dSea) and
+      if (Result = eDomainMismatch) and (PModel.Domain < dSea) and
         (PModel.Cap[mcOver] = 0) then
       begin
@@ -361 +361 @@
               (TroopLoad < Model[mix].MTrans * Model[mix].Cap[mcSeaTrans]) then
             begin
-              result := eLoaded;
+              Result := eLoaded;
               MoveInfo.Cost := PModel.Speed;
               MoveInfo.ToMaster := uix1;
@@ -378 +378 @@
               (AirLoad < Model[mix].MTrans * Model[mix].Cap[mcCarrier]) then
             begin // load plane to ship
-              result := eLoaded;
+              Result := eLoaded;
               MoveInfo.ToMaster := uix1;
               if (uixSelectedTransport >= 0) and (uix1 = uixSelectedTransport)
@@ -385 +385 @@
             end;
       end;
-      if result < rExecuted then
-        exit;
+      if Result < rExecuted then
+        Exit;
 
       if (Master < 0) and (MoveInfo.ToMaster < 0) then
-        MoveInfo.EndHealth := Health - HostileDamage(p, mix, ToLoc,
+        MoveInfo.EndHealth := Health - HostileDamage(P, mix, ToLoc,
           MoveInfo.Cost)
       else
@@ -395 +395 @@
 
       if (Mode = moPlaying) and (PModel.Flags and mdZOC <> 0) and (Master < 0)
-        and (MoveInfo.ToMaster < 0) and (Controlled(p, FromLoc, false) >= coTrue)
+        and (MoveInfo.ToMaster < 0) and (Controlled(P, FromLoc, False) >= coTrue)
       then
       begin
-        DestControlled := Controlled(p, ToLoc, true);
+        DestControlled := Controlled(P, ToLoc, True);
         if DestControlled >= coTrue + coKnown then
         begin
-          result := eZOC;
-          exit;
+          Result := eZOC;
+          Exit;
         end
         else if not TestOnly and (DestControlled >= coTrue) then
         begin
-          result := eZOC_EnemySpotted;
-          exit;
+          Result := eZOC_EnemySpotted;
+          Exit;
         end;
       end;
-      if (Movement = 0) and (ServerVersion[p] >= $0100F1) or
+      if (Movement = 0) and (ServerVersion[P] >= $0100F1) or
         (MoveInfo.Cost > Movement) then
         if (Master >= 0) or (MoveInfo.ToMaster >= 0) then
         begin
-          result := eNoTime_Load;
-          exit;
+          Result := eNoTime_Load;
+          Exit;
         end
         else
         begin
-          result := eNoTime_Move;
-          exit;
+          Result := eNoTime_Move;
+          Exit;
         end;
       if (MoveInfo.EndHealth <= 0) or (MoveInfo.MoveType = mtSpyMission) then
-        result := result or rUnitRemoved;
+        Result := Result or rUnitRemoved;
       // spy mission or victim of HostileDamage
 
@@ -438 +438 @@
 end;
 
-function GetBattleForecast(Loc: integer; var BattleForecast: TBattleForecast;
-  var Duix, Dcix, AStr, DStr, ABaseDamage, DBaseDamage: integer): integer;
-var
-  Time, Defender, ABon, DBon, DCnt, MultiDamage: integer;
+function GetBattleForecast(Loc: Integer; var BattleForecast: TBattleForecast;
+  var Duix, Dcix, AStr, DStr, ABaseDamage, DBaseDamage: Integer): Integer;
+var
+  Time, Defender, ABon, DBon, DCnt, MultiDamage: Integer;
   PModel, DModel: ^TModel;
 begin
@@ -449 +449 @@
     if (Defender < 0) or (Defender = pAtt) then
     begin
-      result := eOK;
-      exit;
+      Result := eOK;
+      Exit;
     end; // no attack, simple move
 
@@ -459 +459 @@
       EndHealthAtt := HealthAtt;
       EndHealthDef := RW[Defender].Un[Duix].Health;
-      result := eOK;
-      exit;
+      Result := eOK;
+      Exit;
     end;
 
@@ -470 +470 @@
         (ObserveLevel[Loc] shr (2 * pAtt) and 3 < lObserveAll) then
       begin
-        result := eHiddenUnit;
-        exit;
+        Result := eHiddenUnit;
+        Exit;
       end; // attacking submarine not allowed
       if (DModel.Cap[mcStealth] > 0) and
         (ObserveLevel[Loc] shr (2 * pAtt) and 3 <> lObserveSuper) then
       begin
-        result := eStealthUnit;
-        exit;
+        Result := eStealthUnit;
+        Exit;
       end; // attacking stealth aircraft not allowed
       if (DModel.Domain = dAir) and (DModel.Kind <> mkSpecial_Glider) and
         (PModel.Domain <> dAir) then
       begin
-        result := eDomainMismatch;
-        exit;
+        Result := eDomainMismatch;
+        Exit;
       end; // can't attack plane
     end;
@@ -492 +492 @@
       (PModel.Domain = dSea) and (RealMap[Loc] and fTerrain >= fGrass)) then
     begin
-      result := eDomainMismatch;
-      exit;
+      Result := eDomainMismatch;
+      Exit;
     end;
     if (PModel.Attack = 0) and not((PModel.Cap[mcBombs] > 0) and
       (FlagsAtt and unBombsLoaded <> 0) and (DModel.Domain < dAir)) then
     begin
-      result := eInvalid;
-      exit;
+      Result := eInvalid;
+      Exit;
     end;
 
     if Movement = 0 then
     begin
-      result := eNoTime_Attack;
-      exit;
-    end;
-
-{$IFOPT O-}assert(InvalidTreatyMap = 0); {$ENDIF}
+      Result := eNoTime_Attack;
+      Exit;
+    end;
+
+{$IFOPT O-}Assert(InvalidTreatyMap = 0); {$ENDIF}
     if RW[pAtt].Treaty[Defender] >= trPeace then
     begin
       if (PModel.Domain <> dAir) and (PModel.Attack > 0) and
-        (integer(RealMap[Loc] shr 27) = pAtt) then
+        (Integer(RealMap[Loc] shr 27) = pAtt) then
         if Movement >= 100 then
         begin // expel friendly unit
           EndHealthDef := RW[Defender].Un[Duix].Health;
           EndHealthAtt := HealthAtt;
-          result := eExpelled
+          Result := eExpelled
         end
         else
-          result := eNoTime_Expel
+          Result := eNoTime_Expel
       else
-        result := eTreaty;
-      exit;
+        Result := eTreaty;
+      Exit;
     end;
 
@@ -534 +534 @@
         (Continent[RW[Defender].City[Dcix].Loc] = GrWallContinent[Defender]))
       then
-        inc(DBon, 8)
+        Inc(DBon, 8)
       else if (PModel.Domain = dSea) and
         (RW[Defender].City[Dcix].Built[imCoastalFort] = 1) then
-        inc(DBon, 4)
+        Inc(DBon, 4)
       else if (PModel.Domain = dAir) and
         (RW[Defender].City[Dcix].Built[imMissileBat] = 1) then
-        inc(DBon, 4);
+        Inc(DBon, 4);
       if RW[Defender].City[Dcix].Built[imBunker] = 1 then
-        inc(DBon, 4)
+        Inc(DBon, 4)
     end;
     if (PModel.Domain = dAir) and (DModel.Cap[mcAirDef] > 0) then
-      inc(DBon, 4);
+      Inc(DBon, 4);
     DStr := DModel.Defense * DBon * 100;
     if (DModel.Domain = dAir) and ((RealMap[Loc] and fCity <> 0) or
@@ -622 +622 @@
 
     if EndHealthDef > 0 then
-      result := eLost
+      Result := eLost
     else if EndHealthAtt > 0 then
-      result := eWon
+      Result := eWon
     else
-      result := eBloody;
+      Result := eBloody;
   end;
 end;
 
-function LoadUnit(p, uix: integer; TestOnly: boolean): integer;
-var
-  uix1, d, Cost, ToMaster: integer;
-begin
-  result := eOK;
-  with RW[p].Un[uix] do
-  begin
-    d := RW[p].Model[mix].Domain;
-    if (Master >= 0) or (d = dSea) or
-      (RW[p].Model[mix].Cap[mcAirTrans] + RW[p].Model[mix].Cap[mcOver] > 0) then
-      result := eViolation
+function LoadUnit(P, uix: Integer; TestOnly: Boolean): Integer;
+var
+  uix1, D, Cost, ToMaster: Integer;
+begin
+  Result := eOK;
+  with RW[P].Un[uix] do
+  begin
+    D := RW[P].Model[mix].Domain;
+    if (Master >= 0) or (D = dSea) or
+      (RW[P].Model[mix].Cap[mcAirTrans] + RW[P].Model[mix].Cap[mcOver] > 0) then
+      Result := eViolation
     else
     begin
       ToMaster := -1;
-      for uix1 := 0 to RW[p].nUn - 1 do
-        if RW[p].Un[uix1].Loc = Loc then
-          with RW[p].Un[uix1], RW[p].Model[mix] do
-            if (d < dSea) and
+      for uix1 := 0 to RW[P].nUn - 1 do
+        if RW[P].Un[uix1].Loc = Loc then
+          with RW[P].Un[uix1], RW[P].Model[mix] do
+            if (D < dSea) and
               (TroopLoad < MTrans * (Cap[mcSeaTrans] + Cap[mcAirTrans])) or
-              (d = dAir) and (AirLoad < MTrans * Cap[mcCarrier]) then
+              (D = dAir) and (AirLoad < MTrans * Cap[mcCarrier]) then
             begin { load onto unit uix1 }
               if (uixSelectedTransport < 0) or (uix1 = uixSelectedTransport)
@@ -661 +661 @@
             end;
       if ToMaster < 0 then
-        result := eNoLoadCapacity
+        Result := eNoLoadCapacity
       else
       begin
-        if d = dAir then
+        if D = dAir then
           Cost := 100
         else
-          Cost := RW[p].Model[mix].Speed;
+          Cost := RW[P].Model[mix].Speed;
         if Movement < Cost then
-          result := eNoTime_Load
+          Result := eNoTime_Load
         else if not TestOnly then
         begin
-          FreeUnit(p, uix);
-          dec(Movement, Cost);
-          if d = dAir then
-            inc(RW[p].Un[ToMaster].AirLoad)
+          FreeUnit(P, uix);
+          Dec(Movement, Cost);
+          if D = dAir then
+            Inc(RW[P].Un[ToMaster].AirLoad)
           else
-            inc(RW[p].Un[ToMaster].TroopLoad);
+            Inc(RW[P].Un[ToMaster].TroopLoad);
           Master := ToMaster;
           UpdateUnitMap(Loc);
@@ -686 +686 @@
 end;
 
-function UnloadUnit(p, uix: integer; TestOnly: boolean): integer;
-var
-  Cost: integer;
-begin
-  result := eOK;
-  with RW[p].Un[uix] do
+function UnloadUnit(P, uix: Integer; TestOnly: Boolean): Integer;
+var
+  Cost: Integer;
+begin
+  Result := eOK;
+  with RW[P].Un[uix] do
     if Master < 0 then
-      result := eNotChanged
-    else if (RW[p].Model[mix].Domain < dSea) and
+      Result := eNotChanged
+    else if (RW[P].Model[mix].Domain < dSea) and
       (RealMap[Loc] and fTerrain < fGrass) then
-      result := eDomainMismatch
+      Result := eDomainMismatch
       // else if (RW[p].Model[mix].Domain<dSea)
       // and (RW[p].Model[mix].Flags and mdCivil<>0)
@@ -702 +702 @@
     else
     begin
-      if RW[p].Model[mix].Domain = dAir then
+      if RW[P].Model[mix].Domain = dAir then
         Cost := 100
       else
-        Cost := RW[p].Model[mix].Speed;
+        Cost := RW[P].Model[mix].Speed;
       if Movement < Cost then
-        result := eNoTime_Load
+        Result := eNoTime_Load
       else if not TestOnly then
       begin
-        dec(Movement, Cost);
-        if RW[p].Model[mix].Domain = dAir then
-          dec(RW[p].Un[Master].AirLoad)
-        else
-        begin
-          dec(RW[p].Un[Master].TroopLoad);
+        Dec(Movement, Cost);
+        if RW[P].Model[mix].Domain = dAir then
+          Dec(RW[P].Un[Master].AirLoad)
+        else
+        begin
+          Dec(RW[P].Un[Master].TroopLoad);
           // Movement:=0 // no more movement after unload
         end;
         Master := -1;
-        PlaceUnit(p, uix);
+        PlaceUnit(P, uix);
         UpdateUnitMap(Loc);
       end;
@@ -725 +725 @@
 end;
 
-procedure Recover(p, uix: integer);
-var
-  cix, Recovery: integer;
-begin
-  with RW[p], Un[uix] do
+procedure Recover(P, uix: Integer);
+var
+  cix, Recovery: Integer;
+begin
+  with RW[P], Un[uix] do
   begin
     if (Master >= 0) and (Model[Un[Master].mix].Cap[mcSupplyShip] > 0) then
@@ -739 +739 @@
       cix := nCity - 1;
       while (cix >= 0) and (City[cix].Loc <> Loc) do
-        dec(cix);
+        Dec(cix);
       if City[cix].Flags and chDisorder <> 0 then
         Recovery := NoCityRecovery
@@ -762 +762 @@
     if Recovery > 100 - Health then
       Recovery := 100 - Health;
-    inc(Health, Recovery);
+    Inc(Health, Recovery);
   end;
 end;
 
-function GetMoveAdvice(p, uix: integer; var a: TMoveAdviceData): integer;
+function GetMoveAdvice(P, uix: Integer; var A: TMoveAdviceData): Integer;
 const
   // domains
@@ -778 +778 @@
   gmaAlpine = 8;
 var
-  i, FromLoc, EndLoc, T, T1, maxmov, initmov, Loc, Loc1, FromTile, ToTile, V8,
+  I, FromLoc, EndLoc, T, T1, maxmov, initmov, Loc, Loc1, FromTile, ToTile, V8,
     MoveInfo, HeavyCost, RailCost, MoveCost, AddDamage, MaxDamage,
-    MovementLeft: integer;
+    MovementLeft: Integer;
   Map: ^TTileList;
   Q: TIPQ;
   Adjacent: TVicinity8Loc;
-  From: array [0 .. lxmax * lymax - 1] of integer;
-  Time: array [0 .. lxmax * lymax - 1] of integer;
-  Damage: array [0 .. lxmax * lymax - 1] of integer;
-  MountainDelay, Resistant: boolean;
+  From: array [0 .. lxmax * lymax - 1] of Integer;
+  Time: array [0 .. lxmax * lymax - 1] of Integer;
+  Damage: array [0 .. lxmax * lymax - 1] of Integer;
+  MountainDelay, Resistant: Boolean;
   // tt,tt0: int64;
 begin
   // QueryPerformanceCounter(tt0);
 
-  MaxDamage := RW[p].Un[uix].Health - 1;
-  if MaxDamage > a.MaxHostile_MovementLeft then
-    if a.MaxHostile_MovementLeft >= 0 then
-      MaxDamage := a.MaxHostile_MovementLeft
+  MaxDamage := RW[P].Un[uix].Health - 1;
+  if MaxDamage > A.MaxHostile_MovementLeft then
+    if A.MaxHostile_MovementLeft >= 0 then
+      MaxDamage := A.MaxHostile_MovementLeft
     else
       MaxDamage := 0;
 
-  Map := @(RW[p].Map^);
-  if (a.ToLoc <> maNextCity) and ((a.ToLoc < 0) or (a.ToLoc >= MapSize)) then
-  begin
-    result := eInvalid;
-    exit;
+  Map := @(RW[P].Map^);
+  if (A.ToLoc <> maNextCity) and ((A.ToLoc < 0) or (A.ToLoc >= MapSize)) then
+  begin
+    Result := eInvalid;
+    Exit;
   end;
-  if (a.ToLoc <> maNextCity) and (Map[a.ToLoc] and fTerrain = fUNKNOWN) then
-  begin
-    result := eNoWay;
-    exit;
+  if (A.ToLoc <> maNextCity) and (Map[A.ToLoc] and fTerrain = fUNKNOWN) then
+  begin
+    Result := eNoWay;
+    Exit;
   end;
 
-  with RW[p].Model[RW[p].Un[uix].mix] do
+  with RW[P].Model[RW[P].Un[uix].mix] do
     case Domain of
       dGround:
-        if (a.ToLoc <> maNextCity) and (Map[a.ToLoc] and fTerrain = fOcean) then
-        begin
-          result := eDomainMismatch;
-          exit;
+        if (A.ToLoc <> maNextCity) and (Map[A.ToLoc] and fTerrain = fOcean) then
+        begin
+          Result := eDomainMismatch;
+          Exit;
         end
         else
@@ -826 +826 @@
             MoveInfo := gmaGround_NoZoC;
           if Cap[mcOver] > 0 then
-            inc(MoveInfo, gmaOver);
+            Inc(MoveInfo, gmaOver);
           if Cap[mcAlpine] > 0 then
-            inc(MoveInfo, gmaAlpine);
+            Inc(MoveInfo, gmaAlpine);
           HeavyCost := 50 + (Speed - 150) * 13 shr 7;
-          if GWonder[woShinkansen].EffectiveOwner = p then
+          if GWonder[woShinkansen].EffectiveOwner = P then
             RailCost := 0
           else
@@ -836 +836 @@
           maxmov := Speed;
           initmov := 0;
-          Resistant := (GWonder[woGardens].EffectiveOwner = p) or
+          Resistant := (GWonder[woGardens].EffectiveOwner = P) or
             (Kind = mkSettler) and (Speed >= 200);
         end;
       dSea:
-        if (a.ToLoc <> maNextCity) and (Map[a.ToLoc] and fTerrain >= fGrass) and
-          (Map[a.ToLoc] and (fCity or fUnit or fCanal) = 0) then
-        begin
-          result := eDomainMismatch;
-          exit;
+        if (A.ToLoc <> maNextCity) and (Map[A.ToLoc] and fTerrain >= fGrass) and
+          (Map[A.ToLoc] and (fCity or fUnit or fCanal) = 0) then
+        begin
+          Result := eDomainMismatch;
+          Exit;
         end
         else
@@ -850 +850 @@
           MoveInfo := gmaSea;
           if Cap[mcNav] > 0 then
-            inc(MoveInfo, gmaNav);
-          maxmov := UnitSpeed(p, RW[p].Un[uix].mix, 100);
-          initmov := maxmov - UnitSpeed(p, RW[p].Un[uix].mix,
-            RW[p].Un[uix].Health);
+            Inc(MoveInfo, gmaNav);
+          maxmov := UnitSpeed(P, RW[P].Un[uix].mix, 100);
+          initmov := maxmov - UnitSpeed(P, RW[P].Un[uix].mix,
+            RW[P].Un[uix].Health);
         end;
       dAir:
@@ -863 +863 @@
     end;
 
-  FromLoc := RW[p].Un[uix].Loc;
+  FromLoc := RW[P].Un[uix].Loc;
   FillChar(Time, SizeOf(Time), 255); { -1 }
   Damage[FromLoc] := 0;
   Q := TIPQ.Create(MapSize);
-  Q.Put(FromLoc, (maxmov - RW[p].Un[uix].Movement) shl 8);
+  Q.Put(FromLoc, (maxmov - RW[P].Un[uix].Movement) shl 8);
   while Q.Get(Loc, T) do
   begin
     Time[Loc] := T;
-    if T >= (a.MoreTurns + 1) shl 20 then
+    if T >= (A.MoreTurns + 1) shl 20 then
     begin
       Loc := -1;
@@ -877 +877 @@
     end;
     FromTile := Map[Loc];
-    if (Loc = a.ToLoc) or (a.ToLoc = maNextCity) and (FromTile and fCity <> 0)
+    if (Loc = A.ToLoc) or (A.ToLoc = maNextCity) and (FromTile and fCity <> 0)
     then
       Break;
     if T and $FFF00 = $FFF00 then
-      inc(T, $100000); // indicates mountain delay
+      Inc(T, $100000); // indicates mountain delay
     V8_to_Loc(Loc, Adjacent);
     for V8 := 0 to 7 do
@@ -889 +889 @@
       begin
         ToTile := Map[Loc1];
-        if (Loc1 = a.ToLoc) and (ToTile and (fUnit or fOwned) = fUnit) and
+        if (Loc1 = A.ToLoc) and (ToTile and (fUnit or fOwned) = fUnit) and
           not((MoveInfo and 3 = gmaSea) and (FromTile and fTerrain >= fGrass))
           and not((MoveInfo and 3 = gmaAir) and ((FromTile and fCity <> 0) or
@@ -898 +898 @@
         end
         else if (ToTile and fTerrain <> fUNKNOWN) and
-          ((Loc1 = a.ToLoc) or (ToTile and (fCity or fOwned) <> fCity))
+          ((Loc1 = A.ToLoc) or (ToTile and (fCity or fOwned) <> fCity))
         // don't move through enemy cities
-          and ((Loc1 = a.ToLoc) or (ToTile and (fUnit or fOwned) <> fUnit))
+          and ((Loc1 = A.ToLoc) or (ToTile and (fUnit or fOwned) <> fUnit))
         // way is blocked
           and (ToTile and not FromTile and fPeace = 0) and
@@ -910 +910 @@
           // calculate move cost, must be identic to GetMoveCost function
           AddDamage := 0;
-          MountainDelay := false;
+          MountainDelay := False;
           case MoveInfo of
 
@@ -956 +956 @@
                     begin
                       MoveCost := maxmov;
-                      MountainDelay := true;
+                      MountainDelay := True;
                     end;
                 end;
@@ -990 +990 @@
           if (MoveCost > 0) and not MountainDelay then
             if V8 and 1 <> 0 then
-              inc(MoveCost, MoveCost * 2)
+              Inc(MoveCost, MoveCost * 2)
             else
-              inc(MoveCost, MoveCost);
+              Inc(MoveCost, MoveCost);
 
           if (MoveInfo and 2 <> 0) // ground unit, check transport load/unload
@@ -1011 +1011 @@
                 if FromTile and (fTerrain or fCity or fRiver or fCanal or
                   fSpecial1 { Oasis } ) = fDesert then
-                  inc(AddDamage, (DesertThurst * (maxmov - T shr 8 and $FFF) -
+                  Inc(AddDamage, (DesertThurst * (maxmov - T shr 8 and $FFF) -
                     1) div maxmov + 1)
                 else if FromTile and (fTerrain or fCity or fRiver or fCanal) = fArctic
                 then
-                  inc(AddDamage, (ArcticThurst * (maxmov - T shr 8 and $FFF) -
+                  Inc(AddDamage, (ArcticThurst * (maxmov - T shr 8 and $FFF) -
                     1) div maxmov + 1);
 
@@ -1037 +1037 @@
   end;
   FreeAndNil(Q);
-  if (Loc = a.ToLoc) or (a.ToLoc = maNextCity) and (Loc >= 0) and
+  if (Loc = A.ToLoc) or (A.ToLoc = maNextCity) and (Loc >= 0) and
     (Map[Loc] and fCity <> 0) then
   begin
-    a.MoreTurns := T shr 20;
+    A.MoreTurns := T shr 20;
     EndLoc := Loc;
-    a.nStep := 0;
+    A.nStep := 0;
     while Loc <> FromLoc do
     begin
       if Time[Loc] < $100000 then
-        inc(a.nStep);
+        Inc(A.nStep);
       Loc := From[Loc];
     end;
     Loc := EndLoc;
-    i := a.nStep;
+    I := A.nStep;
     while Loc <> FromLoc do
     begin
       if Time[Loc] < $100000 then
       begin
-        dec(i);
-        if i < 25 then
-        begin
-          a.dx[i] := ((Loc mod lx * 2 + Loc div lx and 1) -
+        Dec(I);
+        if I < 25 then
+        begin
+          A.dx[I] := ((Loc mod lx * 2 + Loc div lx and 1) -
             (From[Loc] mod lx * 2 + From[Loc] div lx and 1) + 3 * lx)
             mod (2 * lx) - lx;
-          a.dy[i] := Loc div lx - From[Loc] div lx;
+          A.dy[I] := Loc div lx - From[Loc] div lx;
         end
       end;
       Loc := From[Loc];
     end;
-    a.MaxHostile_MovementLeft := maxmov - Time[EndLoc] shr 8 and $FFF;
-    if a.nStep > 25 then
-      a.nStep := 25;
-    result := eOK
+    A.MaxHostile_MovementLeft := maxmov - Time[EndLoc] shr 8 and $FFF;
+    if A.nStep > 25 then
+      A.nStep := 25;
+    Result := eOK
   end
   else
-    result := eNoWay;
+    Result := eNoWay;
 
   // QueryPerformanceCounter(tt);{time in s is: (tt-tt0)/PerfFreq}
 end;
 
-function CanPlaneReturn(p, uix: integer;
-  PlaneReturnData: TPlaneReturnData): boolean;
+function CanPlaneReturn(P, uix: Integer;
+  PlaneReturnData: TPlaneReturnData): Boolean;
 const
   mfEnd = 1;
   mfReached = 2;
 var
-  uix1, T, T1, Loc, Loc1, FromTile, ToTile, V8, MoveCost, maxmov: integer;
+  uix1, T, T1, Loc, Loc1, FromTile, ToTile, V8, MoveCost, maxmov: Integer;
   Map: ^TTileList;
   Q: TIPQ;
   Adjacent: TVicinity8Loc;
-  MapFlags: array [0 .. lxmax * lymax - 1] of byte;
-begin
-  Map := @(RW[p].Map^);
+  MapFlags: array [0 .. lxmax * lymax - 1] of Byte;
+begin
+  Map := @(RW[P].Map^);
 
   // calculate possible return points
   FillChar(MapFlags, SizeOf(MapFlags), 0);
-  if RW[p].Model[RW[p].Un[uix].mix].Kind = mkSpecial_Glider then
+  if RW[P].Model[RW[P].Un[uix].mix].Kind = mkSpecial_Glider then
   begin
     for Loc := 0 to MapSize - 1 do
@@ -1106 +1106 @@
         (Map[Loc] and (fUnit or fOwned) <> fUnit) then
         MapFlags[Loc] := MapFlags[Loc] or mfEnd;
-    if RW[p].Model[RW[p].Un[uix].mix].Cap[mcAirTrans] = 0 then
+    if RW[P].Model[RW[P].Un[uix].mix].Cap[mcAirTrans] = 0 then
     // plane can land on carriers
-      for uix1 := 0 to RW[p].nUn - 1 do
-        with RW[p].Un[uix1], RW[p].Model[mix] do
+      for uix1 := 0 to RW[P].nUn - 1 do
+        with RW[P].Un[uix1], RW[P].Model[mix] do
           if AirLoad < MTrans * Cap[mcCarrier] then
             MapFlags[Loc] := MapFlags[Loc] or mfEnd;
   end;
 
-  with RW[p].Un[uix] do
+  with RW[P].Un[uix] do
   begin
     if Master >= 0 then // can return to same carrier, even if full now
       MapFlags[Loc] := MapFlags[Loc] or mfEnd;
-    maxmov := RW[p].Model[mix].Speed;
+    maxmov := RW[P].Model[mix].Speed;
   end;
 
-  result := false;
+  Result := False;
   Q := TIPQ.Create(MapSize);
   Q.Put(PlaneReturnData.Loc, (maxmov - PlaneReturnData.Movement) shl 8);
@@ -1129 +1129 @@
     if T >= (PlaneReturnData.Fuel + 1) shl 20 then
     begin
-      result := false;
+      Result := False;
       Break;
     end;
     if MapFlags[Loc] and mfEnd <> 0 then
     begin
-      result := true;
+      Result := True;
       Break;
     end;
@@ -1173 +1173 @@
   ____________________________________________________________________
 }
-function CalculateJobWork(p, Loc, Job: integer; var JobWork: integer): integer;
-var
-  TerrType: integer;
-begin
-  result := eOK;
+function CalculateJobWork(P, Loc, Job: Integer; var JobWork: Integer): Integer;
+var
+  TerrType: Integer;
+begin
+  Result := eOK;
   TerrType := RealMap[Loc] and fTerrain;
   with Terrain[TerrType] do
@@ -1183 +1183 @@
       jCity:
         if RealMap[Loc] and fCity <> 0 then
-          result := eInvalid
+          Result := eInvalid
         else if IrrEff = 0 then
-          result := eNoCityTerrain
+          Result := eNoCityTerrain
         else
           JobWork := CityWork;
@@ -1193 +1193 @@
           JobWork := MoveCost * RoadWork;
           if RealMap[Loc] and fRiver <> 0 then
-            if RW[p].Tech[adBridgeBuilding] >= tsApplicable then
-              inc(JobWork, RoadBridgeWork) { across river }
+            if RW[P].Tech[adBridgeBuilding] >= tsApplicable then
+              Inc(JobWork, RoadBridgeWork) { across river }
             else
-              result := eNoBridgeBuilding;
+              Result := eNoBridgeBuilding;
         end
         else
-          result := eInvalid;
+          Result := eInvalid;
       jRR:
         if RealMap[Loc] and fRoad = 0 then
-          result := eNoPreq
+          Result := eNoPreq
         else if RealMap[Loc] and fRR <> 0 then
-          result := eInvalid
+          Result := eInvalid
         else
         begin
           JobWork := MoveCost * RRWork;
           if RealMap[Loc] and fRiver <> 0 then
-            inc(JobWork, RRBridgeWork); { across river }
+            Inc(JobWork, RRBridgeWork); { across river }
         end;
       jClear:
-        if (TerrType = fDesert) and (GWonder[woGardens].EffectiveOwner <> p)
+        if (TerrType = fDesert) and (GWonder[woGardens].EffectiveOwner <> P)
         then
-          result := eInvalid
+          Result := eInvalid
         else if ClearTerrain >= 0 then
           JobWork := IrrClearWork
         else
-          result := eInvalid;
+          Result := eInvalid;
       jIrr:
         begin
@@ -1224 +1224 @@
           if (IrrEff = 0) or (RealMap[Loc] and fTerImp = tiIrrigation) or
             (RealMap[Loc] and fTerImp = tiFarm) then
-            result := eInvalid;
+            Result := eInvalid;
         end;
       jFarm:
         if RealMap[Loc] and fTerImp <> tiIrrigation then
-          result := eNoPreq
+          Result := eNoPreq
         else
         begin
           JobWork := IrrClearWork * FarmWork;
           if (JobWork <= 0) or (RealMap[Loc] and fTerImp = tiFarm) then
-            result := eInvalid;
+            Result := eInvalid;
         end;
       jAfforest:
@@ -1239 +1239 @@
           JobWork := MineAfforestWork
         else
-          result := eInvalid;
+          Result := eInvalid;
       jMine:
         begin
           JobWork := MineAfforestWork;
           if (MineEff = 0) or (RealMap[Loc] and fTerImp = tiMine) then
-            result := eInvalid;
+            Result := eInvalid;
         end;
       jFort:
@@ -1250 +1250 @@
           JobWork := MoveCost * FortWork
         else
-          result := eInvalid;
+          Result := eInvalid;
       jCanal:
         if (RealMap[Loc] and fCanal = 0) and (TerrType in TerrType_Canalable)
@@ -1256 +1256 @@
           JobWork := CanalWork
         else
-          result := eInvalid;
+          Result := eInvalid;
       jTrans:
         begin
           JobWork := TransWork;
           if JobWork <= 0 then
-            result := eInvalid;
+            Result := eInvalid;
         end;
       jPoll:
@@ -1267 +1267 @@
           JobWork := PollWork
         else
-          result := eInvalid;
+          Result := eInvalid;
       jBase:
         if RealMap[Loc] and fTerImp <> tiBase then
           JobWork := MoveCost * BaseWork
         else
-          result := eInvalid;
+          Result := eInvalid;
       jPillage:
         if RealMap[Loc] and (fRoad or fRR or fCanal or fTerImp) <> 0 then
           JobWork := PillageWork
         else
-          result := eInvalid;
-    end;
-end;
-
-function StartJob(p, uix, NewJob: integer; TestOnly: boolean): integer;
-var
-  JobWork, Loc0, p1, uix1, TerrType: integer;
-begin
-{$IFOPT O-}assert(1 shl p and InvalidTreatyMap = 0); {$ENDIF}
-  result := eOK;
-  with RW[p].Un[uix] do
+          Result := eInvalid;
+    end;
+end;
+
+function StartJob(P, uix, NewJob: Integer; TestOnly: Boolean): Integer;
+var
+  JobWork, Loc0, p1, uix1, TerrType: Integer;
+begin
+{$IFOPT O-}Assert(1 shl P and InvalidTreatyMap = 0); {$ENDIF}
+  Result := eOK;
+  with RW[P].Un[uix] do
   begin
     if NewJob = Job then
     begin
-      result := eNotChanged;
-      exit;
+      Result := eNotChanged;
+      Exit;
     end;
     if NewJob = jNone then
@@ -1298 +1298 @@
       if not TestOnly then
         Job := jNone;
-      exit;
+      Exit;
     end;
     Loc0 := Loc;
@@ -1304 +1304 @@
       (NewJob <> jRR) then
     begin
-      result := eDeadLands;
-      exit;
+      Result := eDeadLands;
+      Exit;
     end;
     TerrType := RealMap[Loc0] and fTerrain;
     if (RealMap[Loc0] and fCity <> 0) or (TerrType < fGrass) or (Master >= 0) or
-      not((NewJob = jPillage) and (RW[p].Model[mix].Domain = dGround) or
-      (RW[p].Model[mix].Kind = mkSettler) or (NewJob <> jCity) and
-      (RW[p].Model[mix].Kind = mkSlaves) and (GWonder[woPyramids].EffectiveOwner
+      not((NewJob = jPillage) and (RW[P].Model[mix].Domain = dGround) or
+      (RW[P].Model[mix].Kind = mkSettler) or (NewJob <> jCity) and
+      (RW[P].Model[mix].Kind = mkSlaves) and (GWonder[woPyramids].EffectiveOwner
       >= 0)) then
     begin
-      result := eInvalid;
-      exit;
+      Result := eInvalid;
+      Exit;
     end;
     if (JobPreq[NewJob] <> preNone) and
-      (RW[p].Tech[JobPreq[NewJob]] < tsApplicable) then
-    begin
-      result := eNoPreq;
-      exit;
-    end;
-
-    result := CalculateJobWork(p, Loc0, NewJob, JobWork);
-    if (Mode = moPlaying) and (result = eOK) and (NewJob <> jPoll) then
+      (RW[P].Tech[JobPreq[NewJob]] < tsApplicable) then
+    begin
+      Result := eNoPreq;
+      Exit;
+    end;
+
+    Result := CalculateJobWork(P, Loc0, NewJob, JobWork);
+    if (Mode = moPlaying) and (Result = eOK) and (NewJob <> jPoll) then
     begin // not allowed in territory of friendly nation
       p1 := RealMap[Loc0] shr 27; // owner of territory
-      if (p1 < nPl) and (p1 <> p) and (RW[p].Treaty[p1] >= trPeace) then
-        result := eTreaty; // keep peace treaty!
-    end;
-    if TestOnly or (result < rExecuted) then
-      exit;
+      if (p1 < nPl) and (p1 <> P) and (RW[P].Treaty[p1] >= trPeace) then
+        Result := eTreaty; // keep peace treaty!
+    end;
+    if TestOnly or (Result < rExecuted) then
+      Exit;
 
     if (ToWork[Loc0, NewJob] = 0) or (ToWork[Loc0, NewJob] > JobWork) then
@@ -1338 +1338 @@
     Job := NewJob;
     Flags := Flags and not unFortified;
-    for uix1 := 0 to RW[p].nUn - 1 do
-      if (RW[p].Un[uix1].Loc = Loc) and
-        (RW[p].Un[uix1].Job in ContraJobs[NewJob]) then
-        RW[p].Un[uix1].Job := jNone; // stop contradictive jobs
-    if ServerVersion[p] < $000EF0 then
-      if Work(p, uix) then
-        result := eJobDone;
-    if (NewJob = jCity) and (result = eJobDone) then
-    begin
-      RemoveUnit_UpdateMap(p, uix);
-      result := eCity;
+    for uix1 := 0 to RW[P].nUn - 1 do
+      if (RW[P].Un[uix1].Loc = Loc) and
+        (RW[P].Un[uix1].Job in ContraJobs[NewJob]) then
+        RW[P].Un[uix1].Job := jNone; // stop contradictive jobs
+    if ServerVersion[P] < $000EF0 then
+      if Work(P, uix) then
+        Result := eJobDone;
+    if (NewJob = jCity) and (Result = eJobDone) then
+    begin
+      RemoveUnit_UpdateMap(P, uix);
+      Result := eCity;
     end
     else if Health <= 0 then
     begin // victim of HostileDamage
-      RemoveUnit_UpdateMap(p, uix);
-      result := result or rUnitRemoved;
+      RemoveUnit_UpdateMap(P, uix);
+      Result := Result or rUnitRemoved;
     end;
     if Mode > moLoading_Fast then
     begin
-      if result = eCity then
-      begin
-        ObserveLevel[Loc0] := ObserveLevel[Loc0] and not(3 shl (2 * p));
-        Discover21(Loc0, p, lObserveUnhidden, true, true);
+      if Result = eCity then
+      begin
+        ObserveLevel[Loc0] := ObserveLevel[Loc0] and not(3 shl (2 * P));
+        Discover21(Loc0, P, lObserveUnhidden, True, True);
         // CheckContact;
       end;
@@ -1367 +1367 @@
 end;
 
-function Work(p, uix: integer): boolean;
-var
-  uix1, j0: integer;
-begin
-  result := false;
-  with RW[p].Un[uix] do
+function Work(P, uix: Integer): Boolean;
+var
+  uix1, j0: Integer;
+begin
+  Result := False;
+  with RW[P].Un[uix] do
     if Movement >= 100 then
     begin
-      assert(ToWork[Loc, Job] < $FFFF); // should have been set by StartJob
+      Assert(ToWork[Loc, Job] < $FFFF); // should have been set by StartJob
       if Job >= jRoad then
-        if integer(Movement) >= integer(ToWork[Loc, Job]) then { work complete }
-        begin
-          result := true;
+        if Integer(Movement) >= Integer(ToWork[Loc, Job]) then { work complete }
+        begin
+          Result := True;
           if Job <> jIrr then
-            Health := Health - HostileDamage(p, mix, Loc, ToWork[Loc, Job]);
-          dec(Movement, ToWork[Loc, Job]);
+            Health := Health - HostileDamage(P, mix, Loc, ToWork[Loc, Job]);
+          Dec(Movement, ToWork[Loc, Job]);
           if not(Job in [jCity, jPillage, jPoll]) then
-            inc(Worked[p], ToWork[Loc, Job]);
+            Inc(Worked[P], ToWork[Loc, Job]);
           if Job = jCity then
           begin // found new city
-            FoundCity(p, Loc);
-            inc(Founded[p]);
-            with RW[p].City[RW[p].nCity - 1] do
+            FoundCity(P, Loc);
+            Inc(Founded[P]);
+            with RW[P].City[RW[P].nCity - 1] do
             begin
-              ID := p shl 12 + Founded[p] - 1;
+              ID := P shl 12 + Founded[P] - 1;
               Flags := chFounded;
             end;
             if Mode = moPlaying then
             begin
-              LogCheckBorders(p, RW[p].nCity - 1);
-              RecalcPeaceMap(p);
+              LogCheckBorders(P, RW[P].nCity - 1);
+              RecalcPeaceMap(P);
             end;
 {$IFOPT O-} if Mode < moPlaying then
-              InvalidTreatyMap := not(1 shl p); {$ENDIF}
+              InvalidTreatyMap := not(1 shl P); {$ENDIF}
             // territory should not be considered for the rest of the command
             // execution, because during loading a game it's incorrect before
             // subsequent sIntExpandTerritory is processed
-            RW[p].Un[uix].Health := 0; // causes unit to be removed later
+            RW[P].Un[uix].Health := 0; // causes unit to be removed later
           end
           else
-            CompleteJob(p, Loc, Job);
+            CompleteJob(P, Loc, Job);
           ToWork[Loc, Job] := 0;
           j0 := Job;
-          for uix1 := 0 to RW[p].nUn - 1 do
-            if (RW[p].Un[uix1].Loc = Loc) and (RW[p].Un[uix1].Job = j0) then
-              RW[p].Un[uix1].Job := jNone
+          for uix1 := 0 to RW[P].nUn - 1 do
+            if (RW[P].Un[uix1].Loc = Loc) and (RW[P].Un[uix1].Job = j0) then
+              RW[P].Un[uix1].Job := jNone
         end
         else
         begin
-          dec(ToWork[Loc, Job], Movement);
+          Dec(ToWork[Loc, Job], Movement);
           if not(Job in [jCity, jPillage, jPoll]) then
-            inc(Worked[p], Movement);
-          Health := Health - HostileDamage(p, mix, Loc, Movement);
+            Inc(Worked[P], Movement);
+          Health := Health - HostileDamage(P, mix, Loc, Movement);
           Movement := 0;
         end
@@ -1425 +1425 @@
 end;
 
-function GetJobProgress(p, Loc: integer;
-  var JobProgressData: TJobProgressData): integer;
-var
-  Job, JobResult, uix: integer;
+function GetJobProgress(P, Loc: Integer;
+  var JobProgressData: TJobProgressData): Integer;
+var
+  Job, JobResult, uix: Integer;
 begin
   for Job := 0 to nJob - 1 do
   begin
-    JobResult := CalculateJobWork(p, Loc, Job, JobProgressData[Job].Required);
+    JobResult := CalculateJobWork(P, Loc, Job, JobProgressData[Job].Required);
     if JobResult = eOK then
     begin
@@ -1448 +1448 @@
     JobProgressData[Job].NextTurnPlus := 0;
   end;
-  for uix := 0 to RW[p].nUn - 1 do
-    if (RW[p].Un[uix].Loc = Loc) and (RW[p].Un[uix].Movement >= 100) then
-      inc(JobProgressData[RW[p].Un[uix].Job].NextTurnPlus,
-        RW[p].Un[uix].Movement);
-  result := eOK;
+  for uix := 0 to RW[P].nUn - 1 do
+    if (RW[P].Un[uix].Loc = Loc) and (RW[P].Un[uix].Movement >= 100) then
+      Inc(JobProgressData[RW[P].Un[uix].Job].NextTurnPlus,
+        RW[P].Un[uix].Movement);
+  Result := eOK;
 end;