# This first line initializes autoconf and gives it a file that it can
# look for to make sure the source distribution is complete.
AC_INIT(README)

# The AM_INIT_AUTOMAKE macro tells automake the name and version number
# of the software package so it can generate rules for building a source
# archive.
AM_INIT_AUTOMAKE(pirates, 0.0.1)

# We now have a list of macros which tell autoconf what tools we need to
# build our software, in this case "make", a C++ compiler, and "install".
# If we were creating a C program, we would use AC_PROC_CC instead of CXX.
AC_PROG_MAKE_SET
AC_PROG_CXX
AC_PROG_INSTALL

# This is a trick I learned at Loki - the current compiler for the alpha
# architecture doesn't produce code that works on all versions of the
# alpha processor.  This bit detects the current compile architecture
# and sets the compiler flags to produce portable binary code.
AC_CANONICAL_HOST
AC_CANONICAL_TARGET
case "$target" in
    alpha*-*-linux*)
        CXXFLAGS="$CXXFLAGS -mcpu=ev4 -Wa,-mall"
        ;;
esac

# Use the macro SDL provides to check the installed version of the SDL
# development environment.  Abort the configuration process if the
# minimum version we require isn't available.
SDL_VERSION=1.0.8
AM_PATH_SDL($SDL_VERSION,
            :,
	    AC_MSG_ERROR([*** SDL version $SDL_VERSION not found!])
)
# Add the SDL preprocessor flags and libraries to the build process
CXXFLAGS="$CXXFLAGS $SDL_CFLAGS"
LIBS="$LIBS $SDL_LIBS"

# Finally create all the generated files
# The configure script takes "file.in" and substitutes variables to produce
# "file".  In this case we are just generating the Makefiles, but this could
# be used to generate any number of automatically generated files.
AC_OUTPUT([
Makefile
src/Makefile
])

SUBDIRS = src

EXTRA_DIST = NOTES autogen.sh

bin_PROGRAMS = pirates

pirates_SOURCES =	\
	cacheable.h game.cpp game.h image.cpp image.h logging.cpp logging.h \
	main.cpp manager.h music.cpp music.h nautical_coord.h paths.cpp	\
	paths.h screen.h screen.cpp ship.h splash.cpp splash.h sprite.cpp \
	sprite.h status.cpp status.h text_string.h textfile.h widget.h \
	widget.cpp wind.h 

#!/bin/sh
#
aclocal
automake --foreign
autoconf

./configure $*

/* Basic status reporting class */

#ifndef _status_h
#define _status_h

#include "textstring.h"

typedef enum {
	STATUS_ERROR = -1,
	STATUS_OK = 0
} status_code;

class Status
{
public:
	Status();
	Status(status_code code, const char *message = 0);
	virtual ~Status() { }

	void set_status(status_code code, const char *fmt, ...);
	void set_status(status_code code) {
		m_code = code;
		m_message = 0;
	}
	void set_status_from(Status &object) {
		m_code = object.status();
		m_message = object.status_message();
	}
	void set_status_from(Status *object) {
		set_status_from(*object);
	}

	status_code status(void) {
		return(m_code);
	}
	const char *status_message(void) {
		return(m_message);
	}

protected:
	status_code m_code;
	text_string m_message;
};

#endif /* _status_h */

bool Image::Load(const char *image)
{
        const char *path;

        /* Load the image from disk */
        path = get_path(PATH_DATA, image);
        m_image = IMG_Load(path);
        free_path(path);
        if ( ! m_image ) {
                set_status(STATUS_ERROR, IMG_GetError());
        }
        return(status() == STATUS_OK);
}

bool Sprite::Load(const char *descfile)
{
	...

        m_frames = new Image *[m_numframes+1];
        for ( int i=0; i<m_numframes; ++i ) {
                m_frames[i] = new Image(imagefiles[i]);
		// This function is in the Status base class, and copies
		// the status any error message from the image object
		if ( m_frames[i]->status() != STATUS_OK ) {
                	set_status_from(m_frames[i]);
		}
        }
	return(status() == STATUS_OK);
}

if ( ! sprite->Load(spritefile) ) {
	printf("Couldn't load sprite: %s\n", sprite->status_message());
}

/* This object can be cached in the resource manager */

#ifndef _cacheable_h
#define _cacheable_h

class Cacheable
{
public:
	Cacheable() {
		ref_cnt = 1;
	}
	virtual ~Cacheable() {}

	void AddRef(void) {
		++ref_cnt;
	}

	void DelRef(void) {
		/* Free this object when it has a count of 0 */
		if ( --ref_cnt == 0 ) {
			delete this;
		}
	}

	int RefCnt(void) {
		return(ref_cnt);
	}

private:
	int ref_cnt;
};

#endif /* _cacheable_h */

/* This is a data cache template that can load and unload data at will.
   Items cached in this template must be derived from the Status class
   and have a constructor that takes a filename as a parameter.
*/
template<class T> class ResourceCache : public Status
{
public:
	ResourceCache() {
		m_cache.next = 0;
	}
	~ResourceCache() {
		Flush();
	}

	T *Request(const char *name) {
		T *data;

		data = 0;
		if ( name ) {
			data = Find(name);
			if ( ! data ) {
				data = Load(name);
			}
			if ( data ) {
				data->AddRef();
			}
		}
		return(data);
	}

	void Release(T *data) {
		if ( data ) {
			if ( data->RefCnt() == 1 ) {
				log_warning("Tried to release cached object");
			} else {
				data->DelRef();
			}
		}
	}

	/* Clear all objects from the cache */
	void Flush(void) {
		while ( m_cache.next ) {
			log_debug("Unloading object %s from cache",
			          m_cache.next->name);
			Unload(m_cache.next->data);
		}
	}

	/* Clear all unused objects from the cache
	   This could be faster if the link pointer wasn't trashed by
	   the unload operation...
	*/
	void GarbageCollect(void) {
		struct cache_link *link;
		int n_collected;

		do {
			for ( link=m_cache.next; link; link=link->next ) {
				if ( link->data->RefCnt() == 1 ) {
					Unload(link->data);
					break;
				}
			}
		} while ( link );

		log_debug("Cache: %d objects garbage collected", n_collected);
	}

protected:
	struct cache_link {
		char *name;
		T *data;
		struct cache_link *next;
	} m_cache;

	T *Find(const char *name) {
		T *data;
		struct cache_link *link;

		data = 0;
		for ( link=m_cache.next; link; link=link->next ) {
			if ( strcmp(name, link->name) == 0 ) {
				data = link->data;
				break;
			}
		}
		return(data);
	}

	T *Load(const char *file) {
		struct cache_link *link;
		T *data;

		data = new T(file);
		if ( data->status() == STATUS_OK ) {
			link = new struct cache_link;
			link->next = m_cache.next;
			link->name = strdup(file);
			link->data = data;
			m_cache.next = link;
		} else {
			set_status_from(data);
			delete data;
			data = 0;
		}
		return(data);
	}

	void Unload(T *data) {
		struct cache_link *prev, *link;

		prev = &m_cache;
		for ( link=m_cache.next; link; link=link->next ) {
			if ( data == link->data ) {
				/* Free the object, if it's not in use */
				if ( data->RefCnt() != 1 ) {
				log_warning("Unloading cached object in use");
				}
				data->DelRef();

				/* Remove the link */
				prev->next = link->next;
				delete link;

				/* We found it, stop looking */
				break;
			}
		}
		if ( ! link ) {
			log_warning("Couldn't find object in cache");
		}
	}
};

/* Several logging routines */

#include <stdio.h>
#include <stdarg.h>

void log_warning(const char *fmt, ...)
{
	va_list ap;
	
	fprintf(stderr, "WARNING: ");
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fprintf(stderr, "\n");
}

void log_debug(const char *fmt, ...)

{
#ifdef DEBUG
	va_list ap;
	
	fprintf(stderr, "DEBUG: ");
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fprintf(stderr, "\n");
#endif
}