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;
}
