(*

 * 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; 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; 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 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);

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,

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;

                                if Gear^.Kind = gtSentry then

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

                                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 if AttackerHog <> nil then

            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;