This is the code of the game activity. - three-day project

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;
	}

}