public void Deve_Popular_Id_Pelo_Construtor()
{
const int id = 1;
var transicao = new Transicao(id);
transicao.Id.Should().Be(id);
}
// Use this for initialization
void Start () {
Propriedade<float> propriedade1 = new Propriedade<float>("propriedade1", 9);
sistema.AdicionarPropriedade(propriedade1);
Estado estado1 = new Estado("estado1",sistema);
sistema.AdicionarEstado(estado1);
Estado estado2 = new Estado("estado2", sistema);
sistema.AdicionarEstado(estado2);
Transicao transicao = new Transicao("valor maior que dez",estado1,estado2,sistema);
sistema.AdicionarTransicao(transicao);
Func<float, bool> comparacao = x => { return x > 10; };
Condicao<float> condicao = new Condicao<float>("maior", comparacao, transicao);
transicao.AdicionarCondicao(condicao);
Transicao transicao2 = new Transicao("valor menor que dez", estado2, estado1, sistema);
sistema.AdicionarTransicao(transicao2);
Func<float, bool> comparacao2 = x => { return x < 10; };
Condicao<float> condicao2 = new Condicao<float>("menor", comparacao2, transicao2);
transicao2.AdicionarCondicao(condicao2);
propriedade1.RegistrarObservador(condicao);
propriedade1.RegistrarObservador(condicao2);
sistema.SetarEstadoInicial(estado1.nome);
}
// Adiciona várias transições no autômato
public void addTransicao(string e1, string s, HashSet <string> e2)
{
Transicao t = GeraTransicao(e1, s, e2);
Transicao te = new Transicao();
if (estados.Contains(t.estado1) & simbolos.Contains(t.simbolo) & estados.IsSupersetOf(t.estado2))
{
KeyTransicao temp = new KeyTransicao(t.estado1, t.simbolo);
if (!transicoes.ContainsKey(temp))
{
transicoes.Add(temp, t);
}
else
{
transicoes.TryGetValue(temp, out te);
foreach (string item in t.estado2)
{
if (!te.estado2.Contains(item))
{
te.estado2.Add(item);
}
}
}
}
}
public void analisar(string arquivoEntrada, AutomatoFinito automatoFinito, ref List <TabelaSimbolos> tokensReconhecidos, ref List <string> erros)
{
lerArquivo(arquivoEntrada);
string textoLinha;
for (int numeroLinha = 0; numeroLinha < _listaEntrada.Count; numeroLinha++)
{
// passa cada linha
textoLinha = _listaEntrada[numeroLinha];
textoLinha = textoLinha.Replace(System.Environment.NewLine, " "); // remove quebra de linha e poe espaço
List <string> matches = new List <string>();
// insere espaço antes dos operadores para separar
foreach (System.Text.RegularExpressions.Match m in Utilidades.expressaoOperadores.Matches(textoLinha))
{
if (matches.Contains(m.Value))
{
continue;
}
matches.Insert(0, m.Value);
textoLinha = textoLinha.Replace(matches[0], " " + matches[0] + " ");
}
_listaEntrada[numeroLinha] = Utilidades.expressaoEspacosDuplos.Replace(textoLinha, " ").Trim(); // remove espaços duplos
string[] tokens = _listaEntrada[numeroLinha].Split(' '); // separa cada token pelo separador
foreach (var token in tokens)
{
// passa cada token da linha
Estado estadoAtual = automatoFinito.estados[0]; // estado inicial
for (int i = 0; i < token.Length; i++)
{
// passa cada caractere do token
// verifica se tem uma transição para esse caractere/simbolo
// como ta determinizado, só tem uma ou nenhuma trasição por esse caractere/simbolo
Transicao transicaoSimbolo = (estadoAtual.transicoes.Where(x => x.simbolo.Equals(token[i]))).FirstOrDefault();
if (transicaoSimbolo == null)
{
// não encontrou transição, leva o índice para a última posição
i = token.Length - 1;
}
else
{
estadoAtual = transicaoSimbolo.estadoDestino;
}
if (i == token.Length - 1) // encontrou um separador
{
if (!estadoAtual.final || transicaoSimbolo == null)
{
// erro
erros.Add("Linha " + (numeroLinha + 1) + ": a sequência de símbolos " + token + " não é reconhecida como sentença...");
}
else
{
// token reconhecido
tokensReconhecidos.Add(new TabelaSimbolos(tokensReconhecidos.Count(), token, estadoAtual, numeroLinha + 1));
}
}
}
}
}
}
private bool elimEstMorto(ref Automato automato, ref Dictionary <string, bool> visitados, string estado)
{
bool ret = false;
if (visitados.ContainsKey(estado))
{
visitados.TryGetValue(estado, out ret);
return(ret);
}
else
{
visitados.Add(estado, automato.estadosFinais.Contains(estado));
foreach (string s in automato.simbolos)
{
Transicao t = automato.GetTransicao(estado, s);
foreach (string e2 in t.estado2)
{
if (elimEstMorto(ref automato, ref visitados, e2))
{
ret = true;
}
}
}
}
visitados.Remove(estado);
visitados.Add(estado, ret | automato.estadosFinais.Contains(estado));
return(ret);
}
public void Deve_Habilitar_Transicao_Quando_Tiver_Arco_Inibidor_Com_Peso_Maior_Que_Marcas()
{
var transicao = new Transicao(1);
transicao.CriarArcoEntrada(new Lugar(1, 2), 3, TipoArco.Inibidor);
transicao.EstáHabilitada.Should().BeTrue();
}
public void Nao_Deve_Habilitar_Transicao_Quando_Tiver_Arco_Inibidor_Com_Peso_Menor_Que_Marcas(int qtdMarcasLugar, int pesoArco)
{
var transicao = new Transicao(1);
transicao.CriarArcoEntrada(new Lugar(1, qtdMarcasLugar), pesoArco, TipoArco.Inibidor);
transicao.EstáHabilitada.Should().BeFalse();
}
public void Deve_Habilitar_Transicao_Com_Arco_Reset_Sempre(int qtdMarcasLugar, int pesoArco)
{
var transicao = new Transicao(1);
transicao.CriarArcoEntrada(new Lugar(1, qtdMarcasLugar), pesoArco, TipoArco.Reset);
transicao.EstáHabilitada.Should().BeTrue();
}
public void Deve_Habilitar_Transicao_Quando_Tiver_Arco_Normal_Com_Peso_Menor_Ou_Igual_Que_Marcas_Do_Lugar(int qtdMarcasLugar, int pesoArco)
{
var transicao = new Transicao(1);
transicao.CriarArcoEntrada(new Lugar(1, qtdMarcasLugar), pesoArco, TipoArco.Normal);
transicao.EstáHabilitada.Should().BeTrue();
}
//-------------------------------------------------------------------
public void addTransition(int destino, ArrayList condicao, float probab)
{
Transicao t = new Transicao();
t.destino = destino;
t.condicao = condicao;
t.probabilidade = probab;
transicoes.Add(t);
}
IEnumerator LoadingScene()
{
Transicao transicao = FindObjectOfType <Transicao>();
transicao.StartTransicao(transparent, Color.black);
yield return(new WaitUntil(() => transicao.finished));
SceneManager.LoadScene(ScenePoint);
}
IEnumerator CarregarCena()
{
Transicao transicao = FindObjectOfType <Transicao>();
transicao.IniciarTransicao(transparente, Color.black);
yield return(new WaitUntil(() => transicao.acabou));
SceneManager.LoadScene(cenaAlvo);
}
public void FadeOff()
{
if (FadeAtual == null)
{
FadeAtual = FadeToBlack;
}
AtivarObjeto();
FadeAtual.TerminoudeMostrar += DesativarObjeto;
FadeAtual.FadeOff();
}
// Pega uma transição existente
public Transicao GetTransicao(string estado, string simbolo)
{
Transicao t = new Transicao();
KeyTransicao temp = new KeyTransicao(estado, simbolo);
if (transicoes.ContainsKey(temp))
{
transicoes.TryGetValue(temp, out t);
}
return(t);
}
public void ExecutaTransicao(Transicao transicao)
{
if (transicao.PodeExecutar)
{
foreach (Lugar lugar in transicao.lugaresEntrada)
{
lugar.RetiraMarca();
}
foreach (Lugar lugar in transicao.lugaresSaida)
{
lugar.AdicionaMarca();
}
}
}
//Metodo Elimina Estados Mortos.
//Todo estado que não alcança un estado final é removido.
public Automato eliminaEstadosMortos(Automato automato)
{
Dictionary <string, bool> t = new Dictionary <string, bool>();
elimEstMorto(ref automato, ref t, automato.estadoInicial);
List <KeyTransicao> lk = new List <KeyTransicao>();
List <Transicao> li = new List <Transicao>();
foreach (KeyValuePair <string, bool> v in t)
{
if (v.Value == false)
{
automato.estados.Remove(v.Key);
foreach (KeyValuePair <KeyTransicao, Transicao> tran in automato.transicoes)
{
if (tran.Key.estado == v.Key)
{
lk.Add(tran.Key);
}
if (tran.Value.estado2.Contains(v.Key))
{
Transicao temp = tran.Value;
temp.estado2.Remove(v.Key);
li.Add(temp);
}
}
}
}
foreach (KeyTransicao l in lk)
{
automato.transicoes.Remove(l);
}
foreach (Transicao l in li)
{
KeyTransicao kt = new KeyTransicao
{
estado = l.estado1,
simbolo = l.simbolo
};
automato.transicoes.Remove(kt);
if (l.estado2.Count > 0)
{
automato.transicoes.Add(kt, l);
}
}
return(automato);
}
public void RecebeTransicoes()
{
Console.Write("Quantas transicões: ");
int qtdTransicoes = int.Parse(Console.ReadLine());
for (int i = 1; i <= qtdTransicoes; i++)
{
Transicao transicao = new Transicao($"T{i}");
transicoes.Add(transicao);
RecebeLugaresEntrada(transicao);
RecebeLugaresSaida(transicao);
}
}
/// <summary>
/// Recebe um Evento contendo um Token Lexico
/// </summary>
/// <param name="evento">Tipo: TOKEN_LEXICO, Conteudo: TokenLexico </param>
/// <returns></returns>
public SaidaRotina ReceberToken(Evento evento)
{
TokenLexico tokenLexico = (TokenLexico)evento.Conteudo;
Transicao transicao = AutomatoFinito.BuscaTransicao(Cabecote.EstadoAtual, tokenLexico.Categoria);
if (transicao != null)
{
Transicao(transicao);
Acumulador.Add(tokenLexico);
return(new SaidaRotina(
new List <Evento>(),
new List <Evento>(),
new List <Evento>()
));
}
else
{
if (Cabecote.Aceito)
{
return(new SaidaRotina(
new List <Evento>(),
new List <Evento>()
{
new Evento(evento.InstanteProgramado + 1, TipoEvento.RESET, evento.Tarefa, null), new Evento(evento.InstanteProgramado + 2, TipoEvento.TOKEN_LEXICO, evento.Tarefa, evento.Conteudo)
},
new List <Evento>()
{
new Evento(evento.InstanteProgramado + 1, TipoEvento.TOKEN_LEXICO, evento.Tarefa, GetTokenLexicoFromEstadoAtual())
}
));
}
else
{
List <Evento> eventosSaida = new List <Evento>();
eventosSaida.AddRange(Acumulador.Select(t => new Evento(evento.InstanteProgramado + 1, TipoEvento.TOKEN_LEXICO, evento.Tarefa, t)));
eventosSaida.Add(new Evento(evento.InstanteProgramado + 2, TipoEvento.TOKEN_LEXICO, evento.Tarefa, evento.Conteudo));
return(new SaidaRotina(
new List <Evento>(),
new List <Evento>()
{
new Evento(evento.InstanteProgramado + 1, TipoEvento.RESET, evento.Tarefa, null)
},
eventosSaida
));
}
}
}
public void Deve_Popular_Propriedades_Da_Base_Pelo_Construtor()
{
var lugar = new Lugar(1, 10);
const int peso = 1;
var transicao = new Transicao(1);
const DirecaoArco direcao = DirecaoArco.EntradaTransição;
new ArcoNormal(lugar, peso, transicao, direcao)
.Should()
.BeEquivalentTo(new
{
Lugar = lugar,
Peso = peso,
Transicao = transicao,
Direcao = direcao
});
}
/// <summary>
/// Recebe um Evento contendo uma CaracterCaracterizado
/// </summary>
/// <param name="evento">Tipo: ASCII, Conteudo: CaracterClassificado </param>
/// <returns></returns>
// Token possui Tipo (Identificador, Número, Especial) e Valor
public SaidaRotina ReceberCaracter(Evento evento)
{
CaracterClassificado caracterClassificado = (CaracterClassificado)evento.Conteudo;
Transicao transicao = AutomatoFinito.BuscaTransicao(Cabecote.EstadoAtual, caracterClassificado.Caracter);
if (transicao != null)
{
Transicao(transicao);
if (caracterClassificado.Funcao != FuncaoCaracter.DESCARTAVEL)
{
Acumulador.Add(caracterClassificado);
}
return(new SaidaRotina(
new List <Evento>(),
new List <Evento>(),
new List <Evento>()
));
}
else if (caracterClassificado.Tipo == TipoCaracter.DELIMITADOR || Cabecote.Aceito)
{
return(new SaidaRotina(
new List <Evento>(),
new List <Evento>()
{
new Evento(evento.InstanteProgramado + 1, TipoEvento.RESET, evento.Tarefa, null), new Evento(evento.InstanteProgramado + 2, TipoEvento.ASCII, evento.Tarefa, evento.Conteudo)
},
new List <Evento>()
{
new Evento(evento.InstanteProgramado + 1, TipoEvento.TOKEN_LEXICO, evento.Tarefa, GetTokenLexicoFromEstadoAtual())
}
));
}
else
{
TransicaoNA();
Acumulador.Add(caracterClassificado);
return(new SaidaRotina(
new List <Evento>(),
new List <Evento>(),
new List <Evento>()
));
}
}
private void RecebeLugaresSaida(Transicao transicao)
{
Console.Write($"Quais são os lugares de saida de {transicao.Nome}? ");
string[] arrayLugares = Console.ReadLine().Split(',');
if (arrayLugares.Length > 0)
{
foreach (string nome in arrayLugares)
{
Lugar lugar = lugares.Find(obj => obj.Nome == nome);
Arco arco = new Arco(transicao, lugar);
arcos.Add(arco);
lugar.arco = arco;
transicao.arcos.Add(arco);
transicao.lugaresSaida.Add(lugar);
}
}
}
// Ou cria uma nova transição ou adiciona o estado 2 em uma existente (indeterminizar)
public Transicao GeraTransicao(string e1, string s, HashSet <string> e2)
{
Transicao t = new Transicao();
KeyTransicao temp = new KeyTransicao(e1, s);
if (transicoes.ContainsKey(temp))
{
transicoes.TryGetValue(temp, out t);
}
//char[] delimiter = { '*', '+' };
if (e1.Contains("*") || e1.Contains("+"))
{
// e1 = e1.Split(delimiter)[1];
e1 = e1.Replace("*", "");
e1 = e1.Replace("+", "");
}
t.estado1 = e1;
t.simbolo = s;
foreach (string e in e2)
{
if (e.Contains("*") || e.Contains("+"))
{
//t.estado2.Add(e.Split(delimiter)[1]);
string aux = e;
aux = aux.Replace("*", "");
aux = aux.Replace("+", "");
t.estado2.Add(aux);
}
else
{
t.estado2.Add(e);
}
}
return(t);
}
public void CarregarSimulacao(string caminho)
{
var tipDado = eTipoDado.Nenhum;
foreach (var linha in File.ReadAllLines(caminho))
{
if (linha == "#LUGARES")
{
tipDado = eTipoDado.Lugar;
continue;
}
if (linha == "#TRANSIÇÕES")
{
tipDado = eTipoDado.Transicao;
continue;
}
if (linha == "#ARCOS")
{
tipDado = eTipoDado.Arco;
continue;
}
switch (tipDado)
{
case eTipoDado.Lugar:
var dados = linha.Split(';');
lugares.Add(new Lugar(dados[0], Int32.Parse(dados[1])));
break;
case eTipoDado.Transicao:
dados = linha.Split(';');
var transicao = new Transicao(dados[0]);
transicoes.Add(transicao);
break;
case eTipoDado.Arco:
dados = linha.Split(';');
var arco = new Arco();
arco.peso = Int32.Parse(dados[2]);
if (dados[0].StartsWith("L"))
{
var origem = lugares.Find(l => l.Nome == dados[0]);
arco.origem = origem;
var destino = transicoes.Find(l => l.Nome == dados[1]);
arco.destino = destino;
origem.arco = arco;
destino.arcos.Add(arco);
}
else
{
var origem = transicoes.Find(l => l.Nome == dados[0]);
arco.origem = origem;
var destino = lugares.Find(l => l.Nome == dados[1]);
arco.destino = destino;
origem.arcos.Add(arco);
destino.arco = arco;
}
arcos.Add(arco);
break;
}
}
}
void Transicao(Transicao transicao)
{
Cabecote.EstadoAtual = transicao.Destino;
Cabecote.Aceito = AutomatoFinito.ConfereEstadoFinal(Cabecote.EstadoAtual);
}
public void DesfazerTransicao()
{
Transicao.Rollback();
}
public void FecharTransicao()
{
Transicao.Commit();
}
public void FadeINToBlack()
{
Debug.Log("Fade in to black chamado");
FadeAtual = FadeToBlack;
FadeIn();
}
public void FadeINToWhite()
{
FadeAtual = FadeToWhite;
FadeIn();
}
