Strukturierte Variablen überprüfen

[Sunny]

Also ich habe mal einen kleinen Code zusammen gebastelt und dazu mal eine Frage...

In diesem Code habe ich 7 Variablen mit einer Struktur.
Diese Variablen möchte ich jetzt auf eine bestimmte Bedingung überprüfen.
Erstmal in kleiner Codeschnipsel, damit ihr euch ungefähr vorstellen könnt, wie es ungefähr aussieht und dann eine genauere Erläuterung dazu.

Code: Alles auswählen

Structure vls
  val1.b
  val2.b
EndStructure

Define Point1.vls, Point2.vls, Point3.vls, Point4.vls, Point5.vls, Point6.vls, Point7.vls

Point1\val1 = Random(12) + 2
Point1\val2 = Random(3) + 1

Point2\val1 = Random(12) + 2
Point2\val2 = Random(3) + 1

Point3\val1 = Random(12) + 2
Point3\val2 = Random(3) + 1

Point4\val1 = Random(12) + 2
Point4\val2 = Random(3) + 1

Point5\val1 = Random(12) + 2
Point5\val2 = Random(3) + 1

Point6\val1 = Random(12) + 2
Point6\val2 = Random(3) + 1

Point7\val1 = Random(12) + 2
Point7\val2 = Random(3) + 1

Jetzt möchte ich überprüfen, ob 5 der 7 Variablen mit der Structure "val1" die Werte 14, 13, 12, 11 und 10 enthalten und (wenn das der Fall ist) ob die Structure "val2" dieser 5 Variablen den gleichen Wert haben.
Leider habe ich da irgendwie eine Denk-Blockade, wie schaffe ich das denn am besten?

[NicTheQuick]

Also wenn val1 >= 10 ist, dann kann val2 unmöglich gleich val1 werden.

///Edit:
Oder sollten bei diesen 5 Variablen dann überall das selbe bei val2 stehen?
Dann wäre das die Lösung

Code: Alles auswählen

Structure vls
	val1.b
	val2.b
EndStructure

Dim P.vls(6)
cond1 = 0
cond2 = 0
t = -1

For i = 0 To 6
	P(i)\val1 = Random(12) + 2
	P(i)\val2 = Random(3) + 1
	If (P(i)\val1 >= 10 And P(i)\val1 <= 14)
		If cond1 = 0
			t = P(i)\val2
			cond2 = 1
		ElseIf t = P(i)\val2
			cond2 + 1
		EndIf
		cond1 + 1
	EndIf
Next

Debug Str(cond1) + " Variablen haben einen Wert zwischen 10 und 14 bei val1."
Debug Str(cond2) + " dieser Variablen haben den selben Wert bei val2."

[Sunny]

Ähm nein, das ist nicht ganz das was ich suche. Ich hab mein Problem wohl nicht gut genug geschildert.
Wie erklär ich das denn am besten...

Ich hatte da an so etwas wie eine Procedure gedacht, in der überprüft wird, ob in 5 von 7 Variablen JEDE Zahl von 10 bis 14 vorkommt (bie val1) und wenn ja, ob diese 5 variablen bei val2 den gleichen wert haben.

[NicTheQuick]

Und was ist, wenn die sechste und/oder siebte Variable ebenfalls einen Wert zwischen 10 und 14 haben? Soll bei denen dann auch val2 gleich sein? In dem Fall wären ja ein bzw. zwei der Zahlen zwischen 10 und 14 doppelt. Welche davon darf ich dann ignorieren?

[Sunny]

OK... Ich hab da ein gaaanz schlechtes Codebeispiel geliefert...
Hier mal ein neues:

Code: Alles auswählen

Structure vls
  val1.b
  val2.b
EndStructure

NewList Points.vls()

For a = 1 To 4
  For b = 2 To 14
    AddElement(Points())
    Points()\val1 = b
    Points()\val2 = a
  Next
Next

SelectElement(Point(), Random(ListSize(Points()) - 1))
P1.vls = Point()
DeleteElement(Point())

SelectElement(Point(), Random(ListSize(Points()) - 1))
P2.vls = Point()
DeleteElement(Point())

SelectElement(Point(), Random(ListSize(Points()) - 1))
P3.vls = Point()
DeleteElement(Point())

SelectElement(Point(), Random(ListSize(Points()) - 1))
P4.vls = Point()
DeleteElement(Point())

SelectElement(Point(), Random(ListSize(Points()) - 1))
P5.vls = Point()
DeleteElement(Point())

SelectElement(Point(), Random(ListSize(Points()) - 1))
P6.vls = Point()
DeleteElement(Point())

SelectElement(Point(), Random(ListSize(Points()) - 1))
P7.vls = Point()
DeleteElement(Point())

In diesem Fall ist es bei 5 von 7 Variablen nicht möglich,das 2 Variablen sich sowhol bei val1 als auch bei val2 gleichen.

Dazu mal eine kleine Erklärung, damit man besser verstehen kann, was ich möchte...
Also ich habe grade vor ein kleines Poker-Spiel zu erstellen (Texas Hold'em)...
(val1 = Zahlen von 1 - 10, Bube, Dame, König, Ass)
(val2 = Farben: Karo, Kreuz, etc.)

Und jetzt möchte ich, beim Ende des Spiels, die Karten auf einen RoyalFlush überprüfen.

[NicTheQuick]

Ungetestet sollte es so klappen:

Code: Alles auswählen

Structure vls
  val1.b
  val2.b
EndStructure

NewList Points.vls()

For a = 1 To 4
  For b = 2 To 14
    AddElement(Points())
    Points()\val1 = b
    Points()\val2 = a
  Next
Next

Dim P.vls(6)

Dim type.b(4)
Dim color.b(3)

c = -1
For i = 0 To 6
	SelectElement(Points(), Random(ListSize(Points()) - 1))
	P(i) = Points()
	DeleteElement(Points())
	;Farben zählen
	color(P(i)\val2 - 1) + 1
	If color(P(i)\val2 - 1) = 5 ;Farbe merken, die 5 mal vorkommt
		ok = #True
		c = P(i)\val2
	EndIf
Next

If c >= 0
	;Karten 10, Bube, Dame, König, Ass mit Farbe c zählen
	d = 0
	For i = 0 To 6
		If P(i)\val1 >= 10 And P(i)\val2 = c
			;Kommt eine Zahl öfter als einmal vor, abbrechen
			;funktioniert nur, wenn jede Zahl-Symbol-Kombination nur einmal vorkommt!
			If type(P(i)\val1 - 10)
				Break
			EndIf
			type(P(i)\val1 - 10) + 1
			d + 1
		EndIf
	Next
	If d = 5
	 	Debug "Royal Flush"
	EndIf
EndIf

[Rebon]

Wäre es nicht einfacher jede Karte eine feste Zahl zuzuordnen? Ich würde es jedenfalls mal so probieren, habe jetzt aber nicht alle Möglichkeiten errechnet, könnte sein das ein Ergebnis nach dem zusammen addieren gleich ist und somit wäre die Summe dann natürlich unbrauchbar.

Herz: 2=1, 3=2, 4=30, 5=40, 6=500, 7=600, 8=8000, 9=9000, 10=100000, B=200000, D=3000000, K = 4000000, A = 10000000

Royal Flush wäre dann 17300000.
Oder ein Straight Flush von Ass bis vier wäre 10000033.

Um das jetzt ganz auszutesten, ob das jetzt so funktionieren könnte oder nicht bin ich aber zu faul...

[NicknameFJ]

@rebon:

Wenn Du jeder Karte einen Wert geben willst, würde ich mich am binären Stellenwertsystem orientieren - also

2=1
3=2
4= 4
5= 8
6=16
7=32 etc.

13 Karte pro Farbe x 4 Farben= 52 Möglichkeiten pro Karte, könnte man jede Karte in einer Quad unterbringen (= 64 Bit) - die oberen 4 Bit des Kartenwertes wäre dann noch die Farbe der Karte.

EDIT:
Die Rechnung stimmt nicht - 13 Karten = 13 Bit plus 4 Bit für die Farben = 17 bit =LONG)

Wenn Du Platz sparen willst kannst Du die Farbe (4Möglichkeiten) auch in nur 2 Bit codieren, dann kannst Du das ganze auch in Word Word-Variablen unterbringen 13 + 2 Bit)

Noch eine Idee:
Jeder Farbe wird ein 16 Bit-Block zugeordnet:
Herz = Bit 0-15
Blatt = bit 16-31 usw

innerhalb jedes Blockes die Codierung der Werte der Karte (2-Ass) wie oben in binär
Alle 7 Karten-Werte aufaddieren - benötigt dann Quad (sind ja dann wirklich die o.g. 52 Bit) - Überschneidung (gleiche Summen bei unterschiedlichen Karten) kann es aufgrund der binären Wertung der Karten nicht geben. Dann hast Du pro 16-Bit Block was ja die Farbe representiert die Karten in binärdarstellung) - ooohhh sehe grad wir sind ja im Anfängerforum, da ist das vielleicht etwas zu hoch insbes. dann die erforderlichen Maskieren mit AND bzw. OR auf Binärebene)

ENDEDIT

Hat den Vorteil, dass wenn Du alle Karten(werte) aufaddierst, getrennt nach Farben, Du dann einfach mit einer Bitmusterprüfung arbeiten kannst (logisches and bzw. or/ xor) bzw. mit shift Operatoren << >> um aufeinderfolgendevKarten zu erkennen. Weis nicht ob sowas im weiteren Verlauf benötigt wird, aber ich würde mir die Option offenhalten.

Grüße

NicknameFJ

[Rebon]

Erstmal möchte ich anmerken das Ass bis vier natürlich falsch war, bis fünf geht ein Straight Flush.
@NicknameFJ
Entweder habe ich dich falsch verstanden oder du mich, ich tippe auf ersteres.
Das schöne bei meiner Variante wäre, falls sie funktionieren würde, dass es gar nicht mehr nötig ist die Reihenfolge oder irgendwas sonst, außer die Summe der Karten errechnen zu lassen.
Denn man könnte dann die Rangfolge in einem Array(Ergebnis der addierten Karten) abspeichern, am Ende müsste man dann nur noch die Arrays oder wo auch immer man es abspeichern möchte vergleichen und hätte sofort das Ergebnis ob entweder Gewonnen, Verloren oder Unentschieden.

Zum Beispiel:
7 5 7 5 4
5 5 7 4 7
4 5 7 7 5
7 7 5 5 4
4 7 7 4 5

Die Summe wäre immer gleich, aber ich sehe jetzt das es bereits mit den Pärchen wie z. B. 2=1 und 3=2 leider mit an sicher grenzender Wahrscheinlichkeit zu Überschneidungen kommen würde, man käme dann am Ende wohl auf extrem große Zahlen, um ein gleiches Ergebnis ausschließen zu können. War aber auch nur ein Gedanke von mir, ich hatte eigentlich gar nicht vor ein Pokerspiel zu programmieren.

[NicknameFJ]

Hallo Rebon,

ich wandle die Karten ja auch in Werte um, nur das ich auf das binäre Stellenwertsystem als Codierungsgrundlage zurückgreifen würde. Das schließt es nämlich aus dass es beim Addieren dazu kommt dass Summen zustande kommen die durch unterschiedliche Kartenkonstellationen entstehen und damit nicht mehr eindeutig wären.

Insbesondere die in meinem EDIT unter noch eine Idee aufgeführte Variante mit den 4 x 16-Bit Blöcken (für die vier Farben) mit jeweils bis zu 13 Karten (effektiv sind dann nur jeweils 13 von den 16 Bit pro Block genutzt) führt dazu dass man beim Addieren nicht auf die Farben achten müsste, da diese nicht in irgendwelchen Zusatzbits kodiert sind, sondern schon über die 4 getrennten Blöcke sich nicht ins Gehege kommen würden.

Im Ergebnis nach Addition der 7 Karten ist dann eindeutig - wie bei Dir - abzulesen ob zum Beispiel ein Stait Flash, Full House oder was auch immer vorliegt (kenne mich beim Pokern nicht aus).

Das von Dir als Vorteil angesehene, dass nicht mehr auf die Reihenfolge geprüft werden muss, weil ja mit einer Fixzahl verglichen werden kann, um ein Strait Flash zu erkennen, gilt bei meiner Meethode auch. Ich habe zum Schluß auch nur eine Zahl die alle sieben Karten repräsentiert.

Ich habe nur in meinem ersten Posting gemeint, dass bei der Binären Darstellung es leicht Möglich ist auch andere Konstellationen direkt durch Bitmaskenvergleich o.ä. zu erkennen ohne die genaue Zahl der Addition zu kennen, die die gehalten Karten ja im der ermittelten Summe schon binäre codiert ist. Jede EINS an einer bestimmten Stelle entspräche auch direkt einer ganz bestimmtenn Karte.


Nickname FJ