public ActionResult Adiciona(Comodo comodo)
{
ComodoDAO dao = new ComodoDAO();
dao.Adiciona(comodo);
return(RedirectToAction("Index"));
}
public ActionResult Cadastrar(Comodo model)
{
try {
if (model == null)
{
throw new Exception("Preencha o nome do cômodo");
}
if (model.Nome == null)
{
throw new Exception("Preencha o nome do cômodo");
}
using (var service = new Service <Comodo>())
{
var userId = Convert.ToInt32(Session["UserId"]);
model.UsuarioId = userId;
service.Save(model);
}
TempData["Sucesso"] = true;
TempData["Mensagem"] = "Comodo " + model.Nome + " cadastrado com sucesso";
}
catch (Exception exception) {
TempData["Erro"] = true;
TempData["Mensagem"] = exception.Message;
}
var view = RedirectToAction("Index");
view.ExecuteResult(ControllerContext);
return(null);
}
public void atualizarComodo()
{
if (atualizando)
{
return;
}
atualizando = true;
var comodo = new Comodo();
var controller = new ComodoController();
var index = gridComodos.CurrentCell.RowIndex;
var id = gridComodos.Rows[index].Cells["ID"].Value.ToString();
var nome = gridComodos.Rows[index].Cells["Nome"].Value.ToString();
var largura = gridComodos.Rows[index].Cells["Largura"].Value.ToString();
var comprimento = gridComodos.Rows[index].Cells["Comprimento"].Value.ToString();
int aux;
if (!int.TryParse(id, out aux))
{
return;
}
comodo.Id = int.Parse(id);
if (comodo.ValidarCampos(nome, largura, comprimento))
{
controller.AtualizarComodo(comodo);
}
else
{
CarregarGrids();
}
atualizando = false;
}
public void Excluir(int id)
{
AndromedaContext ctx = new AndromedaContext();
Comodo com = ctx.Comodo.Find(id);
ctx.Entry(com).State = System.Data.Entity.EntityState.Deleted;
ctx.SaveChanges();
}
//[HttpPost]
//[ValidateAntiForgeryToken]
public ActionResult Recuperar(int id)
{
Comodo comodo = db.Comodos.Find(id);
comodo.Ativo = true;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult DeleteConfirmed(int id)
{
Comodo comodo = db.Comodos.Find(id);
comodo.Ativo = false;
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Index([Bind("Largura,Altura,Profundidade")] Comodo comodo)
{
Double quantidadeEmlitros = 0;
quantidadeEmlitros = calculadora.calcularLitragem(comodo);
return(RedirectToRoute(new { Controller = "CalculadoraPintura", Action = "QuantidadeLitros", litros = quantidadeEmlitros }));
}
public void Adiciona(Comodo comodos)
{
using (var context = new BaseContext())
{
context.Comodos.Add(comodos);
context.SaveChanges();
}
}
private void CadastrarItem_Click(object sender, EventArgs e)
{
var comodo = new Comodo();
var comodoController = new ComodoController();
comodo.ValidarCampos(txtNome.Text, numLargura.Text, numComprimento.Text);
comodoController.CadastrarComodo(comodo);
this.Close();
}
void AlterarLuzApagada(bool luzApagada, MeshRenderer luzComodoAtual = null)
{
if (!luzComodoAtual)
{
luzComodoAtual = personagem.luzComodoAtual;
}
Comodo comodo = luzComodoAtual.transform.parent.GetComponent <Comodo>();
comodo.luzApagada = luzApagada;
comodo.AlterarLuz(luzApagada);
}
public ActionResult Edit(Comodo comodo)
{
if (ModelState.IsValid)
{
db.Entry(comodo).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(comodo));
}
bool CalcularSairComodo(GameObject comodo)
{
Comodo comodoScript = comodo.GetComponent <Comodo>();
float quantidadeNpcsComodo = comodoScript.npcsComodo.Count;
if (comodoScript.limiteNpcs && quantidadeNpcsComodo > 0)
{
float chanceComodo = Random.Range(1, 100);
float chanceNpcAdicionalComodo = Mathf.Max(1, jogo.chanceNpcAdicionalComodo - (quantidadeNpcsComodo * 2));
if (chanceComodo > chanceNpcAdicionalComodo)
{
return(false);
}
}
return(true);
}
public ActionResult Edit(int?id)
{
if (id.HasValue != true)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Comodo comodo = db.Comodos.Find(id);
if (comodo == null)
{
return(HttpNotFound());
}
return(View(comodo));
}
public ActionResult Create(Comodo comodo)
{
if (ModelState.IsValid)
{
if (Validacao(comodo) == null)
{
comodo.Ativo = true;
db.Comodos.Add(comodo);
db.SaveChanges();
RedirectToAction("Index");
return(View(comodo));
}
else
{
ViewBag.Erro = "Já existem um comodo com esse nome";
}
}
return(View());
}
public void CadastrarComodo(Comodo Comodo)
{
var dbContext = new DbContext();
try
{
var query = new StringBuilder();
query.AppendLine($"INSERT INTO COMODOS ");
query.AppendLine($"(NOME ,LARGURA ,COMPRIMENTO, DATACRIACAO)");
query.AppendLine($"VALUES");
query.AppendLine($"('{Comodo.Nome}', '{Comodo.Largura}', '{Comodo.Comprimento}', '{DateTime.Now:s}')");
dbContext.ExecuteQuery(query.ToString());
}
catch
{
throw;
}
}
public void AtualizarComodo(Comodo Comodo)
{
var dbContext = new DbContext();
try
{
var query = new StringBuilder();
query.AppendLine($"UPDATE COMODOS SET ");
query.AppendLine($"NOME = '{Comodo.Nome}',");
query.AppendLine($"LARGURA = '{Comodo.Largura}',");
query.AppendLine($"COMPRIMENTO = '{Comodo.Comprimento}'");
query.AppendLine($"WHERE ID = {Comodo.Id}");
dbContext.ExecuteQuery(query.ToString());
}
catch
{
throw;
}
}
void MoverParaWaypoint(bool variarPosicao = true, bool ignorarAlteracoes = false, GameObject objetoDirecao = null)
{
AdicionarDebugInfo("MoverParaWaypoint: " + waypointAtual.name);
Waypoint waypointScript = waypointAtual.GetComponent <Waypoint>();
GameObject comodoWaypoint = waypointScript.comodo;
Comodo comodo = comodoWaypoint.GetComponent <Comodo>();
npc.DefinirComodoAtual(comodoWaypoint);
/*if (modificadorTensaoLiberado && waypointAnterior != waypointAtual && personagem.comodoAtual)
* {
* if (comodo.luzApagada)
* AumentarTensao("Luz - " + personagem.comodoAtual.name);
* else
* ReduzirTensao("Luz - " + personagem.comodoAtual.name);
* }*/
Vector3 posicao = waypointAtual.transform.position;
if (variarPosicao)
{
posicao = VariarPosicao();
}
AtualizarDirecao(posicao);
AtualizarAnimacao("movimento", true);
duracaoMovimento = Vector3.Distance(transform.parent.position, posicao) / (chamarExorcista ? 1.5f : 1f);
iTween.MoveTo(transform.parent.gameObject, iTween.Hash("position", posicao, "easeType", iTween.EaseType.linear, "time", duracaoMovimento));
StartCoroutine(AlterarEmMovimento());
if (objetoDirecao)
{
StartCoroutine(AtualizarDirecaoObjeto(objetoDirecao));
}
}
public Comodo ObterComodo(int id)
{
Comodo retorno = null;
var dbContext = new DbContext();
try
{
var query = $"SELECT * FROM COMODOS WHERE ID = {id}";
var dt = dbContext.ExecuteSelect(query);
var lista = TransformarDataTable(dt);
retorno = lista.FirstOrDefault();
}
catch
{
throw;
}
return(retorno);
}
public ActionResult ComodosSave(Comodo comodo)
{
try
{
using (var service = new Service <Comodo>())
{
service.Save(comodo);
TempData["Sucesso"] = true;
TempData["Mensagem"] = "Cadastrado com sucesso.";
}
}
catch (Exception ex)
{
TempData["Erro"] = true;
TempData["Mensagem"] = "Não foi possível cadastrar. Erro: " + ex.Message;
}
var view = RedirectToAction("Aparelhos");
view.ExecuteResult(ControllerContext);
return(null);
}
void Movimentar()
{
if ((tipoReacao == "objeto" && emMovimento) ||
(tipoReacao == "movimento" && !emMovimento) ||
(tipoReacao == "tensao") && tensaoAtual == 0)
{
DesativarBalaoReacao();
}
if (caminho.Count() > 0 && !emMovimento)
{
if (movimentoLiberado)
{
waypointAnterior = waypointAtual;
waypointAtual = caminho[0];
AdicionarDebugInfo("Processando caminho: " + waypointAnterior.name + " para " + waypointAtual.name);
caminho.RemoveAt(0);
MoverParaWaypoint(caminho.Count() == 0 ? true : false, true, caminho.Count() == 0 ? waypointAtual.transform.parent.gameObject : null);
if (saindo && caminho.Count == 0)
{
AdicionarDebugInfo("NpcSaiu chamado em (saindo && caminho.Count == 0)");
StartCoroutine(NpcSaiu());
return;
}
else if (chamarExorcista && caminho.Count == 0)
{
bool checarChamarExorcista = true;
GameObject[] npcs = GameObject.FindGameObjectsWithTag("NPC");
foreach (GameObject npc in npcs)
{
if (npc != gameObject)
{
NPC npcScript = npc.GetComponent <NPC>();
if (npcScript.chamarExorcista)
{
checarChamarExorcista = false;
break;
}
}
}
if (checarChamarExorcista)
{
StartCoroutine(PrepararExorcista());
}
else
{
chamarExorcista = false;
}
AdicionarDebugInfo("NpcSaiu chamado em (saindo && caminho.Count == 0)");
StartCoroutine(NpcSaiu());
}
}
else
{
movimentoLiberado = true;
}
return;
}
if (movimentar)
{
if (movimentoLiberado)
{
float chance = Random.Range(1, 100);
if (chamadoComodo)
{
chance = chanceSairComodo;
}
if (chance <= chanceSairJogo && waypointAtual != jogo.waypointInicial)
{
caminho = Waypoint.DefinirCaminho(waypointAtual, jogo.waypointInicial, true);
saindo = true;
}
else if (chance <= chanceSairComodo)
{
GameObject comodoSelecionado = null;
if (chamadoComodo)
{
comodoSelecionado = chamadoComodo;
chamadoComodo = null;
}
else
{
List <GameObject> comodos = Comodo.PegarComodos();
Dictionary <GameObject, float> comodosDistancia = new Dictionary <GameObject, float>();
foreach (GameObject comodo in comodos)
{
if (comodo != npc.comodoAtual && !comodo.GetComponent <Comodo>().luzApagada)
{
comodosDistancia.Add(comodo, Vector3.Distance(transform.position, comodo.transform.position));
}
}
if (comodosDistancia.Count > 0)
{
var comodosDistanciaOrdenados = from pair in comodosDistancia
orderby pair.Value ascending
select pair;
var comodosProximos = comodosDistanciaOrdenados.ToList();
int maxComodos = Mathf.Min(2, comodosProximos.Count());
List <GameObject> comodosVisitar = new List <GameObject>();
for (int i = 0; i < maxComodos; i++)
{
comodosVisitar.Add(comodosProximos.First().Key);
comodosProximos.RemoveAt(0);
}
comodoSelecionado = comodosVisitar.PickRandom();
}
}
if (comodoSelecionado)
{
if (!CalcularSairComodo(comodoSelecionado))
{
return;
}
List <GameObject> waypoints = Waypoint.PegarWaypoints(comodoSelecionado, true);
Dictionary <GameObject, float> waypointsDistancia = new Dictionary <GameObject, float>();
foreach (GameObject waypoint in waypoints)
{
waypointsDistancia.Add(waypoint, Vector3.Distance(transform.position, waypoint.transform.position));
}
var waypointsDistanciaOrdenados = from pair in waypointsDistancia
orderby pair.Value ascending
select pair;
var waypointsProximos = waypointsDistanciaOrdenados.ToList();
int maxWaypoints = Mathf.Min(3, waypointsProximos.Count());
List <GameObject> waypointsSelecionados = new List <GameObject>();
for (int i = 0; i < maxWaypoints; i++)
{
waypointsSelecionados.Add(waypointsProximos.First().Key);
waypointsProximos.RemoveAt(0);
}
if (waypointsSelecionados.Count() > 0)
{
GameObject waypointSelecionado = waypointsSelecionados.PickRandom();
caminho = Waypoint.DefinirCaminho(waypointAtual, waypointSelecionado, true);
}
}
}
else if (chance <= chanceObjetoAtrair)
{
Comodo comodo = waypointAtual.GetComponent <Waypoint>().comodo.GetComponent <Comodo>();
List <GameObject> objetosComodo = comodo.objetosComodo;
Dictionary <GameObject, float> objetosDistancia = new Dictionary <GameObject, float>();
foreach (GameObject objeto in objetosComodo)
{
if (!objetosVisitados.Contains(objeto))
{
objetosDistancia.Add(objeto, Vector3.Distance(objeto.transform.position, waypointAtual.transform.position));
}
}
if (objetosDistancia.Count() > 0)
{
var objetosDistanciaOrdenados = from pair in objetosDistancia
orderby pair.Value ascending
select pair;
var objetosProximos = objetosDistanciaOrdenados.ToList();
int maxObjetos = Mathf.Min(3, objetosProximos.Count());
List <GameObject> objetosVisitar = new List <GameObject>();
for (int i = 0; i < maxObjetos; i++)
{
objetosVisitar.Add(objetosProximos.First().Key);
objetosProximos.RemoveAt(0);
}
GameObject visitarObjeto = objetosVisitar.PickRandom(1).First();
objetosVisitados.Add(visitarObjeto);
GameObject waypointChildren = null;
foreach (Transform child in visitarObjeto.transform)
{
if (child.CompareTag("Waypoint"))
{
waypointChildren = child.gameObject;
break;
}
}
if (waypointChildren)
{
caminho = Waypoint.DefinirCaminho(waypointAtual, waypointChildren, true);
tipoReacao = "objeto";
interagindoObjeto = true;
reacaoLiberada = true;
}
}
else
{
//objetosVisitados = new List<GameObject>();
// Colocar uma chance de zerar os objetos visitados no cômodo
// Criar uma lista de objetos visitados dependendo do cômodo em questão
}
}
else if (chance <= chanceWaypointAleatorioComodo)
{
bool waypointDisponivel = false;
List <GameObject> waypointsDisponiveis = Waypoint.PegarWaypoints(npc.comodoAtual, true);
while (!waypointDisponivel && waypointsDisponiveis.Count > 0)
{
GameObject waypoint = waypointsDisponiveis.PickRandom();
if (!waypoint.GetComponent <Waypoint>().travarMovimento)
{
waypointDisponivel = true;
caminho = Waypoint.DefinirCaminho(waypointAtual, waypoint, true);
}
else
{
waypointsDisponiveis.Remove(waypoint);
}
}
}
else
{
AdicionarDebugInfo("Ir para waypoint adjacente.");
waypointAnterior = waypointAtual;
List <GameObject> waypointsDisponiveis = waypointAtual.GetComponent <Waypoint>().waypointsDisponiveis.ToList();
if (waypointsDisponiveis.Count == 0)
{
waypointsDisponiveis = Waypoint.PegarWaypoints(personagem.comodoAtual);
}
bool comodoDisponivel = false;
while (!comodoDisponivel && waypointsDisponiveis.Count > 0)
{
GameObject waypointSelecionado = waypointsDisponiveis[Random.Range(0, waypointsDisponiveis.Count)];
Waypoint waypointScript = waypointSelecionado.GetComponent <Waypoint>();
GameObject comodoWaypoint = waypointScript.comodo;
bool luzApagada = false;
if (comodoWaypoint)
{
luzApagada = comodoWaypoint.GetComponent <Comodo>().luzApagada;
}
bool checarNpcComodo = true;
if (comodoWaypoint != npc.comodoAtual)
{
AdicionarDebugInfo("Calcular para Sair do Cômodo");
checarNpcComodo = CalcularSairComodo(comodoWaypoint);
}
if (checarNpcComodo && !waypointScript.travarMovimento && (waypointScript.objeto || !luzApagada))
{
comodoDisponivel = true;
AdicionarDebugInfo("comodoDisponivel");
waypointAtual = waypointSelecionado;
break;
}
else
{
waypointsDisponiveis.Remove(waypointSelecionado);
}
AdicionarDebugInfo("waypointsDisponiveis.Count: " + waypointsDisponiveis.Count);
}
AdicionarDebugInfo("waypointAtual.name: " + waypointAtual.name + " - waypointAnterior.name: " + waypointAnterior.name);
MoverParaWaypoint();
}
}
else if (!emMovimento)
{
if (waypointAtual.GetComponent <Waypoint>().movimentoAutomatico)
{
List <GameObject> waypointsDisponiveis = waypointAtual.GetComponent <Waypoint>().waypointsDisponiveis;
foreach (GameObject waypoint in waypointsDisponiveis)
{
if (waypoint.name != waypointAnterior.name)
{
bool liberado = false;
GameObject checarWaypoint = waypoint;
while (!liberado)
{
Waypoint waypointScript = checarWaypoint.GetComponent <Waypoint>();
if (waypointScript.movimentoAutomatico)
{
foreach (GameObject wp in waypointScript.waypointsDisponiveis)
{
if (wp.name != checarWaypoint.name)
{
checarWaypoint = wp;
}
}
}
else
{
if (CalcularSairComodo(waypointScript.comodo))
{
liberado = true;
}
break;
}
}
if (liberado)
{
waypointAnterior = waypointAtual;
waypointAtual = waypoint;
MoverParaWaypoint();
break;
}
}
}
}
else if (!liberacaoIniciada)
{
StartCoroutine(LiberacaoMovimento());
}
else if (interagindoObjeto)
{
StartCoroutine(AtualizarAnimacao("foto", true, 2f));
interagindoObjeto = false;
}
}
}
else if (objetoInteracao && atualizarDirecaoAposMovimento && !emMovimento)
{
AtualizarDirecao(objetoInteracao.transform.position);
atualizarDirecaoAposMovimento = false;
}
}
public Comodo Validacao(Comodo comodo)
{
return(db.Comodos.FirstOrDefault(x => x.NomeComodo.Equals(comodo.NomeComodo)));
}
