1051 lines
46 KiB
TypeScript
1051 lines
46 KiB
TypeScript
import 'reflect-metadata';
|
|
export declare class GameEventContract implements Core.EventSystem.EventContract {
|
|
type: any;
|
|
callback: Function;
|
|
expired: boolean;
|
|
broken: boolean;
|
|
register(type: any, callback: Function): void;
|
|
off(): void;
|
|
on(): void;
|
|
break(): void;
|
|
}
|
|
import { GameEventContract } from "./game-event-contract";
|
|
export declare class GameEventListener implements Core.EventSystem.EventListener {
|
|
private listEventContract;
|
|
getContract(): GameEventContract[];
|
|
register(type: any, callback: Function): Core.EventSystem.EventContract;
|
|
}
|
|
import { GameEventListener } from "./game-event-listener";
|
|
export declare class GameEventPublisher implements Core.EventSystem.EventPublisher {
|
|
private listEventListener;
|
|
add(listener: GameEventListener): void;
|
|
emit(type: any): void;
|
|
private executeListenerCallback;
|
|
private removeBrokenContract;
|
|
}
|
|
export declare class BetConstantParameter implements Core.Parameter.BetConstantParameter {
|
|
get DEFAULT_LIST_BET_OPTION(): number[];
|
|
}
|
|
export declare const COMMAND: {
|
|
Default: symbol;
|
|
Target: symbol;
|
|
Decorator: symbol;
|
|
PlaceBet: symbol;
|
|
ClearBet: symbol;
|
|
ClearAllBet: symbol;
|
|
DoubleBet: symbol;
|
|
Rebet: symbol;
|
|
ResetBet: symbol;
|
|
};
|
|
export declare const UNDO_MANAGER: {
|
|
Bet: symbol;
|
|
};
|
|
export declare const CONTROLLER: {
|
|
Default: symbol;
|
|
Game: symbol;
|
|
Room: symbol;
|
|
Bet: symbol;
|
|
BetOption: symbol;
|
|
Balance: symbol;
|
|
Countdown: symbol;
|
|
Statistic: symbol;
|
|
Odds: symbol;
|
|
History: symbol;
|
|
BetLimit: symbol;
|
|
RoundResult: symbol;
|
|
Win: symbol;
|
|
Error: symbol;
|
|
LoungeBetLimit: symbol;
|
|
LoungeBetOption: symbol;
|
|
};
|
|
export declare const CONTROLLER_EVENT_PUBLISHER: {
|
|
Default: symbol;
|
|
};
|
|
export declare const CONTROLLER_EVENT_LISTENER: {
|
|
Default: symbol;
|
|
};
|
|
export declare const GAME_VIEW: {
|
|
Bet: symbol;
|
|
BetOption: symbol;
|
|
Countdown: symbol;
|
|
Statistic: symbol;
|
|
Odds: symbol;
|
|
Balance: symbol;
|
|
History: symbol;
|
|
BetLimit: symbol;
|
|
RoundResult: symbol;
|
|
Win: symbol;
|
|
Error: symbol;
|
|
Lounge: symbol;
|
|
};
|
|
export declare const MODEL: {
|
|
ApplicationConfig: symbol;
|
|
BetLimit: symbol;
|
|
RemainBalance: symbol;
|
|
BetBalance: symbol;
|
|
Bet: symbol;
|
|
Rebet: symbol;
|
|
BetPosition: symbol;
|
|
ListBetOption: symbol;
|
|
SelectedBetOption: symbol;
|
|
RoomIndex: symbol;
|
|
BetConflict: symbol;
|
|
ListBetConflict: symbol;
|
|
History: symbol;
|
|
RoundRecord: symbol;
|
|
Statistic: symbol;
|
|
ListOdds: symbol;
|
|
RoundResult: symbol;
|
|
Win: symbol;
|
|
Countdown: symbol;
|
|
Error: symbol;
|
|
HttpServer: symbol;
|
|
ListRoomBetOption: symbol;
|
|
ListRoomBetLimit: symbol;
|
|
};
|
|
export declare const NETWORK_CONNECTOR: {
|
|
Default: symbol;
|
|
EventProcessor: symbol;
|
|
};
|
|
export declare const NETWORK_REQUEST: {
|
|
Default: symbol;
|
|
};
|
|
export declare const NETWORK_RESPONSE: {
|
|
Default: symbol;
|
|
OnConnect: symbol;
|
|
OnConnectRetry: symbol;
|
|
OnDisconnect: symbol;
|
|
OnLogout: symbol;
|
|
OnRoomJoin: symbol;
|
|
OnMessageData: symbol;
|
|
OnError: symbol;
|
|
OnLoginError: symbol;
|
|
OnBetLimit: symbol;
|
|
OnBalance: symbol;
|
|
OnGameStart: symbol;
|
|
OnBetSettings: symbol;
|
|
OnStatistic: symbol;
|
|
OnRoundStart: symbol;
|
|
OnResult: symbol;
|
|
OnWin: symbol;
|
|
OnRoundEnd: symbol;
|
|
OnConfirmBetSuccessfully: symbol;
|
|
OnConfirmBetFailed: symbol;
|
|
OnOdds: symbol;
|
|
};
|
|
export declare const NETWORK_COMMAND: {
|
|
Connect: symbol;
|
|
JoinRoom: symbol;
|
|
StartNewRound: symbol;
|
|
ConfirmBet: symbol;
|
|
CollectPoint: symbol;
|
|
};
|
|
export declare const NETWORK_EVENT_PUBLISHER: {
|
|
Default: symbol;
|
|
};
|
|
export declare const NETWORK_EVENT_LISTENER: {
|
|
Default: symbol;
|
|
};
|
|
export declare const DATA_PROCESSOR: {
|
|
Default: symbol;
|
|
Chain: symbol;
|
|
};
|
|
export declare const HTTP_RESPONSE: {
|
|
Success: symbol;
|
|
Failed: symbol;
|
|
Invalid: symbol;
|
|
Error: symbol;
|
|
};
|
|
export declare const PARAMETER: {
|
|
BetConstant: symbol;
|
|
GameConstant: symbol;
|
|
};
|
|
export declare const AVAILABLE_BET_CALCULATOR: unique symbol;
|
|
export declare const VALIDATOR: {
|
|
EnoughBalanceToBet: symbol;
|
|
BetConflict: symbol;
|
|
BetPointBelowMaxBetLimit: symbol;
|
|
TotalBetBelowMaxTotalBetLimit: symbol;
|
|
BetForbidden: symbol;
|
|
EmptyBetTable: symbol;
|
|
};
|
|
export type StateMachineKeys = {
|
|
EventManager: symbol;
|
|
StateMachine: symbol;
|
|
};
|
|
export declare const CONTROLLER_STATE_MACHINE: {
|
|
Game: {
|
|
StateMachine: symbol;
|
|
EventManager: symbol;
|
|
};
|
|
Bet: {
|
|
StateMachine: symbol;
|
|
EventManager: symbol;
|
|
};
|
|
BetOption: {
|
|
StateMachine: symbol;
|
|
EventManager: symbol;
|
|
};
|
|
Room: {
|
|
StateMachine: symbol;
|
|
EventManager: symbol;
|
|
};
|
|
};
|
|
export declare const STATE_CONTEXT: unique symbol;
|
|
export declare const DEFAULT_STATE: unique symbol;
|
|
export declare const LIST_STATE_TRANSITION_CREATOR: unique symbol;
|
|
export declare const LIST_STATE_TRANSITION_ASSERTOR: {
|
|
Default: symbol;
|
|
Chain: symbol;
|
|
};
|
|
import { Container } from "inversify";
|
|
declare const container: Container;
|
|
export { container };
|
|
export declare class AvailableBetCalculator implements Core.Service.AvailableBetCalculator {
|
|
private betModel;
|
|
private currentBetLimitModel;
|
|
private remainBalanceModel;
|
|
private listBetOptionModel;
|
|
private betConstantParameter;
|
|
constructor(betModel: Core.Model.BetModel, currentBetLimitModel: Core.Model.BetLimitModel, remainBalanceModel: Core.Model.BalanceModel, listBetOptionModel: Core.Model.ListBetOptionModel, betConstantParameter: Core.Parameter.BetConstantParameter);
|
|
getAvailableBet(betPositionIndex: number): number;
|
|
private getAvailableBetPoint;
|
|
private getAvailableTotalBet;
|
|
}
|
|
export declare abstract class ChainDataProcessor implements Core.Network.DataProcessor {
|
|
private nextDataProcessor;
|
|
constructor(nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
}
|
|
import { CommandWrapper } from "./command-wrapper";
|
|
export declare abstract class CommandProxy extends CommandWrapper {
|
|
execute(): void;
|
|
protected handleValidateFailed(): void;
|
|
protected abstract validate(): boolean;
|
|
}
|
|
export declare abstract class CommandWrapper implements Core.Pattern.Command {
|
|
protected targetCommand: Core.Pattern.Command;
|
|
constructor(targetCommand: Core.Pattern.Command);
|
|
execute(): void;
|
|
}
|
|
export declare class UndoManager implements Core.Pattern.UndoManager {
|
|
private undoableQueue;
|
|
push(undoable: Core.Pattern.Undoable): void;
|
|
undo(): void;
|
|
isUndoable(): boolean;
|
|
reset(): void;
|
|
private removeUndoable;
|
|
}
|
|
export declare class BetConflictValidator implements Core.Service.Validator {
|
|
private betModel;
|
|
private betPositionModel;
|
|
private listBetConflictModel;
|
|
constructor(betModel: Core.Model.BetModel, betPositionModel: Core.Model.BetPositionModel, listBetConflictModel: Core.Model.ListBetConflictModel);
|
|
validate(): boolean;
|
|
private isConflict;
|
|
}
|
|
export declare class BetPointBelowMaxBetLimitValidator implements Core.Service.Validator {
|
|
private betPositionModel;
|
|
private betModel;
|
|
private betLimitModel;
|
|
constructor(betPositionModel: Core.Model.BetPositionModel, betModel: Core.Model.BetModel, betLimitModel: Core.Model.BetLimitModel);
|
|
validate(): boolean;
|
|
}
|
|
export declare class EnoughBalanceToBetValidator implements Core.Service.Validator {
|
|
private listBetOptionModel;
|
|
private remainBalanceModel;
|
|
private betConstantParameter;
|
|
constructor(listBetOptionModel: Core.Model.ListBetOptionModel, remainBalanceModel: Core.Model.BalanceModel, betConstantParameter: Core.Parameter.BetConstantParameter);
|
|
validate(): boolean;
|
|
}
|
|
export declare class TotalBetBelowMaxTotalBetLimitValidator implements Core.Service.Validator {
|
|
private betModel;
|
|
private betLimitModel;
|
|
constructor(betModel: Core.Model.BetModel, betLimitModel: Core.Model.BetLimitModel);
|
|
validate(): boolean;
|
|
}
|
|
export declare class EmptyBetTableValidator implements Core.Service.Validator {
|
|
private betModel;
|
|
constructor(betModel: Core.Model.BetModel);
|
|
validate(): boolean;
|
|
}
|
|
export declare abstract class ListStateTransitionCreator<T extends Core.State.State> implements Core.State.ListStateTransitionCreator<T> {
|
|
private assertor;
|
|
constructor(assertor: Core.State.ListStateTransitionAssertor<T>);
|
|
create(): Core.State.ListStateTransition<T>;
|
|
protected abstract getListStateTransition(): Core.State.ListStateTransition<T>;
|
|
}
|
|
export declare abstract class ChainListStateTransitionAssertor<T extends Core.State.State> implements Core.State.ListStateTransitionAssertor<T> {
|
|
private nextAssertor?;
|
|
constructor(nextAssertor?: Core.State.ListStateTransitionAssertor<T>);
|
|
assert(listStateTransition: Core.State.ListStateTransition<T>): void;
|
|
protected abstract _assert(listStateTransition: Core.State.ListStateTransition<T>): void;
|
|
}
|
|
import { ChainListStateTransitionAssertor } from "./chain-list-state-transition-assertor";
|
|
export declare class ListStateTransitionDuplicateAssertor extends ChainListStateTransitionAssertor<Core.State.State> {
|
|
protected _assert(listStateTransition: Core.State.ListStateTransition<Core.State.State>): void;
|
|
private convertTransitionToString;
|
|
private isDuplicateTransition;
|
|
private isSameFromState;
|
|
private isSameEvent;
|
|
}
|
|
import { ChainListStateTransitionAssertor } from "./chain-list-state-transition-assertor";
|
|
export declare class ListStateTransitionInheritanceAssertor extends ChainListStateTransitionAssertor<Core.State.State> {
|
|
protected _assert(listStateTransition: Core.State.ListStateTransition<Core.State.State>): void;
|
|
private getListState;
|
|
private assertNoStateInheritance;
|
|
private throwErrorIfInherited;
|
|
private isInheritedState;
|
|
}
|
|
export declare function registerStateMachineNetworkEvent(listNetworkEvent: symbol[], stateMachine: Core.State.StateMachine<Core.State.State>): void;
|
|
import { StateMachineKeys } from "../ioc-config/ioc-config-state";
|
|
export declare function setupStateMachineEventManager(stateMachineKeys: StateMachineKeys): void;
|
|
export declare class StateContext<T extends Core.State.State> implements Core.State.StateContext<T> {
|
|
protected currentState: T;
|
|
constructor(defaultState: T);
|
|
setState(state: T): void;
|
|
getState(): T;
|
|
}
|
|
export declare class StateMachineEventManager implements Core.State.StateMachineEventManager {
|
|
private listStateMachine;
|
|
registerStateMachine(stateMachine: Core.State.StateMachine<Core.State.State>): void;
|
|
unregisterStateMachine(stateMachine: Core.State.StateMachine<Core.State.State>): void;
|
|
emit(event: symbol): void;
|
|
}
|
|
export declare class StateMachine<T extends Core.State.State> implements Core.State.StateMachine<T> {
|
|
protected stateContext: Core.State.StateContext<T>;
|
|
private listStateTransition;
|
|
constructor(stateContext: Core.State.StateContext<T>, listStateTransitionCreator: Core.State.ListStateTransitionCreator<T>);
|
|
getState(): T;
|
|
changeState(event: Symbol): void;
|
|
private getTransition;
|
|
private executeTransition;
|
|
}
|
|
import { interfaces } from "inversify";
|
|
declare class BindingHelper {
|
|
targetNamed(request: interfaces.Request, name: string | number | symbol): boolean;
|
|
targetTagged(request: interfaces.Request, key: string | number | symbol, value: unknown): boolean;
|
|
targetIsDefault(request: interfaces.Request): boolean;
|
|
injectInto(request: interfaces.Request, parent: (NewableFunction | string)): boolean;
|
|
parentNamed(request: interfaces.Request, name: string | number | symbol): boolean;
|
|
parentTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean;
|
|
anyAncestorIs(request: interfaces.Request, ancestor: (NewableFunction | string)): boolean;
|
|
noAncestorIs(request: interfaces.Request, ancestor: (NewableFunction | string)): boolean;
|
|
anyAncestorTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean;
|
|
noAncestorTagged(request: interfaces.Request, tag: string | number | symbol, value: unknown): boolean;
|
|
anyAncestorNamed(request: interfaces.Request, name: string | number | symbol): boolean;
|
|
noAncestorNamed(request: interfaces.Request, name: string | number | symbol): boolean;
|
|
}
|
|
declare var when: BindingHelper;
|
|
export { when };
|
|
import { interfaces } from 'inversify';
|
|
declare function customServiceLocator(container: interfaces.Container, doCache?: boolean): {
|
|
customInject: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (proto: any, key: string) => void;
|
|
customInjectNamed: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, named: string) => (proto: any, key: string) => void;
|
|
customInjectTagged: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, key: string, value: any) => (proto: any, propertyName: string) => void;
|
|
customMultiInject: (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>) => (proto: any, key: string) => void;
|
|
};
|
|
export { customServiceLocator };
|
|
import { interfaces } from "inversify";
|
|
interface DependencyBranch {
|
|
from(type: any): DependencyGraphHelper;
|
|
}
|
|
declare class DependencyGraphHelper implements DependencyBranch {
|
|
private container;
|
|
private graphs;
|
|
private isBranching;
|
|
private branchNode;
|
|
private isSingletonGraph;
|
|
inSingletonScope(): DependencyGraphHelper;
|
|
bind(identifier: any, type: any, isConstant?: boolean): DependencyGraphHelper;
|
|
branch(identifier: any, type: any, isConstant?: boolean): DependencyBranch;
|
|
from(type: any): DependencyGraphHelper;
|
|
registerTo(container: interfaces.Container): void;
|
|
private registerGraphToContainer;
|
|
private resetGraph;
|
|
private bindInSingletonScopeTo;
|
|
private bindTo;
|
|
private bindToConstant;
|
|
private recursiveCheckBindingCondition;
|
|
}
|
|
declare var dependencyGraph: DependencyGraphHelper;
|
|
export { dependencyGraph };
|
|
export declare class BalanceController implements Core.Controller.BalanceController {
|
|
private betBalanceModel;
|
|
private remainBalanceModel;
|
|
private balanceGameView;
|
|
constructor(betBalanceModel: Core.Model.BalanceModel, remainBalanceModel: Core.Model.BalanceModel, balanceGameView: Core.View.GameView);
|
|
updateBalance(credit: number, freeCredit: number): void;
|
|
releaseBetCredit(): void;
|
|
withdraw(amount: number): void;
|
|
deposit(amount: number): void;
|
|
private getBalanceModelName;
|
|
private transferCredit;
|
|
private calculateTransferAmounts;
|
|
private resetBetBalance;
|
|
}
|
|
export declare class ClearAllBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable {
|
|
private betModel;
|
|
private remainBalanceModel;
|
|
private balanceController;
|
|
private errorController;
|
|
private betUndoManager;
|
|
private betGameView;
|
|
private listReturnBetPoint;
|
|
private get totalReturnBetPoint();
|
|
constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, errorController: Core.Controller.ErrorController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView);
|
|
execute(): void;
|
|
undo(onSuccess?: Function): void;
|
|
}
|
|
export declare class ClearBetCommand implements Core.Pattern.Command {
|
|
private betPositionModel;
|
|
private betModel;
|
|
private controllerEventPublisher;
|
|
private balanceController;
|
|
constructor(betPositionModel: Core.Model.BetPositionModel, betModel: Core.Model.BetModel, controllerEventPublisher: Core.EventSystem.EventPublisher, balanceController: Core.Controller.BalanceController);
|
|
execute(): void;
|
|
}
|
|
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
|
|
export declare class CheckBetConflictCommandProxy extends CommandProxy {
|
|
private betConflictValidator;
|
|
private errorController;
|
|
constructor(targetCommand: Core.Pattern.Command, betConflictValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
|
|
protected validate(): boolean;
|
|
protected handleValidateFailed(): void;
|
|
}
|
|
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
|
|
export declare class CheckEmptyBetTableCommandProxy extends CommandProxy {
|
|
private emptyBetTableValidator;
|
|
constructor(targetCommand: Core.Pattern.Command, emptyBetTableValidator: Core.Service.Validator);
|
|
protected validate(): boolean;
|
|
}
|
|
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
|
|
export declare class CheckEnoughBalanceCommandProxy extends CommandProxy {
|
|
private enoughBalanceToBetValidator;
|
|
private errorController;
|
|
constructor(targetCommand: Core.Pattern.Command, enoughBalanceToBetValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
|
|
protected validate(): boolean;
|
|
protected handleValidateFailed(): void;
|
|
}
|
|
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
|
|
export declare class CheckMaxBetLimitCommandProxy extends CommandProxy {
|
|
private betPointBelowMaxBetLimitValidator;
|
|
private errorController;
|
|
constructor(targetCommand: Core.Pattern.Command, betPointBelowMaxBetLimitValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
|
|
protected validate(): boolean;
|
|
protected handleValidateFailed(): void;
|
|
}
|
|
import { CommandProxy } from "../../../../../common/service/command/command-proxy";
|
|
export declare class CheckMaxTotalBetLimitCommandProxy extends CommandProxy {
|
|
private totalBetBelowMaxTotalBetLimitValidator;
|
|
private errorController;
|
|
constructor(targetCommand: Core.Pattern.Command, totalBetBelowMaxTotalBetLimitValidator: Core.Service.Validator, errorController: Core.Controller.ErrorController);
|
|
protected validate(): boolean;
|
|
protected handleValidateFailed(): void;
|
|
}
|
|
import { CommandWrapper } from "../../../../../common/service/command/command-wrapper";
|
|
export declare class DoubleBetCommandWrapper extends CommandWrapper {
|
|
}
|
|
import { PlaceMultiBetCommand } from "../place-multi-bet/place-multi-bet-command";
|
|
import { PlaceMultiBetData } from "../place-multi-bet/place-multi-bet-data";
|
|
export declare class DoubleBetCommand extends PlaceMultiBetCommand {
|
|
constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator);
|
|
protected getTargetPlaceMultiBetData(): PlaceMultiBetData;
|
|
}
|
|
import { CommandWrapper } from "../../../../../common/service/command/command-wrapper";
|
|
export declare class PlaceBetCommandWrapper extends CommandWrapper {
|
|
}
|
|
export declare class PlaceBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable {
|
|
protected betPositionModel: Core.Model.BetPositionModel;
|
|
protected selectedBetOptionModel: Core.Model.SelectedBetOptionModel;
|
|
protected betModel: Core.Model.BetModel;
|
|
protected availableBetCalculator: Core.Service.AvailableBetCalculator;
|
|
protected betUndoManager: Core.Pattern.UndoManager;
|
|
private balanceController;
|
|
private betGameView;
|
|
constructor(betPositionModel: Core.Model.BetPositionModel, selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betModel: Core.Model.BetModel, availableBetCalculator: Core.Service.AvailableBetCalculator, betUndoManager: Core.Pattern.UndoManager, balanceController: Core.Controller.BalanceController, betGameView: Core.View.GameView);
|
|
protected placeBetPositionIndex: number;
|
|
protected placedBetValue: number;
|
|
execute(): void;
|
|
undo(onSuccess?: Function): void;
|
|
private placeBet;
|
|
}
|
|
import { PlaceMultiBetData } from "./place-multi-bet-data";
|
|
export declare abstract class PlaceMultiBetCommand implements Core.Pattern.Command, Core.Pattern.Undoable {
|
|
protected betModel: Core.Model.BetModel;
|
|
protected remainBalanceModel: Core.Model.BalanceModel;
|
|
protected balanceController: Core.Controller.BalanceController;
|
|
protected betUndoManager: Core.Pattern.UndoManager;
|
|
protected betGameView: Core.View.GameView;
|
|
private availableBetCalculator;
|
|
private listPlacedBet;
|
|
constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator);
|
|
execute(): void;
|
|
undo(onSuccess?: Function): void;
|
|
private registerUndo;
|
|
private adjustBets;
|
|
private adjustBetsToAvailableBet;
|
|
private adjustBetsToBalance;
|
|
protected abstract getTargetPlaceMultiBetData(): PlaceMultiBetData;
|
|
}
|
|
export type PlaceMultiBetData = {
|
|
betPositionIndex: number;
|
|
betPoint: number;
|
|
}[];
|
|
import { CommandWrapper } from "../../../../../common/service/command/command-wrapper";
|
|
export declare class RebetCommandWrapper extends CommandWrapper {
|
|
}
|
|
import { PlaceMultiBetCommand } from "../place-multi-bet/place-multi-bet-command";
|
|
import { PlaceMultiBetData } from "../place-multi-bet/place-multi-bet-data";
|
|
export declare class RebetCommand extends PlaceMultiBetCommand {
|
|
private rebetModel;
|
|
constructor(betModel: Core.Model.BetModel, remainBalanceModel: Core.Model.BalanceModel, balanceController: Core.Controller.BalanceController, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView, availableBetCalculator: Core.Service.AvailableBetCalculator, rebetModel: Core.Model.BetModel);
|
|
protected getTargetPlaceMultiBetData(): PlaceMultiBetData;
|
|
}
|
|
export declare class ResetBetCommand implements Core.Pattern.Command {
|
|
private balanceController;
|
|
private betBalanceModel;
|
|
private betModel;
|
|
private betUndoManager;
|
|
private betGameView;
|
|
constructor(balanceController: Core.Controller.BalanceController, betBalanceModel: Core.Model.BalanceModel, betModel: Core.Model.BetModel, betUndoManager: Core.Pattern.UndoManager, betGameView: Core.View.GameView);
|
|
execute(): void;
|
|
private returnBetPointToBalance;
|
|
private resetBet;
|
|
}
|
|
export declare class BetController implements Core.Controller.BetController {
|
|
private betControllerStateMachine;
|
|
constructor(betControllerStateMachine: Core.State.BetControllerStateMachine);
|
|
placeBet(betPositionIndex: number): void;
|
|
clearBet(betPositionIndex: number): void;
|
|
clearAllBet(): void;
|
|
doubleBet(): void;
|
|
rebet(): void;
|
|
undo(): void;
|
|
reset(): void;
|
|
}
|
|
export declare class BetControllerDisableState implements Core.State.BetControllerState {
|
|
placeBet(): void;
|
|
clearBet(): void;
|
|
clearAllBet(): void;
|
|
doubleBet(): void;
|
|
undo(): void;
|
|
rebet(): void;
|
|
reset(): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
}
|
|
export declare class BetControllerEnableState implements Core.State.BetControllerState {
|
|
private betPositionModel;
|
|
private betUndoManager;
|
|
constructor(betPositionModel: Core.Model.BetPositionModel, betUndoManager: Core.Pattern.UndoManager);
|
|
placeBet(betPositionIndex: number): void;
|
|
clearBet(betPositionIndex: number): void;
|
|
clearAllBet(): void;
|
|
doubleBet(): void;
|
|
rebet(): void;
|
|
undo(): void;
|
|
reset(): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
}
|
|
export declare const BET_CONTROLLER_EVENT: {
|
|
Enable: symbol;
|
|
Disable: symbol;
|
|
};
|
|
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
|
|
export declare class BetControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.BetControllerState> {
|
|
protected getListStateTransition(): Core.State.ListStateTransition<Core.State.BetControllerState>;
|
|
}
|
|
import { StateContext } from "../../../../common/state/state-context";
|
|
export declare class BetControllerStateContext extends StateContext<Core.State.BetControllerState> implements BetControllerStateContext {
|
|
}
|
|
import { StateMachine } from "../../../../common/state/state-machine";
|
|
export declare class BetControllerStateMachine extends StateMachine<Core.State.BetControllerState> {
|
|
}
|
|
export declare class BetLimitController implements Core.Controller.BetLimitController {
|
|
private betLimitModel;
|
|
private betLimitGameView;
|
|
constructor(betLimitModel: Core.Model.BetLimitModel, betLimitGameView: Core.View.GameView);
|
|
updateCurrentBetLimit(betLimitModel: Core.Model.BetLimitModel): void;
|
|
}
|
|
export declare class LoungeBetLimitController implements Core.Controller.LoungeBetLimitController {
|
|
private listRoomBetLimitModel;
|
|
private loungeGameView;
|
|
constructor(listRoomBetLimitModel: Core.Model.ListRoomBetLimitModel, loungeGameView: Core.View.GameView);
|
|
updateBetLimitSetting(listBetLimitSetting: Core.Model.BetLimitModel[]): void;
|
|
}
|
|
export declare class BetOptionController implements Core.Controller.BetOptionController {
|
|
private listBetOptionModel;
|
|
private selectedBetOptionModel;
|
|
private betOptionGameView;
|
|
private betOptionControllerStateMachine;
|
|
constructor(listBetOptionModel: Core.Model.ListBetOptionModel, selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betOptionGameView: Core.View.GameView, betOptionControllerStateMachine: Core.State.StateMachine<Core.State.BetOptionControllerState>);
|
|
updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
|
|
changeBetOption(betOption: number): void;
|
|
}
|
|
export declare class LoungeBetOptionController implements Core.Controller.LoungeBetOptionController {
|
|
private listRoomBetOptionModel;
|
|
private loungeGameView;
|
|
constructor(listRoomBetOptionModel: Core.Model.ListRoomBetOptionModel, loungeGameView: Core.View.GameView);
|
|
updateBetOptionSetting(listBetOptionSetting: Core.Model.ListBetOptionModel[]): void;
|
|
}
|
|
export declare class BetOptionControllerDisableState implements Core.State.BetOptionControllerState {
|
|
updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
|
|
changeBetOption(betOption: number): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
}
|
|
export declare class BetOptionControllerEnableState implements Core.State.BetOptionControllerState {
|
|
private selectedBetOptionModel;
|
|
private betOptionGameView;
|
|
constructor(selectedBetOptionModel: Core.Model.SelectedBetOptionModel, betOptionGameView: Core.View.GameView);
|
|
changeBetOption(betOption: number): void;
|
|
updateListBetOption(listBetOption: number[], defaultBetOption: number): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
}
|
|
export declare const BET_OPTION_CONTROLLER_EVENT: {
|
|
Disable: symbol;
|
|
Enable: symbol;
|
|
};
|
|
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
|
|
export declare class BetOptionControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.BetOptionControllerState> {
|
|
protected getListStateTransition(): Core.State.ListStateTransition<Core.State.BetOptionControllerState>;
|
|
}
|
|
import { StateContext } from "../../../../common/state/state-context";
|
|
export declare class BetOptionControllerStateContext extends StateContext<Core.State.BetOptionControllerState> implements Core.State.BetOptionControllerStateContext {
|
|
}
|
|
import { StateMachine } from "../../../../common/state/state-machine";
|
|
export declare class BetOptionControllerStateMachine extends StateMachine<Core.State.BetOptionControllerState> {
|
|
}
|
|
export declare class SecondTickCountdownController implements Core.Controller.CountdownController {
|
|
private countdownModel;
|
|
private countdownGameView;
|
|
private intervalId;
|
|
constructor(countdownModel: Core.Model.CountdownModel, countdownGameView: Core.View.GameView);
|
|
startCountdown(duration: number, callbacks?: {
|
|
onComplete?: Function;
|
|
onTick?: Function;
|
|
}): void;
|
|
stop(): void;
|
|
reset(): void;
|
|
private setRemainTime;
|
|
}
|
|
export declare class ErrorController implements Core.Controller.ErrorController {
|
|
private errorModel;
|
|
private errorGameView;
|
|
constructor(errorModel: Core.Model.ErrorModel, errorGameView: Core.View.GameView);
|
|
handleServerError(errorCode: number): void;
|
|
handleError(error: Symbol): void;
|
|
}
|
|
export declare const ERROR_TYPE: {
|
|
MaxBetReached: symbol;
|
|
BetConflict: symbol;
|
|
NotEnoughBalanceToBet: symbol;
|
|
ServerError: symbol;
|
|
Disconnect: symbol;
|
|
};
|
|
export declare class GameController implements Core.Controller.GameController {
|
|
private gameControllerStateMachine;
|
|
constructor(gameControllerStateMachine: Core.State.GameControllerStateMachine);
|
|
startNewRound(): void;
|
|
confirmBet(): void;
|
|
collectPoint(): void;
|
|
}
|
|
import { GameControllerState } from "./game-controller-state";
|
|
export declare class GameControllerBetState extends GameControllerState {
|
|
private connector;
|
|
private betModel;
|
|
private gameControllerEventManager;
|
|
private betControllerEventManager;
|
|
private betOptionControllerEventManager;
|
|
constructor(connector: Core.Network.Connector, betModel: Core.Model.BetModel, gameControllerEventManager: Core.State.StateMachineEventManager, betControllerEventManager: Core.State.StateMachineEventManager, betOptionControllerEventManager: Core.State.StateMachineEventManager);
|
|
confirmBet(): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
private enableControllers;
|
|
private disableControllers;
|
|
}
|
|
import { GameControllerState } from "./game-controller-state";
|
|
export declare class GameControllerCollectingPointState extends GameControllerState {
|
|
private connector;
|
|
constructor(connector: Core.Network.Connector);
|
|
collectPoint(): void;
|
|
}
|
|
import { GameControllerState } from "./game-controller-state";
|
|
export declare class GameControllerDisableState extends GameControllerState {
|
|
private betControllerEventManager;
|
|
private betOptionControllerEventManager;
|
|
constructor(betControllerEventManager: Core.State.StateMachineEventManager, betOptionControllerEventManager: Core.State.StateMachineEventManager);
|
|
enter(): void;
|
|
}
|
|
import { GameControllerState } from "./game-controller-state";
|
|
export declare class GameControllerEndRoundState extends GameControllerState {
|
|
private betController;
|
|
private connector;
|
|
constructor(betController: Core.Controller.BetController, connector: Core.Network.Connector);
|
|
startNewRound(): void;
|
|
leave(): void;
|
|
}
|
|
export declare class GameControllerState implements Core.State.GameControllerState {
|
|
startNewRound(): void;
|
|
confirmBet(): void;
|
|
collectPoint(): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
}
|
|
export declare const GAME_CONTROLLER_EVENT: {
|
|
SendNetworkRequest: symbol;
|
|
};
|
|
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
|
|
export declare class GameControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.GameControllerState> {
|
|
protected getListStateTransition(): Core.State.ListStateTransition<Core.State.GameControllerState>;
|
|
}
|
|
import { StateContext } from "../../../../common/state/state-context";
|
|
export declare class GameControllerStateContext extends StateContext<Core.State.GameControllerState> {
|
|
}
|
|
import { StateMachine } from "../../../../common/state/state-machine";
|
|
export declare class GameControllerStateMachine extends StateMachine<Core.State.GameControllerState> {
|
|
}
|
|
export declare class HistoryController<RoundResult> implements Core.Controller.HistoryController<RoundResult> {
|
|
private historyModel;
|
|
private historyGameView;
|
|
constructor(historyModel: Core.Model.HistoryModel<RoundResult>, historyGameView: Core.View.GameView);
|
|
updateHistory(listRoundRecord: Core.Model.RoundRecordModel<RoundResult>[]): void;
|
|
}
|
|
export declare class OddsController implements Core.Controller.OddsController {
|
|
private listOddsModel;
|
|
private oddsView;
|
|
constructor(listOddsModel: Core.Model.ListOddsModel, oddsView: Core.View.GameView);
|
|
updateListOdds(listOdds: number[]): void;
|
|
}
|
|
export declare class RoundResultController<RoundResult> implements Core.Controller.RoundResultController<RoundResult> {
|
|
private statisticController;
|
|
private roundResultModel;
|
|
private roundResultGameView;
|
|
constructor(statisticController: Core.Controller.StatisticController<RoundResult>, roundResultModel: Core.Model.RoundResultModel<RoundResult>, roundResultGameView: Core.View.GameView);
|
|
updateRoundResult(roundResult: RoundResult): void;
|
|
}
|
|
export declare class RoomController implements Core.Controller.RoomController {
|
|
private roomControllerStateMachine;
|
|
constructor(roomControllerStateMachine: Core.State.StateMachine<Core.State.RoomControllerState>);
|
|
joinRoom(roomIndex: number): void;
|
|
leaveRoom(): void;
|
|
}
|
|
import { RoomControllerState } from "./room-controller-state";
|
|
export declare class RoomControllerDisableState extends RoomControllerState {
|
|
}
|
|
export declare const ROOM_CONTROLLER_EVENT: {
|
|
RequestJoinRoom: symbol;
|
|
LeaveRoom: symbol;
|
|
};
|
|
import { RoomControllerState } from "./room-controller-state";
|
|
export declare class RoomControllerInRoomState extends RoomControllerState {
|
|
private roomControllerEventManager;
|
|
private rebetModel;
|
|
private statisticModel;
|
|
private betController;
|
|
constructor(roomControllerEventManager: Core.State.StateMachineEventManager, rebetModel: Core.Model.BetModel, statisticModel: Core.Model.StatisticModel, betController: Core.Controller.BetController);
|
|
leaveRoom(): void;
|
|
leave(): void;
|
|
private clearStatistics;
|
|
private clearBet;
|
|
}
|
|
import { ListStateTransitionCreator } from "../../../../common/state/list-state-transition-creator";
|
|
export declare class RoomControllerListStateTransitionCreator extends ListStateTransitionCreator<Core.State.RoomControllerState> {
|
|
protected getListStateTransition(): Core.State.ListStateTransition<Core.State.RoomControllerState>;
|
|
}
|
|
import { RoomControllerState } from "./room-controller-state";
|
|
export declare class RoomControllerLoungeState extends RoomControllerState {
|
|
private roomControllerEventManager;
|
|
private connector;
|
|
constructor(roomControllerEventManager: Core.State.StateMachineEventManager, connector: Core.Network.Connector);
|
|
joinRoom(roomIndex: number): void;
|
|
}
|
|
import { StateContext } from "../../../../common/state/state-context";
|
|
export declare class RoomControllerStateContext extends StateContext<Core.State.RoomControllerState> implements Core.State.RoomControllerStateContext {
|
|
}
|
|
import { StateMachine } from "../../../../common/state/state-machine";
|
|
export declare class RoomControllerStateMachine extends StateMachine<Core.State.RoomControllerState> {
|
|
}
|
|
export declare class RoomControllerState implements Core.State.RoomControllerState {
|
|
joinRoom(roomIndex: number): void;
|
|
leaveRoom(): void;
|
|
enter(): void;
|
|
leave(): void;
|
|
}
|
|
export declare class StatisticController<RoundResult> implements Core.Controller.StatisticController<RoundResult> {
|
|
private statisticModel;
|
|
private statisticView;
|
|
constructor(statisticModel: Core.Model.StatisticModel<RoundResult>, statisticView: Core.View.GameView);
|
|
addRoundResult(roundResult: RoundResult): void;
|
|
addListRoundResult(listRoundResult: RoundResult[]): void;
|
|
}
|
|
export declare class WinController implements Core.Controller.WinController {
|
|
private winModel;
|
|
private winGameView;
|
|
constructor(winModel: Core.Model.WinModel, winGameView: Core.View.GameView);
|
|
updateTotalWinPoint(totalWinPoint: number): void;
|
|
}
|
|
export declare abstract class HttpNetworkCommand<ParamType = void> implements Core.Pattern.Command<ParamType> {
|
|
protected networkRequest: Core.Network.NetworkRequest;
|
|
constructor(networkRequest: Core.Network.NetworkRequest);
|
|
execute(param: ParamType): void;
|
|
protected getRequestData(param: ParamType): any;
|
|
}
|
|
export declare class Connector implements Core.Network.Connector {
|
|
private connectCommand;
|
|
private joinRoomCommand;
|
|
private startNewRoundCommand;
|
|
private confirmBetCommand;
|
|
private collectPointCommand;
|
|
constructor(connectCommand: Core.Pattern.Command, joinRoomCommand: Core.Pattern.Command<number>, startNewRoundCommand: Core.Pattern.Command, confirmBetCommand: Core.Pattern.Command<number[]>, collectPointCommand: Core.Pattern.Command);
|
|
connectToServer(): void;
|
|
joinRoom(roomIndex: number): void;
|
|
startNewRound(): void;
|
|
sendConfirmBet(betArray: number[]): void;
|
|
collectPoint(): void;
|
|
}
|
|
import { RESTfulAPIRequest } from "./restful-api-request";
|
|
export declare abstract class APIGet extends RESTfulAPIRequest {
|
|
protected getAPIMethod(): string;
|
|
}
|
|
import { RESTfulAPIRequest } from "./restful-api-request";
|
|
export declare abstract class APIPost extends RESTfulAPIRequest {
|
|
protected getAPIMethod(): string;
|
|
}
|
|
export declare abstract class RESTfulAPIRequest implements Core.Network.NetworkRequest {
|
|
private successResponseHandler;
|
|
private invalidResponseHandler?;
|
|
private failedResponseHandler?;
|
|
private errorResponseHandler?;
|
|
private httpServerModel;
|
|
constructor(successResponseHandler: Core.Network.NetworkResponse, invalidResponseHandler?: Core.Network.NetworkResponse, failedResponseHandler?: Core.Network.NetworkResponse, errorResponseHandler?: Core.Network.NetworkResponse);
|
|
send(data?: any): void;
|
|
private sendHTTPRequest;
|
|
protected getHeader(): HeadersInit;
|
|
protected abstract getAPIMethod(): string;
|
|
protected abstract getAPIName(): string;
|
|
private onSuccessResponse;
|
|
private onInvalidResponse;
|
|
private onRequestFailed;
|
|
private onError;
|
|
}
|
|
export declare class ConsoleTraceResponse implements Core.Network.NetworkResponse {
|
|
onResponse(data?: any): void;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultBalanceProcessor extends ChainDataProcessor {
|
|
private balanceController;
|
|
private betController;
|
|
private betBalanceModel;
|
|
constructor(balanceController: Core.Controller.BalanceController, betController: Core.Controller.BetController, betBalanceModel: Core.Model.BalanceModel, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getBalance;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultBetOptionProcessor extends ChainDataProcessor {
|
|
private betOptionController;
|
|
constructor(betOptionController: Core.Controller.BetOptionController, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getDefaultBetOption;
|
|
private getListBetOption;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultBetSettingProcessor extends ChainDataProcessor {
|
|
private betLimitController;
|
|
private listRoomBetLimitModel;
|
|
private roomIndexModel;
|
|
constructor(betLimitController: Core.Controller.BetLimitController, listRoomBetLimitModel: Core.Model.ListRoomBetLimitModel, roomIndexModel: Core.Model.RoomIndexModel, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getRoomIndex;
|
|
private getBetLimit;
|
|
private processRoomIndex;
|
|
private processBetLimit;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultLoungeBetLimitProcessor extends ChainDataProcessor {
|
|
private loungeBetLimitController;
|
|
constructor(loungeBetLimitController: Core.Controller.LoungeBetLimitController, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getListBetLimitSetting;
|
|
private getBetLimit;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultLoungeBetOptionProcessor extends ChainDataProcessor {
|
|
private loungeBetOptionController;
|
|
constructor(loungeBetOptionController: Core.Controller.LoungeBetOptionController, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getListBetOptionSetting;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultOddsProcessor extends ChainDataProcessor {
|
|
private oddsController;
|
|
constructor(oddsController: Core.Controller.OddsController, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getListOdds;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultServerErrorProcessor extends ChainDataProcessor {
|
|
private errorController;
|
|
constructor(errorController: Core.Controller.ErrorController, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getErrorCode;
|
|
}
|
|
import { ChainDataProcessor } from "../../../common/service/chain-of-responsibility/chain-data-processor";
|
|
export declare class DefaultWinProcessor extends ChainDataProcessor {
|
|
private winController;
|
|
constructor(winController: Core.Controller.WinController, nextDataProcessor?: Core.Network.DataProcessor);
|
|
process(data: any): void;
|
|
private getTotalWinPoint;
|
|
}
|
|
export declare abstract class NetworkResponse implements Core.Network.NetworkResponse {
|
|
protected networkEventPublisher: Core.EventSystem.EventPublisher;
|
|
protected dataProcessor?: Core.Network.DataProcessor;
|
|
constructor(networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor);
|
|
onResponse(data?: any): void;
|
|
protected abstract getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnBalance extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnBetLimitResponse extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnBetSettings extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnConfirmBetFailed extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnConfirmBetSuccessfully extends NetworkResponse {
|
|
private betModel;
|
|
private rebetModel;
|
|
private balanceController;
|
|
constructor(betModel: Core.Model.BetModel, rebetModel: Core.Model.BetModel, balanceController: Core.Controller.BalanceController, networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor);
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
onResponse(data?: any): void;
|
|
private setConfirmedBetToRebet;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnConnect extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnDisconnect extends NetworkResponse {
|
|
private errorController;
|
|
constructor(errorController: Core.Controller.ErrorController, networkEventPublisher: Core.EventSystem.EventPublisher, dataProcessor?: Core.Network.DataProcessor);
|
|
onResponse(data?: any): void;
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnError extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnGameStart extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnOdds extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnRoomJoin extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnRoundEnd extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnRoundResult extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnRoundStart extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnStatistic extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
import { NetworkResponse } from "./network-response";
|
|
export declare class OnWin extends NetworkResponse {
|
|
protected getNetworkResponseSymbol(): Symbol;
|
|
}
|
|
export declare class ApplicationConfigModel implements Core.Model.ApplicationConfigModel {
|
|
sessionOCode: string;
|
|
sessionHash: string;
|
|
platform: string;
|
|
port: number;
|
|
address: string;
|
|
currency: string;
|
|
publisher: string;
|
|
enabledSSL: boolean;
|
|
}
|
|
export declare class BalanceModel implements Core.Model.BalanceModel {
|
|
credit: number;
|
|
freeCredit: number;
|
|
get totalCredit(): number;
|
|
}
|
|
export declare class BetLimitModel implements Core.Model.BetLimitModel {
|
|
listMinBetPoint: number[];
|
|
listMaxBetPoint: number[];
|
|
minTotalBetPoint: number;
|
|
maxTotalBetPoint: number;
|
|
}
|
|
export declare class BetModel implements Core.Model.BetModel {
|
|
listBetPoint: number[];
|
|
constructor(gameConstantParameter: Core.Parameter.GameConstantParameter);
|
|
}
|
|
export declare class BetPositionModel implements Core.Model.BetPositionModel {
|
|
index: number;
|
|
}
|
|
export declare class CountdownModel implements Core.Model.CountdownModel {
|
|
remainTime: number;
|
|
}
|
|
export declare class ErrorModel implements Core.Model.ErrorModel {
|
|
errorType: Symbol;
|
|
serverErrorCode: number;
|
|
}
|
|
export declare class ListBetConflictModel implements Core.Model.ListBetConflictModel {
|
|
listBetConflict: Core.Model.BetConflictModel[];
|
|
}
|
|
export declare class ListBetOptionModel implements Core.Model.ListBetOptionModel {
|
|
listBetOption: number[];
|
|
}
|
|
export declare class ListOddsModel implements Core.Model.ListOddsModel {
|
|
listOdds: number[];
|
|
constructor(gameConstantParameter: Core.Parameter.GameConstantParameter);
|
|
}
|
|
export declare class ListRoomBetLimitModel implements Core.Model.ListRoomBetLimitModel {
|
|
listRoomBetLimit: Core.Model.BetLimitModel[];
|
|
}
|
|
export declare class ListRoomBetOptionModel implements Core.Model.ListRoomBetOptionModel {
|
|
listRoomBetOption: Core.Model.ListBetOptionModel[];
|
|
}
|
|
export declare class RoomIndexModel implements Core.Model.RoomIndexModel {
|
|
roomIndex: number;
|
|
}
|
|
export declare class RoundResultModel<RoundResult> implements Core.Model.RoundResultModel<RoundResult> {
|
|
roundResult: RoundResult;
|
|
}
|
|
export declare class SelectedBetOptionModel implements Core.Model.SelectedBetOptionModel {
|
|
selectedBetOption: number;
|
|
}
|
|
export declare class WinModel implements Core.Model.WinModel {
|
|
totalWinPoint: number;
|
|
}
|
|
export declare class GameView implements Core.View.GameView {
|
|
private listComponent;
|
|
addComponent(component: Core.View.ComponentView): void;
|
|
update(): void;
|
|
}
|