/// <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"); } }