mirror of
https://github.com/SWG-Source/dsrc.git
synced 2026-08-01 01:15:59 -04:00
1330 lines
49 KiB
Java
Executable File
1330 lines
49 KiB
Java
Executable File
package script.gambling.table;
|
|
|
|
import script.dictionary;
|
|
import script.library.*;
|
|
import script.obj_id;
|
|
import script.prose_package;
|
|
import script.string_id;
|
|
|
|
import java.util.Vector;
|
|
|
|
public class pazaak extends script.gambling.base.table
|
|
{
|
|
public pazaak()
|
|
{
|
|
}
|
|
public static final int[] PLAY_DECK =
|
|
{
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
5,
|
|
5,
|
|
6,
|
|
6,
|
|
7,
|
|
7,
|
|
8,
|
|
8,
|
|
9,
|
|
9,
|
|
10,
|
|
10
|
|
};
|
|
public static final int[] DEFAULT_SIDE_DECK =
|
|
{
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
5,
|
|
5
|
|
};
|
|
public static final String SCRIPT_VAR_HAND = "gambling.game.players.hand";
|
|
public static final String SCRIPT_VAR_BOARD = "gambling.game.players.board";
|
|
public static final String SCRIPT_VAR_DECK = "gambling.game.deck";
|
|
public static final String SCRIPT_VAR_TURN = "gambling.game.turn.player";
|
|
public static final String SCRIPT_VAR_TURN_PID = "gambling.game.turn.pid";
|
|
public static final String SCRIPT_VAR_ACTIVE_PLAYERS = "gambling.game.players.active";
|
|
public static final String SCRIPT_VAR_POT_TOTAL = "gambling.game.pot_total";
|
|
public static final String VAR_HOUSE_RAKE = "gambling.rake";
|
|
public static final string_id SID_MAX_BET = new string_id("gambling/pazaak", "max_bet");
|
|
public static final string_id SID_MIN_BET = new string_id("gambling/pazaak", "min_bet");
|
|
public static final string_id SID_BET_REFUND_OVERBET = new string_id("gambling/pazaak", "bet_refund_overbet");
|
|
public static final string_id SID_NOT_ENOUGH_PLAYERS = new string_id("gambling/pazaak", "not_enough_players");
|
|
public static final string_id SID_PAZAAK_BEGIN = new string_id("gambling/pazaak", "pazaak_begin");
|
|
public static final string_id SID_PAZAAK_ERROR = new string_id("gambling/pazaak", "pazaak_error");
|
|
public static final string_id SID_NEXT_TURN_SELF = new string_id("gambling/pazaak", "next_turn_self");
|
|
public static final string_id SID_NEXT_TURN_OTHER = new string_id("gambling/pazaak", "next_turn_other");
|
|
public static final string_id SID_DRAW_CARD_SELF = new string_id("gambling/pazaak", "draw_card_self");
|
|
public static final string_id SID_DRAW_CARD_OTHER = new string_id("gambling/pazaak", "draw_card_other");
|
|
public static final string_id SID_PLAY_CARD_SELF = new string_id("gambling/pazaak", "play_card_self");
|
|
public static final string_id SID_PLAY_CARD_OTHER = new string_id("gambling/pazaak", "play_card_other");
|
|
public static final string_id SID_PLAYER_BUSTED_SELF = new string_id("gambling/pazaak", "player_busted_self");
|
|
public static final string_id SID_PLAYER_BUSTED_OTHER = new string_id("gambling/pazaak", "player_busted_other");
|
|
public static final string_id SID_PLAYER_STAND_SELF = new string_id("gambling/pazaak", "player_stand_self");
|
|
public static final string_id SID_PLAYER_STAND_OTHER = new string_id("gambling/pazaak", "player_stand_other");
|
|
public static final string_id SID_GAME_OVER = new string_id("gambling/pazaak", "game_over");
|
|
public static final string_id SID_PLAYER_WIN_SELF = new string_id("gambling/pazaak", "player_win_self");
|
|
public static final string_id SID_PLAYER_WIN_OTHER = new string_id("gambling/pazaak", "player_win_other");
|
|
public static final string_id SID_PLAYER_INACTIVE_SELF = new string_id("gambling/pazaak", "player_inactive_self");
|
|
public static final string_id SID_PLAYER_INACTIVE_OTHER = new string_id("gambling/pazaak", "player_inactive_other");
|
|
public int OnInitialize(obj_id self) throws InterruptedException
|
|
{
|
|
reseed(getGameTime());
|
|
obj_id structure = player_structure.getStructure(self);
|
|
int table_balance = getBankBalance(self);
|
|
if (isIdValid(structure))
|
|
{
|
|
transferBankCreditsTo(self, structure, table_balance, "noHandler", "noHandler", new dictionary());
|
|
}
|
|
return super.OnInitialize(self);
|
|
}
|
|
public int handleBetPlaced(obj_id self, dictionary params) throws InterruptedException
|
|
{
|
|
LOG("LOG_CHANNEL", "pazaak::handleBetPlaced");
|
|
if (params == null || params.isEmpty())
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
obj_id player = params.getObjId(money.DICT_PLAYER_ID);
|
|
if (!isIdValid(player))
|
|
{
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
int ret = params.getInt(money.DICT_CODE);
|
|
int amt = params.getInt(money.DICT_TOTAL);
|
|
if (ret == money.RET_FAIL || amt < 1)
|
|
{
|
|
dictionary d = new dictionary();
|
|
d.put("player", player);
|
|
messageTo(self, "handleBetFailed", d, 0, false);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
boolean bet_success = true;
|
|
String arg = params.getString("arg");
|
|
String scriptvar_pid = gambling.VAR_GAME_PLAYERS + "." + player + ".pid";
|
|
if (utils.hasScriptVar(self, scriptvar_pid))
|
|
{
|
|
int oldpid = utils.getIntScriptVar(self, scriptvar_pid);
|
|
sui.closeSUI(player, oldpid);
|
|
utils.removeScriptVar(self, scriptvar_pid);
|
|
}
|
|
int minBet = getIntObjVar(self, gambling.VAR_TABLE_BET_MIN);
|
|
if (minBet > 0 && amt < minBet)
|
|
{
|
|
sendSystemMessageTestingOnly(player, " The minimum bet for this station is " + minBet + " credits.");
|
|
bet_success = false;
|
|
}
|
|
int playerIdx = gambling.getGamePlayerIndex(self, player);
|
|
if (playerIdx < 0)
|
|
{
|
|
bet_success = false;
|
|
}
|
|
String ovpath = gambling.VAR_GAME_PLAYERS + "." + playerIdx + ".bet";
|
|
if (hasObjVar(self, ovpath))
|
|
{
|
|
amt += getIntObjVar(self, ovpath);
|
|
int maxBet = getIntObjVar(self, gambling.VAR_TABLE_BET_MAX);
|
|
if (maxBet > 0 && amt > maxBet)
|
|
{
|
|
int refund = amt - maxBet;
|
|
prose_package pp = prose.getPackage(SID_MAX_BET, maxBet);
|
|
sendSystemMessageProse(player, pp);
|
|
pp = prose.getPackage(SID_BET_REFUND_OVERBET, refund);
|
|
sendSystemMessageProse(player, pp);
|
|
transferBankCreditsTo(self, player, refund, "noHandler", "noHandler", new dictionary());
|
|
amt = maxBet;
|
|
}
|
|
}
|
|
if (bet_success)
|
|
{
|
|
setObjVar(self, ovpath, amt);
|
|
addToPazaakPot(self, amt);
|
|
obj_id[] players = getObjIdArrayObjVar(self, gambling.VAR_TABLE_PLAYERS);
|
|
if (players != null && players.length > 0)
|
|
{
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
LOG("LOG_CHANNEL", "players ->" + players[i]);
|
|
updateBetSUI(self, players[i]);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
transferBankCreditsTo(self, player, amt, "noHandler", "noHandler", new dictionary());
|
|
updateBetSUI(self, player);
|
|
}
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
public int handleBetVerifiedFailed(obj_id self, dictionary params) throws InterruptedException
|
|
{
|
|
LOG("LOG_CHANNEL", "saarlac_wheel::handleBetVerifiedFailed");
|
|
obj_id player = params.getObjId("player");
|
|
if (isIdValid(player) && player.isLoaded())
|
|
{
|
|
LOG("LOG_CHANNEL", player + " -> You have insufficent funds.");
|
|
}
|
|
int amt = params.getInt("amt");
|
|
if (amt > 0)
|
|
{
|
|
transferBankCreditsTo(self, player, amt, "noHandler", "noHandler", new dictionary());
|
|
}
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
public int handlePlayerRemoved(obj_id self, dictionary params) throws InterruptedException
|
|
{
|
|
if (params == null || params.isEmpty())
|
|
{
|
|
return super.handlePlayerRemoved(self, params);
|
|
}
|
|
obj_id player = params.getObjId("player");
|
|
if (!isIdValid(player))
|
|
{
|
|
return super.handlePlayerRemoved(self, params);
|
|
}
|
|
String ovpath = gambling.VAR_GAME_PLAYERS + "." + player + ".pid";
|
|
if (utils.hasScriptVar(self, ovpath))
|
|
{
|
|
int pid = utils.getIntScriptVar(self, ovpath);
|
|
sui.closeSUI(player, pid);
|
|
utils.removeScriptVar(self, ovpath);
|
|
}
|
|
if (!hasObjVar(self, gambling.VAR_TABLE_PLAYERS))
|
|
{
|
|
stopTableGame(self);
|
|
}
|
|
else
|
|
{
|
|
prose_package pp = prose.getPackage(gambling.PROSE_PLAYER_LEAVE_OTHER, player);
|
|
sendTableMessage(self, pp);
|
|
if (utils.hasScriptVar(self, SCRIPT_VAR_GAME_ACTIVE))
|
|
{
|
|
removeActivePlayer(self, player);
|
|
addToPazaakBoard(self, player, -999);
|
|
int player_idx = gambling.getGamePlayerIndex(self, player);
|
|
String bet_path = gambling.VAR_GAME_PLAYERS + "." + player_idx + ".bet";
|
|
if (hasObjVar(self, bet_path))
|
|
{
|
|
removeObjVar(self, bet_path);
|
|
}
|
|
sendSystemMessage(player, SID_PLAYER_INACTIVE_SELF);
|
|
pp = prose.getPackage(SID_PLAYER_INACTIVE_OTHER, player, player);
|
|
sendTableMessage(self, pp, player);
|
|
obj_id players[] = getPazaakPlayers(self);
|
|
LOG("LOG_CHANNEL", "removePlayer -- players ->" + players.length);
|
|
if (players != null && players.length == 1)
|
|
{
|
|
obj_id next_turn = utils.getObjIdScriptVar(self, SCRIPT_VAR_TURN);
|
|
if (isIdValid(next_turn))
|
|
{
|
|
int pid = utils.getIntScriptVar(self, SCRIPT_VAR_TURN_PID);
|
|
if (pid > -1)
|
|
{
|
|
sui.closeSUI(next_turn, pid);
|
|
}
|
|
}
|
|
endPazaakGame(self);
|
|
}
|
|
else
|
|
{
|
|
obj_id next_turn = utils.getObjIdScriptVar(self, SCRIPT_VAR_TURN);
|
|
if (isIdValid(next_turn))
|
|
{
|
|
if (next_turn == player)
|
|
{
|
|
int pid = utils.getIntScriptVar(self, SCRIPT_VAR_TURN_PID);
|
|
if (pid > -1)
|
|
{
|
|
sui.closeSUI(next_turn, pid);
|
|
}
|
|
startNextPazaakTurn(self);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int bet = getPazaakPlayerBet(self, player);
|
|
if (bet > -1)
|
|
{
|
|
transferBankCreditsTo(self, player, bet, "noHandler", "noHandler", new dictionary());
|
|
addToPazaakPot(self, -bet);
|
|
}
|
|
int player_idx = gambling.getGamePlayerIndex(self, player);
|
|
String bet_path = gambling.VAR_GAME_PLAYERS + "." + player_idx + ".bet";
|
|
if (hasObjVar(self, bet_path))
|
|
{
|
|
removeObjVar(self, bet_path);
|
|
}
|
|
}
|
|
}
|
|
return super.handlePlayerRemoved(self, params);
|
|
}
|
|
public int msgPlayPazaakCard(obj_id self, dictionary params) throws InterruptedException
|
|
{
|
|
obj_id player = sui.getPlayerId(params);
|
|
if (!isIdValid(player))
|
|
{
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
if (!validatePlayer(self, player))
|
|
{
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
String button = params.getString("buttonPressed");
|
|
if (button.equals("Cancel") || button.equals("No"))
|
|
{
|
|
displayStandUI(self, player);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
int row_selected = sui.getListboxSelectedRow(params);
|
|
if (row_selected > -1)
|
|
{
|
|
int[] hand = getPazaakHand(self, player);
|
|
if (hand != null && hand.length > 0)
|
|
{
|
|
int card_selected = hand[row_selected];
|
|
playPazaakCardFromHand(self, player, card_selected);
|
|
String card_selected_str = displayPazaakCard(card_selected);
|
|
int board_total = getPazaakBoardTotal(self, player);
|
|
prose_package pp = prose.getPackage(SID_PLAY_CARD_SELF, player, null, card_selected_str, board_total);
|
|
sendSystemMessageProse(player, pp);
|
|
pp = prose.getPackage(SID_PLAY_CARD_OTHER, player, null, card_selected_str, board_total);
|
|
sendTableMessage(self, pp, player);
|
|
if (!verifyPazaakBoard(self, player))
|
|
{
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
updatePazaakBetSUI(self);
|
|
}
|
|
}
|
|
displayStandUI(self, player);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
public int msgStandPazaakHand(obj_id self, dictionary params) throws InterruptedException
|
|
{
|
|
String button = params.getString("buttonPressed");
|
|
if (button.equals("Cancel") || button.equals("No"))
|
|
{
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
obj_id player = sui.getPlayerId(params);
|
|
if (!isIdValid(player))
|
|
{
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
if (!validatePlayer(self, player))
|
|
{
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
if (verifyPazaakBoard(self, player))
|
|
{
|
|
int board_total = getPazaakBoardTotal(self, player);
|
|
prose_package pp = prose.getPackage(SID_PLAYER_STAND_SELF, new string_id("", ""), board_total);
|
|
sendSystemMessageProse(player, pp);
|
|
pp = prose.getPackage(SID_PLAYER_STAND_OTHER, player, player, new string_id("", ""), board_total);
|
|
sendTableMessage(self, pp, player);
|
|
removeActivePlayer(self, player);
|
|
updatePazaakBetSUI(self);
|
|
}
|
|
startNextPazaakTurn(self);
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
public int msgStartPazaakGame(obj_id self, dictionary params) throws InterruptedException
|
|
{
|
|
removeObjVar(self, gambling.VAR_GAME_BASE);
|
|
utils.removeScriptVarTree(self, "gambling.game");
|
|
obj_id[] players = getObjIdArrayObjVar(self, gambling.VAR_TABLE_PLAYERS);
|
|
if (players != null)
|
|
{
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
updateBetSUI(self, players[i]);
|
|
}
|
|
}
|
|
if (players.length < getIntObjVar(self, gambling.VAR_TABLE_PLAYER_LIMIT_MIN))
|
|
{
|
|
utils.removeScriptVar(self, gambling.VAR_TABLE_BET_ACCEPT);
|
|
sendTableMessage(self, SID_NOT_ENOUGH_PLAYERS);
|
|
}
|
|
else
|
|
{
|
|
startTableBetting(self);
|
|
}
|
|
return SCRIPT_CONTINUE;
|
|
}
|
|
public void startTableGame(obj_id self) throws InterruptedException
|
|
{
|
|
LOG("LOG_CHANNEL", "hasObjVar ->" + hasObjVar(self, gambling.VAR_GAME_BASE));
|
|
utils.removeScriptVar(self, gambling.VAR_TABLE_BET_ACCEPT);
|
|
utils.setScriptVar(self, SCRIPT_VAR_GAME_ACTIVE, 1);
|
|
obj_id[] players = getPazaakPlayers(self);
|
|
if (players != null)
|
|
{
|
|
LOG("LOG_CHANNEL", "players ->" + players.length);
|
|
if (players.length < 2)
|
|
{
|
|
sendTableMessage(self, SID_NOT_ENOUGH_PLAYERS);
|
|
if (players != null)
|
|
{
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
int bet_amt = getPazaakPlayerBet(self, players[i]);
|
|
LOG("LOG_CHANNEL", "startTableGame: " + players[i] + " amt ->" + bet_amt);
|
|
removePazaakPlayerBet(self, players[i]);
|
|
if (bet_amt > 0)
|
|
{
|
|
transferBankCreditsTo(self, players[i], bet_amt, "noHandler", "noHandler", new dictionary());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
int[] hand = drawPazaakHand(self, players[i]);
|
|
}
|
|
}
|
|
sendTableMessage(self, SID_PAZAAK_BEGIN);
|
|
LOG("LOG_CHANNEL", "players ->" + players);
|
|
LOG("LOG_CHANNEL", "hasObjVar ->" + hasObjVar(self, gambling.VAR_GAME_BASE));
|
|
utils.setScriptVar(self, SCRIPT_VAR_ACTIVE_PLAYERS, players);
|
|
obj_id player = getNextPlayerTurn(self);
|
|
if (player == null)
|
|
{
|
|
sendTableMessage(self, SID_PAZAAK_ERROR);
|
|
stopTableGame(self);
|
|
}
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
updateBetSUI(self, players[i]);
|
|
}
|
|
startPazaakTurn(self, player);
|
|
return;
|
|
}
|
|
public void showBetUi(obj_id self, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(self) || !isIdValid(player))
|
|
{
|
|
return;
|
|
}
|
|
String gameType = getStringObjVar(self, gambling.VAR_TABLE_TYPE);
|
|
if (gameType == null || gameType.equals(""))
|
|
{
|
|
return;
|
|
}
|
|
String title = "@gambling/game_n:" + gameType;
|
|
String prompt = "The following is a summary of current table bets...\n\n";
|
|
prompt += "Use /bet <amount> to wager.\n\n";
|
|
prompt += "Bet Per Hand : " + getIntObjVar(self, gambling.VAR_TABLE_BET_MIN) + "\n";
|
|
prompt += "Cash : " + getCashBalance(player) + "\n";
|
|
prompt += "Bank : " + getBankBalance(player) + "\n";
|
|
prompt += "Total: " + getTotalMoney(player) + "\n";
|
|
prompt += "\nNOTE: if you leave the table after placing a bet, all of your outstanding bets will be forfeit.";
|
|
Vector entries = new Vector();
|
|
entries.setSize(0);
|
|
int total = 0;
|
|
if (utils.hasScriptVar(self, SCRIPT_VAR_TURN))
|
|
{
|
|
obj_id turn_player = utils.getObjIdScriptVar(self, SCRIPT_VAR_TURN);
|
|
if (isIdValid(turn_player))
|
|
{
|
|
if (turn_player == player)
|
|
{
|
|
entries = utils.addElement(entries, "It is your turn.");
|
|
}
|
|
else
|
|
{
|
|
entries = utils.addElement(entries, "It is " + getFirstName(turn_player) + "'s turn.");
|
|
}
|
|
}
|
|
}
|
|
obj_id[] bet_players = getObjIdArrayObjVar(self, gambling.VAR_GAME_PLAYERS_IDS);
|
|
if (bet_players != null && bet_players.length > 0)
|
|
{
|
|
if (utils.hasScriptVar(self, SCRIPT_VAR_GAME_ACTIVE))
|
|
{
|
|
for (int i = 0; i < bet_players.length; i++)
|
|
{
|
|
boolean active = isActivePlayer(self, bet_players[i]);
|
|
int[] hand = getPazaakHand(self, bet_players[i]);
|
|
if (hand != null)
|
|
{
|
|
if (bet_players[i] == player)
|
|
{
|
|
if (active)
|
|
{
|
|
entries = utils.addElement(entries, "Your Hand: " + displayPazaakCards(hand));
|
|
}
|
|
else
|
|
{
|
|
entries = utils.addElement(entries, "Your Hand: Standing");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (active)
|
|
{
|
|
int hand_size = getPazaakHand(self, bet_players[i]).length;
|
|
entries = utils.addElement(entries, getFirstName(bet_players[i]) + "'s Hand: " + hand_size + " cards");
|
|
}
|
|
else
|
|
{
|
|
entries = utils.addElement(entries, getFirstName(bet_players[i]) + "'s Hand: Standing");
|
|
}
|
|
}
|
|
}
|
|
int[] board = getPazaakBoard(self, bet_players[i]);
|
|
int board_total = getPazaakBoardTotal(self, bet_players[i]);
|
|
if (board != null)
|
|
{
|
|
if (bet_players[i] == player)
|
|
{
|
|
if (board_total <= -99 || (board_total > 20 && !active))
|
|
{
|
|
entries = utils.addElement(entries, "Your Board: Out");
|
|
}
|
|
else
|
|
{
|
|
entries = utils.addElement(entries, "Your Board: " + displayPazaakCards(board) + " (Total: " + board_total + ")");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (board_total <= -99 || (board_total > 20 && !active))
|
|
{
|
|
entries = utils.addElement(entries, getFirstName(bet_players[i]) + "'s Board: Out");
|
|
}
|
|
else
|
|
{
|
|
entries = utils.addElement(entries, getFirstName(bet_players[i]) + "'s Board: " + displayPazaakCards(board) + " (Total: " + board_total + ")");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < bet_players.length; i++)
|
|
{
|
|
String betVar = gambling.VAR_GAME_PLAYERS + "." + i + ".bet";
|
|
if (bet_players[i].isLoaded())
|
|
{
|
|
String entry;
|
|
if (hasObjVar(self, betVar))
|
|
{
|
|
int amt = getIntObjVar(self, betVar);
|
|
if (bet_players[i] == player)
|
|
{
|
|
entry = "Your bet : " + amt;
|
|
}
|
|
else
|
|
{
|
|
entry = getFirstName(bet_players[i]) + "'s bet : " + amt;
|
|
}
|
|
entries = utils.addElement(entries, entry);
|
|
total += amt;
|
|
}
|
|
else
|
|
{
|
|
if (bet_players[i] == player)
|
|
{
|
|
entry = "You : 0";
|
|
}
|
|
else
|
|
{
|
|
entry = getFirstName(bet_players[i]) + " : 0";
|
|
}
|
|
entries = utils.addElement(entries, entry);
|
|
}
|
|
}
|
|
entries = utils.alphabetizeStringArray(entries);
|
|
entries = utils.addElement(entries, " ");
|
|
}
|
|
}
|
|
int table_pot = utils.getIntScriptVar(self, SCRIPT_VAR_POT_TOTAL);
|
|
entries = utils.addElement(entries, "Total Bet : " + table_pot);
|
|
int pid = sui.listbox(self, player, prompt, sui.REFRESH_LEAVE_GAME, title, entries, "handleBetUi");
|
|
if (pid == -1)
|
|
{
|
|
sendSystemMessageTestingOnly(player, "The table was unable to create an interface for you.");
|
|
return;
|
|
}
|
|
utils.setScriptVar(self, gambling.VAR_GAME_PLAYERS + "." + player + ".pid", pid);
|
|
}
|
|
public boolean startPazaakTurn(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
int drawn_card = drawPazaakCardFromDeck(table, player);
|
|
String drawn_card_str = displayPazaakCard(drawn_card);
|
|
addToPazaakBoard(table, player, drawn_card);
|
|
int board_total = getPazaakBoardTotal(table, player);
|
|
prose_package pp = prose.getPackage(SID_DRAW_CARD_SELF, player, null, drawn_card_str, board_total);
|
|
sendSystemMessageProse(player, pp);
|
|
pp = prose.getPackage(SID_DRAW_CARD_OTHER, player, null, drawn_card_str, board_total);
|
|
sendTableMessage(table, pp, player);
|
|
obj_id[] players = getPazaakPlayers(table);
|
|
if (players == null)
|
|
{
|
|
return false;
|
|
}
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
updateBetSUI(table, players[i]);
|
|
}
|
|
int[] hand = getPazaakHand(table, player);
|
|
if (hand != null && hand.length > 0)
|
|
{
|
|
displayPlayCardUI(table, player);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (verifyPazaakBoard(table, player))
|
|
{
|
|
displayStandUI(table, player);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
public boolean startNextPazaakTurn(obj_id table) throws InterruptedException
|
|
{
|
|
LOG("LOG_CHANNEL", "startNextPazaakTurn");
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
obj_id player = getNextPlayerTurn(table);
|
|
LOG("LOG_CHANNEL", "startNextPazaakTurn -- player ->" + player);
|
|
if (player == null)
|
|
{
|
|
endPazaakGame(table);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return startPazaakTurn(table, player);
|
|
}
|
|
}
|
|
public boolean endPazaakGame(obj_id table) throws InterruptedException
|
|
{
|
|
LOG("LOG_CHANNEL", "endPazaakGame -- table ->" + table);
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
obj_id[] players = getPazaakPlayers(table);
|
|
LOG("LOG_CHANNEL", "endPazaakGame -- players ->" + players);
|
|
if (players != null && players.length > 0)
|
|
{
|
|
int[] board_totals = new int[players.length];
|
|
int winning_total = -99;
|
|
for (int i = 0; i < board_totals.length; i++)
|
|
{
|
|
int total = getPazaakBoardTotal(table, players[i]);
|
|
if (total > winning_total && total < 21)
|
|
{
|
|
winning_total = total;
|
|
}
|
|
board_totals[i] = total;
|
|
}
|
|
Vector winners = new Vector();
|
|
if (winning_total > -99)
|
|
{
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
LOG("LOG_CHANNEL", "endGame -- player ->" + players[i] + " board ->" + board_totals[i] + " win ->" + winning_total);
|
|
if (board_totals[i] == winning_total)
|
|
{
|
|
winners.add(players[i]);
|
|
}
|
|
}
|
|
prose_package pp = prose.getPackage(SID_GAME_OVER, winning_total);
|
|
sendTableMessage(table, pp);
|
|
}
|
|
else
|
|
{
|
|
winners.add(players[0]);
|
|
}
|
|
if (winners.size() > 0)
|
|
{
|
|
obj_id[] winners_array = new obj_id[winners.size()];
|
|
winners.toArray(winners_array);
|
|
int table_balance = getBankBalance(table);
|
|
int rake = 0;
|
|
if (hasObjVar(table, VAR_HOUSE_RAKE))
|
|
{
|
|
rake = getIntObjVar(table, VAR_HOUSE_RAKE);
|
|
}
|
|
int pay_out = (int)(table_balance * (100 - rake) / 100) / winners_array.length;
|
|
for (int i = 0; i < winners_array.length; i++)
|
|
{
|
|
prose_package pp = prose.getPackage(SID_PLAYER_WIN_SELF, pay_out);
|
|
sendSystemMessageProse(winners_array[i], pp);
|
|
pp = prose.getPackage(SID_PLAYER_WIN_OTHER, winners_array[i], winners_array[i], pay_out);
|
|
sendTableMessage(table, pp, winners_array[i]);
|
|
transferBankCreditsTo(table, winners_array[i], pay_out, "noHandler", "noHandler", new dictionary());
|
|
table_balance -= pay_out;
|
|
}
|
|
obj_id structure = player_structure.getStructure(table);
|
|
if (isIdValid(structure))
|
|
{
|
|
transferBankCreditsTo(table, structure, table_balance, "noHandler", "noHandler", new dictionary());
|
|
}
|
|
}
|
|
}
|
|
messageTo(table, "msgStartPazaakGame", null, 10, false);
|
|
return true;
|
|
}
|
|
public int getPazaakPlayerBet(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return -1;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return -1;
|
|
}
|
|
int idx = gambling.getGamePlayerIndex(table, player);
|
|
String betVar = gambling.VAR_GAME_PLAYERS + "." + idx + ".bet";
|
|
LOG("LOG_CHANNEL", "getPazaakPlayerBet: betVar ->" + betVar + " amt ->" + getIntObjVar(table, betVar));
|
|
if (hasObjVar(table, betVar))
|
|
{
|
|
return getIntObjVar(table, betVar);
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
public boolean removePazaakPlayerBet(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
int idx = gambling.getGamePlayerIndex(table, player);
|
|
String betVar = gambling.VAR_GAME_PLAYERS + "." + idx + ".bet";
|
|
if (hasObjVar(table, betVar))
|
|
{
|
|
removeObjVar(table, betVar);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public obj_id[] getPazaakPlayers(obj_id table) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return null;
|
|
}
|
|
obj_id[] players = getObjIdArrayObjVar(table, gambling.VAR_GAME_PLAYERS_IDS);
|
|
Vector valid_players = new Vector();
|
|
valid_players.setSize(0);
|
|
if (players != null)
|
|
{
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
if (getPazaakPlayerBet(table, players[i]) > 0)
|
|
{
|
|
valid_players.add(players[i]);
|
|
}
|
|
}
|
|
}
|
|
obj_id[] _valid_players = new obj_id[0];
|
|
if (valid_players != null)
|
|
{
|
|
_valid_players = new obj_id[valid_players.size()];
|
|
valid_players.toArray(_valid_players);
|
|
}
|
|
return _valid_players;
|
|
}
|
|
public boolean verifyPazaakBoard(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
int board_total = getPazaakBoardTotal(table, player);
|
|
if (board_total > 20)
|
|
{
|
|
prose_package pp = prose.getPackage(SID_PLAYER_BUSTED_SELF, new string_id("", ""), board_total);
|
|
sendSystemMessageProse(player, pp);
|
|
pp = prose.getPackage(SID_PLAYER_BUSTED_OTHER, player, player, new string_id("", ""), board_total);
|
|
sendTableMessage(table, pp, player);
|
|
removeActivePlayer(table, player);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
public boolean isActivePlayer(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
obj_id[] active_players = utils.getObjIdArrayScriptVar(table, SCRIPT_VAR_ACTIVE_PLAYERS);
|
|
int idx = utils.getElementPositionInArray(active_players, player);
|
|
if (idx == -1)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
public boolean removeActivePlayer(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return true;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return true;
|
|
}
|
|
Vector active_players = utils.getResizeableObjIdArrayScriptVar(table, SCRIPT_VAR_ACTIVE_PLAYERS);
|
|
if (active_players != null)
|
|
{
|
|
int idx = utils.getElementPositionInArray(active_players, player);
|
|
if (idx == -1)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
active_players.removeElementAt(idx);
|
|
obj_id[] array = new obj_id[active_players.size()];
|
|
active_players.toArray(array);
|
|
utils.setScriptVar(table, SCRIPT_VAR_ACTIVE_PLAYERS, array);
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
public boolean validatePlayer(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
if (!gambling.isTablePlayer(table, player) || !player.isLoaded())
|
|
{
|
|
removeActivePlayer(table, player);
|
|
addToPazaakBoard(table, player, -999);
|
|
sendSystemMessage(player, SID_PLAYER_INACTIVE_SELF);
|
|
prose_package pp = prose.getPackage(SID_PLAYER_INACTIVE_OTHER, player, player);
|
|
sendTableMessage(table, pp, player);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
public int[] getPazaakBets(obj_id table) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return null;
|
|
}
|
|
obj_id[] players = getObjIdArrayObjVar(table, gambling.VAR_GAME_PLAYERS_IDS);
|
|
if (players != null && players.length > 0)
|
|
{
|
|
Vector bets = new Vector();
|
|
bets.setSize(0);
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
String betVar = gambling.VAR_GAME_PLAYERS + "." + i + ".bet";
|
|
if (players[i].isLoaded())
|
|
{
|
|
if (hasObjVar(table, betVar))
|
|
{
|
|
int amt = getIntObjVar(table, betVar);
|
|
if (amt > 0)
|
|
{
|
|
bets = utils.addElement(bets, amt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int[] _bets = new int[0];
|
|
if (bets != null)
|
|
{
|
|
_bets = new int[bets.size()];
|
|
for (int _i = 0; _i < bets.size(); ++_i)
|
|
{
|
|
_bets[_i] = ((Integer)bets.get(_i)).intValue();
|
|
}
|
|
}
|
|
return _bets;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
public int[] drawPazaakHand(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return null;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return null;
|
|
}
|
|
Vector default_deck = new Vector();
|
|
default_deck.setSize(0);
|
|
for (int i = 0; i < DEFAULT_SIDE_DECK.length; i++)
|
|
{
|
|
default_deck = utils.addElement(default_deck, DEFAULT_SIDE_DECK[i]);
|
|
}
|
|
int[] hand = new int[4];
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
if (default_deck.size() < 1)
|
|
{
|
|
break;
|
|
}
|
|
int rand_idx = rand(0, default_deck.size() - 1);
|
|
int card = ((Integer)default_deck.get(rand_idx)).intValue();
|
|
hand[i] = card;
|
|
default_deck.removeElementAt(rand_idx);
|
|
}
|
|
int player_idx = gambling.getGamePlayerIndex(table, player);
|
|
if (player_idx > -1)
|
|
{
|
|
String objvar_name = SCRIPT_VAR_HAND + "." + player_idx;
|
|
utils.setScriptVar(table, objvar_name, hand);
|
|
}
|
|
return hand;
|
|
}
|
|
public int drawPazaakCardFromDeck(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return -1;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return -1;
|
|
}
|
|
Vector deck = new Vector();
|
|
deck.setSize(0);
|
|
if (utils.hasScriptVar(table, SCRIPT_VAR_DECK))
|
|
{
|
|
deck = utils.getResizeableIntArrayScriptVar(table, SCRIPT_VAR_DECK);
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < PLAY_DECK.length; i++)
|
|
{
|
|
deck = utils.addElement(deck, PLAY_DECK[i]);
|
|
}
|
|
}
|
|
if (deck == null || deck.size() < 1)
|
|
{
|
|
return -1;
|
|
}
|
|
int rand_idx = rand(0, deck.size() - 1);
|
|
int card = ((Integer)deck.get(rand_idx)).intValue();
|
|
deck.removeElementAt(rand_idx);
|
|
utils.setScriptVar(table, SCRIPT_VAR_DECK, deck);
|
|
return card;
|
|
}
|
|
public int[] getPazaakHand(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return null;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return null;
|
|
}
|
|
int player_idx = gambling.getGamePlayerIndex(table, player);
|
|
String objvar_name = SCRIPT_VAR_HAND + "." + player_idx;
|
|
if (utils.hasScriptVar(table, objvar_name))
|
|
{
|
|
return utils.getIntArrayScriptVar(table, objvar_name);
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
public int[] getPazaakBoard(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return null;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return null;
|
|
}
|
|
int player_idx = gambling.getGamePlayerIndex(table, player);
|
|
String objvar_name = SCRIPT_VAR_BOARD + "." + player_idx;
|
|
if (utils.hasScriptVar(table, objvar_name))
|
|
{
|
|
return utils.getIntArrayScriptVar(table, objvar_name);
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
public int getPazaakBoardTotal(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return -999;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return -999;
|
|
}
|
|
int[] board = getPazaakBoard(table, player);
|
|
if (board != null)
|
|
{
|
|
int total = 0;
|
|
for (int i = 0; i < board.length; i++)
|
|
{
|
|
total += board[i];
|
|
}
|
|
return total;
|
|
}
|
|
else
|
|
{
|
|
return -999;
|
|
}
|
|
}
|
|
public int addToPazaakPot(obj_id table, int amt) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return -1;
|
|
}
|
|
int table_pot = 0;
|
|
if (utils.hasScriptVar(table, SCRIPT_VAR_POT_TOTAL))
|
|
{
|
|
table_pot = utils.getIntScriptVar(table, SCRIPT_VAR_POT_TOTAL);
|
|
}
|
|
table_pot += amt;
|
|
utils.setScriptVar(table, SCRIPT_VAR_POT_TOTAL, table_pot);
|
|
return table_pot;
|
|
}
|
|
public String displayPazaakCards(int[] cards) throws InterruptedException
|
|
{
|
|
if (cards == null || cards.length < 1)
|
|
{
|
|
return null;
|
|
}
|
|
String cards_str = new String();
|
|
for (int i = 0; i < cards.length; i++)
|
|
{
|
|
if (cards[i] >= 0)
|
|
{
|
|
if (cards[i] / 100 > 0)
|
|
{
|
|
cards_str += "+/- " + cards[i] / 100;
|
|
}
|
|
else
|
|
{
|
|
cards_str += "+" + cards[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cards_str += Integer.toString(cards[i]);
|
|
}
|
|
if (i < cards.length - 1)
|
|
{
|
|
cards_str += ", ";
|
|
}
|
|
else if (i != cards.length - 1)
|
|
{
|
|
cards_str += " ";
|
|
}
|
|
}
|
|
return cards_str;
|
|
}
|
|
public String displayPazaakCard(int card) throws InterruptedException
|
|
{
|
|
int[] cards = new int[1];
|
|
cards[0] = card;
|
|
return displayPazaakCards(cards);
|
|
}
|
|
public String[] displayPazaakCardsAsArray(int[] cards) throws InterruptedException
|
|
{
|
|
if (cards == null || cards.length < 1)
|
|
{
|
|
return null;
|
|
}
|
|
Vector cards_str = new Vector();
|
|
for (int i = 0; i < cards.length; i++)
|
|
{
|
|
if (cards[i] >= 0)
|
|
{
|
|
if (cards[i] / 100 > 0)
|
|
{
|
|
utils.addElement(cards_str, "+/- " + cards[i] / 100);
|
|
}
|
|
else
|
|
{
|
|
utils.addElement(cards_str, "+" + cards[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
utils.addElement(cards_str, Integer.toString(cards[i]));
|
|
}
|
|
}
|
|
String[] card_array = new String[cards_str.size()];
|
|
cards_str.toArray(card_array);
|
|
return card_array;
|
|
}
|
|
public boolean playPazaakCardFromHand(obj_id table, obj_id player, int card) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
int player_idx = gambling.getGamePlayerIndex(table, player);
|
|
String objvar_name = SCRIPT_VAR_HAND + "." + player_idx;
|
|
int[] hand = getPazaakHand(table, player);
|
|
if (hand == null || hand.length < 1)
|
|
{
|
|
return false;
|
|
}
|
|
int card_idx = utils.getElementPositionInArray(hand, card);
|
|
if (card_idx == -1)
|
|
{
|
|
return false;
|
|
}
|
|
Vector new_hand = utils.getResizeableIntArrayScriptVar(table, objvar_name);
|
|
new_hand.removeElementAt(card_idx);
|
|
utils.setScriptVar(table, objvar_name, new_hand);
|
|
addToPazaakBoard(table, player, card);
|
|
return true;
|
|
}
|
|
public boolean addToPazaakBoard(obj_id table, obj_id player, int card) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
int player_idx = gambling.getGamePlayerIndex(table, player);
|
|
String objvar_name = SCRIPT_VAR_BOARD + "." + player_idx;
|
|
Vector boards = new Vector();
|
|
boards.setSize(0);
|
|
if (utils.hasScriptVar(table, objvar_name))
|
|
{
|
|
boards = utils.getResizeableIntArrayScriptVar(table, objvar_name);
|
|
}
|
|
boards = utils.addElement(boards, card);
|
|
utils.setScriptVar(table, objvar_name, boards);
|
|
return true;
|
|
}
|
|
public obj_id getNextPlayerTurn(obj_id table) throws InterruptedException
|
|
{
|
|
LOG("LOG_CHANNEL", "pazaak::getNextPlayerTurn");
|
|
if (!isIdValid(table))
|
|
{
|
|
return null;
|
|
}
|
|
obj_id[] active_players = utils.getObjIdArrayScriptVar(table, SCRIPT_VAR_ACTIVE_PLAYERS);
|
|
if (active_players == null || active_players.length == 0)
|
|
{
|
|
return null;
|
|
}
|
|
if (active_players.length == 1)
|
|
{
|
|
obj_id next_player = active_players[0];
|
|
utils.setScriptVar(table, SCRIPT_VAR_TURN, active_players[0]);
|
|
sendSystemMessage(next_player, SID_NEXT_TURN_SELF);
|
|
prose_package pp = prose.getPackage(SID_NEXT_TURN_OTHER, next_player);
|
|
sendTableMessage(table, pp, next_player);
|
|
return next_player;
|
|
}
|
|
obj_id[] players = getPazaakPlayers(table);
|
|
if (players != null && players.length > 0)
|
|
{
|
|
LOG("LOG_CHANNEL", "players ->" + players.length);
|
|
obj_id next_player = obj_id.NULL_ID;
|
|
if (utils.hasScriptVar(table, SCRIPT_VAR_TURN))
|
|
{
|
|
obj_id last_turn = utils.getObjIdScriptVar(table, SCRIPT_VAR_TURN);
|
|
int idx = utils.getElementPositionInArray(players, last_turn);
|
|
if (idx != -1)
|
|
{
|
|
boolean end_list = false;
|
|
while (next_player == obj_id.NULL_ID)
|
|
{
|
|
idx += 1;
|
|
if (idx > players.length - 1)
|
|
{
|
|
if (end_list)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
idx = 0;
|
|
end_list = true;
|
|
}
|
|
}
|
|
if (isActivePlayer(table, players[idx]))
|
|
{
|
|
utils.setScriptVar(table, SCRIPT_VAR_TURN, players[idx]);
|
|
next_player = players[idx];
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sendTableMessage(table, SID_PAZAAK_ERROR);
|
|
stopTableGame(table);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int idx = rand(0, players.length - 1);
|
|
utils.setScriptVar(table, SCRIPT_VAR_TURN, players[idx]);
|
|
next_player = players[idx];
|
|
}
|
|
if (isIdValid(next_player))
|
|
{
|
|
sendSystemMessage(next_player, SID_NEXT_TURN_SELF);
|
|
prose_package pp = prose.getPackage(SID_NEXT_TURN_OTHER, next_player);
|
|
sendTableMessage(table, pp, next_player);
|
|
return next_player;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
public boolean displayPlayCardUI(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
int[] hand = getPazaakHand(table, player);
|
|
String[] hand_str = new String[1];
|
|
if (hand != null && hand.length > 0)
|
|
{
|
|
hand_str = displayPazaakCardsAsArray(hand);
|
|
}
|
|
else
|
|
{
|
|
hand_str[0] = "@gambling/pazaak:no_hand_remaining";
|
|
}
|
|
Vector entries = new Vector();
|
|
entries.setSize(0);
|
|
String title = "@gambling/game_n:pazaak";
|
|
String prompt = "Select a card to play.";
|
|
int pid = sui.listbox(table, player, prompt, sui.OK_CANCEL, title, hand_str, "msgPlayPazaakCard");
|
|
utils.setScriptVar(table, SCRIPT_VAR_TURN_PID, pid);
|
|
return true;
|
|
}
|
|
public boolean displayStandUI(obj_id table, obj_id player) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
if (!isIdValid(player))
|
|
{
|
|
return false;
|
|
}
|
|
String title = "@gambling/game_n:pazaak";
|
|
int board_total = getPazaakBoardTotal(table, player);
|
|
String prompt = "You have a board total of " + board_total + ". Do you wish to stand?";
|
|
int pid = sui.msgbox(table, player, prompt, sui.YES_NO, "msgStandPazaakHand");
|
|
utils.setScriptVar(table, SCRIPT_VAR_TURN_PID, pid);
|
|
return true;
|
|
}
|
|
public boolean updatePazaakBetSUI(obj_id table) throws InterruptedException
|
|
{
|
|
if (!isIdValid(table))
|
|
{
|
|
return false;
|
|
}
|
|
obj_id[] players = getObjIdArrayObjVar(table, gambling.VAR_TABLE_PLAYERS);
|
|
if (players != null && players.length > 0)
|
|
{
|
|
for (int i = 0; i < players.length; i++)
|
|
{
|
|
LOG("LOG_CHANNEL", "players ->" + players[i]);
|
|
updateBetSUI(table, players[i]);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|