Subversion Repositories spacemission

unit colli3DX;

{$include DelphiXcfg.inc}

//*************************************************************************

//*                                                                       *

//*  TCollisionTester3DX  vs 1.3                                          *

//*                                                                       *

//*************************************************************************

//

// This Delphi 4, 5, 6 component is CopyRight:

//

// Henrik Fabricius, August 1999, March 2000, June 2002

// http://users.cybercity.dk/~bbl6194/delphi3dx.htm

// E-mail: henrik_og_bodil@vip.cybercity.dk

//

// You may use this component for free on the following conditions:

// 1) this text must remain part of the unit.

// 2) Any proposals for changes or improvements should be addressed directly to

//    the copyright owner Henrik Fabricius

// 3) The use of this component is on your own risk. The software is provided

//    as is without any garanties and warranty. The CopyRight Owner is not

//    responsible for any damage or losses of any kind caused by the use of this

//    software or the software it is intended to be used with.

//

// To place a link for down-loads of this component on your homepage

// please place a link to the Delphi3DX page where the latest version

// is available.

//

// To use this component you must have

// 1) Delphi 4, 5 or 6

// 2) MS-DirectX 6.0 or higher

// 3) the DelphiX components from Hori in Japan

//

// MS-DirectX is a trademark of the Microsoft Corporation

// Delphi 4, 5 and 6 is a trademark of the Inprise Corporation

//

// Use this component to check for collisions between 3D objects in

// Direct3D games.

// Place your 3D-objects in a world described by :

// - DXDrawUsed -

//

// Group the 3D-objects in series with different material

// or functional properties

// The 3D-object series are named by the property:

// - Indexof3DSeries -

// 3D-objects are named by the property :

// - Indexof3Dobject -

// A 3D-object consist of one or more 3D-elements named by the property :

// - Indexof3DElement -

//

// Surround each of your 3D elements by at least one collision object

// which must be a member of the following primitives :

// - box3D - sphere3D - ellipsoid3D - cylinder3D - conus3D -

// available CollOrientations are :

// - Symmetric_X - Symmetric_Y - Symmetric_Z -

// available material properties are :

// - solid3D - water3D - air3D

// the size of the small end of the conus is described by the property

// - PercentLeftatTop -

// a negative value means that the top is downwards

// available functional properties are :

// - Pickable - Shootable - Fixed3DObject

// Add each object by specifying :

// - FrameSeries - NextAddMesh - CoverWholeMesh -

// - IndexOf3DSeries - IndexOf3DObject - IndexOf3DElement -

// if coverWholeMesh is false then specify a box containing the part of the

// 3D object which should be covered by the coll object by the commands

// - BoxPartMin(x,y,z) - BoxPartMax(x,y,z) -

// Finally add the collision object by executing the command

// - AddCollisionObject -

//

// Bullets are described by the following properties :

// - BulletRadius - BulletRange - BulletFrame - LongShots -

// LongShots moves with a unlimited speed reaching the objects immediately

//

// The actor is described by :

// - FrontDistance - HeadRadius -

//

// The camera-frame and the bullet-frames move each time the move command

// is used in the main program.

// Execute the following commands prior to each move command :

//  - GetOldEyePos - GetOldBulletPos -

// The collisionTester needs this information to test for a possible collision

// in between the starting and the ending points of the Eye/bullet

//

// Test for collision with the following function calls :

// - if CollisionTester3DX1.Collision then ..

// - if CollisionTester3DX1.BulletCollision then ..

// On collision read the HitLinkNr and the properties of the collision object

//

// Destroy 3D collisionObjects by specifying :

//  - NextDestroyNr - IndexOf3DSeries -

// and the executing command DestroyCollisionObject

//

// Initialize the collisionTester with the command :

// - CollisionTester3DX1.ZeroSetIt -

// This must always be done when DXDraw is initialized

//

// To install the component:

// 1) place this unit and the dcr file in the same directory as DelphiX

// 2) In Delphi you must click on Component - Install Component

// 3) Select the colli3DX.pas file and choose the Samples package to install it

// 4) Rebuild the library

// 5) Look for a new icon with a bomb on the page named DelphiX

//

// Tutorial programs are available for down-load at

// http://users.cybercity.dk/~bbl6194/delphi3dx.htm

//

// Good Luck

// Henrik Fabricius

//

//

//****************************************************************************

interface

uses

  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

  StdCtrls, DXClass, DXDraws,

{$IfDef StandardDX}

  DirectDraw, Direct3D, Direct3DRM;

{$Else}

  DirectX;

{$EndIf}

Type

  Tshapes3D = (box3D, sphere3D, ellipsoid3D, cylinder3D, conus3D);

  Tmaterials3D = (solid3D, water3D, air3D);

  TOrientation3D = (symmetric_x, symmetric_y, symmetric_z);

  TFrames3D = Array of Array of IDirect3DRMFrame;

  TCollisionTester3DX = class(TComponent)

  private

    {private declarations}

    FDXDrawUsed       : TDXDraw;

    FFrameSeries      : TFrames3D;

    FNextAddMesh      : IDirect3DRMMesh;

    FBulletFrame      : IDirect3DRMFrame;

    FBoxPartMin       : TD3DVector;

    FBoxPartMax       : TD3DVector;

    FOldBulletPosition: TD3DVector;

    FOldEyePosition   : TD3DVector;

    FNrOfSeries        : integer;

    FSeriesIndex       : integer;

    FSeriesNr          : integer;

    FOrientation3D     : TOrientation3D;

    Fshape3D           : Tshapes3D;

    Fmaterial3D        : Tmaterials3D;

    FPercentLeftAtTop  : integer;

    Fbullet_hitLinknr  : integer;

    FIndexOf3DObject   : integer;

    FIndexOf3DElement  : integer;

    FNextDestroyNr     : integer;

    FNextAllOfMesh     : Boolean;

    FFrontDistance     : integer;

    FBulletRange       : integer;

    FBulletRadius      : integer;

    FHeadRadius        : integer;

    FFixed3DObject     : Boolean;

    FShootable         : Boolean;

    FLongShots         : Boolean;

    FPickable          : Boolean;

    FCheckAllCollObj   : Boolean;

    Fcoll_Nr_Objects  : Array of integer;

    FSeriesIndex_for_SeriesNr : Array of integer;

    FNrinFrameSeries  : Array of Array of integer;

    Fcoll_orientation : Array of Array of TOrientation3D;

    Fcoll_shape       : Array of Array of Tshapes3D;

    Fcoll_material    : Array of Array of Tmaterials3D;

    Fcoll_box_min     : Array of Array of TD3DVector;

    Fcoll_box_max     : Array of Array of TD3DVector;

    Fcoll_radius      : Array of Array of TD3DValue;

    Fcoll_frac_at_top : Array of Array of TD3DValue;

    Fcoll_shootable   : Array of Array of boolean;

    Fcoll_Pickable    : Array of Array of boolean;

    Fcoll_Fixed3D     : Array of Array of boolean;

    Fcoll_objectNr    : Array of Array of integer;

    procedure SetOrientation3D(Value : TOrientation3D);

    procedure SetShape3D(Value: TShapes3D);

    procedure SetMaterial3D(Value: Tmaterials3D);

    procedure SetPercentLeftatTop(Value: integer);

    procedure SetIndexOf3DObject(Value : integer);

    procedure SetIndexOf3DElement(Value : integer);

    procedure SetIndexOf3DSeries(Value : integer);

    procedure SetNextDestroyNr(Value : Integer);

    procedure SetBulletRadius(Value : Integer);

    procedure SetHeadRadius(Value : Integer);

    procedure SetFrontDistance(Value : Integer);

    procedure SetBulletRange(Value : Integer);

    function  add_space_for_one_more : boolean;

    procedure GetTheBox;

    procedure AddBox;

    procedure AddSphere;

    procedure AddCylinder;

    procedure AddConus;

    procedure AddEllipsoid;

    procedure MakeNewSeries;

    procedure Destroy_empty_series(SeriesNr : integer);

    function  GetSeriesNr(Nr : integer): integer;

    procedure remove_collision_object(seriesNr, Value : integer);

    function  CheckForSeriesIndex(indexnow : integer): boolean;

    procedure ListDataForCollObject;

    function  coll_test_box(coll_nr : byte;

                           old_attacker_position, attacker_position : TD3DVector;

                           bullet_radius : TD3DValue; longshot : boolean): boolean;

    function  coll_test_cylinder(coll_nr : byte;

                           old_attacker_position, attacker_position : TD3DVector;

                           bullet_radius : TD3DValue; longshot : boolean): boolean;

    function  coll_test_sphere(coll_nr : byte;

                           old_attacker_position,

                           attacker_position : TD3DVector;

                           bullet_radius : TD3Dvalue; longshot : boolean): boolean;

    function  coll_test_ellipsoid(coll_nr : byte;

                           old_attacker_position, attacker_position : TD3DVector;

                           bullet_radius : TD3DValue; longshot : boolean): boolean;

    function  coll_test_conus(coll_nr : byte;

                           old_attacker_position, attacker_position : TD3DVector;

                           bullet_radius : TD3DValue; longshot : boolean): boolean;

  protected

  public

    Constructor Create(AOwner : TComponent); override;

    destructor Destroy; override;

    property DXDrawUsed       : TDXDraw write FDXDrawUsed stored false;

    property FrameSeries      : TFrames3D write FFrameSeries stored false;

    property NextAddMesh      : IDirect3DRMMesh write FNextAddMesh stored false;

    property BulletFrame      : IDirect3DRMFrame write FBulletFrame stored false;

    procedure ZeroSetIt;

    procedure BoxPartMin(xval, yval, zval: TD3DValue);

    procedure BoxPartMax(xval, yval, zval: TD3DValue);

    procedure GetOldBulletPos;

    procedure GetOldEyePos;

    function  HitLinkNr: integer;

    function  DestroyCollisionObject: boolean;

    procedure AddCollisionObject;

    function  Collision: boolean;

    function  Bulletcollision: boolean;

    function  BulletDead : boolean;

  published

    property BulletRadius     : Integer read FBulletRadius write SetBulletRadius

                                default 0;

    property BulletRange      : Integer read FbulletRange write SetBulletRange

                                Default 100;

    property CollisionCheckAll: Boolean read FCheckAllCollObj

                                write FCheckAllCollObj  Default true;

    property CollOrientation  : TOrientation3D read FOrientation3D

                                write SetOrientation3D default symmetric_y;

    property CollObjectType   : Tshapes3D read Fshape3D write SetShape3D

                                default box3D;

    property CollObjMaterial  : Tmaterials3D read Fmaterial3D write SetMaterial3D

                                default solid3D;

    property CoverWholeMesh   : boolean read FNextAllOfMesh

                                write FNextAllOfMesh default true;

    Property Fixed3DObject    : boolean read FFixed3DObject

                                write FFixed3DObject default true;

    property FrontDistance    : Integer read FFrontDistance

                                write SetFrontDistance default 0;

    property HeadRadius       : integer read FHeadRadius write SetHeadRadius

                                default 0;

    property IndexOf3DSeries  : integer read FSeriesIndex

                                write SetIndexOf3DSeries default 0;

    property IndexOf3DObject  : integer read FIndexOf3DObject

                                write SetIndexOf3DObject default 0;

    property IndexOf3DElement : integer read FIndexOf3DElement

                                write SetIndexOf3DElement default 0;

    property NextDestroyNr    : Integer read FNextDestroyNr

                                write SetNextDestroyNr default 0;

    Property PercentLeftAtTop : integer read FPercentLeftAtTop

                                write SetPercentLeftAtTop default 0;

    Property Pickable         : Boolean read FPickable write FPickable

                                default false;

    Property Shootable        : boolean read FShootable write FShootable

                                Default false;

    Property LongShots        : boolean read FLongShots write FLongShots

                                Default false;

  end; //end of Class

//Registering of the Component

Procedure Register;

implementation

procedure Register;

begin

  //Register the component together with the DelphiX components from Hori

  RegisterComponents('DelphiX', [TCollisionTester3DX]);

end; //end of Register

constructor TCollisionTester3DX.Create(AOwner : TComponent);

begin

  inherited Create(AOwner);

  //The constructor always clears the storage it allocates for a new object

  //Hence there is no need to initialize fields except to nonzero or nonempty

  //values

  FDXDrawUsed := nil;

  FFrameSeries := nil;

  FNextAddMesh := nil;

  FBulletFrame := nil;

  FOrientation3D := symmetric_y;

  FShape3D := box3D;

  FMaterial3D := solid3D;

  FBulletRange := 100;

  FNrOfSeries := 0;

  setlength(FSeriesIndex_for_SeriesNr, 0);

  setlength(FColl_nr_objects, 0);

  setlength(FNrinFrameSeries, 0);

  setlength(Fcoll_shape, 0);

  setlength(Fcoll_box_min, 0);

  setlength(Fcoll_box_max, 0);

  setlength(Fcoll_radius, 0);

  setlength(Fcoll_frac_at_top, 0);

  setlength(Fcoll_objectnr, 0);

  setlength(Fcoll_shootable, 0);

  setlength(Fcoll_pickable, 0);

  setlength(Fcoll_orientation, 0);

  setlength(Fcoll_material, 0);

  setlength(Fcoll_Fixed3D, 0);

end; //end of creation

destructor TCollisionTester3DX.Destroy;

begin

  //destroy any embedded objects and free resources allocated by the objects

  FnrinFrameSeries := nil;

  Fcoll_shape := nil;

  Fcoll_box_min := nil;

  Fcoll_box_max := nil;

  Fcoll_radius := nil;

  Fcoll_frac_at_top := nil;

  Fcoll_objectnr := nil;

  Fcoll_shootable := nil;

  Fcoll_pickable := nil;

  Fcoll_orientation := nil;

  Fcoll_material := nil;

  Fcoll_Fixed3D := nil;

  FSeriesIndex_for_SeriesNr := nil;

  Fcoll_nr_objects := nil;

  inherited Destroy;

end; //end of Destroy

procedure TCollisionTester3DX.ZeroSetIt;

begin

  //initialises the dynamic arrays

  FnrinFrameSeries := nil;

  Fcoll_shape := nil;

  Fcoll_box_min := nil;

  Fcoll_box_max := nil;

  Fcoll_radius := nil;

  Fcoll_frac_at_top := nil;

  Fcoll_objectnr := nil;

  Fcoll_shootable := nil;

  Fcoll_pickable := nil;

  Fcoll_orientation := nil;

  Fcoll_material := nil;

  Fcoll_Fixed3D := nil;

  FSeriesIndex_for_SeriesNr := nil;

  Fcoll_nr_objects := nil;

  FDXDrawUsed := nil;

  FFrameSeries := nil;

  FNextAddMesh := nil;

  FBulletFrame := nil;

  FOrientation3D := symmetric_y;

  FShape3D := box3D;

  FMaterial3D := solid3D;

  FBulletRange := 100;

  FNrOfSeries := 0;

  setlength(FSeriesIndex_for_SeriesNr, 0);

  setlength(FColl_nr_objects, 0);

  setlength(FNrinFrameSeries, 0);

  setlength(Fcoll_shape, 0);

  setlength(Fcoll_box_min, 0);

  setlength(Fcoll_box_max, 0);

  setlength(Fcoll_radius, 0);

  setlength(Fcoll_frac_at_top, 0);

  setlength(Fcoll_objectnr, 0);

  setlength(Fcoll_shootable, 0);

  setlength(Fcoll_pickable, 0);

  setlength(Fcoll_orientation, 0);

  setlength(Fcoll_material, 0);

  setlength(Fcoll_Fixed3D, 0);

end;  //end of ZeroSetIt

function TcollisionTester3DX.HitLinkNr: integer;

begin

  result := Fbullet_hitlinknr;

end; //end of HitLinkNr

procedure TCollisionTester3DX.ListDataForCollObject;

var

  Nr : integer;

begin

  Nr := FBullet_HitLinkNr;

  CollObjectType   := Fcoll_shape[FSeriesNr, Nr];

  CollObjMaterial  := Fcoll_material[FSeriesNr, Nr];

  Fixed3DObject    := Fcoll_Fixed3D[FSeriesNr, Nr];

  CollOrientation  := Fcoll_orientation[FSeriesNr, Nr];

  IndexOf3DObject  := Fcoll_objectNr[FSeriesNr, Nr];

  IndexOf3DSeries  := FSeriesIndex;

  IndexOf3DElement := FNrinFrameSeries[FSeriesNr, Nr];

  Pickable         := Fcoll_pickable[FSeriesNr, Nr];

  Shootable        := Fcoll_shootable[FseriesNr, Nr];

end; //end of ListDataForCollObject

procedure TcollisionTester3DX.SetPercentLeftAtTop(Value : Integer);

begin

  //value can not be negative

  if (FPercentLeftAtTop <> Value) and (Value >= 0)

  then

    FPercentLeftAtTop := value;

end; //end of SetPercentLeftAtTop

procedure TcollisionTester3DX.SetOrientation3D(Value : TOrientation3D);

begin

  if FOrientation3D <> Value

  then

    FOrientation3D := Value;

end; //end setorientation3D

procedure TcollisionTester3DX.SetShape3D(Value : Tshapes3D);

begin

  if Fshape3D <> Value

  then

    Fshape3D := Value;

end; //end setshapes3D

procedure TcollisionTester3DX.SetMaterial3D(Value : Tmaterials3D);

begin

  if Fmaterial3D <> Value

  then

    Fmaterial3D := Value;

end; //end setshapes3D

procedure TCollisionTester3DX.SetIndexOf3DObject(Value : integer);

begin

  //Index can not be negative

  if (FIndexOf3DObject <> Value) and (Value >= 0)

  then

    FIndexOf3DObject := value;

end; //end setIndexOf3DObject

procedure TCollisionTester3DX.SetIndexOf3DElement(Value : integer);

begin

  //Index can not be negative

  if (FIndexOf3DElement <> Value) and (Value >= 0)

  then

    FIndexOf3DElement := value;

end; //end setIndexOf3DElement

procedure TCollisionTester3DX.SetIndexOf3DSeries(Value : integer);

begin

  //Index can not be negative

  if (FSeriesIndex <> Value) and (Value >= 0)

  then

    FSeriesIndex := value;

end; //end of SetIndexOf3DSeries

procedure TCollisionTester3DX.SetNextDestroyNr(Value : integer);

begin

  //Index can not be negative

  if (FNextDestroyNr <> Value) and (Value >= 0)

  then

    FNextDestroyNr := value;

end; //end of SetNextDestroyNr

procedure TCollisionTester3DX.SetBulletRadius(Value : Integer);

begin

  //Radius can not be negative

  if (FBulletRadius <> Value) and (Value >= 0)

  then

    FBulletRadius := value;

end; //end of SetBulletRadius

procedure TCollisionTester3DX.SetHeadRadius(Value : Integer);

begin

  //Radius can not be negative

  if (FHeadRadius <> Value) and (Value >= 0)

  then

    FHeadRadius := value;

end; //end of SetHeadRadius

procedure TCollisionTester3DX.SetFrontDistance(Value : Integer);

begin

  //FrontDistance can not be negative

  if (FFrontDistance <> Value) and (Value >= 0)

  then

    FFrontDistance := value;

end; //end of SetFrontDistance

procedure TCollisionTester3DX.SetBulletRange(Value : Integer);

begin

  //BulletRange can not be negative

  if (FBulletRange <> Value) and (Value >= 0)

  then

    FBulletRange := value;

end; //end of SetBulletRange

function TcollisionTester3DX.Add_Space_For_One_More: boolean;

var

  NewNr : integer;

begin

  //add space for one more element in the present series

  //length of Fcoll_nr_objects and FSeries_nIndex_for_SeriesNr are unchanged

  NewNr := Fcoll_nr_objects[FseriesNr] + 1;

  result := true;

  try

    SetLength(FNrinFrameSeries[FSeriesNr],  NewNr);

    SetLength(Fcoll_shape[FSeriesNr],       NewNr);

    SetLength(Fcoll_box_min[FSeriesNr],     NewNr);

    SetLength(Fcoll_box_max[FSeriesNr],     NewNr);

    SetLength(Fcoll_radius[FSeriesNr],      NewNr);

    SetLength(Fcoll_frac_at_top[FSeriesNr], NewNr);

    SetLength(Fcoll_objectnr[FSeriesNr],    NewNr);

    SetLength(Fcoll_shootable[FSeriesNr],   NewNr);

    SetLength(Fcoll_pickable[FSeriesNr],    NewNr);

    SetLength(Fcoll_orientation[FSeriesNr], NewNr);

    SetLength(Fcoll_material[FSeriesNr],    NewNr);

    SetLength(Fcoll_Fixed3D[FSeriesNr],     NewNr);

  except

    on EOutOfMemory do

    begin

      //There is not enough memory available. Free some memory

      dec(NewNr);

      copy(FNrinFrameSeries[FseriesNr],  0, NewNr);

      copy(Fcoll_shape[FseriesNr],       0, NewNr);

      copy(Fcoll_box_min[FSeriesNr],     0, NewNr);

      copy(Fcoll_box_max[FSeriesNr],     0, NewNr);

      copy(Fcoll_radius[FSeriesNr],      0, NewNr);

      copy(Fcoll_frac_at_top[FSeriesNr], 0, NewNr);

      copy(Fcoll_objectnr[FSeriesNr],    0, NewNr);

      copy(Fcoll_shootable[FSeriesNr],   0, NewNr);

      copy(Fcoll_pickable[FSeriesNr],    0, NewNr);

      copy(Fcoll_orientation[FSeriesNr], 0, NewNr);

      copy(Fcoll_material[FSeriesNr],    0, NewNr);

      copy(Fcoll_Fixed3D[FSeriesNr],     0, NewNr);

      result := false;

    end;

  end;

  //update count of objects in series

  Fcoll_nr_objects[FseriesNr] := NewNr;

end; //end of Add_Space_For_One_More

procedure TcollisionTester3DX.MakeNewSeries;

begin

  inc(FNrOfSeries);

  SetLength(FSeriesIndex_for_SeriesNr, FNrOfSeries);

  FSeriesIndex_for_SeriesNr[FNrOfSeries-1] := FSeriesIndex;

  SetLength(Fcoll_nr_objects, FNrOfSeries);

  Fcoll_nr_objects[FNrOfSeries-1] := 0;

  SetLength(FNrinFrameSeries,  FNrOfSeries);

  SetLength(Fcoll_shape,       FNrOfSeries);

  SetLength(Fcoll_box_min,     FNrOfSeries);

  SetLength(Fcoll_box_max,     FNrOfSeries);

  SetLength(Fcoll_radius,      FNrOfSeries);

  SetLength(Fcoll_frac_at_top, FNrOfSeries);

  SetLength(Fcoll_objectnr,    FNrOfSeries);

  SetLength(Fcoll_shootable,   FNrOfSeries);

  SetLength(Fcoll_pickable,    FNrOfSeries);

  SetLength(Fcoll_orientation, FNrOfSeries);

  SetLength(Fcoll_material,    FNrOfSeries);

  SetLength(Fcoll_Fixed3D,     FNrOfSeries);

end; //end of MakeNewSeries

procedure TcollisionTester3DX.Destroy_Empty_Series(SeriesNr : integer);

var

  i, j : integer;

begin

  if seriesNr < (FNrOfSeries - 1)

  then

  begin

    for i := SeriesNr to (FNrOfSeries - 2) do

    begin

      FSeriesIndex_for_SeriesNr[i] := FSeriesIndex_for_SeriesNr[i+1];

      SetLength(FNrinFrameSeries[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        FNrinFrameSeries[i, j] := FNrinFrameSeries[(i+1), j];

      SetLength(Fcoll_shape[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_shape[i, j] := Fcoll_shape[(i+1), j];

      SetLength(Fcoll_box_min[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_box_min[i, j] := Fcoll_box_min[(i+1), j];

      SetLength(Fcoll_box_max[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_box_max[i, j] := Fcoll_box_max[(i+1), j];

      SetLength(Fcoll_radius[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_radius[i, j] := Fcoll_radius[(i+1), j];

      SetLength(Fcoll_frac_at_top[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_frac_at_top[i, j] := Fcoll_frac_at_top[(i+1), j];

      SetLength(Fcoll_objectnr[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_objectNr[i, j] := Fcoll_objectNr[(i+1), j];

      SetLength(Fcoll_shootable[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_shootable[i, j] := Fcoll_shootable[(i+1), j];

      SetLength(Fcoll_pickable[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_pickable[i, j] := Fcoll_pickable[(i+1), j];

      SetLength(Fcoll_orientation[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_orientation[i, j] := Fcoll_orientation[(i+1), j];

      SetLength(Fcoll_material[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_material[i, j] := Fcoll_material[(i+1), j];

      SetLength(Fcoll_Fixed3D[i], Fcoll_Nr_objects[i+1]);

      for j := 0 to (Fcoll_Nr_objects[i+1] - 1) do

        Fcoll_Fixed3D[i, j] := Fcoll_Fixed3D[(i+1), j];

      Fcoll_nr_objects[i] := Fcoll_nr_objects[i+1];

    end;

  end;

  dec(FNrOfSeries);

  FSeriesIndex_For_SeriesNr := copy(FSeriesIndex_for_SeriesNr, 0, FNrOfSeries);

  Fcoll_Nr_Objects := copy(Fcoll_Nr_Objects, 0, FNrOfSeries);

  FNrinFrameSeries := copy(FNrinFrameSeries, 0, FNrOfSeries);

  Fcoll_Shape := copy(Fcoll_Shape, 0, FNrOfSeries);

  Fcoll_Box_Min := copy(Fcoll_Box_Min, 0, FNrOfSeries);

  Fcoll_Box_Max := copy(Fcoll_Box_Max, 0, FNrOfSeries);

  Fcoll_Radius := copy(Fcoll_Radius, 0, FNrOfSeries);

  Fcoll_Frac_At_Top := copy(Fcoll_Frac_At_Top, 0, FNrOfSeries);

  Fcoll_ObjectNr := copy(Fcoll_ObjectNr, 0, FNrOfSeries);

  Fcoll_Shootable := copy(Fcoll_Shootable, 0, FNrOfSeries);

  Fcoll_Pickable := copy(Fcoll_Pickable, 0, FNrOfSeries);

  Fcoll_orientation := copy(Fcoll_orientation, 0, FNrOfSeries);

  Fcoll_Material := copy(Fcoll_Material, 0, FNrOfSeries);

  Fcoll_Fixed3D := copy(Fcoll_Fixed3D, 0, FNrOfSeries);

end; //end of Destroy_Empty_Series

procedure TcollisionTester3DX.Remove_Collision_Object(SeriesNr, Value : integer);

var

  i : integer;

begin

  //Elements in the series which have a higher index than the one removed

  //gets a smaller index which is correct when the main program removes the object

  for i := 0 to (FColl_nr_objects[SeriesNr] - 1) do

  begin

    if FNrinFrameSeries[SeriesNr, i] >= value

    then

      dec(FNrinFrameSeries[SeriesNr, i]);

  end;

  for i := Value to (Fcoll_nr_objects[SeriesNr] - 2) do

  begin

    FNrinFrameSeries[SeriesNr, i]  := FNrinFrameSeries[SeriesNr, (i+1)];