(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2010 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *)

{$INCLUDE "options.inc"}

unit uGears;

interface

uses SDLh, uConsts, uFloat, Math;

type

    PGear = ^TGear;

    TGearStepProcedure = procedure (Gear: PGear);

    TGear = record

            NextGear, PrevGear: PGear;

            Active: Boolean;

            AdvBounce: Longword;

            Invulnerable: Boolean;

            RenderTimer: Boolean;

            AmmoType : TAmmoType;

            State : Longword;

            X : hwFloat;

            Y : hwFloat;

            dX: hwFloat;

            dY: hwFloat;

            Kind: TGearType;

            Pos: Longword;

            doStep: TGearStepProcedure;

            Radius: LongInt;

            Angle, Power : Longword;

            DirAngle: real;

            Timer : LongWord;

            Elasticity: hwFloat;

            Friction  : hwFloat;

            Message, MsgParam : Longword;

            Hedgehog: pointer;

            Health, Damage, Karma: LongInt;

            CollisionIndex: LongInt;

            Tag: LongInt;

            Tex: PTexture;

            Z: Longword;

            IntersectGear: PGear;

            FlightTime: Longword;

            uid: Longword;

            ImpactSound: TSound; // first sound, others have to be after it in the sounds def.

            nImpactSounds: Word; // count of ImpactSounds

            SoundChannel: LongInt;

            PortalCounter: LongWord  // Hopefully temporary, but avoids infinite portal loops in a guaranteed fashion.

        end;

    TPGearArray = Array of PGear;

var AllInactive: boolean;

    PrvInactive: boolean;

    CurAmmoGear: PGear;

    GearsList: PGear;

    KilledHHs: Longword;

    SuddenDeathDmg: Boolean;

    SpeechType: Longword;

    SpeechText: shortstring;

    TrainingTargetGear: PGear;

    skipFlag: boolean;

    PlacingHogs: boolean; // a convenience flag to indicate placement of hogs is still in progress

    StepSoundTimer: LongInt;

    StepSoundChannel: LongInt;

procedure initModule;

procedure freeModule;

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

function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword ): PGear;

procedure ResurrectHedgehog(gear: PGear);

procedure ProcessGears;

procedure EndTurnCleanup;

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

procedure SetAllToActive;

procedure SetAllHHToActive;

procedure DrawGears;

procedure FreeGearsList;

procedure AddMiscGears;

procedure AssignHHCoords;

function  GearByUID(uid : Longword) : PGear;

procedure InsertGearToList(Gear: PGear);

procedure RemoveGearFromList(Gear: PGear);

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

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

function  GetLaunchX(at: TAmmoType; dir: LongInt; angle: LongInt): LongInt;

function  GetLaunchY(at: TAmmoType; angle: LongInt): LongInt;

implementation

uses uWorld, uMisc, uStore, uConsole, uSound, uTeams, uRandom, uCollisions, uLand, uIO, uLandGraphics,

     uAIMisc, uLocale, uAI, uAmmos, uStats, uVisualGears, uScript, GLunit, uMobile;

const MAXROPEPOINTS = 384;

var RopePoints: record

                Count: Longword;

                HookAngle: GLfloat;

                ar: array[0..MAXROPEPOINTS] of record

                                  X, Y: hwFloat;

                                  dLen: hwFloat;

                                  b: boolean;

                                  end;

                rounded: array[0..MAXROPEPOINTS + 2] of TVertex2f;

                end;

procedure DeleteGear(Gear: PGear); forward;

procedure doMakeExplosion(X, Y, Radius: LongInt; Mask: LongWord); forward;

procedure doMakeExplosion(X, Y, Radius: LongInt; Mask, Tint: LongWord); forward;

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

//procedure AmmoFlameWork(Ammo: PGear); forward;

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

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

procedure SpawnBoxOfSmth; forward;

procedure AfterAttack; forward;

procedure HedgehogStep(Gear: PGear); forward;

procedure doStepHedgehogMoving(Gear: PGear); forward;

procedure HedgehogChAngle(Gear: PGear); forward;

procedure ShotgunShot(Gear: PGear); forward;

procedure PickUp(HH, Gear: PGear); forward;

procedure HHSetWeapon(Gear: PGear); forward;

procedure doStepCase(Gear: PGear); forward;

function GetLaunchX(at: TAmmoType; dir: LongInt; angle: LongInt): LongInt;

begin

    GetLaunchX:= 0

(*

    if (Ammoz[at].ejectX <> 0) or (Ammoz[at].ejectY <> 0) then

        GetLaunchX:= sign(dir) * (8 + hwRound(AngleSin(angle) * Ammoz[at].ejectX) + hwRound(AngleCos(angle) * Ammoz[at].ejectY))

    else

        GetLaunchX:= 0

*)

end;

function GetLaunchY(at: TAmmoType; angle: LongInt): LongInt;

begin

    GetLaunchY:= 0

(*

    if (Ammoz[at].ejectX <> 0) or (Ammoz[at].ejectY <> 0) then

        GetLaunchY:= hwRound(AngleSin(angle) * Ammoz[at].ejectY) - hwRound(AngleCos(angle) * Ammoz[at].ejectX) - 2

    else

        GetLaunchY:= 0

*)

end;

{$INCLUDE "GSHandlers.inc"}

{$INCLUDE "HHHandlers.inc"}

const doStepHandlers: array[TGearType] of TGearStepProcedure = (

            @doStepBomb,

            @doStepHedgehog,

            @doStepShell,

            @doStepGrave,

            @doStepBee,

            @doStepShotgunShot,

            @doStepPickHammer,

            @doStepRope,

            @doStepMine,

            @doStepCase,

            @doStepDEagleShot,

            @doStepDynamite,

            @doStepBomb,

            @doStepCluster,

            @doStepShover,

            @doStepFlame,

            @doStepFirePunch,

            @doStepActionTimer,

            @doStepActionTimer,

            @doStepActionTimer,

            @doStepParachute,

            @doStepAirAttack,

            @doStepAirBomb,

            @doStepBlowTorch,

            @doStepGirder,

            @doStepTeleport,

            @doStepSwitcher,

            @doStepTarget,

            @doStepMortar,

            @doStepWhip,

            @doStepKamikaze,

            @doStepCake,

            @doStepSeduction,

            @doStepWatermelon,

            @doStepCluster,

            @doStepBomb,

            @doStepWaterUp,

            @doStepDrill,

            @doStepBallgun,

            @doStepBomb,

            @doStepRCPlane,

            @doStepSniperRifleShot,

            @doStepJetpack,

            @doStepMolotov,

            @doStepCase,

            @doStepBirdy,

            @doStepEggWork,

            @doStepPortalShot,

            @doStepPiano,

            @doStepBomb,

            @doStepSineGunShot,

            @doStepFlamethrower,

            @doStepSMine,

            @doStepPoisonCloud,

            @doStepHammer,

            @doStepHammerHit,

            @doStepResurrector

            );

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^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear^.PrevGear;

if Gear^.PrevGear <> nil then

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

else

    GearsList:= Gear^.NextGear

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:= PHedgehog(HHGear^.Hedgehog); // the tag needs the tag to determine the text color

AllInactive:= false;

HHGear^.Active:= true;

end;

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

const Counter: Longword = 0;

var gear: PGear;

begin

inc(Counter);

{$IFDEF DEBUGFILE}

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

{$ENDIF}

New(gear);

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

gear^.X:= int2hwFloat(X);

gear^.Y:= int2hwFloat(Y);

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;

gear^.Z:= cUsualZ;

gear^.FlightTime:= 0;

gear^.uid:= Counter;

gear^.SoundChannel:= -1;

gear^.ImpactSound:= sndNone;

gear^.nImpactSounds:= 0;

if CurrentTeam <> nil then

    begin

    gear^.Hedgehog:= CurrentHedgehog;

    gear^.IntersectGear:= CurrentHedgehog^.Gear

    end;

case Kind of

     gtBomb,

     gtClusterBomb,

     gtGasBomb: begin

                gear^.ImpactSound:= sndGrenadeImpact;

                gear^.nImpactSounds:= 1;

                gear^.AdvBounce:= 1;

                gear^.Radius:= 6;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_8;

                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:= 4;

                gear^.Elasticity:= _0_8;

                gear^.Friction:= _0_995;

                gear^.RenderTimer:= true;

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

                end;

    gtHedgehog: begin

                gear^.AdvBounce:= 1;

                gear^.Radius:= cHHRadius;

                gear^.Elasticity:= _0_35;

                gear^.Friction:= _0_999;

                gear^.Angle:= cMaxAngle div 2;

                gear^.Z:= cHHZ;

                if (GameFlags and gfAISurvival) <> 0 then

                    if PHedgehog(gear^.Hedgehog)^.BotLevel > 0 then

                        PHedgehog(gear^.Hedgehog)^.Effects[heResurrectable] := true;

                end;

       gtShell: begin

                gear^.Radius:= 4;

                end;

       gtGrave: begin

                gear^.ImpactSound:= sndGraveImpact;

                gear^.nImpactSounds:= 1;

                gear^.Radius:= 10;

                gear^.Elasticity:= _0_6;

                end;

         gtBee: begin

                gear^.Radius:= 5;

                gear^.Timer:= 500;

                gear^.RenderTimer:= true;

                gear^.Elasticity:= _0_9;

                gear^.Tag:= getRandom(32);

                end;

 gtShotgunShot: begin

                gear^.Timer:= 900;

                gear^.Radius:= 2

                end;

  gtPickHammer: begin

                gear^.Radius:= 10;

                gear^.Timer:= 4000

                end;

   gtHammerHit: begin

                gear^.Radius:= 8;

                gear^.Timer:= 125

                end;

        gtRope: begin

                gear^.Radius:= 3;

                gear^.Friction:= _450;

                RopePoints.Count:= 0;

                end;

        gtMine: begin

                gear^.Health:= 10;

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

                gear^.Radius:= 2;

                gear^.Elasticity:= _0_55;

                gear^.Friction:= _0_995;

                if cMinesTime < 0 then

                    gear^.Timer:= getrandom(6)*1000

                else

                    gear^.Timer:= cMinesTime*1;

                end;

       gtSMine: begin

                gear^.Health:= 10;

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

                gear^.Radius:= 2;

                gear^.Elasticity:= _0_55;

                gear^.Friction:= _0_995;

                gear^.Timer:= 500;

                end;

        gtCase: begin

                gear^.ImpactSound:= sndGraveImpact;

                gear^.nImpactSounds:= 1;

                gear^.Radius:= 16;

                gear^.Elasticity:= _0_3

                end;

  gtExplosives: begin

                gear^.ImpactSound:= sndGrenadeImpact;

                gear^.nImpactSounds:= 1;

                gear^.Radius:= 16;

                gear^.Elasticity:= _0_4;

                gear^.Friction:= _0_995;

                gear^.Health:= cBarrelHealth

                end;

  gtDEagleShot: begin

                gear^.Radius:= 1;

                gear^.Health:= 50

                end;

  gtSniperRifleShot: begin

                gear^.Radius:= 1;

                gear^.Health:= 50

                end;

    gtDynamite: begin

                gear^.Radius:= 3;

                gear^.Elasticity:= _0_55;

                gear^.Friction:= _0_03;

                gear^.Timer:= 5000;

                end;

     gtCluster: begin

                gear^.Radius:= 2;

                gear^.RenderTimer:= true

                end;

      gtShover: gear^.Radius:= 20;

       gtFlame: begin

                gear^.Tag:= GetRandom(32);

                gear^.Radius:= 1;

                gear^.Health:= 5;

                if (gear^.dY.QWordValue = 0) and (gear^.dX.QWordValue = 0) then

                    begin

                    gear^.dY:= (getrandom - _0_8) * _0_03;

                    gear^.dX:= (getrandom - _0_5) * _0_4

                    end

                end;

   gtFirePunch: begin

                gear^.Radius:= 15;

                gear^.Tag:= Y

                end;

     gtAirBomb: begin

                gear^.Radius:= 5;

                end;

   gtBlowTorch: begin

                gear^.Radius:= cHHRadius + cBlowTorchC;

                gear^.Timer:= 7500

                end;

    gtSwitcher: begin

                gear^.Z:= cCurrHHZ

                end;

      gtTarget: begin

                gear^.ImpactSound:= sndGrenadeImpact;

                gear^.nImpactSounds:= 1;

                gear^.Radius:= 10;

                gear^.Elasticity:= _0_3;

                gear^.Timer:= 0

                end;

      gtMortar: begin

                gear^.Radius:= 4;

                gear^.Elasticity:= _0_2;

                gear^.Friction:= _0_08

                end;

        gtWhip: gear^.Radius:= 20;

      gtHammer: gear^.Radius:= 20;

    gtKamikaze: begin

                gear^.Health:= 2048;

                gear^.Radius:= 20

                end;

        gtCake: begin

                gear^.Health:= 2048;

                gear^.Radius:= 7;

                gear^.Z:= cOnHHZ;

                gear^.RenderTimer:= true;

                gear^.DirAngle:= -90 * hwSign(Gear^.dX);

                if not dX.isNegative then gear^.Angle:= 1 else gear^.Angle:= 3

                end;

 gtHellishBomb: begin

                gear^.ImpactSound:= sndHellishImpact1;

                gear^.nImpactSounds:= 4;

                gear^.AdvBounce:= 1;

                gear^.Radius:= 4;

                gear^.Elasticity:= _0_5;

                gear^.Friction:= _0_96;

                gear^.RenderTimer:= true;

                gear^.Timer:= 5000

                end;

       gtDrill: begin