public ActionResult DatosTurno(int id)
{
List <Prestacion> listaP = AccesoDatos.AccesoDatos.listaPresentacion();
//cargar los items del combo
List <SelectListItem> ItemsCombo = listaP.ConvertAll(d =>
{
return(new SelectListItem()
{
Text = d.descripcion,
Value = d.id.ToString(),
Selected = false
});
});
turno resultado = AccesoDatos.AccesoDatos.obtenerT(id);
foreach (var item in ItemsCombo)
{
if (item.Value.Equals(resultado.presta.ToString()))
{
item.Selected = true;
break;
}
}
ViewBag.items = ItemsCombo;
ViewBag.nombre = resultado.nombre;
return(View(resultado));
}
public Empleado(int idEmpleado, string nombre, turno turno, puesto puesto)
{
this.idEmpleado = idEmpleado;
this.nombre = nombre;
this.turnoEmpleado = turno;
this.puestoEmpleado = puesto;
}
public ActionResult Eliminar(int id)
{
//List<Prestacion> listaP = AccesoDatos.AccesoDatos.listaPresentacion();
////cargar los items del combo
//List<SelectListItem> ItemsCombo = listaP.ConvertAll(d =>
//{
// return new SelectListItem()
// {
// Text = d.descripcion,
// Value = d.id.ToString(),
// Selected = false
// };
//});
turno resultado = AccesoDatos.AccesoDatos.obtenerT(id);
//foreach (var item in ItemsCombo)
//{
// if (item.Value.Equals(resultado.presta.ToString()))
// {
// item.Selected = true;
// break;
// }
//}
//ViewBag.items = ItemsCombo;
ViewBag.nombre = resultado.nombre;
return(View(resultado));
}
public static List <turno> listaParamostrar()
{
List <turno> resultado = new List <turno>();
string CadenaC = System.Configuration.ConfigurationManager.AppSettings["CadenaConexion"].ToString();
//creamos una cadena de conexion hacia la base de datos
SqlConnection cn = new SqlConnection(CadenaC);
try
{
//creamos un comando
SqlCommand cmd = new SqlCommand();
string consulta = @"select t.nombreP, t.edad, t.fecha , p.descripcion, id_turno
from turnos t join Prestaciones p on t.id_prestacion = p.idPrestacion ";
cmd.Parameters.Clear(); //le limpiamos los parametros
//se va a ejecutar una accion por usuario por eso es .text como una sentencia sql
cmd.CommandType = System.Data.CommandType.Text;
//le pasa cual seria la consulta que en este caso es el insert
cmd.CommandText = consulta;
//se abra la conexion
cn.Open();
//que el comando tome la conexion con la base de datos
cmd.Connection = cn;
//los parametros debe ser correctos
SqlDataReader dr = cmd.ExecuteReader();
if (dr != null)
{
while (dr.Read())
{
turno t = new turno();
t.nombre = dr["nombreP"].ToString();
t.edad = int.Parse(dr["edad"].ToString());
t.fecha = DateTime.Parse(dr["fecha"].ToString());
t.Descripcion = dr["descripcion"].ToString();
t.id = int.Parse(dr["id_turno"].ToString());
resultado.Add(t);
}
}
}
catch (Exception)
{
throw;
}
finally
{
cn.Close();
}
return(resultado);
}
public void IniciarCambiDeTurno()
{
GameManager.ActualizarVida();
turnoAnterior = TurnoActual;
TurnoActual = turno.cambioDeTurno;
GameManager.ActivarDesactivarBotones();
Invoke("CambioDeTurno", 3.7f);
}
public ActionResult DeleteConfirmed(int id)
{
turno turno = db.turnoes.Find(id);
db.turnoes.Remove(turno);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "id_turno,tipo_turno")] turno turno)
{
if (ModelState.IsValid)
{
db.Entry(turno).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(turno));
}
public ActionResult Create([Bind(Include = "id_turno,tipo_turno")] turno turno)
{
if (ModelState.IsValid)
{
db.turno.Add(turno);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(turno));
}
public ActionResult Create([Bind(Include = "id_turno,nombre_turno,Hora_entrada,Hora_salida")] turno turno)
{
if (ModelState.IsValid)
{
db.turno.Add(turno);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(turno));
}
public ActionResult Edit([Bind(Include = "idPaciente,idProfesional,fecha,idTurno")] turno turno)
{
if (ModelState.IsValid)
{
db.Entry(turno).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.idPaciente = new SelectList(db.pacientes, "idPaciente", "nombre", turno.idPaciente);
ViewBag.idPaciente = new SelectList(db.profesionals, "idProfesional", "nombre", turno.idPaciente);
return(View(turno));
}
public static turno obtenerT(int id)
{
turno resultado = new turno();
string cadenaConexion = System.Configuration.ConfigurationManager.AppSettings["CadenaConexion"].ToString();
//creamos una cadena de conexion hacia la base de datos
SqlConnection cn = new SqlConnection(cadenaConexion);
try
{
//creamos un comando
SqlCommand cmd = new SqlCommand();
string consulta = "SELECT * FROM turnos WHERE id_turno = @id_turno";
cmd.Parameters.Clear(); //le limpiamos los parametros
cmd.Parameters.AddWithValue("@id_turno", id);
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = consulta;
//se abra la conexion
cn.Open();
//que el comando tome la conexion con la base de datos
cmd.Connection = cn;
//los parametros debe ser correctos
SqlDataReader dr = cmd.ExecuteReader();
if (dr != null)
{
while (dr.Read())
{
resultado.id = int.Parse(dr["id_turno"].ToString());
resultado.nombre = dr["nombreP"].ToString();
resultado.edad = int.Parse(dr["edad"].ToString());
resultado.fecha = DateTime.Parse(dr["fecha"].ToString());
resultado.presta = int.Parse(dr["id_prestacion"].ToString());
}
}
}
catch (Exception)
{
throw;
}
finally
{
cn.Close();
}
return(resultado);
}
public ActionResult Create([Bind(Include = "idPaciente,idProfesional,fecha")] turno turno)
{
if (ModelState.IsValid)
{
db.turnoes.Add(turno);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Pacientes = new SelectList(db.pacientes, "idPaciente", "nombre", turno.idPaciente).AsEnumerable <SelectListItem>();
ViewBag.Profesionales = new SelectList(db.profesionals, "idProfesional", "nombre", turno.idProfesional).AsEnumerable <SelectListItem>();
return(View(turno));
}
public static bool InsertarNuevoPedido(turno t)
{
bool resultado = false;
string CadenaC = System.Configuration.ConfigurationManager.AppSettings["CadenaConexion"].ToString();
//creamos una cadena de conexion hacia la base de datos
SqlConnection cn = new SqlConnection(CadenaC);
try
{
//creamos un comando
SqlCommand cmd = new SqlCommand();
string consulta = "INSERT INTO turnos VALUES(@nombreP, @edad, @fecha, @id_prestacion)";
cmd.Parameters.Clear(); //le limpiamos los parametros
cmd.Parameters.AddWithValue("@nombreP", t.nombre); //Le agregamos nuevos parametros
cmd.Parameters.AddWithValue("@edad", t.edad);
cmd.Parameters.AddWithValue("@fecha", t.fecha);
cmd.Parameters.AddWithValue(@"id_prestacion", t.presta);
//se va a ejecutar una accion por usuario por eso es .text como una sentencia sql
cmd.CommandType = System.Data.CommandType.Text;
//le pasa cual seria la consulta que en este caso es el insert
cmd.CommandText = consulta;
//se abra la conexion
cn.Open();
//que el comando tome la conexion con la base de datos
cmd.Connection = cn;
//los parametros debe ser correctos
cmd.ExecuteNonQuery();
resultado = true;
}
catch (Exception)
{
throw;
}
finally
{
cn.Close();
}
return(resultado);
}
// GET: turnoes/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
turno turno = db.turnoes.Find(id);
if (turno == null)
{
return(HttpNotFound());
}
return(View(turno));
}
// GET: turnoes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
turno turno = db.turnoes.Find(id);
if (turno == null)
{
return(HttpNotFound());
}
ViewBag.idPaciente = new SelectList(db.pacientes, "idPaciente", "nombre", turno.idPaciente);
ViewBag.idPaciente = new SelectList(db.profesionals, "idProfesional", "nombre", turno.idPaciente);
return(View(turno));
}
// Update is called once per frame
void Update()
{
contador++;
if (finDelJuego)
{
mensaje("FIN DEL JUEGO");
}
if (eJuego == estadoJuego.simula && contador % 20 == 0 && !finDelJuego)
{
if (turn == turno.turnoZombie)
{
turnoZombie();
turn = turno.lucha1;
}
else if (turn == turno.lucha1)
{
lucha();
actualizaZombisSoldados();
turn = turno.turnoHeroe;
}
else if (turn == turno.turnoHeroe)
{
turnoHeroe();
turn = turno.lucha2;
}
else if (turn == turno.lucha2)
{
lucha();
actualizaZombisSoldados();
turn = turno.turnoZombie;
}
if (nZombies == 0)
{
heroeEstado = estadoHeroe.huir;
}
mensaje("nZombies: " + nZombies + " nSoldados: " + nSoldados);
Resultado.text = ("Resultado: " + puntuacion);
contador = 0;
}
if (Input.GetKey("escape"))
{
Application.Quit();
}
}
public static bool EliminarTurnos(turno t)
{
bool resultado = false;
string cadenaConexion = System.Configuration.ConfigurationManager.AppSettings["CadenaConexion"].ToString();
//creamos una cadena de conexion hacia la base de datos
SqlConnection cn = new SqlConnection(cadenaConexion);
try
{
//creamos un comando
SqlCommand cmd = new SqlCommand();
string consulta = "DELETE FROM turnos WHERE id_turno = @id_turno";
cmd.Parameters.Clear(); //le limpiamos los parametros
cmd.Parameters.AddWithValue(@"id_turno", t.id);
//se va a ejecutar una accion por usuario por eso es .text como una sentencia sql
cmd.CommandType = System.Data.CommandType.Text;
//le pasa cual seria la consulta que en este caso es el insert
cmd.CommandText = consulta;
//se abra la conexion
cn.Open();
//que el comando tome la conexion con la base de datos
cmd.Connection = cn;
//los parametros debe ser correctos
cmd.ExecuteNonQuery();
resultado = true;
}
catch (Exception)
{
throw;
}
finally
{
cn.Close();
}
return(resultado);
}
public ActionResult DatosTurno(turno model)
{
if (ModelState.IsValid)
{
bool resultado = AccesoDatos.AccesoDatos.ActualizarDatosPersonales(model);
if (resultado)
{
return(RedirectToAction("Listado", "Clinica"));
}
else
{
return(View(model));
}
}
else
{
return(View());
}
}
public ActionResult Eliminar(turno model)
{
if (ModelState.IsValid)
{
bool resultado = AccesoDatos.AccesoDatos.EliminarTurnos(model);
if (resultado)
{
return(RedirectToAction("Listado", "Clinica"));
}
else
{
return(View(model));
}
}
return(View());
}
private void UseSkill(turno turnode, Player atacante, int skillSlot, Player objetivo)
{
if (TurnoActual != turnode)
{
return;
}
if (atacante.CrittersOwned[0].Moveset1[skillSlot] is AtackSkill)
{
atacante.Attack(objetivo.CrittersOwned[0], skillSlot, 0);
}
if (atacante.CrittersOwned[0].Moveset1[skillSlot] is SuppSkill)
{
ultimaSuppSkillUtilizada = atacante.Buff(atacante.CrittersOwned[0], skillSlot);
GameManager.MostrarSuppSkill();
}
IniciarCambiDeTurno();
Debug.Log(atacante.gameObject + " Uso! " + atacante.CrittersOwned[0].Moveset1[skillSlot].name);
}
public ActionResult Altaturno(turno modelo)
{
if (ModelState.IsValid)
{
bool resultado = AccesoDatos.AccesoDatos.InsertarNuevoPedido(modelo);
if (resultado)
{
return(RedirectToAction("Listado", "Clinica"));
}
else
{
return(View(modelo));
}
}
return(View(modelo));
}
private void CambioDeTurno()
{
switch (turnoAnterior)
{
case turno.jugador:
TurnoActual = turno.ia;
break;
case turno.ia:
TurnoActual = turno.jugador;
break;
case turno.cambioDeTurno:
break;
default:
Debug.LogError(nameof(turnoAnterior) + " " + turnoAnterior);
break;
}
GameManager.ActivarDesactivarBotones();
}
void Start()
{
LevelManagerObject = FindObjectOfType <SceneControl>();
atributosPlayer = Player.GetComponent <CombateAtributos>();
atributosAdversario = Adversario.GetComponent <CombateAtributos>();
gerenteFase = Adversario.GetComponent <ModificadorAtributos>();
//A: inicializa alinhamento no centro
alinhamentoPlayer = alinhamento.diplomatico;
efetividade.text = "";
//A: aloca numero maximo de argumentos igual a numero de quadros de exibicao
argumentosPlayer = new CombateArgumento[quadroArgumentoPlayer.Length];
argumentosAdversario = new CombateArgumento[quadroArgumentoAdversario.Length];
vidaArgumentosPlayer = new int[quadroArgumentoPlayer.Length];
vidaArgumentosAdversario = new int[quadroArgumentoAdversario.Length];
turnoArgumentosPlayer = new int[quadroArgumentoPlayer.Length];
turnoArgumentosAdversario = new int[quadroArgumentoAdversario.Length];
for (int i = 0; i < argumentosPlayer.Length; i++)
{
argumentosPlayer[i] = null;
vidaArgumentosPlayer[i] = 0;
turnoArgumentosPlayer[i] = 9999;
}
for (int i = 0; i < argumentosAdversario.Length; i++)
{
argumentosAdversario[i] = null;
vidaArgumentosAdversario[i] = 0;
turnoArgumentosAdversario[i] = 9999;
}
atributosPlayer.Shuffle();
//A: Cada ação do jogador substitui o nome escrito em um dos botoes.
for (int i = 0; i < nomeAcoes.Length; i++)
{
//escolhe nome aleatorio entre os descritos no array
nomeAcoes[i].text = atributosPlayer.getAcao(i).nome[0];
//nomeAcoes[i].GetComponent<TooltipObserver>().associaAcao(atributosPlayer.getAcao(i));
//A: Antigo
//nomeAcoes[i].text = atributosPlayer.getAcao(i).nome[Random.Range(0,atributosPlayer.getAcao(i).nome.Length)];
//nomeAcoes[i].GetComponent<TooltipObserver>().associaAcao(atributosPlayer.getAcao(i));
}
VidaPlayer.maxValue = atributosPlayer.atributos.vida;
VidaAdversario.maxValue = atributosAdversario.atributos.vida;
vidaPlayerTexto.text = "" + VidaPlayer;
vidaAdversarioTexto.text = "" + VidaAdversario;
//A: Decide de quem sera o primeiro turno
if (atributosAdversario.getAtributos().iniciativa > atributosPlayer.getAtributos().iniciativa)
{
turnoAtual = turno.adversario;
vezDoOutro.SetActive(true);
turnoAdversario();
}
else
{
turnoAtual = turno.jogador;
vezDoOutro.SetActive(false);
}
//A: garante que nenhuma seta aparece inicialmente no alinhamento
IdxAlinhaAgressivo.SetActive(false);
IdxAlinhaDiplomatico.SetActive(false);
IdxAlinhaDireita.SetActive(false);
IdxAlinhaEsquerda.SetActive(false);
IdxAlinhaManipulador.SetActive(false);
IdxAlinhaDirRev.SetActive(false);
IdxAlinhaEsqRev.SetActive(false);
}
//A: gerencia variaveis relacionadas a passagem de turno
IEnumerator passaTurno()
{
yield return(new WaitForSeconds(entreTurnos / 2));
//A: gerencia criacao de argumentos de ambos (pois existem posturas com retorno de dano, etc)
if (atributosAdversario.getArgumentos() >= atributosAdversario.atributos.barraArgumento)
{
atributosAdversario.setArgumentos(0);
criaArgumento(atributosAdversario);
//A: codigo para criar argumento para adversario vai aqui;
}
if (atributosPlayer.getArgumentos() >= atributosPlayer.atributos.barraArgumento)
{
atributosPlayer.setArgumentos(0);
criaArgumento(atributosPlayer);
//A: codigo para criar argumento para jogador vai aqui;
}
//A: ajusta indices do alinhamento
IdxAlinhaAgressivo.SetActive(false);
IdxAlinhaDiplomatico.SetActive(false);
IdxAlinhaDireita.SetActive(false);
IdxAlinhaEsquerda.SetActive(false);
IdxAlinhaManipulador.SetActive(false);
IdxAlinhaDirRev.SetActive(false);
IdxAlinhaEsqRev.SetActive(false);
//A: esconde fala e exibe resposta
if (turnoAtual == turno.adversario)
{
falasAdversario.SetActive(false);
if (resposta != "")
{
falasPlayer.transform.GetChild(1).GetComponent <Text>().text = resposta;
falasPlayer.SetActive(true);
}
}
else
{
falasPlayer.SetActive(false);
if (resposta != "")
{
falasAdversario.transform.GetChild(1).GetComponent <Text>().text = resposta;
falasAdversario.SetActive(true);
}
}
yield return(new WaitForSeconds(entreTurnos / 2));
falasAdversario.SetActive(false);
falasPlayer.SetActive(false);
for (int i = 0; i < argumentosPlayer.Length; i++)
{
if (argumentosPlayer[i] != null)
{
turnoArgumentosPlayer[i]++;
if (vidaArgumentosPlayer[i] <= 0 || turnoArgumentosPlayer[i] / 2 >= argumentosPlayer[i].duracao)
{
argumentosPlayer[i] = null;
quadroArgumentoPlayer[i].GetComponent <QuadroDeArgumento>().LimpaArgumento();
numArgumentosPlayer--;
}
else
{
if (argumentosPlayer[i].habilidade == CombateArgumento.tipoArgumento.Regenerar && turnoAtual == turno.jogador)
{
atributosPlayer.curar((int)argumentosPlayer[i].valor);
}
}
}
}
for (int i = 0; i < argumentosAdversario.Length; i++)
{
if (argumentosAdversario[i] != null)
{
turnoArgumentosAdversario[i]++;
if (vidaArgumentosAdversario[i] <= 0 || turnoArgumentosAdversario[i] / 2 >= argumentosAdversario[i].duracao)
{
argumentosAdversario[i] = null;
quadroArgumentoAdversario[i].GetComponent <QuadroDeArgumento>().LimpaArgumento();
numArgumentosAdversario--;
}
else
{
if (argumentosAdversario[i].habilidade == CombateArgumento.tipoArgumento.Regenerar && turnoAtual == turno.adversario)
{
atributosAdversario.curar((int)argumentosAdversario[i].valor);
}
}
}
}
yield return(new WaitForSeconds(entreTurnos / 7));
resposta = "";
//A: Verifica se combate acabou
efetividade.text = "";
if (atributosPlayer.getVidaAtual() == 0)
{
LevelManagerObject.derrota = true;
endBattle(LevelManagerObject.derrota);
}
else if (atributosAdversario.getVidaAtual() == 0)
{
LevelManagerObject.derrota = false;
endBattle(LevelManagerObject.derrota);
}
//A: Se nao acabou, passa vez
else
{
if (turnoAtual == turno.adversario)
{
turnoAtual = turno.jogador;
atributosPlayer.Shuffle();
for (int i = 0; i < nomeAcoes.Length; i++)
{
//escolhe nome aleatorio entre os descritos no array
nomeAcoes[i].text = atributosPlayer.getAcao(i).nome[0];
//nomeAcoes[i].GetComponent<TooltipObserver>().associaAcao(atributosPlayer.getAcao(i));
}
vezDoOutro.SetActive(false);
}
else
{
turnoAtual = turno.adversario;
turnoAdversario();
}
}
}
