sco/pokerth
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

BeRo refactoring

Browse Source
This commit is contained in:
doitux
2007-08-07 13:07:39 +00:00
parent 2f76bb82f9
commit c34f683c41
24 changed files with 425 additions and 1337 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/engine/network_engine/clientflop.h
+84 -84
View File
@@ -1,84 +1,84 @@
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTFLOP_H
#define CLIENTFLOP_H
#include "berointerface.h"
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoFlop : public BeRoInterface
{
public:
ClientBeRoFlop(HandInterface*, int, int, int, int);
~ClientBeRoFlop();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setFirstFlopRound(bool theValue);
bool getFirstFlopRound() const;
void setSmallBlindPosition(int theValue);
int getSmallBlindPosition() const;
void setSmallBlind(int theValue);
int getSmallBlind() const;
void setHighestCardsValue(int theValue) {}
int getHighestCardsValue() const {return 0;}
void resetFirstRun();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer2() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int smallBlindPosition;
int smallBlind;
int highestSet;
bool firstFlopRun;
bool firstFlopRound;
int playersTurn;
};
#endif
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTFLOP_H
#define CLIENTFLOP_H
#include "berointerface.h"
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoFlop : public BeRoInterface
{
public:
ClientBeRoFlop(HandInterface*, int, int, int, int);
~ClientBeRoFlop();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setFirstFlopRound(bool theValue);
bool getFirstFlopRound() const;
void setSmallBlindPosition(int theValue);
int getSmallBlindPosition() const;
void setSmallBlind(int theValue);
int getSmallBlind() const;
void setHighestCardsValue(int theValue) {}
int getHighestCardsValue() const {return 0;}
void resetFirstRun();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int smallBlindPosition;
int smallBlind;
int highestSet;
bool firstFlopRun;
bool firstFlopRound;
int playersTurn;
};
#endif
src/engine/network_engine/clientpreflop.h
+75 -75
View File
@@ -1,75 +1,75 @@
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTPREFLOP_H
#define CLIENTPREFLOP_H
#include <berointerface.h>
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoPreflop : public BeRoInterface{
public:
ClientBeRoPreflop(HandInterface*, int, int, int, int);
~ClientBeRoPreflop();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setHighestCardsValue(int theValue) {}
int getHighestCardsValue() const {return 0;}
void resetFirstRun();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer2() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int bigBlindPosition;
int smallBlind;
int highestSet;
bool preflopFirstRound;
int playersTurn;
};
#endif
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTPREFLOP_H
#define CLIENTPREFLOP_H
#include <berointerface.h>
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoPreflop : public BeRoInterface{
public:
ClientBeRoPreflop(HandInterface*, int, int, int, int);
~ClientBeRoPreflop();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setHighestCardsValue(int theValue) {}
int getHighestCardsValue() const {return 0;}
void resetFirstRun();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int bigBlindPosition;
int smallBlind;
int highestSet;
bool preflopFirstRound;
int playersTurn;
};
#endif
src/engine/network_engine/clientriver.h
+89 -89
View File
@@ -1,89 +1,89 @@
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTRIVER_H
#define CLIENTRIVER_H
#include <berointerface.h>
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoRiver : public BeRoInterface{
public:
ClientBeRoRiver(HandInterface*, int, int, int, int);
~ClientBeRoRiver();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setFirstRiverRound(bool theValue);
bool getFirstRiverRound() const;
void setSmallBlindPosition(int theValue);
int getSmallBlindPosition() const;
void setSmallBlind(int theValue);
int getSmallBlind() const;
void setHighestCardsValue(int theValue);
int getHighestCardsValue() const;
void resetFirstRun();
void distributePot();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer2() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int smallBlindPosition;
int smallBlind;
int highestSet;
bool firstRiverRun;
bool firstRiverRound;
int playersTurn;
int highestCardsValue;
};
#endif
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTRIVER_H
#define CLIENTRIVER_H
#include <berointerface.h>
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoRiver : public BeRoInterface{
public:
ClientBeRoRiver(HandInterface*, int, int, int, int);
~ClientBeRoRiver();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setFirstRiverRound(bool theValue);
bool getFirstRiverRound() const;
void setSmallBlindPosition(int theValue);
int getSmallBlindPosition() const;
void setSmallBlind(int theValue);
int getSmallBlind() const;
void setHighestCardsValue(int theValue);
int getHighestCardsValue() const;
void resetFirstRun();
void distributePot();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int smallBlindPosition;
int smallBlind;
int highestSet;
bool firstRiverRun;
bool firstRiverRound;
int playersTurn;
int highestCardsValue;
};
#endif
src/engine/network_engine/clientturn.h
+83 -83
View File
@@ -1,83 +1,83 @@
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTTURN_H
#define CLIENTTURN_H
#include <berointerface.h>
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoTurn : public BeRoInterface{
public:
ClientBeRoTurn(HandInterface*, int, int, int, int);
~ClientBeRoTurn();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setFirstTurnRound(bool theValue);
bool getFirstTurnRound() const;
void setSmallBlindPosition(int theValue);
int getSmallBlindPosition() const;
void setSmallBlind(int theValue);
int getSmallBlind() const;
void setHighestCardsValue(int theValue) {}
int getHighestCardsValue() const {return 0;}
void resetFirstRun();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer2() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int smallBlindPosition;
int smallBlind;
int highestSet;
bool firstTurnRun;
bool firstTurnRound;
int playersTurn;
};
#endif
/***************************************************************************
* Copyright (C) 2007 by Lothar May *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef CLIENTTURN_H
#define CLIENTTURN_H
#include <berointerface.h>
#include <boost/thread.hpp>
class HandInterface;
class ClientBeRoTurn : public BeRoInterface{
public:
ClientBeRoTurn(HandInterface*, int, int, int, int);
~ClientBeRoTurn();
int getMyBeRoID() const;
void setPlayersTurn(int theValue);
int getPlayersTurn() const;
void setHighestSet(int theValue);
int getHighestSet() const;
void setFirstTurnRound(bool theValue);
bool getFirstTurnRound() const;
void setSmallBlindPosition(int theValue);
int getSmallBlindPosition() const;
void setSmallBlind(int theValue);
int getSmallBlind() const;
void setHighestCardsValue(int theValue) {}
int getHighestCardsValue() const {return 0;}
void resetFirstRun();
void run();
void preflopRun() {}
void flopRun() {}
void turnRun() {}
void riverRun() {}
void postRiverRun() {}
void nextPlayer() {}
private:
mutable boost::recursive_mutex m_syncMutex;
HandInterface *myHand;
int myID;
int actualQuantityPlayers;
int dealerPosition;
int smallBlindPosition;
int smallBlind;
int highestSet;
bool firstTurnRun;
bool firstTurnRound;
int playersTurn;
};
#endif