public void start(int indexCena)
{
this.indexCena = indexCena;
fundoGame = new Objects.Objeto2D(Game1.Self.Content.Load <Texture2D>("fundoGame"));
fundoGame.position.X = Game1.Self.Window.ClientBounds.Width / 2;
fundoGame.position.Y = Game1.Self.Window.ClientBounds.Height / 2;
heart = new DumativaHeart.Objects.Heart();
avisoReading = new Objeto2D(Game1.Self.Content.Load <Texture2D>("reading"));
avisoReading.position.X = 500;
avisoReading.position.Y = 425;
avisoFollow = new Objeto2D(Game1.Self.Content.Load <Texture2D>("follow_your_heart"));
avisoFollow.position.X = 500;
avisoFollow.position.Y = 425;
contadorTempo = 600;
Save.lerXml(indexCena);
caixaTexto = new Textbox(800, new Vector2(100, 200), Save.textoAtual, 10, 20);
fontDecisao = Game1.Self.Content.Load <SpriteFont>("fontDecisao");
heart.autoPilot = true;
font = Game1.Self.Content.Load <SpriteFont>("OCR");
line = new Line();
backRender = new RenderTarget2D(Game1.Self.GraphicsDevice, Game1.GameRactangle.Width, Game1.GameRactangle.Height);
}
public override void start()
{
Self = this;
listaStrings = new List <string>();
listaStrings.Add("Hey... are you there?");
listaStrings.Add("It's time to wake up, can you do that?");
listaStrings.Add("I see, you can't do anything right now...");
listaStrings.Add("I will help you then. Press 'A' to control the first beat of your heart.");
listaStrings.Add("Nice! But that is not good enough to wake you up. Press 'S' or 'L' to control the second beat of your heart.");
listaStrings.Add("Awesome! Now is the time. Press 'A' Then Press 'S' or 'L' alternately, in a heartbeat rhythm. That should do it.");
listaStrings.Add("Perfect! I think it's working, soon you will be awake for good. I have one last thing to teach you. It's the most important thing you have to do now before you awake.");
listaStrings.Add("Something is wrong with your body. If the beat is too fast, you will make tense and stressed choices... Try to stress your heart now.. But not too much ! Otherwise you will have a heart attack and well... die.");
listaStrings.Add("Awesome! In the other hand, if the beat is too slow, you will make controlled and sensible choices... Now, Try to calm your heart down. But not too much ! Otherwise you will have a cardiac arrest and also die.");
listaStrings.Add("Perfect! It seems a little tough right now, but you will get used to it. When you see 'Reading' on the screen, you can take your time to read the text. Press 'Enter' when you are done to go to the next step. When you see 'Follow your heart' on the monitor, a decision has to be made. You will have to control your heartbeat.");
listaStrings.Add("Great! You remained calm even with all those news. This is a good Sign!");
listaStrings.Add("Wow! You're already stressed. Calm down my friend! There are a lot of things yet to come. This is just the beginning.");
listaStrings.Add("You're awaking now. I can't help you anymore because of reasons you will not understand. Good Luck and stay alive!");
backRender = new RenderTarget2D(Game1.Self.GraphicsDevice, Game1.GameRactangle.Width, Game1.GameRactangle.Height);
SoundManager.StopMusic();
avisoReading = new Objeto2D(Game1.Self.Content.Load <Texture2D>("reading"));
avisoReading.position.X = 500;
avisoReading.position.Y = 425;
avisoFollow = new Objeto2D(Game1.Self.Content.Load <Texture2D>("follow_your_heart"));
avisoFollow.position.X = 500;
avisoFollow.position.Y = 425;
fundo = new Objects.Objeto2D(Game1.Self.Content.Load <Texture2D>("fundoGame"));
fundo.position.X = Game1.Self.Window.ClientBounds.Width / 2;
fundo.position.Y = Game1.Self.Window.ClientBounds.Height / 2;
heart = new DumativaHeart.Objects.Heart();
line = new Line();
contadorTentativa = 600;
contadorNextTexto = 240;
fraseAtual = 0;
textoLido = false;
filtro = new Objeto2D(Game1.Self.Content.Load <Texture2D>("filtro vermelho"));
//filtro.position.X = Game1.Self.Window.ClientBounds.Width / 2;
//filtro.position.Y = Game1.Self.Window.ClientBounds.Height / 2;
caixaTexto = new Textbox(800, new Vector2(100, 200), listaStrings[fraseAtual], 10, 20);
font = Game1.Self.Content.Load <SpriteFont>("OCR");
fontDecisao = Game1.Self.Content.Load <SpriteFont>("fontDecisao");
}
public override void start()
{
video = Game1.Self.Content.Load <Video>("VideoIntro");
videoPlayer = new VideoPlayer();
videoPlayer.Play(video);
layer = new Objeto2D(videoPlayer.GetTexture());
layer.position.X = Game1.Self.Window.ClientBounds.Width / 2;
layer.position.Y = Game1.Self.Window.ClientBounds.Height / 2;
if (SoundManager.isEffectsMuted)
{
videoPlayer.Volume = 0;
}
}
private void BtnQuadrilatero_Click(object sender, EventArgs e)
{
Quadrilatero quadrilatero = new Quadrilatero();
quadrilatero.Pos = PosAleatorio();
var rnd = new Random(Environment.TickCount);
quadrilatero.Mat_render.CorBorda = new RGBA(255, (byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255));
quadrilatero.Mat_render.CorSolida = new RGBA((byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255), (byte)rnd.Next(0, 255));
quadrilatero.GerarGeometria(rnd.Next(0, 359), raio_padrao, (int)(raio_padrao * 1.5F));
engine2D.AddObjeto(obj_selecionado = quadrilatero);
AtualizarControles(obj_selecionado);
}
private void CboObjeto2D_SelectedIndexChanged(object sender, EventArgs e)
{
if (cboObjeto2D.SelectedValue != null)
{
if (obj_selecionado != null)
{
obj_selecionado.Selecionado = false;
}
AtualizarControles(obj_selecionado = ((Objeto2D)cboObjeto2D.SelectedValue));
obj_selecionado.Selecionado = true;
engine2D.Camera.FocarNoObjeto2D(obj_selecionado);
}
}
private void Form1_KeyDown(object sender, KeyEventArgs e)
{
if (pnScreen.Focused)
{
if (obj_selecionado != null)
{
if (e.KeyCode == Keys.Delete)
{
engine2D.objetos.Remove(obj_selecionado);
obj_selecionado = null;
AtualizarControles(null);
}
}
}
}
public override void start()
{
SoundManager.SetMusic("GameOverSong", true, false, false);
posicao = new Vector2(285, 590);
fundoGameOver = new Objects.Objeto2D(Game1.Self.Content.Load <Texture2D>("fundoGameOver"));
fundoGameOver.position.X = Game1.Self.Window.ClientBounds.Width / 2;
fundoGameOver.position.Y = Game1.Self.Window.ClientBounds.Height / 2;
tracinho = new Objeto2D(Game1.Self.Content.Load <Texture2D>("tracinho"));
tracinho.position = posicao;
contadorDrawUnderline = 0;
contadorMenu = 1;
font = Game1.Self.Content.Load <SpriteFont>("OCR");
}
public void AddObjeto(Objeto2D objeto2d)
{
objeto2d.Id = _id_objeto++;
Objeto2D ambiguo = objetos.Where(x => x.Nome.StartsWith(objeto2d.Nome)).LastOrDefault();
int number = 0;
if (ambiguo != null)
{
int length = objeto2d.Nome.Length;
int.TryParse(ambiguo.Nome.Substring(length), out number);
}
objeto2d.Nome += (++number).ToString("D2");
objetos.Add(objeto2d);
}
public void AddObjeto2D(Objeto2D obj2D)
{
Objeto2D ambiguo = objetos2D.OfType <Objeto2D> ()
.Where(x => x.Nome.StartsWith(obj2D.Nome)).LastOrDefault();
int number = 0;
if (ambiguo != null)
{
int length = obj2D.Nome.Length;
int.TryParse(ambiguo.Nome.Substring(length), out number);
}
obj2D.Nome += (++number).ToString("D2");
objetos2D.Add(obj2D);
obj2D.AssociarEngine(this);
}
public override void start()
{
delay = TimeSpan.FromSeconds(5d);
//SoundManager.SetMusic("GameOverSong", true, false, false);
fundoGameOver = new Objeto2D(Game1.Self.Content.Load <Texture2D>("fundoGame"));
fundoGameOver.position.X = Game1.Self.Window.ClientBounds.Width / 2;
fundoGameOver.position.Y = Game1.Self.Window.ClientBounds.Height / 2;
contadorDrawUnderline = 0;
contadorMenu = 1;
startTime = Game1.currentTime;
font = Game1.Self.Content.Load <SpriteFont>("OCR");
}
static void Main(string[] args)
{
Console.Write("Digite X inicial: ");
int x = int.Parse(Console.ReadLine());
Console.Write("Digite Y inicial: ");
int y = int.Parse(Console.ReadLine());
Objeto2D obj = new Objeto2D();
obj.X = x;
obj.Y = y;
Console.Write("Digite comando: ");
ConsoleKey comando = Console.ReadKey().Key;
while (comando != ConsoleKey.Escape)
{
if (comando == ConsoleKey.RightArrow)
{
obj.MoverParaDireita();
}
else if (comando == ConsoleKey.LeftArrow)
{
obj.MoverParaEsquerda();
}
else if (comando == ConsoleKey.UpArrow)
{
obj.MoverParaCima();
}
else if (comando == ConsoleKey.DownArrow)
{
obj.MoverParaBaixo();
}
Console.WriteLine(obj.Coordenadas());
Console.Write("Digite comando: ");
comando = Console.ReadKey().Key;
}
}
/// <summary>
/// Obtém o objeto 2d através da camera. Utilize X = 0 a Width, Y = 0 a Height
/// </summary>
/// <param name="ponto"></param>
/// <returns></returns>
public static Objeto2D ObterObjeto2DPelaCamera(this Engine2D engine, Camera2D camera, Vetor2D ponto)
{
for (int i = 0; i < engine.objetos.Count; i++)
{
Objeto2D obj = engine.objetos[i];
float xMax = -(camera.Pos.x - camera.ResWidth / 2) + obj.Pos.x + obj.XMax;
float xMin = -(camera.Pos.x - camera.ResWidth / 2) + obj.Pos.x + obj.XMin;
float yMax = -(camera.Pos.y - camera.ResHeigth / 2) + obj.Pos.y + obj.YMax;
float yMin = -(camera.Pos.y - camera.ResHeigth / 2) + obj.Pos.y + obj.YMin;
if (ponto.x >= xMin && ponto.x <= xMax)
{
if (ponto.y >= yMin && ponto.y <= yMax)
{
return(engine.objetos[i]);
}
}
}
return(null);
}
/// <summary>
/// Obtém o objeto 2d através do espaço. Utilize coordenadas existentes em todo o mapa 2D.
/// </summary>
/// <param name="ponto"></param>
/// <returns></returns>
public static Objeto2D ObterObjeto2DPeloEspaco(this Engine2D engine, Vetor2D ponto)
{
for (int i = 0; i < engine.objetos.Count; i++)
{
Objeto2D obj = engine.objetos[i];
float xMax = obj.Pos.x + obj.XMax;
float xMin = obj.Pos.x + obj.XMin;
float yMax = obj.Pos.y + obj.YMax;
float yMin = obj.Pos.y + obj.YMin;
if (ponto.x >= xMin && ponto.x <= xMax)
{
if (ponto.y >= yMin && ponto.y <= yMax)
{
return(engine.objetos[i]);
}
}
}
return(null);
}
public static IEnumerable <Vertice2> ObterVetoresObjeto2DPelaTela(this Camera2D camera, List <Objeto2D> objs, RectangleF rect)
{
#warning Inserir novo sistema que considera angulo e zoom da camera
for (int o = 0; o < objs.Count; o++)
{
Objeto2D obj = objs[o];
for (int i = 1; i < obj.Vertices.Count() + 1; i++)
{
Vertice2 v1, v2;
if (i == obj.Vertices.Count())
{
v1 = obj.Vertices[i - 1];
v2 = obj.Vertices[0];
}
else
{
v1 = obj.Vertices[i - 1];
v2 = obj.Vertices[i];
}
float x1Tela = -(camera.Pos.X - camera.ResWidth / 2) + obj.Pos.X + v1.X;
float y1Tela = -(camera.Pos.Y - camera.ResHeight / 2) + obj.Pos.Y + v1.Y;
float x2Tela = -(camera.Pos.X - camera.ResWidth / 2) + obj.Pos.X + v2.X;
float y2Tela = -(camera.Pos.Y - camera.ResHeight / 2) + obj.Pos.Y + v2.Y;
// Testa se o vetor está colidindo com a região do retângulo
if (Util2D.IntersecaoRetaRetangulo(new Vetor2(x1Tela, y1Tela), new Vetor2(x2Tela, y2Tela), rect))
{
yield return(v1);
yield return(v2);
}
i++; // Próximo vetor
}
}
}
private void AtualizarControles(Objeto2D obj)
{
if (obj != null)
{
cboObjeto2D.SelectedValue = obj;
txtPosX.Text = obj.Pos.x.ToString();
txtPosY.Text = obj.Pos.y.ToString();
txtAngulo.Text = obj.Angulo.ToString();
txtRaio.Text = obj.Raio.ToString();
txtEscalaX.Text = obj.Escala.x.ToString();
txtEscalaY.Text = obj.Escala.y.ToString();
}
else
{
txtPosX.Text = string.Empty;
txtPosY.Text = string.Empty;
txtAngulo.Text = string.Empty;
txtRaio.Text = string.Empty;
txtEscalaX.Text = string.Empty;
txtEscalaY.Text = string.Empty;
}
}
// Calcule a projeção de um polígono em um eixo e retorne-o como um intervalo [min, max]
public void ProjecaoPoligono(Eixos global_eixo, Objeto2D poligono, ref float min, ref float max)
{
// Para projetar um ponto em um eixo, use o produto escalar
float d = global_eixo.Produto(poligono.Vertices[0].Global);
min = d;
max = d;
for (int i = 0; i < poligono.Vertices.Count; i++)
{
d = poligono.Vertices[i].Global.Produto(global_eixo);
if (d < min)
{
min = d;
}
else
{
if (d > max)
{
max = d;
}
}
}
}
public static IEnumerable <Origem2> ObterOrigensObjeto2DPelaTela(this Camera2D cam, List <Objeto2D> objs, params Vertice2[] verticesTela)
{
for (int i = 0; i < verticesTela.Length; i++)
{
// Converte X e Y da tela para as coordenadas X e Y no mundo 2D
Eixos2 xy = ObterPosEspaco2DMouseXY(cam, verticesTela[i]);
verticesTela[i].X = xy.X;
verticesTela[i].Y = xy.Y;
}
for (int o = 0; o < objs.Count; o++)
{
Objeto2D obj = objs[o];
for (int i = 0; i < obj.Origens.Count; i++)
{
Origem2 origem = obj.Origens[i];
if (IntersecaoEntrePoligonos(verticesTela,
new Vertice2(origem.Global.X, origem.Global.Y)))
{
yield return(origem);
}
}
}
}
public ColisaoPoligonoConvexoResultado PoligonoConvexo(
Objeto2D objetoA, Objeto2D objetoB, Vetor2 movimento)
{
ColisaoPoligonoConvexoResultado resultado = new ColisaoPoligonoConvexoResultado();
resultado.Intersecao = true;
resultado.Interceptar = true;
int arestaQuantA = objetoA.Arestas.Count;
int arestaQuantB = objetoB.Arestas.Count;
float minIntervalDistance = float.PositiveInfinity;
Vetor2 EixoTranslacao = new Vetor2();
Vetor2 aresta;
// Loop através de todas as bordas de ambos os polígonos
for (int indiceAresta = 0; indiceAresta < arestaQuantA + arestaQuantB; indiceAresta++)
{
if (indiceAresta < arestaQuantA)
{
aresta = objetoA.Arestas[indiceAresta];
}
else
{
aresta = objetoB.Arestas[indiceAresta - arestaQuantA];
}
// ===== 1. Descobrir se os polígonos estão se cruzando atualmente =====
// Encontre o eixo perpendicular à borda atual
Vetor2 eixo = new Vetor2(objetoA, -aresta.Y, aresta.X);
eixo.Normalizar <Eixos>();
// Encontre a projeção do polígono no eixo atual
float minA = 0; float minB = 0; float maxA = 0; float maxB = 0;
ProjecaoPoligono(eixo, objetoA, ref minA, ref maxA);
ProjecaoPoligono(eixo, objetoB, ref minB, ref maxB);
// Verifique se as projeções de polígono estão se cruzando atualmente
if (DistanciaDoIntervalo(minA, maxA, minB, maxB) > 0)
{
resultado.Intersecao = false;
}
// ===== 2. Agora, encontre os polígonos que irão se *cruzar* =====
// Projetar a velocidade no eixo atual
float velocidadeProjecao = eixo.Produto(movimento);
// Obter a projeção do polígono A durante o movimento
if (velocidadeProjecao < 0)
{
minA += velocidadeProjecao;
}
else
{
maxA += velocidadeProjecao;
}
// Faça o mesmo teste acima para a nova projeção
float distanciaDoIntervalo = DistanciaDoIntervalo(minA, maxA, minB, maxB);
if (distanciaDoIntervalo > 0)
{
resultado.Interceptar = false;
}
// Se os polígonos não estiverem se cruzando e não se cruzarem, saia do loop
if (!resultado.Intersecao && !resultado.Interceptar)
{
break;
}
// Verifique se a distância atual do intervalo é a mínima.
// Em caso afirmativo, armazene a distância do intervalo e a distância atual.
// Isso será usado para calcular o vetor de transladação mínima
distanciaDoIntervalo = Math.Abs(distanciaDoIntervalo);
if (distanciaDoIntervalo < minIntervalDistance)
{
minIntervalDistance = distanciaDoIntervalo;
EixoTranslacao = eixo;
Vetor2 d = new Vetor2(objetoA, (Vetor2)(objetoA.Centro.Global - objetoB.Centro.Global));
if (d.Produto(EixoTranslacao) < 0)
{
EixoTranslacao = -EixoTranslacao;
}
}
}
// O vetor de transladação mínimo pode ser usado para pressionar os polígonos.
// Primeiro move os polígonos pela sua velocidade e, em seguida, move PoligonoA por TransladacaoMinimaVetor.
if (resultado.Interceptar)
{
resultado.TranslacaoMinimaVetor = EixoTranslacao * minIntervalDistance;
}
return(resultado);
}
public Transformacao(Objeto2D obj)
{
this.obj = obj;
}
public static bool IntersecaoEntreDoisPoligonos(Objeto2D a, Objeto2D b)
{
return(IntersecaoEntrePoligonos(
a.Vertices.Select(x => new Vertice2(a.Pos.Global.X, a.Pos.Global.Y)).ToArray(),
b.Vertices.Select(x => new Vertice2(b.Pos.Global.X, b.Pos.Global.Y)).ToArray()));
}
public override void start()
{
background = new Objeto2D(Game1.self.Content.Load<Texture2D>("fundo"));
background.posicao.X = 512;
background.posicao.Y = 384;
backgroundslow = new Objeto2D(Game1.self.Content.Load<Texture2D>("fundoslow"));
backgroundslow.posicao.X = 512;
backgroundslow.posicao.Y = 384;
texture = Game1.self.Content.Load<Texture2D>("coracaovida");
zombie = Game1.self.Content.Load<Texture2D>("Zombie_Tank");
pausedTexture = Game1.self.Content.Load<Texture2D>("pause");
pausedRectangle = new Rectangle(0, 0, 1024, 768);
slowmotionbar = Game1.self.Content.Load<Texture2D>("slowmotionbar");
slowposition = new Vector2(330, 600);
slowRectangle = new Rectangle(0, 0, slowmotionbar.Width, slowmotionbar.Height);
player = new Player(Game1.self.Content.Load<Model>("player"));
InimigoManager.modeloInimigos = Game1.self.Content.Load<Model>("inimigo");
pontos = new Pontos();
TiroManager.Initialize(Game1.self.Content.Load<Model>("player"));
camera = new Camera3D();
random = new Random();
//quantidadeInimigos = 4;
InimigoManager.criarInimigo(quantidadeInimigos);
}