program domino_lerakas;
  uses crt,pozicobj;
  const max=13;       {ennyi db-ot hŁzhatok ki max egyszerre}
        dominodb=36;  {ennyi domin˘nk van ”sszesen}

{      TPoz=(eredeti,kevert,huzott,lerakott)
       TDominoMutato=^Tdomino;
       Tdomino=record
                egyik:szamjegy;
                masik:szamjegy;
                kov,elozo:TDominoMutato;
       end;
       TDominok=object

                fej,akt:Tdominomutato;
                hossz:integer;
                hiba:boolean;
                poz:Tpoz;
         public
                procedure kiir;
                procedure ures;
                procedure lerak(var domlerakott:TDominok;hanyadik:integer);
                procedure legyenegyenlo(var lista2:Tdominok);
                function hol(melyik:integer):Pointer;
                procedure  kever(var mit:TDominok);
                function ures_e:boolean;
                function hibas:boolean;
                procedure elsore;
                procedure utolsora;
                procedure vegerefuz(m:TDominoMutato);
                procedure kifuz(m:TDominoMutato);
                procedure huz6ot(var dom:Tdominok);
                Procedure huzas(var dom:TDominok);

       end;

{---------------------------------------------------------------------
MEGIRANDŕ ELJľRľSOK
-----------------------------------------------------------------------
                procedure kiir;
                procedure ures;

                procedure legyenegyenlo(var lista2:Tdominok);
                function hol(melyik:integer):Pointer;

                function ures_e:boolean;
                function hibas:boolean;
                procedure elsore;
                procedure utolsora;

{ procedure TDominok.vegerefuz(m:TDominoMutato);
     {a lista v‚g‚hez fűzi az m cĄmen lev‹ domin˘t; l. Hol fggv‚ny}
{ procedure TDominok.kifuz(m:TDominoMutato);
     {a list b˘l kifuzi az m cĄmu elem‚t; l. Hol fggv‚ny}
{ procedure TDominok.huzas(var dom:TDominok);
     {hŁz egyet ‚s beteszi a dom lista v‚g‚re; l. Hol fggv‚ny}
{ procedure TDominok.huz6ot(var dom:Tdominok);
     {hat domin˘t hŁz a dom list'ba teszi }
{ procedure TDominok.lerak(var hova:TDominok;hanyadik:integer;var hibas:boolean);
     {a h nyadikat kifuzi ‚s  tfuzi a hova list'ba,
      ha a kiv lasztott domin˘ ‚s a hova lista utols˘ sz ma megegyezik}
{ procedure TDominok.kever(var domsorba:TDominok);
     {az eredeti sorrend szerint felt”lt”tt domin˘kat  tm solja,
     majd megkeveri...(N* kiv laszt 2 v‚letlen domin˘t, majd
     megcser‚li ezeket)}
{procedure jatek(var domkevert,domhuzott,domlerakott:TDominok);
      {a j t‚k program vez‚rli az interaktĄv j t‚kot}

{----------------------------------------------------------------
{LISTA MëVELETEK  - FELHASZNľLHATŕAK
---------------------------------------------------------------------
 procedure TDominok.ures;
     {ures lista be llĄt sa}
{ function TDominok.ures_e:boolean;
     {res_e a lista}
{ procedure TDominok.legyenegyenlo(lista2:Tdominok);
     {a lista2  tm sol sa list ba}
{ procedure TDominok.elsore;
     {a lista els‹ elem‚re  lljon}
{ procedure TDominok.utolsora;
     {a lista utols˘ elem‚re  ll}
{ function TDominok.hol(melyik:integer):TDominok;
     {a lista melyikedik elem‚nek cĄm‚t adja}
{ function TDominok.hibas:boolean;
     {a lista hiba mez‹j‚t olvassa ki ‚s t”rli}
{ procedure TDominok.kiir;
     {a unitban felt”lt”tt pozici˘kra kirajzolja a list t}
{--------------------------------------------------------------------------
SEGD ELJľRľSOK
{--------------------------------------------------------------------------


{ procedure funksor;
     {a funkci˘sor kiĄr sa}
{ procedure uzenet(s:string);
     {zenet a legals˘ sorban, bill. v r}
{ procedure kerdes(var hanyadik:integer;var lista:TDominok;var nemtesz:boolean);
     {k‚rd‚st tesz fel, ellen‹rzi, hogy van-e a list ban h nyadik elem, kil‚p
      a j t‚kb˘l 'V' eset‚n, '*'-ra pedig az elj r sb˘l}
{ procedure cim;
{ procedure asztal;
    {kiĄrja a megfelel‹ pozici˘kra a kihuzott ‚s a m r lerakott domin˘kat}

{ var  domsorba,domkevert,domlerakott,domhuzott:Tdominok;
            {domsorba - a sorba rakott domin˘k
             domkevert list ban a megkevert domin˘k legyenek
             domlerakott list ban az asztalra m r egym s mell‚ rakott domin‹k legyenek
             domhuzott list ban a n lam lev‹, kevertekb‹l kihŁzott domin˘k legyenek}

var
     hanyadik:integer;
     c:char;
     hiba,volteStart,volteKever,esc:boolean;
     i:integer;

procedure kever2(var mit, mire:Tdominok);
var ez,az:TdominoMutato; i,j,k:integer;
{A "veletlenszam-sokszor"-i futtatas: ( k:=1/(0.1+random(1)) ) - es k:real }
  procedure csere(var a,b:tdominomutato); { Belso eljaras a cserere }
    var sv:tdominomutato;
    begin
     sv^.egyik:=a^.egyik;
     sv^.masik:=a^.masik;
     a^.egyik:=b^.egyik;
     a^.masik:=b^.masik;
     b^.egyik:=sv^.egyik;
     b^.masik:=sv^.masik;
     end;
begin
  mire.legyenegyenlo(mit);
  For k:=1 to 50 do begin { Hanyszor keverjen }
    i:=(random(dominodb-1))+1;
    j:=(random(dominodb-1))+1;
    ez:=mire.hol(i);
    az:=mire.hol(j);
    csere(ez,az);

    end;
end;

begin
  cim;
  voltestart:=false; voltekever:=false;

  while c<>'Q' do
  begin

    case c of
    'E': begin                         {EREDETI DOMINŕ SOR }
          clrscr;
          domsorba.kiir;
         end;
    'M': begin
           volteKever:=true;                         {MEGKEVEREM}
           domkevert.ures; domlerakott.ures;  domhuzott.ures;

           {domkevert.kever(domsorba);}   {EZT KELL HELYETTESITENI}
           kever2(domsorba,domkevert);
           clrscr;
           domkevert.kiir; uzenet('Megkevertem.....');
         end;

    'K': begin                         {MľR MEGKEVERT KIĄRľSA}
          if volteKever then
          begin
           clrscr;
           domkevert.kiir;
          end
          else uzenet('  M‚g nem kevert ..')
         end;
    'A': if voltestart then asztal
         else uzenet('  M‚g nem kezdte el a j t‚kot, res az asztal ..');
    'S': begin
           voltestart:=true;volteKever:=true;
           clrscr;
           domkevert.ures; domlerakott.ures;  domhuzott.ures;
           domkevert.kever(domsorba);
           domkevert.kiir; uzenet('Megkevertem.....               ');
           domkevert.huz6ot(domhuzott);
           domkevert.huzas(domlerakott);
           asztal;  uzenet('HŁztam hat domin˘t ‚s egyet k”z‚pre tettem...');
         end;
    'H': begin
          if voltestart then
          begin
           asztal;
           if domhuzott.hossz=max then
            begin
               uzenet('Nem lehet egyszerre t”bb domin˘ mag n l      '  );
            end
           else
            begin
             domkevert.huzas(domhuzott);
             asztal;
            end;
           end
           else uzenet('  M‚g nem kezdte el a j t‚kot, res az asztal .. ')
         end;
    'L': begin
         if voltestart then
         begin
          asztal;
          kerdes(hanyadik,domhuzott,hiba,esc);
          if not domhuzott.hiba then
          begin

              domhuzott.lerak(domlerakott,hanyadik);
              asztal;
              if domhuzott.hiba then uzenet(' Nem illeszkedik a domino...        ');

           end;
          end
          else uzenet('  M‚g nem kezdte el a j t‚kot, res az asztal ..  ')
          end;
      'J':begin

           clrscr;
           domkevert.ures;
           domlerakott.ures;
           domhuzott.ures;
           domkevert.kever(domsorba);
           domkevert.huz6ot(domhuzott);
           domkevert.huzas(domlerakott);
           asztal;
           jatek(domkevert,domhuzott,domlerakott);
           domkevert.ures;
           domlerakott.ures;
           domhuzott.ures;

         end;  {J v‚ge}
     end;  {case v‚ge}
     funksor;
     c:=readkey;
     c:=upcase(c);
  end;   {while v‚ge}

end.