Skip to content

Instantly share code, notes, and snippets.

@Bapho

Bapho/GameActivity.java

Last active December 29, 2015 06:49
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save Bapho/7631823 to your computer and use it in GitHub Desktop.
Save Bapho/7631823 to your computer and use it in GitHub Desktop.
Download ZIP
This is the code of the game activity. - three-day project
Raw
GameActivity.java
package com.baphoware.prjhelloween.activities;
import com.baphoware.prjhelloween.R;
import com.baphoware.prjhelloween.executions.HelloWeenCardHand;
import com.baphoware.prjhelloween.executions.HelloWeenTextViews;
import com.baphoware.prjhelloween.listener.GameActivityOnClickListener;
import android.app.Activity;
import android.os.Bundle;
import android.provider.SyncStateContract.Constants;
import android.view.Menu;
import android.widget.Button;
import android.widget.ImageButton;
import android.widget.TextView;
public class GameActivity extends Activity
{
// statische Werte für die Felder und die Richtung der TextViews deklarieren und intialisieren
private static int LEFT = 0;
private static int UP = 1;
private static int RIGHT = 2;
private static int DOWN = 3;
private static int ONE = 0;
private static int TWO = 1;
private static int THR = 2;
private static int FOU = 3;
private static int FIV = 4;
private static int SIX = 5;
private static int SEV = 6;
private static int EIG = 7;
private static int NIN = 8;
// deklarieren und initialisieren der Objekte
private GameActivityOnClickListener gameListener = null;
private HelloWeenCardHand cardMyHand = null;
private HelloWeenCardHand cardYourHand = null;
private HelloWeenTextViews helloWeenTextViews = null;
private GameActivity gameActivity = null;
// deklarieren und initialisieren der Klassenvariablen
private boolean isGameEnded = false;
private boolean isPlayersTurn = false;
private boolean isComputersTurn = true;
private boolean willChangePlayersTurn = false;
private boolean willChangeComputersTurn = true;
private boolean isPressedNextCard = false;
private boolean[] isFree = new boolean[9];
private int[][] fieldStats = new int[9][4];
private int[] tempIdCard = new int[9];
private int[] idCard = new int[9];
private int fieldNumber = 0;
private int drawId = 0;
// deklarieren und initialisieren der Buttons
private ImageButton cmdOne = null;
private ImageButton cmdTwo = null;
private ImageButton cmdThree = null;
private ImageButton cmdFour = null;
private ImageButton cmdFive = null;
private ImageButton cmdSix = null;
private ImageButton cmdSeven = null;
private ImageButton cmdEight = null;
private ImageButton cmdNine = null;
private ImageButton cmdMyCard = null;
private ImageButton cmdNextCard = null;
private Button cmdComputersTurn = null;
// deklarieren und initialisieren der TextViews
private TextView txtvOneRight = null;
private TextView txtvOneDown = null;
private TextView txtvTwoDown = null;
private TextView txtvTwoLeft = null;
private TextView txtvTwoRight = null;
private TextView txtvThreeLeft = null;
private TextView txtvThreeDown = null;
private TextView txtvFourRight = null;
private TextView txtvFourUp = null;
private TextView txtvFourDown = null;
private TextView txtvFiveUp = null;
private TextView txtvFiveLeft = null;
private TextView txtvFiveDown = null;
private TextView txtvFiveRight = null;
private TextView txtvSixUp = null;
private TextView txtvSixDown = null;
private TextView txtvSixLeft = null;
private TextView txtvSevenUp = null;
private TextView txtvSevenRight = null;
private TextView txtvEightUp = null;
private TextView txtvEightLeft = null;
private TextView txtvEightRight = null;
private TextView txtvNineUp = null;
private TextView txtvNineLeft = null;
private TextView txtvMyCardLeft = null;
private TextView txtvMyCardUp = null;
private TextView txtvMyCardDown = null;
private TextView txtvMyCardRight = null;
private TextView txtvCardNumber = null;
@Override
protected void onCreate( Bundle savedInstanceState )
{
super.onCreate( savedInstanceState );
setContentView( R.layout.game_activity_layout );
// initialisieren und generieren der Buttons
cmdOne = (ImageButton) findViewById( R.id.cmdiOne );
cmdTwo = (ImageButton) findViewById( R.id.cmdiTwo );
cmdThree = (ImageButton) findViewById( R.id.cmdiThree );
cmdFour = (ImageButton) findViewById( R.id.cmdiFour );
cmdFive = (ImageButton) findViewById( R.id.cmdiFive );
cmdSix = (ImageButton) findViewById( R.id.cmdiSix );
cmdSeven = (ImageButton) findViewById( R.id.cmdiSeven );
cmdEight = (ImageButton) findViewById( R.id.cmdiEight );
cmdNine = (ImageButton) findViewById( R.id.cmdiNine );
cmdMyCard = (ImageButton) findViewById( R.id.cmdiMyCard );
cmdNextCard = (ImageButton) findViewById( R.id.cmdiNextCard );
cmdComputersTurn = (Button) findViewById( R.id.cmdComputersTurn );
// initialisieren und generieren der TextViews
txtvOneRight = (TextView) findViewById( R.id.txtvOneRight );
txtvOneDown = (TextView) findViewById( R.id.txtvOneDown );
txtvTwoLeft = (TextView) findViewById( R.id.txtvTwoLeft );
txtvTwoRight = (TextView) findViewById( R.id.txtvTwoRight );
txtvTwoDown = (TextView) findViewById( R.id.txtvTwoDown );
txtvThreeDown = (TextView) findViewById( R.id.txtvThreeDown );
txtvThreeLeft = (TextView) findViewById( R.id.txtvThreeLeft );
txtvFourDown = (TextView) findViewById( R.id.txtvFourDown );
txtvFourRight = (TextView) findViewById( R.id.txtvFourRight );
txtvFourUp = (TextView) findViewById( R.id.txtvFourUp );
txtvFiveRight = (TextView) findViewById( R.id.txtvFiveRight );
txtvFiveLeft = (TextView) findViewById( R.id.txtvFiveLeft );
txtvFiveUp = (TextView) findViewById( R.id.txtvFiveUp );
txtvFiveDown = (TextView) findViewById( R.id.txtvFiveDown );
txtvSixLeft = (TextView) findViewById( R.id.txtvSixLeft );
txtvSixUp = (TextView) findViewById( R.id.txtvSixUp );
txtvSixDown = (TextView) findViewById( R.id.txtvSixDown );
txtvSevenRight = (TextView) findViewById( R.id.txtvSevenRight );
txtvSevenUp = (TextView) findViewById( R.id.txtvSevenUp );
txtvEightLeft = (TextView) findViewById( R.id.txtvEightLeft );
txtvEightUp = (TextView) findViewById( R.id.txtvEightUp );
txtvEightRight = (TextView) findViewById( R.id.txtvEightRight );
txtvNineLeft = (TextView) findViewById( R.id.txtvNineLeft );
txtvNineUp = (TextView) findViewById( R.id.txtvNineUp );
txtvMyCardDown = (TextView) findViewById( R.id.txtvMyCardDown );
txtvMyCardLeft = (TextView) findViewById( R.id.txtvMyCardLeft );
txtvMyCardUp = (TextView) findViewById( R.id.txtvMyCardUp );
txtvMyCardRight = (TextView) findViewById( R.id.txtvMyCardRight );
txtvCardNumber = (TextView) findViewById( R.id.txtvCardNumber );
// initialisieren und generieren der Objektklassen
cardMyHand = new HelloWeenCardHand();
cardYourHand = new HelloWeenCardHand();
helloWeenTextViews = new HelloWeenTextViews();
// die Werte des Spiels initialisieren
initGame();
// initialisieren und generieren des Listeners
gameListener = new GameActivityOnClickListener( cardMyHand, cardYourHand );
// Listener setzen und zuweisen
cmdNextCard.setOnClickListener( gameListener );
cmdComputersTurn.setOnClickListener( gameListener );
cmdOne.setOnClickListener( gameListener );
cmdTwo.setOnClickListener( gameListener );
cmdThree.setOnClickListener( gameListener );
cmdFour.setOnClickListener( gameListener );
cmdFive.setOnClickListener( gameListener );
cmdSix.setOnClickListener( gameListener );
cmdSeven.setOnClickListener( gameListener );
cmdEight.setOnClickListener( gameListener );
cmdNine.setOnClickListener( gameListener );
}
@Override
public boolean onCreateOptionsMenu( Menu menu )
{
return true;
}
public synchronized void initGame()
{
if( isGameEnded == false )
{
for ( int a = 0; a < 9; a++ )
{
System.out.println( "isFree true setzen" );
isFree[a] = true;
idCard[a] = 0;
tempIdCard[a] = 0;
}
}
// der erste Zug des Gegners
cardYourHand.setHandStats();
putCard();
checkOpponent();
endComputersTurn();
// eigene Zufallshände generieren, Anfangswerte setzen
cardMyHand.setHandStats();
// die aktuelle Image Id setzen und das Image schreiben
saveDrawId();
cmdMyCard.setImageResource( drawId );
// ändern der TextViews der Handkarten-Stärken
setTxtvMyCardDown();
setTxtvMyCardLeft();
setTxtvMyCardRight();
setTxtvMyCardUp();
}
// versuchen, eine Karte zu legen
public synchronized void putCard()
{
System.out.println( "in put card; is field free: " + getIsFree( fieldNumber ) + "isPlayersTurn: " + isPlayersTurn + "isComputersTurn: " + isComputersTurn);
// wenn der Spieler dran ist
if( isPlayersTurn == true && isComputersTurn == false )
{
// wenn das Feld frei ist
if( getIsFree( fieldNumber ) == true )
{
System.out.println( "freiheit umkehren in put card mensch" );
// ob der Spielzug am Ende geändert werden muss
willChangePlayersTurn = true;
// Image Id setzen, Image zeichnen und Feld als besetzt markieren
saveDrawId();
setFieldCard( true );
setIsFree( fieldNumber );
}
}
// wenn der Gegner am Zug ist
if( isComputersTurn == true && isPlayersTurn == false )
{
System.out.println( "Computers zug" );
// temp. Endbedingung
boolean isLoopEnded = false;
// temp. Variable, um zu prüfen, ob das Feld frei ist
boolean[] isEmpty = new boolean[50];
// Zählschleifen-Variable
int a = 0;
do
{
// 50 Versuche, ein freies Feld zu treffen
if( a > 0 && a < 50 )
{
System.out.println( "besetzt machen" );
// letztes Feld als besetzt markieren
isEmpty[a - 1] = false;
}
// beim scheitern..
if( a > 49 )
{
isGameEnded = true;
}
System.out.println( "put card cpu field Number vor: " + fieldNumber );
// Gegner legt seine Karte auf ein zufälliges Feld
fieldNumber = (int) ( Math.random() * 9 );
System.out.println( "put card cpu field Number nach: " + fieldNumber );
a++;
// Abbruchbedingung setzen
if( getIsFree( fieldNumber ) == true || isGameEnded )
{
isLoopEnded = true;
}
}
while ( isLoopEnded == false );
if( isGameEnded )
{
System.out.println( "game ended!" );
}
System.out.println( "put card cpu field Number: " + fieldNumber );
// wenn das Feld frei ist
if( getIsFree( fieldNumber ) )
{
// warten, als ob der computer überlegt
try
{
wait( 2000 );
}
catch ( InterruptedException e )
{
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println( "Random Field Number: " + fieldNumber );
// ob der Spielzug am Ende geändert werden muss
willChangeComputersTurn = true;
// Image Id setzen, Image zeichnen und Feld als besetzt markieren
saveDrawId();
setFieldCard( false );
System.out.println( "freiheit umkehren in put card cpu" );
setIsFree( fieldNumber );
}
}
}
// abprüfen und speichern, welche ImageId zur Karte gehört
public synchronized void saveDrawId()
{
// wenn der Gegner dran ist
if( isComputersTurn == true )
{
// eine Handkarte zufällig auswählen
int r = (int) ( Math.random() * 4 );
cardYourHand.setIndexHand( r );
// ImageId speichern
switch( cardYourHand.getHandCard() )
{
case 0:
drawId = R.drawable.blackcat_black;
break;
case 1:
drawId = R.drawable.pumpkin_black;
break;
case 2:
drawId = R.drawable.bat_black;
break;
case 3:
drawId = R.drawable.magichat_black;
break;
case 4:
drawId = R.drawable.magicpotion_black;
break;
case 5:
drawId = R.drawable.axe_black;
break;
case 6:
drawId = R.drawable.skeleton_black;
break;
case 7:
drawId = R.drawable.ghost_black;
break;
case 8:
drawId = R.drawable.tombstone_black;
break;
case 9:
drawId = R.drawable.witch_black;
break;
case 10:
drawId = R.drawable.frankenstein_black;
break;
default:
drawId = R.drawable.plainblack;
break;
}
}
// wenn der Spieler am Zug ist
if( isPlayersTurn == true || isPressedNextCard == true )
{
// ImageId speichern
switch( cardMyHand.getHandCard() )
{
case 0:
drawId = R.drawable.blackcat;
break;
case 1:
drawId = R.drawable.pumpkin;
break;
case 2:
drawId = R.drawable.bat;
break;
case 3:
drawId = R.drawable.magichat;
break;
case 4:
drawId = R.drawable.magicpotion;
break;
case 5:
drawId = R.drawable.axe;
break;
case 6:
drawId = R.drawable.skeleton;
break;
case 7:
drawId = R.drawable.ghost;
break;
case 8:
drawId = R.drawable.tombstone;
break;
case 9:
drawId = R.drawable.witch;
break;
case 10:
drawId = R.drawable.frankenstein;
break;
default:
drawId = R.drawable.plainblack;
break;
}
}
System.out.println( "draw ID: " + drawId );
}
// die Karte wird gelegt
public synchronized void setFieldCard( boolean isHuman )
{
System.out.println( "in setFieldCard, fieldNumber:" + fieldNumber );
// wenn Jemand wirklich am Zug ist
if( ( isPlayersTurn == true && willChangePlayersTurn == true ) || ( isComputersTurn = true && willChangeComputersTurn == true ) )
{
// Feldnummer abprüfen und das Image aus der drawId zeichnen
switch( fieldNumber )
{
case 0:
System.out.println( "in Feld 1 setFieldCard" );
cmdOne.setImageResource( drawId );
setTxtvOneDown();
setTxtvOneRight();
exeIdCard( ONE );
break;
case 1:
cmdTwo.setImageResource( drawId );
setTxtvTwoDown();
setTxtvTwoRight();
setTxtvTwoLeft();
exeIdCard( TWO );
break;
case 2:
cmdThree.setImageResource( drawId );
setTxtvThreeDown();
setTxtvThreeLeft();
exeIdCard( THR );
break;
case 3:
cmdFour.setImageResource( drawId );
setTxtvFourDown();
setTxtvFourRight();
setTxtvFourUp();
exeIdCard( FOU );
break;
case 4:
cmdFive.setImageResource( drawId );
setTxtvFiveDown();
setTxtvFiveRight();
setTxtvFiveUp();
setTxtvFiveLeft();
exeIdCard( FIV );
break;
case 5:
cmdSix.setImageResource( drawId );
setTxtvSixDown();
setTxtvSixUp();
setTxtvSixLeft();
exeIdCard( SIX );
break;
case 6:
cmdSeven.setImageResource( drawId );
setTxtvSevenRight();
setTxtvSevenUp();
exeIdCard( SEV );
break;
case 7:
cmdEight.setImageResource( drawId );
setTxtvEightLeft();
setTxtvEightRight();
setTxtvEightUp();
exeIdCard( EIG );
break;
case 8:
cmdNine.setImageResource( drawId );
setTxtvNineLeft();
setTxtvNineUp();
exeIdCard( NIN );
break;
default:
break;
}
}
}
// setzen des Besitztums einer Karte
public synchronized void exeIdCard( int fieldId )
{
if( isPlayersTurn == true )
{
idCard[fieldId] = 1;
}
if( isComputersTurn == true )
{
idCard[fieldId] = 2;
}
}
// Kartenstärke des jeweiligen Feldes auslesen
public int getFieldStats( int a, int b )
{
return fieldStats[a][b];
}
// das regeln des Besitzzums eines Feldes
public synchronized void checkOpponent()
{
// Fallüberprüfung der Felder 1-9
switch( fieldNumber )
{
case 0:
// bei Besitztum des eigenen Spielers
if( idCard[ONE] == 1 )
{
// wenn die angrenzende Karte der Gegner besitzt
if( idCard[TWO] == 2 )
{
// wenn die eigene Kartenstärke höher ist, als die der gegnerischen Karte
if( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) > getFieldStats( TWO, LEFT ) )
{
tempIdCard[TWO] = 1;
}
}
// wenn die angrenzende Karte der Gegner besitzt
if( idCard[FOU] == 2 )
{
// wenn die eigene Kartenstärke höher ist, als die der gegnerischen Karte
if( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) > getFieldStats( FOU, UP ) )
{
tempIdCard[FOU] = 1;
}
}
}
// bei Besitztum des Gegners
if( idCard[ONE] == 2 )
{
if( idCard[TWO] == 1 )
{
if( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) > getFieldStats( TWO, LEFT ) )
{
tempIdCard[TWO] = 2;
}
}
if( idCard[FOU] == 1 )
{
if( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) > getFieldStats( FOU, UP ) )
{
tempIdCard[FOU] = 2;
}
}
}
break;
case 1:
if( idCard[TWO] == 1 )
{
if( idCard[ONE] == 2 )
{
if( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) > getFieldStats( ONE, RIGHT ) )
{
tempIdCard[ONE] = 1;
}
}
if( idCard[FOU] == 2 )
{
if( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) > getFieldStats( FOU, UP ) )
{
tempIdCard[FOU] = 1;
}
}
}
if( idCard[TWO] == 2 )
{
if( idCard[TWO] == 1 )
{
if( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) > getFieldStats( TWO, LEFT ) )
{
tempIdCard[TWO] = 2;
}
}
if( idCard[FOU] == 1 )
{
if( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) > getFieldStats( FOU, UP ) )
{
tempIdCard[FOU] = 2;
}
}
}
break;
// noch nicht fertig
case 2:
if( idCard[1] == 2 )
{
}
if( idCard[5] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
case 3:
if( idCard[0] == 2 )
{
}
if( idCard[2] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
case 4:
if( idCard[0] == 2 )
{
}
if( idCard[2] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
case 5:
if( idCard[0] == 2 )
{
}
if( idCard[2] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
case 6:
if( idCard[0] == 2 )
{
}
if( idCard[2] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
case 7:
if( idCard[0] == 2 )
{
}
if( idCard[2] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
case 8:
if( idCard[0] == 2 )
{
}
if( idCard[2] == 2 )
{
}
if( idCard[4] == 2 )
{
}
break;
default:
break;
}
// under construction
for ( int a = 0; a < 9; a++ )
{
if( tempIdCard[a] != idCard[a] )
{
idCard[a] = tempIdCard[a];
if( a == fieldNumber )
{
if( idCard[fieldNumber] == 2 )
{
}
}
}
}
}
// die nächste Handkarte anzeigen
public synchronized void setMyCard()
{
if( isGameEnded == false )
{
cardMyHand.setNextHandCard();
isPressedNextCard = true;
saveDrawId();
isPressedNextCard = false;
cmdMyCard.setImageResource( drawId );
setTxtvMyCardDown();
setTxtvMyCardLeft();
setTxtvMyCardRight();
setTxtvMyCardUp();
// die aktuelle Handkartennummer anzeigen lassen
txtvCardNumber.setText( String.valueOf( cardMyHand.getIndexHand() + 1 ) );
}
}
// ändern der TextView
public synchronized void setTxtvOneRight()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvOneRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvOneRight.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvOneDown()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvOneDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvOneDown.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvTwoDown()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvTwoDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvTwoDown.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvTwoLeft()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvTwoLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvTwoLeft.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), LEFT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvTwoRight()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvTwoRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvTwoRight.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvThreeLeft()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvThreeLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvThreeLeft.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), LEFT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvThreeDown()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvThreeDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvThreeDown.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFourRight()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFourRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFourRight.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFourUp()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFourUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFourUp.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), UP ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFourDown()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFourDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFourDown.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFiveUp()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveUp.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), UP ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFiveLeft()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveLeft.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), LEFT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFiveDown()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveDown.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvFiveRight()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvFiveRight.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvSixUp()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSixUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSixUp.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), UP ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvSixDown()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSixDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSixDown.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), DOWN ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvSixLeft()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSixLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSixLeft.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), LEFT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvSevenUp()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSevenUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSevenUp.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), UP ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvSevenRight()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSevenRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvSevenRight.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvEightUp()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvEightUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvEightUp.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), UP ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvEightLeft()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvEightLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvEightLeft.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), LEFT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvEightRight()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvEightRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvEightRight.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), RIGHT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvNineUp()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvNineUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvNineUp.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), UP ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvNineLeft()
{
if( isPlayersTurn == true )
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvNineLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
} else
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvNineLeft.setText( String.valueOf( cardYourHand.getHandStats( cardYourHand.getIndexHand(), LEFT ) ) );
}
}
// ändern der TextView
public synchronized void setTxtvMyCardLeft()
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvMyCardLeft.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), LEFT ) ) );
}
// ändern der TextView
public synchronized void setTxtvMyCardUp()
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvMyCardUp.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), UP ) ) );
}
// ändern der TextView
public synchronized void setTxtvMyCardRight()
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvMyCardRight.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), RIGHT ) ) );
}
// ändern der TextView
public synchronized void setTxtvMyCardDown()
{
// Handkartenstärke von der richtigen Position lesen und zu einem String umwandeln
txtvMyCardDown.setText( String.valueOf( cardMyHand.getHandStats( cardMyHand.getIndexHand(), DOWN ) ) );
}
public synchronized boolean isGameEnded()
{
return isGameEnded;
}
public synchronized void setGameEnded( boolean isGameEnded )
{
this.isGameEnded = isGameEnded;
}
public synchronized boolean isPlayersTurn()
{
return isPlayersTurn;
}
public synchronized void setPlayersTurnFromTrueToFalse()
{
if( willChangePlayersTurn == true && isPlayersTurn == true )
{
System.out.println("player from true to false");
willChangePlayersTurn = !willChangePlayersTurn;
}
}
// den Zug des Gegners beenden und den eigenen einläuten
public synchronized void endComputersTurn()
{
if( willChangeComputersTurn == true && isComputersTurn == true )
{
willChangeComputersTurn = false;
isComputersTurn = false;
isPlayersTurn = true;
}
}
public synchronized void changeComputersTurn()
{
if( isPlayersTurn == true )
{
isComputersTurn = true;
isPlayersTurn = false;
}
}
public synchronized int getFieldNumber()
{
return fieldNumber;
}
public synchronized void setFieldNumber( int fieldNumber )
{
this.fieldNumber = fieldNumber;
}
public synchronized boolean getIsFree( int fieldNumber )
{
return isFree[fieldNumber];
}
public synchronized void setIsFree( int fieldNumber )
{
System.out.println( "freiheit umkehren" );
this.isFree[fieldNumber] = !isFree[fieldNumber];
}
public synchronized void setIsFree( boolean[] isFree )
{
this.isFree = isFree;
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment