Changeset 17

Timestamp:

Oct 5, 2019, 12:17:17 PM (5 years ago)

Author:

chronos

Message:

• Modified: Tiles matrix moved to separate class called TBoard.

Location:

trunk

Files:

• Forms/UFormMain.pas (modified) (1 diff)
• Forms/UFormNew.pas (modified) (1 diff)
• UCore.pas (modified) (3 diffs)
• UGame.pas (modified) (21 diffs)

trunk/Forms/UFormMain.pas

@@ -59 +59 @@
       40: MovedCount := Core.Game.MoveAll(drDown);
     end;
-    if MovedCount > 0 then Core.Game.FillRandomCell;
-    if not Core.Game.CanMove and (Core.Game.GetEmptyCellsCount = 0) then
+    if MovedCount > 0 then Core.Game.FillRandomTile;
+    if not Core.Game.CanMove and (Core.Game.Board.GetEmptyTilesCount = 0) then
       Core.Game.GameOver;
-    if (not Core.Game.Won) and (Core.Game.GetHighestCellValue >= 2048) then
+    if (not Core.Game.Won) and (Core.Game.Board.GetHighestTileValue >= 2048) then
       Core.Game.Win;
   end;

trunk/Forms/UFormNew.pas

@@ -45 +45 @@
 procedure TFormNew.Load(Game: TGame);
 begin
-  ComboBoxSize.ItemIndex := Game.Size.X - 3;
+  ComboBoxSize.ItemIndex := Game.Board.Size.X - 3;
 end;
 
 procedure TFormNew.Save(Game: TGame);
 begin
-  Game.Size := Point(3 + ComboBoxSize.ItemIndex, 3 + ComboBoxSize.ItemIndex);
+  Game.Board.Size := Point(3 + ComboBoxSize.ItemIndex, 3 + ComboBoxSize.ItemIndex);
 end;
 

trunk/UCore.pas

@@ -53 +53 @@
   Randomize;
   Game := TGame.Create;
-  Game.Size := Point(4, 4);
+  Game.Board.Size := Point(4, 4);
   Game.OnChange := GameChange;
   LoadConfig;
@@ -116 +116 @@
 
     Game.TopScore := ReadIntegerWithDefault('TopScore', 0);
-    Game.Size := Point(ReadIntegerWithDefault('SizeX', 4), ReadIntegerWithDefault('SizeY', 4));
+    Game.Board.Size := Point(ReadIntegerWithDefault('SizeX', 4), ReadIntegerWithDefault('SizeY', 4));
     Game.AnimationDuration := ReadIntegerWithDefault('AnimationDuration', 30);
     if ValueExists('LanguageCode') then
@@ -133 +133 @@
 
     WriteInteger('TopScore', Game.TopScore);
-    WriteInteger('SizeX', Game.Size.X);
-    WriteInteger('SizeY', Game.Size.Y);
+    WriteInteger('SizeX', Game.Board.Size.X);
+    WriteInteger('SizeY', Game.Board.Size.Y);
     WriteInteger('AnimationDuration', Game.AnimationDuration);
     if Assigned(Translator1.Language) and (Translator1.Language.Code <> '') then

trunk/UGame.pas

@@ -11 +11 @@
 type
 
-  { TCell }
-
-  TCell = class
+  { TTile }
+
+  TTile = class
     Value: Integer;
     NewValue: Integer;
@@ -19 +19 @@
     Moving: Boolean;
     Shift: TPoint;
-    procedure Assign(Source: TCell);
-  end;
-
-  TCells = class(TFPGObjectList<TCell>)
+    procedure Assign(Source: TTile);
+  end;
+
+  TTiles = class(TFPGObjectList<TTile>)
+  end;
+
+  { TBoard }
+
+  TBoard = class
+  private
+    FSize: TPoint;
+    procedure SetSize(AValue: TPoint);
+  public
+    Tiles: array of array of TTile;
+    procedure Assign(Source: TBoard);
+    procedure Clear;
+    procedure ClearMerged;
+    function GetHighestTileValue: Integer;
+    function GetEmptyTilesCount: Integer;
+    procedure GetEmptyTiles(EmptyTiles: TTiles);
+    destructor Destroy; override;
+    property Size: TPoint read FSize write SetSize;
   end;
 
@@ -35 +53 @@
     FRunning: Boolean;
     FScore: Integer;
-    FSize: TPoint;
-    function GetCellColor(Value: Integer): TColor;
+    function GetTileColor(Value: Integer): TColor;
     procedure SetScore(AValue: Integer);
-    procedure SetSize(AValue: TPoint);
-    procedure GetEmptyCells(EmptyCells: TCells);
     procedure DoChange;
-    procedure ClearMerged;
-    procedure RenderCell(Canvas: TCanvas; Cell: TCell; CellRect: TRect);
+    procedure RenderTile(Canvas: TCanvas; Tile: TTile; TileRect: TRect);
   public
-    Cells: array of array of TCell;
+    Board: TBoard;
     TopScore: Integer;
     AnimationDuration: Integer;
@@ -50 +64 @@
     procedure GameOver;
     procedure Win;
-    function FillRandomCell: Integer;
+    function FillRandomTile: Integer;
     function CanMove: Boolean;
-    function GetEmptyCellsCount: Integer;
-    function GetHighestCellValue: Integer;
     procedure Assign(Source: TGame);
     procedure New;
-    procedure Clear;
     procedure Render(Canvas: TCanvas; CanvasSize: TPoint);
     function MoveAll(Direction: TDirection): Integer;
-    procedure MoveCell(SourceCell, TargetCell: TCell);
+    procedure MoveTile(SourceTile, TargetTile: TTile);
     function IsValidPos(Pos: TPoint): Boolean;
     constructor Create;
     destructor Destroy; override;
     property Score: Integer read FScore write SetScore;
-    property Size: TPoint read FSize write SetSize;
     property Running: Boolean read FRunning write FRunning;
     property OnChange: TNotifyEvent read FOnChange write FOnChange;
@@ -85 +95 @@
 implementation
 
-{ TCell }
-
-procedure TCell.Assign(Source: TCell);
-begin
-  Value := Source.Value;
-  Merged := Source.Merged;
-end;
-
-{ TGame }
-
-procedure TGame.SetSize(AValue: TPoint);
+{ TBoard }
+
+procedure TBoard.SetSize(AValue: TPoint);
 var
   X, Y: Integer;
@@ -102 +104 @@
   for Y := 0 to FSize.Y - 1 do
     for X := 0 to FSize.X - 1 do
-      Cells[Y, X].Free;
+      Tiles[Y, X].Free;
   FSize := AValue;
-  SetLength(Cells, FSize.Y, FSize.X);
+  SetLength(Tiles, FSize.Y, FSize.X);
   for Y := 0 to FSize.Y - 1 do
     for X := 0 to FSize.X - 1 do
-      Cells[Y, X] := TCell.Create;
-end;
-
-procedure TGame.GetEmptyCells(EmptyCells: TCells);
-var
-  X, Y: Integer;
-begin
-  EmptyCells.Clear;
+      Tiles[Y, X] := TTile.Create;
+end;
+
+procedure TBoard.Assign(Source: TBoard);
+var
+  X, Y: Integer;
+begin
+  Size := Source.Size;
   for Y := 0 to Size.Y - 1 do
     for X := 0 to Size.X - 1 do
-      if Cells[Y, X].Value = 0 then
-        EmptyCells.Add(Cells[Y, X]);
-end;
-
-procedure TGame.DoChange;
-begin
-  if Assigned(FOnChange) then FOnChange(Self);
-end;
-
-procedure TGame.ClearMerged;
-var
-  X, Y: Integer;
-begin
+      Tiles[Y, X].Assign(Source.Tiles[Y, X]);
+end;
+
+procedure TBoard.GetEmptyTiles(EmptyTiles: TTiles);
+var
+  X, Y: Integer;
+begin
+  EmptyTiles.Clear;
   for Y := 0 to Size.Y - 1 do
     for X := 0 to Size.X - 1 do
-      Cells[Y, X].Merged := False;
+      if Tiles[Y, X].Value = 0 then
+        EmptyTiles.Add(Tiles[Y, X]);
+end;
+
+destructor TBoard.Destroy;
+begin
+  Size := Point(0, 0);
+  inherited Destroy;
+end;
+
+procedure TBoard.ClearMerged;
+var
+  X, Y: Integer;
+begin
+  for Y := 0 to Size.Y - 1 do
+    for X := 0 to Size.X - 1 do
+      Tiles[Y, X].Merged := False;
+end;
+
+function TBoard.GetEmptyTilesCount: Integer;
+var
+  X, Y: Integer;
+begin
+  Result := 0;
+  for Y := 0 to Size.Y - 1 do
+    for X := 0 to Size.X - 1 do
+      if Tiles[Y, X].Value = 0 then
+        Inc(Result);
+end;
+
+function TBoard.GetHighestTileValue: Integer;
+var
+  X, Y: Integer;
+begin
+  Result := 0;
+  for Y := 0 to Size.Y - 1 do
+    for X := 0 to Size.X - 1 do
+      if Result < Tiles[Y, X].Value then Result := Tiles[Y, X].Value;
+end;
+
+procedure TBoard.Clear;
+var
+  X, Y: Integer;
+begin
+  for Y := 0 to Size.Y - 1 do
+    for X := 0 to Size.X - 1 do
+      Tiles[Y, X].Value := 0;
+end;
+
+
+{ TTile }
+
+procedure TTile.Assign(Source: TTile);
+begin
+  Value := Source.Value;
+  Merged := Source.Merged;
+end;
+
+{ TGame }
+
+procedure TGame.DoChange;
+begin
+  if Assigned(FOnChange) then FOnChange(Self);
 end;
 
@@ -152 +211 @@
 end;
 
-function TGame.FillRandomCell: Integer;
-var
-  EmptyCells: TCells;
+function TGame.FillRandomTile: Integer;
+var
+  EmptyTiles: TTiles;
 begin
   Result := 0;
-  EmptyCells := TCells.Create(False);
-  GetEmptyCells(EmptyCells);
-  if EmptyCells.Count > 0 then begin
-    EmptyCells[Random(EmptyCells.Count)].Value := 2;
+  EmptyTiles := TTiles.Create(False);
+  Board.GetEmptyTiles(EmptyTiles);
+  if EmptyTiles.Count > 0 then begin
+    EmptyTiles[Random(EmptyTiles.Count)].Value := 2;
     Result := 1;
   end;
-  EmptyCells.Free;
+  EmptyTiles.Free;
 end;
 
@@ -187 +246 @@
 end;
 
-function TGame.GetEmptyCellsCount: Integer;
-var
-  X, Y: Integer;
-begin
-  Result := 0;
-  for Y := 0 to Size.Y - 1 do
-    for X := 0 to Size.X - 1 do
-      if Cells[Y, X].Value = 0 then
-        Inc(Result);
-end;
-
-function TGame.GetHighestCellValue: Integer;
-var
-  X, Y: Integer;
-begin
-  Result := 0;
-  for Y := 0 to Size.Y - 1 do
-    for X := 0 to Size.X - 1 do
-      if Result < Cells[Y, X].Value then Result := Cells[Y, X].Value;
-end;
-
 procedure TGame.Assign(Source: TGame);
 var
@@ -216 +254 @@
   AnimationDuration := Source.AnimationDuration;
   Won := Source.Won;
-  Size := Source.Size;
-  for Y := 0 to Size.Y - 1 do
-    for X := 0 to Size.X - 1 do
-      Cells[Y, X].Assign(Source.Cells[Y, X]);
+  Board.Assign(Source.Board);
 end;
 
@@ -226 +261 @@
   I: Integer;
 begin
-  Clear;
+  Board.Clear;
   Score := 0;
   Won := False;
   Running := True;
-  for I := 0 to 1 do FillRandomCell;
+  for I := 0 to 1 do FillRandomTile;
   DoChange;
 end;
 
-procedure TGame.Clear;
-var
-  X, Y: Integer;
-begin
-  for Y := 0 to Size.Y - 1 do
-    for X := 0 to Size.X - 1 do
-      Cells[Y, X].Value := 0;
-end;
-
 procedure TGame.Render(Canvas: TCanvas; CanvasSize: TPoint);
 var
   X, Y: Integer;
-  CellSize: TPoint;
+  TileSize: TPoint;
   ValueStr: string;
   Frame: TRect;
-  CellRect: TRect;
+  TileRect: TRect;
   TopBarHeight: Integer;
-  CellMargin: Integer;
+  TileMargin: Integer;
 begin
   TopBarHeight := ScaleY(24, 96);
-  CellMargin := Round(CanvasSize.X / Size.X * 0.02);
+  TileMargin := Round(CanvasSize.X / Board.Size.X * 0.02);
   Canvas.Brush.Style := bsSolid;
   Canvas.Brush.Color := clBlack;
@@ -272 +298 @@
   // So dimensions are provided by CanvasSize parameter.
   Frame := Rect(2, TopBarHeight, CanvasSize.X - 2, CanvasSize.Y - 2);
-  CellSize := Point(Frame.Width div Size.X, Frame.Height div Size.Y);
-  if CellSize.X < CellSize.Y then CellSize.Y := CellSize.X;
-  if CellSize.Y < CellSize.X then CellSize.X := CellSize.Y;
-  Frame := Rect(Frame.Width div 2 - (Size.X * CellSize.X) div 2,
-    Frame.Top + Frame.Height div 2 - (Size.Y * CellSize.Y) div 2,
-    Frame.Width div 2 + (Size.X * CellSize.X) div 2,
-    Frame.Top + Frame.Height div 2 + (Size.Y * CellSize.Y) div 2);
+  TileSize := Point(Frame.Width div Board.Size.X, Frame.Height div Board.Size.Y);
+  if TileSize.X < TileSize.Y then TileSize.Y := TileSize.X;
+  if TileSize.Y < TileSize.X then TileSize.X := TileSize.Y;
+  Frame := Rect(Frame.Width div 2 - (Board.Size.X * TileSize.X) div 2,
+    Frame.Top + Frame.Height div 2 - (Board.Size.Y * TileSize.Y) div 2,
+    Frame.Width div 2 + (Board.Size.X * TileSize.X) div 2,
+    Frame.Top + Frame.Height div 2 + (Board.Size.Y * TileSize.Y) div 2);
 
   Canvas.Brush.Style := bsSolid;
@@ -286 +312 @@
   Canvas.Font.Color := clBlack;
 
-  // Draw static cells
-  for Y := 0 to Size.Y - 1 do
-    for X := 0 to Size.X - 1 do begin
-      if Cells[Y, X].Moving then Canvas.Brush.Color := GetCellColor(0)
-        else Canvas.Brush.Color := GetCellColor(Cells[Y, X].Value);
+  // Draw static tiles
+  for Y := 0 to Board.Size.Y - 1 do
+    for X := 0 to Board.Size.X - 1 do begin
+      if Board.Tiles[Y, X].Moving then Canvas.Brush.Color := GetTileColor(0)
+        else Canvas.Brush.Color := GetTileColor(Board.Tiles[Y, X].Value);
       Canvas.Brush.Style := bsSolid;
-      CellRect := Bounds(
-        Frame.Left + X * CellSize.X + CellMargin,
-        Frame.Top + Y * CellSize.Y + CellMargin,
-        CellSize.X - 2 * CellMargin, CellSize.Y - 2 * CellMargin);
-      RenderCell(Canvas, Cells[Y, X], CellRect);
-    end;
-
-  // Draw moving cells
-  for Y := 0 to Size.Y - 1 do
-    for X := 0 to Size.X - 1 do
-    if Cells[Y, X].Moving then begin
-      Canvas.Brush.Color := GetCellColor(Cells[Y, X].Value);
+      TileRect := Bounds(
+        Frame.Left + X * TileSize.X + TileMargin,
+        Frame.Top + Y * TileSize.Y + TileMargin,
+        TileSize.X - 2 * TileMargin, TileSize.Y - 2 * TileMargin);
+      RenderTile(Canvas, Board.Tiles[Y, X], TileRect);
+    end;
+
+  // Draw moving Tiles
+  for Y := 0 to Board.Size.Y - 1 do
+    for X := 0 to Board.Size.X - 1 do
+    if Board.Tiles[Y, X].Moving then begin
+      Canvas.Brush.Color := GetTileColor(Board.Tiles[Y, X].Value);
       Canvas.Brush.Style := bsSolid;
-      CellRect := Bounds(
-        Frame.Left + X * CellSize.X + Trunc(Cells[Y, X].Shift.X / 100 * CellSize.X + CellMargin),
-        Frame.Top + Y * CellSize.Y + Trunc(Cells[Y, X].Shift.Y / 100 * CellSize.Y + CellMargin),
-        CellSize.X - 2 * CellMargin, CellSize.Y - 2 * CellMargin);
-      RenderCell(Canvas, Cells[Y, X], CellRect);
-    end;
-end;
-
-procedure TGame.RenderCell(Canvas: TCanvas; Cell: TCell; CellRect: TRect);
+      TileRect := Bounds(
+        Frame.Left + X * TileSize.X + Trunc(Board.Tiles[Y, X].Shift.X / 100 * TileSize.X + TileMargin),
+        Frame.Top + Y * TileSize.Y + Trunc(Board.Tiles[Y, X].Shift.Y / 100 * TileSize.Y + TileMargin),
+        TileSize.X - 2 * TileMargin, TileSize.Y - 2 * TileMargin);
+      RenderTile(Canvas, Board.Tiles[Y, X], TileRect);
+    end;
+end;
+
+procedure TGame.RenderTile(Canvas: TCanvas; Tile: TTile; TileRect: TRect);
 var
   ValueStr: string;
   TextSize: TSize;
 begin
-  Canvas.FillRect(CellRect);
-  if Cell.Value <> 0 then begin
-    ValueStr := IntToStr(Cell.Value);
+  Canvas.FillRect(TileRect);
+  if Tile.Value <> 0 then begin
+    ValueStr := IntToStr(Tile.Value);
     Canvas.Brush.Style := bsClear;
-    Canvas.Font.Height := Trunc(CellRect.Height * 0.7);
+    Canvas.Font.Height := Trunc(TileRect.Height * 0.7);
     TextSize := Canvas.TextExtent(ValueStr);
-    if TextSize.Width > CellRect.Width then
-      Canvas.Font.Height := Trunc(Canvas.Font.Height / TextSize.Width * CellRect.Width);
+    if TextSize.Width > TileRect.Width then
+      Canvas.Font.Height := Trunc(Canvas.Font.Height / TextSize.Width * TileRect.Width);
     TextSize := Canvas.TextExtent(ValueStr);
-    Canvas.TextOut(CellRect.Left + CellRect.Width div 2 - TextSize.Width div 2,
-      CellRect.Top + CellRect.Height div 2 - TextSize.Height div 2, ValueStr);
+    Canvas.TextOut(TileRect.Left + TileRect.Width div 2 - TextSize.Width div 2,
+      TileRect.Top + TileRect.Height div 2 - TextSize.Height div 2, ValueStr);
   end;
 end;
@@ -355 +381 @@
     drLeft: begin
       StartPoint := Point(1, 0);
-      AreaSize := Point(Size.X - 2, Size.Y - 1);
+      AreaSize := Point(Board.Size.X - 2, Board.Size.Y - 1);
       Increment := Point(1, 1);
       MoveDirection := Point(-1, 0);
@@ -361 +387 @@
     drUp: begin
       StartPoint := Point(0, 1);
-      AreaSize := Point(Size.X - 1, Size.Y - 2);
+      AreaSize := Point(Board.Size.X - 1, Board.Size.Y - 2);
       Increment := Point(1, 1);
       MoveDirection := Point(0, -1);
     end;
     drRight: begin
-      StartPoint := Point(Size.X - 2, 0);
-      AreaSize := Point(Size.X - 2, Size.Y - 1);
+      StartPoint := Point(Board.Size.X - 2, 0);
+      AreaSize := Point(Board.Size.X - 2, Board.Size.Y - 1);
       Increment := Point(-1, 1);
       MoveDirection := Point(1, 0);
     end;
     drDown: begin
-      StartPoint := Point(0, Size.Y - 2);
-      AreaSize := Point(Size.X - 1, Size.Y - 2);
+      StartPoint := Point(0, Board.Size.Y - 2);
+      AreaSize := Point(Board.Size.X - 1, Board.Size.Y - 2);
       Increment := Point(1, -1);
       MoveDirection := Point(0, 1);
@@ -379 +405 @@
   end;
   MovedCount := 0;
-  ClearMerged;
-  for I := 0 to Max(Size.X, Size.Y) - 1 do begin
+  Board.ClearMerged;
+  for I := 0 to Max(Board.Size.X, Board.Size.Y) - 1 do begin
     PI.Y := 0;
-    for Y := 0 to Size.Y - 1 do
-      for X := 0 to Size.X - 1 do begin
-        Cells[Y, X].NewValue := Cells[Y, X].Value;
-        Cells[Y, X].Moving := False;
+    for Y := 0 to Board.Size.Y - 1 do
+      for X := 0 to Board.Size.X - 1 do begin
+        Board.Tiles[Y, X].NewValue := Board.Tiles[Y, X].Value;
+        Board.Tiles[Y, X].Moving := False;
       end;
 
@@ -395 +421 @@
         PNew.Y := P.Y + DirectionDiff[Direction].Y;
         if IsValidPos(PNew) then begin
-          if (Cells[P.Y, P.X].NewValue <> 0) then begin
-            if (Cells[PNew.Y, PNew.X].NewValue = 0) then begin
-              Cells[P.Y, P.X].Moving := True;
-              Cells[PNew.Y, PNew.X].NewValue := Cells[P.Y, P.X].NewValue;
-              Cells[PNew.Y, PNew.X].Merged := Cells[P.Y, P.X].Merged;
-              Cells[P.Y, P.X].NewValue := 0;
-              Cells[P.Y, P.X].Merged := False;
+          if (Board.Tiles[P.Y, P.X].NewValue <> 0) then begin
+            if (Board.Tiles[PNew.Y, PNew.X].NewValue = 0) then begin
+              Board.Tiles[P.Y, P.X].Moving := True;
+              Board.Tiles[PNew.Y, PNew.X].NewValue := Board.Tiles[P.Y, P.X].NewValue;
+              Board.Tiles[PNew.Y, PNew.X].Merged := Board.Tiles[P.Y, P.X].Merged;
+              Board.Tiles[P.Y, P.X].NewValue := 0;
+              Board.Tiles[P.Y, P.X].Merged := False;
               Inc(MovedCount);
             end else
-            if (not Cells[P.Y, P.X].Merged) and (not Cells[PNew.Y, PNew.X].Merged) and
-            (Cells[PNew.Y, PNew.X].NewValue = Cells[P.Y, P.X].NewValue) then begin
-              Cells[P.Y, P.X].Moving := True;
-              Cells[PNew.Y, PNew.X].NewValue := Cells[PNew.Y, PNew.X].NewValue + Cells[P.Y, P.X].NewValue;
-              Cells[PNew.Y, PNew.X].Merged := True;
-              Cells[P.Y, P.X].NewValue := 0;
-              Cells[P.Y, P.X].Merged := False;
+            if (not Board.Tiles[P.Y, P.X].Merged) and (not Board.Tiles[PNew.Y, PNew.X].Merged) and
+            (Board.Tiles[PNew.Y, PNew.X].NewValue = Board.Tiles[P.Y, P.X].NewValue) then begin
+              Board.Tiles[P.Y, P.X].Moving := True;
+              Board.Tiles[PNew.Y, PNew.X].NewValue := Board.Tiles[PNew.Y, PNew.X].NewValue + Board.Tiles[P.Y, P.X].NewValue;
+              Board.Tiles[PNew.Y, PNew.X].Merged := True;
+              Board.Tiles[P.Y, P.X].NewValue := 0;
+              Board.Tiles[P.Y, P.X].Merged := False;
               Inc(MovedCount);
-              Score := Score + Cells[PNew.Y, PNew.X].NewValue;
+              Score := Score + Board.Tiles[PNew.Y, PNew.X].NewValue;
             end;
           end;
@@ -425 +451 @@
     end;
 
-    // Animate cell move
+    // Animate tiles move
     StartTime := Now;
-    EndTime := StartTime + AnimationDuration / 300 * OneSecond / Size.X;
+    EndTime := StartTime + AnimationDuration / 300 * OneSecond / Max(Board.Size.X, Board.Size.Y);
     if AnimationDuration > 0 then
     repeat
@@ -433 +459 @@
       Part := (Time - StartTime) / (EndTime - StartTime);
       if Part > 1 then Part := 1;
-      for Y := 0 to Size.Y - 1 do
-        for X := 0 to Size.X - 1 do begin
-          if Cells[Y, X].Moving then
-            Cells[Y, X].Shift := Point(Trunc(Part * MoveDirection.X * 100),
+      for Y := 0 to Board.Size.Y - 1 do
+        for X := 0 to Board.Size.X - 1 do begin
+          if Board.Tiles[Y, X].Moving then
+            Board.Tiles[Y, X].Shift := Point(Trunc(Part * MoveDirection.X * 100),
               Trunc(Part * MoveDirection.Y * 100));
         end;
@@ -444 +470 @@
     until Time > EndTime;
 
-    // Set final cell values
-    for Y := 0 to Size.Y - 1 do
-      for X := 0 to Size.X - 1 do begin
-        Cells[Y, X].Shift := Point(0, 0);
-        Cells[Y, X].Moving := False;
-        Cells[Y, X].Value := Cells[Y, X].NewValue;
+    // Set final tiles values
+    for Y := 0 to Board.Size.Y - 1 do
+      for X := 0 to Board.Size.X - 1 do begin
+        Board.Tiles[Y, X].Shift := Point(0, 0);
+        Board.Tiles[Y, X].Moving := False;
+        Board.Tiles[Y, X].Value := Board.Tiles[Y, X].NewValue;
       end;
     DoChange;
@@ -457 +483 @@
 end;
 
-procedure TGame.MoveCell(SourceCell, TargetCell: TCell);
-begin
-  TargetCell.Value := SourceCell.Value;
-  SourceCell.Value := 0;
-  TargetCell.Merged := SourceCell.Merged;
-  SourceCell.Merged := False;
+procedure TGame.MoveTile(SourceTile, TargetTile: TTile);
+begin
+  TargetTile.Value := SourceTile.Value;
+  SourceTile.Value := 0;
+  TargetTile.Merged := SourceTile.Merged;
+  SourceTile.Merged := False;
 end;
 
 function TGame.IsValidPos(Pos: TPoint): Boolean;
 begin
-  Result := (Pos.X >= 0) and (Pos.X < FSize.X) and
-    (Pos.Y >= 0) and (Pos.Y < FSize.Y);
+  Result := (Pos.X >= 0) and (Pos.X < Board.Size.X) and
+    (Pos.Y >= 0) and (Pos.Y < Board.Size.Y);
 end;
 
@@ -474 +500 @@
 begin
   AnimationDuration := 30;
+  Board := TBoard.Create;
 end;
 
 destructor TGame.Destroy;
 begin
-  Size := Point(0, 0);
+  FreeAndNil(Board);
   inherited;
 end;
 
-function TGame.GetCellColor(Value: Integer): TColor;
+function TGame.GetTileColor(Value: Integer): TColor;
 begin
   case Value of