WINTERMUTE: Get rid of the C-prefix for class-definitions.

6 files changed, 111 insertions, 111 deletions

diff --git a/engines/wintermute/base/particles/part_emitter.cpp b/engines/wintermute/base/particles/part_emitter.cpp
index b3b05b6e65..212f11d2f6 100644
--- a/engines/wintermute/base/particles/part_emitter.cpp
+++ b/engines/wintermute/base/particles/part_emitter.cpp
@@ -43,13 +43,13 @@
 

 namespace WinterMute {

 

-IMPLEMENT_PERSISTENT(CPartEmitter, false)

+IMPLEMENT_PERSISTENT(PartEmitter, false)

 

 //////////////////////////////////////////////////////////////////////////

-CPartEmitter::CPartEmitter(CBGame *inGame, CBScriptHolder *Owner) : CBObject(inGame) {

+PartEmitter::PartEmitter(BaseGame *inGame, BaseScriptHolder *Owner) : BaseObject(inGame) {

 	_width = _height = 0;

 

-	CBPlatform::setRectEmpty(&_border);

+	BasePlatform::setRectEmpty(&_border);

 	_borderThicknessLeft = _borderThicknessRight = _borderThicknessTop = _borderThicknessBottom = 0;

 

 	_angle1 = _angle2 = 0;

@@ -94,7 +94,7 @@ CPartEmitter::CPartEmitter(CBGame *inGame, CBScriptHolder *Owner) : CBObject(inG
 

 

 //////////////////////////////////////////////////////////////////////////

-CPartEmitter::~CPartEmitter(void) {

+PartEmitter::~PartEmitter(void) {

 	for (int i = 0; i < _particles.getSize(); i++) {

 		delete _particles[i];

 	}

@@ -116,7 +116,7 @@ CPartEmitter::~CPartEmitter(void) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::addSprite(const char *filename) {

+bool PartEmitter::addSprite(const char *filename) {

 	if (!filename) return STATUS_FAILED;

 

 	// do we already have the file?

@@ -139,7 +139,7 @@ bool CPartEmitter::addSprite(const char *filename) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::removeSprite(const char *filename) {

+bool PartEmitter::removeSprite(const char *filename) {

 	for (int i = 0; i < _sprites.getSize(); i++) {

 		if (scumm_stricmp(filename, _sprites[i]) == 0) {

 			delete [] _sprites[i];

@@ -151,34 +151,34 @@ bool CPartEmitter::removeSprite(const char *filename) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::initParticle(CPartParticle *particle, uint32 currentTime, uint32 timerDelta) {

+bool PartEmitter::initParticle(PartParticle *particle, uint32 currentTime, uint32 timerDelta) {

 	if (!particle) return STATUS_FAILED;

 	if (_sprites.getSize() == 0) return STATUS_FAILED;

 

-	int posX = CBUtils::randomInt(_posX, _posX + _width);

-	int posY = CBUtils::randomInt(_posY, _posY + _height);

-	float posZ = CBUtils::randomFloat(0.0f, 100.0f);

+	int posX = BaseUtils::randomInt(_posX, _posX + _width);

+	int posY = BaseUtils::randomInt(_posY, _posY + _height);

+	float posZ = BaseUtils::randomFloat(0.0f, 100.0f);

 

 	float velocity;

 	if (_velocityZBased) velocity = _velocity1 + posZ * (_velocity2 - _velocity1) / 100;

-	else velocity = CBUtils::randomFloat(_velocity1, _velocity2);

+	else velocity = BaseUtils::randomFloat(_velocity1, _velocity2);

 

 	float scale;

 	if (_scaleZBased) scale = _scale1 + posZ * (_scale2 - _scale1) / 100;

-	else scale = CBUtils::randomFloat(_scale1, _scale2);

+	else scale = BaseUtils::randomFloat(_scale1, _scale2);

 

 	int lifeTime;

 	if (_lifeTimeZBased) lifeTime = _lifeTime2 - posZ * (_lifeTime2 - _lifeTime1) / 100;

-	else lifeTime = CBUtils::randomInt(_lifeTime1, _lifeTime2);

+	else lifeTime = BaseUtils::randomInt(_lifeTime1, _lifeTime2);

 

-	float angle = CBUtils::randomAngle(_angle1, _angle2);

-	int spriteIndex = CBUtils::randomInt(0, _sprites.getSize() - 1);

+	float angle = BaseUtils::randomAngle(_angle1, _angle2);

+	int spriteIndex = BaseUtils::randomInt(0, _sprites.getSize() - 1);

 

-	float rotation = CBUtils::randomAngle(_rotation1, _rotation2);

-	float angVelocity = CBUtils::randomFloat(_angVelocity1, _angVelocity2);

-	float growthRate = CBUtils::randomFloat(_growthRate1, _growthRate2);

+	float rotation = BaseUtils::randomAngle(_rotation1, _rotation2);

+	float angVelocity = BaseUtils::randomFloat(_angVelocity1, _angVelocity2);

+	float growthRate = BaseUtils::randomFloat(_growthRate1, _growthRate2);

 

-	if (!CBPlatform::isRectEmpty(&_border)) {

+	if (!BasePlatform::isRectEmpty(&_border)) {

 		int thicknessLeft   = (int)(_borderThicknessLeft   - (float)_borderThicknessLeft   * posZ / 100.0f);

 		int thicknessRight  = (int)(_borderThicknessRight  - (float)_borderThicknessRight  * posZ / 100.0f);

 		int thicknessTop    = (int)(_borderThicknessTop    - (float)_borderThicknessTop    * posZ / 100.0f);

@@ -195,14 +195,14 @@ bool CPartEmitter::initParticle(CPartParticle *particle, uint32 currentTime, uin
 	Vector2 vecVel(0, velocity);

 

 	Matrix4 matRot;

-	matRot.rotationZ(Common::deg2rad(CBUtils::normalizeAngle(angle - 180)));

+	matRot.rotationZ(Common::deg2rad(BaseUtils::normalizeAngle(angle - 180)));

 	matRot.transformVector2(vecVel);

 

 	if (_alphaTimeBased) {

 		particle->_alpha1 = _alpha1;

 		particle->_alpha2 = _alpha2;

 	} else {

-		int alpha = CBUtils::randomInt(_alpha1, _alpha2);

+		int alpha = BaseUtils::randomInt(_alpha1, _alpha2);

 		particle->_alpha1 = alpha;

 		particle->_alpha2 = alpha;

 	}

@@ -226,13 +226,13 @@ bool CPartEmitter::initParticle(CPartParticle *particle, uint32 currentTime, uin
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::update() {

+bool PartEmitter::update() {

 	if (!_running) return STATUS_OK;

 	else return updateInternal(_gameRef->_timer, _gameRef->_timerDelta);

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::updateInternal(uint32 currentTime, uint32 timerDelta) {

+bool PartEmitter::updateInternal(uint32 currentTime, uint32 timerDelta) {

 	int numLive = 0;

 

 	for (int i = 0; i < _particles.getSize(); i++) {

@@ -263,10 +263,10 @@ bool CPartEmitter::updateInternal(uint32 currentTime, uint32 timerDelta) {
 					}

 				}

 

-				CPartParticle *particle;

+				PartParticle *particle;

 				if (firstDeadIndex >= 0) particle = _particles[firstDeadIndex];

 				else {

-					particle = new CPartParticle(_gameRef);

+					particle = new PartParticle(_gameRef);

 					_particles.add(particle);

 				}

 				initParticle(particle, currentTime, timerDelta);

@@ -288,7 +288,7 @@ bool CPartEmitter::updateInternal(uint32 currentTime, uint32 timerDelta) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::display(CBRegion *region) {

+bool PartEmitter::display(BaseRegion *region) {

 	if (_sprites.getSize() <= 1) _gameRef->_renderer->startSpriteBatch();

 

 	for (int i = 0; i < _particles.getSize(); i++) {

@@ -305,7 +305,7 @@ bool CPartEmitter::display(CBRegion *region) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::start() {

+bool PartEmitter::start() {

 	for (int i = 0; i < _particles.getSize(); i++) {

 		_particles[i]->_isDead = true;

 	}

@@ -329,16 +329,16 @@ bool CPartEmitter::start() {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::sortParticlesByZ() {

+bool PartEmitter::sortParticlesByZ() {

 	// sort particles by _posY

-	qsort(_particles.getData(), _particles.getSize(), sizeof(CPartParticle *), CPartEmitter::compareZ);

+	qsort(_particles.getData(), _particles.getSize(), sizeof(PartParticle *), PartEmitter::compareZ);

 	return STATUS_OK;

 }

 

 //////////////////////////////////////////////////////////////////////////

-int CPartEmitter::compareZ(const void *obj1, const void *obj2) {

-	CPartParticle *p1 = *(CPartParticle **)obj1;

-	CPartParticle *p2 = *(CPartParticle **)obj2;

+int PartEmitter::compareZ(const void *obj1, const void *obj2) {

+	PartParticle *p1 = *(PartParticle **)obj1;

+	PartParticle *p2 = *(PartParticle **)obj2;

 

 	if (p1->_posZ < p2->_posZ) return -1;

 	else if (p1->_posZ > p2->_posZ) return 1;

@@ -346,14 +346,14 @@ int CPartEmitter::compareZ(const void *obj1, const void *obj2) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::setBorder(int x, int y, int width, int height) {

-	CBPlatform::setRect(&_border, x, y, x + width, y + height);

+bool PartEmitter::setBorder(int x, int y, int width, int height) {

+	BasePlatform::setRect(&_border, x, y, x + width, y + height);

 

 	return STATUS_OK;

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::setBorderThickness(int thicknessLeft, int thicknessRight, int thicknessTop, int thicknessBottom) {

+bool PartEmitter::setBorderThickness(int thicknessLeft, int thicknessRight, int thicknessTop, int thicknessBottom) {

 	_borderThicknessLeft = thicknessLeft;

 	_borderThicknessRight = thicknessRight;

 	_borderThicknessTop = thicknessTop;

@@ -363,8 +363,8 @@ bool CPartEmitter::setBorderThickness(int thicknessLeft, int thicknessRight, int
 }

 

 //////////////////////////////////////////////////////////////////////////

-CPartForce *CPartEmitter::addForceByName(const char *name) {

-	CPartForce *force = NULL;

+PartForce *PartEmitter::addForceByName(const char *name) {

+	PartForce *force = NULL;

 

 	for (int i = 0; i < _forces.getSize(); i++) {

 		if (scumm_stricmp(name, _forces[i]->_name) == 0) {

@@ -373,7 +373,7 @@ CPartForce *CPartEmitter::addForceByName(const char *name) {
 		}

 	}

 	if (!force) {

-		force = new CPartForce(_gameRef);

+		force = new PartForce(_gameRef);

 		if (force) {

 			force->setName(name);

 			_forces.add(force);

@@ -384,8 +384,8 @@ CPartForce *CPartEmitter::addForceByName(const char *name) {
 

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::addForce(const char *name, CPartForce::TForceType type, int posX, int posY, float angle, float strength) {

-	CPartForce *force = addForceByName(name);

+bool PartEmitter::addForce(const char *name, PartForce::TForceType type, int posX, int posY, float angle, float strength) {

+	PartForce *force = addForceByName(name);

 	if (!force) return STATUS_FAILED;

 

 	force->_type = type;

@@ -393,14 +393,14 @@ bool CPartEmitter::addForce(const char *name, CPartForce::TForceType type, int p
 

 	force->_direction = Vector2(0, strength);

 	Matrix4 matRot;

-	matRot.rotationZ(Common::deg2rad(CBUtils::normalizeAngle(angle - 180)));

+	matRot.rotationZ(Common::deg2rad(BaseUtils::normalizeAngle(angle - 180)));

 	matRot.transformVector2(force->_direction);

 

 	return STATUS_OK;

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::removeForce(const char *name) {

+bool PartEmitter::removeForce(const char *name) {

 	for (int i = 0; i < _forces.getSize(); i++) {

 		if (scumm_stricmp(name, _forces[i]->_name) == 0) {

 			delete _forces[i];

@@ -415,7 +415,7 @@ bool CPartEmitter::removeForce(const char *name) {
 //////////////////////////////////////////////////////////////////////////

 // high level scripting interface

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {

+bool PartEmitter::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {

 	//////////////////////////////////////////////////////////////////////////

 	// SetBorder

 	//////////////////////////////////////////////////////////////////////////

@@ -524,7 +524,7 @@ bool CPartEmitter::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		float angle = stack->pop()->getFloat();

 		float strength = stack->pop()->getFloat();

 

-		stack->pushBool(DID_SUCCEED(addForce(forceName, CPartForce::FORCE_GLOBAL, 0, 0, angle, strength)));

+		stack->pushBool(DID_SUCCEED(addForce(forceName, PartForce::FORCE_GLOBAL, 0, 0, angle, strength)));

 

 		return STATUS_OK;

 	}

@@ -540,7 +540,7 @@ bool CPartEmitter::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		float angle = stack->pop()->getFloat();

 		float strength = stack->pop()->getFloat();

 

-		stack->pushBool(DID_SUCCEED(addForce(forceName, CPartForce::FORCE_GLOBAL, posX, posY, angle, strength)));

+		stack->pushBool(DID_SUCCEED(addForce(forceName, PartForce::FORCE_GLOBAL, posX, posY, angle, strength)));

 

 		return STATUS_OK;

 	}

@@ -557,11 +557,11 @@ bool CPartEmitter::scCallMethod(CScScript *script, CScStack *stack, CScStack *th
 		return STATUS_OK;

 	}

 

-	else return CBObject::scCallMethod(script, stack, thisStack, name);

+	else return BaseObject::scCallMethod(script, stack, thisStack, name);

 }

 

 //////////////////////////////////////////////////////////////////////////

-CScValue *CPartEmitter::scGetProperty(const char *name) {

+ScValue *PartEmitter::scGetProperty(const char *name) {

 	_scValue->setNULL();

 

 	//////////////////////////////////////////////////////////////////////////

@@ -828,12 +828,12 @@ CScValue *CPartEmitter::scGetProperty(const char *name) {
 		return _scValue;

 	}

 

-	else return CBObject::scGetProperty(name);

+	else return BaseObject::scGetProperty(name);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::scSetProperty(const char *name, CScValue *value) {

+bool PartEmitter::scSetProperty(const char *name, ScValue *value) {

 	//////////////////////////////////////////////////////////////////////////

 	// X

 	//////////////////////////////////////////////////////////////////////////

@@ -1081,16 +1081,16 @@ bool CPartEmitter::scSetProperty(const char *name, CScValue *value) {
 	else if (strcmp(name, "EmitEvent") == 0) {

 		delete[] _emitEvent;

 		_emitEvent = NULL;

-		if (!value->isNULL()) CBUtils::setString(&_emitEvent, value->getString());

+		if (!value->isNULL()) BaseUtils::setString(&_emitEvent, value->getString());

 		return STATUS_OK;

 	}

 

-	else return CBObject::scSetProperty(name, value);

+	else return BaseObject::scSetProperty(name, value);

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-const char *CPartEmitter::scToString() {

+const char *PartEmitter::scToString() {

 	return "[particle emitter]";

 }

 

@@ -1098,8 +1098,8 @@ const char *CPartEmitter::scToString() {
 

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartEmitter::persist(CBPersistMgr *persistMgr) {

-	CBObject::persist(persistMgr);

+bool PartEmitter::persist(BasePersistenceManager *persistMgr) {

+	BaseObject::persist(persistMgr);

 

 	persistMgr->transfer(TMEMBER(_width));

 	persistMgr->transfer(TMEMBER(_height));

@@ -1171,7 +1171,7 @@ bool CPartEmitter::persist(CBPersistMgr *persistMgr) {
 	} else {

 		persistMgr->transfer(TMEMBER(numForces));

 		for (int i = 0; i < numForces; i++) {

-			CPartForce *force = new CPartForce(_gameRef);

+			PartForce *force = new PartForce(_gameRef);

 			force->persist(persistMgr);

 			_forces.add(force);

 		}

@@ -1187,7 +1187,7 @@ bool CPartEmitter::persist(CBPersistMgr *persistMgr) {
 	} else {

 		persistMgr->transfer(TMEMBER(numParticles));

 		for (int i = 0; i < numParticles; i++) {

-			CPartParticle *particle = new CPartParticle(_gameRef);

+			PartParticle *particle = new PartParticle(_gameRef);

 			particle->persist(persistMgr);

 			_particles.add(particle);

 		}

diff --git a/engines/wintermute/base/particles/part_emitter.h b/engines/wintermute/base/particles/part_emitter.h
index cff0a1ec83..6575544db0 100644
--- a/engines/wintermute/base/particles/part_emitter.h
+++ b/engines/wintermute/base/particles/part_emitter.h
@@ -34,14 +34,14 @@
 #include "engines/wintermute/base/particles/part_force.h"

 

 namespace WinterMute {

-class CBRegion;

-class CPartParticle;

-class CPartEmitter : public CBObject {

+class BaseRegion;

+class PartParticle;

+class PartEmitter : public BaseObject {

 public:

-	DECLARE_PERSISTENT(CPartEmitter, CBObject)

+	DECLARE_PERSISTENT(PartEmitter, BaseObject)

 

-	CPartEmitter(CBGame *inGame, CBScriptHolder *Owner);

-	virtual ~CPartEmitter(void);

+	PartEmitter(BaseGame *inGame, BaseScriptHolder *Owner);

+	virtual ~PartEmitter(void);

 

 	int _width;

 	int _height;

@@ -98,13 +98,13 @@ public:
 	bool _useRegion;

 

 	char *_emitEvent;

-	CBScriptHolder *_owner;

+	BaseScriptHolder *_owner;

 

 	bool start();

 

 	bool update();

 	bool display() { return display(NULL); } // To avoid shadowing the inherited display-function.

-	bool display(CBRegion *region);

+	bool display(BaseRegion *region);

 

 	bool sortParticlesByZ();

 	bool addSprite(const char *filename);

@@ -112,26 +112,26 @@ public:
 	bool setBorder(int x, int y, int width, int height);

 	bool setBorderThickness(int thicknessLeft, int thicknessRight, int thicknessTop, int thicknessBottom);

 

-	bool addForce(const char *name, CPartForce::TForceType type, int posX, int posY, float angle, float strength);

+	bool addForce(const char *name, PartForce::TForceType type, int posX, int posY, float angle, float strength);

 	bool removeForce(const char *name);

 

-	CBArray<CPartForce *, CPartForce *> _forces;

+	BaseArray<PartForce *, PartForce *> _forces;

 

 	// scripting interface

-	virtual CScValue *scGetProperty(const char *name);

-	virtual bool scSetProperty(const char *name, CScValue *value);

-	virtual bool scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name);

+	virtual ScValue *scGetProperty(const char *name);

+	virtual bool scSetProperty(const char *name, ScValue *value);

+	virtual bool scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name);

 	virtual const char *scToString();

 

 

 private:

-	CPartForce *addForceByName(const char *name);

+	PartForce *addForceByName(const char *name);

 	int static compareZ(const void *obj1, const void *obj2);

-	bool initParticle(CPartParticle *particle, uint32 currentTime, uint32 timerDelta);

+	bool initParticle(PartParticle *particle, uint32 currentTime, uint32 timerDelta);

 	bool updateInternal(uint32 currentTime, uint32 timerDelta);

 	uint32 _lastGenTime;

-	CBArray<CPartParticle *, CPartParticle *> _particles;

-	CBArray<char *, char *> _sprites;

+	BaseArray<PartParticle *, PartParticle *> _particles;

+	BaseArray<char *, char *> _sprites;

 };

 

 } // end of namespace WinterMute

diff --git a/engines/wintermute/base/particles/part_force.cpp b/engines/wintermute/base/particles/part_force.cpp
index 2f330c21b0..ba60e8b41c 100644
--- a/engines/wintermute/base/particles/part_force.cpp
+++ b/engines/wintermute/base/particles/part_force.cpp
@@ -34,7 +34,7 @@
 namespace WinterMute {

 

 //////////////////////////////////////////////////////////////////////////

-CPartForce::CPartForce(CBGame *inGame) : CBNamedObject(inGame) {

+PartForce::PartForce(BaseGame *inGame) : BaseNamedObject(inGame) {

 	_pos = Vector2(0.0f, 0.0f);

 	_direction = Vector2(0.0f, 0.0f);

 	_type = FORCE_POINT;

@@ -42,12 +42,12 @@ CPartForce::CPartForce(CBGame *inGame) : CBNamedObject(inGame) {
 

 

 //////////////////////////////////////////////////////////////////////////

-CPartForce::~CPartForce(void) {

+PartForce::~PartForce(void) {

 }

 

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartForce::persist(CBPersistMgr *persistMgr) {

+bool PartForce::persist(BasePersistenceManager *persistMgr) {

 	persistMgr->transfer(TMEMBER(_name));

 	persistMgr->transfer(TMEMBER(_pos));

 	persistMgr->transfer(TMEMBER(_direction));

diff --git a/engines/wintermute/base/particles/part_force.h b/engines/wintermute/base/particles/part_force.h
index f0a6d66c43..ec79ab7238 100644
--- a/engines/wintermute/base/particles/part_force.h
+++ b/engines/wintermute/base/particles/part_force.h
@@ -36,20 +36,20 @@
 

 namespace WinterMute {

 

-class CPartForce : public CBNamedObject {

+class PartForce : public BaseNamedObject {

 public:

 	enum TForceType {

 	    FORCE_POINT, FORCE_GLOBAL

 	};

 

-	CPartForce(CBGame *inGame);

-	virtual ~CPartForce(void);

+	PartForce(BaseGame *inGame);

+	virtual ~PartForce(void);

 

 	Vector2 _pos;

 	Vector2 _direction;

 	TForceType _type;

 

-	bool persist(CBPersistMgr *PersistMgr);

+	bool persist(BasePersistenceManager *PersistMgr);

 };

 

 } // end of namespace WinterMute

diff --git a/engines/wintermute/base/particles/part_particle.cpp b/engines/wintermute/base/particles/part_particle.cpp
index 931f7558c7..93b9f3659d 100644
--- a/engines/wintermute/base/particles/part_particle.cpp
+++ b/engines/wintermute/base/particles/part_particle.cpp
@@ -39,7 +39,7 @@
 namespace WinterMute {

 

 //////////////////////////////////////////////////////////////////////////

-CPartParticle::CPartParticle(CBGame *inGame) : CBBase(inGame) {

+PartParticle::PartParticle(BaseGame *inGame) : BaseClass(inGame) {

 	_pos = Vector2(0.0f, 0.0f);

 	_posZ = 0.0f;

 	_velocity = Vector2(0.0f, 0.0f);

@@ -48,7 +48,7 @@ CPartParticle::CPartParticle(CBGame *inGame) : CBBase(inGame) {
 	_creationTime = 0;

 	_lifeTime = 0;

 	_isDead = true;

-	CBPlatform::setRectEmpty(&_border);

+	BasePlatform::setRectEmpty(&_border);

 

 	_state = PARTICLE_NORMAL;

 	_fadeStart = 0;

@@ -66,13 +66,13 @@ CPartParticle::CPartParticle(CBGame *inGame) : CBBase(inGame) {
 

 

 //////////////////////////////////////////////////////////////////////////

-CPartParticle::~CPartParticle(void) {

+PartParticle::~PartParticle(void) {

 	delete _sprite;

 	_sprite = NULL;

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartParticle::setSprite(const char *filename) {

+bool PartParticle::setSprite(const char *filename) {

 	if (_sprite && _sprite->_filename && scumm_stricmp(filename, _sprite->_filename) == 0) {

 		_sprite->reset();

 		return STATUS_OK;

@@ -81,22 +81,22 @@ bool CPartParticle::setSprite(const char *filename) {
 	delete _sprite;

 	_sprite = NULL;

 

-	CSysClassRegistry::getInstance()->_disabled = true;

-	_sprite = new CBSprite(_gameRef, _gameRef);

+	SystemClassRegistry::getInstance()->_disabled = true;

+	_sprite = new BaseSprite(_gameRef, _gameRef);

 	if (_sprite && DID_SUCCEED(_sprite->loadFile(filename))) {

-		CSysClassRegistry::getInstance()->_disabled = false;

+		SystemClassRegistry::getInstance()->_disabled = false;

 		return STATUS_OK;

 	} else {

 		delete _sprite;

 		_sprite = NULL;

-		CSysClassRegistry::getInstance()->_disabled = false;

+		SystemClassRegistry::getInstance()->_disabled = false;

 		return STATUS_FAILED;

 	}

 

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartParticle::update(CPartEmitter *emitter, uint32 currentTime, uint32 timerDelta) {

+bool PartParticle::update(PartEmitter *emitter, uint32 currentTime, uint32 timerDelta) {

 	if (_state == PARTICLE_FADEIN) {

 		if (currentTime - _fadeStart >= (uint32)_fadeTime) {

 			_state = PARTICLE_NORMAL;

@@ -123,11 +123,11 @@ bool CPartParticle::update(CPartEmitter *emitter, uint32 currentTime, uint32 tim
 		}

 

 		// particle hit the border

-		if (!_isDead && !CBPlatform::isRectEmpty(&_border)) {

+		if (!_isDead && !BasePlatform::isRectEmpty(&_border)) {

 			Point32 p;

 			p.x = (int32)_pos.x;

 			p.y = (int32)_pos.y;

-			if (!CBPlatform::ptInRect(&_border, p))

+			if (!BasePlatform::ptInRect(&_border, p))

 				fadeOut(currentTime, emitter->_fadeOutTime);

 		}

 		if (_state != PARTICLE_NORMAL) return STATUS_OK;

@@ -144,13 +144,13 @@ bool CPartParticle::update(CPartEmitter *emitter, uint32 currentTime, uint32 tim
 		float elapsedTime = (float)timerDelta / 1000.f;

 

 		for (int i = 0; i < emitter->_forces.getSize(); i++) {

-			CPartForce *force = emitter->_forces[i];

+			PartForce *force = emitter->_forces[i];

 			switch (force->_type) {

-			case CPartForce::FORCE_GLOBAL:

+			case PartForce::FORCE_GLOBAL:

 				_velocity += force->_direction * elapsedTime;

 				break;

 

-			case CPartForce::FORCE_POINT: {

+			case PartForce::FORCE_POINT: {

 				Vector2 vecDist = force->_pos - _pos;

 				float dist = fabs(vecDist.length());

 

@@ -165,7 +165,7 @@ bool CPartParticle::update(CPartEmitter *emitter, uint32 currentTime, uint32 tim
 

 		// update rotation

 		_rotation += _angVelocity * elapsedTime;

-		_rotation = CBUtils::normalizeAngle(_rotation);

+		_rotation = BaseUtils::normalizeAngle(_rotation);

 

 		// update scale

 		if (_exponentialGrowth)

@@ -182,7 +182,7 @@ bool CPartParticle::update(CPartEmitter *emitter, uint32 currentTime, uint32 tim
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartParticle::display(CPartEmitter *emitter) {

+bool PartParticle::display(PartEmitter *emitter) {

 	if (!_sprite) return STATUS_FAILED;

 	if (_isDead) return STATUS_OK;

 

@@ -197,7 +197,7 @@ bool CPartParticle::display(CPartEmitter *emitter) {
 

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartParticle::fadeIn(uint32 currentTime, int fadeTime) {

+bool PartParticle::fadeIn(uint32 currentTime, int fadeTime) {

 	_currentAlpha = 0;

 	_fadeStart = currentTime;

 	_fadeTime = fadeTime;

@@ -207,7 +207,7 @@ bool CPartParticle::fadeIn(uint32 currentTime, int fadeTime) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartParticle::fadeOut(uint32 currentTime, int fadeTime) {

+bool PartParticle::fadeOut(uint32 currentTime, int fadeTime) {

 	//_currentAlpha = 255;

 	_fadeStartAlpha = _currentAlpha;

 	_fadeStart = currentTime;

@@ -218,7 +218,7 @@ bool CPartParticle::fadeOut(uint32 currentTime, int fadeTime) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool CPartParticle::persist(CBPersistMgr *persistMgr) {

+bool PartParticle::persist(BasePersistenceManager *persistMgr) {

 	persistMgr->transfer(TMEMBER(_alpha1));

 	persistMgr->transfer(TMEMBER(_alpha2));

 	persistMgr->transfer(TMEMBER(_border));

@@ -244,9 +244,9 @@ bool CPartParticle::persist(CBPersistMgr *persistMgr) {
 	} else {

 		char *filename;

 		persistMgr->transfer(TMEMBER(filename));

-		CSysClassRegistry::getInstance()->_disabled = true;

+		SystemClassRegistry::getInstance()->_disabled = true;

 		setSprite(filename);

-		CSysClassRegistry::getInstance()->_disabled = false;

+		SystemClassRegistry::getInstance()->_disabled = false;

 		delete[] filename;

 		filename = NULL;

 	}

diff --git a/engines/wintermute/base/particles/part_particle.h b/engines/wintermute/base/particles/part_particle.h
index 0b256d44ec..8b0c6eea36 100644
--- a/engines/wintermute/base/particles/part_particle.h
+++ b/engines/wintermute/base/particles/part_particle.h
@@ -36,18 +36,18 @@
 

 namespace WinterMute {

 

-class CPartEmitter;

-class CBSprite;

-class CBPersistMgr;

+class PartEmitter;

+class BaseSprite;

+class BasePersistenceManager;

 

-class CPartParticle : public CBBase {

+class PartParticle : public BaseClass {

 public:

 	enum TParticleState {

 	    PARTICLE_NORMAL, PARTICLE_FADEIN, PARTICLE_FADEOUT

 	};

 

-	CPartParticle(CBGame *inGame);

-	virtual ~CPartParticle(void);

+	PartParticle(BaseGame *inGame);

+	virtual ~PartParticle(void);

 

 	float _growthRate;

 	bool _exponentialGrowth;

@@ -63,21 +63,21 @@ public:
 	float _posZ;

 	Vector2 _velocity;

 	float _scale;

-	CBSprite *_sprite;

+	BaseSprite *_sprite;

 	uint32 _creationTime;

 	int _lifeTime;

 	bool _isDead;

 	TParticleState _state;

 

-	bool update(CPartEmitter *emitter, uint32 currentTime, uint32 timerDelta);

-	bool display(CPartEmitter *emitter);

+	bool update(PartEmitter *emitter, uint32 currentTime, uint32 timerDelta);

+	bool display(PartEmitter *emitter);

 

 	bool setSprite(const char *filename);

 

 	bool fadeIn(uint32 currentTime, int fadeTime);

 	bool fadeOut(uint32 currentTime, int fadeTime);

 

-	bool persist(CBPersistMgr *PersistMgr);

+	bool persist(BasePersistenceManager *PersistMgr);

 private:

 	uint32 _fadeStart;

 	int _fadeTime;