X-Git-Url: https://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fgame%2Fg_grid.pas;h=81974570c4e201bd52d550e2b556fed261e8ffd6;hb=51343dcc874e5db55f029b0750892ca2da971c24;hp=9f14d3d5f69481dc9f6a6763cbb356c9e3b2f4f9;hpb=984a31dcc2636073083a3a3cf8d4d409019d211a;p=d2df-sdl.git

diff --git a/src/game/g_grid.pas b/src/game/g_grid.pas
index 9f14d3d..8197457 100644
--- a/src/game/g_grid.pas
+++ b/src/game/g_grid.pas
@@ -13,34 +13,41 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *)
-{$MODE DELPHI}
-{$modeswitch nestedprocvars}
+// universal spatial grid
+{$INCLUDE ../shared/a_modes.inc}
+{$DEFINE grid_use_buckets}
 unit g_grid;
 
 interface
 
-uses e_log;
-
 const
   GridDefaultTileSize = 32;
+  GridCellBucketSize = 8; // WARNING! can't be less than 2!
 
 type
-  GridQueryCB = function (obj: TObject; tag: Integer): Boolean is nested; // return `true` to stop
+  TGridQueryCB = function (obj: TObject; tag: Integer): Boolean is nested; // return `true` to stop
 
 type
   TBodyGrid = class;
 
-  TBodyProxy = class(TObject)
+  TBodyProxy = Integer;
+
+  PBodyProxyRec = ^TBodyProxyRec;
+  TBodyProxyRec = record
   private
     mX, mY, mWidth, mHeight: Integer; // aabb
     mQueryMark: DWord; // was this object visited at this query?
     mObj: TObject;
-    mGrid: TBodyGrid;
+    //mGrid: TBodyGrid;
     mTag: Integer;
+    nextLink: TBodyProxy; // next free or nothing
+
+  private
+    procedure setup (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
 
   public
-    constructor Create (aGrid: TBodyGrid; aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
-    destructor Destroy (); override;
+    //constructor Create (aGrid: TBodyGrid; aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
+    //destructor Destroy (); override;
 
     property x: Integer read mX;
     property y: Integer read mY;
@@ -48,44 +55,62 @@ type
     property height: Integer read mHeight;
     property obj: TObject read mObj;
     property tag: Integer read mTag;
-    property grid: TBodyGrid read mGrid;
+    //property grid: TBodyGrid read mGrid;
   end;
 
   PGridCell = ^TGridCell;
   TGridCell = record
-    body: TBodyProxy;
+    {$IFDEF grid_use_buckets}
+    bodies: array [0..GridCellBucketSize-1] of Integer; // -1: end of list
+    {$ELSE}
+    body: Integer;
+    {$ENDIF}
     next: Integer; // in this cell; index in mCells
   end;
 
+  TGridInternalCB = function (grida: Integer): Boolean is nested; // return `true` to stop
+
   TBodyGrid = class(TObject)
   private
     mTileSize: Integer;
+    mMinX, mMinY: Integer; // so grids can start at any origin
     mWidth, mHeight: Integer; // in tiles
     mGrid: array of Integer; // mWidth*mHeight, index in mCells
     mCells: array of TGridCell; // cell pool
     mFreeCell: Integer; // first free cell index or -1
-    mLastQuery: Integer;
+    mLastQuery: DWord;
     mUsedCells: Integer;
+    mProxies: array of TBodyProxyRec;
+    mProxyFree: TBodyProxy; // free
+    mProxyCount: Integer; // currently used
+    mProxyMaxCount: Integer;
 
   private
     function allocCell: Integer;
     procedure freeCell (idx: Integer); // `next` is simply overwritten
 
+    function allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer): TBodyProxy;
+    procedure freeProxy (body: TBodyProxy);
+
     procedure insert (body: TBodyProxy);
     procedure remove (body: TBodyProxy);
 
+    function forGridRect (x, y, w, h: Integer; cb: TGridInternalCB): Boolean;
+
   public
-    constructor Create (aPixWidth, aPixHeight: Integer; aTileSize: Integer=GridDefaultTileSize);
+    constructor Create (aMinPixX, aMinPixY, aPixWidth, aPixHeight: Integer; aTileSize: Integer=GridDefaultTileSize);
     destructor Destroy (); override;
 
     function insertBody (aObj: TObject; ax, ay, aWidth, aHeight: Integer; aTag: Integer=0): TBodyProxy;
+    procedure removeBody (aObj: TBodyProxy); // WARNING! this WILL destroy proxy!
+
     procedure moveBody (body: TBodyProxy; dx, dy: Integer);
     procedure resizeBody (body: TBodyProxy; sx, sy: Integer);
     procedure moveResizeBody (body: TBodyProxy; dx, dy, sx, sy: Integer);
 
-    function forEachInAABB (x, y, w, h: Integer; cb: GridQueryCB): Boolean;
+    function forEachInAABB (x, y, w, h: Integer; cb: TGridQueryCB; tagmask: Integer=-1): Boolean;
 
-    function getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy;
+    //function getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy;
 
     procedure dumpStats ();
   end;
@@ -94,11 +119,11 @@ type
 implementation
 
 uses
-  SysUtils;
+  SysUtils, e_log;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
-constructor TBodyProxy.Create (aGrid: TBodyGrid; aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
+procedure TBodyProxyRec.setup (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
 begin
   mX := aX;
   mY := aY;
@@ -106,17 +131,13 @@ begin
   mHeight := aHeight;
   mQueryMark := 0;
   mObj := aObj;
-  mGrid := aGrid;
   mTag := aTag;
-end;
-
-destructor TBodyProxy.Destroy ();
-begin
+  nextLink := -1;
 end;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
-constructor TBodyGrid.Create (aPixWidth, aPixHeight: Integer; aTileSize: Integer=GridDefaultTileSize);
+constructor TBodyGrid.Create (aMinPixX, aMinPixY, aPixWidth, aPixHeight: Integer; aTileSize: Integer=GridDefaultTileSize);
 var
   idx: Integer;
 begin
@@ -125,34 +146,45 @@ begin
   if aPixWidth < aTileSize then aPixWidth := aTileSize;
   if aPixHeight < aTileSize then aPixHeight := aTileSize;
   mTileSize := aTileSize;
+  mMinX := aMinPixX;
+  mMinY := aMinPixY;
   mWidth := (aPixWidth+aTileSize-1) div aTileSize;
   mHeight := (aPixHeight+aTileSize-1) div aTileSize;
   SetLength(mGrid, mWidth*mHeight);
   SetLength(mCells, mWidth*mHeight);
+  SetLength(mProxies, 8192);
   mFreeCell := 0;
   // init free list
   for idx := 0 to High(mCells) do
   begin
-    mCells[idx].body := nil;
+    {$IFDEF grid_use_buckets}
+    mCells[idx].bodies[0] := -1;
+    {$ELSE}
+    mCells[idx].body := -1;
+    {$ENDIF}
     mCells[idx].next := idx+1;
   end;
   mCells[High(mCells)].next := -1; // last cell
   // init grid
   for idx := 0 to High(mGrid) do mGrid[idx] := -1;
+  // init proxies
+  for idx := 0 to High(mProxies) do mProxies[idx].nextLink := idx+1;
+  mProxies[High(mProxies)].nextLink := -1;
   mLastQuery := 0;
   mUsedCells := 0;
+  mProxyFree := 0;
+  mProxyCount := 0;
+  mProxyMaxCount := 0;
   e_WriteLog(Format('created grid with size: %dx%d (tile size: %d); pix: %dx%d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize]), MSG_NOTIFY);
 end;
 
 
 destructor TBodyGrid.Destroy ();
-var
-  idx: Integer;
 begin
-  // free all owned proxies
-  for idx := 0 to High(mCells) do mCells[idx].body.Free;
   mCells := nil;
   mGrid := nil;
+  mProxies := nil;
+  inherited;
 end;
 
 
@@ -172,7 +204,7 @@ begin
     end;
     if (mcb < cnt) then mcb := cnt;
   end;
-  e_WriteLog(Format('grid size: %dx%d (tile size: %d); pix: %dx%d; used cells: %d; max bodys in cell: %d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize, mUsedCells, mcb]), MSG_NOTIFY);
+  e_WriteLog(Format('grid size: %dx%d (tile size: %d); pix: %dx%d; used cells: %d; max bodies in cell: %d; max proxies allocated: %d; proxies used: %d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize, mUsedCells, mcb, mProxyMaxCount, mProxyCount]), MSG_NOTIFY);
 end;
 
 
@@ -184,10 +216,14 @@ begin
   begin
     // no free cells, want more
     mFreeCell := Length(mCells);
-    SetLength(mCells, mFreeCell+16384); // arbitrary number
+    SetLength(mCells, mFreeCell+32768); // arbitrary number
     for idx := mFreeCell to High(mCells) do
     begin
-      mCells[idx].body := nil;
+      {$IFDEF grid_use_buckets}
+      mCells[idx].bodies[0] := -1;
+      {$ELSE}
+      mCells[idx].body := -1;
+      {$ENDIF}
       mCells[idx].next := idx+1;
     end;
     mCells[High(mCells)].next := -1; // last cell
@@ -204,8 +240,8 @@ procedure TBodyGrid.freeCell (idx: Integer);
 begin
   if (idx >= 0) and (idx < High(mCells)) then
   begin
-    if mCells[idx].body = nil then exit; // the thing that should not be
-    mCells[idx].body := nil;
+    //if mCells[idx].body = -1 then exit; // the thing that should not be
+    //mCells[idx].body := -1;
     mCells[idx].next := mFreeCell;
     mFreeCell := idx;
     Dec(mUsedCells);
@@ -213,114 +249,193 @@ begin
 end;
 
 
-procedure TBodyGrid.insert (body: TBodyProxy);
+function TBodyGrid.allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer): TBodyProxy;
 var
-  dx, dy, gx, gy, cidx: Integer;
+  olen, idx: Integer;
+  px: PBodyProxyRec;
 begin
-  if body = nil then exit;
-  if (body.mWidth < 1) or (body.mHeight < 1) then exit;
-  // out of grid?
-  if (body.mX+body.mWidth <= 0) or (body.mY+body.mHeight <= 0) then exit;
-  if (body.mX >= mWidth*mTileSize) or (body.mY >= mHeight*mTileSize) then exit;
-  //e_WriteLog(Format('grid: inserting body: (%d,%d)-(%dx%d)', [body.mX, body.mY, body.mWidth, body.mHeight]), MSG_NOTIFY);
-  gy := body.mY div mTileSize;
-  dy := 0;
-  while (dy < body.mHeight) do
+  if (mProxyFree = -1) then
   begin
-    if (gy >= 0) and (gy < mHeight) then
+    // no free proxies, resize list
+    olen := Length(mProxies);
+    SetLength(mProxies, olen+8192); // arbitrary number
+    for idx := olen to High(mProxies) do mProxies[idx].nextLink := idx+1;
+    mProxies[High(mProxies)].nextLink := -1;
+    mProxyFree := olen;
+  end;
+  // get one from list
+  result := mProxyFree;
+  px := @mProxies[result];
+  mProxyFree := px.nextLink;
+  px.setup(aX, aY, aWidth, aHeight, aObj, aTag);
+  // add to used list
+  px.nextLink := -1;
+  // statistics
+  Inc(mProxyCount);
+  if (mProxyMaxCount < mProxyCount) then mProxyMaxCount := mProxyCount;
+end;
+
+procedure TBodyGrid.freeProxy (body: TBodyProxy);
+begin
+  if (body < 0) or (body > High(mProxies)) then exit; // just in case
+  if (mProxyCount = 0) then raise Exception.Create('wutafuuuuu in grid (no allocated proxies, what i should free now?)');
+  // add to free list
+  mProxies[body].mObj := nil;
+  mProxies[body].nextLink := mProxyFree;
+  mProxyFree := body;
+  Dec(mProxyCount);
+end;
+
+
+function TBodyGrid.forGridRect (x, y, w, h: Integer; cb: TGridInternalCB): Boolean;
+var
+  gx, gy: Integer;
+begin
+  result := false;
+  if (w < 1) or (h < 1) or not assigned(cb) then exit;
+  // fix coords
+  Dec(x, mMinX);
+  Dec(y, mMinY);
+  // go on
+  if (x+w <= 0) or (y+h <= 0) then exit;
+  if (x >= mWidth*mTileSize) or (y >= mHeight*mTileSize) then exit;
+  for gy := y div mTileSize to (y+h-1) div mTileSize do
+  begin
+    if (gy < 0) then continue;
+    if (gy >= mHeight) then break;
+    for gx := x div mTileSize to (x+w-1) div mTileSize do
     begin
-      dx := 0;
-      gx := body.mX div mTileSize;
-      while (dx < body.mWidth) do
+      if (gx < 0) then continue;
+      if (gx >= mWidth) then break;
+      if (cb(gy*mWidth+gx)) then begin result := true; exit; end;
+    end;
+  end;
+end;
+
+
+procedure TBodyGrid.insert (body: TBodyProxy);
+
+  function inserter (grida: Integer): Boolean;
+  var
+    cidx: Integer;
+    pc: PInteger;
+    {$IFDEF grid_use_buckets}
+    pi: PGridCell;
+    f: Integer;
+    {$ENDIF}
+  begin
+    result := false; // never stop
+    // add body to the given grid cell
+    pc := @mGrid[grida];
+    {$IFDEF grid_use_buckets}
+    if (pc^ <> -1) then
+    begin
+      pi := @mCells[pc^];
+      f := 0;
+      for f := 0 to High(TGridCell.bodies) do
       begin
-        if (gx >= 0) and (gx < mWidth) then
+        if (pi.bodies[f] = -1) then
         begin
-          //e_WriteLog(Format('  00: allocating cell for grid coords (%d,%d), body coords:(%d,%d)', [gx, gy, dx, dy]), MSG_NOTIFY);
-          cidx := allocCell();
-          //e_WriteLog(Format('  01: allocated cell for grid coords (%d,%d), body coords:(%d,%d): #%d', [gx, gy, dx, dy, cidx]), MSG_NOTIFY);
-          mCells[cidx].body := body;
-          mCells[cidx].next := mGrid[gy*mWidth+gx];
-          mGrid[gy*mWidth+gx] := cidx;
-          //e_WriteLog(Format('  02: put cell for grid coords (%d,%d), body coords:(%d,%d): #%d', [gx, gy, dx, dy, cidx]), MSG_NOTIFY);
+          // can add here
+          pi.bodies[f] := body;
+          if (f+1 < Length(TGridCell.bodies)) then pi.bodies[f+1] := -1;
+          exit;
         end;
-        Inc(dx, mTileSize);
-        Inc(gx);
       end;
     end;
-    Inc(dy, mTileSize);
-    Inc(gy);
+    // either no room, or no cell at all
+    cidx := allocCell();
+    mCells[cidx].bodies[0] := body;
+    mCells[cidx].bodies[1] := -1;
+    mCells[cidx].next := pc^;
+    pc^ := cidx;
+    {$ELSE}
+    cidx := allocCell();
+    //e_WriteLog(Format('  01: allocated cell for grid coords (%d,%d), body coords:(%d,%d): #%d', [gx, gy, dx, dy, cidx]), MSG_NOTIFY);
+    mCells[cidx].body := body;
+    mCells[cidx].next := pc^;
+    pc^ := cidx;
+    {$ENDIF}
   end;
+
+var
+  px: PBodyProxyRec;
+begin
+  if (body < 0) or (body > High(mProxies)) then exit; // just in case
+  px := @mProxies[body];
+  forGridRect(px.mX, px.mY, px.mWidth, px.mHeight, inserter);
 end;
 
 
 // absolutely not tested
 procedure TBodyGrid.remove (body: TBodyProxy);
-var
-  dx, dy, gx, gy, idx, pidx, tmp: Integer;
-begin
-  if body = nil then exit;
-  if (body.mWidth < 1) or (body.mHeight < 1) then exit;
-  // out of grid?
-  if (body.mX+body.mWidth <= 0) or (body.mY+body.mHeight <= 0) then exit;
-  if (body.mX >= mWidth*mTileSize) or (body.mY >= mHeight*mTileSize) then exit;
-  gy := body.mY div mTileSize;
-  dy := 0;
-  pidx := -1;
-  while (dy < body.mHeight) do
+
+(*
+  function remover (grida: Integer): Boolean;
+  var
+    pidx, idx, tmp: Integer;
   begin
-    if (gy >= 0) and (gy < mHeight) then
+    result := false; // never stop
+    // find and remove cell
+    pidx := -1;
+    idx := mGrid[grida];
+    while idx >= 0 do
     begin
-      dx := 0;
-      gx := body.mX div mTileSize;
-      while (dx < body.mWidth) do
+      tmp := mCells[idx].next;
+      if (mCells[idx].body = body) then
       begin
-        if (gx >= 0) and (gx < mWidth) then
-        begin
-          // find and remove cell
-          pidx := -1;
-          idx := mGrid[gy*mWidth+gx];
-          while idx >= 0 do
-          begin
-            tmp := mCells[idx].next;
-            if mCells[idx].body = body then
-            begin
-              if pidx = -1 then mGrid[gy*mWidth+gx] := tmp else mCells[pidx].next := tmp;
-              freeCell(idx);
-            end
-            else
-            begin
-              pidx := idx;
-            end;
-            idx := tmp;
-          end;
-        end;
-        Inc(dx, mTileSize);
-        Inc(gx);
+        if (pidx = -1) then mGrid[grida] := tmp else mCells[pidx].next := tmp;
+        freeCell(idx);
+        break; // assume that we cannot have one object added to bucket twice
+      end
+      else
+      begin
+        pidx := idx;
       end;
+      idx := tmp;
     end;
-    Inc(dy, mTileSize);
-    Inc(gy);
   end;
+
+var
+  px: PBodyProxyRec;
+*)
+begin
+(*
+  if (body < 0) or (body > High(mProxies)) then exit; // just in case
+  px := @mProxies[body];
+  forGridRect(px.mX, px.mY, px.mWidth, px.mHeight, remover);
+*)
+  raise Exception.Create('TBodyGrid.remove: not yet, sorry');
 end;
 
 
 function TBodyGrid.insertBody (aObj: TObject; aX, aY, aWidth, aHeight: Integer; aTag: Integer=0): TBodyProxy;
 begin
-  result := nil;
-  if aObj = nil then exit;
-  result := TBodyProxy.Create(self, aX, aY, aWidth, aHeight, aObj, aTag);
+  result := allocProxy(aX, aY, aWidth, aHeight, aObj, aTag);
   insert(result);
 end;
 
 
+procedure TBodyGrid.removeBody (aObj: TBodyProxy);
+begin
+  if (aObj < 0) or (aObj > High(mProxies)) then exit; // just in case
+  removeBody(aObj);
+  freeProxy(aObj);
+end;
+
+
 procedure TBodyGrid.moveResizeBody (body: TBodyProxy; dx, dy, sx, sy: Integer);
+var
+  px: PBodyProxyRec;
 begin
-  if (body = nil) or ((dx = 0) and (dy = 0) and (sx = 0) and (sy = 0)) then exit;
+  if (body < 0) or (body > High(mProxies)) then exit; // just in case
+  if ((dx = 0) and (dy = 0) and (sx = 0) and (sy = 0)) then exit;
   remove(body);
-  Inc(body.mX, dx);
-  Inc(body.mY, dy);
-  Inc(body.mWidth, sx);
-  Inc(body.mHeight, sy);
+  px := @mProxies[body];
+  Inc(px.mX, dx);
+  Inc(px.mY, dy);
+  Inc(px.mWidth, sx);
+  Inc(px.mHeight, sy);
   insert(body);
 end;
 
@@ -335,65 +450,100 @@ begin
 end;
 
 
-function TBodyGrid.forEachInAABB (x, y, w, h: Integer; cb: GridQueryCB): Boolean;
+function TBodyGrid.forEachInAABB (x, y, w, h: Integer; cb: TGridQueryCB; tagmask: Integer=-1): Boolean;
+  function iterator (grida: Integer): Boolean;
+  var
+    idx: Integer;
+    px: PBodyProxyRec;
+    {$IFDEF grid_use_buckets}
+    pi: PGridCell;
+    f: Integer;
+    {$ENDIF}
+  begin
+    result := false;
+    idx := mGrid[grida];
+    while (idx >= 0) do
+    begin
+      {$IFDEF grid_use_buckets}
+      pi := @mCells[idx];
+      for f := 0 to High(TGridCell.bodies) do
+      begin
+        if (pi.bodies[f] = -1) then break;
+        px := @mProxies[pi.bodies[f]];
+        if (px.mQueryMark <> mLastQuery) and ((px.mTag and tagmask) <> 0) then
+        begin
+          //e_WriteLog(Format('  query #%d body hit: (%d,%d)-(%dx%d) tag:%d', [mLastQuery, mCells[idx].body.mX, mCells[idx].body.mY, mCells[idx].body.mWidth, mCells[idx].body.mHeight, mCells[idx].body.mTag]), MSG_NOTIFY);
+          px.mQueryMark := mLastQuery;
+          if (cb(px.mObj, px.mTag)) then begin result := true; exit; end;
+        end;
+      end;
+      idx := pi.next;
+      {$ELSE}
+      if (mCells[idx].body <> -1) then
+      begin
+        px := @mProxies[mCells[idx].body];
+        if (px.mQueryMark <> mLastQuery) and ((px.mTag and tagmask) <> 0) then
+        begin
+          //e_WriteLog(Format('  query #%d body hit: (%d,%d)-(%dx%d) tag:%d', [mLastQuery, mCells[idx].body.mX, mCells[idx].body.mY, mCells[idx].body.mWidth, mCells[idx].body.mHeight, mCells[idx].body.mTag]), MSG_NOTIFY);
+          px.mQueryMark := mLastQuery;
+          if (cb(px.mObj, px.mTag)) then begin result := true; exit; end;
+        end;
+      end;
+      idx := mCells[idx].next;
+      {$ENDIF}
+    end;
+  end;
+
 var
-  gx, gy, idx: Integer;
-  minx, miny, maxx, maxy: Integer;
+  idx: Integer;
 begin
   result := false;
   if not assigned(cb) then exit;
-  if (w < 1) or (h < 1) then exit;
-  minx := x;
-  miny := y;
-  maxx := x+w-1;
-  maxy := y+h-1;
-  if (minx > maxx) or (miny > maxy) then exit;
-  if (maxx < 0) or (maxy < 0) then exit;
-  if (minx >= mWidth*mTileSize) or (miny >= mHeight*mTileSize) then exit;
+
   // increase query counter
   Inc(mLastQuery);
   if (mLastQuery = 0) then
   begin
     // just in case of overflow
     mLastQuery := 1;
-    for idx := 0 to High(mCells) do if (mCells[idx].body <> nil) then mCells[idx].body.mQueryMark := 0;
+    for idx := 0 to High(mProxies) do mProxies[idx].mQueryMark := 0;
   end;
   //e_WriteLog(Format('grid: query #%d: (%d,%d)-(%dx%d)', [mLastQuery, minx, miny, maxx, maxy]), MSG_NOTIFY);
-  // process grid
-  for gy := miny div mTileSize to maxy div mTileSize do
-  begin
-    if (gy < 0) then continue;
-    if (gy >= mHeight) then break;
-    for gx := minx div mTileSize to maxx div mTileSize do
-    begin
-      if (gx < 0) then continue;
-      if (gx >= mWidth) then break;
-      idx := mGrid[gy*mWidth+gx];
-      while idx >= 0 do
-      begin
-        if (mCells[idx].body <> nil) and (mCells[idx].body.mQueryMark <> mLastQuery) then
-        begin
-          //e_WriteLog(Format('  query #%d body hit: (%d,%d)-(%dx%d) tag:%d', [mLastQuery, mCells[idx].body.mX, mCells[idx].body.mY, mCells[idx].body.mWidth, mCells[idx].body.mHeight, mCells[idx].body.mTag]), MSG_NOTIFY);
-          mCells[idx].body.mQueryMark := mLastQuery;
-          if (cb(mCells[idx].body.mObj, mCells[idx].body.mTag)) then begin result := true; exit; end;
-        end;
-        idx := mCells[idx].next;
-      end;
-    end;
-  end;
+
+  result := forGridRect(x, y, w, h, iterator);
 end;
 
 
+(*
 function TBodyGrid.getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy;
+var
+  res: TBodyProxy = -1;
 
-  function qq (obj: TObject; tag: Integer): Boolean;
+  function iterator (grida: Integer): Boolean;
+  var
+    idx: Integer;
   begin
-    result := (obj = aObj);
+    result := false;
+    idx := mGrid[grida];
+    while idx >= 0 do
+    begin
+      if (mCells[idx].body <> -1) and (mProxies[mCells[idx].body].mObj = aObj) then
+      begin
+        result := true;
+        res := mCells[idx].body;
+        exit;
+      end;
+      idx := mCells[idx].next;
+    end;
   end;
 
 begin
-  result := nil;
-  forEachInAABB(x, y, w, h, qq);
+  result := -1;
+  if (aObj = nil) then exit;
+  forGridRect(x, y, w, h, iterator);
+  result := res;
 end;
+*)
+
 
 end.