Changeset 223 for trunk

Timestamp:

Jul 14, 2018, 7:21:43 PM (6 years ago)

Author:

chronos

Message:

• Modified: CellMoves moved from terrain map to player map. Every player should have own moves to avoid affecting moves of different player.

Location:

trunk

Files:

• Forms/UFormClient.lfm (modified) (4 diffs)
• Forms/UFormClient.pas (modified) (6 diffs)
• UClientAI.pas (modified) (17 diffs)
• UGame.pas (modified) (52 diffs)
• UGameClient.pas (modified) (2 diffs)

trunk/Forms/UFormClient.lfm

@@ -7 +7 @@
   ClientHeight = 621
   ClientWidth = 775
-  DesignTimePPI = 120
+  DesignTimePPI = 144
   OnClose = FormClose
   OnCreate = FormCreate
@@ -13 +13 @@
   OnKeyUp = FormKeyUp
   OnShow = FormShow
-  LCLVersion = '1.8.2.0'
+  LCLVersion = '1.8.4.0'
   WindowState = wsMaximized
   object StatusBar1: TStatusBar
     Left = 0
-    Height = 28
-    Top = 593
+    Height = 30
+    Top = 591
     Width = 775
     Panels = <    
@@ -34 +34 @@
   object ToolBar1: TToolBar
     Left = 0
-    Height = 593
+    Height = 591
     Top = 0
     Width = 32
@@ -80 +80 @@
   object PaintBox1: TPaintBox
     Left = 32
-    Height = 593
+    Height = 591
     Top = 0
     Width = 743

trunk/Forms/UFormClient.pas

@@ -85 +85 @@
     procedure DoNextPlayer(Sender: TObject);
     procedure DoTurnStart(Sender: TObject);
-    procedure DoMove(CellFrom, CellTo: TCell; var CountOnce,
+    procedure DoMove(CellFrom, CellTo: TPlayerCell; var CountOnce,
       CountRepeat: Integer; Update: Boolean; var Confirm: Boolean);
     procedure SetToolbarHints;
@@ -129 +129 @@
 end;
 
-procedure TFormClient.DoMove(CellFrom, CellTo: TCell; var CountOnce,
+procedure TFormClient.DoMove(CellFrom, CellTo: TPlayerCell; var CountOnce,
   CountRepeat: Integer; Update: Boolean; var Confirm: Boolean);
 var
@@ -146 +146 @@
     FormMove.TrackBarRepeat.Max := FormMove.SpinEditRepeat.MaxValue;
     FormMove.TrackBarRepeat.Position := FormMove.SpinEditRepeat.Value;
-    FormMove.DefendCount := CellTo.Power;
+    FormMove.DefendCount := CellTo.MapCell.Power;
     // Attack count from other surrounding cells without current move if already exists
     FormMove.AttackCount := 0;
@@ -152 +152 @@
     if TUnitMove(CellTo.MovesTo[I]).CellFrom <> CellFrom then
       FormMove.AttackCount := FormMove.AttackCount + TUnitMove(CellTo.MovesTo[I]).CountOnce;
-    FormMove.ShowWinProbability := CellTo.Player <> CellFrom.Player;
+    FormMove.ShowWinProbability := CellTo.MapCell.Player <> CellFrom.MapCell.Player;
 
     if FormMove.ShowModal = mrOk then begin
@@ -456 +456 @@
   Y: Integer);
 var
-  Cell: TCell;
-  OldCell: TCell;
+  Cell: TPlayerCell;
+  OldCell: TPlayerCell;
   CellPos: TPoint;
 begin
@@ -473 +473 @@
     OldCell := Client.View.FocusedCell;
     with Core.Game do
-      Cell := Map.PosToCell(Client.View.CanvasToCellPos(TPoint.Create(X, Y)), Client.View);
+      if Assigned(Client.ControlPlayer) then
+        Cell := Client.ControlPlayer.PlayerMap.PosToCell(Client.View.CanvasToCellPos(TPoint.Create(X, Y)), Client.View);
+        //else Cell := Client.Game.Map.PosToCell(Client.View.CanvasToCellPos(TPoint.Create(X, Y)), Client.View);
     if Assigned(Cell) then begin
       Client.View.FocusedCell := Cell;
-      StatusBar1.Panels[0].Text := '[' + IntToStr(Cell.PosPx.X) + ', ' + IntToStr(Cell.PosPx.Y) +
-        '] (' + IntToStr(Cell.MovesFrom.Count) + ', ' + IntToStr(Cell.MovesTo.Count) + ') ' + IntToStr(Cell.Id);
+      StatusBar1.Panels[0].Text := '[' + IntToStr(Cell.MapCell.PosPx.X) + ', ' + IntToStr(Cell.MapCell.PosPx.Y) +
+        '] (' + IntToStr(Cell.MovesFrom.Count) + ', ' + IntToStr(Cell.MovesTo.Count) + ') ' + IntToStr(Cell.MapCell.Id);
     end else begin
       Client.View.FocusedCell := nil;

trunk/UClientAI.pas

@@ -23 +23 @@
     procedure Process;
     procedure FallBack;
-    function AttackersCount(Cell: TCell): Integer;
+    function AttackersCount(Cell: TPlayerCell): Integer;
   end;
 
@@ -39 +39 @@
 procedure TComputer.AttackNeutral;
 var
-  AllCells: TCells;
+  AllCells: TPlayerCells;
   TotalPower: Integer;
   AttackPower: Integer;
   TotalAttackPower: Integer;
   CanAttack: Integer;
-  TargetCells: TCells;
-  Cell: TCell;
-  NeighborCell: TCell;
+  TargetCells: TPlayerCells;
+  Cell: TPlayerCell;
+  NeighborCell: TPlayerCell;
 const
   AttackDiff = 1;
 begin
-  AllCells := Game.Map.Cells;
-  TargetCells := TCells.Create;
+  AllCells := ControlPlayer.PlayerMap.Cells;
+  TargetCells := TPlayerCells.Create;
   TargetCells.FreeObjects := False;
 
@@ -57 +57 @@
   for Cell in AllCells do
   with Cell do begin
-    if (Terrain <> ttVoid) and (Player = nil) then begin
+    if (MapCell.Terrain <> ttVoid) and (MapCell.Player = nil) then begin
       CanAttack := 0;
       for NeighborCell in Neighbors do
-      if NeighborCell.Player = ControlPlayer then begin
+      if NeighborCell.MapCell.Player = ControlPlayer then begin
         Inc(CanAttack);
       end;
@@ -77 +77 @@
       TotalPower := 0;
       for NeighborCell in Neighbors do
-      if NeighborCell.Player = ControlPlayer then
+      if NeighborCell.MapCell.Player = ControlPlayer then
         TotalPower := TotalPower + NeighborCell.GetAvialPower;
 
       // Attack if target is weaker
-      if TotalPower >= (Power + AttackDiff) then begin
+      if TotalPower >= (MapCell.Power + AttackDiff) then begin
         TotalAttackPower := 0;
         for NeighborCell in Neighbors do
-        if NeighborCell.Player = ControlPlayer then begin
+        if NeighborCell.MapCell.Player = ControlPlayer then begin
           // Use only necessary power
-          AttackPower := Power - TotalAttackPower + AttackDiff;
+          AttackPower := MapCell.Power - TotalAttackPower + AttackDiff;
           if NeighborCell.GetAvialPower < AttackPower then
             AttackPower := NeighborCell.GetAvialPower;
@@ -100 +100 @@
 procedure TComputer.AttackPlayers;
 var
-  AllCells: TCells;
+  AllCells: TPlayerCells;
   TotalPower: Integer;
   AttackPower: Integer;
   TotalAttackPower: Integer;
   CanAttack: Integer;
-  TargetCells: TCells;
-  TargetCell: TCell;
-  NeighborCell: TCell;
+  TargetCells: TPlayerCells;
+  TargetCell: TPlayerCell;
+  NeighborCell: TPlayerCell;
 begin
 if ControlPlayer.Defensive then Exit;
 
-  AllCells := Game.Map.Cells;
-  TargetCells := TCells.Create;
+  AllCells := ControlPlayer.PlayerMap.Cells;
+  TargetCells := TPlayerCells.Create;
   TargetCells.FreeObjects := False;
 
   // Get list of all attack target cells
   for TargetCell in AllCells do begin
-    if (TargetCell.Terrain <> ttVoid) and (TargetCell.Player <> ControlPlayer) and
-      (TargetCell.Player <> nil) then begin
+    if (TargetCell.MapCell.Terrain <> ttVoid) and (TargetCell.MapCell.Player <> ControlPlayer) and
+      (TargetCell.MapCell.Player <> nil) then begin
       CanAttack := 0;
       for NeighborCell in TargetCell.Neighbors do
-      if NeighborCell.Player = ControlPlayer then begin
+      if NeighborCell.MapCell.Player = ControlPlayer then begin
         Inc(CanAttack);
       end;
@@ -137 +137 @@
       TotalPower := 0;
       for NeighborCell in TargetCell.Neighbors do
-      if NeighborCell.Player = ControlPlayer then begin
+      if NeighborCell.MapCell.Player = ControlPlayer then begin
         TotalPower := TotalPower + NeighborCell.GetAvialPower;
       end;
       // Attack if target is weaker
-      if Game.AttackProbability(TotalPower, TargetCell.Power) >=
+      if Game.AttackProbability(TotalPower, TargetCell.MapCell.Power) >=
         ComputerAggroProbability[ControlPlayer.Agressivity] then begin
         // Try to limit total attacking power to necessary minimum
-        while Game.AttackProbability(TotalPower - 1, TargetCell.Power) >=
+        while Game.AttackProbability(TotalPower - 1, TargetCell.MapCell.Power) >=
           ComputerAggroProbability[ControlPlayer.Agressivity] do
           Dec(TotalPower);
@@ -151 +151 @@
         TotalAttackPower := 0;
         for NeighborCell in TargetCell.Neighbors do
-        if NeighborCell.Player = ControlPlayer then begin
+        if NeighborCell.MapCell.Player = ControlPlayer then begin
           // Use only necessary power
           AttackPower := TotalPower - TotalAttackPower;
@@ -168 +168 @@
 procedure TComputer.InnerMoves;
 var
-  AllCells: TCells;
+  AllCells: TPlayerCells;
   I, J: Integer;
   C: Integer;
   CanAttack: Integer;
-  TargetCells: TCells;
-  NewTargetCells: TCells;
-  Cells2: TCells;
+  TargetCells: TPlayerCells;
+  NewTargetCells: TPlayerCells;
+  Cells2: TPlayerCells;
   MovedPower: Integer;
 begin
   // We need to move available power to borders to be available for attacks
   // or defense
-  AllCells := Game.Map.Cells;
-  TargetCells := TCells.Create;
+  AllCells := ControlPlayer.PlayerMap.Cells;
+  TargetCells := TPlayerCells.Create;
   TargetCells.FreeObjects := False;
-  NewTargetCells := TCells.Create;
+  NewTargetCells := TPlayerCells.Create;
   NewTargetCells.FreeObjects := False;
 
@@ -188 +188 @@
   for C := 0 to AllCells.Count - 1 do
   with AllCells[C] do begin
-    if (Player <> ControlPlayer) and (Player <> nil) and (Terrain <> ttVoid) then begin
+    if (MapCell.Player <> ControlPlayer) and (MapCell.Player <> nil) and (MapCell.Terrain <> ttVoid) then begin
       CanAttack := 0;
       for I := 0 to Neighbors.Count - 1 do
-      if ((Neighbors[I].Player = ControlPlayer) or
-      (Neighbors[I].Player = nil)) and (Neighbors[I].Terrain <> ttVoid) then begin
+      if ((Neighbors[I].MapCell.Player = ControlPlayer) or
+      (Neighbors[I].MapCell.Player = nil)) and (Neighbors[I].MapCell.Terrain <> ttVoid) then begin
         Inc(CanAttack);
       end;
@@ -210 +210 @@
     // Set mark for selected border cells
     for C := 0 to TargetCells.Count - 1 do
-      TargetCells[C].Mark := True;
+      TargetCells[C].MapCell.Mark := True;
 
     // Move all power from unmarked cells and mark them
@@ -217 +217 @@
     with TargetCells[C] do begin
       for I := 0 to Neighbors.Count - 1 do begin
-        if (Neighbors[I].Terrain <> ttVoid) and (not Neighbors[I].Mark) then begin
-          if (TargetCells[C].Player = ControlPlayer) and
-          (Neighbors[I].Player = ControlPlayer) then begin
+        if (Neighbors[I].MapCell.Terrain <> ttVoid) and (not Neighbors[I].MapCell.Mark) then begin
+          if (TargetCells[C].MapCell.Player = ControlPlayer) and
+          (Neighbors[I].MapCell.Player = ControlPlayer) then begin
             // Do not take units from front line
             Cells2 := Neighbors[I].Neighbors;
             CanAttack := 0;
             for J := 0 to Cells2.Count - 1 do
-            if ((Cells2[J].Player <> ControlPlayer) or (Cells2[J].Player = nil))
-            and (Cells2[J].Terrain <> ttVoid) then begin
+            if ((Cells2[J].MapCell.Player <> ControlPlayer) or (Cells2[J].MapCell.Player = nil))
+            and (Cells2[J].MapCell.Terrain <> ttVoid) then begin
               Inc(CanAttack);
             end;
@@ -232 +232 @@
               if (TargetCells[C].GetAvialPower + TargetCells[C].GetAttackPower + MovedPower) > Game.Map.MaxPower then
                 MovedPower := Game.Map.MaxPower - TargetCells[C].GetAvialPower - TargetCells[C].GetAttackPower;
-              Player.SetMove(Neighbors[I], TargetCells[C], MovedPower, False);
+              MapCell.Player.SetMove(Neighbors[I], TargetCells[C], MovedPower, False);
             end;
           end;
-          Neighbors[I].Mark := True;
+          Neighbors[I].MapCell.Mark := True;
           NewTargetCells.Add(Neighbors[I]);
         end;
@@ -244 +244 @@
     FreeAndNil(TargetCells);
     TargetCells := NewTargetCells;
-    NewTargetCells := TCells.Create;
+    NewTargetCells := TPlayerCells.Create;
     NewTargetCells.FreeObjects := False;
   end;
@@ -281 +281 @@
   C: Integer;
   I: Integer;
-  AllCells: TCells;
-  BorderCells: TCells;
+  AllCells: TPlayerCells;
+  BorderCells: TPlayerCells;
   EnemyPower: Integer;
 begin
-  BorderCells := TCells.Create;
+  BorderCells := TPlayerCells.Create;
   BorderCells.FreeObjects := False;
-  AllCells := Game.Map.Cells;
+  AllCells := ControlPlayer.PlayerMap.Cells;
 
   // Get list of border cells
   for C := 0 to AllCells.Count - 1 do
   with AllCells[C] do begin
-    if (Terrain <> ttVoid) and (Player = ControlPlayer)  then begin
+    if (MapCell.Terrain <> ttVoid) and (MapCell.Player = ControlPlayer)  then begin
       if AttackersCount(AllCells[C]) > 0 then
         BorderCells.Add(AllCells[C]);
@@ -305 +305 @@
     EnemyPower := 0;
     for I := 0 to Neighbors.Count - 1 do
-    if (Neighbors[I].Player <> ControlPlayer) and (Neighbors[I].Player <> nil) then begin
-      Inc(EnemyPower, Neighbors[I].Power);
+    if (Neighbors[I].MapCell.Player <> ControlPlayer) and (Neighbors[I].MapCell.Player <> nil) then begin
+      Inc(EnemyPower, Neighbors[I].MapCell.Power);
     end;
     if EnemyPower > (GetAvialPower + GetAttackPower) then begin
       // Fallback
       for I := MovesTo.Count - 1 downto 0 do
-        Player.Moves.Remove(MovesTo[I]);
+        MapCell.Player.Moves.Remove(MovesTo[I]);
       for I := 0 to Neighbors.Count - 1 do
-      if (Neighbors[I].Player = Player) and (AttackersCount(Neighbors[I]) = 0) then begin
-        Player.SetMove(BorderCells[C], Neighbors[I], GetAvialPower, False);
+      if (Neighbors[I].MapCell.Player = MapCell.Player) and (AttackersCount(Neighbors[I]) = 0) then begin
+        MapCell.Player.SetMove(BorderCells[C], Neighbors[I], GetAvialPower, False);
         Break;
       end;
@@ -323 +323 @@
 end;
 
-function TComputer.AttackersCount(Cell: TCell): Integer;
+function TComputer.AttackersCount(Cell: TPlayerCell): Integer;
 var
   I: Integer;
@@ -329 +329 @@
   Result := 0;
   for I := 0 to Cell.Neighbors.Count - 1 do
-  if (Cell.Neighbors[I].Player <> ControlPlayer) and
-    (Cell.Neighbors[I].Player <> nil) then begin
+  if (Cell.Neighbors[I].MapCell.Player <> ControlPlayer) and
+    (Cell.Neighbors[I].MapCell.Player <> nil) then begin
       Inc(Result);
   end;

trunk/UGame.pas

@@ -28 +28 @@
   TCellLinks = class;
   TMapArea = class;
+  TPlayerCells = class;
+  TPlayerCell = class;
+  TPlayerMap = class;
 
   TTerrainType = (ttVoid, ttNormal, ttCity);
@@ -50 +53 @@
     PlayerId: Integer;
     Player: TPlayer;
-    MovesFrom: TUnitMoves;
-    MovesTo: TUnitMoves;
     NeighborsId: array of Integer;
     Neighbors: TCells;
@@ -57 +58 @@
     Weight: Integer; // Temporary value
     Angle: Double; // Temporary value
+    PlayerCell: Pointer; // Temporary value
     Links: TCellLinks;
     Extra: TExtraType;
@@ -62 +64 @@
     procedure ConnectTo(Cell: TCell);
     procedure DisconnectFrom(Cell: TCell);
-    procedure Check;
     function NeighboringToVoid: Boolean;
     procedure AreaExtend;
@@ -71 +72 @@
     function IsVisible(View: TView): Boolean;
     function GetColor: TColor;
-    function GetAvialPower: Integer;
-    function GetAttackPower: Integer;
     function ToString: ansistring; override;
     constructor Create;
@@ -140 +139 @@
     Game: TGame;
     SourceRect: TRect;
-    FocusedCell: TCell;
-    SelectedCell: TCell;
+    FocusedCell: TPlayerCell;
+    SelectedCell: TPlayerCell;
     procedure Clear;
     constructor Create;
@@ -210 +209 @@
     Areas: TMapAreas;
     Cyclic: Boolean;
+    procedure Paint(Canvas: TCanvas; View: TView);
     function IsOutsideShape(Coord: TPoint): Boolean; virtual;
     function IsCellsNeighbor(Cell1, Cell2: TCell): Boolean; virtual;
@@ -231 +231 @@
     constructor Create; virtual;
     destructor Destroy; override;
-    procedure Paint(Canvas: TCanvas; View: TView); virtual;
     function CalculatePixelRect: TRect; virtual;
     procedure ForEachCells(Method: TMethod); virtual;
@@ -238 +237 @@
   end;
 
-  TPlayerCells = class;
-  TPlayerMap = class;
-
   { TPlayerCell }
 
   TPlayerCell = class
+    MovesFrom: TUnitMoves;
+    MovesTo: TUnitMoves;
     Explored: Boolean;
     InVisibleRange: Boolean;
     MapCell: TCell;
     List: TPlayerCells;
+    Neighbors: TPlayerCells;
+    procedure ConnectTo(Cell: TPlayerCell);
+    procedure DisconnectFrom(Cell: TPlayerCell);
+    function GetAvialPower: Integer;
+    function GetAttackPower: Integer;
     procedure LoadFromNode(Node: TDOMNode);
     procedure SaveToNode(Node: TDOMNode);
+    constructor Create;
+    destructor Destroy; override;
   end;
 
@@ -256 +261 @@
   TPlayerCells = class(TFPGObjectList<TPlayerCell>)
     Map: TPlayerMap;
+    function FindByCellId(Id: Integer): TPlayerCell;
     function SearchCell(Cell: TCell): TPlayerCell;
     procedure LoadFromNode(Node: TDOMNode);
@@ -266 +272 @@
     Cells: TPlayerCells;
     Player: TPlayer;
+    procedure PaintCell(Canvas: TCanvas; Pos: TPoint; Text: string; View: TView;
+      Cell: TPlayerCell);
+    function PosToCell(Pos: TPoint; View: TView): TPlayerCell; virtual;
+    function CellToPos(Cell: TPlayerCell): TPoint; virtual;
     procedure LoadFromNode(Node: TDOMNode);
     procedure SaveToNode(Node: TDOMNode);
@@ -298 +308 @@
   TUnitMove = class;
 
-  TMoveEvent = procedure(CellFrom, CellTo: TCell; var CountOnce, CountRepeat: Integer;
+  TMoveEvent = procedure(CellFrom, CellTo: TPlayerCell; var CountOnce, CountRepeat: Integer;
     Update: Boolean; var Confirm: Boolean) of object;
 
@@ -310 +320 @@
     procedure SetGame(AValue: TGame);
     procedure Attack(var AttackPower, DefendPower: Integer);
-    procedure ClearMovesFromCell(Cell: TCell);
+    procedure ClearMovesFromCell(Cell: TPlayerCell);
     procedure MoveAll;
     procedure ReduceMovesPower;
+    procedure RemoveInvalidMoves;
     procedure CheckCounterMove(Move: TUnitMove);
     procedure SetMode(AValue: TPlayerMode);
@@ -333 +344 @@
     TurnStats: TGameTurnStats;
     Moves: TUnitMoves;
-    function SetMove(CellFrom, CellTo: TCell; Power: Integer; Confirmation: Boolean = True): TUnitMove;
+    function SetMove(CellFrom, CellTo: TPlayerCell; Power: Integer; Confirmation: Boolean = True): TUnitMove;
     procedure Reset;
     procedure Surrender;
@@ -379 +390 @@
   TUnitMove = class
   private
-    FCellFrom: TCell;
-    FCellTo: TCell;
-    procedure SetCellFrom(AValue: TCell);
-    procedure SetCellTo(AValue: TCell);
+    FCellFrom: TPlayerCell;
+    FCellTo: TPlayerCell;
+    procedure SetCellFrom(AValue: TPlayerCell);
+    procedure SetCellTo(AValue: TPlayerCell);
   public
     List: TUnitMoves;
@@ -391 +402 @@
     constructor Create;
     destructor Destroy; override;
-    property CellFrom: TCell read FCellFrom write SetCellFrom;
-    property CellTo: TCell read FCellTo write SetCellTo;
+    property CellFrom: TPlayerCell read FCellFrom write SetCellFrom;
+    property CellTo: TPlayerCell read FCellTo write SetCellTo;
   end;
 
@@ -399 +410 @@
   TUnitMoves = class(TFPGObjectList<TUnitMove>)
     Game: TGame;
-    function SearchByFromTo(CellFrom, CellTo: TCell): TUnitMove;
+    Player: TPlayer;
+    function SearchByFromTo(CellFrom, CellTo: TPlayerCell): TUnitMove;
     procedure LoadFromNode(Node: TDOMNode);
     procedure SaveToNode(Node: TDOMNode);
@@ -493 +505 @@
 
 procedure InitStrings;
-function CellCompare(const Item1, Item2: TCell): Integer;
-function CellCompareDescending(const Item1, Item2: TCell): Integer;
+function CellCompare(const Item1, Item2: TPlayerCell): Integer;
+function CellCompareDescending(const Item1, Item2: TPlayerCell): Integer;
 
 resourcestring
@@ -744 +756 @@
 end;
 
+procedure TPlayerCell.ConnectTo(Cell: TPlayerCell);
+begin
+  if (Cell.Neighbors.IndexOf(Self) = -1) and
+  (Neighbors.IndexOf(Cell) = -1) then begin;
+    Cell.Neighbors.Add(Self);
+    Neighbors.Add(Cell);
+  end;
+end;
+
+procedure TPlayerCell.DisconnectFrom(Cell: TPlayerCell);
+var
+  I: Integer;
+begin
+  I := Cell.Neighbors.IndexOf(Self);
+  if I >= 0 then Cell.Neighbors.Delete(I) else
+    raise Exception.Create('Can''t disconnect neigboring cells.');
+  I := Neighbors.IndexOf(Cell);
+  if I >= 0 then Neighbors.Delete(I)
+    else Exception.Create('Can''t disconnect neigboring cells.');
+end;
+
+function TPlayerCell.GetAvialPower: Integer;
+var
+  UnitMove: TUnitMove;
+begin
+  Result := MapCell.Power;
+  for UnitMove in MovesFrom do
+    Result := Result - UnitMove.CountOnce;
+end;
+
+function TPlayerCell.GetAttackPower: Integer;
+var
+  I: Integer;
+begin
+  Result := 0;
+  for I := 0 to MovesTo.Count - 1 do
+    Result := Result + TUnitMove(MovesTo[I]).CountOnce;
+end;
+
 procedure TPlayerCell.SaveToNode(Node: TDOMNode);
 begin
@@ -750 +801 @@
 end;
 
+constructor TPlayerCell.Create;
+begin
+  MovesFrom := TUnitMoves.Create;
+  MovesFrom.FreeObjects := False;
+  MovesTo := TUnitMoves.Create;
+  MovesTo.FreeObjects := False;
+  Neighbors := TPlayerCells.Create;
+  Neighbors.FreeObjects := False;
+end;
+
+destructor TPlayerCell.Destroy;
+var
+  I: Integer;
+begin
+  for I := MovesFrom.Count - 1 downto 0 do
+    TUnitMove(MovesFrom[I]).List.Remove(TUnitMove(MovesFrom[I]));
+  FreeAndNil(MovesFrom);
+  for I := MovesTo.Count - 1 downto 0 do
+    TUnitMove(MovesTo[I]).List.Remove(TUnitMove(MovesTo[I]));
+  FreeAndNil(MovesTo);
+  for I := Neighbors.Count - 1 downto 0 do
+    if Neighbors[I].Neighbors.Remove(Self) = -1 then
+      raise Exception.Create(SCellRemoveNeighborError);
+  FreeAndNil(Neighbors);
+  inherited Destroy;
+end;
+
 { TPlayerCells }
+
+function TPlayerCells.FindByCellId(Id: Integer): TPlayerCell;
+var
+  I: Integer;
+begin
+  I := 0;
+  while (I < Count) and (Items[I].MapCell.Id <> Id) do Inc(I);
+  if I < Count then Result := Items[I]
+    else Result := nil;
+end;
 
 function TPlayerCells.SearchCell(Cell: TCell): TPlayerCell;
@@ -792 +880 @@
 { TPlayerMap }
 
+procedure TPlayerMap.PaintCell(Canvas: TCanvas; Pos: TPoint; Text: string;
+  View: TView; Cell: TPlayerCell);
+var
+  I: Integer;
+  TextPos: TPoint;
+  Points: array of Classes.TPoint;
+  TextSize: TSize;
+begin
+  if Cell.MapCell.Extra = etObjectiveTarget then begin
+    Text := Text + '!';
+  end;
+  with Canvas do begin
+    if Assigned(View.FocusedCell) and (View.FocusedCell = Cell) then begin
+      Pen.Color := clYellow;
+      Pen.Style := psSolid;
+      Pen.Width := 1;
+    end else
+    if Cell.MapCell.Terrain = ttCity then begin
+      // Cannot set clear border as it will display shifted on gtk2
+      //Pen.Style := psClear;
+      Pen.Color := clBlack;
+      Pen.Style := psSolid;
+      Pen.Width := 3;
+    end else begin
+      // Cannot set clear border as it will display shifted on gtk2
+      //Pen.Style := psClear;
+      Pen.Color := Brush.Color;
+      Pen.Style := psSolid;
+      Pen.Width := 0;
+    end;
+    // Transform view
+    SetLength(Points, Length(Cell.MapCell.Polygon.Points));
+    for I := 0 to Length(Points) - 1 do
+      Points[I] := PointToStdPoint(View.CellToCanvasPos(Cell.MapCell.Polygon.Points[I]));
+    Brush.Style := bsSolid;
+    //Polygon(Points, False, 0, Length(Points));
+    TCanvasEx.PolygonEx(Canvas, Points, False);
+    //MoveTo(Points[0].X, Points[0].Y);
+    //LineTo(Points[1].X, Points[1].Y);
+
+    // Show cell text
+    if (Cell.GetAvialPower <> 0) or (Cell.MapCell.Extra = etObjectiveTarget) then begin
+      Pen.Style := psSolid;
+      Font.Color := clWhite;
+      Brush.Style := bsClear;
+      Font.Size := Trunc(42 * View.Zoom);
+      TextPos := View.CellToCanvasPos(Pos);
+      TextSize := TextExtent(Text);
+      TCanvasEx.TextOutEx(Canvas, Round(TextPos.X) - TextSize.cx div 2,
+        Round(TextPos.Y) - TextSize.cy div 2, Text, False);
+    end;
+  end;
+end;
+
+function TPlayerMap.PosToCell(Pos: TPoint; View: TView): TPlayerCell;
+var
+  I: Integer;
+begin
+  Result := nil;
+  for I := 0 to Cells.Count - 1 do
+  if Cells[I].MapCell.Terrain <> ttVoid then begin
+    if Cells[I].MapCell.Polygon.IsPointInside(Pos) then begin
+      Result := Cells[I];
+      Exit;
+    end;
+  end;
+end;
+
+function TPlayerMap.CellToPos(Cell: TPlayerCell): TPoint;
+begin
+  Result := Cell.MapCell.PosPx;
+end;
+
 procedure TPlayerMap.LoadFromNode(Node: TDOMNode);
 var
@@ -817 +978 @@
 var
   I: Integer;
+  J: Integer;
   OldCount: Integer;
 begin
+  for I := 0 to Cells.Count - 1 do
+  with TPlayerCell(Cells[I]) do begin
+    for J := Neighbors.Count - 1 downto 0 do
+      DisconnectFrom(Neighbors[J]);
+  end;
+
   // Update players cells count to map cells count to be 1:1
   OldCount := Cells.Count;
@@ -825 +993 @@
     Cells[I] := TPlayerCell.Create;
 
+  for I := 0 to Player.Game.Map.Cells.Count - 1 do begin
+    with Cells[I] do begin
+      List := Cells;
+      Explored := False;
+      InVisibleRange := False;
+      MapCell := Player.Game.Map.Cells[I];
+      Player.Game.Map.Cells[I].PlayerCell := Cells[I];
+    end;
+  end;
+
   for I := 0 to Cells.Count - 1 do
-  with Cells[I] do begin
-    List := Cells;
-    Explored := False;
-    InVisibleRange := False;
-    MapCell := Player.Game.Map.Cells[I];
+  with TPlayerCell(Cells[I]) do begin
+    for J := 0 to MapCell.Neighbors.Count - 1 do
+      ConnectTo(TCell(MapCell.Neighbors[J]).PlayerCell);
   end;
 end;
@@ -896 +1072 @@
       if (Cell.MapCell.Terrain <> ttVoid) and Cell.MapCell.IsVisible(View) then begin
         if Cell.MapCell.Player = Player then
-          CellText := IntToStr(Cell.MapCell.GetAvialPower)
+          CellText := IntToStr(Cell.GetAvialPower)
           else CellText := IntToStr(Cell.MapCell.Power);
-        if Assigned(SelectedCell) and (SelectedCell = Cell.MapCell) then
+        if Assigned(SelectedCell) and (SelectedCell = Cell) then
             Brush.Color := clGreen
-          else if Assigned(SelectedCell) and Player.Game.Map.IsCellsNeighbor(SelectedCell, Cell.MapCell) then
+          else if Assigned(SelectedCell) and Player.Game.Map.IsCellsNeighbor(SelectedCell.MapCell, Cell.MapCell) then
             Brush.Color := clPurple
           else if Player.Game.FogOfWar then begin
@@ -915 +1091 @@
             end;
           end else Brush.Color := Cell.MapCell.GetColor;
-        Player.Game.Map.PaintCell(Canvas, Cell.MapCell.PosPx, CellText, View, Cell.MapCell);
+        Player.PlayerMap.PaintCell(Canvas, Cell.MapCell.PosPx, CellText, View, Cell);
       end else
       if Game.FogOfWar and (Cell.MapCell.Terrain = ttVoid) and (not Cell.Explored) then begin
         Brush.Color := clBlack;
-        Player.Game.Map.PaintCell(Canvas, Cell.MapCell.PosPx, '', View, Cell.MapCell);
+        Player.PlayerMap.PaintCell(Canvas, Cell.MapCell.PosPx, '', View, Cell);
       end;
     end;
@@ -941 +1117 @@
     Pen.Color := clCream;
     for Move in Player.Moves do begin
-      PosFrom := Player.Game.Map.CellToPos(Move.CellFrom);
-      PosTo := Player.Game.Map.CellToPos(Move.CellTo);
+      PosFrom := Player.Game.Map.CellToPos(Move.CellFrom.MapCell);
+      PosTo := Player.Game.Map.CellToPos(Move.CellTo.MapCell);
       // In Fog of war mode show only
-      if Game.FogOfWar and not Cells.SearchCell(Move.CellFrom).InVisibleRange and
-        not Cells.SearchCell(Move.CellTo).InVisibleRange then
+      if Game.FogOfWar and not Cells.SearchCell(Move.CellFrom.MapCell).InVisibleRange and
+        not Cells.SearchCell(Move.CellTo.MapCell).InVisibleRange then
         Continue;
       if Move.CountRepeat > 0 then Pen.Width := 2
@@ -1231 +1407 @@
 { TUnitMoves }
 
-function TUnitMoves.SearchByFromTo(CellFrom, CellTo: TCell): TUnitMove;
+function TUnitMoves.SearchByFromTo(CellFrom, CellTo: TPlayerCell): TUnitMove;
 var
   UnitMove: TUnitMove;
@@ -1308 +1484 @@
 
     Cell.Neighbors.Sort(CompareCellAngle);
+  end;
+end;
+
+procedure TMap.Paint(Canvas: TCanvas; View: TView);
+var
+  I: Integer;
+  Cell: TCell;
+  PosFrom, PosTo: TPoint;
+  Angle: Double;
+  ArrowCenter: TPoint;
+  Move: TUnitMove;
+  CellLink: TCellLink;
+begin
+  with Canvas, View do
+  try
+    Lock;
+
+    // Draw cell links
+    Pen.Color := clBlack;
+    Pen.Style := psSolid;
+    Pen.Width := 3;
+    for CellLink in CellLinks do
+    with CellLink do begin
+      if Length(Points) >= 2 then begin
+        MoveTo(PointToStdPoint(View.CellToCanvasPos(Points[0])));
+        for I := 1 to Length(Points) - 1 do
+          LineTo(PointToStdPoint(View.CellToCanvasPos(Points[I])));
+      end;
+    end;
+
+    // Draw cells
+    for Cell in Cells do begin
+      if (Cell.Terrain <> ttVoid) and Cell.IsVisible(View) then begin
+        if Assigned(SelectedCell) and (SelectedCell.MapCell = Cell) then
+          Brush.Color := clGreen
+          else if Assigned(SelectedCell) and IsCellsNeighbor(SelectedCell.MapCell, Cell) then
+            Brush.Color := clPurple
+          else Brush.Color := Cell.GetColor;
+        //Pen.Color := clBlack;
+        PaintCell(Canvas, Cell.PosPx, IntToStr(Cell.Power), View, Cell);
+      end;
+    end;
+  finally
+    Unlock;
   end;
 end;
@@ -1529 +1749 @@
   end;
   with Canvas do begin
-    if Assigned(View.FocusedCell) and (View.FocusedCell = Cell) then begin
+    if Assigned(View.FocusedCell) and (View.FocusedCell.MapCell = Cell) then begin
       Pen.Color := clYellow;
       Pen.Style := psSolid;
@@ -1558 +1778 @@
 
     // Show cell text
-    if (Cell.GetAvialPower <> 0) or (Cell.Extra = etObjectiveTarget) then begin
+    if (Cell.Power <> 0) or (Cell.Extra = etObjectiveTarget) then begin
       Pen.Style := psSolid;
       Font.Color := clWhite;
@@ -1753 +1973 @@
 { TUnitMove }
 
-procedure TUnitMove.SetCellFrom(AValue: TCell);
+procedure TUnitMove.SetCellFrom(AValue: TPlayerCell);
 begin
   if FCellFrom = AValue then Exit;
@@ -1765 +1985 @@
 end;
 
-procedure TUnitMove.SetCellTo(AValue: TCell);
+procedure TUnitMove.SetCellTo(AValue: TPlayerCell);
 begin
   if FCellTo = AValue then Exit;
@@ -1781 +2001 @@
   CountOnce := ReadInteger(Node, 'CountOnce', 0);
   CountRepeat := ReadInteger(Node, 'CountRepeat', 0);
-  CellFrom := List.Game.Map.Cells.FindById(ReadInteger(Node, 'CellFrom', 0));
-  CellTo := List.Game.Map.Cells.FindById(ReadInteger(Node, 'CellTo', 0));
+  CellFrom := List.Player.PlayerMap.Cells.FindByCellId(ReadInteger(Node, 'CellFrom', 0));
+  CellTo := List.Player.PlayerMap.Cells.FindByCellId(ReadInteger(Node, 'CellTo', 0));
 end;
 
@@ -1789 +2009 @@
   WriteInteger(Node, 'CountOnce', CountOnce);
   WriteInteger(Node, 'CountRepeat', CountRepeat);
-  WriteInteger(Node, 'CellFrom', CellFrom.Id);
-  WriteInteger(Node, 'CellTo', CellTo.Id);
+  WriteInteger(Node, 'CellFrom', CellFrom.MapCell.Id);
+  WriteInteger(Node, 'CellTo', CellTo.MapCell.Id);
 end;
 
@@ -1879 +2099 @@
   if I >= 0 then Neighbors.Delete(I)
     else Exception.Create('Can''t disconnect neigboring cells.');
-end;
-
-procedure TCell.Check;
-var
-  AvailPower: Integer;
-begin
-  AvailPower := GetAvialPower;
-  if AvailPower < 0 then
-    raise Exception.Create(Format(SUnitPowerMismatch, [Power, -(AvailPower - Power)]));
 end;
 
@@ -2036 +2247 @@
 end;
 
-function TCell.GetAvialPower: Integer;
-var
-  UnitMove: TUnitMove;
-begin
-  Result := Power;
-  for UnitMove in MovesFrom do
-    Result := Result - UnitMove.CountOnce;
-end;
-
-function TCell.GetAttackPower: Integer;
-var
-  I: Integer;
-begin
-  Result := 0;
-  for I := 0 to MovesTo.Count - 1 do
-    Result := Result + TUnitMove(MovesTo[I]).CountOnce;
-end;
-
 function TCell.ToString: ansistring;
 begin
@@ -2065 +2258 @@
   Neighbors := TCells.Create;
   Neighbors.FreeObjects := False;
-  MovesFrom := TUnitMoves.Create;
-  MovesFrom.FreeObjects := False;
-  MovesTo := TUnitMoves.Create;
-  MovesTo.FreeObjects := False;
   Links := TCellLinks.Create;
   Links.FreeObjects := False;
@@ -2077 +2266 @@
   I: Integer;
 begin
-  for I := MovesFrom.Count - 1 downto 0 do
-    TUnitMove(MovesFrom[I]).List.Remove(TUnitMove(MovesFrom[I]));
-  FreeAndNil(MovesFrom);
-  for I := MovesTo.Count - 1 downto 0 do
-    TUnitMove(MovesTo[I]).List.Remove(TUnitMove(MovesTo[I]));
-  FreeAndNil(MovesTo);
   for I := Links.Count - 1 downto 0 do
     FMap.CellLinks.Remove(Links[I]);
@@ -2169 +2352 @@
     if Assigned(NewNode) then
       PlayerMap.LoadFromNode(NewNode);
+    PlayerMap.Update;
   end;
   with Node do begin
@@ -2220 +2404 @@
 begin
   Moves := TUnitMoves.Create;
+  Moves.Player := Self;
   StartUnits := DefaultPlayerStartUnits;
   StartCell := nil;
@@ -2325 +2510 @@
 end;
 
-function CellCompare(const Item1, Item2: TCell): Integer;
-begin
-  if Item1.Power > Item2.Power then Result := 1
-  else if Item1.Power < Item2.Power then Result := -1
+function CellCompare(const Item1, Item2: TPlayerCell): Integer;
+begin
+  if Item1.MapCell.Power > Item2.MapCell.Power then Result := 1
+  else if Item1.MapCell.Power < Item2.MapCell.Power then Result := -1
   else Result := 0;
 end;
 
-function CellCompareDescending(const Item1, Item2: TCell): Integer;
-begin
-  if Item1.Power > Item2.Power then Result := -1
-  else if Item1.Power < Item2.Power then Result := 1
+function CellCompareDescending(const Item1, Item2: TPlayerCell): Integer;
+begin
+  if Item1.MapCell.Power > Item2.MapCell.Power then Result := -1
+  else if Item1.MapCell.Power < Item2.MapCell.Power then Result := 1
   else Result := 0;
 end;
@@ -2343 +2528 @@
 procedure TView.SelectCell(Pos: TPoint; Player: TPlayer; ShiftState: TShiftState);
 var
-  NewSelectedCell: TCell;
+  NewSelectedCell: TPlayerCell;
   UnitMove: TUnitMove;
   I: Integer;
 begin
-  NewSelectedCell := Game.Map.PosToCell(CanvasToCellPos(Pos), Self);
+  NewSelectedCell := Player.PlayerMap.PosToCell(CanvasToCellPos(Pos), Self);
   if Assigned(NewSelectedCell) then begin
-    if Assigned(SelectedCell) and Game.Map.IsCellsNeighbor(NewSelectedCell, SelectedCell) then begin
+    if Assigned(SelectedCell) and Game.Map.IsCellsNeighbor(NewSelectedCell.MapCell, SelectedCell.MapCell) then begin
       if ssShift in ShiftState then begin
         // Make maximum unit move without confirmation dialog
@@ -2355 +2540 @@
           Player.Moves.Remove(SelectedCell.MovesFrom[I]);
         end;
-        Game.CurrentPlayer.SetMove(SelectedCell, NewSelectedCell, SelectedCell.Power, False);
+        Game.CurrentPlayer.SetMove(SelectedCell, NewSelectedCell, SelectedCell.MapCell.Power, False);
         SelectedCell := nil;
       end else
@@ -2363 +2548 @@
         for I := SelectedCell.MovesFrom.Count - 1 downto 0 do
           Player.Moves.Remove(SelectedCell.MovesFrom[I]);
-        UnitMove := Game.CurrentPlayer.SetMove(SelectedCell, NewSelectedCell, SelectedCell.Power, False);
+        UnitMove := Game.CurrentPlayer.SetMove(SelectedCell, NewSelectedCell, SelectedCell.MapCell.Power, False);
         if Assigned(UnitMove) then
           UnitMove.CountRepeat := Player.Game.Map.MaxPower;
-        if NewSelectedCell.Player = Player then SelectedCell := NewSelectedCell
+        if NewSelectedCell.MapCell.Player = Player then SelectedCell := NewSelectedCell
           else SelectedCell := nil;
       end else begin
-        Game.CurrentPlayer.SetMove(SelectedCell, NewSelectedCell, SelectedCell.Power);
+        Game.CurrentPlayer.SetMove(SelectedCell, NewSelectedCell, SelectedCell.MapCell.Power);
         SelectedCell := nil;
       end;
     end else
-    if (NewSelectedCell <> SelectedCell) and (NewSelectedCell.Player = Player) then
+    if (NewSelectedCell <> SelectedCell) and (NewSelectedCell.MapCell.Player = Player) then
       SelectedCell := NewSelectedCell
     else
-    if (NewSelectedCell = SelectedCell) and (NewSelectedCell.Player = Player) then
+    if (NewSelectedCell = SelectedCell) and (NewSelectedCell.MapCell.Player = Player) then
       SelectedCell := nil;
   end;
@@ -2412 +2597 @@
   with UnitMove do begin
   if CountOnce > 0 then begin
-    if CellFrom.Player = Self then begin
+    if CellFrom.MapCell.Player = Self then begin
       UnitCount := CountOnce;
-      if CountOnce > CellFrom.Power then
-        UnitCount := CellFrom.Power;
+      if CountOnce > CellFrom.MapCell.Power then
+        UnitCount := CellFrom.MapCell.Power;
       CountOnce := 0;
-      if CellTo.Player = Self then begin
+      if CellTo.MapCell.Player = Self then begin
         // Inner move
-        CellTo.Power := CellTo.Power + UnitCount;
+        CellTo.MapCell.Power := CellTo.MapCell.Power + UnitCount;
       end else begin
         AttackerPower := UnitCount;
-        DefenderPower := CellTo.Power;
+        DefenderPower := CellTo.MapCell.Power;
         Attack(AttackerPower, DefenderPower);
         if DefenderPower = 0 then begin
           // Attacker wins with possible loses
           ClearMovesFromCell(CellTo);
-          CellTo.Player := Self;
-          CellTo.Power := AttackerPower;
+          CellTo.MapCell.Player := Self;
+          CellTo.MapCell.Power := AttackerPower;
         end else
         if AttackerPower = 0 then begin
           // Defender wins with possible loses
-          CellTo.Power := DefenderPower;
+          CellTo.MapCell.Power := DefenderPower;
         end else
           raise Exception.Create(SUnfinishedBattle);
       end;
-      CellFrom.Power := CellFrom.Power - UnitCount;
+      CellFrom.MapCell.Power := CellFrom.MapCell.Power - UnitCount;
     end;
     end;
@@ -2459 +2644 @@
 end;
 
-procedure TPlayer.ClearMovesFromCell(Cell: TCell);
-var
-  I: Integer;
-begin
-  if Assigned(Cell.Player) then
-  for I := Cell.Player.Moves.Count - 1 downto 0 do
-  if TUnitMove(Cell.Player.Moves[I]).CellFrom = Cell then
-    Cell.Player.Moves.Delete(I);
-end;
-
-function TPlayer.SetMove(CellFrom, CellTo: TCell; Power: Integer; Confirmation: Boolean = True): TUnitMove;
+procedure TPlayer.RemoveInvalidMoves;
+var
+  I: Integer;
+begin
+  for I := Moves.Count - 1 downto 0 do
+    if Moves[I].CellFrom.MapCell.Player <> Self then
+      Moves.Delete(I);
+end;
+
+procedure TPlayer.ClearMovesFromCell(Cell: TPlayerCell);
+var
+  I: Integer;
+begin
+  for I := Cell.MovesFrom.Count - 1 downto 0 do
+    Cell.MovesFrom.Delete(I);
+end;
+
+function TPlayer.SetMove(CellFrom, CellTo: TPlayerCell; Power: Integer; Confirmation: Boolean = True): TUnitMove;
 var
   NewMove: TUnitMove;
@@ -2476 +2668 @@
   Confirm: Boolean;
 begin
-  if CellFrom.Player <> Self then
+  if CellFrom.MapCell.Player <> Self then
     raise Exception.Create('Can''t set move of other player.');
   Confirm := True;
@@ -2518 +2710 @@
       end;
     end;
-    CellFrom.Check;
     if Assigned(Game.FOnMoveUpdated) then Game.FOnMoveUpdated(Result);
   end;
@@ -2529 +2720 @@
   for Move in Moves do
   with Move do begin
-    if CellFrom.Player = Self then
+    if CellFrom.MapCell.Player = Self then
       if CountRepeat <= CellFrom.GetAvialPower then
         CountOnce := CountRepeat
@@ -2543 +2734 @@
   // Remove empty moves
   for I := Moves.Count - 1 downto 0 do
-  if (TUnitMove(Moves[I]).CellFrom.Player = Self) and
+  if (TUnitMove(Moves[I]).CellFrom.MapCell.Player = Self) and
     (TUnitMove(Moves[I]).CountOnce = 0) and (TUnitMove(Moves[I]).CountRepeat = 0) then
     Moves.Delete(I);
@@ -2706 +2897 @@
     Area := NewArea;
     AreaExtend;
-  end;
-end;
-
-procedure TMap.Paint(Canvas: TCanvas; View: TView);
-var
-  I: Integer;
-  Cell: TCell;
-  PosFrom, PosTo: TPoint;
-  Angle: Double;
-  ArrowCenter: TPoint;
-  Move: TUnitMove;
-  CellLink: TCellLink;
-begin
-  with Canvas, View do
-  try
-    Lock;
-
-    // Draw cell links
-    Pen.Color := clBlack;
-    Pen.Style := psSolid;
-    Pen.Width := 3;
-    for CellLink in CellLinks do
-    with CellLink do begin
-      if Length(Points) >= 2 then begin
-        MoveTo(PointToStdPoint(View.CellToCanvasPos(Points[0])));
-        for I := 1 to Length(Points) - 1 do
-          LineTo(PointToStdPoint(View.CellToCanvasPos(Points[I])));
-      end;
-    end;
-
-    // Draw cells
-    for Cell in Cells do begin
-      if (Cell.Terrain <> ttVoid) and Cell.IsVisible(View) then begin
-        if Assigned(SelectedCell) and (SelectedCell = Cell) then
-            Brush.Color := clGreen
-          else if Assigned(SelectedCell) and IsCellsNeighbor(SelectedCell, Cell) then
-            Brush.Color := clPurple
-          else Brush.Color := Cell.GetColor;
-        //Pen.Color := clBlack;
-        PaintCell(Canvas, Cell.PosPx, IntToStr(Cell.GetAvialPower), View, Cell);
-      end;
-    end;
-
-    // Draw arrows
-    Pen.Color := clCream;
-    for Move in Game.CurrentPlayer.Moves do begin
-      PosFrom := CellToPos(Move.CellFrom);
-      PosTo := CellToPos(Move.CellTo);
-      if Move.CountRepeat > 0 then Pen.Width := 2
-        else Pen.Width := 1;
-      Angle := ArcTan((PosTo.Y - PosFrom.Y) / (PosTo.X - PosFrom.X));
-      if Sign(PosTo.X - PosFrom.X) = -1 then Angle := Angle + Pi;
-      ArrowCenter := View.CellToCanvasPos(TPoint.Create(Trunc(PosFrom.X + (PosTo.X - PosFrom.X) / 2),
-        Trunc(PosFrom.Y + (PosTo.Y - PosFrom.Y) / 2)));
-      DrawArrow(Canvas, View, ArrowCenter,
-        Angle, IntToStr(Move.CountOnce));
-    end;
-  finally
-    Unlock;
   end;
 end;
@@ -3249 +3381 @@
   CurrentPlayer.PlayerMap.CheckVisibility;
   CurrentPlayer.ReduceMovesPower;
+  CurrentPlayer.RemoveInvalidMoves;
   if Assigned(FOnChange) then
     FOnChange(Self);

trunk/UGameClient.pas

@@ -33 +33 @@
     procedure SetForm(AValue: TForm);
     procedure SetGame(AValue: TGame);
-    procedure PlayerMove(CellFrom, CellTo: TCell; var CountOnce, CountRepeat: Integer;
+    procedure PlayerMove(CellFrom, CellTo: TPlayerCell; var CountOnce, CountRepeat: Integer;
       Update: Boolean; var Confirm: Boolean);
     procedure SetOnMove(AValue: TMoveEvent);
@@ -124 +124 @@
 end;
 
-procedure TClient.PlayerMove(CellFrom, CellTo: TCell; var CountOnce,
+procedure TClient.PlayerMove(CellFrom, CellTo: TPlayerCell; var CountOnce,
   CountRepeat: Integer; Update: Boolean; var Confirm: Boolean);
 begin