public frmGerirDificuldades()
{
InitializeComponent();
_dificuldadeActiva = new Dificuldade();
RefrescarDataViewGrid();
btnAtualizar.Enabled = false;
}
public async Task <IActionResult> Edit(int id, [Bind("DificuldadeId,NomeDificuldade,Observacoes")] Dificuldade dificuldade)
{
if (id != dificuldade.DificuldadeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(dificuldade);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DificuldadeExists(dificuldade.DificuldadeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(dificuldade));
}
/// <summary>
/// Prepara o jogo funcionalmente consoante com a dificuldade escolhida
/// </summary>
public void SetupModel(Dificuldade dificuldade)
{
Program.M_Grelha.Tamanho = classDificuldade.GetTamanho(dificuldade);
SetAmountOfMines();
LoadTileGrid();
LoadAdjacentsMines();
}
public void ShowTop10AccordingtoDifficulty(Dificuldade dificuldade)
{
int i, rank = 0;
UCLeaderBoard.ListViewTop10.Items.Clear();
List <Top10Resultado> listaTop10 = Program.M_Status.top10Resultados;
for (i = 0; i < listaTop10.Count; i++)
{
if (dificuldade.ToString() != listaTop10[i].dificuldade)
{
continue;
}
ListViewItem item = new ListViewItem();
item.Text = ((rank + 1).ToString());
item.SubItems.Add(listaTop10[i].Nome);
item.SubItems.Add(listaTop10[i].Tempo);
item.SubItems.Add(listaTop10[i].Quando);
item.SubItems.Add(listaTop10[i].dificuldade);
rank++;
//row[i] = { (i + 1).ToString(), listaTop10[i].Nome, listaTop10[i].Tempo, listaTop10[i].Quando, listaTop10[i].dificuldade };
//var listViewItem = new ListViewItem(row);
UCLeaderBoard.ListViewTop10.Items.Add(item);
}
}
public static Size GetTamanho(Dificuldade _dificuldade)
{
Size _tamanho = new Size();
switch (_dificuldade)
{
case Dificuldade.Facil:
_tamanho.Width = _tamanho.Height = 9;
break;
case Dificuldade.Medio:
_tamanho.Width = _tamanho.Height = 16;
break;
case Dificuldade.Dificil:
_tamanho.Width = 30;
_tamanho.Height = 16;
break;
default:
throw new ArgumentException("Dificuldade não implementada");
}
return(_tamanho);
}
/// <summary>
/// Altera as definições do jogo consoante a decisão de escolha pelo utilizador na dificuldade
/// </summary>
/// <param name="dificuldade">Dificuldade do jogo escolhida pelo utilizador</param>
public void V_GameMode_ChangeDifficulty(Dificuldade dificuldade)
{
Program.M_Grelha._Dificuldade = dificuldade;
SetupModel();
V_MineSweeperGame.AlteraDificuldadeNoView(Program.M_Grelha._Dificuldade);
V_MineSweeperGame.AtualizaNumeroMinasDisponiveis(M_Grelha.NumMinasTotal);
}
private static void PopulatedTrilhos(Trails4HealthDbContext dbContext)
{
Professor professor1 = dbContext.Professor.SingleOrDefault(p => p.NIF == "236512378");
Professor professor2 = dbContext.Professor.SingleOrDefault(p => p.NIF == "2541236987");
Dificuldade dificuldade1 = dbContext.Dificuldade.SingleOrDefault(d => d.NomeDificuldade == "Difícil");
Dificuldade dificuldade2 = dbContext.Dificuldade.SingleOrDefault(d => d.NomeDificuldade == "Médio");
Dificuldade dificuldade3 = dbContext.Dificuldade.SingleOrDefault(d => d.NomeDificuldade == "Fácil");
dbContext.Trilho.Add(new Trilho {
Nome_Trilho = "Poço do Inferno", Local_Inicio_Trilho = "Ribeira de Leandres", Local_Fim_Trilho = "Poço do Inferno", Distancia_Total = "2,5 km", Duracao_Media = "3h45min", Esta_Ativo = "Sim", Tempo_Gasto = "", ProfessorId = professor2.ProfessorId, DificuldadeId = dificuldade2.DificuldadeId
});
dbContext.Trilho.Add(new Trilho {
Nome_Trilho = "Torre", Local_Inicio_Trilho = "Vila de Manteigas", Local_Fim_Trilho = "Torre", Distancia_Total = "16 km", Duracao_Media = "14h30min", Esta_Ativo = "Sim", Tempo_Gasto = "", ProfessorId = professor2.ProfessorId, DificuldadeId = dificuldade1.DificuldadeId
});
dbContext.Trilho.Add(new Trilho {
Nome_Trilho = "Covão de Santa Maria", Local_Inicio_Trilho = "Pousada de São Lourenço", Local_Fim_Trilho = "Covão de Santa Maria", Distancia_Total = "4 km", Duracao_Media = "4h30min", Esta_Ativo = "Sim", Tempo_Gasto = "", ProfessorId = professor1.ProfessorId, DificuldadeId = dificuldade2.DificuldadeId
});
dbContext.Trilho.Add(new Trilho {
Nome_Trilho = "Corredor de Mouros", Local_Inicio_Trilho = "Covão da Ponte", Local_Fim_Trilho = "Corredor de Mouros", Distancia_Total = "8 km", Duracao_Media = "6h15min", Esta_Ativo = "Sim", Tempo_Gasto = "", ProfessorId = professor2.ProfessorId, DificuldadeId = dificuldade3.DificuldadeId
});
dbContext.Trilho.Add(new Trilho {
Nome_Trilho = "Vale Glaciar do Zezere", Local_Inicio_Trilho = "Alminhas", Local_Fim_Trilho = "Vale Glaciar do Zêzere", Distancia_Total = "8 km", Duracao_Media = "5h02min", Esta_Ativo = "Sim", Tempo_Gasto = "", ProfessorId = professor1.ProfessorId, DificuldadeId = dificuldade1.DificuldadeId
});
}
private string GetPathFile(Dificuldade dificuldade, bool CheckIfExists = true)
{
string pathFile = string.Empty;
if (Program.M_Options.ModoJogo == GameMode.Normal)
{
if (dificuldade == Dificuldade.Facil)
{
pathFile = "BestTimeEasyMode.xml";
}
else if (dificuldade == Dificuldade.Medio)
{
pathFile = "BestTimeMediumMode.xml";
}
else if (dificuldade == Dificuldade.Dificil)
{
pathFile = "BestTimeHardMode.xml";
}
}
else
{
pathFile = "BestTimeReverseMode.xml";
}
if (CheckIfExists == true)
{
if (File.Exists(pathFile) == false)
{
return(null);
}
}
return(pathFile);
}
public Leaderboard(int id, Jogador jogador, int pontuacao, Dificuldade dificuldade)
{
this.Id = id;
this.Jogador = jogador;
this.Pontuacao = pontuacao;
this.Dificuldade = dificuldade;
}
private void UCDifficulty_WarnMainFormReverseModeChoice(Dificuldade dificuldade)
{
Program.M_Options.ModoJogo = GameMode.Inverso;
if (Program.V_MineSweeperGame.IsDisposed)
{
Program.V_MineSweeperGame = new FormMinesweeper();
if (SetupEventsMineSweeper != null)
{
SetupEventsMineSweeper();
}
}
this.Hide();
thread.Abort();
if (StartReverseMode != null)
{
StartReverseMode(dificuldade);
}
Program.V_MineSweeperGame.ShowDialog();
Program.V_MineSweeperGame.Dispose();
if (DestroyModel != null)
{
DestroyModel();
}
this.Show();
}
// GET: principal/autoavaliacao/gerar
public ActionResult Gerar()
{
var model = new AvaliacaoGerarViewModel();
model.Disciplinas = Disciplina.ListarTemQuestoes();
model.Dificuldades = Dificuldade.ListarOrdenadamente();
return(View(model));
}
public ActionResult DeleteConfirmed(int id)
{
Dificuldade dificuldade = db.Dificuldade.Find(id);
db.Dificuldade.Remove(dificuldade);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static int CalcularPontuacao(Dificuldade d)
{
if(d == Dificuldade.Dificil) return ((12 + CalcularModificadorMidia(Jogo.dificuldadeDica)) - (Jogo.numeroPalpite * 2) <= 0 ) ? 0 : (12 + CalcularModificadorMidia(Jogo.dificuldadeDica)) - (Jogo.numeroPalpite * 2) ;
if(d == Dificuldade.Medio) return ((8 + CalcularModificadorMidia(Jogo.dificuldadeDica)) - (Jogo.numeroPalpite * 2) <= 0 ) ? 0 : (8 + CalcularModificadorMidia(Jogo.dificuldadeDica)) - (Jogo.numeroPalpite * 2);
if(d == Dificuldade.Facil) return ((4 + CalcularModificadorMidia(Jogo.dificuldadeDica)) - (Jogo.numeroPalpite * 1) <= 0) ? 0 : (4 + CalcularModificadorMidia(Jogo.dificuldadeDica)) - (Jogo.numeroPalpite * 1);
return 0;
}
public static int CalcularPontuacaoCliente(Dificuldade d, int numAcertos)
{
if(d == Dificuldade.Dificil) return numAcertos * 4 + CalcularModificadorMidiaCliente(Jogo.dificuldadeDica, numAcertos);
if(d == Dificuldade.Medio) return numAcertos * 3 + CalcularModificadorMidiaCliente(Jogo.dificuldadeDica, numAcertos);
if(d == Dificuldade.Facil) return numAcertos * 2 + CalcularModificadorMidiaCliente(Jogo.dificuldadeDica, numAcertos);
return 0;
}
private void RefrescarDataViewGrid()
{
List <Dificuldade> lista = Dificuldade.LerDificuldades();
//BindingList<Dificuldade> bindingList = new BindingList<Dificuldade>(lista);
//BindingSource dataSource = new BindingSource(bindingList, null);
dgvDificuldades.DataSource = lista;
}
public ActionResult Gerar()
{
var model = new AvaliacaoGerarViewModel();
model.Disciplinas = /*Helpers.Sessao.UsuarioCategoriaCodigo == 2 ? */ Disciplina.ListarPorProfessor(Sessao.UsuarioMatricula) /*: Disciplina.ListarOrdenadamente()*/;
model.Dificuldades = Dificuldade.ListarOrdenadamente();
model.Termo = Parametro.Obter().NotaUsoCertificacao;
return(View(model));
}
public int QuantidadeJogadoresPorDificuldade(Dificuldade dificuldade)
{
using (var contexto = new ContextoBaseDeDados())
{
return(contexto.Jogador
.Where(jog => jog.Dificuldade == dificuldade)
.Count());
}
}
public ArtificialIntelligence(Player main, List <GameObject> playerObjects, Grid grid)
{
this.main = main;
this.grid = grid;
this.dificuldade = Utils.ApplicationModel.Dificuldade;
setOrder(playerObjects);
pontosDeAcao = main.status.pontosAcao;
possibleAttacks = new List <PossibleAttack>();
}
private static LinkedList <EquacaoBruta> Filtrar(Dificuldade dificuldadeDesejada, IEnumerable <EquacaoBruta> listaCompletaEquacoes)
{
var listaFiltrada = new LinkedList <EquacaoBruta>();
foreach (var equacaoFacil in listaCompletaEquacoes.Where(e => e.Dificuldade == dificuldadeDesejada))
{
listaFiltrada.AddLast(equacaoFacil);
}
return(listaFiltrada);
}
public ActionResult Edit([Bind(Include = "DificuldadeID,NomeDificuldade")] Dificuldade dificuldade)
{
if (ModelState.IsValid)
{
db.Entry(dificuldade).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dificuldade));
}
public Pergunta AdicionaPergunta(string enunciado, Dificuldade dificuldade)
{
var pergunta = new Pergunta()
{
Descricao = enunciado,
Dificuldade = dificuldade
};
this.Perguntas.Add(pergunta);
return pergunta;
}
public ActionResult Gerar()
{
var model = new AvaliacaoGerarViewModel();
model.Disciplinas = Disciplina.ListarPorProfessor(Helpers.Sessao.UsuarioMatricula);
model.Dificuldades = Dificuldade.ListarOrdenadamente();
model.Termo = Parametro.Obter().NotaUsoAcademica;
return(View(model));
}
public IHttpActionResult GetPalavra(Dificuldade dificuldade)
{
Palavra palavra = servicoDePalavra.BuscarPalavraAleatoria(dificuldade);
if (palavra == null)
{
return(NotFound());
}
return(Ok(palavra));
}
public void Salvar(Dificuldade dificuldade)
{
if (dificuldade.Id == 0)
{
repositorio.Salvar(dificuldade);
}
else
{
repositorio.Editar(dificuldade);
}
}
// GET: principal/questao/cadastrar
public ActionResult Cadastrar()
{
var model = new QuestaoCadastrarViewModel();
model.Termo = Parametro.Obter().TermoResponsabilidade;
model.Disciplinas = Professor.ObterDisciplinas(Sessao.UsuarioMatricula);
model.Tipos = TipoQuestao.ListarOrdenadamente();
model.Dificuldades = Dificuldade.ListarOrdenadamente();
model.TiposAnexo = TipoAnexo.ListarOrdenadamente();
return(View(model));
}
public ActionResult Create([Bind(Include = "DificuldadeID,NomeDificuldade")] Dificuldade dificuldade)
{
if (ModelState.IsValid)
{
db.Dificuldade.Add(dificuldade);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(dificuldade));
}
private LinkedListNode <EquacaoBruta> ObterEquacaoAtualPorDificuldade(Dificuldade dificuldade)
{
switch (dificuldade)
{
case Dificuldade.Facil: return(equacaoFacilAtual);
case Dificuldade.Media: return(equacaoMediaAtual);
default: return(equacaoDificilAtual);
}
}
public IList <Leaderboard> Listar(int pagina, int tamanhoPagina, Dificuldade dificuldade)
{
using (var contexto = new ContextoDeDados())
{
return(contexto.Leaderboard.OrderBy(_ => _.Pontuacao)
.Where(_ => _.Dificuldade == dificuldade)
.Skip(tamanhoPagina * (pagina - 1))
.Take(tamanhoPagina)
.ToList());
}
}
public async Task <IActionResult> Create([Bind("DificuldadeId,NomeDificuldade,Observacoes")] Dificuldade dificuldade)
{
if (ModelState.IsValid)
{
_context.Add(dificuldade);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(dificuldade));
}
public InformacoesEquacao ObterEquacao(Dificuldade dificuldade)
{
var equacaoAtual = ObterEquacaoAtualPorDificuldade(dificuldade);
var equacaoBruta = equacaoAtual.Value;
var equacaoProcessada = interpretadorEquacoesPrimeiroGrau.Interpretar(equacaoBruta.RepresentacaoTextual);
var proxima = equacaoAtual.Next;
AtualizarEquacaoAtual(dificuldade, proxima);
return(new InformacoesEquacao(equacaoProcessada, equacaoBruta));
}
public void AlteraDificuldadeNoView(Dificuldade _dificuldade)
{
this.dificuldade = M_Grelha._Dificuldade;
Tamanho = classDificuldade.GetTamanho(this.dificuldade);
if (Tamanho.Width == 30 && Tamanho.Height == 16)
{
this.Size = new Size(new Point(635, 470));
FLPPainelBotoes.Size = new Size(new Point(604, 324));
}
IniciaComponentes();
}
public void CalcularCusto(Dificuldade dificuldade)
{
// Habilidade de Cura
Player target = Target;
float porcentagemVidaTotal = 100f / (float)target.status.maxVida;
float porcentagemVidaRestante = target.status.vida * porcentagemVidaTotal;
if (!isBasicAttack && !habilidade.IsOfensiva)
{
if (habilidade.tipoHabilidade.Equals(TipoHabilidades.HP))
{
cost = 100 - Mathf.FloorToInt(porcentagemVidaRestante);
// Se for Fácil, pode acontecer de curar um aliado com pouca necessidade de cura
if ((dificuldade == Dificuldade.FACIL && cost > 15) || (dificuldade != Dificuldade.FACIL && cost > 50))
{
float porcentagemVida = (target.status.vida + habilidade.CuraMedia) * porcentagemVidaTotal;
if (porcentagemVida > 100f)
{
porcentagemVida = 100f;
}
cost += Mathf.FloorToInt(porcentagemVida) / 2;
}
}
}
else
{
float pontoAcerto = CalcularChanceAcerto();
if (pontoAcerto > 0)
{
int danoMedio;
if (isBasicAttack)
{
danoMedio = main.atributos.DanoMedio;
}
else
{
danoMedio = habilidade.DanoMedio;
}
float porcentagemDano = danoMedio * porcentagemVidaTotal;
int pontoDano = 0;
int qtyVidaRestante = Mathf.FloorToInt(porcentagemVidaRestante - porcentagemDano);
if (qtyVidaRestante <= 0)
{
pontoDano = 50;
}
else
{
pontoDano = Mathf.FloorToInt(porcentagemDano * 100 / porcentagemVidaRestante);
}
cost = Mathf.FloorToInt(pontoAcerto + pontoDano / 2);
}
}
}
public ActionResult SalvarDificuldade(DificuldadeModel model)
{
var aplicativo = new DificuldadeAplicativo();
Dificuldade dificuldade = new Dificuldade()
{
Id = model.Id.HasValue ? model.Id.Value : 0,
Descricao = model.Descricao
};
aplicativo.Salvar(dificuldade);
return(RedirectToAction("Index"));
}
