Added support for relative line numbers.

Added instructions for, brk and cont. (They are still untested...)
Parser code cleanup. Removed garbage output to stderr.
Reorganize the repository structure.
Updated BLR2 code move it into archive.
Added BLR1 files.

1 files changed, 574 insertions, 0 deletions

diff --git a/archive/blr2/src/background.h b/archive/blr2/src/background.h
new file mode 100644
index 0000000..849438c
--- /dev/null
+++ b/archive/blr2/src/background.h
@@ -0,0 +1,574 @@
+// Chrisoft Bullet Lab Remix HGE  -*- C++ -*-
+// Background drawing Implementations
+// Copyright Chrisoft 2014
+#include <list>
+const char* BACKGROUND_H_FN="background.h";
+
+double deltaBG;
+//********************************************
+//Full-screen Leaves Background
+//********************************************
+class BG_Leaves
+{
+private:
+	DWORD alpha,alim;
+	bool onfadein,onfadeout;
+	int fadebreak;
+	hgeSprite* BGSpr;
+	HTEXTURE LeafTex;
+	void DoFadeIn()
+	{
+		if (LOWFPS)fadebreak+=17;else ++fadebreak;
+		if (fadebreak>17)fadebreak=0;else return;
+		if (LOWFPS)if(alpha+0x20<=alim)alpha+=0x20;else{}
+		else if (alpha+0x2<=alim)alpha+=2;
+		if (alpha>=alim)onfadein=false;
+	}
+	void DoFadeOut()
+	{
+		if (LOWFPS)fadebreak+=17;else ++fadebreak;
+		if (fadebreak>30)fadebreak=0;else return;
+		if (LOWFPS)
+			if (alpha<0x20)alpha=0;else alpha-=0x20;
+		else
+			if (alpha<0x2)alpha=0;else alpha-=0x2;
+		if (!alpha)onfadeout=0;
+	}
+public:
+	bool IsActive()
+	{
+		return alpha?true:false;
+	}
+	void Init(DWORD limalpha)
+	{
+		LeafTex=hge->Texture_Load("./Resources/b_leaves.png");
+		BGSpr=new hgeSprite(LeafTex,0,0,200,150);
+		BGSpr->SetColor(0x00CCCCCC);
+		onfadein=onfadeout=false;alpha=0x00;alim=limalpha;fadebreak=0;
+
+	}
+	void SetFadeIn()
+	{
+		alpha=0x01;
+		onfadein=true;
+	}
+	void SetFadeOut()
+	{
+		alpha=alim;
+		onfadeout=true;
+	}
+	void Update()
+	{
+		double tx,ty,dt;
+		if (onfadein)DoFadeIn();
+		if (onfadeout)DoFadeOut();
+		dt=hge->Timer_GetDelta();
+		deltaBG+=dt;
+		tx=200*cosf(deltaBG/10);
+		ty=150*sinf(deltaBG/10);
+		BGSpr->SetColor(ARGB(alpha,0xCC,0xCC,0xCC));
+		for (int i=-1;i<5;++i)
+		for (int j=-1;j<5;++j)
+			BGSpr->Render(i*199.0f+tx,j*149.0f+ty);
+	}
+};
+BG_Leaves Leaves;
+//********************************************
+//Animated Leaves Background
+//********************************************
+HTEXTURE TLeaf;
+HTEXTURE TSflake;
+bool LE_Active;
+double lescale;
+HTEXTURE letex;TextureRect letr;
+DWORD lecolor;
+class Leaf_Node
+{
+private:
+	hgeSprite* Leaf;
+	double Rotation,DRotate;
+	double x,y,dx,dy;
+public:
+	void init()
+	{
+		Leaf=new hgeSprite(letex,letr.x,letr.y,letr.w,letr.h);
+		Leaf->SetColor(lecolor);
+		x=rand()%908-108;y=-108;
+		dx=rand()%200/100.0f-1.0f;dx*=0.075;
+		dy=rand()%200/100.0f+0.5f;dy*=0.075;
+		Rotation=0;DRotate=rand()%100/10000.0f;DRotate*=0.1;
+	}
+	bool Update()
+	{
+		int times=1;if (LOWFPS)times=17;
+		for (int i=1;i<=times;++i)
+		{
+			Rotation+=DRotate;
+			x+=dx;y+=dy;
+		}
+		if (x>908||x<-108||y>708)return 1;
+		Leaf->RenderEx(x,y,Rotation,lescale);
+		return 0;
+	}
+};
+class Leaf_Anim
+{
+public:
+	std::list<Leaf_Node> llist;
+	double brk;
+	void Init()
+	{
+		llist.clear();
+		brk=rand()%1000/1250.0f;
+	}
+	void Update()
+	{
+		brk-=hge->Timer_GetDelta();
+		if(brk<0)
+		{
+			brk=rand()%1000/1250.0f;
+			Leaf_Node a;a.init();
+			llist.push_back(a);
+		}
+		for(std::list<Leaf_Node>::iterator i=llist.begin();i!=llist.end();++i)
+		{
+			if(i->Update())
+			{
+				std::list<Leaf_Node>::iterator r=i;++r;
+				llist.erase(i);i=--r;
+			}
+		}
+	}
+}Leaf;
+//********************************************
+//3D-sky Background
+//Based on a hge tutorial
+//********************************************
+static const DWORD skyTopColors[3] = {0xFF15092A, 0xFF6C6480, 0xFF89B9D0};
+static const DWORD skyBtmColors[3] = {0xFF303E57, 0xFFAC7963, 0xFFCAD7DB};
+static const DWORD seaTopColors[3] = {0xFF3D546B, 0xFF927E76, 0xFF86A2AD};
+static const DWORD seaBtmColors[3] = {0xFF1E394C, 0xFF2F4E64, 0xFF2F4E64};
+static const int skyseq[9]={0, 0, 1, 2, 2, 2, 1, 0, 0};
+class TDSky
+{
+#define ScreenWidth 800
+#define ScreenHeight 600
+#define Stars 100
+#define SeaDisize 16
+#define SkyHeight (ScreenHeight*0.6f)
+#define StarsHeight (SkyHeight*0.9f)
+#define OrbitRadius (ScreenWidth*0.43f)
+private:
+	HTEXTURE skyitem;
+	hgeQuad skygrad;
+	hgeSprite *sun,*moon,*glow,*seaglow,*star;
+	hgeDistortionMesh *sea,*skylyr;
+	float timet,speed,skya,skylima,seq_residue;
+	int seq_id;
+	float starX[Stars],starY[Stars],starS[Stars],starA[Stars],seaP[SeaDisize];
+	hgeColor colWhite,colSkyTop,colSkyBtm,colSeaTop,colSeaBtm;
+	hgeColor colSun,colSunGlow;
+	hgeColor colMoon,colMoonGlow,colSeaGlow;
+	float sunX,sunY,sunS,sunGlowS;
+	float moonX,moonY,moonS,moonGlowS;
+	float seaGlowX,seaGlowSX,seaGlowSY;
+	bool skyOnFadeIn,skyOnFadeOut;
+	float GetTime()
+	{
+		struct tm *t=0;
+		time_t tt=time(NULL);
+		t=localtime(&tt);
+		float tmp=0;
+		if(t)
+		{
+			tmp=t->tm_sec;
+			tmp=t->tm_min+tmp/60.0f;
+			tmp=t->tm_hour+tmp/60.0f;
+		}
+		return tmp;
+	}
+	void SkyDoFadeIn()
+	{
+		float dlt=1.0f/hge->Timer_GetFPS();
+		if (skya+dlt<skylima)skya+=dlt;
+		else skya=skylima,skyOnFadeIn=false;
+	}
+	void SkyDoFadeOut()
+	{
+		float dlt=1.0f/hge->Timer_GetFPS();
+		if (skya-dlt>0)skya-=dlt;
+		else skya=0.0f,skyOnFadeOut=false;
+	}
+public:
+	bool Init()
+	{
+		skyitem=hge->Texture_Load("./Resources/e_skyitem.png");
+		if(!skyitem) return false;
+		skygrad.tex=0;skygrad.blend=BLEND_DEFAULT;
+		for(int i=0;i<4;++i)skygrad.v[i].z=0.5;
+		skygrad.v[0].tx=0;skygrad.v[0].ty=0;
+		skygrad.v[1].tx=1;skygrad.v[1].ty=0;
+		skygrad.v[2].tx=1;skygrad.v[2].ty=1;
+		skygrad.v[3].tx=0;skygrad.v[3].ty=1;
+		skygrad.v[0].x=0;skygrad.v[0].y=0;
+		skygrad.v[1].x=800;skygrad.v[1].y=0;
+		skygrad.v[2].x=800;skygrad.v[2].y=600;
+		skygrad.v[3].x=0;skygrad.v[3].y=600;
+		sea=new hgeDistortionMesh(SeaDisize, SeaDisize);
+		sea->SetTextureRect(0, 0, ScreenWidth, ScreenHeight-SkyHeight);
+		sun=new hgeSprite(skyitem,81,0,114,114);
+		sun->SetHotSpot(57,57);
+		moon=new hgeSprite(skyitem,0,0,81,81);
+		moon->SetHotSpot(40,40);
+		star=new hgeSprite(skyitem,195,0,9,9);
+		star->SetHotSpot(5,5);
+		glow=new hgeSprite(skyitem,204,0,128,128);
+		glow->SetHotSpot(64,64);
+		glow->SetBlendMode(BLEND_COLORADD | BLEND_ALPHABLEND | BLEND_NOZWRITE);
+		seaglow=new hgeSprite(skyitem,204,96,128,32);
+		seaglow->SetHotSpot(64,0);
+		seaglow->SetBlendMode(BLEND_COLORADD | BLEND_ALPHAADD | BLEND_NOZWRITE);
+		skylyr=new hgeDistortionMesh(16, 16);
+		skylyr->SetTexture(skyitem);
+		skylyr->SetTextureRect(0,128,512,512);
+		skylyr->SetBlendMode(BLEND_ALPHAADD);
+		colWhite.SetHWColor(0xFFFFFFFF);
+		timet=GetTime();
+		speed=skya=0.0f;
+		for(int i=0;i<Stars;++i)
+		{
+			starX[i]=rand()%ScreenWidth;
+			starY[i]=rand()%((int)StarsHeight);
+			starS[i]=(rand()%60+10.0f)/100.0f;
+		}
+		for(int i=0;i<SeaDisize;++i)
+		{
+			seaP[i]=i+(rand()%300-150.0f)/10.0f;
+		}
+		return true;
+	}
+	void Deinit()
+	{
+		delete seaglow;delete glow;
+		delete star;delete moon;
+		delete sun;
+		delete sea;delete skylyr;
+		hge->Texture_Free(skyitem);
+	}
+	void SetSpeed(float _speed){speed=_speed;}
+	void SetSkyA(float _skya){skya=_skya;}
+	void SetTime(float _timet){timet=_timet;}
+	void SkySetFadeIn(float _starta=0.0f,float _lima=1.0f)
+	{
+		skya=_starta;skylima=_lima;
+		skyOnFadeIn=true;skyOnFadeOut=false;
+	}
+	void SkySetFadeOut(float _starta=0.0f)
+	{
+		if (_starta>1E-4)skya=_starta;
+		skyOnFadeIn=false;skyOnFadeOut=true;
+	}
+	void Update()
+	{
+		int i, j, k;
+		float zenith,a,dy,fTime;
+		float posX,s1,s2;
+		const float cellw=ScreenWidth/(SeaDisize-1);
+		hgeColor col1,col2;
+		DWORD dwCol1,dwCol2;
+		if(speed==0.0f) timet=GetTime();
+		else
+		{
+			timet+=hge->Timer_GetDelta()*speed;
+			if(timet>=24.0f) timet-=24.0f;
+		}
+		seq_id=(int)(timet/3);
+		seq_residue=timet/3-seq_id;
+		zenith=-(timet/12.0f*pi-pi/2.0f);
+		col1.SetHWColor(skyTopColors[skyseq[seq_id]]);
+		col2.SetHWColor(skyTopColors[skyseq[seq_id+1]]);
+		colSkyTop=col2*seq_residue + col1*(1.0f-seq_residue);
+		col1.SetHWColor(skyBtmColors[skyseq[seq_id]]);
+		col2.SetHWColor(skyBtmColors[skyseq[seq_id+1]]);
+		colSkyBtm=col2*seq_residue + col1*(1.0f-seq_residue);
+		col1.SetHWColor(seaTopColors[skyseq[seq_id]]);
+		col2.SetHWColor(seaTopColors[skyseq[seq_id+1]]);
+		colSeaTop=col2*seq_residue + col1*(1.0f-seq_residue);
+		col1.SetHWColor(seaBtmColors[skyseq[seq_id]]);
+		col2.SetHWColor(seaBtmColors[skyseq[seq_id+1]]);
+		colSeaBtm=col2*seq_residue + col1*(1.0f-seq_residue);
+		if(seq_id>=6 || seq_id<2)
+			for(int i=0; i<Stars; ++i)
+			{
+				a=1.0f-starY[i]/StarsHeight;
+				//a*=hge->Random_Float(0.6f, 1.0f);
+				a*=(rand()%40+60.0f)/100.0f;
+				if(seq_id>=6) a*=sinf((timet-18.0f)/12.0f*pi);
+				else a*=sinf((1.0f-timet/6.0f)*pi/2);
+				starA[i]=a;
+			}
+			if(seq_id==2) a=sinf(seq_residue*pi/2);
+		else if(seq_id==5) a=cosf(seq_residue*pi/2);
+		else if(seq_id>2 && seq_id<5) a=1.0f;
+		else a=0.0f;
+		colSun.SetHWColor(0xFFEAE1BE);
+		colSun=colSun*(1-a)+colWhite*a;
+		a=(cosf(timet/6.0f*pi)+1.0f)/2.0f;
+		if(seq_id>=2 && seq_id<=6)
+		{
+			colSunGlow=colWhite*a;
+			colSunGlow.a=1.0f;
+		}
+		else colSunGlow.SetHWColor(0xFF000000);
+		sunX=ScreenWidth*0.5f+cosf(zenith)*OrbitRadius;
+		sunY=SkyHeight*1.2f+sinf(zenith)*OrbitRadius;
+		sunS=1.0f-0.3f*sinf((timet-6.0f)/12.0f*pi);
+		sunGlowS=3.0f*(1.0f-a)+3.0f;
+		if(seq_id>=6) a=sinf((timet-18.0f)/12.0f*pi);
+		else a=sinf((1.0f-timet/6.0f)*pi/2);
+		colMoon.SetHWColor(0x20FFFFFF);
+		colMoon=colMoon*(1-a)+colWhite*a;
+		colMoonGlow=colWhite;
+		colMoonGlow.a=0.5f*a;
+		moonX=ScreenWidth*0.5f+cosf(zenith-pi)*OrbitRadius;
+		moonY=SkyHeight*1.2f+sinf(zenith-pi)*OrbitRadius;
+		moonS=1.0f-0.3f*sinf((timet+6.0f)/12.0f*pi);
+		moonGlowS=a*0.4f+0.5f;
+		if(timet>19.0f || timet<4.5f)
+		{
+			a=0.2f;
+			if(timet>19.0f && timet<20.0f) a*=(timet-19.0f);
+			else if(timet>3.5f && timet<4.5f) a*=1.0f-(timet-3.5f);
+			colSeaGlow=colMoonGlow;
+			colSeaGlow.a=a;
+			seaGlowX=moonX;
+			seaGlowSX=moonGlowS*3.0f;
+			seaGlowSY=moonGlowS*2.0f;
+		}
+		else if(timet>6.5f && timet<19.0f)
+		{
+			a=0.3f;
+			if(timet<7.5f) a*=(timet-6.5f);
+			else if(timet>18.0f) a*=1.0f-(timet-18.0f);
+			colSeaGlow=colSunGlow;
+			colSeaGlow.a=a;
+			seaGlowX=sunX;
+			seaGlowSX=sunGlowS;
+			seaGlowSY=sunGlowS*0.6f;
+		}
+		else colSeaGlow.a=0.0f;
+		for(i=1; i<SeaDisize-1; ++i)
+		{
+			a=float(i)/(SeaDisize-1);
+			col1=colSeaTop*(1-a)+colSeaBtm*a;
+			dwCol1=col1.GetHWColor();
+			fTime=2.0f*hge->Timer_GetTime();
+			a*=20;
+			for(j=0; j<SeaDisize; ++j)
+			{
+				sea->SetColor(j, i, dwCol1);
+				dy=a*sinf(seaP[i]+(float(j)/(SeaDisize-1)-0.5f)*pi*16.0f-fTime);
+				sea->SetDisplacement(j, i, 0.0f, dy, HGEDISP_NODE);
+			}
+		}
+		float t=0.1*hge->Timer_GetTime();
+		skylyr->SetTextureRect(128+sin(t)*128.0f,256+cos(t)*128.0f,256,128);
+		if (skyOnFadeIn)SkyDoFadeIn();
+		if (skyOnFadeOut)SkyDoFadeOut();
+		for (int i=-8;i<8;++i)
+		for (int j=-8;j<8;++j)
+		{
+			skylyr->SetColor(j+8,i+8,ARGB((int)(skya*((i+9)*16-16)),0xFF,0xFF,0xFF));
+			skylyr->SetDisplacement(j+8,i+8,j*(16.0f*((i+9)/16.0f)+64.0f),i*24,HGEDISP_CENTER);
+		}
+		dwCol1=colSeaTop.GetHWColor();
+		dwCol2=colSeaBtm.GetHWColor();
+		for(j=0; j<SeaDisize; ++j)
+		{
+			sea->SetColor(j, 0, dwCol1);
+			sea->SetColor(j, SeaDisize-1, dwCol2);
+		}
+		if(timet>19.0f || timet<5.0f)
+		{
+			a=0.12f;
+			if(timet>19.0f && timet<20.0f) a*=(timet-19.0f);
+			else if(timet>4.0f && timet<5.0f) a*=1.0f-(timet-4.0f);
+			posX=moonX;
+		}
+		else if(timet>7.0f && timet<17.0f)
+		{
+			a=0.14f;
+			if(timet<8.0f) a*=(timet-7.0f);
+			else if(timet>16.0f) a*=1.0f-(timet-16.0f);
+			posX=sunX;
+		}
+		else a=0.0f;
+		if(a!=0.0f)
+		{
+			k=(int)floorf(posX/cellw);
+			s1=(1.0f-(posX-k*cellw)/cellw);
+			s2=(1.0f-((k+1)*cellw-posX)/cellw);
+			if(s1>0.7f) s1=0.7f;
+			if(s2>0.7f) s2=0.7f;
+			s1*=a;s2*=a;
+			for(i=0; i<SeaDisize; i+=2)
+			{
+				a=sinf(float(i)/(SeaDisize-1)*pi/2);
+				col1.SetHWColor(sea->GetColor(k,i));
+				col1+=colSun*s1*(1-a);
+				col1.Clamp();
+				sea->SetColor(k, i, col1.GetHWColor());
+				col1.SetHWColor(sea->GetColor(k+1,i));
+				col1+=colSun*s2*(1-a);
+				col1.Clamp();
+				sea->SetColor(k+1, i, col1.GetHWColor());
+			}
+		}
+	}
+	void Render()
+	{
+#ifdef WIN32
+		skygrad.tex=0;
+		skygrad.blend=BLEND_DEFAULT;
+#endif
+		skygrad.v[0].col=skygrad.v[1].col=colSkyTop.GetHWColor();
+		skygrad.v[2].col=skygrad.v[3].col=colSkyBtm.GetHWColor();
+		hge->Gfx_RenderQuad(&skygrad);
+		if(seq_id>=6 || seq_id<2)
+			for(int i=0; i<Stars; ++i)
+			{
+				star->SetColor((DWORD(starA[i]*255.0f)<<24) | 0xFFFFFF);
+				star->RenderEx(starX[i], starY[i], 0.0f, starS[i]);
+			}
+		glow->SetColor(colSunGlow.GetHWColor());
+		glow->RenderEx(sunX, sunY, 0.0f, sunGlowS);
+		sun->SetColor(colSun.GetHWColor());
+		sun->RenderEx(sunX, sunY, 0.0f, sunS);
+		glow->SetColor(colMoonGlow.GetHWColor());
+		glow->RenderEx(moonX, moonY, 0.0f, moonGlowS);
+		moon->SetColor(colMoon.GetHWColor());
+		moon->RenderEx(moonX, moonY, 0.0f, moonS);
+		sea->Render(0, SkyHeight);
+		seaglow->SetColor(colSeaGlow.GetHWColor());
+		seaglow->RenderEx(seaGlowX, SkyHeight, 0.0f, seaGlowSX, seaGlowSY);
+		skylyr->Render(ScreenWidth/8*3,ScreenHeight/3*2);
+	}
+};
+TDSky sky;
+bool skyactive;
+
+class PicBack
+{
+public:
+	enum arMode
+	{
+		Centered,
+		Tiled,
+		Stretched
+	};
+private:
+	hgeQuad quad;
+	arMode Mode;
+	DWORD alpha,alim;
+	bool onfadein,onfadeout;
+	int fadebreak;
+	double scale;
+	void DoFadeIn()
+	{
+		if (LOWFPS)fadebreak+=17;else ++fadebreak;
+		if (fadebreak>17)fadebreak=0;else return;
+		if (LOWFPS)if(alpha+0x20<=alim)alpha+=0x20;else alpha=alim;
+		else if (alpha+0x2<=alim)alpha+=2;else alpha=alim;
+		if (alpha>=alim)onfadein=false;
+	}
+	void DoFadeOut()
+	{
+		if (LOWFPS)fadebreak+=17;else ++fadebreak;
+		if (fadebreak>17)fadebreak=0;else return;
+		if (LOWFPS)if (alpha<0x20)alpha=0;else alpha-=0x20;
+		else if (alpha<0x2)alpha=0;else alpha-=0x2;
+		if (!alpha)onfadeout=false;
+	}
+	void RenderCenterAt(vector2d a,double scl)
+	{
+		vector2d s=vector2d(hge->Texture_GetWidth(quad.tex,true)*scl,hge->Texture_GetHeight(quad.tex,true)*scl);
+		for(int i=0;i<4;++i)quad.v[i].col=SETA(0xFFFFFF,alpha);
+		quad.v[0].x=a.x-s.x/2.0f;quad.v[0].y=a.y-s.y/2.0f;
+		quad.v[1].x=a.x+s.x/2.0f;quad.v[1].y=a.y-s.y/2.0f;
+		quad.v[2].x=a.x+s.x/2.0f;quad.v[2].y=a.y+s.y/2.0f;
+		quad.v[3].x=a.x-s.x/2.0f;quad.v[3].y=a.y+s.y/2.0f;
+		hge->Gfx_RenderQuad(&quad);
+	}
+public:
+	bool active(){return alpha;}
+	void SetScale(double _scl){scale=_scl;}
+	void Init(const char *tx,arMode _Mode,DWORD _alim)
+	{
+		quad.tex=hge->Texture_Load(tx);alim=_alim;
+		Mode=_Mode;scale=1;quad.blend=BLEND_DEFAULT;
+#ifdef WIN32
+		vector2d srl=vector2d(hge->Texture_GetWidth(quad.tex,true),
+			                  hge->Texture_GetHeight(quad.tex,true));
+		vector2d srm=vector2d(hge->Texture_GetWidth(quad.tex,false),
+			                  hge->Texture_GetHeight(quad.tex,false));
+		srm.x=srl.x/srm.x;srm.y=srl.y/srm.y;
+		quad.v[0].tx=0;quad.v[0].ty=0;
+		quad.v[1].tx=srm.x;quad.v[1].ty=0;
+		quad.v[2].tx=srm.x;quad.v[2].ty=srm.y;
+		quad.v[3].tx=0;quad.v[3].ty=srm.y;
+#else
+		quad.v[0].tx=0,quad.v[0].ty=0;
+		quad.v[1].tx=1,quad.v[1].ty=0;
+		quad.v[2].tx=1,quad.v[2].ty=1;
+		quad.v[3].tx=0,quad.v[3].ty=1;
+#endif
+		onfadein=onfadeout=false;alpha=0;
+	}
+	void Update()
+	{
+		if(onfadein)DoFadeIn();if(onfadeout)DoFadeOut();
+		switch(Mode)
+		{
+			case Centered:
+				RenderCenterAt(vector2d(400,300),scale);
+			break;
+			case Tiled:
+			{
+				vector2d s=vector2d(hge->Texture_GetWidth(quad.tex,true)*scale,hge->Texture_GetHeight(quad.tex,true)*scale);
+				for(int i=0;i*s.x<=800;++i)
+				for(int j=0;j*s.y<=600;++j)
+				RenderCenterAt(vector2d(s.x/2+i*s.x,s.y/2+j*s.y),scale);
+			}
+			break;
+			case Stretched:
+				for(int i=0;i<4;++i)quad.v[i].col=SETA(0xFFFFFF,alpha);
+				quad.v[0].x=0,quad.v[0].y=0;
+				quad.v[1].x=800,quad.v[1].y=0;
+				quad.v[2].x=800,quad.v[2].y=600;
+				quad.v[3].x=0,quad.v[3].y=600;
+				hge->Gfx_RenderQuad(&quad);
+			break;
+		}
+	}
+	void SetFadeIn()
+	{
+		alpha=0x01;
+		onfadein=true;
+	}
+	void SetFadeOut()
+	{
+		alpha=alim;
+		onfadeout=true;
+	}
+}binter,bdiff;
+DWORD ColorTransfer(DWORD a,DWORD t)
+{
+	int r=GETR(a),g=GETG(a),b=GETB(a),sa=GETA(a);
+	int tr=GETR(t),tg=GETG(t),tb=GETB(t),ta=GETA(t);
+	if (sa<ta)++sa;if (sa>ta)--sa;
+	if (r<tr)++r;if (r>tr)--r;
+	if (g<tg)++g;if (g>tg)--g;
+	if (b<tb)++b;if (b>tb)--b;
+	a=SETR(a,r);a=SETG(a,g);a=SETB(a,b);a=SETA(a,sa);
+	return a;
+}