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 {$MODE DELPHI}
  17 unit g_gfx;
  18
  19 interface
  20
  21 uses
  22   g_textures;
  23
  24 const
  25   BLOOD_NORMAL = 0;
  26   BLOOD_SPARKS = 1;
  27   ONCEANIM_NONE  = 0;
  28   ONCEANIM_SMOKE = 1;
  29   MARK_FREE     = 0;
  30   MARK_WALL     = 1;
  31   MARK_WATER    = 2;
  32   MARK_ACID     = 4;
  33   MARK_LIFTDOWN = 8;
  34   MARK_LIFTUP   = 16;
  35   MARK_DOOR     = 32;
  36   MARK_LIFTLEFT  = 64;
  37   MARK_LIFTRIGHT = 128;
  38   MARK_BLOCKED  = MARK_WALL + MARK_DOOR;
  39   MARK_LIQUID   = MARK_WATER + MARK_ACID;
  40   MARK_LIFT     = MARK_LIFTDOWN + MARK_LIFTUP + MARK_LIFTLEFT + MARK_LIFTRIGHT;
  41
  42 procedure g_GFX_Init();
  43 procedure g_GFX_Free();
  44
  45 procedure g_GFX_Blood(fX, fY: Integer; Count: Word; vx, vy: Integer;
  46                       DevX, DevY: Word; CR, CG, CB: Byte; Kind: Byte = BLOOD_NORMAL);
  47 procedure g_GFX_Spark(fX, fY: Integer; Count: Word; Angle: SmallInt; DevX, DevY: Byte);
  48 procedure g_GFX_Water(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DevX, DevY, Color: Byte);
  49 procedure g_GFX_SimpleWater(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DefColor, CR, CG, CB: Byte);
  50 procedure g_GFX_Bubbles(fX, fY: Integer; Count: Word; DevX, DevY: Byte);
  51 procedure g_GFX_SetMax(Count: Integer);
  52 function  g_GFX_GetMax(): Integer;
  53
  54 procedure g_GFX_OnceAnim(X, Y: Integer; Anim: TAnimation; AnimType: Byte = 0);
  55
  56 procedure g_Mark(x, y, Width, Height: Integer; t: Byte; st: Boolean);
  57
  58 procedure g_GFX_Update();
  59 procedure g_GFX_Draw();
  60
  61 var
  62   gCollideMap: Array of Array of Byte;
  63
  64 implementation
  65
  66 uses
  67   g_map, g_basic, Math, e_graphics, GL, GLExt,
  68   g_options, g_console, SysUtils, g_triggers, MAPDEF,
  69   g_game, g_language, g_net;
  70
  71 type
  72   TParticle = record
  73     X, Y:               Integer;
  74     VelX, VelY:         Single;
  75     AccelX, AccelY:     Single;
  76     Red, Green, Blue:   Byte;
  77     Alpha:              Byte;
  78     Time, LiveTime:     Word;
  79     State:              Byte;
  80     ParticleType:       Byte;
  81     offsetX, offsetY:   ShortInt;
  82   end;
  83
  84   TOnceAnim = record
  85     AnimType:   Byte;
  86     X, Y:       Integer;
  87     Animation:  TAnimation;
  88   end;
  89
  90 const
  91   PARTICLE_BLOOD   = 0;
  92   PARTICLE_SPARK   = 1;
  93   PARTICLE_BUBBLES = 2;
  94   PARTICLE_WATER   = 3;
  95   STATE_FREE   = 0;
  96   STATE_NORMAL = 1;
  97   STATE_STICK  = 2;
  98
  99 var
 100   Particles: Array of TParticle;
 101   OnceAnims: Array of TOnceAnim;
 102   MaxParticles: Integer;
 103   CurrentParticle: Integer;
 104
 105 procedure g_Mark(x, y, Width, Height: Integer; t: Byte; st: Boolean);
 106 var
 107   yy, y2, xx, x2: Integer;
 108 begin
 109   if x < 0 then
 110   begin
 111     Width := Width + x;
 112     x := 0;
 113   end;
 114
 115   if Width < 0 then
 116     Exit;
 117
 118   if y < 0 then
 119   begin
 120     Height := Height + y;
 121     y := 0;
 122   end;
 123
 124   if Height < 0 then
 125     Exit;
 126
 127   if x > gMapInfo.Width then
 128     Exit;
 129   if y > gMapInfo.Height then
 130     Exit;
 131
 132   y2 := y + Height - 1;
 133   if y2 > gMapInfo.Height then
 134     y2 := gMapInfo.Height;
 135
 136   x2 := x + Width - 1;
 137   if x2 > gMapInfo.Width then
 138     x2 := gMapInfo.Width;
 139
 140   if st then
 141     begin // Óñòàíîâèòü ïðèçíàê
 142       for yy := y to y2 do
 143         for xx := x to x2 do
 144           gCollideMap[yy][xx] := gCollideMap[yy][xx] or t;
 145     end
 146   else
 147     begin // Óáðàòü ïðèçíàê
 148       t := not t;
 149       for yy := y to y2 do
 150         for xx := x to x2 do
 151           gCollideMap[yy][xx] := gCollideMap[yy][xx] and t;
 152     end;
 153 end;
 154
 155 procedure CreateCollideMap();
 156 var
 157   a: Integer;
 158 begin
 159   g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 1/6', 0, False);
 160   SetLength(gCollideMap, gMapInfo.Height+1);
 161   for a := 0 to High(gCollideMap) do
 162     SetLength(gCollideMap[a], gMapInfo.Width+1);
 163
 164   if gWater <> nil then
 165   begin
 166     g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 2/6', 0, True);
 167     for a := 0 to High(gWater) do
 168       with gWater[a] do
 169         g_Mark(X, Y, Width, Height, MARK_WATER, True);
 170   end;
 171
 172   if gAcid1 <> nil then
 173   begin
 174     g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 3/6', 0, True);
 175     for a := 0 to High(gAcid1) do
 176       with gAcid1[a] do
 177         g_Mark(X, Y, Width, Height, MARK_ACID, True);
 178   end;
 179
 180   if gAcid2 <> nil then
 181   begin
 182     g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 4/6', 0, True);
 183     for a := 0 to High(gAcid2) do
 184       with gAcid2[a] do
 185         g_Mark(X, Y, Width, Height, MARK_ACID, True);
 186   end;
 187
 188   if gLifts <> nil then
 189   begin
 190     g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 5/6', 0, True);
 191     for a := 0 to High(gLifts) do
 192       with gLifts[a] do
 193       begin
 194         g_Mark(X, Y, Width, Height, MARK_LIFT, False);
 195
 196         if LiftType = 0 then
 197           g_Mark(X, Y, Width, Height, MARK_LIFTUP, True)
 198         else if LiftType = 1 then
 199           g_Mark(X, Y, Width, Height, MARK_LIFTDOWN, True)
 200         else if LiftType = 2 then
 201           g_Mark(X, Y, Width, Height, MARK_LIFTLEFT, True)
 202         else if LiftType = 3 then
 203           g_Mark(X, Y, Width, Height, MARK_LIFTRIGHT, True)
 204       end;
 205   end;
 206
 207   if gWalls <> nil then
 208   begin
 209     g_Game_SetLoadingText(_lc[I_LOAD_COLLIDE_MAP]+' 6/6', 0, True);
 210     for a := 0 to High(gWalls) do
 211     begin
 212       if gWalls[a].Door then
 213         begin
 214         // Çàêðûòàÿ äâåðü:
 215           if gWalls[a].Enabled then
 216             with gWalls[a] do
 217               g_Mark(X, Y, Width, Height, MARK_DOOR, True)
 218           else // Îòêðûòàÿ äâåðü:
 219             if gWalls[a].Enabled then
 220               with gWalls[a] do
 221                 g_Mark(X, Y, Width, Height, MARK_DOOR, False);
 222         end
 223       else // Ñòåíà
 224         with gWalls[a] do
 225           g_Mark(X, Y, Width, Height, MARK_WALL, True);
 226     end;
 227   end;
 228 end;
 229
 230 procedure g_GFX_Init();
 231 begin
 232   CreateCollideMap();
 233 end;
 234
 235 procedure g_GFX_Free();
 236 var
 237   a: Integer;
 238 begin
 239   Particles := nil;
 240   SetLength(Particles, MaxParticles);
 241   CurrentParticle := 0;
 242
 243   if OnceAnims <> nil then
 244   begin
 245     for a := 0 to High(OnceAnims) do
 246       OnceAnims[a].Animation.Free();
 247
 248     OnceAnims := nil;
 249   end;
 250
 251   gCollideMap := nil;
 252 end;
 253
 254 procedure CorrectOffsets(id: Integer);
 255 begin
 256   with Particles[id] do
 257   begin
 258     if (X >= 0) and (Y > 0) and
 259     (Y < Length(gCollideMap)) and (X < Length(gCollideMap[0])) and
 260     (ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)) then
 261       offsetY := 1 // Ñòåíà ñâåðõó
 262     else
 263       offsetY := 0;
 264
 265     if (X > 0) and (Y >= 0) and
 266     (Y < Length(gCollideMap)) and (X < Length(gCollideMap[0])) and
 267     (ByteBool(gCollideMap[Y, X-1] and MARK_BLOCKED)) then
 268       offsetX := 1 // Ñòåíà ñëåâà
 269     else
 270       offsetX := 0;
 271   end;
 272 end;
 273
 274 procedure g_GFX_SparkVel(fX, fY: Integer; Count: Word; VX, VY: Integer; DevX, DevY: Byte);
 275 var
 276   a: Integer;
 277   DevX1, DevX2,
 278   DevY1, DevY2: Byte;
 279   l: Integer;
 280 begin
 281   l := Length(Particles);
 282   if l = 0 then
 283     Exit;
 284   if Count > l then
 285     Count := l;
 286
 287   DevX1 := DevX div 2;
 288   DevX2 := DevX + 1;
 289   DevY1 := DevY div 2;
 290   DevY2 := DevY + 1;
 291
 292   for a := 1 to Count do
 293   begin
 294     with Particles[CurrentParticle] do
 295     begin
 296       X := fX-DevX1+Random(DevX2);
 297       Y := fY-DevY1+Random(DevY2);
 298
 299       VelX := VX + (Random-Random)*3;
 300       VelY := VY + (Random-Random)*3;
 301
 302       if VelY > -4 then
 303         if VelY-4 < -4 then
 304           VelY := -4
 305         else
 306           VelY := VelY-4;
 307
 308       AccelX := -Sign(VelX)*Random/100;
 309       AccelY := 0.8;
 310
 311       Red := 255;
 312       Green := 100+Random(155);
 313       Blue := 64;
 314       Alpha := 255;
 315
 316       State := STATE_NORMAL;
 317       Time := 0;
 318       LiveTime := 30+Random(60);
 319       ParticleType := PARTICLE_SPARK;
 320
 321       CorrectOffsets(CurrentParticle);
 322     end;
 323
 324     if CurrentParticle+2 > MaxParticles then
 325       CurrentParticle := 0
 326     else
 327       CurrentParticle := CurrentParticle+1;
 328   end;
 329 end;
 330
 331 procedure g_GFX_Blood(fX, fY: Integer; Count: Word; vx, vy: Integer;
 332   DevX, DevY: Word; CR, CG, CB: Byte; Kind: Byte = BLOOD_NORMAL);
 333 var
 334   a: Integer;
 335   DevX1, DevX2,
 336   DevY1, DevY2: Word;
 337   l: Integer;
 338   CRnd: Byte;
 339   CC: SmallInt;
 340 begin
 341   if Kind = BLOOD_SPARKS then
 342   begin
 343     g_GFX_SparkVel(fX, fY, 2 + Random(2), -VX div 2, -VY div 2, DevX, DevY);
 344     Exit;
 345   end;
 346   l := Length(Particles);
 347   if l = 0 then
 348     Exit;
 349   if Count > l then
 350     Count := l;
 351
 352   DevX1 := DevX div 2;
 353   DevX2 := DevX + 1;
 354   DevY1 := DevY div 2;
 355   DevY2 := DevY + 1;
 356
 357   for a := 1 to Count do
 358   begin
 359     with Particles[CurrentParticle] do
 360     begin
 361       X := fX - DevX1 + Random(DevX2);
 362       Y := fY - DevY1 + Random(DevY2);
 363
 364       if (X < 0) or (X > gMapInfo.Width-1) or
 365          (Y < 0) or (Y > gMapInfo.Height-1) or
 366          ByteBool(gCollideMap[Y, X] and MARK_WALL) then
 367         Continue;
 368
 369       VelX := vx + (Random-Random)*3;
 370       VelY := vy + (Random-Random)*3;
 371
 372       if VelY > -4 then
 373         if VelY-4 < -4 then
 374           VelY := -4
 375         else
 376           VelY := VelY-4;
 377
 378       AccelX := -Sign(VelX)*Random/100;
 379       AccelY := 0.8;
 380
 381       CRnd := 20*Random(6);
 382       if CR > 0 then
 383       begin
 384         CC := CR + CRnd - 50;
 385         if CC < 0   then CC := 0;
 386         if CC > 255 then CC := 255;
 387         Red := CC;
 388       end else
 389         Red := 0;
 390       if CG > 0 then
 391       begin
 392         CC := CG + CRnd - 50;
 393         if CC < 0   then CC := 0;
 394         if CC > 255 then CC := 255;
 395         Green := CC;
 396       end else
 397         Green := 0;
 398       if CB > 0 then
 399       begin
 400         CC := CB + CRnd - 50;
 401         if CC < 0   then CC := 0;
 402         if CC > 255 then CC := 255;
 403         Blue := CC;
 404       end else
 405         Blue := 0;
 406
 407       Alpha := 255;
 408
 409       State := STATE_NORMAL;
 410       Time := 0;
 411       LiveTime := 120+Random(40);
 412       ParticleType := PARTICLE_BLOOD;
 413
 414       CorrectOffsets(CurrentParticle);
 415     end;
 416
 417     if CurrentParticle >= MaxParticles-1 then
 418       CurrentParticle := 0
 419     else
 420       CurrentParticle := CurrentParticle+1;
 421   end;
 422 end;
 423
 424 procedure g_GFX_Spark(fX, fY: Integer; Count: Word; Angle: SmallInt; DevX, DevY: Byte);
 425 var
 426   a: Integer;
 427   b: Single;
 428   DevX1, DevX2,
 429   DevY1, DevY2: Byte;
 430   BaseVelX, BaseVelY: Single;
 431   l: Integer;
 432 begin
 433   l := Length(Particles);
 434   if l = 0 then
 435     Exit;
 436   if Count > l then
 437     Count := l;
 438
 439   Angle := 360 - Angle;
 440
 441   DevX1 := DevX div 2;
 442   DevX2 := DevX + 1;
 443   DevY1 := DevY div 2;
 444   DevY2 := DevY + 1;
 445
 446   b := DegToRad(Angle);
 447   BaseVelX := cos(b);
 448   BaseVelY := 1.6*sin(b);
 449   if Abs(BaseVelX) < 0.01 then
 450     BaseVelX := 0.0;
 451   if Abs(BaseVelY) < 0.01 then
 452     BaseVelY := 0.0;
 453   for a := 1 to Count do
 454   begin
 455     with Particles[CurrentParticle] do
 456     begin
 457       X := fX-DevX1+Random(DevX2);
 458       Y := fY-DevY1+Random(DevY2);
 459
 460       VelX := BaseVelX*Random;
 461       VelY := BaseVelY-Random;
 462       AccelX := VelX/3.0;
 463       AccelY := VelY/5.0;
 464
 465       Red := 255;
 466       Green := 100+Random(155);
 467       Blue := 64;
 468       Alpha := 255;
 469
 470       State := STATE_NORMAL;
 471       Time := 0;
 472       LiveTime := 30+Random(60);
 473       ParticleType := PARTICLE_SPARK;
 474
 475       CorrectOffsets(CurrentParticle);
 476     end;
 477
 478     if CurrentParticle+2 > MaxParticles then
 479       CurrentParticle := 0
 480     else
 481       CurrentParticle := CurrentParticle+1;
 482   end;
 483 end;
 484
 485 procedure g_GFX_Water(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DevX, DevY, Color: Byte);
 486 var
 487   a: Integer;
 488   DevX1, DevX2,
 489   DevY1, DevY2: Byte;
 490   l: Integer;
 491 begin
 492   l := Length(Particles);
 493   if l = 0 then
 494     Exit;
 495   if Count > l then
 496     Count := l;
 497
 498   if Abs(fVelX) < 3.0 then
 499     fVelX := 3.0 - 6.0*Random;
 500
 501   DevX1 := DevX div 2;
 502   DevX2 := DevX + 1;
 503   DevY1 := DevY div 2;
 504   DevY2 := DevY + 1;
 505
 506   for a := 1 to Count do
 507   begin
 508     with Particles[CurrentParticle] do
 509     begin
 510       X := fX-DevX1+Random(DevX2);
 511       Y := fY-DevY1+Random(DevY2);
 512
 513       if Abs(fVelX) < 0.5 then
 514         VelX := 1.0 - 2.0*Random
 515       else
 516         VelX := fVelX*Random;
 517       if Random(10) < 7 then
 518         VelX := -VelX;
 519       VelY := fVelY*Random;
 520       AccelX := 0.0;
 521       AccelY := 0.8;
 522
 523       case Color of
 524         1: // Êðàñíûé
 525           begin
 526             Red := 155 + Random(9)*10;
 527             Green := Trunc(150*Random);
 528             Blue := Green;
 529           end;
 530         2: // Çåëåíûé
 531           begin
 532             Red := Trunc(150*Random);
 533             Green := 175 + Random(9)*10;
 534             Blue := Red;
 535           end;
 536         3: // Ñèíèé
 537           begin
 538             Red := Trunc(200*Random);
 539             Green := Red;
 540             Blue := 175 + Random(9)*10;
 541           end;
 542         else // Ñåðûé
 543           begin
 544             Red := 90 + Random(12)*10;
 545             Green := Red;
 546             Blue := Red;
 547           end;
 548       end;
 549
 550       Alpha := 255;
 551
 552       State := STATE_NORMAL;
 553       Time := 0;
 554       LiveTime := 60+Random(60);
 555       ParticleType := PARTICLE_WATER;
 556
 557       CorrectOffsets(CurrentParticle);
 558     end;
 559
 560     if CurrentParticle+2 > MaxParticles then
 561       CurrentParticle := 0
 562     else
 563       CurrentParticle := CurrentParticle+1;
 564   end;
 565 end;
 566
 567 procedure g_GFX_SimpleWater(fX, fY: Integer; Count: Word; fVelX, fVelY: Single; DefColor, CR, CG, CB: Byte);
 568 var
 569   a: Integer;
 570   l: Integer;
 571 begin
 572   l := Length(Particles);
 573   if l = 0 then
 574     Exit;
 575   if Count > l then
 576     Count := l;
 577
 578   for a := 1 to Count do
 579   begin
 580     with Particles[CurrentParticle] do
 581     begin
 582       X := fX;
 583       Y := fY;
 584
 585       VelX := fVelX;
 586       VelY := fVelY;
 587       AccelX := 0.0;
 588       AccelY := 0.8;
 589
 590       case DefColor of
 591         1: // Êðàñíûé
 592           begin
 593             Red := 155 + Random(9)*10;
 594             Green := Trunc(150*Random);
 595             Blue := Green;
 596           end;
 597         2: // Çåëåíûé
 598           begin
 599             Red := Trunc(150*Random);
 600             Green := 175 + Random(9)*10;
 601             Blue := Red;
 602           end;
 603         3: // Ñèíèé
 604           begin
 605             Red := Trunc(200*Random);
 606             Green := Red;
 607             Blue := 175 + Random(9)*10;
 608           end;
 609         4: // Ñâîé öâåò, ñâåòëåå
 610           begin
 611             Red := 20 + Random(19)*10;
 612             Green := Red;
 613             Blue := Red;
 614             Red := Min(Red + CR, 255);
 615             Green := Min(Green + CG, 255);
 616             Blue := Min(Blue + CB, 255);
 617           end;
 618         5: // Ñâîé öâåò, òåìíåå
 619           begin
 620             Red := 20 + Random(19)*10;
 621             Green := Red;
 622             Blue := Red;
 623             Red := Max(CR - Red, 0);
 624             Green := Max(CG - Green, 0);
 625             Blue := Max(CB - Blue, 0);
 626           end;
 627         else // Ñåðûé
 628           begin
 629             Red := 90 + Random(12)*10;
 630             Green := Red;
 631             Blue := Red;
 632           end;
 633       end;
 634
 635       Alpha := 255;
 636
 637       State := STATE_NORMAL;
 638       Time := 0;
 639       LiveTime := 60+Random(60);
 640       ParticleType := PARTICLE_WATER;
 641
 642       CorrectOffsets(CurrentParticle);
 643     end;
 644
 645     if CurrentParticle+2 > MaxParticles then
 646       CurrentParticle := 0
 647     else
 648       CurrentParticle := CurrentParticle+1;
 649   end;
 650 end;
 651
 652 procedure g_GFX_Bubbles(fX, fY: Integer; Count: Word; DevX, DevY: Byte);
 653 var
 654   a: Integer;
 655   DevX1, DevX2,
 656   DevY1, DevY2: Byte;
 657   l: Integer;
 658 begin
 659   l := Length(Particles);
 660   if l = 0 then
 661     Exit;
 662   if Count > l then
 663     Count := l;
 664
 665   DevX1 := DevX div 2;
 666   DevX2 := DevX + 1;
 667   DevY1 := DevY div 2;
 668   DevY2 := DevY + 1;
 669
 670   for a := 1 to Count do
 671   begin
 672     with Particles[CurrentParticle] do
 673     begin
 674       X := fX-DevX1+Random(DevX2);
 675       Y := fY-DevY1+Random(DevY2);
 676
 677       if (X >= gMapInfo.Width) or (X <= 0) or
 678          (Y >= gMapInfo.Height) or (Y <= 0) then
 679         Continue;
 680
 681       if not ByteBool(gCollideMap[Y, X] and MARK_LIQUID) then
 682         Continue;
 683
 684       VelX := 0;
 685       VelY := -1-Random;
 686       AccelX := 0;
 687       AccelY := VelY/10;
 688
 689       Red := 255;
 690       Green := 255;
 691       Blue := 255;
 692       Alpha := 255;
 693
 694       State := STATE_NORMAL;
 695       Time := 0;
 696       LiveTime := 65535;
 697       ParticleType := PARTICLE_BUBBLES;
 698
 699       CorrectOffsets(CurrentParticle);
 700     end;
 701
 702     if CurrentParticle+2 > MaxParticles then
 703       CurrentParticle := 0
 704     else
 705       CurrentParticle := CurrentParticle+1;
 706   end;
 707 end;
 708
 709 procedure g_GFX_SetMax(Count: Integer);
 710 begin
 711   if Count > 50000 then
 712     Count := 50000;
 713
 714   SetLength(Particles, Count);
 715   MaxParticles := Count;
 716   if CurrentParticle >= Count then
 717     CurrentParticle := 0;
 718 end;
 719
 720 function g_GFX_GetMax(): Integer;
 721 begin
 722   Result := MaxParticles;
 723 end;
 724
 725 function FindOnceAnim: DWORD;
 726 var
 727   i: Integer;
 728 begin
 729   if OnceAnims <> nil then
 730     for i := 0 to High(OnceAnims) do
 731       if OnceAnims[i].Animation = nil then
 732       begin
 733         Result := i;
 734         Exit;
 735       end;
 736
 737   if OnceAnims = nil then
 738     begin
 739       SetLength(OnceAnims, 16);
 740       Result := 0;
 741     end
 742   else
 743     begin
 744       Result := High(OnceAnims) + 1;
 745       SetLength(OnceAnims, Length(OnceAnims) + 16);
 746     end;
 747 end;
 748
 749 procedure g_GFX_OnceAnim(X, Y: Integer; Anim: TAnimation; AnimType: Byte = 0);
 750 var
 751   find_id: DWORD;
 752 begin
 753   if Anim = nil then
 754     Exit;
 755
 756   find_id := FindOnceAnim();
 757
 758   OnceAnims[find_id].AnimType := AnimType;
 759   OnceAnims[find_id].Animation := TAnimation.Create(Anim.FramesID, Anim.Loop, Anim.Speed);
 760   OnceAnims[find_id].Animation.Blending := Anim.Blending;
 761   OnceAnims[find_id].Animation.Alpha := Anim.Alpha;
 762   OnceAnims[find_id].X := X;
 763   OnceAnims[find_id].Y := Y;
 764 end;
 765
 766 procedure g_GFX_Update();
 767 var
 768   a: Integer;
 769   w, h: Integer;
 770   dX, dY: SmallInt;
 771   b, len: Integer;
 772   s: ShortInt;
 773   c: Byte;
 774 begin
 775   if Particles <> nil then
 776   begin
 777     w := gMapInfo.Width;
 778     h := gMapInfo.Height;
 779
 780     len := High(Particles);
 781
 782     for a := 0 to len do
 783       if Particles[a].State <> 0 then
 784         with Particles[a] do
 785         begin
 786           if Time = LiveTime then
 787             State := STATE_FREE;
 788           if (X+1 >= w) or (Y+1 >= h) or (X <= 0) or (Y <= 0) then
 789             State := STATE_FREE;
 790           if State = STATE_FREE then
 791             Continue;
 792
 793           case ParticleType of
 794             PARTICLE_BLOOD:
 795             begin
 796               if gAdvBlood then
 797                 begin
 798                   if (State = STATE_STICK) then
 799                     if (not ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)) and
 800                        (not ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)) and
 801                        (not ByteBool(gCollideMap[Y, X-1] and MARK_BLOCKED)) and
 802                        (not ByteBool(gCollideMap[Y, X+1] and MARK_BLOCKED)) then
 803                       begin // Îòëèïëà - êàïàåò
 804                         VelY := 0.5;
 805                         AccelY := 0.15;
 806                         State := STATE_NORMAL;
 807                       end
 808                     else
 809                       if Random(200) = 100 then
 810                       begin // Ïðèëåïëåíà - íî âîçìîæíî ñòåêàåò
 811                         VelY := 0.5;
 812                         AccelY := 0.15;
 813                         Continue;
 814                       end;
 815
 816                   if not ByteBool(gCollideMap[Y, X] and MARK_BLOCKED) then
 817                   begin
 818                     if ByteBool(gCollideMap[Y, X] and MARK_LIFTUP) then
 819                     begin // Ëèôò ââåðõ
 820                       if VelY > -4-Random(3) then
 821                         VelY := VelY - 0.8;
 822                       if Abs(VelX) > 0.1 then
 823                         VelX := VelX - VelX/10.0;
 824                       VelX := VelX + (Random-Random)*0.2;
 825                       AccelY := 0.15;
 826                     end;
 827                     if ByteBool(gCollideMap[Y, X] and MARK_LIFTLEFT) then
 828                     begin // Ïîòîê âëåâî
 829                       if VelX > -8-Random(3) then
 830                         VelX := VelX - 0.8;
 831                       AccelY := 0.15;
 832                     end;
 833                     if ByteBool(gCollideMap[Y, X] and MARK_LIFTRIGHT) then
 834                     begin // Ïîòîê âïðàâî
 835                       if VelX < 8+Random(3) then
 836                         VelX := VelX + 0.8;
 837                       AccelY := 0.15;
 838                     end;
 839                   end;
 840
 841                   dX := Round(VelX);
 842                   dY := Round(VelY);
 843
 844                   if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
 845                     if (State <> STATE_STICK) and
 846                        (not ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)) and
 847                        (not ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)) and
 848                        (not ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)) then
 849                     begin // Âèñèò â âîçäóõå - êàïàåò
 850                       VelY := 0.8;
 851                       AccelY := 0.5;
 852                       State := STATE_NORMAL;
 853                     end;
 854
 855                   if dX <> 0 then
 856                   begin
 857                     if dX > 0 then
 858                       s := 1
 859                     else
 860                       s := -1;
 861
 862                     dX := Abs(dX);
 863
 864                     for b := 1 to dX do
 865                     begin
 866                       if (X+s >= w) or (X+s <= 0) then
 867                       begin
 868                         State := STATE_FREE;
 869                         Break;
 870                       end;
 871
 872                       c := gCollideMap[Y, X+s];
 873
 874                       if ByteBool(c and MARK_BLOCKED) then
 875                       begin // Ñòåíà/äâåðü
 876                         VelX := 0;
 877                         VelY := 0;
 878                         AccelX := 0;
 879                         AccelY := 0;
 880                         State := STATE_STICK;
 881                         Break;
 882                       end;
 883
 884                       X := X+s;
 885                     end;
 886                   end;
 887
 888                   if dY <> 0 then
 889                   begin
 890                     if dY > 0 then
 891                       s := 1
 892                     else
 893                       s := -1;
 894
 895                     dY := Abs(dY);
 896
 897                     for b := 1 to dY do
 898                     begin
 899                       if (Y+s >= h) or (Y+s <= 0) then
 900                       begin
 901                         State := STATE_FREE;
 902                         Break;
 903                       end;
 904
 905                       c := gCollideMap[Y+s, X];
 906
 907                       if ByteBool(c and MARK_BLOCKED) then
 908                       begin // Ñòåíà/äâåðü
 909                         VelX := 0;
 910                         VelY := 0;
 911                         AccelX := 0;
 912                         AccelY := 0;
 913                         if (s > 0) and (State <> STATE_STICK) then
 914                           State := STATE_NORMAL
 915                         else
 916                           State := STATE_STICK;
 917                         Break;
 918                       end;
 919
 920                       Y := Y+s;
 921                     end;
 922                   end;
 923                 end // if gAdvBlood
 924               else
 925                 begin
 926                   dX := Round(VelX);
 927                   dY := Round(VelY);
 928
 929                   if (X+dX >= w) or (Y+dY >= h) or
 930                      (X+dX <= 0) or (Y+dY <= 0) or
 931                      ByteBool(gCollideMap[Y+dY, X+dX] and MARK_BLOCKED) then
 932                     begin // Ñòåíà/äâåðü/ãðàíèöà
 933                       State := STATE_FREE;
 934                       VelX := 0;
 935                       VelY := 0;
 936                     end
 937                   else
 938                     begin
 939                       Y := Y + dY;
 940                       X := X + dX;
 941                     end;
 942                 end;
 943
 944               VelX := VelX + AccelX;
 945               VelY := VelY + AccelY;
 946
 947             // Êðîâü ðàñòâîðÿåòñÿ â æèäêîñòè:
 948               if ByteBool(gCollideMap[Y, X] and MARK_LIQUID) then
 949               begin
 950                 Inc(Time);
 951
 952                 Alpha := 255 - Trunc((255.0 * Time) / LiveTime);
 953               end;
 954             end;
 955
 956             PARTICLE_SPARK:
 957             begin
 958               dX := Round(VelX);
 959               dY := Round(VelY);
 960
 961               if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) and
 962                  (not ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)) and
 963                  (not ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)) and
 964                  (not ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)) then
 965               begin // Âèñèò â âîçäóõå
 966                 VelY := 0.8;
 967                 AccelY := 0.5;
 968               end;
 969
 970               if dX <> 0 then
 971               begin
 972                 if dX > 0 then
 973                   s := 1
 974                 else
 975                   s := -1;
 976
 977                 dX := Abs(dX);
 978
 979                 for b := 1 to dX do
 980                 begin
 981                   if (X+s >= w) or (X+s <= 0) then
 982                   begin
 983                     State := STATE_FREE;
 984                     Break;
 985                   end;
 986
 987                   c := gCollideMap[Y, X+s];
 988
 989                   if ByteBool(c and MARK_BLOCKED) then
 990                     begin // Ñòåíà/äâåðü - ïàäàåò âåðòèêàëüíî
 991                       VelX := 0;
 992                       AccelX := 0;
 993                       Break;
 994                     end
 995                   else // Ïóñòî:
 996                     if c = MARK_FREE then
 997                       X := X + s
 998                     else // Îñòàëüíîå:
 999                       begin
1000                         State := STATE_FREE;
1001                         Break;
1002                       end;
1003                 end;
1004               end;
1005
1006               if dY <> 0 then
1007               begin
1008                 if dY > 0 then
1009                   s := 1
1010                 else
1011                   s := -1;
1012
1013                 dY := Abs(dY);
1014
1015                 for b := 1 to dY do
1016                 begin
1017                   if (Y+s >= h) or (Y+s <= 0) then
1018                   begin
1019                     State := STATE_FREE;
1020                     Break;
1021                   end;
1022
1023                   c := gCollideMap[Y+s, X];
1024
1025                   if ByteBool(c and MARK_BLOCKED) then
1026                     begin // Ñòåíà/äâåðü - ïàäàåò âåðòèêàëüíî
1027                       if s < 0 then
1028                         begin
1029                           VelY := -VelY;
1030                           AccelY := Abs(AccelY);
1031                         end
1032                       else // Èëè íå ïàäàåò
1033                         begin
1034                           VelX := 0;
1035                           AccelX := 0;
1036                           VelY := 0;
1037                           AccelY := 0.8;
1038                         end;
1039
1040                       Break;
1041                     end
1042                   else // Ïóñòî:
1043                     if c = MARK_FREE then
1044                       Y := Y + s
1045                     else // Îñàëüíîå:
1046                       begin
1047                         State := STATE_FREE;
1048                         Break;
1049                       end;
1050                 end;
1051               end;
1052
1053               if VelX <> 0.0 then
1054                 VelX := VelX + AccelX;
1055               if VelY <> 0.0 then
1056               begin
1057                 if AccelY < 10 then
1058                   AccelY := AccelY + 0.08;
1059                 VelY := VelY + AccelY;
1060               end;
1061
1062               Time := Time + 1;
1063             end;
1064
1065             PARTICLE_WATER:
1066             begin
1067               if (State = STATE_STICK) and (Random(30) = 15) then
1068               begin // Ñòåêàåò/îòëèïàåò
1069                 VelY := 0.5;
1070                 AccelY := 0.15;
1071                 if (not ByteBool(gCollideMap[Y, X-1] and MARK_BLOCKED)) and
1072                    (not ByteBool(gCollideMap[Y, X+1] and MARK_BLOCKED)) then
1073                   State := STATE_NORMAL;
1074                 Continue;
1075               end;
1076
1077               if not ByteBool(gCollideMap[Y, X] and MARK_BLOCKED) then
1078               begin
1079                 if ByteBool(gCollideMap[Y, X] and MARK_LIFTUP) then
1080                 begin // Ëèôò ââåðõ
1081                   if VelY > -4-Random(3) then
1082                     VelY := VelY - 0.8;
1083                   if Abs(VelX) > 0.1 then
1084                     VelX := VelX - VelX/10.0;
1085                   VelX := VelX + (Random-Random)*0.2;
1086                   AccelY := 0.15;
1087                 end;
1088                 if ByteBool(gCollideMap[Y, X] and MARK_LIFTLEFT) then
1089                 begin // Ïîòîê âëåâî
1090                   if VelX > -8-Random(3) then
1091                     VelX := VelX - 0.8;
1092                   AccelY := 0.15;
1093                 end;
1094                 if ByteBool(gCollideMap[Y, X] and MARK_LIFTRIGHT) then
1095                 begin // Ïîòîê âïðàâî
1096                   if VelX < 8+Random(3) then
1097                     VelX := VelX + 0.8;
1098                   AccelY := 0.15;
1099                 end;
1100               end;
1101
1102               dX := Round(VelX);
1103               dY := Round(VelY);
1104
1105               if (Abs(VelX) < 0.1) and (Abs(VelY) < 0.1) then
1106                 if (State <> STATE_STICK) and
1107                    (not ByteBool(gCollideMap[Y-1, X] and MARK_BLOCKED)) and
1108                    (not ByteBool(gCollideMap[Y, X] and MARK_BLOCKED)) and
1109                    (not ByteBool(gCollideMap[Y+1, X] and MARK_BLOCKED)) then
1110                 begin // Âèñèò â âîçäóõå - êàïàåò
1111                   VelY := 0.8;
1112                   AccelY := 0.5;
1113                   State := STATE_NORMAL;
1114                 end;
1115
1116               if dX <> 0 then
1117               begin
1118                 if dX > 0 then
1119                   s := 1
1120                 else
1121                   s := -1;
1122
1123                 for b := 1 to Abs(dX) do
1124                 begin
1125                   if (X+s >= w) or (X+s <= 0) then
1126                   begin // Ñáîêó ãðàíèöà
1127                     State := STATE_FREE;
1128                     Break;
1129                   end;
1130
1131                   c := gCollideMap[Y, X+s];
1132
1133                   if ByteBool(c and MARK_LIQUID) and (dY > 0) then
1134                   begin // Ñáîêó æèäêîñòü, à ÷àñòèöà óæå ïàäàåò
1135                     State := STATE_FREE;
1136                     Break;
1137                   end;
1138
1139                   if ByteBool(c and MARK_BLOCKED) then
1140                   begin // Ñòåíà/äâåðü
1141                     VelX := 0;
1142                     VelY := 0;
1143                     AccelX := 0;
1144                     AccelY := 0;
1145                     State := STATE_STICK;
1146                     Break;
1147                   end;
1148
1149                   X := X+s;
1150                 end;
1151               end;
1152
1153               if dY <> 0 then
1154               begin
1155                 if dY > 0 then
1156                   s := 1
1157                 else
1158                   s := -1;
1159
1160                 for b := 1 to Abs(dY) do
1161                 begin
1162                   if (Y+s >= h) or (Y+s <= 0) then
1163                   begin // Ñíèçó/ñâåðõó ãðàíèöà
1164                     State := STATE_FREE;
1165                     Break;
1166                   end;
1167
1168                   c := gCollideMap[Y+s, X];
1169
1170                   if ByteBool(c and MARK_LIQUID) and (dY > 0) then
1171                   begin // Ñíèçó æèäêîñòü, à ÷àñòèöà óæå ïàäàåò
1172                     State := STATE_FREE;
1173                     Break;
1174                   end;
1175
1176                   if ByteBool(c and MARK_BLOCKED) then
1177                   begin // Ñòåíà/äâåðü
1178                     VelX := 0;
1179                     VelY := 0;
1180                     AccelX := 0;
1181                     AccelY := 0;
1182                     if (s > 0) and (State <> STATE_STICK) then
1183                       State := STATE_NORMAL
1184                     else
1185                       State := STATE_STICK;
1186                     Break;
1187                   end;
1188
1189                   Y := Y+s;
1190                 end;
1191               end;
1192
1193               VelX := VelX + AccelX;
1194               VelY := VelY + AccelY;
1195
1196               Time := Time + 1;
1197             end;
1198
1199             PARTICLE_BUBBLES:
1200             begin
1201               dY := Round(VelY);
1202
1203               if dY <> 0 then
1204               begin
1205                 if dY > 0 then
1206                   s := 1
1207                 else
1208                   s := -1;
1209
1210                 for b := 1 to Abs(dY) do
1211                 begin
1212                   if (Y+s >= h) or (Y+s <= 0) then
1213                   begin
1214                     State := STATE_FREE;
1215                     Break;
1216                   end;
1217
1218                   if not ByteBool(gCollideMap[Y+s, X] and MARK_LIQUID) then
1219                   begin // Óæå íå æèäêîñòü
1220                     State := STATE_FREE;
1221                     Break;
1222                   end;
1223
1224                   Y := Y+s;
1225                 end;
1226               end;
1227
1228               if VelY > -4 then
1229                 VelY := VelY + AccelY;
1230
1231               Time := Time + 1;
1232             end;
1233           end; // case
1234
1235           CorrectOffsets(a);
1236         end;
1237   end; // Particles <> nil
1238
1239   if OnceAnims <> nil then
1240   begin
1241     for a := 0 to High(OnceAnims) do
1242       if OnceAnims[a].Animation <> nil then
1243       begin
1244         case OnceAnims[a].AnimType of
1245           ONCEANIM_SMOKE:
1246             begin
1247               if Random(3) = 0 then
1248                 OnceAnims[a].X := OnceAnims[a].X-1+Random(3);
1249               if Random(2) = 0 then
1250                 OnceAnims[a].Y := OnceAnims[a].Y-Random(2);
1251             end;
1252         end;
1253
1254         if OnceAnims[a].Animation.Played then
1255           begin
1256             OnceAnims[a].Animation.Free();
1257             OnceAnims[a].Animation := nil;
1258           end
1259         else
1260           OnceAnims[a].Animation.Update();
1261       end;
1262   end;
1263 end;
1264
1265 procedure g_GFX_Draw();
1266 var
1267   a, len: Integer;
1268 begin
1269   if Particles <> nil then
1270   begin
1271     glDisable(GL_TEXTURE_2D);
1272     glPointSize(2);
1273
1274     glEnable(GL_BLEND);
1275     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1276
1277     glBegin(GL_POINTS);
1278
1279     len := High(Particles);
1280
1281     for a := 0 to len do
1282       with Particles[a] do
1283         if (State <> STATE_FREE) and (X >= sX) and (Y >= sY) and
1284            (X <= sX+sWidth) and (sY <= sY+sHeight) then
1285         begin
1286           glColor4ub(Red, Green, Blue, Alpha);
1287           glVertex2i(X + offsetX, Y + offsetY);
1288         end;
1289
1290     glEnd();
1291
1292     glDisable(GL_BLEND);
1293   end;
1294
1295   if OnceAnims <> nil then
1296     for a := 0 to High(OnceAnims) do
1297       if OnceAnims[a].Animation <> nil then
1298         with OnceAnims[a] do
1299           Animation.Draw(X, Y, M_NONE);
1300 end;
1301
1302 end.