Codigo FINAL Kane

Carlos Henrique Nascimento
O Game como instrumento de crítica social
Trabalho de conclusão de curso apresentado como

exigência parcial, para a obtenção do grau no curso
de Ciência da Computação, da Universidade de
Franca.
Orientador: Prof. Alysson A. Naves Silva
FRANCA
2012
CÓDIGO
SUMÁRIO
1 CAMERA.cs .....................................................................................................4
2 CASAS.cs...........................................................................................................5
3 CONTROLE.cs................................................................................................10
4 FASE1.cs...........................................................................................................14
5 GAME1.cs........................................................................................................29
6 HUD.cs .............................................................................................................44
7 ITEM.cs............................................................................................................47
8 NPC.cs .............................................................................................................48
9 OBJETO.cs.......................................................................................................55
10 PERSONAGEM.cs..........................................................................................57
11 TV.cs .............................................................................................................65
12 SPRITES.cs......................................................................................................68
4
1. CAMERA.CS
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
namespace Kane_1._0
{
class Camera
{
public float Zoom;
public float Rotation;
public Matrix transform;
public Vector2 Position, Origin;
public float deslocamentoCameraY;
public Camera(Viewport viewport)

{
Zoom = 1;
Rotation = 0;
Position = Vector2.Zero;
deslocamentoCameraY = 0;
//centro da tela
Origin = new Vector2(viewport.Width / 2.0f, viewport.Height / 2.0f);
}
public Matrix cameraTransform(Vector2 parallax)

{
transform = Matrix.CreateTranslation(new Vector3(-Position * parallax,0.0f))*
Matrix.CreateTranslation(new Vector3(-Origin, 0.0f)) *
Matrix.CreateRotationZ(Rotation) *
Matrix.CreateScale(Zoom, Zoom, 1) *
Matrix.CreateTranslation(new Vector3(Origin, 0.0f));
return transform;
}
public void Update(Vector2 pos)

{
KeyboardState k = Keyboard.GetState();
if (k.IsKeyDown(Keys.S))
{
if (deslocamentoCameraY > 50)

deslocamentoCameraY -= 5;
}
else
{
if (deslocamentoCameraY < 100)
5
deslocamentoCameraY += 5;
}
if (k.IsKeyDown(Keys.Up))
{
Zoom += 0.01f;
}
if (k.IsKeyDown(Keys.Down))
{
Zoom -= 0.01f;
}
Position = pos - (Origin + new Vector2(0, deslocamentoCameraY));//A camera
vai centralizar no jogador, o numero dentro do vetor é o offset para deslocar a camera
para os lados
}
}
}
2 CASAS.CS
using System;
using System.Linq;
namespace Kane_1._0
{
class Casas : Sprites
{
public bool entrouNaCasa;
public bool entrouNaCasaSetInteriorFlag; //se as for false, os elementos do
interior nao foram setados, se for true, elas já foram e nao devem ser setados novamente
public bool isFinal = false;
public bool fimDeFase = false;
public int tipo;
public Vector2 posPorta1Exterior;
public Vector2 posPorta2Exterior;
public Vector2 posPorta1Interior;
public Vector2 posPorta2Interior;
public Texture2D texPorta1;
public Texture2D texPorta2;
public Texture2D texPorta1interior;
public List<Sprites> ground; //chao
public List<Sprites> cenario; //demais esprites do cenario que não necessitam de
verificação de colisao
public List<Objetos> walls; //limites onde os personagens podem andar
public List<NPC> inimigo; //inimigos
public List<TV> tv; //tv's
public List<Item> item; //itens
public bool temItem = true;

6
public bool sairPelaSegundaPorta;

public bool entrarPelaSegundaPorta;
public KeyboardState kOld;
public KeyboardState k;
bool menuPause;
public Vector2 posicaoKane;
public SpriteFont tutorial;
SoundEffect portaSom;
SoundEffect itemSom;
SoundEffectInstance itemSomInstance;
public int[] listaCaixas;
int contadorTempoTutorial;
public Casas(Vector2 posicaoExteriorCasa, Texture2D texturaExteriorCasa, float

larguraExteriorCasa, float alturaExteriorCasa, float rotationExteriorCasa, float
layerXExteriorCasa, ContentManager Content)
: base(posicaoExteriorCasa, texturaExteriorCasa, larguraExteriorCasa,
alturaExteriorCasa, rotationExteriorCasa, layerXExteriorCasa)
{
listaCaixas = new int[10];
entrouNaCasa = false;
texPorta1 = null;
ground = new List<Sprites>();
cenario = new List<Sprites>();
walls = new List<Objetos>();
menuPause = false;
tv = new List<TV>();
inimigo = new List<NPC>();
item = new List<Item>();
entrouNaCasaSetInteriorFlag = false;
sairPelaSegundaPorta = false;
entrarPelaSegundaPorta = false;
contadorTempoTutorial = 0;
tipo = -1;
camada = 0.5f;
portaSom = Content.Load<SoundEffect>(@"Audio\porta");
itemSom = Content.Load<SoundEffect>(@"Audio\bateria");
itemSomInstance = itemSom.CreateInstance();
}
public void Update(Personagem kane, GameTime gameTime, HUD Hud)

{
k = Keyboard.GetState();
if(isFinal)
if (kane.corpo().Intersects(cenario[4].corpo()))
fimDeFase = true;
if (!entrouNaCasa)
{
if (texPorta1 != null)
{
if (corpo().Intersects(kane.corpo()) && k.IsKeyDown(Keys.W) &&
kOld.IsKeyUp(Keys.W) && !kane.pulou)
{
if (new Rectangle((int)(posicao.X + posPorta1Exterior.X), (int)
(posicao.Y + (altura - 120) + posPorta1Exterior.Y), 80, 120).Intersects(kane.corpo()))
{
entrouNaCasa = true;
entrarPelaSegundaPorta = false;
portaSom.Play();
}
7
if (new Rectangle((int)(posicao.X + posPorta2Exterior.X),
(int)(posicao.Y + (altura - 120) + posPorta2Exterior.Y), 80,
120).Intersects(kane.corpo()))
{
entrouNaCasa = true;
entrarPelaSegundaPorta = true;
portaSom.Play();
}
}
}
}
else
{
entrouNaCasaSetInteriorFlag = true;
foreach (Objetos ob in walls)

{
for (int i = 0; i < 100; i++)
{
if (ob.Ground == i)
ground[i].posicao = new Vector2(ob.posicao.X, ob.posicao.Y -
4);
}
}
if (k.IsKeyDown(Keys.W) && kOld.IsKeyUp(Keys.W) && !kane.pulou)

{
if (new Rectangle((int)posPorta1Interior.X, (int)
(posPorta1Interior.Y), 80, 120).Intersects(kane.corpo()))
{
sairPelaSegundaPorta = false;
portaSom.Play();
}
{
if (new Rectangle((int)(posPorta2Interior.X), (int)
(posPorta2Interior.Y), 80, 120).Intersects(kane.corpo()))
{
sairPelaSegundaPorta = true;
portaSom.Play();
}
}
}

{
ob.Update(ground, inimigo);
}
foreach (TV t in tv)

{
t.Update(Hud.controle, gameTime);
}
if (t.isTvOn)
foreach (NPC npc in inimigo)
if (t.corpoRs().Intersects(npc.corpoR()) &&
8
npc.tvControladora == null)
npc.tvControladora = t;

{
npc.Update(gameTime, ground);
}
foreach (Item i in item)

{
i.Update();
if(kane.item == 0 && kane.corpo().Intersects(i.corpo()))
{
itemSomInstance.Play();
if (i.tipo <= -1)
{
//kane.item = i.tipo;
i.foiPego = true;
Hud.controle.energia = 10;
}
if (i.tipo >= 1)
{
// kane.item = i.tipo;
i.foiPego = true;
kane.dano = 0;
}
}
}
posicaoKane = kane.posicao;
}
kOld = k;
menuPause = false;
}
public void Draw(SpriteBatch spriteBatch)

{
if (!entrouNaCasa)
{
spriteBatch.Draw(texPorta1, new Rectangle((int)(posicao.X +
posPorta1Exterior.X), (int)(posicao.Y + (altura - 120) + posPorta1Exterior.Y), 95, 158),
null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
if(texPorta2 != null)
spriteBatch.Draw(texPorta2, new Rectangle((int)(posicao.X +
posPorta2Exterior.X), (int)(posicao.Y + (altura - 120) + posPorta2Exterior.Y), 95, 158),
null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
base.Draw(spriteBatch);
}
else
{
{
ob.Draw(spriteBatch);
}
foreach (Sprites c in cenario)

{
c.Draw(spriteBatch);
9

{
npc.Draw(spriteBatch);
}
{
t.Draw(spriteBatch);
}
foreach (Item i in item)

{
i.Draw(spriteBatch);
}
if(texPorta1interior == null)
spriteBatch.Draw(texPorta1, new Rectangle((int)(posPorta1Interior.X),
(int)posPorta1Interior.Y, 95, 158), null, new Color(100, 100, 100, 50), 0, Vector2.Zero,
SpriteEffects.None, 0);
else
spriteBatch.Draw(texPorta1interior, new Rectangle((int)
(posPorta1Interior.X), (int)posPorta1Interior.Y, 95, 158), null, new Color(100, 100,
100, 50), 0, Vector2.Zero, SpriteEffects.None, 0);
spriteBatch.Draw(texPorta2, new Rectangle((int)
(posPorta2Interior.X), (int)posPorta2Interior.Y, 95, 158), null, new Color(100, 100,
100, 50), 0, Vector2.Zero, SpriteEffects.None, 0);
k = Keyboard.GetState();
if (k.IsKeyDown(Keys.Escape) && kOld.IsKeyUp(Keys.Escape))
{
if (menuPause)
menuPause = false;
else
menuPause = true;
}
kOld = k;
}
}
public void resetar()

{
ground.Clear();
cenario.Clear();
walls.Clear();
tv.Clear();
inimigo.Clear();
item.Clear();

walls = new List<Objetos>();
tv = new List<TV>();
inimigo = new List<NPC>();
item = new List<Item>();
}
}
}
10
3 CONTROLE.CS
using System;
usIng System.Collections.Generic;
using System.Linq;
namespace Kane_1._0
{
//Classe responsavel pelo controle de TV.
class Controle
{
//controle
public Vector2[] posicaoBotao; //vetor com a posicao de cada botao
public Texture2D[] texBotao; //vetor com a textura de cada botao
public Color[] corBotao; //vetor com a cor de cada botao
public bool[] botaoPressionado;
public int[] tempoBotaoPressionado;
SoundEffect censor;
public bool luzLigada;
public int tempoLuzPisca;
public int fase = 1;
public int energia; //quantidade de nergia do controle, se chegar a 0, o
controle nao pode ser usado
public int botaoSelecionado;//valor de 0 a 8, que corresponde a qual botao do
controle o jogador apertou
private MouseState mOld;
private GamePadState gOld;
public bool isTvSelected; //o controle so pode ser usado se o jogador tiver
selecionado uma TV para controlar
SoundEffectInstance som_botaoSelecionadoInstance;
SoundEffect som_botaoSelecionado;
public Controle(ContentManager Content)

{
posicaoBotao = new Vector2[11]; // (0-8 botoes do controle) - (9 - base do
controle) - (11 - luz)
texBotao = new Texture2D[11]; // (0-8 botoes do controle) - (9 - base do
controle) - (11 - luz)
corBotao = new Color[9]; // nao eh necessario uma posicao a mais no
vetor para modificar a cor da base do controle
botaoPressionado = new bool[9];
tempoBotaoPressionado = new int[9];
luzLigada = false;
tempoLuzPisca = 0;
som_botaoSelecionado = Content.Load<SoundEffect>(@"Audio\botoesControle");
som_botaoSelecionadoInstance = som_botaoSelecionado.CreateInstance();
censor = Content.Load<SoundEffect>(@"Audio\censor");
criaControle(Content);//funcao que seta todas as propriedades iniciais do

controle
isTvSelected = false;//no inicio, nao existe nenhuma TV selecionada pela
jogador.
11
energia = 10;//energia do controle inicial

botaoSelecionado = -1;
}
public void setCor()
{
for (int i = 0; i < 9; i++)
{
corBotao[i] = Color.White;
//botaoPressionado[i] = false;
}
}
public Rectangle corpo(int i)
{
return new Rectangle((int)posicaoBotao[i].X, (int)posicaoBotao[i].Y,

(int)texBotao[i].Width, (int)texBotao[i].Height);
public void criaControle(ContentManager Content)

{
int posicaoX = 1050,posicaoY = 550;
posicaoBotao[0] = new Vector2(posicaoX+85, posicaoY+26);

texBotao[0] = Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_power");
corBotao[0] = Color.White;
posicaoBotao[1] = new Vector2(posicaoX + 110, posicaoY+76);

texBotao[1] =
Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_avancar");

texBotao[2] =
Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_retroceder");

texBotao[3] = Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_pause");
posicaoBotao[4] = new Vector2(posicaoX +35, posicaoY+115);

texBotao[4] =
Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_retrocederCanal");

texBotao[5] =
Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_avancarCanal");

texBotao[6] = Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_play");

texBotao[7] =
Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_volume+");
12

texBotao[8] =
Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_volume-");
posicaoBotao[9] = new Vector2(posicaoX - 8, posicaoY-10);

texBotao[9] = Content.Load<Texture2D>(@"Sprites\HUD\Controle\baseBotoes1");

texBotao[10] = Content.Load<Texture2D>(@"Sprites\HUD\Controle\botao_luz");
for (int i = 0; i < 9; i++)

{
botaoPressionado[i] = false;
tempoBotaoPressionado[i] = 0;
}
}
public void verificaColisaoBotao()
{
for (int i = 0; i < 9; i++)
{
if (botaoPressionado[i])
tempoBotaoPressionado[i]++;
if (tempoBotaoPressionado[i] > 10)

{
tempoBotaoPressionado[i] = 0;
}
}
if (energia > 0 && isTvSelected)

{
MouseState m = Mouse.GetState();
GamePadState g = GamePad.GetState(PlayerIndex.One);
setCor();
if (corpo(9).Intersects(new Rectangle((int)m.X, (int)m.Y, 5,

5)))//verifica se intersectou com a base do controle
{
for (int i = 0; i < 9; i++)
{
if (fase == 1)
{
//i representa o botão apertado
//para verificar outros botoes deve-se adicionar outras
comparações de igualdade no if abaixo
if (i == 0)
if (corpo(i).Intersects(new Rectangle((int)m.X,
(int)m.Y, 1, 1)))//verifica se intersectou nos botoes
{
corBotao[i] = Color.Gray;
if ((m.LeftButton == ButtonState.Pressed &&
mOld.LeftButton == ButtonState.Released) ||
(g.IsButtonDown(Buttons.RightShoulder)) &&
gOld.IsButtonUp(Buttons.RightShoulder))//verifica se clicou
{
energia--;
botaoPressionado[i] = true;
botaoSelecionado = i;
som_botaoSelecionadoInstance.Play();
13
}
}
else
{
}
}
if (fase == 2)
{
if (i == 0 || i == 7 || i == 8)
if (corpo(i).Intersects(new Rectangle((int)m.X,
(int)m.Y, 1, 1)))//verifica se intersectou nos botoes
{
corBotao[i] = Color.Gray;
if ((m.LeftButton == ButtonState.Pressed &&
mOld.LeftButton == ButtonState.Released) ||
(g.IsButtonDown(Buttons.RightShoulder)) &&
gOld.IsButtonUp(Buttons.RightShoulder))//verifica se clicou
{
energia--;
botaoPressionado[i] = true;
botaoSelecionado = i;
som_botaoSelecionadoInstance.Play();
}
}
else
{
}
}
}
}
mOld = m;
gOld = g;
}
else
{
for (int i = 0; i < 9; i++)
}
public void Update()

{
verificaColisaoBotao();//verifica se o mouse colidiu com algum botao. Esta

verificacao poder ser feita nesta classe pois tanto o mouse quanto o controle estao na
mesma camada de coordenadas.
if(energia>0)
if (isTvSelected)
{
luzLigada = true;
tempoLuzPisca++;
}
14
else
{
luzLigada = false;
tempoLuzPisca = 0;
if (tempoLuzPisca > 70)

{
tempoLuzPisca = 0;
censor.Play(0.2f,0, 0);
}
}

{
spriteBatch.Draw(texBotao[9], corpo(9), null, Color.White, 0, Vector2.Zero,

SpriteEffects.None, 0.01f);
for (int i = 0; i < 9; i++)

if(!botaoPressionado[i])
if(i==0)
spriteBatch.Draw(texBotao[i], corpo(i), null, corBotao[i], 0,
Vector2.Zero, SpriteEffects.None, 0);
if(luzLigada && tempoLuzPisca<10)

spriteBatch.Draw(texBotao[10], corpo(10), null, Color.White, 0,
}
}
}
4 FASE1.CS
using System;
using System.Linq;
namespace Kane_1._0
{
class Fase1
{
public bool setouPrimeiraVez;
public bool isInteriorCasa;
HUD Hud; //interface do jogo (HUD)
15
List<Sprites> ground; //chao

List<Sprites> walls; //paredes
List<Sprites> cenario; //demais esprites do cenario que não necessitam de
verificação de colisão
List<Objetos> caixas; //sprites que necessitam de verificação de colisão
List<Casas> casas; //casas
Camera camera; //Camera 2D
public Personagem kane;//personagem jogavel
Vector2 posOldKane;
public int tipoCasa;
public bool fimDeFase = false;
//Acesso à pasta Content
ContentManager Content;
//Acesso à placa de video
GraphicsDevice graphics;
SpriteFont arial;
Texture2D fundo;
Texture2D indicador;
Personagem oldKane;
publiC bool gameOver = false;
Song snowBreak;
float danoOld;
int energiaOld;
public Fase1(ContentManager contentManager, GraphicsDevice graphics)

{
Content = contentManager;
this.graphics = graphics;
isInteriorCasa = false;
oldKane = new Personagem(Content);
walls = new List<Sprites>();
caixas = new List<Objetos>();
casas = new List<Casas>();
snowBreak = Content.Load<Song>(@"Audio\snowBreak");
//fundo
fundo = Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\background");
cenario.Add(new Sprites(new Vector2(-6000, -530), fundo, fundo.Width,
fundo.Height, 0, 1));
cenario[0].layerY = 0.7f;
cenario.Add(new Sprites(new Vector2(-6000 + fundo.Width, -530), fundo,
fundo.Width, fundo.Height, 0, 1));
cenario.Add(new Sprites(new Vector2(-6001 + fundo.Width * 2, -530), fundo,
//neblina
cenario.Add(new Sprites(new Vector2(-7000, 500),
Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\neblina"), 15000, 500, 0, 1));
//casa 1
casas.Add(new Casas(new Vector2(-4000, 370),
16
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\casa"), 600, 380, 0, 1, Content));

casas[0].texPorta1 =
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\porta");
casas[0].posPorta1Exterior = new Vector2(345, -38);
casas[0].posPorta1Interior = new Vector2(900, 340);
casas[0].tipo = 1;//tipo é a variavel que define como sera o interior da
casa através da funcao setInterior(int tipo)
//casa 2
casas[1].tipo = 2;
//casa 6
casas.Add(new Casas(new Vector2(2000, 290),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\porta2");
casas[2].tipo = 3;
//casa 5
casas[3].tipo = 4;
//casa 3
casas[4].posPorta1Exterior = new Vector2(440,-38);
casas[4].tipo = 5;
//casa 4
casas[5].texPorta1interior =
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\4\portaInterior");
casas[5].tipo = 6;
//casa 7 - policia
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\casa"), 1100, 420, 0, 1,
17
Content));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\porta");
casas[6].tipo = 7;
cenario.Add(new Sprites(new Vector2(-5000, -350),

Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\nuvem3"), 1420, 600, 0, 1.1f));
cenario.Add(new Sprites(new Vector2(500, -350),
cenario.Add(new Sprites(new Vector2(2000, -300),
//casas azul
Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\casasFundo"), 1300, 500, 0, 1.05f));
cenario.Add(new Sprites(new Vector2(600, 120),
//casas sortidas
Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\layer6_h"), 1300, 300, 0, 1.03f));
//muros
Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\muro"), 2000, 130, 0, 1.01f));
18

//chao
ground.Add(new Sprites(new Vector2(-5000, 750),
Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\xao"), 10000, 250, 0, 1));
//limite mapa esquerda

caixas.Add(new Objetos(new Vector2(-4440, 150),
Content.Load<Texture2D>(@"Sprites\Fase1\muroBloqueio"), 90, 300, 0, 1, false, Content));
ground.Add(new Sprites(new Vector2(100, 0),
Content.Load<Texture2D>(@"Sprites\tampaCaixas"), 90, 1, 0, 1));
caixas[0].Ground = 1;
caixas[0].isDesenha = false;
//limite mapa galpao tv velha

caixas.Add(new Objetos(new Vector2(2700, 400),
caixas[1].camada = 0;
//limite mapa policia

caixas.Add(new Objetos(new Vector2(3960, 400),
caixas[2].isDesenha = false;
//instancia camera
camera = new Camera(graphics.Viewport);
Hud = new HUD(Content);
//instancia personagem
kane = new Personagem(Content);
kane.posicao = new Vector2(-4200, 620);//posicao inciail
arial = Content.Load<SpriteFont>(@"Fontes\arial");
setouPrimeiraVez = false;
}
public void interiorCasaUpdate(int tipo, GameTime gameTime)

{
kane.Update(gameTime, casas[tipo - 1].walls, casas[tipo - 1].ground,
casas[tipo - 1].tv, casas[tipo-1].inimigo);
Hud.Update(casas[tipo - 1].tv, kane);

casas[tipo - 1].Update(kane, gameTime, Hud);
//quando o personagem sai da casa

if (!casas[tipo - 1].entrouNaCasa)
{
if ((!casas[tipo - 1].entrarPelaSegundaPorta && casas[tipo -
1].sairPelaSegundaPorta) && tipoCasa ==3)
kane.posicao = posOldKane + (casas[tipo - 1].posPorta2Exterior -
casas[tipo - 1].posPorta1Exterior) + new Vector2(100, -10);
else
if ((casas[tipo - 1].entrarPelaSegundaPorta && !casas[tipo -
1].sairPelaSegundaPorta) && tipoCasa == 3)
kane.posicao = posOldKane + new Vector2((kane.posicao.X -
casas[tipo - 1].largura)+50, -10);
else
19
kane.posicao = posOldKane + new Vector2(100, -10); //aparece à

direita porta (100 de distancia). (-10 é para evitar o bug, que o jogador entra dentro
do xao)
tipo = -1;
}
}
public void interiorCasaDraw(int tipo, SpriteBatch spriteBatch)

{
casas[tipo - 1].Draw(spriteBatch);
}
public void setInterior(int tipo)

{
float largura, altura;
switch (tipo)
{
//casa1
case 1:
largura = 1500;
altura = 500;
//chao
casas[0].ground.Add(new Sprites(new Vector2(500, 500),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\porta"), 500, 10, 0, 1));
//limites para andar esquerda e direita

casas[0].walls.Add(new Objetos(new Vector2(450, 0),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\porta"), 50, altura, 0, 1, true,
Content));
casas[0].walls.Add(new Objetos(new Vector2(largura - 500, 0),
Content));
casas[0].walls[0].isDesenha = casas[0].walls[1].isDesenha = false;
//não desenhar os limites
//inimigo
casas[0].inimigo.Add(new NPC(Content, new Vector2(600, 400), false,
true, SpriteEffects.FlipHorizontally));
casas[0].inimigo[0].camada = 0.001f;
//tv
casas[0].tv.Add(new TV(Content, new Vector2(585, 366), true));
casas[0].tv[0].largura = 80;
casas[0].tv[0].altura = 100;
casas[0].tv[0].vol = 100;
casas[0].tv[0].camada = 0.1f;
//elementos do cenario
casas[0].cenario.Add(new Sprites(new Vector2(-20, -300),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\moldura"), largura+40, altura+325, 0,
1));
casas[0].cenario.Add(new Sprites(new Vector2(550, 380),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\estanteTv"), 150, 120, 0, 1));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\fundoInteriorCasa"), largura, altura, 0,
1));
//a casa não tem nenhum item

casas[0].temItem = false;
20
break;
//casa 2
case 2:
largura = 750;
altura = 500;
casas[1].ground.Add(new Sprites(new Vector2(0, altura),

casas[1].ground[1].canWalk = false;
casas[1].walls.Add(new Objetos(new Vector2(-50, 0),
Content));
casas[1].walls.Add(new Objetos(new Vector2(largura, 0),
Content));
casas[1].inimigo.Add(new NPC(Content, new Vector2(100, 400), true,
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\2\moldura"), largura + 178, altura + 225,
0, 1));
1));
break;
//casa 6
case 3:
largura = 1500;
altura = 900;
Content));
casas[2].walls.Add(new Objetos(new Vector2(largura + 200, 0),
Content));
//passagem
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\pilar"), 100, 100, 0, 1, true,
Content));
casas[2].walls[2].Ground = 1;
//caixa da passagem
21
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\objetoMovel1"), 60, 150, 0, 1, false,

Content));
//caixa centro baixo

Content));
//caixa centro acima

Content));
//chao parte2 - nao pode andar o zumbi do chao

//chao parte1 - nao pode andar o zumbi do chao

//plataforma centro baixo

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\madeiras"), 400, 100, 0, 1));
casas[2].cenario[0].camada = 0.5f;
//plataforma direita
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\spotFolha"), 650, 260, 0, 1));
//inimigo plataforma esquerda

//inimigo plataforma centro baixo
//inimigo plataforma centro acima
//inimigo chao
//tv esquerda
22
//tv direita

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\fundoInteriorCasa"), largura, 600, 0,
1));
//plataforma esquerda
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\pilar2"), 200, 220, 0, 1));
//plataforma centro cima

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\prateleiraVelha"), 370, 300, 0, 1));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\pedras"), 200, 80, 0, 1));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\pedras"), 150, 40, 0, 1));
casas[2].cenario.Add(new Sprites(new Vector2(-350, 300),

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\moldura"), largura + 600, altura - 245,
0, 1));
casas[2].cenario[7].camada = 0;
casas[2].ground.Add(new Sprites(new Vector2(-300, altura),

casas[2].item.Add(new Item(new Vector2(1200, 500),

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\6\lampada"), 50, 50, 0, 1, true, 1));
casas[2].item[0].camada = 0;
break;
//casa 5
case 4:
largura = 1500;
altura = 700;
//paredes
Content));
Content));
casas[3].walls[0].isDesenha = false; casas[3].walls[1].isDesenha =
false;
//inimigos
23

//tvs
casas[3].tv.Add(new TV(Content, new Vector2(700, 200), false));
//caixa 800
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\5\box2"), 90, 80, 0, 1, false, Content));
//chao
casas[3].ground.Add(new Sprites(new Vector2(-150, altura),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\5\porta"),365, 10, 0, 1));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\5\porta"), 635+140, 10, 0, 1));
//plataforma1
//plataforma2
//plataforma 5
//plataforma 6
casas[3].ground.Add(new Sprites(new Vector2(-150, 300),
//plataforma grande superior

//plataforma 4
//fundo
1));
0, 1));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\5\bateria"), 50, 50, 0, 1, true, -1));
24
casas[3].cenario.Add(new Objetos(new Vector2(1000, 100),

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\5\box"), 100, 100, 0, 1, false, Content));
break;
//casa 3
case 5:
//ps: por algum motivo tosco que nunca saberei, as caixas devem ser
instanciadas antes do chao, não sei se isso é uma verdade universal ou somente alguma
maldicao da casa 3
largura = 1000;
altura = 500;
//limites da casa
Content));
Content));
//obejto movel- mesinha

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\3\mesinha"), 90, 50, 0, 1, false,
Content));
casas[4].walls[2].camada = 0.1f;
//objeto imovel - estante

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\3\prateleira"), 90, 160, 0, 1, true,
Content));
//define lugares que os NPCs podem andar

//chao de cima
//tv
25
//inimigo
//moldura
0, 1));
//fundo interior da casa

1));
//estante de tv
// if(!setouPrimeiraVez)
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\3\bateria"), 50, 50, 0, 1, true, -1));
break;
//casa 4
case 6:
largura = 1000;
altura = 500;


Content));
Content));




Content.Load<Texture2D>(@"Sprites\Fase1\Casas\4\estatua"), 75, 210, 0, 1));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\4\mesa"), 80, 60, 0, 1));
26

1));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\4\mesa"), 80, 60, 0, 1));
0, 1));
break;
case 7:
largura = 1000;
altura = 500;

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\porta"), 50, altura, 0, 1, true,
Content));
casas[6].walls.Add(new Objetos(new Vector2(largura, 0),
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\porta"), 50, altura, 0, 1, true,
Content));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\porta"), largura, 10, 0, 1));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\cartaz"), 50, 70, 0, 1));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\pc"), 110, 100, 0, 1));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\fundoInteriorCasa"), largura,
altura, 0, 1));
Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\moldura"), largura+300,
altura+155, 0, 1));

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\Policia\cadeira"), 60, 80, 0, 1));
casas[6].isFinal = true;
break;
}
setouPrimeiraVez = true;
public void Update(GameTime gameTime)

{
if (MediaPlayer.State == MediaState.Stopped)
{
MediaPlayer.Play(snowBreak);
MediaPlayer.Volume = 0.4f;
MediaPlayer.IsRepeating = true;
}
camera.Update(kane.posicao);
27
if (!isInteriorCasa)
{
cenario[5].posicao.X -= 1.5f;
if (cenario[5].posicao.X < -22000)
cenario[5].posicao.X = 5000;
Hud.Update(null, kane);
kane.Update(gameTime, caixas, ground, null, null);
if (caixas[0].velocidade.Y == 0)
ground[1].posicao = new Vector2(caixas[0].posicao.X,
caixas[0].posicao.Y);
if (caixas[1].velocidade.Y == 0)
ground[2].posicao = new Vector2(caixas[1].posicao.X,
caixas[1].posicao.Y);
foreach (Objetos ob in caixas)

{
ob.Update(ground, null);
}
foreach (Casas ca in casas)

{
ca.Update(kane, gameTime, Hud);
}

{
if (ca.entrouNaCasa)
{
isInteriorCasa = true;
tipoCasa = ca.tipo;
oldKane.item = kane.item;
posOldKane = kane.posicao;
danoOld = kane.dano;
energiaOld = Hud.controle.energia;
if (!ca.entrarPelaSegundaPorta)
kane.posicao = ca.posPorta1Interior + new Vector2(0, 70);
else
kane.posicao = ca.posPorta2Interior + new Vector2(0, 70);
// kane.posicao = new Vector2((posOldKane.X - ca.posicao.X),
100);
if (ca.entrouNaCasaSetInteriorFlag == false)
setInterior(tipoCasa);
break;
}
else
}
}
else
{
interiorCasaUpdate(tipoCasa, gameTime);
if (casas[tipoCasa - 1].fimDeFase)
{
MediaPlayer.Stop();
fimDeFase = true;
}
28
}
}
public void Draw(SpriteBatch spriteBatch, bool isRecomecar)

{
if (!isInteriorCasa)
{
//desenha o cenario
foreach (Sprites s in cenario)
{
spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend,
null, null, null, null, camera.cameraTransform(s.layer));
s.Draw(spriteBatch);
spriteBatch.End();
}
//desenha o chao
foreach (Sprites s in ground)
{
null, null, null, null, camera.cameraTransform(s.layer));
s.Draw(spriteBatch);
spriteBatch.End();
}

{
null, null, null, null, camera.cameraTransform(ca.layer));
ca.Draw(spriteBatch);
spriteBatch.End();
}

{
null, null, null, null, camera.cameraTransform(ob.layer));
ob.Draw(spriteBatch);
spriteBatch.End();
}
null, null, null, null, camera.cameraTransform(new Vector2(1, 1)));
kane.Draw(spriteBatch);

{
foreach (Objetos ob2 in caixas)
{
if (ob != ob2)
if (ob.corpo().Intersects(ob2.corpo()))
{
ob.velocidade.X = ob2.velocidade.X = 0;
}
}
}
spriteBatch.End();
}
else
29
{
null, null, null, null, camera.cameraTransform(new Vector2(1, 1)));
interiorCasaDraw(tipoCasa, spriteBatch);
kane.Draw(spriteBatch);
spriteBatch.End();
}
if (kane.morreu)
gameOver = true; ;
Hud.Draw(spriteBatch, camera);
Hud.controle.botaoSelecionado = -1;
spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend, null,

null, null, null, camera.cameraTransform(new Vector2(1, 1)));
spriteBatch.DrawString(arial, "Pressione W para entrar.", new Vector2(-
3700,560), Color.White, 0, Vector2.Zero, 1, SpriteEffects.None, 0.0001f);
spriteBatch.End();
public void restartCasa()

{
casas[tipoCasa-1].resetar();
setInterior(tipoCasa);
if (casas[tipoCasa - 1].temItem)
if (!casas[tipoCasa - 1].item[0].foiPego)
kane.item = 0;
Hud.controle.energia = energiaOld;
kane.dano = danoOld;
if (!casas[tipoCasa - 1].entrarPelaSegundaPorta)
kane.posicao = casas[tipoCasa - 1].posPorta1Interior;
else
kane.posicao = casas[tipoCasa - 1].posPorta2Interior;
}
}
}
5 GAME1.CS
using System;
using System.Linq;
30
namespace Kane_1._0
{
public class Game1 : Microsoft.Xna.Framework.Game

{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Level_1 level_1;
Fase1 fase1;
Fase2 fase2;
bool menuPause;
float tempo =0;
Texture2D cursor;
// Estado do Jogo:
// 0 - Escolha de Idiomas
// 1 - Menu principal
// 2 - fase1 / 21 - encerramento fase1
// 666 - gameOver
public int estado;
//////////////selecao de idioma
Texture2D tvReflexo; //fundo de tela (TV desligada com reflexo do Kane)
Texture2D texPT; //textura lingua pt
Texture2D texEN; //textura lingua en
Vector2 posPT; //posição da textura pt
Vector2 posEN; //posição da textura EN
int indexPT; //0 se a textura pt não estiver selecionada; 1 se
estiver selecionada
int indexEN; //0 se a textura en não estiver selecionada; 1 se
estiver selecionada
float escalaEnter; //escala da frase "Aperter Enter"
bool limiteEscalaEnter; //controla quando a escala da frase "Aperte Enter"
deve aumentar ou diminuir
bool aperteEnter; //0 se o jogador não apertou ENTER, 1 se apertou
//////////////fim selecao idioma
//////////////menu inicial
Video tvMenu;
VideoPlayer videoPlayer;
Texture2D texJogar; //textura jogar
Texture2D texOpcoes; //textura opcoes
Texture2D texCreditos; //textura creditos
Texture2D texSair; //textura sair
int itemSelecionado; //armazena qual opção do menu principal foi
selecionada: (1-JOGAR);(2-OPCÕES);(3-CRÉDITOS);(4-SAIR)
float escalaJogar; //escala da textura jogar, este valor é alterado
quando o mouse está sobre a textura
float escalaOpcoes; //escala da textura opcoes, este valor é alterado
float escalaCreditos; //escala da textura creditos, este valor é alterado
float escalaSair; //escala da textura sair, este valor é alterado
Vector2 posJogar; //posicao da textura jogar
Vector2 posOpcoes; //posicao da textura opcoes
Vector2 posCreditos; //posicao da textura creditos
31
Vector2 posSair; //posicao da textura sair
//estas duas flags são responsáveis por dizer ao jogo quando os submenus devem
ser desenhados.
bool menuOpcao; //true, se o jogador selecionar "OPCÕES" no menu
inicial
bool menuCredito; //true, se o jogador selecionar "CREDITOS" no menu
inicial
//////////////fim menu inicial
MouseState mOld;
KeyboardState kOld;
//////////////menu opcoes
Texture2D texOn_offSom;
Texture2D texOn_offVibra;
Texture2D texVibracao;
Texture2D texSom;
Texture2D texVoltar;
Vector2 posOn_offSom;
Vector2 posOn_offVibra;
Vector2 posVibracao;
Vector2 posSom;
Vector2 posVoltar;
float escalaVoltar;
float escalaOn_offSom;
float escalaOn_offVibra;
bool isOn_offSom;
bool isOn_offVibra;
Rectangle mouse;
//menu pause
Texture2D transparenciaMenuPause;
Texture2D texContinuar;
Texture2D texVoltarMenu;
Texture2D texRecomecar;
Vector2 posContinuar;
Vector2 posVoltarMenu;
Vector2 posRecomecar;
float escalaContinuar;
float escalaVoltarMenu;
float escalaRecomecar;
bool recomecar;
float escalaMenuMin;
float escalaMenuMax;
//creditos
Texture2D creditosKane;
Texture2D voltarCreditos;
//GAMEOVER
Texture2D gameOver;
SoundEffect somTVMenu;
SoundEffect somMenu;
SoundEffectInstance somMenuInstance;
bool tocouAbertura = false;

bool acabouAbertura = false;
//abertura
Video abertura;
32
Video fimFase1;
SpriteFont arial;
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
IsMouseVisible = false;
graphics.PreferredBackBufferWidth = 1280;
graphics.PreferredBackBufferHeight = 720;
estado = 2;
}
protected override void Initialize()

{
somTVMenu = Content.Load<SoundEffect>(@"Audio\tv");
somMenu = Content.Load<SoundEffect>(@"Audio\menu");
somMenuInstance = somMenu.CreateInstance();
cursor = Content.Load<Texture2D>(@"Sprites\cursor");
fase1 = new Fase1(Content, GraphicsDevice);
//fase2 = new Fase2(Content, GraphicsDevice, fase1.kane);
level_1 = new Level_1(Content, GraphicsDevice);
videoPlayer = new VideoPlayer();
videoPlayer.IsLooped = true;
itemSelecionado = -1;
escalaMenuMin = 0.7f;
escalaMenuMax = 1.2f;
menuOpcao = menuCredito = false;
menuPause = false;
recomecar = false;
base.Initialize();
}
protected override void LoadContent()

{
spriteBatch = new SpriteBatch(GraphicsDevice);

creditosKane = texCreditos =
Content.Load<Texture2D>(@"Sprites\Menu\PT\creditos\creditosKane");
tvMenu = Content.Load<Video>(@"Videos\tv_on");
videoPlayer.Play(tvMenu);
arial = Content.Load<SpriteFont>(@"Fontes\arial");
abertura = Content.Load<Video>(@"Videos\abertura");
fimFase1 = Content.Load<Video>(@"Videos\fimFase1");
//////////////selecao de idioma
tvReflexo = Content.Load<Texture2D>(@"Sprites\tv_Reflexo");
texPT = Content.Load<Texture2D>(@"Sprites\linguaPT");
texEN = Content.Load<Texture2D>(@"Sprites\linguaEN");
posPT = new Vector2(300, 180);
posEN = new Vector2(300, 380);
indexEN = 0;
indexPT = 1;
escalaEnter = 0.6f;
limiteEscalaEnter = true;
aperteEnter = false;
//////////////fim selecao idioma
transparenciaMenuPause =
Content.Load<Texture2D>(@"Sprites\Menu\PT\PAUSE\transparenciaMenuPause");
33
texContinuar = Content.Load<Texture2D>(@"Sprites\Menu\PT\PAUSE\continuar");
texVoltarMenu = Content.Load<Texture2D>(@"Sprites\Menu\PT\PAUSE\menu");
texRecomecar = Content.Load<Texture2D>(@"Sprites\Menu\PT\PAUSE\restart");
posContinuar = new Vector2(((Window.ClientBounds.Width / 2) -
texContinuar.Width/8), (Window.ClientBounds.Height / 4)+texContinuar.Height);
posVoltarMenu = new Vector2(((Window.ClientBounds.Width / 2) -
texVoltarMenu.Width / 8), (Window.ClientBounds.Height / 4) + texVoltarMenu.Height +
100);
posRecomecar = new Vector2(((Window.ClientBounds.Width / 2) -
texRecomecar.Width / 8), (Window.ClientBounds.Height / 4) + texRecomecar.Height + 200);
escalaContinuar = escalaVoltarMenu = escalaRecomecar = escalaMenuMin;
gameOver = Content.Load<Texture2D>(@"Sprites\gameOver");
protected override void Update(GameTime gameTime)

{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
mouse = new Rectangle(m.X, m.Y, 1, 1);
if (k.IsKeyDown(Keys.Escape) && kOld.IsKeyUp(Keys.Escape) && estado > 1)

{
if (menuPause)
menuPause = false;
else
menuPause = true;
}
if (!menuPause)
{
switch (estado)
{
//////////////////////ESTADO 0 - SELEÇÃO IDIOMA///////////////////
case 0:
//verifica se o mouse fez interseccao com a bandeira brasil
if (mouse.Intersects(new Rectangle((int)posPT.X, (int)posPT.Y,
(int)texPT.Width / 2, (int)texPT.Height)))
{
if (m.LeftButton == ButtonState.Pressed)
{
escalaEnter = 0.6f;
indexPT = 1;
indexEN = 0;
aperteEnter = true;
}
}
else//verifica se o mouse fez interseccao com a bandeira inglesa
if (mouse.Intersects(new Rectangle((int)posEN.X,
(int)posEN.Y, (int)texEN.Width / 2, (int)texEN.Height)))
{
if (m.LeftButton == ButtonState.Pressed)
{
escalaEnter = 0.6f;
indexPT = 0;
indexEN = 1;
aperteEnter = true;
34
}
}
if (limiteEscalaEnter)
{
escalaEnter += 0.01f;
if (escalaEnter > 1)
limiteEscalaEnter = false;
}
else
{
escalaEnter -= 0.01f;
if (escalaEnter < 0.6f)
limiteEscalaEnter = true;
}
//quando uma lingua é selecionada, carregar as sprites do menu

correspondente
if (aperteEnter || (indexEN != 0 || indexPT != 0))
if (k.IsKeyDown(Keys.Enter))
{
//muda o estado
estado = 1;
if (indexEN == 1)
{
//menu inicial
texJogar =
Content.Load<Texture2D>(@"Sprites\Menu\EN\play");
texOpcoes =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\options");
texCreditos =
Content.Load<Texture2D>(@"Sprites\Menu\EN\credits\credits");
texSair =
Content.Load<Texture2D>(@"Sprites\Menu\EN\quit");
//menu opcoes
texOn_offSom =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\on");
texOn_offVibra =
texSom =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\audio");
texVibracao =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\vibration");
texVoltar =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\back");
}
else
{
//menu inicial
texJogar =
Content.Load<Texture2D>(@"Sprites\Menu\PT\jogar");
texOpcoes =
Content.Load<Texture2D>(@"Sprites\Menu\PT\opcoes\opcoes");
texCreditos =
Content.Load<Texture2D>(@"Sprites\Menu\PT\creditos\creditos");
texSair =
Content.Load<Texture2D>(@"Sprites\Menu\PT\sair");
voltarCreditos =
Content.Load<Texture2D>(@"Sprites\Menu\PT\creditos\VOLTAR");
//menu opcoes
35
texOn_offSom =
Content.Load<Texture2D>(@"Sprites\Menu\PT\opcoes\on");
texOn_offVibra =
Content.Load<Texture2D>(@"Sprites\Menu\PT\opcoes\on");
texSom =
Content.Load<Texture2D>(@"Sprites\Menu\PT\opcoes\audio");
texVibracao =
Content.Load<Texture2D>(@"Sprites\Menu\PT\opcoes\vibracao");
texVoltar =
Content.Load<Texture2D>(@"Sprites\Menu\PT\opcoes\voltar");
}
posJogar = new Vector2((1200 / 2) - (texJogar.Width /

6), 180);
posOpcoes = new Vector2((1200 / 2) - (texOpcoes.Width /
6), 280);
posCreditos = new Vector2((1200 / 2) -
(texCreditos.Width / 6), 480);
posSair = new Vector2((1200 / 2) - (texSair.Width / 6),
580);
escalaJogar = escalaOpcoes = escalaCreditos = escalaSair

= escalaMenuMin;
posSom = new Vector2((1200 / 3), 250);

posVibracao = new Vector2((1200 / 3), 350);
posVoltar = new Vector2((1200 / 2) - (texJogar.Width /
6), 500);
posOn_offSom = new Vector2(800, 250);
posOn_offVibra = new Vector2(800, 360);
isOn_offSom = isOn_offVibra = true;
escalaVoltar = escalaOn_offSom = escalaOn_offVibra =

escalaMenuMin;
somTVMenu.Play(0.1f, 0, 0);
}
break;
//////////////////////FIM - ESTADO 0 - SELEÇÃO
IDIOMA///////////////////
////////////////////////////////////////////////////////////////////
/////////////////////////////////////
//////////////////////ESTADO 1 - MENU PRINCIPAL///////////////////
case 1:
//este if verifica se algum submenu deve ser desenhado, ao invés

do menu principal
//se menuOpcao ou menuCredito forem true, então o menu principal
não será desenhado
if (!menuOpcao && !menuCredito)
{
//verifica se o mouse está selecionando a opcao "JOGAR"

if (mouse.Intersects(new Rectangle((int)posJogar.X -
texJogar.Width / 2, (int)posJogar.Y - texJogar.Height / 2, (int)texJogar.Width,
(int)texJogar.Height)))
{
if(escalaJogar == escalaMenuMin)
somMenu.Play();
36
//aumenta o tamanho da sprite até 50% do seu tamanho

original
escalaJogar += 0.1f;
if (escalaJogar >= escalaMenuMax)
escalaJogar = escalaMenuMax;
//atualiza o tamanho das sprites que não estão sendo

selecionadas pelo mouse
escalaCreditos = escalaOpcoes = escalaSair =
escalaMenuMin;
//verifica se o jogador clicou em "JOGAR"

if (m.LeftButton == ButtonState.Pressed &&
mOld.LeftButton == ButtonState.Released)
itemSelecionado = 1;
}
else
//verifica se o mouse está selecionando a opcao "OPCÕES"
if (mouse.Intersects(new Rectangle((int)posOpcoes.X -
texOpcoes.Width / 2, (int)posOpcoes.Y - texOpcoes.Height / 2, (int)texOpcoes.Width,
(int)texOpcoes.Height)))
{
if (escalaOpcoes == escalaMenuMin)
somMenu.Play();
escalaOpcoes += 0.1f;
if (escalaOpcoes >= escalaMenuMax)
escalaOpcoes = escalaMenuMax;
escalaJogar = escalaCreditos = escalaSair =

escalaMenuMin;

}
else
//verifica se o mouse está selecionando a opcao
"CRÉDITOS"
if (mouse.Intersects(new
Rectangle((int)posCreditos.X - texCreditos.Width / 2, (int)posCreditos.Y -
texCreditos.Height / 2, (int)texCreditos.Width, (int)texCreditos.Height)))
{
if (escalaCreditos == escalaMenuMin)
somMenu.Play();
escalaCreditos += 0.1f;
if (escalaCreditos >= escalaMenuMax)
escalaCreditos = escalaMenuMax;
escalaJogar = escalaOpcoes = escalaSair =

escalaMenuMin;

}
else
//verifica se o mouse está selecionando a opcao
37
"SAIR"
Rectangle((int)posSair.X - texSair.Width / 2, (int)posSair.Y - texSair.Height / 2,
(int)texSair.Width, (int)texSair.Height)))
{
if (escalaSair == escalaMenuMin)
somMenu.Play();
escalaSair += 0.1f;
if (escalaSair >= escalaMenuMax)
escalaSair = escalaMenuMax;
escalaJogar = escalaCreditos = escalaOpcoes

= escalaMenuMin;

else
escalaJogar = escalaCreditos = escalaOpcoes
= escalaSair = escalaVoltar = escalaMenuMin;
}
else
if(menuCredito)
{
if (mouse.Intersects(new Rectangle((int)(posVoltar.X + 150)
- voltarCreditos.Width / 2, (int)(posVoltar.Y + 50) - voltarCreditos.Height / 2,
(int)voltarCreditos.Width, (int)voltarCreditos.Height)))
{
escalaVoltar += 0.1f;
if (escalaVoltar >= escalaMenuMax)
escalaVoltar = escalaMenuMax;

{
menuCredito = false;
estado = 1;
}
}
}
else
//se menu opcao for true, o menu principal não é desenhado.
Em seu lugar, aparecerá o menu opcao
if (menuOpcao)
{
if (mouse.Intersects(new Rectangle((int)posVoltar.X -
texVoltar.Width / 2, (int)posVoltar.Y - texVoltar.Height / 2, (int)texVoltar.Width,
(int)texVoltar.Height)))
{
escalaVoltar += 0.1f;
if (escalaVoltar >= escalaMenuMax)
escalaVoltar = escalaMenuMax;
escalaOn_offSom = escalaOn_offVibra = escalaMenuMin;

38

{
menuOpcao = false;
estado = 1;
}
}
else
Rectangle((int)posOn_offSom.X - texOn_offSom.Width, (int)posOn_offSom.Y -
texOn_offSom.Height / 2, (int)texOn_offSom.Width, (int)texOn_offSom.Height)))
{
escalaOn_offSom += 0.1f;
if (escalaOn_offSom >= escalaMenuMax)
escalaOn_offSom = escalaMenuMax;

{
if (isOn_offSom)
{
isOn_offSom = false;
texOn_offSom =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\off");
}
else
{
isOn_offSom = true;
texOn_offSom =
}
escalaVoltar = escalaOn_offVibra =
escalaMenuMin;
}
else
Rectangle((int)posOn_offVibra.X - texOn_offVibra.Width, (int)posOn_offVibra.Y -
texOn_offVibra.Height / 2, (int)texOn_offVibra.Width, (int)texOn_offVibra.Height)))
{
escalaOn_offVibra += 0.1f;
if (escalaOn_offVibra >= escalaMenuMax)
escalaOn_offVibra = escalaMenuMax;

{
if (isOn_offVibra)
{
isOn_offVibra = false;
texOn_offVibra =
Content.Load<Texture2D>(@"Sprites\Menu\EN\options\off");
}
else
39
{
isOn_offVibra = true;
texOn_offVibra =
}
}
escalaVoltar = escalaOn_offSom =
escalaMenuMin;
}
else
escalaVoltar = escalaOn_offSom =
escalaOn_offVibra = escalaOpcoes = escalaMenuMin;
}
tempo += gameTime.ElapsedGameTime.Milliseconds;
if (tempo > 920)
{
somTVMenu.Play(0.1f,0, 0);
tempo = 0;
}
if (itemSelecionado == 1)
estado = 2;
menuOpcao = true;
menuCredito = true;
this.Exit();
break;
//////////////////////FIM - ESTADO 1 - MENU
PRINCIPAL///////////////////
//////////////////////COMEÇO - ESTADO 2 - FASE1///////////////////

case 2:
//reproduz a abertura somente quando entrar no estado 2 pela

primeira vez
if (!tocouAbertura)
{
videoPlayer.Play(abertura);
tocouAbertura = true;
videoPlayer.IsLooped = false;
}
//verifica se o jogador apertou enter para pular a abertura

if (k.IsKeyDown(Keys.Enter))
videoPlayer.Stop();
//verifica se a abertura ja acabou

if (videoPlayer.State == MediaState.Stopped)
acabouAbertura = true;
//se a abertura ja acabou, começar a primeira fase

if (acabouAbertura)
{
//se terminou a primeira fase, reproduzir o encerramento
if (fase1.fimDeFase)
estado = 21;
else//se não terminou, continuar jogando a primeira fase
40
fase1.Update(gameTime);
//se morreu, game over

if (fase1.gameOver)
estado = 666;
}
break;
//////////////////////FIM - ESTADO 2 - FASE1///////////////////
//////////////////////INICIO - ESTADO 2 - FASE1 -

encerramento///////////////////
case 21:
videoPlayer.IsLooped = false;
videoPlayer.Play(fimFase1);
break;
//////////////////////FIM - ESTADO 2 - FASE1 -
encerramento///////////////////
//////////////////////COMEÇO - ESTADO 3 - FASE2///////////////////

case 3:
if (fase2 == null)
{
fase2 = new Fase2(Content, GraphicsDevice, fase1.kane);
fase2.kane.posicao = new Vector2(-4200, 620);//posicao
inicial
fase2.Hud.controle.fase = 2;
}
if (fase2.terminouFase)
estado = 4;
else
fase2.Update(gameTime);
break;
case -1:
level_1.Update(gameTime);
break;
//////////////////////FIM - ESTADO 3 - FASE2///////////////////
case 666:
break;
}
}
else
{
if (mouse.Intersects(new Rectangle((int)posContinuar.X -
texContinuar.Width / 2, (int)posContinuar.Y - texContinuar.Height / 2,
(int)texContinuar.Width, (int)texContinuar.Height)))
{
escalaContinuar += 0.1f;
if (escalaContinuar >= 1.5f)
escalaContinuar = 1.5f;
escalaVoltarMenu = escalaRecomecar = 1;
if (m.LeftButton == ButtonState.Pressed && mOld.LeftButton ==

41
ButtonState.Released)
{
menuPause = false;
}
}
else
if (mouse.Intersects(new Rectangle((int)posVoltarMenu.X -
texVoltarMenu.Width / 2, (int)posVoltarMenu.Y - texVoltarMenu.Height / 2,
(int)texVoltarMenu.Width, (int)texVoltarMenu.Height)))
{
escalaVoltarMenu += 0.1f;
if (escalaVoltarMenu >= 1.5f)
escalaVoltarMenu = 1.5f;
escalaContinuar = escalaRecomecar = 1;

{
menuPause = false;
menuOpcao = false;
menuCredito = false;
if(estado == 2)
fase1 = new Fase1(Content, GraphicsDevice);
estado = 1;
}
}
else
if (mouse.Intersects(new Rectangle((int)posRecomecar.X -
texRecomecar.Width / 2, (int)posRecomecar.Y - texRecomecar.Height / 2,
(int)texRecomecar.Width, (int)texRecomecar.Height)) && (fase1.isInteriorCasa ||(fase2 !=
null && fase2.isInteriorCasa)))
{
escalaRecomecar += 0.1f;
if (escalaRecomecar >= 1.5f)
escalaRecomecar = 1.5f;
escalaContinuar = escalaVoltarMenu = 1;

{
menuPause = false;
if(estado == 2)
fase1.restartCasa();
if (estado == 3)
fase2.restartCasa();
}
}
else
escalaVoltarMenu = escalaContinuar = escalaRecomecar = 1;
mOld = m;
kOld = k;
base.Update(gameTime);
42
protected override void Draw(GameTime gameTime)

{
GraphicsDevice.Clear(new Color(20, 20, 20));
switch (estado)
{
//////////////////////ESTADO 0 - SELEÇÃO IDIOMA///////////////////
case 0:
spriteBatch.Begin();
spriteBatch.Draw(tvReflexo, Vector2.Zero, Color.White);
spriteBatch.Draw(texPT, new Rectangle((int)posPT.X, (int)posPT.Y,
350, 150), new Rectangle((int)(texPT.Width / 2) * indexPT, 0, (int)texPT.Width / 2,
(int)texPT.Height), Color.White);
spriteBatch.Draw(texEN, new Rectangle((int)posEN.X, (int)posEN.Y,
350, 150), new Rectangle((int)((texEN.Width / 2) * indexEN) - 2, 0, (int)(texEN.Width /
2) - 1, (int)texEN.Height), Color.White);
if (indexEN == 1)
spriteBatch.DrawString(arial, " Press Enter", new Vector2(550,
630), Color.White, 0, new Vector2(40, 20), escalaEnter, SpriteEffects.None, 0);
else
spriteBatch.DrawString(arial, "Pressione Enter", new
Vector2(550, 630), Color.White, 0, new Vector2(50, 20), escalaEnter, SpriteEffects.None,
0);
spriteBatch.End();
break;
//////////////////////FIM - ESTADO 0 - SELEÇÃO IDIOMA///////////////////
////////////////////////////////////////////////////////////////////////
/////////////////////////////////
//////////////////////ESTADO 1 - MENU PRINCIPAL///////////////////
case 1:
Texture2D tex = videoPlayer.GetTexture();

spriteBatch.Draw(tex, Vector2.Zero, Color.White);
if (!menuOpcao && !menuCredito)

{
spriteBatch.Draw(texJogar, posJogar, null, Color.White, 0, new
Vector2(texJogar.Width / 2, texJogar.Height / 2), escalaJogar, SpriteEffects.None, 0);
spriteBatch.Draw(texOpcoes, posOpcoes, null, Color.White, 0, new
Vector2(texOpcoes.Width / 2, texOpcoes.Height / 2), escalaOpcoes, SpriteEffects.None,
0);
spriteBatch.Draw(texCreditos, posCreditos, null, Color.White, 0,
new Vector2(texCreditos.Width / 2, texCreditos.Height / 2), escalaCreditos,
spriteBatch.Draw(texSair, posSair, null, Color.White, 0, new
Vector2(texSair.Width / 2, texSair.Height / 2), escalaSair, SpriteEffects.None, 0);
}
else
if (menuOpcao)
{
spriteBatch.Draw(texSom, posSom, null, Color.White, 0, new
Vector2(texJogar.Width / 2, texJogar.Height / 2), 1, SpriteEffects.None, 0);
spriteBatch.Draw(texVibracao, posVibracao, null,
Color.White, 0, new Vector2(texJogar.Width / 2, texJogar.Height / 2), 1,
43
spriteBatch.Draw(texVoltar, posVoltar, null, Color.White, 0,

new Vector2(texJogar.Width / 2, texJogar.Height / 2), escalaVoltar, SpriteEffects.None,
0);
spriteBatch.Draw(texOn_offSom, posOn_offSom, null,
Color.White, 0, new Vector2(texJogar.Width / 2, texJogar.Height / 2), escalaOn_offSom,
spriteBatch.Draw(texOn_offVibra, posOn_offVibra, null,
Color.White, 0, new Vector2(texJogar.Width / 2, texJogar.Height / 2), escalaOn_offVibra,
}
else
if (menuCredito)
{
spriteBatch.Draw(creditosKane, new Rectangle(250, 90,

640, 520), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, 0);
spriteBatch.Draw(Content.Load<Texture2D>(@"Sprites\Menu\
PT\creditos\VOLTAR"), posVoltar + new Vector2(150, 50), null, Color.White, 0, new
Vector2(texJogar.Width / 2, texJogar.Height / 2), escalaVoltar, SpriteEffects.None, 0);
}
spriteBatch.End();
break;
//////////////////////FIM - ESTADO 1 - MENU PRINCIPAL///////////////////
case 2:
if (acabouAbertura)
fase1.Draw(spriteBatch, menuPause);
else
{
Texture2D tex1 = videoPlayer.GetTexture();
spriteBatch.Draw(tex1, Vector2.Zero, Color.White);
spriteBatch.End();
}
break;
case 21:
if (videoPlayer.State == MediaState.Playing)
{
Texture2D tex2 = videoPlayer.GetTexture();
spriteBatch.Draw(tex2, Vector2.Zero, Color.White);

}
else
spriteBatch.Draw(Content.Load<Texture2D>(@"Sprites\obrigado"),
new Vector2(50, 400), null, Color.White, 0, Vector2.Zero, 1, SpriteEffects.None, 0);
spriteBatch.End();
break;
case 3:
if(fase2 != null)
fase2.Draw(spriteBatch, menuPause);
break;
case -1:
level_1.Draw(spriteBatch);
44
break;
case 666:
spriteBatch.Draw(gameOver, new Vector2(0, 0), null, Color.White, 0,
Vector2.Zero, 1, SpriteEffects.None, 0);
spriteBatch.End();
break;
}
if (menuPause && estado > 1)

{
spriteBatch.Draw(transparenciaMenuPause, Vector2.Zero, new Rectangle(0,
0, Window.ClientBounds.Width, Window.ClientBounds.Height), new Color(0, 0, 0, 130), 0,
Vector2.Zero, 1, SpriteEffects.None, 1);
spriteBatch.Draw(transparenciaMenuPause, new
Vector2(Window.ClientBounds.Width / 4,Window.ClientBounds.Height / 4), new Rectangle(0,
0, Window.ClientBounds.Width / 2, Window.ClientBounds.Height / 2), new Color(0, 0, 0,
255), 0, Vector2.Zero, 1, SpriteEffects.None, 1);
spriteBatch.Draw(texContinuar, posContinuar, null, Color.White, 0, new
Vector2(texContinuar.Width / 2, texContinuar.Height / 2), escalaContinuar,
spriteBatch.Draw(texVoltarMenu, posVoltarMenu, null, Color.White, 0, new
Vector2(texVoltarMenu.Width / 2, texVoltarMenu.Height / 2), escalaVoltarMenu,
spriteBatch.Draw(texRecomecar, posRecomecar, null, Color.White, 0, new
Vector2(texRecomecar.Width / 2, texRecomecar.Height / 2), escalaRecomecar,
spriteBatch.End();
}
spriteBatch.Draw(cursor, new Vector2 (mouse.X, mouse.Y), null ,Color.White,
0, Vector2.Zero, 0.5f, SpriteEffects.None, 0);
spriteBatch.End();
base.Draw(gameTime);
}
}
}
6 HUD.CS
using System;
using System.Linq;
//Classe HUD é a interface mostrada na tela durante o jogo.(ex: Barra de energia,

controle remoto, etc)
//As coordenadas das posições na Classe HUD(coordenadas da Tela) são diferentes das
coordenadas das outras classes(coordenadas do Mundo)
//isto se deve ao fato de que, tudo que estiver dentro da classe HUD, não sofre efeito
das layers usadas para o parallas scrolling.
//Logo, para cada camada do parallax scrolling, temos planos de coordenadas diferentes.
//HUD é a camada 0, que não sofre efeito do parallax. O resto do jogo ocorre na segunda
45
camada do parallax(colisões, movimentos, etc).

//As demais camadas de parallax podem ser desconsideradas pois só serão usadas para
construir o cenário, ou seja, nenhuma colisão é feita.
namespace Kane_1._0
{
class HUD
{
public float camada;
//Controle remoto
public Controle controle;
//Barra de energia
public Texture2D barraEnergiaTex; //textura da barra de energia
public Texture2D barraEnergiaCapaTex;
public Vector2 barraEnergiaPos; //posição da barra de energia
public Texture2D breuCircunferencia;
public Texture2D breuRetangulo;
SpriteFont arial;
int score;
public float escala;
public float danoP;
public HUD(ContentManager Content)

{
controle = new Controle(Content);
//instancia controle
escala = 1.8f;
breuCircunferencia = Content.Load<Texture2D>(@"Sprites\HUD\breuCircu");
breuRetangulo = Content.Load<Texture2D>(@"Sprites\HUD\breuRetan");
barraEnergiaCapaTex = Content.Load<Texture2D>(@"Sprites\HUD\capaEnergia");
barraEnergiaTex =
Content.Load<Texture2D>(@"Sprites\HUD\barraEnergia");//carrega a textura da barra de
energia
barraEnergiaPos = new Vector2(45, -5);
//posicao da barra de energia, nas coordenadas do HUD
camada = 0.4f;
public void Update(List<TV> t, Personagem p)

{
danoP = p.dano;
controle.Update();//atualiza controle
//variavel flag para sinalizar se o controle deve ou nao ser ativado nesta
iteracao
//o controle so eh ativado quando o personagem entra no raio da tv
//o FOR abaixo verifica se esta colisao ocorreu. Se ela ocorrer a flag eh
acionada
//e o controle deve ser ativado nesta iteracao
bool ativarControle = false;
//percorre a lista de TVs para verificar quais TVs estao no raio de alcance
do personagem
if(t != null)
foreach (TV tv in t)
{
//verifica se a TV tv esta no raio de alcance do personagem
if (tv.corpoRb().Intersects(p.corpoRs()))//se a tv esta no alcance do
personagem:
46
{
controle.isTvSelected = true;//ativa o controle
ativarControle = true; //aciona a variavel flag
tv.corTV = Color.White; //muda a cor da TV para branco
tv.ativa = true; //seleciona a tv
}
else//se a tv não esta no raio de alcance do controle
{
tv.ativa = false; // tv fica desativada
tv.corTV = Color.Gray; // muda para a cor cinza
}
}
//verifica a variavel flag para saber se deve desativar o controle

if (!ativarControle)
controle.isTvSelected = false;
}
public void Draw(SpriteBatch spriteBatch, Camera camera)

{
//paralax eh o vetor Vector2.Zero, pois tudo for desenhado no HUD deve
permanecer com a posicao estatica em relacao a posicao do mundo
spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend, null,
null, null, null, camera.cameraTransform(new Vector2(0, 0)));
if (danoP > 550)

danoP = 550;
if (danoP > 0)
{
spriteBatch.Draw(breuCircunferencia, new Vector2(650, 450), null,
Color.White, 0, new Vector2(breuCircunferencia.Width / 2, breuCircunferencia.Height /
2), 1.8f - (danoP * 0.003f), SpriteEffects.None, camada);
if (danoP > 300)
{
if (danoP > 500)

{
spriteBatch.Draw(breuRetangulo, new Rectangle(-200, 0, (int)
(danoP+150), 720), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
spriteBatch.Draw(breuRetangulo, new Rectangle(0, -250, 1280,
(int)danoP +50), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
spriteBatch.Draw(breuRetangulo, new Rectangle(1480 - (int)danoP-
150, -100, (int)danoP, 820), null, Color.White, 0, Vector2.Zero, SpriteEffects.None,
camada);
spriteBatch.Draw(breuRetangulo, new Rectangle(0, 1150 -
(int)danoP-50, 1280, (int)danoP), null, Color.White, 0, Vector2.Zero,
SpriteEffects.None, camada);
}
else
{
spriteBatch.Draw(breuRetangulo, new Rectangle(-200, 0, (int)
(danoP), 720), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
spriteBatch.Draw(breuRetangulo, new Rectangle(0, -250, 1280,
(int)danoP), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
spriteBatch.Draw(breuRetangulo, new Rectangle(1480 - (int)danoP,
-100, (int)danoP, 820), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, camada);
spriteBatch.Draw(breuRetangulo, new Rectangle(0, 1150 -
(int)danoP, 1280, (int)danoP), null, Color.White, 0, Vector2.Zero, SpriteEffects.None,
camada);
}
}
47
//desenha o controle
controle.Draw(spriteBatch);
//desenha a barra de energia

//O tamanho da barra de energia diminui de acordo com o uso do controle.
//controle.energia contem um numero inteiro correspondente a quantidade de
energia restante
//este numero eh multiplicado por um valor que representa
spriteBatch.Draw(barraEnergiaCapaTex, new Rectangle((int)0, (int)0,
(int)300, 100), null, Color.White, 0, Vector2.Zero, SpriteEffects.None, 0);
spriteBatch.Draw(barraEnergiaTex, new Rectangle((int)barraEnergiaPos.X,
(int)barraEnergiaPos.Y, (int)(20 * controle.energia), 20), null, Color.White, 0,
Vector2.Zero, SpriteEffects.None, 0.00000001f);//desenha a barra de energia. A largura
do retangulo desenhado diminui sempre que o jogador usar um botao do controle
spriteBatch.End();
}
}
}
7 ITEM.CS
using System;
using System.Linq;
namespace Kane_1._0
{
class Item : Sprites
{
//se for menor ou igual a -1 é uma bateria - a bateria recarregar o controle
//se for maior ou igual a 1 é uma lampada - a lampada limpa o "breu" da tela
//o jogador pode carrregar o item para qualquer lugar e usar quando quiser,
porém, só ele só pode carregar 1 item.
public int tipo;
//se o item foi pego pelo personagem é true
public bool foiPego;
int variacao;
Vector2 posicaoInicial;
bool subir;
public Item(Vector2 posicao, Texture2D textura, float largura, float altura,

float rotation, float layerX, bool isStatic, int tipo)
: base(posicao, textura, largura, altura, rotation, layerX)
{
this.tipo = tipo;
foiPego = false;
48
posicaoInicial = posicao;
subir = true;
variacao = 5;
camada = 0.001f;
}
public void Update()

{
if (!foiPego)
{
if (posicao.Y < posicaoInicial.Y - variacao)
subir = false;
if (posicao.Y > posicaoInicial.Y + variacao)

subir = true;
if(!subir)
posicao.Y += 0.1f;
else
posicao.Y -= 0.1f;
}
}

{
if (!foiPego)
base.Draw(spriteBatch);
}
}
}
8 NPC.CS
using System;
using System.Linq;
namespace Kane_1._0
{
class NPC : Sprites
{
public bool isWalker;
public bool isOnTheGround;
public bool isZombie;
public bool isMen;
public float gravidade;
public int velo;
public int qtdFrames = 0;
public ContentManager Content;
public SpriteEffects direcao;
49
public TV tvControladora;//todo zumbi é afetado por uma tv
//public Vector2 velocidadePause;
public NPC(ContentManager Content, Vector2 posicao, bool isWalker, bool isMen,

SpriteEffects direcao)
: base()
{
velo = 3;
this.Content = Content;
this.largura = 50;
this.altura = 90;
this.isWalker = isWalker;
this.isZombie = isZombie;
this.direcao = direcao;
this.isMen = isMen;
if (isMen)
{
if (isWalker)
if (isZombie)
this.textura =
Content.Load<Texture2D>(@"Sprites\Fase1\NPCs\ZumbiWalker");
else
this.textura =
Content.Load<Texture2D>(@"Sprites\Fase1\NPCs\HomemWalker");
else
if (isZombie)
this.textura =
Content.Load<Texture2D>(@"Sprites\Fase1\NPCs\ZumbiSeguidor");
else
this.textura =
Content.Load<Texture2D>(@"Sprites\Fase1\NPCs\HomemSeguidor");
}
else
if (isWalker)
if (isZombie)
this.textura =
else
this.textura =
else
if (isZombie)
this.textura =
else
this.textura =
Content.Load<Texture2D>(@"Sprites\Fase1\NPCs\Mulher");
this.posicao = posicao;
gravidade = 1;
if(direcao == SpriteEffects.None)
velocidade = new Vector2(velo, gravidade); //gravidade
else
velocidade = new Vector2(-velo, gravidade); //gravidade
isOnTheGround = false;//deve ser falso pois os zumbis nascem no "ar" e deve
cair no chao
currentFrameX = 0;
50
timeSinceLastFrame = 0;
millisecondsPerFrame = 120;
tvControladora = null;
camada = 0.01f;
public void Update(GameTime gameTime, List<Sprites> sprites)

{
movimento(sprites);
//só faz a animação se o botao pause não for precionado

//para verificar se o botao pause esta precionado, tvControladora não pode
ser null, porem tvControladora sempre é null quando isZombie é false, por isso é preciso
verificar se (|| !isZombie)
if ((tvControladora != null && !tvControladora.pause) || !isZombie)
{
////////////////animação///////////////////
timeSinceLastFrame += (int)gameTime.ElapsedGameTime.Milliseconds;
if (timeSinceLastFrame > millisecondsPerFrame)
{
currentFrameX++;
}
if (currentFrameX == 10)
currentFrameX = 0;
////////////////////////////////////////////
}
////////////////////////CODIGO A///////////////////////////
//- verifica se o inimigo esta sendo afetado por uma TV
if (tvControladora != null)
{
if (isMen)
{
if (!isZombie)
{
isZombie = true;//transforma em zumbi
if (isWalker)
this.textura =
else
this.textura =
}
}
}
else
{
if (isMen)
{
if (isZombie)
{
isZombie = false;//transforma em pessoa
if (isWalker)
this.textura =
else
this.textura =
51
Content.Load<Texture2D>(@"Sprites\Fase1\NPCs\HomemSeguidor");
}
}
}
/////////////////////////////FIM A/////////////////////////////////
//atualiza posicao
posicao += velocidade;
//este trexo é para que o inimigo só obedeca a UMA tv de cada vez.

//isto permite que varias TV sejam ligadas, porem a unica que ira
influenciar o zumbi vai ser a primeira tv que foi ligada.
if (tvControladora != null && (!tvControladora.isTvOn || !
corpo().Intersects(tvControladora.corpo())))
tvControladora = null;
}
override public void Draw(SpriteBatch spriteBatch)

{
//desenha pessoa
if (!isZombie)
{
if (isWalker)
{
if (isMen)
{
currentFrameX = 0;
spriteBatch.Draw(textura, corpo(), new Rectangle((int)
(textura.Width / 5) * currentFrameX, 0, (int)(textura.Width / 5), (int)textura.Height),
Color.White, 0, Vector2.Zero, direcao, camada);
}
}
else
{
if (isMen)
{
currentFrameX = 0;
((textura.Width / 7) * currentFrameX) - 1, 0, (int)(textura.Width / 7),
(int)textura.Height), Color.White, 0, Vector2.Zero, direcao, camada);
}
else
(((textura.Width / 10) * currentFrameX) + 0.7f), 0, (int)(textura.Width / 10),
}
}
else//desenha zumbi
{
if (isWalker)
{
currentFrameX = 0;
spriteBatch.Draw(textura, corpo(0, 0, 70, 90), new

Rectangle((int)(textura.Width / 4) * currentFrameX, 0, (int)(textura.Width / 4),
}
else
{
52
if (isMen)
{
currentFrameX = 0;
((textura.Width / 7) * currentFrameX) - 1, 0, (int)(textura.Width / 7),
}
}
}
}
public BoundingBox corpoR()

{
return new BoundingBox( new Vector3(posicao.X , posicao.Y, 0), new
Vector3(posicao.X+largura, posicao.Y+altura, 0));
}
public bool movimento(List<Sprites> sprites)

{
bool entrou = false;
//verifica qual botão do controle foi precionado

if (tvControladora != null)
{
if (tvControladora.pause)//se for o pause, o npc para de movimentar
{
velocidade = Vector2.Zero;
return false;
}
else
if (tvControladora.play)// se for play, o npc volta a movimentar
if (direcao == SpriteEffects.None)
velocidade = new Vector2(velo, 0);
else
velocidade = new Vector2(-velo, 0);
}
else
{
if (direcao == SpriteEffects.None)
velocidade = new Vector2(velo, 0);
else
velocidade = new Vector2(-velo, 0);
}
//////////////////////CODIGO B////////////////////////
//*CODIGO B DEVE FICAR ANTES DO CODIGO C//
//este codigo atualiza o movimento do zumbi seguidor de tv(!isWalker)
if (isZombie && !isWalker && tvControladora != null)
{
// se o zumbi estiver a direita da TV
if (posicao.X > tvControladora.posicao.X)
{
if (!(posicao.X - velo <= tvControladora.posicao.X))
{
velocidade.X = -velo;//andar para a esquerda
direcao = SpriteEffects.FlipHorizontally;//inverte animacao para
a esquerda
}
else
velocidade.X = 0;
}
53
else
//se o zumbi estiver a esquerda da TV
if (posicao.X < tvControladora.posicao.X)
{
if (!(posicao.X + velo >= tvControladora.posicao.X))
{
velocidade.X = velo;//andar para a direita
direcao = SpriteEffects.None;//inverte animacao para a direita
}
else
velocidade.X = 0;
}
}
//////////////////////FIM B/////////////////////////////
for (int i = 0; i < sprites.Count; i++)

{
if (corpo().Intersects(sprites[i].corpo()))
{
velocidade.Y = 0;
isOnTheGround = true;
break;
}
//se apos verificar, o inimigo não está no xao, então ele deve continuar
caindo (gravidade)
else
{
velocidade.Y = gravidade;
isOnTheGround = false;
}
}
if(isOnTheGround)
////////////////////////CODIGO C//////////////////////
//este codigo verifica onde o inimigo pode andar e qual direção deve tomar
for(int i = 0; i < sprites.Count; i++)
{
//verifica se o inimigo esta no xao(isOnTheGround) e perto de alguma
beirada(explicação na linha de baixo).
//canWalk deve ser true para que o inimigo possa andar no chao, caso
contrario, só o personagem pode andar
//corpo() verifica se existe alguma colisao na posicao passada no
parametro. Se houver alguma colisao, quer dizer que não está perto da beirada
//a posição passada no parametro representa os pés do NPC
if (isOnTheGround && sprites[i].canWalk &&
(!corpo((int)largura, (int)altura, (int)largura,
10).Intersects(sprites[i].corpo()) || //borda direita
!corpo(-1 * ((int)largura), (int)altura, (int)largura,
10).Intersects(sprites[i].corpo())))//borda esquerda
{
//quando uma beirada é encontrada, deve-se verificar se existe outro
sprite perto dela, para que o movimento continue
for (int k = 0; k < sprites.Count; k++)
{
//verifica se existe outro "sprite" proximo a borda da esquerda

if (direcao == SpriteEffects.FlipHorizontally &&
sprites[k].canWalk && corpo(-1 * (int)largura, (int)altura-4, (int)largura,
4).Intersects(sprites[k].corpo()))
{
{
54

velocidade.X = -velo;
velocidade.X = velo;
}
else
entrou = true;
break;
}
else
//verifica se existe outro "sprite" proximo a borda da
direita
if (direcao == SpriteEffects.None && sprites[k].canWalk &&
corpo(((int)largura), (int)altura-4, (int)largura, 4).Intersects(sprites[k].corpo()))
{

{
}
else
entrou = true;
break;
}
}
//se não existe nenhum sprite para o inimigo andar,

if(!entrou)
{
if (isWalker || !isZombie)//e o inimigo dor do tipo walker,
então ele vira para a direção oposta(multiplicando a velocidade por -1)
{
if (direcao == SpriteEffects.FlipHorizontally)
direcao = SpriteEffects.None;
else
direcao = SpriteEffects.FlipHorizontally;
velocidade.X *= -1;
}
else//se não for do tipo walker, ele fica parado na beirada do
xao
{
velocidade.X = 0;
}
}
//ao final ele deve retornar true pois o inimigo esta colidindo com
o sprite
return true;
}
// else
//verifica se o inimigo ainda não estiver no xao, deve verificar
para que ele pare de cair.
}
//////////////////////////////////////////FIM
55
C/////////////////////////////////////////
if (isOnTheGround)
return true;
else
return false;
}
}
}
9 OBJETOS.CS
using System;
using System.Linq;
namespace Kane_1._0
{
class Objetos : Sprites
{
public bool isStatic;
SoundEffect arrasta;
SoundEffectInstance arrastaInstance;
SoundEffect caiu;
public bool parouDeCair = false;
//todo objeto não estatico deve ser relacionado a um objeto da lista "ground"
que corresponderá à parte de cima do objeto, para que os personagens possam andar sobre
ele
public int Ground;// contem o index do vetor ground
public Objetos(Vector2 posicao, Texture2D textura, float largura, float altura,

float rotation, float layerX, bool isStatic, ContentManager Content)
: base(posicao, textura, largura, altura, rotation, layerX)
{
Ground = -1;
this.isStatic = isStatic;
//se for objeto estatico
if (isStatic)
velocidade = Vector2.Zero;// permanecer parado
else//se nao
velocidade = new Vector2(0, 1);// cair
arrasta = Content.Load<SoundEffect>(@"Audio\caixaEmpurra");
arrastaInstance = arrasta.CreateInstance();
caiu = Content.Load<SoundEffect>(@"Audio\caixaCaiu");
camada = 0.1f;
}
public void Update(List<Sprites> ground, List<NPC> npc)

{
56
//só movimenta se não for estatico

if (!isStatic)
{
posicao += velocidade;//atualiza posicao
/////////////////CODIGO A//////////////////////////////////
//este codigo verifica se o objeto caiu no xao
int i = 0;//contador do index da lista "ground"
//todo objeto não estatico começa no ar

//quando a posicao é atualizada, este objeto vai cair pois "velocidade =
new Vector2(0, 1)" onde 1 é a gravidade
//este "for" verifica se o objeto colidiu com o chao, para que possa
parar de cair
foreach (Sprites s in ground)
{
//é necessario a comparação do index "i" com "this.ground" pois,
this.ground pois este caso representa a comparação do objeto com ele mesmo
//logo, os dois possuem a mesma posicao, então a verificação deve
ser ignorada quando a condição for verdadeira
if (i != this.Ground)
if (corpo().Intersects(s.corpo()))//se colidiu com o chao
{
velocidade.Y = 0;//para de cair
if (!isStatic && !parouDeCair)
{
caiu.Play();//som
parouDeCair = true;//flag necessário para tocar o som
uma só vez
}
break;
}
velocidade.Y = 5;//o corpo vai continuar a cair se não entrar no if
anterior
i++;
}
/////////////////////FIM A//////////////////////////////////
if (velocidade.Y == 5)
parouDeCair = false;
/////////////////////////CODIGO B///////////////////////////////
//este codigo verifica se o Objeto está sendo empurrando por algum zumbi
if(npc != null)
foreach (NPC n in npc)
{
if(n.isOnTheGround)
//se o NPC for um zumbi e ocorrer a colisão do Objeto com a
parte esquerda do ZUMBI
if (n.isZombie && corpo().Intersects(n.corpo(0, 0, 1,
(int)n.altura)))
{
//se o zumbi estiver virado para a esquerda
if (n.direcao == SpriteEffects.FlipHorizontally)
{
velocidade.X = -5;//mover a caixa para a esquerda
// if(arrastaInstance.State == SoundState.Stopped)
arrastaInstance.Play();
}
break;
57
}
else
//se o NPC for um zumbi e ocorrer a colisão do Objeto com a
parte direita do ZUMBI
if (n.isZombie && corpo().Intersects(n.corpo((int)n.largura,
0, 1, (int)n.altura)))
{
//se o zumbi estiver virado para a direita
if (n.direcao == SpriteEffects.None)
{
velocidade.X = 5;//mover para a direita
// if (arrastaInstance.State == SoundState.Stopped)
arrastaInstance.Play();
}
break;
}
velocidade.X = 0;
}
//////////////////////////FIM B////////////////////////////////////
}
}
}
}
10 PERSONAGEM.CS
using System;
using System.Linq;
//Personagem jogavel
namespace Kane_1._0
{
class Personagem : Sprites
{
enum estado
{
correndo,
parado,
pulou,
no_ar,
cair,
}
public bool morreu = false;
public float impulsoX; //velocidade aplicada ao eixo X do personagem
quando ele está em movimento
58
public float gravidade; //velocidade aplicada ao eixo Y do personagem

quando ele está no ar
public bool isOnTheGround; //true se o personagem está colidindo com o xao
public bool pulou; //true se o personagem esta pulando
public float distanciaPulo; //distancia total que o personagem ja pulou. Este
valor é sempre menor do que a alturaPulo
public int distanciaChao;
public Texture2D texturaRaio; //textura do raio de alcance do personagem
public Rectangle areaAlcance; //area de alcance do raio. Usado para desenhar no
metodo Draw.
//Este retangulo não é usado para a detecção de
colisão,
//mas é usado no metodo corpoR() que define o
corpo usado na colisão
public int raio; //raio da area de alcance do personagem
public bool mostrarArea; //true se a area de alcance do personagem deve ser
mostrada
private KeyboardState kOld; //estado do teclado da iteração anterior

private GamePadState gOld; //estado do gamepad da iteração anterior
public int currentFrameXcorrer = 0; //frame animação correr
public int currentFrameXpular = 0; //frame animacao pular
public int currentFrameXparado = 0; //frame X animação parado
public int currentFrameYparado = 0; //frame Y animação parado
public bool correr = false;
public SpriteEffects direcao = SpriteEffects.None;
ContentManager Content;
float impulsoY;
public float nivelDano;
estado estadoAnimacao;
public float dano = 0;
bool godMod;
// 0 - sem nenhum item
// <= -1 - bateria
// >= 1 - lampada
public int item;
MouseState mOld;
public Personagem(ContentManager Content)

{
this.impulsoY = 6.5f; //velocidade do pulo

this.impulsoX = 5; //veloidade X
this.gravidade = 0.25f;//gravidade
this.distanciaChao = 65;
this.textura = Content.Load<Texture2D>(@"Sprites\Kane\parado");
this.velocidade = new Vector2(0, impulsoY+gravidade); //velocidade inicial
this.posicao = new Vector2(0, 150); //posicao inicial
this.largura = 50.0f; //largura padrão
this.altura = 90.0f; //altura padrão
nivelDano = 0.25f;
this.texturaRaio = Content.Load<Texture2D>(@"Sprites\Kane\raio");
this.raio = 200;
this.mostrarArea = false; //true, mostra o raio ao iniciar
o jogo. Apertar E durante o jogo para mostrar ou esconder
// laser = Content.Load<Texture2D>(@"Sprites\laser");
this.Content = Content;
59
item = 0;
camada = 0.000001f;
/// <summary>
/// Esfera que representa a área de alcance do controle do personagem,
/// usada para verificar a colisão com alguma TV.
/// </summary>
/// <returns></returns>
public BoundingSphere corpoRs()
{
//Cria uma esfera a partir da posição, altura e largura do personagem.
//Deve-se dividir a altura e largura por 2 para que o centro da esfera seja
no centro do personagem.
//O terceiro parametro do Vector3 é zero, pois o jogo é 2D.
//O segundo parameto da BoundingSphere representa o raio. O numero somado ao
raio é o Offset para que
//a distancia da esfera corresponda á distancia da textura do Raio.
return new BoundingSphere(new Vector3((int)posicao.X + largura / 2,
(int)posicao.Y + altura / 2, 0), raio + 10);
}
public BoundingBox corpoRb()

{
return new BoundingBox(new Vector3(posicao.X, posicao.Y, 0), new
Vector3(posicao.X + largura, posicao.Y + altura, 0));
}
/// <summary>
/// Verifica se o personagem está no chao.
/// </summary>
/// <param name="ground">Lista de Sprites que representam o chão</param>
public void onTheGround(List<Sprites> ground)
{
//percorre a lista verificando se o personagem colide com algum sprite que

representa um "chão"
foreach (Sprites g in ground)
{
//colidir a cabeça na plataforma acima
//os valores numericos dos parametros são os valores de Offset para
ajustar a colisao com caixas
if (corpo(30, 0, (int)largura - 50, 5).Intersects(g.corpo()))
{
//se entrar aqui, é porque o personagem bateu a cabeça em algum
"teto"
pulou = false;
// velocidade.Y = gravidade;//personagem começa a cair
g.velocidade.Y = -10;
}
//colidir os pes no xao

//valores numericos são offset para ajustar colisao
if (corpo(0, (int)(altura-5), (int)largura, 10).Intersects(g.corpo()))
{
//se entrar aqui o personagem está pisando em algum "chão"
velocidade.Y = 0;
60
pulou = false;
isOnTheGround = true;
break;// break deve acontecer para que a verificação das outras
posições da lista pare, pois não é mais necessário.
}
else//se estiver no ar
{
//se entrar aqui é porque o personagem está no ar e não foi por
causa do pulo, então o personagem deve cair
//este IF é necessario pois o personagem não deve cair se ele pulou
e não atingiu a altura maxima do pulo
if (!pulou)
{
velocidade.Y += (gravidade / 4);
if (velocidade.Y > 6.5f)
velocidade.Y = 6.5f;
}
isOnTheGround = false;
}
}
}
/// <summary>
/// Verifica colisao com as laterias de Obejetos
/// </summary>
/// <param name="objetos">Lista de Sprites que representam os objetos</param>
public void colideObject(List<Objetos> objetos)
{
//percorre a lista verificando se o personagem colide com algum sprite que
representa algum "objeto"
//os valores numericos são para o Offset necessário para aumentar a precisão
das colisões
foreach (Objetos ob in objetos)
{
if (ob.corpo(-5, 5, 10, (int)ob.altura).Intersects(corpo()))//verifica o
lado esquerdo do personagem
posicao.X -= impulsoX;
else
if (ob.corpo((int)ob.largura - 10, 5, 10,
(int)ob.altura).Intersects(corpo()))//verifica o lado direito do personagem
posicao.X += impulsoX;
}
}
/// <summary>
/// Atualiza personagem
/// </summary>
/// <param name="gameTime">Tempo do jogo</param>
/// <param name="objetos">Objetos que irão colidir com o personagem, exceto o
chão</param>
/// <param name="ground">Chão onde o personagem pode andar</param>
public void Update(GameTime gameTime, List<Objetos> objetos, List<Sprites>
ground, List<TV> tv, List<NPC> npc)
{
//verifica se a visão está completamente escura. Se estiver, o jogador vira

um zumbi e perde o jogo.
if (dano >= 600)
61
morreu = true;
//godMod é utilizado para testes. Se for TRUE está ativado, FALSE desativado
godMod = false;
if (!godMod)
{
//verifica se o jogador está no raio de alcance de alguma TV ligada
//se estiver, a sua visão começará a ficar escura.
if(tv != null)
{
if (t.isTvOn)
if (corpoRb().Intersects(t.corpoRs()))
{
dano += nivelDano;
break;
}
}
////////////////animação///////////////////
// é necessário fazer um if especifico para cada tipo de animação
// pois cada sprite sheet possui uma quantidade de frames diferente
if (estadoAnimacao == estado.correndo)//animação correr
{
{
currentFrameXcorrer++;
}
if (currentFrameXcorrer == 7)
currentFrameXcorrer = 0;
}
else
if (estadoAnimacao == estado.parado)//animação parado
{
{
currentFrameXparado++;
}
if (currentFrameXparado == 3)
{
currentFrameXparado = 0;
currentFrameYparado++;
if (currentFrameYparado == 2)
currentFrameYparado = 0;
}
}
else
if (estadoAnimacao == estado.pulou)//animação pular
{
{
currentFrameXpular++;
}
if (currentFrameXpular == 2)
{
currentFrameXpular = 2;
62
estadoAnimacao = estado.no_ar;
}
}
else
if (estadoAnimacao == estado.no_ar)//animação "no ar"
{
}
else
if (estadoAnimacao == estado.cair)
{
{
currentFrameXpular++;
}
if (currentFrameXpular > 3)
{
}
}
////////////////////////////////////////////
//Define a textura parado ao inicio de todo loop.
//Se o jogador não precionar nenhum botão, está textura permanecerá.
this.textura = Content.Load<Texture2D>(@"Sprites\Kane\parado");
//Define o estado parado após o trecho anterior(que realiza a animação)
//Esta linha é necessária para evitar um bug na animação quando o
jogador está parado.
estadoAnimacao = estado.parado;
////////////////////////////////CODIGO A////////////////////////////////
//este codigo movimenta o personagem
//entradas do usuario
if (k.IsKeyDown(Keys.D) ||
GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X > 0.1f)//ir para a direita(teclado
e gamepad)
{
this.textura = Content.Load<Texture2D>(@"Sprites\Kane\correr");
velocidade.X = impulsoX;
direcao = SpriteEffects.None;
estadoAnimacao = estado.correndo;
}
if (k.IsKeyDown(Keys.A) ||
GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.X < -0.1f)//ir para a
esquerda(teclado e gamepad)
{
this.textura = Content.Load<Texture2D>(@"Sprites\Kane\correr");
velocidade.X = -impulsoX;
direcao = SpriteEffects.FlipHorizontally;
estadoAnimacao = estado.correndo;
}
if ((k.IsKeyDown(Keys.Space) ||
GamePad.GetState(PlayerIndex.One).ThumbSticks.Left.Y > 0.4f) && isOnTheGround)//pular(só
pode pular se estiver no chão: isOnTheGround é true)
{
impulsoY = 7.5f;
//velocidade.Y = -gravidade;// muda a gravidade para o personagem
subir(pular)
pulou = true;
distanciaPulo = posicao.Y;// seta a distancia do pulo para a posicao
Y atual do personagem
63
estadoAnimacao = estado.pulou;
this.textura = Content.Load<Texture2D>(@"Sprites\Kane\pulo");
}
//se o jogador não está no chao, quer dizer que esta no ar
if (!isOnTheGround)
{
this.textura = Content.Load<Texture2D>(@"Sprites\Kane\pulo");
}
//se pulou, mudar a animação e dar um impulso

if (pulou)
{
//seleciona animação que melhor se adapta ao movimento do pulo
if (currentFrameXpular == 2)
else
if (!isOnTheGround)
else
estadoAnimacao = estado.pulou;
posicao.Y -= impulsoY; //atualiza posicao Y

impulsoY -= gravidade; //atualiza velocidade do pulo
}
//se o jogador cair no chao

if (posicao.Y == distanciaPulo)
{
pulou = false;//"para" de pular
}
posicao += velocidade; //atualiza posicao

velocidade.X = 0; //velocidade X deve ser 0 para que o personagem
só se movimente enquanto o jogador está precionando as teclas de movimentacao
onTheGround(ground); //verifica colisão com o chão

colideObject(objetos); //verifica colisão com objetos
////////////////////////////////FIM A/////////////////////////////////
//////////////////////////CODIGO B///////////////////////////////////
//este codigo mostra a area de alcance do controle do personagem
if (((k.IsKeyDown(Keys.E) && kOld.IsKeyUp(Keys.E)) || //apertar
Shift esquerdo(teclado)
(g.Triggers.Left > 0.1) && gOld.Triggers.Left == 0.1))//apertar
defesa superior esquerda(gamepad)
if (mostrarArea)
mostrarArea = false;
else
mostrarArea = true;
kOld = k;//atualiza estado do teclado

/////////////////////////////FIM B///////////////////////////////
//velocidade do personagem é definida em 5 a cada iteração do loop
impulsoX = 5;
//se o personagem entrar em contato com um zumbi, a sua velocidade

diminui
if(npc != null)
foreach (NPC n in npc)
{
64
if (n.isZombie && n.corpo().Intersects(this.corpo()))

{
impulsoX = 3;
}
}
}
else
{
if (k.IsKeyDown(Keys.A))
posicao.X -= 10;
if (k.IsKeyDown(Keys.D))
posicao.X += 10;
if (k.IsKeyDown(Keys.W))
posicao.Y -= 10;
if (k.IsKeyDown(Keys.S))
posicao.Y += 10;
}
if (m.MiddleButton == ButtonState.Pressed && mOld.MiddleButton ==

{
if (godMod)
godMod = false;
else
godMod = true;
}
mOld = m;
}

{
//desenha o personagem
if(estadoAnimacao == estado.correndo)
spriteBatch.Draw(textura, corpo(), new Rectangle((int)(textura.Width /
7) * currentFrameXcorrer, 0, (int)(textura.Width / 7), 142), Color.White, 0,
Vector2.Zero, direcao, camada);
else
if (estadoAnimacao == estado.pulou || estadoAnimacao == estado.cair ||
estadoAnimacao == estado.no_ar)
{
spriteBatch.Draw(textura, corpo(0, 0, 55, 95), new Rectangle((int)
((textura.Width / 5) * currentFrameXpular), 0, (int)(textura.Width / 5),
}
else
spriteBatch.Draw(textura, corpo(0, 0, 40, 90), new Rectangle((int)
((textura.Width / 3) * currentFrameXparado) + 1, ((int)(textura.Height / 2) *
currentFrameYparado)+1, (int)(textura.Width / 3), (int)textura.Height / 2), Color.White,
0, Vector2.Zero, direcao, camada);
Color corRaioTV = new Color(100, 100, 100, 100);
//desenha area de alcance do controle

if (mostrarArea)
{
//Uma textura em forma de circulo é usada para simular a area de alcance
do controle.
//Um retangulo define a posição, altura e largura desta textura.
65
//O raio é usado para criar o Offset correspondente ao raio da usando no

metodo corpoR()
areaAlcance = new Rectangle((int)(posicao.X - raio), (int)(posicao.Y -
raio), (int)(largura + (raio * 2)), (int)(altura + (raio * 2)));
spriteBatch.Draw(texturaRaio, areaAlcance, null, corRaioTV, 0,

Vector2.Zero, SpriteEffects.None, 0f);
}
}
}
}
11 TV.CS
using System;
using System.Linq;
namespace Kane_1._0
{
class TV : Sprites
{
Texture2D tvDesligada;
Texture2D tvLigada;
Texture2D raioTV;
Texture2D raioOnda;
public Color corTV;
public bool isTvOn, ativa, pause, play;
public float vol;//volume
public Rectangle raio;
public bool mostrarRaio;
float volTemp = 0;
int tempo = 0;
private KeyboardState kOld; //estado do teclado da iteração anterior
private GamePadState gOld; //estado do gamepad da iteração anterior
int alphaTotal, alphaIncremento;
public TV(ContentManager Content, Vector2 posicao, bool isTvOn)

{
this.isTvOn = isTvOn;
vol = 200;
pause = false;
play = false;
altura = 100;
largura = 90;
corTV = Color.Gray;
alphaTotal = 0;
alphaIncremento = 10;
mostrarRaio = true;
66
currentFrameX = 0;
tvDesligada = Content.Load<Texture2D>(@"Sprites\TV\tv_desligada");
tvLigada = Content.Load<Texture2D>(@"Sprites\TV\tv_espiral");
raioTV = Content.Load<Texture2D>(@"Sprites\TV\raio");
raioOnda = Content.Load<Texture2D>(@"Sprites\TV\raioOnda2");
ativa = false;
raio = new Rectangle((int)(posicao.X - vol), (int)(posicao.Y - vol), (int)

(largura + (vol * 2)), (int)(altura + (vol * 2)));
camada = 0.02f;
}
public void volume()

{
if (vol < 0)
vol = 0;
if (vol > 500)
vol = 500;
}
public void power()

{
if (isTvOn)
isTvOn = false;
else
{
isTvOn = true;
mostrarRaio = true;
}
}
public void Update(Controle controle, GameTime gameTime)

{
raio = new Rectangle((int)(posicao.X - vol), (int)(posicao.Y - vol), (int)
(largura + (vol * 2)), (int)(altura + (vol * 2)));
atualizaCores();
if (ativa)
{
switch (controle.botaoSelecionado)
{
case 0:
power();
break;
case 3:
if (isTvOn)
{
pause = true;
play = false;
}
break;
case 6:
if (isTvOn && pause)
{
67
pause = false;
play = true;
}
break;
case 7:
if (isTvOn)
{
vol += 25;
volume();
}
break;
case 8:
if (isTvOn)
{
vol -= 25;
volume();
}
break;
}
}
if (!isTvOn)
{
pause = false;
play = false;
mostrarRaio = false;
}
else
{
{
currentFrameX++;
}
currentFrameX = 0;
}
kOld = k;
gOld = g;

{
Color corRaioTV = new Color(100, 100, 100, alphaTotal);
if (isTvOn && mostrarRaio)

{
if (tempo > 5)
{
alphaTotal += alphaIncremento;
tempo = 0;
}
if (alphaTotal > 110)

alphaIncremento = -5;
if (alphaTotal < 50)

alphaIncremento = 5;
68
//spriteBatch.Draw(raioTV, raio, null, corRaioTV, 0, Vector2.Zero,

SpriteEffects.None, 0f);
tempo++;
volTemp += 5;
if (volTemp >= vol)

{
volTemp = 0;
}
Rectangle raioOndaRec = new Rectangle((int)(posicao.X - volTemp), (int)

(posicao.Y - volTemp), (int)(largura + (volTemp * 2)), (int)(altura + (volTemp * 2)));
spriteBatch.Draw(raioOnda, raioOndaRec, null, corRaioTV, 0,

spriteBatch.Draw(raioOnda, raio, null, corRaioTV, 0, Vector2.Zero,

SpriteEffects.None, 0f);
spriteBatch.Draw(tvLigada, corpo(), new Rectangle((int)(tvLigada.Width /

7) * currentFrameX, 0, (int)tvLigada.Width / 7, (int)tvLigada.Height), corTV, 0,
Vector2.Zero, SpriteEffects.None, camada);
}
else
spriteBatch.Draw(tvDesligada, corpo(), null, corTV, 0, Vector2.Zero,
SpriteEffects.None, camada);
}
public Rectangle corpo(int x, int y)

{
return new Rectangle((int)posicao.X+x, (int)posicao.Y+y, (int)largura,
(int)altura);
}
public BoundingSphere corpoRs()

{
return new BoundingSphere(new Vector3((int)posicao.X + largura/2,
(int)posicao.Y + altura/2, 0), vol +30);
}
public BoundingBox corpoRb()
{
return new BoundingBox(new Vector3(posicao.X, posicao.Y, 0), new
Vector3(posicao.X + largura, posicao.Y + altura, 0));
}
}
}
12 SPRITES.CS
using System;
using System.Linq;
69
//A Classe Sprites é usada para criar caminhos para os personagens, assim como outras
imagens que compõe o cenário.
//Os caminhos criados definem onde o jogador e os NPCs podem andar.
namespace Kane_1._0
{
class Sprites
{
public float camada;
public Vector2 posicao; //posicao do sprite
public Vector2 origem; //origem de rotação do sprite
public Vector2 velocidade;//velocidade do sprite
public float largura; //largura do sprite
public float altura; //altura do sprite
public float rotation; //rotação do sprite
public Texture2D textura; //textura do sprite
//variaveis layer são para simular o parallax scrolling
public float layerX; //layerX é a velocidade horizontal que sera aplicada
ao sprite quando o personagem se movimentar no eixo X
public float layerY; //layerY é a velocidade vertical que sera aplicada ao
sprite quando o personagem se movimentar no eixo Y
public Vector2 layer; //camada em que o sprite está
public bool canWalk; //true se o inimigo pode andar sobre este sprite. Sua
função é simular uma parede, deve ser colocada para limitar e controlar os movimentos
dos inimigos
public int timeSinceLastFrame;
public int millisecondsPerFrame;
public int currentFrameX, currentFrameY;
public bool isDesenha;
public int Wall; //necessário para relacionar este chao com o objeto
correspondente
public Sprites()
{ }
/// <summary>
/// Construtor dos Sprites
/// </summary>
/// <param name="posicao">Posição do Sprite</param>
/// <param name="textura">Textura do Sprite</param>
/// <param name="largura">Largura do Sprite</param>
/// <param name="altura">Altura do Sprite</param>
/// <param name="rotation">Rotação do Sprite</param>
/// <param name="layerX">Camada do Sprite</param>
public Sprites(Vector2 posicao, Texture2D textura, float largura, float altura,
float rotation, float layerX)
{
this.origem = new Vector2(textura.Width / 2, textura.Height / 2); //origem é
no centro do sprite
this.largura = largura;
this.altura = altura;
this.rotation = rotation;
this.textura = textura;
this.velocidade = Vector2.Zero;
this.layerX = layerX;
this.layerY = 1; //layerY é 1 pois parallax scrolling nao será aplicado no
movimento vertical
this.layer = new Vector2(layerX, layerY);
70
this.canWalk = true;//padrão é true. Se a função deste sprite é simular uma

parede para o inimigo, então mudar para false
isDesenha = true;
Wall = -1;
camada = 1f;
}
/// <summary>
/// Retangulo normal para colisao do corpo inteiro
/// </summary>
public Rectangle corpo()
{
return new Rectangle((int)posicao.X, (int)posicao.Y, (int)largura,
(int)altura);
}
/// <summary>
/// Retangulo personalidado para realizar colisoes em partes especificas do
inimigo, ou colisões com Offset
/// </summary>
/// <param name="x">Offset posicao X</param>
/// <param name="y">Offset posicao Y</param>
/// <param name="w">Nova largura</param>
/// <param name="h">Nova altura</param>
public Rectangle corpo(int x, int y, int w, int h)
{
return new Rectangle((int)posicao.X + x, (int)posicao.Y + y, w, h);
}
virtual public void Draw(SpriteBatch spriteBatch)

{
this.layer = new Vector2(layerX, layerY);
if(isDesenha)
spriteBatch.Draw(textura, corpo(), null, Color.White,
MathHelper.ToRadians(rotation), Vector2.Zero, SpriteEffects.None, camada);
}
}
}

Codigo FINAL Kane

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Codigo FINAL Kane

Caricato da

Copyright:

Formati disponibili

Carlos Henrique Nascimento

O Game como instrumento de crítica social

Trabalho de conclusão de curso apresentado como

Orientador: Prof. Alysson A. Naves Silva

public Camera(Viewport viewport)

public Matrix cameraTransform(Vector2 parallax)

public void Update(Vector2 pos)

if (deslocamentoCameraY > 50)

public bool temItem = true;

public bool sairPelaSegundaPorta;

public Casas(Vector2 posicaoExteriorCasa, Texture2D texturaExteriorCasa, float

public void Update(Personagem kane, GameTime gameTime, HUD Hud)

foreach (Objetos ob in walls)

if (k.IsKeyDown(Keys.W) && kOld.IsKeyUp(Keys.W) && !kane.pulou)

foreach (Objetos ob in walls)

foreach (TV t in tv)

foreach (NPC npc in inimigo)

foreach (Item i in item)

public void Draw(SpriteBatch spriteBatch)

foreach (Sprites c in cenario)

foreach (NPC npc in inimigo)

foreach (Item i in item)

public void resetar()

ground = new List<Sprites>();

public Controle(ContentManager Content)

criaControle(Content);//funcao que seta todas as propriedades iniciais do

energia = 10;//energia do controle inicial

return new Rectangle((int)posicaoBotao[i].X, (int)posicaoBotao[i].Y,

public void criaControle(ContentManager Content)

posicaoBotao[0] = new Vector2(posicaoX+85, posicaoY+26);

posicaoBotao[1] = new Vector2(posicaoX + 110, posicaoY+76);

posicaoBotao[2] = new Vector2(posicaoX+54, posicaoY+71);

posicaoBotao[3] = new Vector2(posicaoX + 82, posicaoY+76);

posicaoBotao[4] = new Vector2(posicaoX +35, posicaoY+115);

posicaoBotao[5] = new Vector2(posicaoX + 94, posicaoY+121);

posicaoBotao[6] = new Vector2(posicaoX + 61, posicaoY+116);

posicaoBotao[7] = new Vector2(posicaoX + 65, posicaoY+97);

posicaoBotao[8] = new Vector2(posicaoX + 44, posicaoY+140);

posicaoBotao[9] = new Vector2(posicaoX - 8, posicaoY-10);

posicaoBotao[10] = new Vector2(posicaoX+104, posicaoY+7);

for (int i = 0; i < 9; i++)

if (tempoBotaoPressionado[i] > 10)

if (energia > 0 && isTvSelected)

if (corpo(9).Intersects(new Rectangle((int)m.X, (int)m.Y, 5,

public void Update()

verificaColisaoBotao();//verifica se o mouse colidiu com algum botao. Esta

if (tempoLuzPisca > 70)

public void Draw(SpriteBatch spriteBatch)

spriteBatch.Draw(texBotao[9], corpo(9), null, Color.White, 0, Vector2.Zero,

for (int i = 0; i < 9; i++)

if(luzLigada && tempoLuzPisca<10)

List<Sprites> ground; //chao

public Fase1(ContentManager contentManager, GraphicsDevice graphics)

Content.Load<Texture2D>(@"Sprites\Fase1\Casas\1\casa"), 600, 380, 0, 1, Content));

cenario.Add(new Sprites(new Vector2(-5000, -350),

Content.Load<Texture2D>(@"Sprites\Fase1\Cenario\muro"), 2000, 130, 0, 1.01f));

//limite mapa esquerda

//limite mapa galpao tv velha

//limite mapa policia

public void interiorCasaUpdate(int tipo, GameTime gameTime)

Hud.Update(casas[tipo - 1].tv, kane);

//quando o personagem sai da casa

kane.posicao = posOldKane + new Vector2(100, -10); //aparece à

public void interiorCasaDraw(int tipo, SpriteBatch spriteBatch)