dxisoengine.pas

一款RPG游戏的引擎可以自己制作一款RPG游戏的引擎可以自己制作

  FImageList.Items.SaveToStream(s);
end;

procedure TDXIsoMap.SaveToFile(filename: string);
begin
  FIsoMap.SaveToFile(FileName);
end;

procedure TDXIsoMap.SaveToStream(S: TStream);
begin
  FIsoMap.SaveToStream(S);
end;

procedure TDXIsoMap.SetCellSize(const Width, Height: Integer);
var i : Integer;
  rect : TRect;
  bm : TDib;

procedure DrawSquare(var Image :TDib; Ant : integer);
var x,y,a : integer;
begin
  image.SetSize(Width,Height,32);
  Image.Width := Width;
  Image.Height := Height;
  Image.Transparent := True;
  Image.Canvas.Brush.Color := clblack;
  Image.Canvas.FillRect(rect);
  Image.Canvas.Pen.Color := clwhite;
  Image.Canvas.MoveTo(Width div 2, 0);
  Image.Canvas.LineTo(Width, Height div 2);
  Image.Canvas.LineTo(Width div 2, Height);
  Image.Canvas.LineTo(0, Height div 2);
  Image.Canvas.LineTo(Width div 2, 0);
  if (Ant<>-1) then
  begin
    Image.Canvas.Pen.Color := clBlack; // now to erase sections of the square
    a := Ant;
    x := 0;
    while(x<Width) do
    begin
      y := 0;
      while(y < Height) do
      begin
        inc(a);
        if (a mod ANTCOUNT)<>0 then
        begin
          Image.Canvas.moveto(x,0);
          Image.Canvas.lineto(width - x,height);
          Image.Canvas.moveto(0,y);
          Image.Canvas.lineto(width,height - y);
        end;
        Inc(y,2);
      end;
      Inc(x,2);
    end;
  end;
end;
begin
//ShowMessage('Help! this should work, but doesn''t');
  FIsoMap.CellWidth := Width;
  FIsoMap.CellHeight := Height;
  rect.Left := 0; rect.Top := 0; rect.Right := Width; rect.Bottom := Height;
  bm := TDib.Create;
  try
    for i := 0 to ANTCOUNT do
    begin
      DrawSquare(bm,i-1);
//bm.LoadFromFile('d:\grass.bmp');
      if (FGridAnts.Items.Count<=i) then
        FGridAnts.Items.Add.Index;
      FGridAnts.Items[i].Picture.Graphic := bm;
      FGridAnts.Items[i].Restore;
    end;
  finally
    bm.Free;
  end;
end;


procedure TDXIsoMap.SetMapSize(MaxX, MaxY: TGridInt);
begin
  FIsoMap.SetMapSize(MaxX, MaxY);
end;

procedure TDXIsoMap.SetRenderOptions(const Value: TIsoRenderOptions);
begin
  FIsoMap.RenderOptions := Value;
end;

procedure TDXIsoMap.SetXOffset(const Value: Integer);
begin
  FIsoMap.XOffset := Value;
end;

procedure TDXIsoMap.SetYOffset(const Value: Integer);
begin
  FIsoMap.YOffset := Value;
end;

function TDXIsoMap._GetCell(x, y: TGridInt): TIsoCell;
begin
  Result := FIsoMap._GetCell(x, y);
end;

function TDXIsoMap._GetImageColor(ImageIndex: Integer): TColor;
begin
  Result := FIsoMap._GetImageColor(ImageIndex);
end;

procedure TDXIsoMap.WriteStr(Stream: TStream; s: string);
begin
  FIsoMap.WriteStr(Stream, s);
end;


procedure TDXIsoMap.GetSurfaceHeight(var ResultInt: Integer);
begin
//  ResultInt := surfaceheight;
  ResultInt := Self.Surface.Height;
  if (Parent.Height < ResultInt) then
    ResultInt := Parent.Height;
end;

procedure TDXIsoMap.GetSurfaceWidth(var ResultInt: Integer);
begin
  ResultInt := Self.Surface.Width;
//  ResultInt := surfaceWidth;
  if (Parent.Width < ResultInt) then
    ResultInt := Parent.Width;
end;

procedure TDXIsoMap._LoadImageListFromStream(Stream: TStream; Version: string);
begin
  if (Version = Version1) then
    FImageList.Items.LoadFromStream(stream);
  // else handle differently for other versions
end;

procedure TDXIsoMap._SaveImageListToStream(Stream: TStream; Version: string);
begin
  if (Version = Version1) then
    FImageList.Items.SaveToStream(stream);
  // else handle differently for other versions
end;

procedure TDXIsoMap._CanDraw(var ResultBoolean: Boolean);
begin
  ResultBoolean := CanDraw;
end;

function TDXIsoMap.GetImageCount: integer;
begin
  result := FImageList.Items.Count;
end;

procedure TDXIsoMap._GetImageCount(var ResultInt: Integer);
begin
  resultInt := GetImageCount;
end;

procedure TDXIsoMap._GetImageHeight(ImageIndex: Integer; var ResultInt: Integer);
begin
  ResultInt := ImageHeight[ImageIndex];
end;

procedure TDXIsoMap._GetImageWidth(ImageIndex: Integer; var ResultInt: Integer);
begin
  ResultInt := ImageWidth[ImageIndex];
end;

procedure TDXIsoMap._GetPixel(ImageIndex, x, y: Integer;
  var color: TColor);
begin
  color := GetPixel(ImageIndex, x, y);
end;

function TDXIsoMap.GetOnProgress: TIsoProgress;
begin
  result := FIsoMap.OnProgress;
end;

procedure TDXIsoMap.SetOnProgress(const Value: TIsoProgress);
begin
  FIsoMap.OnProgress := Value;
end;

procedure TDXIsoMap.SetBackgroundColor(c: TColor);
begin
  Backgroundcolor := self.Surface.ColorMatch(c);
end;

function TDXIsoMap.GetIsoExt: string;
begin
  result := '.DXM';
end;

procedure TDXIsoMap.DrawGrid(x, y, Animation: integer);
var CellImage: TPictureCollectionItem;
begin
  if not Visible then Exit;
  if (Animation>=0) then
    Animation := Animation mod ANTCOUNT+1
  else
    Animation := 0;

  if not (FGridAnts.Items[Animation] is TPictureCollectionItem) then Exit;
  CellImage := FGridAnts.items[Animation];
//  CellImage := FImageList.Items[0];     // this works
  CellImage.Draw(Surface, x, y - CellHeight, 0);

end;

function TDXIsoMap.GetMapName: string;
begin
  result := FIsoMap.MapName;
end;

procedure TDXIsoMap.SetMapName(const Value: string);
begin
  FIsoMap.MapName := Value;
end;

function TDXIsoMap.GetOnLayerVisible: TIsoGetImgBooleanEvent;
begin
  result := fisomap.OnLayerVisible;
end;

procedure TDXIsoMap.SetOnLayerVisible(const Value: TIsoGetImgBooleanEvent);
begin
  FIsoMap.OnLayerVisible := Value;
end;

function TDXIsoMap.GetLoadUserData: TIsoStreamEvent;
begin
  Result := FIsoMap.OnLoadUserDataFromStream;
end;

function TDXIsoMap.GetSaveUserData: TIsoStreamEvent;
begin
  Result := FIsoMap.OnSaveUserDataToStream;
end;

procedure TDXIsoMap.SetLoadUserData(const Value: TIsoStreamEvent);
begin
  FIsoMap.OnLoadUserDataFromStream := Value;
end;

procedure TDXIsoMap.SetSaveUserData(const Value: TIsoStreamEvent);
begin
  FIsoMap.OnSaveUserDataToStream := Value;
end;

function TDXIsoMap.GetFlip: TNotifyEvent;
begin
  result := FFlip;
end;

procedure TDXIsoMap.SetFlip(const Value: TNotifyEvent);
begin
  FFlip := Value;
end;

procedure TDXIsoMap.BeforeFlip;
begin
    if (assigned(FBeforeFlip)) then
      FBeforeFlip(self);
    Flip;
end;

function TDXIsoMap.GetBeforeFlip: TNotifyEvent;
begin
  result := FBeforeFlip;
end;

procedure TDXIsoMap.SetBeforeFlip(const Value: TNotifyEvent);
begin
  FBeforeFlip := value;
end;

procedure TDXIsoMap._LoadBMPFromStream(Index: Integer; Stream: TStream;
  Version: string);
var dib : tdib;
begin
  if (Version = Version1_1) then
  begin
    if (ImageCount<=Index) then
      FImageList.Items.Add;
    dib := TDib.Create;
    try
      dib.LoadFromStream(Stream);
      FImageList.Items[Index].Picture.Graphic := dib;
      if not (doSystemMemory in Options) then
            FImageList.Items[Index].SystemMemory := false;
      FImageList.Items[Index].Restore;
    finally
      dib.Free;
    end;
    if (Assigned(OnLoadUserImageData)) then
      OnLoadUserImageData(Index,Stream,version);
  end;
  // else handle differently for other versions
end;

procedure TDXIsoMap._SaveBMPToStream(Index: Integer; Stream: TStream;
  Version: string);
var
  dib : tdib;
  c : TPictureCollectionItem;
begin
  if (Version = Version1_1) then
  begin
    c := FImageList.Items[Index];
    dib := TDIB.Create;
    try
      dib.Assign(c.Picture.Graphic);
      dib.SaveToStream(Stream);
      if (Assigned(OnSaveUserImageData)) then
        OnSaveUserImageData(Index,Stream,version);
    finally
      dib.Free;
    end;
  end;
end;
{


  FImageList.Items[Index].Picture.Bitmap.SaveToStream(Stream);// doesn't work if image isn't bmp
  // this is temporary until a tidier solution is found
//    FImageList.Items[Index].Picture.SaveToFile('c:\windows\temp'+IntToStr(Index)+'.bmp');

//    tempstream := TFileStream.Create('temp.bmp',fmOpenRead);
    try
//      Stream.CopyFrom(tempstream,0);
    finally
//      tempstream.Free;
    end;
  end;
  // else handle differently for other versions
end;

}
function TDXIsoMap.GetCls: TIsoCallEvent;
begin
  result := FCls;
end;

procedure TDXIsoMap.SetCls(const Value: TIsoCallEvent);
begin
  FCls := value;
end;

function TDXIsoMap.GetScrollXOffset: Integer;
begin
  result := FIsoMap.ScrollXOffset;
end;

function TDXIsoMap.GetScrollYOffset: Integer;
begin
  Result := FIsoMap.ScrollYOffset;
end;

procedure TDXIsoMap.SetScrollXOffset(const Value: Integer);
begin
  FIsoMap.ScrollXOffset := Value;
end;

procedure TDXIsoMap.SetScrollYOffset(const Value: Integer);
begin
  FIsoMap.ScrollYOffset := Value;
end;

function TDXIsoMap.GetImageName(ImageIndex: integer): string;
begin
      result := FImageList.Items[ImageIndex].DisplayName;
end;

function TDXIsoMap.GetImageTransparentColor(ImageIndex: integer): TColor;
begin
  result := FImageList.Items[ImageIndex].TransparentColor;
end;

procedure TDXIsoMap.SetImageName(Index: Integer; Name: string);
begin
  FImageList.Items[Index].Name := Name;
end;

procedure TDXIsoMap.SetImageTransparentColor(Index: Integer;
  Color: TColor);
begin
  FIMageList.Items[Index].TransparentColor := Color;
end;

procedure TDXIsoMap._GetImageName(ImageIndex: integer; var Name: string);
begin
  Name := GetImagename(ImageIndex);
end;

procedure TDXIsoMap._GetImageTransparentColor(ImageIndex: integer;
  var Color: TColor);
begin
  Color := GetImageTransparentColor(ImageIndex);
end;

procedure TDXIsoMap.RestoreGridAnts;
begin
  SetCellSize(FIsoMap.CellWidth,FIsoMap.CellHeight);
end;

end.