X-Git-Url: https://deadsoftware.ru/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fgame%2Fg_gfx.pas;h=6a994723c44807e0f329321e8c95daf5c820e8a8;hb=d25ad51560a2159ff524fa9ef4ca37a81dcb528f;hp=e74ddcc9068093eaf900b17ff7fed59c53d083d8;hpb=a892de2ecf5c04acbb4c5356f29cacbd07d11c3e;p=d2df-sdl.git

diff --git a/src/game/g_gfx.pas b/src/game/g_gfx.pas
index e74ddcc..6a99472 100644
--- a/src/game/g_gfx.pas
+++ b/src/game/g_gfx.pas
@@ -25,8 +25,10 @@ uses
 const
   BLOOD_NORMAL = 0;
   BLOOD_SPARKS = 1;
+
   ONCEANIM_NONE  = 0;
   ONCEANIM_SMOKE = 1;
+
   MARK_FREE     = 0;
   MARK_WALL     = 1;
   MARK_WATER    = 2;
@@ -36,28 +38,30 @@ const
   MARK_DOOR     = 32;
   MARK_LIFTLEFT  = 64;
   MARK_LIFTRIGHT = 128;
-  MARK_BLOCKED  = MARK_WALL + MARK_DOOR;
-  MARK_LIQUID   = MARK_WATER + MARK_ACID;
-  MARK_LIFT     = MARK_LIFTDOWN + MARK_LIFTUP + MARK_LIFTLEFT + MARK_LIFTRIGHT;
+  MARK_BLOCKED  = MARK_WALL or MARK_DOOR;
+  MARK_LIQUID   = MARK_WATER or MARK_ACID;
+  MARK_LIFT     = MARK_LIFTDOWN or MARK_LIFTUP or MARK_LIFTLEFT or MARK_LIFTRIGHT;
 
-procedure g_GFX_Init();
-procedure g_GFX_Free();
 
-procedure g_GFX_Blood(fX, fY: Integer; Count: Word; vx, vy: Integer;
+procedure g_GFX_Init ();
+procedure g_GFX_Free ();
+
+procedure g_GFX_Blood (fX, fY: Integer; Count: Word; vx, vy: Integer;
                       DevX, DevY: Word; CR, CG, CB: Byte; Kind: Byte = BLOOD_NORMAL);
-procedure g_GFX_Spark(fX, fY: Integer; Count: Word; Angle: SmallInt; DevX, DevY: Byte);
-procedure g_GFX_Water(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DevX, DevY, Color: Byte);
-procedure g_GFX_SimpleWater(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DefColor, CR, CG, CB: Byte);
-procedure g_GFX_Bubbles(fX, fY: Integer; Count: Word; DevX, DevY: Byte);
-procedure g_GFX_SetMax(Count: Integer);
-function  g_GFX_GetMax(): Integer;
+procedure g_GFX_Spark (fX, fY: Integer; Count: Word; Angle: SmallInt; DevX, DevY: Byte);
+procedure g_GFX_Water (fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DevX, DevY, Color: Byte);
+procedure g_GFX_SimpleWater (fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DefColor, CR, CG, CB: Byte);
+procedure g_GFX_Bubbles (fX, fY: Integer; Count: Word; DevX, DevY: Byte);
 
-procedure g_GFX_OnceAnim(X, Y: Integer; Anim: TAnimation; AnimType: Byte = 0);
+procedure g_GFX_SetMax (Count: Integer);
+function  g_GFX_GetMax (): Integer;
 
-procedure g_Mark(x, y, Width, Height: Integer; t: Byte; st: Boolean);
+procedure g_GFX_OnceAnim (X, Y: Integer; Anim: TAnimation; AnimType: Byte = 0);
 
-procedure g_GFX_Update();
-procedure g_GFX_Draw();
+procedure g_Mark (x, y, Width, Height: Integer; t: Byte; st: Boolean=true);
+
+procedure g_GFX_Update ();
+procedure g_GFX_Draw ();
 
 
 var
@@ -70,33 +74,58 @@ implementation
 uses
   g_map, g_panel, g_basic, Math, e_graphics, GL, GLExt,
   g_options, g_console, SysUtils, g_triggers, MAPDEF,
-  g_game, g_language, g_net;
+  g_game, g_language, g_net, xprofiler;
+
+
+const
+  Unknown = Integer($7fffffff);
+
 
 type
-  PParticle = ^TParticle;
+  TPartType = (Blood, Spark, Bubbles, Water);
+  TPartState = (Free, Normal, Stuck, Sleeping);
+  TFloorType = (Wall, LiquidIn, LiquidOut);
+    // Wall: floorY is just before floor
+    // LiquidIn: floorY is liquid *start* (i.e. just in a liquid)
+    // LiquidOut: floorY is liquid *end* (i.e. just out of a liquid)
 
+  PParticle = ^TParticle;
   TParticle = record
-    X, Y:               Integer;
-    VelX, VelY:         Single;
-    AccelX, AccelY:     Single;
-    Red, Green, Blue:   Byte;
-    Alpha:              Byte;
-    Time, LiveTime:     Word;
-    State:              Byte;
-    ParticleType:       Byte;
-    offsetX, offsetY:   ShortInt;
+    x, y: Integer;
+    velX, velY: Single;
+    accelX, accelY: Single;
+    red, green, blue: Byte;
+    alpha: Byte;
+    time, liveTime: Word;
+    state: TPartState;
+    particleType: TPartType;
+    offsetX, offsetY: ShortInt;
     // for bubbles
     liquidTopY: Integer; // don't float higher than this
     // for water
-    stickDX: Integer;
+    stickDX: Integer; // STATE_STICK: -1,1: stuck to a wall; 0: stuck to ceiling
+    justSticked: Boolean; // not used
+    floorY: Integer; // actually, floor-1; `Unknown`: unknown
+    floorType: TFloorType;
+    ceilingY: Integer; // actually, ceiling+1; `Unknown`: unknown
+    wallEndY: Integer; // if we stuck to a wall, this is where wall ends; will never be > floorY
+    // for all
+    onGround: Boolean;
+    awaken: Boolean;
+    stickEY: Integer;
 
     //k8: sorry, i have to emulate virtual methods this way, 'cause i haet `Object`
-
     procedure thinkerBlood ();
     procedure thinkerSpark ();
     procedure thinkerBubble ();
     procedure thinkerWater ();
 
+    procedure findFloor (force: Boolean=false); // this updates `floorY` if forced or Unknown
+    procedure findCeiling (force: Boolean=false); // this updates `ceilingY` if forced or Unknown
+
+    function isSleeping (): Boolean; inline;
+    procedure awake (); inline;
+
     function alive (): Boolean; inline;
     procedure die (); inline;
     procedure think (); inline;
@@ -104,37 +133,192 @@ type
 
   TOnceAnim = record
     AnimType:   Byte;
-    X, Y:       Integer;
+    x, y:       Integer;
     Animation:  TAnimation;
   end;
 
-const
-  PARTICLE_BLOOD   = 0;
-  PARTICLE_SPARK   = 1;
-  PARTICLE_BUBBLES = 2;
-  PARTICLE_WATER   = 3;
-  STATE_FREE   = 0;
-  STATE_NORMAL = 1;
-  STATE_STICK  = 2;
 
 var
-  Particles: array of TParticle;
-  OnceAnims: array of TOnceAnim;
-  MaxParticles: Integer;
-  CurrentParticle: Integer;
+  Particles: array of TParticle = nil;
+  OnceAnims: array of TOnceAnim = nil;
+  MaxParticles: Integer = 0;
+  CurrentParticle: Integer = 0;
+  // awakeMap has one bit for each map grid cell; on g_Mark,
+  // corresponding bits will be set, and in `think()` all particles
+  // in marked cells will be awaken
+  awakeMap: packed array of LongWord = nil;
+  awakeMapH: Integer = -1;
+  awakeMapW: Integer = -1;
+  awakeMinX, awakeMinY: Integer;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+// HACK! using mapgrid
+procedure awmClear (); inline;
+begin
+  if (awakeMapW > 0) then FillDWord(awakeMap[0], Length(awakeMap), 0);
+end;
+
+
+procedure awmSetup ();
+begin
+  assert(mapGrid <> nil);
+  awakeMapW := (mapGrid.gridWidth+mapGrid.tileSize-1) div mapGrid.tileSize;
+  awakeMapW := (awakeMapW+31) div 32; // LongWord has 32 bits ;-)
+  awakeMapH := (mapGrid.gridHeight+mapGrid.tileSize-1) div mapGrid.tileSize;
+  awakeMinX := mapGrid.gridX0;
+  awakeMinY := mapGrid.gridY0;
+  SetLength(awakeMap, awakeMapW*awakeMapH);
+  {$IF DEFINED(D2F_DEBUG)}
+  e_LogWritefln('particle awake map: %sx%s (for grid of size %sx%s)', [awakeMapW, awakeMapH, mapGrid.gridWidth, mapGrid.gridHeight]);
+  {$ENDIF}
+  awmClear();
+end;
+
+
+function awmIsSet (x, y: Integer): Boolean; inline;
+begin
+  x := (x-awakeMinX) div mapGrid.tileSize;
+  y := (y-awakeMinY) div mapGrid.tileSize;
+  if (x >= 0) and (y >= 0) and (x div 32 < awakeMapW) and (y < awakeMapH) then
+  begin
+    {$IF DEFINED(D2F_DEBUG)}
+    assert(y*awakeMapW+x div 32 < Length(awakeMap));
+    {$ENDIF}
+    result := ((awakeMap[y*awakeMapW+x div 32] and (LongWord(1) shl (x mod 32))) <> 0);
+  end
+  else
+  begin
+    result := false;
+  end;
+end;
+
+
+procedure awmSet (x, y: Integer); inline;
+var
+  v: PLongWord;
+begin
+  x := (x-awakeMinX) div mapGrid.tileSize;
+  y := (y-awakeMinY) div mapGrid.tileSize;
+  if (x >= 0) and (y >= 0) and (x div 32 < awakeMapW) and (y < awakeMapH) then
+  begin
+    {$IF DEFINED(D2F_DEBUG)}
+    assert(y*awakeMapW+x div 32 < Length(awakeMap));
+    {$ENDIF}
+    v := @awakeMap[y*awakeMapW+x div 32];
+    v^ := v^ or (LongWord(1) shl (x mod 32));
+  end;
+end;
 
 
 // ////////////////////////////////////////////////////////////////////////// //
-function TParticle.alive (): Boolean; inline; begin result := (State <> STATE_FREE); end;
-procedure TParticle.die (); inline; begin State := STATE_FREE; end;
+function TParticle.alive (): Boolean; inline; begin result := (state <> TPartState.Free); end;
+procedure TParticle.die (); inline; begin state := TPartState.Free; end;
+
+function TParticle.isSleeping (): Boolean; inline;
+begin
+  result := alive and (onGround or (not justSticked and (state = TPartState.Stuck)));
+end;
+
+procedure TParticle.awake (); inline;
+begin
+  if {alive and} (onGround or (not justSticked and (state = TPartState.Stuck))) then
+  begin
+    // wakeup this particle
+    {
+    if (part.ParticleType = PARTICLE_SPARK) then
+    begin
+      e_LogWritefln('waking up particle of type %s; justSticked=%s; onGround=%s; VelY=%s; AccelY=%s', [part.ParticleType, part.justSticked, part.onGround, part.VelY, part.AccelY]);
+    end;
+    }
+    justSticked := true; // so sticked state will be re-evaluated
+    if onGround then
+    begin
+      if (velY = 0) then velY := 0.1;
+      if (accelY = 0) then accelY := 0.5;
+    end;
+    onGround := false; // so onground state will be re-evaluated
+    awaken := true;
+  end;
+end;
+
+
+procedure TParticle.findFloor (force: Boolean=false);
+var
+  ex: Integer;
+  pan: TPanel;
+begin
+  if (not force) and (floorY <> Unknown) then exit;
+  // are we in a liquid?
+  pan := g_Map_PanelAtPoint(x, y, (GridTagObstacle or GridTagLiquid));
+  if (pan <> nil) then
+  begin
+    // either in a wall, or in a liquid
+    if ((pan.tag and GridTagObstacle) <> 0) then
+    begin
+      // we are in the wall, wtf?!
+      floorY := y;
+      floorType := TFloorType.Wall;
+      state := TPartState.Sleeping; // anyway
+      exit;
+    end;
+    // we are in liquid, trace to liquid end
+    floorType := TFloorType.LiquidOut; // exiting liquid
+    //e_LogWritefln('tracing out of a liquid; floorY=%s; y=%s', [floorY, y]);
+    mapGrid.traceOrthoRayWhileIn(ex, floorY, x, y, x, g_Map_MaxY, GridTagLiquid);
+    floorY += 1; // so `floorY` is just out of a liquid
+    //e_LogWritefln('  traced out of a liquid; floorY=%s; y=%s', [floorY, y]);
+  end
+  else
+  begin
+    // not in a wall
+    pan := g_Map_traceToNearest(x, y, x, g_Map_MaxY, (GridTagObstacle or GridTagLiquid), @ex, @floorY);
+    if (pan <> nil) then
+    begin
+      // wall or liquid
+      if ((pan.tag and GridTagObstacle) <> 0) then
+      begin
+        // wall
+        floorType := TFloorType.Wall;
+      end
+      else
+      begin
+        // liquid
+        floorType := TFloorType.LiquidIn; // entering liquid
+        floorY += 1; // so `floorY` is just in a liquid
+      end;
+    end
+    else
+    begin
+      // out of the level; assume wall, but it doesn't really matter
+      floorType := TFloorType.Wall;
+      floorY := g_Map_MaxY+2;
+    end;
+  end;
+end;
+
+
+procedure TParticle.findCeiling (force: Boolean=false);
+var
+  ex: Integer;
+begin
+  if (not force) and (ceilingY <> Unknown) then exit;
+  if (nil = g_Map_traceToNearest(x, y, x, g_Map_MinY, GridTagObstacle, @ex, @ceilingY)) then
+  begin
+    ceilingY := g_Map_MinY-2;
+  end;
+end;
+
 
 procedure TParticle.think (); inline;
 begin
-  case ParticleType of
-    PARTICLE_BLOOD: thinkerBlood();
-    PARTICLE_SPARK: thinkerSpark();
-    PARTICLE_BUBBLES: thinkerBubble();
-    PARTICLE_WATER: thinkerWater();
+  // awake sleeping particle, if necessary
+  if (state = TPartState.Sleeping) and awmIsSet(x, y) then state := TPartState.Normal;
+  case particleType of
+    TPartType.Blood: thinkerBlood();
+    //TPartType.Spark: thinkerSpark();
+    //TPartType.Bubbles: thinkerBubble();
+    //TPartType.Water: thinkerWater();
   end;
 end;
 
@@ -143,7 +327,7 @@ end;
 function isBlockedAt (x, y: Integer): Boolean; inline;
 begin
   if not gpart_dbg_phys_enabled then begin result := false; exit; end;
-  result := g_Map_HasAnyPanelAtPoint(x, y, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+  result := g_Map_HasAnyPanelAtPoint(x, y, (PANEL_WALL or PANEL_OPENDOOR or PANEL_CLOSEDOOR or PANEL_STEP));
 end;
 
 // ???
@@ -190,136 +374,44 @@ begin
 end;
 
 
-procedure g_Mark(x, y, Width, Height: Integer; t: Byte; st: Boolean);
-{$IF not DEFINED(HAS_COLLIDE_BITMAP)}
-begin
-end;
-{$ELSE}
+// ////////////////////////////////////////////////////////////////////////// //
+// st: set mark
+// t: mark type
+// currently unused
+procedure g_Mark(x, y, Width, Height: Integer; t: Byte; st: Boolean=true);
 var
-  yy, y2, xx, x2: Integer;
+  cx, ex, ey: Integer;
+  ts: Integer;
 begin
-  if x < 0 then
+  if (Width < 1) or (Height < 1) then exit;
+  // make some border, so we'll hit particles lying around the panel
+  x -= 1; Width += 2;
+  y -= 1; Height += 2;
+  ex := x+Width;
+  ey := y+Height;
+  ts := mapGrid.tileSize;
+  while (y < ey) do
   begin
-    Width := Width + x;
-    x := 0;
-  end;
-
-  if Width < 0 then
-    Exit;
-
-  if y < 0 then
-  begin
-    Height := Height + y;
-    y := 0;
-  end;
-
-  if Height < 0 then
-    Exit;
-
-  if x > gMapInfo.Width then
-    Exit;
-  if y > gMapInfo.Height then
-    Exit;
-
-  y2 := y + Height - 1;
-  if y2 > gMapInfo.Height then
-    y2 := gMapInfo.Height;
-
-  x2 := x + Width - 1;
-  if x2 > gMapInfo.Width then
-    x2 := gMapInfo.Width;
-
-  if st then
-    begin // Óñòàíîâèòü ïðèçíàê
-      for yy := y to y2 do
-        for xx := x to x2 do
-          gCollideMap[yy][xx] := gCollideMap[yy][xx] or t;
-    end
-  else
-    begin // Óáðàòü ïðèçíàê
-      t := not t;
-      for yy := y to y2 do
-        for xx := x to x2 do
-          gCollideMap[yy][xx] := gCollideMap[yy][xx] and t;
+    cx := x;
+    while (cx < ex) do
+    begin
+      awmSet(cx, y);
+      Inc(cx, ts);
     end;
+    Inc(y, ts);
+  end;
 end;
-{$ENDIF}
 
 
+// ////////////////////////////////////////////////////////////////////////// //
 {$IF DEFINED(HAS_COLLIDE_BITMAP)}
 procedure CreateCollideMap();
 var
   a: Integer;
 begin
-  g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 1/6', 0, False);
-  SetLength(gCollideMap, gMapInfo.Height+1);
-  for a := 0 to High(gCollideMap) do
-    SetLength(gCollideMap[a], gMapInfo.Width+1);
-
-  if gWater <> nil then
-  begin
-    g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 2/6', 0, True);
-    for a := 0 to High(gWater) do
-      with gWater[a] do
-        g_Mark(X, Y, Width, Height, MARK_WATER, True);
-  end;
-
-  if gAcid1 <> nil then
-  begin
-    g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 3/6', 0, True);
-    for a := 0 to High(gAcid1) do
-      with gAcid1[a] do
-        g_Mark(X, Y, Width, Height, MARK_ACID, True);
-  end;
-
-  if gAcid2 <> nil then
-  begin
-    g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 4/6', 0, True);
-    for a := 0 to High(gAcid2) do
-      with gAcid2[a] do
-        g_Mark(X, Y, Width, Height, MARK_ACID, True);
-  end;
-
-  if gLifts <> nil then
-  begin
-    g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 5/6', 0, True);
-    for a := 0 to High(gLifts) do
-      with gLifts[a] do
-      begin
-        g_Mark(X, Y, Width, Height, MARK_LIFT, False);
-
-        if LiftType = 0 then
-          g_Mark(X, Y, Width, Height, MARK_LIFTUP, True)
-        else if LiftType = 1 then
-          g_Mark(X, Y, Width, Height, MARK_LIFTDOWN, True)
-        else if LiftType = 2 then
-          g_Mark(X, Y, Width, Height, MARK_LIFTLEFT, True)
-        else if LiftType = 3 then
-          g_Mark(X, Y, Width, Height, MARK_LIFTRIGHT, True)
-      end;
-  end;
-
-  if gWalls <> nil then
-  begin
-    g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 6/6', 0, True);
-    for a := 0 to High(gWalls) do
-    begin
-      if gWalls[a].Door then
-        begin
-        // Çàêðûòàÿ äâåðü:
-          if gWalls[a].Enabled then
-            with gWalls[a] do
-              g_Mark(X, Y, Width, Height, MARK_DOOR, True)
-          else // Îòêðûòàÿ äâåðü:
-            if gWalls[a].Enabled then
-              with gWalls[a] do
-                g_Mark(X, Y, Width, Height, MARK_DOOR, False);
-        end
-      else // Ñòåíà
-        with gWalls[a] do
-          g_Mark(X, Y, Width, Height, MARK_WALL, True);
-    end;
-  end;
+  //g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 1/6', 0, False);
+  //SetLength(gCollideMap, gMapInfo.Height+1);
+  //for a := 0 to High(gCollideMap) do SetLength(gCollideMap[a], gMapInfo.Width+1);
 end;
 {$ENDIF}
 
@@ -327,6 +419,10 @@ end;
 procedure g_GFX_Init();
 begin
   //CreateCollideMap();
+  awmSetup();
+{$IFDEF HEADLESS}
+  gpart_dbg_enabled := False;
+{$ENDIF}
 end;
 
 
@@ -339,276 +435,462 @@ begin
   for a := 0 to High(Particles) do Particles[a].die();
   CurrentParticle := 0;
 
-  if OnceAnims <> nil then
+  if (OnceAnims <> nil) then
   begin
-    for a := 0 to High(OnceAnims) do
-      OnceAnims[a].Animation.Free();
-
+    for a := 0 to High(OnceAnims) do OnceAnims[a].Animation.Free();
     OnceAnims := nil;
   end;
-end;
 
-
-{
-procedure CorrectOffsets(id: Integer); inline;
-var
-  part: PParticle;
-begin
-  part := @Particles[id];
-  part.offsetX := 0;
-  part.offsetY := 0;
-  // check for upper wall
-  if isBlockedAt(part.X, part.Y-1) then part.offsetY := 1;
-  // check for left wall
-  if isBlockedAt(part.X-1, part.Y) then part.offsetX := 1;
+  awakeMap := nil;
+  // why not?
+  awakeMapH := -1;
+  awakeMapW := -1;
 end;
-}
 
 
 // ////////////////////////////////////////////////////////////////////////// //
 procedure TParticle.thinkerBlood ();
-var
-  w, h: Integer;
-  dX, dY: SmallInt;
-  {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-  b: Integer;
-  s: ShortInt;
-  {$ELSE}
-  pan: TPanel;
-  ex, ey: Integer;
-  {$ENDIF}
-begin
-  w := gMapInfo.Width;
-  h := gMapInfo.Height;
+  procedure stickToCeiling ();
+  begin
+    state := TPartState.Stuck;
+    stickDX := 0;
+    // stop right there, you criminal scum!
+    velX := 0;
+    velY := 0;
+    accelX := 0;
+    accelY := 0;
+    ceilingY := y; // yep
+  end;
 
-  if gAdvBlood then
+  procedure stickToWall (dx: Integer);
+  var
+    ex: Integer;
   begin
-    if (State = STATE_STICK) then
-    begin
-      {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-      {
-      if (not ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)) and
-         (not ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)) and
-         (not ByteBool(gCollideMap[Y, X-1] and MARK_BLOCKED)) and
-         (not ByteBool(gCollideMap[Y, X+1] and MARK_BLOCKED))
-      then
-      }
-      if (not isBlockedAt(X, Y-1)) and
-         (not isBlockedAt(X, Y+1)) and
-         (not isBlockedAt(X-1, Y)) and
-         (not isBlockedAt(X+1, Y))
-      {$ELSE}
-      if not g_Map_CollidePanel(X-1, Y-1, 3, 3, (PANEL_STEP or PANEL_WALL or PANEL_OPENDOOR or PANEL_CLOSEDOOR))
-      {$ENDIF}
-      then
-      begin // Îòëèïëà - êàïàåò
-        VelY := 0.5;
-        AccelY := 0.15;
-        State := STATE_NORMAL;
-      end
-      else if (Random(200) = 100) then
-      begin // Ïðèëåïëåíà - íî âîçìîæíî ñòåêàåò
-        VelY := 0.5;
-        AccelY := 0.15;
-        exit;
-      end;
-    end;
+    state := TPartState.Stuck;
+    if (dX > 0) then stickDX := 1 else stickDX := -1;
+    // stop right there, you criminal scum!
+    velX := 0;
+    velY := 0;
+    accelX := 0;
+    accelY := 0;
+    // find next floor transition
+    findFloor();
+    // find `wallEndY`
+    mapGrid.traceOrthoRayWhileIn(ex, wallEndY, x+stickDX, y, x+stickDX, floorY+1, (GridTagWall or GridTagDoor or GridTagStep));
+    //if (wallEndY > floorY) then wallEndY := floorY; // just in case
+  end;
 
-    {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-    if not isBlockedAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)} then
-    begin
-      if isLiftUpAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTUP)} then
-      begin // Ëèôò ââåðõ
-        if (VelY > -4-Random(3)) then VelY -= 0.8;
-        if (abs(VelX) > 0.1) then VelX -= VelX/10.0;
-        VelX += (Random-Random)*0.2;
-        AccelY := 0.15;
-      end;
-      if isLiftLeftAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTLEFT)} then
-      begin // Ïîòîê âëåâî
-        if (VelX > -8-Random(3)) then VelX -= 0.8;
-        AccelY := 0.15;
-      end;
-      if isLiftRightAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTRIGHT)} then
-      begin // Ïîòîê âïðàâî
-        if (VelX < 8+Random(3)) then VelX += 0.8;
-        AccelY := 0.15;
-      end;
-    end;
-    {$ELSE}
-    pan := g_Map_PanelAtPoint(X, Y, GridTagLift);
-    if (pan <> nil) then
+  procedure hitAFloor ();
+  begin
+    state := TPartState.Sleeping; // we aren't moving anymore
+    // stop right there, you criminal scum!
+    velX := 0;
+    velY := 0;
+    accelX := 0;
+    accelY := 0;
+    floorY := y; // yep
+    floorType := TFloorType.Wall; // yep
+  end;
+
+  // `true`: didn't, get outa thinker
+  function drip (): Boolean;
+  begin
+    result := (Random(200) = 100);
+    if result then begin velY := 0.5; accelY := 0.15; end;
+  end;
+
+  // `true`: affected by air stream
+  function checkAirStreams (): Boolean;
+  var
+    pan: TPanel;
+  begin
+    pan := g_Map_PanelAtPoint(x, y, GridTagLift);
+    result := (pan <> nil);
+    if result then
     begin
       if ((pan.PanelType and PANEL_LIFTUP) <> 0) then
       begin
-        if (VelY > -4-Random(3)) then VelY -= 0.8;
-        if (abs(VelX) > 0.1) then VelX -= VelX/10.0;
-        VelX += (Random-Random)*0.2;
-        AccelY := 0.15;
-      end;
-      if ((pan.PanelType and PANEL_LIFTLEFT) <> 0) then
+        if (velY > -4-Random(3)) then velY -= 0.8;
+        if (abs(velX) > 0.1) then velX -= velX/10.0;
+        velX += (Random-Random)*0.2;
+        accelY := 0.15;
+      end
+      else if ((pan.PanelType and PANEL_LIFTLEFT) <> 0) then
       begin
-        if (VelX > -8-Random(3)) then VelX -= 0.8;
-        AccelY := 0.15;
-      end;
-      if ((pan.PanelType and PANEL_LIFTRIGHT) <> 0) then
+        if (velX > -8-Random(3)) then velX -= 0.8;
+        accelY := 0.15;
+      end
+      else if ((pan.PanelType and PANEL_LIFTRIGHT) <> 0) then
       begin
-        if (VelX < 8+Random(3)) then VelX += 0.8;
-        AccelY := 0.15;
+        if (velX < 8+Random(3)) then velX += 0.8;
+        accelY := 0.15;
+      end
+      else
+      begin
+        result := false;
       end;
+      // awake
+      if result and (state = TPartState.Sleeping) then state := TPartState.Normal;
     end;
-    {$ENDIF}
+  end;
+
+  // switch to sleep mode
+  procedure sleep ();
+  begin
+    state := TPartState.Sleeping;
+    // stop right there, you criminal scum!
+    velX := 0;
+    velY := 0;
+    accelX := 0;
+    accelY := 0;
+  end;
 
-    dX := Round(VelX);
-    dY := Round(VelY);
+  // switch to freefall mode
+  procedure freefall ();
+  begin
+    state := TPartState.Normal;
+    velY := 0.5;
+    accelY := 0.15;
+  end;
 
-    {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-    if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
+  procedure applyGravity (inLiquid: Boolean);
+  begin
+    state := TPartState.Normal;
+    if (inLiquid) then
     begin
-      if (State <> STATE_STICK) and
-         (not isBlockedAt(X, Y-1) {ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)}) and
-         (not isBlockedAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)}) and
-         (not isBlockedAt(X, Y+1) {ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)}) then
-      begin // Âèñèò â âîçäóõå - êàïàåò
-        VelY := 0.8;
-        AccelY := 0.5;
-        State := STATE_NORMAL;
-      end;
-    end;
-    {$ELSE}
-    if (State <> STATE_STICK) and (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
+      velY := 0.5;
+      accelY := 0.15;
+    end
+    else
     begin
-      // Âèñèò â âîçäóõå - êàïàåò
-      if (nil = g_Map_traceToNearest(X, Y-1, X, Y+1, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey)) then
-      begin
-        VelY := 0.8;
-        AccelY := 0.5;
-        State := STATE_NORMAL;
-      end;
+      velY := 0.8;
+      accelY := 0.5;
     end;
-    {$ENDIF}
+  end;
 
-    {$IF DEFINED(D2F_NEW_SPARK_THINKER)}
-    // horizontal
-    if (dX <> 0) then
+label
+  _done;
+var
+  pan: TPanel;
+  dX, dY: SmallInt;
+  ex, ey: Integer;
+begin
+  if gAdvBlood then
+  begin
+    // still check for air streams when sleeping
+    if (state = TPartState.Sleeping) and not checkAirStreams() then exit;
+
+    // process stuck particles
+    if (state = TPartState.Stuck) then
     begin
-      pan := g_Map_traceToNearest(X, Y, X+dX, Y, (GridTagWall or GridTagDoor or GridTagStep), @ex, @ey);
-      X := ex;
-      // free to ride?
-      if (pan <> nil) then
+      // stuck to a ceiling?
+      if (stickDX = 0) then
       begin
-        // Ñòåíà/äâåðü
-        VelX := 0;
-        VelY := 0;
-        AccelX := 0;
-        AccelY := 0;
-        State := STATE_STICK;
-        if (dX > 0) then stickDX := 1 else stickDX := -1;
-      end;
-      if (X < 0) or (X >= w) then begin die(); exit; end;
-    end;
-    // vertical
-    if (dY <> 0) then
-    begin
-      pan := g_Map_traceToNearest(X, Y, X, Y+dY, (GridTagWall or GridTagDoor or GridTagStep), @ex, @ey);
-      Y := ey;
-      // free to ride?
-      if (pan <> nil) then
+        assert(ceilingY <> Unknown);
+        // dropped from a ceiling?
+        if (y > ceilingY) then
+        begin
+          // yep
+          velY := 0.5;
+          accelY := 0.15;
+          state := TPartState.Normal;
+        end
+        else
+        begin
+          // otherwise, try to drip
+          if drip() then goto _done;
+        end;
+      end
+      else
       begin
-        // Ñòåíà/äâåðü
-        VelX := 0;
-        VelY := 0;
-        AccelX := 0;
-        AccelY := 0;
-        if (dY > 0) and (State <> STATE_STICK) then
+        // stuck to a wall
+        assert(wallEndY <> Unknown);
+        // floor transition?
+        if (y = floorY) then
         begin
-          State := STATE_NORMAL;
+          case floorType of
+            TFloorType.Wall: // hit the ground
+              begin
+                sleep();
+                goto _done; // nothing to do anymore
+              end;
+            TFloorType.LiquidIn: // entering the liquid
+              begin
+                // rescan, so we'll know when we'll exit the liquid
+                findFloor(true); // force rescan
+              end;
+            TFloorType.LiquidOut: // exiting the liquid
+              begin
+                // rescan, so we'll know when we'll enter something interesting
+                findFloor(true); // force rescan
+                if (floorType = TFloorType.Wall) and (floorY = y) then begin sleep(); goto _done; end;
+              end;
+          end;
+        end;
+        // wall transition?
+        if (y = wallEndY) then
+        begin
+          // just unstuck from the wall, switch to freefall mode
+          freefall();
         end
         else
         begin
-          State := STATE_STICK;
-               if (g_Map_PanelAtPoint(X-1, Y, (GridTagWall or GridTagDoor or GridTagStep)) <> nil) then stickDX := -1
-          else if (g_Map_PanelAtPoint(X+1, Y, (GridTagWall or GridTagDoor or GridTagStep)) <> nil) then stickDX := 1
-          else stickDX := 0;
+          // otherwise, try to drip
+          if drip() then goto _done;
         end;
       end;
-      if (Y < 0) or (Y >= h) then begin die(); exit; end;
+      // nope, process as usual
     end;
-    {$ELSE}
-    // horizontal
-    if (dX <> 0) then
+
+    // it is important to have it here
+    dX := round(velX);
+    dY := round(velY);
+
+    // gravity, if not stuck
+    if (state <> TPartState.Stuck) and (abs(velX) < 0.1) and (abs(velY) < 0.1) then
     begin
-      if (dX > 0) then s := 1 else s := -1;
-      dX := Abs(dX);
-      for b := 1 to dX do
+      if (floorY = Unknown) then findFloor();
+      // floor transition?
+      if (y = floorY) then
       begin
-        if (X+s >= w) or (X+s <= 0) then begin die(); break; end;
-        //c := gCollideMap[Y, X+s];
-        if isBlockedAt(X+s, Y) {ByteBool(c and MARK_BLOCKED)} then
-        begin // Ñòåíà/äâåðü
-          VelX := 0;
-          VelY := 0;
-          AccelX := 0;
-          AccelY := 0;
-          State := STATE_STICK;
-          break;
+        case floorType of
+          TFloorType.Wall: // hit the ground
+            begin
+              // nothing to do
+            end;
+          TFloorType.LiquidIn: // entering the liquid
+            begin
+              // rescan, so we'll know when we'll exit the liquid
+              findFloor(true); // force rescan
+              applyGravity(true);
+            end;
+          TFloorType.LiquidOut: // exiting the liquid
+            begin
+              // rescan, so we'll know when we'll enter something interesting
+              findFloor(true); // force rescan
+              if (floorType <> TFloorType.Wall) or (floorY <> y) then applyGravity(floorType = TFloorType.LiquidIn);
+            end;
         end;
-        X := X+s;
+      end
+      else
+      begin
+        // looks like we're in the air
+        applyGravity(false);
       end;
     end;
-    // vertical
-    if (dY <> 0) then
+
+    // horizontal movement
+    if (dX <> 0) then
+    begin
+      pan := g_Map_traceToNearest(x, y, x+dX, y, (GridTagWall or GridTagDoor or GridTagStep), @ex, @ey);
+      if (x <> ex) then begin floorY := Unknown; ceilingY := Unknown; end; // dunno yet
+      x := ex;
+      if (x < g_Map_MinX) or (x > g_Map_MaxX) then begin die(); exit; end;
+      if (pan <> nil) then stickToWall(dX); // nope, we stuck
+    end;
+
+    // vertical movement
+    if (dY < 0) then
     begin
-      if (dY > 0) then s := 1 else s := -1;
-      dY := Abs(dY);
-      for b := 1 to dY do
+      // flying up
+      if (ceilingY = Unknown) then findCeiling(); // need to do this anyway
+      y += dY;
+      if (y <= ceilingY) then begin y := ceilingY; stickToCeiling(); end; // oops, hit a ceiling
+    end
+    else
+    begin
+      while (dY > 0) do
       begin
-        if (Y+s >= h) or (Y+s <= 0) then begin die(); break; end;
-        //c := gCollideMap[Y+s, X];
-        if isBlockedAt(X, Y+s) {ByteBool(c and MARK_BLOCKED)} then
-        begin // Ñòåíà/äâåðü
-          VelX := 0;
-          VelY := 0;
-          AccelX := 0;
-          AccelY := 0;
-          if (s > 0) and (State <> STATE_STICK) then State := STATE_NORMAL else State := STATE_STICK;
-          break;
+        // falling down
+        if (floorY = Unknown) then findFloor(); // need to do this anyway
+        y += dY;
+        //e_LogWritefln('floorY=%s; newy=%s; dY=%s; floorType=%s', [floorY, y, dY, floorType]);
+        if (y >= floorY) then
+        begin
+          // floor transition
+          dY := y-floorY;
+          y := floorY;
+          //e_LogWritefln('  HIT FLOORY: floorY=%s; newy=%s; dY=%s; floorType=%s', [floorY, y, dY, floorType]);
+          case floorType of
+            TFloorType.Wall: // hit the ground
+              begin
+                hitAFloor();
+                break; // done with vertical movement
+              end;
+            TFloorType.LiquidIn: // entering the liquid
+              begin
+                // rescan, so we'll know when we'll exit the liquid
+                findFloor(true); // force rescan
+              end;
+            TFloorType.LiquidOut: // exiting the liquid
+              begin
+                // rescan, so we'll know when we'll enter something interesting
+                findFloor(true); // force rescan
+                if (floorType = TFloorType.Wall) and (floorY = y) then
+                begin
+                  hitAFloor();
+                  break; // done with vertical movement
+                end;
+              end;
+          end;
+        end
+        else
+        begin
+          break; // done with vertical movement
         end;
-        Y := Y+s;
       end;
     end;
-    {$ENDIF}
+    if (y < g_Map_MinY) or (y > g_Map_MaxY) then begin die(); exit; end;
   end // if gAdvBlood
   else
   begin
-    dX := Round(VelX);
-    dY := Round(VelY);
-    if (X+dX >= w) or (Y+dY >= h) or (X+dX <= 0) or (Y+dY <= 0) or isBlockedAt(X+dX, Y+dY) {ByteBool(gCollideMap[Y+dY, X+dX] and MARK_BLOCKED)} then
-    begin // Ñòåíà/äâåðü/ãðàíèöà
+    // simple blood
+    dX := Round(velX);
+    dY := Round(velY);
+    if (x+dX > g_Map_MaxX) or (y+dY > g_Map_MaxY) or (x+dX < g_Map_MinX) or (y+dY < g_Map_MinY) or isBlockedAt(x+dX, y+dY) then
+    begin
+      // Ñòåíà/äâåðü/ãðàíèöà
       die();
       exit;
-      //VelX := 0;
-      //VelY := 0;
     end
     else
     begin
-      Y += dY;
-      X += dX;
+      y += dY;
+      x += dX;
     end;
   end;
 
-  VelX += AccelX;
-  VelY += AccelY;
+_done:
+  velX += accelX;
+  velY += accelY;
 
-  // Êðîâü ðàñòâîðÿåòñÿ â æèäêîñòè:
-  if isLiquidAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIQUID)} then
+  // blood will dissolve in other liquids
+  if (floorType = TFloorType.LiquidOut) then
+  begin
+    time += 1;
+    alpha := 255-trunc((255.0*time)/liveTime);
+  end;
+  (*
+  // Êðîâü ðàñòâîðÿåòñÿ â æèäêîñòè
+  if isLiquidAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_LIQUID)} then
   begin
-    Time += 1;
-    Alpha := 255-trunc((255.0*Time)/LiveTime);
+    time += 1;
+    alpha := 255-trunc((255.0*time)/liveTime);
   end;
+  *)
 end;
 
 
+procedure g_GFX_SparkVel (fX, fY: Integer; Count: Word; VX, VY: Integer; DevX, DevY: Byte); forward;
+
+procedure g_GFX_Blood (fX, fY: Integer; Count: Word; vx, vy: Integer;
+                       DevX, DevY: Word; CR, CG, CB: Byte; Kind: Byte = BLOOD_NORMAL);
+var
+  a: Integer;
+  DevX1, DevX2, DevY1, DevY2: Word;
+  l: Integer;
+  CRnd: Byte;
+  CC: SmallInt;
+begin
+  if not gpart_dbg_enabled then Exit;
+
+  if (Kind = BLOOD_SPARKS) then
+  begin
+    g_GFX_SparkVel(fX, fY, 2+Random(2), -VX div 2, -VY div 2, DevX, DevY);
+    exit;
+  end;
+
+  l := Length(Particles);
+  if (l = 0) then exit;
+  if (Count > l) then Count := l;
+
+  DevX1 := DevX div 2;
+  DevX2 := DevX+1;
+  DevY1 := DevY div 2;
+  DevY2 := DevY+1;
+
+  for a := 1 to Count do
+  begin
+    with Particles[CurrentParticle] do
+    begin
+      x := fX-DevX1+Random(DevX2);
+      y := fY-DevY1+Random(DevY2);
+
+      {
+      if (X < 0) or (X > gMapInfo.Width-1) or
+         (Y < 0) or (Y > gMapInfo.Height-1) or
+         ByteBool(gCollideMap[Y, X] and MARK_WALL) then
+        Continue;
+      }
+      if isWallAt(x, y) then continue;
+
+      velX := vx+(Random-Random)*3;
+      velY := vy+(Random-Random)*3;
+
+      if (velY > -4) then
+      begin
+        if (velY-4 < -4) then velY := -4 else velY := velY-4;
+      end;
+
+      accelX := -sign(velX)*Random/100;
+      accelY := 0.8;
+
+      CRnd := 20*Random(6);
+      if (CR > 0) then
+      begin
+        CC := CR+CRnd-50;
+             if (CC < 0) then CC := 0
+        else if (CC > 255) then CC := 255;
+        red := CC;
+      end
+      else
+      begin
+        red := 0;
+      end;
+      if CG > 0 then
+      begin
+        CC := CG+CRnd-50;
+             if (CC < 0) then CC := 0
+        else if (CC > 255) then CC := 255;
+        green := CC;
+      end
+      else
+      begin
+        green := 0;
+      end;
+      if (CB > 0) then
+      begin
+        CC := CB+CRnd-50;
+             if (CC < 0) then CC := 0
+        else if (CC > 255) then CC := 255;
+        blue := CC;
+      end
+      else
+      begin
+        blue := 0;
+      end;
+
+      alpha := 255;
+
+      state := TPartState.Normal;
+      time := 0;
+      liveTime := 120+Random(40);
+      particleType := TPartType.Blood;
+      //justSticked := false;
+      //onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+      //awaken := false;
+      //stickEY := 0;
+      floorY := Unknown;
+      ceilingY := Unknown;
+    end;
+
+    if CurrentParticle >= MaxParticles-1 then
+      CurrentParticle := 0
+    else
+      CurrentParticle := CurrentParticle+1;
+  end;
+end;
+
 
 // ////////////////////////////////////////////////////////////////////////// //
 procedure TParticle.thinkerWater ();
@@ -629,103 +911,126 @@ begin
   {$ENDIF}
 
   //TODO: trace wall end when water becomes stick
-  if (State = STATE_STICK) and (Random(30) = 15) then
+  if (state = TPartState.Stuck) and (Random(30) = 15) then
   begin // Ñòåêàåò/îòëèïàåò
-    VelY := 0.5;
-    AccelY := 0.15;
+    velY := 0.5;
+    accelY := 0.15;
     {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-    if (not isBlockedAt(X-1, Y) {ByteBool(gCollideMap[Y, X-1] and MARK_BLOCKED)}) and
-       (not isBlockedAt(X+1, Y) {ByteBool(gCollideMap[Y, X+1] and MARK_BLOCKED)}) then
-      State := STATE_NORMAL;
+    if (not isBlockedAt(x-1, y) {ByteBool(gCollideMap[Y, X-1] and MARK_BLOCKED)}) and
+       (not isBlockedAt(x+1, y) {ByteBool(gCollideMap[Y, X+1] and MARK_BLOCKED)}) then
+      state := TPartState.Normal;
     {$ELSE}
     if (stickDX = 0) then
     begin
       // no walls around, drop
-      State := STATE_NORMAL;
+      state := TPartState.Normal;
     end
     else
     begin
-      if (g_Map_PanelAtPoint(X+stickDX, Y, (GridTagWall or GridTagDoor or GridTagStep)) = nil) then State := STATE_NORMAL;
+      if justSticked then
+      begin
+        if not mapGrid.traceOrthoRayWhileIn(ex, ey, x+stickDX, y, x+stickDX, mapGrid.gridY0+mapGrid.gridHeight, GridTagWall or GridTagDoor or GridTagStep) then
+        begin
+           // îòëèïëà
+          state := TPartState.Normal;
+          //e_LogWritefln('juststicked unsticked: X=%s; X+stickDX=%s; stickDX=%s; Y=%s', [X, X+stickDX, stickDX, Y]);
+        end
+        else
+        begin
+          stickEY := ey+1;
+          justSticked := false;
+          if (nil <> g_Map_traceToNearest(x, y, x, stickEY, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey)) then
+          begin
+            if (ey > stickEY) then stickEY := ey-1;
+          end;
+          //e_LogWritefln('juststicked: X=%s; X+stickDX=%s; stickDX=%s; Y=%s; stickEY=%s', [X, X+stickDX, stickDX, Y, stickEY]);
+        end;
+      end
+      else
+      begin
+        if (y >= stickEY) then state := TPartState.Normal;
+      end;
+      //if not g_Map_CollidePanel(X-1, Y-1, 3, 3, (PANEL_STEP or PANEL_WALL or PANEL_OPENDOOR or PANEL_CLOSEDOOR))
     end;
     {$ENDIF}
     exit;
   end;
 
   {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-  if not isBlockedAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)} then
+  if not isBlockedAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)} then
   begin
-    if isLiftUpAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTUP)} then
+    if isLiftUpAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTUP)} then
     begin // Ëèôò ââåðõ
-      if VelY > -4-Random(3) then
-        VelY := VelY - 0.8;
-      if Abs(VelX) > 0.1 then
-        VelX := VelX - VelX/10.0;
-      VelX := VelX + (Random-Random)*0.2;
-      AccelY := 0.15;
+      if velY > -4-Random(3) then
+        velY := velY - 0.8;
+      if Abs(velX) > 0.1 then
+        velX := velX - velX/10.0;
+      velX := velX + (Random-Random)*0.2;
+      accelY := 0.15;
     end;
-    if isLiftLeftAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTLEFT)} then
+    if isLiftLeftAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTLEFT)} then
     begin // Ïîòîê âëåâî
-      if VelX > -8-Random(3) then
-        VelX := VelX - 0.8;
-      AccelY := 0.15;
+      if velX > -8-Random(3) then
+        velX := velX - 0.8;
+      accelY := 0.15;
     end;
-    if isLiftRightAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTRIGHT)} then
+    if isLiftRightAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_LIFTRIGHT)} then
     begin // Ïîòîê âïðàâî
-      if VelX < 8+Random(3) then
-        VelX := VelX + 0.8;
-      AccelY := 0.15;
+      if velX < 8+Random(3) then
+        velX := velX + 0.8;
+      accelY := 0.15;
     end;
   end;
   {$ELSE}
-  pan := g_Map_PanelAtPoint(X, Y, (GridTagAcid1 or GridTagAcid2 or GridTagWater or GridTagLift));
+  pan := g_Map_PanelAtPoint(x, y, (GridTagAcid1 or GridTagAcid2 or GridTagWater or GridTagLift));
   if (pan <> nil) then
   begin
     if ((pan.tag and (GridTagAcid1 or GridTagAcid2 or GridTagWater)) <> 0) then begin die(); exit; end;
     if ((pan.PanelType and PANEL_LIFTUP) <> 0) then
     begin
-      if (VelY > -4-Random(3)) then VelY -= 0.8;
-      if (Abs(VelX) > 0.1) then VelX -= VelX/10.0;
-      VelX += (Random-Random)*0.2;
-      AccelY := 0.15;
+      if (velY > -4-Random(3)) then velY -= 0.8;
+      if (Abs(velX) > 0.1) then velX -= velX/10.0;
+      velX += (Random-Random)*0.2;
+      accelY := 0.15;
     end;
     if ((pan.PanelType and PANEL_LIFTLEFT) <> 0) then
     begin
-      if (VelX > -8-Random(3)) then VelX -= 0.8;
-      AccelY := 0.15;
+      if (velX > -8-Random(3)) then velX -= 0.8;
+      accelY := 0.15;
     end;
     if ((pan.PanelType and PANEL_LIFTRIGHT) <> 0) then
     begin
-      if (VelX < 8+Random(3)) then VelX += 0.8;
-      AccelY := 0.15;
+      if (velX < 8+Random(3)) then velX += 0.8;
+      accelY := 0.15;
     end;
   end;
   {$ENDIF}
 
-  dX := Round(VelX);
-  dY := Round(VelY);
+  dX := Round(velX);
+  dY := Round(velY);
 
   {$IF not DEFINED(D2F_NEW_SPARK_THINKER)}
-  if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
+  if (Abs(velX) < 0.1) and (Abs(velY) < 0.1) then
   begin
-    if (State <> STATE_STICK) and
-       (not isBlockedAt(X, Y-1) {ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)}) and
-       (not isBlockedAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)}) and
-       (not isBlockedAt(X, Y+1) {ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)}) then
+    if (state <> TPartState.Stuck) and
+       (not isBlockedAt(x, y-1) {ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)}) and
+       (not isBlockedAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)}) and
+       (not isBlockedAt(x, y+1) {ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)}) then
     begin // Âèñèò â âîçäóõå - êàïàåò
-      VelY := 0.8;
-      AccelY := 0.5;
-      State := STATE_NORMAL;
+      velY := 0.8;
+      accelY := 0.5;
+      state := TPartState.Normal;
     end;
   end;
   {$ELSE}
-  if (State <> STATE_STICK) and (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
+  if (state <> TPartState.Stuck) and (Abs(velX) < 0.1) and (Abs(velY) < 0.1) then
   begin
     // Âèñèò â âîçäóõå - êàïàåò
-    if (nil = g_Map_traceToNearest(X, Y-1, X, Y+1, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey)) then
+    if (nil = g_Map_traceToNearest(x, y-1, x, y+1, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey)) then
     begin
-      VelY := 0.8;
-      AccelY := 0.5;
-      State := STATE_NORMAL;
+      velY := 0.8;
+      accelY := 0.5;
+      state := TPartState.Normal;
     end;
   end;
   {$ENDIF}
@@ -734,8 +1039,9 @@ begin
   // horizontal
   if (dX <> 0) then
   begin
-    pan := g_Map_traceToNearest(X, Y, X+dX, Y, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
-    X := ex;
+    pan := g_Map_traceToNearest(x, y, x+dX, y, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
+    if (x <> ex) then onGround := false;
+    x := ex;
     // free to ride?
     if (pan <> nil) then
     begin
@@ -744,47 +1050,53 @@ begin
       // Ñòåíà/äâåðü?
       if ((pan.tag and (GridTagWall or GridTagDoor or GridTagStep)) <> 0) then
       begin
-        VelX := 0;
-        VelY := 0;
-        AccelX := 0;
-        AccelY := 0;
-        State := STATE_STICK;
+        velX := 0;
+        velY := 0;
+        accelX := 0;
+        accelY := 0;
+        state := TPartState.Stuck;
+        justSticked := true;
         if (dX > 0) then stickDX := 1 else stickDX := -1;
       end;
     end;
-    if (X < 0) or (X >= gMapInfo.Width) then begin die(); exit; end;
+    if (x < 0) or (x >= gMapInfo.Width) then begin die(); exit; end;
   end;
   // vertical
   if (dY <> 0) then
   begin
-    pan := g_Map_traceToNearest(X, Y, X, Y+dY, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
-    Y := ey;
-    // free to ride?
-    if (pan <> nil) then
+    if (dY < 0) or not onGround then
     begin
-      // nope
-      if (dY > 0) and ((pan.tag and (GridTagAcid1 or GridTagAcid2 or GridTagWater)) <> 0) then begin die(); exit; end;
-      // Ñòåíà/äâåðü?
-      if ((pan.tag and (GridTagWall or GridTagDoor or GridTagStep)) <> 0) then
+      pan := g_Map_traceToNearest(x, y, x, y+dY, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
+      y := ey;
+      // free to ride?
+      if (pan <> nil) then
       begin
-        VelX := 0;
-        VelY := 0;
-        AccelX := 0;
-        AccelY := 0;
-        if (dY > 0) and (State <> STATE_STICK) then
-        begin
-          State := STATE_NORMAL;
-        end
-        else
+        // nope
+        if (dY > 0) and ((pan.tag and (GridTagAcid1 or GridTagAcid2 or GridTagWater)) <> 0) then begin die(); exit; end;
+        // Ñòåíà/äâåðü?
+        if ((pan.tag and (GridTagWall or GridTagDoor or GridTagStep)) <> 0) then
         begin
-          State := STATE_STICK;
-               if (g_Map_PanelAtPoint(X-1, Y, (GridTagWall or GridTagDoor or GridTagStep)) <> nil) then stickDX := -1
-          else if (g_Map_PanelAtPoint(X+1, Y, (GridTagWall or GridTagDoor or GridTagStep)) <> nil) then stickDX := 1
-          else stickDX := 0;
+          velX := 0;
+          velY := 0;
+          accelX := 0;
+          accelY := 0;
+          if (dY > 0) and (state <> TPartState.Stuck) then
+          begin
+            state := TPartState.Normal;
+          end
+          else
+          begin
+            state := TPartState.Stuck;
+                 if (g_Map_PanelAtPoint(x-1, y, (GridTagWall or GridTagDoor or GridTagStep)) <> nil) then stickDX := -1
+            else if (g_Map_PanelAtPoint(x+1, y, (GridTagWall or GridTagDoor or GridTagStep)) <> nil) then stickDX := 1
+            else stickDX := 0;
+            justSticked := true;
+          end;
         end;
       end;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
     end;
-    if (Y < 0) or (Y >= gMapInfo.Height) then begin die(); exit; end;
+    if (y < 0) or (y >= gMapInfo.Height) then begin die(); exit; end;
   end;
   {$ELSE}
   // horizontal
@@ -794,20 +1106,21 @@ begin
     for b := 1 to Abs(dX) do
     begin
       // Ñáîêó ãðàíèöà?
-      if (X+s >= w) or (X+s <= 0) then begin die(); break;end;
+      if (x+s >= w) or (x+s <= 0) then begin die(); break;end;
       //c := gCollideMap[Y, X+s];
       // Ñáîêó æèäêîñòü, à ÷àñòèöà óæå ïàäàåò?
-      if isLiquidAt(X+s, Y) {ByteBool(c and MARK_LIQUID)} and (dY > 0) then begin die(); break; end;
-      if isBlockedAt(X+s, Y) {ByteBool(c and MARK_BLOCKED)} then
+      if isLiquidAt(x+s, y) {ByteBool(c and MARK_LIQUID)} and (dY > 0) then begin die(); break; end;
+      if isBlockedAt(x+s, y) {ByteBool(c and MARK_BLOCKED)} then
       begin // Ñòåíà/äâåðü
-        VelX := 0;
-        VelY := 0;
-        AccelX := 0;
-        AccelY := 0;
-        State := STATE_STICK;
+        velX := 0;
+        velY := 0;
+        accelX := 0;
+        accelY := 0;
+        state := TPartState.Stuck;
+        justSticked := true;
         Break;
       end;
-      X := X+s;
+      x := x+s;
     end;
   end;
   // vertical
@@ -817,28 +1130,29 @@ begin
     for b := 1 to Abs(dY) do
     begin
       // Ñíèçó/ñâåðõó ãðàíèöà
-      if (Y+s >= h) or (Y+s <= 0) then begin die(); break; end;
+      if (y+s >= h) or (y+s <= 0) then begin die(); break; end;
       //c := gCollideMap[Y+s, X];
       // Ñíèçó æèäêîñòü, à ÷àñòèöà óæå ïàäàåò
-      if isLiquidAt(X, Y+s) {ByteBool(c and MARK_LIQUID)} and (dY > 0) then begin die(); break; end;
-      if isBlockedAt(X, Y+s) {ByteBool(c and MARK_BLOCKED)} then
+      if isLiquidAt(x, y+s) {ByteBool(c and MARK_LIQUID)} and (dY > 0) then begin die(); break; end;
+      if isBlockedAt(x, y+s) {ByteBool(c and MARK_BLOCKED)} then
       begin // Ñòåíà/äâåðü
-        VelX := 0;
-        VelY := 0;
-        AccelX := 0;
-        AccelY := 0;
-        if (s > 0) and (State <> STATE_STICK) then State := STATE_NORMAL else State := STATE_STICK;
+        velX := 0;
+        velY := 0;
+        accelX := 0;
+        accelY := 0;
+        if (s > 0) and (state <> TPartState.Stuck) then state := TPartState.Normal else state := TPartState.Stuck;
+        justSticked := (state = TPartState.Stuck);
         break;
       end;
-      Y := Y+s;
+      y := y+s;
     end;
   end;
   {$ENDIF}
 
-  VelX += AccelX;
-  VelY += AccelY;
+  velX += accelX;
+  velY += accelY;
 
-  Time += 1;
+  time += 1;
 end;
 
 
@@ -854,56 +1168,57 @@ var
   ex, ey: Integer;
   {$ENDIF}
 begin
-  dX := Round(VelX);
-  dY := Round(VelY);
+  dX := Round(velX);
+  dY := Round(velY);
 
   {$IF DEFINED(D2F_NEW_SPARK_THINKER)}
-  if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
+  if (Abs(velX) < 0.1) and (Abs(velY) < 0.1) then
   begin
-    pan := g_Map_traceToNearest(X, Y-1, X, Y+1, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
+    pan := g_Map_traceToNearest(x, y-1, x, y+1, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
   end;
   {$ELSE}
-  if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) and
-     (not isBlockedAt(X, Y-1) {ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)}) and
-     (not isBlockedAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)}) and
-     (not isBlockedAt(X, Y+1) {ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)}) then
+  if (Abs(velX) < 0.1) and (Abs(velY) < 0.1) and
+     (not isBlockedAt(x, y-1) {ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)}) and
+     (not isBlockedAt(x, y) {ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)}) and
+     (not isBlockedAt(x, y+1) {ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)}) then
   begin // Âèñèò â âîçäóõå
-    VelY := 0.8;
-    AccelY := 0.5;
+    velY := 0.8;
+    accelY := 0.5;
   end;
   {$ENDIF}
 
   if (dX <> 0) then
   begin
     {$IF DEFINED(D2F_NEW_SPARK_THINKER)}
-    pan := g_Map_traceToNearest(X, Y, X+dX, Y, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
+    pan := g_Map_traceToNearest(x, y, x+dX, y, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
     //e_WriteLog(Format('spark h-trace: (%d,%d)-(%d,%d); dx=%d; end=(%d,%d); hit=%d', [X, Y, X+dX, Y, dX, ex, ey, Integer(pan <> nil)]), MSG_NOTIFY);
-    X := ex;
+    if (x <> ex) then onGround := false;
+    x := ex;
     // free to ride?
     if (pan <> nil) then
     begin
       // nope
       if ((pan.tag and (GridTagAcid1 or GridTagAcid2 or GridTagWater)) <> 0) then begin die(); exit; end;
-      VelX := 0;
-      AccelX := 0;
+      velX := 0;
+      accelX := 0;
     end;
-    if (X < 0) or (X >= gMapInfo.Width) then begin die(); exit; end;
+    if (x < 0) or (x >= gMapInfo.Width) then begin die(); exit; end;
     {$ELSE}
     if (dX > 0) then s := 1 else s := -1;
     dX := Abs(dX);
     for b := 1 to dX do
     begin
-      if (X+s >= gMapInfo.Width) or (X+s <= 0) then begin die(); break; end;
+      if (x+s >= gMapInfo.Width) or (x+s <= 0) then begin die(); break; end;
       //c := gCollideMap[Y, X+s];
-      if isBlockedAt(X+s, Y) {ByteBool(c and MARK_BLOCKED)} then
+      if isBlockedAt(x+s, y) {ByteBool(c and MARK_BLOCKED)} then
         begin // Ñòåíà/äâåðü - ïàäàåò âåðòèêàëüíî
-          VelX := 0;
-          AccelX := 0;
+          velX := 0;
+          accelX := 0;
           Break;
         end
       else // Ïóñòî:
-        if not isAnythingAt(X+s, Y) {c = MARK_FREE} then
-          X := X + s
+        if not isAnythingAt(x+s, y) {c = MARK_FREE} then
+          x := x + s
         else // Îñòàëüíîå:
           begin
             die();
@@ -916,66 +1231,65 @@ begin
   if (dY <> 0) then
   begin
     {$IF DEFINED(D2F_NEW_SPARK_THINKER)}
-    pan := g_Map_traceToNearest(X, Y, X, Y+dY, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
-    //e_WriteLog(Format('spark y-trace: (%d,%d)-(%d,%d); dy=%d; end=(%d,%d); hit=%d', [X, Y, X, Y+dY, dY, ex, ey, Integer(pan <> nil)]), MSG_NOTIFY);
-    (*
-    if (pan <> nil) then
+    if (dY < 0) or not onGround then
     begin
-      e_WriteLog(Format('spark y-trace: %08x (%d,%d)-(%d,%d); dy=%d; end=(%d,%d); hittag=%04x', [LongWord(@self), X, Y, X, Y+dY, dY, ex, ey, pan.tag]), MSG_NOTIFY);
-    end
-    else
-    begin
-      e_WriteLog(Format('spark y-trace: %08x (%d,%d)-(%d,%d); dy=%d; end=(%d,%d); hit=%d', [LongWord(@self), X, Y, X, Y+dY, dY, ex, ey, Integer(pan <> nil)]), MSG_NOTIFY);
-    end;
-    *)
-    Y := ey;
-    // free to ride?
-    if (pan <> nil) then
-    begin
-      //die(); exit;
-      // nope
-      if ((pan.tag and (GridTagAcid1 or GridTagAcid2 or GridTagWater)) <> 0) then begin die(); exit; end;
-      if (dY < 0) then
+      pan := g_Map_traceToNearest(x, y, x, y+dY, (GridTagWall or GridTagDoor or GridTagStep or GridTagAcid1 or GridTagAcid2 or GridTagWater), @ex, @ey);
+      y := ey;
+      {
+      if awaken then
       begin
-        VelY := -VelY;
-        AccelY := abs(AccelY);
-      end
-      else
+        awaken := false;
+        e_LogWritefln('AWAKEN particle of type %s; justSticked=%s; onGround=%s; VelY=%s; AccelY=%s; Y=%s; ey=%s', [ParticleType, justSticked, onGround, VelY, AccelY, Y, ey]);
+      end;
+      }
+      // free to ride?
+      if (pan <> nil) then
       begin
-        VelX := 0;
-        AccelX := 0;
-        VelY := 0;
-        AccelY := 0.8;
+        // nope
+        if ((pan.tag and (GridTagAcid1 or GridTagAcid2 or GridTagWater)) <> 0) then begin die(); exit; end;
+        if (dY < 0) then
+        begin
+          velY := -velY;
+          accelY := abs(accelY);
+        end
+        else
+        begin
+          velX := 0;
+          accelX := 0;
+          velY := 0;
+          accelY := 0.8;
+        end;
       end;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
     end;
-    if (Y < 0) or (Y >= gMapInfo.Height) then begin die(); exit; end;
+    if (y < 0) or (y >= gMapInfo.Height) then begin die(); exit; end;
     {$ELSE}
     if (dY > 0) then s := 1 else s := -1;
     dY := Abs(dY);
     for b := 1 to dY do
     begin
-      if (Y+s >= gMapInfo.Height) or (Y+s <= 0) then begin die(); break; end;
+      if (y+s >= gMapInfo.Height) or (y+s <= 0) then begin die(); break; end;
       //c := gCollideMap[Y+s, X];
-      if isBlockedAt(X, Y+s) {ByteBool(c and MARK_BLOCKED)} then
+      if isBlockedAt(x, y+s) {ByteBool(c and MARK_BLOCKED)} then
         begin // Ñòåíà/äâåðü - ïàäàåò âåðòèêàëüíî
           if s < 0 then
             begin
-              VelY := -VelY;
-              AccelY := Abs(AccelY);
+              velY := -velY;
+              accelY := Abs(accelY);
             end
           else // Èëè íå ïàäàåò
             begin
-              VelX := 0;
-              AccelX := 0;
-              VelY := 0;
-              AccelY := 0.8;
+              velX := 0;
+              accelX := 0;
+              velY := 0;
+              accelY := 0.8;
             end;
 
           Break;
         end
       else // Ïóñòî:
-        if not isAnythingAt(X, Y+s) {c = MARK_FREE} then
-          Y := Y + s
+        if not isAnythingAt(x, y+s) {c = MARK_FREE} then
+          y := y + s
         else // Îñàëüíîå:
           begin
             die();
@@ -985,15 +1299,15 @@ begin
     {$ENDIF}
   end;
 
-  if (VelX <> 0.0) then VelX += AccelX;
+  if (velX <> 0.0) then velX += accelX;
 
-  if (VelY <> 0.0) then
+  if (velY <> 0.0) then
   begin
-    if (AccelY < 10) then AccelY += 0.08;
-    VelY += AccelY;
+    if (accelY < 10) then accelY += 0.08;
+    velY += accelY;
   end;
 
-  Time += 1;
+  time += 1;
 end;
 
 // ////////////////////////////////////////////////////////////////////////// //
@@ -1006,7 +1320,7 @@ var
 begin
   h := gMapInfo.Height;
 
-  dY := Round(VelY);
+  dY := Round(velY);
 
   if dY <> 0 then
   begin
@@ -1017,7 +1331,7 @@ begin
 
     for b := 1 to Abs(dY) do
     begin
-      if (Y+s >= h) or (Y+s <= 0) then begin die(); break; end;
+      if (y+s >= h) or (y+s <= 0) then begin die(); break; end;
 
       (*
       if not isLiquidAt(X, Y+s) {ByteBool(gCollideMap[Y+s, X] and MARK_LIQUID)} then
@@ -1027,16 +1341,16 @@ begin
       end;
       *)
       // we traced liquid before, so don't bother checking
-      if (Y+s <= liquidTopY) then begin die(); break; end;
+      if (y+s <= liquidTopY) then begin die(); break; end;
 
-      Y := Y+s;
+      y := y+s;
     end;
   end;
 
-  if VelY > -4 then
-    VelY := VelY + AccelY;
+  if velY > -4 then
+    velY := velY + accelY;
 
-  Time := Time + 1;
+  time := time + 1;
 end;
 
 
@@ -1048,6 +1362,8 @@ var
   DevY1, DevY2: Byte;
   l: Integer;
 begin
+  exit;
+  if not gpart_dbg_enabled then Exit;
   l := Length(Particles);
   if l = 0 then exit;
   if Count > l then Count := l;
@@ -1061,32 +1377,33 @@ begin
   begin
     with Particles[CurrentParticle] do
     begin
-      X := fX-DevX1+Random(DevX2);
-      Y := fY-DevY1+Random(DevY2);
+      x := fX-DevX1+Random(DevX2);
+      y := fY-DevY1+Random(DevY2);
 
-      VelX := VX + (Random-Random)*3;
-      VelY := VY + (Random-Random)*3;
+      velX := VX + (Random-Random)*3;
+      velY := VY + (Random-Random)*3;
 
-      if VelY > -4 then
-        if VelY-4 < -4 then
-          VelY := -4
+      if velY > -4 then
+        if velY-4 < -4 then
+          velY := -4
         else
-          VelY := VelY-4;
-
-      AccelX := -Sign(VelX)*Random/100;
-      AccelY := 0.8;
-
-      Red := 255;
-      Green := 100+Random(155);
-      Blue := 64;
-      Alpha := 255;
-
-      State := STATE_NORMAL;
-      Time := 0;
-      LiveTime := 30+Random(60);
-      ParticleType := PARTICLE_SPARK;
-
-      {CorrectOffsets(CurrentParticle);}
+          velY := velY-4;
+
+      accelX := -Sign(velX)*Random/100;
+      accelY := 0.8;
+
+      red := 255;
+      green := 100+Random(155);
+      blue := 64;
+      alpha := 255;
+
+      state := TPartState.Normal;
+      time := 0;
+      liveTime := 30+Random(60);
+      particleType := TPartType.Spark;
+      justSticked := false;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+      awaken := false;
     end;
 
     if CurrentParticle+2 > MaxParticles then
@@ -1097,103 +1414,6 @@ begin
 end;
 
 
-procedure g_GFX_Blood(fX, fY: Integer; Count: Word; vx, vy: Integer;
-  DevX, DevY: Word; CR, CG, CB: Byte; Kind: Byte = BLOOD_NORMAL);
-var
-  a: Integer;
-  DevX1, DevX2,
-  DevY1, DevY2: Word;
-  l: Integer;
-  CRnd: Byte;
-  CC: SmallInt;
-begin
-  if Kind = BLOOD_SPARKS then
-  begin
-    g_GFX_SparkVel(fX, fY, 2 + Random(2), -VX div 2, -VY div 2, DevX, DevY);
-    Exit;
-  end;
-  l := Length(Particles);
-  if l = 0 then
-    Exit;
-  if Count > l then
-    Count := l;
-
-  DevX1 := DevX div 2;
-  DevX2 := DevX + 1;
-  DevY1 := DevY div 2;
-  DevY2 := DevY + 1;
-
-  for a := 1 to Count do
-  begin
-    with Particles[CurrentParticle] do
-    begin
-      X := fX - DevX1 + Random(DevX2);
-      Y := fY - DevY1 + Random(DevY2);
-
-      {
-      if (X < 0) or (X > gMapInfo.Width-1) or
-         (Y < 0) or (Y > gMapInfo.Height-1) or
-         ByteBool(gCollideMap[Y, X] and MARK_WALL) then
-        Continue;
-      }
-      if isWallAt(X, Y) then continue;
-
-      VelX := vx + (Random-Random)*3;
-      VelY := vy + (Random-Random)*3;
-
-      if VelY > -4 then
-        if VelY-4 < -4 then
-          VelY := -4
-        else
-          VelY := VelY-4;
-
-      AccelX := -Sign(VelX)*Random/100;
-      AccelY := 0.8;
-
-      CRnd := 20*Random(6);
-      if CR > 0 then
-      begin
-        CC := CR + CRnd - 50;
-        if CC < 0   then CC := 0;
-        if CC > 255 then CC := 255;
-        Red := CC;
-      end else
-        Red := 0;
-      if CG > 0 then
-      begin
-        CC := CG + CRnd - 50;
-        if CC < 0   then CC := 0;
-        if CC > 255 then CC := 255;
-        Green := CC;
-      end else
-        Green := 0;
-      if CB > 0 then
-      begin
-        CC := CB + CRnd - 50;
-        if CC < 0   then CC := 0;
-        if CC > 255 then CC := 255;
-        Blue := CC;
-      end else
-        Blue := 0;
-
-      Alpha := 255;
-
-      State := STATE_NORMAL;
-      Time := 0;
-      LiveTime := 120+Random(40);
-      ParticleType := PARTICLE_BLOOD;
-
-      {CorrectOffsets(CurrentParticle);}
-    end;
-
-    if CurrentParticle >= MaxParticles-1 then
-      CurrentParticle := 0
-    else
-      CurrentParticle := CurrentParticle+1;
-  end;
-end;
-
-
 procedure g_GFX_Spark(fX, fY: Integer; Count: Word; Angle: SmallInt; DevX, DevY: Byte);
 var
   a: Integer;
@@ -1203,6 +1423,8 @@ var
   BaseVelX, BaseVelY: Single;
   l: Integer;
 begin
+  exit;
+  if not gpart_dbg_enabled then Exit;
   l := Length(Particles);
   if l = 0 then
     Exit;
@@ -1227,25 +1449,26 @@ begin
   begin
     with Particles[CurrentParticle] do
     begin
-      X := fX-DevX1+Random(DevX2);
-      Y := fY-DevY1+Random(DevY2);
-
-      VelX := BaseVelX*Random;
-      VelY := BaseVelY-Random;
-      AccelX := VelX/3.0;
-      AccelY := VelY/5.0;
-
-      Red := 255;
-      Green := 100+Random(155);
-      Blue := 64;
-      Alpha := 255;
-
-      State := STATE_NORMAL;
-      Time := 0;
-      LiveTime := 30+Random(60);
-      ParticleType := PARTICLE_SPARK;
-
-      {CorrectOffsets(CurrentParticle);}
+      x := fX-DevX1+Random(DevX2);
+      y := fY-DevY1+Random(DevY2);
+
+      velX := BaseVelX*Random;
+      velY := BaseVelY-Random;
+      accelX := velX/3.0;
+      accelY := velY/5.0;
+
+      red := 255;
+      green := 100+Random(155);
+      blue := 64;
+      alpha := 255;
+
+      state := TPartState.Normal;
+      time := 0;
+      liveTime := 30+Random(60);
+      particleType := TPartType.Spark;
+      justSticked := false;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+      awaken := false;
     end;
 
     if CurrentParticle+2 > MaxParticles then
@@ -1255,6 +1478,7 @@ begin
   end;
 end;
 
+
 procedure g_GFX_Water(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DevX, DevY, Color: Byte);
 var
   a: Integer;
@@ -1262,6 +1486,8 @@ var
   DevY1, DevY2: Byte;
   l: Integer;
 begin
+  exit;
+  if not gpart_dbg_enabled then Exit;
   l := Length(Particles);
   if l = 0 then
     Exit;
@@ -1280,54 +1506,55 @@ begin
   begin
     with Particles[CurrentParticle] do
     begin
-      X := fX-DevX1+Random(DevX2);
-      Y := fY-DevY1+Random(DevY2);
+      x := fX-DevX1+Random(DevX2);
+      y := fY-DevY1+Random(DevY2);
 
       if Abs(fVelX) < 0.5 then
-        VelX := 1.0 - 2.0*Random
+        velX := 1.0 - 2.0*Random
       else
-        VelX := fVelX*Random;
+        velX := fVelX*Random;
       if Random(10) < 7 then
-        VelX := -VelX;
-      VelY := fVelY*Random;
-      AccelX := 0.0;
-      AccelY := 0.8;
+        velX := -velX;
+      velY := fVelY*Random;
+      accelX := 0.0;
+      accelY := 0.8;
 
       case Color of
         1: // Êðàñíûé
           begin
-            Red := 155 + Random(9)*10;
-            Green := Trunc(150*Random);
-            Blue := Green;
+            red := 155 + Random(9)*10;
+            green := Trunc(150*Random);
+            blue := green;
           end;
         2: // Çåëåíûé
           begin
-            Red := Trunc(150*Random);
-            Green := 175 + Random(9)*10;
-            Blue := Red;
+            red := Trunc(150*Random);
+            green := 175 + Random(9)*10;
+            blue := red;
           end;
         3: // Ñèíèé
           begin
-            Red := Trunc(200*Random);
-            Green := Red;
-            Blue := 175 + Random(9)*10;
+            red := Trunc(200*Random);
+            green := red;
+            blue := 175 + Random(9)*10;
           end;
         else // Ñåðûé
           begin
-            Red := 90 + Random(12)*10;
-            Green := Red;
-            Blue := Red;
+            red := 90 + Random(12)*10;
+            green := red;
+            blue := red;
           end;
       end;
 
-      Alpha := 255;
+      alpha := 255;
 
-      State := STATE_NORMAL;
-      Time := 0;
-      LiveTime := 60+Random(60);
-      ParticleType := PARTICLE_WATER;
-
-      {CorrectOffsets(CurrentParticle);}
+      state := TPartState.Normal;
+      time := 0;
+      liveTime := 60+Random(60);
+      particleType := TPartType.Water;
+      justSticked := false;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+      awaken := false;
     end;
 
     if CurrentParticle+2 > MaxParticles then
@@ -1337,11 +1564,14 @@ begin
   end;
 end;
 
+
 procedure g_GFX_SimpleWater(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DefColor, CR, CG, CB: Byte);
 var
   a: Integer;
   l: Integer;
 begin
+  exit;
+  if not gpart_dbg_enabled then Exit;
   l := Length(Particles);
   if l = 0 then
     Exit;
@@ -1352,67 +1582,68 @@ begin
   begin
     with Particles[CurrentParticle] do
     begin
-      X := fX;
-      Y := fY;
+      x := fX;
+      y := fY;
 
-      VelX := fVelX;
-      VelY := fVelY;
-      AccelX := 0.0;
-      AccelY := 0.8;
+      velX := fVelX;
+      velY := fVelY;
+      accelX := 0.0;
+      accelY := 0.8;
 
       case DefColor of
         1: // Êðàñíûé
           begin
-            Red := 155 + Random(9)*10;
-            Green := Trunc(150*Random);
-            Blue := Green;
+            red := 155 + Random(9)*10;
+            green := Trunc(150*Random);
+            blue := green;
           end;
         2: // Çåëåíûé
           begin
-            Red := Trunc(150*Random);
-            Green := 175 + Random(9)*10;
-            Blue := Red;
+            red := Trunc(150*Random);
+            green := 175 + Random(9)*10;
+            blue := red;
           end;
         3: // Ñèíèé
           begin
-            Red := Trunc(200*Random);
-            Green := Red;
-            Blue := 175 + Random(9)*10;
+            red := Trunc(200*Random);
+            green := red;
+            blue := 175 + Random(9)*10;
           end;
         4: // Ñâîé öâåò, ñâåòëåå
           begin
-            Red := 20 + Random(19)*10;
-            Green := Red;
-            Blue := Red;
-            Red := Min(Red + CR, 255);
-            Green := Min(Green + CG, 255);
-            Blue := Min(Blue + CB, 255);
+            red := 20 + Random(19)*10;
+            green := red;
+            blue := red;
+            red := Min(red + CR, 255);
+            green := Min(green + CG, 255);
+            blue := Min(blue + CB, 255);
           end;
         5: // Ñâîé öâåò, òåìíåå
           begin
-            Red := 20 + Random(19)*10;
-            Green := Red;
-            Blue := Red;
-            Red := Max(CR - Red, 0);
-            Green := Max(CG - Green, 0);
-            Blue := Max(CB - Blue, 0);
+            red := 20 + Random(19)*10;
+            green := red;
+            blue := red;
+            red := Max(CR - red, 0);
+            green := Max(CG - green, 0);
+            blue := Max(CB - blue, 0);
           end;
         else // Ñåðûé
           begin
-            Red := 90 + Random(12)*10;
-            Green := Red;
-            Blue := Red;
+            red := 90 + Random(12)*10;
+            green := red;
+            blue := red;
           end;
       end;
 
-      Alpha := 255;
+      alpha := 255;
 
-      State := STATE_NORMAL;
-      Time := 0;
-      LiveTime := 60+Random(60);
-      ParticleType := PARTICLE_WATER;
-
-      {CorrectOffsets(CurrentParticle);}
+      state := TPartState.Normal;
+      time := 0;
+      liveTime := 60+Random(60);
+      particleType := TPartType.Water;
+      justSticked := false;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+      awaken := false;
     end;
 
     if CurrentParticle+2 > MaxParticles then
@@ -1423,13 +1654,20 @@ begin
 end;
 
 
+{.$DEFINE D2F_DEBUG_BUBBLES}
 procedure g_GFX_Bubbles(fX, fY: Integer; Count: Word; DevX, DevY: Byte);
 var
   a: Integer;
   DevX1, DevX2,
   DevY1, DevY2: Byte;
   l, liquidx: Integer;
+  {$IF DEFINED(D2F_DEBUG_BUBBLES)}
+  stt: UInt64;
+  nptr, ptr: Boolean;
+  {$ENDIF}
 begin
+  exit;
+  if not gpart_dbg_enabled then Exit;
   l := Length(Particles);
   if l = 0 then
     Exit;
@@ -1445,11 +1683,11 @@ begin
   begin
     with Particles[CurrentParticle] do
     begin
-      X := fX-DevX1+Random(DevX2);
-      Y := fY-DevY1+Random(DevY2);
+      x := fX-DevX1+Random(DevX2);
+      y := fY-DevY1+Random(DevY2);
 
-      if (X >= gMapInfo.Width) or (X <= 0) or
-         (Y >= gMapInfo.Height) or (Y <= 0) then
+      if (x >= gMapInfo.Width) or (x <= 0) or
+         (y >= gMapInfo.Height) or (y <= 0) then
         Continue;
 
       (*
@@ -1460,24 +1698,39 @@ begin
 
       // trace liquid, so we'll know where it ends; do it in 8px steps for speed
       // tracer will return `false` if we started outside of the liquid
-      if not g_Map_TraceLiquidNonPrecise(X, Y, 0, -8, liquidx, liquidTopY) then continue;
-
-      VelX := 0;
-      VelY := -1-Random;
-      AccelX := 0;
-      AccelY := VelY/10;
 
-      Red := 255;
-      Green := 255;
-      Blue := 255;
-      Alpha := 255;
-
-      State := STATE_NORMAL;
-      Time := 0;
-      LiveTime := 65535;
-      ParticleType := PARTICLE_BUBBLES;
+      {$IF DEFINED(D2F_DEBUG_BUBBLES)}
+      stt := curTimeMicro();
+      ptr := mapGrid.traceOrthoRayWhileIn(liquidx, liquidTopY, x, y, x, 0, GridTagWater or GridTagAcid1 or GridTagAcid2);
+      stt := curTimeMicro()-stt;
+      e_LogWritefln('traceOrthoRayWhileIn: time=%s (%s); liquidTopY=%s', [Integer(stt), ptr, liquidTopY]);
+      //
+      stt := curTimeMicro();
+      nptr := g_Map_TraceLiquidNonPrecise(x, y, 0, -8, liquidx, liquidTopY);
+      stt := curTimeMicro()-stt;
+      e_LogWritefln('g_Map_TraceLiquidNonPrecise: time=%s (%s); liquidTopY=%s', [Integer(stt), nptr, liquidTopY]);
+      if not nptr then continue;
+      {$ELSE}
+      if not g_Map_TraceLiquidNonPrecise(x, y, 0, -8, liquidx, liquidTopY) then continue;
+      {$ENDIF}
 
-      {CorrectOffsets(CurrentParticle);}
+      velX := 0;
+      velY := -1-Random;
+      accelX := 0;
+      accelY := velY/10;
+
+      red := 255;
+      green := 255;
+      blue := 255;
+      alpha := 255;
+
+      state := TPartState.Normal;
+      time := 0;
+      liveTime := 65535;
+      particleType := TPartType.Bubbles;
+      justSticked := false;
+      onGround := (velY >= 0) and g_Map_HasAnyPanelAtPoint(x, y+1, (PANEL_WALL or PANEL_CLOSEDOOR or PANEL_STEP));
+      awaken := false;
     end;
 
     if CurrentParticle+2 > MaxParticles then
@@ -1487,6 +1740,8 @@ begin
   end;
 end;
 
+
+// ////////////////////////////////////////////////////////////////////////// //
 procedure g_GFX_SetMax(Count: Integer);
 var
   a: Integer;
@@ -1501,12 +1756,14 @@ begin
     CurrentParticle := 0;
 end;
 
+
 function g_GFX_GetMax(): Integer;
 begin
   Result := MaxParticles;
 end;
 
-function FindOnceAnim: DWORD;
+
+function FindOnceAnim (): DWORD;
 var
   i: Integer;
 begin
@@ -1530,10 +1787,12 @@ begin
     end;
 end;
 
-procedure g_GFX_OnceAnim(X, Y: Integer; Anim: TAnimation; AnimType: Byte = 0);
+
+procedure g_GFX_OnceAnim (x, y: Integer; Anim: TAnimation; AnimType: Byte = 0);
 var
   find_id: DWORD;
 begin
+  if not gpart_dbg_enabled then Exit;
   if Anim = nil then
     Exit;
 
@@ -1542,19 +1801,21 @@ begin
   OnceAnims[find_id].AnimType := AnimType;
   OnceAnims[find_id].Animation := TAnimation.Create(Anim.FramesID, Anim.Loop, Anim.Speed);
   OnceAnims[find_id].Animation.Blending := Anim.Blending;
-  OnceAnims[find_id].Animation.Alpha := Anim.Alpha;
-  OnceAnims[find_id].X := X;
-  OnceAnims[find_id].Y := Y;
+  OnceAnims[find_id].Animation.alpha := Anim.alpha;
+  OnceAnims[find_id].x := x;
+  OnceAnims[find_id].y := y;
 end;
 
-procedure g_GFX_Update();
+
+procedure g_GFX_Update ();
 var
   a: Integer;
   w, h: Integer;
   len: Integer;
 begin
   if not gpart_dbg_enabled then exit;
-  if Particles <> nil then
+
+  if (Particles <> nil) then
   begin
     w := gMapInfo.Width;
     h := gMapInfo.Height;
@@ -1567,17 +1828,19 @@ begin
       begin
         with Particles[a] do
         begin
-          if (Time = LiveTime) then begin die(); continue; end;
-          if (X+1 >= w) or (Y+1 >= h) or (X <= 0) or (Y <= 0) then begin die(); end;
+          if (time = liveTime) then begin die(); continue; end;
+          if (x+1 >= w) or (y+1 >= h) or (x <= 0) or (y <= 0) then begin die(); end;
           //if not alive then Continue;
           //e_WriteLog(Format('particle #%d: %d', [State, ParticleType]), MSG_NOTIFY);
           think();
-          {CorrectOffsets(a);}
         end; // with
       end; // if
     end; // for
   end; // Particles <> nil
 
+  // clear awake map
+  awmClear();
+
   if OnceAnims <> nil then
   begin
     for a := 0 to High(OnceAnims) do
@@ -1587,9 +1850,9 @@ begin
           ONCEANIM_SMOKE:
             begin
               if Random(3) = 0 then
-                OnceAnims[a].X := OnceAnims[a].X-1+Random(3);
+                OnceAnims[a].x := OnceAnims[a].x-1+Random(3);
               if Random(2) = 0 then
-                OnceAnims[a].Y := OnceAnims[a].Y-Random(2);
+                OnceAnims[a].y := OnceAnims[a].y-Random(2);
             end;
         end;
 
@@ -1604,7 +1867,8 @@ begin
   end;
 end;
 
-procedure g_GFX_Draw();
+
+procedure g_GFX_Draw ();
 var
   a, len: Integer;
 begin
@@ -1622,10 +1886,10 @@ begin
 
     for a := 0 to len do
       with Particles[a] do
-        if alive and (X >= sX) and (Y >= sY) and (X <= sX+sWidth) and (sY <= sY+sHeight) then
+        if alive and (x >= sX) and (y >= sY) and (x <= sX+sWidth) and (sY <= sY+sHeight) then
         begin
-          glColor4ub(Red, Green, Blue, Alpha);
-          glVertex2i(X + offsetX, Y + offsetY);
+          glColor4ub(red, green, blue, alpha);
+          glVertex2i(x + offsetX, y + offsetY);
         end;
 
     glEnd();
@@ -1637,7 +1901,8 @@ begin
     for a := 0 to High(OnceAnims) do
       if OnceAnims[a].Animation <> nil then
         with OnceAnims[a] do
-          Animation.Draw(X, Y, M_NONE);
+          Animation.Draw(x, y, M_NONE);
 end;
 
+
 end.