I've been looking through the other questions but just can't seem to figure this out.. I'm using XNA in a custom tilemap loader. Here is the code.
http://pastebin.com/cuatQHTb
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 Pressure
{
public class Game1 : Microsoft.Xna.Framework.Game
{
GraphicsDeviceManager graphics;
SpriteBatch spriteBatch;
Texture2D player;
Vector2 pos = Vector2.Zero;
Vector2 playersp = new Vector2(50.0f, 50.0f);
Texture2D road1;
Texture2D road2;
Texture2D brickwall;
Texture2D floor1;
Texture2D floor2;
Texture2D floor3;
Texture2D grass;
Texture2D sidewalk1;
Texture2D wood;
Texture2D road3;
private Vector2 origin;
KeyboardState currentState;
Camera camera = new Camera();
Vector2 motion;
List<Texture2D> tiles = new List<Texture2D>();
static int tileWidth = 64;
static int tileHeight = 64;
int tileMapWidth;
int tileMapHeight;
static int screenWidth;
static int screenHeight;
static int mapWidthInPixels;
static int mapHeightInPixels;
int[,] map = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 5, 6, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 7, 5, 6, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 8, 1, 1, 1, 2, 2, 1, 8, 7, 5, 6, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 8, 1, 1, 1, 2, 2, 1, 8, 7, 5, 5, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 8, 1, 1, 1, 1, 1, 1, 8, 7, 5, 5, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 8, 1, 3, 3, 3, 1, 1, 8, 7, 5, 6, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 8, 8, 1, 1, 8, 8, 8, 8, 7, 5, 6, 5, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 5, 6, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,},
{5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,},
{9, 9, 9, 5, 5, 9, 9, 9, 5, 5, 9, 9, 9, 5, 5, 5, 5, 5, 9, 9, 9, 5, 5, 9, 9, 9, 5, 5, 9,},
{5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,},
{7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
};
public static int ScreenWidth
{
get { return screenWidth; }
}
public static int ScreenHeight
{
get { return screenHeight; }
}
public static int MapWidthInPixels
{
get { return mapWidthInPixels; }
}
public static int MapHeightInPixels
{
get { return mapHeightInPixels; }
}
public Game1()
{
graphics = new GraphicsDeviceManager(this);
Content.RootDirectory = "Content";
}
protected override void Initialize()
{
base.Initialize();
}
protected override void LoadContent()
{
spriteBatch = new SpriteBatch(GraphicsDevice);
player = Content.Load<Texture2D>("haz");
origin.X = player.Width /2;
origin.Y = player.Height /2;
grass = Content.Load<Texture2D>("grass");
floor1 = Content.Load<Texture2D>("floor1");
floor2 = Content.Load<Texture2D>("floor2");
floor3 = Content.Load<Texture2D>("floor3");
wood = Content.Load<Texture2D>("wood");
road1 = Content.Load<Texture2D>("road1");
road2 = Content.Load<Texture2D>("road2");
sidewalk1 = Content.Load<Texture2D>("sidewalk1");
brickwall = Content.Load<Texture2D>("brickwall");
road3 = Content.Load<Texture2D>("road3");
tiles.Add(grass); //0
tiles.Add(floor1);//1
tiles.Add(floor2);//2
tiles.Add(floor3);//3
tiles.Add(wood);//4
tiles.Add(road1);//5
tiles.Add(road2);//6
tiles.Add(sidewalk1);//7
tiles.Add(brickwall);//8
tiles.Add(road3);//9
tileMapWidth = map.GetLength(1);
tileMapHeight = map.GetLength(0);
mapWidthInPixels = tileMapWidth * tileWidth;
mapHeightInPixels = tileMapHeight * tileHeight;
screenWidth = GraphicsDevice.Viewport.Width;
screenHeight = GraphicsDevice.Viewport.Height;
}
protected override void UnloadContent()
{
}
private float RotationAngle;
private float oldx;
private float oldy;
protected override void Update(GameTime gameTime)
{
oldx = playersp.X;
oldy = playersp.Y;
currentState = Keyboard.GetState();
pos = playersp;
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
this.Exit();
IsMouseVisible = true;
MouseState Mouses = Mouse.GetState();
Vector2 mouseLook = new Vector2(Mouses.X, Mouses.Y);
motion = Vector2.Zero;
Vector2 direction = (playersp ) - mouseLook;
float angle = (float)(Math.Atan2(direction.Y, direction.X));
RotationAngle = angle ;
if (currentState.IsKeyDown(Keys.W))
{
if (playersp.Y > screenHeight /4)
{
playersp.Y = playersp.Y - 1;
}
else
{
ScrollUp();
}
}
if (currentState.IsKeyDown(Keys.A))
{
if (playersp.X > screenWidth / 4)
{
playersp.X = playersp.X - 1;
}
else
{
ScrollLeft();
}
}
if (currentState.IsKeyDown(Keys.S))
{
if (playersp.Y > screenHeight / 1.5f)
{
ScrollDown();
}else{
playersp.Y = playersp.Y + 1;
}
}
if (currentState.IsKeyDown( Keys.D))
{
if (playersp.X > screenWidth / 1.5f)
{
ScrollRight();
}
else
{
playersp.X = playersp.X + 1;
}
}
if (motion != Vector2.Zero)
{
motion.Normalize();
camera.Position += motion * camera.Speed;
}
base.Update(gameTime);
}
private void ScrollUp()
{
motion.Y = -0.5f;
}
private void ScrollRight()
{
motion.X = 0.5f;
}
private void ScrollDown()
{
motion.Y = 0.5f;
}
private void ScrollLeft()
{
motion.X = -0.5f;
}
private Point VectorToCell(Vector2 vector)
{
return new Point(
(int)(vector.X / tileWidth),
(int)(vector.Y / tileHeight));
}
private Vector2 ViewPortVector()
{
return new Vector2(
screenWidth + tileWidth,
screenHeight + tileHeight);
}
protected override void Draw(GameTime gameTime)
{
GraphicsDevice.Clear(Color.CornflowerBlue);
DrawMap();
base.Draw(gameTime);
}
private void DrawMap()
{
Point cameraPoint = VectorToCell(camera.Position);
Point viewPoint = VectorToCell(camera.Position +
ViewPortVector());
Point min = new Point();
Point max = new Point();
min.X = cameraPoint.X;
min.Y = cameraPoint.Y;
max.X = (int)Math.Min(viewPoint.X, map.GetLength(1));
max.Y = (int)Math.Min(viewPoint.Y, map.GetLength(0));
Rectangle tileRectangle = new Rectangle(
0,
0,
tileWidth,
tileHeight);
spriteBatch.Begin();
for (int y = min.Y; y < max.Y; y++)
{
for (int x = min.X; x < max.X; x++)
{
tileRectangle.X = x * tileWidth - (int)camera.Position.X;
tileRectangle.Y = y * tileHeight - (int)camera.Position.Y;
spriteBatch.Draw(tiles[map[y, x]],
tileRectangle,
Color.White);
spriteBatch.Draw(player, pos, null, Color.White, RotationAngle,
origin, 1.0f, SpriteEffects.None, 0f);
}
}
spriteBatch.End();
}
}
}
How would I detect the tiles position and make sure the player doesn't enter that tile? thanks!
You could do something like this:
private static float scalingFactor = 10;
private static float mapSizeX = 19;
private static float mapSizeY = 29;
in Update:
if (playersp.Y > screenHeight /4) {
int mapX = (int) (playersp.X / scalingFactor);
int mapY = (int) (playersp.Y / scalingFactor) - 1;
if (isMovable(mapX, mapY)) {
playersp.Y = playersp.Y - scalingFactor;
}
} else {
ScrollUp();
}
and a new method:
public bool isMovable(int mapX, int mapY)
{
if (mapX < 0 || mapX > 19 || mapY < 0 || mapY > 29) {
return false;
}
int tile = map[mapX, mapY];
if (tile == 4 || tile == 8) {
return false;
}
return true;
}
Similarly for the other directions.
The above code calls the function isMovable to decide whether the player can move to the new location based on the type of tile stored in the map at that position. The decision is false (the player cannot move there) if it is wood or brick wall, otherwise it is true.
The scaling factor is to map between the screen position (captured in playersp) and the tile map. In this case each tile is equivalent to 10 screen "pixels" (You can break it into two separate scales if you want to: one for X dimention, the other for Y).
Note, you need to make sure the values mapSizeX and mapSizeY are correct.
It would be best if you introduced named constants for the type of tile instead of using the numbers -- it will make your code more readable (for you in the future and for others reading it).
EDIT: updated code & explanation
Related
I am trying to have a loop read a multidimensional array defined in a separate class to place objects at the start of a game.
This is the Start function code from the LevelStart class:
void Start () {
//Get Level
Levels levels = ScriptableObject.CreateInstance<Levels>();
level = levels.GetLevel (levelName);
x = level.GetLength(1);
y = level.GetLength (2);
temp = GameObject.Find ("temp").GetComponent<Temp>();
lPos = temp.GetLevelNum() - 1; //Chosen Level
//Read array and place objects
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
if (level[lPos,i,j] == 1) {
Debug.Log ("Spawn Point");
}
else if (level[lPos,i,j] == 2) {
Debug.Log ("Hole");
}
else if (level[lPos,i,j] == 3) {
Debug.Log ("Obstacle");
}
else
Debug.Log ("Open Space");
}
}
}
And the class holding the arrays is Levels.cs:
public int[,,] cave = new int[,,] {
{ //Level 1
{ 0, 0, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0},
{ 3, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 3, 0, 0},
{ 0, 3, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0},
{ 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 3, 0, 0, 0},
{ 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 3, 0},
{ 0, 0, 3, 0, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0},
{ 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0},
{ 0, 0, 3, 0, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0},
{ 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{ 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 3, 0, 0, 0}
},
{ //Level 2
{ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0 },
{ 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0 },
{ 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 3, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 3, 0, 0 },
{ 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0 },
{ 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0 }
}
};
It reads most of the array correctly but positions such as [0,0,0] and [0,0,12] returns 3's when it should be 0
Thanks in advance
Seems to me to be pretty likely that you're simply using the wrong level number - code that is not shown. I suggest using the print statement to ensure temp.GetLevelNum() and lPos are the numbers you think they should be.
I am using C# in a console application.
I need to load data from a text file and load it into a 2d array.
This is what I tried, but when I try to print out the contents of what gets returned nothing gets printed.
public static int[,] LoadMap()
{
const string path = #"1.txt";
string[] fileLines = File.ReadAllLines(path);
int[,] map = new int[fileLines.Length, 15];
string line;
for (int i = 0; i < fileLines.Length; ++i)
{
line = fileLines[i];
for (int j = 0; j < line.Length; ++j)
{
map[i, j] = (int)(line[j] - '0');
}
}
return map;
}
But when I hardcode the data like that, then everything gets displayed perfectly.
private static int[,] Map = new int[MapX, MapY]
{
{ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};
The data in the text file looks like that :
0,0,0,1,1,1,1,1,1,1,1,1,1,1,1
0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
0,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0,0,0,0,0,1
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
Any help will be appreciated whether you fix what I tried or propose something completely different, thanks.
string[] fileLines = File.ReadAllLines(path);
int[,] map = new int[fileLines.Length,fileLines[0].Split(',').Length];
for (int i = 0; i < fileLines.Length; ++i)
{
string line = fileLines[i];
for (int j = 0; j < map.GetLength(1); ++j)
{
string[] split = line.Split(',');
map[i, j] = Convert.ToInt32(split[j]);
}
}
return map;
}
You could use LINQ to parse the lines:
var lines = File.ReadAllLines(path);
int[,] map = new int[fileLines.Length, 25];
for (int i = 0; i < fileLines.Length; ++i)
{
var data = lines[i].Split(',').Select(c => Convert.ToInt32(c)).ToList();
for(int j =0; j<25; ++j)
map[i,j] = data[j];
}
return map;
If you could use a jagged array instead of a 2D array, this becomes simpler:
public static int[][] LoadMap()
{
return File.ReadLines(path)
.Select(l => l.Split(',').Select(Convert.ToInt32).ToArray())
.ToArray();
}
If your text file has commas separating the values, replace this line:
for (int j = 0; j < line.Length; ++j)
With:
for (int j = 0; j < line.Length; j += 2)
That's assuming your values will always be only 1 char long.
When the data comes in from the text file. If it is separated by a comma you can separate it using string.split. Then you load what you get into an array and access it like you normally would do an array.
Like below:
string[] lines = System.IO.File.ReadAllLines(#"path");
foreach (string line in lines)
{
string[] first= line.Split(comma);
}
I'm trying to port a desencrypt function i have in Delphi to C#.
in delphi i use the function Move to get data into memory using a pointer, so i tried to use the marshal.copy function with the same results but sometimes i get an acces violation exception and sometimes blank spaces.
leave attached the code of the function.
Any ideas? Thanks a lot!
public string prDecode(string s)
{
byte[] ArrayMap = new byte[256] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59,60,
61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int I;
char[] ArrayS = s.ToCharArray(0, s.Length);
string resultado = "";
char[] ArrayR = resultado.ToCharArray(0, resultado.Length);
switch (s.Length)
{
case 2:
I = ArrayMap[ArrayS[0]] + (ArrayMap[ArrayS[1]] << 6);
ArrayR = new char[1];
Marshal.Copy((IntPtr)I, ArrayR, 0, ArrayR.Length);
break;
case 3:
I = ArrayMap[ArrayS[0]] + (ArrayMap[ArrayS[1]] << 6) +
(ArrayMap[ArrayS[2]] << 12);
ArrayR = new char[2];
Marshal.Copy((IntPtr)I, ArrayR, 0, ArrayR.Length);
break;
case 4:
I = ArrayMap[ArrayS[0]] + (ArrayMap[ArrayS[1]] << 6) +
(ArrayMap[ArrayS[2]] << 12) + (ArrayMap[ArrayS[3]] << 18);
ArrayR = new char[3];
Marshal.Copy((IntPtr)I, ArrayR, 0, ArrayR.Length);
break;
}
string clave = new string (ArrayR);
return clave;
}
I think the function you're looking for is Array.Copy or Buffer.BlockCopy rather than Marshal.Copy. Marshal.Copy is for copying data to and from unmanaged memory.
There's no need to use Marshal unless you are accessing unmanaged memory for legacy code. Managed code has no need for pointers & using managed methods will be much quicker.
What you're looking for I think, is Array.Copy to copy between arrays using managed code.
I am trying to setup a 2d array in C# to act as a maze to move a character around, I am having a few issues initialising the array, I am trying to do the below
but the InitialiseMaze method is saying the maze is not declared
Can anyone advise
thanks
simon
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace GameMan
{
public class Maze
{
#region Variables
static int[,] maze;
#endregion
#region Constructors/Destructors
public Maze()
{
InitaliseMaze();
}
~Maze()
{
}
#endregion
#region Methods
public void InitaliseMaze()
{
maze = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 3, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 0, 0, 3, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 2, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0},
{0, 0, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 1, 1, 4, 1, 1, 1, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 2, 1, 1, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1},
{0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 1, 1, 1, 1, 1, 1, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 2, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 0 ,0, 2, 0, 0},
{0, 0, 3, 2, 0, 2, 2, 2, 2, 2, 5, 2, 2, 2, 2, 2, 0, 2, 3, 0, 0},
{0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 0},
{0, 0, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0},
{0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
}
#endregion
}
}
You can't initialize an array like that other than in a variable declaration. However, the change is simple:
maze = new int[,] {
// As before
};
As asides:
It looks like maze should be an instance variable rather than a static variable. After all, you're initializing it each time you create an instance of Maze
You have a finalizer for no reason. Finalizers are very rarely required (or indeed advisable) in C#
Ok, well here is some extract from the msdn :
int[,] myArray = {{1,2}, {3,4}, {5,6}, {7,8}};
extracted from MSDN multidimensional arrays
you should also read up concerning Destructors, finalizers etc ... , I bet your coming from C++ ? Differences between the 2 languages arent always obvious :).
Just to make Jon's post a bit clearer:
maze = new int[,]{
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 3, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 0, 0, 3, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 2, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 2, 0, 0},
{0, 0, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 1, 1, 4, 1, 1, 1, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 2, 1, 1, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1},
{0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 1, 1, 1, 1, 1, 1, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 2, 0, 0, 2, 0, 0, 0, 2, 0, 2, 0, 0, 0, 2, 0 ,0, 2, 0, 0},
{0, 0, 3, 2, 0, 2, 2, 2, 2, 2, 5, 2, 2, 2, 2, 2, 0, 2, 3, 0, 0},
{0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 0},
{0, 0, 2, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 0, 2, 2, 2, 2, 0, 0},
{0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0},
{0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
Boy, that was a big maze array...
You need to declare maze
numbers = new int[X,Y]; where X and Y are how big it is
Two-Dimensional Arrays
The simplest form of the multidimensional array is the 2-dimensional array. A 2-dimensional array is a list of one-dimensional arrays.
A 2-dimensional array can be thought of as a table, which has x number of rows and y number of columns. Following is a 2-dimensional array, which contains 3 rows and 4 columns −
Two Dimensional Arrays in C#
Thus, every element in the array a is identified by an element name of the form a[ i , j ], where a is the name of the array, and i and j are the subscripts that uniquely identify each element in array a.
Initializing Two-Dimensional Arrays
int [,] a = new int [3,4] {
{0, 1, 2, 3} , /* initializers for row indexed by 0 */
{4, 5, 6, 7} , /* initializers for row indexed by 1 */
{8, 9, 10, 11} /* initializers for row indexed by 2 */
};
Explain above code:
new int [**3**,4] **3** denoting to rows like how may object in array
eg:
{0, 1, 2, 3} ,
{4, 5, 6, 7} ,
{8, 9, 10, 11}
new int [3,**4**] **4** denoting to columns like total value in object (4 columns)
eg:
{0, 1, 2, 3}
Let us check the program to handle a two dimensional array
using System;
namespace ArrayApplication {
class MyArray {
static void Main(string[] args) {
/* an array with 5 rows and 2 columns*/
int[,] a = new int[5, 2] {{0,0}, {1,2}, {2,4}, {3,6}, {4,8} };
int i, j;
/* output each array element's value */
for (i = 0; i < 5; i++) {
for (j = 0; j < 2; j++) {
Console.WriteLine("a[{0},{1}] = {2}", i, j, a[i,j]);
}
}
Console.ReadKey();
}
}
}
Output:
a[0,0]: 0
a[0,1]: 0
a[1,0]: 1
a[1,1]: 2
a[2,0]: 2
a[2,1]: 4
a[3,0]: 3
a[3,1]: 6
a[4,0]: 4
a[4,1]: 8
ok i know this has been beat to death but i can't seam to get all the ones on google here or anyplace to work
i have a string that looks like this
1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
i store this string
each digit has a range from 0 to 254 and the string is almost random
i need to convert this to a byte array because of a hardware
change
this is what the hardware is looking for
hardware.command(DeviceID, byte[]);
i tested the hardware by doing this
hardware.command(1, new byte[] { 0, 0, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38 });
and all was good
each part is a PWM output percentage on the hardware
this updates every 4ms so it has to be somewhat fast
I don't know if this satisfies your performance requirements, but the easiest way would be to use LINQ:
var myByteArray = (from s in myString.Split(',') select byte.Parse(s)).ToArray();
EDIT: I originally wrote byte.Parse(s.Trim()), but Byte.Parse does not mind surrounding whitespace.
Try something like this:
string datastring = "1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0";
byte[] data = datastring.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(s => byte.Parse(s)).ToArray();
or, without LINQ:
var datastring = "1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0";
var tokens = datastring.Split(',');
byte[] data = new byte[tokens.Length];
for (int i = 0; i < tokens.Length; i++) {
data[i] = byte.Parse(tokens[i]);
}
String[] substringArray = String.Split(',');
List<Bytes> listOfBytes = new List<Bytes>();
foreach(String substring in substringArray )
{
substring = substring.Trim();
listOfBytes.Add(Byte.Parse(substring));
}
Byte [] byteTable = listOfBytes.ToArray();