public void ClientConnected(string username, string password)
{
if (callbacks.ContainsKey(username))
{
throw new FaultException <UserExistsFault>(
new UserExistsFault {
Message = username + " already Loged in"
});
}
else
{
try {
Player player = GetPlayerFromDB(username);
if (player.Password != password)
{
throw new FaultException("Incorrect Password, Try again");
}
IGameServiceCallback callback =
OperationContext.Current.GetCallbackChannel <IGameServiceCallback>();
callbacks.Add(username, callback);
UpdateUsersList();
} catch (Exception ex) {
throw new FaultException(ex.Message);
}
}
}
public void ClientConnected(string username)
{
try
{
/** if (callbacks.ContainsKey(username))
* {
* throw new FaultException<UserExistsFault>(
* new UserExistsFault
* {
* Message = username + " already exists"
* }
* }*/
IGameServiceCallback callback =
OperationContext.Current.GetCallbackChannel
<IGameServiceCallback>();
callbacks.Add(username, callback);
availables.Add(username);
UpdateUsersList();
}
catch (Exception ex)
{
throw new FaultException(ex.Message);
}
}
/// <summary>
/// Notifica a las cuentas de la sala que una cuenta ha salido
/// </summary>
/// <param name="CuentaAEliminar">CuentaModel</param>
private void NotificarCuentasEnSalaSalidaDeJugador(CuentaModel CuentaAEliminar)
{
lock (ObjetoParaSincronizar)
{
List <CuentaModel> cuentasEnLaSala = RecuperarCuentasEnLaSala();
IGameServiceCallback[] ServiciosCallback = new IGameServiceCallback[CuentasEnLaSala.Values.Count];
CuentasEnLaSala.Values.CopyTo(ServiciosCallback, 0);
foreach (IGameServiceCallback canal in ServiciosCallback)
{
try
{
canal.CuentaAbandoSala(CuentaAEliminar);
if (EstadoDeLaPartida != EnumEstadoSala.EnPartida)
{
canal.RefrescarCuentasEnSala(cuentasEnLaSala);
}
}
catch (ObjectDisposedException Dispose)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Dispose.Message);
}
catch (CommunicationObjectAbortedException Communication)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Communication.Message);
}
catch (TimeoutException Time)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Time.Message);
}
}
}
}
public User(string userName, string password, int id, IGameServiceCallback callback)
{
this.UserName = userName;
this.PassWord = password;
this.callback = callback;
this.Id = id;
this.score = 0;
}
/// <summary>
/// Construye una sala con los datos necesarios
/// </summary>
/// <param name="id">String</param>
/// <param name="EsSalaPublica">Boolean</param>
/// <param name="cuenta">CuentaModel</param>
/// <param name="serviceCallback">IGameServiceCallback</param>
/// <param name="DireccionIpDelCliente">String</param>
public Sala(String id, Boolean EsSalaPublica, CuentaModel cuenta, IGameServiceCallback serviceCallback,
String DireccionIpDelCliente)
{
Id = id;
AsignarTipoDeJugador(cuenta);
CuentasEnLaSala.Add(cuenta, serviceCallback);
DireccionesIpDeCuentas.Add(cuenta, DireccionIpDelCliente);
this.EsSalaPublica = EsSalaPublica;
}
/// <summary>
/// Crea una sala publica con Id aleatorio
/// </summary>
/// <param name="Cuenta">CuentaModel</param>
/// <param name="ActualCallback">IGameServiceCallback</param>
/// <returns>La sala que se creada</returns>
private Sala CrearSalaConIdAleatorio(CuentaModel Cuenta, IGameServiceCallback ActualCallback, String DireccionIpDelCliente)
{
String IdDeSala;
do
{
IdDeSala = GeneradorCodigo.GenerarCadena();
} while (EstaElIdDeSalaEnUso(IdDeSala));
Sala NuevaSala = new Sala(IdDeSala, true, Cuenta, ActualCallback, DireccionIpDelCliente);
return(NuevaSala);
}
public void Login(string userName, string passWord, int id)
{
OperationContext context = OperationContext.Current;
IGameServiceCallback callback = context.GetCallbackChannel <IGameServiceCallback>();
User newUser = new User(userName, passWord, id, callback);
CC.Users.Add(newUser);
foreach (var user in CC.Users)
{
user.callback.ShowLogin(userName, id, CC.maxRooms);
}
SendRoomsInfoToAllUsers();
}
/// <summary>
/// Agrega una cuenta a la lista de Cuentas en la sala y notifica a las demas cuentas en la sala
/// </summary>
/// <param name="cuenta">CuentaModel</param>
/// <param name="serviceCallback">IGameServiceCallback</param>
/// <returns>Verdadero si me pude la cuenta se unio a la sala, falso si no</returns>
public Boolean UnirseASala(CuentaModel cuenta, IGameServiceCallback serviceCallback, String DireccionIpDelCliente)
{
bool SeConectoALaSala = false;
if (NumeroJugadoresEnSala >= 5)
{
SeConectoALaSala = false;
}
lock (ObjetoParaSincronizar)
{
try
{
AsignarTipoDeJugador(cuenta);
foreach (IGameServiceCallback callback in CuentasEnLaSala.Values)
{
callback.NuevoCuentaEnLaSala(cuenta);
}
CuentasEnLaSala.Add(cuenta, serviceCallback);
DireccionesIpDeCuentas.Add(cuenta, DireccionIpDelCliente);
SeConectoALaSala = true;
}
catch (ArgumentException)
{
SeConectoALaSala = false;
}
catch (ObjectDisposedException Dispose)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Dispose.Message);
}
catch (TimeoutException Time)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Time.Message);
}
catch (CommunicationException Communication)
{
NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();
logger.Warn(Communication.Message);
}
}
return(SeConectoALaSala);
}
IGameServiceCallback callback = null; //
public bool Join(int usernumber)
{
MyGame = new Game(GameHandler);
lock (syncObj)
{
if (!UserList.Contains(usernumber)) //이름이 기존 채터에 있는지 검색한다.
{
//2. 사용자에게 보내 줄 채널을 설정한다.
callback = OperationContext.Current.GetCallbackChannel <IGameServiceCallback>();
//현재 접속자 정보를 모두에게 전달
BroadcastMessage(usernumber, "", "UserEnter");
//델리게이터 추가(향후 데이터 수신이 가능하도록 구성)
UserList.Add(usernumber);
List += MyGame;
return(true);
}
return(false);
}
}
public void RegisterClient(string username, string password)
{
if (callbacks.ContainsKey(username))
{
throw new FaultException <UserExistsFault>(
new UserExistsFault {
Message = username + " User name is already exist!"
});
}
try {
RegisterNewPlayer(username, password);
IGameServiceCallback callback =
OperationContext.Current.GetCallbackChannel
<IGameServiceCallback>();
callbacks.Add(username, callback);
UpdateUsersList();
} catch (Exception ex) {
throw new FaultException(ex.Message + " this one");
}
}
/// <summary>
/// Crea una Sala personalizada
/// </summary>
/// <param name="Id">String</param>
/// <param name="EsSalaPublica">Boolean</param>
/// <param name="Cuenta">CuentaModel</param>
/// <param name="ActualCallback">IGameServiceCallback</param>
/// <returns>EnumEstadoCrearSalaConId</returns>
public EnumEstadoCrearSalaConId CrearSala(string Id, Boolean EsSalaPublica, CuentaModel Cuenta,
IGameServiceCallback ActualCallback, String DireccionIpDelCliente)
{
EnumEstadoCrearSalaConId EstadoDeCreacionDeSala = EnumEstadoCrearSalaConId.NoSeEncuentraEnSesion;
if (ManejadorDeSesiones.VerificarCuentaLogeada(Cuenta))
{
Cuenta = ManejadorDeSesiones.ObtenerCuentaCompleta(Cuenta);
if (!EstaElIdDeSalaEnUso(Id))
{
Sala SalaAAgregar = new Sala(Id, EsSalaPublica, Cuenta, ActualCallback, DireccionIpDelCliente);
SalasCreadas.Add(SalaAAgregar);
SuscribirseAEventosDeSala(SalaAAgregar);
SalaCreada?.Invoke(SalaAAgregar);
EstadoDeCreacionDeSala = EnumEstadoCrearSalaConId.CreadaCorrectamente;
}
else
{
EstadoDeCreacionDeSala = EnumEstadoCrearSalaConId.IdYaExistente;
}
}
return(EstadoDeCreacionDeSala);
}
/// <summary>
/// Agrega una Cuenta a una sala completa, si no hay salas disponibles la crea
/// </summary>
/// <param name="Cuenta">CuentaModel</param>
/// <param name="ActualCallback">IGameServiceCallback</param>
/// <returns>Verdadero si la sala cuenta se unico correctamenete a la sala o falso si no</returns>
public Boolean UnisrseASalaDisponible(CuentaModel Cuenta, IGameServiceCallback ActualCallback, String DireccionIpDelCliente)
{
Boolean seUnioASala = false;
if (ManejadorDeSesiones.VerificarCuentaLogeada(Cuenta))
{
Cuenta = ManejadorDeSesiones.ObtenerCuentaCompleta(Cuenta);
Sala SalaAUnirse = BuscarSalaIncompleta();
if (SalaAUnirse != null)
{
seUnioASala = SalaAUnirse.UnirseASala(Cuenta, ActualCallback, DireccionIpDelCliente);
SeUnioASala?.Invoke(SalaAUnirse.Id);
}
else
{
Sala NuevaSala = CrearSalaConIdAleatorio(Cuenta, ActualCallback, DireccionIpDelCliente);
SalasCreadas.Add(NuevaSala);
SuscribirseAEventosDeSala(NuevaSala);
SalaCreada?.Invoke(NuevaSala);
seUnioASala = true;
}
}
return(seUnioASala);
}
/// <summary>
/// Operación de interfaz IGameServices.
/// </summary>
/// <param name="gameServiceCreator"></param>
public GameServices(IGameServiceCallback gameServiceCallbackCreator)
{
this.gameChannel = gameServiceCallbackCreator ?? throw new ArgumentNullException("gameServiceCallbackCreator");
}
public Client(IGameServiceCallback callbackHandler)
{
_callbackHandler = callbackHandler;
}
/// <summary>
/// Agrega una Cuenta al a la sala que tenga ese Id
/// </summary>
/// <param name="Id">String</param>
/// <param name="CuentaAAgregar">Cuenta</param>
/// <param name="ActualCallback">IGameServiceCallback</param>
/// <returns>EnumEstadoDeUnirseASala</returns>
public EnumEstadoDeUnirseASala UnirseASalaConId(String Id, CuentaModel CuentaAAgregar, IGameServiceCallback ActualCallback,
String DireccionIpDelCliente)
{
EnumEstadoDeUnirseASala estadoDeUnirseASala = EnumEstadoDeUnirseASala.NoSeEncuentraEnSesion;
if (ManejadorDeSesiones.VerificarCuentaLogeada(CuentaAAgregar))
{
estadoDeUnirseASala = EnumEstadoDeUnirseASala.SalaInexistente;
CuentaAAgregar = ManejadorDeSesiones.ObtenerCuentaCompleta(CuentaAAgregar);
foreach (Sala sala in SalasCreadas)
{
if (sala.Id == Id)
{
if (sala.UnirseASala(CuentaAAgregar, ActualCallback, DireccionIpDelCliente))
{
estadoDeUnirseASala = EnumEstadoDeUnirseASala.UnidoCorrectamente;
SeUnioASala?.Invoke(sala.Id);
}
else
{
estadoDeUnirseASala = EnumEstadoDeUnirseASala.SalaLlena;
}
break;
}
}
}
return(estadoDeUnirseASala);
}
