(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *)

{$INCLUDE "options.inc"}

unit uGearsUtils;

interface

uses uTypes, uFloat;

procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword); inline;

procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord);

procedure AddSplashForGear(Gear: PGear; justSkipping: boolean);

procedure AddBounceEffectForGear(Gear: PGear; imageScale: Single);

procedure AddBounceEffectForGear(Gear: PGear);

function  ModifyDamage(dmg: Longword; Gear: PGear): Longword;

procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource);

procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword);

procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource; Damage: Longword);

procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean; vgTint: Longword);

procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean);

function IncHogHealth(Hedgehog: PHedgehog; healthBoost: LongInt): LongInt;

procedure CheckHHDamage(Gear: PGear);

procedure CalcRotationDirAngle(Gear: PGear);

procedure ResurrectHedgehog(var gear: PGear);

procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); inline;

procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean);

procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity, deleteOnFail: boolean);

function CountLand(x, y, r, c: LongInt; mask, antimask: LongWord): LongInt;

function  CheckGearNear(Kind: TGearType; X, Y: hwFloat; rX, rY: LongInt): PGear;

function  CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear;

function  CheckGearDrowning(var Gear: PGear): boolean;

procedure CheckCollision(Gear: PGear); inline;

procedure CheckCollisionWithLand(Gear: PGear); inline;

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

procedure AmmoShoveCache(Ammo: PGear; Damage, Power: LongInt);

procedure AmmoShoveLine(Ammo: PGear; Damage, Power: LongInt; oX, oY, tX, tY: hwFloat);

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

function  SpawnBoxOfSmth: PGear;

procedure PlayBoxSpawnTaunt(Gear: PGear);

procedure ShotgunShot(Gear: PGear);

function  CountHogsInTeam(HHGear: PGear; countHidden: boolean): LongInt;

function  CanUseTardis(HHGear: PGear): boolean;

procedure SetAllToActive;

procedure SetAllHHToActive(Ice: boolean);

procedure SetAllHHToActive(); inline;

function  GetAmmo(Hedgehog: PHedgehog): TAmmoType;

function  GetUtility(Hedgehog: PHedgehog): TAmmoType;

function WorldWrap(var Gear: PGear): boolean;

function HomingWrap(var Gear: PGear): boolean;

function IsHogFacingLeft(Gear: PGear): boolean;

function IsHogLocal(HH: PHedgehog): boolean;

function MakeHedgehogsStep(Gear: PGear) : boolean;

var doStepHandlers: array[TGearType] of TGearStepProcedure;

implementation

uses uSound, uCollisions, uUtils, uConsts, uVisualGears, uAIMisc,

    uVariables, uLandGraphics, uScript, uStats, uCaptions, uTeams, uStore,

    uLocale, uTextures, uRenderUtils, uRandom, SDLh, uDebug,

    uGearsList, Math, uVisualGearsList, uGearsHandlersMess,

    uGearsHedgehog;

procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword); inline;

begin

    doMakeExplosion(X, Y, Radius, AttackingHog, Mask, $FFFFFFFF);

end;

procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord);

var Gear: PGear;

    dmg, dmgBase: LongInt;

    fX, fY, tdX, tdY: hwFloat;

    vg: PVisualGear;

    i, cnt: LongInt;

    wrap: boolean;

    bubble: PVisualGear;

    s: ansistring;

begin

if Radius > 4 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')');

if Radius > 25 then KickFlakes(Radius, X, Y);

if ((Mask and EXPLNoGfx) = 0) then

    begin

    vg:= nil;

    if CheckCoordInWater(X, Y - Radius) then

        begin

        cnt:= 2 * Radius;

        for i:= (Radius * Radius) div 4 downto 0 do

            begin

            bubble := AddVisualGear(X - Radius + random(cnt), Y - Radius + random(cnt), vgtBubble);

            if bubble <> nil then

                bubble^.dY:= 0.1 + random(20)/10;

            end

        end

    else if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion)

    else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion);

    if vg <> nil then

        vg^.Tint:= Tint;

    end;

if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion);

dmgBase:= Radius shl 1 + cHHRadius div 2;

// we might have to run twice if weWrap is enabled

wrap:= false;

repeat

fX:= int2hwFloat(X);

fY:= int2hwFloat(Y);

Gear:= GearsList;

while Gear <> nil do

    begin

    dmg:= 0;

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

        begin

        case Gear^.Kind of

            gtHedgehog,

                gtMine,

                gtBall,

                gtMelonPiece,

                gtGrenade,

                gtClusterBomb,

                gtSMine,

                gtAirMine,

                gtCase,

                gtTarget,

                gtFlame,

                gtKnife,

                gtExplosives,

                gtSentry: begin

// Run the calcs only once we know we have a type that will need damage

                        tdX:= Gear^.X-fX;

                        tdY:= Gear^.Y-fY;

                        if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then

                            dmg:= dmgBase - hwRound(Distance(tdX, tdY));

                        if dmg > 1 then

                            begin

                            dmg:= ModifyDamage(min(dmg div 2, Radius), Gear);

                            //AddFileLog('Damage: ' + inttostr(dmg));

                            if (Mask and EXPLNoDamage) = 0 then

                                begin

                                if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then

                                    ApplyDamage(Gear, AttackingHog, dmg, dsExplosion)

                                else

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

                                end;

                            if ((Mask and EXPLDoNotTouchAny) = 0) and (((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog)) then

                                begin

                                DeleteCI(Gear);

                                Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, tdX)/(Gear^.Density/_3);

                                Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, tdY)/(Gear^.Density/_3);

                                Gear^.State:= (Gear^.State or gstMoving) and (not gstLoser);

                                if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision);

                                if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then

                                    begin

                                    Gear^.State:= (Gear^.State or gstMoving) and (not (gstHHJumping or gstHHHJump));

                                    if (not GameOver) then

                                        Gear^.State:= (Gear^.State and (not gstWinner));

                                    end;

                                Gear^.Active:= true;

                                if Gear^.Kind <> gtFlame then FollowGear:= Gear;

                                if Gear^.Kind = gtAirMine then

                                    begin

                                    Gear^.Tag:= 1;

                                    Gear^.FlightTime:= 5000;

                                    end

                                end;

                            if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) and

                                (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) and (Gear^.Hedgehog^.Effects[heFrozen] = 0) and

                                (Gear^.State and gstHHDeath = 0) then

                                    begin

                                    if Gear^.Hedgehog^.Effects[hePoisoned] = 0 then

                                        begin

                                        s:= ansistring(Gear^.Hedgehog^.Name);

                                        AddCaption(FormatA(GetEventString(eidPoisoned), s), capcolDefault, capgrpMessage);

                                        uStats.HedgehogPoisoned(Gear, AttackingHog)

                                        end;

                                    Gear^.Hedgehog^.Effects[hePoisoned] := 5;

                                    end

                            end;

                        end;

                gtGrave: if Mask and EXPLDoNotTouchAny = 0 then

// Run the calcs only once we know we have a type that will need damage

                            begin

                            tdX:= Gear^.X-fX;

                            tdY:= Gear^.Y-fY;

                            if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then

                                dmg:= dmgBase - hwRound(Distance(tdX, tdY));

                            if dmg > 1 then

                                begin

                                dmg:= ModifyDamage(min(dmg div 2, Radius), Gear);

                                Gear^.dY:= - _0_004 * dmg;

                                Gear^.Active:= true

                                end

                            end;

            end;

        end;

    Gear:= Gear^.NextGear

    end;

if (Mask and EXPLDontDraw) = 0 then

    if ((GameFlags and gfSolidLand) = 0) or ((Mask and EXPLForceDraw) <> 0) then

        begin

        cnt:= DrawExplosion(X, Y, Radius) div 1608; // approx 2 16x16 circles to erase per chunk

        if (cnt > 0) and (SpritesData[sprChunk].Texture <> nil) then

            for i:= 0 to cnt do

                AddVisualGear(X, Y, vgtChunk)

        end;

if (WorldEdge = weWrap) then

    begin

    // already wrapped? let's not wrap again!

    if wrap then

        break;

    // Radius + 5 because that's the actual radius the explosion changes graphically

    if X + (Radius + 5) > rightX then

        begin

        dec(X, playWidth);

        wrap:= true;

        end

    else if X - (Radius + 5) < leftX then

        begin

        inc(X, playWidth);

        wrap:= true;

        end;

    end;

until (not wrap);

uAIMisc.AwareOfExplosion(0, 0, 0)

end;

function ModifyDamage(dmg: Longword; Gear: PGear): Longword;

var i: hwFloat;

begin

(* Invulnerability cannot be placed in here due to still needing kicks

   Not without a new damage machine.

   King check should be in here instead of ApplyDamage since Tiy wants them kicked less

*)

i:= _1;

if (CurrentHedgehog <> nil) and CurrentHedgehog^.King then

    i:= _1_5;

if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog <> nil) and

   (Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 0)) then

    ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_5 * _0_01)

else

    ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_01);

end;

procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource);

var vampDmg, tmpDmg, i: Longword;

    vg: PVisualGear;

begin

    if Damage = 0 then

        exit; // nothing to apply

    if (Gear^.Kind = gtHedgehog) then

        begin

        Gear^.LastDamage := AttackerHog;

        Gear^.Hedgehog^.Team^.Clan^.Flawless:= false;

        if (Gear^.State and gstHHDeath) = 0 then

            begin

            HHHurt(Gear^.Hedgehog, Source, Damage);

            AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), Damage, Gear^.Hedgehog^.Team^.Clan^.Color);

            end;

        tmpDmg:= min(Damage, max(0,Gear^.Health-Gear^.Damage));

        if (Gear <> CurrentHedgehog^.Gear) and (CurrentHedgehog^.Gear <> nil) and (tmpDmg >= 1) then

            begin

            if cVampiric then

                begin

                vampDmg:= hwRound(int2hwFloat(tmpDmg)*_0_8);

                if vampDmg >= 1 then

                    begin

                    // was considering pulsing on attack, Tiy thinks it should be permanent while in play

                    //CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstVampiric;

                    vampDmg:= IncHogHealth(CurrentHedgehog, vampDmg);

                    RenderHealth(CurrentHedgehog^);

                    RecountTeamHealth(CurrentHedgehog^.Team);

                    HHHeal(CurrentHedgehog, vampDmg, true, $FF0000FF);

                    end

                end;

            if (GameFlags and gfKarma <> 0) and (GameFlags and gfInvulnerable = 0) and

               (CurrentHedgehog^.Effects[heInvulnerable] = 0) then

                begin // this cannot just use Damage or it interrupts shotgun and gets you called stupid

                inc(CurrentHedgehog^.Gear^.Karma, tmpDmg);

                CurrentHedgehog^.Gear^.LastDamage := CurrentHedgehog;

                spawnHealthTagForHH(CurrentHedgehog^.Gear, tmpDmg);

                end;

            end;

        uStats.HedgehogDamaged(Gear, AttackerHog, Damage, false);

    if AprilOne and (Gear^.Hedgehog^.Hat = 'fr_tomato') and (Damage > 2) then

        for i := 0 to random(min(Damage,20))+5 do

        begin

        vg:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot);

        if vg <> nil then

            with vg^ do

            begin

            dx:= 0.001 * (random(100)+10);

            dy:= 0.001 * (random(100)+10);

            tdy:= -cGravityf;

            if random(2) = 0 then

                dx := -dx;

            FrameTicks:= random(500) + 1000;

            State:= ord(sprBubbles);

            Tint:= $ff0000ff

            end

    end

    end else

        Gear^.Hedgehog:= AttackerHog;

    inc(Gear^.Damage, Damage);

    ScriptCall('onGearDamage', Gear^.UID, Damage);

end;

procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword);

var tag: PVisualGear;

begin

tag:= AddVisualGear(hwRound(HHGear^.X), hwRound(HHGear^.Y), vgtHealthTag, dmg);

if (tag <> nil) then

    tag^.Hedgehog:= HHGear^.Hedgehog; // the tag needs the tag to determine the text color

AllInactive:= false;

HHGear^.Active:= true;

end;

// Play effects for hurt hedgehog

procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource; Damage: Longword);

begin

if Hedgehog^.Effects[heFrozen] <> 0 then exit;

if (Damage >= ouchDmg) and (OuchTauntTimer = 0) and ((Source = dsFall) or (Source = dsBullet) or (Source = dsShove) or (Source = dsHammer)) then

    begin

    PlaySoundV(sndOuch, Hedgehog^.Team^.voicepack);

    // Prevent sndOuch from being played too often in short time

    OuchTauntTimer:= 1250;

    end

else if (Source = dsFall) or (Source = dsExplosion) then

    case random(3) of

        0: PlaySoundV(sndOoff1, Hedgehog^.Team^.voicepack);

        1: PlaySoundV(sndOoff2, Hedgehog^.Team^.voicepack);

        2: PlaySoundV(sndOoff3, Hedgehog^.Team^.voicepack);

    end

else if (Source = dsPoison) then

    case random(2) of

        0: PlaySoundV(sndPoisonCough, Hedgehog^.Team^.voicepack);

        1: PlaySoundV(sndPoisonMoan, Hedgehog^.Team^.voicepack);

    end

else

    case random(4) of

        0: PlaySoundV(sndOw1, Hedgehog^.Team^.voicepack);

        1: PlaySoundV(sndOw2, Hedgehog^.Team^.voicepack);

        2: PlaySoundV(sndOw3, Hedgehog^.Team^.voicepack);

        3: PlaySoundV(sndOw4, Hedgehog^.Team^.voicepack);

    end

end;

{-

Show heal particles and message at hog gear.

Hedgehog: Hedgehog which gets the health boost

healthBoost: Amount of added health added

showMessage: Whether to show announcer message

vgTint: Tint of heal particle (if 0, don't render particles)

-}

procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean; vgTint: Longword);

var i: LongInt;

    vg: PVisualGear;

    s: ansistring;

begin

    if healthBoost < 1 then

        exit;

    if showMessage then

        begin

        s:= IntToStr(healthBoost);

        AddCaption(FormatA(trmsg[sidHealthGain], s), Hedgehog^.Team^.Clan^.Color, capgrpAmmoinfo)

        end;

    i:= 0;

    // One particle for every 5 HP. Max. 200 particles

    if (vgTint <> 0) then

        while (i < healthBoost) and (i < 1000) do

            begin

            vg:= AddVisualGear(hwRound(Hedgehog^.Gear^.X), hwRound(Hedgehog^.Gear^.Y), vgtStraightShot);

            if vg <> nil then

                with vg^ do

                    begin

                    Tint:= vgTint;

                    State:= ord(sprHealth)

                    end;

            inc(i, 5)

            end;

end;

// Shorthand for the same above, but with tint implied

procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean);

begin

    HHHeal(Hedgehog, healthBoost, showMessage, $00FF00FF);

end;

// Increase hog health by healthBoost (at least 1).

// Resulting health is capped at cMaxHogHealth.

// Returns actual amount healed.

function IncHogHealth(Hedgehog: PHedgehog; healthBoost: LongInt): LongInt;

var oldHealth: LongInt;

begin

   if healthBoost < 1 then

       begin

       IncHogHealth:= 0;

       exit;

       end;

   oldHealth:= Hedgehog^.Gear^.Health;

   inc(Hedgehog^.Gear^.Health, healthBoost);

   // Prevent overflow

   if (Hedgehog^.Gear^.Health < 1) or (Hedgehog^.Gear^.Health > cMaxHogHealth) then

       Hedgehog^.Gear^.Health:= cMaxHogHealth;

   IncHogHealth:= Hedgehog^.Gear^.Health - oldHealth;

end;

procedure CheckHHDamage(Gear: PGear);

var

    dmg: LongInt;

    i: LongWord;

    particle: PVisualGear;

begin

if _0_4 < Gear^.dY then

    begin

    dmg := ModifyDamage(1 + hwRound((Gear^.dY - _0_4) * 70), Gear);

    if Gear^.Hedgehog^.Effects[heFrozen] = 0 then

         PlaySound(sndBump)

    else PlaySound(sndFrozenHogImpact);

    if dmg < 1 then

        exit;

    for i:= min(12, 3 + dmg div 10) downto 0 do

        begin

        particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);

        if particle <> nil then

            particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480);

        end;

    if ((Gear^.Hedgehog^.Effects[heInvulnerable] <> 0)) then

        exit;

    if Gear^.LastDamage <> nil then

        ApplyDamage(Gear, Gear^.LastDamage, dmg, dsFall)

    else

        ApplyDamage(Gear, CurrentHedgehog, dmg, dsFall);

    end

end;

procedure CalcRotationDirAngle(Gear: PGear);