WebSVN – jumper – Diff – /trunk/Main.pas

 unit Main;
 interface
 uses
   Windows, SysUtils, Classes, Graphics, Dialogs, StdCtrls, Menus, Controls,
   ComCtrls, ExtCtrls, Forms, MMSystem, LevelFunctions, Registry;
 type
-  TField = record
-    FieldType: TFieldType;
-    Goal: Boolean;
-    Panel: TPanel;
-    Stone: TImage;
-  end;
-  TGoalStatus = (gsUndefined, gsNoGoal, gsMultipleStonesRemaining, gsLastStoneInGoalRed, gsLastStoneInGoalYellow, gsLastStoneInGoalGreen, gsLastStoneOutsideGoal);
-  TFieldState = (fsUndefined, fsError, fsLocked, fsAvailable, fsStone);
-  TPlayGroundMatrix = array of array of TField;
   TMainForm = class(TForm)
     Playground: TPanel;
     MainMenu: TMainMenu;
     Help1: TMenuItem;
     MExit: TMenuItem;
     Statistics: TStatusBar;
     Timer: TTimer;
     MNewGame: TMenuItem;
     Help2: TMenuItem;
     MAbout: TMenuItem;
     MHelp: TMenuItem;
     N5: TMenuItem;
     MJumpHistory: TMenuItem;
     N2: TMenuItem;
     N4: TMenuItem;
     MHighScores: TMenuItem;
     MRestartGame: TMenuItem;
     MSettings: TMenuItem;
     MEnableSound: TMenuItem;
     MPauseTime: TMenuItem;
     N1: TMenuItem;
     MUndo: TMenuItem;
     N3: TMenuItem;
     Aboutthislevel1: TMenuItem;
     procedure MExitClick(Sender: TObject);
     procedure TimerTimer(Sender: TObject);
     procedure MNewGameClick(Sender: TObject);
     procedure MAboutClick(Sender: TObject);
     procedure FormShow(Sender: TObject);
     procedure FormCreate(Sender: TObject);
     procedure FormDestroy(Sender: TObject);
     procedure MJumpHistoryClick(Sender: TObject);
     procedure MRestartGameClick(Sender: TObject);
     procedure MHighScoresClick(Sender: TObject);
-    procedure MPauseTimeClick(Sender: TObject);
     procedure FormClose(Sender: TObject; var Action: TCloseAction);
     procedure MHelpClick(Sender: TObject);
-    procedure MEnableSoundClick(Sender: TObject);
     procedure MUndoClick(Sender: TObject);
     procedure Aboutthislevel1Click(Sender: TObject);
     procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
   private
     NoCloseQuery: boolean;
     CountedSeconds: Integer;
     LevelFile: String;
     LookupFieldCoordinateArray: array of TPoint;
     PrevPlaygroundMatrixes: array of TPlayGroundMatrix;
     PlaygroundMatrix: TPlayGroundMatrix;
     Points: Integer;
     LevelTotalStones: Integer;
     LevelRemovedStones: Integer;
     JumpHistory: TStringList;
     Level: TLevel;
     procedure LoadSettings;
     procedure SaveSettings;
     procedure RestartLevel;
     procedure SetNewPlayGroundMatrix(Matrix: TPlayGroundMatrix);
     procedure RedrawStonesFromMatrix(Matrix: TPlayGroundMatrix);
     function AskForLevel: String;
     function AreJumpsPossible: boolean;
     procedure StoneDraggingAllow(Stone: TImage; Allow: boolean);
     procedure NewGame(Filename: string);
     function LevelTime: String;
     procedure DestroyLevel;
     procedure RefreshTime;
     procedure RefreshPoints;
     procedure RefreshStonesRemoved;
     procedure CountPoints(t: TFieldType);
     procedure RemoveStone(x, y: integer; count_points: boolean);
     procedure DoJump(SourceTag, DestTag: integer);
     function CanJump(x, y: integer): boolean;
     function MayJump(SourceX, SourceY, DestX, DestY: integer): boolean; overload;
     function MayJump(SourceTag, DestTag: integer): boolean; overload;
     procedure StoneDragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
     procedure StoneDragDrop(Sender, Source: TObject; X, Y: Integer);
     function DrawField(x, y: integer; t: TFieldProperties; indent: integer): TField;
     function DrawStone(fieldtype: TFieldType; panel: TPanel): TImage;
     function DrawStoneBox(x, y, tag, halftabs: integer; isGoal: boolean): TPanel;
     procedure BuildPlayground(LevelArray: TLevelArray);
-    function FieldState(t: TFieldType): TFieldState; overload;
-    function FieldState(f: TField): TFieldState; overload;
-    function FieldState(x, y: integer): TFieldState; overload;
-    procedure ClearMatrix(Matrix: TPlayGroundMatrix; FreeVCL: boolean);
-    function CloneMatrix(Source: TPlayGroundMatrix): TPlayGroundMatrix;
-    function MatrixHasGoal(Matrix: TPlayGroundMatrix): boolean;
     procedure LoadPictureForType(FieldType: TFieldType; Picture: TPicture);
-    function MatrixWorth(Matrix: TPlayGroundMatrix): integer;
     function GoalStatus: TGoalStatus;
-    function GoalFieldType(Matrix: TPlayGroundMatrix): TFieldType;
   end;
 var
   MainForm: TMainForm;
 implementation
 uses
   About, Finish, Choice, Functions, History, HighScore, Help, Constants, Math;
 {$R *.dfm}
-function TMainForm.MatrixHasGoal(Matrix: TPlayGroundMatrix): boolean;
-var
-  i, j: integer;
-begin
-  result := false;
-  for i := Low(Matrix) to High(Matrix) do
-  begin
-    for j := Low(Matrix[i]) to High(Matrix[i]) do
-    begin
-      result := result or Matrix[i][j].Goal;
-    end;
-  end;
-end;
-function TMainForm.GoalFieldType(Matrix: TPlayGroundMatrix): TFieldType;
-var
-  i, j: integer;
-begin
-  result := ftEmpty; // Damit der Compiler nicht meckert
-  for i := Low(Matrix) to High(Matrix) do
-  begin
-    for j := Low(Matrix[i]) to High(Matrix[i]) do
-    begin
-      if Matrix[i][j].Goal then result := Matrix[i][j].FieldType
-    end;
-  end;
-end;
-function TMainForm.MatrixWorth(Matrix: TPlayGroundMatrix): integer;
-var
-  i, j: integer;
-begin
-  result := 0;
+{ TMainForm }
-  for i := Low(Matrix) to High(Matrix) do
-  begin
-    for j := Low(Matrix[i]) to High(Matrix[i]) do
-    begin
-      Inc(result, FieldTypeWorth(Matrix[i][j].FieldType));
-    end;
-  end;
-end;
-procedure TMainForm.ClearMatrix(Matrix: TPlayGroundMatrix; FreeVCL: boolean);
-var
-  i, j: integer;
-begin
-  for i := Low(Matrix) to High(Matrix) do
-  begin
-    for j := Low(Matrix[i]) to High(Matrix[i]) do
-    begin
-      if FreeVCL then
-      begin
-        if Assigned(Matrix[i][j].Stone) then Matrix[i][j].Stone.Free;
-        if Assigned(Matrix[i][j].Panel) then Matrix[i][j].Panel.Free;
-      end;
-    end;
-    SetLength(Matrix[i], 0);
-  end;
-  SetLength(Matrix, 0);
-end;
 procedure TMainForm.RedrawStonesFromMatrix(Matrix: TPlayGroundMatrix);
 var
   i, j: integer;
 begin
-  for i := Low(Matrix) to High(Matrix) do
+  for i := Low(Matrix.Fields) to High(Matrix.Fields) do
   begin
-    for j := Low(Matrix[i]) to High(Matrix[i]) do
+    for j := Low(Matrix.Fields[i]) to High(Matrix.Fields[i]) do
     begin
-      if Assigned(Matrix[i][j].Stone) then
+      if Assigned(Matrix.Fields[i][j].Stone) then
       begin
-        LoadPictureForType(Matrix[i][j].FieldType, Matrix[i][j].Stone.Picture);
+        LoadPictureForType(Matrix.Fields[i][j].FieldType, Matrix.Fields[i][j].Stone.Picture);
-        StoneDraggingAllow(Matrix[i][j].Stone, FieldState(Matrix[i][j].FieldType) <> fsAvailable);
+        StoneDraggingAllow(Matrix.Fields[i][j].Stone, Matrix.FieldState(Matrix.Fields[i][j].FieldType) <> fsAvailable);
       end;
     end;
   end;
 end;
 procedure TMainForm.DestroyLevel;
 var
   i: Integer;
 begin
+  MPauseTime.Checked := false;
   MPauseTime.Enabled := false;
   Timer.Enabled := false;
   MRestartGame.Enabled := false;
   LevelFile := '';
   CountedSeconds := 0;
   RefreshTime;
   Points := 0;
   RefreshPoints;
   LevelRemovedStones := 0;
   LevelTotalStones := 0;
   RefreshStonesRemoved;
   JumpHistory.Clear;
-  ClearMatrix(PlayGroundMatrix, true);
+  PlayGroundMatrix.ClearMatrix(true);
   for i := 0 to Length(PrevPlaygroundMatrixes)-1 do
-    ClearMatrix(PrevPlaygroundMatrixes[i], false);
+    PrevPlaygroundMatrixes[i].ClearMatrix(false);
   SetLength(PrevPlaygroundMatrixes, 0);
   MUndo.Enabled := false;
   SetLength(LookupFieldCoordinateArray, 0);
   if Assigned(Level) then FreeAndNil(Level);
 end;
 procedure TMainForm.LoadPictureForType(FieldType: TFieldType; Picture: TPicture);
 begin
   case FieldType of
     ftEmpty:  Picture.Bitmap.LoadFromResourceName(HInstance, RES_EMPTY);
     ftGreen:  Picture.Bitmap.LoadFromResourceName(HInstance, RES_GREEN);
     ftYellow: Picture.Bitmap.LoadFromResourceName(HInstance, RES_YELLOW);
     ftRed:    Picture.Bitmap.LoadFromResourceName(HInstance, RES_RED);
   end;
 end;
 function TMainForm.DrawStone(fieldtype: TFieldType; panel: TPanel): TImage;
 begin
   result := TImage.Create(panel);
   result.Parent := panel;
   LoadPictureForType(fieldtype, result.Picture);
   result.Width := panel.Width - 2*MET_SHAPE_MARGIN;
   result.Height := panel.Height - 2*MET_SHAPE_MARGIN;
   result.Left := MET_SHAPE_MARGIN;
   result.Top := MET_SHAPE_MARGIN;
   result.Center := true;
   result.Transparent := true;
   result.Tag := panel.Tag;
   result.OnDragOver := panel.OnDragOver;
   result.OnDragDrop := panel.OnDragDrop;
-  StoneDraggingAllow(result, FieldState(fieldtype) <> fsAvailable);
+  StoneDraggingAllow(result, PlayGroundMatrix.FieldState(fieldtype) <> fsAvailable);
 end;
 procedure TMainForm.StoneDraggingAllow(Stone: TImage; Allow: boolean);
 begin
   if Allow then
   begin
     Stone.DragMode := dmAutomatic;
     (Stone.Parent as TPanel).DragMode := dmAutomatic;
   end
   else
   begin
     Stone.DragMode := dmManual;
     (Stone.Parent as TPanel).DragMode := dmManual;
   end;
 end;
 function TMainForm.DrawStoneBox(x, y, tag, halftabs: integer; isGoal: boolean): TPanel;
 begin
   result := TPanel.Create(Playground);
   result.Parent := Playground;
   if isGoal then
   begin
     result.BevelInner := bvLowered;
   end;
   result.Color := Playground.Color;
   result.BevelOuter := bvLowered;
   result.Width := MET_FIELD_SIZE;
   result.Height := MET_FIELD_SIZE;
   result.Left := x * (MET_FIELD_SIZE+MET_FIELD_SPACE) + MET_FIELD_SPACE + (halftabs*MET_HALFTAB_SIZE);
   result.Top := y * (MET_FIELD_SIZE+MET_FIELD_SPACE) + MET_FIELD_SPACE;
   result.Tag := tag;
   result.OnDragOver := StoneDragOver;
   result.OnDragDrop := StoneDragDrop;
 end;
 procedure TMainForm.MExitClick(Sender: TObject);
 begin
   Close;
 end;
-function TMainForm.FieldState(t: TFieldType): TFieldState;
-begin
-  result := fsError;
-  case t of
-    ftFullSpace:     result := fsLocked;
-    ftEmpty:         result := fsAvailable;
-    ftGreen:         result := fsStone;
-    ftYellow:        result := fsStone;
-    ftRed:           result := fsStone;
-  end;
-end;
-function TMainForm.FieldState(f: TField): TFieldState;
-begin
-  result := FieldState(f.FieldType);
-end;
-function TMainForm.FieldState(x, y: integer): TFieldState;
-begin
-  result := fsError;
-  if (x < Low(PlayGroundMatrix)) or (x > High(PlayGroundMatrix)) then exit;
-  if (y < Low(PlayGroundMatrix[x])) or (y > High(PlayGroundMatrix[x])) then exit;
-  result := FieldState(PlayGroundMatrix[x][y]);
-end;
 procedure TMainForm.RefreshTime;
 begin
   Statistics.Panels.Items[0].Text := Format(LNG_TIME, [LevelTime]);
 end;
 procedure TMainForm.RefreshStonesRemoved;
+resourcestring
+  LNG_STONES_REMOVED = '%d of %d stones removed';
 begin
   Statistics.Panels.Items[1].Text := Format(LNG_STONES_REMOVED, [LevelRemovedStones, LevelTotalStones-1]);
 end;
 procedure TMainForm.RefreshPoints;
 begin
   Statistics.Panels.Items[2].Text := Format(LNG_POINTS, [Points]);
 end;
 procedure TMainForm.CountPoints(t: TFieldType);
 begin
   inc(Points, FieldTypeWorth(t));
   RefreshPoints;
 end;
 procedure TMainForm.RemoveStone(x, y: integer; count_points: boolean);
 begin
   if count_points then
   begin
-    CountPoints(PlayGroundMatrix[x, y].FieldType);
+    CountPoints(PlayGroundMatrix.Fields[x, y].FieldType);
     Inc(LevelRemovedStones);
     RefreshStonesRemoved;
   end;
-  PlayGroundMatrix[x, y].FieldType := ftEmpty;
+  PlayGroundMatrix.Fields[x, y].FieldType := ftEmpty;
-  LoadPictureForType(PlayGroundMatrix[x, y].FieldType, PlayGroundMatrix[x, y].Stone.Picture);
+  LoadPictureForType(PlayGroundMatrix.Fields[x, y].FieldType, PlayGroundMatrix.Fields[x, y].Stone.Picture);
-  StoneDraggingAllow(PlayGroundMatrix[x, y].Stone, false);
+  StoneDraggingAllow(PlayGroundMatrix.Fields[x, y].Stone, false);
 end;
 function TMainForm.CanJump(x, y: integer): boolean;
 begin
-  if FieldState(x, y) <> fsStone then
+  if PlayGroundMatrix.FieldState(x, y) <> fsStone then
   begin
     result := false;
     exit;
   end;
   result := true;
   if MayJump(x, y, x+2, y) then exit;
   if MayJump(x, y, x-2, y) then exit;
   if MayJump(x, y, x, y+2) then exit;
   if MayJump(x, y, x, y-2) then exit;
   if Level.GetGameMode = gmDiagonal then
   begin
     if MayJump(x, y, x-2, y-2) then exit;
     if MayJump(x, y, x+2, y-2) then exit;
     if MayJump(x, y, x-2, y+2) then exit;
     if MayJump(x, y, x+2, y+2) then exit;
   end;
   result := false;
 end;
 procedure TMainForm.Aboutthislevel1Click(Sender: TObject);
 var
   mode: string;
   goalYeSNo: string;
 resourcestring
   LNG_BOARD = 'Board: %s';
   LNG_MODE = 'Mode: %s';
   LNG_STONES_TOTAL = 'Stones: %d';
   LNG_GOAL_AVAILABLE = 'Target field defined';
   LNG_NO_GOAL = 'No target field';
 begin
   if Level.GetGameMode = gmDiagonal then
     mode := 'Diagonal'
   else if Level.GetGameMode = gmNormal then
     mode := 'Normal'
   else
     mode := '?';
   if GoalStatus = gsNoGoal then
     goalYeSNo := LNG_NO_GOAL
   else
     goalYeSNo := LNG_GOAL_AVAILABLE;
   ShowMessage(Format(LNG_BOARD, [ExtractFileNameWithoutExt(LevelFile)]) + #13#10 +
               #13#10 +
               Format(LNG_MODE, [mode]) + #13#10 +
               Format(LNG_STONES_TOTAL, [LevelTotalStones]) + #13#10 +
               goalYesNo);
 end;
 function TMainForm.AreJumpsPossible: boolean;
 var
   i, j: integer;
 begin
   result := false;
-  for i := Low(PlayGroundMatrix) to High(PlayGroundMatrix) do
+  for i := Low(PlayGroundMatrix.Fields) to High(PlayGroundMatrix.Fields) do
   begin
-    for j := Low(PlayGroundMatrix[i]) to High(PlayGroundMatrix[i]) do
+    for j := Low(PlayGroundMatrix.Fields[i]) to High(PlayGroundMatrix.Fields[i]) do
     begin
       if CanJump(i, j) then
       begin
         result := true;
         break;
       end;
       if result then break;
     end;
   end;
 end;
 procedure TMainForm.DoJump(SourceTag, DestTag: integer);
+resourcestring
+  LNG_JUMP_LOG = '%d [%d, %d] -> %d [%d, %d];';
 var
   d, s: TPoint;
   old_fieldtype: TFieldType;
   res: Integer;
 begin
   if not MayJump(SourceTag, DestTag) then exit;
   d := LookupFieldCoordinateArray[DestTag];
   s := LookupFieldCoordinateArray[SourceTag];
   JumpHistory.Add(Format(LNG_JUMP_LOG, [SourceTag+1, s.x+1, s.y+1, DestTag+1, d.x+1, d.y+1]));
   {$REGION 'Stein entfernen und Punkte vergeben'}
   if Level.GetGameMode = gmDiagonal then
   begin
-    if (s.X-2 = d.X) and (s.Y-2 = d.Y) and (FieldState(s.X-1, s.Y-1) = fsStone) then RemoveStone(s.X-1, s.Y-1, true);
+    if (s.X-2 = d.X) and (s.Y-2 = d.Y) and (PlayGroundMatrix.FieldState(s.X-1, s.Y-1) = fsStone) then RemoveStone(s.X-1, s.Y-1, true);
-    if (s.X-2 = d.X) and (s.Y+2 = d.Y) and (FieldState(s.X-1, s.Y+1) = fsStone) then RemoveStone(s.X-1, s.Y+1, true);
+    if (s.X-2 = d.X) and (s.Y+2 = d.Y) and (PlayGroundMatrix.FieldState(s.X-1, s.Y+1) = fsStone) then RemoveStone(s.X-1, s.Y+1, true);
-    if (s.X+2 = d.X) and (s.Y-2 = d.Y) and (FieldState(s.X+1, s.Y-1) = fsStone) then RemoveStone(s.X+1, s.Y-1, true);
+    if (s.X+2 = d.X) and (s.Y-2 = d.Y) and (PlayGroundMatrix.FieldState(s.X+1, s.Y-1) = fsStone) then RemoveStone(s.X+1, s.Y-1, true);
-    if (s.X+2 = d.X) and (s.Y+2 = d.Y) and (FieldState(s.X+1, s.Y+1) = fsStone) then RemoveStone(s.X+1, s.Y+1, true);
+    if (s.X+2 = d.X) and (s.Y+2 = d.Y) and (PlayGroundMatrix.FieldState(s.X+1, s.Y+1) = fsStone) then RemoveStone(s.X+1, s.Y+1, true);
   end;
-  if (s.X+2 = d.X) and (s.Y = d.Y) and (FieldState(s.X+1, s.Y  ) = fsStone) then RemoveStone(s.X+1, s.Y, true);
+  if (s.X+2 = d.X) and (s.Y = d.Y) and (PlayGroundMatrix.FieldState(s.X+1, s.Y  ) = fsStone) then RemoveStone(s.X+1, s.Y, true);
-  if (s.X-2 = d.X) and (s.Y = d.Y) and (FieldState(s.X-1, s.Y  ) = fsStone) then RemoveStone(s.X-1, s.Y, true);
+  if (s.X-2 = d.X) and (s.Y = d.Y) and (PlayGroundMatrix.FieldState(s.X-1, s.Y  ) = fsStone) then RemoveStone(s.X-1, s.Y, true);
-  if (s.X = d.X) and (s.Y+2 = d.Y) and (FieldState(s.X  , s.Y+1) = fsStone) then RemoveStone(s.X, s.Y+1, true);
+  if (s.X = d.X) and (s.Y+2 = d.Y) and (PlayGroundMatrix.FieldState(s.X  , s.Y+1) = fsStone) then RemoveStone(s.X, s.Y+1, true);
-  if (s.X = d.X) and (s.Y-2 = d.Y) and (FieldState(s.X  , s.Y-1) = fsStone) then RemoveStone(s.X, s.Y-1, true);
+  if (s.X = d.X) and (s.Y-2 = d.Y) and (PlayGroundMatrix.FieldState(s.X  , s.Y-1) = fsStone) then RemoveStone(s.X, s.Y-1, true);
   {$ENDREGION}
   // Den Timer erst nach dem ersten Zug starten
   // oder nach einer Pause neustarten
-  if not Timer.Enabled then
+  MPauseTime.Checked := false;
-  begin
-    MPauseTime.Enabled := true;
+  MPauseTime.Enabled := true;
-    Timer.Enabled := true;
+  Timer.Enabled := true;
-  end;
-  MRestartGame.Enabled := true;
   // Sound abspielen
   if MEnableSound.Checked then PlaySound(RES_JUMP, HInstance, SND_ASYNC or SND_NOWAIT or SND_RESOURCE);
   {$REGION 'Nun den Stein springen lassen'}
-  old_fieldtype := PlayGroundMatrix[s.X, s.Y].FieldType; // Steinfarbe merken
+  old_fieldtype := PlayGroundMatrix.Fields[s.X, s.Y].FieldType; // Steinfarbe merken
   RemoveStone(s.X, s.Y, false); // Eigenen Stein entfernen. Keine Punkte zählen, da das unser eigener Stein ist, der springt
-  PlayGroundMatrix[d.X, d.Y].FieldType := old_fieldtype; // Farbe wiederherstellen
+  PlayGroundMatrix.Fields[d.X, d.Y].FieldType := old_fieldtype; // Farbe wiederherstellen
-  LoadPictureForType(PlayGroundMatrix[d.X, d.Y].FieldType, PlayGroundMatrix[d.X, d.Y].Stone.Picture); // Stein an neue Position malen
+  LoadPictureForType(PlayGroundMatrix.Fields[d.X, d.Y].FieldType, PlayGroundMatrix.Fields[d.X, d.Y].Stone.Picture); // Stein an neue Position malen
-  StoneDraggingAllow(PlayGroundMatrix[d.X, d.Y].Stone, true); // Und die Drag-Eigenschaft erneuern
+  StoneDraggingAllow(PlayGroundMatrix.Fields[d.X, d.Y].Stone, true); // Und die Drag-Eigenschaft erneuern
   {$ENDREGION}
   {$REGION 'Sind weitere Sprünge möglich oder ist das Spiel vorbei?'}
   if not AreJumpsPossible then
   begin
+    MPauseTime.Checked := false;
     MPauseTime.Enabled := false;
     Timer.Enabled := false;
     RefreshTime;
     if MEnableSound.Checked then
     begin
       if LevelRemovedStones = LevelTotalStones-1 then
       begin
         if GoalStatus in [gsLastStoneInGoalRed, gsLastStoneInGoalYellow, gsLastStoneInGoalGreen] then
           PlaySound(RES_WIN2, HInstance, SND_ASYNC or SND_NOWAIT or SND_RESOURCE)
         else
           PlaySound(RES_WIN1, HInstance, SND_ASYNC or SND_NOWAIT or SND_RESOURCE)
       end
       else
         PlaySound(RES_LOSE, HInstance, SND_ASYNC or SND_NOWAIT or SND_RESOURCE);
     end;
     res := FinishForm.Execute(ExtractFileNameWithoutExt(LevelFile), Points, LevelTotalStones, LevelRemovedStones, CountedSeconds, GoalStatus, JumpHistory);
     if (res = mrOK) and FinishForm.ReplayCheckbox.Checked then RestartLevel;
   end;
   {$ENDREGION}
   SetLength(PrevPlaygroundMatrixes, Length(PrevPlaygroundMatrixes)+1);
-  PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1] := CloneMatrix(PlaygroundMatrix);
+  PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1] := PlaygroundMatrix.CloneMatrix;
   MUndo.Enabled := true;
 end;
 function TMainForm.MayJump(SourceX, SourceY, DestX, DestY: integer): boolean;
 begin
   result := false;
   // Check 1: Ist das Zielfeld überhaupt leer?
-  if FieldState(DestX, DestY) <> fsAvailable then exit;
+  if PlayGroundMatrix.FieldState(DestX, DestY) <> fsAvailable then exit;
   // Check 2: Befindet sich ein Stein zwischen Source und Destination und ist der Abstand 2?
   if Level.GetGameMode = gmDiagonal then
   begin
-    if (SourceX-2 = DestX) and (SourceY-2 = DestY) and (FieldState(SourceX-1, SourceY-1) = fsStone) then result := true;
+    if (SourceX-2 = DestX) and (SourceY-2 = DestY) and (PlayGroundMatrix.FieldState(SourceX-1, SourceY-1) = fsStone) then result := true;
-    if (SourceX-2 = DestX) and (SourceY+2 = DestY) and (FieldState(SourceX-1, SourceY+1) = fsStone) then result := true;
+    if (SourceX-2 = DestX) and (SourceY+2 = DestY) and (PlayGroundMatrix.FieldState(SourceX-1, SourceY+1) = fsStone) then result := true;
-    if (SourceX+2 = DestX) and (SourceY-2 = DestY) and (FieldState(SourceX+1, SourceY-1) = fsStone) then result := true;
+    if (SourceX+2 = DestX) and (SourceY-2 = DestY) and (PlayGroundMatrix.FieldState(SourceX+1, SourceY-1) = fsStone) then result := true;
-    if (SourceX+2 = DestX) and (SourceY+2 = DestY) and (FieldState(SourceX+1, SourceY+1) = fsStone) then result := true;
+    if (SourceX+2 = DestX) and (SourceY+2 = DestY) and (PlayGroundMatrix.FieldState(SourceX+1, SourceY+1) = fsStone) then result := true;
   end;
-  if (SourceX+2 = DestX) and (SourceY   = DestY) and (FieldState(SourceX+1, SourceY  ) = fsStone) then result := true;
+  if (SourceX+2 = DestX) and (SourceY   = DestY) and (PlayGroundMatrix.FieldState(SourceX+1, SourceY  ) = fsStone) then result := true;
-  if (SourceX-2 = DestX) and (SourceY   = DestY) and (FieldState(SourceX-1, SourceY  ) = fsStone) then result := true;
+  if (SourceX-2 = DestX) and (SourceY   = DestY) and (PlayGroundMatrix.FieldState(SourceX-1, SourceY  ) = fsStone) then result := true;
-  if (SourceX   = DestX) and (SourceY+2 = DestY) and (FieldState(SourceX  , SourceY+1) = fsStone) then result := true;
+  if (SourceX   = DestX) and (SourceY+2 = DestY) and (PlayGroundMatrix.FieldState(SourceX  , SourceY+1) = fsStone) then result := true;
-  if (SourceX   = DestX) and (SourceY-2 = DestY) and (FieldState(SourceX  , SourceY-1) = fsStone) then result := true;
+  if (SourceX   = DestX) and (SourceY-2 = DestY) and (PlayGroundMatrix.FieldState(SourceX  , SourceY-1) = fsStone) then result := true;
 end;
 function TMainForm.MayJump(SourceTag, DestTag: integer): boolean;
 var
   s, d: TPoint;
 begin
   d := LookupFieldCoordinateArray[DestTag];
   s := LookupFieldCoordinateArray[SourceTag];
   result := MayJump(s.X, s.Y, d.X, d.Y);
 end;
 procedure TMainForm.StoneDragDrop(Sender, Source: TObject; X, Y: Integer);
 begin
   DoJump(TComponent(Source).Tag, TComponent(Sender).Tag);
 end;
 procedure TMainForm.StoneDragOver(Sender, Source: TObject; X,
   Y: Integer; State: TDragState; var Accept: Boolean);
 begin
   Accept := MayJump(TComponent(Source).Tag, TComponent(Sender).Tag);
 end;
 function TMainForm.DrawField(x, y: integer; t: TFieldProperties; indent: integer): TField;
 var
   newField: TField;
   index: integer;
 begin
   ZeroMemory(@result, SizeOf(result));
   if t.Typ = ftFullSpace then exit;
   index := Length(LookupFieldCoordinateArray);
   newField.FieldType := t.Typ;
   newField.Goal := t.Goal;
   newField.Panel := DrawStoneBox(x, y, index, indent, t.Goal);
   newField.Stone := DrawStone(t.Typ, newField.Panel);
-  if FieldState(t.Typ) = fsStone then Inc(LevelTotalStones);
+  if PlayGroundMatrix.FieldState(t.Typ) = fsStone then Inc(LevelTotalStones);
   SetLength(LookupFieldCoordinateArray, index + 1);
   LookupFieldCoordinateArray[index].X := x;
   LookupFieldCoordinateArray[index].Y := y;
-  if Length(PlayGroundMatrix) < x+1 then SetLength(PlayGroundMatrix, x+1);
+  if Length(PlayGroundMatrix.Fields) < x+1 then SetLength(PlayGroundMatrix.Fields, x+1);
-  if Length(PlayGroundMatrix[x]) < y+1 then SetLength(PlayGroundMatrix[x], y+1);
+  if Length(PlayGroundMatrix.Fields[x]) < y+1 then SetLength(PlayGroundMatrix.Fields[x], y+1);
-  PlaygroundMatrix[x, y] := newField;
+  PlaygroundMatrix.Fields[x, y] := newField;
   result := newField;
 end;
-function TMainForm.CloneMatrix(Source: TPlayGroundMatrix): TPlayGroundMatrix;
-var
-  i, j: integer;
-begin
-  SetLength(result, Length(Source));
-  for i := Low(Source) to High(Source) do
-  begin
-    SetLength(result[i], Length(Source[i]));
-    for j := Low(Source[i]) to High(Source[i]) do
-    begin
-      result[i][j].FieldType := Source[i][j].FieldType;
-      result[i][j].Goal      := Source[i][j].Goal;
-      result[i][j].Panel     := Source[i][j].Panel;
-      result[i][j].Stone     := Source[i][j].Stone;
-    end;
-  end;
-end;
 procedure TMainForm.BuildPlayground(LevelArray: TLevelArray);
 var
   y, x: integer;
   max_x, max_y: integer;
   p: TPanel;
 begin
   PlayGround.Visible := false;
   // Die Dimensionen ermitteln
   max_x := 0;
   max_y := 0;
   for y := Low(LevelArray) to High(LevelArray) do
   begin
     for x := Low(LevelArray[y].Fields) to High(LevelArray[y].Fields) do
     begin
       p := DrawField(x, y, LevelArray[y].Fields[x], LevelArray[y].Indent).Panel;
       if Assigned(p) then
       begin
         max_x := Max(max_x, p.Left + p.Width);
         max_y := Max(max_y, p.Top  + p.Height);
       end;
     end;
   end;
   PlayGround.Visible := true;
   // Das Form an das Level anpassen
   PlayGround.Top    := MET_OUTER_MARGIN;
   PlayGround.Left   := MET_OUTER_MARGIN;
   PlayGround.Width  := max_x;
   PlayGround.Height := max_y;
   ClientWidth       := 2 * MET_OUTER_MARGIN + PlayGround.Width;
   ClientHeight      := 2 * MET_OUTER_MARGIN + PlayGround.Height + Statistics.Height;
   // If the board is too small, ClientWidth/ClientHeight will stop at a minimum value
   // in this case, we make sure that the Playground is centered
   PlayGround.Left := ClientWidth div 2 - Playground.Width div 2;
   PlayGround.Top := (ClientHeight - Statistics.Height) div 2 - Playground.Height div 2;
   Statistics.Panels.Items[0].Width := Round(ClientWidth*MET_PERCENT_PNL_TIME);
   Statistics.Panels.Items[1].Width := Round(ClientWidth*MET_PERCENT_PNL_STONES);
   SetLength(PrevPlaygroundMatrixes,1);
-  PrevPlaygroundMatrixes[0] := CloneMatrix(PlayGroundMatrix);
+  PrevPlaygroundMatrixes[0] := PlayGroundMatrix.CloneMatrix;
   MUndo.Enabled := false;
 end;
 procedure TMainForm.TimerTimer(Sender: TObject);
 begin
+  if MPauseTime.Checked then exit;
   if mainform.Focused then Inc(CountedSeconds);
   RefreshTime;
 end;
 function TMainForm.LevelTime: String;
 begin
-  result := SecondsToTimeString(CountedSeconds);
+  result := FormatDateTime('hh:nn:ss', CountedSeconds / SecsPerDay)
 end;
 procedure TMainForm.NewGame(Filename: string);
+resourcestring
+  LNG_LVL_INVALID_NO_JUMP = 'Warning! The level is not playable. There are no jumps possible.';
 var
   LevelArray: TLevelArray;
 begin
   DestroyLevel;
+  MPauseTime.Checked := true;
+  MPauseTime.Enabled := true;
+  Timer.Enabled := true;
+  MRestartGame.Enabled := true;
   LevelFile := Filename;
   Level := TLevel.Create(LevelFile);
   LevelArray := Level.LevelStringToLevelArray(true);
   if Length(LevelArray) = 0 then Exit;
   BuildPlayground(LevelArray);
   if not AreJumpsPossible then
   begin
     MessageDlg(LNG_LVL_INVALID_NO_JUMP, mtError, [mbOk], 0);
   end;
   RefreshTime;
   RefreshStonesRemoved;
   RefreshPoints;
 end;
 procedure TMainForm.MNewGameClick(Sender: TObject);
 begin
   LevelFile := AskForLevel;
   if LevelFile <> '' then
   begin
     NewGame(LevelFile);
   end;
 end;
 procedure TMainForm.MAboutClick(Sender: TObject);
 begin
   AboutBox.ShowModal;
 end;
 function TMainForm.AskForLevel: String;
 begin
   LevelChoice.ShowModal;
   if LevelChoice.ModalResult <> mrOK then
   begin
     result := '';
     exit;
   end;
   result := LevelChoice.SelectedLevel;
 end;
 procedure TMainForm.FormShow(Sender: TObject);
 begin
   LevelFile := AskForLevel;
   if LevelFile <> '' then
   begin
     NewGame(LevelFile);
   end
   else
   begin
     NoCloseQuery := true;
     Close;
   end;
 end;
 function TMainForm.GoalStatus: TGoalStatus;
 var
   ft: TFieldType;
 begin
-  if not MatrixHasGoal(PlaygroundMatrix) then
+  if not PlaygroundMatrix.MatrixHasGoal then
     result := gsNoGoal
   else if LevelRemovedStones < LevelTotalStones-1 then
     Result := gsMultipleStonesRemaining
   else
   begin
-    ft := GoalFieldType(PlaygroundMatrix);
+    ft := PlaygroundMatrix.GoalFieldType;
     if ft = ftRed then
       result := gsLastStoneInGoalRed
     else if ft = ftYellow then
       result := gsLastStoneInGoalYellow
     else if ft = ftGreen then
       result := gsLastStoneInGoalGreen
     else
       result := gsUndefined;
   end;
 end;
 procedure TMainForm.FormCreate(Sender: TObject);
 begin
   JumpHistory := TStringList.Create;
   LoadSettings;
 end;
 procedure TMainForm.FormDestroy(Sender: TObject);
 begin
   DestroyLevel;
   JumpHistory.Free;
 end;
 procedure TMainForm.MJumpHistoryClick(Sender: TObject);
 begin
   HistoryForm.JumpMemo.Lines.Assign(JumpHistory);
   HistoryForm.ShowModal;
 end;
 procedure TMainForm.RestartLevel;
 var
   i: Integer;
 begin
-  MPauseTime.Enabled := false;
+  MPauseTime.Checked := true;
-  Timer.Enabled := false;
+  MPauseTime.Enabled := true;
-  MRestartGame.Enabled := false;
+  Timer.Enabled := true;
   CountedSeconds := 0;
   RefreshTime;
   Points := 0;
   RefreshPoints;
   LevelRemovedStones := 0;
   RefreshStonesRemoved;
   JumpHistory.Clear;
   RedrawStonesFromMatrix(PrevPlaygroundMatrixes[0]);
   SetNewPlayGroundMatrix(PrevPlaygroundMatrixes[0]);
   for i := 1 to Length(PrevPlaygroundMatrixes)-1 do
-    ClearMatrix(PrevPlaygroundMatrixes[i], false);
+    PrevPlaygroundMatrixes[i].ClearMatrix(false);
   SetLength(PrevPlaygroundMatrixes, 1);
   MUndo.Enabled := false;
 end;
 procedure TMainForm.SetNewPlayGroundMatrix(Matrix: TPlayGroundMatrix);
 begin
-  ClearMatrix(PlayGroundMatrix, false); // Memory Leak verhindern
+  PlayGroundMatrix.ClearMatrix(false); // Memory Leak verhindern
-  PlayGroundMatrix := CloneMatrix(Matrix);
+  PlayGroundMatrix := Matrix.CloneMatrix;
 end;
 procedure TMainForm.MRestartGameClick(Sender: TObject);
 begin
   RestartLevel;
 end;
 procedure TMainForm.MUndoClick(Sender: TObject);
 var
   PrevWorth: integer;
   NewWorth: integer;
 begin
   if Length(PrevPlaygroundMatrixes) > 1 then
   begin
-    PrevWorth := MatrixWorth(PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1]);
+    PrevWorth := PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1].MatrixWorth;
-    ClearMatrix(PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1], false);
+    PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1].ClearMatrix(false);
     SetLength(PrevPlaygroundMatrixes, Length(PrevPlaygroundMatrixes)-1);
-    NewWorth := MatrixWorth(PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1]);
+    NewWorth := PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1].MatrixWorth;
     RedrawStonesFromMatrix(PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1]);
     SetNewPlayGroundMatrix(PrevPlaygroundMatrixes[Length(PrevPlaygroundMatrixes)-1]);
     JumpHistory.Delete(JumpHistory.Count-1);
     Dec(LevelRemovedStones);
     RefreshStonesRemoved;
     Dec(Points, NewWorth-PrevWorth);
     RefreshPoints;
     // Sound abspielen
     if MEnableSound.Checked then PlaySound(RES_UNDO, HInstance, SND_ASYNC or SND_NOWAIT or SND_RESOURCE);
   end;
   MUndo.Enabled := Length(PrevPlaygroundMatrixes) > 1;
 end;
 procedure TMainForm.MHighScoresClick(Sender: TObject);
 begin
   HighScoreForm.Execute(ExtractFileNameWithoutExt(LevelFile));
 end;
-procedure TMainForm.MPauseTimeClick(Sender: TObject);
-begin
-  MPauseTime.Enabled := false;
-  Timer.Enabled := false;
-end;
 procedure TMainForm.LoadSettings;
 var
   reg: TRegistry;
 begin
   reg := TRegistry.Create;
   try
     reg.RootKey := HKEY_CURRENT_USER;
     if reg.OpenKeyReadOnly(REG_KEY) then
     begin
       if reg.ValueExists(REG_SOUND) then
         MEnableSound.Checked := reg.ReadBool(REG_SOUND);
       reg.CloseKey;
     end;
   finally
     reg.Free;
   end;
 end;
 procedure TMainForm.SaveSettings;
 var
   reg: TRegistry;
 begin
   reg := TRegistry.Create;
   try
     reg.RootKey := HKEY_CURRENT_USER;
     if reg.OpenKey(REG_KEY, true) then
     begin
       reg.WriteBool(REG_SOUND, MEnableSound.Checked);
       reg.CloseKey;
     end;
   finally
     reg.Free;
   end;
 end;
 procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction);
 begin
   SaveSettings;
   if FinishForm.NameEdit.Text <> '' then
   begin
     FinishForm.SaveSettings;
   end;
 end;
 procedure TMainForm.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
 resourcestring
   LNG_REALLY_QUIT = 'Do you really want to quit?';
 begin
   CanClose := NoCloseQuery or (MessageDlg(LNG_REALLY_QUIT, mtConfirmation, mbYesNoCancel, 0) = mrYes);
 end;
 procedure TMainForm.MHelpClick(Sender: TObject);
 begin
   HelpForm.ShowModal;
 end;
-procedure TMainForm.MEnableSoundClick(Sender: TObject);
-begin
-  MEnableSound.Checked := not MEnableSound.Checked;
-end;
 end.

Subversion Repositories jumper

jumper/trunk/Main.pas – Rev 19 → 21