Janilabo | BoxGrid & PointGrid

type
  MSSL_TBoxGrid = record
    startPoint: TPoint;
    size, rows, columns, boxWidth, boxHeight, rowSpace, columnSpace: Integer;
    grid: array of record
      cell: MSSL_TCell;
      bx: TBox;
    end;
  end;
  MSSL_TPointGrid = record
    startPoint: TPoint;
    size, rows, columns, rowSpace, columnSpace: Integer;
    grid: array of record
      cell: MSSL_TCell;
      pt: TPoint;
    end;
  end;

function MSSL_BGBuild(var bg: MSSL_TBoxGrid; startX, startY, boxWidth, boxHeight, rows, columns, rowSpace, columnSpace: Integer): Boolean;
var
  id, r, c: Integer;
begin
  if ((startX < 0) or (startY < 0) or (boxWidth < 1) or (boxHeight < 1) or (rows < 1) or (columns < 1) or (rowSpace < 0) or (columnSpace < 0)) then
    Exit;
  bg.size := (rows * columns);
  bg.rows := rows;
  bg.columns := columns;
  bg.startPoint := Point(startX, startY);
  bg.boxWidth := boxWidth;
  bg.boxHeight := boxHeight;
  bg.rowSpace := rowSpace;
  bg.columnSpace := columnSpace;
  SetLength(bg.grid, bg.size);
  for r := 0 to (rows - 1) do
    for c := 0 to (columns - 1) do
    begin
      id := ((r * columns) + c);
      bg.grid[id].cell.row := r;
      bg.grid[id].cell.column := c;
      bg.grid[id].bx := Box((startX + ((id mod columns) * (boxWidth + (columnSpace + 1)))),
                            (startY + ((id div columns) * (boxHeight + (rowSpace + 1)))),
                            ((startX + ((id mod columns) * (boxWidth + (columnSpace + 1)))) + boxWidth),
                            ((startY + ((id div columns) * (boxHeight + (rowSpace + 1)))) + boxHeight));
    end;
  Result := True;
end;

function MSSL_BGAddRow(var bg: MSSL_TBoxGrid): Boolean;
var
  id, r, c: Integer;
begin
  if ((bg.startPoint.X < 0) or (bg.startPoint.Y < 0) or (bg.boxWidth < 1) or (bg.boxHeight < 1) or (bg.rowSpace < 0) or (bg.columnSpace < 0)) then
    Exit;
  SetLength(bg, 0);
  Inc(bg.rows);
  bg.size := (bg.rows * bg.columns);
  SetLength(bg.grid, bg.size);
  for r := 0 to (bg.rows - 1) do
    for c := 0 to (bg.columns - 1) do
    begin
      id := ((r * bg.columns) + c);
      bg.grid[id].cell.row := r;
      bg.grid[id].cell.column := c;
      bg.grid[id].bx := Box((bg.startPoint.X + ((id mod bg.columns) * (bg.boxWidth + (bg.columnSpace + 1)))),
                            (bg.startPoint.Y + ((id div bg.columns) * (bg.boxHeight + (bg.rowSpace + 1)))),
                            ((bg.startPoint.X + ((id mod bg.columns) * (bg.boxWidth + (bg.columnSpace + 1)))) + bg.boxWidth),
                            ((bg.startPoint.Y + ((id div bg.columns) * (bg.boxHeight + (bg.rowSpace + 1)))) + bg.boxHeight));
    end;
  Result := True;
end;

function MSSL_BGAddColumn(var bg: MSSL_TBoxGrid): Boolean;
var
  id, r, c: Integer;
begin
  if ((bg.startPoint.X < 0) or (bg.startPoint.Y < 0) or (bg.boxWidth < 1) or (bg.boxHeight < 1) or (bg.rowSpace < 0) or (bg.columnSpace < 0)) then
    Exit;
  SetLength(bg, 0);
  Inc(bg.columns);
  bg.size := (bg.rows * bg.columns);
  SetLength(bg.grid, bg.size);
  for r := 0 to (bg.rows - 1) do
    for c := 0 to (bg.columns - 1) do
    begin
      id := ((r * bg.columns) + c);
      bg.grid[id].cell.row := r;
      bg.grid[id].cell.column := c;
      bg.grid[id].bx := Box((bg.startPoint.X + ((id mod bg.columns) * (bg.boxWidth + (bg.columnSpace + 1)))),
                            (bg.startPoint.Y + ((id div bg.columns) * (bg.boxHeight + (bg.rowSpace + 1)))),
                            ((bg.startPoint.X + ((id mod bg.columns) * (bg.boxWidth + (bg.columnSpace + 1)))) + bg.boxWidth),
                            ((bg.startPoint.Y + ((id div bg.columns) * (bg.boxHeight + (bg.rowSpace + 1)))) + bg.boxHeight));
    end;
  Result := True;
end;

function MSSL_BGJumpCellByDistance(bg: MSSL_TBoxGrid; cell: MSSL_TCell; rowMoveDist, columnMoveDist: Integer): Boolean;
begin
  Result := (InRange(0, bg.rows, (cell.row + rowMoveDist)) and InRange(0, bg.columns, (cell.column + columnMoveDist)));
  if not Result then
    Exit;
  cell.row := (cell.row + rowMoveDist);
  cell.column := (cell.column + columnMoveDist);
end;

function MSSL_BGJumpCellByCompassDirection(bg: MSSL_TBoxGrid; var cell: MSSL_TCell; direction, distance: Integer): Boolean;
begin
  if ((distance < 1) or (distance > bg.columns) or (distance > bg.rows) or not InRange(direction, 0, 7)) then
    Exit;
  case direction of
    MSSL_COMPASS_DIRECTION_NORTH_EAST:
      begin
        if ((0 > (cell.row - distance)) or ((bg.columns - 1) < (cell.column + distance))) then
          Exit;
        cell.row := (cell.row - distance);
        cell.column := (cell.column + distance);
      end;
    MSSL_COMPASS_DIRECTION_SOUTH_EAST:
      begin
        if (((bg.rows - 1) < (cell.row + distance)) or ((bg.columns - 1) < (cell.column + distance))) then
          Exit;
        cell.row := (cell.row + distance);
        cell.column := (cell.column + distance);
      end;
    MSSL_COMPASS_DIRECTION_SOUTH_WEST:
      begin
        if (((bg.rows - 1) < (cell.row + distance)) or (0 > (cell.column - distance))) then
          Exit;
        cell.row := (cell.row + distance);
        cell.column := (cell.column - distance);
      end;
    MSSL_COMPASS_DIRECTION_NORTH_WEST:
      begin
        if ((0 > (cell.row - distance)) or (0 > (cell.column - distance))) then
          Exit;
        cell.row := (cell.row - distance);
        cell.column := (cell.column - distance);
      end;
    MSSL_COMPASS_DIRECTION_WEST:
      begin
        if (0 > (cell.column - distance)) then
          Exit;
        cell.column := (cell.column - distance);
      end;
    MSSL_COMPASS_DIRECTION_NORTH:
      begin
        if (0 > (cell.row - distance)) then
          Exit;
        cell.row := (cell.row - distance);
      end;
    MSSL_COMPASS_DIRECTION_EAST:
      begin
        if ((bg.columns - 1) < (cell.column + distance)) then
          Exit;
        cell.column := (cell.column + distance);
      end;
    MSSL_COMPASS_DIRECTION_SOUTH:
      begin
        if ((bg.rows - 1) < (cell.row + distance)) then
          Exit;
        cell.row := (cell.row + distance);
      end;
  end;
  Result := True;
end;

function MSSL_BGGetBoxes(bg: MSSL_TBoxGrid): TBoxArray;
var
  i: Integer;
begin
  if (bg.size < 1) then
    Exit;
  SetLength(Result, bg.size);
  for i := 0 to (bg.size - 1) do
    Result[i] := bg.grid[i].bx;
end;

function MSSL_BGConvertCellToID(bg: MSSL_TBoxGrid; cell: MSSL_TCell): Integer;
begin
  Result := -1;
  if (InRange(cell.row, 0, (bg.rows - 1)) and InRange(cell.column, 0, (bg.columns - 1))) then
    Result := ((cell.row * bg.columns) + cell.column);
end;

function MSSL_BGConvertIDToCell(bg: MSSL_TBoxGrid; ID: Integer): MSSL_TCell;
begin
  if InRange(ID, 0, (bg.size - 1)) then
    for Result.row := 0 to (bg.rows - 1) do
      for Result.column := 0 to (bg.columns - 1) do
        if (ID = ((Result.row * bg.columns) + Result.column)) then
          Exit;
  Result.row := -1;
  Result.column := -1;
end;

function MSSL_BGConvertPointToID(bg: MSSL_TBoxGrid; p: TPoint): Integer;
var
  i: Integer;
begin
  Result := -1;
  if (bg.size > 0) then
    for i := 0 to (bg.size - 1) do
      if PointInBox(p, bg.grid[i].bx) then
      begin
        Result := i;
        Exit;
      end;
end;

function MSSL_BGConvertIDToBox(bg: MSSL_TBoxGrid; ID: Integer): TBox;
begin
  Result := Box(-1, -1, -1, -1);
  if (InRange(ID, 0, (bg.size - 1)) and (bg.size > 0)) then
    Result := bg.grid[ID].bx;
end;

function MSSL_PGBuild(var pg: MSSL_TPointGrid; startX, startY, rows, columns, rowSpace, columnSpace: Integer): Boolean;
var
  id, r, c: Integer;
begin
  if ((startX < 0) or (startY < 0) or (rows < 1) or (columns < 1) or (rowSpace < 0) or (columnSpace < 0)) then
    Exit;
  pg.size := (rows * columns);
  pg.rows := rows;
  pg.columns := columns;
  pg.startPoint := Point(startX, startY);
  pg.rowSpace := rowSpace;
  pg.columnSpace := columnSpace;
  SetLength(pg.grid, pg.size);
  for r := 0 to (rows - 1) do
    for c := 0 to (columns - 1) do
    begin
      id := ((r * columns) + c);
      pg.grid[id].cell.row := r;
      pg.grid[id].cell.column := c;
      pg.grid[id].pt := Point((startX + ((id mod columns) * (columnSpace + 1))),
                              (startY + ((id div columns) * (rowSpace + 1))));
    end;
  Result := True;
end;

function MSSL_PGAddRow(var pg: MSSL_TPointGrid): Boolean;
var
  id, r, c: Integer;
begin
  if ((pg.startPoint.X < 0) or (pg.startPoint.Y < 0) or (pg.rowSpace < 0) or (pg.columnSpace < 0)) then
    Exit;
  SetLength(pg, 0);
  Inc(pg.rows);
  pg.size := (pg.rows * pg.columns);
  SetLength(pg.grid, pg.size);
  for r := 0 to (pg.rows - 1) do
    for c := 0 to (pg.columns - 1) do
    begin
      id := ((r * pg.columns) + c);
      pg.grid[id].cell.row := r;
      pg.grid[id].cell.column := c;
      pg.grid[id].pt := Point((pg.startPoint.X + ((id mod pg.columns) * (pg.columnSpace + 1))),
                              (pg.startPoint.Y + ((id div pg.columns) * (pg.rowSpace + 1))));
    end;
  Result := True;
end;

function MSSL_PGAddColumn(var pg: MSSL_TPointGrid): Boolean;
var
  id, r, c: Integer;
begin
  if ((pg.startPoint.X < 0) or (pg.startPoint.Y < 0) or (pg.rowSpace < 0) or (pg.columnSpace < 0)) then
    Exit;
  SetLength(pg, 0);
  Inc(pg.columns);
  pg.size := (pg.rows * pg.columns);
  SetLength(pg.grid, pg.size);
  for r := 0 to (pg.rows - 1) do
    for c := 0 to (pg.columns - 1) do
    begin
      id := ((r * pg.columns) + c);
      pg.grid[id].cell.row := r;
      pg.grid[id].cell.column := c;
      pg.grid[id].pt := Point((pg.startPoint.X + ((id mod pg.columns) * (pg.columnSpace + 1))),
                              (pg.startPoint.Y + ((id div pg.columns) * (pg.rowSpace + 1))));
    end;
  Result := True;
end;

function MSSL_PGJumpCellByDistance(pg: MSSL_TPointGrid; cell: MSSL_TCell; rowMoveDist, columnMoveDist: Integer): Boolean;
begin
  Result := (InRange(0, pg.rows, (cell.row + rowMoveDist)) and InRange(0, pg.columns, (cell.column + columnMoveDist)));
  if not Result then
    Exit;
  cell.row := (cell.row + rowMoveDist);
  cell.column := (cell.column + columnMoveDist);
end;

function MSSL_PGJumpCellByCompassDirection(pg: MSSL_TPointGrid; var cell: MSSL_TCell; direction, distance: Integer): Boolean;
begin
  if ((distance < 1) or (distance > pg.columns) or (distance > pg.rows) or not InRange(direction, 0, 7)) then
    Exit;
  case direction of
    MSSL_COMPASS_DIRECTION_NORTH_EAST:
      begin
        if ((0 > (cell.row - distance)) or ((pg.columns - 1) < (cell.column + distance))) then
          Exit;
        cell.row := (cell.row - distance);
        cell.column := (cell.column + distance);
      end;
    MSSL_COMPASS_DIRECTION_SOUTH_EAST:
      begin
        if (((pg.rows - 1) < (cell.row + distance)) or ((pg.columns - 1) < (cell.column + distance))) then
          Exit;
        cell.row := (cell.row + distance);
        cell.column := (cell.column + distance);
      end;
    MSSL_COMPASS_DIRECTION_SOUTH_WEST:
      begin
        if (((pg.rows - 1) < (cell.row + distance)) or (0 > (cell.column - distance))) then
          Exit;
        cell.row := (cell.row + distance);
        cell.column := (cell.column - distance);
      end;
    MSSL_COMPASS_DIRECTION_NORTH_WEST:
      begin
        if ((0 > (cell.row - distance)) or (0 > (cell.column - distance))) then
          Exit;
        cell.row := (cell.row - distance);
        cell.column := (cell.column - distance);
      end;
    MSSL_COMPASS_DIRECTION_WEST:
      begin
        if (0 > (cell.column - distance)) then
          Exit;
        cell.column := (cell.column - distance);
      end;
    MSSL_COMPASS_DIRECTION_NORTH:
      begin
        if (0 > (cell.row - distance)) then
          Exit;
        cell.row := (cell.row - distance);
      end;
    MSSL_COMPASS_DIRECTION_EAST:
      begin
        if ((pg.columns - 1) < (cell.column + distance)) then
          Exit;
        cell.column := (cell.column + distance);
      end;
    MSSL_COMPASS_DIRECTION_SOUTH:
      begin
        if ((pg.rows - 1) < (cell.row + distance)) then
          Exit;
        cell.row := (cell.row + distance);
      end;
  end;
  Result := True;
end;

function MSSL_PGGetPoints(pg: MSSL_TPointGrid): TPointArray;
var
  i: Integer;
begin
  if (pg.size < 1) then
    Exit;
  SetLength(Result, pg.size);
  for i := 0 to (pg.size - 1) do
    Result[i] := pg.grid[i].pt;
end;

function MSSL_PGCellToID(pg: MSSL_TPointGrid; cell: MSSL_TCell): Integer;
begin
  Result := -1;
  if (InRange(cell.row, 0, (pg.rows - 1)) and InRange(cell.column, 0, (pg.columns - 1))) then
    Result := ((cell.row * pg.columns) + cell.column);
end;

function MSSL_PGIDToCell(pg: MSSL_TPointGrid; ID: Integer): MSSL_TCell;
begin
  if InRange(ID, 0, (pg.size - 1)) then
    for Result.row := 0 to (pg.rows - 1) do
      for Result.column := 0 to (pg.columns - 1) do
        if (ID = ((Result.row * pg.columns) + Result.column)) then
          Exit;
  Result.row := -1;
  Result.column := -1;
end;

function MSSL_PGPointToID(pg: MSSL_TPointGrid; p: TPoint): Integer;
var
  i: Integer;
begin
  Result := -1;
  if (pg.size > 0) then
    for i := 0 to (pg.size - 1) do
      if (p = pg.grid[i].pt) then
      begin
        Result := i;
        Exit;
      end;
end;

function MSSL_PGIDToPoint(pg: MSSL_TPointGrid; ID: Integer): TPoint;
begin
  Result := Point(-1, -1);
  if (InRange(ID, 0, (pg.size - 1)) and (pg.size > 0)) then
    Result := pg.grid[ID].pt;
end;

function MSSL_PGPointToCell(pg: MSSL_TPointGrid; p: TPoint): MSSL_TCell;
begin
  if (pg.size > 0) then
    for Result.row := 0 to (pg.rows - 1) do
      for Result.column := 0 to (pg.columns - 1) do
        if (p = pg.grid[((Result.row * pg.columns) + Result.column)].pt) then
          Exit;
  Result.row := -1;
  Result.column := -1;
end;

function MSSL_PGCellToPoint(pg: MSSL_TPointGrid; cell: MSSL_TCell): TPoint;
var
  ID: Integer;
begin
  Result := Point(-1, -1);
  if (InRange(ID, 0, (pg.size - 1)) and (pg.size > 0)) then
    Result := pg.grid[((cell.row * pg.columns) + cell.column)].pt;
end;