Sorry your browser is not supported!

#ifndef _H_TEMPLATE_
#define _H_TEMPLATE_

/////////////////////////////////////////
// CONSTANTS ////////////////////////////
/////////////////////////////////////////

#if defined(AGKWINDOWS) || defined(IDE_MAC)
#define DEVICE_WIDTH 1024
#define DEVICE_HEIGHT 768
#define DEVICE_POS_X 32
#define DEVICE_POS_Y 32
#define FULLSCREEN false
#endif

// this is required by AGK for Mac and Windows
// but we will also use this ourselves
#define WINDOW_TITLE "State Machine Demo"

// Link to AGK libraries
#include "agk.h"

// include our defined types
#include "type_defs.h"

// get some standard objects we need, if not already included
#include <string>

/////////////////////////////////////////
// CLASS DEFINITION /////////////////////
/////////////////////////////////////////
class app
{
	private:
		TA_USHORT	app_state;		// state app is in
		bool			did_end;			// flag for game has ended
		std::string	app_err_msg;	// error message for error state

	public:
		// main vars
#ifdef IDE_MAC
		// the Mac setup uses actual variables to hold
		// the device width and height that must be
		// part of the app class
		unsigned int m_DeviceWidth;
		unsigned int m_DeviceHeight;
#endif
	
	public:
		// constructor
		app() {};

		// destructor
		~app() {};
	
		// main app functions
		void Begin( void );
		void Loop( void );
		void End( void );

	private:
		void closeThisApp(bool noforce=true);
		void hadAnAppError(const char* errmsg,const char* extra=NULL);
		void inBadState();
};

extern app App;

#endif

// Allow us to use the LoadImage function name
#ifdef LoadImage
 #undef LoadImage
#endif

// Includes, namespace and prototypes
#include "template.h"

// supporting classes/functions
#include "simple_pointer.h"
#include "handle_objects.h"

// include for main process
#include "main_process.h"

// Namespace
using namespace AGK;
app App;

/////////////////////////////////////////
// CONSTANTS ////////////////////////////
/////////////////////////////////////////

// application states
#define _AS_DISPLAY_INIT_	1
#define _AS_MAIN_INIT_		2
#define _AS_MAIN_PLAY_		3
#define _AS_MAIN_DONE_		4
#define _AS_BAD_STATE_		5

/////////////////////////////////////////
// PROTOTYPES ///////////////////////////
/////////////////////////////////////////

#ifdef IDE_ANDROID
extern void exit(int);
#endif

/////////////////////////////////////////
// CLASS IMPLEMENTATION /////////////////
/////////////////////////////////////////

// Begin app, called once at the start
void app::Begin(void)
{
	// assume okay for now
	did_end = false;
	app_err_msg = "";

	// set the initial state
	makeStateChange(app_state,_AS_DISPLAY_INIT_,"_AS_DISPLAY_INIT_");

	// attempt to initialise the display
	if (startProcessDisplay(WINDOW_TITLE)) hadAnAppError("Failed to initialise properly:",processErrorWas());
}

void app::Loop (void)
{
	// check for ended
	if (app::did_end) return;

	// process based on state
	// the states are checked in the order
	// of most often occuring first
	switch (app_state)
	{
		case _AS_MAIN_PLAY_:
			//  handle the main processing loop
			if (mainProcessLoop()) makeStateChange(app_state,_AS_MAIN_DONE_,"_AS_MAIN_DONE_");

			break;
		case _AS_MAIN_DONE_:
			// close down
			closeThisApp();

			// done, we want to make sure we skip the agk::Sync() call
			// because the AGK engine may need a cycle or two to properly forget
			// everything that was created
			return;
		case _AS_BAD_STATE_:
			// display message and done
			inBadState();
			break;
		case _AS_MAIN_INIT_:
			// do game initialisation
			// the initialiseTheProcess function does not return
			// control back to this main loop until
			// the initialisation is either complete or fails
			// if it doesn't fail (true=fails), then we change to next state
			if (initialiseTheProcess())
			{
				// oops, initialisation did not work
				hadAnAppError("Failed to initialise properly:",processErrorWas());
			} else {
				// initialisation finished without error
				// start actual game initialisation in the next cycle
				makeStateChange(app_state,_AS_MAIN_PLAY_,"_AS_MAIN_PLAY_");
			}
			break;
		case _AS_DISPLAY_INIT_:
			// we want to make sure that the display syncs right now
			// so that our splash screen displays and so that
			// our display is correctly 'formatted'
			// before we start initialisation
			agk::Sync();
			agk::Sync();

			// start actual game initialisation in the next cycle
			makeStateChange(app_state,_AS_MAIN_INIT_,"_AS_MAIN_INIT_");
			break;
	}

	// sync display
	agk::Sync();
}


// Called when the app ends
void app::End ( void )
{
	// clean up, if not already done
	doProcessCleanup();
}

void app::closeThisApp(bool noforce/*=true*/)
{
	// indicate done
	app::did_end = true;

	// completely exit the app
#ifdef AGKWINDOWS
	PostQuitMessage(0);
#endif
#ifdef AGKIOS
	// forcing a quit in iOS is against recommended guidelines - use HOME button
	// the exit button is disabled on AGKIOS builds
	// but if you want to do so, this is the code
	agk::MasterReset();
	exit(0);
#endif
#ifdef IDE_ANDROID
	// similar to iOS, an exit button should not be done
	// but if you want to do so, this is the code
	agk::MasterReset();
	exit(0);
#endif
#ifdef IDE_MAC
	glfwCloseWindow();
#endif
}

void app::hadAnAppError(const char* errmsg,const char* extra/*=NULL*/)
{
	// start the message
	app_err_msg = "\n\n\n";
	app_err_msg += errmsg;

	// check for extra
	if (extra != NULL)
	{
		// add extra bits
		app_err_msg += "\n";
		app_err_msg += extra;
	}

	// finish the message
	app_err_msg += "\n\n\nTouch anywhere to exit";

	// save the state as bad
	makeStateChange(app_state,_AS_BAD_STATE_,"_AS_BAD_STATE_");

	// show a message
	agk::Print(app_err_msg.c_str());
}

void app::inBadState()
{
	// check for exit
	if (TAPointer::gotPress()) closeThisApp(false);

	// show a message
	agk::Print(app_err_msg.c_str());
}

while (!bExitLoop)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT) bExitLoop = true;
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			// call app each frame
			try
			{
				if (!agk::IsCapturingImage()) App.Loop();
			}
			catch (...)
			{
				uString err = agk::GetLastError();
				err.Prepend("Uncaught exception: \n\n");
				MessageBox(NULL, err.GetStr(), "Error", 0);
				bExitLoop = true;
			}
		}
	}

while (!bExitLoop)
	{
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT) bExitLoop = true;
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			// call app each frame
			try
			{
				if (!agk::IsCapturingImage())
				{
						bExitLoop = !App.Loop();
				}
			}
			catch (...)
			{
				uString err = agk::GetLastError();
				err.Prepend("Uncaught exception: \n\n");
				MessageBox(NULL, err.GetStr(), "Error", 0);
				bExitLoop = true;
			}
		}
	}

bool app::Loop (void)
{
	//If error has happened, cancel loop
	if (DataStruct::error != 0)
	{
		return false;
	}
	//agk::Print( agk::ScreenFPS() );
	//mainMap
	mainMap->update();
	agk::Sync();
	return true;
}

while (!bExitLoop)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.message == WM_QUIT) bExitLoop = true;
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            // call app each frame
            try
            {
                if (!agk::IsCapturingImage()) App.Loop();
            }
            catch (...)
            {
                uString err = agk::GetLastError();
                err.Prepend("Uncaught exception: \n\n");
                MessageBox(NULL, err.GetStr(), "Error", 0);
                bExitLoop = true;
            }
        }
    }

// Includes
#include "template.h"

// Namespace
using namespace AGK;

app App;

//REVOLUTION

//Initialization
void app::Begin(void)
{
	agk::SetVirtualResolution (1024, 768);
	agk::SetClearColor( 151,170,204 ); // light blue
	agk::SetSyncRate(60,0);
	agk::SetScissor(0,0,0,0);
	init();
}

//Main loop
bool app::Loop (void)
{
	//If error has happened, cancel loop
	if (DataStruct::error != 0)
	{
		return false;
	}
	//agk::Print( agk::ScreenFPS() );
	//mainMap
	mainMap->update();
	agk::Sync();
	return true;
}

//Cleanup
void app::End (void)
{
	DataStruct::destroy();
	delete mainMap;
}

//Load all important graphics etc.
void app::init()
{

	//Initialize DataStruct stuff
	DataStruct::init();

	if (DataStruct::error != 0)
	{
		return;
	}


	bool exists = false;

	if (agk::GetImageExists( DataStruct::findTile("water") ) == 1)
	{
		exists = true;
	}
	unsigned int waterID = DataStruct::findTile("water");

	//resetting folder to root
	agk::SetFolder("/");


	mainMap = new GameMap();

	return;
}

//Main loop
bool app::Loop (void)
{
	//If error has happened, cancel loop
	if (DataStruct::error != 0)
	{
		return false;
	}
	//agk::Print( agk::ScreenFPS() );
	//mainMap
	mainMap->update();
	agk::Sync();
	return true;
}

while GetPointerPressed() = 0
  rem do something
endwhile
print "something"

while (agk::GetPointerPressed() == 0)
{
  // do something
}
agk::Print('something');

void app::closeThisApp()
{
   // completely exit the app
#ifdef AGKWINDOWS
   PostQuitMessage(0);
#endif
#ifdef AGKIOS
   // forcing a quit in iOS is against recommended guidelines - use HOME button
   // the exit button is disabled on AGKIOS builds
   // but if you want to do so, this is the code
   agk::MasterReset();
   exit(0);
#endif
#ifdef IDE_ANDROID
   // similar to iOS, an exit button should not be done
   // but if you want to do so, this is the code
   agk::MasterReset();
   exit(0);
#endif
#ifdef IDE_MAC
   glfwCloseWindow();
#endif
}

 
   private:
      void closeThisApp();