Athanazio

ok vc acordou com um mal humor da molestia, e acha que para resolver seu problema basta escrever uns codigos em C++ para ler arquivos bitmap e converter em seja lah o que for ??? nao foi isto que aconteceu ?
ahhh entao alguem resolveu que vc deveria ler arquivos BMP e calcular seja lah o que for baseado nos valores de cores dos pixels impares ?? naooooo ??? seja lah o que for use :
easybmp.sourceforge.net

A biblioteca C para ler bitmap que nao deixa vc na mao !

Olas ! em minhas aventuras de jogos, desenvolvi mais um para a competição ludum dare, agora na versão mini.
O tema desta competição era “tempo”, e era necessário usar as trilhas sonoras fornecidas pela competição. fiz um tetris que usa relógios como os elementos gráficos do jogo.

baixe aqui o jogo !timetris_minild9_20090524

Pelo que estou estudando, entendi que ateh consigo ler arquivos externos ao programa usando a classe StreamReader, mas quando o build do projeto for feito vai ter dependência que o arquivo exista fora do executável e não tenho a menor idéia de como referenciar o sistema de arquivo do Xbox por exemplo.

Assim sendo tem a tal da pasta content no projeto do jogo, dando add em itens nesta pasta, eles podem ser carregados pelo ContentManager !! mor legal.

No meu caso preciso carregar arquivos de mapa que gerei que contém um monte de zeros e uns, algo do tipo :

111111111111111111111111111111
100000000001100000000000000001
101111111111101111111111111101
101111111111101111111111111101
100000000001100001100001100001
101111111101111101101101101111
101111111101111101101101101111
100000001101100001101101100001


entaum seguindo alguns tutoriais, entendi que precisava escrever um contentimporter, para que o xna soubesse como transformar meu belo arquivo em objetos usaveis.

segui o tutorial e criei um Content PipeLine Extension Library dentro da mesma solution do jogo

e criei a classe MapFilesImporter

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Graphics;
using Microsoft.Xna.Framework.Content.Pipeline.Processors;

using Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler;
using Microsoft.Xna.Framework.Content;

using System.IO;

namespace MapFilesContentPipeLine
{
[ContentImporter(".maze", DisplayName = "Map Files - ChikenMaze")]
public class MapFilesImporter : ContentImporter
{

public override Boolean[,] Import(string filename,
ContentImporterContext context)
{
FileStream stream = File.OpenRead(filename);
StreamReader reader = new StreamReader(stream);
List> buffer = new List>();

string line = reader.ReadLine();
while (line != null)
{

List bufferLine = new List();
foreach (char one in line)
{
bufferLine.Add(one == ‘1′ ? true : false);
}
buffer.Add(bufferLine);
line = reader.ReadLine();
}

Boolean[,] result = new Boolean[buffer.Count, buffer[0].Count];
int row = 0;
int col = 0;

// copy data to the matrix
foreach (List onelist in buffer)
{
foreach (Boolean spot in onelist)
{
result[row, col] = spot;
col++;
}
row++;
col = 0;
}

return result;
}

}
}

Lembrando é claro de fazer referência ao projeto to content pipeline tanto no projeto do jogo, quanto nas referências da pasta content, isto me rendeu um tempão para perceber … hehehehe

dai tive a surpresa legal …
Error 1 Building content threw RankException: Cannot serialize multidimensional arrays.
po custava saber serializar arrays multidimensionais ?? =)

bem vou ter que mudar um pouco a estratégia de carregar os mapas, jah vi que vou precisar de um tipo de dados mais simplim que um array multidimensional de booleanos, pow mais simples que isso !! hehehehe, vou criar algo do tipo MapDefinition com as strings das linhas e um método para transformar na famigerada matriz de booleanos.

então refiz a classe de importar o formato de arquivo que tenho, novinha em folha !
comparando com a anterior, nesta mudei o display name para poder verificar se estava usando a nova implementação (danado desconfiado huahuahuuah) e passei a retornar List para os intimos conhecida como lista de tamanho variável de string.

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Graphics;
using Microsoft.Xna.Framework.Content.Pipeline.Processors;

using Microsoft.Xna.Framework.Content.Pipeline.Serialization.Compiler;
using Microsoft.Xna.Framework.Content;

using System.IO;

namespace MapFilesContentPipeLine
{
[ContentImporter(".maze", DisplayName = "Map Files - ChikenMaze (List)")]
public class MapFilesImporter : ContentImporter>
{

public override List Import(string filename,
ContentImporterContext context)
{
FileStream stream = File.OpenRead(filename);
StreamReader reader = new StreamReader(stream);
List buffer = new List();

string line = reader.ReadLine();
while (line != null)
{
buffer.Add(line);
line = reader.ReadLine();
}

return buffer;
}

}
}

com esta novidade precisei alterar um pouco a classe que gerencia os mapas para poder converter de List para Boolean[,] olha como ficou o trecho que carrega o mapa e o conversor de um tipo para o outro.

public Map getMap(int level)
{
// ok ok in one line would be cooler =)
// Boolean[,] map = ListString2MatrixBoolean(scene.game.Content.Load>(getMapName(level)));
//
// but this way we can read easily at 4:30AM
//
string filename = getMapName(level);
List buffer = scene.game.Content.Load>(filename);
Boolean[,] map = ListString2MatrixBoolean(buffer);
return new Map(this.scene, map);
}

public Boolean[,] ListString2MatrixBoolean(List list)
{
Boolean[,] result = new Boolean[list.Count, list[0].Length];
int row = 0;
int col = 0;

foreach (string line in list) {
foreach (char one in line)
{
result[row, col] = (one == ‘1′ ? true : false);
col++;
}
row++;
col = 0;
}

return result;
}

ultimo comentario para os desesperados que leram até o final, uma pena que minha mãe não programa em c# !! ela estaria lendo tudinho !! huahuahuhua

quando fizer referência ao arquivo a ser carregado nao inclua a extensão, eu estava buscando por maze_10_10.maze e recebendo o erro de “file not found”, resolvi fazer do mesmo jeito que estava fazendo com os arquivos de imagens e todos ficaram felizes, basta uasr o nome sem extensão.

olha que bela imagem da galinha andando num mapa carregado do arquivo !!

link para os tutoriais

Custom Content Importer with XNA 2.0
http://www.ziggyware.com/readarticle.php?article_id=166

Using a Custom Importer or Content Processor
http://msdn.microsoft.com/en-us/library/bb447743(XNAGameStudio.20).aspx

este post eh continuação de

http://www.athanazio.com/2009/01/11/c-criando-um-labirinto-v1/

Fazer as conexões entre os elementos do labirinto foi uma coisa interessante, porque eu preciso de uma representação onde cada posição, seja parede ou celula vazia tenha a mesma largura para representar isto para cada item do labirinto criei uma matriz 3×3 onde a posição do centro representa a celula em si e as posições ao redor são as possiveis conexões com as proximas células, veja o desenho abaixo

o centro do quadro eh a celula atual sendo processada, e as caixa ao redor sao os possiveis vizinhos, note que para cara vizinho existe uma combinacao de modificadores para x e y, por exemplo o vizinho ao norte é 0 e -1 o do leste 1 e 0 e assim por diante.

alem disto para conectar ao vizinho armazenei tambem que coordenada na matriz de conexões é necessário atualizar para realizar a conexão, por exemplo para o norte a conexão é feita em 1,2 da matriz de conexões.

a matriz com estas definições está na classe de geração do maze

int[,] SearchNeighBorNumbers = { { 0, -1, 1, 2 }, { 1, 0, 0, 1 }, { 0, 1, 1, 0 }, { -1, 0, 2, 1 } };

desta forma preciso sortear somente que linha desta matriz vou usar para manipular o vizinho, e assim realizo as conexões. Antes que eu me esqueça ! além de mudar a matriz de conexões do vizinho é necessário fazer o mesmo na célula corrente e para encontrar a célula correta basta usar o mesmo deslocamento usado para encontrar o vizinho, dentro da matriz de conexões da celula atual, a partir da posicao 1,1 conforme este treco abaixo

current.conections[
1 + SearchNeighBorNumbers[neighborRow, NEIGHBOR_X],
1 + SearchNeighBorNumbers[neighborRow, NEIGHBOR_Y]] = OPEN;

algumas referencias para labirintos

tutorial sobre a geração do labirinto
http://www.mazeworks.com/mazegen/mazetut/index.htm

mais comentarios sobre o algoritmo
http://en.wikipedia.org/wiki/Maze#Generating_mazes

uma visao mais detalhada do Deep-first
http://en.wikipedia.org/wiki/Depth-first_search

Para o jogo que estou criando preciso de uns labirintos e como não achei algo que pudesse gerar para um arquivo texto, estou implementando o meu mesmo, com algumas leituras vi que o algoritmo mais fácil para este caso seria a através de uma pilha assim eu garanto que percorri todos os elementos do labirinto.

o algortimo consiste em escolher uma posicao aleatoria, e buscar os vizinhos nao visitados ao redor, encontrando um abre caminho ateh ele e empilha o mesmo, e vai fazendo isto até que não existam vizinhos não visitados, assim vai desempilhando para voltar no caminho e tentando achar vizinhos não visitados no caminho de volta.
Assim percorremos todo o mapa mas ainda ficam uns becos sem saída, como pode ver marcado neste desenho que fiz quando estava testando manualmente o algoritmo

o teste foi de 5×5 e marquei com bolinhas abobora os becos sem saída, na próxima versão do algoritmo vou guardar os becos sem saída e conectar com algum vizinho =) eh melhor fazzer andar em círculos do que encontrar um beco em saída, hehehe

Seguem os códigos fonte, do gerador e do programa que esta gravando num arquivo texto o maze gerado, que por sinal esta com algum problema ainda …

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace MazeGenerator
{
class Program
{
static void Main(string[] args)
{
MazeGen mazeGen = new MazeGen();
MazeGen.MazeCell[,] maze = mazeGen.generateMaze(5,5);

string fileName = “c:/work/maze” + DateTime.Now.ToBinary() + “.txt”;
FileStream stream = File.Open(fileName, FileMode.OpenOrCreate);
StreamWriter writer = new StreamWriter(stream);

for (int n = 0; n < maze.GetLength(0); n++)
{
for (int conn = 0; conn < 3; conn++)
{
for (int m = 0; m < maze.GetLength(1); m++)
{
writer.Write(maze[n, m].conections[conn, 0] == MazeGen.OPEN ? "_" : "*");
writer.Write(maze[n, m].conections[conn, 1] == MazeGen.OPEN ? "_" : "*");
writer.Write(maze[n, m].conections[conn, 2] == MazeGen.OPEN ? "_" : "*");
}
writer.WriteLine();
}
}
writer.Close();
}
}
}

MazeGen,cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace MazeGenerator
{
public class MazeGen
{
public const Boolean DEBUG = true;
public const int CLOSED = 0;
public const int OPEN = 1;

public const int NEIGHBOR_X = 0;
public const int NEIGHBOR_Y = 1;
public const int NEIGHBOR_CONNECTION_2OPEN_X = 2;
public const int NEIGHBOR_CONNECTION_2OPEN_Y = 3;
public const int POSSIBLE_NEIGHBORS = 4;

public static Random random = new Random();

public class MazeCell
{
public MazeCell(int X, int Y)
{
this.X = X;
this.Y = Y;
this.Visited = false;
}

public Boolean Visited = false;
public int X;
public int Y;
// north, east, south, west
public byte[,] conections = { { CLOSED, CLOSED, CLOSED },
{ CLOSED, OPEN, CLOSED },
{ CLOSED, CLOSED, CLOSED } };

public override string ToString()
{
string buffer = "";
foreach( byte one in conections){
buffer += one.ToString();
}

return X + "," + Y + " [" + buffer +"] ";
}
}

// used to random the neighbor cell
// { increment of X, increment of Y, connection to open in the neighbor }
int[,] SearchNeighBorNumbers = { { 0, -1, 1, 2 }, { 1, 0, 0, 1 }, { 0, 1, 1, 0 }, { -1, 0, 2, 1 } };

public MazeCell[,] generateMaze(int rows, int cols)
{

// fill the matrix
MazeCell[,] result = new MazeCell[rows, cols];
for (int n = 0; n < result.GetLength(0); n++)
{
for (int m = 0; m < result.GetLength(1); m++)
{
result[n, m] = new MazeCell(n, m);
}
}

int visited = 1;
int total = rows * cols;

Stack path = new Stack();

int x = random.Next(1, rows - 1);
int y = random.Next(1, cols - 1);

result[x, y].Visited = true;

path.Push(result[x, y]);
MazeCell current = result[x, y];

while (visited < total)
{
// try the unvisited neighbors
int neighborRow = random.Next(0, 3);
MazeCell neighbor = nextRandomUnvisited(result, current, neighborRow);

int tries = 1;
while (tries < POSSIBLE_NEIGHBORS && neighbor == null)
{
neighborRow ++;
if( neighborRow >= POSSIBLE_NEIGHBORS ){
neighborRow = 0;
}
neighbor = nextRandomUnvisited(result, current, neighborRow);
tries ++;
}

if (neighbor == null)
{
current = (MazeCell)path.Pop();
}
else
{
current.conections[
1 + SearchNeighBorNumbers[neighborRow, NEIGHBOR_X],
1 + SearchNeighBorNumbers[neighborRow, NEIGHBOR_Y]] = OPEN;

neighbor.Visited = true;
neighbor.conections[
SearchNeighBorNumbers[neighborRow, NEIGHBOR_CONNECTION_2OPEN_X],
SearchNeighBorNumbers[neighborRow, NEIGHBOR_CONNECTION_2OPEN_Y]] = OPEN;

if (DEBUG){Console.WriteLine(“from {0} to {1}”, current, neighbor);}

path.Push(neighbor);
current = neighbor;
visited++;
}
}

return result;
}

public MazeCell nextRandomUnvisited(MazeCell[,] result, MazeCell current, int neighborRow)
{

int testX = current.X + SearchNeighBorNumbers[neighborRow, NEIGHBOR_X];
int testY = current.Y + SearchNeighBorNumbers[neighborRow, NEIGHBOR_Y];

// check if neighbor exists
// if not will try again
if (testX >= 0 && testX < result.GetLength(0) && testY >= 0 && testY < result.GetLength(1))
{

if (!result[testX, testY].Visited)
{
return result[testX, testY];
}
}

return null;
}

}
}

Uai ! em ateh map scroll hehehe, bem parte das minhas reflexões sobre a forma de implementar o jogo estão se materalizando, criei o conceito de cena, contendo o gerenciador de eventos e deslocamento da tela para permitir o scroll da tela de fundo.

o primeiro detalhe eh a classe Scene em si

using System;
using System.Collections.Generic;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace ChickenMaze
{
public abstract class Scene
{
public Game game;
public EventManager eventManager;
public int X;
public int Y;

public Scene(Game game, EventManager eventManager)
{
this.game= game;
this.eventManager= eventManager;
this.X = 0;
this.Y = 0;
}

public abstract void Initialize();
public abstract void LoadContent();
public abstract void Draw(GameTime gameTime, SpriteBatch spriteBatch);

}
}

que em alguns aspectos tentei manter o design semelhante a classe Game, com excessão do método Draw que adicionei o objeto spriteBatch sendo passado como parâmetro para evitar esta complexidade na cena atual, assim na classe Game principal do jogo um objeto scene é criado, e ao executar initialize, loadcontent e draw os respectivos metodos da Scene corrente serão chamados.

Esta abaixo eh a SceneMainMaze que determina os detalhes especificos do jogo, como sprite que vai ser usado como personagem, mapa e tratadores de eventos, note que a implementação dos eventos fica separada deste código.

using System;
using System.Collections.Generic;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace ChickenMaze
{
class SceneMainMaze : Scene
{
Sprite chicken;
Map map;

public SceneMainMaze(Game game, EventManager eventManager)
: base(game, eventManager)
{

}

public override void Initialize(){

map = new Map(this);
chicken = new Sprite(“chicken”, this);
chicken.Position = map.GetFirstFreeSpot();
chicken.SetMap(map);

eventManager.addHandler(new EventCantMoveHere(this));
eventManager.addHandler(new EventKeyboardLeft(this, chicken, map));
eventManager.addHandler(new EventKeyboardRight(this, chicken, map));
eventManager.addHandler(new EventKeyboardUp(this, chicken, map));
eventManager.addHandler(new EventKeyboardDown(this, chicken, map));
eventManager.addHandler(new EventNeedScrollMap(this, chicken, map ));
}

public override void LoadContent()
{
chicken.LoadContent(game.Content);
map.LoadContent(game.Content);
}

public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
{
Color color = new Color(0, 136, 0);
game.GraphicsDevice.Clear(color);

map.Draw(spriteBatch);
chicken.Draw(spriteBatch);
}
}
}

Então o trecho abaixo mostra como os eventos são registrados para que ao serem disparados, o tipo de evento é testado e em seguida o métido run() dos eventos é executado

eventManager.addHandler(new EventKeyboardDown(this, chicken, map));
eventManager.addHandler(new EventNeedScrollMap(this, chicken, map ));

O código abaixo é o tratador de eventos para quando o scroll de mapa eh necessário

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace ChickenMaze
{
class EventNeedScrollMap: EventHandler
{
protected Sprite sprite;
protected Map map;

protected int HorizontalBorderLimit;
protected int VerticalBorderLimit;

const byte BORDER_DIVISION_INDEX = 4;

public EventNeedScrollMap(Scene scene, Sprite sprite, Map map)
: base(EventHandler.EventType.SPRITE_MOVED, scene)
{
this.sprite = sprite;
this.map = map;

HorizontalBorderLimit = scene.game.GraphicsDevice.Viewport.Width / BORDER_DIVISION_INDEX;
VerticalBorderLimit = scene.game.GraphicsDevice.Viewport.Height / BORDER_DIVISION_INDEX;
}

///

int SceneShift = sprite.speed;
int x = (int)sprite.Position.X – scene.X;
int y = (int)sprite.Position.Y – scene.Y;

// into left limit
if (x < scene.game.GraphicsDevice.Viewport.X + HorizontalBorderLimit)
{
if (scene.X - SceneShift > 0)
{
scene.X -= SceneShift;
}
}

// into right limit
if (x > scene.game.GraphicsDevice.Viewport.X
+ scene.game.GraphicsDevice.Viewport.Width – HorizontalBorderLimit)
{
scene.X += SceneShift;
}

// into top limit
if (y < scene.game.GraphicsDevice.Viewport.Y + VerticalBorderLimit)
{
if (scene.Y - SceneShift > 0)
{
scene.Y -= SceneShift;
}
}

// into bottom limit
if (y > scene.game.GraphicsDevice.Viewport.Y
+ scene.game.GraphicsDevice.Viewport.Height – VerticalBorderLimit)
{
scene.Y += SceneShift;
}

}

}
}

Desta maneira tratadores de evento podem ser facilmente reaproveitados entre jogos, e inclusive escrever código para realizar testes destes tratadores.

os próximos passos são :

• carregar o mapa de uma arquivo
• determinar que a galinha chegou no fim do mapa e criar evento para isto
• adicionar sons
• adicionar timer na tela
• adicionar os marcadores de labirinto com ovos (1 ovo a cada 10 segundos com duração de 60 segundos cada)
• adciionar cena de tela inicial
• adicionar cena de pontuação

eh este que vou usar !
http://www.ii.uni.wroc.pl/~wzychla/maze_en.html

usando o tal do Spritefont descobri que o tamanho da fonte fica definido neste xml que tem o mapeamento da fonte para o aplicativo, provavelmente porque rola algo de gerar as imagens da fonte para a exibição, dai fica definido o tamanho, e no mesmo xml é possivel trocar o nome da fonte também.

    <FontName>Kootenay</FontName>

    <Size>12</Size>

segundo a microsoft, http://msdn.microsoft.com/en-us/library/bb447673.aspx
, as fontes que podem ser distribuídas de grátis com os jogos são:

• Kooten.ttf
• Linds.ttf
• Miramo.ttf
• Bold Miramob.ttf
• Peric.ttf
• Pericl.ttf
• Pesca.ttf
• Pescab.ttf

Em minha exploração atual enfrentei algumas duvidas que foram interessantes: ao movimentar o personagem pela tela os movimentos para baixo e para a a direita nao permitiam que o personagem ficasse colado no obstáculo, mantendo sempre uma certa distância, e o segundo que ocorreu logo apos quando tentei exibir no personagem a posicao na tela, que foi como carregar e exibir texto.

vamos por partes, esta tela abaixo mostra o resultado do esforço de debugar o movimento do personagem na tela, exibindo a posição atual na janela

e depois na interface escolha Spritefont

primeiro quanto a discussão do movimento para baixo e para a direita, o trecho de código abaixo mostra como fiz a implementação dos tratadores de eventos isolada da implementação do Sprite e do bloco principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;

namespace ChickenMaze
{
class EventKeyboardDown: EventHandler
{
protected Sprite sprite;
protected Map map;

public EventKeyboardDown(EventManager manager, Sprite sprite, Map map)
: base(EventHandler.EventType.KEYBOARD_DOWN, manager)
{
this.sprite = sprite;
this.map = map;
}

public override void run(Object source) {

int x = (int)sprite.Position.X;
int y = (int)sprite.Position.Y + sprite.speed;

if (map.IsAvailable(x + sprite.GetWidth()-1, y + sprite.GetHeight()-1)
&& map.IsAvailable(x, y + sprite.GetHeight()-1))
{
sprite.Position.Y = y;
}
else
{
manager.trigger(this, EventHandler.EventType.CANT_MOVE_THERE);
}

}

}
}

A chave da solução do problema esta no fato de comparar os pontos -1 hehehe bobagem pura da minha parte, porque se estou por exemplo no ponto 60 e somo 60 com certeza nao vou poder colocar este ponto numa posicao 120 porque 60+60 = 120 e estando 120 ocupado a resposta vai ser sempre, ok, ali nao pode, mas se faço a comparação com -1 ai sim vou testar o ultimo pixel do bloco que estou movimentando.

Outra questão é desenhar o texto, que não teve mistério, o mistério foi descobrir como carregar a fonte o trecho abaixo exibe o texto

public static void DrawText(string text, Vector2 position)
{
spriteBatch.DrawString(spriteFont, text, position, Color.White);
}

e para carregar uma fonte basta criar uma nova sprite font que eh uma referencia dentro do projeto para uma fonte que vai ser carregada na hora de gerar o projeto para deploy, clique com o botão direito em content conforme a figura abaixo

e no codigo fonte faça referência ao Spritefont criado

spriteFont = Content.Load(“SpriteFont1″);

agora vou empacotar o pxóximo post trocando a caixinha amarela pela galinha e preparar as explicações de como foi organizado o código

http://msdn.microsoft.com/en-us/library/bb194906.aspx

bem ainda não é quase nada, mas pelo menos os sprite esta se movendo na tela =)

Tem a classe Sprite que eh uma variação da classe usada em http://www.xnadevelopment.com/tutorials/thewizard/theWizard.shtml e a classe principal do jogo em si Game1.

o que acontece eh que no método update() da classe do jogo verifico o estado do teclado e de acordo com este estado chamo métodos do objeto chicken para mover pela tela.

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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace ChickenMaze
{
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Sprite chicken;

public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = “Content”;
}

protected override void Initialize()
{
chicken = new Sprite(“chicken”);
base.Initialize();
}

protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
chicken.LoadContent(this.Content);
}

protected override void UnloadContent()
{
}

protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();

UpdateKeyboard(Keyboard.GetState());
base.Update(gameTime);
}

public void UpdateKeyboard(KeyboardState keyboardState)
{

if( keyboardState.IsKeyDown(Keys.Left)){
chicken.Left();
}

if (keyboardState.IsKeyDown(Keys.Right))
{
chicken.Right();
}

if (keyboardState.IsKeyDown(Keys.Down))
{
chicken.Down();
}

if (keyboardState.IsKeyDown(Keys.Up))
{
chicken.Up();
}

}

protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
spriteBatch.Begin();
chicken.Draw(spriteBatch);
spriteBatch.End();
base.Draw(gameTime);
}
}
}

e na classe Sprite esta a carga da imagem e posicionamento da imagem na hora do desenho.

using System;
using System.Collections.Generic;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace ChickenMaze
{
class Sprite
{
private int speed = 5;
private string assetName;

public Sprite(string assetName)
{
this.assetName = assetName;
}

//The current position of the Sprite
public Vector2 Position = new Vector2(0,0);

//The texture object used when drawing the sprite
private Texture2D mSpriteTexture;

//Load the texture for the sprite using the Content Pipeline
public void LoadContent(ContentManager theContentManager)
{
mSpriteTexture = theContentManager.Load(this.assetName);
}

//Draw the sprite to the screen
public void Draw(SpriteBatch theSpriteBatch)
{
theSpriteBatch.Draw(mSpriteTexture, Position, Color.White);
}

public void Left()
{
Position.X -= speed;
}

public void Right()
{
Position.X += speed;
}

public void Down()
{
Position.Y += speed;
}

public void Up()
{
Position.Y -= speed;
}

}
}

arre o primeiro sprite na tela a gente nunca esquece !!

olha que belo o codigo !!

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;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace WindowsGame1
{

public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;

Vector2 mPosition = new Vector2(0, 0);

Texture2D mSpriteTexture;

public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = “Content”;
}

protected override void Initialize()
{
base.Initialize();
}

protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
mSpriteTexture = this.Content.Load(“alien”);
}

protected override void UnloadContent()
{
}

protected override void Update(GameTime gameTime)
{
// Allows the game to exit
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();

base.Update(gameTime);
}

protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);

spriteBatch.Begin();
spriteBatch.Draw(mSpriteTexture, mPosition, Color.White);
spriteBatch.End();

base.Draw(gameTime);
}
}
}

hauhauhuaa lembrei dos meus tempos de clipper summer 87 e os famigerados comandos de posicionamento de cursor na tela e fazer interfaces magicas em modo texto !! veja que legal este experimento de colocar os cursores nos seus lugares !!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
class ConsolePosition
{
static void Main(string[] args)
{
Console.Title = “back to clipper summer 87 !!”;
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.WindowLeft = Console.WindowTop = 0;
Console.WindowHeight = Console.BufferHeight = 30;
Console.WindowWidth = Console.BufferWidth = 80;

int[] numbers = {1,2,3,4,5,6,7};
foreach(int n in numbers){
Console.SetCursorPosition(n,n);
Console.Write(“#”);
}
}
}
}

deu ateh vontade de fazer um joguinho bem bocó de mexer um treco na tela hehehehe

outros exemplos parecidos
http://msdn.microsoft.com/en-us/library/system.console.setwindowposition.aspx
http://nodstrum.com/2007/11/09/matrix-code-in-c/

ao menos duas formas de percorrer uma matriz

using System;

namespace foo
{
class numbersAreGreat{
static void Main (string[] args){
string[] numbers = {“one”, “two”, “three”, “four”, “five”};
if (args.Length > 0)
{
int number = int.Parse(args[0]);
if (number <= 0)
{
Console.WriteLine("please more than zero");
}
else
if (number > numbers.Length)
{
Console.WriteLine(“{0} is greater than we can understand…”, number);
}
else
{
Console.WriteLine(“thanks for the {0} ! “, numbers[number - 1]);
}
}
else
{
Console.WriteLine(“would be a big effort to inform an integer ?”);
}

}
}
}

Neste experimento rolou de declarar array inline, fazer teste de parametros da linha de comando, display no console, fomatação de mensagem do tipo printf() que deu pra reparar eh com {0}, que por sinal eh do mesmo jeito nos arquivos de resource do struts, coincidência ? =)

using System;

namespace foo
{
class numbersAreGreat{
static void Main (string[] args){
string[] numbers = {“one”, “two”, “three”, “four”, “five”};
if (args.Length > 0)
{
int number = int.Parse(args[0]);
if (number <= 0)
{
Console.WriteLine("please more than zero");
}
else
if (number > numbers.Length)
{
Console.WriteLine(“{0} is greater than we can understand…”, number);
}
else
{
Console.WriteLine(“thanks for the {0} ! “, numbers[number - 1]);
}
}
else
{
Console.WriteLine(“would be a big effort to inform an integer ?”);
}

}
}
}