/// <summary>
/// Gets the ongoing battle of a given user.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>The battle director of an ongoing battle</returns>
public IBattleDirector GetOngoingBattle(IRoomUser user)
{
return this.battles.FirstOrDefault(
battle => battle.Scenario.State != BattleState.Concluded &&
battle.Scenario.State != BattleState.Aborted &&
(battle.Scenario.PlayerA.Username == user.Username ||
battle.Scenario.PlayerB.Username == user.Username));
}
internal void AddBattle(IRoomUser A, IRoomUser B)
{
// TODO: Agregar una batalla a la lista de batallas, crear Players en base a IRoomUser
/*BattleDirector director = new BattleDirector();
director.Scenario = new BattleScenario()
{
PlayerA = A,
PlayerB = B,
Result = BattleResult.None,
State = BattleState.WaitingForCardElection
};*/
}
public IBattleRequest FindBattle(IRoomUser user)
{
BattleRequest request = new BattleRequest(user);
request.State = RequestState.Waiting;
IBattleRequest aRequest = this.battles.FirstOrDefault(battle => battle.State == RequestState.Waiting);
if (aRequest != null)
{
((BattleRequest)aRequest).State = RequestState.Ready;
request.State = RequestState.Ready;
((BattleManager)user.Room.BattlesManager).AddBattle(user, aRequest.Requestor);
}
return request;
}
/**
* Obtiene los retos que ha recibido el jugador user
* Notas:
* Si hay más de 1 reto pendiente, cada llamada a este método
* obtendrá un reto de la lista (FIFO) de retos pendientes
* Si el resultado de la operación es Fail, entonces no se ha recibido
* ningún reto y ResultData es null, si es Success, quiere decir que hay reto(s) pendiente(s)
* y en ResultData se envía el reto pendiente
**/
public IOperationResult<IReceivedChallenge> GetReceivedChallenge(IRoomUser user)
{
OperationResult<IReceivedChallenge> result;
var value = Model.Cache.Retrieve<IReceivedChallenge>(chal => chal.Challengee.Username == user.Username);
if (value != null)
{
result = new OperationResult<IReceivedChallenge>(ResultValue.Success, "", (IReceivedChallenge)value);
}
else
{
result = new OperationResult<IReceivedChallenge>(ResultValue.Fail, "", value);
}
return result;
}
public RoomUserDTO(IRoomUser user)
{
this.Username = user.Username;
this.RoomUserState = ((Func<string>)(() =>
{
/* JavaScript style: Booyah! */
switch (user.State)
{
case InRoomState.Idle:
return Resources.RoomUserIdle;
case InRoomState.Playing:
return Resources.RoomUserPlaying;
case InRoomState.RequestingBattle:
return Resources.RoomUserRequestedBattle;
case InRoomState.RequestingChallenge:
return Resources.RoomUserRequestedChallenge;
default:
throw new Exception("No puede ser. Imposible.");
}
}))();
}
public IBattleRequest GetRequestedBattle(IRoomUser user)
{
return this.battles.Where(b => b.Requestor.Username == user.Username).FirstOrDefault();
}
public IOperationResult LeaveRoom(IRoomUser roomUser)
{
Contract.Requires(roomUser != null, "roomUser is null.");
return default(IOperationResult);
}
public IBattleRequest FindBattle(IRoomUser requestor)
{
throw new NotImplementedException();
}
/// <summary>
/// Permite a un usuario de cuarto salirse del cuarto en que se encuentra
/// </summary>
/// <param name="roomUser">El usuario de cuarto.</param>
public IOperationResult LeaveRoom(IRoomUser roomUser)
{
OperationResult result;
if (this.roomsUserLists[roomUser.Room].Remove(roomUser))
{
messaging.Publish(roomUser.Room, Tuple.Create(roomUser, RoomAction.Leave));
result = new OperationResult(ResultValue.Success, "");
}
else
{
result = new OperationResult(ResultValue.Fail, Properties.Resources.UserWasNotInRoom);
}
return result;
}
public static void Init()
{
Initializer.ReleaseDependencies();
Initializer.LoadDependencies();
// Mock Room User
Mock<IRoomUser> roomUser = MakeRoomUser();
mRoomUser = roomUser.Object;
// Make user session
Func<IOperationResult<IDictionary<IPlayer, int>>> valuesGetter = () =>
{
IDictionary<IPlayer, int> values = new Dictionary<IPlayer, int>();
values.Add(Opp, 10);
values.Add(User, 20);
return Mok.Helper.CreateResultWith(ResultValue.Fail, values);
};
Mock<IUserSession> uSession = MakeUserSession(roomUser, valuesGetter);
UserSession = uSession.Object;
Mock<IRoomUser> roomOpponent = MakeRoomOpponent();
Mock<IUserSession> oSession = MakeOpponentSession(roomOpponent, valuesGetter);
OppSession = oSession.Object;
Mok.Helper.SetupAccountManager(ResultValue.Fail, ResultValue.Success, uSession.Object, oSession.Object);
// Setup the room
Mock<IRoom> moqRoom = MakeRoom(roomUser, roomOpponent);
mRoom = moqRoom.Object;
// Setup the users' cards (8)
IOperable<Mock<ICard>> buildOperation = CreateCardsMaker();
int i = 0;
mUserCards = buildOperation
.With(moqCard => moqCard.SetupGet(c => c.Name).Returns("user-card#" + ((++i % 8) + 1)))
.Build().Select(moq => moq.Object);
mOppCards = buildOperation
.With(moqCard => moqCard.SetupGet(c => c.Name).Returns("opp-card#" + ((++i % 8) + 1)))
.Build().Select(moq => moq.Object);
// Setup a successful operation result
Mock<IOperationResult> opResult = MakeOperationResult();
// Setup the users
Mock<IPlayer> moqUser = SetupUsers(opResult);
mUser = moqUser.Object;
// Setup the battle opponent
Mock<IPlayer> moqOpp = MakeOpponentPlayer(opResult);
mOpp = moqOpp.Object;
// Setup the battle scenario
Mock<IBattleDirector> director = MakeBattleDirector(opResult);
mBattleDirector = director.Object;
// Setup the Rooms Manager
Mock<IRoomsManager> moqRoomsManager = MakeRoomsManager(roomOpponent);
Mok.Helper.Inject(moqRoomsManager.Object);
}
void IRoomController.DisconnectUser(IRoomUser roomUser)
{
if (roomUser.Room != this)
throw new ArgumentException("user is not for this room");
lock (roomUsers)
roomUsers.Remove(roomUser.User.Id);
}
public Challenge(IRoomUser challenger, IRoomUser challengee)
{
this.Challengee = challengee;
this.Challenger = challenger;
this.State = ChallengeState.Sent;
}
private void Init(string sessionId)
{
Contract.Requires(!String.IsNullOrEmpty(sessionId), "sessionId is null or empty.");
var accMgr = Dependency.Locator.GetSingleton<IAccountManager>();
IUserSession userSession = SessionHelper.GetSession(sessionId);
IRoomsManager roomMgr = Dependency.Locator.GetSingleton<IRoomsManager>();
IOperationResult<IRoomUser> operation = roomMgr.GetRoomUser(userSession);
if (operation.Result == ResultValue.Success)
{
this.roomUser = operation.ResultData;
this.Usuarios = this.roomUser.Room.Users
.Select(u => Dependency.Locator.Create<IRoomUserDTO>(u));
this.SelectedUserIndex = 0;
this.LogoutButton = Dependency.Locator.Create<ILogoutButtonPresentation>(sessionId);
this.UpdateBasedOnRoomUser();
}
else
{
throw new NavigationException(string.Format(Resources.PrimeroDebeEntrarAUnCuarto));
}
}
/**
* Envía un reto nuevo
* Restricciones:
* Solamente se puede enviar un reto a la vez, si se intenta enviar otro reto,
* se cancelará el reto anterior y se enviará uno nuevo, a menos que el reto
* anterior ya haya sido aceptado, en cuyo caso, se regresará el reto
* enviado anteriormente que ha sido aceptado
**/
public IOperationResult<IIssuedChallenge> Send(IRoomUser challenger, IRoomUser challengee)
{
var chall = new Challenge(challenger, challengee);
Model.Cache.Add(this, chall);
messaging.Publish(challengee.Room, Tuple.Create(challengee, chall));
return new OperationResult<IIssuedChallenge>(ResultValue.Success, "", chall);
}
public Task StartListenerBanPollAsync(IRoomUser listener)
{
throw new NotImplementedException();
}
public BattleRequest(IRoomUser user)
{
this.Requestor = user;
}
private void Init(string sessionId)
{
Contract.Requires(!string.IsNullOrEmpty(sessionId));
session = SessionHelper.GetSession(sessionId);
var result = Dependency.Locator.GetSingleton<IRoomsManager>()
.GetRoomUser(session);
if (result.Result == ResultValue.Success)
{
roomUser = result.ResultData;
director = roomUser.Room.BattlesManager
.GetOngoingBattle(roomUser);
scenario = director.Scenario;
this.InitCommonState();
switch (scenario.State)
{
case BattleState.WaitingForCardElection:
this.SetCardElectionState();
break;
case BattleState.WaitingForCardRemoval:
this.SetCardRemovalState();
break;
case BattleState.CalculatingResult:
this.SetCalculatingState();
break;
case BattleState.Concluded:
this.SetConcludedState();
break;
case BattleState.Aborted:
this.SetAbortedState();
break;
}
}
else
{
throw new NavigationException("Primero debe iniciar una batalla");
}
}
