In this thread, exclusive to AmigaLife, I will try to post updates, as much as possible, about my progress of the Amiga adaptation of Athanor 2.
This project started super slowly around 2015. It is mostly based on the original Amstrad CPC version, using the same original drawings, except that everything was re-colored from the ground up.
The game itself is programmed in C, targeting the OCS Amigas, including the good old unexpanded A500 with 1MB of RAM (either 512KB CHIP + 512KB SLOW or 1MB CHIP).
 
Stay tuned! 

Cool concept, following this project Keep on the good work ..

While working on the game, I occasionnaly test it on various configurations, including the bare bone A500 without any RAM expansion.
That means that the game should run with only 512Kb of CHIP RAM.

This shouldn't be an issue for this genre of classic adventure game, but remember that everything is done using the AmigaOS calls, and even on an A500 the game is supposed to be OS-Friendly.

I tried to reclaim memory occupied by the CLI/SHELL screen + window opened by AmigaOS1.3 when booting the game (the game starts using a regular startup sequence) but it turns out the game itself cannot invoke CloseWorkBench() or even EndCli(). 1st option will fail silently, 2nd option will shutdown the game (as it seems to be a child taks of the CLI that we are trying to end).

Anyways... I used a fallback strategy : add21k, aka add44k, aka add36k.
All of these tools use the same trick : remove one of the bitplanes from the CLI/Workbench screen to free as much memory as possible.

I found one of these on Aminet, and it includes the source code :
https://aminet.net/package.php?package=util/misc/add36k.lzh

So I decided to borrow the routine and add it to the R-Page engine.
The result looks like this :

/// Add36k does nearly the same as 'subbp' or 'add21k', exept that it does not
/// only free 21kb of memory (one std. workbench plane), but in fact 36kb of
/// memory (that is one plane and 250 lines of the others).
/// Original code by Alexander Rawass
VOID add36k(struct IntuitionBase *ibase)
{
long pl0,pl1,plb,ple;
struct Screen *scr;
struct BitMap *bm;
struct Window *win;
ULONG origheight;

if (ibase != NULL)
{
scr = ibase->ActiveScreen;
win = ibase->ActiveWindow;

origheight=scr->Height;
SizeWindow(win,0,-150);

Delay(1*50);

scr->Height=50;
scr->Depth=1;
bm=&scr->BitMap;
bm->Rows=50;
bm->Depth=1;
pl0=bm->Planes[0];
pl1=bm->Planes[1];
bm->Planes[1]=NULL;
plb=pl0+(640*50/8);
ple=pl1+(640*origheight/8);

RemakeDisplay();
FreeMem(plb,ple-plb);
}
}

Once added to the project, it allows the game to allocate more memory to its internal cache. That means the player will have to wait less time when going from a place to another, as the screens/places he visited will remain longer in memory, thus reducing the disk access.

In the end, I might spare this extra memory for something else. Stay tuned!

Without add36k, the screen cache is 90Kb large :
 


When calling add36k, the screen cache is 135Kb large :
 

Athanor 2, game dev warstories 

The most funny glitch I had when working on the game’s display is one well documented side effect of the Amiga’s parallel architecture. As the blitter and the CPU works concurrently, you need to take care of which one is the fastest...

Turns out the result really depends on the Amiga model. On the basic A500 everything might be ok.

Let’s say :
- malloc() and load a bitmap from disk
- blit it to the screen
- free() the bitmap

Problem:
On a faster 68k machine with the same OCS blitter, turns out the free() might occur before the blit is completed, leading to a garbaged display, as the blitter goes on with the blitting stuff while the data is not available anymore.

This happens especially if you do like me, cleaning all the bitplane pointers table after freeing it

void free_allocated_bitmap(struct BitMap *allocated_bitmap)
{
if (allocated_bitmap)
{
UWORD i;

if (allocated_bitmap->Planes[0] != NULL)
FreeMem(allocated_bitmap->Planes[0], RASSIZE(allocated_bitmap->BytesPerRow << 3, allocated_bitmap->Rows) * allocated_bitmap->Depth);
else
printf("free_allocated_bitmap() error, plane ptr should not be NULL!\n");

for (i = 0; i < allocated_bitmap->Depth; i++)
{
if (allocated_bitmap->Planes[i] != NULL)
allocated_bitmap->Planes[i] = NULL;
}

if (allocated_bitmap != NULL)
{
FreeMem(allocated_bitmap, (LONG)sizeof(struct BitMap));
allocated_bitmap = NULL;
}
}
}

Solution:
To solve workaround this issue, I ended up with a blocking call to WaitBlit() do that the free cannot occur before the blitter is done...

We're talking Adventure Game, here, performance is not a real concern 

Ladies & Gentlemen, Boys and Girls, People, Folks, here is a pre-release video of the (soon to come) Amiga OCS Version of ATHANOR 2 - The Legend of the Birdmen :