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/VGSHandlers.inc
changeset 6580 6155187bf599
parent 6553 91365db8b82c
child 6700 e04da46ee43c
equal deleted inserted replaced
6579:fc52f7c22c9b 6580:6155187bf599 
    36     inc(FrameTicks, Steps);
 
    36     inc(FrameTicks, Steps);
 
    37     if not SuddenDeathDmg and (FrameTicks > vobFrameTicks) then
 
    37     if not SuddenDeathDmg and (FrameTicks > vobFrameTicks) then
 
    38         begin
 
    38         begin
 
    39         dec(FrameTicks, vobFrameTicks);
 
    39         dec(FrameTicks, vobFrameTicks);
 
    40         inc(Frame);
 
    40         inc(Frame);
 
    41         if Frame = vobFramesCount then Frame:= 0
 
    41         if Frame = vobFramesCount then
 
       
    42             Frame:= 0
 
    42         end
 
    43         end
 
    43     else if SuddenDeathDmg and (FrameTicks > vobSDFrameTicks) then
 
    44     else if SuddenDeathDmg and (FrameTicks > vobSDFrameTicks) then
 
    44         begin
 
    45         begin
 
    45         dec(FrameTicks, vobSDFrameTicks);
 
    46         dec(FrameTicks, vobSDFrameTicks);
 
    46         inc(Frame);
 
    47         inc(Frame);
 
    47         if Frame = vobSDFramesCount then Frame:= 0
 
    48         if Frame = vobSDFramesCount then
 
       
    49             Frame:= 0
 
    48         end;
 
    50         end;
 
    49     X:= X + (cWindSpeedf * 400 + dX + tdX) * Steps * Gear^.Scale;
 
    51     X:= X + (cWindSpeedf * 400 + dX + tdX) * Steps * Gear^.Scale;
 
    50     if SuddenDeathDmg then
 
    52     if SuddenDeathDmg then
 
    51         Y:= Y + (dY + tdY + cGravityf * vobSDFallSpeed) * Steps * Gear^.Scale
 
    53         Y:= Y + (dY + tdY + cGravityf * vobSDFallSpeed) * Steps * Gear^.Scale
 
    52     else
 
    54     else
 
    57     else
 
    59     else
 
    58         if Angle < - 360 then
 
    60         if Angle < - 360 then
 
    59             Angle:= Angle + 360;
 
    61             Angle:= Angle + 360;
 
    60     
    62     
    61   
    63   
    62     if (round(X) >= cLeftScreenBorder) and
 
    64     if (round(X) >= cLeftScreenBorder)
 
    63        (round(X) <= cRightScreenBorder) and
 
    65     and (round(X) <= cRightScreenBorder)
 
    64        (round(Y) - 75 <= LAND_HEIGHT) and
 
    66     and (round(Y) - 75 <= LAND_HEIGHT)
 
    65        (Timer > 0) and (Timer-Steps > 0) then
 
    67     and (Timer > 0) and (Timer-Steps > 0) then
 
    66         begin
 
    68         begin
 
    67         if tdX > 0 then sign := 1
 
    69         if tdX > 0 then
 
    68         else sign:= -1;
 
    70             sign := 1
 
       
    71         else
 
       
    72             sign:= -1;
 
    69         tdX:= tdX - 0.005*Steps*sign;
 
    73         tdX:= tdX - 0.005*Steps*sign;
 
    70         if ((sign < 0) and (tdX > 0)) or ((sign > 0) and (tdX < 0)) then tdX:= 0;
 
    74         if ((sign < 0) and (tdX > 0)) or ((sign > 0) and (tdX < 0)) then
 
    71         if tdX > 0 then sign := 1
 
    75             tdX:= 0;
 
    72         else sign:= -1;
 
    76         if tdX > 0 then
 
       
    77             sign := 1
 
       
    78         else
 
       
    79             sign:= -1;
 
    73         tdY:= tdY - 0.005*Steps*sign;
 
    80         tdY:= tdY - 0.005*Steps*sign;
 
    74         if ((sign < 0) and (tdY > 0)) or ((sign > 0) and (tdY < 0)) then tdY:= 0;
 
    81         if ((sign < 0) and (tdY > 0)) or ((sign > 0) and (tdY < 0)) then
 
       
    82             tdY:= 0;
 
    75         dec(Timer, Steps)
 
    83         dec(Timer, Steps)
 
    76         end
 
    84         end
 
    77     else
 
    85     else
 
    78         begin
 
    86         begin
 
    79         if round(X) < cLeftScreenBorder then X:= X + cScreenSpace else
 
    87         if round(X) < cLeftScreenBorder then
 
    80         if round(X) > cRightScreenBorder then X:= X - cScreenSpace;
 
    88             X:= X + cScreenSpace
 
    81         // if round(Y) < (LAND_HEIGHT - 1024 - 75) then Y:= Y + 25.0; // For if flag is set for flakes rising upwards?
 
    89         else
 
    82         if (Gear^.Layer = 2) and (round(Y) - 225 > LAND_HEIGHT) then Y:= Y - (1024 + 300) // TODO - configure in theme (jellies for example could use limited range)
 
    90             if round(X) > cRightScreenBorder then
 
    83         else if (Gear^.Layer <> 2) and (round(Y) + 50 > LAND_HEIGHT) then Y:= Y - (1024 + 25);
 
    91                 X:= X - cScreenSpace;
 
       
    92             // if round(Y) < (LAND_HEIGHT - 1024 - 75) then Y:= Y + 25.0; // For if flag is set for flakes rising upwards?
 
       
    93             if (Gear^.Layer = 2) and (round(Y) - 225 > LAND_HEIGHT) then
 
       
    94                 Y:= Y - (1024 + 300) // TODO - configure in theme (jellies for example could use limited range)
 
       
    95             else if (Gear^.Layer <> 2) and (round(Y) + 50 > LAND_HEIGHT) then
 
       
    96                 Y:= Y - (1024 + 25);
 
    84         Timer:= 0;
 
    97         Timer:= 0;
 
    85         tdX:= 0;
 
    98         tdX:= 0;
 
    86         tdY:= 0
 
    99         tdY:= 0
 
    87         end;
 
   100         end;
 
    88     end;
 
   101     end;
 
   110 t := 8 * Gear^.Scale * hwFloat2Float(AngleSin(s mod 2048));
 
   123 t := 8 * Gear^.Scale * hwFloat2Float(AngleSin(s mod 2048));
 
   111 if (s < 2048) then t := -t;
 
   124 if (s < 2048) then t := -t;
 
   112 
   125 
   113 Gear^.Y := LAND_HEIGHT - 1184 + LongInt(Gear^.Timer mod 8) + t;
 
   126 Gear^.Y := LAND_HEIGHT - 1184 + LongInt(Gear^.Timer mod 8) + t;
 
   114 
   127 
   115 if round(Gear^.X) < cLeftScreenBorder then Gear^.X:= Gear^.X + cScreenSpace else
 
   128 if round(Gear^.X) < cLeftScreenBorder then
 
   116 if round(Gear^.X) > cRightScreenBorder then Gear^.X:= Gear^.X - cScreenSpace
 
   129     Gear^.X:= Gear^.X + cScreenSpace
 
       
   130 else
 
       
   131     if round(Gear^.X) > cRightScreenBorder then
 
       
   132         Gear^.X:= Gear^.X - cScreenSpace
 
   117 end;
 
   133 end;
 
   118 
   134 
   119 ////////////////////////////////////////////////////////////////////////////////
 
   135 ////////////////////////////////////////////////////////////////////////////////
 
   120 procedure doStepExpl(Gear: PVisualGear; Steps: Longword);
 
   136 procedure doStepExpl(Gear: PVisualGear; Steps: Longword);
 
   121 begin
 
   137 begin
 
   123 
   139 
   124 Gear^.Y:= Gear^.Y + Gear^.dY * Steps;
 
   140 Gear^.Y:= Gear^.Y + Gear^.dY * Steps;
 
   125 //Gear^.dY:= Gear^.dY + cGravityf;
 
   141 //Gear^.dY:= Gear^.dY + cGravityf;
 
   126 
   142 
   127 if Gear^.FrameTicks <= Steps then
 
   143 if Gear^.FrameTicks <= Steps then
 
   128     if Gear^.Frame = 0 then DeleteVisualGear(Gear)
 
   144     if Gear^.Frame = 0 then
 
       
   145         DeleteVisualGear(Gear)
 
   129     else
 
   146     else
 
   130         begin
 
   147         begin
 
   131         dec(Gear^.Frame);
 
   148         dec(Gear^.Frame);
 
   132         Gear^.FrameTicks:= cExplFrameTicks
 
   149         Gear^.FrameTicks:= cExplFrameTicks
 
   133         end
 
   150         end
 
   241 end;
 
   258 end;
 
   242 
   259 
   243 ////////////////////////////////////////////////////////////////////////////////
 
   260 ////////////////////////////////////////////////////////////////////////////////
 
   244 procedure doStepBubble(Gear: PVisualGear; Steps: Longword);
 
   261 procedure doStepBubble(Gear: PVisualGear; Steps: Longword);
 
   245 begin
 
   262 begin
 
   246     Gear^.X:= Gear^.X + Gear^.dX * Steps;
 
   263 Gear^.X:= Gear^.X + Gear^.dX * Steps;
 
   247     Gear^.Y:= Gear^.Y + Gear^.dY * Steps;
 
   264 Gear^.Y:= Gear^.Y + Gear^.dY * Steps;
 
   248     Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;
 
   265 Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;
 
   249 
   266 Gear^.dX := Gear^.dX / (1.001 * Steps);
 
   250     Gear^.dX := Gear^.dX / (1.001 * Steps);
 
   267 Gear^.dY := Gear^.dY / (1.001 * Steps);
 
   251     Gear^.dY := Gear^.dY / (1.001 * Steps);
 
   268 
   252 
   269 if (Gear^.FrameTicks <= Steps) or (round(Gear^.Y) < cWaterLine) then
 
   253     if (Gear^.FrameTicks <= Steps) or (round(Gear^.Y) < cWaterLine) then
 
   270     DeleteVisualGear(Gear)
 
       
   271 else
 
       
   272     dec(Gear^.FrameTicks, Steps)
 
       
   273 end;
 
       
   274 
       
   275 ////////////////////////////////////////////////////////////////////////////////
 
       
   276 procedure doStepSteam(Gear: PVisualGear; Steps: Longword);
 
       
   277 begin
 
       
   278 Gear^.X:= Gear^.X + (cWindSpeedf * 100 + Gear^.dX) * Steps;
 
       
   279 Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;
 
       
   280 
       
   281 if Gear^.FrameTicks <= Steps then
 
       
   282     if Gear^.Frame = 0 then
 
   254         DeleteVisualGear(Gear)
 
   283         DeleteVisualGear(Gear)
 
   255     else
 
   284     else
 
   256         dec(Gear^.FrameTicks, Steps)
 
   285         begin
 
   257 end;
 
   286         if Random(2) = 0 then
 
   258 
   287             dec(Gear^.Frame);
 
   259 ////////////////////////////////////////////////////////////////////////////////
 
   288         Gear^.FrameTicks:= cExplFrameTicks
 
   260 procedure doStepSteam(Gear: PVisualGear; Steps: Longword);
 
   289         end
 
   261 begin
 
   290 else dec(Gear^.FrameTicks, Steps)
 
   262     Gear^.X:= Gear^.X + (cWindSpeedf * 100 + Gear^.dX) * Steps;
 
       
   263     Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;
 
       
   264 
       
   265     if Gear^.FrameTicks <= Steps then
 
       
   266         if Gear^.Frame = 0 then DeleteVisualGear(Gear)
 
       
   267         else
 
       
   268             begin
 
       
   269             if Random(2) = 0 then dec(Gear^.Frame);
 
       
   270             Gear^.FrameTicks:= cExplFrameTicks
 
       
   271             end
 
       
   272         else dec(Gear^.FrameTicks, Steps)
 
       
   273 end;
 
   291 end;
 
   274 
   292 
   275 ////////////////////////////////////////////////////////////////////////////////
 
   293 ////////////////////////////////////////////////////////////////////////////////
 
   276 procedure doStepAmmo(Gear: PVisualGear; Steps: Longword);
 
   294 procedure doStepAmmo(Gear: PVisualGear; Steps: Longword);
 
   277 begin
 
   295 begin
 
   278     Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;
 
   296 Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;
 
   279 
   297 
   280     Gear^.scale:= Gear^.scale + 0.0025 * Steps;
 
   298 Gear^.scale:= Gear^.scale + 0.0025 * Steps;
 
   281     Gear^.alpha:= Gear^.alpha - 0.0015 * Steps;
 
   299 Gear^.alpha:= Gear^.alpha - 0.0015 * Steps;
 
   282 
   300 
   283     if Gear^.alpha < 0 then DeleteVisualGear(Gear)
 
   301 if Gear^.alpha < 0 then
 
       
   302     DeleteVisualGear(Gear)
 
   284 end;
 
   303 end;
 
   285 
   304 
   286 ////////////////////////////////////////////////////////////////////////////////
 
   305 ////////////////////////////////////////////////////////////////////////////////
 
   287 procedure doStepSmoke(Gear: PVisualGear; Steps: Longword);
 
   306 procedure doStepSmoke(Gear: PVisualGear; Steps: Longword);
 
   288 begin
 
   307 begin
 
   289     Gear^.X:= Gear^.X + (cWindSpeedf + Gear^.dX) * Steps;
 
   308 Gear^.X:= Gear^.X + (cWindSpeedf + Gear^.dX) * Steps;
 
   290     Gear^.Y:= Gear^.Y - (cDrownSpeedf + Gear^.dY) * Steps;
 
   309 Gear^.Y:= Gear^.Y - (cDrownSpeedf + Gear^.dY) * Steps;
 
   291 
   310 
   292     Gear^.dX := Gear^.dX + (cWindSpeedf * 0.3 * Steps);
 
   311 Gear^.dX := Gear^.dX + (cWindSpeedf * 0.3 * Steps);
 
   293     //Gear^.dY := Gear^.dY - (cDrownSpeedf * 0.995);
 
   312 //Gear^.dY := Gear^.dY - (cDrownSpeedf * 0.995);
 
   294 
   313 
   295     if Gear^.FrameTicks <= Steps then
 
   314 if Gear^.FrameTicks <= Steps then
 
   296         if Gear^.Frame = 0 then DeleteVisualGear(Gear)
 
   315     if Gear^.Frame = 0 then
 
   297         else
 
   316         DeleteVisualGear(Gear)
 
   298             begin
 
   317     else
 
   299             if Random(2) = 0 then dec(Gear^.Frame);
 
   318         begin
 
   300             Gear^.FrameTicks:= cExplFrameTicks
 
   319         if Random(2) = 0 then
 
   301             end
 
   320             dec(Gear^.Frame);
 
   302         else dec(Gear^.FrameTicks, Steps)
 
   321         Gear^.FrameTicks:= cExplFrameTicks
 
       
   322         end
 
       
   323     else dec(Gear^.FrameTicks, Steps)
 
   303 end;
 
   324 end;
 
   304 
   325 
   305 ////////////////////////////////////////////////////////////////////////////////
 
   326 ////////////////////////////////////////////////////////////////////////////////
 
   306 procedure doStepDust(Gear: PVisualGear; Steps: Longword);
 
   327 procedure doStepDust(Gear: PVisualGear; Steps: Longword);
 
   307 begin
 
   328 begin
 
   308     Gear^.X:= Gear^.X + (cWindSpeedf + (cWindSpeedf * 0.03 * Steps) + Gear^.dX) * Steps;
 
   329 Gear^.X:= Gear^.X + (cWindSpeedf + (cWindSpeedf * 0.03 * Steps) + Gear^.dX) * Steps;
 
   309     Gear^.Y:= Gear^.Y - (Gear^.dY) * Steps;
 
   330 Gear^.Y:= Gear^.Y - (Gear^.dY) * Steps;
 
   310 
   331 
   311     Gear^.dX := Gear^.dX - (Gear^.dX * 0.005 * Steps);
 
   332 Gear^.dX := Gear^.dX - (Gear^.dX * 0.005 * Steps);
 
   312     Gear^.dY := Gear^.dY - (cDrownSpeedf * 0.001 * Steps);
 
   333 Gear^.dY := Gear^.dY - (cDrownSpeedf * 0.001 * Steps);
 
   313 
   334 
   314     if Gear^.FrameTicks <= Steps then
 
   335 if Gear^.FrameTicks <= Steps then
 
   315         if Gear^.Frame = 0 then DeleteVisualGear(Gear)
 
   336     if Gear^.Frame = 0 then
 
   316         else
 
   337             DeleteVisualGear(Gear)
 
   317             begin
 
   338     else
 
   318             dec(Gear^.Frame);
 
   339         begin
 
   319             Gear^.FrameTicks:= cExplFrameTicks
 
   340         dec(Gear^.Frame);
 
   320             end
 
   341         Gear^.FrameTicks:= cExplFrameTicks
 
   321         else dec(Gear^.FrameTicks, Steps)
 
   342         end
 
       
   343     else dec(Gear^.FrameTicks, Steps)
 
   322 end;
 
   344 end;
 
   323 
   345 
   324 ////////////////////////////////////////////////////////////////////////////////
 
   346 ////////////////////////////////////////////////////////////////////////////////
 
   325 procedure doStepSplash(Gear: PVisualGear; Steps: Longword);
 
   347 procedure doStepSplash(Gear: PVisualGear; Steps: Longword);
 
   326 begin
 
   348 begin
 
   327   if Gear^.FrameTicks <= Steps then
 
   349 if Gear^.FrameTicks <= Steps then
 
   328       DeleteVisualGear(Gear)
 
   350     DeleteVisualGear(Gear)
 
   329   else
 
   351 else
 
   330       dec(Gear^.FrameTicks, Steps);
 
   352     dec(Gear^.FrameTicks, Steps);
 
   331 end;
 
   353 end;
 
   332 
   354 
   333 ////////////////////////////////////////////////////////////////////////////////
 
   355 ////////////////////////////////////////////////////////////////////////////////
 
   334 procedure doStepDroplet(Gear: PVisualGear; Steps: Longword);
 
   356 procedure doStepDroplet(Gear: PVisualGear; Steps: Longword);
 
   335 begin
 
   357 begin
 
   336   Gear^.X:= Gear^.X + Gear^.dX * Steps;
 
   358 Gear^.X:= Gear^.X + Gear^.dX * Steps;
 
   337 
   359 
   338   Gear^.Y:= Gear^.Y + Gear^.dY * Steps;
 
   360 Gear^.Y:= Gear^.Y + Gear^.dY * Steps;
 
   339   Gear^.dY:= Gear^.dY + cGravityf * Steps;
 
   361 Gear^.dY:= Gear^.dY + cGravityf * Steps;
 
   340 
   362 
   341   if round(Gear^.Y) > cWaterLine then begin
 
   363 if round(Gear^.Y) > cWaterLine then
 
       
   364     begin
 
   342     DeleteVisualGear(Gear);
 
   365     DeleteVisualGear(Gear);
 
   343     PlaySound(TSound(ord(sndDroplet1) + Random(3)));
 
   366     PlaySound(TSound(ord(sndDroplet1) + Random(3)));
 
   344     end;
 
   367     end;
 
   345 end;
 
   368 end;
 
   346 
   369 
   347 ////////////////////////////////////////////////////////////////////////////////
 
   370 ////////////////////////////////////////////////////////////////////////////////
 
   348 procedure doStepSmokeRing(Gear: PVisualGear; Steps: Longword);
 
   371 procedure doStepSmokeRing(Gear: PVisualGear; Steps: Longword);
 
   349 begin
 
   372 begin
 
   350 inc(Gear^.Timer, Steps);
 
   373 inc(Gear^.Timer, Steps);
 
   351 if Gear^.Timer >= Gear^.FrameTicks then DeleteVisualGear(Gear)
 
   374 if Gear^.Timer >= Gear^.FrameTicks then
 
       
   375     DeleteVisualGear(Gear)
 
   352 else
 
   376 else
 
   353     begin
 
   377     begin
 
   354     Gear^.scale := 1.25 * (-power(2, -10 * Int(Gear^.Timer)/Gear^.FrameTicks) + 1) + 0.4;
 
   378     Gear^.scale := 1.25 * (-power(2, -10 * Int(Gear^.Timer)/Gear^.FrameTicks) + 1) + 0.4;
 
   355     Gear^.alpha := 1 - power(Gear^.Timer / 350, 4);
 
   379     Gear^.alpha := 1 - power(Gear^.Timer / 350, 4);
 
   356     if Gear^.alpha < 0 then Gear^.alpha:= 0;
 
   380     if Gear^.alpha < 0 then
 
       
   381         Gear^.alpha:= 0;
 
   357     end;
 
   382     end;
 
   358 end;
 
   383 end;
 
   359 
   384 
   360 ////////////////////////////////////////////////////////////////////////////////
 
   385 ////////////////////////////////////////////////////////////////////////////////
 
   361 procedure doStepFeather(Gear: PVisualGear; Steps: Longword);
 
   386 procedure doStepFeather(Gear: PVisualGear; Steps: Longword);
 
   399                 {$WARNINGS ON}
 
   424                 {$WARNINGS ON}
 
   400                 end;
 
   425                 end;
 
   401 
   426 
   402     if (Gear^.Timer = 0) or (currsorter <> Gear) then
 
   427     if (Gear^.Timer = 0) or (currsorter <> Gear) then
 
   403         begin
 
   428         begin
 
   404         if currsorter = Gear then currsorter:= nil;
 
   429         if currsorter = Gear then
 
       
   430             currsorter:= nil;
 
   405         DeleteVisualGear(Gear);
 
   431         DeleteVisualGear(Gear);
 
   406         exit
 
   432         exit
 
   407         end
 
   433         end
 
   408     end
 
   434     end
 
   409 end;
 
   435 end;
 
   475 procedure doStepSpeechBubble(Gear: PVisualGear; Steps: Longword);
 
   501 procedure doStepSpeechBubble(Gear: PVisualGear; Steps: Longword);
 
   476 begin
 
   502 begin
 
   477 Steps:= Steps; // avoid compiler hint
 
   503 Steps:= Steps; // avoid compiler hint
 
   478 
   504 
   479 with Gear^.Hedgehog^ do
 
   505 with Gear^.Hedgehog^ do
 
   480     if SpeechGear <> nil then SpeechGear^.Timer:= 0;
 
   506     if SpeechGear <> nil then
 
       
   507         SpeechGear^.Timer:= 0;
 
   481 
   508 
   482 Gear^.Hedgehog^.SpeechGear:= Gear;
 
   509 Gear^.Hedgehog^.SpeechGear:= Gear;
 
   483 
   510 
   484 Gear^.Timer:= max(LongInt(Length(Gear^.Text)) * 150, 3000);
 
   511 Gear^.Timer:= max(LongInt(Length(Gear^.Text)) * 150, 3000);
 
   485 
   512 
   534 if (round(Gear^.Y) > cWaterLine) and (Gear^.Frame = 0)  then
 
   561 if (round(Gear^.Y) > cWaterLine) and (Gear^.Frame = 0)  then
 
   535     Gear^.doStep:= @doStepHealthTagWorkUnderWater;
 
   562     Gear^.doStep:= @doStepHealthTagWorkUnderWater;
 
   536 
   563 
   537 Gear^.Y:= Gear^.Y - Gear^.Tex^.h;
 
   564 Gear^.Y:= Gear^.Y - Gear^.Tex^.h;
 
   538 
   565 
   539 if Steps > 1 then Gear^.doStep(Gear, Steps-1);
 
   566 if Steps > 1 then
 
       
   567     Gear^.doStep(Gear, Steps-1);
 
   540 end;
 
   568 end;
 
   541 
   569 
   542 ////////////////////////////////////////////////////////////////////////////////
 
   570 ////////////////////////////////////////////////////////////////////////////////
 
   543 procedure doStepSmokeTrace(Gear: PVisualGear; Steps: Longword);
 
   571 procedure doStepSmokeTrace(Gear: PVisualGear; Steps: Longword);
 
   544 begin
 
   572 begin
 
   545 inc(Gear^.Timer, Steps );
 
   573 inc(Gear^.Timer, Steps );
 
   546 if Gear^.Timer > 64 then
 
   574 if Gear^.Timer > 64 then
 
   547     begin
 
   575     begin
 
   548     if Gear^.State = 0 then
 
   576     if Gear^.State = 0 then
 
   549       begin
 
   577         begin
 
   550       DeleteVisualGear(Gear);
 
   578         DeleteVisualGear(Gear);
 
   551       exit;
 
   579         exit;
 
   552       end;
 
   580         end;
 
   553     dec(Gear^.State, Gear^.Timer div 65);
 
   581     dec(Gear^.State, Gear^.Timer div 65);
 
   554     Gear^.Timer:= Gear^.Timer mod 65;
 
   582     Gear^.Timer:= Gear^.Timer mod 65;
 
   555     end;
 
   583     end;
 
   556 Gear^.dX:= Gear^.dX + cWindSpeedf * Steps;
 
   584 Gear^.dX:= Gear^.dX + cWindSpeedf * Steps;
 
   557 Gear^.X:= Gear^.X + Gear^.dX;
 
   585 Gear^.X:= Gear^.X + Gear^.dX;
 
   563 inc(Gear^.Timer, Steps);
 
   591 inc(Gear^.Timer, Steps);
 
   564 if Gear^.Timer > 75 then
 
   592 if Gear^.Timer > 75 then
 
   565     begin
 
   593     begin
 
   566     inc(Gear^.State, Gear^.Timer div 76);
 
   594     inc(Gear^.State, Gear^.Timer div 76);
 
   567     Gear^.Timer:= Gear^.Timer mod 76;
 
   595     Gear^.Timer:= Gear^.Timer mod 76;
 
   568     if Gear^.State > 5 then DeleteVisualGear(Gear);
 
   596     if Gear^.State > 5 then
 
       
   597         DeleteVisualGear(Gear);
 
   569     end;
 
   598     end;
 
   570 end;
 
   599 end;
 
   571 
   600 
   572 procedure doStepExplosion(Gear: PVisualGear; Steps: Longword);
 
   601 procedure doStepExplosion(Gear: PVisualGear; Steps: Longword);
 
   573 var i: LongWord;
 
   602 var i: LongWord;
 
   586         end
 
   615         end
 
   587     end;
 
   616     end;
 
   588 for i:= 0 to  8 do AddVisualGear(gX, gY, vgtExplPart);
 
   617 for i:= 0 to  8 do AddVisualGear(gX, gY, vgtExplPart);
 
   589 for i:= 0 to  8 do AddVisualGear(gX, gY, vgtExplPart2);
 
   618 for i:= 0 to  8 do AddVisualGear(gX, gY, vgtExplPart2);
 
   590 Gear^.doStep:= @doStepExplosionWork;
 
   619 Gear^.doStep:= @doStepExplosionWork;
 
   591 if Steps > 1 then Gear^.doStep(Gear, Steps-1);
 
   620 if Steps > 1 then
 
       
   621     Gear^.doStep(Gear, Steps-1);
 
   592 end;
 
   622 end;
 
   593 
   623 
   594 
   624 
   595 ////////////////////////////////////////////////////////////////////////////////
 
   625 ////////////////////////////////////////////////////////////////////////////////
 
   596 procedure doStepBigExplosionWork(Gear: PVisualGear; Steps: Longword);
 
   626 procedure doStepBigExplosionWork(Gear: PVisualGear; Steps: Longword);
 
   602     begin
 
   632     begin
 
   603     maxMovement := max(1, 13 - ((Gear^.Timer * 15) div 250));
 
   633     maxMovement := max(1, 13 - ((Gear^.Timer * 15) div 250));
 
   604     ShakeCamera(maxMovement);
 
   634     ShakeCamera(maxMovement);
 
   605     end;
 
   635     end;
 
   606 
   636 
   607 if Gear^.Timer > 250 then DeleteVisualGear(Gear);
 
   637 if Gear^.Timer > 250 then
 
       
   638     DeleteVisualGear(Gear);
 
   608 end;
 
   639 end;
 
   609 
   640 
   610 procedure doStepBigExplosion(Gear: PVisualGear; Steps: Longword);
 
   641 procedure doStepBigExplosion(Gear: PVisualGear; Steps: Longword);
 
   611 var i: LongWord;
 
   642 var i: LongWord;
 
   612     gX,gY: LongInt;
 
   643     gX,gY: LongInt;
 
   625         begin
 
   656         begin
 
   626         vg^.State:= gstTmpFlag;
 
   657         vg^.State:= gstTmpFlag;
 
   627         inc(vg^.FrameTicks, vg^.FrameTicks)
 
   658         inc(vg^.FrameTicks, vg^.FrameTicks)
 
   628         end
 
   659         end
 
   629     end;
 
   660     end;
 
   630 for i:= 0 to 15 do AddVisualGear(gX, gY, vgtExplPart);
 
   661 for i:= 0 to 15 do
 
   631 for i:= 0 to 15 do AddVisualGear(gX, gY, vgtExplPart2);
 
   662     AddVisualGear(gX, gY, vgtExplPart);
 
       
   663 for i:= 0 to 15 do
 
       
   664     AddVisualGear(gX, gY, vgtExplPart2);
 
   632 Gear^.doStep:= @doStepBigExplosionWork;
 
   665 Gear^.doStep:= @doStepBigExplosionWork;
 
   633 if Steps > 1 then Gear^.doStep(Gear, Steps-1);
 
   666 if Steps > 1 then
 
       
   667     Gear^.doStep(Gear, Steps-1);
 
   634 performRumble();
 
   668 performRumble();
 
   635 end;
 
   669 end;
 
   636 
   670 
   637 procedure doStepChunk(Gear: PVisualGear; Steps: Longword);
 
   671 procedure doStepChunk(Gear: PVisualGear; Steps: Longword);
 
   638 begin
 
   672 begin
 
   651 end;
 
   685 end;
 
   652 
   686 
   653 ////////////////////////////////////////////////////////////////////////////////
 
   687 ////////////////////////////////////////////////////////////////////////////////
 
   654 procedure doStepBulletHit(Gear: PVisualGear; Steps: Longword);
 
   688 procedure doStepBulletHit(Gear: PVisualGear; Steps: Longword);
 
   655 begin
 
   689 begin
 
   656   if Gear^.FrameTicks <= Steps then
 
   690 if Gear^.FrameTicks <= Steps then
 
   657       DeleteVisualGear(Gear)
 
   691     DeleteVisualGear(Gear)
 
   658   else
 
   692 else
 
   659       dec(Gear^.FrameTicks, Steps);
 
   693     dec(Gear^.FrameTicks, Steps);
 
   660 end;
 
   694 end;
 
   661 
   695 
   662 ////////////////////////////////////////////////////////////////////////////////
 
   696 ////////////////////////////////////////////////////////////////////////////////
 
   663 procedure doStepCircle(Gear: PVisualGear; Steps: Longword);
 
   697 procedure doStepCircle(Gear: PVisualGear; Steps: Longword);
 
   664 var tmp: LongInt;
 
   698 var tmp: LongInt;
 
   670             begin
 
   704             begin
 
   671             inc(FrameTicks);
 
   705             inc(FrameTicks);
 
   672             if (FrameTicks mod Frame) = 0 then
 
   706             if (FrameTicks mod Frame) = 0 then
 
   673                 begin
 
   707                 begin
 
   674                 tmp:= Gear^.Tint and $FF;
 
   708                 tmp:= Gear^.Tint and $FF;
 
   675                 if tdY >= 0 then inc(tmp)
 
   709                 if tdY >= 0 then
 
   676                 else dec(tmp);
 
   710                     inc(tmp)
 
   677                 if tmp < round(dX) then tdY:= 1;
 
   711                 else
 
   678                 if tmp > round(dY) then tdY:= -1;
 
   712                     dec(tmp);
 
   679                 if tmp > 255 then tmp := 255;
 
   713                 if tmp < round(dX) then
 
   680                 if tmp < 0 then tmp := 0;
 
   714                     tdY:= 1;
 
       
   715                 if tmp > round(dY) then
 
       
   716                     tdY:= -1;
 
       
   717                 if tmp > 255 then
 
       
   718                     tmp := 255;
 
       
   719                 if tmp < 0 then
 
       
   720                     tmp := 0;
 
   681                 Gear^.Tint:= (Gear^.Tint and $FFFFFF00) or Longword(tmp)
 
   721                 Gear^.Tint:= (Gear^.Tint and $FFFFFF00) or Longword(tmp)
 
   682                 end
 
   722                 end
 
   683             end
 
   723             end
 
   684 end;
 
   724 end;
 
   685 
   725 
   686 ////////////////////////////////////////////////////////////////////////////////
 
   726 ////////////////////////////////////////////////////////////////////////////////
 
   687 procedure doStepSmoothWindBar(Gear: PVisualGear; Steps: Longword);
 
   727 procedure doStepSmoothWindBar(Gear: PVisualGear; Steps: Longword);
 
   688 begin
 
   728 begin
 
   689     inc(Gear^.Timer, Steps);
 
   729 inc(Gear^.Timer, Steps);
 
   690     
   730     
   691     while Gear^.Timer >= 10 do
 
   731     while Gear^.Timer >= 10 do
 
   692         begin
 
   732         begin
 
   693         dec(Gear^.Timer, 10);
 
   733         dec(Gear^.Timer, 10);
 
   694         if WindBarWidth < Gear^.Tag then inc(WindBarWidth)
 
   734         if WindBarWidth < Gear^.Tag then
 
   695         else if WindBarWidth > Gear^.Tag then dec(WindBarWidth);
 
   735             inc(WindBarWidth)
 
       
   736         else if WindBarWidth > Gear^.Tag then
 
       
   737             dec(WindBarWidth);
 
   696         end;
 
   738         end;
 
   697         
   739         
   698 if WindBarWidth = Gear^.Tag then 
   740 if WindBarWidth = Gear^.Tag then 
   699     DeleteVisualGear(Gear)
 
   741     DeleteVisualGear(Gear)
 
   700 end;
 
   742 end;
hedgewars