colli3dx.pas

传奇源代码的delphi版本

  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)];
    Fcoll_shape[SeriesNr, i]       := Fcoll_shape[SeriesNr, (i+1)];
    Fcoll_box_min[SeriesNr, i]     := Fcoll_box_min[SeriesNr, (i+1)];
    Fcoll_box_max[SeriesNr, i]     := Fcoll_box_max[SeriesNr, (i+1)];
    Fcoll_radius[seriesNr, i]      := Fcoll_radius[SeriesNr, (i+1)];
    Fcoll_frac_at_top[SeriesNr, i] := Fcoll_frac_at_top[SeriesNr, (i+1)];
    Fcoll_objectnr[SeriesNr, i]    := Fcoll_objectnr[SeriesNr, (i+1)];
    Fcoll_shootable[SeriesNr, i]   := Fcoll_shootable[SeriesNr, (i+1)];
    Fcoll_Pickable[SeriesNr, i]    := Fcoll_Pickable[SeriesNr, (i+1)];
    Fcoll_orientation[SeriesNr, i] := Fcoll_orientation[SeriesNr, (i+1)];
    Fcoll_material[SeriesNr, i]    := Fcoll_material[SeriesNr, (i+1)];
    Fcoll_Fixed3D[SeriesNr, i]     := Fcoll_Fixed3D[SeriesNr, (i+1)];
  end;

  dec(Fcoll_nr_objects[SeriesNr]);

  //remember to reduce the length of Fcoll_frame
  FNrinFrameSeries[SeriesNr]  := copy(FNrinFrameSeries[SeriesNr], 0,
                                 Fcoll_nr_objects[SeriesNr]);
  Fcoll_shape[SeriesNr]       := copy(Fcoll_shape[SeriesNr], 0,
                                 Fcoll_nr_objects[SeriesNr]);
  Fcoll_box_min[SeriesNr]     := copy(Fcoll_box_min[SeriesNr], 0,
                                 Fcoll_nr_objects[SeriesNr]);
  Fcoll_box_max[SeriesNr]     := copy(Fcoll_box_max[SeriesNr], 0,