public RoomOperationResult ChangeSeat(LoginToken token, int newSeat) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Locked; } var room = loggedInGuidToRoom[token.token]; if (room.State == RoomState.Gaming) { return RoomOperationResult.Locked; } if (newSeat < 0 || newSeat >= room.Seats.Count) return RoomOperationResult.Invalid; var seat = room.Seats[newSeat]; if (seat.Account == null && seat.State == SeatState.Empty) { foreach (var remove in room.Seats) { if (remove.Account == loggedInGuidToAccount[token.token]) { seat.State = remove.State; seat.Account = remove.Account; remove.Account = null; remove.State = SeatState.Empty; NotifyRoomLayoutChanged(newRoomId); return RoomOperationResult.Success; } } } Console.WriteLine("Full"); return RoomOperationResult.Full; } return RoomOperationResult.Auth; }
public RoomOperationResult CancelReady(LoginToken token) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Invalid; } var room = loggedInGuidToRoom[token.token]; var seat = room.Seats.FirstOrDefault(s => s.Account == loggedInGuidToAccount[token.token]); if (seat == null) return RoomOperationResult.Invalid; if (seat.State != SeatState.GuestReady) return RoomOperationResult.Invalid; seat.State = SeatState.GuestTaken; NotifyRoomLayoutChanged(room.Id); return RoomOperationResult.Success; } return RoomOperationResult.Auth; }
public RoomOperationResult EnterRoom(LoginToken token, int roomId, bool spectate, string password, out Room room) { room = null; if (VerifyClient(token)) { Console.WriteLine("{1} Enter room {0}", roomId, token.token); if (loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Locked; } if (rooms.ContainsKey(roomId)) { if (rooms[roomId].State == RoomState.Gaming) return RoomOperationResult.Locked; int seatNo = 0; foreach (var seat in rooms[roomId].Seats) { Console.WriteLine("Testing seat {0}", seatNo); if (seat.Account == null && seat.State == SeatState.Empty) { loggedInGuidToRoom.Add(token.token, rooms[roomId]); seat.Account = loggedInGuidToAccount[token.token]; seat.State = SeatState.GuestTaken; NotifyRoomLayoutChanged(roomId); Console.WriteLine("Seat {0}", seatNo); room = rooms[roomId]; return RoomOperationResult.Success; } seatNo++; } Console.WriteLine("Full"); return RoomOperationResult.Full; } } Console.WriteLine("Rogue enter room calls"); return RoomOperationResult.Auth; }
public void Logout() { Connection.Logout(); LoginToken = new LoginToken(); }
public LoginStatus Login(int version, string username, string hash, out Account retAccount, out string reconnectionString, out LoginToken reconnectionToken) { reconnectionToken = new LoginToken(); reconnectionString = null; if (version != Misc.ProtocolVersion) { retAccount = null; return LoginStatus.OutdatedVersion; } Account authenticatedAccount = Authenticate(username, hash); if (authenticatedAccount == null) { retAccount = null; return LoginStatus.InvalidUsernameAndPassword; } var connection = OperationContext.Current.GetCallbackChannel<IGameClient>(); lock (loggedInAccounts) { ClientAccount disconnected = null; if (loggedInAccounts.ContainsKey(username)) { disconnected = loggedInAccounts[username]; var ping = disconnected.CallbackChannel; try { if (ping.Ping()) { reconnectionString = null; retAccount = null; return LoginStatus.InvalidUsernameAndPassword; } } catch (Exception) { } disconnected.CallbackChannel = connection; currentAccount = disconnected; var room = disconnected.CurrentRoom; if (room != null) { if (room.Room.State == RoomState.Gaming && !disconnected.Account.IsDead) { reconnectionString = room.Room.IpAddress.ToString() + ":" + room.Room.IpPort; reconnectionToken = disconnected.Account.LoginToken; } else { disconnected.CurrentRoom = null; } } } else { var acc = new ClientAccount() { Account = authenticatedAccount, CallbackChannel = connection, LobbyService = this }; loggedInAccounts.Add(username, acc); currentAccount = acc; // hack var roomresult = from r in rooms.Values where r.Room.Seats.Any(st => st.Account == authenticatedAccount) select r; if (roomresult.Count() > 0) { acc.CurrentRoom = roomresult.First(); } } } Trace.TraceInformation("{0} logged in", username); EventHandler faultHandler = (o, s) => { try { if (currentAccount.CurrentRoom.Room.State == RoomState.Gaming) return; _Logout(currentAccount); } catch (Exception) { } }; OperationContext.Current.Channel.Faulted += faultHandler; OperationContext.Current.Channel.Closed += faultHandler; retAccount = currentAccount.Account; _Unspectate(currentAccount); currentAccount.OpContext = OperationContext.Current; return LoginStatus.Success; }
private bool VerifyClient(LoginToken token) { if (loggedInGuidToAccount.ContainsKey(token.token)) { if (loggedInGuidToChannel.ContainsKey(token.token)) { if (loggedInGuidToChannel[token.token] == OperationContext.Current.GetCallbackChannel<IGameClient>()) { return true; } } } return false; }
private void _startClient() { _userName = tab0UserName.Text; _passWd = tab0Password.Password; Properties.Settings.Default.LastHostName = tab0HostName.Text; Properties.Settings.Default.LastUserName = tab0UserName.Text; Properties.Settings.Default.Save(); #if !DEBUG bool createdNew; if (appMutex == null) { appMutex = new System.Threading.Mutex(true, "Sanguosha", out createdNew); ///if creation of mutex is successful if (!createdNew && tab0HostName.Text != "127.0.0.1") { appMutex = null; _Warn("You already have another Sanguosha running!"); return; } } #endif if (string.IsNullOrEmpty(_userName)) { _Warn("Please provide a username"); return; } busyIndicator.BusyContent = Resources["Busy.ConnectServer"]; busyIndicator.IsBusy = true; ILobbyService server = null; LoginToken token = new LoginToken(); string reconnect = null; _hostName = tab0HostName.Text; if (!_hostName.Contains(":")) { _hostName = _hostName + ":" + DefaultLobbyPort; } BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (o, ea) => { try { ea.Result = LoginStatus.UnknownFailure; _LogOut(); var lobbyModel = LobbyViewModel.Instance; var binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; var endpoint = new EndpointAddress(string.Format("net.tcp://{0}/GameService", _hostName)); _channelFactory = new DuplexChannelFactory<ILobbyService>(lobbyModel, binding, endpoint); server = _channelFactory.CreateChannel(); _channelFactory.Faulted += channelFactory_Faulted; Account ret; var stat = server.Login(Misc.ProtocolVersion, _userName, _passWd, out ret, out reconnect, out token); if (stat == LoginStatus.Success) { LobbyViewModel.Instance.CurrentAccount = ret; if (reconnect != null) { Application.Current.Dispatcher.Invoke((ThreadStart)delegate() { MainGame.BackwardNavigationService = this.NavigationService; busyIndicator.BusyContent = Resources["Busy.Reconnecting"]; }); } } ea.Result = stat; } catch (Exception e) { string s = e.StackTrace; } }; worker.RunWorkerCompleted += (o, ea) => { bool success = false; if ((LoginStatus)ea.Result == LoginStatus.Success) { LobbyView lobby = LobbyView.Instance; LobbyView.Instance.OnNavigateBack += lobby_OnNavigateBack; var lobbyModel = LobbyViewModel.Instance; lobbyModel.Connection = server; lobbyModel.LoginToken = token; if (reconnect == null) { this.NavigationService.Navigate(lobby); busyIndicator.IsBusy = false; } else { lobbyModel.NotifyGameStart(reconnect, token); busyIndicator.IsBusy = true; } success = true; } if (!success) { if ((LoginStatus)ea.Result == LoginStatus.InvalidUsernameAndPassword) { MessageBox.Show("Invalid Username and Password"); busyIndicator.IsBusy = false; } else if ((LoginStatus)ea.Result == LoginStatus.OutdatedVersion) { // MessageBox.Show("Outdated version. Please update"); busyIndicator.BusyContent = Resources["Busy.Updating"]; } else { MessageBox.Show("Cannot connect to server."); busyIndicator.IsBusy = false; } } startButton.IsEnabled = true; }; worker.RunWorkerAsync(); }
public RoomOperationResult Kick(LoginToken token, int seatNo) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Invalid; } var room = loggedInGuidToRoom[token.token]; var seat = room.Seats.FirstOrDefault(s => s.Account == loggedInGuidToAccount[token.token]); if (seat == null) return RoomOperationResult.Invalid; if (seat.State != SeatState.Host) return RoomOperationResult.Invalid; if (room.Seats[seatNo].State == SeatState.GuestReady || room.Seats[seatNo].State == SeatState.GuestTaken) { _ExitRoom(new LoginToken() { token = loggedInAccountToGuid[room.Seats[seatNo].Account] }, room.Id); return RoomOperationResult.Success; } return RoomOperationResult.Invalid; } return RoomOperationResult.Auth; }
public void Logout(LoginToken token) { if (VerifyClient(token)) { _Logout(token); } }
public LoginStatus Login(int version, string username, out LoginToken token, out Account retAccount, out string reconnectionString) { var disconnected = accounts.FirstOrDefault(ac => ac.UserName == username); if (disconnected != null) { token = new LoginToken() { token = loggedInAccountToGuid[disconnected] }; var ping = loggedInGuidToChannel[token.token]; try { if (ping.Ping()) { reconnectionString = null; retAccount = null; return LoginStatus.InvalidUsernameAndPassword; } } catch (Exception) { } } else { token = new LoginToken(); token.token = System.Guid.NewGuid(); } reconnectionString = null; if (version != Misc.ProtocolVersion) { retAccount = null; return LoginStatus.OutdatedVersion; } Console.WriteLine("{0} logged in", username); var connection = OperationContext.Current.GetCallbackChannel<IGameClient>(); OperationContext.Current.Channel.Faulted += new EventHandler(Channel_Faulted); OperationContext.Current.Channel.Closed += new EventHandler(Channel_Faulted); Account account = disconnected; if (account == null) { account = new Account() { UserName = username, Id = newAccountId++ }; accounts.Add(account); if (accountContext != null) { try { accountContext.Accounts.Add(account); accountContext.SaveChanges(); } catch (Exception e) { Trace.TraceError(e.ToString()); } } } retAccount = account; if (disconnected != null) { loggedInGuidToAccount.Remove(token.token); loggedInAccountToGuid.Remove(disconnected); if (loggedInGuidToChannel.ContainsKey(token.token)) { loggedInChannelsToGuid.Remove(loggedInGuidToChannel[token.token]); loggedInGuidToChannel.Remove(token.token); } } loggedInGuidToAccount.Add(token.token, account); loggedInGuidToChannel.Add(token.token, connection); loggedInAccountToGuid.Add(account, token.token); loggedInChannelsToGuid.Add(connection, token.token); if (disconnected != null && loggedInGuidToRoom.ContainsKey(token.token) && loggedInGuidToRoom[token.token].State == RoomState.Gaming) { reconnectionString = loggedInGuidToRoom[token.token].IpAddress.ToString() + ":" + loggedInGuidToRoom[token.token].IpPort; } return LoginStatus.Success; }
public RoomOperationResult OpenSeat(LoginToken token, int seatNo) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Invalid; } var room = loggedInGuidToRoom[token.token]; var seat = room.Seats.FirstOrDefault(s => s.Account == loggedInGuidToAccount[token.token]); if (seat == null) return RoomOperationResult.Invalid; if (seat.State != SeatState.Host) return RoomOperationResult.Invalid; if (room.Seats[seatNo].State != SeatState.Closed) return RoomOperationResult.Invalid; room.Seats[seatNo].State = SeatState.Empty; NotifyRoomLayoutChanged(room.Id); return RoomOperationResult.Success; } return RoomOperationResult.Auth; }
private void _Logout(LoginToken token) { if (!loggedInGuidToAccount.ContainsKey(token.TokenString)) return; Console.WriteLine("{0} logged out", loggedInGuidToAccount[token.TokenString].UserName); if (loggedInGuidToRoom.ContainsKey(token.TokenString)) { _ExitRoom(token); } accounts.Remove(loggedInGuidToAccount[token.TokenString]); loggedInAccountToGuid.Remove(loggedInGuidToAccount[token.TokenString]); loggedInChannelsToGuid.Remove(loggedInGuidToChannel[token.TokenString]); loggedInGuidToChannel.Remove(token.TokenString); loggedInGuidToAccount.Remove(token.TokenString); }
public RoomOperationResult Chat(LoginToken token, string message) { if (VerifyClient(token)) { if (message.Length > Misc.MaxChatLength) return RoomOperationResult.Invalid; try { if (loggedInGuidToRoom.ContainsKey(token.token)/* && loggedInGuidToRoom[token.token].State == RoomState.Gaming*/) { foreach (var seat in loggedInGuidToRoom[token.token].Seats) { if (seat.Account != null) { loggedInGuidToChannel[loggedInAccountToGuid[seat.Account]].NotifyChat(loggedInGuidToAccount[token.token], message); } } } /*else { foreach (var pair in loggedInGuidToChannel) { pair.Value.NotifyChat(loggedInGuidToAccount[token.token], message); } }*/ } catch (Exception) { } return RoomOperationResult.Success; } return RoomOperationResult.Auth; }
public RoomOperationResult Spectate(LoginToken token, int roomId) { if (VerifyClient(token)) { if (loggedInGuidToRoom.ContainsKey(token.TokenString)) { return RoomOperationResult.Invalid; } var room = rooms[roomId]; if (room.State != RoomState.Gaming) return RoomOperationResult.Invalid; var channel = loggedInGuidToChannel[token.TokenString]; channel.NotifyGameStart(room.IpAddress + ":" + room.IpPort); return RoomOperationResult.Success; } return RoomOperationResult.Auth; }
public LoginStatus Login(int version, string username, string hash, out LoginToken token, out Account retAccount, out string reconnectionString) { var disconnected = accounts.FirstOrDefault(ac => ac.UserName == username); if (!Authenticate(username, hash)) { reconnectionString = null; retAccount = null; token = new LoginToken(); token.TokenString = System.Guid.NewGuid(); return LoginStatus.InvalidUsernameAndPassword; } if (disconnected != null) { token = new LoginToken() { TokenString = loggedInAccountToGuid[disconnected] }; var ping = loggedInGuidToChannel[token.TokenString]; try { if (ping.Ping()) { reconnectionString = null; retAccount = null; return LoginStatus.InvalidUsernameAndPassword; } } catch (Exception) { } } else { token = new LoginToken(); token.TokenString = System.Guid.NewGuid(); } reconnectionString = null; if (version != Misc.ProtocolVersion) { retAccount = null; return LoginStatus.OutdatedVersion; } Console.WriteLine("{0} logged in", username); var connection = OperationContext.Current.GetCallbackChannel<IGameClient>(); OperationContext.Current.Channel.Faulted += new EventHandler(Channel_Faulted); OperationContext.Current.Channel.Closed += new EventHandler(Channel_Faulted); Account account = disconnected; if (account == null) { account = GetAccount(username, hash); accounts.Add(account); } retAccount = account; if (disconnected != null) { loggedInGuidToAccount.Remove(token.TokenString); loggedInAccountToGuid.Remove(disconnected); if (loggedInGuidToChannel.ContainsKey(token.TokenString)) { loggedInChannelsToGuid.Remove(loggedInGuidToChannel[token.TokenString]); loggedInGuidToChannel.Remove(token.TokenString); } } loggedInGuidToAccount.Add(token.TokenString, account); loggedInGuidToChannel.Add(token.TokenString, connection); loggedInAccountToGuid.Add(account, token.TokenString); loggedInChannelsToGuid.Add(connection, token.TokenString); if (disconnected != null && loggedInGuidToRoom.ContainsKey(token.TokenString)) { if (loggedInGuidToRoom[token.TokenString].State == RoomState.Gaming && gamingInfo.ContainsKey(loggedInGuidToRoom[token.TokenString]) && !gamingInfo[loggedInGuidToRoom[token.TokenString]].isDead[gamingInfo[loggedInGuidToRoom[token.TokenString]].Accounts.IndexOf(account)]) { reconnectionString = loggedInGuidToRoom[token.TokenString].IpAddress.ToString() + ":" + loggedInGuidToRoom[token.TokenString].IpPort; } else { loggedInGuidToRoom.Remove(token.TokenString); } } return LoginStatus.Success; }
public RoomOperationResult Kick(LoginToken token, int seatNo) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.TokenString)) { return RoomOperationResult.Invalid; } var room = loggedInGuidToRoom[token.TokenString]; var seat = room.Seats.FirstOrDefault(s => s.Account == loggedInGuidToAccount[token.TokenString]); if (seat == null) return RoomOperationResult.Invalid; if (seat.State != SeatState.Host) return RoomOperationResult.Invalid; if (room.Seats[seatNo].State == SeatState.GuestReady || room.Seats[seatNo].State == SeatState.GuestTaken) { var kicked = new LoginToken() { TokenString = loggedInAccountToGuid[room.Seats[seatNo].Account] }; _ExitRoom(kicked); loggedInGuidToChannel[kicked.TokenString].NotifyKicked(); return RoomOperationResult.Success; } return RoomOperationResult.Invalid; } return RoomOperationResult.Auth; }
public RoomOperationResult ExitRoom(LoginToken token, int roomId) { if (VerifyClient(token)) { return _ExitRoom(token, roomId); } return RoomOperationResult.Auth; }
public RoomOperationResult StartGame(LoginToken token) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Invalid; } int portNumber; var room = loggedInGuidToRoom[token.token]; var total = room.Seats.Count(pl => pl.Account != null); var initiator = room.Seats.FirstOrDefault(pl => pl.Account == loggedInGuidToAccount[token.token]); if (room.State == RoomState.Gaming) return RoomOperationResult.Invalid; if (total <= 1) return RoomOperationResult.Invalid; if (initiator == null || initiator.State != SeatState.Host) return RoomOperationResult.Invalid; if (room.Seats.Any(cs => cs.Account != null && cs.State != SeatState.Host && cs.State != SeatState.GuestReady)) return RoomOperationResult.Invalid; room.State = RoomState.Gaming; foreach (var unready in room.Seats) { if (unready.State == SeatState.GuestReady) unready.State = SeatState.GuestTaken; } var gs = new GameSettings() { TimeOutSeconds = room.TimeOutSeconds, TotalPlayers = total, CheatEnabled = CheatEnabled }; var config = new AccountConfiguration(); config.AccountIds = new List<LoginToken>(); config.Accounts = new List<Account>(); foreach (var addconfig in room.Seats) { if (addconfig.Account != null) { config.AccountIds.Add(new LoginToken() { token = loggedInAccountToGuid[addconfig.Account] }); config.Accounts.Add(addconfig.Account); } } GameService.StartGameService(HostingIp, gs, config, room.Id, _OnGameEnds, out portNumber); room.IpAddress = HostingIp.ToString(); room.IpPort = portNumber; _NotifyGameStart(loggedInGuidToRoom[token.token].Id, HostingIp, portNumber); return RoomOperationResult.Success; } return RoomOperationResult.Auth; }
public IEnumerable<Room> GetRooms(LoginToken token, bool notReadyRoomsOnly) { if (VerifyClient(token)) { List<Room> ret = new List<Room>(); foreach (var pair in rooms) { if (!notReadyRoomsOnly || pair.Value.State == RoomState.Waiting) { ret.Add(pair.Value); } } return ret; } return null; }
private RoomOperationResult _ExitRoom(LoginToken token) { if (loggedInGuidToRoom.ContainsKey(token.token)) { var room = loggedInGuidToRoom[token.token]; foreach (var seat in room.Seats) { if (seat.Account == loggedInGuidToAccount[token.token]) { bool findAnotherHost = false; if (seat.State == SeatState.Host) { findAnotherHost = true; } seat.Account = null; seat.State = SeatState.Empty; loggedInGuidToRoom.Remove(token.token); if (!room.Seats.Any(state => state.State != SeatState.Empty && state.State != SeatState.Closed)) { rooms.Remove(room.Id); return RoomOperationResult.Success; } if (findAnotherHost) { foreach (var host in room.Seats) { if (host.Account != null) { host.State = SeatState.Host; break; } } } NotifyRoomLayoutChanged(room.Id); return RoomOperationResult.Success; } } } return RoomOperationResult.Invalid; }
public LoginStatus Login(int version, string username, out LoginToken token, out Account retAccount) { Console.WriteLine("{0} logged in", username); var connection = OperationContext.Current.GetCallbackChannel<IGameClient>(); OperationContext.Current.Channel.Faulted += new EventHandler(Channel_Faulted); OperationContext.Current.Channel.Closed += new EventHandler(Channel_Faulted); token = new LoginToken(); token.token = System.Guid.NewGuid(); Account account = new Account() { Username = username, Id = newAccountId++ }; retAccount = account; loggedInGuidToAccount.Add(token.token, account); loggedInGuidToChannel.Add(token.token, connection); loggedInAccountToGuid.Add(account, token.token); loggedInChannelsToGuid.Add(connection, token.token); return LoginStatus.Success; }
private void _Logout(LoginToken token) { if (!loggedInGuidToAccount.ContainsKey(token.token)) return; Console.WriteLine("{0} logged out", loggedInGuidToAccount[token.token].Username); if (loggedInGuidToRoom.ContainsKey(token.token)) { _ExitRoom(token, loggedInGuidToRoom[token.token].Id); } loggedInGuidToAccount.Remove(token.token); }
public RoomOperationResult StartGame(LoginToken token) { if (VerifyClient(token)) { if (!loggedInGuidToRoom.ContainsKey(token.token)) { return RoomOperationResult.Invalid; } int portNumber; var room = loggedInGuidToRoom[token.token]; var total = room.Seats.Count(pl => pl.Account != null); var initiator = room.Seats.FirstOrDefault(pl => pl.Account == loggedInGuidToAccount[token.token]); if (room.State == RoomState.Gaming) return RoomOperationResult.Invalid; if (total <= 1) return RoomOperationResult.Invalid; if (initiator == null || initiator.State != SeatState.Host) return RoomOperationResult.Invalid; room.State = RoomState.Gaming; var gs = new GameSettings() { TimeOutSeconds = room.TimeOutSeconds, TotalPlayers = total, CheatEnabled = CheatEnabled }; GameService.StartGameService(HostingIp, gs, room.Id, _OnGameEnds, out portNumber); _NotifyGameStart(loggedInGuidToRoom[token.token].Id, HostingIp, portNumber); return RoomOperationResult.Success; } return RoomOperationResult.Auth; }
public Room CreateRoom(LoginToken token, string password = null) { if (VerifyClient(token)) { if (loggedInGuidToRoom.ContainsKey(token.token)) { return null; } while (rooms.ContainsKey(newRoomId)) { newRoomId++; } Room room = new Room(); for (int i = 0; i < 8; i++) { room.Seats.Add(new Seat() { State = SeatState.Empty }); } room.Seats[0].Account = loggedInGuidToAccount[token.token]; room.Seats[0].State = SeatState.Host; room.Id = newRoomId; room.OwnerId = 0; rooms.Add(newRoomId, room); if (loggedInGuidToRoom.ContainsKey(token.token)) { loggedInGuidToRoom.Remove(token.token); } loggedInGuidToRoom.Add(token.token, room); Console.WriteLine("created room {0}", newRoomId); return room; } Console.WriteLine("Invalid createroom call"); return null; }
private RoomOperationResult _ExitRoom(LoginToken token, int roomId) { if (loggedInGuidToRoom.ContainsKey(token.token)) { var room = loggedInGuidToRoom[token.token]; foreach (var seat in room.Seats) { if (seat.Account == loggedInGuidToAccount[token.token]) { seat.Account = null; seat.State = SeatState.Empty; loggedInGuidToRoom.Remove(token.token); if (!room.Seats.Any(state => state.State != SeatState.Empty)) { rooms.Remove(room.Id); return RoomOperationResult.Success; } NotifyRoomLayoutChanged(roomId); return RoomOperationResult.Success; } } } return RoomOperationResult.Invalid; }
public void NotifyGameStart(string connectionString, LoginToken token) { GameServerConnectionString = connectionString; _loginToken = token; Application.Current.Dispatcher.BeginInvoke((ThreadStart)delegate() { LobbyView.Instance.StartGame(); }); }
private void _startClient() { string userName = tab0UserName.Text; string passwd = tab0Password.Password; Properties.Settings.Default.LastHostName = tab0HostName.Text; Properties.Settings.Default.LastUserName = tab0UserName.Text; Properties.Settings.Default.Save(); #if !DEBUG if (string.IsNullOrEmpty(userName)) { _Warn("Please provide a username"); return; } #endif busyIndicator.BusyContent = Resources["Busy.ConnectServer"]; busyIndicator.IsBusy = true; ILobbyService server = null; LoginToken token = new LoginToken(); string reconnect = null; string hostName = tab0HostName.Text; if (!hostName.Contains(":")) { hostName = hostName + ":" + DefaultLobbyPort; } BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (o, ea) => { try { ea.Result = LoginStatus.UnknownFailure; var lobbyModel = LobbyViewModel.Instance; var binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; var endpoint = new EndpointAddress(string.Format("net.tcp://{0}/GameService", hostName)); var channelFactory = new DuplexChannelFactory<ILobbyService>(lobbyModel, binding, endpoint); server = channelFactory.CreateChannel(); Account ret; var stat = server.Login(Misc.ProtocolVersion, userName, passwd, out token, out ret, out reconnect); if (stat == LoginStatus.Success) { LobbyViewModel.Instance.CurrentAccount = ret; if (reconnect != null) { Application.Current.Dispatcher.Invoke((ThreadStart)delegate() { MainGame.BackwardNavigationService = this.NavigationService; busyIndicator.BusyContent = Resources["Busy.Reconnecting"]; }); } } ea.Result = stat; } catch (Exception e) { string s = e.StackTrace; } }; worker.RunWorkerCompleted += (o, ea) => { bool success = false; if ((LoginStatus)ea.Result == LoginStatus.Success) { LobbyView lobby = LobbyView.Instance; LobbyView.Instance.OnNavigateBack += lobby_OnNavigateBack; var lobbyModel = LobbyViewModel.Instance; lobbyModel.Connection = server; lobbyModel.LoginToken = token; if (reconnect == null) { this.NavigationService.Navigate(lobby); busyIndicator.IsBusy = false; } else { lobbyModel.NotifyGameStart(reconnect); busyIndicator.IsBusy = true; } success = true; } if (!success) { if ((LoginStatus)ea.Result == LoginStatus.InvalidUsernameAndPassword) { MessageBox.Show("Invalid Username and Password"); busyIndicator.IsBusy = false; } else { // MessageBox.Show("Outdated version. Please update"); busyIndicator.BusyContent = Resources["Busy.Updating"]; } } }; worker.RunWorkerAsync(); }
private void _startClient() { busyIndicator.BusyContent = Resources["Busy.ConnectServer"]; busyIndicator.IsBusy = true; ILobbyService server = null; LoginToken token = new LoginToken(); string hostName = tab0HostName.Text; if (!hostName.Contains(":")) { hostName = hostName + ":" + DefaultLobbyPort; } string userName = tab0UserName.Text; BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (o, ea) => { try { ea.Result = false; var lobbyModel = LobbyViewModel.Instance; var binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; var endpoint = new EndpointAddress(string.Format("net.tcp://{0}/GameService", hostName)); var channelFactory = new DuplexChannelFactory<ILobbyService>(lobbyModel, binding, endpoint); server = channelFactory.CreateChannel(); Account ret; if (server.Login(1, userName, out token, out ret) == LoginStatus.Success) { LobbyViewModel.Instance.CurrentAccount = ret; ea.Result = true; } } catch (Exception e) { string s = e.StackTrace; } }; worker.RunWorkerCompleted += (o, ea) => { busyIndicator.IsBusy = false; bool success = false; if ((bool)ea.Result) { LobbyView lobby = new LobbyView(); var lobbyModel = LobbyViewModel.Instance; lobbyModel.Connection = server; lobbyModel.LoginToken = token; this.NavigationService.Navigate(lobby); success = true; } if (!success) { MessageBox.Show("Failed to launch client"); } }; worker.RunWorkerAsync(); }
/// <summary> /// /// </summary> /// <param name="isReplay">Set true if this is client is connected to a replayFile</param> /// <param name="replayStream"></param> /// <exception cref="System.ArgumentOutOfRangeException" /> /// <exception cref="System.Net.Sockets.SocketException" /> public void Start(Stream recordStream = null, LoginToken? token = null) { IPEndPoint ep = new IPEndPoint(IPAddress.Parse(IpString), PortNumber); TcpClient client = new TcpClient(); client.Connect(ep); NetworkStream stream = client.GetStream(); receiver = new ItemReceiver(stream, recordStream); sender = new ItemSender(stream); if (token != null) { sender.Send((LoginToken)token); sender.Flush(); } commId = 0; }
private RoomOperationResult _ExitRoom(LoginToken token) { if (loggedInGuidToRoom.ContainsKey(token.TokenString)) { var room = loggedInGuidToRoom[token.TokenString]; foreach (var seat in room.Seats) { if (seat.Account == loggedInGuidToAccount[token.TokenString]) { if (loggedInGuidToRoom[token.TokenString].State == RoomState.Gaming && gamingInfo.ContainsKey(loggedInGuidToRoom[token.TokenString]) && !gamingInfo[loggedInGuidToRoom[token.TokenString]].isDead[gamingInfo[loggedInGuidToRoom[token.TokenString]].Accounts.IndexOf(seat.Account)]) { return RoomOperationResult.Locked; } bool findAnotherHost = false; if (seat.State == SeatState.Host) { findAnotherHost = true; } seat.Account = null; seat.State = SeatState.Empty; loggedInGuidToRoom.Remove(token.TokenString); if (!room.Seats.Any(state => state.State != SeatState.Empty && state.State != SeatState.Closed)) { rooms.Remove(room.Id); return RoomOperationResult.Success; } if (findAnotherHost) { foreach (var host in room.Seats) { if (host.Account != null) { host.State = SeatState.Host; break; } } } NotifyRoomLayoutChanged(room.Id); return RoomOperationResult.Success; } } } return RoomOperationResult.Invalid; }