Valen "the third Age" Code

/*    Copyright 2007 Arne Schober
//
//    This file is part of Valen3d.
//
//    Valen3d is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 3 of the License, or
//    (at your option) any later version.
//
//    Valen3d is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>. //*/

#pragma once
#include "Object.h"
#include "stdfx.h" //Öhm bin ich auf die dume Idee gekommen? naja scheint wohl zu gehen. (pragma once in Ehren!)
#include "EventPayload.h"
#include "MemoryManager/MemoryManaged.h"
//#include <boost/enable_shared_from_this.hpp>

class EventPayload;
typedef Object pObject; 

//struct Event;
struct Event //: public MemoryManaged//: public boost::enable_shared_from_this<Event>
{
public:
	EventFailture failed;
	Object* sender;
	Object* receiver;

	Event();
	Event(Object* sender);
	Event(Object* sender, Object* receiver);
	virtual ~Event();
	
	virtual Event* accept(pObject &o) 
	{
		switch(failed)
		{
		case fEvent:
			assert(std::cerr << "Event* Event::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct DoneEvent : public Event
{
	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fDoneEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* DoneEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct NullEvent : public Event
{
	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fNullEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* NullEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct QuitEvent : public Event
{
	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fQuitEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* QuitEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct InputEvent : public Event
{
	InputEvent() {}
	InputEvent(Object* sender) : Event(sender) {}
	InputEvent(Object* sender, Object* receiver) : Event(sender,receiver){}

	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fInputEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* InputEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct SwitchEvent : public InputEvent
{
	SwitchEvent() {}
	SwitchEvent(Object* sender)						: InputEvent(sender) {}
	SwitchEvent(Object* sender, Object* receiver)	: InputEvent(sender, receiver) {}

	virtual Event* accept(pObject &o) 
	{
		InputEvent* a;
		Event*		b;

		switch(failed)
		{
		case fSwitchEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fInputEvent: b = this;
			failed = fNoFailture;
			return o.handle(*b);
		case fEvent:
			assert(std::cerr << "Event* SwitchEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct MouseEvent : public InputEvent
{
	SDL_EventType	type;
	Uint16			x, y;
	Uint8			button;

	MouseEvent(SDL_EventType type, Uint16 x, Uint16	y)								: type(type), x(x), y(y) {}
	MouseEvent(SDL_EventType type, Uint16 x, Uint16	y, Uint8 button)				: type(type), x(x), y(y), button(button) {}
	MouseEvent(SDL_EventType type, Uint16 x, Uint16	y, Object* sender)				: type(type), x(x), y(y), InputEvent(sender) {}
	MouseEvent(SDL_EventType type, Uint16 x, Uint16	y, Uint8 button, Object* sender): type(type), x(x), y(y), button(button), InputEvent(sender) {}
	
	virtual Event* accept(pObject &o) 
	{
		InputEvent* a;
		Event*		b;

		switch(failed)
		{
		case fMouseEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fInputEvent: b = this;
			failed = fNoFailture;
			return o.handle(*b);
		case fEvent:
			assert(std::cerr << "Event* SwitchEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct KeyboardEvent : public InputEvent
{
	SDL_EventType type;
	SDLKey key;
	Uint16 unicode;

	KeyboardEvent(SDL_EventType type, SDLKey key)								 : key(key), type(type){}
	KeyboardEvent(SDL_EventType type, SDLKey key, Uint16 unicode)				 : key(key), type(type), unicode(unicode){}
	KeyboardEvent(SDL_EventType type, SDLKey key, Object* sender)				 : key(key), type(type), InputEvent(sender) {}
	KeyboardEvent(SDL_EventType type, SDLKey key, Uint16 unicode, Object* sender): key(key), type(type), unicode(unicode), InputEvent(sender) {}

	virtual Event* accept(pObject &o) 
	{
		InputEvent* a;
		Event*		b;

		switch(failed)
		{
		case fKeyboardEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fInputEvent: b = this;
			failed = fNoFailture;
			return o.handle(*b);
		case fEvent:
			assert(std::cerr << "Event* KeyboardEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct TimedEvent : public Event
{
	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fTimedEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* TimedEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct RendererEvent : public Event
{
	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fRendererEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* RendererEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct DrawEvent : public RendererEvent
{
	virtual Event* accept(pObject &o) 
	{
		RendererEvent*	a;
		Event*			b;

		switch(failed)
		{
		case fDrawEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fRendererEvent: b = this;
			failed = fNoFailture;
			return o.handle(*b);
		case fEvent:
			assert(std::cerr << "Event* DrawEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct UpdateEvent : public Event //TODO dieser Event wurde unter Zeitdruck schwer missbraucht, bitte machen Sie eine Anzeige gg Unbekannt.
{
	//EventPayload* data; //TODO Payloadklassen definieren 
	std::string theString; //jajaja Faulheit geht vor ich muss ich schon mit der Codeintegration ärgern^^
	PayloadType type;
	unsigned offset;
	bool returnPressed;
	
	UpdateEvent(Object* sender) : Event(sender), type(none), offset(0), returnPressed(false) {} 
	UpdateEvent(Object* sender, Object* receiver) : Event(sender, receiver), type(none), offset(0), returnPressed(false) {}

	virtual Event* accept(pObject &o) 
	{
		Event* a;

		switch(failed)
		{
		case fUpdateEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fEvent:
			assert(std::cerr << "Event* UpdateEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};

struct ScreenResizeEvent : public RendererEvent
{
	int w;
	int h;

	ScreenResizeEvent(int w, int h) : w(w), h(h){}

	virtual Event* accept(pObject &o) 
	{
		RendererEvent*	a;
		Event*			b;

		switch(failed)
		{
		case fScreenResizeEvent: a = this;
			failed = fNoFailture;
			return o.handle(*a);
		case fRendererEvent: b = this;
			failed = fNoFailture;
			return o.handle(*b);
		case fEvent:
			assert(std::cerr << "Event* DrawEvent::accept(pObject &o) <- Event Not handable: " << failed << std::endl);
			//failed = fNoFailture;
			return 0; //TODO ErrorEvent
		default:
			failed = fNoFailture;
			return o.handle(*this);
		}
	}
};