Hjælp til kortspil i Delphi7

Hej vi er gået fuldstændig i stå med vores kortspil og derfor ville det være rart hvis en af jer ville hjælpe os med dette her:

hvis computer har en kulør som bliver lagt ud, skal den  højeste af denne kulør ligges ud
ellers hvis computer har rydere (2'erne), smides en af disse ud
ellers ligges laveste kort ud


unit eventu;

interface

uses CardClasses,CardFkt;

  procedure ProgInit;
  procedure NewGame;
  procedure MouseDown(Pile: TPile; Card: TCard);
  procedure MouseUp(Pile: TPile; Card: TCard);


implementation

uses dialogs,sysutils;

{ her kan du placere globale erklæringer af f.eks. pile }
var p1,p2,p3,p4,p5,p6,p7,p8: TPile;

procedure ProgInit;
{ Kaldes ved programstart;
  skriv evt. initialiseringer ved programstart i denne procedure }
begin
end;

procedure NewGame;
{ Kaldes ved start af nyt spil;
  skriv evt. initialiseringer ved start af nyt spil;
  HUSK først at kalde free for alle skabte objekter fra
  evt. tidligere spil  }

var c: TCard;
i: integer;
korttype: integer;

begin
  CTable.clear;

  p1:=TPile.Create(365,450,30,0);
  CTable.addPile(p1);

  for i := 1 to 5 do // uddel 5 kort
    begin
      randomize();
      korttype := random(4);
      c := TCard.create(TCSuit(korttype), random(13)+1, true);
      p1.insertAtTop(c);
    end;

{c:=TCard.create(CLUB,Random(13)+1,true);
  p1.insertAtTop(c);
  c:=TCard.create(CLUB,Random(13)+1,true);
  p1.insertAtTop(c);
  c:=TCard.create(CLUB,Random(13)+1,true);
  p1.insertAtTop(c);
  c:=TCard.create(CLUB,Random(13)+1,true);
  p1.insertAtTop(c);
  c:=TCard.create(CLUB,Random(13)+1,true);
  p1.insertAtTop(c);}

  p2:=TPile.Create(420,345,30,0);
  CTable.addPile(p2);


  p3:=TPile.Create(365,30,30,0);
  CTable.addPile(p3);

  for i := 1 to 5 do // uddel 5 kort
    begin
      randomize();
      korttype := random(4);
      c := TCard.create(TCSuit(korttype), random(13)+1, false);
      p3.insertAtTop(c);
    end;

{c:=TCard.create(HEART,Random(13)+1,true);
  p3.insertAtTop(c);
  c:=TCard.create(HEART,Random(13)+1,true);
  p3.insertAtTop(c);
  c:=TCard.create(HEART,Random(13)+1,true);
  p3.insertAtTop(c);
  c:=TCard.create(HEART,Random(13)+1,true);
  p3.insertAtTop(c);
  c:=TCard.create(HEART,Random(13)+1,true);
  p3.insertAtTop(c);}

  p4:=TPile.Create(420,135,30,0);
  CTable.addPile(p4);


  p5:=TPile.Create(120,238,30,0);
  CTable.addPile(p5);

  for i := 1 to 5 do // uddel 5 kort
    begin
      randomize();
      korttype := random(4);
      c := TCard.create(TCSuit(korttype), random(13)+1, false);
      p5.insertAtTop(c);
    end;

{c:=TCard.create(DIAMOND,Random(13)+1,true);
  p5.insertAtTop(c);
  c:=TCard.create(DIAMOND,Random(13)+1,true);
  p5.insertAtTop(c);
  c:=TCard.create(DIAMOND,Random(13)+1,true);
  p5.insertAtTop(c);
  c:=TCard.create(DIAMOND,Random(13)+1,true);
  p5.insertAtTop(c);
  c:=TCard.create(DIAMOND,Random(13)+1,true);
  p5.insertAtTop(c);}

  p6:=TPile.Create(330,238,30,0);
  CTable.addPile(p6);


  p7:=TPile.Create(600,238,30,0);
  CTable.addPile(p7);

  for i := 1 to 5 do // uddel 5 kort
    begin
      randomize();
      korttype := random(4);
      c := TCard.create(TCSuit(korttype), random(13)+1, false);
      p7.insertAtTop(c);
    end;

{c:=TCard.create(SPADE,Random(13)+1,true);
  p7.insertAtTop(c);
  c:=TCard.create(SPADE,Random(13)+1,true);
  p7.insertAtTop(c);
  c:=TCard.create(SPADE,Random(13)+1,true);
  p7.insertAtTop(c);
  c:=TCard.create(SPADE,Random(13)+1,true);
  p7.insertAtTop(c);
  c:=TCard.create(SPADE,Random(13)+1,true);
  p7.insertAtTop(c);}

  p8:=TPile.Create(510,238,30,0);
  CTable.addPile(p8);


end;

procedure MouseDown(Pile: TPile; Card: TCard);
{ kaldes ved MouseDown i bunken Pile på kortet Card;
  skriv kode der skal udføres ved MouseDown }
var c: TCard;

  procedure koerComputersTur();
    var
      i: integer;
      besked : string;
      crd : TCard;


    begin
{
      Check hvilke kort computeren har
        hvis computer har en kulør som bliver lagt ud, skal den  højeste af denne kulør ligges ud
        ellers hvis computer har rydere, smides en af disse ud
        ellers ligges laveste kort ud
}
      for i := 0 to p5.getSize - 1 do
        begin
          crd := p5.getCardAt(i);
          besked := '';
          besked := inttostr( crd.getValue );

          if crd.getSuit = HEART then
            besked := besked + ' HEART';

          if crd.getSuit = CLUB then
            besked := besked + ' CLUB';

          if crd.getSuit = DIAMOND then
            besked := besked + ' DIAMOND';

          if crd.getSuit = SPADE then
            besked := besked + ' SPADE';

          // Udskriver alle P5s kort

          showmessage( besked );
          end;


      {if (Pile=p5) and (Card<>nil) and (p6.isEmpty) then
        begin

          c:=p5.Find();
          c:=p5.removeCard(c);
          p6.insertAtTop(c);
          p6.flipTop;
        end;}
    end;

begin
  if (Pile=p1) and (Card<>nil) and (p2.isEmpty) then
    begin
      c:=p1.removeCard(Card);
      p2.insertAtTop(c);
    end;
  koerComputersTur;


{
begin
  if (Pile=p1) and (Card<>nil) and (p6.isEmpty) then
    begin
      c:=p5.removeCard(Card);
      p6.insertAtTop(c);
    end;

begin
  if (Pile=p1) and (Card<>nil) and (p4.isEmpty) then
    begin
      c:=p3.removeCard(Card);
      p4.insertAtTop(c);
    end;

begin
  if (Pile=p1) and (Card<>nil) and (p8.isEmpty) then
    begin
      c:=p7.removeCard(Card);
      p8.insertAtTop(c);
    end;
end;
end;
end;}

end;

procedure MouseUp(Pile: TPile; Card: TCard);
{ kaldes ved MouseUp i bunken Pile på kortet Card;
  skriv kode der skal udføres ved MouseUp }

begin
end;

end.




Cardclasses

unit cardclasses;

interface

uses classes,windows,forms,sysutils,graphics;

type
  TCColor=(BLACK,RED);
  TCSuit=(SPADE,HEART,DIAMOND,CLUB);

  TPile=class;

  TCard=class
          private
            suit: TCSuit;
            value: integer;
            faceUp: boolean;
            selected: boolean;
            myPile: TPile;
            procedure setMyPile(p: TPile);
            function  getCardHeight: integer;
            function  getCardWidth: integer;
          public
            constructor create(aSuit: TCSuit; aValue: integer;
                              aFaceUp: boolean);
            function  getColor: TCColor;
            function  getSuit: TCSuit;
            function  getValue: integer;
            function  getCardNr: integer;
            procedure TurnFaceUp;
            procedure TurnFaceDown;
            procedure flip;
            procedure select;
            procedure deSelect;
            function  isSelected: boolean;
            function  hasFaceUp: boolean;
          end;

  TPile=class
          private
            x: integer;        // position
            y: integer;
            minAntal: integer;  // minimum antal kort, default 0 , bruges ikke indtil videre
            maxAntal: integer;  // maximum antal kort, default 52, bruges ikke indtil videre
            dx: integer;        // retning
            dy: integer;        // forskydning i pxel fra kort til kort ved tegning
            cards: TList;
            PrevCount: integer;
            LockRefresh: boolean;
            EmptyPileType: integer; // angiver hvordan en tom
                                    // bunke vises
            IsVisible: boolean;
            procedure refresh;
            procedure DrawEmptyPile;
            function  xyInCard(x,y: integer): TCard;
            function  HFillRect: TRect;
            function  VFillRect: TRect;
          public
            constructor create(ax,ay,adx,ady: integer);
            destructor  free;
            procedure SetEmptyPileShow(aType: integer);
            procedure MoveTo(ax,ay: integer);
            function  getX: integer;
            function  getY: integer;
            function  getCardX(c: TCard): integer;
            function  getCardY(c: TCard): integer;
            procedure setMinAntal(min: integer);
            procedure setMaxAntal(max: integer);
            function  isEmpty: boolean;
            function  getSize: integer;
            function  getIndex(c: TCard): integer;
            function  Find(suit: TCSuit; value: integer): TCard;
            procedure insertAtTop(c: TCard);
            procedure insertAtBottom(c: TCard);
            procedure insertAbove(c0,c: TCard);
            procedure insertBelow(c0,c: TCard);
            procedure insertAt(Index: integer; c: TCard);
            function  removeCard(c: TCard): TCard;
            function  removeCardAt(n: integer): TCard;
            function  removeTopCard: TCard;
            function  removeBottomCard: TCard;
            function  flipTop: TCard;
            function  flipBottom: TCard;
            function  flipCard(c: TCard): TCard;
            function  flipFromTop(c: TCard): TCard;
            function  flipFromBottom(c: TCard): TCard;
            procedure flipAll;
            procedure turnAllFaceUp;
            procedure turnAllFaceDown;
            function  getTopCard: TCard;
            function  getBottomCard: TCard;
            function  getCardAt(n: integer): TCard;
            procedure clear;
            procedure make52; overload;
            procedure make52(faceUp: boolean); overload;
            procedure Extract(p: TPile; l,h: integer);
            procedure Shuffle;
            procedure SortValue;
            procedure SortSuit;
        end;

  TCTable=class
          private
            Piles: TList;
            onMove: TPile;
            procedure startMoving(p: TPile);
            procedure stopMoving;
          public
            constructor create;
            destructor  free;
            procedure  addPile(p: TPile);
            procedure  removePile(p: TPile);
            procedure  clear;
            procedure  Refresh;
            procedure  GetPileCardAt(x,y: integer;
                            var Pile: TPile; var Card: TCard);
        end;

var CTable: TCTable;

implementation

uses gui, Cardfkt;

  constructor TCard.create(aSuit: TCSuit; aValue: integer;
                          aFaceUp: boolean);
  begin
    suit:=aSuit;
    value:=aValue;
    faceUp:=aFaceUp;
    myPile:=nil;
  end;

  procedure TCard.setMyPile(p: TPile);
  begin
    myPile:=p;
  end;

  function TCard.getColor: TCColor;
  begin
    if (suit=SPADE) or (suit=CLUB) then Result:=BLACK
                                  else Result:=RED;
  end;

  function TCard.getSuit: TCSuit;
  begin
    Result:= suit;
  end;

  function TCard.getValue: integer;
  begin
    Result:= value;
  end;

  function TCard.getCardNr: integer;
  begin
    if faceUp then Result:= (3-ord(suit))+(value-1)*4
              else Result:= -1;
  end;

  procedure TCard.TurnFaceUp;
  begin
    faceUp:=true;
    if myPile<>nil then myPile.refresh;
  end;

  procedure TCard.TurnFaceDown;
  begin
    faceUp:=false;
    if myPile<>nil then myPile.refresh;
  end;

  procedure TCard.flip;
  begin
    faceUp:=not faceUp;
    if myPile<>nil then myPile.refresh;
  end;


  procedure TCard.select;
  begin
    selected:=true;
    if myPile<>nil then myPile.refresh;
  end;

  procedure TCard.deSelect;
  begin
    selected:=false;
    if myPile<>nil then myPile.refresh;
  end;

  function TCard.isSelected: boolean;
  begin
    Result:= selected;
  end;

  function TCard.hasFaceUp: boolean;
  begin
    Result:= faceUp;
  end;

  function TCard.getCardHeight: integer;
  begin
    Result:= cardHeight;
  end;

  function TCard.getCardWidth: integer;
  begin
    Result:= cardWidth;
  end;

  constructor TPile.create(ax,ay,adx,ady: integer);
  begin
    x:=ax;
    y:=ay;
    minAntal:=0;
    maxAntal:=52;
    dx:=adx;
    dy:=ady;
    LockRefresh:=false;
    PrevCount:=0;
    EmptyPileType:=0;
    IsVisible:=false;

    Cards:=TList.Create;
  end;

  destructor TPile.free;
  begin
    Clear;
  end;

  procedure TPile.clear;
  begin
    while cards.count>0 do
    begin
      TCard(cards[0]).free;  // frigiv kortet
      cards.delete(0); // slet fra listen
    end;
    refresh;
  end;

  procedure TPile.SetEmptyPileShow(aType: integer);
  begin
    EmptyPileType:=aType;
  end;

  procedure TPile.MoveTo(ax,ay: integer);
  begin
    x:=ax;
    y:=ay;
    refresh;
  end;

  function TPile.getX: integer;
  begin
    Result:= x;
  end;

  function TPile.getY: integer;
  begin
    Result:= y;
  end;

  function TPile.getCardX(c: TCard): integer;
  begin
    if c=nil then Result:= x
            else Result:= x+cards.indexOf(c)*dx;
  end;

  function TPile.getCardY(c: TCard): integer;
  begin
    if c=nil then Result:= y
            else Result:= y+cards.indexOf(c)*dy;
  end;

  function TPile.HFillRect: TRect;
  var w: integer;
  begin
    w:=cardWidth; if dx<0 then w:=0;
    Result.Left:=x+(Cards.Count-1)*dx+w;
    Result.Right:=x+(PrevCount-1)*dx+w;
    Result.Top:=y+(PrevCount-1)*dy;
    Result.Bottom:=Result.Top+CardHeight;
  end;

  function  TPile.VFillRect: TRect;
  var h: integer;
  begin
    h:=cardHeight; if dy<0 then h:=0;
    Result.Left:=x+(PrevCount-1)*dx;
    Result.Right:=Result.Left+CardWidth;
    Result.Top:=y+(PrevCount-1)*dy+h;
    Result.Bottom:=y+(Cards.Count-1)*dy+h;
  end;

  procedure TPile.setMinAntal(min: integer);
  begin
    minAntal:=min;
  end;

  procedure TPile.setMaxAntal(max: integer);
  begin
    maxAntal:=max;
  end;

  function TPile.isEmpty: boolean;
  begin
    Result:= cards.Count=0;
  end;

  function TPile.getSize: integer;
  begin
    Result:= cards.Count;
  end;

  function TPile.getIndex(c: TCard): integer;
  begin
    Result:= cards.indexOf(c);
  end;

  function TPile.Find(suit: TCSuit; value: integer): TCard;
  var c: TCard; i: integer;
  begin
    Result:= nil;
    for i:=0 to cards.count-1 do
    begin
      c:=TCard(cards.items[i]);
      if (c.getSuit=suit) and (c.getValue=value) then
      begin Result:= c; break end;
    end;
  end;

  procedure TPile.insertAtTop(c: TCard);
  begin
    if c<>nil then
    begin cards.add(c);
      c.setMyPile(self);
      refresh;
    end;
  end;

  procedure TPile.insertAtBottom(c: TCard);
  begin
    if c<>nil then
    begin cards.insert(0,c);
      c.setMyPile(self);
      refresh;
    end;
  end;

  procedure TPile.insertAbove(c0,c: TCard);
  var i: integer;
  begin
    i:=cards.IndexOf(c0);
    if (c<>nil) and (i>=0) then
    begin cards.insert(i+1,c);
      c.setMyPile(self);
      refresh;
    end;
  end;

  procedure TPile.insertBelow(c0,c: TCard);
  var i: integer;
  begin
    i:=cards.indexOf(c0);
    if (c<>nil) and (i>=0) then
    begin cards.insert(i,c);
      c.setMyPile(self);
      refresh;
    end;
  end;

  procedure TPile.insertAt(Index: integer; c: TCard);
  begin
    if (index<cards.Count) and (index>=0) then
    begin
      cards.insert(index,c);
      c.setMyPile(self);
      refresh;
    end;
  end;

  function TPile.removeCard(c: TCard): TCard;
  begin
    cards.remove(c);
    c.setMyPile(nil);
    refresh;
    Result:= c;
  end;

  function TPile.removeCardAt(n: integer): TCard;
  var c: TCard;
  begin
    if (n>=0) and (n<cards.Count) then
    begin
      c:=Cards.items[n];
      Cards.delete(n);
      c.setMyPile(nil);
      refresh;
      Result:= c;
    end
    else Result:= nil;
  end;

  function TPile.removeTopCard: TCard;
  var c: TCard;
  begin
    c:=cards.Items[Cards.Count-1];
    cards.remove(c);
    c.setMyPile(nil);
    refresh;
    Result:= c;
  end;

  function TPile.removeBottomCard: TCard;
  var c: TCard;
  begin
    c:=cards.Items[0];
    cards.remove(c);
    c.setMyPile(nil);
    refresh;
    Result:= c;
  end;

  function TPile.flipTop: TCard;
  var c: TCard;
  begin
    c:=cards.Items[Cards.Count-1];
    c.flip;
    refresh;
    Result:= c;
  end;

  function TPile.flipBottom: TCard;
  var c: TCard;
  begin
    c:=cards.Items[0];
    c.flip;
    refresh;
    Result:= c;
  end;

  function TPile.flipCard(c: TCard): TCard;
  begin
    c.flip;
    refresh;
    Result:= c;
  end;

  function TPile.flipFromTop(c: TCard): TCard;
  var i: integer;
  begin
    LockRefresh:=true;
    for i:=cards.indexOf(c) to cards.Count-1 do
      TCard(cards.Items[i]).flip;
    LockRefresh:=false;
    refresh;
    Result:= c;
  end;

  function TPile.flipFromBottom(c: TCard): TCard;
  var i: integer;
  begin
    LockRefresh:=true;
    for i:=cards.indexOf(c) downto 0 do
      TCard(cards.Items[i]).flip;
    LockRefresh:=false;
    refresh;
    Result:= c;
  end;

  procedure TPile.flipAll;
  var i: integer;
  begin
    LockRefresh:=true;
    for i:=cards.count-1 downto 0 do
      TCard(cards.Items[i]).flip;
    LockRefresh:=false;
    refresh;
  end;

  procedure TPile.turnAllFaceUp;
  var i: integer;
  begin
    LockRefresh:=true;
    for i:=cards.count-1 downto 0 do
      TCard(cards.Items[i]).turnFaceUp;
    LockRefresh:=false;
    refresh;
  end;

  procedure TPile.turnAllFaceDown;
  var i: integer;
  begin
    LockRefresh:=true;
    for i:=cards.count-1 downto 0 do
      TCard(cards.Items[i]).turnFaceDown;
    LockRefresh:=false;
    refresh;
  end;

  function TPile.getTopCard: TCard;
  begin
    if (cards.Count=0) then Result:= nil
                      else Result:= cards.Items[Cards.Count-1];
  end;

  function TPile.getBottomCard: TCard;
  begin
    if cards.count=0 then Result:= nil
    else Result:=cards.Items[0];
  end;

  function TPile.getCardAt(n: integer): TCard;
  begin
    if (0<=n) and (n<cards.count) then Result:= Cards.Items[n]
                                  else Result:= nil;
  end;

  procedure TPile.make52;
  begin
    make52(true);
  end;

  procedure TPile.make52(faceUp: boolean);
  var suit: TCSuit; value: integer; c: TCard;
  begin
    LockRefresh:=true;
    cards.Clear;
    for suit:=SPADE to CLUB do
      for value:=1 to 13 do
      begin
        c:=TCard.Create(suit,value,faceUp);
        insertAtTop(c);
      end;
    LockRefresh:=false;
    refresh;
  end;

  procedure TPile.Extract(p: TPile; l,h: integer);
  var n: integer;
  begin
    if (l<0) or (h>=p.Cards.count) or (l>h) then exit;

    LockRefresh:=true;
    if p=self then
    begin
      for n:=0 to l-1 do removeBottomCard;
      while Cards.Count>h-l+1 do removeTopCard;
    end
    else
    begin
      cards.clear;
      for n:=l to h do
        insertAtTop(p.removeCardAt(l));
    end;
    LockRefresh:=false;
    refresh;
  end;

  procedure TPile.Shuffle;
  var i,n1,n2: integer;
  begin
    for i:=0 to 5*cards.Count do
    begin
      n1:=i mod cards.Count;
      n2:=random(Cards.Count);
      cards.Exchange(n1,n2);
    end;
    refresh;
  end;

  procedure TPile.SortValue;
  var i,j,min: integer;

    function Compare(n1,n2: integer): integer;
    begin
      if GetCardAt(n1).value<GetCardAt(n2).value then Result:=-1
      else
        if GetCardAt(n1).value>GetCardAt(n2).value then Result:=1
        else
        begin
          if GetCardAt(n1).suit<GetCardAt(n2).suit then Result:=-1
          else
            if GetCardAt(n1).suit>GetCardAt(n2).suit then Result:=1
            else Result:=0
        end
    end;

  begin
    for i:=0 to Cards.Count-1 do
    begin
      min:=i;
      for j:=i+1 to Cards.count-1 do
        if Compare(j,min)=-1 then min:=j;
      Cards.Exchange(i,min);
    end;
    Refresh;
  end;

  procedure TPile.SortSuit;
  var i,j,min: integer;

    function Compare(n1,n2: integer): integer;
    begin
      if GetCardAt(n1).suit<GetCardAt(n2).suit then Result:=-1
      else
        if GetCardAt(n1).suit>GetCardAt(n2).suit then Result:=1
        else
        begin
          if GetCardAt(n1).value<GetCardAt(n2).value then Result:=-1
          else
            if GetCardAt(n1).value>GetCardAt(n2).value then Result:=1
            else Result:=0
        end
    end;

  begin
    for i:=0 to Cards.Count-1 do
    begin
      min:=i;
      for j:=i+1 to Cards.count-1 do
        if Compare(j,min)=-1 then min:=j;
      Cards.Exchange(i,min);
    end;
    Refresh;
  end;

  procedure TPile.refresh;
  var i: integer; c: TCard;
  begin
    if LockRefresh or not IsVisible then exit;

    if Cards.Count<PrevCount then
    begin
      FrmBord.EraseRect(HFillRect,VFillRect);
    end;

    if Cards.Count=0 then
      DrawEmptyPile
    else
      for i:=0 to Cards.Count-1 do
      begin
        c:=Cards[i];
        if c.faceUp then
        begin
          if c.isSelected then
            FrmBord.CardDrawInverted(x+dx*i,y+dy*i,c.getCardNr)
          else
          begin
            FrmBord.CardDraw(x+dx*i,y+dy*i,c.getCardNr);
          end
        end
        else
          FrmBord.BackDraw(x+dx*i,y+dy*i,0);
      end;
    PrevCount:=Cards.Count;
  end;

  procedure TPile.DrawEmptyPile;
  begin
    FrmBord.DrawEmptyPile(EmptyPileType,x,y);
  end;

  function TPile.xyInCard(x,y: integer): TCard;
  var c: TCard; i,cx,cy: integer;
  begin
    Result:= nil;

    for i:=cards.Count-1 downto 0 do
    begin
      c:=cards.Items[i];
      cx:=getCardX(c);
      cy:=getCardY(c);
      if (cx<=x) and (x<=cx+CardWidth) and
        (cy<=y) and (y<=cy+CardHeight) then
      begin
        Result:= c;
        break
      end
    end;
  end;

  constructor TCTable.create;
  begin
    Piles:=TList.Create;
    onMove:=nil;
  end;

  destructor TCTable.free;
  begin
    clear;
  end;

  procedure TCTable.addPile(p: TPile);
  begin
    if p=nil then exit;
    Piles.add(p);
    p.IsVisible:=true;
    p.refresh;
  end;

  procedure TCTable.removePile(p: TPile);
  begin
    Piles.remove(p);
    p.IsVisible:=false;
    FrmBord.Invalidate;
  end;

  procedure TCTable.clear;
  begin
    while Piles.Count>0 do
    begin
      TPile(Piles[0]).free;  // frigiv bunken
      Piles.delete(0);
    end;
    FrmBord.invalidate;
  end;

  procedure TCTable.startMoving(p: TPile);
  begin
    onMove:=p;
  end;

  procedure TCTable.stopMoving;
  begin
    onMove:=nil;
  end;

  procedure TCTable.Refresh;
  var i: integer;
  begin
    for i:=0 to Piles.Count-1 do
      TPile(Piles[i]).Refresh;
  end;

  procedure TCTable.GetPileCardAt(x,y: integer;
                      var Pile: TPile; var Card: TCard);
  var n,m: integer;
ok1,ok2,ok3,ok4: boolean;

    function HiddenCard(n,x,y: integer): boolean;
    var i,j,xc,yc: integer; p: TPile;
    begin
      Result:=false;
      for i:=n+1 to Piles.Count-1 do
      begin
        p:=Piles[i];
        for j:=0 to p.cards.count-1 do
        begin
          xc:=p.x+j*p.dx; yc:=p.y+j*p.dy;
          if ((xc<x) and (x<xc+CardWidth) and
              (yc<y) and (y<yc+CardHeight)) or
            ((xc<x+CardWidth) and (x+CardWidth<xc+CardWidth) and
              (yc<y) and (y<yc+CardHeight)) or
            ((xc<x) and (x<xc+CardWidth) and
              (yc<y+CardHeight) and (y+CardHeight<yc+CardHeight)) or
            ((xc<x+CardWidth) and (x+CardWidth<xc+CardWidth) and
              (yc<y+CardHeight) and (y+CardHeight<yc+CardHeight)) then
            begin
              Result:=true;
              exit;
            end
        end
      end
    end;

  begin
    Card:=nil;
    for n:=Piles.Count-1 downto 0 do
    begin
      Pile:=TPile(Piles[n]);
      for m:=Pile.Cards.Count-1 downto 0 do
      begin
        Card:=Pile.xyInCard(x,y);
        if Card<>nil then
        begin
          if not HiddenCard(n,Pile.getCardX(Card),Pile.getCardY(Card)) then
            exit;
          break;
        end
      end;
      if (Pile.x<=x) and (x<=Pile.x+CardWidth) and
        (Pile.y<=y) and (y<=Pile.y+CardHeight) then
      begin
        if not HiddenCard(n,Pile.x,Pile.y) then
          exit;
      end
    end;
    Card:=nil; Pile:=nil;
  end;

initialization

  CTable:=TCTable.create;

end.