Mercurial Mercurial > hedgewars / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hedgewars/uVisualGears.pas
changeset 3593 ae50f63e4fa9
parent 3592 0bcad5c38c9e
child 3594 aeca3d8f1b29
equal deleted inserted replaced
3592:0bcad5c38c9e 3593:ae50f63e4fa9 
    26     TVGearStepProcedure = procedure (Gear: PVisualGear; Steps: Longword);
 
    26     TVGearStepProcedure = procedure (Gear: PVisualGear; Steps: Longword);
 
    27     TVisualGear = record
 
    27     TVisualGear = record
 
    28         NextGear, PrevGear: PVisualGear;
 
    28         NextGear, PrevGear: PVisualGear;
 
    29         Frame,
 
    29         Frame,
 
    30         FrameTicks: Longword;
 
    30         FrameTicks: Longword;
 
    31         X : hwFloat;
 
    31         X : float;
 
    32         Y : hwFloat;
 
    32         Y : float;
 
    33         dX: hwFloat;
 
    33         dX: float;
 
    34         dY: hwFloat;
 
    34         dY: float;
 
    35         tdX: hwFloat;
 
    35         tdX: float;
 
    36         tdY: hwFloat;
 
    36         tdY: float;
 
    37         mdY: QWord;
 
       
    38         State : Longword;
 
    37         State : Longword;
 
    39         Timer: Longword;
 
    38         Timer: Longword;
 
    40         Angle, dAngle: real;
 
    39         Angle, dAngle: real;
 
    41         Kind: TVisualGearType;
 
    40         Kind: TVisualGearType;
 
    42         doStep: TVGearStepProcedure;
 
    41         doStep: TVGearStepProcedure;
 
   121         );
 
   120         );
 
   122 
   121 
   123 function  AddVisualGear(X, Y: LongInt; Kind: TVisualGearType; State: LongWord = 0): PVisualGear;
 
   122 function  AddVisualGear(X, Y: LongInt; Kind: TVisualGearType; State: LongWord = 0): PVisualGear;
 
   124 var gear: PVisualGear;
 
   123 var gear: PVisualGear;
 
   125     t: Longword;
 
   124     t: Longword;
 
   126     sp: hwFloat;
 
   125     sp: float;
 
   127 begin
 
   126 begin
 
   128 if (GameType = gmtSave) or (fastUntilLag and (GameType = gmtNet)) then // we are scrolling now
 
   127 if (GameType = gmtSave) or (fastUntilLag and (GameType = gmtNet)) then // we are scrolling now
 
   129     if Kind <> vgtCloud then
 
   128     if Kind <> vgtCloud then
 
   130         begin
 
   129         begin
 
   131         AddVisualGear:= nil;
 
   130         AddVisualGear:= nil;
 
   146     exit
 
   145     exit
 
   147     end;
 
   146     end;
 
   148 
   147 
   149 New(gear);
 
   148 New(gear);
 
   150 FillChar(gear^, sizeof(TVisualGear), 0);
 
   149 FillChar(gear^, sizeof(TVisualGear), 0);
 
   151 gear^.X:= int2hwFloat(X);
 
   150 gear^.X:= float(X);
 
   152 gear^.Y:= int2hwFloat(Y);
 
   151 gear^.Y:= float(Y);
 
   153 gear^.Kind := Kind;
 
   152 gear^.Kind := Kind;
 
   154 gear^.doStep:= doStepHandlers[Kind];
 
   153 gear^.doStep:= doStepHandlers[Kind];
 
   155 gear^.State:= 0;
 
   154 gear^.State:= 0;
 
   156 gear^.Tint:= $FFFFFFFF;
 
   155 gear^.Tint:= $FFFFFFFF;
 
   157 
   156 
   158 with gear^ do
 
   157 with gear^ do
 
   159     case Kind of
 
   158     case Kind of
 
   160     vgtFlake: begin
 
   159     vgtFlake: begin
 
   161                 Timer:= 0;
 
   160                 Timer:= 0;
 
   162                 tdX:= _0;
 
   161                 tdX:= 0;
 
   163                 tdY:= _0;
 
   162                 tdY:= 0;
 
   164                 FrameTicks:= random(vobFrameTicks);
 
   163                 FrameTicks:= random(vobFrameTicks);
 
   165                 Frame:= random(vobFramesCount);
 
   164                 Frame:= random(vobFramesCount);
 
   166                 Angle:= random * 360;
 
   165                 Angle:= random * 360;
 
   167                 dx.isNegative:= random(2) = 0;
 
   166                 dx:= 0.0000038654705 * random(10000);
 
   168                 dx.QWordValue:= random(100000000);
 
   167                 dy:= 0.000003506096 * random(7000);
 
   169                 dy.isNegative:= false;
 
   168                 if random(2) = 0 then dx*=-1;
 
   170                 dy.QWordValue:= random(70000000);
 
       
   171                 dAngle:= (random(2) * 2 - 1) * (1 + random) * vobVelocity / 1000
 
   169                 dAngle:= (random(2) * 2 - 1) * (1 + random) * vobVelocity / 1000
 
   172                 end;
 
   170                 end;
 
   173     vgtCloud: begin
 
   171     vgtCloud: begin
 
   174                 Frame:= random(4);
 
   172                 Frame:= random(4);
 
   175                 dx.isNegative:= random(2) = 0;
 
   173                 dx:= 0.000005 * random(10000);
 
   176                 dx.QWordValue:= random(214748364);
 
   174                 if random(2) = 0 then dx*=-1;
 
   177                 mdY:= random(4096);
 
   175                 timer:= random(4096);
 
   178                 end;
 
   176                 end;
 
   179     vgtExplPart,
 
   177     vgtExplPart,
 
   180     vgtExplPart2: begin
 
   178     vgtExplPart2: begin
 
   181                 t:= random(1024);
 
   179                 t:= random(1024);
 
   182                 sp:= _0_001 * (random(95) + 70);
 
   180                 sp:= 0.001 * (random(95) + 70);
 
   183                 dx:= AngleSin(t) * sp;
 
   181                 dx:= AngleSin(t).QWordValue/4294967296 * sp;
 
   184                 dx.isNegative:= random(2) = 0;
 
   182                 dy:= AngleCos(t).QWordValue/4294967296 * sp;
 
   185                 dy:= AngleCos(t) * sp;
 
   183                 if random(2) = 0 then dx*=-1;
 
   186                 dy.isNegative:= random(2) = 0;
 
   184                 if random(2) = 0 then dy*=-1;
 
   187                 Frame:= 7 - random(3);
 
   185                 Frame:= 7 - random(3);
 
   188                 FrameTicks:= cExplFrameTicks
 
   186                 FrameTicks:= cExplFrameTicks
 
   189                 end;
 
   187                 end;
 
   190         vgtFire: begin
 
   188         vgtFire: begin
 
   191                 t:= random(1024);
 
   189                 t:= random(1024);
 
   192                 sp:= _0_001 * (random(85) + 95);
 
   190                 sp:= 0.001 * (random(85) + 95);
 
   193                 dx:= AngleSin(t) * sp;
 
   191                 dx:= AngleSin(t).QWordValue/4294967296 * sp;
 
   194                 dx.isNegative:= random(2) = 0;
 
   192                 dy:= AngleCos(t).QWordValue/4294967296 * sp;
 
   195                 dy:= AngleCos(t) * sp;
 
   193                 if random(2) = 0 then dx*=-1;
 
   196                 dy.isNegative:= random(2) = 0;
 
   194                 if random(2) = 0 then dy*=-1;
 
   197                 FrameTicks:= 650 + random(250);
 
   195                 FrameTicks:= 650 + random(250);
 
   198                 Frame:= random(8)
 
   196                 Frame:= random(8)
 
   199                 end;
 
   197                 end;
 
   200          vgtEgg: begin
 
   198          vgtEgg: begin
 
   201                 t:= random(1024);
 
   199                 t:= random(1024);
 
   202                 sp:= _0_001 * (random(85) + 95);
 
   200                 sp:= 0.001 * (random(85) + 95);
 
   203                 dx:= AngleSin(t) * sp;
 
   201                 dx:= AngleSin(t).QWordValue/4294967296 * sp;
 
   204                 dx.isNegative:= random(2) = 0;
 
   202                 dy:= AngleCos(t).QWordValue/4294967296 * sp;
 
   205                 dy:= AngleCos(t) * sp;
 
   203                 if random(2) = 0 then dx*=-1;
 
   206                 dy.isNegative:= random(2) = 0;
 
   204                 if random(2) = 0 then dy*=-1;
 
   207                 FrameTicks:= 650 + random(250);
 
   205                 FrameTicks:= 650 + random(250);
 
   208                 Frame:= 1
 
   206                 Frame:= 1
 
   209                 end;
 
   207                 end;
 
   210         vgtShell: FrameTicks:= 500;
 
   208         vgtShell: FrameTicks:= 500;
 
   211     vgtSmallDamageTag: begin
 
   209     vgtSmallDamageTag: begin
 
   212                 gear^.FrameTicks:= 1100
 
   210                 gear^.FrameTicks:= 1100
 
   213                 end;
 
   211                 end;
 
   214     vgtBubble: begin
 
   212     vgtBubble: begin
 
   215                 dx.isNegative:= random(2) = 0;
 
   213                 dx:= 0.0000038654705 * random(10000);
 
   216                 dx.QWordValue:= random(100000000);
 
   214                 dy:= 0.001 * (random(85) + 95);
 
   217                 dy:= _0_001 * (random(85) + 95);
 
   215                 if random(2) = 0 then dx*=-1;
 
   218                 dy.isNegative:= false;
 
       
   219                 FrameTicks:= 250 + random(1751);
 
   216                 FrameTicks:= 250 + random(1751);
 
   220                 Frame:= random(5)
 
   217                 Frame:= random(5)
 
   221                 end;
 
   218                 end;
 
   222     vgtSteam: begin
 
   219     vgtSteam: begin
 
   223                 dx.isNegative:= random(2) = 0;
 
   220                 dx:= 0.0000038654705 * random(10000);
 
   224                 dx.QWordValue:= random(100000000);
 
   221                 dy:= 0.001 * (random(85) + 95);
 
   225                 dy:= _0_001 * (random(85) + 95);
 
   222                 if random(2) = 0 then dx*=-1;
 
   226                 dy.isNegative:= false;
 
       
   227                 Frame:= 7 - random(3);
 
   223                 Frame:= 7 - random(3);
 
   228                 FrameTicks:= cExplFrameTicks * 2;
 
   224                 FrameTicks:= cExplFrameTicks * 2;
 
   229                 end;
 
   225                 end;
 
   230     vgtAmmo: begin
 
   226     vgtAmmo: begin
 
   231                 alpha:= 1.0;
 
   227                 alpha:= 1.0;
 
   232                 scale:= 1.0
 
   228                 scale:= 1.0
 
   233                 end;
 
   229                 end;
 
   234   vgtSmokeWhite, 
   230   vgtSmokeWhite, 
   235   vgtSmoke: begin
 
   231   vgtSmoke: begin
 
   236                 dx:= _0_0002 * (random(45) + 10);
 
   232                 dx:= 0.0002 * (random(45) + 10);
 
   237                 dx.isNegative:= random(2) = 0;
 
   233                 dy:= 0.0002 * (random(45) + 10);
 
   238                 dy:= _0_0002 * (random(45) + 10);
 
   234                 if random(2) = 0 then dx*=-1;
 
   239                 dy.isNegative:= false;
 
       
   240                 Frame:= 7 - random(2);
 
   235                 Frame:= 7 - random(2);
 
   241                 FrameTicks:= cExplFrameTicks * 2;
 
   236                 FrameTicks:= cExplFrameTicks * 2;
 
   242                 end;
 
   237                 end;
 
   243     vgtHealth: begin
 
   238     vgtHealth: begin
 
   244                 dx:= _0_001 * random(45);
 
   239                 dx:= 0.001 * random(45);
 
   245                 dx.isNegative:= random(2) = 0;
 
   240                 dy:= 0.001 * (random(20) + 25);
 
   246                 dy:= _0_001 * (random(20) + 25);
 
   241                 if random(2) = 0 then dx*=-1;
 
   247                 Frame:= 0;
 
   242                 Frame:= 0;
 
   248                 FrameTicks:= random(750) + 1250;
 
   243                 FrameTicks:= random(750) + 1250;
 
   249                 end;
 
   244                 end;
 
   250   vgtDust: begin
 
   245   vgtDust: begin
 
   251                 dx:= _0_005 * (random(15) + 10);
 
   246                 dx:= 0.005 * (random(15) + 10);
 
   252                 dx.isNegative:= random(2) = 0;
 
   247                 dy:= 0.001 * (random(40) + 20);
 
   253                 dy:= _0_001 * (random(40) + 20);
 
   248                 if random(2) = 0 then dx*=-1;
 
   254                 Frame:= 7 - random(2);
 
   249                 Frame:= 7 - random(2);
 
   255                 FrameTicks:= random(20) + 15;
 
   250                 FrameTicks:= random(20) + 15;
 
   256                 end;
 
   251                 end;
 
   257   vgtSplash: begin
 
   252   vgtSplash: begin
 
   258                 dx:= _0;
 
   253                 dx:= 0;
 
   259                 dx.isNegative:= false;
 
   254                 dy:= 0;
 
   260                 dy:= _0;
 
       
   261                 FrameTicks:= 740;
 
   255                 FrameTicks:= 740;
 
   262                 Frame:= 19;
 
   256                 Frame:= 19;
 
   263                 end;
 
   257                 end;
 
   264     vgtDroplet: begin
 
   258     vgtDroplet: begin
 
   265                 dx:= _0_001 * (random(75) + 15);
 
   259                 dx:= 0.001 * (random(75) + 15);
 
   266                 dx.isNegative:= random(2) = 0;
 
   260                 dy:= -0.001 * (random(80) + 120);
 
   267                 dy:= _0_001 * (random(80) + 120);
 
   261                 if random(2) = 0 then dx*=-1;
 
   268                 dy.isNegative:= true;
 
       
   269                 FrameTicks:= 250 + random(1751);
 
   262                 FrameTicks:= 250 + random(1751);
 
   270                 Frame:= random(3)
 
   263                 Frame:= random(3)
 
   271                 end;
 
   264                 end;
 
   272    vgtBeeTrace: begin
 
   265    vgtBeeTrace: begin
 
   273                 FrameTicks:= 1000;
 
   266                 FrameTicks:= 1000;
 
   274                 Frame:= random(16);
 
   267                 Frame:= random(16);
 
   275                 end;
 
   268                 end;
 
   276     vgtSmokeRing: begin
 
   269     vgtSmokeRing: begin
 
   277                 dx:= _0;
 
   270                 dx:= 0;
 
   278                 dx.isNegative:= false;
 
   271                 dy:= 0;
 
   279                 dy:= _0;
 
       
   280                 dy.isNegative:= false;
 
       
   281                 FrameTicks:= 600;
 
   272                 FrameTicks:= 600;
 
   282                 Timer:= 0;
 
   273                 Timer:= 0;
 
   283                 Frame:= 0;
 
   274                 Frame:= 0;
 
   284                 scale:= 0.6;
 
   275                 scale:= 0.6;
 
   285                 alpha:= 1;
 
   276                 alpha:= 1;
 
   286                 angle:= random(360);
 
   277                 angle:= random(360);
 
   287                 end;
 
   278                 end;
 
   288      vgtFeather: begin
 
   279      vgtFeather: begin
 
   289                 t:= random(1024);
 
   280                 t:= random(1024);
 
   290                 sp:= _0_001 * (random(85) + 95);
 
   281                 sp:= 0.001 * (random(85) + 95);
 
   291                 dx:= AngleSin(t) * sp;
 
   282                 dx:= AngleSin(t).QWordValue/4294967296 * sp;
 
   292                 dx.isNegative:= random(2) = 0;
 
   283                 dy:= AngleCos(t).QWordValue/4294967296 * sp;
 
   293                 dy:= AngleCos(t) * sp;
 
   284                 if random(2) = 0 then dx*=-1;
 
   294                 dy.isNegative:= random(2) = 0;
 
   285                 if random(2) = 0 then dy*=-1;
 
   295                 FrameTicks:= 650 + random(250);
 
   286                 FrameTicks:= 650 + random(250);
 
   296                 Frame:= 1
 
   287                 Frame:= 1
 
   297                 end;
 
   288                 end;
 
   298   vgtHealthTag: begin
 
   289   vgtHealthTag: begin
 
   299                 gear^.Timer:= 1500;
 
   290                 gear^.Timer:= 1500;
 
   300                 //gear^.Z:= 2002;
 
   291                 //gear^.Z:= 2002;
 
   301                 end;
 
   292                 end;
 
   302   vgtSmokeTrace,
 
   293   vgtSmokeTrace,
 
   303   vgtEvilTrace: begin
 
   294   vgtEvilTrace: begin
 
   304                 gear^.X:= gear^.X - _16;
 
   295                 gear^.X:= gear^.X - 16;
 
   305                 gear^.Y:= gear^.Y - _16;
 
   296                 gear^.Y:= gear^.Y - 16;
 
   306                 gear^.State:= 8;
 
   297                 gear^.State:= 8;
 
   307                 //gear^.Z:= cSmokeZ
 
   298                 //gear^.Z:= cSmokeZ
 
   308                 end;
 
   299                 end;
 
   309 vgtBigExplosion: begin
 
   300 vgtBigExplosion: begin
 
   310                 gear^.Angle:= random(360);
 
   301                 gear^.Angle:= random(360);
 
   360       begin
 
   351       begin
 
   361       Gear:= t;
 
   352       Gear:= t;
 
   362       if Gear^.Kind = vgtFlake then
 
   353       if Gear^.Kind = vgtFlake then
 
   363           begin
 
   354           begin
 
   364           // Damage calc from doMakeExplosion
 
   355           // Damage calc from doMakeExplosion
 
   365           dmg:= min(100,Radius  + cHHRadius div 2 - (hwRound(hwAbs(Gear^.X - int2hwFloat(X))+hwAbs(Gear^.Y - int2hwFloat(Y))) div 5));
 
   356           dmg:= min(101,Radius  + cHHRadius div 2 - (round(abs(Gear^.X - float(X))+abs(Gear^.Y - float(Y))) div 5));
 
   366           if dmg > 1 then
 
   357           if dmg > 1 then
 
   367               begin
 
   358               begin
 
   368               Gear^.tdX:= SignAs(_0_02 * dmg + cHHKick, Gear^.X - int2hwFloat(X));
 
   359               Gear^.tdX:= 0.02 * dmg + 0.01;
 
   369               Gear^.tdY:= SignAs(_0_02 * dmg + cHHKick, Gear^.Y - int2hwFloat(Y));
 
   360               if Gear^.X - X < 0 then Gear^.tdX *= -1;
 
       
   361               Gear^.tdY:= 0.02 * dmg + 0.01;
 
       
   362               if Gear^.Y - Y < 0 then Gear^.tdY *= -1;
 
   370               Gear^.Timer:= 200
 
   363               Gear^.Timer:= 200
 
   371               end
 
   364               end
 
   372           end;
 
   365           end;
 
   373       t:= Gear^.NextGear
 
   366       t:= Gear^.NextGear
 
   374       end
 
   367       end
 
   382     0: while Gear <> nil do
 
   375     0: while Gear <> nil do
 
   383         begin
 
   376         begin
 
   384         Tint(Gear^.Tint);
 
   377         Tint(Gear^.Tint);
 
   385         case Gear^.Kind of
 
   378         case Gear^.Kind of
 
   386             vgtFlake: if vobVelocity = 0 then
 
   379             vgtFlake: if vobVelocity = 0 then
 
   387                         DrawSprite(sprFlake, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame)
 
   380                         DrawSprite(sprFlake, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame)
 
   388                     else
 
   381                     else
 
   389                         DrawRotatedF(sprFlake, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle);
 
   382                         DrawRotatedF(sprFlake, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle);
 
   390             vgtCloud: DrawSprite(sprCloud, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame);
 
   383             vgtCloud: DrawSprite(sprCloud, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame);
 
   391             end;
 
   384             end;
 
   392         Gear:= Gear^.NextGear
 
   385         Gear:= Gear^.NextGear
 
   393         end;
 
   386         end;
 
   394     1: while Gear <> nil do
 
   387     1: while Gear <> nil do
 
   395         begin
 
   388         begin
 
   396         Tint(Gear^.Tint);
 
   389         Tint(Gear^.Tint);
 
   397         case Gear^.Kind of
 
   390         case Gear^.Kind of
 
   398             vgtSmokeTrace: if Gear^.State < 8 then DrawSprite(sprSmokeTrace, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.State);
 
   391             vgtSmokeTrace: if Gear^.State < 8 then DrawSprite(sprSmokeTrace, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.State);
 
   399             vgtEvilTrace: if Gear^.State < 8 then DrawSprite(sprEvilTrace, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.State);
 
   392             vgtEvilTrace: if Gear^.State < 8 then DrawSprite(sprEvilTrace, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.State);
 
   400         end;
 
   393         end;
 
   401             if not cReducedQuality then
 
   394             if not cReducedQuality then
 
   402                 case Gear^.Kind of
 
   395                 case Gear^.Kind of
 
   403                     vgtSmoke: DrawSprite(sprSmoke, hwRound(Gear^.X) + WorldDx - 11, hwRound(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame);
 
   396                     vgtSmoke: DrawSprite(sprSmoke, round(Gear^.X) + WorldDx - 11, round(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame);
 
   404                     vgtSmokeWhite: DrawSprite(sprSmokeWhite, hwRound(Gear^.X) + WorldDx - 11, hwRound(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame);
 
   397                     vgtSmokeWhite: DrawSprite(sprSmokeWhite, round(Gear^.X) + WorldDx - 11, round(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame);
 
   405                     vgtDust: DrawSprite(sprDust, hwRound(Gear^.X) + WorldDx - 11, hwRound(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame);
 
   398                     vgtDust: DrawSprite(sprDust, round(Gear^.X) + WorldDx - 11, round(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame);
 
   406                     vgtFeather: begin
 
   399                     vgtFeather: begin
 
   407                             if Gear^.FrameTicks < 255 then
 
   400                             if Gear^.FrameTicks < 255 then
 
   408                                 Tint($FF, $FF, $FF, Gear^.FrameTicks);
 
   401                                 Tint($FF, $FF, $FF, Gear^.FrameTicks);
 
   409                             DrawRotatedF(sprFeather, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle);
 
   402                             DrawRotatedF(sprFeather, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle);
 
   410                             end;
 
   403                             end;
 
   411                  end;
 
   404                  end;
 
   412         Gear:= Gear^.NextGear
 
   405         Gear:= Gear^.NextGear
 
   413         end;
 
   406         end;
 
   414     2: while Gear <> nil do
 
   407     2: while Gear <> nil do
 
   415         begin
 
   408         begin
 
   416         Tint(Gear^.Tint);
 
   409         Tint(Gear^.Tint);
 
   417         case Gear^.Kind of
 
   410         case Gear^.Kind of
 
   418             vgtExplosion: DrawSprite(sprExplosion50, hwRound(Gear^.X) - 32 + WorldDx, hwRound(Gear^.Y) - 32 + WorldDy, Gear^.State);
 
   411             vgtExplosion: DrawSprite(sprExplosion50, round(Gear^.X) - 32 + WorldDx, round(Gear^.Y) - 32 + WorldDy, Gear^.State);
 
   419             vgtBigExplosion: begin
 
   412             vgtBigExplosion: begin
 
   420                              Tint($FF, $FF, $FF, floor($FF * (1 - power(Gear^.Timer / 250, 4))));
 
   413                              Tint($FF, $FF, $FF, floor($FF * (1 - power(Gear^.Timer / 250, 4))));
 
   421                              DrawRotatedTextureF(SpritesData[sprBigExplosion].Texture, 0.85 * (-power(2, -10 * Int(Gear^.Timer)/250) + 1) + 0.4, 0, 0, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, 1, 385, 385, Gear^.Angle);
 
   414                              DrawRotatedTextureF(SpritesData[sprBigExplosion].Texture, 0.85 * (-power(2, -10 * Int(Gear^.Timer)/250) + 1) + 0.4, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 0, 1, 385, 385, Gear^.Angle);
 
   422                              end;
 
   415                              end;
 
   423             end;
 
   416             end;
 
   424         if not cReducedQuality then
 
   417         if not cReducedQuality then
 
   425             case Gear^.Kind of
 
   418             case Gear^.Kind of
 
   426                 vgtExplPart: DrawSprite(sprExplPart, hwRound(Gear^.X) + WorldDx - 16, hwRound(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame);
 
   419                 vgtExplPart: DrawSprite(sprExplPart, round(Gear^.X) + WorldDx - 16, round(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame);
 
   427                 vgtExplPart2: DrawSprite(sprExplPart2, hwRound(Gear^.X) + WorldDx - 16, hwRound(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame);
 
   420                 vgtExplPart2: DrawSprite(sprExplPart2, round(Gear^.X) + WorldDx - 16, round(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame);
 
   428                 vgtFire: DrawSprite(sprFlame, hwRound(Gear^.X) + WorldDx - 8, hwRound(Gear^.Y) + WorldDy, (RealTicks div 64 + Gear^.Frame) mod 8);
 
   421                 vgtFire: DrawSprite(sprFlame, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy, (RealTicks div 64 + Gear^.Frame) mod 8);
 
   429                 vgtBubble: DrawSprite(sprBubbles, hwRound(Gear^.X) + WorldDx - 8, hwRound(Gear^.Y) + WorldDy - 8, Gear^.Frame);//(RealTicks div 64 + Gear^.Frame) mod 8);
 
   422                 vgtBubble: DrawSprite(sprBubbles, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy - 8, Gear^.Frame);//(RealTicks div 64 + Gear^.Frame) mod 8);
 
   430                 vgtSteam: DrawSprite(sprExplPart, hwRound(Gear^.X) + WorldDx - 16, hwRound(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame);
 
   423                 vgtSteam: DrawSprite(sprExplPart, round(Gear^.X) + WorldDx - 16, round(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame);
 
   431                 vgtAmmo: begin
 
   424                 vgtAmmo: begin
 
   432                         Tint($FF, $FF, $FF, floor(Gear^.alpha * $FF));
 
   425                         Tint($FF, $FF, $FF, floor(Gear^.alpha * $FF));
 
   433                         DrawTextureF(ropeIconTex, Gear^.scale, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, 1, 32, 32);
 
   426                         DrawTextureF(ropeIconTex, Gear^.scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 0, 1, 32, 32);
 
   434                         DrawTextureF(SpritesData[sprAMAmmos].Texture, Gear^.scale * 0.90, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Frame - 1, 1, 32, 32);
 
   427                         DrawTextureF(SpritesData[sprAMAmmos].Texture, Gear^.scale * 0.90, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame - 1, 1, 32, 32);
 
   435                         end;
 
   428                         end;
 
   436                 vgtHealth:  begin
 
   429                 vgtHealth:  begin
 
   437                             case Gear^.Frame div 10 of
 
   430                             case Gear^.Frame div 10 of
 
   438                                 0:Tint(0, $FF, 0, floor(Gear^.FrameTicks * $FF / 1000));
 
   431                                 0:Tint(0, $FF, 0, floor(Gear^.FrameTicks * $FF / 1000));
 
   439                                 1:Tint($FF, 0, 0, floor(Gear^.FrameTicks * $FF / 1000));
 
   432                                 1:Tint($FF, 0, 0, floor(Gear^.FrameTicks * $FF / 1000));
 
   440                             end;
 
   433                             end;
 
   441                             DrawSprite(sprHealth, hwRound(Gear^.X) + WorldDx - 8, hwRound(Gear^.Y) + WorldDy - 8, 0);
 
   434                             DrawSprite(sprHealth, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy - 8, 0);
 
   442                             end;
 
   435                             end;
 
   443                 vgtShell: begin
 
   436                 vgtShell: begin
 
   444                             if Gear^.FrameTicks < $FF then
 
   437                             if Gear^.FrameTicks < $FF then
 
   445                                 Tint($FF, $FF, $FF, Gear^.FrameTicks);
 
   438                                 Tint($FF, $FF, $FF, Gear^.FrameTicks);
 
   446                             DrawRotatedF(sprShell, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle);
 
   439                             DrawRotatedF(sprShell, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle);
 
   447                             end;
 
   440                             end;
 
   448                   vgtEgg: begin
 
   441                   vgtEgg: begin
 
   449                             if Gear^.FrameTicks < $FF then
 
   442                             if Gear^.FrameTicks < $FF then
 
   450                                 Tint($FF, $FF, $FF, Gear^.FrameTicks);
 
   443                                 Tint($FF, $FF, $FF, Gear^.FrameTicks);
 
   451                             DrawRotatedF(sprEgg, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle);
 
   444                             DrawRotatedF(sprEgg, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle);
 
   452                             end;
 
   445                             end;
 
   453                 vgtSplash: DrawSprite(sprSplash, hwRound(Gear^.X) + WorldDx - 40, hwRound(Gear^.Y) + WorldDy - 58, 19 - (Gear^.FrameTicks div 37));
 
   446                 vgtSplash: DrawSprite(sprSplash, round(Gear^.X) + WorldDx - 40, round(Gear^.Y) + WorldDy - 58, 19 - (Gear^.FrameTicks div 37));
 
   454                 vgtDroplet: DrawSprite(sprDroplet, hwRound(Gear^.X) + WorldDx - 8, hwRound(Gear^.Y) + WorldDy - 8, Gear^.Frame);
 
   447                 vgtDroplet: DrawSprite(sprDroplet, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy - 8, Gear^.Frame);
 
   455                vgtBeeTrace: begin
 
   448                vgtBeeTrace: begin
 
   456                             if Gear^.FrameTicks < $FF then
 
   449                             if Gear^.FrameTicks < $FF then
 
   457                                 Tint($FF, $FF, $FF, Gear^.FrameTicks div 2)
 
   450                                 Tint($FF, $FF, $FF, Gear^.FrameTicks div 2)
 
   458                             else
 
   451                             else
 
   459                                 Tint($FF, $FF, $FF, $80);
 
   452                                 Tint($FF, $FF, $FF, $80);
 
   460                             DrawRotatedF(sprBeeTrace, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Frame, 1, (RealTicks shr 4) mod cMaxAngle);
 
   453                             DrawRotatedF(sprBeeTrace, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, (RealTicks shr 4) mod cMaxAngle);
 
   461                             end;
 
   454                             end;
 
   462                 vgtSmokeRing: begin
 
   455                 vgtSmokeRing: begin
 
   463                             Tint($FF, $FF, $FF, floor(Gear^.alpha * $FF));
 
   456                             Tint($FF, $FF, $FF, floor(Gear^.alpha * $FF));
 
   464                             DrawRotatedTextureF(SpritesData[sprSmokeRing].Texture, Gear^.scale, 0, 0, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, 1, 200, 200, Gear^.Angle);
 
   457                             DrawRotatedTextureF(SpritesData[sprSmokeRing].Texture, Gear^.scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 0, 1, 200, 200, Gear^.Angle);
 
   465                             end;
 
   458                             end;
 
   466             end;
 
   459             end;
 
   467         case Gear^.Kind of
 
   460         case Gear^.Kind of
 
   468             vgtSmallDamageTag: DrawCentered(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Tex);
 
   461             vgtSmallDamageTag: DrawCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex);
 
   469             vgtSpeechBubble: if Gear^.Tex <> nil then DrawCentered(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Tex);
 
   462             vgtSpeechBubble: if Gear^.Tex <> nil then DrawCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex);
 
   470             vgtHealthTag: if Gear^.Tex <> nil then DrawCentered(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Tex);
 
   463             vgtHealthTag: if Gear^.Tex <> nil then DrawCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex);
 
   471         end;
 
   464         end;
 
   472         Gear:= Gear^.NextGear
 
   465         Gear:= Gear^.NextGear
 
   473         end
 
   466         end
 
   474     end
 
   467     end
 
   475 end;
 
   468 end;
hedgewars