public RoboDTO(Robo robo)
{
#region Cabeca
Cabeca = new CabecaDTO();
Cabeca.Rotacao = robo.Cabeca.Rotacao;
Cabeca.RotacaoDesc = EnumHelper.GetDescription(robo.Cabeca.Rotacao);
Cabeca.Inclinacao = robo.Cabeca.Inclinacao;
Cabeca.InclinacaoDesc = EnumHelper.GetDescription(robo.Cabeca.Inclinacao);
#endregion Cabeca
#region Bracos
BracoDireito = new BracoDTO();
BracoDireito.Cotovelo = robo.BracoDireito.Cotovelo;
BracoDireito.CotoveloDesc = EnumHelper.GetDescription(robo.BracoDireito.Cotovelo);
BracoDireito.Pulso = robo.BracoDireito.Pulso;
BracoDireito.PulsoDesc = EnumHelper.GetDescription(robo.BracoDireito.Pulso);
BracoEsquerdo = new BracoDTO();
BracoEsquerdo.Cotovelo = robo.BracoEsquerdo.Cotovelo;
BracoEsquerdo.CotoveloDesc = EnumHelper.GetDescription(robo.BracoEsquerdo.Cotovelo);
BracoEsquerdo.Pulso = robo.BracoEsquerdo.Pulso;
BracoEsquerdo.PulsoDesc = EnumHelper.GetDescription(robo.BracoEsquerdo.Pulso);
#endregion Bracos
}
public void DadoChromeAbertoDeveMostrarEntrarNoTitulo()
{
Robo.AcessarUrl(Caminhos.StartUrl);
Assert.Contains("Entrar - Assistente de Estágio", Robo.Driver.Title);
Robo.Fechar();
}
public ServiceRobo()
{
var context = HttpContext.Current;
if (context != null)
{
if (context.Cache[CacheKey] == null)
{
var robos = new Robo[]
{
new Robo
{
//estados iniciais do R.O.B.O
Name = "",
CabecaInclinacao = 2,
CabecaRotacao = 3,
BracoEsquerdoCotovelo = 1,
BracoEsquerdoPulso = 3,
BracoDireitoCotovelo = 1,
BracoDireitoPulso = 3
}
};
context.Cache[CacheKey] = robos;
}
}
}
public void Movement_Service_Start_With_Initialize_Should_Return_Correct_Result2()
{
var moveAreaMock = new Mock <IMoveArea <int> >();
moveAreaMock.SetupGet(s => s.Width).Returns(10);
moveAreaMock.SetupGet(s => s.Height).Returns(10);
var robo = new Robo <int, int>(moveAreaMock.Object);
var service = new MovementService <int, int>(robo);
robo.Step = 1;
service.Initialize("PLACE 1,2,EAST");
service.ProcessCommand("MOVE");
service.ProcessCommand("MOVE");
service.ProcessCommand("LEFT");
service.ProcessCommand("MOVE");
var expectedDirection = DirectionFactory <int, int> .Create("NORTH");
robo.Direction.GetType().Should().BeSameAs(expectedDirection.GetType());
robo.Position.X.Should().Be(3);
robo.Position.Y.Should().Be(3);
service.ProcessCommand("MOVE");
robo.Position.X.Should().Be(3);
robo.Position.Y.Should().Be(4);
}
public string ValidarComandosRobo(RoboDTO comandoAlterar, Robo comandoAtual)
{
var validar = ValidarRotacaoCabeca(comandoAlterar.Cabeca, comandoAtual.Cabeca);
if (!string.IsNullOrEmpty(validar))
{
return(validar);
}
validar = ValidarInclinacaoCabeca(comandoAlterar.Cabeca, comandoAtual.Cabeca);
if (!string.IsNullOrEmpty(validar))
{
return(validar);
}
validar = ValidarComandosBracoDireto(comandoAlterar.BracoDireito, comandoAtual.BracoDireito);
if (!string.IsNullOrEmpty(validar))
{
return(validar);
}
validar = ValidarComandosBracoEsquerdo(comandoAlterar.BracoEsquerdo, comandoAtual.BracoEsquerdo);
if (!string.IsNullOrEmpty(validar))
{
return(validar);
}
return(string.Empty);
}
public ServicoBase(TClass obj, Robo robo, IValidacaoBase <TClass, Robo> validador, string key)
{
_obj = obj;
_robo = robo;
_validador = validador;
_key = key;
}
public void MoveMML()
{
IRobo robo = new Robo();
var controller = new MarsController(robo);
var result = controller.Post("MML");
Assert.Equal(typeof(Microsoft.AspNetCore.Mvc.OkObjectResult), result.GetType());
}
public void MoveAAAIsNotTypeOK()
{
IRobo robo = new Robo();
var controller = new MarsController(robo);
var result = controller.Post("AAA");
Assert.IsNotType <Microsoft.AspNetCore.Mvc.OkObjectResult>(result.GetType());
}
public void DeveVirarParaADireita()
{
robo = new Robo(Direcao.Oeste);
robo = robo.MudarDirecao(Direcao.Leste);
robo.Incremento.Should().Be(Direcao.Leste);
}
public HttpResponseMessage Post(Robo robo)
{
this.serviceRobo.Save(robo);
var response = Request.CreateResponse <Robo>(System.Net.HttpStatusCode.Created, robo);
return(response);
}
public void DadoChromeAbertoDeveMostrarAsssitenteDeEstagio()
{
Robo.AcessarUrl(Caminhos.StartUrl);
string TituloCartao = Robo.ObterTextoPorId("tituloHome");
Assert.Contains("Assistente de Estágio", TituloCartao);
Robo.Fechar();
}
void Start()
{
roboController = transform.parent.GetComponent <Robo>();
particle = GetComponentInChildren <ParticleSystem>();
particle.renderer.sortingLayerName = "ForeGround";
particle.renderer.sortingOrder = 1;
}
public void DeveAndarParaAEsquerdaQuandoADirecaoForEsquerda()
{
robo = robo.MudarDirecao(Direcao.Oeste);
robo = robo.Andar();
var posicao = new Posicao(-1, 0);
robo.Posicao.Should().Be(posicao);
}
//Só poderá movimentar o Pulso caso o Cotovelo esteja Fortemente Contraído.
public void PulsoMovimentar_MovimentarPulsoComCotoveloEmRepouso_RetornarFalso()
{
Robo Robo = JsonConvert.DeserializeObject <Robo>("{ \"Cabeca\": { \"CabecaInclinacao\": { \"EstadoAtual\": 1, \"ProximoEstado\": 2, \"AnteriorEstado\": 0 }, \"CabecaRotacao\": { \"EstadoAtual\": 2, \"ProximoEstado\": 3,\"AnteriorEstado\": 1 } }, \"BracoEsquerdo\": { \"Cotovelo\": { \"EstadoAtual\": 0, \"ProximoEstado\": 1, \"AnteriorEstado\": 0 }, \"Pulso\": { \"EstadoAtual\": 2, \"ProximoEstado\": 3, \"AnteriorEstado\": 1 } }, \"BracoDireito\": { \"Cotovelo\": { \"EstadoAtual\": 0, \"ProximoEstado\": 1, \"AnteriorEstado\": 0 }, \"Pulso\": { \"EstadoAtual\": 2, \"ProximoEstado\": 3, \"AnteriorEstado\": 1 } } }");
PulsoValidacao PulsoValidacao = new PulsoValidacao();
ValidacaoResultado Retorno = PulsoValidacao.Validar(Robo.BracoDireito.Pulso, Robo, "PulsoDireito");
Assert.AreEqual(false, Retorno.Valido);
}
//Só poderá Rotacionar a Cabeça caso sua Inclinação da Cabeça não esteja em estado Para Baixo.
public void CabecaRotacao_RotacionarCabecaCasoInclinacaoNaoSejaParaBaixo_RetornarVerdadeiro()
{
Robo Robo = JsonConvert.DeserializeObject <Robo>("{ \"Cabeca\": { \"CabecaInclinacao\": { \"EstadoAtual\": 1, \"ProximoEstado\": 2, \"AnteriorEstado\": 0 }, \"CabecaRotacao\": { \"EstadoAtual\": 2, \"ProximoEstado\": 3,\"AnteriorEstado\": 1 } }, \"BracoEsquerdo\": { \"Cotovelo\": { \"EstadoAtual\": 0, \"ProximoEstado\": 1, \"AnteriorEstado\": 0 }, \"Pulso\": { \"EstadoAtual\": 2, \"ProximoEstado\": 3, \"AnteriorEstado\": 1 } }, \"BracoDireito\": { \"Cotovelo\": { \"EstadoAtual\": 1, \"ProximoEstado\": 2, \"AnteriorEstado\": 0 }, \"Pulso\": { \"EstadoAtual\": 2, \"ProximoEstado\": 3, \"AnteriorEstado\": 1 } } }");
CabecaValidacao CabecaRotacaoValidacao = new CabecaValidacao();
ValidacaoResultado Retorno = CabecaRotacaoValidacao.Validar(Robo.Cabeca.CabecaRotacao, Robo, "CabecaRotacao");
Assert.AreEqual(true, Retorno.Valido);
}
public void DeveAndarParaADireitaQuandoADirecaoForDireita()
{
robo = robo.MudarDirecao(Direcao.Leste);
robo = robo.Andar();
var posicao = new Posicao(1, 0);
robo.Posicao.Should().Be(posicao);
}
public void DeveDispararExcecaoComComandoInvalido()
{
string comando = "AAA";
var robo = new Robo();
var posicao = robo.ObterPosicao();
Assert.Equal("(0,0,N)", posicao);
Assert.Equal("Comando inválido", Assert.Throws <NegocioException>(() => robo.AplicarComando(comando)).Message);
}
public void DeveDispararExcecaoForaDoTerreno()
{
string comando = "MMMMMMMMMMMMMMMMMMMMMMMM";
var robo = new Robo();
var posicao = robo.ObterPosicao();
Assert.Equal("(0,0,N)", posicao);
Assert.Equal("Posição inválida", Assert.Throws <NegocioException>(() => robo.AplicarComando(comando)).Message);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
BundleTable.EnableOptimizations = false;
Robo robo = new Robo();
robo.Start();
}
public void Movement_Service_Start_Without_Initialize_Should_Throw_Exceptions(string command, string exceptionMessage)
{
var moveAreaMock = new Mock <IMoveArea <int> >();
moveAreaMock.SetupGet(s => s.Width).Returns(10);
moveAreaMock.SetupGet(s => s.Height).Returns(10);
var robo = new Robo <int, int>(moveAreaMock.Object);
var service = new MovementService <int, int>(robo);
Action act = () => service.ProcessCommand(command);
act.Should().Throw <InvalidOperationException>().WithMessage(exceptionMessage);
}
public async Task <bool> UpdateRobo(string name, Robo item)
{
try {
ReplaceOneResult actionResult = await _context.Robos
.ReplaceOneAsync(n => n.Name.Equals(name), item, new UpdateOptions { IsUpsert = true });
return(actionResult.IsAcknowledged &&
actionResult.ModifiedCount > 0);
} catch (Exception ex) {
// log or manage the exception
throw ex;
}
}
public Robo GetSituacaoAtual()
{
var cabeca = db.Cabecas.ToList().LastOrDefault();
var bDireito = db.BracoDireitoes.ToList().LastOrDefault();
var bEsquerdo = db.BracoEsquerdoes.ToList().LastOrDefault();
Robo robo = new Robo();
robo.cabeca = cabeca;
robo.bracoDireito = bDireito;
robo.bracoEsquerdo = bEsquerdo;
return(robo);
}
public void Robo_Initialize_Should_Throw_Exception(string command, string exceptionMessage)
{
var moveAreaMock = new Mock <IMoveArea <int> >();
moveAreaMock.SetupGet(s => s.Width).Returns(10);
moveAreaMock.SetupGet(s => s.Height).Returns(10);
var robo = new Robo <int, int>(moveAreaMock.Object);
Action act = () => robo.Initialize(command);
act.Should().Throw <ArgumentException>().WithMessage(exceptionMessage);
}
public void TestePulsoIncorreto()
{
mock = Substitute.For <IRoboService>();
Robo robo = new Robo();
robo.BracoDireito = new BracoDireito();
robo.BracoDireito.ProximoMovimentoPulso = 3;
robo.BracoDireito.ProximoMovimentoCotovelo = 2;
mock.NextMove(robo)
.Returns(new Robo {
mensagem = "Valor do Cotovelo errado."
});
}
private void RoboInitialize()
{
Console.WriteLine("Инициализация аниматора");
RA = new RoboAnimator(Program.comandText, this);
Console.WriteLine("Инициализация роботов");
Image I = Image.FromFile(@"..\..\Animation\Robo\RoboHand_Default.png");
Robo R = new Robo(I, 1);
RA.addRobo(R);
Controls.Add(R.RoboBox);
}
public IActionResult NextMove(Robo robo)
{
Robo roboRetorno = new Robo();
try
{
roboRetorno = _roboService.NextMove(robo);
return(Ok(roboRetorno));
}
catch (Exception ex)
{
return(BadRequest(roboRetorno));
}
}
public void DeveMovimentarPara20S()
{
string comando = "MMRMMRMM";
var robo = new Robo();
var posicao = robo.ObterPosicao();
Assert.Equal("(0,0,N)", posicao);
robo.AplicarComando(comando);
posicao = robo.ObterPosicao();
Assert.Equal("(2,0,S)", posicao);
}
//Aciona quando é clicado o componente 'btn_MoverRoboUm'
private void btn_MoverRoboUm_Click(object sender, EventArgs e)
{
/* Condição para saber se os dados foram preenchidos corretamente,
* se sim chamar um método de classe para adicionar o resultado onde o objeto se encontra atualmente no componente 'lbx_Resultado'.
*/
if (txt_PosiEntrada.Text.Count() == 3 && txt_PosiPriRobo.Text.Count() == 4 && txt_MoviPriRobo.Text.Count() != 0)
{
lbx_Resultado.Items.Add("O robo 1 se encontra em: " + Robo.PosicaoFinal(txt_PosiPriRobo.Text, txt_MoviPriRobo.Text));
}
else
{
MessageBox.Show("Dados incompletos, preencha corretamente a posição de entrada, a posição do robô 1 e sua movimentação!", "Atenção!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public async Task <IHttpActionResult> Get()
{
try
{
var allCabeca = db.Cabecas.ToList();
var allBEsquerdo = db.BracoDireitoes.ToList();
var allBDireito = db.BracoEsquerdoes.ToList();
if (allCabeca.Count == 0)
{
Cabeca item = new Cabeca();
item.Inclinacao = 0;
item.Rotacao = 0;
db.Cabecas.Add(item);
await db.SaveChangesAsync();
}
if (allBEsquerdo.Count == 0)
{
BracoEsquerdo item = new BracoEsquerdo();
item.Cotovelo = 0;
item.Pulso = 0;
db.BracoEsquerdoes.Add(item);
await db.SaveChangesAsync();
}
if (allBDireito.Count == 0)
{
BracoDireito item = new BracoDireito();
item.Cotovelo = 0;
item.Pulso = 0;
db.BracoDireitoes.Add(item);
await db.SaveChangesAsync();
}
var cabeca = db.Cabecas.ToList().LastOrDefault();
var bDireito = db.BracoDireitoes.ToList().LastOrDefault();
var bEsquerdo = db.BracoEsquerdoes.ToList().LastOrDefault();
Robo robo = new Robo();
robo.cabeca = cabeca;
robo.bracoDireito = bDireito;
robo.bracoEsquerdo = bEsquerdo;
return(Ok(robo));
}
catch (WebException we)
{
return(BadRequest(we.Message));
}
}
public Robo ExecutarComandosRobo(RoboDTO comandosRobo)
{
Robo robo = new Robo();
robo.Cabeca.Rotacao = comandosRobo.Cabeca.Rotacao;
robo.Cabeca.Inclinacao = comandosRobo.Cabeca.Inclinacao;
robo.BracoDireito.Cotovelo = comandosRobo.BracoDireito.Cotovelo;
robo.BracoDireito.Pulso = comandosRobo.BracoDireito.Pulso;
robo.BracoEsquerdo.Cotovelo = comandosRobo.BracoEsquerdo.Cotovelo;
robo.BracoEsquerdo.Pulso = comandosRobo.BracoEsquerdo.Pulso;
return(robo);
}
//testa se a letra digitada eh encontrada
public bool Guess(char letter, Robo robo)
{
bool found = false;
List<int> posicoesLetraEncontrada = new List<int>();
//converte para maiuscula
letter = Char.ToUpper(letter);
//Procura a letra na palavra
for (int i = 0; i < completeWordChars.Length; i++)
{
//Se a letra for encontrada, precisa ser trocado o WildCard na palavra parcial
//na mesma posicao da palavra completa
if (completeWordChars[i] == letter)
{
partialWordChars[i] = letter;
found = true;
}
}
robo.Palavras = robo.VerificaPorLetra(partialWordChars);
return found;
}
//logica do jogo
public void Play(string inputedWord)
{
//retira acentos
string newWord = Robo.RemoveAcento(inputedWord);
//instancia um objeto da classe algoritmo
Robo myPC = new Robo(newWord);
//
Word w = new Word(newWord);
while (true)
{
Console.WriteLine("---COMEÇOU o JOGO DA FORCA !!---\n");
Console.WriteLine("O Robô poderá errar no máximo {0} vezes\n", MaxErrors);
int errors = 0;
//armazena as letras tentadas
HashSet<char> triedLetters = new HashSet<char>();
while (!w.Finished && errors < MaxErrors)
{
//exibe a propriedade palavra parcial do objeto w da classe word
Console.WriteLine("___");
Console.WriteLine("| |");
Console.WriteLine("| O");
Console.WriteLine("|");
Console.WriteLine(w.PartialWord);
Console.WriteLine("Erros = {0}", errors);
Thread.Sleep(4000);
//roda a função do algoritmo que analisa a palavra a ser jogada
string letter = myPC.TryLetter().ToString();
//Solicita a letra
Console.WriteLine("O computador irá jogar uma letra...");
Thread.Sleep(2000);
Console.WriteLine("Letra jogada: {0}\n", letter);
Thread.Sleep(2000);
if (triedLetters.Contains(letter[0]))
{
Console.WriteLine("A letra {0} já foi jogada\n", letter);
continue;
}
else
{
triedLetters.Add(letter[0]);
}
bool found = w.Guess(letter[0], myPC);
if (found)
{
//Se encontrou, mostra a mensagem
Console.WriteLine("Robô: Parabéns pra mim! Encontrei uma letra!\n");
}
else
{
//se nao encontrou, aumenta os erros e exibe mensagem
errors++;
char c = Convert.ToChar(letter);
myPC.LetrasJogadasErradas.Add(c);
Console.WriteLine("Robô: Droga! Errei =/ \n");
}
}
//se o loop acabou, é porque o computador achou a palavra ou acabou suas tentativas
string Option = null;
//testa porque o loop acabou - pelo numero de erros ou por acerto do algoritmo
if (errors < MaxErrors)
{
//se acertou, exibe mensagem parabenizando
Console.WriteLine(@"\o/");
Console.WriteLine(@" |");
Console.WriteLine(@"/ \");
Console.WriteLine(w.PartialWord);
Console.WriteLine("Erros = {0}", errors);
Console.WriteLine("\nO Algoritmo conseguiu adivinhar a palavra({0})! =) \nDeseja testar o algoritmo novamente? (S/N) ", w.CompleteWord);
//recebe a opção do usuario
Option = Console.ReadLine();
}
else
{
//se for por erros, exibe mensagem
myPC.VerificaSeConhecePalavra(w.CompleteWord);
Console.WriteLine("\nO algoritmo de análise não foi capaz de advinhar a palavra, que era: {0}. \nDeseja testar o algoritmo novamente? (S/N)", w.CompleteWord);
//recebe a opção do usuario
Option = Console.ReadLine();
}
if (Option.Length > 0 && (Option[0] == 's' || Option[0] == 'S'))
{
Console.WriteLine("Ok, vamos testar novamente o Algoritmo!!");
Console.WriteLine("Digite uma nova palavra:");
string novaPalavra = Console.ReadLine();
Console.WriteLine("\nDigite quantas tentativas o Algoritmo vai ter para descobrir a palavra digitada: ");
int tentativas = Convert.ToInt32(Console.ReadLine());
Option = null;
Game game = new Game(tentativas);
game.Play(novaPalavra);
}
else
{
Console.WriteLine("Até a próxima!!");
break;
}
}
}
public GameObject criarRobo( GameObject armaturePrefab, GameObject headPrefab, GameObject bodyPrefab, GameObject armsPrefab, GameObject legsPrefab, string scriptName )
{
GameObject newRobot, oldPart, newPart;
Part part;
BoxCollider collider;
Rigidbody rigidbody;
Transform armature;
armature = null;
oldPart = newPart = null;
Debug.Log("Instanciando novo robo a partir do prefab: "+armaturePrefab.name);
newRobot = (GameObject) Instantiate( armaturePrefab );
newRobot.name = "newRobot";
collider = newRobot.AddComponent<BoxCollider>();
rigidbody = newRobot.AddComponent<Rigidbody>();
newRobot.AddComponent( scriptName );
Debug.Log("\tProcurando armature do prefab...");
armature = procuraObjetoEmUmaObjetoInstanciado( "Armature", newRobot.transform ).transform;
Debug.Log("\tContruindo Head: "+headPrefab.name );
if( headPrefab != armaturePrefab ){
oldPart = procuraObjetoEmUmaObjetoInstanciado( "head", newRobot.transform );
newPart = procuraObjetoEmUmaPrefab( "head", headPrefab );
changePart( oldPart, newPart, newRobot );
}
part = procuraObjetoEmUmaObjetoInstanciado( "head", newRobot.transform ).GetComponent<Part>();
part.PartType = "head";
part.PrefabName = getNameByGameObject( headPrefab );
part.Id = RobotUtility.contador++;
Debug.Log("\tContruindo Body: "+bodyPrefab.name);
if( bodyPrefab != armaturePrefab ){
oldPart = procuraObjetoEmUmaObjetoInstanciado( "body", newRobot.transform );
newPart = procuraObjetoEmUmaPrefab( "body", bodyPrefab );
changePart( oldPart, newPart, newRobot );
}
part = procuraObjetoEmUmaObjetoInstanciado( "body", newRobot.transform ).GetComponent<Part>();
part.PartType = "body";
part.PrefabName = getNameByGameObject( bodyPrefab );
part.Id = RobotUtility.contador++;
Debug.Log("\tContruindo Arms: "+armsPrefab.name);
if( armsPrefab != armaturePrefab ){
oldPart = procuraObjetoEmUmaObjetoInstanciado( "arms", newRobot.transform );
newPart = procuraObjetoEmUmaPrefab( "arms", armsPrefab );
changePart( oldPart, newPart, newRobot );
}
part = procuraObjetoEmUmaObjetoInstanciado( "arms", newRobot.transform ).GetComponent<Part>();
part.PartType = "arms";
part.PrefabName = getNameByGameObject( armsPrefab );
part.Id = RobotUtility.contador++;
Debug.Log("\tContruindo legs: "+legsPrefab.name);
if( legsPrefab != armaturePrefab ){
oldPart = procuraObjetoEmUmaObjetoInstanciado( "legs", newRobot.transform );
newPart = procuraObjetoEmUmaPrefab( "legs", legsPrefab );
changePart( oldPart, newPart, newRobot );
}
part = procuraObjetoEmUmaObjetoInstanciado( "legs", newRobot.transform ).GetComponent<Part>();
part.PartType = "legs";
part.PrefabName = getNameByGameObject( legsPrefab );
part.Id = RobotUtility.contador++;
Debug.Log("\tContruindo Fisica");
//collider.center = new Vector3( 0, 0 , -1 );
collider.size = new Vector3( 0.1F, 0.1F, 0.1F );
rigidbody.mass = 100;
rigidbody.freezeRotation = true;
Robo robo = new Robo();
return newRobot;
}
