(*

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

interface

uses uFloat, uTypes, SDLh;

function  AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear;

function  AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord): PGear;

procedure DeleteGear(Gear: PGear);

procedure InsertGearToList(Gear: PGear);

procedure RemoveGearFromList(Gear: PGear);

var curHandledGear: PGear;

implementation

uses uRandom, uUtils, uConsts, uVariables, uAmmos, uTeams, uStats,

    uTextures, uScript, uRenderUtils, uAI, uCollisions,

    uGearsRender, uGearsUtils, uDebug;

const

    GearKindAmmoTypeMap : array [TGearType] of TAmmoType = (

(*          gtFlame *)   amNothing

(*       gtHedgehog *) , amNothing

(*           gtMine *) , amMine

(*           gtCase *) , amNothing

(*        gtAirMine *) , amAirMine

(*     gtExplosives *) , amNothing

(*        gtGrenade *) , amGrenade

(*          gtShell *) , amBazooka

(*          gtGrave *) , amNothing

(*            gtBee *) , amBee

(*    gtShotgunShot *) , amShotgun

(*     gtPickHammer *) , amPickHammer

(*           gtRope *) , amRope

(*     gtDEagleShot *) , amDEagle

(*       gtDynamite *) , amDynamite

(*    gtClusterBomb *) , amClusterBomb

(*        gtCluster *) , amClusterBomb

(*         gtShover *) , amBaseballBat  // Shover is only used for baseball bat right now

(*      gtFirePunch *) , amFirePunch

(*    gtATStartGame *) , amNothing

(*   gtATFinishGame *) , amNothing

(*      gtParachute *) , amParachute

(*      gtAirAttack *) , amAirAttack

(*        gtAirBomb *) , amAirAttack

(*      gtBlowTorch *) , amBlowTorch

(*         gtGirder *) , amGirder

(*       gtTeleport *) , amTeleport

(*       gtSwitcher *) , amSwitch

(*         gtTarget *) , amNothing

(*         gtMortar *) , amMortar

(*           gtWhip *) , amWhip

(*       gtKamikaze *) , amKamikaze

(*           gtCake *) , amCake

(*      gtSeduction *) , amSeduction

(*     gtWatermelon *) , amWatermelon

(*     gtMelonPiece *) , amWatermelon

(*    gtHellishBomb *) , amHellishBomb

(*        gtWaterUp *) , amNothing

(*          gtDrill *) , amDrill

(*        gtBallGun *) , amBallgun

(*           gtBall *) , amBallgun

(*        gtRCPlane *) , amRCPlane

(*gtSniperRifleShot *) , amSniperRifle

(*        gtJetpack *) , amJetpack

(*        gtMolotov *) , amMolotov

(*          gtBirdy *) , amBirdy

(*            gtEgg *) , amBirdy

(*         gtPortal *) , amPortalGun

(*          gtPiano *) , amPiano

(*        gtGasBomb *) , amGasBomb

(*    gtSineGunShot *) , amSineGun

(*   gtFlamethrower *) , amFlamethrower

(*          gtSMine *) , amSMine

(*    gtPoisonCloud *) , amNothing

(*         gtHammer *) , amHammer

(*      gtHammerHit *) , amHammer

(*    gtResurrector *) , amResurrector

(*    gtPoisonCloud *) , amNothing

(*       gtSnowball *) , amSnowball

(*          gtFlake *) , amNothing

(*        gtLandGun *) , amLandGun

(*         gtTardis *) , amTardis

(*         gtIceGun *) , amIceGun

(*        gtAddAmmo *) , amNothing

(*  gtGenericFaller *) , amNothing

(*          gtKnife *) , amKnife

(*        gtCreeper *) , amCreeper

(*        gtMinigun *) , amMinigun

(*  gtMinigunBullet *) , amMinigun

    );

var GCounter: LongWord = 0; // this does not get re-initialized, but should be harmless

const

    cUsualZ = 500;

    cOnHHZ = 2000;

procedure InsertGearToList(Gear: PGear);

var tmp, ptmp: PGear;

begin

    tmp:= GearsList;

    ptmp:= GearsList;

    while (tmp <> nil) and (tmp^.Z < Gear^.Z) do

        begin

        ptmp:= tmp;

        tmp:= tmp^.NextGear

        end;

    if ptmp <> tmp then

        begin

        Gear^.NextGear:= ptmp^.NextGear;

        Gear^.PrevGear:= ptmp;

        if ptmp^.NextGear <> nil then

            ptmp^.NextGear^.PrevGear:= Gear;

        ptmp^.NextGear:= Gear

        end

    else

        begin

        Gear^.NextGear:= GearsList;

        if Gear^.NextGear <> nil then

            Gear^.NextGear^.PrevGear:= Gear;

        GearsList:= Gear;

        end;

end;

procedure RemoveGearFromList(Gear: PGear);

begin

if (Gear <> GearsList) and (Gear <> nil) and (Gear^.NextGear = nil) and (Gear^.PrevGear = nil) then

    begin

    AddFileLog('Attempted to remove Gear #'+inttostr(Gear^.uid)+' from the list twice.');

    exit

    end;

checkFails((Gear = nil) or (curHandledGear = nil) or (Gear = curHandledGear), 'You''re doing it wrong', true);

if Gear^.NextGear <> nil then

    Gear^.NextGear^.PrevGear:= Gear^.PrevGear;

if Gear^.PrevGear <> nil then

    Gear^.PrevGear^.NextGear:= Gear^.NextGear

else

    GearsList:= Gear^.NextGear;

Gear^.NextGear:= nil;

Gear^.PrevGear:= nil

end;

function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear;

begin

AddGear:= AddGear(X, Y, Kind, State, dX, dY, Timer, 0);

end;

function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord): PGear;

var gear: PGear;

    //c: byte;

    cakeData: PCakeData;

begin

if newUid = 0 then

    inc(GCounter);

AddFileLog('AddGear: #' + inttostr(GCounter) + ' (' + inttostr(x) + ',' + inttostr(y) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind));

New(gear);

FillChar(gear^, sizeof(TGear), 0);

gear^.X:= int2hwFloat(X);

gear^.Y:= int2hwFloat(Y);

gear^.Target.X:= NoPointX;

gear^.Kind := Kind;

gear^.State:= State;

gear^.Active:= true;

gear^.dX:= dX;

gear^.dY:= dY;

gear^.doStep:= doStepHandlers[Kind];

gear^.CollisionIndex:= -1;

gear^.Timer:= Timer;

if newUid = 0 then

     gear^.uid:= GCounter

else gear^.uid:= newUid;

gear^.SoundChannel:= -1;

gear^.ImpactSound:= sndNone;

gear^.Density:= _1;

// Define ammo association, if any.

gear^.AmmoType:= GearKindAmmoTypeMap[Kind];

gear^.CollisionMask:= lfAll;

gear^.Tint:= $FFFFFFFF;

gear^.Data:= nil;

gear^.Sticky:= false;

if CurrentHedgehog <> nil then

    begin

    gear^.Hedgehog:= CurrentHedgehog;

    if (CurrentHedgehog^.Gear <> nil) and (hwRound(CurrentHedgehog^.Gear^.X) = X) and (hwRound(CurrentHedgehog^.Gear^.Y) = Y) then

        gear^.CollisionMask:= lfNotCurHogCrate

    end;

if (Ammoz[Gear^.AmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then

    gear^.Z:= cHHZ+1

else gear^.Z:= cUsualZ;

case Kind of

          gtFlame: Gear^.Boom := 2;  // some additional expl in there are x3, x4 this

       gtHedgehog: Gear^.Boom := 30;

           gtMine: Gear^.Boom := 50;

           gtCase: Gear^.Boom := 25;

        gtAirMine: Gear^.Boom := 30;

     gtExplosives: Gear^.Boom := 75;

        gtGrenade: Gear^.Boom := 50;

          gtShell: Gear^.Boom := 50;

            gtBee: Gear^.Boom := 50;

    gtShotgunShot: Gear^.Boom := 25;

     gtPickHammer: Gear^.Boom := 6;

//           gtRope: Gear^.Boom := 2; could be funny to have rope attaching to hog deal small amount of dmg?

     gtDEagleShot: Gear^.Boom := 7;

       gtDynamite: Gear^.Boom := 75;

    gtClusterBomb: Gear^.Boom := 20;

     gtMelonPiece,

        gtCluster: Gear^.Boom := Timer;

         gtShover: Gear^.Boom := 30;

      gtFirePunch: Gear^.Boom := 30;

        gtAirBomb: Gear^.Boom := 30;

      gtBlowTorch: Gear^.Boom := 2;

         gtMortar: Gear^.Boom := 20;

           gtWhip: Gear^.Boom := 30;

       gtKamikaze: Gear^.Boom := 30; // both shove and explosion

           gtCake: Gear^.Boom := cakeDmg; // why is cake damage a global constant

     gtWatermelon: Gear^.Boom := 75;

    gtHellishBomb: Gear^.Boom := 90;

          gtDrill: if Gear^.State and gsttmpFlag = 0 then

                        Gear^.Boom := 50

                   else Gear^.Boom := 30;

           gtBall: Gear^.Boom := 40;

        gtRCPlane: Gear^.Boom := 25;

// sniper rifle is distance linked, this Boom is just an arbitrary scaling factor applied to timer-based-damage

// because, eh, why not..

gtSniperRifleShot: Gear^.Boom := 100000;

            gtEgg: Gear^.Boom := 10;

          gtPiano: Gear^.Boom := 80;

        gtGasBomb: Gear^.Boom := 20;

    gtSineGunShot: Gear^.Boom := 35;

          gtSMine: Gear^.Boom := 30;

    gtSnowball: Gear^.Boom := 200000; // arbitrary scaling for the shove

         gtHammer: if cDamageModifier > _1 then // scale it based on cDamageModifier?

                         Gear^.Boom := 2

                    else Gear^.Boom := 3;

    gtPoisonCloud: Gear^.Boom := 20;

          gtKnife: Gear^.Boom := 40000; // arbitrary scaling factor since impact-based

        gtCreeper: Gear^.Boom := 100;

    gtMinigunBullet: Gear^.Boom := 2;

    end;

case Kind of

     gtGrenade,

     gtClusterBomb,

     gtGasBomb: begin

                gear^.ImpactSound:= sndGrenadeImpact;

                gear^.nImpactSounds:= 1;

                gear^.AdvBounce:= 1;

                gear^.Radius:= 5;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_8;

                gear^.Density:= _1_5;

                gear^.RenderTimer:= true;

                if gear^.Timer = 0 then

                    gear^.Timer:= 3000

                end;

  gtWatermelon: begin

                gear^.ImpactSound:= sndMelonImpact;

                gear^.nImpactSounds:= 1;

                gear^.AdvBounce:= 1;

                gear^.Radius:= 6;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_995;

                gear^.Density:= _2;

                gear^.RenderTimer:= true;

                if gear^.Timer = 0 then

                    gear^.Timer:= 3000

                end;

  gtMelonPiece: begin

                gear^.AdvBounce:= 1;

                gear^.Density:= _2;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_995;

                gear^.Radius:= 4

                end;

    gtHedgehog: begin

                gear^.AdvBounce:= 1;

                gear^.Radius:= cHHRadius;

                gear^.Elasticity:= _0_35;

                gear^.Friction:= _0_999;

                gear^.Angle:= cMaxAngle div 2;

                gear^.Density:= _3;

                gear^.Z:= cHHZ;

                if (GameFlags and gfAISurvival) <> 0 then

                    if gear^.Hedgehog^.BotLevel > 0 then

                        gear^.Hedgehog^.Effects[heResurrectable] := 1;

                if (GameFlags and gfArtillery) <> 0 then

                    gear^.Hedgehog^.Effects[heArtillery] := 1;

                // this would presumably be set in the frontend

                // if we weren't going to do that yet, would need to reinit GetRandom

                // oh, and, randomising slightly R and B might be nice too.

                //gear^.Tint:= $fa00efff or ((random(80)+128) shl 16)

                //gear^.Tint:= $faa4efff

                //gear^.Tint:= (($e0+random(32)) shl 24) or

                //             ((random(80)+128) shl 16) or

                //             (($d5+random(32)) shl 8) or $ff

                {c:= GetRandom(32);

                gear^.Tint:= (($e0+c) shl 24) or

                             ((GetRandom(90)+128) shl 16) or

                             (($d5+c) shl 8) or $ff}

                end;

   gtParachute: gear^.Z:= cCurrHHZ;

       gtShell: begin

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_8;

                gear^.Radius:= 4;

                gear^.Density:= _1;

                gear^.AdvBounce:= 1;

                end;

       gtSnowball: begin

                gear^.ImpactSound:= sndMudballImpact;

                gear^.nImpactSounds:= 1;

                gear^.Radius:= 4;

                gear^.Density:= _0_5;

                gear^.AdvBounce:= 1;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_8;

                end;

     gtFlake: begin

                with Gear^ do

                    begin

                    Pos:= 0;

                    Radius:= 1;

                    DirAngle:= random(360);

                    Sticky:= true;

                    if State and gstTmpFlag = 0 then

                        begin

                        dx.isNegative:= GetRandom(2) = 0;

                        dx.QWordValue:= QWord($40DA) * GetRandom(10000) * 8;

                        dy.isNegative:= false;

                        dy.QWordValue:= QWord($3AD3) * GetRandom(7000) * 8;

                        if GetRandom(2) = 0 then

                            dx := -dx;

                        Tint:= $FFFFFFFF

                        end

                    else

                        Tint:= (ExplosionBorderColor shr RShift and $FF shl 24) or

                               (ExplosionBorderColor shr GShift and $FF shl 16) or

                               (ExplosionBorderColor shr BShift and $FF shl 8) or $FF;

                    State:= State or gstInvisible;

                    // use health field to store current frameticks

                    if vobFrameTicks > 0 then

                        Health:= random(vobFrameTicks)

                    else

                        Health:= 0;

                    // use timer to store currently displayed frame index

                    if gear^.Timer = 0 then Timer:= random(vobFramesCount);

                    Damage:= (random(2) * 2 - 1) * (vobVelocity + random(vobVelocity)) * 8

                    end

                end;

       gtGrave: begin

                gear^.ImpactSound:= sndGraveImpact;

                gear^.nImpactSounds:= 1;

                gear^.Radius:= 10;

                gear^.Elasticity:= _0_6;

                gear^.Z:= 1;

                end;

         gtBee: begin

                gear^.Radius:= 5;

                if gear^.Timer = 0 then gear^.Timer:= 500;

                gear^.RenderTimer:= true;

                gear^.Elasticity:= _0_9;

                gear^.Tag:= 0;

                gear^.State:= Gear^.State or gstSubmersible

                end;

   gtSeduction: begin

                gear^.Radius:= cSeductionDist;

                end;

 gtShotgunShot: begin

                if gear^.Timer = 0 then gear^.Timer:= 900;

                gear^.Radius:= 2

                end;

  gtPickHammer: begin

                gear^.Radius:= 10;

                if gear^.Timer = 0 then gear^.Timer:= 4000

                end;

   gtHammerHit: begin

                gear^.Radius:= 8;

                if gear^.Timer = 0 then gear^.Timer:= 125

                end;

        gtRope: begin

                gear^.Radius:= 3;

                gear^.Friction:= _450 * _0_01 * cRopePercent;

                RopePoints.Count:= 0;

                gear^.Tint:= $D8D8D8FF;

                gear^.Tag:= 0; // normal rope render

                gear^.CollisionMask:= lfNotCurHogCrate //lfNotObjMask or lfNotHHObjMask;

                end;

        gtMine: begin

                gear^.ImpactSound:= sndMineImpact;

                gear^.nImpactSounds:= 1;

                gear^.Health:= 10;

                gear^.State:= gear^.State or gstMoving;

                gear^.Radius:= 2;

                gear^.Elasticity:= _0_55;

                gear^.Friction:= _0_995;

                gear^.Density:= _1;

                if gear^.Timer = 0 then

                    begin

                    if cMinesTime < 0 then

                        begin

                        gear^.Timer:= getrandom(51)*100;

                        gear^.Karma:= 1;

                        end

                    else

                        gear^.Timer:= cMinesTime;

                    end;

                gear^.RenderTimer:= true;

                end;

     gtAirMine: begin

                gear^.AdvBounce:= 1;

                gear^.ImpactSound:= sndAirMineImpact;

                gear^.nImpactSounds:= 1;

                gear^.Health:= 30;

                gear^.State:= gear^.State or gstMoving or gstNoGravity or gstSubmersible;

                gear^.Radius:= 8;

                gear^.Elasticity:= _0_55;

                gear^.Friction:= _0_995;

                gear^.Density:= _1;

                gear^.Angle:= 175; // Radius at which air bombs will start "seeking". $FFFFFFFF = unlimited. check is skipped.

                gear^.Power:= cMaxWindSpeed.QWordValue div 2; // hwFloat converted. 1/2 g default. defines the "seek" speed when a gear is in range.

                gear^.Pos:= cMaxWindSpeed.QWordValue * 3 div 2; // air friction. slows it down when not hitting stuff

                gear^.Tag:= 0;

                if gear^.Timer = 0 then

                    begin

                    if cMinesTime < 0 then

                        begin

                        gear^.Timer:= getrandom(13)*100;

                        gear^.Karma:= 1;

                        end

                    else

                        gear^.Timer:= cMinesTime div 4;

                    end;

                gear^.RenderTimer:= true;

                gear^.WDTimer:= gear^.Timer

                end;

       gtSMine: begin

                gear^.Health:= 10;

                gear^.State:= gear^.State or gstMoving;

                gear^.Radius:= 2;

                gear^.Elasticity:= _0_55;

                gear^.Friction:= _0_995;

                gear^.Density:= _1_6;

                gear^.AdvBounce:= 1;

                gear^.Sticky:= true;

                if gear^.Timer = 0 then gear^.Timer:= 500;

                gear^.RenderTimer:= true;

                end;

       gtKnife: begin

                gear^.ImpactSound:= sndKnifeImpact;

                gear^.AdvBounce:= 1;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_8;