(*

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

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

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

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

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

procedure SpawnBoxOfSmth;

procedure ShotgunShot(Gear: PGear);

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

(*if (Mask and EXPLAllDamageInRadius) = 0 then

    dmgRadius:= Radius shl 1

else

    dmgRadius:= Radius;

dmgBase:= dmgRadius + cHHRadius div 2;*)

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;

    //dmg:= dmgRadius  + cHHRadius div 2 - hwRound(Distance(Gear^.X - int2hwFloat(X), Gear^.Y - int2hwFloat(Y)));

    //if (dmg > 1) and

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

        begin

        case Gear^.Kind of

            gtHedgehog,

                gtMine,

                gtBall,

                gtMelonPiece,

                gtGrenade,

                gtClusterBomb,

            //    gtCluster, too game breaking I think

                gtSMine,

                gtAirMine,

                gtCase,

                gtTarget,

                gtFlame,

                gtKnife,

                gtExplosives: begin //,

                //gtStructure: 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

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

                                Gear^.Active:= true;

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

                                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), cWhiteColor, 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 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) > LongInt(rightX) then

        begin

        dec(X, playWidth);

        wrap:= true;

        end

    else if X - (Radius + 5) < LongInt(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 s: ansistring;

    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;

        HHHurt(Gear^.Hedgehog, Source);

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

        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;

                    inc(CurrentHedgehog^.Gear^.Health,vampDmg);

                    s:= IntToStr(vampDmg);

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

                    RenderHealth(CurrentHedgehog^);

                    RecountTeamHealth(CurrentHedgehog^.Team);

                    i:= 0;

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

                        begin

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

                        if vg <> nil then

                            with vg^ do

                                begin

                                Tint:= $FF0000FF;

                                State:= ord(sprHealth)

                                end;

                        inc(i, 5);

                        end;

                    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;

			//if random(2) = 0 then

			//    dy := -dy;

			FrameTicks:= random(500) + 1000;

			State:= ord(sprBubbles);

			//Tint:= $bd2f03ff

			Tint:= $ff0000ff

			end

	end

    end else

    //else if Gear^.Kind <> gtStructure then // not gtHedgehog nor gtStructure

        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;

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

begin

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

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;

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 _0_6 < Gear^.dY then

    //    PlaySound(sndOw4, Gear^.Hedgehog^.Team^.voicepack)

    //else

    //    PlaySound(sndOw1, Gear^.Hedgehog^.Team^.voicepack);

    if Gear^.LastDamage <> nil then

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

    else

        ApplyDamage(Gear, CurrentHedgehog, dmg, dsFall);

    end

end;

procedure CalcRotationDirAngle(Gear: PGear);

var

    dAngle: real;

begin

    // Frac/Round to be kind to JS as of 2012-08-27 where there is yet no int64/uint64

    //dAngle := (Gear^.dX.QWordValue + Gear^.dY.QWordValue) / $80000000;

    dAngle := (Gear^.dX.Round + Gear^.dY.Round) / 2 + (Gear^.dX.Frac/$100000000+Gear^.dY.Frac/$100000000);

    if not Gear^.dX.isNegative then

        Gear^.DirAngle := Gear^.DirAngle + dAngle

    else

        Gear^.DirAngle := Gear^.DirAngle - dAngle;

    if Gear^.DirAngle < 0 then

        Gear^.DirAngle := Gear^.DirAngle + 360

    else if 360 < Gear^.DirAngle then

        Gear^.DirAngle := Gear^.DirAngle - 360

end;

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

var x, y, i, distL, distR, distB, minDist, maxDrops: LongInt;

    splash, particle: PVisualGear;

    speed, hwTmp: hwFloat;

    vi, vs, tmp: real; // impact speed and sideways speed

    isImpactH, isImpactRight: boolean;

const dist2surf = 4;

begin

x:= hwRound(Gear^.X);

y:= hwRound(Gear^.Y);

// find position for splash and impact speed

distB:= cWaterline - y;

if WorldEdge <> weSea then

    minDist:= distB

else

    begin

    distL:= x - leftX;

    distR:= rightX - x;

    minDist:= min(distB, min(distL, distR));

    end;

isImpactH:= (minDist <> distB);

if not isImpactH then

    begin

    y:= cWaterline - dist2surf;

    speed:= hwAbs(Gear^.dY);

    end

else

    begin

    isImpactRight := minDist = distR;

    if isImpactRight then

        x:= rightX - dist2surf

    else

        x:= leftX + dist2surf;

    speed:= hwAbs(Gear^.dX);

    end;

// splash sound

if justSkipping then

    PlaySound(sndSkip)

else

    begin

    // adjust water impact sound based on gear speed and density

    hwTmp:= hwAbs(Gear^.Density * speed);

    if hwTmp > _1 then