public void Move(Direcao direcao)
{
switch (direcao)
{
case Direcao.Cima:
if (Localizacao.Y - Velocidade >= 0)
Localizacao = new Point(Localizacao.X, Localizacao.Y - Velocidade);
else
Localizacao = new Point(Localizacao.X, 0);
break;
case Direcao.Baixo:
if (Localizacao.Y + Velocidade <= 156)
Localizacao = new Point(Localizacao.X, Localizacao.Y + Velocidade);
else
Localizacao = new Point(Localizacao.X, 156);
break;
case Direcao.Direita:
if (Localizacao.X + Velocidade <= 418)
Localizacao = new Point(Localizacao.X + Velocidade, Localizacao.Y);
else
Localizacao = new Point(418, Localizacao.Y);
break;
case Direcao.Esquerda:
if (Localizacao.X - Velocidade >= 0)
Localizacao = new Point(Localizacao.X - Velocidade, Localizacao.Y);
else
Localizacao = new Point(0, Localizacao.Y);
break;
}
}
public void GirarNaDirecao( Direcao _direcao )
{
if (_direcao == Direcao.CIMA){
GirarParaCima();
} else if (_direcao == Direcao.BAIXO){
GirarParaBaixo();
} else if (_direcao == Direcao.ESQUERDA){
GirarParaEsquerda();
} else {
GirarParaDireita();
}
}
public Cloud(ScreenManager sceneManager)
{
viewport = sceneManager.Game.GraphicsDevice.Viewport;
textura = sceneManager.Game.Content.Load<Texture2D>(@"cloud");
posicao.X = RandomHelper.RandomInt(-startx, viewport.Width);
posicao.Y = RandomHelper.RandomInt(-starty, viewport.Height / 3);
escala = RandomHelper.RandomFloat(0.2f, 0.7f);
velocidade = RandomHelper.RandomFloat(0.01f, 0.07f);
flip = (SpriteEffects)RandomHelper.RandomInt(0, 2);
direcao = (Direcao)RandomHelper.RandomInt(-1, 1);
if (direcao == 0)
direcao = (Direcao)1;
}
public Carro(string placa, Modelo modelo, int ano, int km, Cores cor, Direcao dir, bool freio, bool ar, int capacidade)
{
Placa = placa;
ModeloCarro = modelo;
Ano = ano;
Quilometragem = km;
Cor = cor;
Direcao = dir;
FreioABS = freio;
ArCondicionado = ar;
Capacidade = capacidade;
Alugado = false;
}
private void AtualizaOlhar(float inputHorizontal)
{
// Checa se o Input é pra direita
if (inputHorizontal == 1)
{
// Checa se o olhar NÃO é pra direita, e então muda
if (direcaoOlhar != Direcao.Direita)
{
direcaoOlhar = Direcao.Direita;
transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
}
}
else if (inputHorizontal == -1)
{
// Checa se o olhar NÃO é pra esquerda, e então muda
if (direcaoOlhar != Direcao.Esquerda)
{
direcaoOlhar = Direcao.Esquerda;
transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
}
}
}
private void AtualizarDirecao(float inputHorizontal)
{
// Caso estejamos nos movimentando para direita rotacione para direita (apenas se não estava olhando para lá em primeiro lugar!)
if (inputHorizontal == 1)
{
// Se não estivermos olhando para a direita, gira nosso personagem para a direita e atualiza nosso olharDirecao.
if (direcaoOlhar != Direcao.Direita)
{
transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
direcaoOlhar = Direcao.Direita;
}
}
else if (inputHorizontal == -1)
{
// Se não estivermos olhando para a esquerda, gira nosso personagem a esquerda e atualiza nosso olharDirecao.
if (direcaoOlhar != Direcao.Esquerda)
{
transform.localScale = new Vector3(-transform.localScale.x, transform.localScale.y, transform.localScale.z);
direcaoOlhar = Direcao.Esquerda;
}
}
}
public override void Mover(Peao peao, Tabuleiro tab)
{
if (Sentido == Direcao.Norte)
{
if (peao.Y == 1 && peao.X == 0)
{
Sentido = Direcao.Leste;
}
peao.Y -= 1;
}
else if (Sentido == Direcao.Leste)
{
if (peao.Y == 0 && peao.X == tab.Colunas - 2)
{
Sentido = Direcao.Sul;
}
peao.X += 1;
}
else if (Sentido == Direcao.Sul)
{
if (peao.Y == tab.Linhas - 2 && peao.X == tab.Colunas - 1)
{
Sentido = Direcao.Oeste;
}
peao.Y += 1;
}
else if (Sentido == Direcao.Oeste)
{
if (peao.Y == tab.Linhas - 1 && peao.X == 1)
{
Sentido = Direcao.Norte;
}
peao.X -= 1;
}
}
/*
* * Função responsável por verificar se um movimento
* de touch está sendo feito e manter o controle sobre
* o mesmo.
*
* * É chamada sempre que se deseja capturar algum
* movimento de touch (geralmente em funções Update())
*/
public void atualiza()
{
if (Input.touchCount == 0)
{
encerraMov();
}
else
{
if (!emMovimento)
{
primeiroToque = true;
iniciaMov();
}
}
if (emMovimento)
{
valorInicial = primeiroToque ? Input.GetTouch(0).position.x : valorFinal;
valorFinal = Input.GetTouch(0).position.x;
distancia = calcDistancia(valorInicial, valorFinal);
direcao = valorFinal - valorInicial > 0 ? Direcao.DIREITA : Direcao.ESQUERDA;
primeiroToque = false;
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.tag == "defesa" || collision.tag == "arvore")
{
print(collision.tag);
espera.Add(collision.gameObject);
if (espera.Count == 1)
{
InvokeRepeating("Atacar", 0, 0.5f);
}
andar = false;
attacking = true;
}
else if (collision.gameObject.tag == "seta")
{
Direcao dir = collision.GetComponent <Direcao>();
dire = dir.direction;
an.SetBool("direita", dir.anim == "direita");
an.SetBool("esquerda", dir.anim == "esquerda");
an.SetBool("cima", dir.anim == "cima");
an.SetBool("baixo", dir.anim == "baixo");
}
}
private void criarCaminho(int pos)
{
HashSet <int> rngs = new HashSet <int>();
while (rngs.Count != MAX_DIR)
{
rngs.Add(Random.Range(0, MAX_DIR));
}
foreach (int rng in rngs)
{
Direcao dir = (Direcao)rng;
int destPre = posDestino(pos, dir);
int dest = posDestino(destPre, dir);
if (!possivelAndar(pos, dir) || !casaNaoPisada(dest))
{
continue;
}
marcarCasaPossivel(dest);
marcarCasaPossivel(destPre);
criarCaminho(dest);
}
}
private void MostrarStatusSensor(Direcao direcao)
{
Sensor1_Saida.Fill = RoboAtual.Sensores[0].VerSaida ? Brushes.Blue : Brushes.Red;
Sensor1_Parede.Fill = RoboAtual.Sensores[0].Parede ? Brushes.Blue : Brushes.Red;
Sensor1_Volta.Fill = RoboAtual.Sensores[0].JaPassou ? Brushes.Blue : Brushes.Red;
Sensor2_Saida.Fill = RoboAtual.Sensores[1].VerSaida ? Brushes.Blue : Brushes.Red;
Sensor2_Parede.Fill = RoboAtual.Sensores[1].Parede ? Brushes.Blue : Brushes.Red;
Sensor2_Volta.Fill = RoboAtual.Sensores[1].JaPassou ? Brushes.Blue : Brushes.Red;
Sensor3_Saida.Fill = RoboAtual.Sensores[2].VerSaida ? Brushes.Blue : Brushes.Red;
Sensor3_Parede.Fill = RoboAtual.Sensores[2].Parede ? Brushes.Blue : Brushes.Red;
Sensor3_Volta.Fill = RoboAtual.Sensores[2].JaPassou ? Brushes.Blue : Brushes.Red;
Sensor4_Saida.Fill = RoboAtual.Sensores[3].VerSaida ? Brushes.Blue : Brushes.Red;
Sensor4_Parede.Fill = RoboAtual.Sensores[3].Parede ? Brushes.Blue : Brushes.Red;
Sensor4_Volta.Fill = RoboAtual.Sensores[3].JaPassou ? Brushes.Blue : Brushes.Red;
Decisao_Esq.Fill = direcao == Direcao.Esquerda ? Brushes.Blue : Brushes.Red;
Decisao_Cima.Fill = direcao == Direcao.Cima ? Brushes.Blue : Brushes.Red;
Decisao_Dir.Fill = direcao == Direcao.Direita ? Brushes.Blue : Brushes.Red;
Decisao_Baixo.Fill = direcao == Direcao.Baixo ? Brushes.Blue : Brushes.Red;
}
private Direcao MudaDirecao(Direcao atual, char comando)
{
Direcao NovaDirecao = atual;
if (comando == 'R')
{
NovaDirecao = (Direcao)(((int)atual + 1) % 4);
}
else if (comando == 'L')
{
NovaDirecao = (Direcao)((int)atual - 1);
}
//Quando atual inicia com Cima e vira pra esquerda, o resultado será -1
if (NovaDirecao < 0)
{
NovaDirecao = Direcao.Esquerda;
}
return(NovaDirecao);
}
private float rotacaoNave(Direcao direcao)
{
float rot;
switch (direcao)
{
case Direcao.Direita:
rot = RotDireita;
break;
case Direcao.Esquerda:
rot = RotEsquerda;
break;
case Direcao.Centro:
rot = 0;
break;
default:
rot = 0;
break;
}
return(rot);
}
private int posDestino(int pos, Direcao dir)
{
int ret = pos;
switch (dir)
{
case Direcao.Leste:
ret += ANDAR_LESTE;
break;
case Direcao.Norte:
ret += ANDAR_NORTE;
break;
case Direcao.Oeste:
ret += ANDAR_OESTE;
break;
default: /* Sul */
ret += ANDAR_SUL;
break;
}
return(ret);
}
public void Initialize(
Texture2D walkLeft, Texture2D walkRight,
Texture2D attackLeft, Texture2D attackRight,
Texture2D shurikenLeft, Texture2D shurikenRight, //revisar
SoundEffect espadaSom,
int frameCountWalk, int frameWidthWalk, int frameHeightWalk,
float scaleWalk, int frameCountAttack, int frameWidthAttack, int frameHeightAttack, int frameTimeAttack, float scaleAttack,
int x, int y, int shurikens, int widthScreen)
{
this.walkLeft = walkLeft;
this.walkRight = walkRight;
this.attackLeft = attackLeft;
this.attackRight = attackRight;
this.shurikenLeft = shurikenLeft;
this.shurikenRight = shurikenRight;
this.frameCountWalk = frameCountWalk;
this.scaleWalk = scaleWalk;
this.scaleAttack = scaleAttack;
this.frameWidthWalk = frameWidthWalk;
this.frameHeightWalk = frameHeightWalk;
this.frameWidthAttack = frameWidthAttack;
this.frameHeightAttack = frameHeightAttack;
this.frameTimeAttack = frameTimeAttack;
this.frameCountAttack = frameCountAttack;
this.espadaSom = espadaSom;
this.x = x;
this.y = y;
this.shurikens = shurikens;
this.currentFrameWalk = 0;
this.currentFrameAttack = 0;
this.direcao = Direcao.LeftRight;
this.speed = 3;
this.espada = false;
this.lancements = new List <Shuriken1>();
this.widthScreen = widthScreen;
}
public override void Update(GameTime gameTime)
{
if (!(Game as Main).Started)
{
return;
}
var dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
var keys = Keyboard.GetState().GetPressedKeys();
if (Arma.Municao <= 0)
{
Arma = new CanhaoSimples();
}
if (keys.Contains(Keys.Up))
{
Animation.Start();
Inercia -= Direcao * dt * Aceleracao;
}
else if (keys.Contains(Keys.Down))
{
Inercia += Direcao * dt * Aceleracao / 5;
}
else
{
Animation.Stop().SelectIndex(6);
}
Animation.Update(gameTime);
if (keys.Contains(Keys.Right))
{
Direcao = Direcao.Rotate(0.1f);
}
else if (keys.Contains(Keys.Left))
{
Direcao = Direcao.Rotate(-0.1f);
}
if (Posicao.X > Game.Window.ClientBounds.Width)
{
Posicao = new Vector2(0, Posicao.Y);
}
if (Posicao.X < 0)
{
Posicao = new Vector2(Game.Window.ClientBounds.Width, Posicao.Y);
}
if (Posicao.Y > Game.Window.ClientBounds.Height)
{
Posicao = new Vector2(Posicao.X, 0);
}
if (Posicao.Y < 0)
{
Posicao = new Vector2(Posicao.X, Game.Window.ClientBounds.Height);
}
var angle = -Direcao.Angle();
Bounds.Clear();
Bounds.Add(Posicao);
Bounds.Add(new Vector2(Posicao.X, Posicao.Y - Animation.Source.Height / 2).Rotate(angle, Posicao));
Bounds.Add(new Vector2(Posicao.X - Animation.Source.Width / 2 + 5, Posicao.Y - Animation.Source.Height / 2 + 5).Rotate(angle, Posicao));
Bounds.Add(new Vector2(Posicao.X + Animation.Source.Width / 2 - 5, Posicao.Y - Animation.Source.Height / 2 + 5).Rotate(angle, Posicao));
if (Keyboard.GetState().IsKeyDown(Keys.Space))
{
Arma.Atira(Game, gameTime, new [] { Bounds[2], Bounds[3] }, -Direcao);
}
if (Keyboard.GetState().IsKeyUp(Keys.Space))
{
Arma.Reset();
}
Posicao += Inercia;
var meteoros = Game.Components.OfType <Meteoro>();
// if (meteoros.Any(p => p.Contem(Bounds)))
// (Game as Main).End();
}
public static void Init(Control control, Direcao direcao)
{
Init(control, control, direcao);
}
internal static bool RegistrarTransferenciaDeArquivo(int codigoHistoricoExecucaoProcesso, DateTime dataHoraTransferencia, Direcao direcao, Status status, string caminhoOrigem, string caminhoDestino, string parceiro)
{
bool resultado = false;
string query = "INSERT INTO CONTROLE_INTEGRACAO.PARCEIRO_TRANSFERENCIA_ARQUIVO (CODIGO_HISTORICO_EXECUCAO, ID_PROTOCOLO, DATA_HORA, DIRECAO, STATUS, CAMINHO_ORIGEM, CAMINHO_DESTINO, PARCEIRO) VALUES (:CODIGO_HISTORICO_EXECUCAO, :ID_PROTOCOLO, to_date(:DATA_HORA, 'dd-mm-yyyy HH24:MI:SS'), :DIRECAO, :STATUS, :CAMINHO_ORIGEM, :CAMINHO_DESTINO, :PARCEIRO)";
int IdProtocolo = ObterNumeroProtocolo(codigoHistoricoExecucaoProcesso);
Dictionary <string, string> parametros = new Dictionary <string, string>();
parametros.Add("CODIGO_HISTORICO_EXECUCAO", codigoHistoricoExecucaoProcesso.ToString());
parametros.Add("ID_PROTOCOLO ", IdProtocolo.ToString());
parametros.Add("DATA_HORA", dataHoraTransferencia.ToString());
parametros.Add("DIRECAO", ((char)direcao.GetHashCode()).ToString());
parametros.Add("STATUS", ((char)status.GetHashCode()).ToString());
parametros.Add("CAMINHO_ORIGEM", caminhoOrigem);
parametros.Add("CAMINHO_DESTINO", caminhoDestino);
parametros.Add("PARCEIRO", parceiro);
try
{
int execucao = DatabaseHelper.ExecutarNonQuery(query, parametros);
resultado = execucao > -1 ? true : false;
}
catch (Exception ex)
{
throw ex;
}
return(resultado);
}
public void Vire(Direcao movimento)
{
movimentosExploratorio[movimento].Invoke();
}
public void Change_Room(Vector2 new_pos, Direcao dir)
{
if (!player.can_change_rooms)
{
return;
}
else
{
StartCoroutine(player.Cooldown_Change_Rooms());
}
RoomData next_room = null;
Vector3 offset = Vector2.zero;
switch (dir)
{
case Direcao.UP:
next_room = roomLoader.currentRoom.roomUp;
new_pos = new Vector2(new_pos.x, -new_pos.y);
offset = Vector2.down;
break;
case Direcao.RIGHT:
next_room = roomLoader.currentRoom.roomToTheRight;
new_pos = new Vector2(-new_pos.x, new_pos.y);
offset = Vector2.left;
break;
case Direcao.LEFT:
next_room = roomLoader.currentRoom.roomToTheLeft;
new_pos = new Vector2(-new_pos.x, new_pos.y);
offset = Vector2.left;
break;
case Direcao.DOWN:
next_room = roomLoader.currentRoom.roomDown;
new_pos = new Vector2(new_pos.x, -new_pos.y);
offset = Vector2.down;
break;
}
if (next_room == null)
{
// Debug.Log("Trying to access room " + dir + " but none found.");
return;
}
if (!cleared_rooms.Contains(next_room.name))
{
enemyLoader.Spawn(next_room.levelEnemyData);
}
roomLoader.Unserialize(next_room);
roomLoader.currentRoom = next_room;
Update_Player_New_Room(offset);
foreach (GameObject go in GameObject.FindGameObjectsWithTag("RoomAlteration"))
{
Destroy(go);
}
foreach (GameObject go in GameObject.FindGameObjectsWithTag("Arrow"))
{
StartCoroutine(go.GetComponentInChildren <Projectile>().Destroy());
}
foreach (GameObject go in GameObject.FindGameObjectsWithTag("Trap"))
{
Destroy(go);
}
Enemy.Reset_Frozen();
// Load_Room_Alterations(next_room.id);
}
/// <summary>
/// Posiciona um navio no mapa com a primeira posição dada por X e Y e
/// a direção por d.
///
/// A direção
/// </summary>
/// <param name="tipo">Tipo de navio a ser posicionado</param>
/// <param name="x">Posição X do navio</param>
/// <param name="y">Posição Y do navio</param>
/// <param name="d">Direção do navio.</param>
/// <exception cref="IndexOutOfRangeException">Se o navio sair dos limites do mapa</exception>
/// <exception cref="ArgumentException">Se a direção for inválida</exception>
/// <exception cref="Exception">Se o navio interseccionar com outro ou o tabuleiro já tiver navios demais do tipo passado</exception>
public void PosicionarNavio(TipoDeNavio tipo, int x, int y, Direcao d)
{
if (Contar(tipo) == tipo.Limite())
{
throw new Exception("O tabuleiro já tem navios demais desse tipo");
}
// Determina o incremento na posição X e Y para a direção dada
int ix = 0, iy = 0;
switch ((int)d)
{
case 0:
iy = 1;
break;
case 1:
ix = -1;
break;
case 2:
iy = -1;
break;
case 3:
ix = 1;
break;
default:
throw new ArgumentException("Direção inválida");
}
// Gera as células para o navio
int len = tipo.Tamanho();
Celula[] celulas = new Celula[len];
for (int i = celulas.Length - 1; i >= 0; i--)
{
int nx = x + ix * i, ny = y + iy * i;
if (nx < 0 || nx >= NumeroDeColunas || ny < 0 || ny >= NumeroDeLinhas)
{
throw new Exception("Navio fora do tabuleiro");
}
celulas[i] = new Celula(nx, ny, tipo, null, i == celulas.Length - 1 ? null : celulas[i + 1]);
}
// Define a primeiro célula do navio para cada célula do navio e verifica intersecção
foreach (Celula celula in celulas)
{
celula.PrimeiraDoNavio = celulas[0]; // Define o ponteiro para a primeira célula do navio posicionado
if (this[celula.Linha, celula.Coluna] != null)
{
throw new Exception("Intersecção de navios");
}
}
// Posiciona as células na matriz
foreach (Celula celula in celulas)
{
this[celula.Linha, celula.Coluna] = celula;
}
Navios.Add(new int[] { x, y, (int)d }, tipo);
}
public override void Update(GameTime gameTime)
{
if (pulando)
{
subindo = false;
}
//Calcular a posicao do inimigo
float posicaoX = posicao.X;
if (direcao == Direcao.Esquerda)
{
posicaoX = posicao.X + medidas.X / 3;
}
else
{
posicaoX = Bordas.X - medidas.X / 3;
}
tileX = (int)Math.Floor(posicaoX / Tile.Dimensoes.X);
tileY = (int)Math.Floor(Bordas.Y / Tile.Dimensoes.Y);
//Se estiver numa altura diferente e não estiver numa escada ou pulando, passa a ter ai simples
if (Math.Abs(principal.telaJogo.Personagem.Posicao.Y - posicao.Y) > HitTest.Height + 10 && !subindo && !pulando)
{
inteligencia = IA.Simples;
}
//Se o personagem tiver na tela da água e empurrar 3 ou mais itens na água, os seguranças ficam sempre alertas
//Caso contrário...
if (principal.telaJogo.Personagem.ItensUsados < 3 || !principal.telaJogo.mapa.Caminho.EndsWith("Agua"))
{
//Se estiver numa altura a 800 px de distância, passa a ter IA simples e deixa de ser perseguidor
if (Math.Abs(principal.telaJogo.Personagem.Posicao.Y - posicao.Y) > 800 && !subindo && !pulando)
{
inteligencia = IA.Simples;
perseguidor = false;
}
}
if (inteligencia == IA.Simples)
{
AndarLados(tileX, tileY, gameTime);
}
else if (inteligencia == IA.Perseguir)
{
if (principal.telaJogo.Personagem.Posicao.X < posicao.X)
{
direcao = Direcao.Esquerda;
flip = SpriteEffects.FlipHorizontally;
}
else
{
direcao = Direcao.Direita;
flip = SpriteEffects.None;
}
PerseguirLados(tileX, tileY, gameTime);
PerseguirAcima(tileX, tileY);
}
//Se encostar no persoangem, ele morre
if (principal.telaJogo.Personagem.Animacao.AnimacaoAtual != "null" && !principal.telaJogo.Personagem.Morto && !principal.telaJogo.Derrota && !principal.telaJogo.Pausado)
{
if (HitTest.Intersects(principal.telaJogo.Personagem.HitTest) && !principal.telaJogo.Personagem.Passando)
{
principal.telaJogo.Personagem.morrer();
}
}
//Para de se mover se o jogador perdeu ou se está esperando
if (principal.telaJogo.Derrota || principal.telaJogo.Personagem.Morto || tempoEspera > 0)
{
velocidade.X = 0;
velocidade.Y = 0;
if (!subindo && !pulando)
{
animacao.AnimacaoAtual = "parado";
animacao.iniciarAnimacao();
}
else if (subindo)
{
animacao.pararAnimacao();
}
if (principal.telaJogo.Personagem.Morto)
{
inteligencia = IA.Simples;
perseguidor = false;
}
}
else
{
//caso contrário, se não estiver pulando ou subindo, muda para andar
if (!pulando && !subindo)
{
animacao.AnimacaoAtual = "andando";
animacao.iniciarAnimacao();
}
}
//Ajuste se permanecer parado por um tempo maior que a espera máxima
if (posicaoAnterior == posicao)
{
if (subindo)
{
animacao.pararAnimacao();
}
else
{
animacao.AnimacaoAtual = "parado";
animacao.iniciarAnimacao();
}
tempoParado += (float)gameTime.ElapsedGameTime.TotalSeconds;
if (tempoParado > tempoEsperaMax + 1 || (subindo && tempoParado > tempoEsperaMax / 2))
{
pular();
tempoParado = 0;
}
}
else
{
tempoParado = 0;
}
posicaoAnterior = posicao;
base.Update(gameTime);
}
// Update is called once per frame
void Update()
{
if (gameController.CurrentState == StateMachine.INQUEST)
{
if (executar == true)
{
inputFieldMain.interactable = false;
inputFieldFunc1.interactable = false;
inputFieldFunc2.interactable = false;
switch (direcao)
{
case Direcao.NORTE:
posicaoParado = new Vector2(0, 1);
break;
case Direcao.SUL:
posicaoParado = new Vector2(0, -1);
break;
case Direcao.LESTE:
posicaoParado = new Vector2(1, 0);
break;
case Direcao.OESTE:
posicaoParado = new Vector2(-1, 0);
break;
}
botaoExecutar.gameObject.SetActive(false);
botaoParar.gameObject.SetActive(true);
if (atual == 0)
{
anim.SetBool("andando", andando);
anim.SetFloat("posicaoX", posicaoAndando.x);
anim.SetFloat("posicaoY", posicaoAndando.y);
anim.SetFloat("paradoX", posicaoParado.x);
anim.SetFloat("paradoY", posicaoParado.y);
if (executados[atual] < comandosM.Length)
{
switch (comandosM[executados[atual]])
{
case "Andar()":
Andar();
break;
case "Virar('Esquerda')":
Virar("Esquerda");
break;
case "Virar('Direita')":
Virar("Direita");
break;
case "Func1()":
if (atual == 1)
{
executados[atual] = 0;
}
anteriorF1 = atual;
atual = 1;
break;
case "Func2()":
if (atual == 2)
{
executados[atual] = 0;
}
anteriorF2 = atual;
atual = 2;
break;
case "Pegar()":
if (chegou == true)
{
if (PlayerPrefs.GetInt("ULTIMAFASE") == 1)
{
canvas.GetComponent <UIGamePlay>().EntrarQuest(1);
PlayerPrefs.SetInt("ULTIMAFASE", 2);
}
else if (PlayerPrefs.GetInt("ULTIMAFASE") == 2)
{
canvas.GetComponent <UIGamePlay>().EntrarQuest(2);
PlayerPrefs.SetInt("ULTIMAFASE", 3);
}
else if (PlayerPrefs.GetInt("ULTIMAFASE") == 3)
{
falaFim.SetActive(true);
PlayerPrefs.SetInt("ULTIMAFASE", 4);
}
executar = false;
}
else
{
executados[atual]++;
}
break;
default:
if (atual == 1)
{
executados[atual] = 0;
atual = anteriorF1;
executados[atual]++;
}
else if (atual == 2)
{
executados[atual] = 0;
atual = anteriorF2;
executados[atual]++;
}
else
{
executados[atual]++;
}
break;
}
}
}
}
else
{
transform.position = new Vector3(PlayerPrefs.GetFloat("PosicaoInicialX"), PlayerPrefs.GetFloat("PosicaoInicialY"), PlayerPrefs.GetFloat("PosicaoInicialZ"));
botaoExecutar.gameObject.SetActive(true);
botaoParar.gameObject.SetActive(false);
chegou = false;
executados[0] = 0;
executados[1] = 0;
executados[2] = 0;
inputFieldMain.interactable = true;
inputFieldFunc1.interactable = true;
inputFieldFunc2.interactable = true;
direcao = Direcao.LESTE;
anim.SetBool("andando", false);
anim.SetFloat("paradoX", 1);
anim.SetFloat("paradoY", 0);
}
}
}
private void AtualizarPosicaoDoAviao(int numeroDoJogador, Direcao direcao)
{
switch (direcao)
{
case Direcao.Esquerda:
Jogador[numeroDoJogador].PosicaoDoAviao.X -= VelocidadeAviao;
break;
case Direcao.Direita:
Jogador[numeroDoJogador].PosicaoDoAviao.X += VelocidadeAviao;
break;
case Direcao.Cima:
Jogador[numeroDoJogador].PosicaoDoAviao.Y -= VelocidadeAviao;
break;
case Direcao.Baixo:
Jogador[numeroDoJogador].PosicaoDoAviao.Y += VelocidadeAviao;
break;
default:
break;
}
enviarPosicaoDoAviaoParaClientes(numeroDoJogador);
}
private SalaQuadrada[,] Resolver(int[] tamanho, string caminhoIda, string caminhoVolta)
{
Direcao direcaoAtual = Direcao.Baixo;
SalaQuadrada[,] salao = new SalaQuadrada[tamanho[0], tamanho[1]];
//O eixoX pode ficar negativo, entao soma-se o limite esquerdo, é o eixo inicial em X
int eixoX = tamanho[2];
if (eixoX < 0)
{
eixoX *= -1;
}
int eixoY = 0;
//Não conta o primeiro e ultimo comando, pois é do lado de fora do labirinto
for (int i = 1; i < caminhoIda.Length; i++)
{
if (eixoX == 1 && eixoY == 3)
{
Console.Write("");
}
//Inicializacao
if (salao[eixoX, eixoY] == null)
{
salao[eixoX, eixoY] = new SalaQuadrada();
}
//Primeiro muda a direcao pra saber qual a direcao que ele esta virando
direcaoAtual = MudaDirecao(direcaoAtual, caminhoIda[i]);
if (caminhoIda[i] == 'L')
{
if (direcaoAtual == Direcao.Esquerda)
{
salao[eixoX, eixoY].EsquerdaAberta = true;
}
else if (direcaoAtual == Direcao.Direita)
{
salao[eixoX, eixoY].DireitaAberta = true;
}
else if (direcaoAtual == Direcao.Cima)
{
salao[eixoX, eixoY].AcimaAberta = true;
}
else if (direcaoAtual == Direcao.Baixo)
{
salao[eixoX, eixoY].AbaixoAberta = true;
}
}
else if (caminhoIda[i] == 'R')
{
//Verifica se ele anda depois do R ou faz outro R, se fizer outro R ignora
if (caminhoIda[i + 1] == 'W')
{
if (direcaoAtual == Direcao.Esquerda)
{
salao[eixoX, eixoY].EsquerdaAberta = true;
salao[eixoX, eixoY].AbaixoAberta = false;
salao[eixoX, eixoY].DireitaAberta = false;
}
else if (direcaoAtual == Direcao.Direita)
{
salao[eixoX, eixoY].DireitaAberta = true;
salao[eixoX, eixoY].AcimaAberta = false;
salao[eixoX, eixoY].EsquerdaAberta = false;
}
else if (direcaoAtual == Direcao.Cima)
{
salao[eixoX, eixoY].AcimaAberta = true;
salao[eixoX, eixoY].EsquerdaAberta = false;
salao[eixoX, eixoY].AbaixoAberta = false;
}
else if (direcaoAtual == Direcao.Baixo)
{
salao[eixoX, eixoY].AbaixoAberta = true;
salao[eixoX, eixoY].AcimaAberta = false;
salao[eixoX, eixoY].DireitaAberta = false;
}
}
}
if (caminhoIda[i] == 'W')
{
if (direcaoAtual == Direcao.Esquerda)
{
salao[eixoX, eixoY].EsquerdaAberta = true;
//Salao[eixoX, eixoY].AbaixoAberta = false;
eixoX--;
}
else if (direcaoAtual == Direcao.Direita)
{
salao[eixoX, eixoY].DireitaAberta = true;
//Salao[eixoX, eixoY].AcimaAberta = false;
eixoX++;
}
else if (direcaoAtual == Direcao.Cima)
{
salao[eixoX, eixoY].AcimaAberta = true;
//Salao[eixoX, eixoY].EsquerdaAberta = false;
eixoY--;
}
else if (direcaoAtual == Direcao.Baixo)
{
salao[eixoX, eixoY].AbaixoAberta = true;
//Salao[eixoX, eixoY].DireitaAberta = false;
eixoY++;
}
}
}
//Caminho de volta
//Inverte a direcao
direcaoAtual = MudaDirecao(direcaoAtual, 'R');
direcaoAtual = MudaDirecao(direcaoAtual, 'R');
//Volta pra dentro do labirinto
if (direcaoAtual == Direcao.Esquerda)
{
eixoX--;
}
else if (direcaoAtual == Direcao.Direita)
{
eixoX++;
}
else if (direcaoAtual == Direcao.Cima)
{
eixoY--;
}
else if (direcaoAtual == Direcao.Baixo)
{
eixoY++;
}
//Não conta o primeiro e ultimo comando, pois é do lado de fora do labirinto
for (int i = 1; i < caminhoVolta.Length; i++)
{
if (eixoX == 1 && eixoY == 3)
{
Console.Write("");
}
if (eixoY > -1 && eixoX > -1)
{
//Inicializacao
if (salao[eixoX, eixoY] == null)
{
salao[eixoX, eixoY] = new SalaQuadrada();
}
//Primeiro muda a direcao pra saber qual a direcao que ele esta virando
direcaoAtual = MudaDirecao(direcaoAtual, caminhoVolta[i]);
if (caminhoVolta[i] == 'L')
{
if (direcaoAtual == Direcao.Esquerda)
{
salao[eixoX, eixoY].EsquerdaAberta = true;
}
else if (direcaoAtual == Direcao.Direita)
{
salao[eixoX, eixoY].DireitaAberta = true;
}
else if (direcaoAtual == Direcao.Cima)
{
salao[eixoX, eixoY].AcimaAberta = true;
}
else if (direcaoAtual == Direcao.Baixo)
{
salao[eixoX, eixoY].AbaixoAberta = true;
}
}
else if (caminhoVolta[i] == 'R')
{
//Verifica se ele anda depois do R ou faz outro R, se fizer outro R ignora
if (caminhoVolta[i + 1] == 'W')
{
if (direcaoAtual == Direcao.Esquerda)
{
salao[eixoX, eixoY].EsquerdaAberta = true;
salao[eixoX, eixoY].AbaixoAberta = false;
salao[eixoX, eixoY].DireitaAberta = false;
}
else if (direcaoAtual == Direcao.Direita)
{
salao[eixoX, eixoY].DireitaAberta = true;
salao[eixoX, eixoY].AcimaAberta = false;
salao[eixoX, eixoY].EsquerdaAberta = false;
}
else if (direcaoAtual == Direcao.Cima)
{
salao[eixoX, eixoY].AcimaAberta = true;
salao[eixoX, eixoY].EsquerdaAberta = false;
salao[eixoX, eixoY].AbaixoAberta = false;
}
else if (direcaoAtual == Direcao.Baixo)
{
salao[eixoX, eixoY].AbaixoAberta = true;
salao[eixoX, eixoY].AcimaAberta = false;
salao[eixoX, eixoY].DireitaAberta = false;
}
}
}
if (caminhoVolta[i] == 'W')
{
if (direcaoAtual == Direcao.Esquerda)
{
salao[eixoX, eixoY].EsquerdaAberta = true;
//Salao[eixoX, eixoY].AbaixoAberta = false;
eixoX--;
}
else if (direcaoAtual == Direcao.Direita)
{
salao[eixoX, eixoY].DireitaAberta = true;
//Salao[eixoX, eixoY].AcimaAberta = false;
eixoX++;
}
else if (direcaoAtual == Direcao.Cima)
{
salao[eixoX, eixoY].AcimaAberta = true;
//Salao[eixoX, eixoY].EsquerdaAberta = false;
eixoY--;
}
else if (direcaoAtual == Direcao.Baixo)
{
salao[eixoX, eixoY].AbaixoAberta = true;
//Salao[eixoX, eixoY].DireitaAberta = false;
eixoY++;
}
}
}
else
{
if (eixoY == -1)
{
eixoY = 0;
}
else
{
eixoX = 0;
}
}
}
return(salao);
}
private Direcao MudaDirecao(Direcao atual, char comando)
{
Direcao NovaDirecao = atual;
if (comando == 'R')
NovaDirecao = (Direcao)(((int)atual + 1) % 4);
else if (comando == 'L')
NovaDirecao = (Direcao)((int)atual - 1);
//Quando atual inicia com Cima e vira pra esquerda, o resultado será -1
if (NovaDirecao < 0)
NovaDirecao = Direcao.Esquerda;
return NovaDirecao;
}
private int[] DescobrirTamanho(string caminhoIda, string caminhoVolta)
{
Direcao DirecaoAtual = Direcao.Baixo;
int limiteEsq = 0;
int limiteDir = 0;
int eixoX = 0;
int limiteCima = 0;
int limiteBaixo = 0;
int eixoY = 0;
//Não conta o primeiro e ultimo comando, pois é do lado de fora do labirinto
for (int i = 1; i < caminhoIda.Length - 1; i++)
{
DirecaoAtual = MudaDirecao(DirecaoAtual, caminhoIda[i]);
//Descobre a largura do labirinto
if (caminhoIda[i] == 'W')
{
if (DirecaoAtual == Direcao.Esquerda)
{
eixoX--;
}
else if (DirecaoAtual == Direcao.Direita)
{
eixoX++;
}
else if (DirecaoAtual == Direcao.Cima)
{
eixoY--;
}
else if (DirecaoAtual == Direcao.Baixo)
{
eixoY++;
}
}
//Atualiza os limites
if (eixoX < limiteEsq)
{
limiteEsq = eixoX;
}
if (eixoX > limiteDir)
{
limiteDir = eixoX;
}
if (eixoY < limiteCima)
{
limiteCima = eixoY;
}
if (eixoY > limiteBaixo)
{
limiteBaixo = eixoY;
}
}
//CaminhoVolta
//Inverte a direcao
DirecaoAtual = MudaDirecao(DirecaoAtual, 'R');
DirecaoAtual = MudaDirecao(DirecaoAtual, 'R');
//Não conta o primeiro e ultimo comando, pois é do lado de fora do labirinto
for (int i = 1; i < caminhoVolta.Length - 1; i++)
{
DirecaoAtual = MudaDirecao(DirecaoAtual, caminhoVolta[i]);
//Descobre a largura do labirinto
if (caminhoVolta[i] == 'W')
{
if (DirecaoAtual == Direcao.Esquerda)
{
eixoX--;
}
else if (DirecaoAtual == Direcao.Direita)
{
eixoX++;
}
else if (DirecaoAtual == Direcao.Cima)
{
eixoY--;
}
else if (DirecaoAtual == Direcao.Baixo)
{
eixoY++;
}
}
//Atualiza os limites
if (eixoX < limiteEsq)
{
limiteEsq = eixoX;
}
if (eixoX > limiteDir)
{
limiteDir = eixoX;
}
if (eixoY < limiteCima)
{
limiteCima = eixoY;
}
if (eixoY > limiteBaixo)
{
limiteBaixo = eixoY;
}
}
//+1 pois nao conta o eixo central
int TamanhoX = limiteDir - limiteEsq + 1;
int TamanhoY = limiteBaixo - limiteCima + 1;
return(new int[3] {
TamanhoX, TamanhoY, limiteEsq
});
}
/// <summary>
/// BuscarDataUtil
/// Retorna a data útil anterior ou posterior à 'dataBase'
/// Reversa da função Dt_Data_Util do sistema em Delphi
/// </summary>
public static DateTime BuscarDataUtil(DateTime dataBase, IEnumerable <FeriadoEntidade> feriados, Direcao direcao, Estado?estado)
{
DateTime dtTmp = dataBase;
string estadoTmp;
const string todos = "";
estadoTmp = estado.HasValue ? estado.Value.ToString() : todos;
while (true)
{
if (direcao == Direcao.Posterior)
{
dtTmp = dtTmp.AddDays(1);
}
else
{
dtTmp = dtTmp.AddDays(-1);
}
if (dtTmp.DayOfWeek == DayOfWeek.Sunday)
{
if (direcao == Direcao.Posterior)
{
dtTmp = dtTmp.AddDays(1);
}
else
{
dtTmp = dtTmp.AddDays(-2);
}
}
if (dtTmp.DayOfWeek == DayOfWeek.Saturday)
{
if (direcao == Direcao.Posterior)
{
dtTmp = dtTmp.AddDays(2);
}
else
{
dtTmp = dtTmp.AddDays(-1);
}
}
//Se não for nem feriado local nem feriado estadual, achou a data
var feriado = feriados
.Where((x => (x.DT_FERIADO == dtTmp && x.LOCAL == estadoTmp) || (x.DT_FERIADO == dtTmp && estadoTmp == todos)))
.SingleOrDefault();
if (feriado == null)
{
break;
}
}
return(dtTmp);
}
//Tick do jogo
public void tick2()
{
//Stopwatch para testar performance
Stopwatch st1 = new Stopwatch();
st1.Start();
//Pega as direções armazenadas e joga pra direção atual
if (subDir1 != Direcao.Nenhuma)
{
direction = subDir1;
subDir1 = Direcao.Nenhuma;
}
if (subDir2 != Direcao.Nenhuma)
{
subDir1 = subDir2;
subDir2 = Direcao.Nenhuma;
}
//Move snake para a proxima posição e executa o metodo
if (direction == Direcao.Left)
{
posição.X -= dimension;
moveRect();
}
else
if (direction == Direcao.Right)
{
posição.X += dimension;
moveRect();
}
else
if (direction == Direcao.Up)
{
posição.Y -= dimension;
moveRect();
}
else
if (direction == Direcao.Down)
{
posição.Y += dimension;
moveRect();
}
//Passa por todos os retangulos para mudar sua cor caso mude de tema e mudar o tamanho da Border
PointCollection d = new PointCollection();
for (int i = 0; i < rects.Count; i++)
{
d.Add(new Point(Canvas.GetLeft(rects[i]), Canvas.GetTop(rects[i])));
rects[i].StrokeThickness = i / (double)rects.Count;
if (i == rects.Count - 1)
{
rects[i].StrokeThickness = 1.2;
}
if (rects[i].Fill != rectColor)
{
rects[i].Fill = rectColor;
}
if (rects[i].Stroke != rectStrokeColor)
{
rects[i].Stroke = rectStrokeColor;
}
}
//Caso a cobra bata em si mesma
if (d.Where(l => l == posição).Count() > 1)
{
Canvas.SetZIndex(rects.Last(), int.MaxValue);
rects.Last().Fill = hitColor;
t.Stop();
MessageBox.Show("Nice");
t.Dispose();
return;
}
//Caso saia do quadrado
if (posição.X > 29 * dimension || posição.Y > 29 * dimension || posição.X < 0 || posição.Y < 0)
{
rects.Last().Fill = hitColor;
t.Stop();
MessageBox.Show("Nice");
t.Dispose();
}
//Teste de performance
st1.Stop();
Debug.WriteLine(st1.Elapsed);
}
public string ObterPosicao()
{
return($"({EixoX},{EixoY},{Direcao.ToString()})");
}
//Metodo que adiciona os retangulos da cobra e diz qual é a frente e a direção
public void createBaseRects()
{
rects.Add(refRect(2, 2));
rects.Add(refRect(3, 2));
rects.Add(refRect(4, 2));
rects.Add(refRect(5, 2));
rects.Add(refRect(6, 2));
rects.Add(refRect(7, 2));
rects.Add(refRect(8, 2));
rects.Add(refRect(9, 2));
posição = new Point(9 * dimension, 2 * dimension);
canvas.Children.Add(food);
foreach (var x in rects)
{
canvas.Children.Add(x);
}
direction = Direcao.Right;
}
//Tick do jogo
public void tick2()
{
//Stopwatch para testar performance
Stopwatch st1 = new Stopwatch();
st1.Start();
//Pega as direções armazenadas e joga pra direção atual
if (subDir1 != Direcao.Nenhuma)
{
direction = subDir1;
subDir1 = Direcao.Nenhuma;
}
if (subDir2 != Direcao.Nenhuma)
{
subDir1 = subDir2;
subDir2 = Direcao.Nenhuma;
}
//Move snake para a proxima posição e executa o metodo
if (direction == Direcao.Left)
{
posição.X -= dimension;
moveRect();
}
else
if (direction == Direcao.Right)
{
posição.X += dimension;
moveRect();
}
else
if (direction == Direcao.Up)
{
posição.Y -= dimension;
moveRect();
}
else
if (direction == Direcao.Down)
{
posição.Y += dimension;
moveRect();
}
//Passa por todos os retangulos para mudar sua cor caso mude de tema e mudar o tamanho da Border
PointCollection d = new PointCollection();
for (int i = 0; i < rects.Count; i++)
{
d.Add(new Point(Canvas.GetLeft(rects[i]), Canvas.GetTop(rects[i])));
rects[i].StrokeThickness = i / (double)rects.Count;
if (i == rects.Count - 1)
{
rects[i].StrokeThickness = 1.2;
}
if (rects[i].Fill != rectColor)
{
rects[i].Fill = rectColor;
}
if (rects[i].Stroke != rectStrokeColor)
{
rects[i].Stroke = rectStrokeColor;
}
}
//Caso a cobra bata em si mesma
if (d.Where(l => l == posição).Count() > 1)
{
Canvas.SetZIndex(rects.Last(), int.MaxValue);
rects.Last().Fill = hitColor;
t.Stop();
MessageBox.Show("Snake is kill");
t.Dispose();
return;
}
//Caso saia do quadrado
if (posição.X > 29 * dimension || posição.Y > 29 * dimension || posição.X < 0 || posição.Y < 0)
{
rects.Last().Fill = hitColor;
t.Stop();
MessageBox.Show("Snake is kill");
t.Dispose();
}
//Teste de performance
st1.Stop();
Debug.WriteLine(st1.Elapsed);
}
private void MudarDirecao(Direcao novaDirecao)
{
// TODO: Virar o robô visualmente
DirecaoAtual = novaDirecao;
}
public RotCamera(Transform Obj, Direcao derecao, float rotacao, ref List <IComando> lista)
{
}
public double GetCosDirecao()
{
return(Math.Round(Math.Cos(2 * Constants.PI * (Double.Parse(Direcao.Replace('.', ',')) / 180)), 3));
}
