My first post so hello to all

It's not that I can't do it but I know I won't do it efficiently and it really matters this time. I tend to complicate too much in programming areas I'm not very experienced with so I come to ask your help guys.

But before I start to present you my question let me explain please a very important thing. I'm creating a program in an ancient BASIC like language called AMOS for AMIGA computers. It's important because I aim to 2 MB of RAM configuration. Yes, two MEGABYTES, not gigabytes . This changes a lot as you surly agree.

I have a world map 2400 x 2400 pixels. It's simply too large to load it complete to the memory (apart from this map I have other graphics, a lot of code and also need a room for music and sound samples.) I decided to divide and split it into smaller sections:

I created files called by the following order:
world_ne_1a.iff
world_ne_1b.iff
world_ne_1c.iff
...
world_ne_5a.iff
world_ne_5b.iff
world_ne_5c.iff

world_se_1a.iff
...
world_se_5c.iff

world_nw_1a.iff
...
world_nw_5c.iff

world_sw_1a.iff
...
world_sw_5c.iff

Those files are about 40kB each and have resolution 400 x 240 pixels.

This is how I'd do it (it might not be the best way but this what came to my mind):

Input: A spot on the map using real N/W/E/S coordinates.
1. Convert to pixel coordinates (geo to pixel - already fully functional in my program).
2. Check to which of the four sections of the world it corresponds. For instance, if it's NE section of the globe/map then the program determines on which box 400 x 240 pixels it appears on.
3. Load that file (e.g. world_ne_2b.iff)
4. Copy whole image and store it as blocks 50 x 30 pixels (400/50=8, 240/30=8 - I need those to be divisible by 8 pixes and these values fit perfectly my need)
5. Having X,Y converted data pixel from point 1. center corresponding block (50 x 30 pixel) on the screen (200 x 176 (on my sketch it's 200 x 180 but it should be 200 x 176)) and fill the rest of the visible screen around it with other appropiate blocks of the map.
6. New data input: GoSub 1., GoSub 2., GoTo 7.
7. If new coordinates do not correspond to the actual section displayed on the screen and other map blocks stored in RAM erase those blocks from memory and GoTo point 2.

That's the main idea. But there can be a more RAM memory hungry scenario where a spot appears on the map close to the "corner" of a 400 x 240 box. Then the program needs to load two or even four pictures depending on the X,Y axis. But even four images (~160kB) loaded into RAM is not a problem.

Now goes my question: How to program it using BASIC like code? How would you do it guys? In a pseudo code or whatever language you prefer (except references to API or DLLs)

Thank you in advance and if you need me to clarify some of my description please let me know.

So firstly why are you not using a Tilemap?

Secondly as you stated AMOS is Ancient. I did play around with it in like 91 - 92 but, nowadays Ive forgotten it, I couldn't even tell you how to write a Hello World using AMOS. I don't think you'll get much help on Gamdev but, there is a "Commodore Amiga" group on Facebook. A bunch of guys on there still develop games in AMOS so if you joined there and asked for help you'd get a better response.

Thanks Norman, I'll look into that, it's interesting but maybe I'll point you and others to what I think could work - with your help guys of course.

@Hexmind I can't load whole map because 2MB of RAM is not enough for it. But I'm starting to think that I could simplify it a bit more that I though. See below.

@xbattlestation I know AMOS very well, it's not an issue. I did ask how would you do in BASIC like code but It really doesn't matter much what language it is. Pseudo code can be adapted to practically any language. I know C++ (I created a game in OpenGL) so even if it was in it's pure code (no API nor other stuff like dlls, etc.) that would do too. Yes, AMOS is based on STOS, you're correct. But there is no need to use any plugin because AMOS has sufficient graphics commands built in. I already have a routine that stores blocks and draws them onto the screen but it's just displaying, it doesn't interact with the rest of my code. I keep those blocks as tilemap, as Buster2000 also suggested. But now I need to access them according to the pixel X,Y position. I thought I could store this tilemap in an array, but how to define it and how to access it by given input coordinates?

2400 x 2400 pixels

If it was just a simple array, let's call it world[5,9]...

--NW-----NE--
world[0,1,2 | 3,4,5]
world[1,n,n | n,n,n]
world[2,n,n | n,n,n]
world[3,n,n | n,n,n]
world[4,n,n | n,n,n]
--SW--|--SE--
world[5,n,n | n,n,n]
world[6,n,n | n,n,n]
world[7,n,n | n,n,n]
world[8,n,n | n,n,n]
world[9,n,n | n,n,n]

...I'd do the following thing (I'm open to any suggestion/correction):

The axis "cuts" the world map and divides it horizontally and vertically. First the program needs to determine which of four sections the given coordinates apply to. That's an easy part: N0°-N90° and E0°-E180° corresponds to upper right (NE), N0°-N90° and W0°-W180° is upper left (NW), S0°-S90° and E0°-E180° is lower right section (SE), S0°-S90° and W0°-W180° is lower left (SW). So I'd do a simple check:

If coordinate_X <=2 AND coordinate_Y <=4 Then section of the map is NW
If coordinate_X >=3 AND coordinate_Y <=4 Then section of the map is NE
If coordinate_X <=2 AND coordinate_Y >=5 Then section of the map is SW
If coordinate_X >=3 AND coordinate_Y >=5 Then section of the map is SE

Let's assume for this example we want to display Sri Lanka island which lays in the NE section 1b zone:

Knowing the section and pixel position X,Y from geo2pixel routine the program needs to determine now the image file which is 400 x 240 pixels. That doesn't seem to be complicated either. The center of Sri Lanka is more or less at X=538 adn Y=1152 (remember that each section of the world is 1200 x 1200 pixels). I'd do this checking:

If coordinate_X <=400 AND coordinate_Y <=240 Then load image world_ne_5a.iff
If coordinate_X >400 AND coordinate_X <=800 AND coordinate_Y <=240 Then load image world_ne_5b.iff
If coordinate_X >800 AND coordinate_Y <=240 Then load image world_ne_5c.iff
If coordinate_X <=400 AND coordinate_Y >240 AND coordinate_Y <=480 Then load image world_ne_4a.iff
If coordinate_X >400 AND coordinate_X <=800 AND coordinate_Y >240 AND coordinate_Y <=480 Then load image world_ne_4b.iff
...and so on until X=538 and Y=1152 fulfill the condition:
If coordinate_X >400 AND coordinate_X <=800 AND coordinate_Y >960 Then load image world_ne_1b.iff

At this moment I have the section and the image file. Should I create another array? If so it could be map[7,7] (400/8 x 240/8 = 64 blocks 50 x 30).
Now some calculations:

local_X = X (538) - 400 (1a is out of range so do not count it) = 138
local_Y = Y (1152) - 960 (5b to 2b are out of range, do not count their Y) = 192

New local coordinates are X=138 and Y=192. So far so good. Now let's find the tile:

tile_X = Int ((138 / 50) * 0.5)
tile_Y = Int ((192 / 30) * 0.5)

(tile_X = 3, tile_Y = 7)

Now I'd have to center it on the display area 200 x 176 (although the screen size is 320 x 256 I use limited area due to the graphic panel and other data).
At a time there can be only 4 or 5 visible horizontal tiles and 6 or 7 vertical (depending on the point at the centered tile):

But maybe I don't have to create any tiles but simply center the whole 400x240 image? And in case if some of the map pases onto another section (like in this case of Sri Lanka where I'd need to attach another image from SE section bcause it is too low on the screen) simply load it from another picture(s) and stick them to it in order to fill the area? Sounds like a solution somehow. It wouldn't be pro but I'm starting to think that I'd be OK with it...

Any (constructive) thoughts regarding?

Just jumping in right here, but why don't you organize your filenames in pixel-base coordinates?

In X direction you use chunks of 400 pixels, and in y in chunks of 240 pixels

world_x0_y0.iff

world_x400_y0.iff

..

world_x2000_y2160.iff

No idea about your language, but something like

xbase = 400 * int(xpos / 400);
ybase = 240 * int(ypos / 240);
filename = "world_x" + str(xbase) + "_y" + str(ybase) + ".iff"

(xpos, ypos) is the pixel coordinate, "int(xpos / 400)" does integer division (rounding down), "str(xbase)" converts number to string.

That's why I posted here - to hear suggestions . Thanks for your tip Alberth, seems to be a good idea

Do you need rendering speed?

If you don't then all is good.

If you do then the approaches above are not going to work.

The approach I used on the Amiga was to scan the map and break it down to unique 8 by 8 tiles.

The first thing you notice is that the Earth has a lot of water. A hell of a lot of water, I mean I wouldn't want to try and drink it even if it was beer.

So all the areas of the map that are solid water can be broken down into a single 8 by 8 tile.

The same basic idea is used to extract all the unique tiles you need to to display the whole map. When I did it I was a bit brutal in the comparison tool and got it down to 187 tiles.

So 187 * 8 * 8 = 11968 pixels. A hell of a lot less than 2400 by 2400

Then you need a map. 2400/8 * 2400/8 is 90,000 so you could just use that, but I needed ram for game code as well.

So I then ran the code again on the generated map to create macro areas which contain 8 by 8 tiles. Each macro tile is then 64 by 64 pixels, which was perfect for me a large play area in a small amount of bytes.

I can't remember how many tiles that generated, it wasn't a huge improvement like the first run, but I think it saved me a couple of K.

Anyway, this is only if you need speed. The technique you are currently using will be fine otherwise.