(*

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

procedure initializeGear(gear: PGear; X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord);

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

(*         gtSentry *) , amSentry

    );

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;

procedure initializeGear(gear: PGear; X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord);

var cakeData: PCakeData;

begin

    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;

    // set gstInBounceEdge if gear spawned inside the bounce world edge

    if WorldEdge = weBounce then

        if (hwRound(gear^.X) - Gear^.Radius < leftX) or (hwRound(gear^.X) + Gear^.Radius > rightX) then

            case gear^.Kind of

                // list all gears here that could collide with the bounce world edge

                gtHedgehog,

                gtFlame,

                gtMine,

                gtAirBomb,

                gtDrill,

                gtNapalmBomb,

                gtCase,

                gtAirMine,

                gtExplosives,

                gtGrenade,

                gtShell,

                gtBee,

                gtDynamite,

                gtClusterBomb,

                gtMelonPiece,

                gtCluster,

                gtMortar,

                gtKamikaze,

                gtCake,

                gtWatermelon,

                gtGasBomb,

                gtHellishBomb,

                gtBall,

                gtRCPlane,

                gtSniperRifleShot,

                gtShotgunShot,

                gtDEagleShot,

                gtSineGunShot,

                gtMinigunBullet,

                gtEgg,

                gtPiano,

                gtSMine,

                gtSnowball,

                gtKnife,

                gtCreeper,

                gtSentry,

                gtMolotov,

                gtFlake,

                gtGrave,

                gtPortal,

                gtTarget:

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

            end;

    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;

             gtSentry: Gear^.Boom := 40;

        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: begin

                    gear^.Tag:= 1; // hog face dir. 1 = right, -1 = left

                    gear^.Z:= cCurrHHZ;

                    end;

           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.