(*

 * Hedgewars, a worms-like game

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

type PGear = ^TGear;

     TGearStepProcedure = procedure (Gear: PGear);

     TGear = record

             NextGear, PrevGear: PGear;

             Active: Boolean;

             State : Longword;

             X : hwFloat;

             Y : hwFloat;

             dX: hwFloat;

             dY: hwFloat;

             Kind: TGearType;

             Pos: Longword;

             doStep: TGearStepProcedure;

             Radius: LongInt;

             Angle, Power : Longword;

             DirAngle: hwFloat;

             Timer : LongWord;

             Elasticity: hwFloat;

             Friction  : hwFloat;

             Message : Longword;

             Hedgehog: pointer;

             Health, Damage: LongInt;

             CollisionIndex: LongInt;

             Tag: LongInt;

             Surf: PSDL_Surface;

             Z: Longword;

             IntersectGear: PGear;

             end;

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

procedure ProcessGears;

procedure SetAllToActive;

procedure SetAllHHToActive;

procedure DrawGears(Surface: PSDL_Surface);

procedure FreeGearsList;

procedure AddMiscGears;

procedure AddClouds;

procedure AssignHHCoords;

procedure InsertGearToList(Gear: PGear);

procedure RemoveGearFromList(Gear: PGear);

var CurAmmoGear: PGear = nil;

    GearsList: PGear = nil;

    KilledHHs: Longword = 0;

implementation

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

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

var RopePoints: record

                Count: Longword;

                HookAngle: LongInt;

                ar: array[0..300] of record

                                  X, Y: hwFloat;

                                  dLen: hwFloat;

                                  b: boolean;

                                  end;

                 end;

    StepDamage: Longword = 0;

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

procedure HedgehogStep(Gear: PGear); forward;

procedure HedgehogChAngle(Gear: PGear); forward;

procedure ShotgunShot(Gear: PGear); forward;

procedure AddDamageTag(X, Y, Damage: LongWord; Gear: PGear); forward;

{$INCLUDE GSHandlers.inc}

{$INCLUDE HHHandlers.inc}

const doStepHandlers: array[TGearType] of TGearStepProcedure = (

                                                               @doStepCloud,

                                                               @doStepBomb,

                                                               @doStepHedgehog,

                                                               @doStepGrenade,

                                                               @doStepHealthTag,

                                                               @doStepGrave,

                                                               @doStepUFO,

                                                               @doStepShotgunShot,

                                                               @doStepPickHammer,

                                                               @doStepRope,

                                                               @doStepSmokeTrace,

                                                               @doStepExplosion,

                                                               @doStepMine,

                                                               @doStepCase,

                                                               @doStepDEagleShot,

                                                               @doStepDynamite,

                                                               @doStepTeamHealthSorter,

                                                               @doStepBomb,

                                                               @doStepCluster,

                                                               @doStepShover,

                                                               @doStepFlame,

                                                               @doStepFirePunch,

                                                               @doStepActionTimer,

                                                               @doStepActionTimer,

                                                               @doStepActionTimer,

                                                               @doStepParachute,

                                                               @doStepAirAttack,

                                                               @doStepAirBomb,

                                                               @doStepBlowTorch,

                                                               @doStepGirder,

                                                               @doStepTeleport,

                                                               @doStepHealthTag,

                                                               @doStepSwitcher

                                                               );

procedure InsertGearToList(Gear: PGear);

var tmp: PGear;

begin

if GearsList = nil then

   GearsList:= Gear

   else begin

   // WARNING: this code assumes that the first gears added to the list are clouds (have maximal Z)

   tmp:= GearsList;

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

          tmp:= tmp^.NextGear;

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

   Gear^.PrevGear:= tmp^.PrevGear;

   tmp^.PrevGear:= Gear;

   Gear^.NextGear:= tmp;

   if GearsList = tmp then 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 begin

   GearsList:= Gear^.NextGear;

   if GearsList <> nil then GearsList^.PrevGear:= nil

   end;

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(x)+','+inttostr(y)+'), d('+floattostr(dX)+','+floattostr(dY)+')');{$ENDIF}

New(Result);

{$IFDEF DEBUGFILE}AddFileLog('AddGear: type = ' + inttostr(ord(Kind)));{$ENDIF}

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;

if CurrentTeam <> nil then

   begin

   Result^.Hedgehog:= @(CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog]);

   Result^.IntersectGear:= CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear

   end;

case Kind of

       gtCloud: Result^.Z:= High(Result^.Z);

   gtAmmo_Bomb: begin

                Result^.Radius:= 4;

                Result^.Elasticity:= _0_6;

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

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

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

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

                Result^.State:= 8

                end;

        gtRope: begin

                Result^.Radius:= 3;

                Result^.Friction:= _450;

                RopePoints.Count:= 0;

                end;

   gtExplosion: begin

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

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

                end;

        gtMine: begin

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

                Result^.Radius:= 3;

                Result^.Elasticity:= _0_55;

                Result^.Friction:= _0_995;

                Result^.Timer:= 3000;

                end;

        gtCase: begin

                Result^.Radius:= 16;

                Result^.Elasticity:= _0_4

                end;

  gtDEagleShot: 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;

 gtClusterBomb: begin

                Result^.Radius:= 4;

                Result^.Elasticity:= _0_6;

                Result^.Friction:= _0_995;

                end;

       gtFlame: begin

                Result^.Angle:= Counter mod 64;

                Result^.Radius:= 1;

                Result^.Health:= 2;

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

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

                end;

   gtFirePunch: begin

                Result^.Radius:= 15;

                Result^.Tag:= Y

                end;

     gtAirBomb: begin

                Result^.Radius:= 10;

                end;

   gtBlowTorch: begin

                Result^.Radius:= cHHRadius + cBlowTorchC;

                Result^.Timer:= 7500;

                end;

 gtSmallDamage: begin

                Result^.Timer:= 1100;

                Result^.Z:= 2000;

                end;

     end;

InsertGearToList(Result);

AddGear:= Result

end;

procedure DeleteGear(Gear: PGear);

var team: PTeam;

    t: Longword;

begin

DeleteCI(Gear);

if Gear^.Surf <> nil then

   begin

   SDL_FreeSurface(Gear^.Surf);

   Gear^.Surf:= nil

   end;

if Gear^.Kind = gtHedgehog then

   if CurAmmoGear <> nil then

      begin

      Gear^.Message:= gm_Destroy;

      CurAmmoGear^.Message:= gm_Destroy;

      exit

      end else

      begin

      if not (hwRound(Gear^.Y) < cWaterLine) then

         begin

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

         AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtHealthTag, t, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog;

         inc(StepDamage, t)

         end;

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

      if CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear = Gear then

         FreeActionsList; // to avoid ThinkThread on drawned gear

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

      inc(KilledHHs);

      RecountTeamHealth(team);

      end;

{$IFDEF DEBUGFILE}AddFileLog('DeleteGear');{$ENDIF}

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;

begin

CheckNoDamage:= true;

Gear:= GearsList;

while Gear <> nil do

      begin

      if Gear^.Kind = gtHedgehog then

         if Gear^.Damage <> 0 then

            begin

            CheckNoDamage:= false;

            inc(StepDamage, Gear^.Damage);

            if Gear^.Health < Gear^.Damage then Gear^.Health:= 0

                                           else dec(Gear^.Health, Gear^.Damage);

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

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

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

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

            Gear^.Damage:= 0

            end;

      Gear:= Gear^.NextGear

      end;

end;

procedure AddDamageTag(X, Y, Damage: LongWord; Gear: PGear);

begin

if cAltDamage then

   AddGear(X, Y, gtSmallDamage, Damage, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog;

end;

procedure ProcessGears;

const delay: LongInt = cInactDelay;

      step: (stDelay, stChDmg, stChWin, stSpawn, stNTurn) = stDelay;

var Gear, t: PGear;

begin

AllInactive:= true;

t:= GearsList;

while t<>nil do

      begin

      Gear:= t;

      t:= Gear^.NextGear;

      if Gear^.Active then Gear^.doStep(Gear);

      end;

if AllInactive then

   case step of

        stDelay: begin

                 dec(delay);

                 if delay = 0 then

                    begin

                    inc(step);

                    delay:= cInactDelay

                    end

                 end;

        stChDmg: if CheckNoDamage then inc(step) else step:= stDelay;

        stChWin: if not CheckForWin then inc(step) else step:= stDelay;

        stSpawn: begin

                 if not isInMultiShoot then SpawnBoxOfSmth;

                 inc(step)

                 end;

        stNTurn: begin

                 //AwareOfExplosion(0, 0, 0);

                 if isInMultiShoot then isInMultiShoot:= false

                    else begin

                    with CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog] do

                         if MaxStepDamage < StepDamage then MaxStepDamage:= StepDamage;

                    StepDamage:= 0;

                    ParseCommand('/nextturn', true);

                    end;

                 step:= Low(step)

                 end;

        end;

if TurnTimeLeft > 0 then

   if CurrentTeam <> nil then

      if CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil then

         if ((CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear^.State and gstAttacking) = 0)

            and not isInMultiShoot then dec(TurnTimeLeft);

inc(GameTicks)

end;

procedure SetAllToActive;

var t: PGear;

begin

AllInactive:= false;

t:= GearsList;

while t <> nil do

      begin

      t^.Active:= true;

      t:= t^.NextGear

      end

end;

procedure SetAllHHToActive;

var t: PGear;

begin

AllInactive:= false;

t:= GearsList;

while t <> nil do

      begin

      if t^.Kind = gtHedgehog then t^.Active:= true;

      t:= t^.NextGear

      end

end;

procedure DrawHH(Gear: PGear; Surface: PSDL_Surface);

var t: LongInt;

begin

DrawHedgehog(hwRound(Gear^.X) - 15 + WorldDx, hwRound(Gear^.Y) - 18 + WorldDy,

             hwSign(Gear^.dX), 0,

             PHedgehog(Gear^.Hedgehog)^.visStepPos div 2,

             Surface);

with PHedgehog(Gear^.Hedgehog)^ do

     if (Gear^.State and not gstAnimation) = 0 then

        begin

        t:= hwRound(Gear^.Y) - cHHRadius - 10 + WorldDy;

        dec(t, HealthTag^.h + 2);

        DrawCentered(hwRound(Gear^.X) + WorldDx, t, HealthTag, Surface);

        dec(t, NameTag^.h + 2);

        DrawCentered(hwRound(Gear^.X) + WorldDx, t, NameTag, Surface);

        dec(t, Team^.NameTag^.h + 2);

        DrawCentered(hwRound(Gear^.X) + WorldDx, t, Team^.NameTag, Surface)

        end else // Current hedgehog

        begin

        if bShowFinger and ((Gear^.State and gstHHDriven) <> 0) then

           DrawSprite(sprFinger, hwRound(Gear^.X) - 16 + WorldDx, hwRound(Gear^.Y) - 64 + WorldDy,

                      GameTicks div 32 mod 16, Surface);

        if (Gear^.State and (gstMoving or gstDrowning or gstFalling)) = 0 then

           if (Gear^.State and gstHHThinking) <> 0 then

              DrawGear(sQuestion, hwRound(Gear^.X) - 10 + WorldDx, hwRound(Gear^.Y) - cHHRadius - 34 + WorldDy, Surface)

              else

              if ShowCrosshair and ((Gear^.State and gstAttacked) = 0) then

                 DrawSurfSprite(Round(hwRound(Gear^.X) + hwSign(Gear^.dX) * Sin(Gear^.Angle*pi/cMaxAngle)*60) + WorldDx - 11,

                           Round(hwRound(Gear^.Y) - Cos(Gear^.Angle*pi/cMaxAngle)*60) + WorldDy - 12,

                           24, (18 + hwSign(Gear^.dX) * LongInt(((Gear^.Angle * 72 div cMaxAngle) + 1) div 2) mod 18) mod 18,

                           Team^.CrosshairSurf, Surface);

        end;

end;

procedure DrawGears(Surface: PSDL_Surface);

var Gear: PGear;

    i: Longword;

    roplen: LongInt;