source: trunk/Units.pas

unit Units;

interface

uses
  Classes, SysUtils, Generics.Collections, Geometry, DOM, XML, ItemList, UnitKind;

type
  TUnit = class
  private
    FId: Integer;
    FMapCell: TObject; // TCell
    FPlayer: TObject; // TPlayer
    procedure SetId(AValue: Integer);
    procedure SetMapCell(AValue: TObject);
    procedure SetPlayer(AValue: TObject);
  public
    Game: TObject; // TGame
    Kind: TUnitKind;
    KindId: Integer; // Temporary
    Power: Integer;
    Moves: Integer;
    Position: TPoint;
    PlayerId: Integer; // Temporary
    procedure FixRefId;
    function GetPowerAttack: Integer;
    function GetPowerDefense: Integer;
    procedure LoadFromNode(Node: TDOMNode);
    procedure SaveToNode(Node: TDOMNode);
    procedure Assign(Source: TUnit);
    constructor Create;
    destructor Destroy; override;
    property Player: TObject read FPlayer write SetPlayer; // TPlayer
    property MapCell: TObject read FMapCell write SetMapCell; // TMapCell;
    property Id: Integer read FId write SetId;
  end;

  { TUnits }

  TUnits = class(TObjectList<TUnit>)
    NewId: Integer;
    Game: TObject; //TGame;
    procedure RecalculateItemsId;
    procedure FixRefId;
    function FindById(Id: Integer): TUnit;
    function GetNewId: Integer;
    procedure LoadFromNode(Node: TDOMNode);
    procedure SaveToNode(Node: TDOMNode);
    function AddNew(Kind: TUnitKind; Power: Integer): TUnit;
    constructor Create(FreeObjects: Boolean = True);
    procedure Assign(Source: TUnits);
  end;


implementation

uses
  Player, Map, Game;

{ TUnits }

procedure TUnits.RecalculateItemsId;
var
  I: Integer;
begin
  for I := 0 to Count - 1 do
    Items[I].Id := I + 1;
  NewId := Count + 1;
end;

procedure TUnits.FixRefId;
var
  I: Integer;
begin
  for I := 0 to Count - 1 do
    Items[I].FixRefId;
end;

function TUnits.FindById(Id: Integer): TUnit;
var
  I: Integer;
begin
  I := 0;
  while (I < Count) and (Items[I].Id <> Id) do Inc(I);
  if I < Count then Result := Items[I]
    else Result := nil;
end;

function TUnits.GetNewId: Integer;
begin
  Result := NewId;
  Inc(NewId);
end;

procedure TUnits.LoadFromNode(Node: TDOMNode);
var
  Node2: TDOMNode;
  NewItem: TUnit;
begin
  Count := 0;
  Node2 := Node.FirstChild;
  while Assigned(Node2) and (Node2.NodeName = 'Unit') do begin
    NewItem := TUnit.Create;
    NewItem.Game := Game;
    NewItem.LoadFromNode(Node2);
    Add(NewItem);
    Node2 := Node2.NextSibling;
  end;
end;

procedure TUnits.SaveToNode(Node: TDOMNode);
var
  I: Integer;
  NewNode2: TDOMNode;
begin
  for I := 0 to Count - 1 do
  with Items[I] do begin
    NewNode2 := Node.OwnerDocument.CreateElement('Unit');
    Node.AppendChild(NewNode2);
    SaveToNode(NewNode2);
  end;
end;

function TUnits.AddNew(Kind: TUnitKind; Power: Integer): TUnit;
begin
  Result := TUnit.Create;
  Result.Id := GetNewId;
  Result.Kind := Kind;
  Result.Power := Power;
  Result.Game := Game;
  Add(Result);
end;

constructor TUnits.Create(FreeObjects: Boolean);
begin
  inherited;
  NewId := 1;
end;

procedure TUnits.Assign(Source: TUnits);
var
  I: Integer;
begin
  while Count > Source.Count do
    Delete(Count - 1);
  while Count < Source.Count do
    Add(TUnit.Create);
  for I := 0 to Count - 1 do begin
    Items[I].Assign(Source[I]);
    Items[I].Game := Game;
  end;
  NewId := Source.NewId;
end;

{ TUnit }

procedure TUnit.SetId(AValue: Integer);
begin
  if FId = AValue then Exit;
  FId := AValue;
end;

procedure TUnit.SetMapCell(AValue: TObject);
var
  OldValue: TCell;
begin
  if FMapCell = AValue then Exit;
  OldValue := TCell(FMapCell);
  FMapCell := nil;
  if Assigned(OldValue) then OldValue.OneUnit := nil;
  FMapCell := AValue;
  if Assigned(FMapCell) then TCell(FMapCell).OneUnit := Self;
end;

procedure TUnit.SetPlayer(AValue: TObject);
var
  OldValue: TPlayer;
begin
  if FPlayer = AValue then Exit;
  OldValue := TPlayer(FPlayer);
  FPlayer := nil;
  if Assigned(OldValue) then TPlayer(OldValue).Units.Remove(Self);
  FPlayer := AValue;
  if Assigned(FPlayer) then TPlayer(FPlayer).Units.Add(Self);
end;

procedure TUnit.FixRefId;
begin
  if PlayerId <> 0 then begin
    Player := TGame(Game).Players.FindById(PlayerId);
    if not Assigned(Player) then
      raise Exception.Create('Referenced player id ' + IntToStr(PlayerId) + ' not found.');
  end else Player := nil;

  if KindId <> 0 then begin
    Kind := TGame(Game).GameSystem.UnitKinds.FindById(KindId);
    if not Assigned(Kind) then
      raise Exception.Create('Referenced unit kind id ' + IntToStr(KindId) + ' not found.');
  end else Kind := nil;
end;

function TUnit.GetPowerAttack: Integer;
begin
  Result := Power * Kind.PowerAttack;
end;

function TUnit.GetPowerDefense: Integer;
begin
  Result := Power * Kind.PowerDefense;
end;

procedure TUnit.LoadFromNode(Node: TDOMNode);
begin
  Id := ReadInteger(Node, 'Id', 0);
  Power := ReadInteger(Node, 'Power', 0);
  Moves := ReadInteger(Node, 'Moves', 0);
  KindId := ReadInteger(Node, 'Kind', 0);
  PlayerId := ReadInteger(Node, 'Player', 0);
end;

procedure TUnit.SaveToNode(Node: TDOMNode);
begin
  WriteInteger(Node, 'Id', Id);
  WriteInteger(Node, 'Power', Power);
  WriteInteger(Node, 'Moves', Moves);
  if Assigned(Kind) then WriteInteger(Node, 'Kind', Kind.Id)
    else WriteInteger(Node, 'Kind', 0);
  if Assigned(Player) then WriteInteger(Node, 'Player', TPlayer(Player).Id)
    else WriteInteger(Node, 'Player', 0);
end;

procedure TUnit.Assign(Source: TUnit);
begin
  Kind := Source.Kind;
  Moves := Source.Moves;
  Power := Source.Power;
  Id := Source.Id;
end;

constructor TUnit.Create;
begin
  Player := nil;
end;

destructor TUnit.Destroy;
begin
  MapCell := nil;
  Player := nil;
  inherited;
end;

end.