1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:

function Kartenhoehe(ID:integer):TAusgabe;
  var x,y,z:integer; //Zählvariablen
  var Hoehe:integer; //Höhe der Karten ohne Berücksichtigung der Kartenfarbe
  var Paar:Array[1..13]of integer; //Auflistung der Paare
  var Paar1,Paar2,Drilling,Vierling:integer; //Wert der Karten
  var Fullhouse:Array[1..2] of integer; //Wert des Fullhouse
  var Strasse:Array[1..5] of integer; //Karten in der Straße
  var Flush:Array[1..5] of integer; //Karten im Flush
  var Straightflush:boolean;
  var Straightflushdraw:boolean;
  var abgebrochen:boolean;
  var HoechsteKarten:Array[1..7] of integer;
  var hilfe:integer;
begin
//alle Variablen 0 bzw. false
Paar1:=0;
Paar2:=0;
Drilling:=0;
Vierling:=0;
Fullhouse[1]:=0;
Fullhouse[2]:=0;
Strasse[4]:=0;
Strasse[5]:=0;
Flush[4]:=0;
Flush[5]:=0;
Straightflush:=false;
Straightflushdraw:=false;

//höchste Karten eintragen
  begin
    for x:=1 to 7 do
      HoechsteKarten[x]:=HoeheBerechnen(SpielerKarten[ID,x]);                    HIER IST DER FEHLER
    begin //Bubblesort
      for x:=1 to 7 do
        for y:=1 to 7 do
          if y<7
            then if (HoechsteKarten[y]>HoechsteKarten[y+1]) OR (HoechsteKarten[y]=0)
              then begin
                hilfe:=HoechsteKarten[y];
                HoechsteKarten[y]:=HoechsteKarten[y+1];
                HoechsteKarten[y+1]:=hilfe;
              end;
    end; //Bubblesort ENDE
  end; //höchste Karten eintragen ENDE

//Paar
  for x:=1 to 13 do Paar[x]:=0;

  begin //Paare ermitteln
    for x:=1 to 6 do begin //Anfangskarte Zähler
      abgebrochen:=false;
      if SpielerKarten[ID,x]=0 then break; //abbrechen, wenn keine Karte vorhanden
      for y:=x+1 to 7 do begin //2. Karte Zähler
        if (SpielerKarten[ID,y]=0) then break; //abbrechen, wenn keine Karte vorhanden
        if abgebrochen=false then begin
          if HoeheBerechnen(SpielerKarten[ID,x])=HoeheBerechnen(SpielerKarten[ID,y]) //Wenn beide Karten denselben Wert haben
            then begin
              Hoehe:=HoeheBerechnen(SpielerKarten[ID,x]);
              Paar[Hoehe]:=Paar[Hoehe]+1; //Paar registrieren
              abgebrochen:=true;
            end; //if Anweisung ENDE
        end;
      end; //2. Karte Zähler ENDE
    end; //Anfangskarte Zähler ENDE
  end; //Paare ermitteln ENDE

//ermittelte Paare auswerten (Paar-2Paare-Drilling-FullHouse-Vierling)
  begin //Auswertung
    for x:=1 to 13 do begin //Paare auslesen
      if Paar[x]=1  //=Paar
        then begin
          if Paar1=0
            then Paar1:=x
          else if Paar2=0
            then Paar2:=x
          else if (x<Paar1) OR (x<Paar2)
            then if Paar1<Paar2
              then Paar2:=x
              else Paar1:=x;
        end; //Paare eintragen ENDE
      if Paar[x]=2 //=Drilling
        then Drilling:=x;
      if Paar[x]=3 //=Vierling
        then begin
          Vierling:=x;
          break; //hier ist nichts höheres als Vierling möglich
        end;
    end; //Schleife zum Paare auslesen ENDE
    if (Drilling<>0) AND (Paar1<>0) //FullHouse Berechnung
      then begin
        Fullhouse[1]:=Drilling;
        Fullhouse[2]:=Paar1;
        if (Paar2<>0) AND (Paar2<Paar1) //Wenn ein Drilling und 2 Paare vorhanden sind nehme das größere Paar
          then Fullhouse[2]:=Paar2;
      end; //Fullhouse Berechnung ENDE
  end; //Auswertung ENDE

//Straße
if Vierling=0 then //Wenn so etwas vorhanden ist, dann gibt es keine Straße
  begin
    for x:=1 to 7 do begin
      if Strasse[4]<>0 then break; //Wenn bereit ein Straightdraw vorliegt abbrechen
      Strasse[1]:=SpielerKarten[ID,x];
      abgebrochen:=true;
      for y:=1 to 4 do begin //Schleife für die Teile 2-5 der Strasse
        if abgebrochen then begin //Abbruch wenn die Strasse nicht fortgesetzt werden kann
          abgebrochen:=false;
          for z:=1 to 7 do begin //alle Karten überprüfen
            if (abgebrochen=false) AND (HoeheBerechnen(SpielerKarten[ID,z])=Strasse[y]+1)
                then begin
                  Strasse[y+1]:=SpielerKarten[ID,z];
                  abgebrochen:=true;
                end;
          end; //z-Schleife ENDE
        end; //if-Anweisung ENDE
      end; //y-Schleife ENDE
    end; //x-Schleife ENDE
  if (HoeheBerechnen(Strasse[1])=10) AND (HoeheBerechnen(Strasse[4])=13)
    then if HoechsteKarten[1]=1 then
      for x:=1 to 7 do
        if HoeheBerechnen(SpielerKarten[ID,x])=1
          then Strasse[5]:=SpielerKarten[ID,x]; //Strasse, wenn ein Ass unter eine Strasse von 2-5 kommt
  end; //Straße erkennen ENDE

//Flush
if Vierling=0 then //Wenn ein Vierling vorhanden ist, ist ein Flush nicht möglich
  begin
    for x:=1 to 4 do begin
      if Flush[4]<>0 then break;
      Flush[1]:=SpielerKarten[ID,x];
      hilfe:=x+1;
      for y:=2 to 5 do begin
        abgebrochen:=false;
        for z:=hilfe to 7 do begin
          if (abgebrochen=false)
            then begin
              if (FarbeBerechnen(Flush[1])=FarbeBerechnen(SpielerKarten[ID,z]))
                then begin
                  Flush[y]:=SpielerKarten[ID,z];
                  abgebrochen:=true;
                end;
              hilfe:=hilfe+1;
            end;
        end; //z-Schleife ENDE
      end; //y-Schleife ENDE
    end; //x-Schleife ENDE
  end; //Flush erkennen ENDE

//Flush Karten sortieren
  begin
    if Flush[5]<>0 then begin
      begin //Bubblesort
        for x:=1 to 5 do
          for y:=1 to 5 do
            if y<5
              then if Flush[y]>Flush[y+1]
                then begin
                  hilfe:=Flush[y];
                  Flush[y]:=Flush[y+1];
                  Flush[y+1]:=hilfe;
                end;
      end; //Bubblesort ENDE
    end;
  end; //Flush sortieren ENDE


//Straightflush
if (Strasse[4]<>0) AND (Flush[4]<>0) then
  begin
    hilfe:=0;
    for x:=1 to 5 do
      if Strasse[1]=HoeheBerechnen(Flush[1])
        then hilfe:=hilfe+1
        else break;
    if hilfe=4 then Straightflushdraw:=true;
    if hilfe=5 then Straightflush:=true;
  end; //Straightflush erkennen ENDE

//AUSGABE
  begin
    //Highcard
    result[1]:=0;
    result[2]:=HoechsteKarten[1];
    result[3]:=HoechsteKarten[2];
    result[4]:=HoechsteKarten[3];
    result[5]:=HoechsteKarten[4];
    result[6]:=HoechsteKarten[5];

    //Straightdraw
    if (Strasse[4]<>0) AND (Strasse[5]=0) //AND (Pokertisch.River.Visible=false)
      then result[1]:=1;

    //Flushdraw
    if (Flush[4]<>0) AND (Flush[5]=0) //AND (Pokertisch.River.Visible=false)
      then result[1]:=2;

    //Straightflushdraw
    if (Straightflushdraw) //AND (Pokertisch.River.Visible=false)
      then result[1]:=3;

    //Paar
    if (Paar1<>0) AND (Paar2=0)
      then begin
        result[1]:=4;
        result[2]:=Paar1;
        result[3]:=Paar1;
        if (Paar1<>HoechsteKarten[1]) AND (Paar1=HoechsteKarten[2])
          then result[4]:=HoechsteKarten[1]
        else if Paar1=HoechsteKarten[3]
          then begin
            result[4]:=HoechsteKarten[1];
            result[5]:=HoechsteKarten[2];
          end
        else if Paar1=HoechsteKarten[4]
          then begin
            result[4]:=HoechsteKarten[1];
            result[5]:=HoechsteKarten[2];
            result[6]:=HoechsteKarten[3];
          end;
      end;

    //2 Paare
    if (Paar1<>0) AND (Paar2<>0)
      then begin
        result[1]:=5;
        result[2]:=Paar1;
        result[3]:=Paar1;
        result[4]:=Paar2;
        result[5]:=Paar2;
        result[6]:=HoechsteKarten[1];
        if Paar1>Paar2
          then begin
            result[2]:=Paar2;
            result[3]:=Paar2;
            result[4]:=Paar1;
            result[5]:=Paar1;
          end;
        if (result[2]=HoechsteKarten[1])
          then if result[4]=HoechsteKarten[3]
            then result[6]:=HoechsteKarten[5]
            else result[6]:=HoechsteKarten[3];
      end;

    //Drilling
    if (Drilling <>0) AND (Paar1=0)
      then begin
        result[1]:=6;
        result[2]:=Drilling;
        result[3]:=Drilling;
        result[4]:=Drilling;
        result[5]:=HoechsteKarten[1];
        result[6]:=HoechsteKarten[2];
        if Drilling=HoechsteKarten[1]
          then begin
            result[5]:=HoechsteKarten[4];
            result[6]:=HoechsteKarten[5];
          end;
        if Drilling=HoechsteKarten[2]
          then result[6]:=HoechsteKarten[5];
      end;

    //Strasse
    if Strasse[5]<>0
      then begin
        result[1]:=7;
        for x:=1 to 5 do
          result[x+1]:=Strasse[x];
      end;

    //Flush
    if Flush[5]<>0
      then begin
          result[1]:=8;
          for x:=1 to 5 do
            result[x+1]:=HoeheBerechnen(Flush[x]);
      end;

    //FullHouse
    if FullHouse[1]<>0
      then begin
        result[1]:=9;
        result[2]:=FullHouse[1];
        result[3]:=FullHouse[1];
        result[4]:=FullHouse[1];
        result[5]:=FullHouse[2];
        result[6]:=FullHouse[2];
      end;

    //Vierling
    if Vierling<>0
      then begin
        result[1]:=10; //10 = Vierling
        result[2]:=Vierling;
        result[3]:=Vierling;
        result[4]:=Vierling;
        result[5]:=Vierling;
        if HoechsteKarten[1]=Vierling
          then result[6]:=HoechsteKarten[5]
          else result[6]:=HoechsteKarten[1];
      end;

    //Straightflush
      if Straightflush
        then begin
          if Strasse[1]=1
            then result[1]:=12 //12 = Royalflush vorhanden
            else result[1]:=11; //11 = Straightflush vorhanden
          for x:=1 to 5 do
            result[x+1]:=Strasse[x];
        end;
  end;
end;					

1:
2:
3:
4:
5:
6:

function Kartenhoehe(ID:integer):TAusgabe;
......
begin
......
    for x:=1 to 7 do
      HoechsteKarten[x]:=HoeheBerechnen(SpielerKarten[ID,x]);