Exemple #1
0
            /// <summary>
            /// Ejecuta una acción de una carta del lado servidor
            /// </summary>
            public CardActionResult ExecuteServer(Mesa mesa, Tablero tablero, DataStr data)
            {
                var e          = new Events.EventHelper(tablero, mesa);
                var expression = "var result = new YerbaSoft.Web.Games.Clue.Common.DTO.Clue.Card.CardAction.CardActionResult(tablero, true);" + this.Server + "return result;";
                var result     = (CardActionResult)e.ExecuteAction(expression, data);

                tablero = result?.Tablero ?? tablero;

                return(result);
            }
        public IEnumerable <string> CalcMoveTo(string[] start, int dados, Mesa mesa)
        {
            var places = new List <string>();

            foreach (var s in start)
            {
                places.AddRange(CalcMoveTo(s, dados, mesa));
            }

            return(places);
        }
        /// <summary>
        /// MAIN PROCESS :: Cambia de turno al siguiente jugador y continúa el flujo
        /// </summary>
        /// <param name="mesa"></param>
        /// <param name="starting"></param>
        public void NuevoTurno(Mesa mesa, int?index = null)
        {
            tablero.TurnoIndex = index ?? (tablero.TurnoIndex >= tablero.Turnos.Length - 1 ? 0 : (tablero.TurnoIndex + 1));   // calculo el index del siguiente turno
            tablero.Turno      = tablero.Turnos[tablero.TurnoIndex];
            tablero.Status     = TurnoStatus.Start;

            mesa.TipoTablero.EventManager.OnStart(mesa, tablero);

            if (!TieneCartas(tablero.Status))
            {
                this.TiraDados(mesa);
            }
        }
        /// <summary>
        /// MAIN PROCESS :: Chequea información y finaliza el turno y continúa el flujo
        /// </summary>
        public void FinDeTurno(Mesa mesa)
        {
            mesa.TipoTablero.EventManager.OnFinTurno(mesa, tablero);

            if (tablero.Status == TurnoStatus.DespuesDados || tablero.Status == TurnoStatus.DespuesAcusacion)   // validación por si cambia el estado en algun evento
            {
                tablero.Status = TurnoStatus.FinDeTurno;
            }

            tablero.Status = Common.DTO.Clue.TurnoStatus.FinDeTurno;

            if (!TieneCartas(TurnoStatus.FinDeTurno))
            {
                this.NuevoTurno(mesa);
            }
        }
        /// <summary>
        /// MAIN PROCESS :: Mueve el personaje y continúa el flujo
        /// </summary>
        public void MoverPersonaje(Mesa mesa, string pos)
        {
            tablero.Posiciones[tablero.TurnoIndex] = pos;   // muevo al jugador
            tablero.MoveTo = new string[] { };              // quito los posibles movimientos del jugador
            tablero.CurrentRoom[tablero.TurnoIndex] = null; // por default reseteo que esté en alguna habitación

            mesa.TipoTablero.EventManager.OnMove(mesa, tablero);

            if (tablero.Status == TurnoStatus.Acusando)
            {
                this.EmpezarAcusamiento(); // entró a una habitación
            }
            else
            {
                this.FinDeTurno(mesa); // solo caminó por el mapa
            }
        }
        /// <summary>
        /// MAIN PROCESS :: Tira los dados y continúa el flujo
        /// </summary>
        public void TiraDados(Mesa mesa)
        {
            ///TODO: GGR - los dados se deberían iniciar cuando se inicia el tablero
            var dados = new Dados(mesa.TipoTablero.Dados);

            tablero.Dados.ShuffleDados();// = dados.Select(p => p.Shufle()).ToArray();

            mesa.TipoTablero.EventManager.OnTirarDados(mesa, tablero);

            if ((tablero.MoveTo?.Length ?? 0) == 0)     // validación por si algún evento ya calculó el movimiento
            {
                tablero.MoveTo = CalcMoveTo(tablero.Posiciones[tablero.TurnoIndex], tablero.Dados.GetValues(true).Sum(p => p ?? 0), mesa).ToArray();
            }

            if (tablero.Status == TurnoStatus.Start)    // validación por si algún evento cambió de estado
            {
                tablero.Status = TurnoStatus.DespuesDados;
            }
        }
        public void UseCard(Guid idUser, Mesa mesa, Card card, Card.DataStr data)
        {
            Card.CardAction.CardActionResult result = null;

            var userTurnoIndex = tablero.Turnos.IndexOf(p => p == idUser);
            var status         = tablero.Status;

            if (card.Action != null && card.Action.Server != null)
            {
                result = card.Action.ExecuteServer(mesa, tablero, data);
            }

            //quito la carta de la mano del jugador
            var cards = tablero.Cards[userTurnoIndex].ToList();

            cards.RemoveAt(cards.IndexOf(p => p.Name == card.Name));
            tablero.Cards[userTurnoIndex] = cards.ToArray();

            ///Avanzo de estado excepto que se especifique el parámetro "nextStatus como false"
            if (result?.NextStatus ?? true)
            {
                ForceContinueStatus(mesa);
            }
        }