public static Ente RemoverActividadDeEnte(Ente ente, Actividad actividad)
{
var _ente = RepositorioEntes.Find(item => item.Nombre == ente.Nombre);
_ente.MisActividades.RemoveAll(item => item.Descripcion == actividad.Descripcion);
return(_ente);
}
public PlayAEntityCommand(CartaPartida cl, JugadorPartida p, int tablePos, Ente ente)
{
this.p = p;
this.cl = cl;
this.tablePos = tablePos;
this.ente = ente;
}
public ActionResult Edit([Bind(Include = "EnteID,NombreCompleto,FechaNacimiento,SexoID,Polizas")] Ente ente)
{
if (ModelState.IsValid)
{
foreach (Poliza poliza in ente.Polizas)
{
if (poliza.PolizaID == 0)
{
poliza.AseguradoID = ente.EnteID;
db.Entry(poliza).State = EntityState.Added;
}
else
{
db.Entry(poliza).State = EntityState.Modified;
}
}
db.Entry(ente).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.SexoID = new SelectList(db.Sexos, "SexoID", "Descripcion", ente.SexoID);
return(View(ente));
}
/// <summary>
/// Muestra la accion (ataque, defensa, activar) correspondiente al ente en la batalla.
/// </summary>
/// <param name="idEnte">Identifier ente.</param>
public void MostrarAccion(int idEnte)
{
Ente ente = Recursos.EntesCreadosEnElJuego[idEnte];
if (ente.GetType() == typeof(Magica))
{
//Si la magica es de tipo trampa no debe salir la opcion de activar voluntariamente
if (EntePreparado(ente) && !EsMagicaTrampa(ente))
{
AccionesPopUp.Instance.MostrarAccionEfecto();
AccionesPopUp.Instance.RegistrarCallBack(ActivarEfectoMagica, idEnte);
}
}
else
{
Criatura criatura = (Criatura)ente;
if (criatura.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
if (!CriaturaHaAtacado(criatura))
{
AccionesPopUp.Instance.MostrarAccionDefensa();
}
}
else
{
AccionesPopUp.Instance.MostrarAccionAtaque();
}
AccionesPopUp.Instance.RegistrarCallBack(CambiarPosicionCriatura, idEnte);
}
}
/// <summary>
/// Permite jugar un ente para el bot.
/// </summary>
/// <returns><c>true</c>, if ente was jugared, <c>false</c> otherwise.</returns>
bool JugarEnte()
{
bool movimientoHecho = false;
for (int i = 0; i < NumEntesEnLaMesa() && !movimientoHecho; i++)
{
Ente cl = EntesEnLaMesa() [i];
if (Controlador.Instance.EntePuedeUsarse(cl))
{
// attack a random target with a creature
if (cl.GetType() == typeof(Magica))
{
if (!((Magica)cl).EfectoActivado)
{
if (!Controlador.Instance.EsMagicaTrampa(cl))
{
Controlador.Instance.ActivarEfectoMagica(cl.ID);
movimientoHecho = true;
}
}
}
else
{
Criatura criatura = (Criatura)cl;
if (criatura.PosicionCriatura.Equals(PosicionCriatura.ATAQUE))
{
if (!Controlador.Instance.CriaturaHaAtacado(criatura))
{
JugadorPartida enemigo = Controlador.Instance.OtroJugador(this);
if (enemigo.NumEntesEnLaMesa() > 0)
{
int index = Random.Range(0, enemigo.NumEntesEnLaMesa());
Ente enteObjetivo = enemigo.EntesEnLaMesa() [index];
if (enteObjetivo.GetType() == typeof(Criatura) || (enteObjetivo.GetType() == typeof(Magica) && !((Magica)enteObjetivo).EfectoActivado))
{
Controlador.Instance.AtacarEnte(cl.ID, enteObjetivo.ID);
movimientoHecho = true;
}
}
else
{
Controlador.Instance.AtacarJugador(cl.ID, enemigo.ID);
movimientoHecho = true;
}
}
}
else
{
Controlador.Instance.CambiarPosicionCriatura(criatura.ID);
movimientoHecho = true;
}
}
}
}
if (movimientoHecho)
{
InsertDelay(1f);
}
return(movimientoHecho);
}
public static Ente AgregarActividadAEnte(Actividad actividad, Ente ente)
{
Ente _ente = BuscarEnte(ente);
_ente.MisActividades.Add(actividad);
ActualizarEnte(_ente);
return(_ente);
}
public ActionResult DeleteConfirmed(int id)
{
Ente ente = db.Entes.Find(id);
db.Entes.Remove(ente);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// Función que mata un ente.
/// </summary>
/// <param name="idEnte">Identifier ente.</param>
public void MuerteEnte(int idEnte)
{
Ente ente = Recursos.EntesCreadosEnElJuego[idEnte];
JugadorPartida jugadorObjetivo = Controlador.Instance.ObtenerDueñoEnte(ente);
jugadorObjetivo.EliminarEnteMesa(ente);
ente.Morir();
new EnteDieCommand(idEnte, jugadorObjetivo).AñadirAlaCola();
}
public static int AgregarEnte(Ente ente)
{
if (ente.MisActividades == null)
{
ente.MisActividades = new List <Actividad>();
}
RepositorioEntes.Add(ente);
return(1);
}
/// <summary>
/// Mira si la criatura se encuentra en posicion de ataque.
/// </summary>
/// <returns><c>true</c>, if en posicion ataque was estaed, <c>false</c> otherwise.</returns>
/// <param name="idEnte">Identifier ente.</param>
public bool EstaEnPosicionAtaque(int idEnte)
{
Ente ente = Recursos.EntesCreadosEnElJuego[idEnte];
if (ente.GetType() == typeof(Criatura))
{
return(((Criatura)ente).PosicionCriatura.Equals(PosicionCriatura.ATAQUE));
}
return(false);
}
public ActionResult Create([Bind(Include = "EnteID,NombreCompleto,FechaNacimiento,SexoID")] Ente ente)
{
if (ModelState.IsValid)
{
db.Entes.Add(ente);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.SexoID = new SelectList(db.Sexos, "SexoID", "Descripcion", ente.SexoID);
ViewBag.Sexos = db.Sexos.ToList();
return(View(ente));
}
// GET: Entes/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ente ente = db.Entes.Find(id);
if (ente == null)
{
return(HttpNotFound());
}
return(View(ente));
}
// GET: Entes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ente ente = db.Entes.Include(e => e.Polizas).FirstOrDefault(f => f.EnteID == id);
if (ente == null)
{
return(HttpNotFound());
}
ViewBag.SexoID = new SelectList(db.Sexos, "SexoID", "Descripcion", ente.SexoID);
return(View(ente));
}
/// <summary>
/// Jugar carta
/// </summary>
/// <param name="cartaJugada"></param>
/// <param name="ente"></param>
/// <param name="tablePos"></param>
private void JugarCarta(JugadorPartida jugador, CartaPartida cartaJugada, Ente ente, int tablePos)
{
jugador.AñadirEnteMesa(tablePos, ente);
// no matter what happens, move this card to PlayACardSpot
new PlayAEntityCommand(cartaJugada, jugador, tablePos, ente).AñadirAlaCola();
if (jugador.GetType() == typeof(JugadorHumano))
{
ActualizarManaJugador(jugador);
MostrarCartasJugablesJugador(jugador);
}
jugador.EliminarCartaMano(cartaJugada);
if (jugador.GetType() == typeof(JugadorHumano))
{
MostrarCartasJugablesJugador(jugador);
}
}
/// <summary>
/// Función que permite atacar a un ente.
/// </summary>
/// <param name="idAtacante">Identifier atacante.</param>
/// <param name="idObjetivo">Identifier objetivo.</param>
public void AtacarEnte(int idAtacante, int idObjetivo)
{
Ente atacante = Recursos.EntesCreadosEnElJuego[idAtacante];
Ente objetivo = Recursos.EntesCreadosEnElJuego[idObjetivo];
if (atacante.GetType() == typeof(Criatura))
{
((Criatura)atacante).HaAtacado = true;
}
if (objetivo.GetType() == typeof(Criatura))
{
Criatura criaturaObjetivo = (Criatura)objetivo;
AtacarCriatura((Criatura)atacante, criaturaObjetivo);
}
else
{
ActivarEfectoMagica(idObjetivo, idAtacante);
}
}
public EnteDao SelectByCodiceEnte(string name)
{
Ente _ente = new Ente();
EnteDao _eBL = null;
using (db)
{
EnteProvider provider = new EnteProvider();
_ente = provider.SelectByEnte(db, name);
}
if (_ente != null)
{
#region comment
//_eBL = new EnteDao
//{
// CodAppl = _ente.CodAppl,
// CodiceEnte = _ente.CodiceEnte,
// CodiceFiscale = _ente.CodiceFiscale,
// CodiceUtente = _ente.CodiceUtente,
// ContribuzioneEnte = _ente.ContribuzioneEnte,
// DataAggiornamento = _ente.DataAggiornamento,
// DataFine = _ente.DataFine,
// DataInizio = _ente.DataInizio,
// EnteAppartenenza = _ente.EnteAppartenenza,
// Progressivo = _ente.Progressivo,
// RagioneSociale = _ente.RagioneSociale,
// TipologiaEnte =_ente.TipologiaEnte
//};
#endregion
_eBL = new EnteDao();
Asdep.Common.DAO.ExtraDao.PropertyCopier <Ente, EnteDao> .Copy(_ente, _eBL);
}
return(_eBL);
}
public void AñadirEnteMesa(int posicionMesa, Ente ente)
{
mesa.EntesEnTablero.Insert(posicionMesa, ente);
}
/// <summary>
/// Una magica tipo trampa es aquella que no puede activarse voluntariamente, de momento solo se compara con la de espejo.
/// </summary>
/// <returns><c>true</c>, if magica trampa was esed, <c>false</c> otherwise.</returns>
/// <param name="ente">Ente.</param>
public bool EsMagicaTrampa(Ente ente)
{
Magica magica = (Magica)ente;
return(magica.AssetCarta.Efecto.Equals(Efecto.Espejo));
}
public static Ente BuscarEnte(Ente ente)
{
return(RepositorioEntes.Find(item => item.Nombre == ente.Nombre));
}
public Ente BuscarEnte(Ente ente)
{
return(Repositorios.BuscarEnte(ente));
}
public int AgregarEnte(Ente ente)
{
return(Repositorios.AgregarEnte(ente));
}
/// <summary>
/// Determina el jugador dueño del ente.
/// </summary>
/// <returns>The dueño ente.</returns>
/// <param name="ente">Ente.</param>
public JugadorPartida ObtenerDueñoEnte(Ente ente)
{
JugadorPartida jugador = Controlador.Instance.Local.Area.Equals(ente.Area) ? Controlador.Instance.Local : Controlador.Instance.Enemigo;
return(jugador);
}
public Ente RemoverActividadDeEnte(Ente ente, Actividad actividad)
{
return(Repositorios.RemoverActividadDeEnte(ente, actividad));
}
public static int ActualizarEnte(Ente ente)
{
RemoverEnte(ente);
return(AgregarEnte(ente));
}
/// <summary>
/// Ente preparado para usarse
/// </summary>
/// <returns><c>true</c>, if preparado was ented, <c>false</c> otherwise.</returns>
/// <param name="ente">Ente.</param>
public bool EntePreparado(Ente ente)
{
return(ente.AtaquesRestantesEnTurno > 0);
}
public void EliminarEnteMesa(Ente ente)
{
mesa.EntesEnTablero.Remove(ente);
}
public void PlaceCreatureAt(int index, Ente ente)
{
EntesEnTablero.Insert(index, ente);
}
public static int RemoverEnte(Ente ente)
{
return(RepositorioEntes.RemoveAll(item => item.Nombre == ente.Nombre));
}
public Ente AgregarActividadAEnte(Ente ente, Actividad actividad)
{
return(Repositorios.AgregarActividadAEnte(actividad, ente));
}
/// <summary>
/// Mira si el ente es mágico.
/// </summary>
/// <returns><c>true</c>, if magica was esed, <c>false</c> otherwise.</returns>
/// <param name="idEnte">Identifier ente.</param>
public bool EsMagica(int idEnte)
{
Ente ente = Recursos.EntesCreadosEnElJuego[idEnte];
return(ente.GetType() == typeof(Magica));
}