Subversion Repositories jumper

Rev

Rev 22 | Rev 24 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 22 Rev 23
Line 48... Line 48...
48 
    procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
 48 
    procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
49 
  private
 49 
  private
50 
    NoCloseQuery: boolean;
 50 
    NoCloseQuery: boolean;
51 
    CountedSeconds: Integer;
 51 
    CountedSeconds: Integer;
52 
    LevelFile: String;
 52 
    LevelFile: String;
53 
    LookupFieldCoordinateArray: array of TPoint;
 - 
 
54 
    PrevPlaygroundMatrixes: array of TPlayGroundMatrix;
 53 
    PrevPlaygroundMatrixes: array of TPlayGroundMatrix;
55 
    PlaygroundMatrix: TPlayGroundMatrix;
 54 
    PlaygroundMatrix: TPlayGroundMatrix;
56 
    Points: Integer;
 55 
    Points: Integer;
57 
    LevelTotalStones: Integer;
 56 
    LevelTotalStones: Integer;
58 
    LevelRemovedStones: Integer;
 57 
    LevelRemovedStones: Integer;
Line 96... Line 95...
96 
 
 95 
 
97 
{ TMainForm }
 96 
{ TMainForm }
98 
 
 97 
 
99 
procedure TMainForm.RedrawStonesFromMatrix(Matrix: TPlayGroundMatrix);
 98 
procedure TMainForm.RedrawStonesFromMatrix(Matrix: TPlayGroundMatrix);
100 
var
 99 
var
101 
  i, j: integer;
 100 
  x, y: integer;
102 
begin
 101 
begin
103 
  for i := Low(Matrix.Fields) to High(Matrix.Fields) do
 102 
  for x := Low(Matrix.Fields) to High(Matrix.Fields) do
104 
  begin
 103 
  begin
105 
    for j := Low(Matrix.Fields[i]) to High(Matrix.Fields[i]) do
 104 
    for y := Low(Matrix.Fields[x]) to High(Matrix.Fields[x]) do
106 
    begin
 105 
    begin
107 
      if Assigned(Matrix.Fields[i][j].Stone) then
 106 
      if Assigned(Matrix.Fields[x][y].Stone) then
108 
      begin
 107 
      begin
109 
        LoadPictureForType(Matrix.Fields[i][j].FieldType, Matrix.Fields[i][j].Stone.Picture);
 108 
        LoadPictureForType(Matrix.Fields[x][y].FieldType, Matrix.Fields[x][y].Stone.Picture);
110 
        StoneDraggingAllow(Matrix.Fields[i][j].Stone, Matrix.FieldState(Matrix.Fields[i][j].FieldType) <> fsAvailable);
 109 
        StoneDraggingAllow(Matrix.Fields[x][y].Stone, Matrix.FieldState(Matrix.Fields[x][y].FieldType) <> fsAvailable);
111 
      end;
 110 
      end;
112 
    end;
 111 
    end;
113 
  end;
 112 
  end;
114 
end;
 113 
end;
115 
 
 114 
 
Line 141... Line 140...
141 
  for i := 0 to Length(PrevPlaygroundMatrixes)-1 do
 140 
  for i := 0 to Length(PrevPlaygroundMatrixes)-1 do
142 
    PrevPlaygroundMatrixes[i].ClearMatrix(false);
 141 
    PrevPlaygroundMatrixes[i].ClearMatrix(false);
143 
  SetLength(PrevPlaygroundMatrixes, 0);
 142 
  SetLength(PrevPlaygroundMatrixes, 0);
144 
  MUndo.Enabled := false;
 143 
  MUndo.Enabled := false;
145 
 
 144 
 
146 
  SetLength(LookupFieldCoordinateArray, 0);
 - 
 
147 
 
 - 
 
148 
  if Assigned(Level) then FreeAndNil(Level);
 145 
  if Assigned(Level) then FreeAndNil(Level);
149 
end;
 146 
end;
150 
 
 147 
 
151 
procedure TMainForm.LoadPictureForType(FieldType: TFieldType; Picture: TPicture);
 148 
procedure TMainForm.LoadPictureForType(FieldType: TFieldType; Picture: TPicture);
152 
begin
 149 
begin
Line 241... Line 238...
241 
    RefreshPoints;
 238 
    RefreshPoints;
242 
 
 239 
 
243 
    Inc(LevelRemovedStones);
 240 
    Inc(LevelRemovedStones);
244 
    RefreshStonesRemoved;
 241 
    RefreshStonesRemoved;
245 
  end;
 242 
  end;
- 
 
 243 
 
246 
  PlayGroundMatrix.Fields[x, y].FieldType := ftEmpty;
 244 
  PlayGroundMatrix.Fields[x, y].FieldType := ftEmpty;
247 
  LoadPictureForType(PlayGroundMatrix.Fields[x, y].FieldType, PlayGroundMatrix.Fields[x, y].Stone.Picture);
 245 
  LoadPictureForType(PlayGroundMatrix.Fields[x, y].FieldType, PlayGroundMatrix.Fields[x, y].Stone.Picture);
248 
  StoneDraggingAllow(PlayGroundMatrix.Fields[x, y].Stone, false);
 246 
  StoneDraggingAllow(PlayGroundMatrix.Fields[x, y].Stone, false);
249 
end;
 247 
end;
250 
 
 248 
 
Line 279... Line 277...
279 
 
 277 
 
280 
procedure TMainForm.DoJump(SourceTag, DestTag: integer);
 278 
procedure TMainForm.DoJump(SourceTag, DestTag: integer);
281 
resourcestring
 279 
resourcestring
282 
  LNG_JUMP_LOG = '%d [%d, %d] -> %d [%d, %d];';
 280 
  LNG_JUMP_LOG = '%d [%d, %d] -> %d [%d, %d];';
283 
var
 281 
var
284 
  d, s: TPoint;
 282 
  d, s: TCoord;
285 
  old_fieldtype: TFieldType;
 283 
  old_fieldtype: TFieldType;
286 
  res: Integer;
 284 
  res: Integer;
287 
begin
 285 
begin
288 
  if not MayJump(SourceTag, DestTag) then exit;
 286 
  if not MayJump(SourceTag, DestTag) then exit;
289 
 
 287 
 
290 
  d := LookupFieldCoordinateArray[DestTag];
 288 
  s := PlaygroundMatrix.IndexToCoord(SourceTag);
291 
  s := LookupFieldCoordinateArray[SourceTag];
 289 
  d := PlaygroundMatrix.IndexToCoord(DestTag);
292 
 
 290 
 
293 
  JumpHistory.Add(Format(LNG_JUMP_LOG, [SourceTag+1, s.x+1, s.y+1, DestTag+1, d.x+1, d.y+1]));
 291 
  JumpHistory.Add(Format(LNG_JUMP_LOG, [SourceTag+1, s.x+1, s.y+1, DestTag+1, d.x+1, d.y+1]));
294 
 
 292 
 
295 
  {$REGION 'Stein entfernen und Punkte vergeben'}
 293 
  {$REGION 'Stein entfernen und Punkte vergeben'}
296 
  if Level.GameMode = gmDiagonal then
 294 
  if Level.GameMode = gmDiagonal then
Line 353... Line 351...
353 
  MUndo.Enabled := true;
 351 
  MUndo.Enabled := true;
354 
end;
 352 
end;
355 
 
 353 
 
356 
function TMainForm.MayJump(SourceTag, DestTag: integer): boolean;
 354 
function TMainForm.MayJump(SourceTag, DestTag: integer): boolean;
357 
var
 355 
var
358 
  s, d: TPoint;
 356 
  s, d: TCoord;
359 
begin
 357 
begin
360 
  d := LookupFieldCoordinateArray[DestTag];
 358 
  s := PlayGroundMatrix.IndexToCoord(SourceTag);
361 
  s := LookupFieldCoordinateArray[SourceTag];
 359 
  d := PlayGroundMatrix.IndexToCoord(DestTag);
362 
 
 360 
 
363 
  result := PlaygroundMatrix.CanJump(s.X, s.Y, d.X, d.Y, Level.GameMode = gmDiagonal);
 361 
  result := PlaygroundMatrix.CanJump(s.X, s.Y, d.X, d.Y, Level.GameMode = gmDiagonal);
364 
end;
 362 
end;
365 
 
 363 
 
366 
procedure TMainForm.StoneDragDrop(Sender, Source: TObject; X, Y: Integer);
 364 
procedure TMainForm.StoneDragDrop(Sender, Source: TObject; X, Y: Integer);
Line 380... Line 378...
380 
  index: integer;
 378 
  index: integer;
381 
begin
 379 
begin
382 
  ZeroMemory(@result, SizeOf(result));
 380 
  ZeroMemory(@result, SizeOf(result));
383 
  if t.Typ = ftFullSpace then exit;
 381 
  if t.Typ = ftFullSpace then exit;
384 
 
 382 
 
385 
  index := Length(LookupFieldCoordinateArray);
 383 
  index := PlaygroundMatrix.CoordToIndex(x, y);
386 
 
 384 
 
387 
  newField.FieldType := t.Typ;
 385 
  newField.FieldType := t.Typ;
388 
  newField.Goal := t.Goal;
 386 
  newField.Goal := t.Goal;
389 
  newField.Panel := DrawStoneBox(x, y, index, indent, t.Goal);
 387 
  newField.Panel := DrawStoneBox(x, y, index, indent, t.Goal);
390 
  newField.Stone := DrawStone(t.Typ, newField.Panel);
 388 
  newField.Stone := DrawStone(t.Typ, newField.Panel);
391 
  if PlayGroundMatrix.FieldState(t.Typ) = fsStone then Inc(LevelTotalStones);
 - 
 
392 
 
 - 
 
393 
  SetLength(LookupFieldCoordinateArray, index + 1);
 - 
 
394 
  LookupFieldCoordinateArray[index].X := x;
 - 
 
395 
  LookupFieldCoordinateArray[index].Y := y;
 - 
 
396 
 
 - 
 
397 
  if Length(PlayGroundMatrix.Fields) < x+1 then SetLength(PlayGroundMatrix.Fields, x+1);
 - 
 
398 
  if Length(PlayGroundMatrix.Fields[x]) < y+1 then SetLength(PlayGroundMatrix.Fields[x], y+1);
 - 
 
399 
  PlaygroundMatrix.Fields[x, y] := newField;
 - 
 
400 
 
 389 
 
401 
  result := newField;
 390 
  result := newField;
402 
end;
 391 
end;
403 
 
 392 
 
404 
procedure TMainForm.BuildPlayground(LevelArray: TLevelArray);
 393 
procedure TMainForm.BuildPlayground(LevelArray: TLevelArray);
405 
var
 394 
var
406 
  y, x: integer;
 395 
  y, x: integer;
407 
  max_x, max_y: integer;
 396 
  max_x, max_y: integer;
408 
  p: TPanel;
 397 
  p: TPanel;
- 
 
 398 
  newField: TField;
409 
begin
 399 
begin
410 
  PlayGround.Visible := false;
 400 
  PlayGround.Visible := false;
411 
 
 401 
 
412 
  // Die Dimensionen ermitteln
 402 
  // Attention: PlaygroundMatrix is indexed [x,y] while LevelArray is indexed [y,x]
- 
 
 403 
  // TODO: PlaygroundMatrix and LevelArray are redundant. Can't we just replace one with the other?
- 
 
 404 
  PlaygroundMatrix.InitFieldArray(Length(LevelArray[0].Fields), Length(LevelArray));
- 
 
 405 
 
413 
  max_x := 0;
 406 
  max_x := 0;
414 
  max_y := 0;
 407 
  max_y := 0;
415 
  for y := Low(LevelArray) to High(LevelArray) do
 408 
  for y := Low(LevelArray) to High(LevelArray) do
416 
  begin
 409 
  begin
417 
    for x := Low(LevelArray[y].Fields) to High(LevelArray[y].Fields) do
 410 
    for x := Low(LevelArray[y].Fields) to High(LevelArray[y].Fields) do
418 
    begin
 411 
    begin
- 
 
 412 
      if TPlayGroundMatrix.FieldState(LevelArray[y].Fields[x].Typ) = fsStone then
- 
 
 413 
        Inc(LevelTotalStones);
419 
      p := DrawField(x, y, LevelArray[y].Fields[x], LevelArray[y].Indent).Panel;
 414 
      newField := DrawField(x, y, LevelArray[y].Fields[x], LevelArray[y].Indent);
- 
 
 415 
      PlaygroundMatrix.Fields[x, y] := newField;
- 
 
 416 
      p := newField.Panel;
420 
      if Assigned(p) then
 417 
      if Assigned(p) then
421 
      begin
 418 
      begin
422 
        max_x := Max(max_x, p.Left + p.Width);
 419 
        max_x := Max(max_x, p.Left + p.Width);
423 
        max_y := Max(max_y, p.Top  + p.Height);
 420 
        max_y := Max(max_y, p.Top  + p.Height);
424 
      end;
 421 
      end;