2024-05-31 12:10:00 +01:00
|
|
|
#include "PlayerAreaModel.h"
|
2024-06-08 10:58:34 +01:00
|
|
|
#include <cstdint>
|
2024-05-31 12:10:00 +01:00
|
|
|
|
|
|
|
PlayerAreaModel::PlayerAreaModel(QObject *parent)
|
|
|
|
{
|
2024-06-02 21:13:43 +01:00
|
|
|
Player defaultValues;
|
2024-06-09 13:25:58 +01:00
|
|
|
Bet defaultBets;
|
2024-06-02 21:13:43 +01:00
|
|
|
|
2024-06-07 10:06:28 +01:00
|
|
|
for(int i = 0; i < 8; i++){
|
2024-06-02 21:13:43 +01:00
|
|
|
players.append(defaultValues);
|
2024-06-09 13:25:58 +01:00
|
|
|
for (int ii = 0; ii < 2; ii++) {
|
|
|
|
players[i].bets.append(defaultBets);
|
|
|
|
}
|
2024-06-01 13:19:32 +01:00
|
|
|
}
|
2024-06-09 13:25:58 +01:00
|
|
|
/* This is set to avoid segfaults if the starting value is out of bounds */
|
2024-06-08 12:55:29 +01:00
|
|
|
focusedPlayer_ = 1;
|
2024-05-31 12:10:00 +01:00
|
|
|
}
|
|
|
|
|
2024-06-02 21:13:43 +01:00
|
|
|
uint PlayerAreaModel::focusedPlayer()
|
|
|
|
{
|
|
|
|
return focusedPlayer_;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerAreaModel::setFocusedPlayer(int n)
|
|
|
|
{
|
|
|
|
focusedPlayer_ = n;
|
|
|
|
Player player = players.at(n);
|
2024-06-09 13:25:58 +01:00
|
|
|
BetType b1 = player.bets[0].betType;
|
|
|
|
BetType b2 = player.bets[1].betType;
|
|
|
|
uint n1 = player.bets[0].betSpot;
|
|
|
|
uint n2 = player.bets[1].betSpot;
|
2024-06-02 21:13:43 +01:00
|
|
|
emit focusedPlayerChanged(b1, n1, b2, n2);
|
|
|
|
}
|
|
|
|
|
2024-06-01 13:19:32 +01:00
|
|
|
QString PlayerAreaModel::getPlayerName(int n)
|
2024-05-31 12:10:00 +01:00
|
|
|
{
|
2024-06-02 21:13:43 +01:00
|
|
|
return players.at(n).playerName;
|
2024-05-31 12:10:00 +01:00
|
|
|
}
|
|
|
|
|
2024-05-31 12:34:47 +01:00
|
|
|
void PlayerAreaModel::setPlayerName(QString s, int n)
|
2024-05-31 12:10:00 +01:00
|
|
|
{
|
2024-06-08 00:41:25 +01:00
|
|
|
players[n].playerName = s;
|
2024-05-31 12:10:00 +01:00
|
|
|
}
|
2024-06-01 07:11:29 +01:00
|
|
|
|
2024-06-02 21:13:43 +01:00
|
|
|
void PlayerAreaModel::bet(BetType b, int n, int bet)
|
2024-06-01 13:19:32 +01:00
|
|
|
{
|
2024-06-02 21:13:43 +01:00
|
|
|
Player *player = &players[focusedPlayer_];
|
|
|
|
|
2024-06-09 13:25:58 +01:00
|
|
|
for (int i = 0; i < 2; i++) {
|
|
|
|
if (player->bets[i].betType == NONE) {
|
|
|
|
player->bets[i].betType = b;
|
|
|
|
player->bets[i].betValue = bet;
|
|
|
|
player->bets[i].betSpot = n;
|
|
|
|
/*
|
|
|
|
* This is needed because the visual roulette board is inverted from the
|
|
|
|
* actual QML grid we use to represent it.
|
|
|
|
* Here we use 35 because the grid is 0-indexed, but later we use 36 when it is 1-indexed.
|
|
|
|
*/
|
|
|
|
if (b == SINGLE && n <= 35) {
|
|
|
|
n = 35 - n;
|
|
|
|
}
|
|
|
|
emit betChanged(b, n, bet);
|
|
|
|
break;
|
2024-06-07 08:31:38 +01:00
|
|
|
}
|
2024-06-02 21:13:43 +01:00
|
|
|
}
|
2024-06-01 13:19:32 +01:00
|
|
|
}
|
|
|
|
|
2024-06-02 21:13:43 +01:00
|
|
|
void PlayerAreaModel::removeBet(BetType b, int n)
|
2024-06-01 07:11:29 +01:00
|
|
|
{
|
2024-06-02 21:13:43 +01:00
|
|
|
Player *player = &players[focusedPlayer_];
|
2024-06-09 13:25:58 +01:00
|
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
|
|
if (player->bets[i].betType == b && player->bets[i].betSpot == n) {
|
|
|
|
player->bets[i].betType = NONE;
|
|
|
|
if (b == SINGLE && n <= 35) {
|
|
|
|
n = 35 - n;
|
|
|
|
}
|
|
|
|
emit betRemoved(b, n);
|
2024-06-07 08:31:38 +01:00
|
|
|
}
|
2024-06-02 21:13:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2024-06-07 18:03:22 +01:00
|
|
|
void PlayerAreaModel::cancelBet(BetType b, int n)
|
|
|
|
{
|
2024-06-04 21:10:39 +01:00
|
|
|
emit betCanceled(b, n);
|
2024-06-01 07:11:29 +01:00
|
|
|
}
|
2024-06-02 21:13:43 +01:00
|
|
|
|
2024-06-07 18:03:22 +01:00
|
|
|
void PlayerAreaModel::payout()
|
|
|
|
{
|
2024-06-09 13:25:58 +01:00
|
|
|
if (players.at(0).bets[0].betType == NONE) {
|
2024-06-08 12:55:29 +01:00
|
|
|
fprintf(stderr, "Select where the ball landed\n");
|
2024-06-08 00:41:25 +01:00
|
|
|
} else {
|
2024-06-09 13:25:58 +01:00
|
|
|
int rollSpot = 36 - players.at(0).bets[0].betSpot;
|
2024-06-08 00:41:25 +01:00
|
|
|
|
|
|
|
for (int i = 1; i < 8; i++) {
|
|
|
|
players[i].payout = 0;
|
2024-06-09 13:25:58 +01:00
|
|
|
for (int ii = 0; ii < 2; ii++) {
|
|
|
|
int betType = players.at(i).bets[ii].betType;
|
|
|
|
int betSpot;
|
2024-06-08 10:58:34 +01:00
|
|
|
|
2024-06-09 13:25:58 +01:00
|
|
|
if (betType != NONE) {
|
|
|
|
betSpot = players.at(i).bets[ii].betSpot;
|
2024-06-08 10:58:34 +01:00
|
|
|
|
2024-06-09 13:25:58 +01:00
|
|
|
if (betType == SINGLE && betSpot <= 35) {
|
|
|
|
betSpot = 36 - betSpot;
|
|
|
|
} else {
|
|
|
|
betSpot += 1;
|
2024-06-08 10:58:34 +01:00
|
|
|
}
|
2024-06-08 00:41:25 +01:00
|
|
|
|
2024-06-09 13:25:58 +01:00
|
|
|
if (betType == SINGLE && betSpot == rollSpot) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 21;
|
|
|
|
} else if (betType == RED && (((int64_t)1 << (rollSpot - 1)) & redNumbers)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 2;
|
|
|
|
} else if (betType == BLACK && !(((int64_t)1 << (rollSpot - 1)) & redNumbers)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 2;
|
|
|
|
} else if (betType == ODD && (rollSpot % 2)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 2;
|
|
|
|
} else if (betType == EVEN && !(rollSpot % 2)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 2;
|
|
|
|
} else if (betType == LOW && rollSpot <= 18 ) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 2;
|
|
|
|
} else if (betType == HIGH && rollSpot >= 19 && rollSpot < 37) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 2;
|
|
|
|
} else if (betType == DOZEN) {
|
|
|
|
printf("CHECK %d %d\n", betSpot, rollSpot);
|
|
|
|
if (rollSpot <= 12 * betSpot && rollSpot >= (12 * (betSpot - 1)) + 1) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 3;
|
|
|
|
}
|
|
|
|
} else if (betType == STREET) {
|
|
|
|
if (rollSpot <= 3 * betSpot && rollSpot >= (3 * (betSpot - 1)) + 1) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 6;
|
|
|
|
}
|
|
|
|
} else if (betType == COLUMN) {
|
|
|
|
if (betSpot == 1 && (((int64_t)1 << (rollSpot - 1)) & column1)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 3;
|
|
|
|
} else if (betSpot == 2 && (((int64_t)1 << (rollSpot - 1)) & column2)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 3;
|
|
|
|
} else if (betSpot == 3 && (((int64_t)1 << (rollSpot - 1)) & column3)) {
|
|
|
|
players[i].payout += players.at(i).bets[ii].betValue * 3;
|
|
|
|
}
|
2024-06-08 10:58:34 +01:00
|
|
|
}
|
2024-06-08 00:41:25 +01:00
|
|
|
}
|
|
|
|
}
|
2024-06-09 13:25:58 +01:00
|
|
|
|
2024-06-08 10:58:34 +01:00
|
|
|
emit results(players.at(i).playerName, i, players.at(i).payout);
|
2024-06-08 00:41:25 +01:00
|
|
|
}
|
|
|
|
}
|
2024-06-07 18:03:22 +01:00
|
|
|
}
|