Tiled Maps, or Position maps

Newbie & Debugging Questions
#1

Hello,
I’m thinking about the best way to write a strategie game. as far as my imagination gets me I can think about 2 ways to implement a 2D gameworld:

  1. A Tiled Map, you make your board/field out of smaller fields, called tiles, these tiles each have the same hight and width, and are represented through an Object in your 2 Dimensional Array, that contains informations about units, buildings etc. on this tile.

  2. A positionbased map, On this kind of map the building- and unitobjects have a position object, that tells us where it is, and they also have an radius or hight and width, when you move the units on this map you change their position Object and the render method does the remaining.

I believe, the Tiled Map is the easier one to implement, but not as multifunctional as the position map, what makes the Tiled Map (at least for me) easier is, the easier posibility to build a uniue terrain. On the Tiled Map you do it with an attribute of your tile object, that says what kind of terrain it is (I would do it so), but with an position map that gets a little bit harder. My way of doing it would be to create an 2D pixel-array, that says what terrain is on which pixel, and when I’m trying to build something I check for a collision (checking every coordiante in the range of the new building for the right terrain).

My Questions are:

  1. What do you use?
  2. Maybe what do you want to use, and why? (If it’s different from question 1)
  3. How large can this 2D pixel-array be, that it’s still performant enough?
  4. Everything else you know about this topic.

Reasons for me asking:
I’m thinking about writing a strategy game, that gives you as much freedom as possible, and for that I want to implement a “position map” that let’s the user build and move everything as exact as possible.

Greetings
biro

#2

A tile map helps with rendering. You only need to render the part of the map that if visible on the screen. You can also make the tiles smaller. Say your objects are 32 pixels you can make each tile 16. This will give more flexibility with placement. (This is what I’m currently working with).
With a position based map, do you need to fill every pixel? As in, can you use a blanket background to cover the area, like grass, then only place elements that can’t be built on, like mountains and trees. Doing that you would only need to check the collision of the objects, not every pixel.

#3

I’ve just gone through exactly the same process. The solution I used was to create maps using tiles of terrain and then to allow per-pixel positioning and movement of entities on top of it. Each tile contains all its own per-pixel information that can be queried when an entity moves over it, but because tiles are being reused throughout the map it doesn’t suffer the memory issues of an explicit huge 2D image.

From each entity’s perspective the map is not tiled. Collision detection is done using a grid-based index that is independent of the underlying map.

I think the practical alternative to a tiled map is to use polygons to represent chunks of terrain. The only reason I didn’t go down that path is that I couldn’t think of a nice way to render terrain polygons. One plus of this approach is that you can reuse some of the polygon-based path finding code people have put on these forums (was it CommanderKeith?).

#4

I’ve used a Tiled map for my turn-based RPG with RTS-style control.

Some things are just easier with tiles such as collision detection or determining if a unit is surrounded. Now my game is turn-based at heart and therefore tiles i.e. discrete movement makes the most sense.

I don’t feel bound by tiles though. I can animate smooth movement as a unit moves from one tile to another.

Is your game turn-based?

#5

Hello,
thanks for you answers.

@aazimon:
The point with the pixels is, that I don’t want to create “Objects” like mountains and trees, I want to create more or less soils, like earth with minerals (gray color) for mines, green earth for farms, yellow for deserts, etc. Trees, you already correctly said, will be added through objects, that represent them and their whereabouts.

The important question to the pixels is: Is it possible to save the soils (for the pixels) in an 2D Array, that is let’s say 1000010000 or 100000100000 times large?
How performant would that be?

On another note:
On this kind of map I would need to implement a more complex collision control for building units, and buildings, a simple way would be to check every already built building with the new building I want to buiild, if they collide i won’t and can’t build it.

Question:
How performant would this system be, when I have let’s say 1000 building built, how long would it need until all buildings are checked for collision with the new one I want to build?

Greetings
biro

#6

Probably best to start coding and find out. If for whatever reason you end up iterating over every single pixel then 10k^2 or 100k^2 is going to suck. But if you can avoid it through some kind of optimization the size won’t be an issue.

A 1000 objects is nothing for a modern computer.

#7

I haven’t done a lot with collisions, but it may be better to divide the image up into more managable sections. When you place a building, only check collisions with the image for the section that the image is being placed in. If you’re placing a building at 100x 89, there is no point to see if it collides with a point at 100000 x 89.

#8

That’s pretty standard, and what I meant by “grid-based index”. You need to check not only the same section, but also adjacent sections (in case your entity is right near the boundary between two).

#9

If I’m understanding you correctly, is that you would have the image be the holder of information. Will the user work at the pixel level? Or would it be more like, he builds a farm “object” which is several pixels in size? Can you give me more information on how the game machanics work?

#10

Hello,
I don’t want to work on the images.
I want to work on an 2 Dimensional Array that represents the underground material the field has, earth, water, sand, minerals…
This Array will be read from an File. After I’ve extracted the file to my Array I create the picture (pixel for pixel).
The building system should be very much like the on from the Settlers 4 if you don’t know it watch a trailer on youtube. Only that it will have no heigth, like hills have.

At the moment I’m not entirely sure what kind of data this 2 Dimensional Array should contain per pixel. Should it only be the kind of background/soil or maybe a stock for it too? (like 20 coal), and how long does it need to create such an array, and is it’s “jumping ability” affected by its size?

Greetings
biro