diff --git a/src/engine/berofactoryinterface.h b/src/engine/berofactoryinterface.h
index fc935af9..49fdc52d 100644
--- a/src/engine/berofactoryinterface.h
+++ b/src/engine/berofactoryinterface.h
@@ -16,6 +16,10 @@
 	@author FThauer FHammer <webmaster@pokerth.net>
 */
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include <berointerface.h>
 
 class BeRoFactoryInterface{
@@ -27,6 +31,8 @@ public:
 
 	virtual BeRoInterface* createBeRoPreflop() =0;
 
+	virtual std::vector<boost::shared_ptr<BeRoInterface> > createBeRo() =0;
+
 };
 
 #endif
diff --git a/src/engine/berointerface.h b/src/engine/berointerface.h
index c075bbcb..a61a7c05 100644
--- a/src/engine/berointerface.h
+++ b/src/engine/berointerface.h
@@ -32,6 +32,8 @@ public:
 	virtual void resetFirstRun() =0;
 	virtual int getHighestCardsValue() const =0;
 
+	virtual void run() =0;
+
 	virtual void preflopRun() =0;
 	virtual void flopRun() =0;
 	virtual void turnRun() =0;
diff --git a/src/engine/handinterface.h b/src/engine/handinterface.h
index c8be2644..be3c38e7 100644
--- a/src/engine/handinterface.h
+++ b/src/engine/handinterface.h
@@ -20,6 +20,10 @@
 #ifndef HANDINTERFACE_H
 #define HANDINTERFACE_H
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include "guiinterface.h"
 #include "boardinterface.h"
 #include "playerinterface.h"
@@ -38,12 +42,12 @@ public:
 
 	virtual PlayerInterface** getPlayerArray() const =0;
 	virtual BoardInterface* getBoard() const =0;
-	virtual BeRoInterface* getPreflop() const =0;
-	virtual BeRoInterface* getFlop() const =0;
-	virtual BeRoInterface* getTurn() const =0;
-	virtual BeRoInterface* getRiver() const =0;
+	virtual boost::shared_ptr<BeRoInterface> getPreflop() const =0;
+	virtual boost::shared_ptr<BeRoInterface> getFlop() const =0;
+	virtual boost::shared_ptr<BeRoInterface> getTurn() const =0;
+	virtual boost::shared_ptr<BeRoInterface> getRiver() const =0;
 	virtual GuiInterface* getGuiInterface() const =0;
-	virtual BeRoInterface* getCurrentBeRo() const =0;
+	virtual boost::shared_ptr<BeRoInterface> getCurrentBeRo() const =0;
 
 	virtual void setMyID(int theValue) =0;
 	virtual int getMyID() const =0;
diff --git a/src/engine/local_engine/localbero.h b/src/engine/local_engine/localbero.h
index 50c0cf1d..a18adc7d 100644
--- a/src/engine/local_engine/localbero.h
+++ b/src/engine/local_engine/localbero.h
@@ -28,7 +28,8 @@ public:
 	int getHighestCardsValue() const {}
 	void setHighestCardsValue(int theValue) {}
 
-	//only until bero refactory is over
+	void run() {}
+	//only until bero refactoring is over
 	void preflopRun() {}
 	void flopRun() {}
 	void riverRun() {}
diff --git a/src/engine/local_engine/localberofactory.cpp b/src/engine/local_engine/localberofactory.cpp
index 6ee4c1da..18222e09 100644
--- a/src/engine/local_engine/localberofactory.cpp
+++ b/src/engine/local_engine/localberofactory.cpp
@@ -21,6 +21,24 @@ LocalBeRoFactory::LocalBeRoFactory (HandInterface* hi, int id, int aP, int dP, i
 LocalBeRoFactory::~LocalBeRoFactory()
 {}
 
+std::vector<boost::shared_ptr<BeRoInterface> > LocalBeRoFactory::createBeRo() {
+
+	std::vector<boost::shared_ptr<BeRoInterface> > myBeRo;
+
+	myBeRo.push_back(boost::shared_ptr<BeRoInterface>(new LocalBeRoPreflop(myHand, myID, actualQuantityPlayers, dealerPosition, smallBlind)));
+
+	myBeRo.push_back(boost::shared_ptr<BeRoInterface>(new LocalBeRoFlop(myHand, myID, actualQuantityPlayers, dealerPosition, smallBlind)));
+
+	myBeRo.push_back(boost::shared_ptr<BeRoInterface>(new LocalBeRoTurn(myHand, myID, actualQuantityPlayers, dealerPosition, smallBlind)));
+
+	myBeRo.push_back(boost::shared_ptr<BeRoInterface>(new LocalBeRoRiver(myHand, myID, actualQuantityPlayers, dealerPosition, smallBlind)));
+
+	myBeRo.push_back(boost::shared_ptr<BeRoInterface>(new LocalBeRoPostRiver(myHand, myID, actualQuantityPlayers, dealerPosition, smallBlind)));
+
+	return myBeRo;
+
+}
+
 BeRoInterface* LocalBeRoFactory::createBeRoPreflop() {
 
 	BeRoInterface* preflopBeRo = new LocalBeRoPreflop ( myHand, myID, actualQuantityPlayers, dealerPosition, smallBlind );
diff --git a/src/engine/local_engine/localberofactory.h b/src/engine/local_engine/localberofactory.h
index 779dbfee..5df7be77 100644
--- a/src/engine/local_engine/localberofactory.h
+++ b/src/engine/local_engine/localberofactory.h
@@ -14,6 +14,10 @@
 
 #include <istream>
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include <berofactoryinterface.h>
 #include <berointerface.h>
 #include <handinterface.h>
@@ -37,6 +41,9 @@ public:
 
 	BeRoInterface* createBeRoPreflop();
 
+	std::vector<boost::shared_ptr<BeRoInterface> > createBeRo();
+
+
 private:
 
     HandInterface* myHand;
diff --git a/src/engine/local_engine/localberoflop.cpp b/src/engine/local_engine/localberoflop.cpp
index e8d14f91..4194312c 100644
--- a/src/engine/local_engine/localberoflop.cpp
+++ b/src/engine/local_engine/localberoflop.cpp
@@ -45,7 +45,7 @@ LocalBeRoFlop::~LocalBeRoFlop()
 {
 }
 
-void LocalBeRoFlop::flopRun() {
+void LocalBeRoFlop::run() {
 
 	cout << "LocalBeroFlopRun!!!" << endl;
 	
diff --git a/src/engine/local_engine/localberoflop.h b/src/engine/local_engine/localberoflop.h
index 0c4b6425..4324b17d 100644
--- a/src/engine/local_engine/localberoflop.h
+++ b/src/engine/local_engine/localberoflop.h
@@ -49,7 +49,8 @@ public:
 
 	void resetFirstRun() { firstFlopRun = false; }
 
-	void flopRun();
+	void run();
+
 	void nextPlayer2();
 
 private:
diff --git a/src/engine/local_engine/localberopreflop.cpp b/src/engine/local_engine/localberopreflop.cpp
index 4a22aea5..3b056320 100644
--- a/src/engine/local_engine/localberopreflop.cpp
+++ b/src/engine/local_engine/localberopreflop.cpp
@@ -50,7 +50,7 @@ LocalBeRoPreflop::~LocalBeRoPreflop()
 
 }
 
-void LocalBeRoPreflop::preflopRun() {
+void LocalBeRoPreflop::run() {
 
 	cout << "LocalBeroPreflopRun!!!" << endl;
 
diff --git a/src/engine/local_engine/localberopreflop.h b/src/engine/local_engine/localberopreflop.h
index 74eababc..44b865dd 100644
--- a/src/engine/local_engine/localberopreflop.h
+++ b/src/engine/local_engine/localberopreflop.h
@@ -37,7 +37,7 @@ public:
 	void setHighestSet(int theValue) { highestSet = theValue; }
 	int getHighestSet() const { return highestSet;}
 
-	void preflopRun();
+	void run();
 	void nextPlayer2(); 
 	
 
diff --git a/src/engine/local_engine/localberoriver.cpp b/src/engine/local_engine/localberoriver.cpp
index 00c735f9..7189ff31 100644
--- a/src/engine/local_engine/localberoriver.cpp
+++ b/src/engine/local_engine/localberoriver.cpp
@@ -45,7 +45,7 @@ LocalBeRoRiver::~LocalBeRoRiver()
 }
 
 
-void LocalBeRoRiver::riverRun() {
+void LocalBeRoRiver::run() {
 
 	cout << "LocalBeroRiverRun!!!" << endl;
 	int i;
diff --git a/src/engine/local_engine/localberoriver.h b/src/engine/local_engine/localberoriver.h
index 2679ba7e..76fb26f5 100644
--- a/src/engine/local_engine/localberoriver.h
+++ b/src/engine/local_engine/localberoriver.h
@@ -51,7 +51,7 @@ public:
 
 	void resetFirstRun() { firstRiverRun = false; }
 
-	void riverRun();
+	void run();
 	void postRiverRun();
 	void nextPlayer2();
 	void distributePot();
diff --git a/src/engine/local_engine/localberoturn.cpp b/src/engine/local_engine/localberoturn.cpp
index e8bd5b2d..a7fe85b8 100644
--- a/src/engine/local_engine/localberoturn.cpp
+++ b/src/engine/local_engine/localberoturn.cpp
@@ -46,7 +46,7 @@ LocalBeRoTurn::~LocalBeRoTurn()
 }
 
 
-void LocalBeRoTurn::turnRun() {
+void LocalBeRoTurn::run() {
 
 	cout << "LocalBeroTurnRun!!!" << endl;
 	int i;
diff --git a/src/engine/local_engine/localberoturn.h b/src/engine/local_engine/localberoturn.h
index 8af1ec06..627a18ce 100644
--- a/src/engine/local_engine/localberoturn.h
+++ b/src/engine/local_engine/localberoturn.h
@@ -48,7 +48,7 @@ public:
 	void resetFirstRun() { firstTurnRun = false; }
 
 	void nextPlayer2();
-	void turnRun();
+	void run();
 
 private:
 
diff --git a/src/engine/local_engine/localhand.cpp b/src/engine/local_engine/localhand.cpp
index f535bfb1..2a9803f3 100755
--- a/src/engine/local_engine/localhand.cpp
+++ b/src/engine/local_engine/localhand.cpp
@@ -27,12 +27,11 @@
 using namespace std;
 
 LocalHand::LocalHand(boost::shared_ptr<EngineFactory> f, GuiInterface *g, BoardInterface *b, PlayerInterface **p, int id, int sP, int aP, int dP, int sB,int sC)
-: myFactory(f), myGui(g),  myBoard(b), playerArray(p), myPreflop(0), myFlop(0), myTurn(0), myRiver(0),
-  myID(id), actualQuantityPlayers(aP), startQuantityPlayers(sP), dealerPosition(dP), actualRound(0),
-  smallBlind(sB), startCash(sC), activePlayersCounter(aP), lastPlayersTurn(0), allInCondition(0),
+: myFactory(f), myBeRo(0), myGui(g),  myBoard(b), playerArray(p), myID(id), actualQuantityPlayers(aP), startQuantityPlayers(sP), dealerPosition(dP), actualRound(0), smallBlind(sB), startCash(sC), activePlayersCounter(aP), lastPlayersTurn(0), allInCondition(0),
   cardsShown(false), bettingRoundsPlayed(0)
 {
 
+
 	int i, j, k;
 
 	CardsValue myCardsValue;
@@ -166,33 +165,17 @@ LocalHand::LocalHand(boost::shared_ptr<EngineFactory> f, GuiInterface *g, BoardI
 	// Dealer, SB, BB bestimmen
 	assignButtons();
 
-	// Preflop, Flop, Turn und River erstellen
-// 	myPreflop =  myFactory->createPreflop(this, myID, actualQuantityPlayers, dealerPosition, smallBlind);
-// 	myFlop = myFactory->createFlop(this, myID, actualQuantityPlayers, dealerPosition, smallBlind);
-// 	myTurn = myFactory->createTurn(this, myID, actualQuantityPlayers, dealerPosition, smallBlind);
-// 	myRiver = myFactory->createRiver(this, myID, actualQuantityPlayers, dealerPosition, smallBlind);
-
 	myBeRoFactory = myFactory->createBeRoFactory(this, myID, actualQuantityPlayers, dealerPosition, smallBlind);
 
 	int currentRound = actualRound; // for Lothar ;-)
 
-	myBeRo = myBeRoFactory->createBeRoPreflop();
+	myBeRo = myBeRoFactory->createBeRo();
 }
 
 
 
 LocalHand::~LocalHand()
 {
-
-	delete myPreflop;
-	myPreflop = 0;
-	delete myFlop;
-	myFlop = 0;
-	delete myTurn;
-	myTurn = 0;
-	delete myRiver;
-	myRiver = 0;
-
 }
 
 void LocalHand::start() {
@@ -327,17 +310,7 @@ void LocalHand::switchRounds() {
 				// Spieler ermitteln, der noch nicht All In ist
 				if(playerArray[i]->getMyAction() != 1 && playerArray[i]->getMyAction() != 6 && playerArray[i]->getMyActiveStatus() == 1) {	
 					tempHighestSet = 0;
-					switch (actualRound) {
-						case 0: {tempHighestSet = myBeRo->getHighestSet();}
-						break;
-						case 1: {tempHighestSet = myBeRo->getHighestSet();}
-						break;
-						case 2: {tempHighestSet = myBeRo->getHighestSet();}
-						break;
-						case 3: {tempHighestSet = myBeRo->getHighestSet();}
-						break;
-						default: {}	
-					}
+					tempHighestSet = myBeRo[actualRound]->getHighestSet();
 // 					cout << "tempHighestSet: " << tempHighestSet << "playerArray[i]->getMySet(): " << playerArray[i]->getMySet() << endl;
 					
 					if(playerArray[i]->getMySet() >= tempHighestSet) {
@@ -383,8 +356,6 @@ void LocalHand::switchRounds() {
 // 
 
 	int currentRound = actualRound;
-	
-	myBeRo = myBeRoFactory->switchRounds(myBeRo, currentRound);
 
 // 	cout << "NextPlayerSpeed2 start" << endl;
 	switch(actualRound) {
diff --git a/src/engine/local_engine/localhand.h b/src/engine/local_engine/localhand.h
index 52e6b704..f94baf47 100755
--- a/src/engine/local_engine/localhand.h
+++ b/src/engine/local_engine/localhand.h
@@ -20,15 +20,15 @@
 #ifndef LOCALHAND_H
 #define LOCALHAND_H
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include <enginefactory.h>
 #include <guiinterface.h>
 #include <boardinterface.h>
 #include <playerinterface.h>
 #include <handinterface.h>
-#include <preflopinterface.h>
-#include <flopinterface.h>
-#include <turninterface.h>
-#include <riverinterface.h>
 #include <berointerface.h>
 #include <berofactoryinterface.h>
 
@@ -42,12 +42,12 @@ public:
 
 	PlayerInterface** getPlayerArray() const { return playerArray; }
 	BoardInterface* getBoard() const { return myBoard; }
-	BeRoInterface* getPreflop() const { return myBeRo; }
-	BeRoInterface* getFlop() const { return myBeRo; }
-	BeRoInterface* getTurn() const { return myBeRo; }
-	BeRoInterface* getRiver() const { return myBeRo; }
+	boost::shared_ptr<BeRoInterface> getPreflop() const { return myBeRo[actualRound]; }
+	boost::shared_ptr<BeRoInterface> getFlop() const { return myBeRo[actualRound]; }
+	boost::shared_ptr<BeRoInterface> getTurn() const { return myBeRo[actualRound]; }
+	boost::shared_ptr<BeRoInterface> getRiver() const { return myBeRo[actualRound]; }
 	GuiInterface* getGuiInterface() const { return myGui; }
-	BeRoInterface* getCurrentBeRo() const { return myBeRo; }
+	boost::shared_ptr<BeRoInterface> getCurrentBeRo() const { return myBeRo[actualRound]; }
 
 	void setMyID(int theValue) { myID = theValue; }
 	int getMyID() const { return myID; }
@@ -96,12 +96,8 @@ private:
 	GuiInterface *myGui;
 	BoardInterface *myBoard;
 	PlayerInterface **playerArray;
-	PreflopInterface *myPreflop;
-	FlopInterface *myFlop;
-	TurnInterface *myTurn;
-	RiverInterface *myRiver;
-	BeRoInterface *myBeRo;
 	BeRoFactoryInterface *myBeRoFactory;
+	std::vector<boost::shared_ptr<BeRoInterface> > myBeRo;
 
 	int myID;
 	int actualQuantityPlayers;
diff --git a/src/engine/network_engine/clientbero.h b/src/engine/network_engine/clientbero.h
index 85608c82..49297735 100644
--- a/src/engine/network_engine/clientbero.h
+++ b/src/engine/network_engine/clientbero.h
@@ -12,6 +12,10 @@
 #ifndef CLIENTBERO_H
 #define CLIENTBERO_H
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include "berointerface.h"
 
 
@@ -26,6 +30,8 @@ public:
 
 	int getMyBeRoID() const { return myBeRoID; }
 
+	void run() {}
+
 protected:
 
 	int myBeRoID;
diff --git a/src/engine/network_engine/clientberofactory.cpp b/src/engine/network_engine/clientberofactory.cpp
index 270d3722..4624854e 100644
--- a/src/engine/network_engine/clientberofactory.cpp
+++ b/src/engine/network_engine/clientberofactory.cpp
@@ -22,6 +22,19 @@ ClientBeRoFactory::~ClientBeRoFactory()
 {
 }
 
+std::vector<boost::shared_ptr<BeRoInterface> > ClientBeRoFactory::createBeRo()
+{
+	std::vector<boost::shared_ptr<BeRoInterface> > bettingRounds;
+//         bettingRounds.push_back(boost::shared_ptr<BeRoInterface>(new
+// LocalBeRoPreflop(...)));
+//         bettingRounds.push_back(boost::shared_ptr<BeRoInterface>(new
+// LocalBeRoFlop(...)));
+// 
+//         ...
+	return bettingRounds;
+}
+
+
 
 BeRoInterface* ClientBeRoFactory::switchRounds(BeRoInterface* currentBeRo, int currentRound) { return NULL;}
 
diff --git a/src/engine/network_engine/clientberofactory.h b/src/engine/network_engine/clientberofactory.h
index bd50d68b..fb7b1c3f 100644
--- a/src/engine/network_engine/clientberofactory.h
+++ b/src/engine/network_engine/clientberofactory.h
@@ -12,6 +12,10 @@
 #ifndef CLIENTBEROFACTORY_H
 #define CLIENTBEROFACTORY_H
 
+#include <vector>
+
+#include <boost/shared_ptr.hpp>
+
 #include <berofactoryinterface.h>
 #include <handinterface.h>
 
@@ -29,6 +33,8 @@ public:
 
 	BeRoInterface* createBeRoPreflop();
 
+	std::vector<boost::shared_ptr<BeRoInterface> > createBeRo();
+
 };
 
 #endif
diff --git a/src/engine/network_engine/clienthand.cpp b/src/engine/network_engine/clienthand.cpp
index 099e1cfd..80c1cfb7 100644
--- a/src/engine/network_engine/clienthand.cpp
+++ b/src/engine/network_engine/clienthand.cpp
@@ -84,34 +84,34 @@ ClientHand::getBoard() const
 	return myBoard;
 }
 
-BeRoInterface*
+boost::shared_ptr<BeRoInterface>
 ClientHand::getPreflop() const
 {
-	return myBeRo;
+	return myBeRo[actualRound];
 }
 
-BeRoInterface*
+boost::shared_ptr<BeRoInterface>
 ClientHand::getFlop() const
 {
-	return myBeRo;
+	return myBeRo[actualRound];
 }
 
-BeRoInterface*
+boost::shared_ptr<BeRoInterface>
 ClientHand::getTurn() const
 {
-	return myBeRo;
+	return myBeRo[actualRound];
 }
 
-BeRoInterface*
+boost::shared_ptr<BeRoInterface>
 ClientHand::getRiver() const
 {
-	return myBeRo;
+	return myBeRo[actualRound];
 }
 
-BeRoInterface*
+boost::shared_ptr<BeRoInterface>
 ClientHand::getCurrentBeRo() const
 {
-	return myBeRo;
+	return myBeRo[actualRound];
 }
 
 
diff --git a/src/engine/network_engine/clienthand.h b/src/engine/network_engine/clienthand.h
index 06dfe30f..d786fa93 100644
--- a/src/engine/network_engine/clienthand.h
+++ b/src/engine/network_engine/clienthand.h
@@ -32,91 +32,94 @@
 
 #include <boost/thread.hpp>
 
+#include <vector>
+
 class ClientHand : public HandInterface
 {
-public:
-	ClientHand(boost::shared_ptr<EngineFactory> f, GuiInterface*, BoardInterface*, PlayerInterface**, int, int, int, int, int, int);
-	~ClientHand();
+	public:
+		ClientHand ( boost::shared_ptr<EngineFactory> f, GuiInterface*, BoardInterface*, PlayerInterface**, int, int, int, int, int, int );
+		~ClientHand();
 
-	void start();
+		void start();
 
-	PlayerInterface** getPlayerArray() const;
-	BoardInterface* getBoard() const;
-	BeRoInterface* getPreflop() const;
-	BeRoInterface* getFlop() const;
-	BeRoInterface* getTurn() const;
-	BeRoInterface* getRiver() const;
-	GuiInterface* getGuiInterface() const;
-	BeRoInterface* getCurrentBeRo() const;
+		PlayerInterface** getPlayerArray() const;
+		BoardInterface* getBoard() const;
+		boost::shared_ptr<BeRoInterface> getPreflop() const;
+		boost::shared_ptr<BeRoInterface> getFlop() const;
+		boost::shared_ptr<BeRoInterface> getTurn() const;
+		boost::shared_ptr<BeRoInterface> getRiver() const;
+		GuiInterface* getGuiInterface() const;
+		boost::shared_ptr<BeRoInterface> getCurrentBeRo() const;
 
-	void setMyID(int theValue);
-	int getMyID() const;
-	
-	void setActualQuantityPlayers(int theValue);
-	int getActualQuantityPlayers() const;
+		void setMyID ( int theValue );
+		int getMyID() const;
 
-	void setStartQuantityPlayers(int theValue);
-	int getStartQuantityPlayers() const;
+		void setActualQuantityPlayers ( int theValue );
+		int getActualQuantityPlayers() const;
 
-	void setActualRound(int theValue);
-	int getActualRound() const;
+		void setStartQuantityPlayers ( int theValue );
+		int getStartQuantityPlayers() const;
 
-	void setDealerPosition(int theValue);
-	int getDealerPosition() const;
+		void setActualRound ( int theValue );
+		int getActualRound() const;
 
-	void setSmallBlind(int theValue);
-	int getSmallBlind() const;
+		void setDealerPosition ( int theValue );
+		int getDealerPosition() const;
 
-	void setAllInCondition(bool theValue);
-	bool getAllInCondition() const;
+		void setSmallBlind ( int theValue );
+		int getSmallBlind() const;
 
-	void setStartCash(int theValue);
-	int getStartCash() const;
+		void setAllInCondition ( bool theValue );
+		bool getAllInCondition() const;
 
-	void setActivePlayersCounter(int theValue);
-	int getActivePlayersCounter() const;
-	
-	void setBettingRoundsPlayed(int theValue);
-	int getBettingRoundsPlayed() const;
+		void setStartCash ( int theValue );
+		int getStartCash() const;
 
-	void setLastPlayersTurn(int theValue);
-	int getLastPlayersTurn() const;
+		void setActivePlayersCounter ( int theValue );
+		int getActivePlayersCounter() const;
 
-	void setCardsShown(bool theValue);
-	bool getCardsShown() const;
+		void setBettingRoundsPlayed ( int theValue );
+		int getBettingRoundsPlayed() const;
 
-	void switchRounds();
+		void setLastPlayersTurn ( int theValue );
+		int getLastPlayersTurn() const;
+
+		void setCardsShown ( bool theValue );
+		bool getCardsShown() const;
+
+		void switchRounds();
 
 
-private:
-	mutable boost::recursive_mutex m_syncMutex;
+	private:
+		mutable boost::recursive_mutex m_syncMutex;
 
-	boost::shared_ptr<EngineFactory> myFactory;
-	GuiInterface *myGui;
-	BoardInterface *myBoard;
-	PlayerInterface **playerArray;
-	PreflopInterface *myPreflop;
-	FlopInterface *myFlop;
-	TurnInterface *myTurn;
-	RiverInterface *myRiver;
-	BeRoInterface *myBeRo;
+		boost::shared_ptr<EngineFactory> myFactory;
+		GuiInterface *myGui;
+		BoardInterface *myBoard;
+		PlayerInterface **playerArray;
+		PreflopInterface *myPreflop;
+		FlopInterface *myFlop;
+		TurnInterface *myTurn;
+		RiverInterface *myRiver;
+		BeRoInterface *myOldBeRo;
+		std::vector<boost::shared_ptr<BeRoInterface> > myBeRo;
 
-	int myID;
-	int actualQuantityPlayers;
-	int startQuantityPlayers;
-	int dealerPosition; // -1 -> neutral
-	int actualRound; //0 = preflop, 1 = flop, 2 = turn, 3 = river
-	int smallBlind;
-	int startCash;
-	int activePlayersCounter;
+		int myID;
+		int actualQuantityPlayers;
+		int startQuantityPlayers;
+		int dealerPosition; // -1 -> neutral
+		int actualRound; //0 = preflop, 1 = flop, 2 = turn, 3 = river
+		int smallBlind;
+		int startCash;
+		int activePlayersCounter;
 
-	int lastPlayersTurn;
+		int lastPlayersTurn;
 
-	bool allInCondition;
-	bool cardsShown;
+		bool allInCondition;
+		bool cardsShown;
 
-	// hier steht bis zu welcher bettingRound der human player gespielt hat: 0 - nur Preflop, 1 - bis Flop, ...
-	int bettingRoundsPlayed;
+		// hier steht bis zu welcher bettingRound der human player gespielt hat: 0 - nur Preflop, 1 - bis Flop, ...
+		int bettingRoundsPlayed;
 };
 
 #endif
diff --git a/src/gui/qt/mainwindow/mainwindowimpl.cpp b/src/gui/qt/mainwindow/mainwindowimpl.cpp
index a2d94124..0b8211fe 100755
--- a/src/gui/qt/mainwindow/mainwindowimpl.cpp
+++ b/src/gui/qt/mainwindow/mainwindowimpl.cpp
@@ -1814,26 +1814,26 @@ void mainWindowImpl::nextPlayerAnimation() {
 }
 
 void mainWindowImpl::preflopAnimation1() { preflopAnimation1Timer->start(nextPlayerSpeed2); }
-void mainWindowImpl::preflopAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getPreflop()->preflopRun(); }
+void mainWindowImpl::preflopAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getPreflop()->run(); }
 
 void mainWindowImpl::preflopAnimation2() { preflopAnimation2Timer->start(preflopNextPlayerSpeed); }
 void mainWindowImpl::preflopAnimation2Action() { mySession->getCurrentGame()->getCurrentHand()->getPreflop()->nextPlayer2(); }
 
 
 void mainWindowImpl::flopAnimation1() { flopAnimation1Timer->start(nextPlayerSpeed2); }
-void mainWindowImpl::flopAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getFlop()->flopRun(); }
+void mainWindowImpl::flopAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getFlop()->run(); }
 
 void mainWindowImpl::flopAnimation2() { flopAnimation2Timer->start(nextPlayerSpeed3); }
 void mainWindowImpl::flopAnimation2Action() { mySession->getCurrentGame()->getCurrentHand()->getFlop()->nextPlayer2(); }
 
 void mainWindowImpl::turnAnimation1() { turnAnimation1Timer->start(nextPlayerSpeed2); }
-void mainWindowImpl::turnAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getTurn()->turnRun(); }
+void mainWindowImpl::turnAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getTurn()->run(); }
 
 void mainWindowImpl::turnAnimation2() { turnAnimation2Timer->start(nextPlayerSpeed3); }
 void mainWindowImpl::turnAnimation2Action() { mySession->getCurrentGame()->getCurrentHand()->getTurn()->nextPlayer2(); }
 
 void mainWindowImpl::riverAnimation1() { riverAnimation1Timer->start(nextPlayerSpeed2); }
-void mainWindowImpl::riverAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getRiver()->riverRun(); }
+void mainWindowImpl::riverAnimation1Action() { mySession->getCurrentGame()->getCurrentHand()->getRiver()->run(); }
 
 void mainWindowImpl::riverAnimation2() { riverAnimation2Timer->start(nextPlayerSpeed3); }
 void mainWindowImpl::riverAnimation2Action() { mySession->getCurrentGame()->getCurrentHand()->getRiver()->nextPlayer2(); }
@@ -1944,7 +1944,6 @@ void mainWindowImpl::postRiverRunAnimation3() {
 
 	int i;
 	HandInterface *currentHand = mySession->getCurrentGame()->getCurrentHand();
-	cout << currentHand->getRiver()->getMyBeRoID() << endl;
 	//Alle Winner erhellen und "Winner" schreiben
 	for(i=0; i<MAX_NUMBER_OF_PLAYERS; i++) {
 		if(currentHand->getPlayerArray()[i]->getMyActiveStatus() && currentHand->getPlayerArray()[i]->getMyAction() != 1 && currentHand->getPlayerArray()[i]->getMyCardsValueInt() == currentHand->getRiver()->getHighestCardsValue() ) {