src/game/g_gfx.pas

   1 (* Copyright (C)  DooM 2D:Forever Developers
   2  *
   3  * This program is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *)
  16 {$INCLUDE ../shared/a_modes.inc}
  17 unit g_gfx;
  18
  19 interface
  20
  21 uses
  22   e_log, g_textures;
  23
  24 const
  25   BLOOD_NORMAL = 0;
  26   BLOOD_SPARKS = 1;
  27
  28   ONCEANIM_NONE  = 0;
  29   ONCEANIM_SMOKE = 1;
  30
  31   MARK_FREE     = 0;
  32   MARK_WALL     = 1;
  33   MARK_WATER    = 2;
  34   MARK_ACID     = 4;
  35   MARK_LIFTDOWN = 8;
  36   MARK_LIFTUP   = 16;
  37   MARK_DOOR     = 32;
  38   MARK_LIFTLEFT  = 64;
  39   MARK_LIFTRIGHT = 128;
  40   MARK_BLOCKED  = MARK_WALL or MARK_DOOR;
  41   MARK_LIQUID   = MARK_WATER or MARK_ACID;
  42   MARK_LIFT     = MARK_LIFTDOWN or MARK_LIFTUP or MARK_LIFTLEFT or MARK_LIFTRIGHT;
  43
  44
  45 procedure g_GFX_Init ();
  46 procedure g_GFX_Free ();
  47
  48 procedure g_GFX_Blood (fX, fY: Integer; count: Word; vx, vy: Integer;
  49                        devX, devY: Word; cr, cg, cb: Byte; kind: Byte=BLOOD_NORMAL);
  50 procedure g_GFX_Spark (fX, fY: Integer; count: Word; angle: SmallInt; devX, devY: Byte);
  51 procedure g_GFX_Water (fX, fY: Integer; count: Word; fVelX, fVelY: Single; devX, devY, color: Byte;
  52                        simple: Boolean=false; cr: Byte=0; cg: Byte=0; cb: Byte=0);
  53 procedure g_GFX_SimpleWater (fX, fY: Integer; count: Word; fVelX, fVelY: Single; defColor, cr, cg, cb: Byte);
  54 procedure g_GFX_Bubbles (fX, fY: Integer; count: Word; devX, devY: Byte);
  55
  56 procedure g_GFX_SetMax (count: Integer);
  57 function  g_GFX_GetMax (): Integer;
  58
  59 procedure g_GFX_OnceAnim (X, Y: Integer; Anim: TAnimation; AnimType: Byte = 0);
  60
  61 procedure g_Mark (x, y, Width, Height: Integer; t: Byte; st: Boolean=true);
  62
  63 procedure g_GFX_Update ();
  64 procedure g_GFX_Draw ();
  65
  66
  67 var
  68   gpart_dbg_enabled: Boolean = true;
  69   gpart_dbg_phys_enabled: Boolean = true;
  70
  71
  72 implementation
  73
  74 uses
  75   g_map, g_panel, g_basic, Math, e_graphics, GL, GLExt,
  76   g_options, g_console, SysUtils, g_triggers, MAPDEF,
  77   g_game, g_language, g_net, utils, xprofiler;
  78
  79
  80 const
  81   Unknown = Integer($7fffffff);
  82
  83
  84 type
  85   TPartType = (Blood, Spark, Bubbles, Water);
  86   TPartState = (Free, Normal, Stuck, Sleeping);
  87   TFloorType = (Wall, LiquidIn, LiquidOut);
  88     // Wall: floorY is just before floor
  89     // LiquidIn: floorY is liquid *start* (i.e. just in a liquid)
  90     // LiquidOut: floorY is liquid *end* (i.e. just out of a liquid)
  91   TEnvType = (EAir, ELiquid, EWall); // where particle is now
  92
  93   // note: this MUST be record, so we can keep it in
  94   // dynamic array and has sequential memory access pattern
  95   PParticle = ^TParticle;
  96   TParticle = record
  97     x, y: Integer;
  98     velX, velY: Single;
  99     accelX, accelY: Single;
 100     state: TPartState;
 101     particleType: TPartType;
 102     red, green, blue: Byte;
 103     alpha: Byte;
 104     time, liveTime: Word;
 105     stickDX: Integer; // STATE_STICK: -1,1: stuck to a wall; 0: stuck to ceiling
 106     justSticked: Boolean; // not used
 107     floorY: Integer; // actually, floor-1; `Unknown`: unknown
 108     floorType: TFloorType;
 109     env: TEnvType; // where particle is now
 110     ceilingY: Integer; // actually, ceiling+1; `Unknown`: unknown
 111     wallEndY: Integer; // if we stuck to a wall, this is where wall ends
 112
 113     //k8: sorry, i have to emulate virtual methods this way, 'cause i haet `Object`
 114     procedure thinkerBloodAndWater ();
 115     procedure thinkerSpark ();
 116     procedure thinkerBubble ();
 117
 118     procedure findFloor (force: Boolean=false); // this updates `floorY` if forced or Unknown
 119     procedure findCeiling (force: Boolean=false); // this updates `ceilingY` if forced or Unknown
 120
 121     procedure freeze (); inline; // remove velocities and acceleration
 122     procedure sleep (); inline; // switch to sleep mode
 123
 124     function alive (): Boolean; inline;
 125     procedure die (); inline;
 126     procedure think (); inline;
 127   end;
 128
 129   TOnceAnim = record
 130     AnimType:   Byte;
 131     x, y:       Integer;
 132     Animation:  TAnimation;
 133   end;
 134
 135
 136 var
 137   Particles: array of TParticle = nil;
 138   OnceAnims: array of TOnceAnim = nil;
 139   MaxParticles: Integer = 0;
 140   CurrentParticle: Integer = 0;
 141   // awakeMap has one bit for each map grid cell; on g_Mark,
 142   // corresponding bits will be set, and in `think()` all particles
 143   // in marked cells will be awaken
 144   awakeMap: packed array of LongWord = nil;
 145   awakeMapH: Integer = -1;
 146   awakeMapW: Integer = -1;
 147   awakeMinX, awakeMinY: Integer;
 148   awakeDirty: Boolean = false;
 149
 150
 151 // ////////////////////////////////////////////////////////////////////////// //
 152 // HACK! using mapgrid
 153 procedure awmClear (); inline;
 154 begin
 155   if awakeDirty and (awakeMapW > 0) then
 156   begin
 157     FillDWord(awakeMap[0], Length(awakeMap), 0);
 158     awakeDirty := false;
 159   end;
 160 end;
 161
 162
 163 procedure awmSetup ();
 164 begin
 165   assert(mapGrid <> nil);
 166   awakeMapW := (mapGrid.gridWidth+mapGrid.tileSize-1) div mapGrid.tileSize;
 167   awakeMapW := (awakeMapW+31) div 32; // LongWord has 32 bits ;-)
 168   awakeMapH := (mapGrid.gridHeight+mapGrid.tileSize-1) div mapGrid.tileSize;
 169   awakeMinX := mapGrid.gridX0;
 170   awakeMinY := mapGrid.gridY0;
 171   SetLength(awakeMap, awakeMapW*awakeMapH);
 172   {$IF DEFINED(D2F_DEBUG)}
 173   e_LogWritefln('particle awake map: %sx%s (for grid of size %sx%s)', [awakeMapW, awakeMapH, mapGrid.gridWidth, mapGrid.gridHeight]);
 174   {$ENDIF}
 175   awakeDirty := true;
 176   awmClear();
 177 end;
 178
 179
 180 function awmIsSet (x, y: Integer): Boolean; inline;
 181 begin
 182   x := (x-awakeMinX) div mapGrid.tileSize;
 183   y := (y-awakeMinY) div mapGrid.tileSize;
 184   if (x >= 0) and (y >= 0) and (x div 32 < awakeMapW) and (y < awakeMapH) then
 185   begin
 186     {$IF DEFINED(D2F_DEBUG)}
 187     assert(y*awakeMapW+x div 32 < Length(awakeMap));
 188     {$ENDIF}
 189     result := ((awakeMap[y*awakeMapW+x div 32] and (LongWord(1) shl (x mod 32))) <> 0);
 190   end
 191   else
 192   begin
 193     result := false;
 194   end;
 195 end;
 196
 197
 198 procedure awmSet (x, y: Integer); inline;
 199 var
 200   v: PLongWord;
 201 begin
 202   x := (x-awakeMinX) div mapGrid.tileSize;
 203   y := (y-awakeMinY) div mapGrid.tileSize;
 204   if (x >= 0) and (y >= 0) and (x div 32 < awakeMapW) and (y < awakeMapH) then
 205   begin
 206     {$IF DEFINED(D2F_DEBUG)}
 207     assert(y*awakeMapW+x div 32 < Length(awakeMap));
 208     {$ENDIF}
 209     v := @awakeMap[y*awakeMapW+x div 32];
 210     v^ := v^ or (LongWord(1) shl (x mod 32));
 211     awakeDirty := true;
 212   end;
 213 end;
 214
 215
 216 // ////////////////////////////////////////////////////////////////////////// //
 217 function TParticle.alive (): Boolean; inline; begin result := (state <> TPartState.Free); end;
 218 procedure TParticle.die (); inline; begin state := TPartState.Free; end;
 219
 220 // remove velocities and acceleration
 221 procedure TParticle.freeze (); inline;
 222 begin
 223   // stop right there, you criminal scum!
 224   velX := 0;
 225   velY := 0;
 226   accelX := 0;
 227   accelY := 0;
 228 end;
 229
 230
 231 // switch to sleep mode
 232 procedure TParticle.sleep (); inline;
 233 begin
 234   state := TPartState.Sleeping;
 235   freeze();
 236 end;
 237
 238
 239 procedure TParticle.findFloor (force: Boolean=false);
 240 var
 241   ex: Integer;
 242   pan: TPanel;
 243 begin
 244   if (not force) and (floorY <> Unknown) then exit;
 245   // stuck in the wall? rescan, 'cause it can be mplat
 246   if (env = TEnvType.EWall) then
 247   begin
 248     pan := g_Map_PanelAtPoint(x, y, (GridTagObstacle or GridTagLiquid));
 249     if (pan <> nil) then
 250     begin
 251       // either in a wall, or in a liquid
 252       if ((pan.tag and GridTagObstacle) <> 0) then
 253       begin
 254         // we are in the wall, wtf?!
 255         floorY := y;
 256         env := TEnvType.EWall;
 257         floorType := TFloorType.Wall;
 258         state := TPartState.Sleeping; // anyway
 259         exit;
 260       end;
 261       // we are in liquid, trace to liquid end
 262       env := TEnvType.ELiquid;
 263     end;
 264   end;
 265   // are we in a liquid?
 266   if (env = TEnvType.ELiquid) then
 267   begin
 268     // trace out of the liquid
 269     //env := TEnvType.ELiquid;
 270     floorType := TFloorType.LiquidOut;
 271     //e_LogWritefln('tracing out of a liquid; floorY=%s; y=%s', [floorY, y]);
 272     mapGrid.traceOrthoRayWhileIn(ex, floorY, x, y, x, g_Map_MaxY, GridTagLiquid);
 273     floorY += 1; // so `floorY` is just out of a liquid
 274     //e_LogWritefln('  traced out of a liquid; floorY=%s; y=%s', [floorY, y]);
 275   end
 276   else
 277   begin
 278     // in the air
 279     assert(env = TEnvType.EAir);
 280     //env := TEnvType.EAir;
 281     pan := g_Map_traceToNearest(x, y, x, g_Map_MaxY, (GridTagObstacle or GridTagLiquid), @ex, @floorY);
 282     if (pan <> nil) then
 283     begin
 284       // wall or liquid
 285       if ((pan.tag and GridTagObstacle) <> 0) then
 286       begin
 287         // wall
 288         floorType := TFloorType.Wall;
 289       end
 290       else
 291       begin
 292         // liquid
 293         floorType := TFloorType.LiquidIn; // entering liquid
 294         floorY += 1; // so `floorY` is just in a liquid
 295       end;
 296     end
 297     else
 298     begin
 299       // out of the level; assume wall, but it doesn't really matter
 300       floorType := TFloorType.Wall;
 301       floorY := g_Map_MaxY+2;
 302     end;
 303   end;
 304 end;
 305
 306
 307 procedure TParticle.findCeiling (force: Boolean=false);
 308 var
 309   ex: Integer;
 310 begin
 311   if (not force) and (ceilingY <> Unknown) then exit;
 312   if (nil = g_Map_traceToNearest(x, y, x, g_Map_MinY, GridTagObstacle, @ex, @ceilingY)) then
 313   begin
 314     ceilingY := g_Map_MinY-2;
 315   end;
 316 end;
 317
 318
 319 procedure TParticle.think (); inline;
 320 begin
 321   // awake sleeping particle, if necessary
 322   if awakeDirty then
 323   begin
 324     case state of
 325       TPartState.Sleeping, TPartState.Stuck:
 326         if awmIsSet(x, y) then
 327         begin
 328           state := TPartState.Normal;
 329           floorY := Unknown;
 330           ceilingY := Unknown;
 331           if (velY = 0) then velY := 0.1;
 332           if (accelY = 0) then accelY := 0.5;
 333         end;
 334     end;
 335   end;
 336   case particleType of
 337     TPartType.Blood, TPartType.Water: thinkerBloodAndWater();
 338     TPartType.Spark: thinkerSpark();
 339     TPartType.Bubbles: thinkerBubble();
 340   end;
 341 end;
 342
 343
 344 // ////////////////////////////////////////////////////////////////////////// //
 345 procedure TParticle.thinkerBloodAndWater ();
 346   procedure stickToCeiling ();
 347   begin
 348     state := TPartState.Stuck;
 349     stickDX := 0;
 350     freeze();
 351     ceilingY := y; // yep
 352   end;
 353
 354   procedure stickToWall (dx: Integer);
 355   var
 356     ex: Integer;
 357   begin
 358     state := TPartState.Stuck;
 359     if (dX > 0) then stickDX := 1 else stickDX := -1;
 360     freeze();
 361     // find next floor transition
 362     findFloor();
 363     // find `wallEndY`
 364     mapGrid.traceOrthoRayWhileIn(ex, wallEndY, x+stickDX, y, x+stickDX, floorY+1, (GridTagWall or GridTagDoor or GridTagStep));
 365   end;
 366
 367   procedure hitAFloor ();
 368   begin
 369     state := TPartState.Sleeping; // we aren't moving anymore
 370     freeze();
 371     floorY := y; // yep
 372     floorType := TFloorType.Wall; // yep
 373   end;
 374
 375   // `true`: didn't, get outa thinker
 376   function drip (): Boolean;
 377   begin
 378     case particleType of
 379       TPartType.Blood: result := (Random(200) = 100);
 380       TPartType.Water: result := (Random(30) = 15);
 381       else raise Exception.Create('internal error in particle engine: drip');
 382     end;
 383     if result then begin velY := 0.5; accelY := 0.15; end;
 384   end;
 385
 386   // `true`: affected by air stream
 387   function checkAirStreams (): Boolean;
 388   var
 389     pan: TPanel;
 390   begin
 391     pan := g_Map_PanelAtPoint(x, y, GridTagLift);
 392     result := (pan <> nil);
 393     if result then
 394     begin
 395       if ((pan.PanelType and PANEL_LIFTUP) <> 0) then
 396       begin
 397         if (velY > -4-Random(3)) then velY -= 0.8;
 398         if (abs(velX) > 0.1) then velX -= velX/10.0;
 399         velX += (Random-Random)*0.2;
 400         accelY := 0.15;
 401       end
 402       else if ((pan.PanelType and PANEL_LIFTLEFT) <> 0) then
 403       begin
 404         if (velX > -8-Random(3)) then velX -= 0.8;
 405         accelY := 0.15;
 406       end
 407       else if ((pan.PanelType and PANEL_LIFTRIGHT) <> 0) then
 408       begin
 409         if (velX < 8+Random(3)) then velX += 0.8;
 410         accelY := 0.15;
 411       end
 412       else
 413       begin
 414         result := false;
 415       end;
 416       // awake
 417       if result and (state = TPartState.Sleeping) then state := TPartState.Normal;
 418     end;
 419   end;
 420
 421   // switch to freefall mode
 422   procedure freefall ();
 423   begin
 424     state := TPartState.Normal;
 425     velY := 0.5;
 426     accelY := 0.15;
 427   end;
 428
 429   procedure applyGravity (inLiquid: Boolean);
 430   begin
 431     state := TPartState.Normal;
 432     if (inLiquid) then
 433     begin
 434       velY := 0.5;
 435       accelY := 0.15;
 436     end
 437     else
 438     begin
 439       velY := 0.8;
 440       accelY := 0.5;
 441     end;
 442   end;
 443
 444 label
 445   _done;
 446 var
 447   pan: TPanel;
 448   dX, dY: SmallInt;
 449   ex, ey: Integer;
 450   checkEnv: Boolean;
 451 begin
 452   if not gpart_dbg_phys_enabled then goto _done;
 453
 454   if gAdvBlood then
 455   begin
 456     // still check for air streams when sleeping
 457     if (state = TPartState.Sleeping) then begin checkAirStreams(); goto _done; end; // so blood will dissolve
 458
 459     // process stuck particles
 460     if (state = TPartState.Stuck) then
 461     begin
 462       // stuck to a ceiling?
 463       if (stickDX = 0) then
 464       begin
 465         // yeah, stuck to a ceiling
 466         assert(ceilingY <> Unknown);
 467         // dropped from a ceiling?
 468         if (y > ceilingY) then
 469         begin
 470           // yep
 471           velY := 0.5;
 472           accelY := 0.15;
 473           state := TPartState.Normal;
 474         end
 475         else
 476         begin
 477           // otherwise, try to drip
 478           if drip() then goto _done;
 479         end;
 480       end
 481       else
 482       begin
 483         // stuck to a wall
 484         assert(wallEndY <> Unknown);
 485         // floor transition?
 486         if (wallEndY <= floorY) and (y >= floorY) then
 487         begin
 488           y := floorY;
 489           case floorType of
 490             TFloorType.Wall: // hit the ground
 491               begin
 492                 sleep();
 493                 goto _done; // nothing to do anymore
 494               end;
 495             TFloorType.LiquidIn: // entering the liquid
 496               begin
 497                 // rescan, so we'll know when we'll exit the liquid
 498                 findFloor(true); // force rescan
 499               end;
 500             TFloorType.LiquidOut: // exiting the liquid
 501               begin
 502                 // rescan, so we'll know when we'll enter something interesting
 503                 findFloor(true); // force rescan
 504                 if (floorType = TFloorType.Wall) and (floorY = y) then begin sleep(); goto _done; end;
 505               end;
 506           end;
 507         end;
 508         // wall transition?
 509         if (floorY <= wallEndY) and (y >= wallEndY) then
 510         begin
 511           // just unstuck from the wall, switch to freefall mode
 512           y := wallEndY;
 513           freefall();
 514         end
 515         else
 516         begin
 517           // otherwise, try to drip
 518           if drip() then goto _done;
 519         end;
 520       end;
 521       // nope, process as usual
 522     end;
 523
 524     // it is important to have it here
 525     dX := round(velX);
 526     dY := round(velY);
 527
 528     // gravity, if not stuck
 529     if (state <> TPartState.Stuck) and (abs(velX) < 0.1) and (abs(velY) < 0.1) then
 530     begin
 531       if (floorY = Unknown) then findFloor();
 532       // floor transition?
 533       if (y = floorY) then
 534       begin
 535         case floorType of
 536           TFloorType.Wall: // hit the ground
 537             begin
 538               // nothing to do
 539             end;
 540           TFloorType.LiquidIn: // entering the liquid
 541             begin
 542               // rescan, so we'll know when we'll exit the liquid
 543               findFloor(true); // force rescan
 544               applyGravity(true);
 545             end;
 546           TFloorType.LiquidOut: // exiting the liquid
 547             begin
 548               // rescan, so we'll know when we'll enter something interesting
 549               findFloor(true); // force rescan
 550               if (floorType <> TFloorType.Wall) or (floorY <> y) then applyGravity(floorType = TFloorType.LiquidIn);
 551             end;
 552         end;
 553       end
 554       else
 555       begin
 556         // looks like we're in the air
 557         applyGravity(false);
 558       end;
 559     end;
 560
 561     // trace movement
 562     if (dX <> 0) then
 563     begin
 564       // has some horizontal velocity
 565       pan := g_Map_traceToNearest(x, y, x+dX, y+dY, GridTagObstacle, @ex, @ey);
 566       checkEnv := (x <> ex);
 567       x := ex;
 568       y := ey;
 569       if checkEnv then
 570       begin
 571         // dunno yet
 572         floorY := Unknown;
 573         ceilingY := Unknown;
 574         // check environment (air/liquid)
 575         if (g_Map_PanelAtPoint(x, y, GridTagLiquid) <> nil) then env := TEnvType.ELiquid else env := TEnvType.EAir;
 576       end;
 577       if (pan <> nil) then
 578       begin
 579         // we stuck
 580         // the only case when we can have both ceiling and wall is corner; stick to wall in this case
 581         // check if we stuck to a wall
 582         if (dX < 0) then dX := -1 else dX := 1;
 583         if (g_Map_PanelAtPoint(x+dX, y, GridTagObstacle) <> nil) then
 584         begin
 585           // stuck to a wall
 586           stickToWall(dX);
 587         end
 588         else
 589         begin
 590           // stuck to a ceiling
 591           stickToCeiling();
 592         end;
 593       end;
 594     end
 595     else if (dY <> 0) then
 596     begin
 597       // has only vertical velocity
 598       if (dY < 0) then
 599       begin
 600         // flying up
 601         if (ceilingY = Unknown) then findCeiling(); // need to do this anyway
 602         y += dY;
 603         if (y <= ceilingY) then begin y := ceilingY; stickToCeiling(); end; // oops, hit a ceiling
 604         // environment didn't changed
 605       end
 606       else
 607       begin
 608         while (dY > 0) do
 609         begin
 610           // falling down
 611           if (floorY = Unknown) then findFloor(); // need to do this anyway
 612           if (floorType = TFloorType.LiquidOut) then env := TEnvType.ELiquid else env := TEnvType.EAir;
 613           y += dY;
 614           //e_LogWritefln('floorY=%s; newy=%s; dY=%s; floorType=%s', [floorY, y, dY, floorType]);
 615           if (y >= floorY) then
 616           begin
 617             // floor transition
 618             dY := y-floorY;
 619             y := floorY;
 620             //e_LogWritefln('  HIT FLOORY: floorY=%s; newy=%s; dY=%s; floorType=%s', [floorY, y, dY, floorType]);
 621             case floorType of
 622               TFloorType.Wall: // hit the ground
 623                 begin
 624                   // environment didn't changed
 625                   hitAFloor();
 626                   break; // done with vertical movement
 627                 end;
 628               TFloorType.LiquidIn: // entering the liquid
 629                 begin
 630                   // we're entered the liquid
 631                   env := TEnvType.ELiquid;
 632                   // rescan, so we'll know when we'll exit the liquid
 633                   findFloor(true); // force rescan
 634                 end;
 635               TFloorType.LiquidOut: // exiting the liquid
 636                 begin
 637                   // we're exited the liquid
 638                   env := TEnvType.EAir;
 639                   // rescan, so we'll know when we'll enter something interesting
 640                   findFloor(true); // force rescan
 641                   if (floorType = TFloorType.Wall) and (floorY = y) then
 642                   begin
 643                     hitAFloor();
 644                     break; // done with vertical movement
 645                   end;
 646                 end;
 647             end;
 648           end
 649           else
 650           begin
 651             break; // done with vertical movement
 652           end;
 653         end;
 654       end;
 655     end;
 656   end // if gAdvBlood
 657   else
 658   begin
 659     // simple blood
 660     dX := round(velX);
 661     dY := round(velY);
 662     y += dY;
 663     x += dX;
 664     if (g_Map_PanelAtPoint(x, y, GridTagObstacle) <> nil) then begin die(); exit; end;
 665   end;
 666
 667 _done:
 668   if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then begin die(); end;
 669
 670   velX += accelX;
 671   velY += accelY;
 672
 673   // blood will dissolve in other liquids
 674   if (particleType = TPartType.Blood) then
 675   begin
 676     if (env = TEnvType.ELiquid) then
 677     begin
 678       time += 1;
 679       if (liveTime <= 0) then begin die(); exit; end;
 680       ex := 255-trunc(255.0*time/liveTime);
 681       if (ex <= 10) then begin die(); exit; end;
 682       if (ex > 250) then ex := 255;
 683       alpha := Byte(ex);
 684     end;
 685   end
 686   else
 687   begin
 688     // water will disappear in any liquid
 689     if (env = TEnvType.ELiquid) then begin die(); exit; end;
 690     time += 1;
 691     // dry water
 692     if (liveTime <= 0) then begin die(); exit; end;
 693     ex := 255-trunc(255.0*time/liveTime);
 694     if (ex <= 10) then begin die(); exit; end;
 695     if (ex > 250) then ex := 255;
 696     alpha := Byte(ex);
 697   end;
 698 end;
 699
 700
 701 // ////////////////////////////////////////////////////////////////////////// //
 702 procedure g_GFX_SparkVel (fX, fY: Integer; count: Word; vx, vy: Integer; devX, devY: Byte); forward;
 703
 704 procedure g_GFX_Blood (fX, fY: Integer; count: Word; vx, vy: Integer;
 705                        devX, devY: Word; cr, cg, cb: Byte; kind: Byte = BLOOD_NORMAL);
 706
 707   function genColor (cbase, crnd: Integer; def: Byte=0): Byte;
 708   begin
 709     if (cbase > 0) then
 710     begin
 711       cbase += crnd;
 712            if (cbase < 0) then result := 0
 713       else if (cbase > 255) then result := 255
 714       else result := Byte(cbase);
 715     end
 716     else
 717     begin
 718       result := def;
 719     end;
 720   end;
 721
 722 var
 723   a: Integer;
 724   devX1, devX2, devY1, devY2: Integer;
 725   l: Integer;
 726   crnd: Integer;
 727   pan: TPanel;
 728 begin
 729   if not gpart_dbg_enabled then exit;
 730
 731   if (kind = BLOOD_SPARKS) then
 732   begin
 733     g_GFX_SparkVel(fX, fY, 2+Random(2), -vx div 2, -vy div 2, devX, devY);
 734     exit;
 735   end;
 736
 737   l := Length(Particles);
 738   if (l = 0) then exit;
 739   if (count > l) then count := l;
 740
 741   devX1 := devX div 2;
 742   devX2 := devX+1;
 743   devY1 := devY div 2;
 744   devY2 := devY+1;
 745
 746   for a := 1 to count do
 747   begin
 748     with Particles[CurrentParticle] do
 749     begin
 750       x := fX-devX1+Random(devX2);
 751       y := fY-devY1+Random(devY2);
 752
 753       // check for level bounds
 754       if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then continue;
 755
 756       // in what environment we are starting in?
 757       pan := g_Map_PanelAtPoint(x, y, (GridTagObstacle or GridTagLiquid));
 758       if (pan <> nil) then
 759       begin
 760         // either in a wall, or in a liquid
 761         if ((pan.tag and GridTagObstacle) <> 0) then continue; // don't spawn in walls
 762         env := TEnvType.ELiquid;
 763       end
 764       else
 765       begin
 766         env := TEnvType.EAir;
 767       end;
 768
 769       velX := vx+(Random-Random)*3;
 770       velY := vy+(Random-Random)*3;
 771
 772       if (velY > -4) then
 773       begin
 774         if (velY-4 < -4) then velY := -4 else velY := velY-4;
 775       end;
 776
 777       accelX := -sign(velX)*Random/100;
 778       accelY := 0.8;
 779
 780       crnd := 20*Random(6)-50;
 781
 782       red := genColor(cr, CRnd, 0);
 783       green := genColor(cg, CRnd, 0);
 784       blue := genColor(cb, CRnd, 0);
 785       alpha := 255;
 786
 787       particleType := TPartType.Blood;
 788       state := TPartState.Normal;
 789       time := 0;
 790       liveTime := 120+Random(40);
 791       floorY := Unknown;
 792       ceilingY := Unknown;
 793     end;
 794
 795     if (CurrentParticle >= MaxParticles-1) then CurrentParticle := 0 else CurrentParticle += 1;
 796   end;
 797 end;
 798
 799
 800 procedure g_GFX_Water (fX, fY: Integer; count: Word; fVelX, fVelY: Single; devX, devY, color: Byte;
 801                        simple: Boolean=false; cr: Byte=0; cg: Byte=0; cb: Byte=0);
 802 var
 803   a: Integer;
 804   devX1, devX2, devY1, devY2: Integer;
 805   l: Integer;
 806   pan: TPanel;
 807 begin
 808   if not gpart_dbg_enabled then exit;
 809
 810   l := Length(Particles);
 811   if (l = 0) then exit;
 812   if (count > l) then count := l;
 813
 814   if (abs(fVelX) < 3.0) then fVelX := 3.0-6.0*Random;
 815
 816   devX1 := devX div 2;
 817   devX2 := devX+1;
 818   devY1 := devY div 2;
 819   devY2 := devY+1;
 820
 821   if (not simple) and (color > 3) then color := 0;
 822
 823   for a := 1 to count do
 824   begin
 825     with Particles[CurrentParticle] do
 826     begin
 827       if not simple then
 828       begin
 829         x := fX-devX1+Random(devX2);
 830         y := fY-devY1+Random(devY2);
 831
 832         if (abs(fVelX) < 0.5) then velX := 1.0-2.0*Random else velX := fVelX*Random;
 833         if (Random(10) < 7) then velX := -velX;
 834         velY := fVelY*Random;
 835         accelX := 0.0;
 836         accelY := 0.8;
 837       end
 838       else
 839       begin
 840         x := fX;
 841         y := fY;
 842
 843         velX := fVelX;
 844         velY := fVelY;
 845         accelX := 0.0;
 846         accelY := 0.8;
 847       end;
 848
 849       // check for level bounds
 850       if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then continue;
 851
 852       // in what environment we are starting in?
 853       pan := g_Map_PanelAtPoint(x, y, (GridTagObstacle or GridTagLiquid));
 854       if (pan <> nil) then
 855       begin
 856         // either in a wall, or in a liquid
 857         //if ((pan.tag and GridTagObstacle) <> 0) then continue; // don't spawn in walls
 858         //env := TEnvType.ELiquid;
 859         continue;
 860       end
 861       else
 862       begin
 863         env := TEnvType.EAir;
 864       end;
 865
 866       // color
 867       case color of
 868         1: // reddish
 869           begin
 870             red := 155+Random(9)*10;
 871             green := trunc(150*Random);
 872             blue := green;
 873           end;
 874         2: // greenish
 875           begin
 876             red := trunc(150*Random);
 877             green := 175+Random(9)*10;
 878             blue := red;
 879           end;
 880         3: // bluish
 881           begin
 882             red := trunc(200*Random);
 883             green := red;
 884             blue := 175+Random(9)*10;
 885           end;
 886         4: // Ñâîé öâåò, ñâåòëåå
 887           begin
 888             red := 20+Random(19)*10;
 889             green := red;
 890             blue := red;
 891             red := nmin(red+cr, 255);
 892             green := nmin(green+cg, 255);
 893             blue := nmin(blue+cb, 255);
 894           end;
 895         5: // Ñâîé öâåò, òåìíåå
 896           begin
 897             red := 20+Random(19)*10;
 898             green := red;
 899             blue := red;
 900             red := nmax(cr-red, 0);
 901             green := nmax(cg-green, 0);
 902             blue := nmax(cb-blue, 0);
 903           end;
 904         else // grayish
 905           begin
 906             red := 90+random(12)*10;
 907             green := red;
 908             blue := red;
 909           end;
 910       end;
 911       alpha := 255;
 912
 913       particleType := TPartType.Water;
 914       state := TPartState.Normal;
 915       time := 0;
 916       liveTime := 60+Random(60);
 917       floorY := Unknown;
 918       ceilingY := Unknown;
 919     end;
 920
 921     if (CurrentParticle >= MaxParticles-1) then CurrentParticle := 0 else CurrentParticle += 1;
 922   end;
 923 end;
 924
 925
 926 procedure g_GFX_SimpleWater (fX, fY: Integer; count: Word; fVelX, fVelY: Single; defColor, cr, cg, cb: Byte);
 927 begin
 928   g_GFX_Water(fX, fY, count, 0, 0, 0, 0, defColor, true, cr, cg, cb);
 929 end;
 930
 931
 932 // ////////////////////////////////////////////////////////////////////////// //
 933 procedure TParticle.thinkerBubble ();
 934 var
 935   dY: Integer;
 936 begin
 937   dY := round(velY);
 938
 939   if (dY <> 0) then
 940   begin
 941     y += dY;
 942     if (dY < 0) then
 943     begin
 944       if (y <= ceilingY) then begin die(); exit; end;
 945     end
 946     else
 947     begin
 948       if (y >= floorY) then begin die(); exit; end;
 949     end;
 950     if (y < g_Map_MinY) or (y > g_Map_MaxY) then begin die(); exit; end;
 951   end;
 952
 953   if (velY > -4) then velY += accelY;
 954
 955   time += 1;
 956 end;
 957
 958
 959 {.$DEFINE D2F_DEBUG_BUBBLES}
 960 procedure g_GFX_Bubbles (fX, fY: Integer; count: Word; devX, devY: Byte);
 961 var
 962   a, liquidx: Integer;
 963   devX1, devX2, devY1, devY2: Integer;
 964   l: Integer;
 965   {$IF DEFINED(D2F_DEBUG_BUBBLES)}
 966   stt: UInt64;
 967   nptr, ptr: Boolean;
 968   {$ENDIF}
 969 begin
 970   if not gpart_dbg_enabled then exit;
 971
 972   l := Length(Particles);
 973   if (l = 0) then exit;
 974   if (count > l) then count := l;
 975
 976   devX1 := devX div 2;
 977   devX2 := devX+1;
 978   devY1 := devY div 2;
 979   devY2 := devY+1;
 980
 981   for a := 1 to count do
 982   begin
 983     with Particles[CurrentParticle] do
 984     begin
 985       x := fX-devX1+Random(devX2);
 986       y := fY-devY1+Random(devY2);
 987
 988       // check for level bounds
 989       if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then continue;
 990
 991       (*
 992       // don't spawn bubbles outside of the liquid
 993       if not isLiquidAt(X, Y) {ByteBool(gCollideMap[Y, X] and MARK_LIQUID)} then
 994         Continue;
 995       *)
 996
 997       // trace liquid, so we'll know where it ends; do it in 8px steps for speed
 998       // tracer will return `false` if we started outside of the liquid
 999
1000       {$IF DEFINED(D2F_DEBUG_BUBBLES)}
1001       stt := curTimeMicro();
1002       ptr := mapGrid.traceOrthoRayWhileIn(liquidx, liquidTopY, x, y, x, 0, GridTagWater or GridTagAcid1 or GridTagAcid2);
1003       stt := curTimeMicro()-stt;
1004       e_LogWritefln('traceOrthoRayWhileIn: time=%s (%s); liquidTopY=%s', [Integer(stt), ptr, liquidTopY]);
1005       //
1006       stt := curTimeMicro();
1007       nptr := g_Map_TraceLiquidNonPrecise(x, y, 0, -8, liquidx, liquidTopY);
1008       stt := curTimeMicro()-stt;
1009       e_LogWritefln('g_Map_TraceLiquidNonPrecise: time=%s (%s); liquidTopY=%s', [Integer(stt), nptr, liquidTopY]);
1010       if not nptr then continue;
1011       {$ELSE}
1012       if not g_Map_TraceLiquidNonPrecise(x, y, 0, -8, liquidx, ceilingY) then continue;
1013       if not g_Map_TraceLiquidNonPrecise(x, y, 0, +8, liquidx, floorY) then continue;
1014       {$ENDIF}
1015
1016       velX := 0;
1017       velY := -1-Random;
1018       accelX := 0;
1019       accelY := velY/10;
1020
1021       red := 255;
1022       green := 255;
1023       blue := 255;
1024       alpha := 255;
1025
1026       state := TPartState.Normal;
1027       particleType := TPartType.Bubbles;
1028       time := 0;
1029       liveTime := 65535;
1030     end;
1031
1032     if (CurrentParticle >= MaxParticles-1) then CurrentParticle := 0 else CurrentParticle += 1;
1033   end;
1034 end;
1035
1036
1037 // ////////////////////////////////////////////////////////////////////////// //
1038 procedure TParticle.thinkerSpark ();
1039 label
1040   _done;
1041 var
1042   dX, dY: SmallInt;
1043   pan: TPanel;
1044   ex, ey: Integer;
1045 begin
1046   if not gpart_dbg_phys_enabled then goto _done;
1047
1048   dX := round(velX);
1049   dY := round(velY);
1050
1051   // apply gravity
1052   if (abs(velX) < 0.1) and (abs(velY) < 0.1) then
1053   begin
1054     velY := 0.8;
1055     accelY := 0.5;
1056   end;
1057
1058   // flying
1059   if (dX <> 0) then
1060   begin
1061     // has some horizontal velocity
1062     pan := g_Map_traceToNearest(x, y, x+dX, y+dY, (GridTagObstacle or GridTagLiquid), @ex, @ey);
1063     if (x <> ex) then begin floorY := Unknown; ceilingY := Unknown; end; // dunno yet
1064     x := ex;
1065     y := ey;
1066     if (pan <> nil) then
1067     begin
1068       if ((pan.tag and GridTagLiquid) <> 0) then begin die(); exit; end; // die in liquid
1069       // hit the wall; falling down vertically
1070       velX := 0;
1071       accelX := 0;
1072     end;
1073   end
1074   else if (dY <> 0) then
1075   begin
1076     // has some vertical velocity
1077     if (dY < 0) then
1078     begin
1079       // flying up
1080       if (ceilingY = Unknown) then findCeiling(); // need to do this anyway
1081       y += dY;
1082       if (y <= ceilingY) then
1083       begin
1084         // oops, hit a ceiling
1085         y := ceilingY;
1086         velY := -velY;
1087         accelY := abs(accelY);
1088       end;
1089       // environment didn't changed
1090     end
1091     else
1092     begin
1093       // falling down
1094       if (floorY = Unknown) then findFloor(); // need to do this anyway
1095       y += dY;
1096       if (y >= floorY) then
1097       begin
1098         // hit something except a floor?
1099         if (floorType <> TFloorType.Wall) then begin die(); exit; end; // yep: just die
1100         // otherwise, go to sleep
1101         y := floorY;
1102         sleep();
1103         // environment didn't changed
1104       end;
1105     end;
1106   end;
1107
1108 _done:
1109   if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then begin die(); end;
1110
1111   if (velX <> 0.0) then velX += accelX;
1112
1113   if (velY <> 0.0) then
1114   begin
1115     if (accelY < 10) then accelY += 0.08;
1116     velY += accelY;
1117   end;
1118
1119   time += 1;
1120 end;
1121
1122
1123 // ////////////////////////////////////////////////////////////////////////// //
1124 procedure g_GFX_SparkVel (fX, fY: Integer; count: Word; vx, vy: Integer; devX, devY: Byte);
1125 var
1126   a: Integer;
1127   devX1, devX2, devY1, devY2: Integer;
1128   l: Integer;
1129   pan: TPanel;
1130 begin
1131   if not gpart_dbg_enabled then exit;
1132
1133   l := Length(Particles);
1134   if (l = 0) then exit;
1135   if (count > l) then count := l;
1136
1137   devX1 := devX div 2;
1138   devX2 := devX+1;
1139   devY1 := devY div 2;
1140   devY2 := devY+1;
1141
1142   for a := 1 to count do
1143   begin
1144     with Particles[CurrentParticle] do
1145     begin
1146       x := fX-devX1+Random(devX2);
1147       y := fY-devY1+Random(devY2);
1148
1149       // check for level bounds
1150       if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then continue;
1151
1152       // in what environment we are starting in?
1153       pan := g_Map_PanelAtPoint(x, y, (GridTagObstacle or GridTagLiquid));
1154       if (pan <> nil) then
1155       begin
1156         // either in a wall, or in a liquid
1157         //if ((pan.tag and GridTagObstacle) <> 0) then continue; // don't spawn in walls
1158         //env := TEnvType.ELiquid;
1159         continue;
1160       end
1161       else
1162       begin
1163         env := TEnvType.EAir;
1164       end;
1165
1166       velX := vx+(Random-Random)*3;
1167       velY := vy+(Random-Random)*3;
1168
1169       if (velY > -4) then
1170       begin
1171         if (velY-4 < -4) then velY := -4 else velY := velY-4;
1172       end;
1173
1174       accelX := -sign(velX)*Random/100;
1175       accelY := 0.8;
1176
1177       red := 255;
1178       green := 100+Random(155);
1179       blue := 64;
1180       alpha := 255;
1181
1182       particleType := TPartType.Spark;
1183       state := TPartState.Normal;
1184       time := 0;
1185       liveTime := 30+Random(60);
1186       floorY := Unknown;
1187       ceilingY := Unknown;
1188     end;
1189
1190     if (CurrentParticle >= MaxParticles-1) then CurrentParticle := 0 else CurrentParticle += 1;
1191   end;
1192 end;
1193
1194
1195 procedure g_GFX_Spark (fX, fY: Integer; count: Word; angle: SmallInt; devX, devY: Byte);
1196 var
1197   a: Integer;
1198   b: Single;
1199   devX1, devX2, devY1, devY2: Integer;
1200   baseVelX, baseVelY: Single;
1201   l: Integer;
1202   pan: TPanel;
1203 begin
1204   if not gpart_dbg_enabled then exit;
1205
1206   l := Length(Particles);
1207   if (l = 0) then exit;
1208   if (count > l) then count := l;
1209
1210   angle := 360-angle;
1211
1212   devX1 := devX div 2;
1213   devX2 := devX+1;
1214   devY1 := devY div 2;
1215   devY2 := devY+1;
1216
1217   b := DegToRad(angle);
1218   baseVelX := cos(b);
1219   baseVelY := 1.6*sin(b);
1220   if (abs(baseVelX) < 0.01) then baseVelX := 0.0;
1221   if (abs(baseVelY) < 0.01) then baseVelY := 0.0;
1222
1223   for a := 1 to count do
1224   begin
1225     with Particles[CurrentParticle] do
1226     begin
1227       x := fX-devX1+Random(devX2);
1228       y := fY-devY1+Random(devY2);
1229
1230       // check for level bounds
1231       if (x < g_Map_MinX) or (y < g_Map_MinY) or (x > g_Map_MaxX) or (y > g_Map_MaxY) then continue;
1232
1233       // in what environment we are starting in?
1234       pan := g_Map_PanelAtPoint(x, y, (GridTagObstacle or GridTagLiquid));
1235       if (pan <> nil) then
1236       begin
1237         // either in a wall, or in a liquid
1238         //if ((pan.tag and GridTagObstacle) <> 0) then continue; // don't spawn in walls
1239         //env := TEnvType.ELiquid;
1240         continue;
1241       end
1242       else
1243       begin
1244         env := TEnvType.EAir;
1245       end;
1246
1247       velX := baseVelX*Random;
1248       velY := baseVelY-Random;
1249       accelX := velX/3.0;
1250       accelY := velY/5.0;
1251
1252       red := 255;
1253       green := 100+Random(155);
1254       blue := 64;
1255       alpha := 255;
1256
1257       particleType := TPartType.Spark;
1258       state := TPartState.Normal;
1259       time := 0;
1260       liveTime := 30+Random(60);
1261       floorY := Unknown;
1262       ceilingY := Unknown;
1263     end;
1264
1265     if (CurrentParticle >= MaxParticles-1) then CurrentParticle := 0 else CurrentParticle += 1;
1266   end;
1267 end;
1268
1269
1270 // ////////////////////////////////////////////////////////////////////////// //
1271 procedure g_GFX_SetMax (count: Integer);
1272 var
1273   a: Integer;
1274 begin
1275   if count > 50000 then count := 50000;
1276   if (count < 1) then count := 1;
1277   SetLength(Particles, count);
1278   for a := 0 to High(Particles) do Particles[a].die();
1279   MaxParticles := count;
1280   CurrentParticle := 0;
1281 end;
1282
1283
1284 function g_GFX_GetMax (): Integer;
1285 begin
1286   result := MaxParticles;
1287 end;
1288
1289
1290 function FindOnceAnim (): DWORD;
1291 var
1292   i: Integer;
1293 begin
1294   if OnceAnims <> nil then
1295     for i := 0 to High(OnceAnims) do
1296       if OnceAnims[i].Animation = nil then
1297       begin
1298         Result := i;
1299         Exit;
1300       end;
1301
1302   if OnceAnims = nil then
1303     begin
1304       SetLength(OnceAnims, 16);
1305       Result := 0;
1306     end
1307   else
1308     begin
1309       Result := High(OnceAnims) + 1;
1310       SetLength(OnceAnims, Length(OnceAnims) + 16);
1311     end;
1312 end;
1313
1314
1315 procedure g_GFX_OnceAnim (x, y: Integer; Anim: TAnimation; AnimType: Byte = 0);
1316 var
1317   find_id: DWORD;
1318 begin
1319   if not gpart_dbg_enabled then exit;
1320
1321   if (Anim = nil) then exit;
1322
1323   find_id := FindOnceAnim();
1324
1325   OnceAnims[find_id].AnimType := AnimType;
1326   OnceAnims[find_id].Animation := TAnimation.Create(Anim.FramesID, Anim.Loop, Anim.Speed);
1327   OnceAnims[find_id].Animation.Blending := Anim.Blending;
1328   OnceAnims[find_id].Animation.alpha := Anim.alpha;
1329   OnceAnims[find_id].x := x;
1330   OnceAnims[find_id].y := y;
1331 end;
1332
1333
1334 // ////////////////////////////////////////////////////////////////////////// //
1335 // st: set mark
1336 // t: mark type
1337 // currently unused
1338 procedure g_Mark (x, y, Width, Height: Integer; t: Byte; st: Boolean=true);
1339 var
1340   cx, ex, ey: Integer;
1341   ts: Integer;
1342 begin
1343   if not gpart_dbg_enabled then exit;
1344
1345   if (Width < 1) or (Height < 1) then exit;
1346   // make some border, so we'll hit particles lying around the panel
1347   x -= 1; Width += 2;
1348   y -= 1; Height += 2;
1349   ex := x+Width;
1350   ey := y+Height;
1351   ts := mapGrid.tileSize;
1352   while (y < ey) do
1353   begin
1354     cx := x;
1355     while (cx < ex) do
1356     begin
1357       awmSet(cx, y);
1358       Inc(cx, ts);
1359     end;
1360     Inc(y, ts);
1361   end;
1362 end;
1363
1364
1365 // ////////////////////////////////////////////////////////////////////////// //
1366 procedure g_GFX_Init ();
1367 begin
1368   //g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 1/6', 0, False);
1369   //SetLength(gCollideMap, gMapInfo.Height+1);
1370   //for a := 0 to High(gCollideMap) do SetLength(gCollideMap[a], gMapInfo.Width+1);
1371   awmSetup();
1372 {$IFDEF HEADLESS}
1373   gpart_dbg_enabled := false;
1374 {$ENDIF}
1375 end;
1376
1377
1378 procedure g_GFX_Free ();
1379 var
1380   a: Integer;
1381 begin
1382   Particles := nil;
1383   SetLength(Particles, MaxParticles);
1384   for a := 0 to High(Particles) do Particles[a].die();
1385   CurrentParticle := 0;
1386
1387   if (OnceAnims <> nil) then
1388   begin
1389     for a := 0 to High(OnceAnims) do OnceAnims[a].Animation.Free();
1390     OnceAnims := nil;
1391   end;
1392
1393   awakeMap := nil;
1394   // why not?
1395   awakeMapH := -1;
1396   awakeMapW := -1;
1397 end;
1398
1399
1400 // ////////////////////////////////////////////////////////////////////////// //
1401 procedure g_GFX_Update ();
1402 var
1403   a: Integer;
1404   w, h: Integer;
1405   len: Integer;
1406 begin
1407   if not gpart_dbg_enabled then exit;
1408
1409   if (Particles <> nil) then
1410   begin
1411     w := gMapInfo.Width;
1412     h := gMapInfo.Height;
1413
1414     len := High(Particles);
1415
1416     for a := 0 to len do
1417     begin
1418       if Particles[a].alive then
1419       begin
1420         with Particles[a] do
1421         begin
1422           if (time = liveTime) then begin die(); continue; end;
1423           if (x+1 >= w) or (y+1 >= h) or (x <= 0) or (y <= 0) then begin die(); end;
1424           think();
1425         end; // with
1426       end; // if
1427     end; // for
1428   end; // Particles <> nil
1429
1430   // clear awake map
1431   awmClear();
1432
1433   if OnceAnims <> nil then
1434   begin
1435     for a := 0 to High(OnceAnims) do
1436       if OnceAnims[a].Animation <> nil then
1437       begin
1438         case OnceAnims[a].AnimType of
1439           ONCEANIM_SMOKE:
1440             begin
1441               if Random(3) = 0 then
1442                 OnceAnims[a].x := OnceAnims[a].x-1+Random(3);
1443               if Random(2) = 0 then
1444                 OnceAnims[a].y := OnceAnims[a].y-Random(2);
1445             end;
1446         end;
1447
1448         if OnceAnims[a].Animation.Played then
1449           begin
1450             OnceAnims[a].Animation.Free();
1451             OnceAnims[a].Animation := nil;
1452           end
1453         else
1454           OnceAnims[a].Animation.Update();
1455       end;
1456   end;
1457 end;
1458
1459
1460 procedure g_GFX_Draw ();
1461 var
1462   a, len: Integer;
1463 begin
1464   if not gpart_dbg_enabled then exit;
1465
1466   if (Particles <> nil) then
1467   begin
1468     glDisable(GL_TEXTURE_2D);
1469     glPointSize(2);
1470
1471     glEnable(GL_BLEND);
1472     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1473
1474     glBegin(GL_POINTS);
1475
1476     len := High(Particles);
1477     for a := 0 to len do
1478     begin
1479       with Particles[a] do
1480       begin
1481         if alive and (x >= sX) and (y >= sY) and (x <= sX+sWidth) and (sY <= sY+sHeight) then
1482         begin
1483           glColor4ub(red, green, blue, alpha);
1484           glVertex2f(x+0.37, y+0.37);
1485         end;
1486       end;
1487     end;
1488
1489     glEnd();
1490
1491     glDisable(GL_BLEND);
1492   end;
1493
1494   if (OnceAnims <> nil) then
1495   begin
1496     len := High(OnceAnims);
1497     for a := 0 to len do
1498     begin
1499       if (OnceAnims[a].Animation <> nil) then
1500       begin
1501         with OnceAnims[a] do Animation.Draw(x, y, M_NONE);
1502       end;
1503     end;
1504   end;
1505 end;
1506
1507
1508 end.