CGE: Some more renaming (wip)

20 files changed, 569 insertions, 562 deletions

diff --git a/engines/cge/bitmap.cpp b/engines/cge/bitmap.cpp
index 9f19e91b1f..ab5c1ff3c7 100644
--- a/engines/cge/bitmap.cpp
+++ b/engines/cge/bitmap.cpp
@@ -35,18 +35,18 @@
 
 namespace CGE {
 
-DAC *BITMAP::Pal = NULL;
+DAC *Bitmap::Pal = NULL;
 #define MAXPATH  128
 
-void BITMAP::init() {
+void Bitmap::init() {
 	Pal = NULL;
 }
 
-void BITMAP::deinit() {
+void Bitmap::deinit() {
 }
 
 #pragma argsused
-BITMAP::BITMAP(const char *fname, bool rem) : M(NULL), V(NULL) {
+Bitmap::Bitmap(const char *fname, bool rem) : _m(NULL), _v(NULL) {
 	char pat[MAXPATH];
 	ForceExt(pat, fname, ".VBM");
 
@@ -65,8 +65,8 @@ BITMAP::BITMAP(const char *fname, bool rem) : M(NULL), V(NULL) {
 			if (BMPLoad(&file)) {
 				Code();
 				if (rem) {
-					free(M);
-					M = NULL;
+					free(_m);
+					_m = NULL;
 				}
 			} else
 				error("Bad BMP [%s]", fname);
@@ -78,7 +78,7 @@ BITMAP::BITMAP(const char *fname, bool rem) : M(NULL), V(NULL) {
 }
 
 
-BITMAP::BITMAP(uint16 w, uint16 h, uint8 *map) : W(w), H(h), M(map), V(NULL) {
+Bitmap::Bitmap(uint16 w, uint16 h, uint8 *map) : _w(w), _h(h), _m(map), _v(NULL) {
 	if (map)
 		Code();
 }
@@ -87,14 +87,14 @@ BITMAP::BITMAP(uint16 w, uint16 h, uint8 *map) : W(w), H(h), M(map), V(NULL) {
 // following routine creates filled rectangle
 // immediately as VGA video chunks, in near memory as fast as possible,
 // especially for text line real time display
-BITMAP::BITMAP(uint16 w, uint16 h, uint8 fill)
-	: W((w + 3) & ~3),                              // only full uint32 allowed!
-	  H(h),
-	  M(NULL) {
-	uint16 dsiz = W >> 2;                           // data size (1 plane line size)
+Bitmap::Bitmap(uint16 w, uint16 h, uint8 fill)
+	: _w((w + 3) & ~3),                              // only full uint32 allowed!
+	  _h(h),
+	  _m(NULL) {
+	uint16 dsiz = _w >> 2;                           // data size (1 plane line size)
 	uint16 lsiz = 2 + dsiz + 2;                     // uint16 for line header, uint16 for gap
-	uint16 psiz = H * lsiz;                         // - last gape, but + plane trailer
-	uint8 *v = new uint8[4 * psiz + H * sizeof(*B)];// the same for 4 planes
+	uint16 psiz = _h * lsiz;                         // - last gape, but + plane trailer
+	uint8 *v = new uint8[4 * psiz + _h * sizeof(*_b)];// the same for 4 planes
 	                                                // + room for wash table
 	if (v == NULL)
 		error("No core");
@@ -106,39 +106,39 @@ BITMAP::BITMAP(uint16 w, uint16 h, uint8 fill)
 	*(uint16 *)(v + psiz - 2) = EOI;                // plane trailer uint16
 	memcpy(v + psiz, v, 3 * psiz);                  // tricky replicate planes
 	HideDesc *b = (HideDesc *)(v + 4 * psiz);
-	b->skip = (SCR_WID - W) >> 2;
-	b->hide = W >> 2;
-	memcpy(b + 1, b, (H - 1) * sizeof(*b));         // tricky fill entire table
+	b->skip = (SCR_WID - _w) >> 2;
+	b->hide = _w >> 2;
+	memcpy(b + 1, b, (_h - 1) * sizeof(*b));         // tricky fill entire table
 	b->skip = 0;                                    // fix the first entry
-	V = v;
-	B = b;
+	_v = v;
+	_b = b;
 }
 
 
-BITMAP::BITMAP(const BITMAP &bmp) : W(bmp.W), H(bmp.H), M(NULL), V(NULL) {
-	uint8 *v0 = bmp.V;
+Bitmap::Bitmap(const Bitmap &bmp) : _w(bmp._w), _h(bmp._h), _m(NULL), _v(NULL) {
+	uint8 *v0 = bmp._v;
 	if (v0) {
-		uint16 vsiz = (uint8 *)(bmp.B) - (uint8 *)(v0);
-		uint16 siz = vsiz + H * sizeof(HideDesc);
+		uint16 vsiz = (uint8 *)(bmp._b) - (uint8 *)(v0);
+		uint16 siz = vsiz + _h * sizeof(HideDesc);
 		uint8 *v1 = farnew(uint8, siz);
 		if (v1 == NULL)
 			error("No core");
 		memcpy(v1, v0, siz);
-		B = (HideDesc *)((V = v1) + vsiz);
+		_b = (HideDesc *)((_v = v1) + vsiz);
 	}
 }
 
 
-BITMAP::~BITMAP(void) {
-	if (MemType(M) == FAR_MEM)
-		free(M);
+Bitmap::~Bitmap(void) {
+	if (MemType(_m) == FAR_MEM)
+		free(_m);
 
-	switch (MemType(V)) {
+	switch (MemType(_v)) {
 	case NEAR_MEM :
-		delete[](uint8 *) V;
+		delete[](uint8 *) _v;
 		break;
 	case FAR_MEM  :
-		free(V);
+		free(_v);
 	default:
 		warning("Unhandled MemType in Bitmap destructor");
 		break;
@@ -147,92 +147,92 @@ BITMAP::~BITMAP(void) {
 }
 
 
-BITMAP &BITMAP::operator = (const BITMAP &bmp) {
-	uint8 *v0 = bmp.V;
-	W = bmp.W;
-	H = bmp.H;
-	M = NULL;
-	if (MemType(V) == FAR_MEM)
-		free(V);
+Bitmap &Bitmap::operator = (const Bitmap &bmp) {
+	uint8 *v0 = bmp._v;
+	_w = bmp._w;
+	_h = bmp._h;
+	_m = NULL;
+	if (MemType(_v) == FAR_MEM)
+		free(_v);
 	if (v0 == NULL)
-		V = NULL;
+		_v = NULL;
 	else {
-		uint16 vsiz = (uint8 *)bmp.B - (uint8 *)v0;
-		uint16 siz = vsiz + H * sizeof(HideDesc);
+		uint16 vsiz = (uint8 *)bmp._b - (uint8 *)v0;
+		uint16 siz = vsiz + _h * sizeof(HideDesc);
 		uint8 *v1 = farnew(uint8, siz);
 		if (v1 == NULL)
 			error("No core");
 		memcpy(v1, v0, siz);
-		B = (HideDesc *)((V = v1) + vsiz);
+		_b = (HideDesc *)((_v = v1) + vsiz);
 	}
 	return *this;
 }
 
 
-uint16 BITMAP::MoveVmap(uint8 *buf) {
-	if (V) {
-		uint16 vsiz = (uint8 *)B - (uint8 *)V;
-		uint16 siz = vsiz + H * sizeof(HideDesc);
-		memcpy(buf, V, siz);
-		if (MemType(V) == FAR_MEM)
-			free(V);
-		B = (HideDesc *)((V = buf) + vsiz);
+uint16 Bitmap::MoveVmap(uint8 *buf) {
+	if (_v) {
+		uint16 vsiz = (uint8 *)_b - (uint8 *)_v;
+		uint16 siz = vsiz + _h * sizeof(HideDesc);
+		memcpy(buf, _v, siz);
+		if (MemType(_v) == FAR_MEM)
+			free(_v);
+		_b = (HideDesc *)((_v = buf) + vsiz);
 		return siz;
 	}
 	return 0;
 }
 
 
-BMP_PTR BITMAP::Code(void) {
-	if (M) {
+BMP_PTR Bitmap::Code(void) {
+	if (_m) {
 		uint16 i, cnt;
 
-		if (V) {                                        // old X-map exists, so remove it
-			switch (MemType(V)) {
+		if (_v) {                                        // old X-map exists, so remove it
+			switch (MemType(_v)) {
 			case NEAR_MEM :
-				delete[](uint8 *) V;
+				delete[](uint8 *) _v;
 				break;
 			case FAR_MEM  :
-				free(V);
+				free(_v);
 				break;
 			default:
 				warning("Unhandled MemType in Bitmap::Code()");
 				break;
 			}
-			V = NULL;
+			_v = NULL;
 		}
 
 		while (true) {                                  // at most 2 times: for (V == NULL) & for allocated block;
-			uint8 *im = V + 2;
-			uint16 *cp = (uint16 *) V;
+			uint8 *im = _v + 2;
+			uint16 *cp = (uint16 *) _v;
 			int bpl;
 
-			if (V) {                                      // 2nd pass - fill the hide table
-				for (i = 0; i < H; i++) {
-					B[i].skip = 0xFFFF;
-					B[i].hide = 0x0000;
+			if (_v) {                                      // 2nd pass - fill the hide table
+				for (i = 0; i < _h; i++) {
+					_b[i].skip = 0xFFFF;
+					_b[i].hide = 0x0000;
 				}
 			}
 			for (bpl = 0; bpl < 4; bpl++) {              // once per each bitplane
-				uint8 *bm = M;
+				uint8 *bm = _m;
 				bool skip = (bm[bpl] == TRANS);
 				uint16 j;
 
 				cnt = 0;
-				for (i = 0; i < H; i++) {                  // once per each line
+				for (i = 0; i < _h; i++) {                  // once per each line
 					uint8 pix;
-					for (j = bpl; j < W; j += 4) {
+					for (j = bpl; j < _w; j += 4) {
 						pix = bm[j];
-						if (V && pix != TRANS) {
-							if (j < B[i].skip)
-								B[i].skip = j;
+						if (_v && pix != TRANS) {
+							if (j < _b[i].skip)
+								_b[i].skip = j;
 
-							if (j >= B[i].hide)
-								B[i].hide = j + 1;
+							if (j >= _b[i].hide)
+								_b[i].hide = j + 1;
 						}
 						if ((pix == TRANS) != skip || cnt >= 0x3FF0) { // end of block
 							cnt |= (skip) ? SKP : CPY;
-							if (V)
+							if (_v)
 								*cp = cnt;                          // store block description uint16
 
 							cp = (uint16 *) im;
@@ -241,20 +241,20 @@ BMP_PTR BITMAP::Code(void) {
 							cnt = 0;
 						}
 						if (! skip) {
-							if (V)
+							if (_v)
 								*im = pix;
 							++ im;
 						}
 						++ cnt;
 					}
 
-					bm += W;
-					if (W < SCR_WID) {
+					bm += _w;
+					if (_w < SCR_WID) {
 						if (skip) {
 							cnt += (SCR_WID - j + 3) / 4;
 						} else {
 							cnt |= CPY;
-							if (V)
+							if (_v)
 								*cp = cnt;
 
 							cp = (uint16 *) im;
@@ -266,37 +266,37 @@ BMP_PTR BITMAP::Code(void) {
 				}
 				if (cnt && ! skip) {
 					cnt |= CPY;
-					if (V)
+					if (_v)
 						*cp = cnt;
 
 					cp = (uint16 *) im;
 					im += 2;
 				}
-				if (V)
+				if (_v)
 					*cp = EOI;
 				cp = (uint16 *) im;
 				im += 2;
 			}
-			if (V)
+			if (_v)
 				break;
 
-			uint16 sizV = (uint16)(im - 2 - V);
-			V = farnew(uint8, sizV + H * sizeof(*B));
-			if (! V)
+			uint16 sizV = (uint16)(im - 2 - _v);
+			_v = farnew(uint8, sizV + _h * sizeof(*_b));
+			if (!_v)
 				error("No core");
 
-			B = (HideDesc *)(V + sizV);
+			_b = (HideDesc *)(_v + sizV);
 		}
 		cnt = 0;
-		for (i = 0; i < H; i++) {
-			if (B[i].skip == 0xFFFF) {                    // whole line is skipped
-				B[i].skip = (cnt + SCR_WID) >> 2;
+		for (i = 0; i < _h; i++) {
+			if (_b[i].skip == 0xFFFF) {                    // whole line is skipped
+				_b[i].skip = (cnt + SCR_WID) >> 2;
 				cnt = 0;
 			} else {
-				uint16 s = B[i].skip & ~3;
-				uint16 h = (B[i].hide + 3) & ~3;
-				B[i].skip = (cnt + s) >> 2;
-				B[i].hide = (h - s) >> 2;
+				uint16 s = _b[i].skip & ~3;
+				uint16 h = (_b[i].hide + 3) & ~3;
+				_b[i].skip = (cnt + s) >> 2;
+				_b[i].hide = (h - s) >> 2;
 				cnt = SCR_WID - h;
 			}
 		}
@@ -305,14 +305,14 @@ BMP_PTR BITMAP::Code(void) {
 }
 
 
-bool BITMAP::SolidAt(int x, int y) {
+bool Bitmap::SolidAt(int x, int y) {
 	uint8 *m;
 	uint16 r, n, n0;
 
-	if ((x >= W) || (y >= H))
+	if ((x >= _w) || (y >= _h))
 		return false;
 
-	m = V;
+	m = _v;
 	r = x % 4;
 	n0 = (SCR_WID * y + x) / 4, n = 0;
 
@@ -326,7 +326,7 @@ bool BITMAP::SolidAt(int x, int y) {
 
 		switch (t) {
 		case EOI :
-			-- r;
+			r--;
 		case SKP :
 			w = 0;
 			break;
@@ -366,9 +366,9 @@ bool BITMAP::SolidAt(int x, int y) {
 }
 
 
-bool BITMAP::VBMSave(XFILE *f) {
+bool Bitmap::VBMSave(XFILE *f) {
 	uint16 p = (Pal != NULL),
-	       n = ((uint16)(((uint8 *)B) - V)) + H * sizeof(HideDesc);
+	       n = ((uint16)(((uint8 *)_b) - _v)) + _h * sizeof(HideDesc);
 	if (f->Error == 0)
 		f->Write((uint8 *)&p, sizeof(p));
 
@@ -376,23 +376,23 @@ bool BITMAP::VBMSave(XFILE *f) {
 		f->Write((uint8 *)&n, sizeof(n));
 
 	if (f->Error == 0)
-		f->Write((uint8 *)&W, sizeof(W));
+		f->Write((uint8 *)&_w, sizeof(_w));
 
 	if (f->Error == 0)
-		f->Write((uint8 *)&H, sizeof(H));
+		f->Write((uint8 *)&_h, sizeof(_h));
 
 	if (f->Error == 0)
 		if (p)
 			f->Write((uint8 *)Pal, 256 * 3);
 
 	if (f->Error == 0)
-		f->Write(V, n);
+		f->Write(_v, n);
 
 	return (f->Error == 0);
 }
 
 
-bool BITMAP::VBMLoad(XFILE *f) {
+bool Bitmap::VBMLoad(XFILE *f) {
 	uint16 p = 0, n = 0;
 	if (f->Error == 0)
 		f->Read((uint8 *)&p, sizeof(p));
@@ -401,10 +401,10 @@ bool BITMAP::VBMLoad(XFILE *f) {
 		f->Read((uint8 *)&n, sizeof(n));
 
 	if (f->Error == 0)
-		f->Read((uint8 *)&W, sizeof(W));
+		f->Read((uint8 *)&_w, sizeof(_w));
 
 	if (f->Error == 0)
-		f->Read((uint8 *)&H, sizeof(H));
+		f->Read((uint8 *)&_h, sizeof(_h));
 
 	if (f->Error == 0) {
 		if (p) {
@@ -416,17 +416,17 @@ bool BITMAP::VBMLoad(XFILE *f) {
 				f->Seek(f->Mark() + PAL_SIZ);
 		}
 	}
-	if ((V = farnew(uint8, n)) == NULL)
+	if ((_v = farnew(uint8, n)) == NULL)
 		return false;
 
 	if (f->Error == 0)
-		f->Read(V, n);
+		f->Read(_v, n);
 
-	B = (HideDesc *)(V + n - H * sizeof(HideDesc));
+	_b = (HideDesc *)(_v + n - _h * sizeof(HideDesc));
 	return (f->Error == 0);
 }
 
-bool BITMAP::BMPLoad (XFILE * f) {
+bool Bitmap::BMPLoad (XFILE * f) {
   struct {
 	   char BM[2];
 	   union { int16 len; int32 len_; };
@@ -459,13 +459,13 @@ bool BITMAP::BMPLoad (XFILE * f) {
 		    }
 		  Pal = NULL;
 		}
-	      H = hea.hig;
-	      W = hea.wid;
-	      if ((M = farnew(byte, H * W)) != NULL) {
+	      _h = hea.hig;
+	      _w = hea.wid;
+	      if ((_m = farnew(byte, _h * _w)) != NULL) {
 		  int16 r = (4 - (hea.wid & 3)) % 4;
 		  byte buf[3]; int i;
-		  for (i = H-1; i >= 0; i --) {
-		      f->Read(M + (W * i), W);
+		  for (i = _h - 1; i >= 0; i--) {
+		      f->Read(_m + (_w * i), _w);
 		      if (r && f->Error == 0)
 				  f->Read(buf, r);
 		      if (f->Error)
diff --git a/engines/cge/bitmap.h b/engines/cge/bitmap.h
index e114760e2a..cfa7830f39 100644
--- a/engines/cge/bitmap.h
+++ b/engines/cge/bitmap.h
@@ -59,25 +59,28 @@ struct HideDesc {
 
 #include "common/pack-end.h"
 
-class BITMAP {
+class Bitmap {
 	bool BMPLoad(XFILE *f);
 	bool VBMLoad(XFILE *f);
 public:
 	static DAC *Pal;
-	uint16 W, H;
-	uint8 *M, * V;
-	HideDesc *B;
-	BITMAP(const char *fname, bool rem = true);
-	BITMAP(uint16 w, uint16 h, uint8 *map);
-	BITMAP(uint16 w, uint16 h, uint8 fill);
-	BITMAP(const BITMAP &bmp);
-	~BITMAP(void);
+	uint16 _w;
+	uint16 _h;
+	uint8 *_m;
+	uint8 *_v;
+	HideDesc *_b;
+
+	Bitmap(const char *fname, bool rem = true);
+	Bitmap(uint16 w, uint16 h, uint8 *map);
+	Bitmap(uint16 w, uint16 h, uint8 fill);
+	Bitmap(const Bitmap &bmp);
+	~Bitmap(void);
 	static void init();
 	static void deinit();
 
-	BITMAP *FlipH(void);
-	BITMAP *Code();
-	BITMAP &operator = (const BITMAP &bmp);
+	Bitmap *FlipH(void);
+	Bitmap *Code();
+	Bitmap &operator = (const Bitmap &bmp);
 	void Hide(int x, int y);
 	void Show(int x, int y);
 	void XShow(int x, int y);
@@ -87,7 +90,7 @@ public:
 };
 
 
-typedef BITMAP     *BMP_PTR;
+typedef Bitmap *BMP_PTR;
 
 } // End of namespace CGE
 
diff --git a/engines/cge/bitmaps.h b/engines/cge/bitmaps.h
index 5ac878de3c..40b1158b21 100644
--- a/engines/cge/bitmaps.h
+++ b/engines/cge/bitmaps.h
@@ -32,12 +32,12 @@
 
 namespace CGE {
 
-extern BITMAP  *MB[];
-extern BITMAP  *HL[];
-extern BITMAP  *MC[];
-extern BITMAP  *PR[];
-extern BITMAP  *SP[];
-extern BITMAP  *LI[];
+extern Bitmap *MB[];
+extern Bitmap *HL[];
+extern Bitmap *MC[];
+extern Bitmap *PR[];
+extern Bitmap *SP[];
+extern Bitmap *LI[];
 
 } // End of namespace CGE
 
diff --git a/engines/cge/cge.cpp b/engines/cge/cge.cpp
index 07638ebdd8..885aa4d492 100644
--- a/engines/cge/cge.cpp
+++ b/engines/cge/cge.cpp
@@ -57,7 +57,7 @@ void CGEEngine::setup() {
 	// Initialise classes that have static members
 	VGA::init();
 	VFILE::init();
-	BITMAP::init();
+	Bitmap::init();
 	TALK::init();
 
 	// Initialise engine objects
@@ -77,22 +77,22 @@ void CGEEngine::setup() {
 	InfoLine = new INFO_LINE(this, INFO_W);
 	_cavLight = new Sprite(this, PR);
 	DebugLine = new INFO_LINE(this, SCR_WID);
-	MB[0] = new BITMAP("BRICK");
+	MB[0] = new Bitmap("BRICK");
 	MB[1] = NULL;
-	HL[0] = new BITMAP("HLINE");
+	HL[0] = new Bitmap("HLINE");
 	HL[1] = NULL;
-	MC[0] = new BITMAP("MOUSE");
-	MC[1] = new BITMAP("DUMMY");
+	MC[0] = new Bitmap("MOUSE");
+	MC[1] = new Bitmap("DUMMY");
 	MC[2] = NULL;
-	PR[0] = new BITMAP("PRESS");
+	PR[0] = new Bitmap("PRESS");
 	PR[1] = NULL;
-	SP[0] = new BITMAP("SPK_L");
-	SP[1] = new BITMAP("SPK_R");
+	SP[0] = new Bitmap("SPK_L");
+	SP[1] = new Bitmap("SPK_R");
 	SP[2] = NULL;
-	LI[0] = new BITMAP("LITE0");
-	LI[1] = new BITMAP("LITE1");
-	LI[2] = new BITMAP("LITE2");
-	LI[3] = new BITMAP("LITE3");
+	LI[0] = new Bitmap("LITE0");
+	LI[1] = new Bitmap("LITE1");
+	LI[2] = new Bitmap("LITE2");
+	LI[3] = new Bitmap("LITE3");
 	LI[4] = NULL;
 	Snail = new SNAIL(this, false);
 	Snail_ = new SNAIL(this, true);
@@ -105,7 +105,7 @@ CGEEngine::~CGEEngine() {
 
 	// Call classes with static members to clear them up
 	TALK::deinit();
-	BITMAP::deinit();
+	Bitmap::deinit();
 	VFILE::deinit();
 	VGA::deinit();
 
diff --git a/engines/cge/cge_main.cpp b/engines/cge/cge_main.cpp
index e5294c0c14..1e1b952f77 100644
--- a/engines/cge/cge_main.cpp
+++ b/engines/cge/cge_main.cpp
@@ -281,7 +281,7 @@ void CGEEngine::LoadGame(XFILE &file, bool tiny = false) {
 			if (n != sizeof(S))
 				break;
 
-			S.Prev = S.Next = NULL;
+			S._prev = S._next = NULL;
 			spr = (scumm_stricmp(S.File + 2, "MUCHA") == 0) ? new FLY(this, NULL)
 			      : new Sprite(this, NULL);
 			if (spr == NULL)
@@ -325,7 +325,7 @@ static void SaveGame(XFILE &file) {
 
 	file.Write((uint8 *) & (i = SVGCHKSUM), sizeof(i));
 
-	for (spr = Vga->SpareQ->First(); spr; spr = spr->Next)
+	for (spr = Vga->SpareQ->First(); spr; spr = spr->_next)
 		if (spr->_ref >= 1000)
 			if (!file.Error)
 				file.Write((uint8 *)spr, sizeof(*spr));
@@ -393,29 +393,31 @@ WALK::WALK(CGEEngine *vm, BMP_PTR *shpl)
 
 
 void WALK::Tick(void) {
-	if (Flags.Hide)
+	if (_flags._hide)
 		return;
 
-	Here = XZ(X + W / 2, Y + H);
+	Here = XZ(_x + _w / 2, _y + _h);
 
 	if (Dir != NO_DIR) {
 		Sprite *spr;
 		Sys->FunTouch();
-		for (spr = Vga->ShowQ->First(); spr; spr = spr->Next) {
-				if (Distance(spr) < 2) {
-				if (! spr->Flags.Near) {
+		for (spr = Vga->ShowQ->First(); spr; spr = spr->_next) {
+			if (Distance(spr) < 2) {
+				if (!spr->_flags._near) {
 					FeedSnail(spr, NEAR);
-					spr->Flags.Near = true;
+					spr->_flags._near = true;
 				}
-			} else spr->Flags.Near = false;
+			} else {
+				spr->_flags._near = false;
+			}
 		}
 	}
 
-	if (Flags.Hold || TracePtr < 0)
+	if (_flags._hold || TracePtr < 0)
 		Park();
 	else {
 		if (Here == Trace[TracePtr]) {
-			if (-- TracePtr < 0)
+			if (--TracePtr < 0)
 				Park();
 		} else {
 			signed char dx, dz;
@@ -425,13 +427,13 @@ void WALK::Tick(void) {
 		}
 	}
 	Step();
-	if ((Dir == WW && X <= 0)           ||
-	    (Dir == EE && X + W >= SCR_WID) ||
-	    (Dir == SS && Y + W >= WORLD_HIG - 2))
+	if ((Dir == WW && _x <= 0)           ||
+	    (Dir == EE && _x + _w >= SCR_WID) ||
+	    (Dir == SS && _y + _w >= WORLD_HIG - 2))
 		Park();
 	else {
 		signed char x;            // dummy var
-		Here.Split(x, Z);         // take current Z position
+		Here.Split(x, _z);         // take current Z position
 		SNPOST_(SNZTRIM, -1, 0, this);    // update Hero's pos in show queue
 	}
 }
@@ -439,15 +441,15 @@ void WALK::Tick(void) {
 
 int WALK::Distance(Sprite *spr) {
 	int dx, dz;
-	dx = spr->X - (X + W - WALKSIDE);
+	dx = spr->_x - (_x + _w - WALKSIDE);
 	if (dx < 0)
-		dx = (X + WALKSIDE) - (spr->X + spr->W);
+		dx = (_x + WALKSIDE) - (spr->_x + spr->_w);
 
 	if (dx < 0)
 		dx = 0;
 
 	dx /= MAP_XGRID;
-	dz = spr->Z - Z;
+	dz = spr->_z - _z;
 	if (dz < 0)
 		dz = - dz;
 
@@ -469,8 +471,8 @@ void WALK::Turn(DIR d) {
 
 
 void WALK::Park(void) {
-	if (Time == 0)
-		++Time;
+	if (_time == 0)
+		++_time;
 
 	if (Dir != NO_DIR) {
 		Step(9 + 4 * Dir + Dir);
@@ -507,11 +509,12 @@ void WALK::FindWay(CLUSTER c) {
 
 void WALK::FindWay(Sprite *spr) {
 	if (spr && spr != this) {
-		int x = spr->X, z = spr->Z;
-		if (spr->Flags.East)
-			x += spr->W + W / 2 - WALKSIDE;
+		int x = spr->_x;
+		int z = spr->_z;
+		if (spr->_flags._east)
+			x += spr->_w + _w / 2 - WALKSIDE;
 		else
-			x -= W / 2 - WALKSIDE;
+			x -= _w / 2 - WALKSIDE;
 		FindWay(CLUSTER((x / MAP_XGRID),
 		                ((z < MAP_ZCNT - MAX_DISTANCE) ? (z + 1)
 		                 : (z - 1))));
@@ -520,7 +523,7 @@ void WALK::FindWay(Sprite *spr) {
 
 
 bool WALK::Lower(Sprite *spr) {
-	return (spr->Y > Y + (H * 3) / 5);
+	return (spr->_y > _y + (_h * 3) / 5);
 }
 
 
@@ -528,7 +531,7 @@ void WALK::Reach(Sprite *spr, int mode) {
 	if (spr) {
 		Hero->FindWay(spr);
 		if (mode < 0) {
-			mode = spr->Flags.East;
+			mode = spr->_flags._east;
 			if (Lower(spr))
 				mode += 2;
 		}
@@ -556,15 +559,15 @@ private:
 
 SQUARE::SQUARE(CGEEngine *vm)
 	: Sprite(vm, MB), _vm(vm) {
-	Flags.Kill = true;
-	Flags.BDel = false;
+	_flags._kill = true;
+	_flags._bDel = false;
 }
 
 
 void SQUARE::Touch(uint16 mask, int x, int y) {
 	Sprite::Touch(mask, x, y);
 	if (mask & L_UP) {
-		XZ(X + x, Y + y).Cell() = 0;
+		XZ(_x + x, _y + y).Cell() = 0;
 		SNPOST_(SNKILL, -1, 0, this);
 	}
 }
@@ -610,7 +613,7 @@ void CGEEngine::Quit() {
 		{ NULL, &CGEEngine::dummy          }
 	};
 
-	if (Snail->Idle() && ! Hero->Flags.Hide) {
+	if (Snail->Idle() && ! Hero->_flags._hide) {
 		if (VMENU::Addr) {
 			SNPOST_(SNKILL, -1, 0, VMENU::Addr);
 			ResetQSwitch();
@@ -632,14 +635,14 @@ static void AltCtrlDel(void) {
 // Used in stubbed function, do not remove!
 static void MiniStep(int stp) {
 	if (stp < 0)
-		_miniCave->Flags.Hide = true;
+		_miniCave->_flags._hide = true;
 	else {
 		&*Mini;
 		*MiniShp[0] = *MiniShpList[stp];
 		if (Fx.Current)
 			&*(Fx.Current->EAddr());
 
-		_miniCave->Flags.Hide = false;
+		_miniCave->_flags._hide = false;
 	}
 }
 
@@ -672,9 +675,9 @@ void SYSTEM::FunTouch(void) {
 static void ShowBak(int ref) {
 	Sprite *spr = Vga->SpareQ->Locate(ref);
 	if (spr) {
-		BITMAP::Pal = VGA::SysPal;
+		Bitmap::Pal = VGA::SysPal;
 		spr->Expand();
-		BITMAP::Pal = NULL;
+		Bitmap::Pal = NULL;
 		spr->Show(2);
 		Vga->CopyPage(1, 2);
 		Sys->SetPal();
@@ -693,10 +696,10 @@ static void CaveUp(void) {
 	Text->Preload(BakRef, BakRef + 1000);
 	Sprite *spr = Vga->SpareQ->First();
 	while (spr) {
-		Sprite *n = spr->Next;
+		Sprite *n = spr->_next;
 		if (spr->_cave == Now || spr->_cave == 0)
 			if (spr->_ref != BakRef) {
-				if (spr->Flags.Back)
+				if (spr->_flags._back)
 					spr->BackShow();
 				else
 					ExpandSprite(spr);
@@ -711,11 +714,11 @@ static void CaveUp(void) {
 	}
 
 	if (Hero) {
-		Hero->Goto(HeroXY[Now - 1].X, HeroXY[Now - 1].Y);
+		Hero->Goto(HeroXY[Now - 1]._x, HeroXY[Now - 1]._y);
 		// following 2 lines trims Hero's Z position!
 		Hero->Tick();
-		Hero->Time = 1;
-		Hero->Flags.Hide = false;
+		Hero->_time = 1;
+		Hero->_flags._hide = false;
 	}
 
 	if (! Dark)
@@ -730,7 +733,7 @@ static void CaveUp(void) {
 		Vga->ShowQ->Remove(_shadow);
 		_shadow->MakeXlat(Glass(VGA::SysPal, 204, 204, 204));
 		Vga->ShowQ->Insert(_shadow, Hero);
-		_shadow->Z = Hero->Z;
+		_shadow->_z = Hero->_z;
 	}
 	FeedSnail(Vga->ShowQ->Locate(BakRef + 999), TAKE);
 	Vga->Show();
@@ -747,11 +750,11 @@ static void CaveUp(void) {
 
 void CGEEngine::CaveDown() {
 	Sprite *spr;
-	if (!_horzLine->Flags.Hide)
+	if (!_horzLine->_flags._hide)
 		SwitchMapping();
 
 	for (spr = Vga->ShowQ->First(); spr;) {
-		Sprite *n = spr->Next;
+		Sprite *n = spr->_next;
 		if (spr->_ref >= 1000 /*&& spr->_cave*/) {
 			if (spr->_ref % 1000 == 999)
 				FeedSnail(spr, TAKE);
@@ -844,7 +847,7 @@ void SYSTEM::Touch(uint16 mask, int x, int y) {
 				Sprite *m = Vga->ShowQ->Locate(17001);
 				if (m) {
 					m->Step(1);
-					m->Time = 216; // 3s
+					m->_time = 216; // 3s
 				}
 			}
 			break;
@@ -909,7 +912,7 @@ void SYSTEM::Touch(uint16 mask, int x, int y) {
 				_sprite->Step(x - '0');
 			break;
 		case F10          :
-			if (Snail->Idle() && ! Hero->Flags.Hide)
+			if (Snail->Idle() && ! Hero->_flags._hide)
 				_vm->StartCountDown();
 			break;
 		case 'J':
@@ -957,7 +960,7 @@ void SYSTEM::Touch(uint16 mask, int x, int y) {
 			if (cav && Snail->Idle() && Hero->TracePtr < 0)
 				_vm->SwitchCave(cav);
 
-			if (!_horzLine->Flags.Hide) {
+			if (!_horzLine->_flags._hide) {
 				if (y >= MAP_TOP && y < MAP_TOP + MAP_HIG) {
 					int8 x1, z1;
 					XZ(x, y).Split(x1, z1);
@@ -985,7 +988,7 @@ void SYSTEM::Tick(void) {
 				else if (STARTUP::Core >= CORE_MID) {
 					int n = new_random(100);
 					if (n > 96)
-						HeroCover(6 + (Hero->X + Hero->W / 2 < SCR_WID / 2));
+						HeroCover(6 + (Hero->_x + Hero->_w / 2 < SCR_WID / 2));
 					else {
 						if (n > 90)
 							HeroCover(5);
@@ -1000,7 +1003,7 @@ void SYSTEM::Tick(void) {
 			}
 			FunTouch();
 		}
-	Time = SYSTIMERATE;
+	_time = SYSTIMERATE;
 }
 
 
@@ -1070,8 +1073,8 @@ void CGEEngine::TakeName() {
 		if (tn) {
 			tn->SetName(Text->getText(GETNAME_TITLE));
 			tn->Center();
-			tn->Goto(tn->X, tn->Y - 10);
-			tn->Z = 126;
+			tn->Goto(tn->_x, tn->_y - 10);
+			tn->_z = 126;
 			Vga->ShowQ->Insert(tn);
 		}
 	}
@@ -1079,7 +1082,7 @@ void CGEEngine::TakeName() {
 
 
 void CGEEngine::SwitchMapping() {
-	if (_horzLine->Flags.Hide) {
+	if (_horzLine->_flags._hide) {
 		int i;
 		for (i = 0; i < MAP_ZCNT; i++) {
 			int j;
@@ -1090,28 +1093,28 @@ void CGEEngine::SwitchMapping() {
 		}
 	} else {
 		Sprite *s;
-		for (s = Vga->ShowQ->First(); s; s = s->Next)
-			if (s->W == MAP_XGRID && s->H == MAP_ZGRID)
+		for (s = Vga->ShowQ->First(); s; s = s->_next)
+			if (s->_w == MAP_XGRID && s->_h == MAP_ZGRID)
 				SNPOST_(SNKILL, -1, 0, s);
 	}
-	_horzLine->Flags.Hide = !_horzLine->Flags.Hide;
+	_horzLine->_flags._hide = !_horzLine->_flags._hide;
 }
 
 
 static void KillSprite(void) {
-	_sprite->Flags.Kill = true;
-	_sprite->Flags.BDel = true;
+	_sprite->_flags._kill = true;
+	_sprite->_flags._bDel = true;
 	SNPOST_(SNKILL, -1, 0, _sprite);
 	_sprite = NULL;
 }
 
 
 static void PushSprite(void) {
-	Sprite *spr = _sprite->Prev;
+	Sprite *spr = _sprite->_prev;
 	if (spr) {
 		Vga->ShowQ->Insert(Vga->ShowQ->Remove(_sprite), spr);
-		while (_sprite->Z > _sprite->Next->Z)
-			--_sprite->Z;
+		while (_sprite->_z > _sprite->_next->_z)
+			_sprite->_z--;
 	} else
 		SNPOST_(SNSOUND, -1, 2, NULL);
 }
@@ -1119,17 +1122,17 @@ static void PushSprite(void) {
 
 static void PullSprite(void) {
 	bool ok = false;
-	Sprite *spr = _sprite->Next;
+	Sprite *spr = _sprite->_next;
 	if (spr) {
-		spr = spr->Next;
+		spr = spr->_next;
 		if (spr)
-			ok = (!spr->Flags.Slav);
+			ok = (!spr->_flags._slav);
 	}
 	if (ok) {
 		Vga->ShowQ->Insert(Vga->ShowQ->Remove(_sprite), spr);
-		if (_sprite->Prev)
-			while (_sprite->Z < _sprite->Prev->Z)
-				++_sprite->Z;
+		if (_sprite->_prev)
+			while (_sprite->_z < _sprite->_prev->_z)
+				_sprite->_z++;
 	} else
 		SNPOST_(SNSOUND, -1, 2, NULL);
 }
@@ -1151,8 +1154,8 @@ static void SaveMapping(void) {
 	{
 		IOHAND cf(ProgName(".HXY"), WRI);
 			if (!cf.Error) {
-				HeroXY[Now - 1].X = Hero->X;
-				HeroXY[Now - 1].Y = Hero->Y;
+				HeroXY[Now - 1]._x = Hero->_x;
+				HeroXY[Now - 1]._y = Hero->_y;
 				cf.Write((uint8 *) HeroXY, sizeof(HeroXY));
 		}
 	}
@@ -1180,7 +1183,7 @@ static  char    DebugText[] = " N=00000 F=000000 X=000 Y=000 FPS=0000\0S=00:00 0
 #define SP__    (DebugText + 70)
 
 static void SayDebug(void) {
-	if (!DebugLine->Flags.Hide) {
+	if (!DebugLine->_flags._hide) {
 		static long t = -1L;
 		long t1 = Timer();
 
@@ -1192,25 +1195,25 @@ static void SayDebug(void) {
 			t = t1;
 		}
 
-		dwtom(Mouse->X, ABSX, 10, 3);
-		dwtom(Mouse->Y, ABSY, 10, 3);
+		dwtom(Mouse->_x, ABSX, 10, 3);
+		dwtom(Mouse->_y, ABSY, 10, 3);
 //		dwtom(coreleft(), NFRE, 10, 5);
 //		dwtom(farcoreleft(), FFRE, 10, 6);
 
 		// sprite queue size
 		uint16 n = 0;
 		Sprite *spr;
-		for (spr = Vga->ShowQ->First(); spr; spr = spr->Next) {
+		for (spr = Vga->ShowQ->First(); spr; spr = spr->_next) {
 			++ n;
 			if (spr == _sprite) {
 				*XSPR = ' ';
 				dwtom(n, SP_N, 10, 2);
-				dwtom(_sprite->X, SP_X, 10, 3);
-				dwtom(_sprite->Y, SP_Y, 10, 3);
-				dwtom(_sprite->Z, SP_Z, 10, 3);
-				dwtom(_sprite->W, SP_W, 10, 3);
-				dwtom(_sprite->H, SP_H, 10, 3);
-				dwtom(*(uint16 *)(&_sprite->Flags), SP_F, 16, 2);
+				dwtom(_sprite->_x, SP_X, 10, 3);
+				dwtom(_sprite->_y, SP_Y, 10, 3);
+				dwtom(_sprite->_z, SP_Z, 10, 3);
+				dwtom(_sprite->_w, SP_W, 10, 3);
+				dwtom(_sprite->_h, SP_H, 10, 3);
+				dwtom(*(uint16 *)(&_sprite->_flags), SP_F, 16, 2);
 			}
 		}
 		dwtom(n, SP_S, 10, 2);
@@ -1221,7 +1224,7 @@ static void SayDebug(void) {
 
 
 static void SwitchDebug(void) {
-	DebugLine->Flags.Hide = ! DebugLine->Flags.Hide;
+	DebugLine->_flags._hide = ! DebugLine->_flags._hide;
 }
 
 
@@ -1259,16 +1262,16 @@ void Sprite::Touch(uint16 mask, int x, int y) {
 			_vm->OptionTouch(_ref % 10, mask);
 			return;
 		}
-		if (Flags.Syst)
+		if (_flags._syst)
 			return;       // cannot access system sprites
 		if (Game) if (mask & L_UP) {
 				mask &= ~L_UP;
 				mask |= R_UP;
 			}
 		if ((mask & R_UP) && Snail->Idle()) {
-			Sprite *ps = (_pocLight->SeqPtr) ? _pocket[PocPtr] : NULL;
+			Sprite *ps = (_pocLight->_seqPtr) ? _pocket[PocPtr] : NULL;
 			if (ps) {
-				if (Flags.Kept || Hero->Distance(this) < MAX_DISTANCE) {
+				if (_flags._kept || Hero->Distance(this) < MAX_DISTANCE) {
 					if (Works(ps)) {
 						FeedSnail(ps, TAKE);
 					} else
@@ -1277,18 +1280,18 @@ void Sprite::Touch(uint16 mask, int x, int y) {
 				} else
 					TooFar();
 			} else {
-				if (Flags.Kept)
+				if (_flags._kept)
 					mask |= L_UP;
 				else {
 					if (Hero->Distance(this) < MAX_DISTANCE) {
 						///
-						if (Flags.Port) {
+						if (_flags._port) {
 							if (FindPocket(NULL) < 0)
 								PocFul();
 							else {
 								SNPOST(SNREACH, -1, -1, this);
 								SNPOST(SNKEEP, -1, -1, this);
-								Flags.Port = false;
+								_flags._port = false;
 							}
 						} else {
 							if (TakePtr != NO_PTR) {
@@ -1306,7 +1309,7 @@ void Sprite::Touch(uint16 mask, int x, int y) {
 			}
 		}
 		if ((mask & L_UP) && Snail->Idle()) {
-			if (Flags.Kept) {
+			if (_flags._kept) {
 				int n;
 				for (n = 0; n < POCKET_NX; n++) {
 					if (_pocket[n] == this) {
@@ -1456,12 +1459,12 @@ void CGEEngine::LoadSprite(const char *fname, int ref, int cav, int col = 0, int
 	if (_sprite) {
 		_sprite->_ref = ref;
 		_sprite->_cave = cav;
-		_sprite->Z = pos;
-		_sprite->Flags.East = east;
-		_sprite->Flags.Port = port;
-		_sprite->Flags.Tran = tran;
-		_sprite->Flags.Kill = true;
-		_sprite->Flags.BDel = true;
+		_sprite->_z = pos;
+		_sprite->_flags._east = east;
+		_sprite->_flags._port = port;
+		_sprite->_flags._tran = tran;
+		_sprite->_flags._kill = true;
+		_sprite->_flags._bDel = true;
 
 		// Extract the filename, without the extension
 		strcpy(_sprite->File, fname);
@@ -1469,7 +1472,7 @@ void CGEEngine::LoadSprite(const char *fname, int ref, int cav, int col = 0, int
 		if (p)
 			*p = '\0';
 
-		_sprite->ShpCnt = shpcnt;
+		_sprite->_shpCnt = shpcnt;
 		Vga->SpareQ->Append(_sprite);
 	}
 }
@@ -1528,7 +1531,7 @@ void CGEEngine::LoadScript(const char *fname) {
 		_sprite = NULL;
 		LoadSprite(SpN, SpI, SpA, SpX, SpY, SpZ);
 		if (_sprite && BkG)
-			_sprite->Flags.Back = true;
+			_sprite->_flags._back = true;
 	}
 	if (! ok)
 		error("%s [%s]", NumStr("Bad INI line ######", lcnt), fname);
@@ -1586,9 +1589,9 @@ void CGEEngine::RunGame() {
 	Text->Preload(100, 1000);
 	LoadHeroXY();
 
-	_cavLight->Flags.Tran = true;
+	_cavLight->_flags._tran = true;
 	Vga->ShowQ->Append(_cavLight);
-	_cavLight->Flags.Hide = true;
+	_cavLight->_flags._hide = true;
 
 	static Seq pocSeq[] = { { 0, 0, 0, 0, 20 },
 		{ 1, 2, 0, 0,  4 },
@@ -1599,9 +1602,9 @@ void CGEEngine::RunGame() {
 		{ 0, 1, 0, 0, 16 },
 	};
 	_pocLight->SetSeq(pocSeq);
-	_pocLight->Flags.Tran = true;
-	_pocLight->Time = 1;
-	_pocLight->Z = 120;
+	_pocLight->_flags._tran = true;
+	_pocLight->_time = 1;
+	_pocLight->_z = 120;
 	Vga->ShowQ->Append(_pocLight);
 	SelectPocket(-1);
 
@@ -1626,9 +1629,9 @@ void CGEEngine::RunGame() {
 			LoadSprite("MINI", -1, 0, MINI_X, MINI_Y);
 			ExpandSprite(_miniCave = _sprite);  // NULL is ok
 			if (_miniCave) {
-				_miniCave->Flags.Hide = true;
+				_miniCave->_flags._hide = true;
 				_miniCave->MoveShapes(ptr);
-				MiniShp[0] = new BITMAP(*_miniCave->Shp());
+				MiniShp[0] = new Bitmap(*_miniCave->Shp());
 				MiniShpList = _miniCave->SetShapeList(MiniShp);
 				PostMiniStep(-1);
 			}
@@ -1637,28 +1640,28 @@ void CGEEngine::RunGame() {
 
 	if (Hero) {
 		ExpandSprite(Hero);
-		Hero->Goto(HeroXY[Now - 1].X, HeroXY[Now - 1].Y);
+		Hero->Goto(HeroXY[Now - 1]._x, HeroXY[Now - 1]._y);
 		if (INI_FILE::Exist("00SHADOW.SPR")) {
-			LoadSprite("00SHADOW", -1, 0, Hero->X + 14, Hero->Y + 51);
+			LoadSprite("00SHADOW", -1, 0, Hero->_x + 14, Hero->_y + 51);
 			if ((_shadow = _sprite) != NULL) {
 				_shadow->_ref = 2;
-				_shadow->Flags.Tran = true;
-				Hero->Flags.Shad = true;
+				_shadow->_flags._tran = true;
+				Hero->_flags._shad = true;
 				Vga->ShowQ->Insert(Vga->SpareQ->Remove(_shadow), Hero);
 			}
 		}
 	}
 
 	InfoLine->Goto(INFO_X, INFO_Y);
-	InfoLine->Flags.Tran = true;
+	InfoLine->_flags._tran = true;
 	InfoLine->Update(NULL);
 	Vga->ShowQ->Insert(InfoLine);
 
-	DebugLine->Z = 126;
+	DebugLine->_z = 126;
 	Vga->ShowQ->Insert(DebugLine);
 
-	_horzLine->Y = MAP_TOP - (MAP_TOP > 0);
-	_horzLine->Z = 126;
+	_horzLine->_y = MAP_TOP - (MAP_TOP > 0);
+	_horzLine->_z = 126;
 	Vga->ShowQ->Insert(_horzLine);
 
 	Mouse->Busy = Vga->SpareQ->Locate(BUSY_REF);
@@ -1719,14 +1722,14 @@ void CGEEngine::Movie(const char *ext) {
 
 
 bool CGEEngine::ShowTitle(const char *name) {
-	BITMAP::Pal = VGA::SysPal;
-	BMP_PTR LB[] =  { new BITMAP(name), NULL };
-	BITMAP::Pal = NULL;
+	Bitmap::Pal = VGA::SysPal;
+	BMP_PTR LB[] =  { new Bitmap(name), NULL };
+	Bitmap::Pal = NULL;
 	bool usr_ok = false;
 
 	Sprite D(this, LB);
-	D.Flags.Kill = true;
-	D.Flags.BDel = true;
+	D._flags._kill = true;
+	D._flags._bDel = true;
 	D.Center();
 	D.Show(2);
 
@@ -1846,8 +1849,8 @@ void CGEEngine::cge_main(void) {
 	if (!SVG0FILE::Exist(SVG0NAME))
 		STARTUP::Mode = 2;
 
-	DebugLine->Flags.Hide = true;
-	_horzLine->Flags.Hide = true;
+	DebugLine->_flags._hide = true;
+	_horzLine->_flags._hide = true;
 
 	//srand((uint16) Timer());
 	Sys = new SYSTEM(this);
diff --git a/engines/cge/config.cpp b/engines/cge/config.cpp
index a9d55957af..2673143285 100644
--- a/engines/cge/config.cpp
+++ b/engines/cge/config.cpp
@@ -147,10 +147,10 @@ void CGEEngine::SelectSound() {
 	if (VMENU::Addr)
 		SNPOST_(SNKILL, -1, 0, VMENU::Addr);
 	Inf(Text->getText(STYPE_TEXT));
-	Talk->Goto(Talk->X, FONT_HIG / 2);
+	Talk->Goto(Talk->_x, FONT_HIG / 2);
 	for (i = 0; i < ArrayCount(DevName); i++)
 		DevMenu[i].Text = Text->getText(DevName[i]);
-	(new VMENU(this, DevMenu, SCR_WID / 2, Talk->Y + Talk->H + TEXT_VM + FONT_HIG))->SetName(Text->getText(MENU_TEXT));
+	(new VMENU(this, DevMenu, SCR_WID / 2, Talk->_y + Talk->_h + TEXT_VM + FONT_HIG))->SetName(Text->getText(MENU_TEXT));
 }
 
 
@@ -184,8 +184,8 @@ static int     Hlp;
 
 void CGEEngine::SNSelect() {
 	Inf(Text->getText(Hlp));
-	Talk->Goto(Talk->X, FONT_HIG / 2);
-	(new VMENU(this, Cho, SCR_WID / 2, Talk->Y + Talk->H + TEXT_VM + FONT_HIG))->SetName(Text->getText(MENU_TEXT));
+	Talk->Goto(Talk->_x, FONT_HIG / 2);
+	(new VMENU(this, Cho, SCR_WID / 2, Talk->_y + Talk->_h + TEXT_VM + FONT_HIG))->SetName(Text->getText(MENU_TEXT));
 }
 
 
diff --git a/engines/cge/game.cpp b/engines/cge/game.cpp
index a5b82f1e8d..87daced31e 100644
--- a/engines/cge/game.cpp
+++ b/engines/cge/game.cpp
@@ -67,25 +67,25 @@ int FLY::L = 20,
     FLY::B = 100;
 
 
-FLY::FLY(CGEEngine *vm, BITMAP **shpl)
+FLY::FLY(CGEEngine *vm, Bitmap **shpl)
 	: Sprite(vm, shpl), Tx(0), Ty(0), _vm(vm) {
 	Step(new_random(2));
-	Goto(L + new_random(R - L - W), T + new_random(B - T - H));
+	Goto(L + new_random(R - L - _w), T + new_random(B - T - _h));
 }
 
 
 void FLY::Tick(void) {
 	Step();
-	if (! Flags.Kept) {
+	if (!_flags._kept) {
 		if (new_random(10) < 1) {
 			Tx = new_random(3) - 1;
 			Ty = new_random(3) - 1;
 		}
-		if (X + Tx < L || X + Tx + W > R)
+		if (_x + Tx < L || _x + Tx + _w > R)
 			Tx = -Tx;
-		if (Y + Ty < T || Y + Ty + H > B)
+		if (_y + Ty < T || _y + Ty + _h > B)
 			Ty = -Ty;
-		Goto(X + Tx, Y + Ty);
+		Goto(_x + Tx, _y + Ty);
 	}
 }
 
diff --git a/engines/cge/game.h b/engines/cge/game.h
index fb4dad6fae..a64018aa58 100644
--- a/engines/cge/game.h
+++ b/engines/cge/game.h
@@ -48,7 +48,7 @@ class FLY : public Sprite {
 	static int L, T, R, B;
 public:
 	int Tx, Ty;
-	FLY(CGEEngine *vm, BITMAP **shpl);
+	FLY(CGEEngine *vm, Bitmap **shpl);
 	void Tick(void);
 private:
 	CGEEngine *_vm;
diff --git a/engines/cge/gettext.cpp b/engines/cge/gettext.cpp
index f891b9c092..e3c60b6e21 100644
--- a/engines/cge/gettext.cpp
+++ b/engines/cge/gettext.cpp
@@ -44,8 +44,8 @@ GET_TEXT::GET_TEXT(CGEEngine *vm, const char *info, char *text, int size, void (
 	Mode = RECT;
 	TS[0] = Box((i + 3) & ~3, 2 * TEXT_VM + 2 * FONT_HIG + TEXT_LS);
 	SetShapeList(TS);
-	Flags.BDel = true;
-	Flags.Kill = true;
+	_flags._bDel = true;
+	_flags._kill = true;
 	memcpy(Buff, text, Len);
 	Buff[Len] = ' ';
 	Buff[Len + 1] = '\0';
@@ -66,7 +66,7 @@ void GET_TEXT::Tick(void) {
 		Cntr = 0;
 	}
 	PutLine(1, Buff);
-	Time = GTTIME;
+	_time = GTTIME;
 }
 
 
@@ -107,7 +107,7 @@ void GET_TEXT::Touch(uint16 mask, int x, int y) {
 					if (p)
 						x = ogon[p - bezo];
 				}
-				if (Len < Size && 2 * TEXT_HM + _Font->Width(Buff) + _Font->Wid[x] <= W) {
+				if (Len < Size && 2 * TEXT_HM + _Font->Width(Buff) + _Font->Wid[x] <= _w) {
 					Buff[Len + 2] = Buff[Len + 1];
 					Buff[Len + 1] = Buff[Len];
 					Buff[Len++] = x;
diff --git a/engines/cge/mixer.cpp b/engines/cge/mixer.cpp
index c1f688babd..7b9ce59f5e 100644
--- a/engines/cge/mixer.cpp
+++ b/engines/cge/mixer.cpp
@@ -42,15 +42,15 @@ bool   MIXER::Appear = false;
 
 MIXER::MIXER(CGEEngine *vm, int x, int y) : Sprite(vm, NULL), Fall(MIX_FALL), _vm(vm) {
 	Appear = true;
-	mb[0] = new BITMAP("VOLUME");
+	mb[0] = new Bitmap("VOLUME");
 	mb[1] = NULL;
 	SetShapeList(mb);
 	SetName(Text->getText(MIX_NAME));
-	Flags.Syst = true;
-	Flags.Kill = true;
-	Flags.BDel = true;
+	_flags._syst = true;
+	_flags._kill = true;
+	_flags._bDel = true;
 	Goto(x, y);
-	Z = MIX_Z;
+	_z = MIX_Z;
 
 	// slaves
 
@@ -58,7 +58,7 @@ MIXER::MIXER(CGEEngine *vm, int x, int y) : Sprite(vm, NULL), Fall(MIX_FALL), _v
 	for (i = 0; i < MIX_MAX; i++) {
 		static char fn[] = "V00";
 		wtom(i, fn + 1, 10, 2);
-		lb[i] = new BITMAP(fn);
+		lb[i] = new Bitmap(fn);
 		ls[i].Now = ls[i].Next = i;
 		ls[i].Dx = ls[i].Dy = ls[i].Dly = 0;
 	}
@@ -68,13 +68,13 @@ MIXER::MIXER(CGEEngine *vm, int x, int y) : Sprite(vm, NULL), Fall(MIX_FALL), _v
 		register Sprite *spr = new Sprite(_vm, lb);
 		spr->SetSeq(ls);
 		spr->Goto(x + 2 + 12 * i, y + 8);
-		spr->Flags.Tran = true;
-		spr->Flags.Kill = true;
-		spr->Flags.BDel = false;
-		spr->Z = MIX_Z;
+		spr->_flags._tran = true;
+		spr->_flags._kill = true;
+		spr->_flags._bDel = false;
+		spr->_z = MIX_Z;
 		Led[i] = spr;
 	}
-	Led[ArrayCount(Led) - 1]->Flags.BDel = true;
+	Led[ArrayCount(Led) - 1]->_flags._bDel = true;
 
 	Vga->ShowQ->Insert(this);
 	for (i = 0; i < ArrayCount(Led); i++)
@@ -88,7 +88,7 @@ MIXER::MIXER(CGEEngine *vm, int x, int y) : Sprite(vm, NULL), Fall(MIX_FALL), _v
 	SNDDrvInfo.VOL4.DL = i;
 	SNDDrvInfo.VOL4.DR = i;
 	Update();
-	Time = MIX_DELAY;
+	_time = MIX_DELAY;
 }
 
 MIXER::~MIXER(void) {
@@ -100,11 +100,11 @@ MIXER::~MIXER(void) {
 void MIXER::Touch(uint16 mask, int x, int y) {
 	Sprite::Touch(mask, x, y);
 	if (mask & L_UP) {
-		uint8 *vol = (&SNDDrvInfo.VOL2.D) + (x < W / 2);
+		uint8 *vol = (&SNDDrvInfo.VOL2.D) + (x < _w / 2);
 		if (y < MIX_BHIG) {
 			if (*vol < 0xFF)
 				*vol += 0x11;
-		} else if (y >= H - MIX_BHIG) {
+		} else if (y >= _h - MIX_BHIG) {
 			if (*vol > 0x00)
 				*vol -= 0x11;
 		}
@@ -114,12 +114,12 @@ void MIXER::Touch(uint16 mask, int x, int y) {
 
 
 void MIXER::Tick(void) {
-	int x = Mouse->X;
-	int y = Mouse->Y;
+	int x = Mouse->_x;
+	int y = Mouse->_y;
 	if (SpriteAt(x, y) == this) {
 		Fall = MIX_FALL;
-		if (Flags.Hold)
-			Touch(L_UP, x - X, y - Y);
+		if (_flags._hold)
+			Touch(L_UP, x - _x, y - _y);
 	} else {
 		if (Fall)
 			--Fall;
@@ -129,7 +129,7 @@ void MIXER::Tick(void) {
 			SNPOST_(SNKILL, -1, 0, this);
 		}
 	}
-	Time = MIX_DELAY;
+	_time = MIX_DELAY;
 }
 
 
diff --git a/engines/cge/mouse.cpp b/engines/cge/mouse.cpp
index cb94e926c5..5bdf7449fc 100644
--- a/engines/cge/mouse.cpp
+++ b/engines/cge/mouse.cpp
@@ -31,7 +31,7 @@
 
 namespace CGE {
 
-EVENT Evt[EVT_MAX];
+Event Evt[EVT_MAX];
 
 uint16 EvtHead = 0, EvtTail = 0;
 
@@ -39,7 +39,7 @@ MOUSE_FUN *MOUSE::OldMouseFun  = NULL;
 uint16     MOUSE::OldMouseMask = 0;
 
 
-MOUSE::MOUSE(CGEEngine *vm, BITMAP **shpl) : Sprite(vm, shpl), Busy(NULL), Hold(NULL), hx(0), _vm(vm) {
+MOUSE::MOUSE(CGEEngine *vm, Bitmap **shpl) : Sprite(vm, shpl), Busy(NULL), Hold(NULL), hx(0), _vm(vm) {
 	static Seq ms[] = {
 		{ 0, 0, 0, 0, 1 },
 		{ 1, 1, 0, 0, 1 }
@@ -136,8 +136,8 @@ void MOUSE::ClrEvt(Sprite *spr) {
 	if (spr) {
 		uint16 e;
 		for (e = EvtTail; e != EvtHead; e = (e + 1) % EVT_MAX)
-			if (Evt[e].Ptr == spr)
-				Evt[e].Msk = 0;
+			if (Evt[e]._ptr == spr)
+				Evt[e]._msk = 0;
 	} else
 		EvtTail = EvtHead;
 }
@@ -146,49 +146,49 @@ void MOUSE::ClrEvt(Sprite *spr) {
 void MOUSE::Tick(void) {
 	Step();
 	while (EvtTail != EvtHead) {
-		EVENT e = Evt[EvtTail];
-		if (e.Msk) {
-			if (Hold && e.Ptr != Hold)
-				Hold->Touch(e.Msk | ATTN, e.X - Hold->X, e.Y - Hold->Y);
+		Event e = Evt[EvtTail];
+		if (e._msk) {
+			if (Hold && e._ptr != Hold)
+				Hold->Touch(e._msk | ATTN, e._x - Hold->_x, e._y - Hold->_y);
 
 			// update mouse cursor position
-			if (e.Msk & ROLL)
-				Goto(e.X, e.Y);
+			if (e._msk & ROLL)
+				Goto(e._x, e._y);
 
 			// activate current touched SPRITE
-			if (e.Ptr) {
-				if (e.Msk & KEYB)
-					e.Ptr->Touch(e.Msk, e.X, e.Y);
+			if (e._ptr) {
+				if (e._msk & KEYB)
+					e._ptr->Touch(e._msk, e._x, e._y);
 				else
-					e.Ptr->Touch(e.Msk, e.X - e.Ptr->X, e.Y - e.Ptr->Y);
+					e._ptr->Touch(e._msk, e._x - e._ptr->_x, e._y - e._ptr->_y);
 			} else if (Sys)
-					Sys->Touch(e.Msk, e.X, e.Y);
+					Sys->Touch(e._msk, e._x, e._y);
 
-			if (e.Msk & L_DN) {
-				Hold = e.Ptr;
+			if (e._msk & L_DN) {
+				Hold = e._ptr;
 				if (Hold) {
-					Hold->Flags.Hold = true;
-					hx = e.X - Hold->X;
-					hy = e.Y - Hold->Y;
+					Hold->_flags._hold = true;
+					hx = e._x - Hold->_x;
+					hy = e._y - Hold->_y;
 				}
 			}
 
-			if (e.Msk & L_UP) {
+			if (e._msk & L_UP) {
 				if (Hold) {
-					Hold->Flags.Hold = false;
+					Hold->_flags._hold = false;
 					Hold = NULL;
 				}
 			}
 			///Touched = e.Ptr;
 
 			// discard Text if button released
-			if (e.Msk & (L_UP | R_UP))
+			if (e._msk & (L_UP | R_UP))
 				KillText();
 		}
 		EvtTail = (EvtTail + 1) % EVT_MAX;
 	}
 	if (Hold)
-		Hold->Goto(X - hx, Y - hy);
+		Hold->Goto(_x - hx, _y - hy);
 }
 
 } // End of namespace CGE
diff --git a/engines/cge/mouse.h b/engines/cge/mouse.h
index 28152b7f29..4d95f10423 100644
--- a/engines/cge/mouse.h
+++ b/engines/cge/mouse.h
@@ -45,13 +45,14 @@ namespace CGE {
 
 extern TALK *Talk;
 
-struct EVENT {
-	uint16 Msk;
-	uint16 X, Y;
-	Sprite *Ptr;
+struct Event {
+	uint16 _msk;
+	uint16 _x;
+	uint16 _y;
+	Sprite *_ptr;
 };
 
-extern EVENT  Evt[EVT_MAX];
+extern Event Evt[EVT_MAX];
 extern uint16 EvtHead, EvtTail;
 typedef void (MOUSE_FUN)(void);
 
@@ -69,7 +70,7 @@ public:
 	int Buttons;
 	Sprite *Busy;
 	//Sprite *Touched;
-	MOUSE(CGEEngine *vm, BITMAP **shpl = MC);
+	MOUSE(CGEEngine *vm, Bitmap **shpl = MC);
 	~MOUSE();
 	void On();
 	void Off();
diff --git a/engines/cge/snail.cpp b/engines/cge/snail.cpp
index 50eed3f562..565c7d33f0 100644
--- a/engines/cge/snail.cpp
+++ b/engines/cge/snail.cpp
@@ -75,7 +75,7 @@ static void SNGame(Sprite *spr, int num) {
 		int buref = 0;
 		int Stage = 0;
 
-		for (dup[0] = Vga->ShowQ->First(); dup[0]; dup[0] = dup[0]->Next) {
+		for (dup[0] = Vga->ShowQ->First(); dup[0]; dup[0] = dup[0]->_next) {
 			buref = dup[0]->_ref;
 			if (buref / 1000 == 16 && buref % 100 == 6) {
 				Stage = (buref / 100) % 10;
@@ -88,8 +88,8 @@ static void SNGame(Sprite *spr, int num) {
 		}
 
 		if (Game) { // continue game
-			int i = new_random(3), hand = (dup[0]->ShpCnt == 6);
-			++ Stage;
+			int i = new_random(3), hand = (dup[0]->_shpCnt == 6);
+			Stage++;
 			if (hand && Stage > DRESSED)
 				++hand;
 			if (i >= 0 || (dup[i] == spr && new_random(3) == 0)) {
@@ -188,7 +188,7 @@ static void SNGame(Sprite *spr, int num) {
 			}
 			///--------------------
 			SNPOST(SNSETZ, 20700, 0, NULL);
-			bool hit = (k1->SeqPtr + k2->SeqPtr + k3->SeqPtr == 15);
+			bool hit = (k1->_seqPtr + k2->_seqPtr + k3->_seqPtr == 15);
 			if (hit) {
 				if (spr->_ref == 1) {
 					SNPOST(SNSAY,      1, 20003, NULL);       // hura!
@@ -295,7 +295,7 @@ int FindPocket(Sprite *spr) {
 
 
 void SelectPocket(int n) {
-	if (n < 0 || (_pocLight->SeqPtr && PocPtr == n)) {
+	if (n < 0 || (_pocLight->_seqPtr && PocPtr == n)) {
 		_pocLight->Step(0);
 		n = FindPocket(NULL);
 		if (n >= 0)
@@ -325,10 +325,10 @@ void Hide1(Sprite *spr) {
 }
 
 
-void SNGhost(BITMAP *bmp) {
+void SNGhost(Bitmap *bmp) {
 	// TODO : Get x and y from M but not using segment / offset
-	//bmp->Hide(FP_OFF(bmp->M), FP_SEG(bmp->M));
-	bmp->M = NULL;
+	//bmp->Hide(FP_OFF(bmp->_m), FP_SEG(bmp->_m));
+	bmp->_m = NULL;
 	delete bmp;
 	warning("STUB: SNGhost");
 }
@@ -509,10 +509,10 @@ static void SNZTrim(Sprite *spr) {
 			bool en = _heart->_enable;
 			Sprite *s;
 			_heart->_enable = false;
-			s = (spr->Flags.Shad) ? spr->Prev : NULL;
+			s = (spr->_flags._shad) ? spr->_prev : NULL;
 			Vga->ShowQ->Insert(Vga->ShowQ->Remove(spr));
 			if (s) {
-				s->Z = spr->Z;
+				s->_z = spr->_z;
 				Vga->ShowQ->Insert(Vga->ShowQ->Remove(s), spr);
 			}
 			_heart->_enable = en;
@@ -522,9 +522,9 @@ static void SNZTrim(Sprite *spr) {
 
 static void SNHide(Sprite *spr, int val) {
 	if (spr) {
-		spr->Flags.Hide = (val >= 0) ? (val != 0) : (! spr->Flags.Hide);
-		if (spr->Flags.Shad)
-			spr->Prev->Flags.Hide = spr->Flags.Hide;
+		spr->_flags._hide = (val >= 0) ? (val != 0) : (!spr->_flags._hide);
+		if (spr->_flags._shad)
+			spr->_prev->_flags._hide = spr->_flags._hide;
 	}
 }
 
@@ -553,7 +553,7 @@ void SNSeq(Sprite *spr, int val) {
 
 void SNRSeq(Sprite *spr, int val) {
 	if (spr)
-		SNSeq(spr, spr->SeqPtr + val);
+		SNSeq(spr, spr->_seqPtr + val);
 }
 
 
@@ -565,22 +565,22 @@ void SNSend(Sprite *spr, int val) {
 		spr->_cave = val;
 		if (val1 != was1) {
 			if (was1) {
-				if (spr->Flags.Kept) {
+				if (spr->_flags._kept) {
 					int n = FindPocket(spr);
 					if (n >= 0)
 						_pocket[n] = NULL;
 				}
 				Hide1(spr);
 				ContractSprite(spr);
-				spr->Flags.Slav = false;
+				spr->_flags._slav = false;
 			} else {
 				if (spr->_ref % 1000 == 0)
-					BITMAP::Pal = VGA::SysPal;
-				if (spr->Flags.Back)
+					Bitmap::Pal = VGA::SysPal;
+				if (spr->_flags._back)
 					spr->BackShow(true);
 				else
 					ExpandSprite(spr);
-				BITMAP::Pal = NULL;
+				Bitmap::Pal = NULL;
 			}
 		}
 	}
@@ -596,15 +596,15 @@ void SNSwap(Sprite *spr, int xref) {
 		bool xwas1 = (xwas == 0 || xwas == Now);
 
 		Swap(spr->_cave, xspr->_cave);
-		Swap(spr->X, xspr->X);
-		Swap(spr->Y, xspr->Y);
-		Swap(spr->Z, xspr->Z);
-		if (spr->Flags.Kept) {
+		Swap(spr->_x, xspr->_x);
+		Swap(spr->_y, xspr->_y);
+		Swap(spr->_z, xspr->_z);
+		if (spr->_flags._kept) {
 			int n = FindPocket(spr);
 			if (n >= 0)
 				_pocket[n] = xspr;
-			xspr->Flags.Kept = true;
-			xspr->Flags.Port = false;
+			xspr->_flags._kept = true;
+			xspr->_flags._port = false;
 		}
 		if (xwas1 != was1) {
 			if (was1) {
@@ -625,14 +625,14 @@ void SNSwap(Sprite *spr, int xref) {
 void SNCover(Sprite *spr, int xref) {
 	Sprite *xspr = Locate(xref);
 	if (spr && xspr) {
-		spr->Flags.Hide = true;
-		xspr->Z = spr->Z;
+		spr->_flags._hide = true;
+		xspr->_z = spr->_z;
 		xspr->_cave = spr->_cave;
-		xspr->Goto(spr->X, spr->Y);
+		xspr->Goto(spr->_x, spr->_y);
 		ExpandSprite(xspr);
-		if ((xspr->Flags.Shad = spr->Flags.Shad) == 1) {
-			Vga->ShowQ->Insert(Vga->ShowQ->Remove(spr->Prev), xspr);
-			spr->Flags.Shad = false;
+		if ((xspr->_flags._shad = spr->_flags._shad) == 1) {
+			Vga->ShowQ->Insert(Vga->ShowQ->Remove(spr->_prev), xspr);
+			spr->_flags._shad = false;
 		}
 		FeedSnail(xspr, NEAR);
 	}
@@ -641,28 +641,28 @@ void SNCover(Sprite *spr, int xref) {
 
 void SNUncover(Sprite *spr, Sprite *xspr) {
 	if (spr && xspr) {
-		spr->Flags.Hide = false;
+		spr->_flags._hide = false;
 		spr->_cave = xspr->_cave;
-		spr->Goto(xspr->X, xspr->Y);
-		if ((spr->Flags.Shad = xspr->Flags.Shad) == 1) {
-			Vga->ShowQ->Insert(Vga->ShowQ->Remove(xspr->Prev), spr);
-			xspr->Flags.Shad = false;
+		spr->Goto(xspr->_x, xspr->_y);
+		if ((spr->_flags._shad = xspr->_flags._shad) == 1) {
+			Vga->ShowQ->Insert(Vga->ShowQ->Remove(xspr->_prev), spr);
+			xspr->_flags._shad = false;
 		}
-		spr->Z = xspr->Z;
+		spr->_z = xspr->_z;
 		SNSend(xspr, -1);
-		if (spr->Time == 0)
-			++spr->Time;
+		if (spr->_time == 0)
+			++spr->_time;
 	}
 }
 
 
 void SNSetX0(int cav, int x0) {
-	HeroXY[cav - 1].X = x0;
+	HeroXY[cav - 1]._x = x0;
 }
 
 
 void SNSetY0(int cav, int y0) {
-	HeroXY[cav - 1].Y = y0;
+	HeroXY[cav - 1]._y = y0;
 }
 
 
@@ -674,19 +674,19 @@ void SNSetXY(Sprite *spr, uint16 xy) {
 
 void SNRelX(Sprite *spr, int x) {
 	if (spr && Hero)
-		spr->Goto(Hero->X + x, spr->Y);
+		spr->Goto(Hero->_x + x, spr->_y);
 }
 
 
 void SNRelY(Sprite *spr, int y) {
 	if (spr && Hero)
-		spr->Goto(spr->X, Hero->Y + y);
+		spr->Goto(spr->_x, Hero->_y + y);
 }
 
 
 void SNRelZ(Sprite *spr, int z) {
 	if (spr && Hero) {
-		spr->Z = Hero->Z + z;
+		spr->_z = Hero->_z + z;
 		SNZTrim(spr);
 	}
 }
@@ -694,19 +694,19 @@ void SNRelZ(Sprite *spr, int z) {
 
 void SNSetX(Sprite *spr, int x) {
 	if (spr)
-		spr->Goto(x, spr->Y);
+		spr->Goto(x, spr->_y);
 }
 
 
 void SNSetY(Sprite *spr, int y) {
 	if (spr)
-		spr->Goto(spr->X, y);
+		spr->Goto(spr->_x, y);
 }
 
 
 void SNSetZ(Sprite *spr, int z) {
 	if (spr) {
-		spr->Z = z;
+		spr->_z = z;
 		//SNPOST_(SNZTRIM, -1, 0, spr);
 		SNZTrim(spr);
 	}
@@ -718,9 +718,9 @@ void SNSlave(Sprite *spr, int ref) {
 	if (spr && slv) {
 		if (spr->Active()) {
 			SNSend(slv, spr->_cave);
-			slv->Flags.Slav = true;
-			slv->Z = spr->Z;
-			Vga->ShowQ->Insert(Vga->ShowQ->Remove(slv), spr->Next);
+			slv->_flags._slav = true;
+			slv->_z = spr->_z;
+			Vga->ShowQ->Insert(Vga->ShowQ->Remove(slv), spr->_next);
 		}
 	}
 }
@@ -728,36 +728,37 @@ void SNSlave(Sprite *spr, int ref) {
 
 void SNTrans(Sprite *spr, int trans) {
 	if (spr)
-		spr->Flags.Tran = (trans < 0) ? !spr->Flags.Tran : (trans != 0);
+		spr->_flags._tran = (trans < 0) ? !spr->_flags._tran : (trans != 0);
 }
 
 
 void SNPort(Sprite *spr, int port) {
 	if (spr)
-		spr->Flags.Port = (port < 0) ? !spr->Flags.Port : (port != 0);
+		spr->_flags._port = (port < 0) ? !spr->_flags._port : (port != 0);
 }
 
 
 void SNKill(Sprite *spr) {
 	if (spr) {
-		if (spr->Flags.Kept) {
+		if (spr->_flags._kept) {
 			int n = FindPocket(spr);
 			if (n >= 0)
 				_pocket[n] = NULL;
 		}
-		Sprite *nx = spr->Next;
+		Sprite *nx = spr->_next;
 		Hide1(spr);
 		Vga->ShowQ->Remove(spr);
 		MOUSE::ClrEvt(spr);
-		if (spr->Flags.Kill)
+		if (spr->_flags._kill)
 			delete spr;
 		else {
 			spr->_cave = -1;
 			Vga->SpareQ->Append(spr);
 		}
-		if (nx)
-			if (nx->Flags.Slav)
+		if (nx) {
+			if (nx->_flags._slav)
 				SNKill(nx);
+		}
 	}
 }
 
@@ -767,20 +768,20 @@ static void SNSound(Sprite *spr, int wav, int cnt) {
 		if (wav == -1)
 			Sound.Stop();
 		else
-			Sound.Play(Fx[wav], (spr) ? ((spr->X + spr->W / 2) / (SCR_WID / 16)) : 8, cnt);
+			Sound.Play(Fx[wav], (spr) ? ((spr->_x + spr->_w / 2) / (SCR_WID / 16)) : 8, cnt);
 	}
 }
 
 
 void SNKeep(Sprite *spr, int stp) {
 	SelectPocket(-1);
-	if (spr && ! spr->Flags.Kept && _pocket[PocPtr] == NULL) {
+	if (spr && ! spr->_flags._kept && _pocket[PocPtr] == NULL) {
 		SNSound(spr, 3, 1);
 		_pocket[PocPtr] = spr;
 		spr->_cave = 0;
-		spr->Flags.Kept = true;
-		spr->Goto(POCKET_X + POCKET_DX * PocPtr + POCKET_DX / 2 - spr->W / 2,
-		          POCKET_Y + POCKET_DY / 2 - spr->H / 2);
+		spr->_flags._kept = true;
+		spr->Goto(POCKET_X + POCKET_DX * PocPtr + POCKET_DX / 2 - spr->_w / 2,
+		          POCKET_Y + POCKET_DY / 2 - spr->_h / 2);
 		if (stp >= 0)
 			spr->Step(stp);
 	}
@@ -794,7 +795,7 @@ void SNGive(Sprite *spr, int stp) {
 		if (p >= 0) {
 			_pocket[p] = NULL;
 			spr->_cave = Now;
-			spr->Flags.Kept = false;
+			spr->_flags._kept = false;
 			if (stp >= 0)
 				spr->Step(stp);
 		}
@@ -828,7 +829,7 @@ static void SNLevel(Sprite *spr, int lev) {
 	}
 	MaxCave = maxcav[Lev];
 	if (spr)
-		spr->Flags.Hide = false;
+		spr->_flags._hide = false;
 }
 
 
@@ -937,7 +938,7 @@ void SNAIL::RunCom(void) {
 				if (sprel) {
 					if (sprel->SeqTest(snc->Val) &&
 					        (snc->Val >= 0 || sprel != Hero || Hero->TracePtr < 0)) {
-						_heart->setXTimer(&Pause, sprel->Time);
+						_heart->setXTimer(&Pause, sprel->_time);
 					} else
 						goto xit;
 				}
@@ -1111,13 +1112,13 @@ void SNAIL::RunCom(void) {
 				SNZTrim(sprel);
 				break;
 			case SNGHOST    :
-				SNGhost((BITMAP *) snc->Ptr);
+				SNGhost((Bitmap *) snc->Ptr);
 				break;
 			default :
 				warning("Unhandled snc->Com in SNMouse(bool)");
 				break;
 			}
-			++Tail;
+			Tail++;
 			if (!Turbo)
 				break;
 		}
diff --git a/engines/cge/snail.h b/engines/cge/snail.h
index 9449a8081e..e1df628d3b 100644
--- a/engines/cge/snail.h
+++ b/engines/cge/snail.h
@@ -117,8 +117,8 @@ extern  int MaxCave;
 extern  int PocPtr;
 extern  BAR Barriers[];
 extern  struct HXY {
-	int X;
-	int Y;
+	int _x;
+	int _y;
 } HeroXY[];
 
 } // End of namespace CGE
diff --git a/engines/cge/talk.cpp b/engines/cge/talk.cpp
index 43917732be..5aa5e44b8d 100644
--- a/engines/cge/talk.cpp
+++ b/engines/cge/talk.cpp
@@ -100,7 +100,7 @@ void FONT::Save(void) {
 TALK::TALK(CGEEngine *vm, const char *tx, TBOX_STYLE mode)
 	: Sprite(vm, NULL), Mode(mode), _vm(vm) {
 	TS[0] = TS[1] = NULL;
-	Flags.Syst = true;
+	_flags._syst = true;
 	Update(tx);
 }
 
@@ -108,7 +108,7 @@ TALK::TALK(CGEEngine *vm, const char *tx, TBOX_STYLE mode)
 TALK::TALK(CGEEngine *vm)
 	: Sprite(vm, NULL), Mode(PURE), _vm(vm) {
 	TS[0] = TS[1] = NULL;
-	Flags.Syst = true;
+	_flags._syst = true;
 }
 
 
@@ -158,11 +158,11 @@ void TALK::Update(const char *tx) {
 		TS[0] = Box(mw, mh);
 	}
 
-	m = TS[0]->M + ln * mw + hmarg;
+	m = TS[0]->_m + ln * mw + hmarg;
 
 	while (* tx) {
 		if (*tx == '|' || *tx == '\n')
-			m = TS[0]->M + (ln += FONT_HIG + TEXT_LS) * mw + hmarg;
+			m = TS[0]->_m + (ln += FONT_HIG + TEXT_LS) * mw + hmarg;
 		else {
 			int cw = _Font->Wid[*tx], i;
 			uint8 *f = _Font->Map + _Font->Pos[*tx];
@@ -176,10 +176,10 @@ void TALK::Update(const char *tx) {
 					b >>= 1;
 					pp += mw;
 				}
-				++m;
+				m++;
 			}
 		}
-		++tx;
+		tx++;
 	}
 	TS[0]->Code();
 	SetShapeList(TS);
@@ -188,7 +188,7 @@ void TALK::Update(const char *tx) {
 
 
 
-BITMAP *TALK::Box(uint16 w, uint16 h) {
+Bitmap *TALK::Box(uint16 w, uint16 h) {
 	uint8 *b, * p, * q;
 	uint16 n, r = (Mode == ROUND) ? TEXT_RD : 0;
 
@@ -228,14 +228,14 @@ BITMAP *TALK::Box(uint16 w, uint16 h) {
 			q -= w;
 		}
 	}
-	return new BITMAP(w, h, b);
+	return new Bitmap(w, h, b);
 }
 
 
 void TALK::PutLine(int line, const char *text) {
 // Note: (TS[0].W % 4) have to be 0
-	uint16 w = TS[0]->W, h = TS[0]->H;
-	uint8 *v = TS[0]->V, * p;
+	uint16 w = TS[0]->_w, h = TS[0]->_h;
+	uint8 *v = TS[0]->_v, * p;
 	uint16 dsiz = w >> 2;     // data size (1 plane line size)
 	uint16 lsiz = 2 + dsiz + 2;   // uint16 for line header, uint16 for gap
 	uint16 psiz = h * lsiz;       // - last gap, but + plane trailer
@@ -278,22 +278,22 @@ void TALK::PutLine(int line, const char *text) {
 				if (p >= q)
 					p = p - size + 1;
 			}
-			++text;
+			text++;
 		}
 	}
 }
 
 
 INFO_LINE::INFO_LINE(CGEEngine *vm, uint16 w) : TALK(vm), OldTxt(NULL), _vm(vm) {
-	TS[0] = new BITMAP(w, FONT_HIG, TEXT_BG);
+	TS[0] = new Bitmap(w, FONT_HIG, TEXT_BG);
 	SetShapeList(TS);
 }
 
 
 void INFO_LINE::Update(const char *tx) {
 	if (tx != OldTxt) {
-		uint16 w = TS[0]->W, h = TS[0]->H;
-		uint8 *v = (uint8 *) TS[0]->V;
+		uint16 w = TS[0]->_w, h = TS[0]->_h;
+		uint8 *v = (uint8 *) TS[0]->_v;
 		uint16 dsiz = w >> 2;                           // data size (1 plane line size)
 		uint16 lsiz = 2 + dsiz + 2;                     // uint16 for line header, uint16 for gap
 		uint16 psiz = h * lsiz;                         // - last gape, but + plane trailer
@@ -324,7 +324,7 @@ void INFO_LINE::Update(const char *tx) {
 					if (p >= q)
 						p = p - size + 1;
 				}
-				++tx;
+				tx++;
 			}
 		}
 		OldTxt = tx;
diff --git a/engines/cge/talk.h b/engines/cge/talk.h
index 2a38af91d1..60f7f213d4 100644
--- a/engines/cge/talk.h
+++ b/engines/cge/talk.h
@@ -71,8 +71,8 @@ enum    TBOX_STYLE  { PURE, RECT, ROUND };
 class TALK : public Sprite {
 protected:
 	TBOX_STYLE Mode;
-	BITMAP *TS[2];
-	BITMAP *Box(uint16 w, uint16 h);
+	Bitmap *TS[2];
+	Bitmap *Box(uint16 w, uint16 h);
 public:
 	TALK(CGEEngine *vm, const char *tx, TBOX_STYLE mode = PURE);
 	TALK(CGEEngine *vm);
diff --git a/engines/cge/text.cpp b/engines/cge/text.cpp
index 74ff6fac2d..7b191b492b 100644
--- a/engines/cge/text.cpp
+++ b/engines/cge/text.cpp
@@ -184,11 +184,11 @@ void TEXT::Say(const char *txt, Sprite *spr) {
 	KillText();
 	Talk = new TALK(_vm, txt, ROUND);
 	if (Talk) {
-		bool east = spr->Flags.East;
-		int x = (east) ? (spr->X + spr->W - 2) : (spr->X + 2);
-		int y = spr->Y + 2;
+		bool east = spr->_flags._east;
+		int x = (east) ? (spr->_x + spr->_w - 2) : (spr->_x + 2);
+		int y = spr->_y + 2;
 		Sprite *spike = new Sprite(_vm, SP);
-		uint16 sw = spike->W;
+		uint16 sw = spike->_w;
 
 		if (east) {
 			if (x + sw + TEXT_RD + 5 >= SCR_WID)
@@ -197,21 +197,21 @@ void TEXT::Say(const char *txt, Sprite *spr) {
 			if (x <= 5 + TEXT_RD + sw)
 				east = true;
 		}
-		x = (east) ? (spr->X + spr->W - 2) : (spr->X + 2 - sw);
+		x = (east) ? (spr->_x + spr->_w - 2) : (spr->_x + 2 - sw);
 		if (spr->_ref == 1)
 			x += ((east) ? -10 : 10); // Hero
 
-		Talk->Flags.Kill = true;
-		Talk->Flags.BDel = true;
+		Talk->_flags._kill = true;
+		Talk->_flags._bDel = true;
 		Talk->SetName(Text->getText(SAY_NAME));
-		Talk->Goto(x - (Talk->W - sw) / 2 - 3 + 6 * east, y - spike->H - Talk->H + 1);
-		Talk->Z = 125;
+		Talk->Goto(x - (Talk->_w - sw) / 2 - 3 + 6 * east, y - spike->_h - Talk->_h + 1);
+		Talk->_z = 125;
 		Talk->_ref = SAY_REF;
 
-		spike->Goto(x, Talk->Y + Talk->H - 1);
-		spike->Z = 126;
-		spike->Flags.Slav = true;
-		spike->Flags.Kill = true;
+		spike->Goto(x, Talk->_y + Talk->_h - 1);
+		spike->_z = 126;
+		spike->_flags._slav = true;
+		spike->_flags._kill = true;
 		spike->SetName(Text->getText(SAY_NAME));
 		spike->Step(east);
 		spike->_ref = SAY_REF;
@@ -225,12 +225,12 @@ void CGEEngine::Inf(const char *txt) {
 	KillText();
 	Talk = new TALK(this, txt, RECT);
 	if (Talk) {
-		Talk->Flags.Kill = true;
-		Talk->Flags.BDel = true;
+		Talk->_flags._kill = true;
+		Talk->_flags._bDel = true;
 		Talk->SetName(Text->getText(INF_NAME));
 		Talk->Center();
-		Talk->Goto(Talk->X, Talk->Y - 20);
-		Talk->Z = 126;
+		Talk->Goto(Talk->_x, Talk->_y - 20);
+		Talk->_z = 126;
 		Talk->_ref = INF_REF;
 		Vga->ShowQ->Insert(Talk, Vga->ShowQ->Last());
 	}
diff --git a/engines/cge/vga13h.cpp b/engines/cge/vga13h.cpp
index 56960389c8..673d6036d8 100644
--- a/engines/cge/vga13h.cpp
+++ b/engines/cge/vga13h.cpp
@@ -356,11 +356,11 @@ void Heart::setXTimer(uint16 *ptr, uint16 time) {
 
 
 Sprite::Sprite(CGEEngine *vm, BMP_PTR *shp)
-	: X(0), Y(0), Z(0), NearPtr(0), TakePtr(0),
-	  Next(NULL), Prev(NULL), SeqPtr(NO_SEQ), Time(0), //Delay(0),
+	: _x(0), _y(0), _z(0), NearPtr(0), TakePtr(0),
+	  _next(NULL), _prev(NULL), _seqPtr(NO_SEQ), _time(0), //Delay(0),
 	  _ext(NULL), _ref(-1), _cave(0), _vm(vm) {
 	memset(File, 0, sizeof(File));
-	*((uint16 *)&Flags) = 0;
+	*((uint16 *)&_flags) = 0;
 	SetShapeList(shp);
 }
 
@@ -374,8 +374,8 @@ BMP_PTR Sprite::Shp() {
 	register SprExt *e = _ext;
 	if (e)
 		if (e->_seq) {
-			int i = e->_seq[SeqPtr].Now;
-			if (i >= ShpCnt) {
+			int i = e->_seq[_seqPtr].Now;
+			if (i >= _shpCnt) {
 				//char s[256];
 				//sprintf(s, "Seq=%p ShpCnt=%d SeqPtr=%d Now=%d Next=%d",
 				//      Seq, ShpCnt, SeqPtr, Seq[SeqPtr].Now, Seq[SeqPtr].Next);
@@ -391,24 +391,24 @@ BMP_PTR Sprite::Shp() {
 BMP_PTR *Sprite::SetShapeList(BMP_PTR *shp) {
 	BMP_PTR *r = (_ext) ? _ext->_shpList : NULL;
 
-	ShpCnt = 0;
-	W = 0;
-	H = 0;
+	_shpCnt = 0;
+	_w = 0;
+	_h = 0;
 
 	if (shp) {
 		BMP_PTR *p;
 		for (p = shp; *p; p++) {
 			BMP_PTR b = (*p); // ->Code();
-			if (b->W > W)
-				W = b->W;
-			if (b->H > H)
-				H = b->H;
-			++ShpCnt;
+			if (b->_w > _w)
+				_w = b->_w;
+			if (b->_h > _h)
+				_h = b->_h;
+			_shpCnt++;
 		}
 		Expand();
 		_ext->_shpList = shp;
 		if (!_ext->_seq)
-			SetSeq((ShpCnt < 2) ? _seq1 : _seq2);
+			SetSeq((_shpCnt < 2) ? _seq1 : _seq2);
 	}
 	return r;
 }
@@ -441,19 +441,19 @@ Seq *Sprite::SetSeq(Seq *seq) {
 	Expand();
 	register Seq *s = _ext->_seq;
 	_ext->_seq = seq;
-	if (SeqPtr == NO_SEQ)
+	if (_seqPtr == NO_SEQ)
 		Step(0);
-	else if (Time == 0)
-		Step(SeqPtr);
+	else if (_time == 0)
+		Step(_seqPtr);
 	return s;
 }
 
 
 bool Sprite::SeqTest(int n) {
 	if (n >= 0)
-		return (SeqPtr == n);
+		return (_seqPtr == n);
 	if (_ext)
-		return (_ext->_seq[SeqPtr].Next == SeqPtr);
+		return (_ext->_seq[_seqPtr].Next == _seqPtr);
 	return true;
 }
 
@@ -491,7 +491,7 @@ Sprite *Sprite::Expand(void) {
 		if (*File) {
 			static const char *Comd[] = { "Name", "Phase", "Seq", "Near", "Take", NULL };
 			char line[LINE_MAX], fname[MAXPATH];
-			BMP_PTR *shplist = new BMP_PTR [ShpCnt + 1];
+			BMP_PTR *shplist = new BMP_PTR [_shpCnt + 1];
 			Seq *seq = NULL;
 			int shpcnt = 0,
 			    seqcnt = 0,
@@ -521,7 +521,7 @@ Sprite *Sprite::Expand(void) {
 						break;
 					}
 					case 1 : { // Phase
-						shplist[shpcnt++] = new BITMAP(strtok(NULL, " \t,;/"));
+						shplist[shpcnt++] = new Bitmap(strtok(NULL, " \t,;/"));
 						break;
 					}
 					case 2 : { // Seq
@@ -583,7 +583,7 @@ Sprite *Sprite::Expand(void) {
 					}
 				}
 			} else { // no sprite description: try to read immediately from .BMP
-				shplist[shpcnt++] = new BITMAP(File);
+				shplist[shpcnt++] = new Bitmap(File);
 			}
 			shplist[shpcnt] = NULL;
 			if (seq) {
@@ -593,7 +593,7 @@ Sprite *Sprite::Expand(void) {
 					error("Bad JUMP in SEQ [%s]", fname);
 				SetSeq(seq);
 			} else
-				SetSeq((ShpCnt == 1) ? _seq1 : _seq2);
+				SetSeq((_shpCnt == 1) ? _seq1 : _seq2);
 			//disable();  // disable interupt
 
 			SetShapeList(shplist);
@@ -618,7 +618,7 @@ Sprite *Sprite::Contract(void) {
 	if (e) {
 		if (e->_name)
 			delete[] e->_name;
-		if (Flags.BDel && e->_shpList) {
+		if (_flags._bDel && e->_shpList) {
 			int i;
 			for (i = 0; e->_shpList[i]; i++)
 			delete e->_shpList[i];
@@ -651,15 +651,15 @@ Sprite *Sprite::BackShow(bool fast) {
 
 void Sprite::Step(int nr) {
 	if (nr >= 0)
-		SeqPtr = nr;
+		_seqPtr = nr;
 	if (_ext) {
 		Seq *seq;
 		if (nr < 0)
-			SeqPtr = _ext->_seq[SeqPtr].Next;
-		seq = _ext->_seq + SeqPtr;
+			_seqPtr = _ext->_seq[_seqPtr].Next;
+		seq = _ext->_seq + _seqPtr;
 		if (seq->Dly >= 0) {
-			Goto(X + (seq->Dx), Y + (seq->Dy));
-			Time = seq->Dly;
+			Goto(_x + (seq->Dx), _y + (seq->Dy));
+			_time = seq->Dly;
 		}
 	}
 }
@@ -674,19 +674,19 @@ void Sprite::MakeXlat(uint8 *x) {
 	if (_ext) {
 		BMP_PTR *b;
 
-		if (Flags.Xlat)
+		if (_flags._xlat)
 			KillXlat();
 		for (b = _ext->_shpList; *b; b++)
-			(*b)->M = x;
-		Flags.Xlat = true;
+			(*b)->_m = x;
+		_flags._xlat = true;
 	}
 }
 
 
 void Sprite::KillXlat(void) {
-	if (Flags.Xlat && _ext) {
+	if (_flags._xlat && _ext) {
 		BMP_PTR *b;
-		uint8 *m = (*_ext->_shpList)->M;
+		uint8 *m = (*_ext->_shpList)->_m;
 
 		switch (MemType(m)) {
 		case NEAR_MEM :
@@ -700,38 +700,38 @@ void Sprite::KillXlat(void) {
 			break;
 		}
 		for (b = _ext->_shpList; *b; b++)
-			(*b)->M = NULL;
-		Flags.Xlat = false;
+			(*b)->_m = NULL;
+		_flags._xlat = false;
 	}
 }
 
 
 void Sprite::Goto(int x, int y) {
-	int xo = X, yo = Y;
-	if (W < SCR_WID) {
+	int xo = _x, yo = _y;
+	if (_x < SCR_WID) {
 		if (x < 0)
 			x = 0;
-		if (x + W > SCR_WID)
-			x = (SCR_WID - W);
-		X = x;
+		if (x + _w > SCR_WID)
+			x = (SCR_WID - _w);
+		_x = x;
 	}
-	if (H < SCR_HIG) {
+	if (_h < SCR_HIG) {
 		if (y < 0)
 			y = 0;
-		if (y + H > SCR_HIG)
-			y = (SCR_HIG - H);
-		Y = y;
+		if (y + _h > SCR_HIG)
+			y = (SCR_HIG - _h);
+		_y = y;
 	}
-	if (Next)
-		if (Next->Flags.Slav)
-			Next->Goto(Next->X - xo + X, Next->Y - yo + Y);
-	if (Flags.Shad)
-		Prev->Goto(Prev->X - xo + X, Prev->Y - yo + Y);
+	if (_next)
+		if (_next->_flags._slav)
+			_next->Goto(_next->_x - xo + _x, _next->_y - yo + _y);
+	if (_flags._shad)
+		_prev->Goto(_prev->_x - xo + _x, _prev->_y - yo + _y);
 }
 
 
 void Sprite::Center(void) {
-	Goto((SCR_WID - W) / 2, (SCR_HIG - H) / 2);
+	Goto((SCR_WID - _w) / 2, (SCR_HIG - _h) / 2);
 }
 
 
@@ -742,12 +742,12 @@ void Sprite::Show(void) {
 	e->_x0 = e->_x1;
 	e->_y0 = e->_y1;
 	e->_b0 = e->_b1;
-	e->_x1 = X;
-	e->_y1 = Y;
+	e->_x1 = _x;
+	e->_y1 = _y;
 	e->_b1 = Shp();
 //  asm sti     // ...done!
-	if (! Flags.Hide) {
-		if (Flags.Xlat)
+	if (!_flags._hide) {
+		if (_flags._xlat)
 			e->_b1->XShow(e->_x1, e->_y1);
 		else
 			e->_b1->Show(e->_x1, e->_y1);
@@ -758,7 +758,7 @@ void Sprite::Show(void) {
 void Sprite::Show(uint16 pg) {
 	Graphics::Surface *a = VGA::Page[1];
 	VGA::Page[1] = VGA::Page[pg & 3];
-	Shp()->Show(X, Y);
+	Shp()->Show(_x, _y);
 	VGA::Page[1] = a;
 }
 
@@ -773,16 +773,16 @@ void Sprite::Hide(void) {
 BMP_PTR Sprite::Ghost(void) {
 	register SprExt *e = _ext;
 	if (e->_b1) {
-		BMP_PTR bmp = new BITMAP(0, 0, (uint8 *)NULL);
+		BMP_PTR bmp = new Bitmap(0, 0, (uint8 *)NULL);
 		if (bmp == NULL)
 			error("No core");
-		bmp->W = e->_b1->W;
-		bmp->H = e->_b1->H;
-		if ((bmp->B = farnew(HideDesc, bmp->H)) == NULL)
+		bmp->_w = e->_b1->_w;
+		bmp->_h = e->_b1->_h;
+		if ((bmp->_b = farnew(HideDesc, bmp->_h)) == NULL)
 			error("No Core");
-		bmp->V = (uint8 *) memcpy(bmp->B, e->_b1->B, sizeof(HideDesc) * bmp->H);
+		bmp->_v = (uint8 *) memcpy(bmp->_b, e->_b1->_b, sizeof(HideDesc) * bmp->_h);
 		// TODO offset correctly in the surface using y1 pitch and x1 and not via offset segment
-		//bmp->M = (uint8 *) MK_FP(e->y1, e->x1);
+		//bmp->_m = (uint8 *) MK_FP(e->y1, e->x1);
 		warning("FIXME: SPRITE::Ghost");
 		return bmp;
 	}
@@ -793,10 +793,12 @@ BMP_PTR Sprite::Ghost(void) {
 Sprite *SpriteAt(int x, int y) {
 	Sprite *spr = NULL, * tail = Vga->ShowQ->Last();
 	if (tail) {
-		for (spr = tail->Prev; spr; spr = spr->Prev)
-			if (! spr->Flags.Hide && ! spr->Flags.Tran)
-				if (spr->Shp()->SolidAt(x - spr->X, y - spr->Y))
+		for (spr = tail->_prev; spr; spr = spr->_prev) {
+			if (! spr->_flags._hide && ! spr->_flags._tran) {
+				if (spr->Shp()->SolidAt(x - spr->_x, y - spr->_y))
 					break;
+			}
+		}
 	}
 	return spr;
 }
@@ -814,7 +816,7 @@ QUEUE::~QUEUE(void) {
 void QUEUE::Clear(void) {
 	while (Head) {
 		Sprite *s = Remove(Head);
-		if (s->Flags.Kill)
+		if (s->_flags._kill)
 			delete s;
 	}
 }
@@ -823,7 +825,7 @@ void QUEUE::Clear(void) {
 void QUEUE::ForAll(void (*fun)(Sprite *)) {
 	Sprite *s = Head;
 	while (s) {
-		Sprite *n = s->Next;
+		Sprite *n = s->_next;
 		fun(s);
 		s = n;
 	}
@@ -832,8 +834,8 @@ void QUEUE::ForAll(void (*fun)(Sprite *)) {
 
 void QUEUE::Append(Sprite *spr) {
 	if (Tail) {
-		spr->Prev = Tail;
-		Tail->Next = spr;
+		spr->_prev = Tail;
+		Tail->_next = spr;
 	} else
 		Head = spr;
 	Tail = spr;
@@ -846,18 +848,18 @@ void QUEUE::Append(Sprite *spr) {
 
 void QUEUE::Insert(Sprite *spr, Sprite *nxt) {
 	if (nxt == Head) {
-		spr->Next = Head;
+		spr->_next = Head;
 		Head = spr;
 		if (! Tail)
 			Tail = spr;
 	} else {
-		spr->Next = nxt;
-		spr->Prev = nxt->Prev;
-		if (spr->Prev)
-			spr->Prev->Next = spr;
+		spr->_next = nxt;
+		spr->_prev = nxt->_prev;
+		if (spr->_prev)
+			spr->_prev->_next = spr;
 	}
-	if (spr->Next)
-		spr->Next->Prev = spr;
+	if (spr->_next)
+		spr->_next->_prev = spr;
 	if (Show)
 		spr->Expand();
 	else
@@ -867,8 +869,8 @@ void QUEUE::Insert(Sprite *spr, Sprite *nxt) {
 
 void QUEUE::Insert(Sprite *spr) {
 	Sprite *s;
-	for (s = Head; s; s = s->Next)
-		if (s->Z > spr->Z)
+	for (s = Head; s; s = s->_next)
+		if (s->_z > spr->_z)
 			break;
 	if (s)
 		Insert(spr, s);
@@ -883,22 +885,22 @@ void QUEUE::Insert(Sprite *spr) {
 
 Sprite *QUEUE::Remove(Sprite *spr) {
 	if (spr == Head)
-		Head = spr->Next;
+		Head = spr->_next;
 	if (spr == Tail)
-		Tail = spr->Prev;
-	if (spr->Next)
-		spr->Next->Prev = spr->Prev;
-	if (spr->Prev)
-		spr->Prev->Next = spr->Next;
-	spr->Prev = NULL;
-	spr->Next = NULL;
+		Tail = spr->_prev;
+	if (spr->_next)
+		spr->_next->_prev = spr->_prev;
+	if (spr->_prev)
+		spr->_prev->_next = spr->_next;
+	spr->_prev = NULL;
+	spr->_next = NULL;
 	return spr;
 }
 
 
 Sprite *QUEUE::Locate(int ref) {
 	Sprite *spr;
-	for (spr = Head; spr; spr = spr->Next) {
+	for (spr = Head; spr; spr = spr->_next) {
 		if (spr->_ref == ref)
 			return spr;
 	}
@@ -1134,10 +1136,10 @@ void VGA::Sunset(void) {
 void VGA::Show(void) {
 	Sprite *spr = ShowQ->First();
 
-	for (spr = ShowQ->First(); spr; spr = spr->Next)
+	for (spr = ShowQ->First(); spr; spr = spr->_next)
 		spr->Show();
 	Update();
-	for (spr = ShowQ->First(); spr; spr = spr->Next)
+	for (spr = ShowQ->First(); spr; spr = spr->_next)
 		spr->Hide();
 
 	++ FrmCnt;
@@ -1176,7 +1178,7 @@ void VGA::CopyPage(uint16 d, uint16 s) {
 
 //--------------------------------------------------------------------------
 
-void BITMAP::XShow(int x, int y) {
+void Bitmap::XShow(int x, int y) {
 	/*
 	  uint8 rmsk = x % 4,
 	       mask = 1 << rmsk,
@@ -1258,8 +1260,8 @@ void BITMAP::XShow(int x, int y) {
 }
 
 
-void BITMAP::Show(int x, int y) {
-	const byte *srcP = (const byte *)V;
+void Bitmap::Show(int x, int y) {
+	const byte *srcP = (const byte *)_v;
 	byte *destEndP = (byte *)VGA::Page[1]->pixels + (SCR_WID * SCR_HIG);
 
 	// Loop through processing data for each plane. The game originally ran in plane mapped mode, where a
@@ -1320,7 +1322,7 @@ void BITMAP::Show(int x, int y) {
 }
 
 
-void BITMAP::Hide(int x, int y) {
+void Bitmap::Hide(int x, int y) {
 	/*
 	  uint8 *scr = VGA::Page[1] + y * (SCR_WID / 4) + x / 4;
 	  uint16 d = FP_OFF(VGA::Page[2]) - FP_OFF(VGA::Page[1]);
@@ -1383,7 +1385,7 @@ void BITMAP::Hide(int x, int y) {
 	    asm pop si
 	//  asm pop bx
 	*/
-	warning("STUB: BITMAP::Hide");
+	warning("STUB: Bitmap::Hide");
 }
 
 } // End of namespace CGE
diff --git a/engines/cge/vga13h.h b/engines/cge/vga13h.h
index 77594217ab..0c75dd6ba9 100644
--- a/engines/cge/vga13h.h
+++ b/engines/cge/vga13h.h
@@ -172,32 +172,35 @@ public:
 	int _ref;
 	signed char _cave;
 	struct FLAGS {
-		uint16 Hide : 1;       // general visibility switch
-		uint16 Near : 1;       // Near action lock
-		uint16 Drag : 1;       // sprite is moveable
-		uint16 Hold : 1;       // sprite is held with mouse
-		uint16 ____ : 1;       // intrrupt driven animation
-		uint16 Slav : 1;       // slave object
-		uint16 Syst : 1;       // system object
-		uint16 Kill : 1;       // dispose memory after remove
-		uint16 Xlat : 1;       // 2nd way display: xlat table
-		uint16 Port : 1;       // portable
-		uint16 Kept : 1;       // kept in pocket
-		uint16 East : 1;       // talk to east (in opposite to west)
-		uint16 Shad : 1;       // shadow
-		uint16 Back : 1;       // 'send to background' request
-		uint16 BDel : 1;       // delete bitmaps in ~SPRITE
-		uint16 Tran : 1;       // transparent (untouchable)
-	} Flags;
-	int X, Y;
-	signed char Z;
-	uint16 W, H;
-	uint16 Time;
+		uint16 _hide : 1;       // general visibility switch
+		uint16 _near : 1;       // Near action lock
+		uint16 _drag : 1;       // sprite is moveable
+		uint16 _hold : 1;       // sprite is held with mouse
+		uint16 _____ : 1;       // intrrupt driven animation
+		uint16 _slav : 1;       // slave object
+		uint16 _syst : 1;       // system object
+		uint16 _kill : 1;       // dispose memory after remove
+		uint16 _xlat : 1;       // 2nd way display: xlat table
+		uint16 _port : 1;       // portable
+		uint16 _kept : 1;       // kept in pocket
+		uint16 _east : 1;       // talk to east (in opposite to west)
+		uint16 _shad : 1;       // shadow
+		uint16 _back : 1;       // 'send to background' request
+		uint16 _bDel : 1;       // delete bitmaps in ~SPRITE
+		uint16 _tran : 1;       // transparent (untouchable)
+	} _flags;
+	int _x;
+	int _y;
+	signed char _z;
+	uint16 _w;
+	uint16 _h;
+	uint16 _time;
 	uint8 NearPtr, TakePtr;
-	int SeqPtr;
-	int ShpCnt;
+	int _seqPtr;
+	int _shpCnt;
 	char File[MAXFILE];
-	Sprite *Prev, * Next;
+	Sprite *_prev;
+	Sprite *_next;
 	bool Works(Sprite *spr);
 	bool SeqTest(int n);
 	inline bool Active(void) {
@@ -329,12 +332,6 @@ uint8 Closest(CBLK *pal, CBLK x) {
 #undef f
 }
 
-
-
-
-
-
-
 char   *NumStr(char *str, int num);
 //static void       Video       (void);
 uint16 *SaveScreen(void);
diff --git a/engines/cge/vmenu.cpp b/engines/cge/vmenu.cpp
index ed335191aa..ed07a1269f 100644
--- a/engines/cge/vmenu.cpp
+++ b/engines/cge/vmenu.cpp
@@ -60,12 +60,12 @@ MENU_BAR::MENU_BAR(CGEEngine *vm, uint16 w) : TALK(vm), _vm(vm) {
 		p1 += w;
 		p2 -= w;
 	}
-	TS[0] = new BITMAP(w, h, p);
+	TS[0] = new Bitmap(w, h, p);
 	SetShapeList(TS);
-	Flags.Slav = true;
-	Flags.Tran = true;
-	Flags.Kill = true;
-	Flags.BDel = true;
+	_flags._slav = true;
+	_flags._tran = true;
+	_flags._kill = true;
+	_flags._bDel = true;
 }
 
 
@@ -78,7 +78,7 @@ char *VMGather(CHOICE *list) {
 
 	for (cp = list; cp->Text; cp++) {
 		len += strlen(cp->Text);
-		++h;
+		h++;
 	}
 	vmgt = new char[len + h];
 	if (vmgt) {
@@ -87,7 +87,7 @@ char *VMGather(CHOICE *list) {
 			if (*vmgt)
 				strcat(vmgt, "|");
 			strcat(vmgt, cp->Text);
-			++ h;
+			h++;
 		}
 	}
 	return vmgt;
@@ -106,16 +106,16 @@ VMENU::VMENU(CGEEngine *vm, CHOICE *list, int x, int y)
 	delete[] vmgt;
 	Items = 0;
 	for (cp = list; cp->Text; cp++)
-		++Items;
-	Flags.BDel = true;
-	Flags.Kill = true;
+		Items++;
+	_flags._bDel = true;
+	_flags._kill = true;
 	if (x < 0 || y < 0)
 		Center();
 	else
-		Goto(x - W / 2, y - (TEXT_VM + FONT_HIG / 2));
+		Goto(x - _w / 2, y - (TEXT_VM + FONT_HIG / 2));
 	Vga->ShowQ->Insert(this, Vga->ShowQ->Last());
-	Bar = new MENU_BAR(_vm, W - 2 * TEXT_HM);
-	Bar->Goto(X + TEXT_HM - MB_HM, Y + TEXT_VM - MB_VM);
+	Bar = new MENU_BAR(_vm, _w - 2 * TEXT_HM);
+	Bar->Goto(_x + TEXT_HM - MB_HM, _y + TEXT_VM - MB_VM);
 	Vga->ShowQ->Insert(Bar, Vga->ShowQ->Last());
 }
 
@@ -137,12 +137,12 @@ void VMENU::Touch(uint16 mask, int x, int y) {
 		if (y >= 0) {
 			n = y / h;
 			if (n < Items)
-				ok = (x >= TEXT_HM && x < W - TEXT_HM/* && y % h < FONT_HIG*/);
+				ok = (x >= TEXT_HM && x < _w - TEXT_HM/* && y % h < FONT_HIG*/);
 			else
 				n = Items - 1;
 		}
 
-		Bar->Goto(X + TEXT_HM - MB_HM, Y + TEXT_VM + n * h - MB_VM);
+		Bar->Goto(_x + TEXT_HM - MB_HM, _y + TEXT_VM + n * h - MB_VM);
 
 		if (ok && (mask & L_UP)) {
 			Items = 0;