55 procedure InsertGearToList(Gear: PGear);

    55 procedure doStepDrowningGear(Gear: PGear);

    56 procedure RemoveGearFromList(Gear: PGear);

    57 procedure DeleteGear(Gear: PGear); 

    64      uGearsHedgehog;

    62      uGearsHedgehog, uGearsUtils, uGearsList;

    82 const doStepHandlers: array[TGearType] of TGearStepProcedure = (

    78 function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs

    79 var Gear: PGear;

    80     dmg: LongInt;

    81 begin

    82 CheckNoDamage:= true;

    83 Gear:= GearsList;

    84 while Gear <> nil do

    85     begin

    86     if (Gear^.Kind = gtHedgehog) and (((GameFlags and gfInfAttack) = 0) or ((Gear^.dX.QWordValue < _0_000004.QWordValue) and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then

    87         begin

    88         if (not isInMultiShoot) then inc(Gear^.Damage, Gear^.Karma);

    89         if (Gear^.Damage <> 0) and

    90         (not Gear^.Invulnerable) then

    91             begin

    92             CheckNoDamage:= false;

    93 

    94             dmg:= Gear^.Damage;

    95             if Gear^.Health < dmg then

    96                 begin

    97                 Gear^.Active:= true;

    98                 Gear^.Health:= 0

    99                 end

   100             else

   101                 dec(Gear^.Health, dmg);

   102 

   103             if (Gear^.Hedgehog^.Team = CurrentTeam) and

   104                (Gear^.Damage <> Gear^.Karma) and

   105                 (not Gear^.Hedgehog^.King) and

   106                 (not Gear^.Hedgehog^.Effects[hePoisoned]) and

   107                 (not SuddenDeathDmg) then

   108                 Gear^.State:= Gear^.State or gstLoser;

   109 

   110             spawnHealthTagForHH(Gear, dmg);

   111 

   112             RenderHealth(Gear^.Hedgehog^);

   113             RecountTeamHealth(Gear^.Hedgehog^.Team);

   114 

   115             end;

   116         if (not isInMultiShoot) then Gear^.Karma:= 0;

   117         Gear^.Damage:= 0

   118         end;

   119     Gear:= Gear^.NextGear

   120     end;

   121 end;

   122 

   123 procedure HealthMachine;

   124 var Gear: PGear;

   125     team: PTeam;

   126        i: LongWord;

   127     flag: Boolean;

   128      tmp: LongWord;

   129 begin

   130     Gear:= GearsList;

   131 

   132     while Gear <> nil do

   133     begin

   134         if Gear^.Kind = gtHedgehog then

   135             begin

   136             tmp:= 0;

   137             if Gear^.Hedgehog^.Effects[hePoisoned] then

   138                 begin

   139                 inc(tmp, ModifyDamage(5, Gear));

   140                 if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth)  // does not need a minimum check since <= 1 basically disables it

   141                 end;

   142             if (TotalRounds > cSuddenDTurns - 1) then

   143                 begin

   144                 inc(tmp, cHealthDecrease);

   145                 if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth, cHealthDecrease)

   146                 end;

   147             if Gear^.Hedgehog^.King then

   148                 begin

   149                 flag:= false;

   150                 team:= Gear^.Hedgehog^.Team;

   151                 for i:= 0 to Pred(team^.HedgehogsNumber) do

   152                     if (team^.Hedgehogs[i].Gear <> nil) and

   153                         (not team^.Hedgehogs[i].King) and

   154                         (team^.Hedgehogs[i].Gear^.Health > team^.Hedgehogs[i].Gear^.Damage)

   155                     then flag:= true;

   156                 if not flag then

   157                     begin

   158                     inc(tmp, 5);

   159                     if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth, 5)

   160                     end

   161                 end;

   162             if tmp > 0 then 

   163                 begin

   164                 inc(Gear^.Damage, min(tmp, max(0,Gear^.Health - 1 - Gear^.Damage)));

   165                 HHHurt(Gear^.Hedgehog, dsPoison);

   166                 end

   167             end;

   168 

   169         Gear:= Gear^.NextGear

   170     end;

   171 end;

   172 

   173 procedure ProcessGears;

   174 const delay: LongWord = 0;

   175       delay2: LongWord = 0;

   176     step: (stDelay, stChDmg, stSweep, stTurnReact,

   177             stAfterDelay, stChWin, stWater, stChWin2, stHealth,

   178             stSpawn, stNTurn) = stDelay;

   179 var Gear, t: PGear;

   180     i, AliveCount: LongInt;

   181     s: shortstring;

   182 begin

   183 PrvInactive:= AllInactive;

   184 AllInactive:= true;

   185 

   186 if (StepSoundTimer > 0) and (StepSoundChannel < 0) then

   187     StepSoundChannel:= LoopSound(sndSteps)

   188 else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then

   189     begin

   190     StopSound(StepSoundChannel);

   191     StepSoundChannel:= -1

   192     end;

   193 

   194 if StepSoundTimer > 0 then

   195     dec(StepSoundTimer, 1);

   196 

   197 t:= GearsList;

   198 while t <> nil do

   199     begin

   200     Gear:= t;

   201     t:= Gear^.NextGear;

   202 

   203     if Gear^.Active then

   204         begin

   205         if Gear^.RenderTimer and (Gear^.Timer > 500) and ((Gear^.Timer mod 1000) = 0) then

   206             begin

   207             FreeTexture(Gear^.Tex);

   208             Gear^.Tex:= RenderStringTex(inttostr(Gear^.Timer div 1000), cWhiteColor, fntSmall);

   209             end;

   210         Gear^.doStep(Gear);

   211         // might be useful later

   212         //ScriptCall('onGearStep', Gear^.uid);

   213         end

   214     end;

   215 

   216 if AllInactive then

   217 case step of

   218     stDelay: begin

   219         if delay = 0 then

   220             delay:= cInactDelay

   221         else

   222             dec(delay);

   223 

   224         if delay = 0 then

   225             inc(step)

   226         end;

   227     stChDmg: if CheckNoDamage then inc(step) else step:= stDelay;

   228     stSweep: if SweepDirty then

   229                 begin

   230                 SetAllToActive;

   231                 step:= stChDmg

   232                 end else inc(step);

   233     stTurnReact: begin

   234         if (not bBetweenTurns) and (not isInMultiShoot) then

   235             begin

   236             uStats.TurnReaction;

   237             inc(step)

   238         end else

   239             inc(step, 2);

   240         end;

   241     stAfterDelay: begin

   242         if delay = 0 then

   243             delay:= cInactDelay

   244         else

   245             dec(delay);

   246 

   247         if delay = 0 then

   248         inc(step)

   249         end;

   250     stChWin: begin

   251             CheckForWin;

   252             inc(step)

   253             end;

   254     stWater: if (not bBetweenTurns) and (not isInMultiShoot) then

   255                 begin

   256                 if TotalRounds = cSuddenDTurns + 1 then bWaterRising:= true;

   257 

   258                 if bWaterRising and (cWaterRise > 0) then

   259                     AddGear(0, 0, gtWaterUp, 0, _0, _0, 0)^.Tag:= cWaterRise;

   260 

   261                 inc(step)

   262                 end else inc(step);

   263     stChWin2: begin

   264             CheckForWin;

   265             inc(step)

   266             end;

   267     stHealth: begin

   268             if (cWaterRise <> 0) or (cHealthDecrease <> 0) then

   269                 begin

   270                 if (TotalRounds = cSuddenDTurns) and (not SuddenDeath) and (not isInMultiShoot) then

   271                     begin

   272                     SuddenDeath:= true;

   273                     if cHealthDecrease <> 0 then

   274                         begin

   275                         SuddenDeathDmg:= true;

   276                         

   277                         // flash

   278                         ScreenFade:= sfFromWhite;

   279                         ScreenFadeValue:= sfMax;

   280                         ScreenFadeSpeed:= 1;

   281                         

   282                         ChangeToSDClouds;

   283                         ChangeToSDFlakes;

   284                         glClearColor(SDSkyColor.r * (SDTint/255) / 255, SDSkyColor.g * (SDTint/255) / 255, SDSkyColor.b * (SDTint/255) / 255, 0.99);

   285                         Ammoz[amTardis].SkipTurns:= 9999;

   286                         Ammoz[amTardis].Probability:= 0;

   287                         end;

   288                     AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState);

   289                     playSound(sndSuddenDeath);

   290                     StopMusic //No SDMusic for now

   291                     //MusicFN:= SDMusic;

   292                     //ChangeMusic

   293                     end

   294                 else if (TotalRounds < cSuddenDTurns) and (not isInMultiShoot) then

   295                     begin

   296                     i:= cSuddenDTurns - TotalRounds;

   297                     s:= inttostr(i);

   298                     if i = 1 then

   299                         AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState)

   300                     else if (i = 2) or ((i > 0) and ((i mod 50 = 0) or ((i <= 25) and (i mod 5 = 0)))) then

   301                         AddCaption(Format(trmsg[sidRoundsSD], s), cWhiteColor, capgrpGameState);

   302                     end;

   303                 end;

   304             if bBetweenTurns

   305                 or isInMultiShoot

   306                 or (TotalRounds = -1) then inc(step)

   307             else begin

   308                 bBetweenTurns:= true;

   309                 HealthMachine;

   310                 step:= stChDmg

   311                 end

   312             end;

   313     stSpawn: begin

   314             if not isInMultiShoot then SpawnBoxOfSmth;

   315             inc(step)

   316             end;

   317     stNTurn: begin

   318             if isInMultiShoot then

   319                 isInMultiShoot:= false

   320             else begin

   321                 // delayed till after 0.9.12

   322                 // reset to default zoom

   323                 //ZoomValue:= ZoomDefault;

   324                 with CurrentHedgehog^ do

   325                     if (Gear <> nil)

   326                         and ((Gear^.State and gstAttacked) = 0)

   327                         and (MultiShootAttacks > 0) then OnUsedAmmo(CurrentHedgehog^);

   328 

   329                 EndTurnCleanup;

   330 

   331                 FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn

   332 

   333                 ParseCommand('/nextturn', true);

   334                 SwitchHedgehog;

   335 

   336                 AfterSwitchHedgehog;

   337                 bBetweenTurns:= false

   338                 end;

   339             step:= Low(step)

   340             end;

   341     end

   342 else if ((GameFlags and gfInfAttack) <> 0) then

   343     begin

   344     if delay2 = 0 then

   345         delay2:= cInactDelay * 50

   346     else

   347         begin

   348         dec(delay2);

   349 

   350         if ((delay2 mod cInactDelay) = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) and (not CurrentHedgehog^.Unplaced) then

   351             begin

   352             if (CurrentHedgehog^.Gear^.State and gstAttacked <> 0) and (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then

   353                 begin

   354                 CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstHHChooseTarget;

   355                 isCursorVisible := true

   356                 end;

   357             CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State and (not gstAttacked);

   358             end;

   359         if delay2 = 0 then

   360             begin

   361             if (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.State and gstAttacked = 0) and (CurAmmoGear = nil) then SweepDirty;

   362             CheckNoDamage;

   363             AliveCount:= 0; // shorter version of check for win to allow typical step activity to proceed

   364             for i:= 0 to Pred(ClansCount) do

   365                 if ClansArray[i]^.ClanHealth > 0 then inc(AliveCount);

   366             if (AliveCount <= 1) and ((GameFlags and gfOneClanMode) = 0) then

   367                 begin

   368                 step:= stChDmg;

   369                 if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft;

   370                 TurnTimeLeft:= 0

   371                 end

   372             end

   373         end

   374     end;

   375 

   376 if TurnTimeLeft > 0 then

   377         if CurrentHedgehog^.Gear <> nil then

   378             if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0)

   379                 and (not isInMultiShoot) then

   380                 begin

   381                 if (TurnTimeLeft = 5000)

   382                     and (cHedgehogTurnTime >= 10000)

   383                     and (not PlacingHogs)

   384                     and (CurrentHedgehog^.Gear <> nil)

   385                     and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then

   386                         AddVoice(sndHurry, CurrentTeam^.voicepack);

   387                 if ReadyTimeLeft > 0 then

   388                     begin

   389                     if ReadyTimeLeft = 2000 then

   390                         AddVoice(sndComeonthen, CurrentTeam^.voicepack);

   391                     dec(ReadyTimeLeft)

   392                     end

   393                 else

   394                     dec(TurnTimeLeft)

   395                 end;

   396 

   397 if skipFlag then

   398     begin

   399     if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft;

   400     TurnTimeLeft:= 0;

   401     skipFlag:= false;

   402     inc(CurrentHedgehog^.Team^.stats.TurnSkips);

   403     end;

   404 

   405 if ((GameTicks and $FFFF) = $FFFF) then

   406     begin

   407     if (not CurrentTeam^.ExtDriven) then

   408         begin

   409         SendIPC('#');

   410         AddFileLog('hiTicks increment message sent')

   411         end;

   412 

   413     if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then

   414         inc(hiTicks) // we do not recieve a message for this

   415     end;

   416 

   417 ScriptCall('onGameTick');

   418 inc(GameTicks)

   419 end;

   420 

   421 //Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn

   422 //If any of these are set as permanent toggles in the frontend, that needs to be checked and skipped here.

   423 procedure EndTurnCleanup;

   424 var  i: LongInt;

   425      t: PGear;

   426 begin

   427     SpeechText:= ''; // in case it has not been consumed

   428 

   429     if (GameFlags and gfLowGravity) = 0 then

   430         begin

   431         cGravity:= cMaxWindSpeed * 2;

   432         cGravityf:= 0.00025 * 2

   433         end;

   434 

   435     if (GameFlags and gfVampiric) = 0 then

   436         cVampiric:= false;

   437 

   438     cDamageModifier:= _1;

   439 

   440     if (GameFlags and gfLaserSight) = 0 then

   441         cLaserSighting:= false;

   442 

   443     if (GameFlags and gfArtillery) = 0 then

   444         cArtillery:= false;

   445     // have to sweep *all* current team hedgehogs since it is theoretically possible if you have enough invulnerabilities and switch turns to make your entire team invulnerable

   446     if (CurrentTeam <> nil) then

   447         with CurrentTeam^ do

   448             for i:= 0 to cMaxHHIndex do

   449                 with Hedgehogs[i] do

   450                     begin

   451 (*

   452                     if (SpeechGear <> nil) then

   453                         begin

   454                         DeleteVisualGear(SpeechGear);  // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue

   455                         SpeechGear:= nil

   456                         end;

   457 *)

   458 

   459                     if (Gear <> nil) then

   460                         begin

   461                         if (GameFlags and gfInvulnerable) = 0 then

   462                             Gear^.Invulnerable:= false;

   463                         end;

   464                     end;

   465     t:= GearsList;

   466     while t <> nil do

   467         begin

   468         t^.PortalCounter:= 0;

   469         if ((GameFlags and gfResetHealth) <> 0) and (t^.Kind = gtHedgehog) and (t^.Health < t^.Hedgehog^.InitialHealth) then

   470             begin

   471             t^.Health:= t^.Hedgehog^.InitialHealth;

   472             RenderHealth(t^.Hedgehog^);

   473             end;

   474         t:= t^.NextGear

   475         end;

   476    

   477     if ((GameFlags and gfResetWeps) <> 0) and (not PlacingHogs) then

   478         ResetWeapons;

   479 

   480     if (GameFlags and gfResetHealth) <> 0 then

   481         for i:= 0 to Pred(TeamsCount) do

   482             RecountTeamHealth(TeamsArray[i])

   483 end;

   484 

   485 procedure SetAllToActive;

   486 var t: PGear;

   487 begin

   488 AllInactive:= false;

   489 t:= GearsList;

   490 while t <> nil do

   491     begin

   492     t^.Active:= true;

   493     t:= t^.NextGear

   494     end

   495 end;

   496 

   497 procedure SetAllHHToActive;

   498 var t: PGear;

   499 begin

   500 AllInactive:= false;

   501 t:= GearsList;

   502 while t <> nil do

   503     begin

   504     if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then t^.Active:= true;

   505     t:= t^.NextGear

   506     end

   507 end;

   508 

   509 

   510 procedure DrawGears;

   511 var Gear: PGear;

   512     x, y: LongInt;

   513 begin

   514 Gear:= GearsList;

   515 while Gear <> nil do

   516     begin

   517     if Gear^.State and gstInvisible = 0 then

   518         begin

   519         x:= hwRound(Gear^.X) + WorldDx;

   520         y:= hwRound(Gear^.Y) + WorldDy;

   521         RenderGear(Gear, x, y);

   522         end;

   523     Gear:= Gear^.NextGear

   524     end;

   525 end;

   526 

   527 procedure FreeGearsList;

   528 var t, tt: PGear;

   529 begin

   530     tt:= GearsList;

   531     GearsList:= nil;

   532     while tt <> nil do

   533     begin

   534         t:= tt;

   535         tt:= tt^.NextGear;

   536         Dispose(t)

   537     end;

   538 end;

   539 

   540 procedure AddMiscGears;

   541 var i: Longword;

   542     Gear: PGear;

   543 begin

   544 AddGear(0, 0, gtATStartGame, 0, _0, _0, 2000);

   545 

   546 i:= 0;

   547 Gear:= PGear(1);

   548 while (i < cLandMines) {and (Gear <> nil)} do // disable this check until better solution found

   549     begin

   550     Gear:= AddGear(0, 0, gtMine, 0, _0, _0, 0);

   551     FindPlace(Gear, false, 0, LAND_WIDTH);

   552     inc(i)

   553     end;

   554 

   555 i:= 0;

   556 Gear:= PGear(1);

   557 while (i < cExplosives){ and (Gear <> nil)} do

   558     begin

   559     Gear:= AddGear(0, 0, gtExplosives, 0, _0, _0, 0);

   560     FindPlace(Gear, false, 0, LAND_WIDTH);

   561     inc(i)

   562     end;

   563 

   564 if (GameFlags and gfLowGravity) <> 0 then

   565     begin

   566     cGravity:= cMaxWindSpeed;

   567     cGravityf:= 0.00025

   568     end;

   569 

   570 if (GameFlags and gfVampiric) <> 0 then

   571     cVampiric:= true;

   572 

   573 Gear:= GearsList;

   574 if (GameFlags and gfInvulnerable) <> 0 then

   575    while Gear <> nil do

   576        begin

   577        Gear^.Invulnerable:= true;  // this is only checked on hogs right now, so no need for gear type check

   578        Gear:= Gear^.NextGear

   579        end;

   580 

   581 if (GameFlags and gfLaserSight) <> 0 then

   582     cLaserSighting:= true;

   583 

   584 if (GameFlags and gfArtillery) <> 0 then

   585     cArtillery:= true;

   586 

   587 if not hasBorder and ((Theme = 'Snow') or (Theme = 'Christmas')) then

   588     for i:= 0 to Pred(vobCount*2) do

   589         AddGear(GetRandom(LAND_WIDTH+1024)-512, LAND_HEIGHT - GetRandom(LAND_HEIGHT div 2), gtFlake, 0, _0, _0, 0);

   590 end;

   591 

   592 

   593 procedure ShotgunShot(Gear: PGear);

   594 var t: PGear;

   595     dmg, r, dist: LongInt;

   596     dx, dy: hwFloat;

   597 begin

   598 Gear^.Radius:= cShotgunRadius;

   599 t:= GearsList;

   600 while t <> nil do

   601     begin

   602     case t^.Kind of

   603         gtHedgehog,

   604             gtMine,

   605             gtSMine,

   606             gtCase,

   607             gtTarget,

   608             gtExplosives,

   609             gtStructure: begin

   610 //addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg));

   611                     dmg:= 0;

   612                     r:= Gear^.Radius + t^.Radius;

   613                     dx:= Gear^.X-t^.X;

   614                     dx.isNegative:= false;

   615                     dy:= Gear^.Y-t^.Y;

   616                     dy.isNegative:= false;

   617                     if r-hwRound(dx+dy) > 0 then

   618                         begin

   619                         dist:= hwRound(Distance(dx, dy));

   620                         dmg:= ModifyDamage(min(r - dist, 25), t);

   621                         end;

   622                     if dmg > 0 then

   623                         begin

   624                         if (not t^.Invulnerable) then

   625                             ApplyDamage(t, Gear^.Hedgehog, dmg, dsBullet)

   626                         else

   627                             Gear^.State:= Gear^.State or gstWinner;

   628 

   629                         DeleteCI(t);

   630                         t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX);

   631                         t^.dY:= t^.dY + Gear^.dY * dmg * _0_01;

   632                         t^.State:= t^.State or gstMoving;

   633                         t^.Active:= true;

   634                         FollowGear:= t

   635                         end

   636                     end;

   637             gtGrave: begin

   638                     dmg:= 0;

   639                     r:= Gear^.Radius + t^.Radius;

   640                     dx:= Gear^.X-t^.X;

   641                     dx.isNegative:= false;

   642                     dy:= Gear^.Y-t^.Y;

   643                     dy.isNegative:= false;

   644                     if r-hwRound(dx+dy) > 0 then

   645                         begin

   646                         dist:= hwRound(Distance(dx, dy));

   647                         dmg:= ModifyDamage(min(r - dist, 25), t);

   648                         end;

   649                     if dmg > 0 then

   650                         begin

   651                         t^.dY:= - _0_1;

   652                         t^.Active:= true

   653                         end

   654                     end;

   655         end;

   656     t:= t^.NextGear

   657     end;

   658 if (GameFlags and gfSolidLand) = 0 then DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius)

   659 end;

   660 

   661 procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt);

   662 var t: PGearArray;

   663     Gear: PGear;

   664     i, tmpDmg: LongInt;

   665     VGear: PVisualGear;

   666 begin

   667 t:= CheckGearsCollision(Ammo);

   668 // Just to avoid hogs on rope dodging fire.

   669 if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy)) and

   670    (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) and

   671    (sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then

   672     begin

   673     t^.ar[t^.Count]:= CurrentHedgehog^.Gear;

   674     inc(t^.Count)

   675     end;

   676 

   677 i:= t^.Count;

   678 

   679 if (Ammo^.Kind = gtFlame) and (i > 0) then Ammo^.Health:= 0;

   680 while i > 0 do

   681     begin

   682     dec(i);

   683     Gear:= t^.ar[i];

   684     tmpDmg:= ModifyDamage(Damage, Gear);

   685     if (Gear^.State and gstNoDamage) = 0 then

   686         begin

   687 

   688         if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then 

   689             begin

   690             VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit);

   691             if VGear <> nil then VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY);

   692             end;

   693 

   694         if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then Gear^.FlightTime:= 1;

   695 

   696         case Gear^.Kind of

   697             gtHedgehog,

   698             gtMine,

   699             gtSMine,

   700             gtTarget,

   701             gtCase,

   702             gtExplosives,

   703             gtStructure: begin

   704                     if (Ammo^.Kind = gtDrill) then begin Ammo^.Timer:= 0; exit; end;

   705                     if (not Gear^.Invulnerable) then

   706                         ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove)

   707                     else

   708                         Gear^.State:= Gear^.State or gstWinner;

   709                     if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then 

   710                         begin

   711                         if (Ammo^.Hedgehog^.Gear <> nil) then Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable);

   712                         ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch

   713                         end;

   714 

   715                     DeleteCI(Gear);

   716                     if (Gear^.Kind = gtHedgehog) and Gear^.Hedgehog^.King then

   717                         begin

   718                         Gear^.dX:= Ammo^.dX * Power * _0_005;

   719                         Gear^.dY:= Ammo^.dY * Power * _0_005

   720                         end

   721                     else

   722                         begin

   723                         Gear^.dX:= Ammo^.dX * Power * _0_01;

   724                         Gear^.dY:= Ammo^.dY * Power * _0_01

   725                         end;

   726 

   727                     Gear^.Active:= true;

   728                     Gear^.State:= Gear^.State or gstMoving;

   729 

   730                     if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then

   731                         begin

   732                         if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX))

   733                             or (TestCollisionYwithGear(Gear, -1) <> 0)) then Gear^.Y:= Gear^.Y - _1;

   734                         if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX))

   735                             or (TestCollisionYwithGear(Gear, -1) <> 0)) then Gear^.Y:= Gear^.Y - _1;

   736                         if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX))

   737                             or (TestCollisionYwithGear(Gear, -1) <> 0)) then Gear^.Y:= Gear^.Y - _1;

   738                         end;

   739 

   740                     if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then FollowGear:= Gear

   741                     end;

   742         end

   743         end;

   744     end;

   745 if i <> 0 then SetAllToActive

   746 end;

   747 

   748 procedure AssignHHCoords;

   749 var i, t, p, j: LongInt;

   750     ar: array[0..Pred(cMaxHHs)] of PHedgehog;

   751     Count: Longword;

   752 begin

   753 if (GameFlags and gfPlaceHog) <> 0 then PlacingHogs:= true;

   754 if (GameFlags and gfDivideTeams) <> 0 then

   755     begin

   756     t:= 0;

   757     TryDo(ClansCount = 2, 'More or less than 2 clans on map in divided teams mode!', true);

   758     for p:= 0 to 1 do

   759         begin

   760         with ClansArray[p]^ do

   761             for j:= 0 to Pred(TeamsNumber) do

   762                 with Teams[j]^ do

   763                     for i:= 0 to cMaxHHIndex do

   764                         with Hedgehogs[i] do

   765                             if (Gear <> nil) and (Gear^.X.QWordValue = 0) then

   766                                 begin

   767                                 if PlacingHogs then Unplaced:= true

   768                                 else FindPlace(Gear, false, t, t + LAND_WIDTH div 2);// could make Gear == nil;

   769                                 if Gear <> nil then

   770                                     begin

   771                                     Gear^.Pos:= GetRandom(49);

   772                                     Gear^.dX.isNegative:= p = 1;

   773                                     end

   774                                 end;

   775         t:= LAND_WIDTH div 2

   776         end

   777     end else // mix hedgehogs

   778     begin

   779     Count:= 0;

   780     for p:= 0 to Pred(TeamsCount) do

   781         with TeamsArray[p]^ do

   782         begin

   783         for i:= 0 to cMaxHHIndex do

   784             with Hedgehogs[i] do

   785                 if (Gear <> nil) and (Gear^.X.QWordValue = 0) then

   786                     begin

   787                     ar[Count]:= @Hedgehogs[i];

   788                     inc(Count)

   789                     end;

   790         end;

   791     // unC0Rr, while it is true user can watch value on map screen, IMO this (and check above) should be enforced in UI

   792     // - is there a good place to put values for the different widgets to check?  Right now they are kind of disconnected.

   793     //it would be nice if divide teams, forts mode and hh per map could all be checked by the team widget, or maybe disable start button

   794     TryDo(Count <= MaxHedgehogs, 'Too many hedgehogs for this map! (max # is ' + inttostr(MaxHedgehogs) + ')', true);

   795     while (Count > 0) do

   796         begin

   797         i:= GetRandom(Count);

   798         if PlacingHogs then ar[i]^.Unplaced:= true

   799         else FindPlace(ar[i]^.Gear, false, 0, LAND_WIDTH);

   800         if ar[i]^.Gear <> nil then

   801             begin

   802             ar[i]^.Gear^.dX.isNegative:= hwRound(ar[i]^.Gear^.X) > LAND_WIDTH div 2;

   803             ar[i]^.Gear^.Pos:= GetRandom(19)

   804             end;

   805         ar[i]:= ar[Count - 1];

   806         dec(Count)

   807         end

   808     end

   809 end;

   810 

   811 function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray;

   812 var

   813     t: PGear;

   814     l: Longword;

   815 begin

   816     r:= r*r;

   817     GearsNear := nil;

   818     t := GearsList;

   819     while t <> nil do 

   820         begin

   821         if (t^.Kind = Kind) 

   822             and ((X - t^.X)*(X - t^.X) + (Y - t^.Y)*(Y-t^.Y) < int2hwFloat(r)) then

   823             begin

   824             l:= Length(GearsNear);

   825             SetLength(GearsNear, l + 1);

   826             GearsNear[l] := t;

   827             end;

   828         t := t^.NextGear;

   829     end;

   830 end;

   831 

   832 {procedure AmmoFlameWork(Ammo: PGear);

   833 var t: PGear;

   834 begin

   835 t:= GearsList;

   836 while t <> nil do

   837     begin

   838     if (t^.Kind = gtHedgehog) and (t^.Y < Ammo^.Y) then

   839         if not (hwSqr(Ammo^.X - t^.X) + hwSqr(Ammo^.Y - t^.Y - int2hwFloat(cHHRadius)) * 2 > _2) then

   840             begin

   841             ApplyDamage(t, 5);

   842             t^.dX:= t^.dX + (t^.X - Ammo^.X) * _0_02;

   843             t^.dY:= - _0_25;

   844             t^.Active:= true;

   845             DeleteCI(t);

   846             FollowGear:= t

   847             end;

   848     t:= t^.NextGear

   849     end;

   850 end;}

   851 

   852 

   853 function CountGears(Kind: TGearType): Longword;

   854 var t: PGear;

   855     count: Longword = 0;

   856 begin

   857 

   858 t:= GearsList;

   859 while t <> nil do

   860     begin

   861     if t^.Kind = Kind then inc(count);

   862     t:= t^.NextGear

   863     end;

   864 CountGears:= count;

   865 end;

   866 

   867 function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword): PGear;

   868 begin

   869     FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0);

   870     cCaseFactor := 0;

   871 

   872     if (crate <> HealthCrate) and (content > ord(High(TAmmoType))) then content := ord(High(TAmmoType));

   873 

   874     case crate of

   875         HealthCrate: begin

   876             FollowGear^.Pos := posCaseHealth;

   877             FollowGear^.Health := content;

   878             AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo);

   879             end;

   880         AmmoCrate: begin

   881             FollowGear^.Pos := posCaseAmmo;

   882             FollowGear^.AmmoType := TAmmoType(content);

   883             AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo);

   884             end;

   885         UtilityCrate: begin

   886             FollowGear^.Pos := posCaseUtility;

   887             FollowGear^.AmmoType := TAmmoType(content);

   888             AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo);

   889             end;

   890     end;

   891 

   892     if ( (x = 0) and (y = 0) ) then FindPlace(FollowGear, true, 0, LAND_WIDTH);

   893 

   894     SpawnCustomCrateAt := FollowGear;

   895 end;

   896 

   897 function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean): PGear;

   898 begin

   899     FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0);

   900     cCaseFactor := 0;

   901     FollowGear^.Pos := posCaseDummy;

   902     

   903     if explode then FollowGear^.Pos := FollowGear^.Pos + posCaseExplode;

   904     if poison then FollowGear^.Pos := FollowGear^.Pos + posCasePoison;

   905 

   906     case crate of

   907         HealthCrate: begin

   908             FollowGear^.Pos := FollowGear^.Pos + posCaseHealth;

   909             AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo);

   910             end;

   911         AmmoCrate: begin

   912             FollowGear^.Pos := FollowGear^.Pos + posCaseAmmo;

   913             AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo);

   914             end;

   915         UtilityCrate: begin

   916             FollowGear^.Pos := FollowGear^.Pos + posCaseUtility;

   917             AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo);

   918             end;

   919     end;

   920 

   921     if ( (x = 0) and (y = 0) ) then FindPlace(FollowGear, true, 0, LAND_WIDTH);

   922 

   923     SpawnFakeCrateAt := FollowGear;

   924 end;

   925 

   926 function GetAmmo(Hedgehog: PHedgehog): TAmmoType;

   927 var t, aTot: LongInt;

   928     i: TAmmoType;

   929 begin

   930 

   931 aTot:= 0;

   932 for i:= Low(TAmmoType) to High(TAmmoType) do

   933     if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then

   934         inc(aTot, Ammoz[i].Probability);

   935 

   936 t:= aTot;

   937 i:= Low(TAmmoType);

   938 if (t > 0) then

   939     begin

   940     t:= GetRandom(t);

   941     while t >= 0 do

   942       begin

   943       inc(i);

   944       if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then

   945           dec(t, Ammoz[i].Probability)

   946       end

   947     end;

   948 GetAmmo:= i

   949 end;

   950 

   951 function GetUtility(Hedgehog: PHedgehog): TAmmoType;

   952 var t, uTot: LongInt;

   953     i: TAmmoType;

   954 begin

   955 

   956 uTot:= 0;

   957 for i:= Low(TAmmoType) to High(TAmmoType) do

   958     if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then

   959         inc(uTot, Ammoz[i].Probability);

   960 

   961 t:= uTot;

   962 i:= Low(TAmmoType);

   963 if (t > 0) then

   964     begin

   965     t:= GetRandom(t);

   966     while t >= 0 do

   967       begin

   968       inc(i);

   969       if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then

   970           dec(t, Ammoz[i].Probability)

   971       end

   972     end;

   973 GetUtility:= i

   974 end;

   975 

   976 

   977 

   978 procedure SpawnBoxOfSmth;

   979 var t, aTot, uTot, a, h: LongInt;

   980     i: TAmmoType;

   981 begin

   982 if (PlacingHogs) or

   983    (cCaseFactor = 0) or

   984    (CountGears(gtCase) >= 5) or

   985    (GetRandom(cCaseFactor) <> 0) then exit;

   986 

   987 FollowGear:= nil;

   988 aTot:= 0;

   989 uTot:= 0;

   990 for i:= Low(TAmmoType) to High(TAmmoType) do

   991     if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then

   992         inc(aTot, Ammoz[i].Probability)

   993     else

   994         inc(uTot, Ammoz[i].Probability);

   995 

   996 t:=0;

   997 a:=aTot;

   998 h:= 1;

   999 

  1000 if (aTot+uTot) <> 0 then

  1001     if ((GameFlags and gfInvulnerable) = 0) then

  1002         begin

  1003         h:= cHealthCaseProb * 100;

  1004         t:= GetRandom(10000);

  1005         a:= (10000-h)*aTot div (aTot+uTot)

  1006         end

  1007     else

  1008         begin

  1009         t:= GetRandom(aTot+uTot);

  1010         h:= 0

  1011         end;

  1012 

  1013 

  1014 if t<h then

  1015     begin

  1016     FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0);

  1017     FollowGear^.Health:= cHealthCaseAmount;

  1018     FollowGear^.Pos:= posCaseHealth;

  1019     AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo);

  1020     end

  1021 else if (t<a+h) then

  1022     begin

  1023     t:= aTot;

  1024     if (t > 0) then

  1025         begin

  1026         FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0);

  1027         t:= GetRandom(t);

  1028         i:= Low(TAmmoType);

  1029         FollowGear^.Pos:= posCaseAmmo;

  1030         FollowGear^.AmmoType:= i;

  1031         AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo);

  1032         end

  1033     end

  1034 else

  1035     begin

  1036     t:= uTot;

  1037     if (t > 0) then

  1038         begin

  1039         FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0);

  1040         t:= GetRandom(t);

  1041         i:= Low(TAmmoType);

  1042         FollowGear^.Pos:= posCaseUtility;

  1043         FollowGear^.AmmoType:= i;

  1044         AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo);

  1045         end

  1046     end;

  1047 

  1048 // handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities

  1049 if (FollowGear <> nil) then

  1050     begin

  1051     FindPlace(FollowGear, true, 0, LAND_WIDTH);

  1052 

  1053     if (FollowGear <> nil) then

  1054         AddVoice(sndReinforce, CurrentTeam^.voicepack)

  1055     end

  1056 end;

  1057 

  1058 

  1059 function GearByUID(uid : Longword) : PGear;

  1060 var gear: PGear;

  1061 begin

  1062 GearByUID:= nil;

  1063 if uid = 0 then exit;

  1064 if (lastGearByUID <> nil) and (lastGearByUID^.uid = uid) then

  1065     begin

  1066     GearByUID:= lastGearByUID;

  1067     exit

  1068     end;

  1069 gear:= GearsList;

  1070 while gear <> nil do

  1071     begin

  1072     if gear^.uid = uid then

  1073         begin

  1074         lastGearByUID:= gear;

  1075         GearByUID:= gear;

  1076         exit

  1077         end;

  1078     gear:= gear^.NextGear

  1079     end

  1080 end;

  1081 

  1082 

  1083 procedure chSkip(var s: shortstring);

  1084 begin

  1085 s:= s; // avoid compiler hint

  1086 if not CurrentTeam^.ExtDriven then SendIPC(',');

  1087 uStats.Skipped;

  1088 skipFlag:= true

  1089 end;

  1090 

  1091 procedure chHogSay(var s: shortstring);

  1092 var Gear: PVisualGear;

  1093     text: shortstring;

  1094     hh: PHedgehog;

  1095     i, x, t, h: byte;

  1096     c, j: LongInt;

  1097 begin

  1098     hh:= nil;

  1099     i:= 0;

  1100     t:= 0;

  1101     x:= byte(s[1]);  // speech type

  1102     if x < 4 then

  1103         begin

  1104         t:= byte(s[2]);  // team

  1105         if Length(s) > 2 then h:= byte(s[3])  // target hog

  1106         end;

  1107     // allow targetting a hog by specifying a number as the first portion of the text

  1108     if (x < 4) and (h > byte('0')) and (h < byte('9')) then i:= h - 48;

  1109     if i <> 0 then text:= copy(s, 4, Length(s) - 1)

  1110     else if x < 4 then text:= copy(s, 3, Length(s) - 1)

  1111     else text:= copy(s, 2, Length(s) - 1);

  1112 

  1113     (*

  1114     if CheckNoTeamOrHH then

  1115         begin

  1116         ParseCommand('say ' + text, true);

  1117         exit

  1118         end;

  1119     *)

  1120 

  1121     if (x < 4) and (TeamsArray[t] <> nil) then

  1122         begin

  1123             // if team matches current hedgehog team, default to current hedgehog

  1124             if (i = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Team = TeamsArray[t]) then hh:= CurrentHedgehog

  1125             else 

  1126                 begin

  1127             // otherwise use the first living hog or the hog amongs the remaining ones indicated by i

  1128                 j:= 0;

  1129                 c:= 0;

  1130                 while (j <= cMaxHHIndex) and (hh = nil) do

  1131                     begin

  1132                     if (TeamsArray[t]^.Hedgehogs[j].Gear <> nil) then

  1133                         begin

  1134                         inc(c);

  1135                         if (i=0) or (i=c) then

  1136                             hh:= @TeamsArray[t]^.Hedgehogs[j]

  1137                         end;

  1138                     inc(j)

  1139                     end

  1140                 end;

  1141         if hh <> nil then 

  1142             begin

  1143             Gear:= AddVisualGear(0, 0, vgtSpeechBubble);

  1144             if Gear <> nil then

  1145                 begin

  1146                 Gear^.Hedgehog:= hh;

  1147                 Gear^.Text:= text;

  1148                 Gear^.FrameTicks:= x

  1149                 end

  1150             end

  1151         //else ParseCommand('say ' + text, true)

  1152         end

  1153     else if (x >= 4) then

  1154         begin

  1155         SpeechType:= x-3;

  1156         SpeechText:= text

  1157         end;

  1158 end;

  1159 

  1160 procedure initModule;

  1161 const handlers: array[TGearType] of TGearStepProcedure = (

   145 

  1224 begin

   146 function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs

  1225     doStepHandlers:= handlers;

   147 var Gear: PGear;

  1226 

   148     dmg: LongInt;

   149 begin

   150 CheckNoDamage:= true;

   151 Gear:= GearsList;

   152 while Gear <> nil do

   153     begin