poker-html-client
Version:
HTML client for online poker
1,195 lines (1,034 loc) • 43.7 kB
text/typescript
/* tslint:disable:no-bitwise no-use-before-declare */
import * as ko from "knockout";
import { Game } from "../api/game";
import { Tournament, TournamentDefinition, TournamentPlayerStatus } from "../api/tournament";
import { appConfig } from "../appconfig";
import * as authManager from "../authmanager";
import * as commandManager from "../commandmanager";
import { debugSettings } from "../debugsettings";
import { _ } from "../languagemanager";
import { SimplePopup } from "../popups/simplepopup";
import { appReloadService, connectionService, slowInternetService } from "../services";
import * as broadcastService from "../services/broadcastservice";
import { ConnectionWrapper } from "../services/connectionwrapper";
import { settings } from "../settings";
import * as timeService from "../timeservice";
import { TableView } from "./tableview";
import { TournamentView } from "./tournamentview";
declare var apiHost: string;
declare var host: string;
class TableManager {
public tables: KnockoutObservableArray<TableView>;
public currentIndex: KnockoutObservable<number>;
public hasTurn: KnockoutComputed<boolean>;
public maxTablesReached: Signal;
/**
* Tournaments in which player registered.
*/
public tournaments: KnockoutObservableArray<TournamentView>;
private duplicators: DuplicateFinder[];
private reserveTablesForTournaments = false;
constructor() {
const self = this;
this.tables = ko.observableArray<TableView>([]);
this.tournaments = ko.observableArray<TournamentView>([]);
this.currentIndex = ko.observable(0);
connectionService.reconnected.add(() => self.onReconnected());
this.duplicators = [];
this.maxTablesReached = new signals.Signal();
this.hasTurn = ko.computed(function () {
const tablesWithTurn = self.tables().filter((table) => table.isMyTurn());
return tablesWithTurn.length > 0;
}, this);
}
public initialize() {
const self = this;
commandManager.registerCommand("app.selectTable", function (parameters?: any[]): void {
if (parameters.length < 1) {
// tslint:disable-next-line:no-console
console.log("Insufficient parameters to the 'app.selectTable' command");
return;
}
const table = parameters[0] as GameTableModel;
const update = parameters.length <= 1
? true
: parameters[1] as boolean;
self.selectTable(table, update);
appReloadService.startMonitoring(table.TableId);
});
commandManager.registerCommand("app.leaveTable", function (parameters?: any[]): JQueryDeferred<void> {
const result = $.Deferred<void>();
if (parameters.length < 1) {
// tslint:disable-next-line:no-console
console.log("Insufficient parameters to the 'app.leaveTable' command");
result.reject();
return result;
}
const tableId: number = parameters[0];
let tableView = self.getTableById(tableId);
// tslint:disable-next-line:no-console
console.log("Leaving table " + tableView.tableId.toString());
if (tableView != null) {
tableView.showStandupPrompt().then(function () {
tableView.disconnect();
tableView = self.remove(tableView);
// appReloadService.clearMonitoring(table.TableId);
// Adjust currently selected table.
self.adjustTablePosition();
result.resolve();
}, function () {
result.reject();
});
return result;
}
result.reject();
return result;
});
connectionService.newConnection.add(function() {
if (authManager.authenticated()) {
self.initializeChatHub(connectionService.currentConnection);
self.initializeGameHub(connectionService.currentConnection);
}
});
settings.autoHideCards.subscribe(function(newValue) {
const api = new Game(host);
self.tables().forEach(function(tableView) {
// Set open card parameters in parallel for all tables.
api.setTableParameters(tableView.tableId, !newValue);
});
settings.saveSettings();
});
}
public onReconnected() {
this.connectTables();
this.connectTournaments();
}
public async getCurrentTables() {
const api = new Game(host);
const data = await api.getTables();
const tablesData = data.Data as GameTableModel[];
const sittingTables = !(appConfig.game.seatMode || appConfig.game.tablePreviewMode)
? await this.getSittingTablesFromServer()
: await this.getSavedSittingTables();
for (const tableId of sittingTables) {
for (const model of tablesData) {
if (model.TableId === tableId) {
this.selectTable(model, false);
}
}
}
return sittingTables;
}
public async getCurrentTournaments() {
const self = this;
const gapi = new Game(host);
const tapi = new Tournament(host);
const data = await tapi.getTournaments(0, 0, 0, 0, 0);
const tournamentsData = data.Data;
const registeredTournamentsData = await tapi.getRegisteredTournaments();
const status = registeredTournamentsData.Status;
if (status === "Ok") {
const rtournaments = registeredTournamentsData.Data;
if (rtournaments !== null && rtournaments.length !== 0) {
const args = await self.requestTournamentsInformation(rtournaments);
const tournaments = [] as TournamentDefinition[];
for (let i = 0; i < args.length; i++) {
tournaments.push(args[i]);
}
return tournaments;
} else {
return [];
}
} else {
if (status === "AuthorizationError") {
return [];
} else {
throw new Error("Could not get status of registered tournaments");
}
}
}
public async getCurrentTablesAndTournaments() {
if (!authManager.authenticated()) {
return;
}
const tablesRequest = this.getCurrentTables();
const tournamentsRequest = async () => {
const value = await this.getCurrentTournaments();
const startedTournaments = value.filter((tournament) => {
return tournament.Status === TournamentStatus.LateRegistration
|| tournament.Status === TournamentStatus.Started;
});
if (startedTournaments.length === 0) {
return;
}
const messages = [_("tournament.areYouInFollowingTournaments")];
startedTournaments.forEach((tournament) => messages.push(tournament.TournamentName));
timeService.setTimeout(() => {
SimplePopup.display(_("tournament.tournaments"), messages);
}, 2000);
};
await Promise.all([tablesRequest, tournamentsRequest]);
}
public selectTableCommandHandler(parameters: any[]): void {
// Do nothing.
}
public clear() {
this.currentIndex(0);
this.tables([]);
this.tournaments([]);
}
public clearTables() {
this.tables().forEach((table) => {
table.clearInformation();
});
}
public connectTables() {
this.tables().forEach((table) => {
table.updateTableInformation();
});
}
public stopConnectingToTables() {
this.tables().forEach((table) => {
table.cancelUpdateTableInformation();
});
}
public clearTournaments() {
this.tournaments().forEach((tournament) => {
tournament.clearInformation();
});
}
public connectTournaments() {
this.tournaments().forEach((tournament) => {
tournament.updateTournamentInformation();
});
}
public async openTournamentById(tournamentId: number, attempts: number = 3) {
if (attempts === 0) {
SimplePopup.display(_("tournament.error"), _("tournament.errorConnectonToTournament"));
return;
}
const tournamentApi = new Tournament(host);
const tournamentInfo = await tournamentApi.getTournament(tournamentId);
if (tournamentInfo.Status === "Ok") {
const tournamentData = tournamentInfo.Data;
tableManager.selectTournament(tournamentData, true);
} else {
this.openTournamentById(tournamentId, attempts - 1);
}
}
public getTablesReservation() {
const tablesWithoutTournament = this.tables().filter((table) => table.tournament() === null);
const notFinishedTournaments = this.tournaments().filter((tournamentView) => {
const tdata = tournamentView.tournamentData();
const tplayer = tdata.TournamentPlayers.filter((tournamentPlayer) => {
return tournamentPlayer.PlayerId === authManager.loginId();
});
if (tplayer.length === 0) {
return false;
}
if (tplayer[0].Status !== TournamentPlayerStatus.Playing) {
return false;
}
return tdata.Status !== TournamentStatus.Completed
&& tdata.Status !== TournamentStatus.Cancelled
&& tdata.Status !== TournamentStatus.RegistrationCancelled;
});
this.logDataEvent("Count of tables: " + tablesWithoutTournament.length + ", "
+ "count of tournaments: " + notFinishedTournaments.length);
if (this.reserveTablesForTournaments) {
return Math.max(tablesWithoutTournament.length + notFinishedTournaments.length, this.tables().length);
}
return this.tables().length;
}
public selectTournament(model: TournamentDefinition, update: boolean) {
const self = this;
const tournamentId = model.TournamentId;
let tournamentView = this.getTournamentById(tournamentId);
const append = function() {
if (tournamentView === null) {
tournamentView = self.addTournament(tournamentId, model);
}
if (update && connectionService.currentConnection !== null) {
tournamentView.updateTournamentInformation();
}
};
if (this.getTablesReservation() >= 4 && tournamentView === null && this.reserveTablesForTournaments) {
this.maxTablesReached.dispatch(append);
}
append();
}
public selectTable(model: GameTableModel, update: boolean) {
const tableId = model.TableId;
let tableView = this.getTableById(tableId);
const append = () => {
if (tableView === null) {
tableView = this.addTable(tableId, model);
}
this.selectById(tableId);
if (update) {
if (connectionService.currentConnection !== null) {
console.log("Update table information");
tableView.updateTableInformation();
} else {
console.log(`The table ${tableId} added to list of tables, but not updated since no active connection`);
}
} else {
console.log(`The table ${tableId} added to list of tables, but not updated`);
}
};
if (tableView == null) {
this.removeTournamentTables(model.TournamentId);
}
if (this.getTablesReservation() >= 4 && tableView === null) {
this.removeClosedTables();
if (this.getTablesReservation() >= 4 && tableView === null) {
this.maxTablesReached.dispatch(append);
}
append();
} else {
append();
}
}
public addTable(tableId: number, model: GameTableModel) {
const table = new TableView(tableId, model);
this.tables.push(table);
table.onMyTurn.add(this.onMyTurn, this);
return table;
}
public remove(table: TableView) {
const tables = this.tables().filter(function(value: TableView) {
return value !== table;
});
this.tables(tables);
table.onMyTurn.remove(this.onMyTurn, this);
return table;
}
public removeTableById(tableId: number) {
const view = this.getTableById(tableId);
if (view === null) {
return null;
}
return this.remove(view);
}
public adjustTablePosition() {
let maxIndex = this.tables().length - 1;
maxIndex = maxIndex < 0 ? 0 : maxIndex;
if (this.currentIndex() > maxIndex) {
this.currentIndex(maxIndex);
}
}
public prevTable() {
const length = this.tables().length;
if (length <= 1) {
return;
}
const maxIndex = this.tables().length - 1;
const index = this.currentIndex();
const nextIndex = (index - 1 + this.tables().length) % this.tables().length;
this.currentIndex(nextIndex);
}
public nextTable() {
const length = this.tables().length;
if (length <= 1) {
return;
}
const maxIndex = this.tables().length - 1;
const index = this.currentIndex();
const nextIndex = (index + 1 + this.tables().length) % this.tables().length;
this.currentIndex(nextIndex);
}
public addTournament(tournamentId: number, model: TournamentDefinition) {
const tournament = new TournamentView(tournamentId, model);
this.tournaments.push(tournament);
return tournament;
}
public removeTournament(tournament: TournamentView) {
const tournaments = this.tournaments().filter(function(value) {
return value !== tournament;
});
this.tournaments(tournaments);
return tournament;
}
public removeTournamentById(tableId: number) {
const view = this.getTournamentById(tableId);
if (view === null) {
return null;
}
return this.removeTournament(view);
}
/**
* Handles notification about current turn of the player.
* @param tableId Number Id of the table where table playing.
*/
public onMyTurn(tableId: number) {
if (settings.autoSwitchTables()) {
this.selectById(tableId);
}
if (settings.soundEnabled()) {
// Added vibration.
}
}
/**
* Gets table view by id
* @param tableId Id of the player which join the table
* @returns Table view for the table with given id
*/
public getTableById(tableId: number) {
const result = this.tables().filter(function(value: TableView) {
return value.tableId === tableId;
});
if (result.length === 0) {
return null;
}
return result[0];
}
/**
* Gets tournament by it's id.
* tournamentId Number If of the tournament to retreive.
*/
public getTournamentById(tournamentId: number) {
const result = this.tournaments().filter(function(value: TournamentView) {
return value.tournamentId === tournamentId;
});
if (result.length === 0) {
return null;
}
return result[0];
}
public isOpened(tableId: number) {
return this.getTableById(tableId) != null;
}
/**
* Selects current table view by id.
* @param tableId Id of the table which selected
*/
public selectById(tableId: number): void {
const tables = this.tables();
for (let i = 0; i < tables.length; i++) {
const tableView = tables[i];
if (tableView.tableId === tableId) {
this.currentIndex(i);
return;
}
}
this.currentIndex(0);
}
private async getSittingTablesFromServer() {
const api = new Game(host);
const sittingTablesData = await api.getSitingTables();
const status = sittingTablesData.Status;
if (status === "Ok") {
const sittingTables = sittingTablesData.Data;
return sittingTables;
} else {
if (status === "AuthorizationError") {
return [];
} else {
throw new Error("Could not get current tables from server");
}
}
}
private async getSavedSittingTables() {
const tableIdString = localStorage.getItem("tableId");
if (tableIdString !== null) {
const tableId = parseInt(tableIdString, 10);
return [tableId];
}
return [];
}
private initializeChatHub(wrapper: ConnectionWrapper) {
const self = this;
const chatHub = wrapper.connection.Chat;
chatHub.client.ChatConnected = function(tableId, lastMessageId) {
if (wrapper.terminated) {
return;
}
self.logDataEvent("ChatConnected", tableId, lastMessageId);
const tableView = tableManager.getTableById(tableId);
if (tableView === null) {
return;
}
tableView.lastMessageId = lastMessageId;
};
chatHub.client.Message = function(messageId, tableId, type, sender, message) {
if (wrapper.terminated) {
return;
}
self.logDataEvent("Message", messageId, tableId, type, sender, message);
const tableView = tableManager.getTableById(tableId);
if (tableView === null) {
return;
}
if (type === "C") {
tableView.addMessage(messageId, sender, message);
}
if (type === "S") {
tableView.addSystemMessage(messageId, message);
}
if (type === "B") {
broadcastService.displayMessage(message);
}
};
chatHub.client.MessageChanged = function(messageId, tableId, type, sender, message) {
if (wrapper.terminated) {
return;
}
self.logDataEvent("MessageChanged", messageId, tableId, type, sender, message);
const tableView = tableManager.getTableById(tableId);
if (tableView === null) {
return;
}
if (type === "C") {
tableView.updateMessage(messageId, sender, message);
}
if (type === "S") {
tableView.updateSystemMessage(messageId, message);
}
};
}
private initializeGameHub(wrapper: ConnectionWrapper) {
const self = this;
const gameHub = wrapper.connection.Game;
gameHub.client.TableStatusInfo = function(
tableId, players, pots, cards, dealerSeat, buyIn,
baseBuyIn, leaveTime, timePass, currentPlayerId, lastRaise, gameId, authenticated,
actionsCount, frozen, opened, pauseDate, lastMessageId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onTableStatusInfo(players, pots, cards, dealerSeat, buyIn, baseBuyIn, leaveTime,
timePass, currentPlayerId, lastRaise, gameId, authenticated, actionsCount, frozen, opened,
pauseDate, lastMessageId);
const cardsArr = cards == null ? allNoneClasses : cardsArray(cards);
self.logDataEvent("Table status info: TableId - ", tableId, " Players - ", players, players.length,
" Pots - ", pots, " Cards - ", cardsArr.join(" "));
};
gameHub.client.GameStarted = function(tableId, gameId, players, actions, dealerSeat) {
if (wrapper.terminated) {
return;
}
self.clearBetEvents(tableId);
self.registerEvent(tableId, ["Game", "GameStarted", tableId, gameId, players, actions, dealerSeat]);
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onGameStarted(gameId, players, actions, dealerSeat);
self.logDataEvent("Game started: TableId - ", tableId, " GameId - ", gameId, " Players - ", players);
};
gameHub.client.Bet = function(tableId, playerId, type, amount, nextPlayerId, actionId) {
if (wrapper.terminated) {
return;
}
if (type !== 2 && type !== 3) {
self.registerEvent(tableId, ["Game", "Bet", tableId, playerId, type, amount, nextPlayerId, actionId]);
}
const tableView = tableManager.getTableById(tableId);
if (tableView === null) {
return;
}
tableView.onBet(playerId, type, amount, nextPlayerId);
let typeString = "Unknown";
switch (type) {
case 0:
typeString = "Blind";
break;
case 1:
typeString = "Ante";
break;
case 2:
typeString = "Check/Call";
break;
case 3:
typeString = "Bet/Raise";
break;
case 4:
typeString = "Fold";
break;
case 5:
typeString = "ForcedBet";
break;
case 6:
typeString = "ReturnMoney";
break;
default:
typeString = "Unknown bet type: " + type.toString();
break;
}
self.logDataEvent("Bet: TableId - ", tableId,
" PlayerId - ", playerId,
" Type - ", typeString,
" Amount - ", amount,
" Next Player Id - ", nextPlayerId);
};
gameHub.client.OpenCards = function(tableId, type, cards: string, pots: number[]) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onMoveMoneyToPot(pots);
tableView.onOpenCards(decodeCardsArray(cards));
let typeString: string;
switch (type) {
case 0:
typeString = "Flop";
break;
case 1:
typeString = "Turn";
break;
case 2:
typeString = "River";
break;
default:
typeString = "Unknown open cards type: " + type.toString();
break;
}
const cardsStrings = cardsArray(cards).join(" ");
self.logDataEvent(`Open cards: TableId - ${tableId} Type - ${typeString} Cards - ${cardsStrings}`);
};
gameHub.client.MoneyAdded = function(tableId, playerId, amount) {
if (wrapper.terminated) {
return;
}
self.logDataEvent("Money added: TableId - ", tableId, " PlayerId - ", playerId, " Amount - ", amount);
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onMoneyAdded(playerId, amount);
};
gameHub.client.MoneyRemoved = function(tableId, playerId, amount) {
if (wrapper.terminated) {
return;
}
self.logDataEvent("Money removed: TableId - ", tableId, " PlayerId - ", playerId, " Amount - ", amount);
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onMoneyRemoved(playerId, amount);
};
gameHub.client.PlayerCards = function(tableId, playerId, cards: string) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onPlayerCards(playerId, decodeCardsArray(cards));
const cardsString = cardsArray(cards).join(" ");
self.logDataEvent("Player cards: TableId - ", tableId, " PlayerId - ", playerId, " Cards - ", cardsString);
};
gameHub.client.PlayerCardOpened = (tableId, playerId, cardPosition, cardValue) => {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onPlayerCardOpened(playerId, cardPosition, cardValue);
this.logDataEvent("Player cards: TableId - ", tableId, " PlayerId - ", playerId, " Card on position - ", cardPosition, " with value - ", cardValue);
};
gameHub.client.PlayerCardsMucked = function(tableId, playerId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onPlayerCardsMucked(playerId);
self.logDataEvent("Cards mucked. TableId - ", tableId, " PlayerId - ", playerId);
};
gameHub.client.MoveMoneyToPot = function(tableId, amount) {
if (wrapper.terminated) {
return;
}
self.logDataEvent("TableId - ", tableId, " Amount - ", amount);
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
// tableView.onMoveMoneyToPot(amount);
};
gameHub.client.GameFinished = function(tableId, gameId, winners, rake) {
if (wrapper.terminated) {
return;
}
self.registerEvent(tableId, ["Game", "GameFinished", tableId, gameId, winners, rake]);
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
return;
}
tableView.onGameFinished(gameId, winners, rake);
self.logDataEvent("TableId - ", tableId, " GameId - ", gameId, " Winners - ", winners, " Rake - ", rake);
};
gameHub.client.PlayerStatus = function(tableId, playerId, status) {
if (wrapper.terminated) {
return;
}
const statusString = [];
if ((status & 1) !== 0) {
statusString.push("Sitout");
}
if ((status & 2) !== 0) {
statusString.push("Blocked");
}
if (statusString.length === 0) {
statusString.push("Regular");
}
if ((status & 8) !== 0) {
statusString.push("InGame");
}
self.logDataEvent("TableId - ", tableId, " PlayerId - ", playerId, " Status - ", statusString.join("+"));
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
// tslint:disable-next-line:no-console
console.warn("Receive unexpected PlayerStatus(" + tableId + "," + playerId + "," + status + ")");
return;
}
tableView.onPlayerStatus(playerId, status);
};
gameHub.client.Sit = function(tableId, playerId, playerName, seat, amount, playerUrl, points, stars) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected Sit(" + tableId + "," + playerId + "," + playerName + ")");
return;
}
self.logDataEvent("Sit: TableId - ", tableId, " PlayerId - ", playerId, " PlayerName- ", playerName);
tableView.onSit(playerId, seat, playerName, amount, playerUrl, points, stars);
};
gameHub.client.Standup = function(tableId, playerId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected Standup(" + tableId + "," + playerId + ")");
return;
}
self.logDataEvent("Standup: TableId - ", tableId, " PlayerId - ", playerId);
tableView.onStandup(playerId);
};
gameHub.client.TableFrozen = function(tableId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected TableFrozen(" + tableId + ")");
return;
}
tableView.onFrozen();
};
gameHub.client.TableUnfrozen = function(tableId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected TableUnfrozen(" + tableId + ")");
return;
}
tableView.onUnfrozen();
};
gameHub.client.TableOpened = function(tableId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected TableOpened(" + tableId + ")");
return;
}
tableView.onOpened();
};
gameHub.client.TableClosed = function(tableId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected TableClosed(" + tableId + ")");
return;
}
tableView.onClosed();
};
gameHub.client.TablePaused = function(tableId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected TablePaused(" + tableId + ")");
return;
}
tableView.onPaused();
};
gameHub.client.TableResumed = function(tableId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected TableResumed(" + tableId + ")");
return;
}
tableView.onResumed();
};
gameHub.client.FinalTableCardsOpened = function(tableId, cards) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn("Receive unexpected FinalTableCardsOpened(" + tableId + "," + cards + ")");
return;
}
tableView.onFinalTableCardsOpened(decodeCardsArray(cards));
};
gameHub.client.TableBetParametersChanged = function(tableId, smallBind, bigBlind, ante) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn(`Receive unexpected TableBetParametersChanged(${tableId},${smallBind},${bigBlind},${ante}`);
return;
}
tableView.onTableBetParametersChanged(smallBind, bigBlind, ante);
};
gameHub.client.TableTournamentChanged = function(tableId, tournamentId) {
if (wrapper.terminated) {
return;
}
const tableView = tableManager.getTableById(tableId);
if (tableView == null) {
console.warn(`Receive unexpected TableTournamentChanged(${tableId}, ${tournamentId})`);
return;
}
tableView.onTableTournamentChanged(tournamentId);
};
gameHub.client.TournamentStatusChanged = function(tournamentId, status) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentStatusChanged(" + tournamentId + "," + status + ")");
return;
}
tournamentView.onTournamentStatusChanged(status);
};
gameHub.client.TournamentTableChanged = function(tournamentId, tableId) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentTableChanged(" + tournamentId + "," + tableId + ")");
return;
}
tournamentView.onTournamentTableChanged(tableId);
};
gameHub.client.TournamentPlayerGameCompleted = function(tournamentId, placeTaken) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentPlayerGameCompleted(" + tournamentId + "," + placeTaken + ")");
return;
}
tournamentView.onTournamentPlayerGameCompleted(placeTaken);
};
gameHub.client.TournamentBetLevelChanged = function(tournamentId, level) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentBetLevelChanged(" + tournamentId + "," + level + ")");
return;
}
tournamentView.onTournamentBetLevelChanged(level);
};
gameHub.client.TournamentRoundChanged = function(tournamentId, round) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentRoundChanged(" + tournamentId + "," + round + ")");
return;
}
tournamentView.onTournamentRoundChanged(round);
};
gameHub.client.TournamentRebuyStatusChanged = function(tournamentId, rebuyAllowed, addonAllowed) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentRebuyStatusChanged(" + tournamentId + ","
+ rebuyAllowed + "," + addonAllowed + ")");
return;
}
tournamentView.onTournamentRebuyStatusChanged(rebuyAllowed, addonAllowed);
};
gameHub.client.TournamentRebuyCountChanged = function(tournamentId, rebuyCount, addonCount) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentRebuyCountChanged(" + tournamentId + "," + rebuyCount + "," + addonCount + ")");
return;
}
tournamentView.onTournamentRebuyCountChanged(rebuyCount, addonCount);
};
gameHub.client.TournamentFrozen = function(tournamentId) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentFrozen(" + tournamentId + ")");
return;
}
tournamentView.onTournamentFrozen();
};
gameHub.client.TournamentUnfrozen = function(tournamentId) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView == null) {
console.warn("Receive unexpected TournamentUnfrozen(" + tournamentId + ")");
return;
}
tournamentView.onTournamentUnfrozen();
};
gameHub.client.TournamentRegistration = function(tournamentId) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView != null) {
console.warn("Receive unexpected TournamentRegistration(" + tournamentId + ")");
return;
}
self.openTournamentById(tournamentId);
};
gameHub.client.TournamentRegistrationCancelled = function(tournamentId) {
if (wrapper.terminated) {
return;
}
const tournamentView = tableManager.getTournamentById(tournamentId);
if (tournamentView === null) {
console.warn("Receive unexpected TournamentRegistrationCancelled(" + tournamentId + ")");
return;
}
tournamentView.onTournamentRegistrationCancelled();
gameHub.server.unsubscribeTournament(tournamentId);
tableManager.removeTournamentById(tournamentId);
};
}
/**
* Remove all tables from the given tournament
*/
private removeTournamentTables(tournamentId: number) {
const tables = this.tables()
.filter((table) => table.tournament() === null || table.tournament().tournamentId !== tournamentId);
this.tables(tables);
}
private requestTournamentsInformation(tournaments: TournamentPlayerStateDefinition[]) {
const self = this;
const deferreds = [] as Array<Promise<TournamentDefinition>>;
for (let i = 0; i < tournaments.length; i++) {
const tournamentPlayerState = tournaments[i];
const d = this.buildTournamentInformationRequest(
tournamentPlayerState.TournamentId,
tournamentPlayerState.TableId);
deferreds.push(d);
}
return Promise.all(deferreds);
}
private async buildTournamentInformationRequest(tournamentId: number, tableId: number): Promise<TournamentDefinition> {
const self = this;
const gapi = new Game(host);
const tapi = new Tournament(host);
const data = await tapi.getTournament(tournamentId);
const tournamentData = data.Data;
self.selectTournament(tournamentData, false);
if (tableId != null) {
const tableData = await gapi.getTableById(tableId);
self.selectTable(tableData.Data, false);
const tournamentTableView = self.getTableById(tableId);
const tournamentView = self.getTournamentById(tournamentId);
tournamentTableView.tournament(tournamentView);
}
return tournamentData;
}
/**
* Remove closed table
*/
private removeClosedTables() {
const tables = this.tables();
let tableId = null;
for (const t in tables) {
if (!tables.hasOwnProperty(t)) {
continue;
}
const table = tables[t];
if (!table.opened()) {
tableId = table.tableId;
break;
}
}
if (tableId === null) {
return;
}
this.removeTableById(tableId);
}
private registerEvent(tableId: number, data: any[]) {
const finder = this.getDuplicator(tableId);
finder.registerEvent(data);
if (finder.validateDuplicateEvents()) {
finder.printDebug();
slowInternetService.showDuplicatedConnectionPopup();
}
}
private clearBetEvents(tableId: number) {
const finder = this.getDuplicator(tableId);
finder.erase((value, index, c) => {
return value[1] !== "Bet";
});
}
private getDuplicator(tableId: number) {
let finder = this.duplicators[tableId];
if (finder == null) {
finder = new DuplicateFinder();
this.duplicators[tableId] = finder;
}
return finder;
}
private logDataEvent(message: any, ...optionalParams: any[]) {
if (debugSettings.connection.signalR && debugSettings.connection.dataEvents) {
console.log(message, optionalParams);
}
}
}
export const tableManager = new TableManager();