Objects.simba

{*Credit Widget, Modified by Lordsaturn*}
procedure TReflectObjectArray.Sort;
var
  I, C, L: integer;
  Tpa: TPointArray;
  Temp: TReflectObjectArray;
begin
  L := GetArrayLength(Self);
  if L < 1 then
    Exit;
  SetArrayLength(Tpa, L);
  SetArrayLength(Temp, L);
  for I := 0 to L - 1 do
    Tpa[I] := Self[I]._Tile;
  SortTPAFrom(Tpa, Reflect.Tiles.GetGlobalTile);
  for I := 0 to L - 1 do
    for C := 0 to L - 1 do
      if (Tpa[I].Y = Self[C]._Tile.Y) and (Tpa[I].X = Self[C]._Tile.X) then
        Temp[I] := Self[C];
  Self := Temp;
end;

function TReflectObject.GetTile: TTile;
var
  LocalTile: TTile;
begin
  if Reflect.Smart.IsNull(Self.Reference) then
  begin
    Reflect.Logger.Error('Avoided using null''d pointer at: TReflectObject.GetTile');
    Exit(Point(-1, -1));
  end;

  if Self._ObjType.Index <> ObjGame.Index then
    Exit(Self._Tile);
  LocalTile := Point(Reflect.Smart.GetFieldInt(
    Self.Reference, Self._ObjType.LocalX), Reflect.Smart.GetFieldInt(
    Self.Reference, Self._ObjType.LocalY));
  Result := Point(LocalTile.X + Reflect.Misc.BaseX, LocalTile.Y +
    Reflect.Misc.BaseY);
end;

function TReflectObject.GetOffset: TTile;
var
  LocalTile: TTile;
begin
  if Reflect.Smart.IsNull(Self.Reference) then
  begin
    Reflect.Logger.Error('Avoided using null''d pointer at: TReflectObject.GetOffset');
    Exit(Point(-1, -1));
  end;

  if Self._ObjType.Index <> ObjGame.Index then
  begin
    Reflect.Logger.Warn('Only ObjGame has an Offset @.GetOffset');
    Exit(Point(-1, -1));
  end;
  LocalTile := Point(Reflect.Smart.GetFieldInt(
    Self.Reference, Self._ObjType.OffsetX), Reflect.Smart.GetFieldInt(
    Self.Reference, Self._ObjType.OffsetY));
  Result := Point(LocalTile.X + Reflect.Misc.BaseX, LocalTile.Y +
    Reflect.Misc.BaseY);
end;

function TReflectObject.GetOrientation: Integer;
begin
  if Reflect.Smart.IsNull(Self.Reference) then
  begin
    Reflect.Logger.Error('Avoided using null''d pointer at: TReflectObject.GetOrientation');
    Exit(-1);
  end;

  Result := Reflect.Smart.GetFieldInt(Self.Reference, Self._ObjType.Orientation);
end;

function TReflectObject.GetId: Integer;
begin
  if Reflect.Smart.IsNull(Self.Reference) then
  begin
    Reflect.Logger.Error('Avoided using null''d pointer at: TReflectObject.GetId');
    Exit(-1);
  end;

  Result := Reflect.Smart.GetFieldInt(Self.Reference, Self._ObjType.Id);
  Result := (Result shr 14) and $7fff;
end;

function TReflectObject.GetName: string;
var
  Id: Integer;
  Line: string;
begin
  Id := Self.GetId;
  if not InRange(Id, 0, Definition_Objects_Length) then
    Exit;
  Line := ObjectCache.GetStrings(Id);
  Result := Between('''name'': ''', ''',', Line);
end;

function TReflectObject.GetHeight: Integer;
var
  Id: Integer;
  Line: string;
begin
  Id := Self.GetId;
  if not InRange(Id, 0, Definition_Objects_Length) then
    Exit;
  Line := ObjectCache.GetStrings(Id);
  Result := StrToInt(Between('height'': ', ',', Line));
end;

function TReflectObject.GetActions: TStringArray;
var
  Id: Integer;
  Line, Temp: string;
begin
  Id := Self.GetId;
  if not InRange(Id, 0, Definition_Objects_Length) then
    Exit;
  Line := ObjectCache.GetStrings(Id);
  SetLength(Result, 5);
  Temp := Between('''actions'': [''', ']', Line);
  Temp := Copy(Temp, 1, Length(Temp) - 1);
  Result := Explode(''',''',Temp);
end;

function TReflectObject.GetMSPoint: TPoint;
var
  OffsetX, OffsetY, XShift, YShift: Extended;
  Tile: TPoint;
begin
  if Self._ObjType.Index <> ObjGame.Index then
    Exit(Reflect.Tiles.TileToMs(Self.GetTile));
  Tile := Self.GetTile;
  OffsetX := (Tile.X + Self.GetOffset.X) / 2;
  OffsetY := (Tile.Y + Self.GetOffset.Y) / 2;
  XShift := Frac(OffsetX) * 128;
  YShift := Frac(OffsetY) * 128;
  if Self.GetOffset.X mod 2 = 0 then
    XShift := XShift * -1;
  if Self.GetOffset.Y mod 2 = 0 then
    YShift := YShift * -1;
  Result := Reflect.Tiles.TileToMs(Point(Round(OffsetX), Round(OffsetY)),
    Round(XShift), Round(YShift), 0);
end;

{$IFNDEF CODEINSIGHT}
procedure TReflectObject._GetObject(Iteration: Integer; _Tile: TTile);
var
  Id: Integer;
  Temp: TReflectObject;
begin
  if (Self._ObjType.Index <> ObjGame.Index) then
  begin
    Reflect.Mem.GetObject(ckSceneTile, ckObject, Self._ObjType.SceneObject,
      Iteration, Iteration);
    Self.Reference := HookCache[ckObject][Iteration];
    Self._Tile := _Tile;
  end
  else
  begin
    Reflect.Mem.GetObjectArray(ckSceneTile, ckObject,
      Self._ObjType.SceneObject, Iteration, Iteration, 0);
    Self.Reference := HookCache[ckObject][Iteration];
    Self._Tile := _Tile;
  end;
end;
{$ENDIF}

procedure TReflectObjectArray.GetAll(
  ObjType: TObjectType; Distance: Integer = 103; Position: TPoint = Point(-1, -1));
var
  Multi, BaseX, BaseY, X, Y, I, Count, Plane, HighX, HighY, XDistance, YDistance: integer;
  Temp: TReflectObject;
  ObjectHook, SceneHook: THook;
begin
  if not Reflect.Mem.IsNull(ckObject) then
    Reflect.Mem.FreeObjects(ckObject, True);

  if Position.X = -1 then
    Position := Reflect.Tiles.GetGlobalTile;

  Distance := Round(Distance / 2);
  if HookCache[TCacheKey.ckRegion][0] = 0 then
    Reflect.Mem.GetObject(ckNull, ckRegion, Client_Region, 0, 0);
  BaseX := Reflect.Misc.BaseX;
  BaseY := Reflect.Misc.BaseY;
  Position := Point(Position.X - BaseX, Position.Y - BaseY);
  Plane := Reflect.Tiles.GetPlane;
  HighX := Position.X + Distance;
  HighY := Position.Y + Distance;
  if HighX > 103 then
    HighX := 103;
  if HighY > 103 then
    HighY := 103;
  XDistance := Position.X - Distance;
  YDistance := Position.Y - Distance;
  if XDistance < 0 then
    XDistance := 0;
  if YDistance < 0 then
    YDistance := 0;
  SetLength(Self, Definition_Objects_Length);
  for X := XDistance to HighX do
    for Y := YDistance to HighY do
    begin
      Reflect.Mem.Get3DObject(ckRegion, ckSceneTile, Region_SceneTiles,
        Count, 0, Plane, X, Y);
      Temp._ObjType := ObjType;
      Temp._GetObject(Count, Point(BaseX + X, BaseY + Y));
      Inc(Count);
      if Temp.Reference = 0 then
        Continue;
      Self[I] := Temp;
      Inc(I);
    end;
  SetLength(Self, I);
  Reflect.Mem.FreeObjects(ckSceneTile, Count);
  Self.Sort;
end;

procedure TReflectObject.GetAt(ObjType: TObjectType; _Tile: TTile);
var
  ObjectHook, SceneHook: THook;
  Multi, BaseX, BaseY, Plane: Integer;
  Temp: TReflectObject;
begin
  if (HookCache[ckObject][0] <> 0) then
    Reflect.Mem.FreeObjects(ckObject, True);
  BaseX := Reflect.Misc.BaseX;
  BaseY := Reflect.Misc.BaseY;
  Plane := Reflect.Tiles.GetPlane;
  if HookCache[TCacheKey.ckRegion][0] = 0 then
    Reflect.Mem.GetObject(ckNull, ckRegion, Client_Region, 0, 0);
  Reflect.Mem.Get3DObject(ckRegion, ckSceneTile, Region_SceneTiles, 0, 0, Plane,
    _Tile.X - BaseX, _Tile.Y - BaseY);
  Self._ObjType := ObjType;

  Self._GetObject(0, _Tile);
  Reflect.Mem.FreeObjects(ckSceneTile, False);
end;

procedure TReflectObjectArray.Get(ObjType: TObjectType; Input: TVariantArray; Distance: Integer = 103);
var
  I : Integer;
  IDs : TIntegerArray;
  Names : TStringArray;
  Temp : TReflectObjectArray;
begin
  for I := 0 to High(Input) do
    if Reflect.Misc.VariantIsString(Input[I]) then
    begin
      SetLength(Names, Length(Names)+1);
      Names[High(Names)] := Input[I];
    end
    else
    begin
      if Reflect.Misc.VariantIsInteger(Input[I]) then
      begin
        SetLength(IDs, Length(IDs)+1);
        IDs[High(IDs)] := Input[I];
      end;
    end;

  Self := [];
  Temp.GetAll(ObjType, Distance);

  for I := 0 to High(Temp) do
    if InIntArray(IDs, Temp[I].GetID) or Reflect.Internals.InStringArray(Names, Temp[I].GetName) then
    begin
      SetLength(Self, Length(Self)+1);
      Self[High(Self)] := Temp[I];
    end;

  Self.Sort;
end;

procedure TReflectObjectArray.Get(ObjType: TObjectType; Names: TStringArray; Distance: Integer = 103); Overload;
var
  Temp : TVariantArray;
  I : Integer;
begin
  SetLength(Temp, Length(Names));
  for I := 0 to High(Names) do
    Temp[I] := Names[I];

  Self.Get(ObjType, Temp, Distance);
end;

procedure TReflectObjectArray.Get(ObjType: TObjectType; IDs: TIntegerArray; Distance: Integer = 103); Overload;
var
  Temp : TVariantArray;
  I : Integer;
begin
  SetLength(Temp, Length(IDs));
  for I := 0 to High(IDs) do
    Temp[I] := IDs[I];

  Self.Get(ObjType, Temp, Distance);
end;

procedure TReflectObjectArray.Get(ObjType: TObjectType; Name: String; Distance: Integer = 103); Overload;
var
  Temp : TVariantArray;
begin
  Temp := [Name];
  Self.Get(ObjType, Temp, Distance);
end;

procedure TReflectObjectArray.Get(ObjType: TObjectType; ID: Integer; Distance: Integer = 103); Overload;
var
  Temp : TVariantArray;
begin
  Temp := [ID];
  Self.Get(ObjType, Temp, Distance);
end;

function TReflectObject.Find(ObjType: TObjectType; Input: TVariantArray; Distance: Integer = 103): Boolean;
var
  Temp: TReflectObjectArray;
begin
  Temp.Get(ObjType, Input, Distance);
  if Length(Temp) = 0 then
    Exit;
  Result := True;
  Self := Temp[0];
end;

function TReflectObject.Find(ObjType: TObjectType; Names: TStringArray; Distance: Integer = 103): Boolean; Overload;
var
  Temp : TVariantArray;
  I : Integer;
begin
  SetLength(Temp, Length(Names));
  for I := 0 to High(Names) do
    Temp[I] := Names[I];

  Result := Self.Find(ObjType, Temp, Distance);
end;

function TReflectObject.Find(ObjType: TObjectType; IDs: TIntegerArray; Distance: Integer = 103): Boolean; Overload;
var
  Temp : TVariantArray;
  I : Integer;
begin
  SetLength(Temp, Length(IDs));
  for I := 0 to High(IDs) do
    Temp[I] := IDs[I];

  Result := Self.Find(ObjType, Temp, Distance);
end;

function TReflectObject.Find(ObjType: TObjectType; Name: String; Distance: Integer = 103): Boolean; Overload;
var
  Temp : TVariantArray;
begin
  Temp := [Name];
  Result := Self.Find(ObjType, Temp, Distance);
end;

function TReflectObject.Find(ObjType: TObjectType; ID: Integer; Distance: Integer = 103): Boolean; Overload;
var
  Temp : TVariantArray;
begin
  Temp := [ID];
  Result := Self.Find(ObjType, Temp, Distance);
end;

function TReflectObject.IsOnMS: Boolean;
begin
  Result := PointInBox(Self.GetMSPoint, [MSX1, MSY1, MSX2, MSY2]);
end;

procedure TReflectionInternals.SetupObjects;
begin
  ObjGame.Index := 1;
  ObjGame.Id := GameObject_ID;
  ObjGame.Flags := GameObject_Flags;
  ObjGame.Plane := GameObject_Plane;
  ObjGame.Height := GameObject_Height;
  ObjGame.Render := GameObject_Render;
  ObjGame.Orientation := GameObject_Orientation;
  ObjGame.LocalX := GameObject_LocalX;
  ObjGame.LocalY := GameObject_LocalY;
  ObjGame.OffsetX := GameObject_OffsetX;
  ObjGame.OffsetY := GameObject_OffsetY;
  ObjGame.SceneObject := SceneTile_GameObject;
  ObjWallDecoration.Index := 2;
  ObjWallDecoration.Id := WallDecoration_Id;
  ObjWallDecoration.Flags := WallDecoration_Flags;
  ObjWallDecoration.Plane := WallDecoration_Plane;
  ObjWallDecoration.Height := WallDecoration_Height;
  ObjWallDecoration.Render := WallDecoration_Renderable;
  ObjWallDecoration.Orientation := WallDecoration_Orientation;
  ObjWallDecoration.LocalX := WallDecoration_LocalX;
  ObjWallDecoration.LocalY := WallDecoration_LocalY;
  ObjWallDecoration.RelativeX := WallDecoration_RelativeX;
  ObjWallDecoration.RelativeY := WallDecoration_RelativeY;
  ObjWallDecoration.SceneObject := SceneTile_WallDecoration;
  ObjFloorDecoration.Index := 3;
  ObjFloorDecoration.Id := WallDecoration_Id;
  ObjFloorDecoration.Flags := FloorDecoration_Flags;
  ObjFloorDecoration.Plane := FloorDecoration_Plane;
  ObjFloorDecoration.Render := FloorDecoration_Render;
  ObjFloorDecoration.LocalX := FloorDecoration_LocalX;
  ObjFloorDecoration.LocalY := FloorDecoration_LocalY;
  ObjFloorDecoration.SceneObject := SceneTile_GroundDecoration;
  ObjBoundary.Index := 4;
  ObjBoundary.Id := BoundaryObject_Id;
  ObjBoundary.Flags := BoundaryObject_Flags;
  ObjBoundary.Plane := BoundaryObject_Plane;
  ObjBoundary.Height := BoundaryObject_Height;
  ObjBoundary.Render := BoundaryObject_Render;
  ObjBoundary.Orientation := BoundaryObject_Orientation;
  ObjBoundary.LocalX := BoundaryObject_LocalX;
  ObjBoundary.LocalY := BoundaryObject_LocalY;
  ObjBoundary.SceneObject := SceneTile_BoundaryObject;
end;