/// <summary>
/// Método responsável por verificar se o robo pode repousar os braços
/// </summary>
/// <param name="_robo">Ojeto robo que será verificado o estado atual do braço</param>
/// <param name="ladoBraco">Parâmetro para identificar qual dos braços (esquerdo ou direito) está sendo verificado.</param>
/// <returns>Retorno booleano com base na permissão do movimento.</returns>
public bool PermitirRepousarBraco(IRobo _robo, byte ladoBraco)
{
var resultado = false;
switch (ladoBraco)
{
case 1:
{
if (_robo.BracoEsquerdo.Cotovelo.Estado == (byte)EnumsRobo.Estados.LevementeContraido)
{
resultado = true;
}
else
{
resultado = false;
}
break;
}
case 2:
{
if (_robo.BracoDireito.Cotovelo.Estado == (byte)EnumsRobo.Estados.LevementeContraido)
{
resultado = true;
}
else
{
resultado = false;
}
break;
}
}
return(resultado);
}
/// <summary>
/// Método para verificar se o braço está fortemente contraído. Utilizado para bloquear rotação dos pulsos caso não esteja neste estado.
/// </summary>
/// <param name="_robo">Objeto robô utilizado para verificar o estado dos braços.</param>
/// <param name="ladoBraco">Identificador de qual braço está sendo verficado (esquerdo ou direito).</param>
/// <returns></returns>
public bool VericarBracoFortementeContraido(IRobo _robo, byte ladoBraco)
{
var resultado = false;
switch (ladoBraco)
{
case 1:
{
if (_robo.BracoEsquerdo.Cotovelo.Estado == (byte)EnumsRobo.Estados.FortementeContraido)
{
resultado = true;
}
break;
}
case 2:
{
if (_robo.BracoDireito.Cotovelo.Estado == (byte)EnumsRobo.Estados.FortementeContraido)
{
resultado = true;
}
break;
}
}
return(resultado);
}
/// <summary>
/// Método responsável por verificar se o robo pode realizar movimento de rotação da cabeça.
/// O movimento só é permitido se a cabeça não estiver inclinada para baixo
/// </summary>
/// <param name="_robo">Ojeto robo, utilizado para ver a inclinacao atual de sua cabeça.</param>
/// <returns>Retorno booleano com base na permissao do movimento</returns>
public bool PermitirRotacionarCabeca(IRobo _robo)
{
var resultado = false;
//Permitir rotacao se a cabeça não estiver inclinada para baixo.
if (!(_robo.Cabeca.Inclinacao == (byte)EnumsRobo.InclinacaoCabeca.ParaBaixo))
{
resultado = true;
}
return(resultado);
}
public IndexModel(IRobo robo,
ICabecaInclinacaoAppServico cabecaInclinacaoAppServico,
ICabecaRotacaoAppServico cabecaRotacaoAppServico,
IPulsoEsquerdoAppServico pulsoEsquerdoAppServico,
IPulsoDireitoAppServico pulsoDireitoAppServico,
ICotoveloEsquerdoAppServico cotoveloEsquerdoAppServico,
ICotoveloDireitoAppServico cotoveloDireitoAppServico)
{
_robo = robo;
_cabecaInclinacaoAppServico = cabecaInclinacaoAppServico;
_cabecaRotacaoAppServico = cabecaRotacaoAppServico;
_pulsoEsquerdoAppServico = pulsoEsquerdoAppServico;
_pulsoDireitoAppServico = pulsoDireitoAppServico;
_cotoveloEsquerdoAppServico = cotoveloEsquerdoAppServico;
_cotoveloDireitoAppServico = cotoveloDireitoAppServico;
}
/// <summary>
/// Método responsável por rotacionar os pulsos do robo.
/// O robô fará o movimento com base no grau de rotação e braço que está fazendo o movimento.
/// </summary>
/// <param name="_robo">Objeto robô que irá rotacionar.</param>
/// <param name="grauRotacao">Valor do grau de rotação que o robô deve rotacionar.</param>
/// <param name="ladoBraco">Identificador de qual braço está realizando o movimento (esquerdo ou direito)</param>
public void RotacionarPulsoRobo(IRobo _robo, int grauRotacao, byte ladoBraco)
{
_robo.BracoEsquerdo.Pulso.Rotacao = 0;
_robo.BracoDireito.Pulso.Rotacao = 0;
switch (ladoBraco)
{
case 1:
{
_robo.BracoEsquerdo.Pulso.Rotacao = grauRotacao;
break;
}
case 2:
{
_robo.BracoDireito.Pulso.Rotacao = grauRotacao;
break;
}
}
}
/// <summary>
/// Método responsável por verificar se o robo pode realizar movimento de contração leve do cotovelo
/// </summary>
/// <param name="_robo">Ojeto robo que será verificado o estado atual do braço</param>
/// <param name="ladoBraco">Parâmetro para identificar qual dos braços (esquerdo ou direito) está sendo verificado.</param>
/// <returns></returns>
public bool PermitirContrairLevementeCotovelo(IRobo _robo, byte ladoBraco)
{
var resultado = false;
byte estadoRobo = 0;
if (ladoBraco == 1)
{
estadoRobo = _robo.BracoEsquerdo.Cotovelo.Estado;
}
if (ladoBraco == 2)
{
estadoRobo = _robo.BracoDireito.Cotovelo.Estado;
}
if ((estadoRobo == (byte)EnumsRobo.Estados.EmRepouso) || (estadoRobo == (byte)EnumsRobo.Estados.Contraido))
{
resultado = true;
}
return(resultado);
}
public PulsoEsquerdoServico(IRobo robo)
: base(robo.BracoEsquerdo.Pulso, (Robo)robo, new PulsoValidacao(), "PulsoEsquerdo")
{
}
/// <summary>
/// Método responsável por inclinar a cabeça do robo. Esta inclinacao pode ser para cima ou para baixo.
/// </summary>
/// <param name="_robo">Objeto robo que receberá o movimento</param>
/// <param name="direcaoInclinacao">Direção da inclinacao. recebe um número que representa a direção. Ver EnumsRobo</param>
public void InclinarCabeca(IRobo _robo, byte direcaoInclinacao)
{
_robo.Cabeca.Inclinacao = 0;
_robo.Cabeca.Inclinacao = direcaoInclinacao;
}
public void Execute(IRobo robo)
{
}
public CotoveloEsquerdoServico(IRobo robo)
: base(robo.BracoEsquerdo.Cotovelo, (Robo)robo, null, string.Empty)
{
}
public ComandosRoboController(IRobo robo)
{
_robo = robo;
}
public MovementService(IRobo <T, U> robot)
{
_robot = robot;
}
/// <summary>
/// Método responsável por colocar a cabeça do robô em repouso.
/// </summary>
/// <param name="_robo"></param>
public void RepousarCabecaRobo(IRobo _robo)
{
_robo.Cabeca.Estado = (byte)EnumsRobo.EstadoCabeca.EmRepouso;
}
public void Execute(IRobo robo)
{
robo.Mover();
}
public CotoveloDireitoServico(IRobo robo)
: base(robo.BracoDireito.Cotovelo, (Robo)robo, null, string.Empty)
{
}
public RoboController(IRobo robo)
{
_robo = robo;
}
public void Execute(IRobo robo)
{
robo.RotacionarDireita();
}
public MarsController(IRobo robo)
{
_robo = robo;
}
/// <summary>
/// Método responsável por realizar rotação da cabeça do robô, com base no grau de rotação designado.
/// </summary>
/// <param name="_robo">Objeto robo para configurar o grau de rotação na cabeça</param>
/// <param name="grauRotacao">Grau de rotação que a cabeça do robô deverá rotacionar</param>
public void RotacionarCabecaRobo(IRobo _robo, int grauRotacao)
{
_robo.Cabeca.Rotacao = 0;
_robo.Cabeca.Rotacao = grauRotacao;
}
public CabecaController(IRobo robo)
{
_robo = robo;
}
public BracoDireitoController(IRobo robo) : base(robo)
{
_robo = robo;
}
public void Execute(IRobo robo)
{
robo.RotacionarEsquerda();
}
public RoboController(IRobo robo, IRegrasRobo regraRobo)
{
_robo = robo;
_regraRobo = regraRobo;
}
public CabecaRotacaoServico(IRobo robo)
: base(robo.Cabeca.CabecaRotacao, (Robo)robo, new CabecaValidacao(), "CabecaRotacao")
{
}
public CabecaInclinacaoServico(IRobo robo)
: base(robo.Cabeca.CabecaInclinacao, (Robo)robo, null, string.Empty)
{
}
public BracoController(IRobo robo)
{
_robo = robo;
}
public PulsoDireitoServico(IRobo robo)
: base(robo.BracoDireito.Pulso, (Robo)robo, new PulsoValidacao(), "PulsoDireito")
{
}
public BracoEsquerdoController(IRobo robo) : base(robo)
{
_robo = robo;
}
