/// <summary>
/// Opusczenie turnieju
/// </summary>
/// <param name="tournament"></param>
public void DoLeftTournamentMode(ITournamentGameModel tournament)
{
ITournamentGameModel gameModel = this.GameList.Get <TournamentGameController>().Where(g => g.GameModel.TournamentModel.ID == tournament.TournamentModel.ID).
Select(g => g.GameModel).
FirstOrDefault();
var user = ClientModel.GetUser(CurrentClient).User;
var canLeftTournament = (gameModel.IsStarted() == false);
if (canLeftTournament)
{
var player = gameModel.TournamentModel.PlayersList.FirstOrDefault(c => c.Player.User.ID == user.ID);
if (player != null)
{
player.Player.LeaveGame(gameModel);
}
else
{
throw new ApplicationException("Nie zarejestrowano takiego użytkownika w turnieju.");
}
user.GetClient().OnMessage("Poprawnie wypisano z turnieju. Na Twoje konto została zwrócona kwota wpisowego.");
}
else
{
throw new ApplicationException("Nie można wypisac się z turnieju po jego starcie.");
}
}
public void OnTournamentGameModelUpdate(ITournamentGameModel game)
{
if (OnTournamentGameModelUpdateEvent != null)
{
OnTournamentGameModelUpdateEvent(game);
}
}
public TournamentGameController(ITournamentGameModel gameModel)
{
this.GameList = new List <Game>();
this.Type = TournamentPlayingType.Default;
this.PotModel = new StaticWinningPotModel(gameModel.TournamentModel);
this.SetGameModel(gameModel);
}
public void SetGameModel(ITournamentGameModel gameModel)
{
//Tworzy turniej
this.GameModel = gameModel;
//Eventy na listy i akcje gry
this.GameModel.TournamentModel.PlayersList.CollectionChanged += (object sender, NotifyCollectionChangedEventArgs e) =>
{
this.GameModel.TournamentModel.Registered = this.GameModel.TournamentModel.PlayersList.Count();
foreach (ClientModel user in PokerService.Instance.Clients)
{
user.ClientProxy.OnTournamentGameModelUpdate(this.GameModel);
}
if (e.NewItems != null && this.GameModel.IsStarted())
{
//Dołączamy użytkownika do jakiegoś stołu jesli gra sie rozpoczela
foreach (Object item in e.NewItems)
{
var newPlayer = item as TournamentPlayerModel;
TournamentPlacemenet(newPlayer);
}
}
};
}
private void UpdateTournamentModel(ITournamentGameModel tournamentModel)
{
this.Entries.Text = GameModel.TournamentModel.Registered + "/" + GameModel.TournamentModel.MaxPlayers;
this.WinPot.Text = GameModel.TournamentModel.WinPotCurrency;
this.WinPotSummary.Text = this.WinPot.Text;
this.Status.Text = GameModel.TournamentModel.State.ToString();
if (tournamentModel is SitAndGoTournamentGameModel)
{
this.WhenStart.Text = "gdy uzbiera się " + tournamentModel.TournamentModel.MaxPlayers + " graczy";
}
else
{
this.WhenStart.Text = tournamentModel.StartString;
}
SetTournamentDescription();
RegisterInTournament.Visibility = Visibility.Collapsed;
UnRegister.Visibility = Visibility.Collapsed;
GetSeatTournament.Visibility = Visibility.Collapsed;
//Miejsca platne
UpdatePrizeList();
UpdatePlayerList();
this.DataContext = GameModel;
}
public void OnTournamentTableListUpdate(ITournamentGameModel table, List <TableModel> tableList)
{
if (OnTournamentTableListUpdateEvent != null)
{
OnTournamentTableListUpdateEvent(table, tableList);
}
}
public void SetTournamentModeNote(ITournamentGameModel tournamentMode)
{
//Wypisujemy informacje o turnieju
TablePlayerList.Visibility = Visibility.Collapsed;
PlayerList.ItemsSource = null;
EventName.Text = tournamentMode.TournamentModel.Name;
EventStatus.Text = "Gra turniejowa";
EventNameID.Text = "ID: #" + (tournamentMode.TournamentModel.ID).ToString().PadLeft(8, '0');
//Parsujemy informacje na temat stolu do listy elementow
TableSideElementList.ItemsSource = null;
List <TableSideElement> tableSideElementList = new List <TableSideElement>();
tableSideElementList.Add(
new TableSideElement()
{
Title = "Kwota rejestracji:",
Description = "Kwota do zapłaty przy rejestracji",
Value = tournamentMode.TournamentModel.EntryPaymentCurrency
}
);
if (tournamentMode.TournamentModel.State != Enums.TournamentState.Running && tournamentMode.TournamentModel.State != Enums.TournamentState.LateRegistration && tournamentMode.TournamentModel.State != Enums.TournamentState.Completed)
{
tableSideElementList.Add(
new TableSideElement()
{
Title = "Start turnieju:",
Description = "Kiedy turniej się zaczyna",
Value = tournamentMode.StartString
}
);
}
tableSideElementList.Add(
new TableSideElement()
{
Title = "Ilość graczy:",
Description = "Zarejestrowani gracze",
Value = tournamentMode.TournamentModel.Registered.ToString()
}
);
tableSideElementList.Add(
new TableSideElement()
{
Title = "Status turnieju:",
Description = "Aktualny status",
Value = tournamentMode.TournamentModel.State.ToString()
}
);
TableSideElementList.ItemsSource = tableSideElementList;
if (tournamentMode == null)
{
return;
}
}
/// <summary>
/// Pobiera stol na ktorym siedzi gracz
/// </summary>
/// <param name="tournament"></param>
/// <returns></returns>
public TableModel GetTournametTable(ITournamentGameModel tournament)
{
var user = ClientModel.GetUser(CurrentClient);
return(PokerService.Instance.GameList.Get <TournamentGameController>().
Select(e => e.GameModel.TournamentModel.TableList).
Where(t => t.Any(e => e.PlayersList.Any(f => f.User.ID == user.User.ID))).FirstOrDefault().
FirstOrDefault(e => e.PlayersList.Any(f => f.User.ID == user.User.ID)));
}
void Instance_OnTournamentTableListUpdateEvent(ITournamentGameModel game, List <TableModel> tableList)
{
if (game.TournamentModel.ID == GameModel.TournamentModel.ID)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
UpdateTournamentTableList(tableList);
}));
}
}
void Instance_OnTournamentGameModelUpdateEvent(ITournamentGameModel game)
{
if (game.TournamentModel.ID == GameModel.TournamentModel.ID)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
GameModel = game;
UpdateTournamentModel(game);
}));
}
}
/// <summary>
/// Pobiera liste gracyz turniejowych wedlug modelu turnieju
/// </summary>
/// <param name="tournament"></param>
/// <returns></returns>
public List <TournamentPlayerModel> GetTournamentPlayers(ITournamentGameModel tournament)
{
var tournamentModel = GameList.Get <TournamentGameController>().ToList().FirstOrDefault(t => t.GameModel.TournamentModel.ID == tournament.TournamentModel.ID);
if (tournamentModel == null)
{
throw new ApplicationException("Nieznany identyfikator turnieju.");
}
return(tournamentModel.GameModel.TournamentModel.PlayersList.ToList());
}
public static void LeaveGame(this PlayerModel player, ITournamentGameModel gameModel)
{
var _gameModel = gameModel;
//Tranzakcja dołączenia do gry
player.User.GameLeaveTransaction(gameModel.TournamentModel.EntryCurrency, gameModel.TournamentModel.EntryPayment);
var tournamentPlayer = _gameModel.TournamentModel.PlayersList.FirstOrDefault(p => p.Player.User.ID == player.User.ID);
_gameModel.TournamentModel.PlayersList.Remove(tournamentPlayer);
}
public TournamentWindow(ITournamentGameModel tournamentModel)
{
GameModel = tournamentModel;
PokerClient.Instance.OnTournamentGameModelUpdateEvent += Instance_OnTournamentGameModelUpdateEvent;
PokerClient.Instance.OnTournamentTableListUpdateEvent += Instance_OnTournamentTableListUpdateEvent;
InitializeComponent();
this.WindowTitle.Text = "Lobby turniejowe - " + tournamentModel.TournamentModel.Name;
this.Title = WindowTitle.Text;
UpdateTournamentModel(tournamentModel);
UpdateRegisterStatus();
UpdateTournamentTableList(null);
}
public static void JoinToGame(this PlayerModel player, ITournamentGameModel gameModel)
{
var _gameModel = gameModel;
//Tranzakcja dołączenia do gry
player.User.GameJoinTransaction(gameModel.TournamentModel.EntryCurrency, gameModel.TournamentModel.EntryPayment);
var tournamentPlayer = new TournamentPlayerModel()
{
PlaceID = 0,
Player = player,
};
//Dołączenie do listy graczy, jesli gracz nie mial rezerwacji i jest to mozliwe
_gameModel.TournamentModel.PlayersList.Add(tournamentPlayer);
}
public static void OpenTournamentWindow(ITournamentGameModel game)
{
/**
* Sprawdz czy stol uruchomiony
* jesli tak podswietl go jesli nie - utworz nowe okno stolu
* */
if (Application.Current.Windows.OfType <TournamentWindow>().Any(t => t.GameModel.TournamentModel.ID == game.TournamentModel.ID))
{
return;
}
TournamentWindow gameWindow = new TournamentWindow(game);
gameWindow.Owner = MainWindow.Instance;
gameWindow.Show();
gameWindow.Owner = null;
}
/// <summary>
/// Dołącza do gry rankingowej
/// </summary>
/// <param name="tournament"></param>
public void DoJoinTournamentMode(ITournamentGameModel game)
{
ITournamentGameModel gameModel = this.GameList.Get <TournamentGameController>().Where(g => g.GameModel.TournamentModel.ID == game.TournamentModel.ID).
Select(g => g.GameModel).
FirstOrDefault();
//Sprawdzamy czy użytkownika stać na wejście do turnieju
var user = ClientModel.GetUser(CurrentClient).User;
if (user.GetWallet(gameModel.TournamentModel.EntryCurrency).Available < gameModel.TournamentModel.EntryPayment)
{
throw new ApplicationException("Nie posiadasz wystarczającej ilości środków na koncie aby dołączyć do tego turnieju.");
}
//Sprawdzamy czy nie osiągnięto maksymalnej ilości graczy
if (gameModel.TournamentModel.MaxPlayers <= gameModel.TournamentModel.PlayersList.ToList().Count())
{
throw new ApplicationException("Nie możesz się zarejestrować w tym turnieju ponieważ maksymalna liczba graczy już została osiągnięta.");
}
//Sprawdzamy czy rejestracja nadal jest otwarta
if (gameModel.TournamentModel.State != Enums.TournamentState.Registration && gameModel.TournamentModel.State != Enums.TournamentState.LateRegistration)
{
throw new ApplicationException("Rejestracja do tego turnieju jest zamknięta.");
}
//Sprawdzamy czy gracz już uczestniczył w tym turnieju
if (gameModel.TournamentModel.PlayersList.Any(c => c.Player.User.ID == user.ID))
{
throw new ApplicationException("Nie można ponownie zarejestrować się do tego turnieju.");
}
PlayerModel _player = new PlayerModel()
{
User = (UserModel)user,
Stack = 1500,
TimeBank = 0,
Seat = PlayerModel.AUTO_SEAT
};
_player.JoinToGame(gameModel);
user.GetClient().OnMessage("Zarejestrowano w turnieju " + gameModel.TournamentModel.Name + ", z Twojego konta została potrącona kwota " + gameModel.TournamentModel.EntryPaymentCurrency);
}
public Lobby()
{
Console.WriteLine("Lobby constructor");
this.Initialized += (obj, args) =>
{
Console.WriteLine("Lobby.Initialized");
//Zaznaczam ostatnio aktywna zakladke
LobbyTab.SelectedIndex = Properties.Settings.Default.LastLobbyTab;
//Aktualizacja statystyk
PokerClient.Instance.OnGetStatsInfoEvent += Instance_OnGetStatsInfoEvent;
//Rekalma
PokerClient.Instance.OnGetAdvertisingEvent += (adv) =>
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
SetAdvertisingLobby(adv);
}));
};
//Informacja o nowym transferze
PokerClient.Instance.OnDepositInfoEvent += (transfer) =>
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
if (!Properties.Settings.Default.DontShowDepositWindow)
{
DepositInfoWindow deposit = new DepositInfoWindow(transfer);
deposit.ShowModal(MainWindow.Instance);
}
}));
};
PokerClient.Instance.OnNormalModeUpdateEvent += (game) =>
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
if (NormalModelList == null)
{
return;
}
//Aktualizacja elementów listy
NormalGameModel item = NormalModelList.FirstOrDefault(t => t.Table.ID == game.Table.ID);
if (item != null)
{
NormalModelList[NormalModelList.IndexOf(item)] = game;
NormalGameModeList.Items.Refresh();
}
}));
};
PokerClient.Instance.OnTournamentGameModelUpdateEvent += (game) =>
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
if (NormalModelList == null)
{
return;
}
//Aktualizacja elementów listy
ITournamentGameModel item = TournamentModelList.FirstOrDefault(t => t.TournamentModel.ID == game.TournamentModel.ID);
if (item != null)
{
TournamentModelList[TournamentModelList.IndexOf(item)] = game;
TournamentGameModeList.Items.Refresh();
}
}));
};
PokerClient.Instance.OnTableOpenWindowEvent += (table) =>
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
if (Application.Current.Windows.OfType <PokerGameWindow>().Any(w => w.TableModel.ID == table.ID))
{
return;
}
PokerGameWindow gameWindow = new PokerGameWindow(table);
gameWindow.Show();
}));
};
Session.Data.Client.Connected += (e, o) =>
{
Console.WriteLine("OnConnect");
RefreshNormalMode();
RefreshTournamentMode();
};
Session.Data.Client.Disconnected += (e, o) =>
{
Console.WriteLine("OnDisconnect");
};
InitializeLobby();
};
InitializeComponent();
}
