(*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * http://www.opensource.org/licenses/cddl1.php.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * http://www.opensource.org/licenses/cddl1.php.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Portions Copyright 2012 Andreas Schneider
 *)
unit UStatics;

{$mode objfpc}{$H+}

interface

uses
  SysUtils, Classes, fgl, UGenericIndex, UWorldItem, UTiledata;

type
  { TStaticItem }

  TStaticItem = class(TWorldItem)
    constructor Create(AOwner: TWorldBlock; AData: TStream; ABlockX,
      ABlockY: Word); overload;
    constructor Create(AOwner: TWorldBlock; AData: TStream); overload;
  protected
    { Members }
    FHue: Word;

    { Methods }
    procedure SetHue(AValue: Word);
  public
    { Fields }
    property Hue: Word read FHue write SetHue;

    { Methods }
    function Clone: TStaticItem; override;
    function GetSize: Integer; override;
    procedure UpdatePriorities(ATileData: TStaticTiledata; ASolver: Integer);
    procedure Write(AData: TStream); override;
  end;

  TStaticItemList = specialize TFPGObjectList<TStaticItem>;

  { TStaticBlock}

  TStaticBlock = class(TWorldBlock)
    constructor Create(AData: TStream; AIndex: TGenericIndex; AX, AY: Word);
      overload;
    constructor Create(AData: TStream; AIndex: TGenericIndex); overload;
    destructor Destroy; override;
  protected
    { Members }
    FItems: TStaticItemList;
  public
    { Fields }
    property Items: TStaticItemList read FItems write FItems;

    { Methods }
    function Clone: TStaticBlock; override;
    function GetSize: Integer; override;
    procedure ReverseWrite(AData: TStream);
    procedure Sort;
    procedure Write(AData: TStream); override;
  end;

function CompareStaticItems(const AStatic1, AStatic2: TStaticItem): Integer;

implementation

function CompareStaticItems(const AStatic1, AStatic2: TStaticItem): Integer;
begin
  Result := CompareWorldItems(AStatic1, AStatic2);
end;

{ TStaticItem }

constructor TStaticItem.Create(AOwner: TWorldBlock; AData: TStream; ABlockX,
  ABlockY: Word);
var
  iX, iY: Byte;
begin
  inherited Create(AOwner);

  if AData <> nil then
  begin
    AData.Read(FTileID, SizeOf(SmallInt));
    AData.Read(iX, SizeOf(Byte));
    AData.Read(iY, SizeOf(Byte));
    AData.Read(FZ, SizeOf(ShortInt));
    AData.Read(FHue, SizeOf(SmallInt));

    FX := ABlockX * 8 + iX;
    FY := ABlockY * 8 + iY;
  end;
end;

constructor TStaticItem.Create(AOwner: TWorldBlock; AData: TStream);
begin
  Create(AOwner, AData, 0, 0);
end;

procedure TStaticItem.SetHue(AValue: Word);
begin
  if FHue = AValue then
    Exit;

  FHue := AValue;
  DoChanged;
end;

function TStaticItem.Clone: TStaticItem;
begin
  Result := TStaticItem.Create(nil, nil);
  Result.FTileID := FTileID;
  Result.FX := FX;
  Result.FY := FY;
  Result.FZ := FZ;
  Result.FHue := FHue;
end;

function TStaticItem.GetSize: Integer;
begin
  Result := 7;
end;

procedure TStaticItem.UpdatePriorities(ATileData: TStaticTiledata;
  ASolver: Integer);
begin
  FPriorityBonus := 0;
  if not (tdfBackground in ATileData.Flags) then
    Inc(FPriorityBonus);
  if ATileData.Height > 0 then
    Inc(FPriorityBonus);
  FPriority := Z + FPriorityBonus;
  FPrioritySolver := ASolver;
end;

procedure TStaticItem.Write(AData: TStream);
var
  iX, iY: Byte;
begin
  iX := FX mod 8;
  iY := FY mod 8;

  AData.Write(FTileID, SizeOf(SmallInt));
  AData.Write(iX, SizeOf(Byte));
  AData.Write(iY, SizeOf(Byte));
  AData.Write(FZ, SizeOf(ShortInt));
  AData.Write(FHue, SizeOf(SmallInt));
end;

{ TStaticBlock }

constructor TStaticBlock.Create(AData: TStream; AIndex: TGenericIndex;
  AX, AY: Word);
var
  i: Integer;
  block: TMemoryStream;
begin
  inherited Create;
  FX := AX;
  FY := AY;

  FItems := TStaticItemList.Create(True);
  if (AData <> nil) and (AIndex.Lookup > 0) and (AIndex.Size > 0) then
  begin
    AData.Position := AIndex.Lookup;
    block := TMemoryStream.Create;
    block.CopyFrom(AData, AIndex.Size);
    block.Position := 0;
    for i := 1 to (AIndex.Size div 7) do
      FItems.Add(TStaticItem.Create(Self, block, AX, AY));
    block.Free;
  end;
  FChanged := False;
end;

constructor TStaticBlock.Create(AData: TStream; AIndex: TGenericIndex);
begin
  Create(AData, AIndex, 0, 0);
end;

destructor TStaticBlock.Destroy;
begin
  FreeAndNil(FItems);
  inherited;
end;

function TStaticBlock.Clone: TStaticBlock;
var
  i: Integer;
begin
  Result := TStaticBlock.Create(nil, nil, FX, FY);
  for i := 0 to FItems.Count - 1 do
    Result.FItems.Add(FItems.Items[i].Clone);
end;

function TStaticBlock.GetSize: Integer;
begin
  Result := FItems.Count * 7;
end;

procedure TStaticBlock.ReverseWrite(AData: TStream);
var
  i: Integer;
begin
  for i := FItems.Count - 1 downto 0 do
    FItems[i].Write(AData);
end;

procedure TStaticBlock.Sort;
begin
  FItems.Sort(@CompareStaticItems);
end;

procedure TStaticBlock.Write(AData: TStream);
var
  i: Integer;
begin
  for i := 0 to FItems.Count - 1 do
    FItems[i].Write(AData);
end;

end.