HGE* g_phge = 0;

// in globalscape (remember its just an example
VKeyboard* Keys = 0;

// Initializing (don??t forget to delete)
Keys = new VKeyboard();

// adding the keys we want to use
Keys->AddKey(HGEK_ESCAPE);
Keys->AddKey(HGEK_F1);


bool FrameFunc()
{
	if(Keys!=0)
	{
		// to Update the KeyStates use Update() function
		// give a valid pointer to hge class to the function
		Keys->Update(g_phge);
		
		
		if(Keys->Hit(HGEK_A)) // Hit the "A" Key ?
		{
		.....
		}
		
		if(Keys->Hold(HGEK_A)) // Hold the "A" Key ?
		{
		.....
		}
		
		if(Keys->Released(HGEK_A)) // Hold the "A" Key ?
		{
		.....
		}
		
	
	}

// Dont forget to delete the VKeyboard class from heap
delete(Keys);

}

HGE* g_phge = 0;

// in globalscape (remember its just an example
VKeyboard* MoveKeys = 0;

// Initializing (don??t forget to delete)
MoveKeys = new VKeyboard();


// Function for keyhandling 
// perhabs for character movement
void CharacterMoveKeyHandling(VKey Key)
{
	if(Key._key == HGEK_LEFT && Hold(Key)) Player->MoveLeft();
	if(Key._key == HGEK_RIGHT && Hold(Key)) Player->MoveRight();
	if(Key._key == HGEK_DOWN && Hold(Key)) Player->MoveDown();
	if(Key._key == HGEK_UP && Hold(Key)) Player->MoveUp();
}


// adding the keys we want to use and bind them to CharacterMoveKeyHandling function
MoveKeys->AddKey(HGEK_LEFT, CharacterMoveKeyHandling);
MoveKeys->AddKey(HGEK_RIGHT, CharacterMoveKeyHandling);
MoveKeys->AddKey(HGEK_DOWN, CharacterMoveKeyHandling);
MoveKeys->AddKey(HGEK_UP, CharacterMoveKeyHandling);


bool FrameFunc()
{
	if(MoveKeys!=0)
	{
		// to Update the KeyStates use Update() function
		// give a valid pointer to hge class to the function
		Keys->Update(g_phge);
		
		// and we??re done
		// if one of our keys changes keystate
		// Keystates : VK_NULL,VK_HIT,VK_HOLD,VK_RELEASED
		// CharacterMoveKeyHandling function is startet
		// with the key wich is acutal updatet exept keystate
		// is set to VK_NULL	
	}
	
	
// Dont forget to delete the VKeyboard class from heap
delete(MoveKeys);

#ifndef __VKEYBOARD_HEADER_INCLUDED__
#define __VKEYBOARD_HEADER_INCLUDED__

#include "hge.h"

// Virtual Keyboard Key States
typedef enum VKey_State
{
  VK_NULL=0,
  VK_HIT,
  VK_HOLD,
  VK_RELEASED
} VKey_State;

// Virtual Key
typedef struct VKey
{
 int _key;             // example HGEK_ESCAPE
 VKey_State _state;    // Key State
} VKey;

// Helperfunctions to test Keystate
bool Hit(VKey Key);
bool Hold(VKey Key);
bool Released(VKey Key);

// Functionpointer for AutoFunction KeyActivity
typedef void (*VKey_fnptr)(VKey Key);

// Virtual Key Node for list implementation
struct VKey_Node
{
  VKey Key;
  VKey_fnptr AutoFunc;
  VKey_Node* Next;
};

// Virutal Keyboard Class
class VKeyboard
{
  public:
  // CTOR
  VKeyboard();
  // DTOR
  ~VKeyboard();
  
  // Add a Key to listen to
  // u can add a functionpointer to the key
  // defined like VKey_fnptr typedef
  void AddKey(int Key, VKey_fnptr AFunc = 0);
  
  // Remove a Key listening to
  void RemoveKey(int Key);
  
  // Did the user hit the key
  bool Hit(int Key);
  
  // Does the user hold down the key
  bool Hold(int Key);
  
  // Has the user released the key
  bool Released(int Key);
  
  // Are we listening to this key
  bool Contains(int Key);
  
  // Update Keystates
  void Update(HGE* phge);
  
  
  // switch Key from Key to NewKey
  // attached functions remain
  void Set(int Key, int NewKey);
  
  // Set a function to the Key
  void Set(int Key, VKey_fnptr KeyFunc=0);
  
  // Set a function to all Keys we??re listening to
  void Set(VKey_fnptr KeyFunc);
  
  
  private:
  // Root Entry to the attached keys
  VKey_Node* Root;
  // Remove a key_node from the attached keys
  void DeleteNode(VKey_Node* KeyNode);
  // State Tester
  bool KeyState(int Key, VKey_State State);
  
  // Get a Pointer to a specific Key
  // if parameter to set to false
  // and key is not registered
  // u??ll get 0
  VKey* GetKey(int Key,bool create=true);
  
  // Get a KeyNode Pointer including the specific Key
  // if parameter to set to false
  // and key is not regis  // u??ll get 0
  VKey_Node* GetNode(int Key,bool create=true);
  
};

#endif

/*

     VKeyboard Class for HGE
     -----------------------------
     by Frederic Czyborra in 2009
     freddyczyborra@googlemail.com

*/

#include "VKeyboard.h"



bool Hit(VKey Key){ return (Key._state==VK_HIT);}
bool Hold(VKey Key){ return (Key._state==VK_HOLD);}
bool Released(VKey Key){ return (Key._state==VK_RELEASED);}


VKeyboard::VKeyboard():Root(0)
{}

VKeyboard::~VKeyboard()
{
   DeleteNode(this->Root);                       
}

void VKeyboard::Update(HGE* phge)
{
 VKey_Node* Cursor = this->Root;
 while(Cursor!=0)
 {
   if(phge->Input_GetKeyState(Cursor->Key._key))
   {
    switch(Cursor->Key._state)
    {
       case(VK_HIT):
       {
       Cursor->Key._state = VK_HOLD;
       if(Cursor->AutoFunc!=0) Cursor->AutoFunc(Cursor->Key);
       }
       break;
       case(VK_HOLD): break;
       default:
       {
       Cursor->Key._state = VK_HIT;
       if(Cursor->AutoFunc!=0) Cursor->AutoFunc(Cursor->Key);
       }
    }
                                         
   }
   else
   {
    switch(Cursor->Key._state)
    {
       case(VK_HIT):
       case(VK_HOLD):
       Cursor->Key._state = VK_RELEASED;
       if(Cursor->AutoFunc!=0) Cursor->AutoFunc(Cursor->Key);
       break;
       default:
       Cursor->Key._state = VK_NULL;
    }
   }
 Cursor = Cursor->Next;
 }
}


void VKeyboard::AddKey(int Key,VKey_fnptr AFunc)
{
  if(this->Root!=0)
  {
    VKey_Node* Cursor = this->Root;
    if(Cursor!=0)
    {
    while(Cursor->Next != 0)
    {
     Cursor = Cursor->Next;
    }
    
    Cursor->Next = new VKey_Node();
    Cursor = Cursor->Next;
    if(Cursor!=0)
    {
    Cursor->Key._key = Key;
    Cursor->Key._state = VK_NULL;
    Cursor->AutoFunc = AFunc;
    Cursor->Next=0;
    }
    }  
    return;                   
  }
  
  
  
  this->Root = new VKey_Node();
    if(this->Root!=0)
    {
       this->Root->Key._key = Key;
       this->Root->Key._state = VK_NULL;
       this->Root->AutoFunc = AFunc;
       this->Root->Next = 0;        
    }
  
}

void VKeyboard::DeleteNode(VKey_Node* KeyNode)
{
     if(KeyNode!=0)
     {
       if(KeyNode->Next!=0) this->DeleteNode(KeyNode->Next);
       KeyNode->Next=0;
       delete KeyNode;   
     }
}

bool VKeyboard::Contains(int Key)
{
  VKey_Node* Cursor = this->Root;
  while(Cursor!=0)
  {
    if(Cursor->Key._key == Key) return true;
    Cursor = Cursor->Next;
  }
  return false;
}

bool VKeyboard::Hit(int Key)
{
 return this->KeyState(Key, VK_HIT);
}

bool VKeyboard::Hold(int Key)
{
 return this->KeyState(Key, VK_HOLD); 
}

bool VKeyboard::Released(int Key)
{
 return this->KeyState(Key, VK_RELEASED);
}

bool VKeyboard::KeyState(int Key, VKey_State State)
{
     VKey_Node* Cursor = this->Root;
     while(Cursor!=0)
     {
      if(Cursor->Key._key == Key)
      {
                           if(Cursor->Key._state == State) return true;
                           return false;
      }
      Cursor=Cursor->Next;    
     }
     return false;
}


VKey* VKeyboard::GetKey(int Key,bool create)
{
    if(!Contains(Key)&&create) AddKey(Key);
    VKey_Node* Cursor = Root;
    while(Cursor!=0)
    {
       if(Cursor->Key._key == Key) return &Cursor->Key;
       Cursor=Cursor->Next;
    }
    
    return 0;  
}

VKey_Node* VKeyboard::GetNode(int Key,bool create)
{
    if(!Contains(Key)&&create) AddKey(Key);
    VKey_Node* Cursor = Root;
    while(Cursor!=0)
    {
       if(Cursor->Key._key == Key) return Cursor;
       Cursor=Cursor->Next;
    }
    
    return 0;  
}

void VKeyboard::Set(int Key, int NewKey)
{
    VKey* Cursor = GetKey(Key);
    if(Cursor!=0) Cursor->_key = NewKey;
}

void VKeyboard::Set(int Key, VKey_fnptr KeyFunc)
{
    VKey_Node* Cursor = GetNode(Key);
    if(Cursor!=0) Cursor->AutoFunc = KeyFunc;  
}

void VKeyboard::Set(VKey_fnptr KeyFunc)
{
     VKey_Node* Cursor = Root;
     while(Cursor!=0)
     {
       Cursor->AutoFunc = KeyFunc;
       Cursor = Cursor->Next;
     }
}

void VKeyboard::RemoveKey(int Key)
{
     VKey_Node* Cursor = Root;
     VKey_Node* Parent = 0;
     while(Cursor!=0)
     {
     if(Cursor->Key._key == Key)
     {
     if(Parent!=0)
     {
        Parent->Next = Cursor->Next;
        Cursor->Next = 0;
        delete(Cursor);
        return;
     }     
     }
     Parent = Cursor;
     Cursor = Cursor->Next;
     }
}

/*
** HGE System state constants
*/
enum hgeBoolState
{
...
	// Andy : Texture clamping
	HGE_TEXTURECLAMP	= 8,	// bool		clamp textures?		(default: false)
...
};

	if(bTextureFilter)
	{
	....
	}

	// Andy Begin : Texture clamping
	if (bTextureClamp)
	{
		pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_CLAMP);
		pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_CLAMP);
	}
	else
	{
		pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_WRAP);
		pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_WRAP);
	}
	// Andy: End

// System States
...
...
// Andy : Texture clamping
bool				bTextureClamp;

...
// Andy Begin : Texture clamping
case HGE_TEXTURECLAMP: 
			if (bTextureClamp == value)
			{
				// Minor optimisation: state hasn't changed. Early-out to avoid the _render_batch() call.
				// this check isn't done for HGE_TEXTUREFILTER. Hint hint ;)
				return;
			}
			bTextureClamp = value;
			if(pD3DDevice)
			{
				_render_batch();
				if (bTextureClamp)
				{
					pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_CLAMP);
					pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_CLAMP);
				}
				else
				{
					pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSU,D3DTADDRESS_WRAP);
					pD3DDevice->SetSamplerState(0,D3DSAMP_ADDRESSV,D3DTADDRESS_WRAP);
				}
			}
			break;
// Andy End

...
// Andy : Texture clamping
case HGE_TEXTURECLAMP:	return bTextureClamp;

#ifndef ___RECTBARprofeclipserulez
#define ___RECTBARprofeclipserulez

#include 
#include 


//Macros para usar los valores
#define getBarCtrl(id) ((hgeGUIRectBar*)gui->GetCtrl(id))
#define getBar(id)      (getBarCtrl(id)->getPercent())
#define setBar(id,per) (getBarCtrl(id)->setPercent(per))

class hgeGUIRectBar :
	public hgeGUIObject
{
public:
	hgeGUIRectBar(int _id, float _x, float _y, float _h, float _w, char* texto = "" );
	~hgeGUIRectBar(void);
	virtual void Render();
	void Update(float dt);
	void setPercent(float _per){ percent = _per/100; w=percent*ws; }
	float getPercent(){ return percent; }



private:
	
	hgeQuad quad, quadbg;
	hgeFont * fnt;
	float percent;
	float x,y,h,w,ws;
	
	char* m_label;

	//para almacenar color
	DWORD m_color;

};
#endif //___RECTBARprofeclipserulez

#include ".\hgeguirectbar.h"

#define BORDE 5
#define VERDE ARGB(255,157,255,157)
#define AMARILLO ARGB(255,255,255,89)
#define ROJO ARGB(255,255,0,0)

hgeGUIRectBar::hgeGUIRectBar(int _id, float _x, float _y, float _h, float _w, char* texto)
{

	id = _id;
	bStatic = false;
	bVisible = true;
	bEnabled = true;

	// Factor para calcular la "completitud" de la barra + valor contenedor de largo de la barra
	percent = 1.0f;
	w = _w;
	x = _x;
	y = _y;
	h = _h;
	ws = _w;

	m_label = texto;
        //TODO FOR YOU! CHOSE A FONTBAR OF YOUR ELECTION
	fnt = new hgeFont("data/font/fontbar.fnt");

}

hgeGUIRectBar::~hgeGUIRectBar(void)
{

	delete fnt;	

}


void hgeGUIRectBar::Render()
{
	
	//NOTA: Quad es
	/* 3 -- 0
	   |    |
	   |    |
	   2 -- 1 */

	//quadbg = rect??ngulo de fondo
	quadbg.v[1].x = x - BORDE;			quadbg.v[1].y = y + BORDE;
	quadbg.v[2].x = x + ws + BORDE;	quadbg.v[2].y = y + BORDE;
	quadbg.v[3].x = x + ws + BORDE;	quadbg.v[3].y = y - h - BORDE;
	quadbg.v[0].x = x - BORDE;			quadbg.v[0].y = y - h - BORDE;

	quadbg.v[0].z = 1.0f;
	quadbg.v[1].z = 1.0f;
	quadbg.v[2].z = 1.0f;
	quadbg.v[3].z = 1.0f; 

	// de color blanco
	for (int i  = 0; i <4 ; i++)<br />	{
		quadbg.v[i].col = ARGB(255,255,255,255);
	}

	quadbg.tex = 0;
	quadbg.blend = BLEND_DEFAULT;

	
	//quad = rect??ngulo de barra
	quad.v[1].x = x;		quad.v[1].y = y;
	quad.v[2].x = x + w;	quad.v[2].y = y;
	quad.v[3].x = x + w;	quad.v[3].y = y - h;
	quad.v[0].x = x;		quad.v[0].y = y - h;

	quad.v[0].z = 1.0f;
	quad.v[1].z = 1.0f;
	quad.v[2].z = 1.0f;
	quad.v[3].z = 1.0f; 

	// de color seg??n el estado (DEFINE'd)
	// verde claro : ARGB(255,157,255,157)
	// amarillo : ARGB(255,255,255,89)
	// rojo : ARGB(255,255,0,0)

	for (int i  = 0 ; i <4; i++)<br />	{
		quad.v[i].col = m_color;	
	}

	quad.tex = 0;
	quad.blend = BLEND_DEFAULT;

	//Texto

	fnt->printf(x+2,y-2, HGETEXT_LEFT, "%s", m_label);

	hge->Gfx_RenderQuad(&quadbg);
	hge->Gfx_RenderQuad(&quad);
	
}

void hgeGUIRectBar::Update(float dt)
{

	//default verde
	//amarillo debajo 60%
	//rojo debajo 20%

	if(percent <= 0.6f)<br />	{
		m_color = AMARILLO;
		if (percent <= 0.2f)<br />
		{
			m_color = ROJO;
		} 
	} else { 
		m_color = VERDE; 
	}



}

#include 
#include 
using std::string;
#include 

#ifndef AVI_H
#define AVI_H

class AVI {
public:
	enum playMode {
		PLAY_ONCE = 0,
		PLAY_LOOP = 1
	};

protected:
	enum state {
		STATE_STOP = 0,
		STATE_PLAY = 1,
		STATE_PAUSE = 2
	};

	state currentState;
	playMode currentPlayMode;

	HTEXTURE texture;
	hgeSprite *sprite;
	HGE *hge;

	PAVIFILE aviFile;
	PAVISTREAM aviStream;
	PGETFRAME aviFrame;

	int firstFrame;
	int currentFrame;
	int numFrames;
	float frameLength;
	float clipLength;
	float lastDrawTime;
	
public:
	float x;
	float y;
	float width;
	float height;

	AVI(string filename, playMode playmode, HGE *hge);
	virtual ~AVI();
	virtual void update();
	virtual void render();
	
	virtual void play();
	virtual void pause();
	virtual void stop();
	virtual AVI::state getState();
};

#endif /* AVI_H */

#include 
#include 
#include 
#include 
#include 

AVI::AVI(string filename, playMode playmode, HGE *hge) {
	this->hge = hge;

	x=0;
	y=0;

	texture = NULL;
	sprite = NULL;

	aviFile = NULL;
	aviStream = NULL;
	aviFrame = NULL;
	firstFrame = 0;
	currentFrame = 0;
	numFrames = 0;
	clipLength = 0;
	frameLength = 0;
	lastDrawTime = -1;
	currentPlayMode = playmode;
	currentState = STATE_PLAY;

	// Open avi File
	int res=AVIFileOpen(&aviFile, filename.c_str(), OF_READ, NULL);
    if (res!=AVIERR_OK) {
		// Could not open file
		if (aviFile!=NULL) {
            AVIFileRelease(aviFile);
			aviFile = NULL;
		}
    }

	// Get file info
	if(aviFile) {
		AVIFILEINFO aviInfo;
		AVIFileInfo(aviFile, &aviInfo, sizeof(AVIFILEINFO));

		this->width = (float)aviInfo.dwWidth;
		this->height = (float)aviInfo.dwHeight;

		clipLength = ((float)aviInfo.dwLength*(float)aviInfo.dwScale)/((float)aviInfo.dwRate);
		frameLength = (float)aviInfo.dwScale / (float)aviInfo.dwRate;

		// Open Stream and read more info
		int res;
	    res = AVIFileGetStream(aviFile, &aviStream, streamtypeVIDEO, 0);
		firstFrame = AVIStreamStart(aviStream);
		currentFrame = firstFrame;
		numFrames = AVIStreamLength(aviStream);

		if(res != AVIERR_OK ||
		   firstFrame == -1 ||
		   numFrames == -1) 
		{
			// Error Reading File
			if (aviStream!=NULL)
				AVIStreamRelease(aviStream);
			aviStream = NULL;
            AVIFileRelease(aviFile);
			aviFile = NULL;
		}

		if(aviStream) {
			aviFrame = AVIStreamGetFrameOpen(aviStream, NULL);
		}
	}

	texture = hge->Texture_Create((int)this->width, (int)this->height);
	sprite = new hgeSprite(texture, 0, 0, this->width, this->height);
	sprite->SetColor(0xFFFFFFFF);

	DWORD *pixels = hge->Texture_Lock(texture, false);
	if(pixels) {
		std::cout << "edit" << std::endl;<br />		// Set initial texture to white
		for(DWORD i = 0; i < (hge->Texture_GetWidth(texture) * this->height); i++) {
			pixels[i] = 0xFFFFFFFF;
		}

		hge->Texture_Unlock(texture);
	}
}

void AVI::update() {
	if(currentState != STATE_PLAY)
		return;
	
	if(lastDrawTime == -1)
		lastDrawTime = hge->Timer_GetTime();

	int targetFrame = currentFrame + (int)floor((hge->Timer_GetTime() - lastDrawTime)/frameLength);
	if(targetFrame != currentFrame) {
		lastDrawTime += (targetFrame - currentFrame) * frameLength;
		currentFrame = targetFrame;
		// Movie is at end
		if(currentFrame >= numFrames + firstFrame) {
			if(currentPlayMode == PLAY_ONCE) {
				stop();
				return;
			}
			else if(currentPlayMode == PLAY_LOOP) {
				currentFrame = firstFrame;
			}
		}
		std::cout << "draw frame " << currentFrame << std::endl;<br />		// Get Frame Bitmap
		LPBITMAPINFOHEADER lpbi;
		lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(aviFrame, currentFrame);
		if(!lpbi) {
			// Error getting frame information
			return;
		}
		// Create pointer to Device Indepenedent Bitmap (DIB) Pixel Data (written in reverse - see Google or MSDN)
		BYTE *pData = (BYTE*)(lpbi+1);
		DWORD *pixels = hge->Texture_Lock(texture, false);
		if(pixels) {
			// Write 24 bpp Bitmap data (B8:G8:R8) to texture pixels
			if(lpbi->biBitCount == 24) {
				long tWidth = hge->Texture_GetWidth(texture);
				long vWidth = (long)sprite->GetWidth();
				long vHeight = (long)sprite->GetHeight();
				long texPos;
				long bitPos;
				DWORD val;
				for(long i = 0; i < vHeight; i++) {
					for(long j = 0; j < vWidth; j++) {
						texPos = tWidth*i + j;
						bitPos = (vWidth*(vHeight-i-1)+(j)) * 3;
						val = 0xFF000000 | pData[bitPos + 2] << 16 | pData[bitPos + 1] << 8 | pData[bitPos];<br />						pixels[texPos] = val; 
					}
				}
			}
			// Write 16 bpp Bitmap data (X1:B5:G5:R5) to texture pixels
			else if(lpbi->biBitCount == 16) {
				WORD *pDataWord = (WORD*)pData;
				long tWidth = hge->Texture_GetWidth(texture);
				long vWidth = (long)sprite->GetWidth();
				long vHeight = (long)sprite->GetHeight();
				long texPos, bitPos;
				WORD colorDat, tmp;
				DWORD val;
				BYTE r, g, b;
				for(long i = 0; i < vHeight; i++) {
					for(long j = 0; j < vWidth; j++) {
						texPos = tWidth*i + j;
						bitPos = vWidth*(vHeight-i-1)+(j);
						colorDat = pDataWord[bitPos];
						tmp = colorDat;
						b = (tmp & 0x1F) << 3;<br />						tmp = tmp >> 5;
						g = (tmp & 0x1F) << 3;<br />						tmp = tmp >> 5;
						r = (tmp & 0x1F) << 3;<br />						val = 0xFF000000 | (r) << 16 | (g) << 8 | (b);<br />						pixels[texPos] = val; 
					}
				}
			}

			hge->Texture_Unlock(texture);
		}
		else {
			// Couldn't lock texture
		}

	}
}

void AVI::render() {
	if(this->width != sprite->GetWidth() || this->height != sprite->GetHeight()) {
		sprite->RenderStretch(x, y, x + width, y + height);
	}
	else {

		sprite->Render(x, y);
	}
}

AVI::~AVI() {
	if(aviFrame) {
		AVIStreamGetFrameClose(aviFrame);
	}
	if(aviStream) {
		AVIStreamRelease(aviStream);
	}
	if(aviFile) {
		AVIFileRelease(aviFile);
	}

	if(texture)
		hge->Texture_Free(texture);
	if(sprite)
		delete sprite;
}

void AVI::play() {
	if(currentState != STATE_PLAY) {
		currentState = STATE_PLAY;
		lastDrawTime = hge->Timer_GetTime();
	}
}

void AVI::pause() {
	if(currentState == STATE_PLAY)
		currentState = STATE_PAUSE;
}

void AVI::stop() {
	currentFrame = firstFrame;
	currentState = STATE_STOP;
}

AVI::state AVI::getState() {
	return currentState;
}

#include 

HGE *hge = 0;
AVI *avi = NULL;

// This function will be called by HGE once per frame.
// Put your game loop code here. In this example we
// just check whether ESC key has been pressed.
bool FrameFunc()
{
	if (hge->Input_GetKeyState(HGEK_ESCAPE)) return true;
	
	avi->update();

	// Continue execution
	return false;
}

bool RenderFunc() {
	hge->Gfx_BeginScene();
	avi->render();
	hge->Gfx_EndScene();
	return false;
}

int _tmain(int argc, _TCHAR* argv[])
{
	hge = hgeCreate(HGE_VERSION);
	hge->System_SetState(HGE_FRAMEFUNC, FrameFunc);
	hge->System_SetState(HGE_RENDERFUNC, RenderFunc);
	hge->System_SetState(HGE_TITLE, "HGE AVI Test");
	hge->System_SetState(HGE_WINDOWED, true);
	hge->System_SetState(HGE_USESOUND, false);

	if(hge->System_Initiate())
	{
		// Initialize AVI Library
		AVIFileInit();
		
		// Create AVI object
		avi = new AVI("C:\\videos\\AVI_DivX.avi", AVI::PLAY_ONCE, hge);
		// Move object on screen
		avi->x = 30;
		avi->y = 30;

		// Stretch movie
		avi->height = 300;
		avi->width = 400;


		hge->System_Start();
		
		delete avi;

		// Exit AVI Library
		AVIFileExit();
	}
	else
	{	
		// If HGE initialization failed show error message
		MessageBox(NULL, hge->System_GetErrorMessage(), "Error", MB_OK | MB_ICONERROR | MB_APPLMODAL);
	}

	hge->System_Shutdown();
	hge->Release();

	return 0;
}

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
	Engine* ae = new Engine();
	State*  my = new State(ae->GetHGEEngine());

	if (! ae->Init( "Simple Test Game", my ))
	{
		MessageBox(NULL, ae->GetHGEEngine()->System_GetErrorMessage(), "Error",
               MB_OK | MB_ICONERROR | MB_APPLMODAL);
	}

	ae->Cleanup();
	ae->Quit();

	delete my;
	delete ae;

	return 0;
}

DOWNLOAD

Point to2D(float a1, float b1, float c1)
{
	Point p;

	// We first make a check to choose which calcultation method we'll use
	float xi = cos(ca1+M_PI_2);
	float yi = sin(ca1+M_PI_2);
	float zi = 0; // not needed

	float xj = cos(ca1)*sin(ca2+M_PI_2);
	float yj = sin(ca1)*sin(ca2+M_PI_2);
	float zj = 0; //not needed
	//float zj = cos(ca2+M_PI_2);

	if ( (fabs(xj) < 0.001) && (fabs(yj) < 0.001) )
	{
		// ^j is (0,0,1), we have to use a more simple formula
		float X, Y;
		X = a1*xi+b1*yi;
		Y = c1;

		p.x = (cd/500)*X+512;
		p.y = -(cd/500)*Y+384;
	}
	else
	{
		float t1 = sin(ca2)*cos(ca1);
		float t2 = sin(ca2)*sin(ca1);
		float t3 = cos(ca2);
		// We define the screen plane P :
		//   x*A + y*B + z*C + D = 0
		// With :
		float A = t1-cx;
		float B = t2-cy;
		float C = t3-cz;
		float D = t1*cx + t2*cy + t3*cz - cd;

		// Projection of the provided point on the plane :
		float L  = -(A*a1 + B*b1 + C*c1 + D)/(A*A+B*B+C*C);
		float a2 = L*A + a1;
		float b2 = L*B + b1;
		float c2 = 0; // not needed
		//float c2 = L*C + c1;

		// We define a reference mark (O, ^i, ^j) :
		//    O(xo, yo, zo)
		//   ^i(xi, yi, zi)
		//   ^j(xj, yj, zj)
		// With O, ^i and ^j belonging to P and ^i.^j = 0
		// So :
		float xo = cx+cd*t1;
		float yo = cy+cd*t2;
		float zo = 0; // not needed
		//float zo = cz+cd*cos(ca2);

		// ^i and ^j are already calcultated

		// Then at last, we get the screen coordinates :
		float X, Y;
		X = (yj*(a2-xo)-xj*(b2-yo))/(xi*yj-xj*yi);
		Y = (yi*(a2-xo)-xi*(b2-yo))/(xi*yj-xj*yi);

		p.x = (cd/500)*X+512;
		p.y = -(cd/500)*Y+384;
	}

	return p;
}

class CLinearInterpolator
{
public:
	bool Init(float from, float to, float duration);
	bool Update(float dt);
	float GetValue();
private:
	float value;
	float max;
	float step;
	float remainingTime;

};

///  pass a from and to value to span over the given time
bool CLinearInterpolator::Init(float from, float to, float duration)
{
	if(duration<0) return false;<br />	
	value = from;
	max = to;  //  our target
	remainingTime = duration;  // how much time is left
	step = (to-from)/duration; /// we use this to calculate even, linear steps.
	return true;

}

///  called each frame and gets the value closer to its target
bool CLinearInterpolator::Update(float dt)
{
if (remainingTime <=0) <br />	{	
		if (value!=max) value=max;  // let make sure we land on the original 'to' value
		return true;  ///  we're done, return true
	}
	
	remainingTime -= dt; // decrement the amount of time remaining
	value += step*dt; ///  move the value we're tracking 
	return false;
}
///  called to determine what the current value is
float CLinearInterpolator::GetValue()
{
	return value;
}

CLinearInterpolator *objectLerp=new CLinearInterpolator;
objectLerp->Init(0,1,2);  ///  go from 0 to 1 in 2 seconds

///  in your update frame call this
objectLerp->Update(dt);  // where dt is from your delta timer

///  when rendering...
//  random sprite will scale vertically when pegged to lerp
sprite->RenderEx(600,600,0,1.0f,objectLerp->GetValue());

 struct paraEdges      // a parallelogram can be defined by two opposing coords due to its symmetry.
 {
    float minX, minY, maxX, maxY;
 };

// Calculating the upper left and lower right corner of the parallelogram which surrounds the quad,
// needed for scaling and rotation. When rotating, only the center of the parallelogram is needed,
// corresponding to the center of the quad (although this isn't always quite right), but that's done
// by the rotating function itself with the help of the two outer points calculated here.
// Note: I'm using "frame" as a synonym for this parallelogram, because it's a (symmetric) frame of the quad.
void getPara(const hgeQuad& quadS, paraEdges& quadD)
{
    quadD.minX = (quadS.v[0].x < quadS.v[1].x) ? quadS.v[0].x : quadS.v[1].x;
    quadD.minX = (quadD.minX < quadS.v[2].x) ? quadD.minX : quadS.v[2].x;
    quadD.minX = (quadD.minX < quadS.v[3].x) ? quadD.minX : quadS.v[3].x;

    quadD.maxX = (quadS.v[0].x > quadS.v[1].x) ? quadS.v[0].x : quadS.v[1].x;
    quadD.maxX = (quadD.maxX > quadS.v[2].x) ? quadD.maxX : quadS.v[2].x;
    quadD.maxX = (quadD.maxX > quadS.v[3].x) ? quadD.maxX : quadS.v[3].x;

    quadD.minY = (quadS.v[0].y < quadS.v[1].y) ? quadS.v[0].y : quadS.v[1].y;
    quadD.minY = (quadD.minY < quadS.v[2].y) ? quadD.minY : quadS.v[2].y;
    quadD.minY = (quadD.minY < quadS.v[3].y) ? quadD.minY : quadS.v[3].y;

    quadD.maxY = (quadS.v[0].y > quadS.v[1].y) ? quadS.v[0].y : quadS.v[1].y;
    quadD.maxY = (quadD.maxY > quadS.v[2].y) ? quadD.maxY : quadS.v[2].y;
    quadD.maxY = (quadD.maxY > quadS.v[3].y) ? quadD.maxY : quadS.v[3].y;
}

// scaling an object. amount in percent/100. I don't call this function "scaleQuad" due to overloading capabilities of C++,
// so there will be a function which scales triples, too.
// So what is it doing? First, we calculate the outer points of the frame (see getPara();). Then this frame will be scaled by
// the amount given, and last the old quad coords are being projected onto the new frame via distance calculation.
void scaleObject(hgeQuad& quad, float amount)
{
    if (amount==0) exit;        // no scaling

    float x[4], y[4];
    paraEdges paraShort;

    getPara(quad, paraShort);   // we need the two edges of the parallelogram, our "frame"

    // we need to calc the distance every vertex of the object has from the upper left frame origin (for final frame-to-quad scaling projection)

    for (int i=0; i<4; i++)<br />    {
        x[i] = quad.v[i].x - paraShort.minX;
        y[i] = quad.v[i].y - paraShort.minY;
    }

    // alright, now we need the coordinates of the scaled frame

    float amountX = ((paraShort.maxX - paraShort.minX) * amount) / 2; // here we calc the length each side has to be extended in both directions
    float amountY = ((paraShort.maxY - paraShort.minY) * amount) / 2;

    paraShort.minX -= amountX;        // scaling the frame
//    paraShort.maxX += amountX;        // we don't need the lower right corner for the scaling projection

    paraShort.minY -= amountY;
//    paraShort.maxY += amountY;

    // Ok, we got the new coordinates of the frame. Now we have to project the old quad coords onto this new frame.

    for (int i=0; i<4; i++)<br />    {
        quad.v[i].x = paraShort.minX + x[i] + x[i] * amount;
        quad.v[i].y = paraShort.minY + y[i] + y[i] * amount;
    }

    // scaling finished.
}

#include "GuiCtrls.h"

GuiButton::GuiButton(int id, float x, float y, char* caption)
{
	this->id = id;
	this->caption = caption;

	state = 0;

	bStatic = false;
	bVisible = true;
	bEnabled = true;
	
	rect.Set(x, y, x + 90, y + 20);

	disable = GET_RES->GetSprite("buttonDisable");
	release = GET_RES->GetSprite("buttonRelease");
	hovered = GET_RES->GetSprite("buttonHovered");
	pressed = GET_RES->GetSprite("buttonPressed");
}

void GuiButton::Render()
{
	if (!bEnabled) disable->Render(rect.x1, rect.y1);
    
	switch (state) {
		case 0:
		release->Render(rect.x1, rect.y1);
		GET_FNT->Render(rect.x1 + 45, rect.y1, HGETEXT_CENTER, caption);
		break;
             
		case 1:
		hovered->Render(rect.x1, rect.y1);
		GET_FNT->Render(rect.x1 + 45, rect.y1, HGETEXT_CENTER, caption);
		break;
                  
		case 2:
		pressed->Render(rect.x1, rect.y1);
		GET_FNT->Render(rect.x1 + 45, rect.y1, HGETEXT_CENTER, caption);
		break;
	}	
}

void CtrlButton::MouseOver(bool bOver)
{
	if (bOver) state = 1;
	else state = 0;
}

bool CtrlButton::MouseLButton(bool bDown)
{
	if(bDown) {
		state = 2;
		return false;
	}
    
	else {
		state = 0;
		gui->SetFocus(id);
		return true;
	}
}

#ifndef GUICTRLS_H
#define GUICTRLS_H

#include 
#include 
#include "SomeClassThatContainsResourceStuff.h"

class GuiButton : public hgeGUIObject
{
	public:

	GuiButton(int id, float x, float y, char* caption);

	void Render();
	
	void MouseOver(bool bOver);

	bool MouseLButton(bool bDown);

	private:

	BYTE state;

	char* caption;

	hgeSprite* disable;
	hgeSprite* release;
	hgeSprite* hovered;
	hgeSprite* pressed;
};

#endif

class ammo
{
	public:
		virtual ~ammo();
		virtual void Fire_Animation();

		int ammoNum;
		float velocity;
		float radius;  //for hitbox use
		float timer;
		float nowTime;
		float lastTime;
		bool fireKey;	//fire animation
		HTEXTURE texAmmo;
		hgeRect *hitbox;
		hgeVector vPosition;
		hgeVector vDirection;
		hgeAnimation *animAmmo;
		hgeParticleSystem *par;  //particle system 
		
};

ammo::~ammo()
{
	delete hitbox;
	delete par;
	hge->Target_Free(texAmmo);
}

vector ListofAmmo;
ammo *newAmmo = new ammo();
ListofAmmo.push_back(newAmmo);
ListofAmmo.clear();