Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Reelya]

You need to focus on data structures and how to work with them. Much of programming is having a toolkit of "solutions" (aka "patterns) to very simple problems, and being able to recognize when you can re-use one of those solutions to make whatever you need. And be able to refactor existing code in small steps. "knowing everything at the start" isn't how programming works. You break problems down into easier to understand components, and build up from the simplest system, in a consistent way.

e.g. the "Marines" example is a good test case. Say you want 10 marines, each marine is going to have stats and weapons. Start by just having an array of 10 ints, with each int holding "weapon type", with hard-coded weapons in code (e.g. "if (weaponType[ i ] == 2) cout << "power sword" etc). Try and make this, with just 2-3 weapon types.

So what's the logical next step here? Do only one thing. There are two choices. You could either improve the "marines" system, or you could improve the "weapons" system.

The weapon system obviously sucks since you have to edit the if statements whenever the weapon name gets printed out. So you can make an array of strings, which holds the weapon names. Hard-code this array, but use the marine's int to look up the value.

After you have the weapon look-up table working you can think of adding more data to the marines (each marine is just an int right now). The way to do this is refactoring. Make a struct which only holds a single int, then replace the int in the array with your struct. Re-wire all the references to the array to access the int.

Now, the above changes don't actually change what the program does, but they are the sort of framework-improving code that's critical to making the program better. Putting the weapon types into a table means it's much quicker to add new weapon types, and turning the marines into a struct allows you to add new variables for each marine more easily.

[Spehss _]

What's some methods of organizing data for something like a roguelike dungeon? I'm fiddling around with writing a dungeon generation algorithm. Maps consists of Tile objects which contain all the data pertaining to a single space of a dungeon. I was using a two dimensional array to hold all the Tile objects. It works but I'm starting to wonder if there's alternative and/or better ways. It feels clunky to have to specify the size of the 2nd dimension in the array every time I write a new function that takes that array as an argument.

One thing that comes to mind is a single dimensional array and each Tile in the array contains two ints for the x and y coordinate of that Tile.

[EnigmaticHat]

That's how I do it.  There's a simple formula you can use to turn the position in the array into the coordinates, assuming tiles were entered into the array in ascending order of x values first and then y values, and you know the width and height of your dungeon.

Where n = position in the array, x and y are the coordinates in integers:

y = n / width
x = n % width

You can also invert it with:

n = y * width + x

[Reelya]

What's some methods of organizing data for something like a roguelike dungeon? I'm fiddling around with writing a dungeon generation algorithm. Maps consists of Tile objects which contain all the data pertaining to a single space of a dungeon. I was using a two dimensional array to hold all the Tile objects. It works but I'm starting to wonder if there's alternative and/or better ways. It feels clunky to have to specify the size of the 2nd dimension in the array every time I write a new function that takes that array as an argument.

One thing that comes to mind is a single dimensional array and each Tile in the array contains two ints for the x and y coordinate of that Tile.

That method would have too much memory and speed overhead. Though it's useful to have separate data for creatures and objects that stores its own location.

The real solution is to not pass raw arrays around. Make a level object and pass a pointer/reference to that. The level object contains an array and x/y size information, plus any other level-specific stuff. Additionally, you set it up so that the array can by dynamically sized.

That's where EnigmaHat's idea comes in. Making a dynamic actual 2D array in C++ is a pain in the ass:
http://stackoverflow.com/questions/936687/how-do-i-declare-a-2d-array-in-c-using-new
When you make a static 2D array, it's tightly packed in memory and unpacks using the x/y values to look up the location. When you make a dynamic 2D array, it's done in a bullshit way with a for loop and a pointers-to-pointers, which means it needs to deference TWO pointers each time you access a map tile.

So what's better? make a 1D pointer, then wrap that inside your own custom container, which treats it like a 2D array. The only caveat is that you reference tiles by tile(x,y) rather than tile[ x ][ y ]

Spoiler (click to show/hide)

Code: [Select]

class Level
{
   int sizex; // map size x
   int sizey; // map size y
   char* floor;
   InitLevel(int x, int y)
   {
      sizex = x;
      sizey = y;
      floor = new char[x * y];
   }

   ~Level()
   {
      delete [] floor;
   }
   
   char &Floor(int x, int y)
   {
      return floor[y * sizex + x];
   }
}

Level level;
level.InitLevel(80,25);
level(0,0) = '#';
// etc


There you have a nice basic dynamic-sizable "2D" array class, and you only need to pass 1 parameter around, which is faster.

[ancistrus]

There is this program that generates sql queries (oracle).
It seems most of them end with - where rownum<=0

Is there EVER a good reason for that? Its so weird I am not even sure anymore.

[miauw62]

What's some methods of organizing data for something like a roguelike dungeon? I'm fiddling around with writing a dungeon generation algorithm. Maps consists of Tile objects which contain all the data pertaining to a single space of a dungeon. I was using a two dimensional array to hold all the Tile objects. It works but I'm starting to wonder if there's alternative and/or better ways. It feels clunky to have to specify the size of the 2nd dimension in the array every time I write a new function that takes that array as an argument.

One thing that comes to mind is a single dimensional array and each Tile in the array contains two ints for the x and y coordinate of that Tile.

That method would have too much memory and speed overhead. Though it's useful to have separate data for creatures and objects that stores its own location.

The real solution is to not pass raw arrays around. Make a level object and pass a pointer/reference to that. The level object contains an array and x/y size information, plus any other level-specific stuff. Additionally, you set it up so that the array can by dynamically sized.

That's where EnigmaHat's idea comes in. Making a dynamic actual 2D array in C++ is a pain in the ass:
http://stackoverflow.com/questions/936687/how-do-i-declare-a-2d-array-in-c-using-new
When you make a static 2D array, it's tightly packed in memory and unpacks using the x/y values to look up the location. When you make a dynamic 2D array, it's done in a bullshit way with a for loop and a pointers-to-pointers, which means it needs to deference TWO pointers each time you access a map tile.

So what's better? make a 1D pointer, then wrap that inside your own custom container, which treats it like a 2D array. The only caveat is that you reference tiles by tile(x,y) rather than tile[ x ][ y ]

Spoiler (click to show/hide)

Code: [Select]

class Level
{
   int sizex; // map size x
   int sizey; // map size y
   char* floor;
   InitLevel(int x, int y)
   {
      sizex = x;
      sizey = y;
      floor = new char[x * y];
   }

   ~Level()
   {
      delete [] floor;
   }
   
   char &Floor(int x, int y)
   {
      return floor[y * sizex + x];
   }
}

Level level;
level.InitLevel(80,25);
level(0,0) = '#';
// etc


There you have a nice basic dynamic-sizable "2D" array class, and you only need to pass 1 parameter around, which is faster.

Shouldn't it be possible to overload operators so you can do Tile tile = level[x][y]?

[cerapa]

It is, but you need a secondary class for that. The overloaded [] would need to return an object that has an overloaded [] that returns the final value.

It's simpler to just make a get(int x, int y) method.

[LoSboccacc]

it is indeed possible to overload [] and it's listed under 'madness', for example if you try to use the overloaded [] on a pointer instead of a reference it'll fail because is gonna index pointer type, while for arrays it is expected to be equivalent

http://www.learncpp.com/cpp-tutorial/98-overloading-the-subscript-operator/

just use a class with a deferred array and create method on top of it to access the array.

[miauw62]

huh, didn't know it was that hard to overload [] in C++. I thought it was easy, but I may have been thinking of C#

[Ghills]

There is this program that generates sql queries (oracle).
It seems most of them end with - where rownum<=0

Is there EVER a good reason for that? Its so weird I am not even sure anymore.

Possibilities:

The coder didn't want to generate queries that could be run by someone too inexperienced to understand them.

There was an actual column 'rownum' which had some meaning,

Other han that, I've got nothing.

[TheDarkStar]

It is, but you need a secondary class for that. The overloaded [] would need to return an object that has an overloaded [] that returns the final value.

It's simpler to just make a get(int x, int y) method.

No, you can do it with one class, but iirc you have your [] overload return a pointer to something rather than an actual value. (it's been a while since I've needed it and I don't think I have the code lying around anymore, sorry)

[LoSboccacc]

It is, but you need a secondary class for that. The overloaded [] would need to return an object that has an overloaded [] that returns the final value.

It's simpler to just make a get(int x, int y) method.

No, you can do it with one class, but iirc you have your [] overload return a pointer to something rather than an actual value. (it's been a while since I've needed it and I don't think I have the code lying around anymore, sorry)

but if you return pointer you cannot call overloaded [] on it, you have to cast it out first, making it a clunky syntax mess where you overloaded to simplify a one line method call (!)

[Skyrunner]

besides, map.get(x,y) isn't all that complex compared to

Code: [Select]

map[x][y].

[lethosor]

but if you return pointer you cannot call overloaded [] on it, you have to cast it out first, making it a clunky syntax mess where you overloaded to simplify a one line method call (!)

If you're storing everything in a flat internal buffer (which appears to have been suggested above), operator[] could return a pointer to the middle of the buffer:

Code: [Select]

Thing *buffer;
Thing *operator[](int x) {
  return &buffer[x * height];  // or "buffer + (x * height)"
}

Then map[x][y] would effectively be the same as "buffer[(x * height) + y]".

I believe that's the idea TheDarkStar was getting at. Of course, it doesn't do any checking for invalid values of y, which could return items in other columns, but that's the same situation as the example for get() mentioned above. (It also relies on the data being grouped by column internally, but there may be a way to group it by row if you want, although it's an implementation detail that really shouldn't make a difference.)

[LoSboccacc]

Then map[x][y] would effectively be the same as "buffer[(x * height) + y]".

I understand that part about pointers, but I was specifically mentioning his previous idea of overloading subscripts, in which case the second [] call will be standard pointer offset and not the expected overloaded subscript unless, magic.