Allows access to Mappy data, which is stored in a DLL Been updated so you dont need Memory.DLL

This allows GBA data (saved from Mappy) to be compiled into a Visual Studio C/C++/C .NET compile, which then, in turn can be used in DBPro. The main advantage to this is that it is harder for levels to be modified.

                                    ` This code was downloaded from The Game Creators
                                    ` It is reproduced here with full permission
                                    ` http://www.thegamecreators.com
                                    
                                    Header:
#ifdef READGBAMAPPY_EXPORTS
#define READGBAMAPPY_API __declspec(dllexport)
#else
#define READGBAMAPPY_API __declspec(dllimport)
#endif

DWORD	READGBAMAPPY_API	readTileAtPosition(DWORD layer,DWORD x,DWORD y);
DWORD	READGBAMAPPY_API	writeTileAtPosition(DWORD layer,DWORD x,DWORD y,DWORD block);
void	READGBAMAPPY_API	readBlockData(DWORD ptr,DWORD block);
void	READGBAMAPPY_API	writeBlockData(DWORD ptr,DWORD block);
DWORD	READGBAMAPPY_API	getNumLayers(void);
DWORD	READGBAMAPPY_API	getWidth(void);
DWORD	READGBAMAPPY_API	getHeight(void);
DWORD	READGBAMAPPY_API	countNumberOfTiles(void);
DWORD	READGBAMAPPY_API	findTile(DWORD ptr,DWORD tile);
---
Code

// ReadGBAMappy.cpp : Defines the entry point for the DLL application.
//
// Written by Nicholas Kingsley ©2003.  All rights reserved
// You may alter this code (ney, you MUST alter it!)

#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "stddef.h"
#include "ReadGBAMappy.h"
#include "F:\Mappy Graphics\TestMap.txt"
//#include "Test.txt"		// This is the file that contains all the data.  Put this in with the code
						// or rename it.
						// Note : CONST should NOT be used.

#define MAXLAYERS	8
#define WIDTH		100
#define HEIGHT		100

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }
    return TRUE;
}

DWORD getNumLayers(void)
{
	return (MAXLAYERS);
}

DWORD getWidth(void)
{
	return (WIDTH);
}

DWORD getHeight(void)
{
	return (HEIGHT);
}

DWORD readTileAtPosition(DWORD layer,DWORD x,DWORD y)
{
	switch (layer) {
		case	0	:	return ((DWORD) maparray0[y][x]);
		case	1	:	return ((DWORD) maparray1[y][x]);
		case	2	:	return ((DWORD) maparray2[y][x]);
		case	3	:	return ((DWORD) maparray3[y][x]);
		case	4	:	return ((DWORD) maparray4[y][x]);
		case	5	:	return ((DWORD) maparray5[y][x]);
		case	6	:	return ((DWORD) maparray6[y][x]);
		case	7	:	return ((DWORD) maparray7[y][x]);
		default		:	return (0);
		};
}

DWORD writeTileAtPosition(DWORD layer,DWORD x,DWORD y,DWORD block)
{
DWORD value;

	value=readTileAtPosition(layer,x,y);						
	switch (layer) {
		case	0	:	maparray0[y][x]=(short) block;
						break;
		case	1	:	maparray1[y][x]=(short) block;
						break;
		case	2	:	maparray2[y][x]=(short) block;
						break;
		case	3	:	maparray3[y][x]=(short) block;
						break;
		case	4	:	maparray4[y][x]=(short) block;
						break;
		case	5	:	maparray5[y][x]=(short) block;
						break;
		case	6	:	maparray6[y][x]=(short) block;
						break;
		case	7	:	maparray7[y][x]=(short) block;
						break;
		default		:	break;
		};

	return (value);
}

void readBlockData(DWORD ptr,DWORD block)
{
	memcpy((LPSTR) ptr,(char *) &blockstr[block],sizeof(BLKSTR));
	//__pokeString(ptr,0,(char *) &blockstr[block],sizeof(BLKSTR),0);
}

void writeBlockData(DWORD ptr,DWORD block)
{
	memcpy((LPSTR) &blockstr[block],(LPSTR) ptr,sizeof(BLKSTR));
	//__pokeString((DWORD) &blockstr[block],0,(LPSTR) ptr,sizeof(BLKSTR),0);
}

DWORD countNumberOfTiles(void)
{
register int x,y,layer;
register DWORD count;

	count=0;
	for (layer=0; layer<MAXLAYERS-1; layer+=2)
	{
		for (y=0; y<HEIGHT; y++)
		{
			for (x=0; x<WIDTH; x++)
			{
				count+=(readTileAtPosition(layer,x,y)>0 ? 1 : 0)+
					(readTileAtPosition(layer+1,x,y)>0 ? 1 : 0);
				
			}
		}
	}

	return (count);
}

DWORD addTileToMemoryList(DWORD ptr,DWORD layer,DWORD x,DWORD y,DWORD index,DWORD *count)
{
struct {
	DWORD layer;
	DWORD x;
	DWORD y;
	} tile;

	tile.layer=layer;
	tile.x=x;
	tile.y=y;
	memcpy((LPSTR) ptr,(char *) &tile,sizeof(tile));
//	__pokeL(ptr,index,layer);
//	__pokeL(ptr,index+4,x);
//	__pokeL(ptr,index+8,y);
	*(count)=*(count)+1;
	return (index+12);
}

DWORD findTile(DWORD ptr,DWORD tile)
{
register int x,y,layer,index;
register DWORD count;

	count=0;
	index=0;

	for (layer=0; layer<MAXLAYERS-1; layer+=2)
	{
		for (y=0; y<HEIGHT; y++)
		{
			for (x=0; x<WIDTH; x++)
			{
				if (readTileAtPosition(layer,x,y)==tile)
				{
					index=addTileToMemoryList(ptr,layer,x,y,index,&count);
				}

				if (readTileAtPosition(layer+1,x,y)==tile)
				{
					index=addTileToMemoryList(ptr,layer+1,x,y,index,&count);
				}
			}
		}
	}

	return (count);
}