X-Git-Url: http://deadsoftware.ru/gitweb?a=blobdiff_plain;f=src%2Fgame%2Fg_grid.pas;h=a56c670270a42aeb38439164b4c3a1160b1cee43;hb=7292fe409145dfcbb2776e34bb64d56e32985b9d;hp=9f14d3d5f69481dc9f6a6763cbb356c9e3b2f4f9;hpb=984a31dcc2636073083a3a3cf8d4d409019d211a;p=d2df-sdl.git

diff --git a/src/game/g_grid.pas b/src/game/g_grid.pas
index 9f14d3d..a56c670 100644
--- a/src/game/g_grid.pas
+++ b/src/game/g_grid.pas
@@ -13,8 +13,7 @@
  * 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}
+{$INCLUDE g_amodes.inc}
 unit g_grid;
 
 interface
@@ -37,6 +36,11 @@ type
     mObj: TObject;
     mGrid: TBodyGrid;
     mTag: Integer;
+    prevLink: TBodyProxy; // only for used
+    nextLink: TBodyProxy; // either used or free
+
+  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);
@@ -57,28 +61,41 @@ type
     next: Integer; // in this cell; index in mCells
   end;
 
+  GridInternalCB = 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;
     mUsedCells: Integer;
+    mProxyFree: TBodyProxy; // free
+    mProxyList: TBodyProxy; // used
+    mProxyCount: Integer; // total allocated
 
   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: GridInternalCB): 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 NOT 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);
@@ -91,6 +108,33 @@ type
   end;
 
 
+type
+  TBinaryHeapLessFn = function (a, b: TObject): Boolean;
+
+  TBinaryHeapObj = class(TObject)
+  private
+    elem: array of TObject;
+    elemUsed: Integer;
+    lessfn: TBinaryHeapLessFn;
+
+  private
+    procedure heapify (root: Integer);
+
+  public
+    constructor Create (alessfn: TBinaryHeapLessFn);
+    destructor Destroy (); override;
+
+    procedure clear ();
+
+    procedure insert (val: TObject);
+
+    function front (): TObject;
+    procedure popFront ();
+
+    property count: Integer read elemUsed;
+  end;
+
+
 implementation
 
 uses
@@ -99,6 +143,19 @@ uses
 
 // ////////////////////////////////////////////////////////////////////////// //
 constructor TBodyProxy.Create (aGrid: TBodyGrid; aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
+begin
+  mGrid := aGrid;
+  setup(aX, aY, aWidth, aHeight, aObj, aTag);
+end;
+
+
+destructor TBodyProxy.Destroy ();
+begin
+  inherited;
+end;
+
+
+procedure TBodyProxy.setup (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer);
 begin
   mX := aX;
   mY := aY;
@@ -106,17 +163,14 @@ begin
   mHeight := aHeight;
   mQueryMark := 0;
   mObj := aObj;
-  mGrid := aGrid;
   mTag := aTag;
-end;
-
-destructor TBodyProxy.Destroy ();
-begin
+  prevLink := nil;
+  nextLink := nil;
 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,6 +179,8 @@ 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);
@@ -141,18 +197,35 @@ begin
   for idx := 0 to High(mGrid) do mGrid[idx] := -1;
   mLastQuery := 0;
   mUsedCells := 0;
+  mProxyFree := nil;
+  mProxyList := nil;
+  mProxyCount := 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;
+  px: TBodyProxy;
 begin
   // free all owned proxies
-  for idx := 0 to High(mCells) do mCells[idx].body.Free;
+  while mProxyFree <> nil do
+  begin
+    px := mProxyFree;
+    mProxyFree := px.nextLink;
+    px.Free();
+  end;
+
+  while mProxyList <> nil do
+  begin
+    px := mProxyList;
+    mProxyList := px.nextLink;
+    px.Free();
+  end;
+
   mCells := nil;
   mGrid := nil;
+  inherited;
 end;
 
 
@@ -172,7 +245,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; proxies allocated: %d', [mWidth, mHeight, mTileSize, mWidth*mTileSize, mHeight*mTileSize, mUsedCells, mcb, mProxyCount]), MSG_NOTIFY);
 end;
 
 
@@ -184,7 +257,7 @@ 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;
@@ -213,106 +286,152 @@ begin
 end;
 
 
-procedure TBodyGrid.insert (body: TBodyProxy);
+function TBodyGrid.allocProxy (aX, aY, aWidth, aHeight: Integer; aObj: TObject; aTag: Integer): TBodyProxy;
+begin
+  if (mProxyFree = nil) then
+  begin
+    // no free proxies, create new
+    result := TBodyProxy.Create(self, aX, aY, aWidth, aHeight, aObj, aTag);
+    Inc(mProxyCount);
+  end
+  else
+  begin
+    // get one from list
+    result := mProxyFree;
+    mProxyFree := result.nextLink;
+    result.setup(aX, aY, aWidth, aHeight, aObj, aTag);
+  end;
+  // add to used list
+  result.nextLink := mProxyList;
+  if (mProxyList <> nil) then mProxyList.prevLink := result;
+  mProxyList := result;
+end;
+
+procedure TBodyGrid.freeProxy (body: TBodyProxy);
+begin
+  if body = nil then exit; // just in case
+  // remove from used list
+  if (body.prevLink = nil) then
+  begin
+    // this must be head
+    if (body <> mProxyList) then raise Exception.Create('wutafuuuuu in grid?');
+    mProxyList := body.nextLink;
+  end
+  else
+  begin
+    body.prevLink.nextLink := body.nextLink;
+  end;
+  if (body.nextLink <> nil) then body.nextLink.prevLink := body.prevLink;
+  // add to free list
+  //body.mObj := nil; //WARNING! DON'T DO THIS! `removeBody()` depends on valid mObj
+  body.prevLink := nil;
+  body.nextLink := mProxyFree;
+  mProxyFree := body;
+end;
+
+
+function TBodyGrid.forGridRect (x, y, w, h: Integer; cb: GridInternalCB): Boolean;
 var
-  dx, dy, gx, gy, cidx: Integer;
+  gx, gy: 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;
-  //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
+  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) and (gy < mHeight) then
+    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
-      begin
-        if (gx >= 0) and (gx < mWidth) 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);
-        end;
-        Inc(dx, mTileSize);
-        Inc(gx);
-      end;
+      if (gx < 0) then continue;
+      if (gx >= mWidth) then break;
+      if (cb(gy*mWidth+gx)) then begin result := true; exit; end;
     end;
-    Inc(dy, mTileSize);
-    Inc(gy);
   end;
 end;
 
 
-// absolutely not tested
-procedure TBodyGrid.remove (body: TBodyProxy);
-var
-  dx, dy, gx, gy, idx, pidx, tmp: Integer;
+procedure TBodyGrid.insert (body: TBodyProxy);
+
+  function inserter (grida: Integer): Boolean;
+  var
+    cidx: Integer;
+  begin
+    result := false; // never stop
+    // add body to the given grid cell
+    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[grida];
+    mGrid[grida] := cidx;
+  end;
+
 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
+  forGridRect(body.mX, body.mY, body.mWidth, body.mHeight, inserter);
+end;
+
+
+// absolutely not tested
+procedure TBodyGrid.remove (body: TBodyProxy);
+
+  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;
+
+begin
+  if body = nil then exit;
+  forGridRect(body.mX, body.mY, body.mWidth, body.mHeight, remover);
 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;
 
 
+// WARNING! this will NOT destroy proxy!
+procedure TBodyGrid.removeBody (aObj: TBodyProxy);
+begin
+  if aObj = nil then exit;
+  if (aObj.mGrid <> self) then raise Exception.Create('trying to remove alien proxy from grid');
+  removeBody(aObj);
+  //HACK!
+  freeProxy(aObj);
+  if (mProxyFree <> aObj) then raise Exception.Create('grid deletion invariant fucked');
+  mProxyFree := aObj.nextLink;
+  aObj.nextLink := nil;
+end;
+
+
 procedure TBodyGrid.moveResizeBody (body: TBodyProxy; dx, dy, sx, sy: Integer);
 begin
   if (body = nil) or ((dx = 0) and (dy = 0) and (sx = 0) and (sy = 0)) then exit;
@@ -336,20 +455,30 @@ end;
 
 
 function TBodyGrid.forEachInAABB (x, y, w, h: Integer; cb: GridQueryCB): Boolean;
+  function iterator (grida: Integer): Boolean;
+  var
+    idx: Integer;
+  begin
+    result := false;
+    idx := mGrid[grida];
+    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;
+
 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
@@ -359,41 +488,118 @@ begin
     for idx := 0 to High(mCells) do if (mCells[idx].body <> nil) then mCells[idx].body.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
+
+  result := forGridRect(x, y, w, h, iterator);
+end;
+
+
+function TBodyGrid.getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy;
+var
+  res: TBodyProxy = nil;
+
+  function iterator (grida: Integer): Boolean;
+  var
+    idx: Integer;
   begin
-    if (gy < 0) then continue;
-    if (gy >= mHeight) then break;
-    for gx := minx div mTileSize to maxx div mTileSize do
+    result := false;
+    idx := mGrid[grida];
+    while idx >= 0 do
     begin
-      if (gx < 0) then continue;
-      if (gx >= mWidth) then break;
-      idx := mGrid[gy*mWidth+gx];
-      while idx >= 0 do
+      if (mCells[idx].body <> nil) and (mCells[idx].body = aObj) then
       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;
+        result := true;
+        res := mCells[idx].body;
+        exit;
       end;
+      idx := mCells[idx].next;
     end;
   end;
+
+begin
+  result := nil;
+  if (aObj = nil) then exit;
+  forGridRect(x, y, w, h, iterator);
+  result := res;
 end;
 
 
-function TBodyGrid.getProxyForBody (aObj: TObject; x, y, w, h: Integer): TBodyProxy;
+// ////////////////////////////////////////////////////////////////////////// //
+constructor TBinaryHeapObj.Create (alessfn: TBinaryHeapLessFn);
+begin
+  if not assigned(alessfn) then raise Exception.Create('wutafuck?!');
+  lessfn := alessfn;
+  SetLength(elem, 8192); // 'cause why not?
+  elemUsed := 0;
+end;
+
+
+destructor TBinaryHeapObj.Destroy ();
+begin
+  inherited;
+end;
+
+
+procedure TBinaryHeapObj.clear ();
+begin
+  elemUsed := 0;
+end;
+
 
-  function qq (obj: TObject; tag: Integer): Boolean;
+procedure TBinaryHeapObj.heapify (root: Integer);
+var
+  smallest, right: Integer;
+  tmp: TObject;
+begin
+  while true do
   begin
-    result := (obj = aObj);
+    smallest := 2*root+1; // left child
+    if (smallest >= elemUsed) then break; // anyway
+    right := smallest+1; // right child
+    if not lessfn(elem[smallest], elem[root]) then smallest := root;
+    if (right < elemUsed) and (lessfn(elem[right], elem[smallest])) then smallest := right;
+    if (smallest = root) then break;
+    // swap
+    tmp := elem[root];
+    elem[root] := elem[smallest];
+    elem[smallest] := tmp;
+    root := smallest;
   end;
+end;
 
+
+procedure TBinaryHeapObj.insert (val: TObject);
+var
+  i, par: Integer;
 begin
-  result := nil;
-  forEachInAABB(x, y, w, h, qq);
+  if (val = nil) then exit;
+  i := elemUsed;
+  if (i = Length(elem)) then SetLength(elem, Length(elem)+16384); // arbitrary number
+  Inc(elemUsed);
+  while (i <> 0) do
+  begin
+    par := (i-1) div 2; // parent
+    if not lessfn(val, elem[par]) then break;
+    elem[i] := elem[par];
+    i := par;
+  end;
+  elem[i] := val;
+end;
+
+function TBinaryHeapObj.front (): TObject;
+begin
+  if elemUsed > 0 then result := elem[0] else result := nil;
 end;
 
+
+procedure TBinaryHeapObj.popFront ();
+begin
+  if (elemUsed > 0) then
+  begin
+    Dec(elemUsed);
+    elem[0] := elem[elemUsed];
+    heapify(0);
+  end;
+end;
+
+
 end.