Integer in zwei Bits

L

lucyyy

Mitglied
Guten Tag,

folgende Aufgabe habe ich:
Implementiere das Interface Spielfeld mit einer weiteren Klasse SpielfeldInteger, die intern eine int-Variable zur Darstellung des aktuellen Spielfeldzustandes verwendet. Wieder darf das Interface nicht verändert werden. Verwende die Bit-Operationen von Java, um den Zustand einer Zelle des Spielfeldes in jeweils zwei Bits der int-Variablen abzulegen (warum gerade zwei?).

Dabei geht es um das Spiel TicTacToe.

Wie genau kann ich hier also einen Integer in 2 Bits umwandeln?
 
mihe7

mihe7

Top Contributor
Ein int sind 32 Bits, da gibts nichts umzuwandeln. Worum es geht, ist einzelne Bits zu setzen. Das funktioniert, indem man mit dem bitweisen Oder-Operator zwei ints miteinander verknüpft.
 
K

kneitzel

Gast
Also erst einmal die Frage: Wie viele Zustände hat ein Feld bei Tic Tac Toe?
==> Daraus kann man die Anzahl der notwendigen Bits bekommen.

Wie viele Spielfelder hat ein TicTacToe Spiel? ==> Dann kann man sich, zusammen aus der oberen Information, die Anzahl der Bits ausrechnen, die man braucht. Und man kann prüfen, ob es in ein int passt ... (Und wird wohl, da es ja so vorgegeben ist)

Dann muss man nur noch überlegen, wie man auf welches Bits zugreifen kann ... Was für bitweise Zugriffe kennst Du denn in Java?
 
K

kneitzel

Gast
mihe7 hat gesagt.:
Ein int sind 32 Bits, da gibts nichts umzuwandeln. Worum es geht, ist einzelne Bits zu setzen. Das funktioniert, indem man mit dem bitweisen Oder-Operator zwei ints miteinander verknüpft.
Zum Vergrößern anklicken....
Nunja - ich würde auch noch den shift Operator erwähnen. Der wird sich bei der Aufgabe bestimmt auch als hilfreich erweisen denke ich mal....
 
mihe7

mihe7

Top Contributor
OK, sehen wir uns mal ein TicTacToe-Spielfeld an und tragen dort jeweils zwei Bits ein. Als Ausgangswert verwenden wir einfach mal 0 für jedes Bit.

00​
00​
00​
00​
00​
00​
00​
00​
00​

Wie viele Zustände kann ein einzelnes Feld nun einnehmen? Wie viele Zustände kann man mit einem Bit darstellen? Wie kann man die verschiedenen Zustände mit zwei Bits kodieren?
 
L

lucyyy

Mitglied
mihe7 hat gesagt.:
OK, sehen wir uns mal ein TicTacToe-Spielfeld an und tragen dort jeweils zwei Bits ein. Als Ausgangswert verwenden wir einfach mal 0 für jedes Bit.

00​
00​
00​
00​
00​
00​
00​
00​
00​

Wie viele Zustände kann ein einzelnes Feld nun einnehmen? Wie viele Zustände kann man mit einem Bit darstellen? Wie kann man die verschiedenen Zustände mit zwei Bits kodieren?
Zum Vergrößern anklicken....
Ein Feld kann ab da ja nur noch einen Zustand annehmen. Also der, dass da jemand drauf ist. Entweder Spieler 1 oder Spieler 2. Heißt er kann aus zwei Zuständen nur einen annehmen.
Ich weiß aber leider nicht, wie ich es mit zwei Bits kodieren kann. Ich würde aus 00 dann einfach 11 oder 22 machen.
In meinem Studiengang haben wir aber nie damit gearbeitet, weshalb ich nicht wirklich Ahnung davon habe haha
 
K

kneitzel

Gast
Die Frage wäre evtl. angebracht, in wie weit die Zusammenhänge mit Bit, Byte und Integer verstanden wurden.
Kannst du erläutern, was sich hinter diesen Begriffen verbirgt und wie diese zusammen hängen?
 
W

White_Fox

Top Contributor
lucyyy hat gesagt.:
Ein Feld kann ab da ja nur noch einen Zustand annehmen. Also der, dass da jemand drauf ist. Entweder Spieler 1 oder Spieler 2. Heißt er kann aus zwei Zuständen nur einen annehmen.
Ich weiß aber leider nicht, wie ich es mit zwei Bits kodieren kann. Ich würde aus 00 dann einfach 11 oder 22 machen.
In meinem Studiengang haben wir aber nie damit gearbeitet, weshalb ich nicht wirklich Ahnung davon habe haha
Zum Vergrößern anklicken....
mihe7 will auf Stellenwertsysteme hinaus. Ein Bit ist in der Computerrechnerei die kleinstmögliche Informationseinheint und kann zwei mögliche Zustände annehmen. Im Computer werden die Zustände eines Bits mit Strom AN/Strom AUS dargestellt, genauso gut könntest du aber z.B. auch eine Leuchte ein- oder ausschalten (das wird in der Elektronik übrigens auch genutzt).

Wenn du jetzt mehrere Bits aneinanderreihst, kannst du damit Zahlen bilden, wobei jedes Bit eine Wertstelle repräsentiert.
Im Dezimalsystem kennst du das: bei einer dreistelligen Zahl, z.B. 231, hast du ganz rechts die Einerstelle, in der Mitte die Zehnerstelle, links die Hunderterstelle, und kannst das Ganze nach links beliebig erweitern.

Bei Bits funktioniert das ganz genauso, der Witz ist, daß du halt nur bis 1 zählen kannst. Willst du bis zwei zählen mußt du um eine Stelle links erweitern. Und das nennt man dann Binär- oder Dualsystem. Wenn du zwei Bits hast, kannst du insgesamt bis drei (also vier Zustände, null gibt es ja auch noch) zählen (0bx = Binärsystem):

0b00 -> 0
0b01 -> 1
0b10 -> 2
0b11 -> 3

Nur aus Interesse: Was studierst du eigentlich?
 
W

White_Fox

Top Contributor
Sicher mußt du nicht umrechnen. Aber lucyyy muß wissen, wie man zwei Bits in 32 Bits unterbringt, und da finde ich es schon hilfreich zu wissen, wie das mit den Stellen funktioniert. :)
 
mihe7

mihe7

Top Contributor
White_Fox hat gesagt.:
Sicher mußt du nicht umrechnen. Aber lucyyy muß wissen, wie man zwei Bits in 32 Bits unterbringt, und da finde ich es schon hilfreich zu wissen, wie das mit den Stellen funktioniert. :)
Zum Vergrößern anklicken....
Das ändert aber nichts daran, dass ich darauf nicht hinaus wollte :)

Mir ging es einfach darum, dass ein int 32 Bits speichert und man jedes Bit mit einer Bitmaske und einer Oder-Verknüpfung setzen kann (mit einer Und-Verknüpfung testen kann usw.) Dass sich die 32 Bits auch als Zahl interpretieren lassen, spielt dabei keine Rolle, man könnte den Spaß auch mit einem BitSet nachbilden.
 
K

kneitzel

Gast
Meniskusschaden hat gesagt.:
Um das zu vertiefen könnte man dann noch die Implementierung so ändern, dass statt der int- eine short-Variable als Spielfeldspeicher verwendet wird.
Zum Vergrößern anklicken....
Naja - die Idee dürfte doch sein, das ganze Spielfeld in nur einem int zu speichern. Da reichen ja 3 Byte aus.

Wobei das Verständnis mit den Zahlen auch gut und wichtig ist. Ich hatte ja erst einmal explizite shift Operationen im Sinn. Aber das braucht man nicht, denn durch die Zahlen geht das ja ebenso gut. (Wobei es auf das Gleiche hinaus läuft. Ein shift um eine Position ist ja auch nur eine Multiplikation oder Division durch zwei.

Aber daher ist halt der erste wichtig Punkte: Ist das Verständnis da, um was es hier denn dann geht. Wie die Daten prinzipiell gehalten werden und so. (Daher schon mein #11!)
 
M

Meniskusschaden

Top Contributor
kneitzel hat gesagt.:
Naja - die Idee dürfte doch sein, das ganze Spielfeld in nur einem int zu speichern. Da reichen ja 3 Byte aus.
Zum Vergrößern anklicken....
Ja. Ich hatte ich es als Vertiefung (des Themas Stellenwertsysteme) bezeichnet, weil es für die eigentliche Aufgabe nicht erforderlich ist. Damit ist die Implementierung nicht mehr ganz so einfach wie mit den Bitmasken, dafür drückt man den Speicherbedarf auf zwei Byte.
 
L

lucyyy

Mitglied
An sich verstehe ich generell Bits und so schon. Aber in der Aufgabenstellung wiederum habe ich echt keine Ahnung.
Mein Prof will ja, dass ich dann pro Zelle zwei Bits zur Darstellung verwende. Aber wie kann ich dies überhaupt machen?
Ich habe bis jetzt nur mit integer, long und short gearbeitet zur Zahlendarstellung.
Deswegen bin ich echt verwirrt von dieser Aufgabe.

Und kurz zu der Frage was ich studiere: Ich studiere European Computer Science xD
 
mihe7

mihe7

Top Contributor
a | b liefert in Java die bitweise OR-Verknüpfung von a und b.
a & b liefert in Java die bitweise AND-Verknüpfung von a und b.
a << 1 liefert in Java die Bits von a um ein Bit nach links verschoben.
a >> 1 liefert in Java die Bits von a um ein Bit nach rechts verschoben (das Vorzeichen wird dabei berücksichtigt)
a >>> 1 funktioniert wie a >> 1, nur ohne Berücksichtigung des Vorzeichens.

Mach was draus :)
 
L

lucyyy

Mitglied
mihe7 hat gesagt.:
a | b liefert in Java die bitweise OR-Verknüpfung von a und b.
a & b liefert in Java die bitweise AND-Verknüpfung von a und b.
a << 1 liefert in Java die Bits von a um ein Bit nach links verschoben.
a >> 1 liefert in Java die Bits von a um ein Bit nach rechts verschoben (das Vorzeichen wird dabei berücksichtigt)
a >>> 1 funktioniert wie a >> 1, nur ohne Berücksichtigung des Vorzeichens.

Mach was draus :)
Zum Vergrößern anklicken....
Ich verstehe nicht, wie mir das zur Aufgabe weiterhilft.
Ich hab doch einen Integer der pro 2 Bits mir eine Zelle darstellt. Wie kann ich aber diesen Integer in 18 Bits umwandeln. Und kann ich das dann als einen normalen Integer verwenden um Zahlen darzustellen.
Also dass ich dann sage, dass wenn die erste Zelle besetzt ist, der Integer folgendermaßen aussieht: 110000000000000000?
 
H

httpdigest

Top Contributor
Hier mal etwas ausführlicher, weil es ganz offensichtlich den Anschein hat, als fehlten dir hier noch einige wichtige Konzepte:

Ihr sollt als primitiven Datentyp `int` zur Modellierung des Spielfeldes verwenden.
Ein `int` in Java hat 32 Bits. Das Spielfeld hat 9 Zellen und pro Zelle habt ihr jeweils 3 verschiedene Zustände, die die Zelle annehmen _kann_. Oben wurde ja schon erläutert, dass man aufgerundet 2 Bits benötigt, um 3 Zustände zu speichern (ceil(log2(3)) == 2). Also musst du jede Zelle mit zwei Bits darstellen, wofür du für ein Feld mit 9 Zellen also 9*2 = 18 Bits benötigst. Das sind gerade 2 Bits mehr als der nächstkleinere Datentyp `short` besitzt. Somit sollt ihr wohl also `int` nehmen.

Man kann in Java ein int nicht in "kleine" Bits umwandeln, weil es ein "Bit" als Datentyp nicht gibt. Du musst also Bitoperationen wie @mihe7 schon sagte, jeweils immer auf das ganze 32-bit `int` anwenden, wenn du eine "Zelle" aktualisieren willst. Du hast als "Wortbreite" für alle möglichen Operationen also immer "ganze 32-bits".

Jetzt musst du die logischen, bitweisen Operationen verwenden (deren Wahrheitstabellen du ja sicherlich kennst - zumindest bei OR), um gezielt nur einzelne Bits in dem ganzen `int` zu setzen.
 
L

lucyyy

Mitglied
httpdigest hat gesagt.:
Hier mal etwas ausführlicher, weil es ganz offensichtlich den Anschein hat, als fehlten dir hier noch einige wichtige Konzepte:

Ihr sollt als primitiven Datentyp `int` zur Modellierung des Spielfeldes verwenden.
Ein `int` in Java hat 32 Bits. Das Spielfeld hat 9 Zellen und pro Zelle habt ihr jeweils 3 verschiedene Zustände, die die Zelle annehmen _kann_. Oben wurde ja schon erläutert, dass man aufgerundet 2 Bits benötigt, um 3 Zustände zu speichern (ceil(log2(3)) == 2). Also musst du jede Zelle mit zwei Bits darstellen, wofür du für ein Feld mit 9 Zellen also 9*2 = 18 Bits benötigst. Das sind gerade 2 Bits mehr als der nächstkleinere Datentyp `short` besitzt. Somit sollt ihr wohl also `int` nehmen.

Man kann in Java ein int nicht in "kleine" Bits umwandeln, weil es ein "Bit" als Datentyp nicht gibt. Du musst also Bitoperationen wie @mihe7 schon sagte, jeweils immer auf das ganze 32-bit `int` anwenden, wenn du eine "Zelle" aktualisieren willst. Du hast als "Wortbreite" für alle möglichen Operationen also immer "ganze 32-bits".

Jetzt musst du die logischen, bitweisen Operationen verwenden (deren Wahrheitstabellen du ja sicherlich kennst), um gezielt nur einzelne Bits in dem ganzen `int` zu setzen.
Zum Vergrößern anklicken....
Ah okay, jetzt habe ich es schon etwas besser verstanden.
Wenn ich zum Beispiel die erste Zelle mit den Spieler 1 besetzen möchte. Muss ich dann a>>b verwenden, damit die ersten beiden Bits auf 1 gesetzt werden?
 
H

httpdigest

Top Contributor
lucyyy hat gesagt.:
Wenn ich zum Beispiel die erste Zelle mit den Spieler 1 besetzen möchte. Muss ich dann a>>b verwenden, damit die ersten beiden Bits auf 1 gesetzt werden?
Zum Vergrößern anklicken....
Warum willst du denn die ersten beiden Bits auf 1 setzen? Und was genau sind für dich die ersten Bits? Also: Du hast 3 verschiedene Zustände und 2 Bits pro Zelle.
Wie genau planst du, mit den jeweils zwei Bits pro Zelle die drei Zustände abzubilden?
 
K

kneitzel

Gast
Das wichtige sind die Zusammenhänge.

Bit -> Byte: Ein Byte besteht aus 8 Bit. Diese kann man hintereinander weg schreiben, also z.B. 00000000.
Wenn man da nun die Stellen durchgeht, dann haben die eine gewisse Wertigkeit. So wie im Dezimalsystem auch.

Wertigkeit im Dezimalsystem:
- Erste Ziffer sind die Einer. (mal 10^0 = 1)
- zweite Ziffer sind die Zehner (mal 10^1 = 10)
- dritte Ziffer sind die Hunderter (mal 10^2 = 100)
- ...

Im Dualen System ist es auch so, nur eben ist die Basis jetzt 2 und nicht zehn, also haben wie 2^0, 2^1, 2^2, .... sprich: Wertigkeiten sind 1, 2, 4, 8, 10, .... (Also immer mal 2 statt mal 10 im 10er-System)

Integer -> sind sind nun 4 Byte, also kann man schreiben:
00000000 00000000 00000000 00000000
==> 32 Bit.

Wenn Du nun 2 Bit für eine Darstellung brauchst, dann kannst Du das natürlich nehmen ... bei 9 Feldern brauchst du also 18 Bit. Von den 32 bleiben also 14 unbenutzt:
00000000 000000xx xxxxxxxx xxxxxxxx
0er sind unbenutzte Bits, x benutzte.

Nun ist die Frage, wie kommst Du an die zwei Bit, die Dich interessieren?
Da kann man nun mit bitweisen Operationen hantieren ... also z.B. mittels UND.

00000000 000000xx xxxxxxxx xxxxxxxx und
00000000 00000000 00000000 00000011
== 00000000 00000000 00000000 000000xx --> Wir haben nur noch die letzten beiden Bits...

Aber ebenso kann man sich anschauen, das da für Wertigkeiten sind. 1, 2, 4!! Ab der 4 wollen wir nichts mehr. Also nehmen wir einfach die Zahl und Rechnen modulo 4!
Kann man sich ja gut aufschreiben: x*1 + y*2 -> modulo 4 bleiben die, wenn da ein x 1 sein soll.
x*4 + x*8 + x*16 + ... --> Das wird bei modulo 4 immer 0 geben.

Wenn ich nun binär eine Zahl xxyy habe (mal nur 4 Bits dargestellt) und mich interessieren nur die xx: Wie bekommt man diese xx?
a) logisch und: yyxx UND 1100 -> yy00 - aber der Wert ist halt noch hoch...
b) shift Operation: Ich kann bits verschieben. Ich verschiebe zwei Stellen und schon ist xx entfallen und ich habe nur yy.
c) eine shift Operation ist auch ein geteilt durch 2. Also einfach / 4 rechnen und ich habe auch yy.

Also wenn ich xxxxyyxx habe, dann kann ich diese binäre Zahl durch 4 Teilen (dann verschiebe ich diese so dass yy am Ende steht) und dann modulo rechnen. Und schon habe ich den Wert des Feldes ...

Nun musst Du nur überlegen, wie Du an jedes einzelne Felde kommen kannst. Wie sieht da die Berechnung aus?
Also mich interessiert jeweils das yy:
Feld 1: 00000000 000000xx xxxxxxxx xxxxxxyy
Feld 2: 00000000 000000xx xxxxxxxx xxxxyyxx
Feld 3: 00000000 000000xx xxxxxxxx xxyyxxxx
Feld 4: 00000000 000000xx xxxxxxxx yyxxxxxx
Feld 5: 00000000 000000xx xxxxxxyy xxxxxxxx
Feld 6: 00000000 000000xx xxxxyyxx xxxxxxxx
Feld 7: 00000000 000000xx xxyyxxxx xxxxxxxx
Feld 8: 00000000 000000xx yyxxxxxx xxxxxxxx
Feld 9: 00000000 000000yy xxxxxxxx xxxxxxxx

Mit den Informationen oben sollte es also möglich sein den jeweiligen Wert von yy zu lesen.

Wenn Du das hast, dann bleibt nur noch die Frage, wie Du die einzelnen Bits setzen kannst...
 
L

lucyyy

Mitglied
kneitzel hat gesagt.:
Nun musst Du nur überlegen, wie Du an jedes einzelne Felde kommen kannst. Wie sieht da die Berechnung aus?
Also mich interessiert jeweils das yy:
Feld 1: 00000000 000000xx xxxxxxxx xxxxxxyy
Feld 2: 00000000 000000xx xxxxxxxx xxxxyyxx
Feld 3: 00000000 000000xx xxxxxxxx xxyyxxxx
Feld 4: 00000000 000000xx xxxxxxxx yyxxxxxx
Feld 5: 00000000 000000xx xxxxxxyy xxxxxxxx
Feld 6: 00000000 000000xx xxxxyyxx xxxxxxxx
Feld 7: 00000000 000000xx xxyyxxxx xxxxxxxx
Feld 8: 00000000 000000xx yyxxxxxx xxxxxxxx
Feld 9: 00000000 000000yy xxxxxxxx xxxxxxxx
Zum Vergrößern anklicken....
Kann ich dann hier einfach durch 4 rechnen und dann modulo?
Also das bei jedem Feld machen?
 
L

lucyyy

Mitglied
thecain hat gesagt.:
Wie würdest du es denn z.B für Feld 1.lösen? Welche Werte gibt es, wie stellst du sie dar?
Zum Vergrößern anklicken....
Ich würde beim 1.Feld Und 00000000 00000000 00000000 00000011 machen und dann habe ich die letzten beiden Bits.
Ich weiß aber nicht, ob dort Diese dann direkt verändert werden, oder ob ich die irgendwie noch ändern muss und wie weiß ich auch nicht.
 
mihe7

mihe7

Top Contributor
Code: 
00000000 00000000 00000000 00000000 ODER
00000000 00000000 00000000 000000ab ERGIBT
00000000 00000000 00000000 000000ab
Code: 
00000000 00000000 00000000 00000000 ODER
00000000 00000000 00000000 0000ab00 ERGIBT
00000000 00000000 00000000 0000ab00
Code: 
00000000 00000000 00000000 00001100 ODER
00000000 00000000 00000000 ab000000 ERGIBT
00000000 00000000 00000000 ab001100
Damit hätten wir z. B. mal die Felder 1, 2, und 4 durch.

Wenn man einen Spieler mit
Code: 
00000000 00000000 00000000 000000ab
darstellt und das n-te Feld besetzen möchte, muss man die Bitfolge um 2*(n-1) Bits nach links verschieben. Zum Beispiel Feld 5 -> Verschiebung um 8 nach links:

Code: 
00000000 00000000 000000ab 00000000

Verknüpft man damit das Feld, erhält man eben ein Spielfeld, in dem Feld 5 mit ab besetzt ist - vorausgesetzt, das Feld war vorher leer!

Jetzt ist die Frage: was ist a und was ist b? Für Spieler 1 könnte man a=0, b=1 wählen und für Spieler 2 könnte man a=1 und b=0 wählen. Dann gibt es je Feld zwei Bit: 00 = leer, 01 = Spieler 1 und 10 = Spieler 2.
 
L

lucyyy

Mitglied
mihe7 hat gesagt.:
Code: 
00000000 00000000 00000000 00000000 ODER
00000000 00000000 00000000 000000ab ERGIBT
00000000 00000000 00000000 000000ab
Code: 
00000000 00000000 00000000 00000000 ODER
00000000 00000000 00000000 0000ab00 ERGIBT
00000000 00000000 00000000 0000ab00
Code: 
00000000 00000000 00000000 00001100 ODER
00000000 00000000 00000000 ab000000 ERGIBT
00000000 00000000 00000000 ab001100
Damit hätten wir z. B. mal die Felder 1, 2, und 4 durch.

Wenn man einen Spieler mit
Code: 
00000000 00000000 00000000 000000ab
darstellt und das n-te Feld besetzen möchte, muss man die Bitfolge um 2*(n-1) Bits nach links verschieben. Zum Beispiel Feld 5 -> Verschiebung um 8 nach links:

Code: 
00000000 00000000 000000ab 00000000

Verknüpft man damit das Feld, erhält man eben ein Spielfeld, in dem Feld 5 mit ab besetzt ist - vorausgesetzt, das Feld war vorher leer!

Jetzt ist die Frage: was ist a und was ist b? Für Spieler 1 könnte man a=0, b=1 wählen und für Spieler 2 könnte man a=1 und b=0 wählen. Dann gibt es je Feld zwei Bit: 00 = leer, 01 = Spieler 1 und 10 = Spieler 2.
Zum Vergrößern anklicken....
Und wie kann ich dass dann um n*(n-1) nach links verschieben?
Und muss ich dann am Anfang den integer mit 32 Nullen initialisieren?
Meine Idee wäre es dann bei den Cases einfach immer anzugeben, dass wenn er auf dem Feld... ist, soll er es verschieben und mit den Benutzer füllen sozusagen.
 
mihe7

mihe7

Top Contributor
lucyyy hat gesagt.:
Und wie kann ich dass dann um n*(n-1) nach links verschieben?
Und muss ich dann am Anfang den integer mit 32 Nullen initialisieren?
Meine Idee wäre es dann bei den Cases einfach immer anzugeben, dass wenn er auf dem Feld... ist, soll er es verschieben und mit den Benutzer füllen sozusagen.
Zum Vergrößern anklicken....
Wie oben geschrieben: mit dem <<-Operator :)

OK, ich mach mal Code, vielleicht wird es dann leichter:
Java: 
class Test {
    // Konstante für die Bitmaske des Spielers, wir könnten auch einfach = 1 schreiben,
    // hier nur zur Verdeutlichung der Bits.
    public static final int SPIELER1 = 0b00000000_00000000_00000000_00000001; 

    // Unser Spielfeld, das wird automatisch mit 0 initialisiert -> alle 32 Bits sind also 0.
    private int spielfeld; 

    // Beispiel, wie man ein gegebenes Feld mit Spieler 1 besetzt.
    public void besetzeFeldMitSpieler1(int feldIndex) {
        int verschiebung = 2*feldIndex; // feldIndex für das erste Feld ist 0, will man das n-te Feld, rechnet man 2*(n-1) wie oben
        int bitmaske = SPIELER1 << verschiebung; // verschieben der Bits von SPIELER1 um verschiebung Bits nach links, das Ergebnis wird in bitmaske abgelegt
        spiefeld = spielfeld | bitmaske; // hier verknüpfen wir das Spielfeld mit der Bitmaske per ODER-Verknüpfung (wie oben) und speichern das Ergebnis in Spielfeld.
    }
    ...
}
 
L

lucyyy

Mitglied
mihe7 hat gesagt.:
Wie oben geschrieben: mit dem <<-Operator :)

OK, ich mach mal Code, vielleicht wird es dann leichter:
Java: 
class Test {
    // Konstante für die Bitmaske des Spielers, wir könnten auch einfach = 1 schreiben,
    // hier nur zur Verdeutlichung der Bits.
    public static final int SPIELER1 = 0b00000000_00000000_00000000_00000001;

    // Unser Spielfeld, das wird automatisch mit 0 initialisiert -> alle 32 Bits sind also 0.
    private int spielfeld;

    // Beispiel, wie man ein gegebenes Feld mit Spieler 1 besetzt.
    public void besetzeFeldMitSpieler1(int feldIndex) {
        int verschiebung = 2*feldIndex; // feldIndex für das erste Feld ist 0, will man das n-te Feld, rechnet man 2*(n-1) wie oben
        int bitmaske = SPIELER1 << verschiebung; // verschieben der Bits von SPIELER1 um verschiebung Bits nach links, das Ergebnis wird in bitmaske abgelegt
        spiefeld = spielfeld | bitmaske; // hier verknüpfen wir das Spielfeld mit der Bitmaske per ODER-Verknüpfung (wie oben) und speichern das Ergebnis in Spielfeld.
    }
    ...
}
Zum Vergrößern anklicken....
Das macht es auf jeden Fall schon mal viel leichter, dankeschön!
Ich werde es mal versuchen und falls ich Schwierigkeiten oder Fragen habe werde ich nochmal schreiben
 

Aktuelle Jobs

Neue Themen


Oben