I've posted this similar code a month or so ago, I'm back working on it. This time I am using OpenLayer.

I am trying to create a 2D tiling engine. The tiles are not tiling correctly and there must be a memory leak because my processor is using 100% right now >.< (It's making typing hard and I don't want to restart until I finish this)
First here are the resources I am using and a screen shot:
Output:
{"name":"errorns2.png","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/b\/b\/bbc6fb5e4cd202edcafe68147998ffd0.png","w":626,"h":512,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/b\/b\/bbc6fb5e4cd202edcafe68147998ffd0"}
tile.bmp
http://img227.imageshack.us/img227/4897/tilefq0.png
Here is majority of the code:
FYI: m_* Variables are members of that class
main.cpp

Tile.cpp

Map.cpp

firstmap.LoadMap((int *)&map, 21, 16, 1); I've switched it between those before and it had no effect via compile time but I switched it back to how you thought it should be.

int Column     = Xpos;
int Row        = Ypos;

This sets it so when you call cMap::Draw() You can set the topleft coords to draw. Normally this would be 0,0 But the map can be bigger than the tiles you can display on the screen so we are going to want to change that position a lot. With a map 100x100tiles you are going to want to draw the rest of the map sometimes :-D. In my example program Column and Row are set to 0.

Does anyone know of a way to get Two-Dimensional data out of a One-Dimensional array?

Still hasn't solved my problem :-( I've narrowed it down though. Something is going wrong with the inputs to cTile::Draw(). Its inputing some huge number as the TileNumber. So it must be something wrong with my loop inside of cMap::Draw();

I know this is not related to your problem, I just felt like pointing it out.

bool cTile::LoadTileSet(char* filename, int TileWidth, int TileHeight)
{
     m_Filename          = filename;
     if((m_TileWidth = TileWidth) <= 0 || (m_TileHeight = TileHeight) <= 0)
          return false;
     ...

In these few lines of code, I can spot some issues that might be problematic. Let's have a closer look, shall we? if((m_TileWidth = TileWidth) <= 0: Making use of side-effects never is a good idea. Why? Because it makes the code harder to read, and thus also harder to understand. Let's assume this method is called with 0 for TileWidth and some other value for TileHeight (not important). LoadTileSet will return false as expected, only that the internal state of this cTile instance now is really messed up. m_TileHeight wasn't assigned the value we passed, so it is probably uninitialized. m_TileWidth is 0, even though this is an incorrect value. m_Filename will hold the value of filename, even though the loading failed.

     m_TileHeight   = TileHeight;
     m_TileWidth    = TileWidth;

These lines are absolutely unnecessary if you keep the assignments in the previous if clause (which I advise you not to!).

My point is, you make it hard for anyone to determine the exact footprint (i.e., postcondition if you prefer that term) for all possible input data. I'm guessing you are not overriding or implementing LoadTileSet, so for starters you could declare both TileHeight and TileWidth as unsigned int. This rules out negative numbers and makes that fact also obvious on first sight.

Keeping the state of the object clear might work like this:

Alright, to wrap it up, always expect the worst to happen. Think through the cases with bad input and all combinations of them, and try to catch as many of them as you possibly can. Define what exactly a method should do (like, change any of the object's members only if successful, and on error leave the object entirely untouched). I can almost certainly assure you that this thinking will help the prevention of many bugs.

This might not help you right now, but hopefully you can use it in the long run.

Best choice is probably std::string

This is still wrong.
Example:

0 0 0 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

if the upper-left 0 is at the position (0,0), you want element (3,2). So how do you calculate the one-dimensional index? Each row has 7 numbers (m_Width in your case). So if we want row 2 we say 2 * m_Width, which is 2*7 = 14. Then we simply add the column index, 14 + 3 = 17. Let's count (beginning with 0).. it is RIGHT!
So your formula would be Row * m_Width + Column.

And if that doesn't work (another error somewhere else?) you should add debugging output like the following:
Original code

          while(Column < m_Width && Xpixel < screenWIDTH)
          {
               TileNumber = m_Map[Row * m_Width + Column];
               m_Tiles->DrawTile(TileNumber, (float)Xpixel, (float)Ypixel);
               Column++;
               Xpixel += m_Tiles->GetTileWidth();
          }

With debugging output:

          while(Column < m_Width && Xpixel < screenWIDTH)
          {
               int arrayIndex = Row * m_Width + Column;
               printf("Row: %d, Column: %d, ArrayIndex: %d, ",Row,Column,arrayIndex); 
               TileNumber = m_Map[arrayIndex];
               printf("TileNumber: %d\n",TileNumber);
               m_Tiles->DrawTile(TileNumber, (float)Xpixel, (float)Ypixel);
               Column++;
               Xpixel += m_Tiles->GetTileWidth();
          }

That will give you a lot of output, so you should redirect it to a file. Then you can check the following: Your map array in the test case is 16*21, so ArrayIndex mustn't be bigger than (16*21) = 336!

I know. printf() outputs to the standard output, so if you are smart you compile your program as a console application, start it from terminal in windowed mode and then look at the output in the terminal. You can also start it like
program.exe >log.txt
to output into a file. Or you directly write to a file, by using ofstream or fprintf().