(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2009 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

 *)

unit uGears;

interface

uses SDLh, uConsts, uFloat;

{$INCLUDE options.inc}

const AllInactive: boolean = false;

      PrvInactive: boolean = false;

type PGear = ^TGear;

	TGearStepProcedure = procedure (Gear: PGear);

	TGear = record

			NextGear, PrevGear: PGear;

			Active: Boolean;

			Invulnerable: Boolean;

			Ammo : PAmmo;

			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;

			TriggerId: Longword;

			uid: Longword

			end;

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

procedure ProcessGears;

procedure ResetUtilities;

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

procedure SetAllToActive;

procedure SetAllHHToActive;

procedure DrawGears;

procedure FreeGearsList;

procedure AddMiscGears;

procedure AssignHHCoords;

procedure InsertGearToList(Gear: PGear);

procedure RemoveGearFromList(Gear: PGear);

var CurAmmoGear: PGear = nil;

    GearsList: PGear = nil;

    KilledHHs: Longword = 0;

    SuddenDeathDmg: Boolean = false;

    SpeechType: Longword = 1;

    SpeechText: shortstring;

implementation

uses uWorld, uMisc, uStore, uConsole, uSound, uTeams, uRandom, uCollisions,

	uLand, uIO, uLandGraphics, uAIMisc, uLocale, uAI, uAmmos, uTriggers, 

{$IFDEF GLES11}

	gles11,

{$ELSE}

	GL,

{$ENDIF}

	uStats, uVisualGears;

const MAXROPEPOINTS = 384;

var RopePoints: record

                Count: Longword;

                HookAngle: GLfloat;

                ar: array[0..MAXROPEPOINTS] of record

                                  X, Y: hwFloat;

                                  dLen: hwFloat;

                                  b: boolean;

                                  end;

                 end;

procedure DeleteGear(Gear: PGear); forward;

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

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

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

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

procedure SpawnBoxOfSmth; forward;

procedure AfterAttack; forward;

procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); 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;

{$INCLUDE GSHandlers.inc}

{$INCLUDE HHHandlers.inc}

const doStepHandlers: array[TGearType] of TGearStepProcedure = (

			@doStepBomb,

			@doStepHedgehog,

			@doStepGrenade,

			@doStepHealthTag,

			@doStepGrave,

			@doStepUFO,

			@doStepShotgunShot,

			@doStepPickHammer,

			@doStepRope,

			@doStepSmokeTrace,

			@doStepExplosion,

			@doStepMine,

			@doStepCase,

			@doStepDEagleShot,

			@doStepDynamite,

			@doStepBomb,

			@doStepCluster,

			@doStepShover,

			@doStepFlame,

			@doStepFirePunch,

			@doStepActionTimer,

			@doStepActionTimer,

			@doStepActionTimer,

			@doStepParachute,

			@doStepAirAttack,

			@doStepAirBomb,

			@doStepBlowTorch,

			@doStepGirder,

			@doStepTeleport,

			@doStepSwitcher,

			@doStepCase,

			@doStepMortar,

			@doStepWhip,

			@doStepKamikaze,

			@doStepCake,

			@doStepSeduction,

			@doStepWatermelon,

			@doStepCluster,

			@doStepBomb,

			@doStepSmokeTrace,

			@doStepWaterUp,

			@doStepDrill,

			@doStepBallgun,

			@doStepBomb,

			@doStepRCPlane,

			@doStepSniperRifleShot

			);

procedure InsertGearToList(Gear: PGear);

var tmp, ptmp: PGear;

begin

if GearsList = nil then

	GearsList:= Gear

	else begin

	tmp:= GearsList;

	ptmp:= GearsList;

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

		begin

		ptmp:= tmp;

		tmp:= tmp^.NextGear

		end;

	if ptmp <> nil then

		begin

		Gear^.NextGear:= ptmp^.NextGear;

		Gear^.PrevGear:= ptmp;

		if ptmp^.NextGear <> nil then ptmp^.NextGear^.PrevGear:= Gear;

		ptmp^.NextGear:= Gear

		end

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

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

const Counter: Longword = 0;

var Result: PGear;

begin

inc(Counter);

{$IFDEF DEBUGFILE}

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

{$ENDIF}

New(Result);

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

Result^.X:= int2hwFloat(X);

Result^.Y:= int2hwFloat(Y);

Result^.Kind := Kind;

Result^.State:= State;

Result^.Active:= true;

Result^.dX:= dX;

Result^.dY:= dY;

Result^.doStep:= doStepHandlers[Kind];

Result^.CollisionIndex:= -1;

Result^.Timer:= Timer;

Result^.Z:= cUsualZ;

Result^.uid:= Counter;

if CurrentTeam <> nil then

	begin

	Result^.Hedgehog:= CurrentHedgehog;

	Result^.IntersectGear:= CurrentHedgehog^.Gear

	end;

case Kind of

   gtAmmo_Bomb,

 gtClusterBomb: begin

                Result^.Radius:= 4;

                Result^.Elasticity:= _0_6;

                Result^.Friction:= _0_96;

                end;

  gtWatermelon: begin

                Result^.Radius:= 4;

                Result^.Elasticity:= _0_8;

                Result^.Friction:= _0_995;

                end;

    gtHedgehog: begin

                Result^.Radius:= cHHRadius;

                Result^.Elasticity:= _0_35;

                Result^.Friction:= _0_999;

                Result^.Angle:= cMaxAngle div 2;

                Result^.Z:= cHHZ;

                end;

gtAmmo_Grenade: begin

                Result^.Radius:= 4;

                end;

   gtHealthTag: begin

                Result^.Timer:= 1500;

                Result^.Z:= 2002;

                end;

       gtGrave: begin

                Result^.Radius:= 10;

                Result^.Elasticity:= _0_6;

                end;

         gtUFO: begin

                Result^.Radius:= 5;

                Result^.Timer:= 500;

                Result^.Elasticity:= _0_9

                end;

 gtShotgunShot: begin

                Result^.Timer:= 900;

                Result^.Radius:= 2

                end;

  gtPickHammer: begin

                Result^.Radius:= 10;

                Result^.Timer:= 4000

                end;

  gtSmokeTrace,

   gtEvilTrace: begin

                Result^.X:= Result^.X - _16;

                Result^.Y:= Result^.Y - _16;

                Result^.State:= 8;

                Result^.Z:= cSmokeZ

                end;

        gtRope: begin

                Result^.Radius:= 3;

                Result^.Friction:= _450;

                RopePoints.Count:= 0;

                end;

   gtExplosion: begin

                Result^.X:= Result^.X;

                Result^.Y:= Result^.Y;

                end;

        gtMine: begin

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

                Result^.Radius:= 2;

                Result^.Elasticity:= _0_55;

                Result^.Friction:= _0_995;

                if cMinesTime < 0 then

                    Result^.Timer:= getrandom(4)*1000

                else

                    Result^.Timer:= cMinesTime*1;

                end;

        gtCase: begin

                Result^.Radius:= 16;

                Result^.Elasticity:= _0_3

                end;

  gtDEagleShot: begin

                Result^.Radius:= 1;

                Result^.Health:= 50

                end;

  gtSniperRifleShot: begin

                Result^.Radius:= 1;

                Result^.Health:= 50

                end;

    gtDynamite: begin

                Result^.Radius:= 3;

                Result^.Elasticity:= _0_55;

                Result^.Friction:= _0_03;

                Result^.Timer:= 5000;

                end;

     gtCluster: Result^.Radius:= 2;

      gtShover: Result^.Radius:= 20;

       gtFlame: begin

                Result^.Tag:= Counter mod 32;

                Result^.Radius:= 1;

                Result^.Health:= 5;

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

                	begin

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

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

                	end

                end;

   gtFirePunch: begin

                Result^.Radius:= 15;

                Result^.Tag:= Y

                end;

     gtAirBomb: begin

                Result^.Radius:= 5;

                end;

   gtBlowTorch: begin

                Result^.Radius:= cHHRadius + cBlowTorchC;

                Result^.Timer:= 7500;

                end;

    gtSwitcher: begin

                Result^.Z:= cCurrHHZ

                end;

      gtTarget: begin

                Result^.Radius:= 16;

                Result^.Elasticity:= _0_3

                end;

      gtMortar: begin

                Result^.Radius:= 4;

                Result^.Elasticity:= _0_2;

                Result^.Friction:= _0_08

                end;

        gtWhip: Result^.Radius:= 20;

    gtKamikaze: begin

                Result^.Health:= 2048;

                Result^.Radius:= 20

                end;

        gtCake: begin

                Result^.Health:= 2048;

                Result^.Radius:= 7;

                Result^.Z:= cOnHHZ;

                if hwSign(dX) > 0 then Result^.Angle:= 1 else Result^.Angle:= 3

                end;

 gtHellishBomb: begin

                Result^.Radius:= 4;

                Result^.Elasticity:= _0_5;

                Result^.Friction:= _0_96;

                end;

       gtDrill: begin

                Result^.Timer:= 5000;

                Result^.Radius:= 4;

                end;

        gtBall: begin

                Result^.Radius:= 5;

                Result^.Tag:= random(8);

                Result^.Timer:= 5000;

                Result^.Elasticity:= _0_7;

                Result^.Friction:= _0_995;

                end;

     gtBallgun: begin

                Result^.Timer:= 5001;

                end;

     gtRCPlane: begin

                Result^.Timer:= 15000;

                Result^.Health:= 3;

                Result^.Radius:= 8;

                end;

     end;

InsertGearToList(Result);

AddGear:= Result

end;

procedure DeleteGear(Gear: PGear);

var team: PTeam;

	t: Longword;

begin

DeleteCI(Gear);

if Gear^.Tex <> nil then

	begin

	FreeTexture(Gear^.Tex);

	Gear^.Tex:= nil

	end;

if Gear^.Kind = gtHedgehog then

	if (CurAmmoGear <> nil) and (CurrentHedgehog^.Gear = Gear) then

		begin

		Gear^.Message:= gm_Destroy;

		CurAmmoGear^.Message:= gm_Destroy;

		exit

		end

	else

		begin

		if (hwRound(Gear^.Y) >= cWaterLine) then

			begin

			t:= max(Gear^.Damage, Gear^.Health);

			Gear^.Damage:= t;

			AddGear(hwRound(Gear^.X), min(hwRound(Gear^.Y),cWaterLine+cVisibleWater+32), gtHealthTag, t, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog;

			uStats.HedgehogDamaged(Gear)

			end;

		team:= PHedgehog(Gear^.Hedgehog)^.Team;

		if CurrentHedgehog^.Gear = Gear then

			FreeActionsList; // to avoid ThinkThread on drawned gear

		PHedgehog(Gear^.Hedgehog)^.Gear:= nil;

		inc(KilledHHs);

		RecountTeamHealth(team)

		end;

{$IFDEF DEBUGFILE}

with Gear^ do AddFileLog('Delete: #' + inttostr(uid) + ' (' + inttostr(hwRound(x)) + ',' + inttostr(hwRound(y)) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + inttostr(ord(Kind)));

{$ENDIF}

if Gear^.TriggerId <> 0 then TickTrigger(Gear^.TriggerId);

if CurAmmoGear = Gear then CurAmmoGear:= nil;

if FollowGear = Gear then FollowGear:= nil;

RemoveGearFromList(Gear);

Dispose(Gear)

end;

function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs

var Gear: PGear;

    dmg: LongInt;

begin

CheckNoDamage:= true;

Gear:= GearsList;

while Gear <> nil do

	begin

	if Gear^.Kind = gtHedgehog then

		begin

		if (not isInMultiShoot) then inc(Gear^.Damage, Gear^.Karma);

		if (Gear^.Damage <> 0) and

		(not Gear^.Invulnerable) then

			begin

			CheckNoDamage:= false;

			uStats.HedgehogDamaged(Gear);

			dmg:= Gear^.Damage;

			if Gear^.Health < dmg then

				Gear^.Health:= 0

			else

				dec(Gear^.Health, dmg);

            if (PHedgehog(Gear^.Hedgehog)^.Team = CurrentTeam) and

               (Gear^.Damage <> Gear^.Karma) and

                not SuddenDeathDmg then

                Gear^.State:= Gear^.State or gstLoser;

			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y) - cHHRadius - 12,

					gtHealthTag, dmg, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog;

			RenderHealth(PHedgehog(Gear^.Hedgehog)^);

			RecountTeamHealth(PHedgehog(Gear^.Hedgehog)^.Team);

			end;

		if (not isInMultiShoot) then Gear^.Karma:= 0;

		Gear^.Damage:= 0

		end;

	Gear:= Gear^.NextGear

	end;