diff options
Diffstat (limited to 'engines/wintermute/ad')
52 files changed, 1263 insertions, 1263 deletions
diff --git a/engines/wintermute/ad/ad_actor.cpp b/engines/wintermute/ad/ad_actor.cpp index 36f1aa8286..1da28cd93d 100644 --- a/engines/wintermute/ad/ad_actor.cpp +++ b/engines/wintermute/ad/ad_actor.cpp @@ -52,12 +52,12 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdActor, false)
+IMPLEMENT_PERSISTENT(AdActor, false)
//////////////////////////////////////////////////////////////////////////
-CAdActor::CAdActor(CBGame *inGame): CAdTalkHolder(inGame) {
- _path = new CAdPath(_gameRef);
+AdActor::AdActor(BaseGame *inGame): AdTalkHolder(inGame) {
+ _path = new AdPath(_gameRef);
_type = OBJECT_ACTOR;
_dir = DI_LEFT;
@@ -67,7 +67,7 @@ CAdActor::CAdActor(CBGame *inGame): CAdTalkHolder(inGame) { _turnLeftSprite = NULL;
_turnRightSprite = NULL;
- _targetPoint = new CBPoint;
+ _targetPoint = new BasePoint;
_afterWalkDir = DI_NONE;
_animSprite2 = NULL;
@@ -76,7 +76,7 @@ CAdActor::CAdActor(CBGame *inGame): CAdTalkHolder(inGame) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::setDefaultAnimNames() {
+bool AdActor::setDefaultAnimNames() {
_talkAnimName = "talk";
_idleAnimName = "idle";
_walkAnimName = "walk";
@@ -86,7 +86,7 @@ bool CAdActor::setDefaultAnimNames() { }
//////////////////////////////////////////////////////////////////////////
-CAdActor::~CAdActor() {
+AdActor::~AdActor() {
delete _path;
delete _targetPoint;
_path = NULL;
@@ -123,10 +123,10 @@ CAdActor::~CAdActor() { //////////////////////////////////////////////////////////////////////////
-bool CAdActor::loadFile(const char *filename) {
+bool AdActor::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdActor::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdActor::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -183,7 +183,7 @@ TOKEN_DEF(EDITOR_PROPERTY) TOKEN_DEF(ANIMATION)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::loadBuffer(byte *buffer, bool complete) {
+bool AdActor::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ACTOR)
TOKEN_TABLE(X)
@@ -225,7 +225,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ACTOR) {
@@ -235,8 +235,8 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { buffer = params;
}
- CAdGame *adGame = (CAdGame *)_gameRef;
- CAdSpriteSet *spr = NULL;
+ AdGame *adGame = (AdGame *)_gameRef;
+ AdSpriteSet *spr = NULL;
int ar = 0, ag = 0, ab = 0, alpha = 0;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
@@ -290,19 +290,19 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { case TOKEN_WALK:
delete _walkSprite;
_walkSprite = NULL;
- spr = new CAdSpriteSet(_gameRef, this);
+ spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texWalkLifeTime, CACHE_HALF))) cmd = PARSERR_GENERIC;
else _walkSprite = spr;
break;
case TOKEN_TALK:
- spr = new CAdSpriteSet(_gameRef, this);
+ spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
else _talkSprites.add(spr);
break;
case TOKEN_TALK_SPECIAL:
- spr = new CAdSpriteSet(_gameRef, this);
+ spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
else _talkSpritesEx.add(spr);
break;
@@ -310,7 +310,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { case TOKEN_STAND:
delete _standSprite;
_standSprite = NULL;
- spr = new CAdSpriteSet(_gameRef, this);
+ spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true, adGame->_texStandLifeTime))) cmd = PARSERR_GENERIC;
else _standSprite = spr;
break;
@@ -318,7 +318,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { case TOKEN_TURN_LEFT:
delete _turnLeftSprite;
_turnLeftSprite = NULL;
- spr = new CAdSpriteSet(_gameRef, this);
+ spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true))) cmd = PARSERR_GENERIC;
else _turnLeftSprite = spr;
break;
@@ -326,7 +326,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { case TOKEN_TURN_RIGHT:
delete _turnRightSprite;
_turnRightSprite = NULL;
- spr = new CAdSpriteSet(_gameRef, this);
+ spr = new AdSpriteSet(_gameRef, this);
if (!spr || DID_FAIL(spr->loadBuffer(params, true))) cmd = PARSERR_GENERIC;
else _turnRightSprite = spr;
break;
@@ -337,7 +337,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { case TOKEN_CURSOR:
delete _cursor;
- _cursor = new CBSprite(_gameRef);
+ _cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = NULL;
@@ -378,8 +378,8 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { delete _currentBlockRegion;
_blockRegion = NULL;
_currentBlockRegion = NULL;
- CBRegion *rgn = new CBRegion(_gameRef);
- CBRegion *crgn = new CBRegion(_gameRef);
+ BaseRegion *rgn = new BaseRegion(_gameRef);
+ BaseRegion *crgn = new BaseRegion(_gameRef);
if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
delete _blockRegion;
delete _currentBlockRegion;
@@ -399,8 +399,8 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { delete _currentWptGroup;
_wptGroup = NULL;
_currentWptGroup = NULL;
- CAdWaypointGroup *wpt = new CAdWaypointGroup(_gameRef);
- CAdWaypointGroup *cwpt = new CAdWaypointGroup(_gameRef);
+ AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
+ AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
delete _wptGroup;
delete _currentWptGroup;
@@ -432,7 +432,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_ANIMATION: {
- CAdSpriteSet *Anim = new CAdSpriteSet(_gameRef, this);
+ AdSpriteSet *Anim = new AdSpriteSet(_gameRef, this);
if (!Anim || DID_FAIL(Anim->loadBuffer(params, false))) cmd = PARSERR_GENERIC;
else _anims.add(Anim);
}
@@ -460,7 +460,7 @@ bool CAdActor::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-void CAdActor::turnTo(TDirection dir) {
+void AdActor::turnTo(TDirection dir) {
int delta1, delta2, delta3, delta;
delta1 = dir - _dir;
@@ -486,7 +486,7 @@ void CAdActor::turnTo(TDirection dir) { //////////////////////////////////////////////////////////////////////////
-void CAdActor::goTo(int x, int y, TDirection afterWalkDir) {
+void AdActor::goTo(int x, int y, TDirection afterWalkDir) {
_afterWalkDir = afterWalkDir;
if (x == _targetPoint->x && y == _targetPoint->y && _state == STATE_FOLLOWING_PATH) return;
@@ -496,7 +496,7 @@ void CAdActor::goTo(int x, int y, TDirection afterWalkDir) { _targetPoint->x = x;
_targetPoint->y = y;
- ((CAdGame *)_gameRef)->_scene->correctTargetPoint(_posX, _posY, &_targetPoint->x, &_targetPoint->y, true, this);
+ ((AdGame *)_gameRef)->_scene->correctTargetPoint(_posX, _posY, &_targetPoint->x, &_targetPoint->y, true, this);
_state = STATE_SEARCHING_PATH;
@@ -504,12 +504,12 @@ void CAdActor::goTo(int x, int y, TDirection afterWalkDir) { //////////////////////////////////////////////////////////////////////////
-bool CAdActor::display() {
+bool AdActor::display() {
if (_active) updateSounds();
uint32 alpha;
if (_alphaColor != 0) alpha = _alphaColor;
- else alpha = _shadowable ? ((CAdGame *)_gameRef)->_scene->getAlphaAt(_posX, _posY, true) : 0xFFFFFFFF;
+ else alpha = _shadowable ? ((AdGame *)_gameRef)->_scene->getAlphaAt(_posX, _posY, true) : 0xFFFFFFFF;
float scaleX, scaleY;
getScale(&scaleX, &scaleY);
@@ -518,14 +518,14 @@ bool CAdActor::display() { float rotate;
if (_rotatable) {
if (_rotateValid) rotate = _rotate;
- else rotate = ((CAdGame *)_gameRef)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
+ else rotate = ((AdGame *)_gameRef)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
} else rotate = 0.0f;
if (_active) displaySpriteAttachments(true);
if (_currentSprite && _active) {
bool reg = _registrable;
- if (_ignoreItems && ((CAdGame *)_gameRef)->_selectedItem) reg = false;
+ if (_ignoreItems && ((AdGame *)_gameRef)->_selectedItem) reg = false;
_currentSprite->display(_posX,
_posY,
@@ -547,7 +547,7 @@ bool CAdActor::display() { //////////////////////////////////////////////////////////////////////////
-bool CAdActor::update() {
+bool AdActor::update() {
_currentSprite = NULL;
if (_state == STATE_READY) {
@@ -582,7 +582,7 @@ bool CAdActor::update() { if (_standSprite) {
_currentSprite = _standSprite->getSprite(_dir);
} else {
- CAdSpriteSet *Anim = getAnimByName(_idleAnimName);
+ AdSpriteSet *Anim = getAnimByName(_idleAnimName);
if (Anim) _currentSprite = Anim->getSprite(_dir);
}
}
@@ -615,7 +615,7 @@ bool CAdActor::update() { if (_turnLeftSprite) {
_tempSprite2 = _turnLeftSprite->getSprite(_dir);
} else {
- CAdSpriteSet *Anim = getAnimByName(_turnLeftAnimName);
+ AdSpriteSet *Anim = getAnimByName(_turnLeftAnimName);
if (Anim) _tempSprite2 = Anim->getSprite(_dir);
}
@@ -644,7 +644,7 @@ bool CAdActor::update() { if (_turnRightSprite) {
_tempSprite2 = _turnRightSprite->getSprite(_dir);
} else {
- CAdSpriteSet *Anim = getAnimByName(_turnRightAnimName);
+ AdSpriteSet *Anim = getAnimByName(_turnRightAnimName);
if (Anim) _tempSprite2 = Anim->getSprite(_dir);
}
@@ -661,7 +661,7 @@ bool CAdActor::update() { //////////////////////////////////////////////////////////////////////////
case STATE_SEARCHING_PATH:
// keep asking scene for the path
- if (((CAdGame *)_gameRef)->_scene->getPath(CBPoint(_posX, _posY), *_targetPoint, _path, this))
+ if (((AdGame *)_gameRef)->_scene->getPath(BasePoint(_posX, _posY), *_targetPoint, _path, this))
_state = STATE_WAITING_PATH;
break;
@@ -696,12 +696,12 @@ bool CAdActor::update() { if (_tempSprite2) {
_tempSprite2->reset();
_currentSprite = _tempSprite2;
- ((CAdGame *)_gameRef)->addSentence(_sentence);
+ ((AdGame *)_gameRef)->addSentence(_sentence);
}
}
} else {
_currentSprite = _tempSprite2;
- ((CAdGame *)_gameRef)->addSentence(_sentence);
+ ((AdGame *)_gameRef)->addSentence(_sentence);
}
}
break;
@@ -714,7 +714,7 @@ bool CAdActor::update() { if (_standSprite) {
_currentSprite = _standSprite->getSprite(_dir);
} else {
- CAdSpriteSet *Anim = getAnimByName(_idleAnimName);
+ AdSpriteSet *Anim = getAnimByName(_idleAnimName);
if (Anim) _currentSprite = Anim->getSprite(_dir);
}
}
@@ -726,7 +726,7 @@ bool CAdActor::update() { if (_currentSprite && !already_moved) {
- _currentSprite->GetCurrentFrame(_zoomable ? ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
+ _currentSprite->GetCurrentFrame(_zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
if (_currentSprite->_changed) {
_posX += _currentSprite->_moveX;
_posY += _currentSprite->_moveY;
@@ -747,7 +747,7 @@ bool CAdActor::update() { //////////////////////////////////////////////////////////////////////////
-void CAdActor::followPath() {
+void AdActor::followPath() {
// skip current position
_path->getFirst();
while (_path->getCurrent() != NULL) {
@@ -758,7 +758,7 @@ void CAdActor::followPath() { // are there points to follow?
if (_path->getCurrent() != NULL) {
_state = STATE_FOLLOWING_PATH;;
- initLine(CBPoint(_posX, _posY), *_path->getCurrent());
+ initLine(BasePoint(_posX, _posY), *_path->getCurrent());
} else {
if (_afterWalkDir != DI_NONE) turnTo(_afterWalkDir);
else _state = STATE_READY;
@@ -767,17 +767,17 @@ void CAdActor::followPath() { //////////////////////////////////////////////////////////////////////////
-void CAdActor::getNextStep() {
+void AdActor::getNextStep() {
if (_walkSprite) {
_currentSprite = _walkSprite->getSprite(_dir);
} else {
- CAdSpriteSet *Anim = getAnimByName(_walkAnimName);
+ AdSpriteSet *Anim = getAnimByName(_walkAnimName);
if (Anim) _currentSprite = Anim->getSprite(_dir);
}
if (!_currentSprite) return;
- _currentSprite->GetCurrentFrame(_zoomable ? ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
+ _currentSprite->GetCurrentFrame(_zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100, _zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
if (!_currentSprite->_changed) return;
@@ -796,7 +796,7 @@ void CAdActor::getNextStep() { maxStepX--;
}
- if (((CAdGame *)_gameRef)->_scene->isBlockedAt((int)_pFX,(int) _pFY, true, this)) {
+ if (((AdGame *)_gameRef)->_scene->isBlockedAt((int)_pFX,(int) _pFY, true, this)) {
if (_pFCount == 0) {
_state = _nextState;
_nextState = STATE_READY;
@@ -824,13 +824,13 @@ void CAdActor::getNextStep() { _state = _nextState;
_nextState = STATE_READY;
}
- } else initLine(CBPoint(_posX, _posY), *_path->getCurrent());
+ } else initLine(BasePoint(_posX, _posY), *_path->getCurrent());
}
}
//////////////////////////////////////////////////////////////////////////
-void CAdActor::initLine(CBPoint startPt, CBPoint endPt) {
+void AdActor::initLine(BasePoint startPt, BasePoint endPt) {
_pFCount = MAX((abs(endPt.x - startPt.x)) , (abs(endPt.y - startPt.y)));
_pFStepX = (double)(endPt.x - startPt.x) / _pFCount;
@@ -850,7 +850,7 @@ void CAdActor::initLine(CBPoint startPt, CBPoint endPt) { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdActor::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// GoTo / GoToAsync
//////////////////////////////////////////////////////////////////////////
@@ -869,19 +869,19 @@ bool CAdActor::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GoToObject") == 0 || strcmp(name, "GoToObjectAsync") == 0) {
stack->correctParams(1);
- CScValue *Val = stack->pop();
+ ScValue *Val = stack->pop();
if (!Val->isNative()) {
script->runtimeError("actor.%s method accepts an entity refrence only", name);
stack->pushNULL();
return STATUS_OK;
}
- CAdObject *Obj = (CAdObject *)Val->getNative();
+ AdObject *Obj = (AdObject *)Val->getNative();
if (!Obj || Obj->_type != OBJECT_ENTITY) {
script->runtimeError("actor.%s method accepts an entity refrence only", name);
stack->pushNULL();
return STATUS_OK;
}
- CAdEntity *Ent = (CAdEntity *)Obj;
+ AdEntity *Ent = (AdEntity *)Obj;
if (Ent->_walkToX == 0 && Ent->_walkToY == 0) goTo(Ent->_posX, Ent->_posY);
else goTo(Ent->_walkToX, Ent->_walkToY, Ent->_walkToDir);
if (strcmp(name, "GoToObjectAsync") != 0) script->waitForExclusive(this);
@@ -895,11 +895,11 @@ bool CAdActor::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt else if (strcmp(name, "TurnTo") == 0 || strcmp(name, "TurnToAsync") == 0) {
stack->correctParams(1);
int dir;
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
// turn to object?
- if (val->isNative() && _gameRef->validObject((CBObject *)val->getNative())) {
- CBObject *obj = (CBObject *)val->getNative();
+ if (val->isNative() && _gameRef->validObject((BaseObject *)val->getNative())) {
+ BaseObject *obj = (BaseObject *)val->getNative();
int angle = (int)(atan2((double)(obj->_posY - _posY), (double)(obj->_posX - _posX)) * (180 / 3.14));
dir = (int)angleToDirection(angle);
}
@@ -968,12 +968,12 @@ bool CAdActor::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt return STATUS_OK;
}
- else return CAdTalkHolder::scCallMethod(script, stack, thisStack, name);
+ else return AdTalkHolder::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdActor::scGetProperty(const char *name) {
+ScValue *AdActor::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -1030,12 +1030,12 @@ CScValue *CAdActor::scGetProperty(const char *name) { return _scValue;
}
- else return CAdTalkHolder::scGetProperty(name);
+ else return AdTalkHolder::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::scSetProperty(const char *name, CScValue *value) {
+bool AdActor::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Direction
//////////////////////////////////////////////////////////////////////////
@@ -1090,27 +1090,27 @@ bool CAdActor::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CAdTalkHolder::scSetProperty(name, value);
+ else return AdTalkHolder::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdActor::scToString() {
+const char *AdActor::scToString() {
return "[actor object]";
}
//////////////////////////////////////////////////////////////////////////
-CBSprite *CAdActor::getTalkStance(const char *stance) {
+BaseSprite *AdActor::getTalkStance(const char *stance) {
// forced stance?
if (_forcedTalkAnimName && !_forcedTalkAnimUsed) {
_forcedTalkAnimUsed = true;
delete _animSprite;
- _animSprite = new CBSprite(_gameRef, this);
+ _animSprite = new BaseSprite(_gameRef, this);
if (_animSprite) {
bool res = _animSprite->loadFile(_forcedTalkAnimName);
if (DID_FAIL(res)) {
- _gameRef->LOG(res, "CAdActor::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
+ _gameRef->LOG(res, "AdActor::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
delete _animSprite;
_animSprite = NULL;
} else return _animSprite;
@@ -1122,15 +1122,15 @@ CBSprite *CAdActor::getTalkStance(const char *stance) { return getTalkStanceOld(stance);
// new way
- CBSprite *ret = NULL;
+ BaseSprite *ret = NULL;
// do we have an animation with this name?
- CAdSpriteSet *Anim = getAnimByName(stance);
+ AdSpriteSet *Anim = getAnimByName(stance);
if (Anim) ret = Anim->getSprite(_dir);
// not - get a random talk
if (!ret) {
- CBArray<CAdSpriteSet *, CAdSpriteSet *> TalkAnims;
+ BaseArray<AdSpriteSet *, AdSpriteSet *> TalkAnims;
for (int i = 0; i < _anims.getSize(); i++) {
if (_talkAnimName.compareToIgnoreCase(_anims[i]->_name) == 0)
TalkAnims.add(_anims[i]);
@@ -1151,8 +1151,8 @@ CBSprite *CAdActor::getTalkStance(const char *stance) { }
//////////////////////////////////////////////////////////////////////////
-CBSprite *CAdActor::getTalkStanceOld(const char *stance) {
- CBSprite *ret = NULL;
+BaseSprite *AdActor::getTalkStanceOld(const char *stance) {
+ BaseSprite *ret = NULL;
if (stance != NULL) {
// search special stances
@@ -1187,8 +1187,8 @@ CBSprite *CAdActor::getTalkStanceOld(const char *stance) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::persist(CBPersistMgr *persistMgr) {
- CAdTalkHolder::persist(persistMgr);
+bool AdActor::persist(BasePersistenceManager *persistMgr) {
+ AdTalkHolder::persist(persistMgr);
persistMgr->transfer(TMEMBER_INT(_dir));
persistMgr->transfer(TMEMBER(_path));
@@ -1221,7 +1221,7 @@ bool CAdActor::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-TDirection CAdActor::angleToDirection(int angle) {
+TDirection AdActor::angleToDirection(int angle) {
TDirection ret = DI_DOWN;;
if (angle > -112 && angle <= -67) ret = DI_UP;
@@ -1238,22 +1238,22 @@ TDirection CAdActor::angleToDirection(int angle) { //////////////////////////////////////////////////////////////////////////
-int CAdActor::getHeight() {
+int AdActor::getHeight() {
// if no current sprite is set, set some
if (_currentSprite == NULL) {
if (_standSprite) _currentSprite = _standSprite->getSprite(_dir);
else {
- CAdSpriteSet *Anim = getAnimByName(_idleAnimName);
+ AdSpriteSet *Anim = getAnimByName(_idleAnimName);
if (Anim) _currentSprite = Anim->getSprite(_dir);
}
}
// and get height
- return CAdTalkHolder::getHeight();
+ return AdTalkHolder::getHeight();
}
//////////////////////////////////////////////////////////////////////////
-CAdSpriteSet *CAdActor::getAnimByName(const Common::String &animName) {
+AdSpriteSet *AdActor::getAnimByName(const Common::String &animName) {
for (int i = 0; i < _anims.getSize(); i++) {
if (animName.compareToIgnoreCase(_anims[i]->_name) == 0)
return _anims[i];
@@ -1262,7 +1262,7 @@ CAdSpriteSet *CAdActor::getAnimByName(const Common::String &animName) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::mergeAnims(const char *animsFilename) {
+bool AdActor::mergeAnims(const char *animsFilename) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ANIMATION)
TOKEN_TABLE_END
@@ -1270,21 +1270,21 @@ bool CAdActor::mergeAnims(const char *animsFilename) { byte *fileBuffer = _gameRef->_fileManager->readWholeFile(animsFilename);
if (fileBuffer == NULL) {
- _gameRef->LOG(0, "CAdActor::MergeAnims failed for file '%s'", animsFilename);
+ _gameRef->LOG(0, "AdActor::MergeAnims failed for file '%s'", animsFilename);
return STATUS_FAILED;
}
byte *buffer = fileBuffer;
byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
bool Ret = STATUS_OK;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_ANIMATION: {
- CAdSpriteSet *Anim = new CAdSpriteSet(_gameRef, this);
+ AdSpriteSet *Anim = new AdSpriteSet(_gameRef, this);
if (!Anim || DID_FAIL(Anim->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
Ret = STATUS_FAILED;
@@ -1298,9 +1298,9 @@ bool CAdActor::mergeAnims(const char *animsFilename) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdActor::playAnim(const char *filename) {
+bool AdActor::playAnim(const char *filename) {
// if we have an anim with this name, use it
- CAdSpriteSet *Anim = getAnimByName(filename);
+ AdSpriteSet *Anim = getAnimByName(filename);
if (Anim) {
_animSprite2 = Anim->getSprite(_dir);
if (_animSprite2) {
@@ -1310,7 +1310,7 @@ bool CAdActor::playAnim(const char *filename) { }
}
// otherwise call the standard handler
- return CAdTalkHolder::playAnim(filename);
+ return AdTalkHolder::playAnim(filename);
}
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_actor.h b/engines/wintermute/ad/ad_actor.h index 67e0630f83..3cce827b17 100644 --- a/engines/wintermute/ad/ad_actor.h +++ b/engines/wintermute/ad/ad_actor.h @@ -39,31 +39,31 @@ namespace WinterMute {
-class CAdSpriteSet;
-class CAdPath;
-class CAdActor : public CAdTalkHolder {
+class AdSpriteSet;
+class AdPath;
+class AdActor : public AdTalkHolder {
public:
TDirection angleToDirection(int angle);
- DECLARE_PERSISTENT(CAdActor, CAdTalkHolder)
+ DECLARE_PERSISTENT(AdActor, AdTalkHolder)
virtual int getHeight();
- CBSprite *getTalkStance(const char *stance);
+ BaseSprite *getTalkStance(const char *stance);
virtual void goTo(int x, int y, TDirection afterWalkDir = DI_NONE);
- CBPoint *_targetPoint;
+ BasePoint *_targetPoint;
virtual bool update();
virtual bool display();
TDirection _targetDir;
TDirection _afterWalkDir;
virtual void turnTo(TDirection dir);
- CAdPath *_path;
- CAdSpriteSet *_walkSprite;
- CAdSpriteSet *_standSprite;
- CAdSpriteSet *_turnLeftSprite;
- CAdSpriteSet *_turnRightSprite;
- CBArray<CAdSpriteSet *, CAdSpriteSet *> _talkSprites;
- CBArray<CAdSpriteSet *, CAdSpriteSet *> _talkSpritesEx;
+ AdPath *_path;
+ AdSpriteSet *_walkSprite;
+ AdSpriteSet *_standSprite;
+ AdSpriteSet *_turnLeftSprite;
+ AdSpriteSet *_turnRightSprite;
+ BaseArray<AdSpriteSet *, AdSpriteSet *> _talkSprites;
+ BaseArray<AdSpriteSet *, AdSpriteSet *> _talkSpritesEx;
TDirection _dir;
- CAdActor(CBGame *inGame/*=NULL*/);
- virtual ~CAdActor();
+ AdActor(BaseGame *inGame/*=NULL*/);
+ virtual ~AdActor();
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
@@ -73,23 +73,23 @@ public: Common::String _walkAnimName;
Common::String _turnLeftAnimName;
Common::String _turnRightAnimName;
- CBArray<CAdSpriteSet *, CAdSpriteSet *> _anims;
+ BaseArray<AdSpriteSet *, AdSpriteSet *> _anims;
virtual bool playAnim(const char *filename);
- CAdSpriteSet *getAnimByName(const Common::String &animName);
+ AdSpriteSet *getAnimByName(const Common::String &animName);
// 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:
bool setDefaultAnimNames();
- CBSprite *getTalkStanceOld(const char *stance);
+ BaseSprite *getTalkStanceOld(const char *stance);
bool mergeAnims(const char *animsFilename);
- CBSprite *_animSprite2;
+ BaseSprite *_animSprite2;
- void initLine(CBPoint startPt, CBPoint endPt);
+ void initLine(BasePoint startPt, BasePoint endPt);
void getNextStep();
void followPath();
double _pFStepX;
diff --git a/engines/wintermute/ad/ad_entity.cpp b/engines/wintermute/ad/ad_entity.cpp index 5f32017264..06a551b252 100644 --- a/engines/wintermute/ad/ad_entity.cpp +++ b/engines/wintermute/ad/ad_entity.cpp @@ -55,10 +55,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdEntity, false)
+IMPLEMENT_PERSISTENT(AdEntity, false)
//////////////////////////////////////////////////////////////////////////
-CAdEntity::CAdEntity(CBGame *inGame): CAdTalkHolder(inGame) {
+AdEntity::AdEntity(BaseGame *inGame): AdTalkHolder(inGame) {
_type = OBJECT_ENTITY;
_subtype = ENTITY_NORMAL;
_region = NULL;
@@ -72,7 +72,7 @@ CAdEntity::CAdEntity(CBGame *inGame): CAdTalkHolder(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdEntity::~CAdEntity() {
+AdEntity::~AdEntity() {
_gameRef->unregisterObject(_region);
delete _theora;
@@ -84,10 +84,10 @@ CAdEntity::~CAdEntity() { //////////////////////////////////////////////////////////////////////////
-bool CAdEntity::loadFile(const char *filename) {
+bool AdEntity::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdEntity::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdEntity::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -150,7 +150,7 @@ TOKEN_DEF(WALK_TO_DIR) TOKEN_DEF(SAVE_STATE)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdEntity::loadBuffer(byte *buffer, bool complete) {
+bool AdEntity::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ENTITY)
TOKEN_TABLE(SPRITE)
@@ -198,7 +198,7 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ENTITY) {
@@ -208,8 +208,8 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { buffer = params;
}
- CAdGame *adGame = (CAdGame *)_gameRef;
- CBSprite *spr = NULL;
+ AdGame *adGame = (AdGame *)_gameRef;
+ BaseSprite *spr = NULL;
int ar = 0, ag = 0, ab = 0, alpha = 0;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
@@ -228,21 +228,21 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { case TOKEN_SPRITE: {
delete _sprite;
_sprite = NULL;
- spr = new CBSprite(_gameRef, this);
+ spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile((char *)params))) cmd = PARSERR_GENERIC;
else _sprite = spr;
}
break;
case TOKEN_TALK: {
- spr = new CBSprite(_gameRef, this);
+ spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
else _talkSprites.add(spr);
}
break;
case TOKEN_TALK_SPECIAL: {
- spr = new CBSprite(_gameRef, this);
+ spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile((char *)params, adGame->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
else _talkSpritesEx.add(spr);
}
@@ -305,7 +305,7 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { case TOKEN_CURSOR:
delete _cursor;
- _cursor = new CBSprite(_gameRef);
+ _cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = NULL;
@@ -320,7 +320,7 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { case TOKEN_REGION: {
if (_region) _gameRef->unregisterObject(_region);
_region = NULL;
- CBRegion *rgn = new CBRegion(_gameRef);
+ BaseRegion *rgn = new BaseRegion(_gameRef);
if (!rgn || DID_FAIL(rgn->loadBuffer(params, false))) cmd = PARSERR_GENERIC;
else {
_region = rgn;
@@ -334,8 +334,8 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { _blockRegion = NULL;
delete _currentBlockRegion;
_currentBlockRegion = NULL;
- CBRegion *rgn = new CBRegion(_gameRef);
- CBRegion *crgn = new CBRegion(_gameRef);
+ BaseRegion *rgn = new BaseRegion(_gameRef);
+ BaseRegion *crgn = new BaseRegion(_gameRef);
if (!rgn || !crgn || DID_FAIL(rgn->loadBuffer(params, false))) {
delete _blockRegion;
_blockRegion = NULL;
@@ -355,8 +355,8 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { _wptGroup = NULL;
delete _currentWptGroup;
_currentWptGroup = NULL;
- CAdWaypointGroup *wpt = new CAdWaypointGroup(_gameRef);
- CAdWaypointGroup *cwpt = new CAdWaypointGroup(_gameRef);
+ AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
+ AdWaypointGroup *cwpt = new AdWaypointGroup(_gameRef);
if (!wpt || !cwpt || DID_FAIL(wpt->loadBuffer(params, false))) {
delete _wptGroup;
_wptGroup = NULL;
@@ -380,7 +380,7 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { delete _sprite;
_sprite = NULL;
if (_gameRef->_editorMode) {
- spr = new CBSprite(_gameRef, this);
+ spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile("entity_sound.sprite"))) cmd = PARSERR_GENERIC;
else _sprite = spr;
}
@@ -474,20 +474,20 @@ bool CAdEntity::loadBuffer(byte *buffer, bool complete) { _alphaColor = BYTETORGBA(ar, ag, ab, alpha);
_state = STATE_READY;
- if (_item && ((CAdGame *)_gameRef)->isItemTaken(_item)) _active = false;
+ if (_item && ((AdGame *)_gameRef)->isItemTaken(_item)) _active = false;
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdEntity::display() {
+bool AdEntity::display() {
if (_active) {
updateSounds();
uint32 Alpha;
if (_alphaColor != 0) Alpha = _alphaColor;
- else Alpha = _shadowable ? ((CAdGame *)_gameRef)->_scene->getAlphaAt(_posX, _posY) : 0xFFFFFFFF;
+ else Alpha = _shadowable ? ((AdGame *)_gameRef)->_scene->getAlphaAt(_posX, _posY) : 0xFFFFFFFF;
float ScaleX, ScaleY;
getScale(&ScaleX, &ScaleY);
@@ -495,15 +495,15 @@ bool CAdEntity::display() { float Rotate;
if (_rotatable) {
if (_rotateValid) Rotate = _rotate;
- else Rotate = ((CAdGame *)_gameRef)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
+ else Rotate = ((AdGame *)_gameRef)->_scene->getRotationAt(_posX, _posY) + _relativeRotate;
} else Rotate = 0.0f;
bool Reg = _registrable;
- if (_ignoreItems && ((CAdGame *)_gameRef)->_selectedItem) Reg = false;
+ if (_ignoreItems && ((AdGame *)_gameRef)->_selectedItem) Reg = false;
if (_region && (Reg || _editorAlwaysRegister)) {
- _gameRef->_renderer->_rectList.add(new CBActiveRect(_gameRef, _registerAlias, _region, _gameRef->_offsetX, _gameRef->_offsetY));
+ _gameRef->_renderer->_rectList.add(new BaseActiveRect(_gameRef, _registerAlias, _region, _gameRef->_offsetX, _gameRef->_offsetY));
}
displaySpriteAttachments(true);
@@ -529,7 +529,7 @@ bool CAdEntity::display() { //////////////////////////////////////////////////////////////////////////
-bool CAdEntity::update() {
+bool AdEntity::update() {
_currentSprite = NULL;
if (_state == STATE_READY && _animSprite) {
@@ -577,11 +577,11 @@ bool CAdEntity::update() { _tempSprite2->reset();
_currentSprite = _tempSprite2;
}
- ((CAdGame *)_gameRef)->addSentence(_sentence);
+ ((AdGame *)_gameRef)->addSentence(_sentence);
}
} else {
_currentSprite = _tempSprite2;
- ((CAdGame *)_gameRef)->addSentence(_sentence);
+ ((AdGame *)_gameRef)->addSentence(_sentence);
}
}
break;
@@ -591,7 +591,7 @@ bool CAdEntity::update() { if (_currentSprite) {
- _currentSprite->GetCurrentFrame(_zoomable ? ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
+ _currentSprite->GetCurrentFrame(_zoomable ? ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) : 100);
if (_currentSprite->_changed) {
_posX += _currentSprite->_moveX;
_posY += _currentSprite->_moveY;
@@ -625,7 +625,7 @@ bool CAdEntity::update() { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdEntity::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdEntity::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// StopSound
//////////////////////////////////////////////////////////////////////////
@@ -644,11 +644,11 @@ bool CAdEntity::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS stack->correctParams(4);
const char *filename = stack->pop()->getString();
bool looping = stack->pop()->getBool(false);
- CScValue *valAlpha = stack->pop();
+ ScValue *valAlpha = stack->pop();
int startTime = stack->pop()->getInt();
delete _theora;
- _theora = new CVidTheoraPlayer(_gameRef);
+ _theora = new VideoTheoraPlayer(_gameRef);
if (_theora && DID_SUCCEED(_theora->initialize(filename))) {
if (!valAlpha->isNULL()) _theora->setAlphaImage(valAlpha->getString());
_theora->play(VID_PLAY_POS, 0, 0, false, false, looping, startTime, _scale >= 0.0f ? _scale : -1.0f, _sFXVolume);
@@ -732,7 +732,7 @@ bool CAdEntity::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS else if (strcmp(name, "CreateRegion") == 0) {
stack->correctParams(0);
if (!_region) {
- _region = new CBRegion(_gameRef);
+ _region = new BaseRegion(_gameRef);
_gameRef->registerObject(_region);
}
if (_region) stack->pushNative(_region, true);
@@ -755,12 +755,12 @@ bool CAdEntity::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS return STATUS_OK;
}
- else return CAdTalkHolder::scCallMethod(script, stack, thisStack, name);
+ else return AdTalkHolder::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdEntity::scGetProperty(const char *name) {
+ScValue *AdEntity::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -826,12 +826,12 @@ CScValue *CAdEntity::scGetProperty(const char *name) { return _scValue;
}
- else return CAdTalkHolder::scGetProperty(name);
+ else return AdTalkHolder::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdEntity::scSetProperty(const char *name, CScValue *value) {
+bool AdEntity::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Item
@@ -866,18 +866,18 @@ bool CAdEntity::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CAdTalkHolder::scSetProperty(name, value);
+ else return AdTalkHolder::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdEntity::scToString() {
+const char *AdEntity::scToString() {
return "[entity object]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdEntity::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdEntity::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "ENTITY {\n");
buffer->putTextIndent(indent + 2, "NAME=\"%s\"\n", _name);
if (_subtype == ENTITY_SOUND)
@@ -942,13 +942,13 @@ bool CAdEntity::saveAsText(CBDynBuffer *buffer, int indent) { if (_cursor && _cursor->_filename)
buffer->putTextIndent(indent + 2, "CURSOR=\"%s\"\n", _cursor->_filename);
- CAdTalkHolder::saveAsText(buffer, indent + 2);
+ AdTalkHolder::saveAsText(buffer, indent + 2);
if (_region) _region->saveAsText(buffer, indent + 2);
if (_scProp) _scProp->saveAsText(buffer, indent + 2);
- CAdObject::saveAsText(buffer, indent + 2);
+ AdObject::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n\n");
@@ -957,18 +957,18 @@ bool CAdEntity::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-int CAdEntity::getHeight() {
+int AdEntity::getHeight() {
if (_region && !_sprite) {
return _region->_rect.bottom - _region->_rect.top;
} else {
if (_currentSprite == NULL) _currentSprite = _sprite;
- return CAdObject::getHeight();
+ return AdObject::getHeight();
}
}
//////////////////////////////////////////////////////////////////////////
-void CAdEntity::updatePosition() {
+void AdEntity::updatePosition() {
if (_region && !_sprite) {
_posX = _region->_rect.left + (_region->_rect.right - _region->_rect.left) / 2;
_posY = _region->_rect.bottom;
@@ -977,8 +977,8 @@ void CAdEntity::updatePosition() { //////////////////////////////////////////////////////////////////////////
-bool CAdEntity::persist(CBPersistMgr *persistMgr) {
- CAdTalkHolder::persist(persistMgr);
+bool AdEntity::persist(BasePersistenceManager *persistMgr) {
+ AdTalkHolder::persist(persistMgr);
persistMgr->transfer(TMEMBER(_item));
persistMgr->transfer(TMEMBER(_region));
@@ -998,12 +998,12 @@ bool CAdEntity::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-void CAdEntity::setItem(const char *itemName) {
- CBUtils::setString(&_item, itemName);
+void AdEntity::setItem(const char *itemName) {
+ BaseUtils::setString(&_item, itemName);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdEntity::setSprite(const char *filename) {
+bool AdEntity::setSprite(const char *filename) {
bool setCurrent = false;
if (_currentSprite == _sprite) {
_currentSprite = NULL;
@@ -1012,7 +1012,7 @@ bool CAdEntity::setSprite(const char *filename) { delete _sprite;
_sprite = NULL;
- CBSprite *spr = new CBSprite(_gameRef, this);
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
delete _sprite;
_sprite = NULL;
diff --git a/engines/wintermute/ad/ad_entity.h b/engines/wintermute/ad/ad_entity.h index 8b67d27c1f..9931327916 100644 --- a/engines/wintermute/ad/ad_entity.h +++ b/engines/wintermute/ad/ad_entity.h @@ -32,33 +32,33 @@ #include "engines/wintermute/ad/ad_talk_holder.h"
namespace WinterMute {
-class CVidTheoraPlayer;
-class CAdEntity : public CAdTalkHolder {
+class VideoTheoraPlayer;
+class AdEntity : public AdTalkHolder {
public:
- CVidTheoraPlayer *_theora;
+ VideoTheoraPlayer *_theora;
bool setSprite(const char *filename);
int _walkToX;
int _walkToY;
TDirection _walkToDir;
void setItem(const char *itemName);
char *_item;
- DECLARE_PERSISTENT(CAdEntity, CAdTalkHolder)
+ DECLARE_PERSISTENT(AdEntity, AdTalkHolder)
void updatePosition();
virtual int getHeight();
- CBRegion *_region;
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ BaseRegion *_region;
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
virtual bool update();
virtual bool display();
- CAdEntity(CBGame *inGame);
- virtual ~CAdEntity();
+ AdEntity(BaseGame *inGame);
+ virtual ~AdEntity();
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
TEntityType _subtype;
// 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();
};
diff --git a/engines/wintermute/ad/ad_game.cpp b/engines/wintermute/ad/ad_game.cpp index 69cda25f29..e10ec1bf6d 100644 --- a/engines/wintermute/ad/ad_game.cpp +++ b/engines/wintermute/ad/ad_game.cpp @@ -63,14 +63,14 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdGame, true)
+IMPLEMENT_PERSISTENT(AdGame, true)
//////////////////////////////////////////////////////////////////////////
-CAdGame::CAdGame(): CBGame() {
+AdGame::AdGame(): BaseGame() {
_responseBox = NULL;
_inventoryBox = NULL;
- _scene = new CAdScene(_gameRef);
+ _scene = new AdScene(_gameRef);
_scene->setName("");
registerObject(_scene);
@@ -98,7 +98,7 @@ CAdGame::CAdGame(): CBGame() { _debugStartupScene = NULL;
_startupScene = NULL;
- _invObject = new CAdObject(this);
+ _invObject = new AdObject(this);
_inventoryOwner = _invObject;
_tempDisableSaveState = false;
@@ -111,13 +111,13 @@ CAdGame::CAdGame(): CBGame() { //////////////////////////////////////////////////////////////////////////
-CAdGame::~CAdGame() {
+AdGame::~AdGame() {
cleanup();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::cleanup() {
+bool AdGame::cleanup() {
int i;
for (i = 0; i < _objects.getSize(); i++) {
@@ -190,12 +190,12 @@ bool CAdGame::cleanup() { for (i = 0; i < _responsesGame.getSize(); i++) delete _responsesGame[i];
_responsesGame.removeAll();
- return CBGame::cleanup();
+ return BaseGame::cleanup();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::initLoop() {
+bool AdGame::initLoop() {
if (_scheduledScene && _transMgr->isReady()) {
changeScene(_scheduledScene, _scheduledFadeIn);
delete[] _scheduledScene;
@@ -206,7 +206,7 @@ bool CAdGame::initLoop() { bool res;
- res = CBGame::initLoop();
+ res = BaseGame::initLoop();
if (DID_FAIL(res)) return res;
if (_scene) res = _scene->initLoop();
@@ -218,14 +218,14 @@ bool CAdGame::initLoop() { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::addObject(CAdObject *object) {
+bool AdGame::addObject(AdObject *object) {
_objects.add(object);
return registerObject(object);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::removeObject(CAdObject *object) {
+bool AdGame::removeObject(AdObject *object) {
// in case the user called Scene.CreateXXX() and Game.DeleteXXX()
if (_scene) {
bool Res = _scene->removeObject(object);
@@ -243,9 +243,9 @@ bool CAdGame::removeObject(CAdObject *object) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::changeScene(const char *filename, bool fadeIn) {
+bool AdGame::changeScene(const char *filename, bool fadeIn) {
if (_scene == NULL) {
- _scene = new CAdScene(_gameRef);
+ _scene = new AdScene(_gameRef);
registerObject(_scene);
} else {
_scene->applyEvent("SceneShutdown", true);
@@ -287,13 +287,13 @@ bool CAdGame::changeScene(const char *filename, bool fadeIn) { //////////////////////////////////////////////////////////////////////////
-void CAdGame::addSentence(CAdSentence *sentence) {
+void AdGame::addSentence(AdSentence *sentence) {
_sentences.add(sentence);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::displaySentences(bool frozen) {
+bool AdGame::displaySentences(bool frozen) {
for (int i = 0; i < _sentences.getSize(); i++) {
if (frozen && _sentences[i]->_freezable) continue;
else _sentences[i]->display();
@@ -303,7 +303,7 @@ bool CAdGame::displaySentences(bool frozen) { //////////////////////////////////////////////////////////////////////////
-void CAdGame::finishSentences() {
+void AdGame::finishSentences() {
for (int i = 0; i < _sentences.getSize(); i++) {
if (_sentences[i]->CanSkip()) {
_sentences[i]->_duration = 0;
@@ -316,15 +316,15 @@ void CAdGame::finishSentences() { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdGame::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// ChangeScene
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "ChangeScene") == 0) {
stack->correctParams(3);
const char *filename = stack->pop()->getString();
- CScValue *valFadeOut = stack->pop();
- CScValue *valFadeIn = stack->pop();
+ ScValue *valFadeOut = stack->pop();
+ ScValue *valFadeIn = stack->pop();
bool transOut = valFadeOut->isNULL() ? true : valFadeOut->getBool();
bool transIn = valFadeIn->isNULL() ? true : valFadeIn->getBool();
@@ -346,7 +346,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "LoadActor") == 0) {
stack->correctParams(1);
- CAdActor *act = new CAdActor(_gameRef);
+ AdActor *act = new AdActor(_gameRef);
if (act && DID_SUCCEED(act->loadFile(stack->pop()->getString()))) {
addObject(act);
stack->pushNative(act, true);
@@ -363,7 +363,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "LoadEntity") == 0) {
stack->correctParams(1);
- CAdEntity *ent = new CAdEntity(_gameRef);
+ AdEntity *ent = new AdEntity(_gameRef);
if (ent && DID_SUCCEED(ent->loadFile(stack->pop()->getString()))) {
addObject(ent);
stack->pushNative(ent, true);
@@ -380,8 +380,8 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "UnloadObject") == 0 || strcmp(name, "UnloadActor") == 0 || strcmp(name, "UnloadEntity") == 0 || strcmp(name, "DeleteEntity") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
- CAdObject *obj = (CAdObject *)val->getNative();
+ ScValue *val = stack->pop();
+ AdObject *obj = (AdObject *)val->getNative();
removeObject(obj);
if (val->getType() == VAL_VARIABLE_REF) val->setNULL();
@@ -394,9 +394,9 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "CreateEntity") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdEntity *ent = new CAdEntity(_gameRef);
+ AdEntity *ent = new AdEntity(_gameRef);
addObject(ent);
if (!val->isNULL()) ent->setName(val->getString());
stack->pushNative(ent, true);
@@ -408,9 +408,9 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "CreateItem") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdItem *item = new CAdItem(_gameRef);
+ AdItem *item = new AdItem(_gameRef);
addItem(item);
if (!val->isNULL()) item->setName(val->getString());
stack->pushNative(item, true);
@@ -422,10 +422,10 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DeleteItem") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdItem *item = NULL;
- if (val->isNative()) item = (CAdItem *)val->getNative();
+ AdItem *item = NULL;
+ if (val->isNative()) item = (AdItem *)val->getNative();
else item = getItemByName(val->getString());
if (item) {
@@ -441,9 +441,9 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "QueryItem") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdItem *item = NULL;
+ AdItem *item = NULL;
if (val->isInt()) {
int index = val->getInt();
if (index >= 0 && index < _items.getSize()) item = _items[index];
@@ -465,13 +465,13 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta stack->correctParams(6);
int id = stack->pop()->getInt();
const char *text = stack->pop()->getString();
- CScValue *val1 = stack->pop();
- CScValue *val2 = stack->pop();
- CScValue *val3 = stack->pop();
- CScValue *val4 = stack->pop();
+ ScValue *val1 = stack->pop();
+ ScValue *val2 = stack->pop();
+ ScValue *val3 = stack->pop();
+ ScValue *val4 = stack->pop();
if (_responseBox) {
- CAdResponse *res = new CAdResponse(_gameRef);
+ AdResponse *res = new AdResponse(_gameRef);
if (res) {
res->_iD = id;
res->setText(text);
@@ -573,7 +573,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "StartDlgBranch") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
Common::String branchName;
if (val->isNULL()) {
branchName.format("line%d", script->_currentLine);
@@ -592,7 +592,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta stack->correctParams(1);
const char *branchName = NULL;
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (!val->isNULL()) branchName = val->getString();
endDlgBranch(branchName, script->_filename == NULL ? "" : script->_filename, script->_threadEvent == NULL ? "" : script->_threadEvent);
@@ -648,10 +648,10 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta else if (strcmp(name, "IsItemTaken") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (!val->isNULL()) {
for (int i = 0; i < _inventories.getSize(); i++) {
- CAdInventory *Inv = _inventories[i];
+ AdInventory *Inv = _inventories[i];
for (int j = 0; j < Inv->_takenItems.getSize(); j++) {
if (val->getNative() == Inv->_takenItems[j]) {
@@ -703,7 +703,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta const char *filename = stack->pop()->getString();
_gameRef->unregisterObject(_responseBox);
- _responseBox = new CAdResponseBox(_gameRef);
+ _responseBox = new AdResponseBox(_gameRef);
if (_responseBox && !DID_FAIL(_responseBox->loadFile(filename))) {
registerObject(_responseBox);
stack->pushBool(true);
@@ -723,7 +723,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta const char *filename = stack->pop()->getString();
_gameRef->unregisterObject(_inventoryBox);
- _inventoryBox = new CAdInventoryBox(_gameRef);
+ _inventoryBox = new AdInventoryBox(_gameRef);
if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile(filename))) {
registerObject(_inventoryBox);
stack->pushBool(true);
@@ -784,7 +784,7 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta if (width <= 0) width = _renderer->_width;
if (height <= 0) height = _renderer->_height;
- if (!_sceneViewport) _sceneViewport = new CBViewport(_gameRef);
+ if (!_sceneViewport) _sceneViewport = new BaseViewport(_gameRef);
if (_sceneViewport) _sceneViewport->setRect(x, y, x + width, y + height);
stack->pushBool(true);
@@ -793,12 +793,12 @@ bool CAdGame::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta }
- else return CBGame::scCallMethod(script, stack, thisStack, name);
+ else return BaseGame::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdGame::scGetProperty(const char *name) {
+ScValue *AdGame::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -947,12 +947,12 @@ CScValue *CAdGame::scGetProperty(const char *name) { return _scValue;
}
- else return CBGame::scGetProperty(name);
+ else return BaseGame::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::scSetProperty(const char *name, CScValue *value) {
+bool AdGame::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// SelectedItem
@@ -964,7 +964,7 @@ bool CAdGame::scSetProperty(const char *name, CScValue *value) { _selectedItem = NULL;
for (int i = 0; i < _items.getSize(); i++) {
if (_items[i] == value->getNative()) {
- _selectedItem = (CAdItem *)value->getNative();
+ _selectedItem = (AdItem *)value->getNative();
break;
}
}
@@ -1001,9 +1001,9 @@ bool CAdGame::scSetProperty(const char *name, CScValue *value) { if (value->isNULL()) _inventoryOwner = _invObject;
else {
- CBObject *Obj = (CBObject *)value->getNative();
+ BaseObject *Obj = (BaseObject *)value->getNative();
if (Obj == this) _inventoryOwner = _invObject;
- else if (_gameRef->validObject(Obj)) _inventoryOwner = (CAdObject *)Obj;
+ else if (_gameRef->validObject(Obj)) _inventoryOwner = (AdObject *)Obj;
}
if (_inventoryOwner && _inventoryBox) _inventoryBox->_scrollOffset = _inventoryOwner->getInventory()->_scrollOffset;
@@ -1037,18 +1037,18 @@ bool CAdGame::scSetProperty(const char *name, CScValue *value) { if (value == NULL) {
delete[] _startupScene;
_startupScene = NULL;
- } else CBUtils::setString(&_startupScene, value->getString());
+ } else BaseUtils::setString(&_startupScene, value->getString());
return STATUS_OK;
}
- else return CBGame::scSetProperty(name, value);
+ else return BaseGame::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::ExternalCall(CScScript *script, CScStack *stack, CScStack *thisStack, char *name) {
- CScValue *this_obj;
+bool AdGame::ExternalCall(ScScript *script, ScStack *stack, ScStack *thisStack, char *name) {
+ ScValue *this_obj;
//////////////////////////////////////////////////////////////////////////
// Actor
@@ -1057,7 +1057,7 @@ bool CAdGame::ExternalCall(CScScript *script, CScStack *stack, CScStack *thisSta stack->correctParams(0);
this_obj = thisStack->getTop();
- this_obj->setNative(new CAdActor(_gameRef));
+ this_obj->setNative(new AdActor(_gameRef));
stack->pushNULL();
}
@@ -1068,14 +1068,14 @@ bool CAdGame::ExternalCall(CScScript *script, CScStack *stack, CScStack *thisSta stack->correctParams(0);
this_obj = thisStack->getTop();
- this_obj->setNative(new CAdEntity(_gameRef));
+ this_obj->setNative(new AdEntity(_gameRef));
stack->pushNULL();
}
//////////////////////////////////////////////////////////////////////////
// call parent
- else return CBGame::ExternalCall(script, stack, thisStack, name);
+ else return BaseGame::ExternalCall(script, stack, thisStack, name);
return STATUS_OK;
@@ -1083,13 +1083,13 @@ bool CAdGame::ExternalCall(CScScript *script, CScStack *stack, CScStack *thisSta //////////////////////////////////////////////////////////////////////////
-bool CAdGame::showCursor() {
+bool AdGame::showCursor() {
if (_cursorHidden) return STATUS_OK;
if (_selectedItem && _gameRef->_state == GAME_RUNNING && _stateEx == GAME_NORMAL && _interactive) {
if (_selectedItem->_cursorCombined) {
- CBSprite *origLastCursor = _lastCursor;
- CBGame::showCursor();
+ BaseSprite *origLastCursor = _lastCursor;
+ BaseGame::showCursor();
_lastCursor = origLastCursor;
}
if (_activeObject && _selectedItem->_cursorHover && _activeObject->getExtendedFlag("usable")) {
@@ -1098,15 +1098,15 @@ bool CAdGame::showCursor() { else
return drawCursor(_selectedItem->_cursorNormal);
} else return drawCursor(_selectedItem->_cursorNormal);
- } else return CBGame::showCursor();
+ } else return BaseGame::showCursor();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::loadFile(const char *filename) {
+bool AdGame::loadFile(const char *filename) {
byte *buffer = _fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdGame::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdGame::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -1139,7 +1139,7 @@ TOKEN_DEF(STARTUP_SCENE) TOKEN_DEF(DEBUG_STARTUP_SCENE)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::loadBuffer(byte *buffer, bool complete) {
+bool AdGame::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(GAME)
TOKEN_TABLE(AD_GAME)
@@ -1156,14 +1156,14 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { byte *params;
byte *params2;
int cmd = 1;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
bool itemFound = false, itemsFound = false;
while (cmd > 0 && (cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_GAME:
- if (DID_FAIL(CBGame::loadBuffer(params, false))) cmd = PARSERR_GENERIC;
+ if (DID_FAIL(BaseGame::loadBuffer(params, false))) cmd = PARSERR_GENERIC;
break;
case TOKEN_AD_GAME:
@@ -1171,7 +1171,7 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { switch (cmd) {
case TOKEN_RESPONSE_BOX:
delete _responseBox;
- _responseBox = new CAdResponseBox(_gameRef);
+ _responseBox = new AdResponseBox(_gameRef);
if (_responseBox && !DID_FAIL(_responseBox->loadFile((char *)params2)))
registerObject(_responseBox);
else {
@@ -1183,7 +1183,7 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { case TOKEN_INVENTORY_BOX:
delete _inventoryBox;
- _inventoryBox = new CAdInventoryBox(_gameRef);
+ _inventoryBox = new AdInventoryBox(_gameRef);
if (_inventoryBox && !DID_FAIL(_inventoryBox->loadFile((char *)params2)))
registerObject(_inventoryBox);
else {
@@ -1195,7 +1195,7 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { case TOKEN_ITEMS:
itemsFound = true;
- CBUtils::setString(&_itemsFile, (char *)params2);
+ BaseUtils::setString(&_itemsFile, (char *)params2);
if (DID_FAIL(loadItemsFile(_itemsFile))) {
delete[] _itemsFile;
_itemsFile = NULL;
@@ -1212,7 +1212,7 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { case TOKEN_SCENE_VIEWPORT: {
Rect32 rc;
parser.scanStr((char *)params2, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
- if (!_sceneViewport) _sceneViewport = new CBViewport(_gameRef);
+ if (!_sceneViewport) _sceneViewport = new BaseViewport(_gameRef);
if (_sceneViewport) _sceneViewport->setRect(rc.left, rc.top, rc.right, rc.bottom);
}
break;
@@ -1222,11 +1222,11 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_STARTUP_SCENE:
- CBUtils::setString(&_startupScene, (char *)params2);
+ BaseUtils::setString(&_startupScene, (char *)params2);
break;
case TOKEN_DEBUG_STARTUP_SCENE:
- CBUtils::setString(&_debugStartupScene, (char *)params2);
+ BaseUtils::setString(&_debugStartupScene, (char *)params2);
break;
}
}
@@ -1252,9 +1252,9 @@ bool CAdGame::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::persist(CBPersistMgr *persistMgr) {
+bool AdGame::persist(BasePersistenceManager *persistMgr) {
if (!persistMgr->_saving) cleanup();
- CBGame::persist(persistMgr);
+ BaseGame::persist(persistMgr);
_dlgPendingBranches.persist(persistMgr);
@@ -1303,27 +1303,27 @@ bool CAdGame::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::loadGame(const char *filename) {
- bool ret = CBGame::loadGame(filename);
- if (DID_SUCCEED(ret)) CSysClassRegistry::getInstance()->enumInstances(afterLoadRegion, "CAdRegion", NULL);
+bool AdGame::loadGame(const char *filename) {
+ bool ret = BaseGame::loadGame(filename);
+ if (DID_SUCCEED(ret)) SystemClassRegistry::getInstance()->enumInstances(afterLoadRegion, "AdRegion", NULL);
return ret;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::initAfterLoad() {
- CBGame::initAfterLoad();
- CSysClassRegistry::getInstance()->enumInstances(afterLoadScene, "CAdScene", NULL);
+bool AdGame::initAfterLoad() {
+ BaseGame::initAfterLoad();
+ SystemClassRegistry::getInstance()->enumInstances(afterLoadScene, "AdScene", NULL);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-void CAdGame::afterLoadScene(void *scene, void *data) {
- ((CAdScene *)scene)->afterLoad();
+void AdGame::afterLoadScene(void *scene, void *data) {
+ ((AdScene *)scene)->afterLoad();
}
//////////////////////////////////////////////////////////////////////////
-void CAdGame::setPrevSceneName(const char *name) {
+void AdGame::setPrevSceneName(const char *name) {
delete[] _prevSceneName;
_prevSceneName = NULL;
if (name) {
@@ -1334,7 +1334,7 @@ void CAdGame::setPrevSceneName(const char *name) { //////////////////////////////////////////////////////////////////////////
-void CAdGame::setPrevSceneFilename(const char *name) {
+void AdGame::setPrevSceneFilename(const char *name) {
delete[] _prevSceneFilename;
_prevSceneFilename = NULL;
if (name) {
@@ -1345,7 +1345,7 @@ void CAdGame::setPrevSceneFilename(const char *name) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::scheduleChangeScene(const char *filename, bool fadeIn) {
+bool AdGame::scheduleChangeScene(const char *filename, bool fadeIn) {
delete[] _scheduledScene;
_scheduledScene = NULL;
@@ -1362,8 +1362,8 @@ bool CAdGame::scheduleChangeScene(const char *filename, bool fadeIn) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::getVersion(byte *verMajor, byte *verMinor, byte *extMajor, byte *extMinor) {
- CBGame::getVersion(verMajor, verMinor, NULL, NULL);
+bool AdGame::getVersion(byte *verMajor, byte *verMinor, byte *extMajor, byte *extMinor) {
+ BaseGame::getVersion(verMajor, verMinor, NULL, NULL);
if (extMajor) *extMajor = 0;
if (extMinor) *extMinor = 0;
@@ -1373,10 +1373,10 @@ bool CAdGame::getVersion(byte *verMajor, byte *verMinor, byte *extMajor, byte *e //////////////////////////////////////////////////////////////////////////
-bool CAdGame::loadItemsFile(const char *filename, bool merge) {
+bool AdGame::loadItemsFile(const char *filename, bool merge) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdGame::LoadItemsFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdGame::LoadItemsFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -1395,14 +1395,14 @@ bool CAdGame::loadItemsFile(const char *filename, bool merge) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::loadItemsBuffer(byte *buffer, bool merge) {
+bool AdGame::loadItemsBuffer(byte *buffer, bool merge) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ITEM)
TOKEN_TABLE_END
byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (!merge) {
while (_items.getSize() > 0) deleteItem(_items[0]);
@@ -1411,11 +1411,11 @@ bool CAdGame::loadItemsBuffer(byte *buffer, bool merge) { while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_ITEM: {
- CAdItem *item = new CAdItem(_gameRef);
+ AdItem *item = new AdItem(_gameRef);
if (item && !DID_FAIL(item->loadBuffer(params, false))) {
// delete item with the same name, if exists
if (merge) {
- CAdItem *PrevItem = getItemByName(item->_name);
+ AdItem *PrevItem = getItemByName(item->_name);
if (PrevItem) deleteItem(PrevItem);
}
addItem(item);
@@ -1443,7 +1443,7 @@ bool CAdGame::loadItemsBuffer(byte *buffer, bool merge) { //////////////////////////////////////////////////////////////////////////
-CAdSceneState *CAdGame::getSceneState(const char *filename, bool saving) {
+AdSceneState *AdGame::getSceneState(const char *filename, bool saving) {
char *filenameCor = new char[strlen(filename) + 1];
strcpy(filenameCor, filename);
for (uint32 i = 0; i < strlen(filenameCor); i++) {
@@ -1458,7 +1458,7 @@ CAdSceneState *CAdGame::getSceneState(const char *filename, bool saving) { }
if (saving) {
- CAdSceneState *ret = new CAdSceneState(_gameRef);
+ AdSceneState *ret = new AdSceneState(_gameRef);
ret->setFilename(filenameCor);
_sceneStates.add(ret);
@@ -1473,18 +1473,18 @@ CAdSceneState *CAdGame::getSceneState(const char *filename, bool saving) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::windowLoadHook(CUIWindow *win, char **buffer, char **params) {
+bool AdGame::windowLoadHook(UIWindow *win, char **buffer, char **params) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ENTITY_CONTAINER)
TOKEN_TABLE_END
int cmd = PARSERR_GENERIC;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
cmd = parser.getCommand(buffer, commands, params);
switch (cmd) {
case TOKEN_ENTITY_CONTAINER: {
- CUIEntity *ent = new CUIEntity(_gameRef);
+ UIEntity *ent = new UIEntity(_gameRef);
if (!ent || DID_FAIL(ent->loadBuffer((byte *)*params, false))) {
delete ent;
ent = NULL;
@@ -1507,12 +1507,12 @@ bool CAdGame::windowLoadHook(CUIWindow *win, char **buffer, char **params) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::windowScriptMethodHook(CUIWindow *win, CScScript *script, CScStack *stack, const char *name) {
+bool AdGame::windowScriptMethodHook(UIWindow *win, ScScript *script, ScStack *stack, const char *name) {
if (strcmp(name, "CreateEntityContainer") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CUIEntity *ent = new CUIEntity(_gameRef);
+ UIEntity *ent = new UIEntity(_gameRef);
if (!val->isNULL()) ent->setName(val->getString());
stack->pushNative(ent, true);
@@ -1525,7 +1525,7 @@ bool CAdGame::windowScriptMethodHook(CUIWindow *win, CScScript *script, CScStack //////////////////////////////////////////////////////////////////////////
-bool CAdGame::startDlgBranch(const char *branchName, const char *scriptName, const char *eventName) {
+bool AdGame::startDlgBranch(const char *branchName, const char *scriptName, const char *eventName) {
char *name = new char[strlen(branchName) + 1 + strlen(scriptName) + 1 + strlen(eventName) + 1];
if (name) {
sprintf(name, "%s.%s.%s", branchName, scriptName, eventName);
@@ -1536,7 +1536,7 @@ bool CAdGame::startDlgBranch(const char *branchName, const char *scriptName, con //////////////////////////////////////////////////////////////////////////
-bool CAdGame::endDlgBranch(const char *branchName, const char *scriptName, const char *eventName) {
+bool AdGame::endDlgBranch(const char *branchName, const char *scriptName, const char *eventName) {
char *name = NULL;
bool deleteName = false;
if (branchName == NULL && _dlgPendingBranches.getSize() > 0) {
@@ -1583,7 +1583,7 @@ bool CAdGame::endDlgBranch(const char *branchName, const char *scriptName, const //////////////////////////////////////////////////////////////////////////
-bool CAdGame::clearBranchResponses(char *name) {
+bool AdGame::clearBranchResponses(char *name) {
for (int i = 0; i < _responsesBranch.getSize(); i++) {
if (scumm_stricmp(name, _responsesBranch[i]->_context) == 0) {
delete _responsesBranch[i];
@@ -1596,9 +1596,9 @@ bool CAdGame::clearBranchResponses(char *name) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::addBranchResponse(int ID) {
+bool AdGame::addBranchResponse(int ID) {
if (branchResponseUsed(ID)) return STATUS_OK;
- CAdResponseContext *r = new CAdResponseContext(_gameRef);
+ AdResponseContext *r = new AdResponseContext(_gameRef);
r->_iD = ID;
r->setContext(_dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : NULL);
_responsesBranch.add(r);
@@ -1607,7 +1607,7 @@ bool CAdGame::addBranchResponse(int ID) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::branchResponseUsed(int ID) {
+bool AdGame::branchResponseUsed(int ID) {
char *Context = _dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : NULL;
for (int i = 0; i < _responsesBranch.getSize(); i++) {
if (_responsesBranch[i]->_iD == ID) {
@@ -1619,9 +1619,9 @@ bool CAdGame::branchResponseUsed(int ID) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::addGameResponse(int ID) {
+bool AdGame::addGameResponse(int ID) {
if (gameResponseUsed(ID)) return STATUS_OK;
- CAdResponseContext *r = new CAdResponseContext(_gameRef);
+ AdResponseContext *r = new AdResponseContext(_gameRef);
r->_iD = ID;
r->setContext(_dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : NULL);
_responsesGame.add(r);
@@ -1630,10 +1630,10 @@ bool CAdGame::addGameResponse(int ID) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::gameResponseUsed(int ID) {
+bool AdGame::gameResponseUsed(int ID) {
char *Context = _dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : NULL;
for (int i = 0; i < _responsesGame.getSize(); i++) {
- CAdResponseContext *RespContext = _responsesGame[i];
+ AdResponseContext *RespContext = _responsesGame[i];
if (RespContext->_iD == ID) {
if ((Context == NULL && RespContext->_context == NULL) || ((Context != NULL && RespContext->_context != NULL) && scumm_stricmp(Context, RespContext->_context) == 0)) return true;
}
@@ -1643,7 +1643,7 @@ bool CAdGame::gameResponseUsed(int ID) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::resetResponse(int ID) {
+bool AdGame::resetResponse(int ID) {
char *Context = _dlgPendingBranches.getSize() > 0 ? _dlgPendingBranches[_dlgPendingBranches.getSize() - 1] : NULL;
int i;
@@ -1672,7 +1672,7 @@ bool CAdGame::resetResponse(int ID) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::displayContent(bool doUpdate, bool displayAll) {
+bool AdGame::displayContent(bool doUpdate, bool displayAll) {
// init
if (doUpdate) initLoop();
@@ -1740,7 +1740,7 @@ bool CAdGame::displayContent(bool doUpdate, bool displayAll) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::registerInventory(CAdInventory *inv) {
+bool AdGame::registerInventory(AdInventory *inv) {
for (int i = 0; i < _inventories.getSize(); i++) {
if (_inventories[i] == inv) return STATUS_OK;
}
@@ -1751,7 +1751,7 @@ bool CAdGame::registerInventory(CAdInventory *inv) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::unregisterInventory(CAdInventory *inv) {
+bool AdGame::unregisterInventory(AdInventory *inv) {
for (int i = 0; i < _inventories.getSize(); i++) {
if (_inventories[i] == inv) {
unregisterObject(_inventories[i]);
@@ -1763,9 +1763,9 @@ bool CAdGame::unregisterInventory(CAdInventory *inv) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::isItemTaken(char *itemName) {
+bool AdGame::isItemTaken(char *itemName) {
for (int i = 0; i < _inventories.getSize(); i++) {
- CAdInventory *Inv = _inventories[i];
+ AdInventory *Inv = _inventories[i];
for (int j = 0; j < Inv->_takenItems.getSize(); j++) {
if (scumm_stricmp(itemName, Inv->_takenItems[j]->_name) == 0) {
@@ -1777,7 +1777,7 @@ bool CAdGame::isItemTaken(char *itemName) { }
//////////////////////////////////////////////////////////////////////////
-CAdItem *CAdGame::getItemByName(const char *name) {
+AdItem *AdGame::getItemByName(const char *name) {
for (int i = 0; i < _items.getSize(); i++) {
if (scumm_stricmp(_items[i]->_name, name) == 0) return _items[i];
}
@@ -1786,14 +1786,14 @@ CAdItem *CAdGame::getItemByName(const char *name) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::addItem(CAdItem *item) {
+bool AdGame::addItem(AdItem *item) {
_items.add(item);
return _gameRef->registerObject(item);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::resetContent() {
+bool AdGame::resetContent() {
// clear pending dialogs
for (int i = 0; i < _dlgPendingBranches.getSize(); i++) {
delete [] _dlgPendingBranches[i];
@@ -1823,12 +1823,12 @@ bool CAdGame::resetContent() { _tempDisableSaveState = true;
- return CBGame::resetContent();
+ return BaseGame::resetContent();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::deleteItem(CAdItem *item) {
+bool AdGame::deleteItem(AdItem *item) {
if (!item) return STATUS_FAILED;
if (_selectedItem == item) _selectedItem = NULL;
@@ -1853,7 +1853,7 @@ bool CAdGame::deleteItem(CAdItem *item) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::addSpeechDir(const char *dir) {
+bool AdGame::addSpeechDir(const char *dir) {
if (!dir || dir[0] == '\0') return STATUS_FAILED;
char *temp = new char[strlen(dir) + 2];
@@ -1874,7 +1874,7 @@ bool CAdGame::addSpeechDir(const char *dir) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::removeSpeechDir(const char *dir) {
+bool AdGame::removeSpeechDir(const char *dir) {
if (!dir || dir[0] == '\0') return STATUS_FAILED;
char *temp = new char[strlen(dir) + 2];
@@ -1899,7 +1899,7 @@ bool CAdGame::removeSpeechDir(const char *dir) { //////////////////////////////////////////////////////////////////////////
-char *CAdGame::findSpeechFile(char *stringID) {
+char *AdGame::findSpeechFile(char *stringID) {
char *ret = new char[MAX_PATH_LENGTH];
for (int i = 0; i < _speechDirs.getSize(); i++) {
@@ -1923,15 +1923,15 @@ char *CAdGame::findSpeechFile(char *stringID) { //////////////////////////////////////////////////////////////////////////
-bool CAdGame::validMouse() {
+bool AdGame::validMouse() {
Point32 pos;
- CBPlatform::getCursorPos(&pos);
+ BasePlatform::getCursorPos(&pos);
return _renderer->pointInViewport(&pos);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::onMouseLeftDown() {
+bool AdGame::onMouseLeftDown() {
if (!validMouse()) return STATUS_OK;
if (_state == GAME_RUNNING && !_interactive) {
if (_talkSkipButton == TALK_SKIP_LEFT || _talkSkipButton == TALK_SKIP_BOTH) {
@@ -1953,16 +1953,16 @@ bool CAdGame::onMouseLeftDown() { if (_activeObject != NULL) _gameRef->_capturedObject = _gameRef->_activeObject;
_mouseLeftDown = true;
- CBPlatform::setCapture(/*_renderer->_window*/);
+ BasePlatform::setCapture(/*_renderer->_window*/);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::onMouseLeftUp() {
+bool AdGame::onMouseLeftUp() {
if (_activeObject) _activeObject->handleMouse(MOUSE_RELEASE, MOUSE_BUTTON_LEFT);
- CBPlatform::releaseCapture();
+ BasePlatform::releaseCapture();
_capturedObject = NULL;
_mouseLeftDown = false;
@@ -1978,7 +1978,7 @@ bool CAdGame::onMouseLeftUp() { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::onMouseLeftDblClick() {
+bool AdGame::onMouseLeftDblClick() {
if (!validMouse()) return STATUS_OK;
if (_state == GAME_RUNNING && !_interactive) return STATUS_OK;
@@ -1997,7 +1997,7 @@ bool CAdGame::onMouseLeftDblClick() { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::onMouseRightDown() {
+bool AdGame::onMouseRightDown() {
if (!validMouse()) return STATUS_OK;
if (_state == GAME_RUNNING && !_interactive) {
if (_talkSkipButton == TALK_SKIP_RIGHT || _talkSkipButton == TALK_SKIP_BOTH) {
@@ -2022,7 +2022,7 @@ bool CAdGame::onMouseRightDown() { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::onMouseRightUp() {
+bool AdGame::onMouseRightUp() {
if (_activeObject) _activeObject->handleMouse(MOUSE_RELEASE, MOUSE_BUTTON_RIGHT);
bool handled = _state == GAME_RUNNING && DID_SUCCEED(applyEvent("RightRelease"));
@@ -2037,7 +2037,7 @@ bool CAdGame::onMouseRightUp() { }
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::displayDebugInfo() {
+bool AdGame::displayDebugInfo() {
char str[100];
if (_gameRef->_debugDebugMode) {
sprintf(str, "Mouse: %d, %d (scene: %d, %d)", _mousePos.x, _mousePos.y, _mousePos.x + _scene->getOffsetLeft(), _mousePos.y + _scene->getOffsetTop());
@@ -2046,12 +2046,12 @@ bool CAdGame::displayDebugInfo() { sprintf(str, "Scene: %s (prev: %s)", (_scene && _scene->_name) ? _scene->_name : "???", _prevSceneName ? _prevSceneName : "???");
_systemFont->drawText((byte *)str, 0, 110, _renderer->_width, TAL_RIGHT);
}
- return CBGame::displayDebugInfo();
+ return BaseGame::displayDebugInfo();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdGame::onScriptShutdown(CScScript *script) {
+bool AdGame::onScriptShutdown(ScScript *script) {
if (_responseBox && _responseBox->_waitingScript == script)
_responseBox->_waitingScript = NULL;
diff --git a/engines/wintermute/ad/ad_game.h b/engines/wintermute/ad/ad_game.h index 09b3e09df0..b52fd2832f 100644 --- a/engines/wintermute/ad/ad_game.h +++ b/engines/wintermute/ad/ad_game.h @@ -32,19 +32,19 @@ #include "engines/wintermute/base/base_game.h"
namespace WinterMute {
-class CAdItem;
-class CAdInventory;
-class CAdSceneState;
-class CAdScene;
-class CAdItem;
-class CAdObject;
-class CAdSentence;
-class CAdInventoryBox;
-class CAdResponseContext;
-class CAdResponseBox;
-class CAdGame : public CBGame {
+class AdItem;
+class AdInventory;
+class AdSceneState;
+class AdScene;
+class AdItem;
+class AdObject;
+class AdSentence;
+class AdInventoryBox;
+class AdResponseContext;
+class AdResponseBox;
+class AdGame : public BaseGame {
public:
- virtual bool onScriptShutdown(CScScript *script);
+ virtual bool onScriptShutdown(ScScript *script);
virtual bool onMouseLeftDown();
virtual bool onMouseLeftUp();
@@ -60,25 +60,25 @@ public: bool _smartItemCursor;
- CBArray<char *, char *> _speechDirs;
+ BaseArray<char *, char *> _speechDirs;
bool addSpeechDir(const char *dir);
bool removeSpeechDir(const char *dir);
char *findSpeechFile(char *StringID);
- bool deleteItem(CAdItem *Item);
+ bool deleteItem(AdItem *Item);
char *_itemsFile;
bool _tempDisableSaveState;
virtual bool resetContent();
- bool addItem(CAdItem *item);
- CAdItem *getItemByName(const char *name);
- CBArray<CAdItem *, CAdItem *> _items;
- CAdObject *_inventoryOwner;
+ bool addItem(AdItem *item);
+ AdItem *getItemByName(const char *name);
+ BaseArray<AdItem *, AdItem *> _items;
+ AdObject *_inventoryOwner;
bool isItemTaken(char *itemName);
- bool registerInventory(CAdInventory *inv);
- bool unregisterInventory(CAdInventory *inv);
+ bool registerInventory(AdInventory *inv);
+ bool unregisterInventory(AdInventory *inv);
- CAdObject *_invObject;
- CBArray<CAdInventory *, CAdInventory *> _inventories;
+ AdObject *_invObject;
+ BaseArray<AdInventory *, AdInventory *> _inventories;
virtual bool displayContent(bool update = true, bool displayAll = false);
char *_debugStartupScene;
char *_startupScene;
@@ -92,11 +92,11 @@ public: bool clearBranchResponses(char *name);
bool startDlgBranch(const char *branchName, const char *scriptName, const char *eventName);
bool endDlgBranch(const char *branchName, const char *scriptName, const char *eventName);
- virtual bool windowLoadHook(CUIWindow *win, char **buf, char **params);
- virtual bool windowScriptMethodHook(CUIWindow *win, CScScript *script, CScStack *stack, const char *name);
+ virtual bool windowLoadHook(UIWindow *win, char **buf, char **params);
+ virtual bool windowScriptMethodHook(UIWindow *win, ScScript *script, ScStack *stack, const char *name);
- CAdSceneState *getSceneState(const char *filename, bool saving);
- CBViewport *_sceneViewport;
+ AdSceneState *getSceneState(const char *filename, bool saving);
+ BaseViewport *_sceneViewport;
int _texItemLifeTime;
int _texWalkLifeTime;
int _texStandLifeTime;
@@ -113,32 +113,32 @@ public: char *_prevSceneName;
char *_prevSceneFilename;
virtual bool loadGame(const char *filename);
- CAdItem *_selectedItem;
+ AdItem *_selectedItem;
bool cleanup();
- DECLARE_PERSISTENT(CAdGame, CBGame)
+ DECLARE_PERSISTENT(AdGame, BaseGame)
void finishSentences();
bool showCursor();
TGameStateEx _stateEx;
- CAdResponseBox *_responseBox;
- CAdInventoryBox *_inventoryBox;
+ AdResponseBox *_responseBox;
+ AdInventoryBox *_inventoryBox;
bool displaySentences(bool frozen);
- void addSentence(CAdSentence *sentence);
+ void addSentence(AdSentence *sentence);
bool changeScene(const char *filename, bool fadeIn);
- bool removeObject(CAdObject *object);
- bool addObject(CAdObject *object);
- CAdScene *_scene;
+ bool removeObject(AdObject *object);
+ bool addObject(AdObject *object);
+ AdScene *_scene;
bool initLoop();
- CAdGame();
- virtual ~CAdGame();
- CBArray<CAdObject *, CAdObject *> _objects;
- CBArray<CAdSentence *, CAdSentence *> _sentences;
+ AdGame();
+ virtual ~AdGame();
+ BaseArray<AdObject *, AdObject *> _objects;
+ BaseArray<AdSentence *, AdSentence *> _sentences;
- CBArray<CAdSceneState *, CAdSceneState *> _sceneStates;
- CBArray<char *, char *> _dlgPendingBranches;
+ BaseArray<AdSceneState *, AdSceneState *> _sceneStates;
+ BaseArray<char *, char *> _dlgPendingBranches;
- CBArray<CAdResponseContext *, CAdResponseContext *> _responsesBranch;
- CBArray<CAdResponseContext *, CAdResponseContext *> _responsesGame;
+ BaseArray<AdResponseContext *, AdResponseContext *> _responsesBranch;
+ BaseArray<AdResponseContext *, AdResponseContext *> _responsesGame;
virtual bool loadFile(const char *filename);
virtual bool loadBuffer(byte *buffer, bool complete = true);
@@ -147,12 +147,12 @@ public: bool loadItemsBuffer(byte *buffer, bool merge = false);
- virtual bool ExternalCall(CScScript *script, CScStack *stack, CScStack *thisStack, char *name);
+ virtual bool ExternalCall(ScScript *script, ScStack *stack, ScStack *thisStack, char *name);
// 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);
bool validMouse();
};
diff --git a/engines/wintermute/ad/ad_inventory.cpp b/engines/wintermute/ad/ad_inventory.cpp index cfbc9e5029..fd56eef419 100644 --- a/engines/wintermute/ad/ad_inventory.cpp +++ b/engines/wintermute/ad/ad_inventory.cpp @@ -34,25 +34,25 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdInventory, false)
+IMPLEMENT_PERSISTENT(AdInventory, false)
//////////////////////////////////////////////////////////////////////////
-CAdInventory::CAdInventory(CBGame *inGame): CBObject(inGame) {
+AdInventory::AdInventory(BaseGame *inGame): BaseObject(inGame) {
_scrollOffset = 0;
}
//////////////////////////////////////////////////////////////////////////
-CAdInventory::~CAdInventory() {
+AdInventory::~AdInventory() {
_takenItems.removeAll(); // ref only
}
//////////////////////////////////////////////////////////////////////////
-bool CAdInventory::insertItem(const char *name, const char *insertAfter) {
+bool AdInventory::insertItem(const char *name, const char *insertAfter) {
if (name == NULL) return STATUS_FAILED;
- CAdItem *item = ((CAdGame *)_gameRef)->getItemByName(name);
+ AdItem *item = ((AdGame *)_gameRef)->getItemByName(name);
if (item == NULL) return STATUS_FAILED;
int insertIndex = -1;
@@ -74,12 +74,12 @@ bool CAdInventory::insertItem(const char *name, const char *insertAfter) { //////////////////////////////////////////////////////////////////////////
-bool CAdInventory::removeItem(const char *name) {
+bool AdInventory::removeItem(const char *name) {
if (name == NULL) return STATUS_FAILED;
for (int i = 0; i < _takenItems.getSize(); i++) {
if (scumm_stricmp(_takenItems[i]->_name, name) == 0) {
- if (((CAdGame *)_gameRef)->_selectedItem == _takenItems[i])((CAdGame *)_gameRef)->_selectedItem = NULL;
+ if (((AdGame *)_gameRef)->_selectedItem == _takenItems[i])((AdGame *)_gameRef)->_selectedItem = NULL;
_takenItems.removeAt(i);
return STATUS_OK;
}
@@ -91,12 +91,12 @@ bool CAdInventory::removeItem(const char *name) { //////////////////////////////////////////////////////////////////////////
-bool CAdInventory::removeItem(CAdItem *item) {
+bool AdInventory::removeItem(AdItem *item) {
if (item == NULL) return STATUS_FAILED;
for (int i = 0; i < _takenItems.getSize(); i++) {
if (_takenItems[i] == item) {
- if (((CAdGame *)_gameRef)->_selectedItem == _takenItems[i])((CAdGame *)_gameRef)->_selectedItem = NULL;
+ if (((AdGame *)_gameRef)->_selectedItem == _takenItems[i])((AdGame *)_gameRef)->_selectedItem = NULL;
_takenItems.removeAt(i);
return STATUS_OK;
}
@@ -106,9 +106,9 @@ bool CAdInventory::removeItem(CAdItem *item) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdInventory::persist(CBPersistMgr *persistMgr) {
+bool AdInventory::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
_takenItems.persist(persistMgr);
persistMgr->transfer(TMEMBER(_scrollOffset));
diff --git a/engines/wintermute/ad/ad_inventory.h b/engines/wintermute/ad/ad_inventory.h index 84d9308d5d..6f7537633d 100644 --- a/engines/wintermute/ad/ad_inventory.h +++ b/engines/wintermute/ad/ad_inventory.h @@ -33,17 +33,17 @@ namespace WinterMute {
-class CAdItem;
+class AdItem;
-class CAdInventory : public CBObject {
+class AdInventory : public BaseObject {
public:
- DECLARE_PERSISTENT(CAdInventory, CBObject)
+ DECLARE_PERSISTENT(AdInventory, BaseObject)
bool removeItem(const char *name);
- bool removeItem(CAdItem *Item);
+ bool removeItem(AdItem *Item);
bool insertItem(const char *name, const char *insertAfter = NULL);
- CAdInventory(CBGame *inGame);
- virtual ~CAdInventory();
- CBArray<CAdItem *, CAdItem *> _takenItems;
+ AdInventory(BaseGame *inGame);
+ virtual ~AdInventory();
+ BaseArray<AdItem *, AdItem *> _takenItems;
int _scrollOffset;
};
diff --git a/engines/wintermute/ad/ad_inventory_box.cpp b/engines/wintermute/ad/ad_inventory_box.cpp index abe8676376..f835dd22d4 100644 --- a/engines/wintermute/ad/ad_inventory_box.cpp +++ b/engines/wintermute/ad/ad_inventory_box.cpp @@ -43,10 +43,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdInventoryBox, false)
+IMPLEMENT_PERSISTENT(AdInventoryBox, false)
//////////////////////////////////////////////////////////////////////////
-CAdInventoryBox::CAdInventoryBox(CBGame *inGame): CBObject(inGame) {
+AdInventoryBox::AdInventoryBox(BaseGame *inGame): BaseObject(inGame) {
_itemsArea.setEmpty();
_scrollOffset = 0;
_spacing = 0;
@@ -64,7 +64,7 @@ CAdInventoryBox::CAdInventoryBox(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdInventoryBox::~CAdInventoryBox() {
+AdInventoryBox::~AdInventoryBox() {
_gameRef->unregisterObject(_window);
_window = NULL;
@@ -74,8 +74,8 @@ CAdInventoryBox::~CAdInventoryBox() { //////////////////////////////////////////////////////////////////////////
-bool CAdInventoryBox::listen(CBScriptHolder *param1, uint32 param2) {
- CUIObject *obj = (CUIObject *)param1;
+bool AdInventoryBox::listen(BaseScriptHolder *param1, uint32 param2) {
+ UIObject *obj = (UIObject *)param1;
switch (obj->_type) {
case UI_BUTTON:
@@ -86,10 +86,10 @@ bool CAdInventoryBox::listen(CBScriptHolder *param1, uint32 param2) { _scrollOffset = MAX(_scrollOffset, 0);
} else if (scumm_stricmp(obj->_name, "next") == 0) {
_scrollOffset += _scrollBy;
- } else return CBObject::listen(param1, param2);
+ } else return BaseObject::listen(param1, param2);
break;
default:
- error("CAdInventoryBox::Listen - Unhandled enum");
+ error("AdInventoryBox::Listen - Unhandled enum");
break;
}
@@ -98,8 +98,8 @@ bool CAdInventoryBox::listen(CBScriptHolder *param1, uint32 param2) { //////////////////////////////////////////////////////////////////////////
-bool CAdInventoryBox::display() {
- CAdGame *adGame = (CAdGame *)_gameRef;
+bool AdInventoryBox::display() {
+ AdGame *adGame = (AdGame *)_gameRef;
if (!_visible) return STATUS_OK;
@@ -137,8 +137,8 @@ bool CAdInventoryBox::display() { for (int i = 0; i < itemsX; i++) {
int itemIndex = _scrollOffset + j * itemsX + i;
if (itemIndex >= 0 && itemIndex < adGame->_inventoryOwner->getInventory()->_takenItems.getSize()) {
- CAdItem *item = adGame->_inventoryOwner->getInventory()->_takenItems[itemIndex];
- if (item != ((CAdGame *)_gameRef)->_selectedItem || !_hideSelected) {
+ AdItem *item = adGame->_inventoryOwner->getInventory()->_takenItems[itemIndex];
+ if (item != ((AdGame *)_gameRef)->_selectedItem || !_hideSelected) {
item->update();
item->display(xxx, yyy);
}
@@ -155,10 +155,10 @@ bool CAdInventoryBox::display() { //////////////////////////////////////////////////////////////////////////
-bool CAdInventoryBox::loadFile(const char *filename) {
+bool AdInventoryBox::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdInventoryBox::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdInventoryBox::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -193,7 +193,7 @@ TOKEN_DEF(HIDE_SELECTED) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdInventoryBox::loadBuffer(byte *buffer, bool complete) {
+bool AdInventoryBox::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(INVENTORY_BOX)
TOKEN_TABLE(TEMPLATE)
@@ -213,7 +213,7 @@ bool CAdInventoryBox::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd = 2;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
bool always_visible = false;
_exclusive = false;
@@ -241,7 +241,7 @@ bool CAdInventoryBox::loadBuffer(byte *buffer, bool complete) { case TOKEN_WINDOW:
delete _window;
- _window = new CUIWindow(_gameRef);
+ _window = new UIWindow(_gameRef);
if (!_window || DID_FAIL(_window->loadBuffer(params, false))) {
delete _window;
_window = NULL;
@@ -297,7 +297,7 @@ bool CAdInventoryBox::loadBuffer(byte *buffer, bool complete) { if (_exclusive) {
delete _closeButton;
- _closeButton = new CUIButton(_gameRef);
+ _closeButton = new UIButton(_gameRef);
if (_closeButton) {
_closeButton->setName("close");
_closeButton->setListener(this, _closeButton, 0);
@@ -318,7 +318,7 @@ bool CAdInventoryBox::loadBuffer(byte *buffer, bool complete) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdInventoryBox::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdInventoryBox::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "INVENTORY_BOX\n");
buffer->putTextIndent(indent, "{\n");
@@ -343,7 +343,7 @@ bool CAdInventoryBox::saveAsText(CBDynBuffer *buffer, int indent) { buffer->putTextIndent(indent + 2, "\n");
// editor properties
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
return STATUS_OK;
@@ -351,8 +351,8 @@ bool CAdInventoryBox::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdInventoryBox::persist(CBPersistMgr *persistMgr) {
- CBObject::persist(persistMgr);
+bool AdInventoryBox::persist(BasePersistenceManager *persistMgr) {
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_closeButton));
persistMgr->transfer(TMEMBER(_hideSelected));
diff --git a/engines/wintermute/ad/ad_inventory_box.h b/engines/wintermute/ad/ad_inventory_box.h index 09d3ef409e..dfbf62be9a 100644 --- a/engines/wintermute/ad/ad_inventory_box.h +++ b/engines/wintermute/ad/ad_inventory_box.h @@ -33,30 +33,30 @@ #include "common/rect.h"
namespace WinterMute {
-class CUIButton;
-class CUIWindow;
+class UIButton;
+class UIWindow;
-class CAdInventoryBox : public CBObject {
+class AdInventoryBox : public BaseObject {
public:
bool _hideSelected;
- DECLARE_PERSISTENT(CAdInventoryBox, CBObject)
+ DECLARE_PERSISTENT(AdInventoryBox, BaseObject)
bool _exclusive;
int _scrollBy;
int _itemHeight;
int _itemWidth;
bool _visible;
virtual bool display();
- CUIButton *_closeButton;
+ UIButton *_closeButton;
int _spacing;
int _scrollOffset;
Rect32 _itemsArea;
- bool listen(CBScriptHolder *param1, uint32 param2);
- CUIWindow *_window;
- CAdInventoryBox(CBGame *inGame);
- virtual ~CAdInventoryBox();
+ bool listen(BaseScriptHolder *param1, uint32 param2);
+ UIWindow *_window;
+ AdInventoryBox(BaseGame *inGame);
+ virtual ~AdInventoryBox();
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_item.cpp b/engines/wintermute/ad/ad_item.cpp index 9c49a86bcb..781b924513 100644 --- a/engines/wintermute/ad/ad_item.cpp +++ b/engines/wintermute/ad/ad_item.cpp @@ -46,10 +46,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdItem, false)
+IMPLEMENT_PERSISTENT(AdItem, false)
//////////////////////////////////////////////////////////////////////////
-CAdItem::CAdItem(CBGame *inGame): CAdTalkHolder(inGame) {
+AdItem::AdItem(BaseGame *inGame): AdTalkHolder(inGame) {
_spriteHover = NULL;
_cursorNormal = _cursorHover = NULL;
@@ -70,7 +70,7 @@ CAdItem::CAdItem(CBGame *inGame): CAdTalkHolder(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdItem::~CAdItem() {
+AdItem::~AdItem() {
delete _spriteHover;
delete _cursorNormal;
delete _cursorHover;
@@ -84,10 +84,10 @@ CAdItem::~CAdItem() { //////////////////////////////////////////////////////////////////////////
-bool CAdItem::loadFile(const char *filename) {
+bool AdItem::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdItem::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdItem::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -134,7 +134,7 @@ TOKEN_DEF(AMOUNT_STRING) TOKEN_DEF(AMOUNT)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdItem::loadBuffer(byte *buffer, bool complete) {
+bool AdItem::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ITEM)
TOKEN_TABLE(TEMPLATE)
@@ -166,7 +166,7 @@ bool CAdItem::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd = 2;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ITEM) {
@@ -198,8 +198,8 @@ bool CAdItem::loadBuffer(byte *buffer, bool complete) { case TOKEN_IMAGE:
case TOKEN_SPRITE:
delete _sprite;
- _sprite = new CBSprite(_gameRef, this);
- if (!_sprite || DID_FAIL(_sprite->loadFile((char *)params, ((CAdGame *)_gameRef)->_texItemLifeTime))) {
+ _sprite = new BaseSprite(_gameRef, this);
+ if (!_sprite || DID_FAIL(_sprite->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
delete _sprite;
cmd = PARSERR_GENERIC;
}
@@ -208,8 +208,8 @@ bool CAdItem::loadBuffer(byte *buffer, bool complete) { case TOKEN_IMAGE_HOVER:
case TOKEN_SPRITE_HOVER:
delete _spriteHover;
- _spriteHover = new CBSprite(_gameRef, this);
- if (!_spriteHover || DID_FAIL(_spriteHover->loadFile((char *)params, ((CAdGame *)_gameRef)->_texItemLifeTime))) {
+ _spriteHover = new BaseSprite(_gameRef, this);
+ if (!_spriteHover || DID_FAIL(_spriteHover->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
delete _spriteHover;
cmd = PARSERR_GENERIC;
}
@@ -238,27 +238,27 @@ bool CAdItem::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_AMOUNT_STRING:
- CBUtils::setString(&_amountString, (char *)params);
+ BaseUtils::setString(&_amountString, (char *)params);
break;
case TOKEN_TALK: {
- CBSprite *spr = new CBSprite(_gameRef, this);
- if (!spr || DID_FAIL(spr->loadFile((char *)params, ((CAdGame *)_gameRef)->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
+ if (!spr || DID_FAIL(spr->loadFile((char *)params, ((AdGame *)_gameRef)->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
else _talkSprites.add(spr);
}
break;
case TOKEN_TALK_SPECIAL: {
- CBSprite *spr = new CBSprite(_gameRef, this);
- if (!spr || DID_FAIL(spr->loadFile((char *)params, ((CAdGame *)_gameRef)->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
+ if (!spr || DID_FAIL(spr->loadFile((char *)params, ((AdGame *)_gameRef)->_texTalkLifeTime))) cmd = PARSERR_GENERIC;
else _talkSpritesEx.add(spr);
}
break;
case TOKEN_CURSOR:
delete _cursorNormal;
- _cursorNormal = new CBSprite(_gameRef);
- if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile((char *)params, ((CAdGame *)_gameRef)->_texItemLifeTime))) {
+ _cursorNormal = new BaseSprite(_gameRef);
+ if (!_cursorNormal || DID_FAIL(_cursorNormal->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
delete _cursorNormal;
_cursorNormal = NULL;
cmd = PARSERR_GENERIC;
@@ -267,8 +267,8 @@ bool CAdItem::loadBuffer(byte *buffer, bool complete) { case TOKEN_CURSOR_HOVER:
delete _cursorHover;
- _cursorHover = new CBSprite(_gameRef);
- if (!_cursorHover || DID_FAIL(_cursorHover->loadFile((char *)params, ((CAdGame *)_gameRef)->_texItemLifeTime))) {
+ _cursorHover = new BaseSprite(_gameRef);
+ if (!_cursorHover || DID_FAIL(_cursorHover->loadFile((char *)params, ((AdGame *)_gameRef)->_texItemLifeTime))) {
delete _cursorHover;
_cursorHover = NULL;
cmd = PARSERR_GENERIC;
@@ -319,7 +319,7 @@ bool CAdItem::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdItem::update() {
+bool AdItem::update() {
_currentSprite = NULL;
if (_state == STATE_READY && _animSprite) {
@@ -369,11 +369,11 @@ bool CAdItem::update() { _tempSprite2->reset();
_currentSprite = _tempSprite2;
}
- ((CAdGame *)_gameRef)->addSentence(_sentence);
+ ((AdGame *)_gameRef)->addSentence(_sentence);
}
} else {
_currentSprite = _tempSprite2;
- ((CAdGame *)_gameRef)->addSentence(_sentence);
+ ((AdGame *)_gameRef)->addSentence(_sentence);
}
}
default:
@@ -386,7 +386,7 @@ bool CAdItem::update() { //////////////////////////////////////////////////////////////////////////
-bool CAdItem::display(int x, int y) {
+bool AdItem::display(int x, int y) {
int width = 0;
if (_currentSprite) {
Rect32 rc;
@@ -412,7 +412,7 @@ bool CAdItem::display(int x, int y) { }
amountX += _amountOffsetX;
- CBFont *font = _font ? _font : _gameRef->_systemFont;
+ BaseFont *font = _font ? _font : _gameRef->_systemFont;
if (font) {
if (_amountString) font->drawText((byte *)_amountString, amountX, amountY, width, _amountAlign);
else {
@@ -430,7 +430,7 @@ bool CAdItem::display(int x, int y) { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdItem::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdItem::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// SetHoverSprite
//////////////////////////////////////////////////////////////////////////
@@ -444,7 +444,7 @@ bool CAdItem::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta delete _spriteHover;
_spriteHover = NULL;
- CBSprite *spr = new CBSprite(_gameRef, this);
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
stack->pushBool(false);
script->runtimeError("Item.SetHoverSprite failed for file '%s'", filename);
@@ -487,7 +487,7 @@ bool CAdItem::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta delete _cursorNormal;
_cursorNormal = NULL;
- CBSprite *spr = new CBSprite(_gameRef);
+ BaseSprite *spr = new BaseSprite(_gameRef);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
stack->pushBool(false);
script->runtimeError("Item.SetNormalCursor failed for file '%s'", filename);
@@ -530,7 +530,7 @@ bool CAdItem::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta delete _cursorHover;
_cursorHover = NULL;
- CBSprite *spr = new CBSprite(_gameRef);
+ BaseSprite *spr = new BaseSprite(_gameRef);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
stack->pushBool(false);
script->runtimeError("Item.SetHoverCursor failed for file '%s'", filename);
@@ -563,12 +563,12 @@ bool CAdItem::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSta return STATUS_OK;
}
- else return CAdTalkHolder::scCallMethod(script, stack, thisStack, name);
+ else return AdTalkHolder::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdItem::scGetProperty(const char *name) {
+ScValue *AdItem::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -644,12 +644,12 @@ CScValue *CAdItem::scGetProperty(const char *name) { return _scValue;
}
- else return CAdTalkHolder::scGetProperty(name);
+ else return AdTalkHolder::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdItem::scSetProperty(const char *name, CScValue *value) {
+bool AdItem::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Name
//////////////////////////////////////////////////////////////////////////
@@ -706,7 +706,7 @@ bool CAdItem::scSetProperty(const char *name, CScValue *value) { delete[] _amountString;
_amountString = NULL;
} else {
- CBUtils::setString(&_amountString, value->getString());
+ BaseUtils::setString(&_amountString, value->getString());
}
return STATUS_OK;
}
@@ -719,20 +719,20 @@ bool CAdItem::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CAdTalkHolder::scSetProperty(name, value);
+ else return AdTalkHolder::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdItem::scToString() {
+const char *AdItem::scToString() {
return "[item]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdItem::persist(CBPersistMgr *persistMgr) {
+bool AdItem::persist(BasePersistenceManager *persistMgr) {
- CAdTalkHolder::persist(persistMgr);
+ AdTalkHolder::persist(persistMgr);
persistMgr->transfer(TMEMBER(_cursorCombined));
persistMgr->transfer(TMEMBER(_cursorHover));
@@ -751,10 +751,10 @@ bool CAdItem::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdItem::getExtendedFlag(const char *flagName) {
+bool AdItem::getExtendedFlag(const char *flagName) {
if (!flagName) return false;
else if (strcmp(flagName, "usable") == 0) return true;
- else return CAdObject::getExtendedFlag(flagName);
+ else return AdObject::getExtendedFlag(flagName);
}
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_item.h b/engines/wintermute/ad/ad_item.h index 34b19a830f..11010c2a35 100644 --- a/engines/wintermute/ad/ad_item.h +++ b/engines/wintermute/ad/ad_item.h @@ -34,7 +34,7 @@ namespace WinterMute {
-class CAdItem : public CAdTalkHolder {
+class AdItem : public AdTalkHolder {
public:
bool _displayAmount;
int _amount;
@@ -45,23 +45,23 @@ public: bool update();
- DECLARE_PERSISTENT(CAdItem, CAdTalkHolder)
+ DECLARE_PERSISTENT(AdItem, AdTalkHolder)
bool display(int x, int y);
bool getExtendedFlag(const char *flagName);
bool _inInventory;
bool _cursorCombined;
- CBSprite *_spriteHover;
- CBSprite *_cursorNormal;
- CBSprite *_cursorHover;
- CAdItem(CBGame *inGame);
- virtual ~CAdItem();
+ BaseSprite *_spriteHover;
+ BaseSprite *_cursorNormal;
+ BaseSprite *_cursorHover;
+ AdItem(BaseGame *inGame);
+ virtual ~AdItem();
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
// 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();
};
diff --git a/engines/wintermute/ad/ad_layer.cpp b/engines/wintermute/ad/ad_layer.cpp index e23948ed87..2cd7ac26ce 100644 --- a/engines/wintermute/ad/ad_layer.cpp +++ b/engines/wintermute/ad/ad_layer.cpp @@ -41,10 +41,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdLayer, false)
+IMPLEMENT_PERSISTENT(AdLayer, false)
//////////////////////////////////////////////////////////////////////////
-CAdLayer::CAdLayer(CBGame *inGame): CBObject(inGame) {
+AdLayer::AdLayer(BaseGame *inGame): BaseObject(inGame) {
_main = false;
_width = _height = 0;
_active = true;
@@ -53,7 +53,7 @@ CAdLayer::CAdLayer(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdLayer::~CAdLayer() {
+AdLayer::~AdLayer() {
for (int i = 0; i < _nodes.getSize(); i++)
delete _nodes[i];
_nodes.removeAll();
@@ -61,10 +61,10 @@ CAdLayer::~CAdLayer() { //////////////////////////////////////////////////////////////////////////
-bool CAdLayer::loadFile(const char *filename) {
+bool AdLayer::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdLayer::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdLayer::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -99,7 +99,7 @@ TOKEN_DEF(CLOSE_UP) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdLayer::loadBuffer(byte *buffer, bool complete) {
+bool AdLayer::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(LAYER)
TOKEN_TABLE(TEMPLATE)
@@ -120,7 +120,7 @@ bool CAdLayer::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_LAYER) {
@@ -165,8 +165,8 @@ bool CAdLayer::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_REGION: {
- CAdRegion *region = new CAdRegion(_gameRef);
- CAdSceneNode *node = new CAdSceneNode(_gameRef);
+ AdRegion *region = new AdRegion(_gameRef);
+ AdSceneNode *node = new AdSceneNode(_gameRef);
if (!region || !node || DID_FAIL(region->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
delete region;
@@ -181,8 +181,8 @@ bool CAdLayer::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_ENTITY: {
- CAdEntity *entity = new CAdEntity(_gameRef);
- CAdSceneNode *node = new CAdSceneNode(_gameRef);
+ AdEntity *entity = new AdEntity(_gameRef);
+ AdSceneNode *node = new AdSceneNode(_gameRef);
if (entity) entity->_zoomable = false; // scene entites default to NOT zoom
if (!entity || !node || DID_FAIL(entity->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
@@ -226,13 +226,13 @@ bool CAdLayer::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdLayer::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdLayer::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// GetNode
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "GetNode") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
int node = -1;
if (val->_type == VAL_INT) node = val->getInt();
@@ -267,16 +267,16 @@ bool CAdLayer::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "AddRegion") == 0 || strcmp(name, "AddEntity") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdSceneNode *node = new CAdSceneNode(_gameRef);
+ AdSceneNode *node = new AdSceneNode(_gameRef);
if (strcmp(name, "AddRegion") == 0) {
- CAdRegion *region = new CAdRegion(_gameRef);
+ AdRegion *region = new AdRegion(_gameRef);
if (!val->isNULL()) region->setName(val->getString());
node->setRegion(region);
stack->pushNative(region, true);
} else {
- CAdEntity *entity = new CAdEntity(_gameRef);
+ AdEntity *entity = new AdEntity(_gameRef);
if (!val->isNULL()) entity->setName(val->getString());
node->setEntity(entity);
stack->pushNative(entity, true);
@@ -291,16 +291,16 @@ bool CAdLayer::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt else if (strcmp(name, "InsertRegion") == 0 || strcmp(name, "InsertEntity") == 0) {
stack->correctParams(2);
int index = stack->pop()->getInt();
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdSceneNode *node = new CAdSceneNode(_gameRef);
+ AdSceneNode *node = new AdSceneNode(_gameRef);
if (strcmp(name, "InsertRegion") == 0) {
- CAdRegion *region = new CAdRegion(_gameRef);
+ AdRegion *region = new AdRegion(_gameRef);
if (!val->isNULL()) region->setName(val->getString());
node->setRegion(region);
stack->pushNative(region, true);
} else {
- CAdEntity *entity = new CAdEntity(_gameRef);
+ AdEntity *entity = new AdEntity(_gameRef);
if (!val->isNULL()) entity->setName(val->getString());
node->setEntity(entity);
stack->pushNative(entity, true);
@@ -317,11 +317,11 @@ bool CAdLayer::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DeleteNode") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdSceneNode *toDelete = NULL;
+ AdSceneNode *toDelete = NULL;
if (val->isNative()) {
- CBScriptable *temp = val->getNative();
+ BaseScriptable *temp = val->getNative();
for (int i = 0; i < _nodes.getSize(); i++) {
if (_nodes[i]->_region == temp || _nodes[i]->_entity == temp) {
toDelete = _nodes[i];
@@ -351,12 +351,12 @@ bool CAdLayer::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt return STATUS_OK;
}
- else return CBObject::scCallMethod(script, stack, thisStack, name);
+ else return BaseObject::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdLayer::scGetProperty(const char *name) {
+ScValue *AdLayer::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -415,12 +415,12 @@ CScValue *CAdLayer::scGetProperty(const char *name) { return _scValue;
}
- else return CBObject::scGetProperty(name);
+ else return BaseObject::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdLayer::scSetProperty(const char *name, CScValue *value) {
+bool AdLayer::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Name
//////////////////////////////////////////////////////////////////////////
@@ -466,18 +466,18 @@ bool CAdLayer::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CBObject::scSetProperty(name, value);
+ else return BaseObject::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdLayer::scToString() {
+const char *AdLayer::scToString() {
return "[layer]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdLayer::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdLayer::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "LAYER {\n");
buffer->putTextIndent(indent + 2, "NAME=\"%s\"\n", _name);
buffer->putTextIndent(indent + 2, "CAPTION=\"%s\"\n", getCaption());
@@ -506,12 +506,12 @@ bool CAdLayer::saveAsText(CBDynBuffer *buffer, int indent) { _nodes[i]->_region->saveAsText(buffer, indent + 2);
break;
default:
- error("CAdLayer::SaveAsText - Unhandled enum");
+ error("AdLayer::SaveAsText - Unhandled enum");
break;
}
}
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n\n");
@@ -520,9 +520,9 @@ bool CAdLayer::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdLayer::persist(CBPersistMgr *persistMgr) {
+bool AdLayer::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_active));
persistMgr->transfer(TMEMBER(_closeUp));
diff --git a/engines/wintermute/ad/ad_layer.h b/engines/wintermute/ad/ad_layer.h index 0ccdb13ae7..b76cbf1d99 100644 --- a/engines/wintermute/ad/ad_layer.h +++ b/engines/wintermute/ad/ad_layer.h @@ -30,26 +30,26 @@ #define WINTERMUTE_ADLAYER_H
namespace WinterMute {
-class CAdSceneNode;
-class CAdLayer : public CBObject {
+class AdSceneNode;
+class AdLayer : public BaseObject {
public:
bool _closeUp;
- DECLARE_PERSISTENT(CAdLayer, CBObject)
+ DECLARE_PERSISTENT(AdLayer, BaseObject)
bool _active;
int _height;
int _width;
bool _main;
- CAdLayer(CBGame *inGame);
- virtual ~CAdLayer();
- CBArray<CAdSceneNode *, CAdSceneNode *> _nodes;
+ AdLayer(BaseGame *inGame);
+ virtual ~AdLayer();
+ BaseArray<AdSceneNode *, AdSceneNode *> _nodes;
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
// 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();
};
diff --git a/engines/wintermute/ad/ad_node_state.cpp b/engines/wintermute/ad/ad_node_state.cpp index 06f9c4cf95..12bd275614 100644 --- a/engines/wintermute/ad/ad_node_state.cpp +++ b/engines/wintermute/ad/ad_node_state.cpp @@ -38,11 +38,11 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdNodeState, false)
+IMPLEMENT_PERSISTENT(AdNodeState, false)
//////////////////////////////////////////////////////////////////////////
-CAdNodeState::CAdNodeState(CBGame *inGame): CBBase(inGame) {
+AdNodeState::AdNodeState(BaseGame *inGame): BaseClass(inGame) {
_name = NULL;
_active = false;
for (int i = 0; i < 7; i++) _caption[i] = NULL;
@@ -53,7 +53,7 @@ CAdNodeState::CAdNodeState(CBGame *inGame): CBBase(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdNodeState::~CAdNodeState() {
+AdNodeState::~AdNodeState() {
delete[] _name;
delete[] _filename;
delete[] _cursor;
@@ -68,31 +68,31 @@ CAdNodeState::~CAdNodeState() { //////////////////////////////////////////////////////////////////////////
-void CAdNodeState::setName(const char *name) {
+void AdNodeState::setName(const char *name) {
delete[] _name;
_name = NULL;
- CBUtils::setString(&_name, name);
+ BaseUtils::setString(&_name, name);
}
//////////////////////////////////////////////////////////////////////////
-void CAdNodeState::setFilename(const char *filename) {
+void AdNodeState::setFilename(const char *filename) {
delete[] _filename;
_filename = NULL;
- CBUtils::setString(&_filename, filename);
+ BaseUtils::setString(&_filename, filename);
}
//////////////////////////////////////////////////////////////////////////
-void CAdNodeState::setCursor(const char *filename) {
+void AdNodeState::setCursor(const char *filename) {
delete[] _cursor;
_cursor = NULL;
- CBUtils::setString(&_cursor, filename);
+ BaseUtils::setString(&_cursor, filename);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdNodeState::persist(CBPersistMgr *persistMgr) {
+bool AdNodeState::persist(BasePersistenceManager *persistMgr) {
persistMgr->transfer(TMEMBER(_gameRef));
persistMgr->transfer(TMEMBER(_active));
@@ -107,7 +107,7 @@ bool CAdNodeState::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-void CAdNodeState::setCaption(const char *caption, int caseVal) {
+void AdNodeState::setCaption(const char *caption, int caseVal) {
if (caseVal== 0) caseVal= 1;
if (caseVal< 1 || caseVal> 7) return;
@@ -121,7 +121,7 @@ void CAdNodeState::setCaption(const char *caption, int caseVal) { //////////////////////////////////////////////////////////////////////////
-char *CAdNodeState::getCaption(int caseVal) {
+char *AdNodeState::getCaption(int caseVal) {
if (caseVal== 0) caseVal= 1;
if (caseVal< 1 || caseVal> 7 || _caption[caseVal- 1] == NULL) return "";
else return _caption[caseVal- 1];
@@ -129,7 +129,7 @@ char *CAdNodeState::getCaption(int caseVal) { //////////////////////////////////////////////////////////////////////////
-bool CAdNodeState::transferEntity(CAdEntity *entity, bool includingSprites, bool saving) {
+bool AdNodeState::transferEntity(AdEntity *entity, bool includingSprites, bool saving) {
if (!entity) return STATUS_FAILED;
// hack!
diff --git a/engines/wintermute/ad/ad_node_state.h b/engines/wintermute/ad/ad_node_state.h index 186f2ebbb2..fc7692a1bf 100644 --- a/engines/wintermute/ad/ad_node_state.h +++ b/engines/wintermute/ad/ad_node_state.h @@ -31,17 +31,17 @@ namespace WinterMute {
-class CAdEntity;
+class AdEntity;
-class CAdNodeState : public CBBase {
+class AdNodeState : public BaseClass {
public:
- bool transferEntity(CAdEntity *entity, bool includingSprites, bool saving);
+ bool transferEntity(AdEntity *entity, bool includingSprites, bool saving);
void setName(const char *name);
void setFilename(const char *filename);
void setCursor(const char *filename);
- DECLARE_PERSISTENT(CAdNodeState, CBBase)
- CAdNodeState(CBGame *inGame);
- virtual ~CAdNodeState();
+ DECLARE_PERSISTENT(AdNodeState, BaseClass)
+ AdNodeState(BaseGame *inGame);
+ virtual ~AdNodeState();
char *_name;
bool _active;
char *_caption[7];
diff --git a/engines/wintermute/ad/ad_object.cpp b/engines/wintermute/ad/ad_object.cpp index 46f2e590fd..39593c482c 100644 --- a/engines/wintermute/ad/ad_object.cpp +++ b/engines/wintermute/ad/ad_object.cpp @@ -54,10 +54,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdObject, false)
+IMPLEMENT_PERSISTENT(AdObject, false)
//////////////////////////////////////////////////////////////////////////
-CAdObject::CAdObject(CBGame *inGame): CBObject(inGame) {
+AdObject::AdObject(BaseGame *inGame): BaseObject(inGame) {
_type = OBJECT_NONE;
_state = _nextState = STATE_NONE;
@@ -105,7 +105,7 @@ CAdObject::CAdObject(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdObject::~CAdObject() {
+AdObject::~AdObject() {
_currentSprite = NULL; // reference only, don't delete
delete _animSprite;
_animSprite = NULL;
@@ -130,7 +130,7 @@ CAdObject::~CAdObject() { if (_font) _gameRef->_fontStorage->removeFont(_font);
if (_inventory) {
- ((CAdGame *)_gameRef)->unregisterInventory(_inventory);
+ ((AdGame *)_gameRef)->unregisterInventory(_inventory);
_inventory = NULL;
}
@@ -151,17 +151,17 @@ CAdObject::~CAdObject() { //////////////////////////////////////////////////////////////////////////
-bool CAdObject::playAnim(const char *filename) {
+bool AdObject::playAnim(const char *filename) {
delete _animSprite;
_animSprite = NULL;
- _animSprite = new CBSprite(_gameRef, this);
+ _animSprite = new BaseSprite(_gameRef, this);
if (!_animSprite) {
- _gameRef->LOG(0, "CAdObject::PlayAnim: error creating temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
+ _gameRef->LOG(0, "AdObject::PlayAnim: error creating temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
return STATUS_FAILED;
}
bool res = _animSprite->loadFile(filename);
if (DID_FAIL(res)) {
- _gameRef->LOG(res, "CAdObject::PlayAnim: error loading temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
+ _gameRef->LOG(res, "AdObject::PlayAnim: error loading temp sprite (object:\"%s\" sprite:\"%s\")", _name, filename);
delete _animSprite;
_animSprite = NULL;
return res;
@@ -173,13 +173,13 @@ bool CAdObject::playAnim(const char *filename) { //////////////////////////////////////////////////////////////////////////
-bool CAdObject::display() {
+bool AdObject::display() {
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::update() {
+bool AdObject::update() {
return STATUS_OK;
}
@@ -187,7 +187,7 @@ bool CAdObject::update() { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdObject::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// PlayAnim / PlayAnimAsync
@@ -257,14 +257,14 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS stack->correctParams(5);
const char *text = stack->pop()->getString();
- CScValue *soundVal = stack->pop();
+ ScValue *soundVal = stack->pop();
int duration = stack->pop()->getInt();
- CScValue *valStances = stack->pop();
+ ScValue *valStances = stack->pop();
const char *stances = valStances->isNULL() ? NULL : valStances->getString();
int align = 0;
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (val->isNULL()) align = TAL_CENTER;
else align = val->getInt();
@@ -285,11 +285,11 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS else if (strcmp(name, "StickToRegion") == 0) {
stack->correctParams(1);
- CAdLayer *main = ((CAdGame *)_gameRef)->_scene->_mainLayer;
+ AdLayer *main = ((AdGame *)_gameRef)->_scene->_mainLayer;
bool regFound = false;
int i;
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (val->isNULL() || !main) {
_stickRegion = NULL;
regFound = true;
@@ -303,7 +303,7 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS }
}
} else if (val->isNative()) {
- CBScriptable *obj = val->getNative();
+ BaseScriptable *obj = val->getNative();
for (i = 0; i < main->_nodes.getSize(); i++) {
if (main->_nodes[i]->_type == OBJECT_REGION && main->_nodes[i]->_region == obj) {
@@ -325,7 +325,7 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "SetFont") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (val->isNULL()) SetFont(NULL);
else SetFont(val->getString());
@@ -351,11 +351,11 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS stack->correctParams(2);
if (!_inventory) {
- _inventory = new CAdInventory(_gameRef);
- ((CAdGame *)_gameRef)->registerInventory(_inventory);
+ _inventory = new AdInventory(_gameRef);
+ ((AdGame *)_gameRef)->registerInventory(_inventory);
}
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (!val->isNULL()) {
const char *itemName = val->getString();
val = stack->pop();
@@ -363,7 +363,7 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS if (DID_FAIL(_inventory->insertItem(itemName, insertAfter))) script->runtimeError("Cannot add item '%s' to inventory", itemName);
else {
// hide associated entities
- ((CAdGame *)_gameRef)->_scene->handleItemAssociations(itemName, false);
+ ((AdGame *)_gameRef)->_scene->handleItemAssociations(itemName, false);
}
} else script->runtimeError("TakeItem: item name expected");
@@ -379,16 +379,16 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS stack->correctParams(1);
if (!_inventory) {
- _inventory = new CAdInventory(_gameRef);
- ((CAdGame *)_gameRef)->registerInventory(_inventory);
+ _inventory = new AdInventory(_gameRef);
+ ((AdGame *)_gameRef)->registerInventory(_inventory);
}
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (!val->isNULL()) {
if (DID_FAIL(_inventory->removeItem(val->getString()))) script->runtimeError("Cannot remove item '%s' from inventory", val->getString());
else {
// show associated entities
- ((CAdGame *)_gameRef)->_scene->handleItemAssociations(val->getString(), true);
+ ((AdGame *)_gameRef)->_scene->handleItemAssociations(val->getString(), true);
}
} else script->runtimeError("DropItem: item name expected");
@@ -403,13 +403,13 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS stack->correctParams(1);
if (!_inventory) {
- _inventory = new CAdInventory(_gameRef);
- ((CAdGame *)_gameRef)->registerInventory(_inventory);
+ _inventory = new AdInventory(_gameRef);
+ ((AdGame *)_gameRef)->registerInventory(_inventory);
}
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (val->_type == VAL_STRING) {
- CAdItem *item = ((CAdGame *)_gameRef)->getItemByName(val->getString());
+ AdItem *item = ((AdGame *)_gameRef)->getItemByName(val->getString());
if (item) stack->pushNative(item, true);
else stack->pushNULL();
} else if (val->isNULL() || val->getInt() < 0 || val->getInt() >= _inventory->_takenItems.getSize())
@@ -427,11 +427,11 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS stack->correctParams(1);
if (!_inventory) {
- _inventory = new CAdInventory(_gameRef);
- ((CAdGame *)_gameRef)->registerInventory(_inventory);
+ _inventory = new AdInventory(_gameRef);
+ ((AdGame *)_gameRef)->registerInventory(_inventory);
}
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (!val->isNULL()) {
for (int i = 0; i < _inventory->_takenItems.getSize(); i++) {
if (val->getNative() == _inventory->_takenItems[i]) {
@@ -457,7 +457,7 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS int offsetX = stack->pop()->getInt();
int offsetY = stack->pop()->getInt();
- CPartEmitter *emitter = createParticleEmitter(followParent, offsetX, offsetY);
+ PartEmitter *emitter = createParticleEmitter(followParent, offsetX, offsetY);
if (emitter) stack->pushNative(_partEmitter, true);
else stack->pushNULL();
@@ -489,7 +489,7 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS int offsetY = stack->pop()->getInt();
bool res;
- CAdEntity *ent = new CAdEntity(_gameRef);
+ AdEntity *ent = new AdEntity(_gameRef);
if (DID_FAIL(res = ent->loadFile(filename))) {
delete ent;
ent = NULL;
@@ -516,10 +516,10 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "RemoveAttachment") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
bool found = false;
if (val->isNative()) {
- CBScriptable *obj = val->getNative();
+ BaseScriptable *obj = val->getNative();
for (int i = 0; i < _attachmentsPre.getSize(); i++) {
if (_attachmentsPre[i] == obj) {
found = true;
@@ -565,9 +565,9 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GetAttachment") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdObject *ret = NULL;
+ AdObject *ret = NULL;
if (val->isInt()) {
int index = val->getInt();
int currIndex = 0;
@@ -603,12 +603,12 @@ bool CAdObject::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS return STATUS_OK;
}
- else return CBObject::scCallMethod(script, stack, thisStack, name);
+ else return BaseObject::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdObject::scGetProperty(const char *name) {
+ScValue *AdObject::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -710,12 +710,12 @@ CScValue *CAdObject::scGetProperty(const char *name) { }
- else return CBObject::scGetProperty(name);
+ else return BaseObject::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::scSetProperty(const char *name, CScValue *value) {
+bool AdObject::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Active
@@ -781,18 +781,18 @@ bool CAdObject::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CBObject::scSetProperty(name, value);
+ else return BaseObject::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdObject::scToString() {
+const char *AdObject::scToString() {
return "[ad object]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::SetFont(const char *filename) {
+bool AdObject::SetFont(const char *filename) {
if (_font) _gameRef->_fontStorage->removeFont(_font);
if (filename) {
_font = _gameRef->_fontStorage->addFont(filename);
@@ -805,17 +805,17 @@ bool CAdObject::SetFont(const char *filename) { //////////////////////////////////////////////////////////////////////////
-int CAdObject::getHeight() {
+int AdObject::getHeight() {
if (!_currentSprite) return 0;
else {
- CBFrame *frame = _currentSprite->_frames[_currentSprite->_currentFrame];
+ BaseFrame *frame = _currentSprite->_frames[_currentSprite->_currentFrame];
int ret = 0;
for (int i = 0; i < frame->_subframes.getSize(); i++) {
ret = MAX(ret, frame->_subframes[i]->_hotspotY);
}
if (_zoomable) {
- float zoom = ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY);
+ float zoom = ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY);
ret = (int)(ret * zoom / 100);
}
return ret;
@@ -824,8 +824,8 @@ int CAdObject::getHeight() { //////////////////////////////////////////////////////////////////////////
-void CAdObject::talk(const char *text, const char *sound, uint32 duration, const char *stances, TTextAlign Align) {
- if (!_sentence) _sentence = new CAdSentence(_gameRef);
+void AdObject::talk(const char *text, const char *sound, uint32 duration, const char *stances, TTextAlign Align) {
+ if (!_sentence) _sentence = new AdSentence(_gameRef);
if (!_sentence) return;
if (_forcedTalkAnimName && _forcedTalkAnimUsed) {
@@ -852,7 +852,7 @@ void CAdObject::talk(const char *text, const char *sound, uint32 duration, const if (!sound) {
char *key = _gameRef->_stringTable->getKey(text);
if (key) {
- sound = ((CAdGame *)_gameRef)->findSpeechFile(key);
+ sound = ((AdGame *)_gameRef)->findSpeechFile(key);
delete [] key;
if (sound) deleteSound = true;
@@ -861,7 +861,7 @@ void CAdObject::talk(const char *text, const char *sound, uint32 duration, const // load sound and set duration appropriately
if (sound) {
- CBSound *snd = new CBSound(_gameRef);
+ BaseSound *snd = new BaseSound(_gameRef);
if (snd && DID_SUCCEED(snd->setSound(sound, Audio::Mixer::kSpeechSoundType, true))) {
_sentence->setSound(snd);
if (_sentence->_duration <= 0) {
@@ -883,8 +883,8 @@ void CAdObject::talk(const char *text, const char *sound, uint32 duration, const y = _posY;
if (!_sceneIndependent && _subtitlesModRelative) {
- x -= ((CAdGame *)_gameRef)->_scene->getOffsetLeft();
- y -= ((CAdGame *)_gameRef)->_scene->getOffsetTop();
+ x -= ((AdGame *)_gameRef)->_scene->getOffsetLeft();
+ y -= ((AdGame *)_gameRef)->_scene->getOffsetTop();
}
@@ -920,8 +920,8 @@ void CAdObject::talk(const char *text, const char *sound, uint32 duration, const if (_subtitlesModRelative) {
- _sentence->_pos.x += ((CAdGame *)_gameRef)->_scene->getOffsetLeft();
- _sentence->_pos.y += ((CAdGame *)_gameRef)->_scene->getOffsetTop();
+ _sentence->_pos.x += ((AdGame *)_gameRef)->_scene->getOffsetLeft();
+ _sentence->_pos.y += ((AdGame *)_gameRef)->_scene->getOffsetTop();
}
_sentence->_fixedPos = !_subtitlesModRelative;
@@ -936,7 +936,7 @@ void CAdObject::talk(const char *text, const char *sound, uint32 duration, const //////////////////////////////////////////////////////////////////////////
-bool CAdObject::reset() {
+bool AdObject::reset() {
if (_state == STATE_PLAYING_ANIM && _animSprite != NULL) {
delete _animSprite;
_animSprite = NULL;
@@ -953,8 +953,8 @@ bool CAdObject::reset() { //////////////////////////////////////////////////////////////////////////
-bool CAdObject::persist(CBPersistMgr *persistMgr) {
- CBObject::persist(persistMgr);
+bool AdObject::persist(BasePersistenceManager *persistMgr) {
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_active));
persistMgr->transfer(TMEMBER(_blockRegion));
@@ -998,46 +998,46 @@ bool CAdObject::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdObject::updateSounds() {
+bool AdObject::updateSounds() {
if (_sentence && _sentence->_sound)
updateOneSound(_sentence->_sound);
- return CBObject::updateSounds();
+ return BaseObject::updateSounds();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::resetSoundPan() {
+bool AdObject::resetSoundPan() {
if (_sentence && _sentence->_sound) {
_sentence->_sound->setPan(0.0f);
}
- return CBObject::resetSoundPan();
+ return BaseObject::resetSoundPan();
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::getExtendedFlag(const char *flagName) {
+bool AdObject::getExtendedFlag(const char *flagName) {
if (!flagName) return false;
else if (strcmp(flagName, "usable") == 0) return true;
- else return CBObject::getExtendedFlag(flagName);
+ else return BaseObject::getExtendedFlag(flagName);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdObject::saveAsText(BaseDynamicBuffer *buffer, int indent) {
if (_blockRegion) _blockRegion->saveAsText(buffer, indent + 2, "BLOCKED_REGION");
if (_wptGroup) _wptGroup->saveAsText(buffer, indent + 2);
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::updateBlockRegion() {
- CAdGame *adGame = (CAdGame *)_gameRef;
+bool AdObject::updateBlockRegion() {
+ AdGame *adGame = (AdGame *)_gameRef;
if (adGame->_scene) {
if (_blockRegion && _currentBlockRegion)
_currentBlockRegion->mimic(_blockRegion, _zoomable ? adGame->_scene->getScaleAt(_posY) : 100.0f, _posX, _posY);
@@ -1049,20 +1049,20 @@ bool CAdObject::updateBlockRegion() { }
//////////////////////////////////////////////////////////////////////////
-CAdInventory *CAdObject::getInventory() {
+AdInventory *AdObject::getInventory() {
if (!_inventory) {
- _inventory = new CAdInventory(_gameRef);
- ((CAdGame *)_gameRef)->registerInventory(_inventory);
+ _inventory = new AdInventory(_gameRef);
+ ((AdGame *)_gameRef)->registerInventory(_inventory);
}
return _inventory;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::afterMove() {
- CAdRegion *newRegions[MAX_NUM_REGIONS];
+bool AdObject::afterMove() {
+ AdRegion *newRegions[MAX_NUM_REGIONS];
- ((CAdGame *)_gameRef)->_scene->getRegionsAt(_posX, _posY, newRegions, MAX_NUM_REGIONS);
+ ((AdGame *)_gameRef)->_scene->getRegionsAt(_posX, _posY, newRegions, MAX_NUM_REGIONS);
for (int i = 0; i < MAX_NUM_REGIONS; i++) {
if (!newRegions[i]) break;
bool regFound = false;
@@ -1087,20 +1087,20 @@ bool CAdObject::afterMove() { }
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::invalidateCurrRegions() {
+bool AdObject::invalidateCurrRegions() {
for (int i = 0; i < MAX_NUM_REGIONS; i++) _currentRegions[i] = NULL;
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::getScale(float *scaleX, float *scaleY) {
+bool AdObject::getScale(float *scaleX, float *scaleY) {
if (_zoomable) {
if (_scaleX >= 0 || _scaleY >= 0) {
*scaleX = _scaleX < 0 ? 100 : _scaleX;
*scaleY = _scaleY < 0 ? 100 : _scaleY;
} else if (_scale >= 0) *scaleX = *scaleY = _scale;
- else *scaleX = *scaleY = ((CAdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) + _relativeScale;
+ else *scaleX = *scaleY = ((AdGame *)_gameRef)->_scene->getZoomAt(_posX, _posY) + _relativeScale;
} else {
*scaleX = *scaleY = 100;
}
@@ -1108,7 +1108,7 @@ bool CAdObject::getScale(float *scaleX, float *scaleY) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::updateSpriteAttachments() {
+bool AdObject::updateSpriteAttachments() {
for (int i = 0; i < _attachmentsPre.getSize(); i++) {
_attachmentsPre[i]->update();
}
@@ -1119,7 +1119,7 @@ bool CAdObject::updateSpriteAttachments() { }
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::displaySpriteAttachments(bool preDisplay) {
+bool AdObject::displaySpriteAttachments(bool preDisplay) {
if (preDisplay) {
for (int i = 0; i < _attachmentsPre.getSize(); i++) {
displaySpriteAttachment(_attachmentsPre[i]);
@@ -1133,7 +1133,7 @@ bool CAdObject::displaySpriteAttachments(bool preDisplay) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::displaySpriteAttachment(CAdObject *attachment) {
+bool AdObject::displaySpriteAttachment(AdObject *attachment) {
if (!attachment->_active) return STATUS_OK;
float scaleX, scaleY;
@@ -1171,13 +1171,13 @@ bool CAdObject::displaySpriteAttachment(CAdObject *attachment) { }
//////////////////////////////////////////////////////////////////////////
-CPartEmitter *CAdObject::createParticleEmitter(bool followParent, int offsetX, int offsetY) {
+PartEmitter *AdObject::createParticleEmitter(bool followParent, int offsetX, int offsetY) {
_partFollowParent = followParent;
_partOffsetX = offsetX;
_partOffsetY = offsetY;
if (!_partEmitter) {
- _partEmitter = new CPartEmitter(_gameRef, this);
+ _partEmitter = new PartEmitter(_gameRef, this);
if (_partEmitter) {
_gameRef->registerObject(_partEmitter);
}
@@ -1187,7 +1187,7 @@ CPartEmitter *CAdObject::createParticleEmitter(bool followParent, int offsetX, i }
//////////////////////////////////////////////////////////////////////////
-bool CAdObject::updatePartEmitter() {
+bool AdObject::updatePartEmitter() {
if (!_partEmitter) return STATUS_FAILED;
if (_partFollowParent) {
diff --git a/engines/wintermute/ad/ad_object.h b/engines/wintermute/ad/ad_object.h index dd123092a3..a8da8bd820 100644 --- a/engines/wintermute/ad/ad_object.h +++ b/engines/wintermute/ad/ad_object.h @@ -34,19 +34,19 @@ namespace WinterMute {
-class CAdWaypointGroup;
-class CAdRegion;
-class CAdSentence;
-class CBFont;
-class CBRegion;
-class CAdInventory;
+class AdWaypointGroup;
+class AdRegion;
+class AdSentence;
+class BaseFont;
+class BaseRegion;
+class AdInventory;
#define MAX_NUM_REGIONS 10
-class CAdObject : public CBObject {
+class AdObject : public BaseObject {
public:
- CPartEmitter *_partEmitter;
- virtual CPartEmitter *createParticleEmitter(bool followParent = false, int offsetX = 0, int offsetY = 0);
+ PartEmitter *_partEmitter;
+ virtual PartEmitter *createParticleEmitter(bool followParent = false, int offsetX = 0, int offsetY = 0);
virtual bool updatePartEmitter();
bool _partFollowParent;
int _partOffsetX;
@@ -58,7 +58,7 @@ public: int _subtitlesModX;
int _subtitlesModY;
int _subtitlesWidth;
- CAdRegion *_stickRegion;
+ AdRegion *_stickRegion;
bool _sceneIndependent;
bool _ignoreItems;
bool updateBlockRegion();
@@ -68,51 +68,51 @@ public: virtual bool resetSoundPan();
virtual bool updateSounds();
bool reset();
- DECLARE_PERSISTENT(CAdObject, CBObject)
+ DECLARE_PERSISTENT(AdObject, BaseObject)
virtual void talk(const char *text, const char *sound = NULL, uint32 duration = 0, const char *stances = NULL, TTextAlign align = TAL_CENTER);
virtual int getHeight();
- CAdSentence *_sentence;
+ AdSentence *_sentence;
bool SetFont(const char *filename);
virtual bool update();
virtual bool display();
bool _drawn;
bool _active;
virtual bool playAnim(const char *filename);
- CBSprite *_animSprite;
- CBSprite *_currentSprite;
+ BaseSprite *_animSprite;
+ BaseSprite *_currentSprite;
TObjectState _state;
TObjectState _nextState;
TObjectType _type;
- CAdObject(CBGame *inGame);
- virtual ~CAdObject();
- CBFont *_font;
- CBSprite *_tempSprite2;
- CBRegion *_blockRegion;
- CAdWaypointGroup *_wptGroup;
- CBRegion *_currentBlockRegion;
- CAdWaypointGroup *_currentWptGroup;
- CAdInventory *getInventory();
-
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ AdObject(BaseGame *inGame);
+ virtual ~AdObject();
+ BaseFont *_font;
+ BaseSprite *_tempSprite2;
+ BaseRegion *_blockRegion;
+ AdWaypointGroup *_wptGroup;
+ BaseRegion *_currentBlockRegion;
+ AdWaypointGroup *_currentWptGroup;
+ AdInventory *getInventory();
+
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
virtual bool afterMove();
- CAdRegion *_currentRegions[MAX_NUM_REGIONS];
+ AdRegion *_currentRegions[MAX_NUM_REGIONS];
// 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();
- CBArray<CAdObject *, CAdObject *> _attachmentsPre;
- CBArray<CAdObject *, CAdObject *> _attachmentsPost;
+ BaseArray<AdObject *, AdObject *> _attachmentsPre;
+ BaseArray<AdObject *, AdObject *> _attachmentsPost;
bool updateSpriteAttachments();
bool displaySpriteAttachments(bool preDisplay);
- CAdObject *_registerAlias;
+ AdObject *_registerAlias;
private:
- bool displaySpriteAttachment(CAdObject *attachment);
- CAdInventory *_inventory;
+ bool displaySpriteAttachment(AdObject *attachment);
+ AdInventory *_inventory;
protected:
bool getScale(float *scaleX, float *scaleY);
diff --git a/engines/wintermute/ad/ad_path.cpp b/engines/wintermute/ad/ad_path.cpp index 780912ce08..cecfaa37d6 100644 --- a/engines/wintermute/ad/ad_path.cpp +++ b/engines/wintermute/ad/ad_path.cpp @@ -32,23 +32,23 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdPath, false)
+IMPLEMENT_PERSISTENT(AdPath, false)
//////////////////////////////////////////////////////////////////////////
-CAdPath::CAdPath(CBGame *inGame): CBBase(inGame) {
+AdPath::AdPath(BaseGame *inGame): BaseClass(inGame) {
_currIndex = -1;
_ready = false;
}
//////////////////////////////////////////////////////////////////////////
-CAdPath::~CAdPath() {
+AdPath::~AdPath() {
reset();
}
//////////////////////////////////////////////////////////////////////////
-void CAdPath::reset() {
+void AdPath::reset() {
for (int i = 0; i < _points.getSize(); i++)
delete _points[i];
@@ -59,7 +59,7 @@ void CAdPath::reset() { //////////////////////////////////////////////////////////////////////////
-CBPoint *CAdPath::getFirst() {
+BasePoint *AdPath::getFirst() {
if (_points.getSize() > 0) {
_currIndex = 0;
return _points[_currIndex];
@@ -68,7 +68,7 @@ CBPoint *CAdPath::getFirst() { //////////////////////////////////////////////////////////////////////////
-CBPoint *CAdPath::getNext() {
+BasePoint *AdPath::getNext() {
_currIndex++;
if (_currIndex < _points.getSize()) return _points[_currIndex];
else return NULL;
@@ -76,20 +76,20 @@ CBPoint *CAdPath::getNext() { //////////////////////////////////////////////////////////////////////////
-CBPoint *CAdPath::getCurrent() {
+BasePoint *AdPath::getCurrent() {
if (_currIndex >= 0 && _currIndex < _points.getSize()) return _points[_currIndex];
else return NULL;
}
//////////////////////////////////////////////////////////////////////////
-void CAdPath::addPoint(CBPoint *point) {
+void AdPath::addPoint(BasePoint *point) {
_points.add(point);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdPath::setReady(bool ready) {
+bool AdPath::setReady(bool ready) {
bool orig = _ready;
_ready = ready;
@@ -98,7 +98,7 @@ bool CAdPath::setReady(bool ready) { //////////////////////////////////////////////////////////////////////////
-bool CAdPath::persist(CBPersistMgr *persistMgr) {
+bool AdPath::persist(BasePersistenceManager *persistMgr) {
persistMgr->transfer(TMEMBER(_gameRef));
diff --git a/engines/wintermute/ad/ad_path.h b/engines/wintermute/ad/ad_path.h index f27362bfd9..958f52af03 100644 --- a/engines/wintermute/ad/ad_path.h +++ b/engines/wintermute/ad/ad_path.h @@ -34,19 +34,19 @@ #include "engines/wintermute/base/base.h"
namespace WinterMute {
-class CBPoint;
-class CAdPath : public CBBase {
+class BasePoint;
+class AdPath : public BaseClass {
public:
- DECLARE_PERSISTENT(CAdPath, CBBase)
- CBPoint *getCurrent();
+ DECLARE_PERSISTENT(AdPath, BaseClass)
+ BasePoint *getCurrent();
bool setReady(bool ready = true);
- void addPoint(CBPoint *point);
- CBPoint *getNext();
- CBPoint *getFirst();
+ void addPoint(BasePoint *point);
+ BasePoint *getNext();
+ BasePoint *getFirst();
void reset();
- CAdPath(CBGame *inGame);
- virtual ~CAdPath();
- CBArray <CBPoint *, CBPoint *> _points;
+ AdPath(BaseGame *inGame);
+ virtual ~AdPath();
+ BaseArray <BasePoint *, BasePoint *> _points;
int _currIndex;
bool _ready;
};
diff --git a/engines/wintermute/ad/ad_path_point.cpp b/engines/wintermute/ad/ad_path_point.cpp index d4b910a30f..d5d447eb9a 100644 --- a/engines/wintermute/ad/ad_path_point.cpp +++ b/engines/wintermute/ad/ad_path_point.cpp @@ -31,10 +31,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdPathPoint, false)
+IMPLEMENT_PERSISTENT(AdPathPoint, false)
//////////////////////////////////////////////////////////////////////////
-CAdPathPoint::CAdPathPoint() {
+AdPathPoint::AdPathPoint() {
x = y = 0;
_distance = 0;
@@ -44,7 +44,7 @@ CAdPathPoint::CAdPathPoint() { //////////////////////////////////////////////////////////////////////////
-CAdPathPoint::CAdPathPoint(int initX, int initY, int initDistance) {
+AdPathPoint::AdPathPoint(int initX, int initY, int initDistance) {
x = initX;
y = initY;
_distance = initDistance;
@@ -55,15 +55,15 @@ CAdPathPoint::CAdPathPoint(int initX, int initY, int initDistance) { //////////////////////////////////////////////////////////////////////////
-CAdPathPoint::~CAdPathPoint() {
+AdPathPoint::~AdPathPoint() {
_origin = NULL;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdPathPoint::persist(CBPersistMgr *persistMgr) {
+bool AdPathPoint::persist(BasePersistenceManager *persistMgr) {
- CBPoint::persist(persistMgr);
+ BasePoint::persist(persistMgr);
persistMgr->transfer(TMEMBER(_distance));
persistMgr->transfer(TMEMBER(_marked));
diff --git a/engines/wintermute/ad/ad_path_point.h b/engines/wintermute/ad/ad_path_point.h index 2a58237bb9..ea0a5795d0 100644 --- a/engines/wintermute/ad/ad_path_point.h +++ b/engines/wintermute/ad/ad_path_point.h @@ -34,13 +34,13 @@ namespace WinterMute {
-class CAdPathPoint : public CBPoint {
+class AdPathPoint : public BasePoint {
public:
- DECLARE_PERSISTENT(CAdPathPoint, CBPoint)
- CAdPathPoint(int initX, int initY, int initDistance);
- CAdPathPoint();
- virtual ~CAdPathPoint();
- CAdPathPoint *_origin;
+ DECLARE_PERSISTENT(AdPathPoint, BasePoint)
+ AdPathPoint(int initX, int initY, int initDistance);
+ AdPathPoint();
+ virtual ~AdPathPoint();
+ AdPathPoint *_origin;
bool _marked;
int _distance;
};
diff --git a/engines/wintermute/ad/ad_region.cpp b/engines/wintermute/ad/ad_region.cpp index ae65be5013..1bd6051bda 100644 --- a/engines/wintermute/ad/ad_region.cpp +++ b/engines/wintermute/ad/ad_region.cpp @@ -37,10 +37,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdRegion, false)
+IMPLEMENT_PERSISTENT(AdRegion, false)
//////////////////////////////////////////////////////////////////////////
-CAdRegion::CAdRegion(CBGame *inGame): CBRegion(inGame) {
+AdRegion::AdRegion(BaseGame *inGame): BaseRegion(inGame) {
_blocked = false;
_decoration = false;
_zoom = 0;
@@ -49,15 +49,15 @@ CAdRegion::CAdRegion(CBGame *inGame): CBRegion(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdRegion::~CAdRegion() {
+AdRegion::~AdRegion() {
}
//////////////////////////////////////////////////////////////////////////
-bool CAdRegion::loadFile(const char *filename) {
+bool AdRegion::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdRegion::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdRegion::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -95,7 +95,7 @@ TOKEN_DEF(PROPERTY) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdRegion::loadBuffer(byte *buffer, bool complete) {
+bool AdRegion::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(REGION)
TOKEN_TABLE(TEMPLATE)
@@ -118,7 +118,7 @@ bool CAdRegion::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_REGION) {
@@ -170,7 +170,7 @@ bool CAdRegion::loadBuffer(byte *buffer, bool complete) { case TOKEN_POINT: {
int x, y;
parser.scanStr((char *)params, "%d,%d", &x, &y);
- _points.add(new CBPoint(x, y));
+ _points.add(new BasePoint(x, y));
}
break;
@@ -219,7 +219,7 @@ bool CAdRegion::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdRegion::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdRegion::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
/*
//////////////////////////////////////////////////////////////////////////
// SkipTo
@@ -233,12 +233,12 @@ bool CAdRegion::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisS return STATUS_OK;
}
- else*/ return CBRegion::scCallMethod(script, stack, thisStack, name);
+ else*/ return BaseRegion::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdRegion::scGetProperty(const char *name) {
+ScValue *AdRegion::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -289,12 +289,12 @@ CScValue *CAdRegion::scGetProperty(const char *name) { return _scValue;
}
- else return CBRegion::scGetProperty(name);
+ else return BaseRegion::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdRegion::scSetProperty(const char *name, CScValue *value) {
+bool AdRegion::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Name
//////////////////////////////////////////////////////////////////////////
@@ -335,18 +335,18 @@ bool CAdRegion::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CBRegion::scSetProperty(name, value);
+ else return BaseRegion::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdRegion::scToString() {
+const char *AdRegion::scToString() {
return "[ad region]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdRegion::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdRegion::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "REGION {\n");
buffer->putTextIndent(indent + 2, "NAME=\"%s\"\n", _name);
buffer->putTextIndent(indent + 2, "CAPTION=\"%s\"\n", getCaption());
@@ -369,7 +369,7 @@ bool CAdRegion::saveAsText(CBDynBuffer *buffer, int indent) { buffer->putTextIndent(indent + 2, "POINT {%d,%d}\n", _points[i]->x, _points[i]->y);
}
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n\n");
@@ -378,8 +378,8 @@ bool CAdRegion::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdRegion::persist(CBPersistMgr *persistMgr) {
- CBRegion::persist(persistMgr);
+bool AdRegion::persist(BasePersistenceManager *persistMgr) {
+ BaseRegion::persist(persistMgr);
persistMgr->transfer(TMEMBER(_alpha));
persistMgr->transfer(TMEMBER(_blocked));
diff --git a/engines/wintermute/ad/ad_region.h b/engines/wintermute/ad/ad_region.h index 62c5fd6ba3..7ee36dc970 100644 --- a/engines/wintermute/ad/ad_region.h +++ b/engines/wintermute/ad/ad_region.h @@ -33,23 +33,23 @@ namespace WinterMute {
-class CAdRegion : public CBRegion {
+class AdRegion : public BaseRegion {
public:
- DECLARE_PERSISTENT(CAdRegion, CBRegion)
+ DECLARE_PERSISTENT(AdRegion, BaseRegion)
uint32 _alpha;
float _zoom;
bool _blocked;
bool _decoration;
- CAdRegion(CBGame *inGame);
- virtual ~CAdRegion();
+ AdRegion(BaseGame *inGame);
+ virtual ~AdRegion();
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
// 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();
};
diff --git a/engines/wintermute/ad/ad_response.cpp b/engines/wintermute/ad/ad_response.cpp index b653fbd36a..29398f547c 100644 --- a/engines/wintermute/ad/ad_response.cpp +++ b/engines/wintermute/ad/ad_response.cpp @@ -35,10 +35,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdResponse, false)
+IMPLEMENT_PERSISTENT(AdResponse, false)
//////////////////////////////////////////////////////////////////////////
-CAdResponse::CAdResponse(CBGame *inGame): CBObject(inGame) {
+AdResponse::AdResponse(BaseGame *inGame): BaseObject(inGame) {
_text = NULL;
_textOrig = NULL;
_icon = _iconHover = _iconPressed = NULL;
@@ -49,7 +49,7 @@ CAdResponse::CAdResponse(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdResponse::~CAdResponse() {
+AdResponse::~AdResponse() {
delete[] _text;
delete[] _textOrig;
delete _icon;
@@ -65,18 +65,18 @@ CAdResponse::~CAdResponse() { //////////////////////////////////////////////////////////////////////////
-void CAdResponse::setText(const char *text) {
- CBUtils::setString(&_text, text);
- CBUtils::setString(&_textOrig, text);
+void AdResponse::setText(const char *text) {
+ BaseUtils::setString(&_text, text);
+ BaseUtils::setString(&_textOrig, text);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdResponse::setIcon(const char *filename) {
+bool AdResponse::setIcon(const char *filename) {
delete _icon;
- _icon = new CBSprite(_gameRef);
+ _icon = new BaseSprite(_gameRef);
if (!_icon || DID_FAIL(_icon->loadFile(filename))) {
- _gameRef->LOG(0, "CAdResponse::setIcon failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdResponse::setIcon failed for file '%s'", filename);
delete _icon;
_icon = NULL;
return STATUS_FAILED;
@@ -85,22 +85,22 @@ bool CAdResponse::setIcon(const char *filename) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdResponse::setFont(const char *filename) {
+bool AdResponse::setFont(const char *filename) {
if (_font) _gameRef->_fontStorage->removeFont(_font);
_font = _gameRef->_fontStorage->addFont(filename);
if (!_font) {
- _gameRef->LOG(0, "CAdResponse::setFont failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdResponse::setFont failed for file '%s'", filename);
return STATUS_FAILED;
}
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdResponse::setIconHover(const char *filename) {
+bool AdResponse::setIconHover(const char *filename) {
delete _iconHover;
- _iconHover = new CBSprite(_gameRef);
+ _iconHover = new BaseSprite(_gameRef);
if (!_iconHover || DID_FAIL(_iconHover->loadFile(filename))) {
- _gameRef->LOG(0, "CAdResponse::setIconHover failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdResponse::setIconHover failed for file '%s'", filename);
delete _iconHover;
_iconHover = NULL;
return STATUS_FAILED;
@@ -110,11 +110,11 @@ bool CAdResponse::setIconHover(const char *filename) { //////////////////////////////////////////////////////////////////////////
-bool CAdResponse::setIconPressed(const char *filename) {
+bool AdResponse::setIconPressed(const char *filename) {
delete _iconPressed;
- _iconPressed = new CBSprite(_gameRef);
+ _iconPressed = new BaseSprite(_gameRef);
if (!_iconPressed || DID_FAIL(_iconPressed->loadFile(filename))) {
- _gameRef->LOG(0, "CAdResponse::setIconPressed failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdResponse::setIconPressed failed for file '%s'", filename);
delete _iconPressed;
_iconPressed = NULL;
return STATUS_FAILED;
@@ -124,9 +124,9 @@ bool CAdResponse::setIconPressed(const char *filename) { //////////////////////////////////////////////////////////////////////////
-bool CAdResponse::persist(CBPersistMgr *persistMgr) {
+bool AdResponse::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_icon));
persistMgr->transfer(TMEMBER(_iconHover));
diff --git a/engines/wintermute/ad/ad_response.h b/engines/wintermute/ad/ad_response.h index da450b2229..0cb8f6628b 100644 --- a/engines/wintermute/ad/ad_response.h +++ b/engines/wintermute/ad/ad_response.h @@ -34,24 +34,24 @@ #include "engines/wintermute/ad/ad_types.h"
namespace WinterMute {
-class CBFont;
-class CAdResponse : public CBObject {
+class BaseFont;
+class AdResponse : public BaseObject {
public:
- DECLARE_PERSISTENT(CAdResponse, CBObject)
+ DECLARE_PERSISTENT(AdResponse, BaseObject)
bool setIcon(const char *filename);
bool setFont(const char *filename);
bool setIconHover(const char *filename);
bool setIconPressed(const char *filename);
void setText(const char *text);
int _iD;
- CBSprite *_icon;
- CBSprite *_iconHover;
- CBSprite *_iconPressed;
- CBFont *_font;
+ BaseSprite *_icon;
+ BaseSprite *_iconHover;
+ BaseSprite *_iconPressed;
+ BaseFont *_font;
char *_text;
char *_textOrig;
- CAdResponse(CBGame *inGame);
- virtual ~CAdResponse();
+ AdResponse(BaseGame *inGame);
+ virtual ~AdResponse();
TResponseType _responseType;
};
diff --git a/engines/wintermute/ad/ad_response_box.cpp b/engines/wintermute/ad/ad_response_box.cpp index 2499c9a732..5b7e441abc 100644 --- a/engines/wintermute/ad/ad_response_box.cpp +++ b/engines/wintermute/ad/ad_response_box.cpp @@ -47,17 +47,17 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdResponseBox, false)
+IMPLEMENT_PERSISTENT(AdResponseBox, false)
//////////////////////////////////////////////////////////////////////////
-CAdResponseBox::CAdResponseBox(CBGame *inGame): CBObject(inGame) {
+AdResponseBox::AdResponseBox(BaseGame *inGame): BaseObject(inGame) {
_font = _fontHover = NULL;
_window = NULL;
- _shieldWindow = new CUIWindow(_gameRef);
+ _shieldWindow = new UIWindow(_gameRef);
_horizontal = false;
- CBPlatform::setRectEmpty(&_responseArea);
+ BasePlatform::setRectEmpty(&_responseArea);
_scrollOffset = 0;
_spacing = 0;
@@ -71,7 +71,7 @@ CAdResponseBox::CAdResponseBox(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdResponseBox::~CAdResponseBox() {
+AdResponseBox::~AdResponseBox() {
delete _window;
_window = NULL;
@@ -93,7 +93,7 @@ CAdResponseBox::~CAdResponseBox() { //////////////////////////////////////////////////////////////////////////
-void CAdResponseBox::clearResponses() {
+void AdResponseBox::clearResponses() {
for (int i = 0; i < _responses.getSize(); i++) {
delete _responses[i];
}
@@ -102,7 +102,7 @@ void CAdResponseBox::clearResponses() { //////////////////////////////////////////////////////////////////////////
-void CAdResponseBox::clearButtons() {
+void AdResponseBox::clearButtons() {
for (int i = 0; i < _respButtons.getSize(); i++) {
delete _respButtons[i];
}
@@ -111,7 +111,7 @@ void CAdResponseBox::clearButtons() { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::invalidateButtons() {
+bool AdResponseBox::invalidateButtons() {
for (int i = 0; i < _respButtons.getSize(); i++) {
_respButtons[i]->_image = NULL;
_respButtons[i]->_cursor = NULL;
@@ -125,12 +125,12 @@ bool CAdResponseBox::invalidateButtons() { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::createButtons() {
+bool AdResponseBox::createButtons() {
clearButtons();
_scrollOffset = 0;
for (int i = 0; i < _responses.getSize(); i++) {
- CUIButton *btn = new CUIButton(_gameRef);
+ UIButton *btn = new UIButton(_gameRef);
if (btn) {
btn->_parent = _window;
btn->_sharedFonts = btn->_sharedImages = true;
@@ -187,10 +187,10 @@ bool CAdResponseBox::createButtons() { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::loadFile(const char *filename) {
+bool AdResponseBox::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdResponseBox::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdResponseBox::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -223,7 +223,7 @@ TOKEN_DEF(VERTICAL_ALIGN) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::loadBuffer(byte *buffer, bool complete) {
+bool AdResponseBox::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(RESPONSE_BOX)
TOKEN_TABLE(TEMPLATE)
@@ -242,7 +242,7 @@ bool CAdResponseBox::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_RESPONSE_BOX) {
@@ -260,7 +260,7 @@ bool CAdResponseBox::loadBuffer(byte *buffer, bool complete) { case TOKEN_WINDOW:
delete _window;
- _window = new CUIWindow(_gameRef);
+ _window = new UIWindow(_gameRef);
if (!_window || DID_FAIL(_window->loadBuffer(params, false))) {
delete _window;
_window = NULL;
@@ -310,7 +310,7 @@ bool CAdResponseBox::loadBuffer(byte *buffer, bool complete) { case TOKEN_CURSOR:
delete _cursor;
- _cursor = new CBSprite(_gameRef);
+ _cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = NULL;
@@ -335,7 +335,7 @@ bool CAdResponseBox::loadBuffer(byte *buffer, bool complete) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdResponseBox::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "RESPONSE_BOX\n");
buffer->putTextIndent(indent, "{\n");
@@ -362,7 +362,7 @@ bool CAdResponseBox::saveAsText(CBDynBuffer *buffer, int indent) { buffer->putTextIndent(indent + 2, "TEXT_ALIGN=\"%s\"\n", "center");
break;
default:
- error("CAdResponseBox::SaveAsText - Unhandled enum");
+ error("AdResponseBox::SaveAsText - Unhandled enum");
break;
}
@@ -388,7 +388,7 @@ bool CAdResponseBox::saveAsText(CBDynBuffer *buffer, int indent) { buffer->putTextIndent(indent + 2, "\n");
// editor properties
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
return STATUS_OK;
@@ -396,10 +396,10 @@ bool CAdResponseBox::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::display() {
+bool AdResponseBox::display() {
Rect32 rect = _responseArea;
if (_window) {
- CBPlatform::offsetRect(&rect, _window->_posX, _window->_posY);
+ BasePlatform::offsetRect(&rect, _window->_posX, _window->_posY);
//_window->display();
}
@@ -482,8 +482,8 @@ bool CAdResponseBox::display() { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::listen(CBScriptHolder *param1, uint32 param2) {
- CUIObject *obj = (CUIObject *)param1;
+bool AdResponseBox::listen(BaseScriptHolder *param1, uint32 param2) {
+ UIObject *obj = (UIObject *)param1;
switch (obj->_type) {
case UI_BUTTON:
@@ -496,11 +496,11 @@ bool CAdResponseBox::listen(CBScriptHolder *param1, uint32 param2) { handleResponse(_responses[param2]);
_waitingScript = NULL;
_gameRef->_state = GAME_RUNNING;
- ((CAdGame *)_gameRef)->_stateEx = GAME_NORMAL;
+ ((AdGame *)_gameRef)->_stateEx = GAME_NORMAL;
_ready = true;
invalidateButtons();
clearResponses();
- } else return CBObject::listen(param1, param2);
+ } else return BaseObject::listen(param1, param2);
break;
default:
error("AdResponseBox::Listen - Unhandled enum");
@@ -511,8 +511,8 @@ bool CAdResponseBox::listen(CBScriptHolder *param1, uint32 param2) { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::persist(CBPersistMgr *persistMgr) {
- CBObject::persist(persistMgr);
+bool AdResponseBox::persist(BasePersistenceManager *persistMgr) {
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_font));
persistMgr->transfer(TMEMBER(_fontHover));
@@ -536,8 +536,8 @@ bool CAdResponseBox::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::weedResponses() {
- CAdGame *adGame = (CAdGame *)_gameRef;
+bool AdResponseBox::weedResponses() {
+ AdGame *adGame = (AdGame *)_gameRef;
for (int i = 0; i < _responses.getSize(); i++) {
switch (_responses[i]->_responseType) {
@@ -557,7 +557,7 @@ bool CAdResponseBox::weedResponses() { }
break;
default:
- warning("CAdResponseBox::WeedResponses - Unhandled enum");
+ warning("AdResponseBox::WeedResponses - Unhandled enum");
break;
}
}
@@ -566,17 +566,17 @@ bool CAdResponseBox::weedResponses() { //////////////////////////////////////////////////////////////////////////
-void CAdResponseBox::setLastResponseText(const char *text, const char *textOrig) {
- CBUtils::setString(&_lastResponseText, text);
- CBUtils::setString(&_lastResponseTextOrig, textOrig);
+void AdResponseBox::setLastResponseText(const char *text, const char *textOrig) {
+ BaseUtils::setString(&_lastResponseText, text);
+ BaseUtils::setString(&_lastResponseTextOrig, textOrig);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::handleResponse(CAdResponse *response) {
+bool AdResponseBox::handleResponse(AdResponse *response) {
setLastResponseText(response->_text, response->_textOrig);
- CAdGame *adGame = (CAdGame *)_gameRef;
+ AdGame *adGame = (AdGame *)_gameRef;
switch (response->_responseType) {
case RESPONSE_ONCE:
@@ -587,7 +587,7 @@ bool CAdResponseBox::handleResponse(CAdResponse *response) { adGame->addGameResponse(response->_iD);
break;
default:
- warning("CAdResponseBox::HandleResponse - Unhandled enum");
+ warning("AdResponseBox::HandleResponse - Unhandled enum");
}
return STATUS_OK;
@@ -595,8 +595,8 @@ bool CAdResponseBox::handleResponse(CAdResponse *response) { //////////////////////////////////////////////////////////////////////////
-CBObject *CAdResponseBox::getNextAccessObject(CBObject *currObject) {
- CBArray<CUIObject *, CUIObject *> objects;
+BaseObject *AdResponseBox::getNextAccessObject(BaseObject *currObject) {
+ BaseArray<UIObject *, UIObject *> objects;
getObjects(objects, true);
if (objects.getSize() == 0) return NULL;
@@ -615,8 +615,8 @@ CBObject *CAdResponseBox::getNextAccessObject(CBObject *currObject) { }
//////////////////////////////////////////////////////////////////////////
-CBObject *CAdResponseBox::getPrevAccessObject(CBObject *currObject) {
- CBArray<CUIObject *, CUIObject *> objects;
+BaseObject *AdResponseBox::getPrevAccessObject(BaseObject *currObject) {
+ BaseArray<UIObject *, UIObject *> objects;
getObjects(objects, true);
if (objects.getSize() == 0) return NULL;
@@ -635,7 +635,7 @@ CBObject *CAdResponseBox::getPrevAccessObject(CBObject *currObject) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdResponseBox::getObjects(CBArray<CUIObject *, CUIObject *> &objects, bool interactiveOnly) {
+bool AdResponseBox::getObjects(BaseArray<UIObject *, UIObject *> &objects, bool interactiveOnly) {
for (int i = 0; i < _respButtons.getSize(); i++) {
objects.add(_respButtons[i]);
}
diff --git a/engines/wintermute/ad/ad_response_box.h b/engines/wintermute/ad/ad_response_box.h index 7c611ef2d6..f77ff3360c 100644 --- a/engines/wintermute/ad/ad_response_box.h +++ b/engines/wintermute/ad/ad_response_box.h @@ -34,23 +34,23 @@ namespace WinterMute {
-class CUIButton;
-class CUIWindow;
-class CUIObject;
-class CAdResponse;
-class CAdResponseBox : public CBObject {
+class UIButton;
+class UIWindow;
+class UIObject;
+class AdResponse;
+class AdResponseBox : public BaseObject {
public:
- CBObject *getNextAccessObject(CBObject *CurrObject);
- CBObject *getPrevAccessObject(CBObject *CurrObject);
- bool getObjects(CBArray<CUIObject *, CUIObject *> &objects, bool interactiveOnly);
+ BaseObject *getNextAccessObject(BaseObject *CurrObject);
+ BaseObject *getPrevAccessObject(BaseObject *CurrObject);
+ bool getObjects(BaseArray<UIObject *, UIObject *> &objects, bool interactiveOnly);
- bool handleResponse(CAdResponse *response);
+ bool handleResponse(AdResponse *response);
void setLastResponseText(const char *text, const char *textOrig);
char *_lastResponseText;
char *_lastResponseTextOrig;
- DECLARE_PERSISTENT(CAdResponseBox, CBObject)
- CScScript *_waitingScript;
- virtual bool listen(CBScriptHolder *param1, uint32 param2);
+ DECLARE_PERSISTENT(AdResponseBox, BaseObject)
+ ScScript *_waitingScript;
+ virtual bool listen(BaseScriptHolder *param1, uint32 param2);
typedef enum {
EVENT_PREV,
EVENT_NEXT,
@@ -61,25 +61,25 @@ public: bool display();
int _spacing;
int _scrollOffset;
- CBFont *_fontHover;
- CBFont *_font;
+ BaseFont *_fontHover;
+ BaseFont *_font;
bool createButtons();
bool invalidateButtons();
void clearButtons();
void clearResponses();
- CAdResponseBox(CBGame *inGame);
- virtual ~CAdResponseBox();
- CBArray<CAdResponse *, CAdResponse *> _responses;
- CBArray<CUIButton *, CUIButton *> _respButtons;
- CUIWindow *_window;
- CUIWindow *_shieldWindow;
+ AdResponseBox(BaseGame *inGame);
+ virtual ~AdResponseBox();
+ BaseArray<AdResponse *, AdResponse *> _responses;
+ BaseArray<UIButton *, UIButton *> _respButtons;
+ UIWindow *_window;
+ UIWindow *_shieldWindow;
bool _horizontal;
Rect32 _responseArea;
int _verticalAlign;
TTextAlign _align;
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_response_context.cpp b/engines/wintermute/ad/ad_response_context.cpp index 02b819d6de..32d9415fe9 100644 --- a/engines/wintermute/ad/ad_response_context.cpp +++ b/engines/wintermute/ad/ad_response_context.cpp @@ -32,24 +32,24 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdResponseContext, false)
+IMPLEMENT_PERSISTENT(AdResponseContext, false)
//////////////////////////////////////////////////////////////////////////
-CAdResponseContext::CAdResponseContext(CBGame *inGame): CBBase(inGame) {
+AdResponseContext::AdResponseContext(BaseGame *inGame): BaseClass(inGame) {
_iD = 0;
_context = NULL;
}
//////////////////////////////////////////////////////////////////////////
-CAdResponseContext::~CAdResponseContext() {
+AdResponseContext::~AdResponseContext() {
delete[] _context;
_context = NULL;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdResponseContext::persist(CBPersistMgr *persistMgr) {
+bool AdResponseContext::persist(BasePersistenceManager *persistMgr) {
persistMgr->transfer(TMEMBER(_gameRef));
persistMgr->transfer(TMEMBER(_context));
persistMgr->transfer(TMEMBER(_iD));
@@ -58,7 +58,7 @@ bool CAdResponseContext::persist(CBPersistMgr *persistMgr) { }
//////////////////////////////////////////////////////////////////////////
-void CAdResponseContext::setContext(const char *context) {
+void AdResponseContext::setContext(const char *context) {
delete[] _context;
_context = NULL;
if (context) {
diff --git a/engines/wintermute/ad/ad_response_context.h b/engines/wintermute/ad/ad_response_context.h index 79eaa27640..d0dc1546b7 100644 --- a/engines/wintermute/ad/ad_response_context.h +++ b/engines/wintermute/ad/ad_response_context.h @@ -34,14 +34,14 @@ namespace WinterMute {
-class CAdResponseContext : public CBBase {
+class AdResponseContext : public BaseClass {
public:
void setContext(const char *context);
int _iD;
char *_context;
- DECLARE_PERSISTENT(CAdResponseContext, CBBase)
- CAdResponseContext(CBGame *inGame);
- virtual ~CAdResponseContext();
+ DECLARE_PERSISTENT(AdResponseContext, BaseClass)
+ AdResponseContext(BaseGame *inGame);
+ virtual ~AdResponseContext();
};
diff --git a/engines/wintermute/ad/ad_rot_level.cpp b/engines/wintermute/ad/ad_rot_level.cpp index 0ffbaf6919..e758eaa1f6 100644 --- a/engines/wintermute/ad/ad_rot_level.cpp +++ b/engines/wintermute/ad/ad_rot_level.cpp @@ -36,27 +36,27 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdRotLevel, false)
+IMPLEMENT_PERSISTENT(AdRotLevel, false)
//////////////////////////////////////////////////////////////////////////
-CAdRotLevel::CAdRotLevel(CBGame *inGame): CBObject(inGame) {
+AdRotLevel::AdRotLevel(BaseGame *inGame): BaseObject(inGame) {
_posX = 0;
_rotation = 0.0f;
}
//////////////////////////////////////////////////////////////////////////
-CAdRotLevel::~CAdRotLevel() {
+AdRotLevel::~AdRotLevel() {
}
//////////////////////////////////////////////////////////////////////////
-bool CAdRotLevel::loadFile(const char *filename) {
+bool AdRotLevel::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdRotLevel::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdRotLevel::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -82,7 +82,7 @@ TOKEN_DEF(ROTATION) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdRotLevel::loadBuffer(byte *buffer, bool complete) {
+bool AdRotLevel::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ROTATION_LEVEL)
TOKEN_TABLE(TEMPLATE)
@@ -93,7 +93,7 @@ bool CAdRotLevel::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ROTATION_LEVEL) {
@@ -135,11 +135,11 @@ bool CAdRotLevel::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdRotLevel::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdRotLevel::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "ROTATION_LEVEL {\n");
buffer->putTextIndent(indent + 2, "X=%d\n", _posX);
buffer->putTextIndent(indent + 2, "ROTATION=%d\n", (int)_rotation);
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
return STATUS_OK;
@@ -147,9 +147,9 @@ bool CAdRotLevel::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdRotLevel::persist(CBPersistMgr *persistMgr) {
+bool AdRotLevel::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_rotation));
diff --git a/engines/wintermute/ad/ad_rot_level.h b/engines/wintermute/ad/ad_rot_level.h index 2bd9519d65..4339a379a5 100644 --- a/engines/wintermute/ad/ad_rot_level.h +++ b/engines/wintermute/ad/ad_rot_level.h @@ -33,13 +33,13 @@ namespace WinterMute {
-class CAdRotLevel : public CBObject {
+class AdRotLevel : public BaseObject {
public:
- DECLARE_PERSISTENT(CAdRotLevel, CBObject)
- CAdRotLevel(CBGame *inGame);
- virtual ~CAdRotLevel();
+ DECLARE_PERSISTENT(AdRotLevel, BaseObject)
+ AdRotLevel(BaseGame *inGame);
+ virtual ~AdRotLevel();
float _rotation;
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
};
diff --git a/engines/wintermute/ad/ad_scale_level.cpp b/engines/wintermute/ad/ad_scale_level.cpp index 220d3c4b39..65e0cc4663 100644 --- a/engines/wintermute/ad/ad_scale_level.cpp +++ b/engines/wintermute/ad/ad_scale_level.cpp @@ -35,26 +35,26 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdScaleLevel, false)
+IMPLEMENT_PERSISTENT(AdScaleLevel, false)
//////////////////////////////////////////////////////////////////////////
-CAdScaleLevel::CAdScaleLevel(CBGame *inGame): CBObject(inGame) {
+AdScaleLevel::AdScaleLevel(BaseGame *inGame): BaseObject(inGame) {
_posY = 0;
_scale = 100;
}
//////////////////////////////////////////////////////////////////////////
-CAdScaleLevel::~CAdScaleLevel() {
+AdScaleLevel::~AdScaleLevel() {
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScaleLevel::loadFile(const char *filename) {
+bool AdScaleLevel::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdScaleLevel::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdScaleLevel::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -80,7 +80,7 @@ TOKEN_DEF(SCALE) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdScaleLevel::loadBuffer(byte *buffer, bool complete) {
+bool AdScaleLevel::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(SCALE_LEVEL)
TOKEN_TABLE(TEMPLATE)
@@ -91,7 +91,7 @@ bool CAdScaleLevel::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_SCALE_LEVEL) {
@@ -133,11 +133,11 @@ bool CAdScaleLevel::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdScaleLevel::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdScaleLevel::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "SCALE_LEVEL {\n");
buffer->putTextIndent(indent + 2, "Y=%d\n", _posY);
buffer->putTextIndent(indent + 2, "SCALE=%d\n", (int)_scale);
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
return STATUS_OK;
@@ -145,9 +145,9 @@ bool CAdScaleLevel::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdScaleLevel::persist(CBPersistMgr *persistMgr) {
+bool AdScaleLevel::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_scale));
diff --git a/engines/wintermute/ad/ad_scale_level.h b/engines/wintermute/ad/ad_scale_level.h index 4a81c00dda..5e84f8c9ce 100644 --- a/engines/wintermute/ad/ad_scale_level.h +++ b/engines/wintermute/ad/ad_scale_level.h @@ -34,13 +34,13 @@ namespace WinterMute {
-class CAdScaleLevel : public CBObject {
+class AdScaleLevel : public BaseObject {
public:
- DECLARE_PERSISTENT(CAdScaleLevel, CBObject)
+ DECLARE_PERSISTENT(AdScaleLevel, BaseObject)
float _scale;
- CAdScaleLevel(CBGame *inGame);
- virtual ~CAdScaleLevel();
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ AdScaleLevel(BaseGame *inGame);
+ virtual ~AdScaleLevel();
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
};
diff --git a/engines/wintermute/ad/ad_scene.cpp b/engines/wintermute/ad/ad_scene.cpp index 11030d6996..104fe6dd4d 100644 --- a/engines/wintermute/ad/ad_scene.cpp +++ b/engines/wintermute/ad/ad_scene.cpp @@ -62,17 +62,17 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdScene, false)
+IMPLEMENT_PERSISTENT(AdScene, false)
//////////////////////////////////////////////////////////////////////////
-CAdScene::CAdScene(CBGame *inGame): CBObject(inGame) {
- _pfTarget = new CBPoint;
+AdScene::AdScene(BaseGame *inGame): BaseObject(inGame) {
+ _pfTarget = new BasePoint;
setDefaults();
}
//////////////////////////////////////////////////////////////////////////
-CAdScene::~CAdScene() {
+AdScene::~AdScene() {
cleanup();
_gameRef->unregisterObject(_fader);
delete _pfTarget;
@@ -81,7 +81,7 @@ CAdScene::~CAdScene() { //////////////////////////////////////////////////////////////////////////
-void CAdScene::setDefaults() {
+void AdScene::setDefaults() {
_initialized = false;
_pfReady = true;
_pfTargetPath = NULL;
@@ -128,7 +128,7 @@ void CAdScene::setDefaults() { _shieldWindow = NULL;
- _fader = new CBFader(_gameRef);
+ _fader = new BaseFader(_gameRef);
_gameRef->registerObject(_fader);
_viewport = NULL;
@@ -136,8 +136,8 @@ void CAdScene::setDefaults() { //////////////////////////////////////////////////////////////////////////
-void CAdScene::cleanup() {
- CBObject::cleanup();
+void AdScene::cleanup() {
+ BaseObject::cleanup();
_mainLayer = NULL; // reference only
@@ -184,7 +184,7 @@ void CAdScene::cleanup() { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::getPath(CBPoint source, CBPoint target, CAdPath *path, CBObject *requester) {
+bool AdScene::getPath(BasePoint source, BasePoint target, AdPath *path, BaseObject *requester) {
if (!_pfReady) return false;
else {
_pfReady = false;
@@ -200,7 +200,7 @@ bool CAdScene::getPath(CBPoint source, CBPoint target, CAdPath *path, CBObject * pfPointsStart();
// first point
- //_pfPath.add(new CAdPathPoint(source.x, source.y, 0));
+ //_pfPath.add(new AdPathPoint(source.x, source.y, 0));
// if we're one pixel stuck, get unstuck
int startX = source.x;
@@ -228,7 +228,7 @@ bool CAdScene::getPath(CBPoint source, CBPoint target, CAdPath *path, CBObject * //CorrectTargetPoint(&target.x, &target.y);
// last point
- //_pfPath.add(new CAdPathPoint(target.x, target.y, INT_MAX));
+ //_pfPath.add(new AdPathPoint(target.x, target.y, INT_MAX));
pfPointsAdd(target.x, target.y, INT_MAX);
// active waypoints
@@ -245,7 +245,7 @@ bool CAdScene::getPath(CBPoint source, CBPoint target, CAdPath *path, CBObject * pfAddWaypointGroup(_objects[i]->_currentWptGroup, requester);
}
}
- CAdGame *adGame = (CAdGame *)_gameRef;
+ AdGame *adGame = (AdGame *)_gameRef;
for (i = 0; i < adGame->_objects.getSize(); i++) {
if (adGame->_objects[i]->_active && adGame->_objects[i] != requester && adGame->_objects[i]->_currentWptGroup) {
pfAddWaypointGroup(adGame->_objects[i]->_currentWptGroup, requester);
@@ -258,26 +258,26 @@ bool CAdScene::getPath(CBPoint source, CBPoint target, CAdPath *path, CBObject * //////////////////////////////////////////////////////////////////////////
-void CAdScene::pfAddWaypointGroup(CAdWaypointGroup *wpt, CBObject *requester) {
+void AdScene::pfAddWaypointGroup(AdWaypointGroup *wpt, BaseObject *requester) {
if (!wpt->_active) return;
for (int i = 0; i < wpt->_points.getSize(); i++) {
if (isBlockedAt(wpt->_points[i]->x, wpt->_points[i]->y, true, requester)) continue;
- //_pfPath.add(new CAdPathPoint(Wpt->_points[i]->x, Wpt->_points[i]->y, INT_MAX));
+ //_pfPath.add(new AdPathPoint(Wpt->_points[i]->x, Wpt->_points[i]->y, INT_MAX));
pfPointsAdd(wpt->_points[i]->x, wpt->_points[i]->y, INT_MAX);
}
}
//////////////////////////////////////////////////////////////////////////
-float CAdScene::getZoomAt(int x, int y) {
+float AdScene::getZoomAt(int x, int y) {
float ret = 100;
bool found = false;
if (_mainLayer) {
for (int i = _mainLayer->_nodes.getSize() - 1; i >= 0; i--) {
- CAdSceneNode *node = _mainLayer->_nodes[i];
+ AdSceneNode *node = _mainLayer->_nodes[i];
if (node->_type == OBJECT_REGION && node->_region->_active && !node->_region->_blocked && node->_region->pointInRegion(x, y)) {
if (node->_region->_zoom != 0) {
ret = node->_region->_zoom;
@@ -294,7 +294,7 @@ float CAdScene::getZoomAt(int x, int y) { //////////////////////////////////////////////////////////////////////////
-uint32 CAdScene::getAlphaAt(int x, int y, bool colorCheck) {
+uint32 AdScene::getAlphaAt(int x, int y, bool colorCheck) {
if (!_gameRef->_debugDebugMode) colorCheck = false;
uint32 ret;
@@ -303,7 +303,7 @@ uint32 CAdScene::getAlphaAt(int x, int y, bool colorCheck) { if (_mainLayer) {
for (int i = _mainLayer->_nodes.getSize() - 1; i >= 0; i--) {
- CAdSceneNode *node = _mainLayer->_nodes[i];
+ AdSceneNode *node = _mainLayer->_nodes[i];
if (node->_type == OBJECT_REGION && node->_region->_active && (colorCheck || !node->_region->_blocked) && node->_region->pointInRegion(x, y)) {
if (!node->_region->_blocked) ret = node->_region->_alpha;
break;
@@ -315,7 +315,7 @@ uint32 CAdScene::getAlphaAt(int x, int y, bool colorCheck) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::isBlockedAt(int x, int y, bool checkFreeObjects, CBObject *requester) {
+bool AdScene::isBlockedAt(int x, int y, bool checkFreeObjects, BaseObject *requester) {
bool ret = true;
@@ -325,7 +325,7 @@ bool CAdScene::isBlockedAt(int x, int y, bool checkFreeObjects, CBObject *reques if (_objects[i]->_currentBlockRegion->pointInRegion(x, y)) return true;
}
}
- CAdGame *adGame = (CAdGame *)_gameRef;
+ AdGame *adGame = (AdGame *)_gameRef;
for (int i = 0; i < adGame->_objects.getSize(); i++) {
if (adGame->_objects[i]->_active && adGame->_objects[i] != requester && adGame->_objects[i]->_currentBlockRegion) {
if (adGame->_objects[i]->_currentBlockRegion->pointInRegion(x, y)) return true;
@@ -336,7 +336,7 @@ bool CAdScene::isBlockedAt(int x, int y, bool checkFreeObjects, CBObject *reques if (_mainLayer) {
for (int i = 0; i < _mainLayer->_nodes.getSize(); i++) {
- CAdSceneNode *node = _mainLayer->_nodes[i];
+ AdSceneNode *node = _mainLayer->_nodes[i];
/*
if (Node->_type == OBJECT_REGION && Node->_region->_active && Node->_region->_blocked && Node->_region->PointInRegion(X, Y))
{
@@ -357,7 +357,7 @@ bool CAdScene::isBlockedAt(int x, int y, bool checkFreeObjects, CBObject *reques //////////////////////////////////////////////////////////////////////////
-bool CAdScene::isWalkableAt(int x, int y, bool checkFreeObjects, CBObject *requester) {
+bool AdScene::isWalkableAt(int x, int y, bool checkFreeObjects, BaseObject *requester) {
bool ret = false;
if (checkFreeObjects) {
@@ -366,7 +366,7 @@ bool CAdScene::isWalkableAt(int x, int y, bool checkFreeObjects, CBObject *reque if (_objects[i]->_currentBlockRegion->pointInRegion(x, y)) return false;
}
}
- CAdGame *adGame = (CAdGame *)_gameRef;
+ AdGame *adGame = (AdGame *)_gameRef;
for (int i = 0; i < adGame->_objects.getSize(); i++) {
if (adGame->_objects[i]->_active && adGame->_objects[i] != requester && adGame->_objects[i]->_currentBlockRegion) {
if (adGame->_objects[i]->_currentBlockRegion->pointInRegion(x, y)) return false;
@@ -377,7 +377,7 @@ bool CAdScene::isWalkableAt(int x, int y, bool checkFreeObjects, CBObject *reque if (_mainLayer) {
for (int i = 0; i < _mainLayer->_nodes.getSize(); i++) {
- CAdSceneNode *node = _mainLayer->_nodes[i];
+ AdSceneNode *node = _mainLayer->_nodes[i];
if (node->_type == OBJECT_REGION && node->_region->_active && !node->_region->_decoration && node->_region->pointInRegion(x, y)) {
if (node->_region->_blocked) {
ret = false;
@@ -391,7 +391,7 @@ bool CAdScene::isWalkableAt(int x, int y, bool checkFreeObjects, CBObject *reque //////////////////////////////////////////////////////////////////////////
-int CAdScene::getPointsDist(CBPoint p1, CBPoint p2, CBObject *requester) {
+int AdScene::getPointsDist(BasePoint p1, BasePoint p2, BaseObject *requester) {
double xStep, yStep, x, y;
int xLength, yLength, xCount, yCount;
int x1, y1, x2, y2;
@@ -406,8 +406,8 @@ int CAdScene::getPointsDist(CBPoint p1, CBPoint p2, CBObject *requester) { if (xLength > yLength) {
if (x1 > x2) {
- CBUtils::swap(&x1, &x2);
- CBUtils::swap(&y1, &y2);
+ BaseUtils::swap(&x1, &x2);
+ BaseUtils::swap(&y1, &y2);
}
yStep = (double)(y2 - y1) / (double)(x2 - x1);
@@ -419,8 +419,8 @@ int CAdScene::getPointsDist(CBPoint p1, CBPoint p2, CBObject *requester) { }
} else {
if (y1 > y2) {
- CBUtils::swap(&x1, &x2);
- CBUtils::swap(&y1, &y2);
+ BaseUtils::swap(&x1, &x2);
+ BaseUtils::swap(&y1, &y2);
}
xStep = (double)(x2 - x1) / (double)(y2 - y1);
@@ -436,11 +436,11 @@ int CAdScene::getPointsDist(CBPoint p1, CBPoint p2, CBObject *requester) { //////////////////////////////////////////////////////////////////////////
-void CAdScene::pathFinderStep() {
+void AdScene::pathFinderStep() {
int i;
// get lowest unmarked
int lowestDist = INT_MAX;
- CAdPathPoint *lowestPt = NULL;
+ AdPathPoint *lowestPt = NULL;
for (i = 0; i < _pfPointsNum; i++)
if (!_pfPath[i]->_marked && _pfPath[i]->_distance < lowestDist) {
@@ -459,7 +459,7 @@ void CAdScene::pathFinderStep() { // target point marked, generate path and terminate
if (lowestPt->x == _pfTarget->x && lowestPt->y == _pfTarget->y) {
while (lowestPt != NULL) {
- _pfTargetPath->_points.insertAt(0, new CBPoint(lowestPt->x, lowestPt->y));
+ _pfTargetPath->_points.insertAt(0, new BasePoint(lowestPt->x, lowestPt->y));
lowestPt = lowestPt->_origin;
}
@@ -481,18 +481,18 @@ void CAdScene::pathFinderStep() { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::initLoop() {
+bool AdScene::initLoop() {
#ifdef _DEBUGxxxx
int nu_steps = 0;
uint32 start = _gameRef->_currentTime;
- while (!_pfReady && CBPlatform::getTime() - start <= _pfMaxTime) {
+ while (!_pfReady && BasePlatform::getTime() - start <= _pfMaxTime) {
PathFinderStep();
nu_steps++;
}
if (nu_steps > 0) _gameRef->LOG(0, "STAT: PathFinder iterations in one loop: %d (%s) _pfMaxTime=%d", nu_steps, _pfReady ? "finished" : "not yet done", _pfMaxTime);
#else
uint32 start = _gameRef->_currentTime;
- while (!_pfReady && CBPlatform::getTime() - start <= _pfMaxTime) pathFinderStep();
+ while (!_pfReady && BasePlatform::getTime() - start <= _pfMaxTime) pathFinderStep();
#endif
return STATUS_OK;
@@ -500,10 +500,10 @@ bool CAdScene::initLoop() { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::loadFile(const char *filename) {
+bool AdScene::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdScene::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdScene::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -565,7 +565,7 @@ TOKEN_DEF(PERSISTENT_STATE) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::loadBuffer(byte *buffer, bool complete) {
+bool AdScene::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(SCENE)
TOKEN_TABLE(TEMPLATE)
@@ -610,7 +610,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_SCENE) {
@@ -639,7 +639,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_LAYER: {
- CAdLayer *layer = new CAdLayer(_gameRef);
+ AdLayer *layer = new AdLayer(_gameRef);
if (!layer || DID_FAIL(layer->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
delete layer;
@@ -657,7 +657,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_WAYPOINTS: {
- CAdWaypointGroup *wpt = new CAdWaypointGroup(_gameRef);
+ AdWaypointGroup *wpt = new AdWaypointGroup(_gameRef);
if (!wpt || DID_FAIL(wpt->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
delete wpt;
@@ -670,7 +670,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_SCALE_LEVEL: {
- CAdScaleLevel *sl = new CAdScaleLevel(_gameRef);
+ AdScaleLevel *sl = new AdScaleLevel(_gameRef);
if (!sl || DID_FAIL(sl->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
delete sl;
@@ -683,7 +683,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_ROTATION_LEVEL: {
- CAdRotLevel *rl = new CAdRotLevel(_gameRef);
+ AdRotLevel *rl = new AdRotLevel(_gameRef);
if (!rl || DID_FAIL(rl->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
delete rl;
@@ -696,7 +696,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_ENTITY: {
- CAdEntity *entity = new CAdEntity(_gameRef);
+ AdEntity *entity = new AdEntity(_gameRef);
if (!entity || DID_FAIL(entity->loadBuffer(params, false))) {
cmd = PARSERR_GENERIC;
delete entity;
@@ -709,7 +709,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { case TOKEN_CURSOR:
delete _cursor;
- _cursor = new CBSprite(_gameRef);
+ _cursor = new BaseSprite(_gameRef);
if (!_cursor || DID_FAIL(_cursor->loadFile((char *)params))) {
delete _cursor;
_cursor = NULL;
@@ -820,7 +820,7 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { case TOKEN_VIEWPORT: {
Rect32 rc;
parser.scanStr((char *)params, "%d,%d,%d,%d", &rc.left, &rc.top, &rc.right, &rc.bottom);
- if (!_viewport) _viewport = new CBViewport(_gameRef);
+ if (!_viewport) _viewport = new BaseViewport(_gameRef);
if (_viewport) _viewport->setRect(rc.left, rc.top, rc.right, rc.bottom, true);
}
@@ -856,11 +856,11 @@ bool CAdScene::loadBuffer(byte *buffer, bool complete) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::traverseNodes(bool doUpdate) {
+bool AdScene::traverseNodes(bool doUpdate) {
if (!_initialized) return STATUS_OK;
int j, k;
- CAdGame *adGame = (CAdGame *)_gameRef;
+ AdGame *adGame = (AdGame *)_gameRef;
//////////////////////////////////////////////////////////////////////////
@@ -949,7 +949,7 @@ bool CAdScene::traverseNodes(bool doUpdate) { // make layer exclusive
if (!doUpdate) {
if (_layers[j]->_closeUp && !_gameRef->_editorMode) {
- if (!_shieldWindow) _shieldWindow = new CUIWindow(_gameRef);
+ if (!_shieldWindow) _shieldWindow = new UIWindow(_gameRef);
if (_shieldWindow) {
_shieldWindow->_posX = _shieldWindow->_posY = 0;
_shieldWindow->_width = _gameRef->_renderer->_width;
@@ -978,7 +978,7 @@ bool CAdScene::traverseNodes(bool doUpdate) { // for each node
for (k = 0; k < _layers[j]->_nodes.getSize(); k++) {
- CAdSceneNode *node = _layers[j]->_nodes[k];
+ AdSceneNode *node = _layers[j]->_nodes[k];
switch (node->_type) {
case OBJECT_ENTITY:
if (node->_entity->_active && (_gameRef->_editorMode || !node->_entity->_editorOnly)) {
@@ -1030,13 +1030,13 @@ bool CAdScene::traverseNodes(bool doUpdate) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::display() {
+bool AdScene::display() {
return traverseNodes(false);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::updateFreeObjects() {
- CAdGame *adGame = (CAdGame *)_gameRef;
+bool AdScene::updateFreeObjects() {
+ AdGame *adGame = (AdGame *)_gameRef;
bool is3DSet;
// *** update all active objects
@@ -1067,10 +1067,10 @@ bool CAdScene::updateFreeObjects() { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::displayRegionContent(CAdRegion *region, bool display3DOnly) {
- CAdGame *adGame = (CAdGame *)_gameRef;
- CBArray<CAdObject *, CAdObject *> objects;
- CAdObject *obj;
+bool AdScene::displayRegionContent(AdRegion *region, bool display3DOnly) {
+ AdGame *adGame = (AdGame *)_gameRef;
+ BaseArray<AdObject *, AdObject *> objects;
+ AdObject *obj;
// global objects
for (int i = 0; i < adGame->_objects.getSize(); i++) {
@@ -1089,7 +1089,7 @@ bool CAdScene::displayRegionContent(CAdRegion *region, bool display3DOnly) { }
// sort by _posY
- qsort(objects.getData(), objects.getSize(), sizeof(CAdObject *), CAdScene::compareObjs);
+ qsort(objects.getData(), objects.getSize(), sizeof(AdObject *), AdScene::compareObjs);
// display them
for (int i = 0; i < objects.getSize(); i++) {
@@ -1120,9 +1120,9 @@ bool CAdScene::displayRegionContent(CAdRegion *region, bool display3DOnly) { }
//////////////////////////////////////////////////////////////////////////
-int CAdScene::compareObjs(const void *obj1, const void *obj2) {
- CAdObject *object1 = *(CAdObject **)obj1;
- CAdObject *object2 = *(CAdObject **)obj2;
+int AdScene::compareObjs(const void *obj1, const void *obj2) {
+ AdObject *object1 = *(AdObject **)obj1;
+ AdObject *object2 = *(AdObject **)obj2;
if (object1->_posY < object2->_posY) return -1;
else if (object1->_posY > object2->_posY) return 1;
@@ -1130,9 +1130,9 @@ int CAdScene::compareObjs(const void *obj1, const void *obj2) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::displayRegionContentOld(CAdRegion *region) {
- CAdGame *adGame = (CAdGame *)_gameRef;
- CAdObject *obj;
+bool AdScene::displayRegionContentOld(AdRegion *region) {
+ AdGame *adGame = (AdGame *)_gameRef;
+ AdObject *obj;
// display all objects in region sorted by _posY
do {
@@ -1180,12 +1180,12 @@ bool CAdScene::displayRegionContentOld(CAdRegion *region) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::update() {
+bool AdScene::update() {
return traverseNodes(true);
}
//////////////////////////////////////////////////////////////////////////
-void CAdScene::scrollTo(int offsetX, int offsetY) {
+void AdScene::scrollTo(int offsetX, int offsetY) {
int viewportWidth, viewportHeight;
getViewportSize(&viewportWidth, &viewportHeight);
@@ -1210,19 +1210,19 @@ void CAdScene::scrollTo(int offsetX, int offsetY) { //////////////////////////////////////////////////////////////////////////
-void CAdScene::scrollToObject(CBObject *object) {
+void AdScene::scrollToObject(BaseObject *object) {
if (object) scrollTo(object->_posX, object->_posY - object->getHeight() / 2);
}
//////////////////////////////////////////////////////////////////////////
-void CAdScene::skipToObject(CBObject *object) {
+void AdScene::skipToObject(BaseObject *object) {
if (object) skipTo(object->_posX, object->_posY - object->getHeight() / 2);
}
//////////////////////////////////////////////////////////////////////////
-void CAdScene::skipTo(int offsetX, int offsetY) {
+void AdScene::skipTo(int offsetX, int offsetY) {
int viewportWidth, viewportHeight;
getViewportSize(&viewportWidth, &viewportHeight);
@@ -1240,13 +1240,13 @@ void CAdScene::skipTo(int offsetX, int offsetY) { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdScene::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// LoadActor
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "LoadActor") == 0) {
stack->correctParams(1);
- CAdActor *act = new CAdActor(_gameRef);
+ AdActor *act = new AdActor(_gameRef);
if (act && DID_SUCCEED(act->loadFile(stack->pop()->getString()))) {
addObject(act);
stack->pushNative(act, true);
@@ -1263,7 +1263,7 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "LoadEntity") == 0) {
stack->correctParams(1);
- CAdEntity *ent = new CAdEntity(_gameRef);
+ AdEntity *ent = new AdEntity(_gameRef);
if (ent && DID_SUCCEED(ent->loadFile(stack->pop()->getString()))) {
addObject(ent);
stack->pushNative(ent, true);
@@ -1280,9 +1280,9 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "CreateEntity") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdEntity *ent = new CAdEntity(_gameRef);
+ AdEntity *ent = new AdEntity(_gameRef);
addObject(ent);
if (!val->isNULL()) ent->setName(val->getString());
stack->pushNative(ent, true);
@@ -1294,8 +1294,8 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "UnloadObject") == 0 || strcmp(name, "UnloadActor") == 0 || strcmp(name, "UnloadEntity") == 0 || strcmp(name, "UnloadActor3D") == 0 || strcmp(name, "DeleteEntity") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
- CAdObject *obj = (CAdObject *)val->getNative();
+ ScValue *val = stack->pop();
+ AdObject *obj = (AdObject *)val->getNative();
removeObject(obj);
if (val->getType() == VAL_VARIABLE_REF) val->setNULL();
@@ -1308,10 +1308,10 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "SkipTo") == 0) {
stack->correctParams(2);
- CScValue *val1 = stack->pop();
- CScValue *val2 = stack->pop();
+ ScValue *val1 = stack->pop();
+ ScValue *val2 = stack->pop();
if (val1->isNative()) {
- skipToObject((CBObject *)val1->getNative());
+ skipToObject((BaseObject *)val1->getNative());
} else {
skipTo(val1->getInt(), val2->getInt());
}
@@ -1324,10 +1324,10 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "ScrollTo") == 0 || strcmp(name, "ScrollToAsync") == 0) {
stack->correctParams(2);
- CScValue *val1 = stack->pop();
- CScValue *val2 = stack->pop();
+ ScValue *val1 = stack->pop();
+ ScValue *val2 = stack->pop();
if (val1->isNative()) {
- scrollToObject((CBObject *)val1->getNative());
+ scrollToObject((BaseObject *)val1->getNative());
} else {
scrollTo(val1->getInt(), val2->getInt());
}
@@ -1341,7 +1341,7 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GetLayer") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
if (val->isInt()) {
int layer = val->getInt();
if (layer < 0 || layer >= _layers.getSize()) stack->pushNULL();
@@ -1379,8 +1379,8 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt stack->correctParams(1);
const char *nodeName = stack->pop()->getString();
- CBObject *node = getNodeByName(nodeName);
- if (node) stack->pushNative((CBScriptable *)node, true);
+ BaseObject *node = getNodeByName(nodeName);
+ if (node) stack->pushNative((BaseScriptable *)node, true);
else stack->pushNULL();
return STATUS_OK;
@@ -1391,9 +1391,9 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "GetFreeNode") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdObject *ret = NULL;
+ AdObject *ret = NULL;
if (val->isInt()) {
int index = val->getInt();
if (index >= 0 && index < _objects.getSize()) ret = _objects[index];
@@ -1419,14 +1419,14 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt stack->correctParams(3);
int x = stack->pop()->getInt();
int y = stack->pop()->getInt();
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
bool includeDecors = false;
if (!val->isNULL()) includeDecors = val->getBool();
if (_mainLayer) {
for (int i = _mainLayer->_nodes.getSize() - 1; i >= 0; i--) {
- CAdSceneNode *node = _mainLayer->_nodes[i];
+ AdSceneNode *node = _mainLayer->_nodes[i];
if (node->_type == OBJECT_REGION && node->_region->_active && node->_region->pointInRegion(x, y)) {
if (node->_region->_decoration && !includeDecors) continue;
@@ -1570,7 +1570,7 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt if (width <= 0) width = _gameRef->_renderer->_width;
if (height <= 0) height = _gameRef->_renderer->_height;
- if (!_viewport) _viewport = new CBViewport(_gameRef);
+ if (!_viewport) _viewport = new BaseViewport(_gameRef);
if (_viewport) _viewport->setRect(x, y, x + width, y + height);
stack->pushBool(true);
@@ -1583,9 +1583,9 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "AddLayer") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdLayer *layer = new CAdLayer(_gameRef);
+ AdLayer *layer = new AdLayer(_gameRef);
if (!val->isNULL()) layer->setName(val->getString());
if (_mainLayer) {
layer->_width = _mainLayer->_width;
@@ -1604,9 +1604,9 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt else if (strcmp(name, "InsertLayer") == 0) {
stack->correctParams(2);
int index = stack->pop()->getInt();
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdLayer *layer = new CAdLayer(_gameRef);
+ AdLayer *layer = new AdLayer(_gameRef);
if (!val->isNULL()) layer->setName(val->getString());
if (_mainLayer) {
layer->_width = _mainLayer->_width;
@@ -1627,11 +1627,11 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt //////////////////////////////////////////////////////////////////////////
else if (strcmp(name, "DeleteLayer") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
- CAdLayer *toDelete = NULL;
+ AdLayer *toDelete = NULL;
if (val->isNative()) {
- CBScriptable *temp = val->getNative();
+ BaseScriptable *temp = val->getNative();
for (int i = 0; i < _layers.getSize(); i++) {
if (_layers[i] == temp) {
toDelete = _layers[i];
@@ -1666,12 +1666,12 @@ bool CAdScene::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisSt return STATUS_OK;
}
- else return CBObject::scCallMethod(script, stack, thisStack, name);
+ else return BaseObject::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdScene::scGetProperty(const char *name) {
+ScValue *AdScene::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -1829,12 +1829,12 @@ CScValue *CAdScene::scGetProperty(const char *name) { return _scValue;
}
- else return CBObject::scGetProperty(name);
+ else return BaseObject::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::scSetProperty(const char *name, CScValue *value) {
+bool AdScene::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Name
//////////////////////////////////////////////////////////////////////////
@@ -1931,25 +1931,25 @@ bool CAdScene::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CBObject::scSetProperty(name, value);
+ else return BaseObject::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdScene::scToString() {
+const char *AdScene::scToString() {
return "[scene object]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::addObject(CAdObject *object) {
+bool AdScene::addObject(AdObject *object) {
_objects.add(object);
return _gameRef->registerObject(object);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::removeObject(CAdObject *object) {
+bool AdScene::removeObject(AdObject *object) {
for (int i = 0; i < _objects.getSize(); i++) {
if (_objects[i] == object) {
_objects.removeAt(i);
@@ -1961,7 +1961,7 @@ bool CAdScene::removeObject(CAdObject *object) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdScene::saveAsText(BaseDynamicBuffer *buffer, int indent) {
int i;
buffer->putTextIndent(indent, "SCENE {\n");
@@ -2019,7 +2019,7 @@ bool CAdScene::saveAsText(CBDynBuffer *buffer, int indent) { buffer->putTextIndent(indent + 2, "\n");
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
// waypoints
buffer->putTextIndent(indent + 2, "; ----- waypoints\n");
@@ -2059,13 +2059,13 @@ bool CAdScene::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::sortScaleLevels() {
+bool AdScene::sortScaleLevels() {
bool changed;
do {
changed = false;
for (int i = 0; i < _scaleLevels.getSize() - 1; i++) {
if (_scaleLevels[i]->_posY > _scaleLevels[i + 1]->_posY) {
- CAdScaleLevel *sl = _scaleLevels[i];
+ AdScaleLevel *sl = _scaleLevels[i];
_scaleLevels[i] = _scaleLevels[i + 1];
_scaleLevels[i + 1] = sl;
@@ -2080,13 +2080,13 @@ bool CAdScene::sortScaleLevels() { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::sortRotLevels() {
+bool AdScene::sortRotLevels() {
bool changed;
do {
changed = false;
for (int i = 0; i < _rotLevels.getSize() - 1; i++) {
if (_rotLevels[i]->_posX > _rotLevels[i + 1]->_posX) {
- CAdRotLevel *rl = _rotLevels[i];
+ AdRotLevel *rl = _rotLevels[i];
_rotLevels[i] = _rotLevels[i + 1];
_rotLevels[i + 1] = rl;
@@ -2101,12 +2101,12 @@ bool CAdScene::sortRotLevels() { //////////////////////////////////////////////////////////////////////////
-float CAdScene::getScaleAt(int Y) {
- CAdScaleLevel *prev = NULL;
- CAdScaleLevel *next = NULL;
+float AdScene::getScaleAt(int Y) {
+ AdScaleLevel *prev = NULL;
+ AdScaleLevel *next = NULL;
for (int i = 0; i < _scaleLevels.getSize(); i++) {
- /* CAdScaleLevel *xxx = _scaleLevels[i];*/
+ /* AdScaleLevel *xxx = _scaleLevels[i];*/
/* int j = _scaleLevels.getSize(); */
if (_scaleLevels[i]->_posY < Y) prev = _scaleLevels[i];
else {
@@ -2127,8 +2127,8 @@ float CAdScene::getScaleAt(int Y) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::persist(CBPersistMgr *persistMgr) {
- CBObject::persist(persistMgr);
+bool AdScene::persist(BasePersistenceManager *persistMgr) {
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_autoScroll));
persistMgr->transfer(TMEMBER(_editorColBlocked));
@@ -2187,12 +2187,12 @@ bool CAdScene::persist(CBPersistMgr *persistMgr) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::afterLoad() {
+bool AdScene::afterLoad() {
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::correctTargetPoint2(int startX, int startY, int *targetX, int *targetY, bool checkFreeObjects, CBObject *requester) {
+bool AdScene::correctTargetPoint2(int startX, int startY, int *targetX, int *targetY, bool checkFreeObjects, BaseObject *requester) {
double xStep, yStep, x, y;
int xLength, yLength, xCount, yCount;
int x1, y1, x2, y2;
@@ -2251,7 +2251,7 @@ bool CAdScene::correctTargetPoint2(int startX, int startY, int *targetX, int *ta }
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::correctTargetPoint(int startX, int startY, int *argX, int *argY, bool checkFreeObjects, CBObject *requester) {
+bool AdScene::correctTargetPoint(int startX, int startY, int *argX, int *argY, bool checkFreeObjects, BaseObject *requester) {
int x = *argX;
int y = *argY;
@@ -2328,15 +2328,15 @@ bool CAdScene::correctTargetPoint(int startX, int startY, int *argX, int *argY, //////////////////////////////////////////////////////////////////////////
-void CAdScene::pfPointsStart() {
+void AdScene::pfPointsStart() {
_pfPointsNum = 0;
}
//////////////////////////////////////////////////////////////////////////
-void CAdScene::pfPointsAdd(int x, int y, int distance) {
+void AdScene::pfPointsAdd(int x, int y, int distance) {
if (_pfPointsNum >= _pfPath.getSize()) {
- _pfPath.add(new CAdPathPoint(x, y, distance));
+ _pfPath.add(new AdPathPoint(x, y, distance));
} else {
_pfPath[_pfPointsNum]->x = x;
_pfPath[_pfPointsNum]->y = y;
@@ -2350,8 +2350,8 @@ void CAdScene::pfPointsAdd(int x, int y, int distance) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::getViewportOffset(int *offsetX, int *offsetY) {
- CAdGame *adGame = (CAdGame *)_gameRef;
+bool AdScene::getViewportOffset(int *offsetX, int *offsetY) {
+ AdGame *adGame = (AdGame *)_gameRef;
if (_viewport && !_gameRef->_editorMode) {
if (offsetX) *offsetX = _viewport->_offsetX;
if (offsetY) *offsetY = _viewport->_offsetY;
@@ -2367,8 +2367,8 @@ bool CAdScene::getViewportOffset(int *offsetX, int *offsetY) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::getViewportSize(int *width, int *height) {
- CAdGame *adGame = (CAdGame *)_gameRef;
+bool AdScene::getViewportSize(int *width, int *height) {
+ AdGame *adGame = (AdGame *)_gameRef;
if (_viewport && !_gameRef->_editorMode) {
if (width) *width = _viewport->getWidth();
if (height) *height = _viewport->getHeight();
@@ -2384,7 +2384,7 @@ bool CAdScene::getViewportSize(int *width, int *height) { //////////////////////////////////////////////////////////////////////////
-int CAdScene::getOffsetLeft() {
+int AdScene::getOffsetLeft() {
int viewportX;
getViewportOffset(&viewportX);
@@ -2393,7 +2393,7 @@ int CAdScene::getOffsetLeft() { //////////////////////////////////////////////////////////////////////////
-int CAdScene::getOffsetTop() {
+int AdScene::getOffsetTop() {
int viewportY;
getViewportOffset(NULL, &viewportY);
@@ -2402,7 +2402,7 @@ int CAdScene::getOffsetTop() { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::pointInViewport(int x, int y) {
+bool AdScene::pointInViewport(int x, int y) {
int left, top, width, height;
getViewportOffset(&left, &top);
@@ -2413,21 +2413,21 @@ bool CAdScene::pointInViewport(int x, int y) { //////////////////////////////////////////////////////////////////////////
-void CAdScene::setOffset(int offsetLeft, int offsetTop) {
+void AdScene::setOffset(int offsetLeft, int offsetTop) {
_offsetLeft = offsetLeft;
_offsetTop = offsetTop;
}
//////////////////////////////////////////////////////////////////////////
-CBObject *CAdScene::getNodeByName(const char *name) {
- CBObject *ret = NULL;
+BaseObject *AdScene::getNodeByName(const char *name) {
+ BaseObject *ret = NULL;
// dependent objects
for (int i = 0; i < _layers.getSize(); i++) {
- CAdLayer *layer = _layers[i];
+ AdLayer *layer = _layers[i];
for (int j = 0; j < layer->_nodes.getSize(); j++) {
- CAdSceneNode *node = layer->_nodes[j];
+ AdSceneNode *node = layer->_nodes[j];
if ((node->_type == OBJECT_ENTITY && !scumm_stricmp(name, node->_entity->_name)) ||
(node->_type == OBJECT_REGION && !scumm_stricmp(name, node->_region->_name))) {
switch (node->_type) {
@@ -2464,32 +2464,32 @@ CBObject *CAdScene::getNodeByName(const char *name) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::saveState() {
+bool AdScene::saveState() {
return persistState(true);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::loadState() {
+bool AdScene::loadState() {
return persistState(false);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::persistState(bool saving) {
+bool AdScene::persistState(bool saving) {
if (!_persistentState) return STATUS_OK;
- CAdGame *adGame = (CAdGame *)_gameRef;
- CAdSceneState *state = adGame->getSceneState(_filename, saving);
+ AdGame *adGame = (AdGame *)_gameRef;
+ AdSceneState *state = adGame->getSceneState(_filename, saving);
if (!state) return STATUS_OK;
- CAdNodeState *nodeState;
+ AdNodeState *nodeState;
// dependent objects
for (int i = 0; i < _layers.getSize(); i++) {
- CAdLayer *layer = _layers[i];
+ AdLayer *layer = _layers[i];
for (int j = 0; j < layer->_nodes.getSize(); j++) {
- CAdSceneNode *node = layer->_nodes[j];
+ AdSceneNode *node = layer->_nodes[j];
switch (node->_type) {
case OBJECT_ENTITY:
if (!node->_entity->_saveState) continue;
@@ -2509,7 +2509,7 @@ bool CAdScene::persistState(bool saving) { }
break;
default:
- warning("CAdScene::PersistState - unhandled enum");
+ warning("AdScene::PersistState - unhandled enum");
break;
}
}
@@ -2521,7 +2521,7 @@ bool CAdScene::persistState(bool saving) { if (_objects[i]->_type == OBJECT_ENTITY) {
nodeState = state->getNodeState(_objects[i]->_name, saving);
if (nodeState) {
- nodeState->transferEntity((CAdEntity *)_objects[i], _persistentStateSprites, saving);
+ nodeState->transferEntity((AdEntity *)_objects[i], _persistentStateSprites, saving);
//if(Saving) NodeState->_active = _objects[i]->_active;
//else _objects[i]->_active = NodeState->_active;
}
@@ -2542,12 +2542,12 @@ bool CAdScene::persistState(bool saving) { //////////////////////////////////////////////////////////////////////////
-float CAdScene::getRotationAt(int x, int y) {
- CAdRotLevel *prev = NULL;
- CAdRotLevel *next = NULL;
+float AdScene::getRotationAt(int x, int y) {
+ AdRotLevel *prev = NULL;
+ AdRotLevel *next = NULL;
for (int i = 0; i < _rotLevels.getSize(); i++) {
- /* CAdRotLevel *xxx = _rotLevels[i];
+ /* AdRotLevel *xxx = _rotLevels[i];
int j = _rotLevels.getSize();*/
if (_rotLevels[i]->_posX < x) prev = _rotLevels[i];
else {
@@ -2568,12 +2568,12 @@ float CAdScene::getRotationAt(int x, int y) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::handleItemAssociations(const char *itemName, bool show) {
+bool AdScene::handleItemAssociations(const char *itemName, bool show) {
for (int i = 0; i < _layers.getSize(); i++) {
- CAdLayer *layer = _layers[i];
+ AdLayer *layer = _layers[i];
for (int j = 0; j < layer->_nodes.getSize(); j++) {
if (layer->_nodes[j]->_type == OBJECT_ENTITY) {
- CAdEntity *ent = layer->_nodes[j]->_entity;
+ AdEntity *ent = layer->_nodes[j]->_entity;
if (ent->_item && strcmp(ent->_item, itemName) == 0) ent->_active = show;
}
@@ -2582,7 +2582,7 @@ bool CAdScene::handleItemAssociations(const char *itemName, bool show) { for (int i = 0; i < _objects.getSize(); i++) {
if (_objects[i]->_type == OBJECT_ENTITY) {
- CAdEntity *ent = (CAdEntity *)_objects[i];
+ AdEntity *ent = (AdEntity *)_objects[i];
if (ent->_item && strcmp(ent->_item, itemName) == 0) ent->_active = show;
}
}
@@ -2592,11 +2592,11 @@ bool CAdScene::handleItemAssociations(const char *itemName, bool show) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::getRegionsAt(int x, int y, CAdRegion **regionList, int numRegions) {
+bool AdScene::getRegionsAt(int x, int y, AdRegion **regionList, int numRegions) {
int numUsed = 0;
if (_mainLayer) {
for (int i = _mainLayer->_nodes.getSize() - 1; i >= 0; i--) {
- CAdSceneNode *node = _mainLayer->_nodes[i];
+ AdSceneNode *node = _mainLayer->_nodes[i];
if (node->_type == OBJECT_REGION && node->_region->_active && node->_region->pointInRegion(x, y)) {
if (numUsed < numRegions - 1) {
regionList[numUsed] = node->_region;
@@ -2613,14 +2613,14 @@ bool CAdScene::getRegionsAt(int x, int y, CAdRegion **regionList, int numRegions }
//////////////////////////////////////////////////////////////////////////
-bool CAdScene::restoreDeviceObjects() {
+bool AdScene::restoreDeviceObjects() {
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-CBObject *CAdScene::getNextAccessObject(CBObject *currObject) {
- CBArray<CAdObject *, CAdObject *> objects;
+BaseObject *AdScene::getNextAccessObject(BaseObject *currObject) {
+ BaseArray<AdObject *, AdObject *> objects;
getSceneObjects(objects, true);
if (objects.getSize() == 0) return NULL;
@@ -2639,8 +2639,8 @@ CBObject *CAdScene::getNextAccessObject(CBObject *currObject) { }
//////////////////////////////////////////////////////////////////////////
-CBObject *CAdScene::getPrevAccessObject(CBObject *currObject) {
- CBArray<CAdObject *, CAdObject *> objects;
+BaseObject *AdScene::getPrevAccessObject(BaseObject *currObject) {
+ BaseArray<AdObject *, AdObject *> objects;
getSceneObjects(objects, true);
if (objects.getSize() == 0) return NULL;
@@ -2660,24 +2660,24 @@ CBObject *CAdScene::getPrevAccessObject(CBObject *currObject) { //////////////////////////////////////////////////////////////////////////
-bool CAdScene::getSceneObjects(CBArray<CAdObject *, CAdObject *> &objects, bool interactiveOnly) {
+bool AdScene::getSceneObjects(BaseArray<AdObject *, AdObject *> &objects, bool interactiveOnly) {
for (int i = 0; i < _layers.getSize(); i++) {
// close-up layer -> remove everything below it
if (interactiveOnly && _layers[i]->_closeUp) objects.removeAll();
for (int j = 0; j < _layers[i]->_nodes.getSize(); j++) {
- CAdSceneNode *node = _layers[i]->_nodes[j];
+ AdSceneNode *node = _layers[i]->_nodes[j];
switch (node->_type) {
case OBJECT_ENTITY: {
- CAdEntity *ent = node->_entity;
+ AdEntity *ent = node->_entity;
if (ent->_active && (ent->_registrable || !interactiveOnly))
objects.add(ent);
}
break;
case OBJECT_REGION: {
- CBArray<CAdObject *, CAdObject *> regionObj;
+ BaseArray<AdObject *, AdObject *> regionObj;
getRegionObjects(node->_region, regionObj, interactiveOnly);
for (int newIndex = 0; newIndex < regionObj.getSize(); newIndex++) {
bool found = false;
@@ -2693,14 +2693,14 @@ bool CAdScene::getSceneObjects(CBArray<CAdObject *, CAdObject *> &objects, bool }
break;
default:
- warning("CAdScene::GetSceneObjects - Unhandled enum");
+ warning("AdScene::GetSceneObjects - Unhandled enum");
break;
}
}
}
// objects outside any region
- CBArray<CAdObject *, CAdObject *> regionObj;
+ BaseArray<AdObject *, AdObject *> regionObj;
getRegionObjects(NULL, regionObj, interactiveOnly);
for (int newIndex = 0; newIndex < regionObj.getSize(); newIndex++) {
bool found = false;
@@ -2719,9 +2719,9 @@ bool CAdScene::getSceneObjects(CBArray<CAdObject *, CAdObject *> &objects, bool //////////////////////////////////////////////////////////////////////////
-bool CAdScene::getRegionObjects(CAdRegion *region, CBArray<CAdObject *, CAdObject *> &objects, bool interactiveOnly) {
- CAdGame *adGame = (CAdGame *)_gameRef;
- CAdObject *obj;
+bool AdScene::getRegionObjects(AdRegion *region, BaseArray<AdObject *, AdObject *> &objects, bool interactiveOnly) {
+ AdGame *adGame = (AdGame *)_gameRef;
+ AdObject *obj;
// global objects
for (int i = 0; i < adGame->_objects.getSize(); i++) {
@@ -2744,7 +2744,7 @@ bool CAdScene::getRegionObjects(CAdRegion *region, CBArray<CAdObject *, CAdObjec }
// sort by _posY
- qsort(objects.getData(), objects.getSize(), sizeof(CAdObject *), CAdScene::compareObjs);
+ qsort(objects.getData(), objects.getSize(), sizeof(AdObject *), AdScene::compareObjs);
return STATUS_OK;
}
diff --git a/engines/wintermute/ad/ad_scene.h b/engines/wintermute/ad/ad_scene.h index ab62a4a7fc..b1420cc5c2 100644 --- a/engines/wintermute/ad/ad_scene.h +++ b/engines/wintermute/ad/ad_scene.h @@ -33,53 +33,53 @@ namespace WinterMute {
-class CUIWindow;
-class CAdObject;
-class CAdRegion;
-class CBViewport;
-class CAdLayer;
-class CBPoint;
-class CAdWaypointGroup;
-class CAdPath;
-class CAdScaleLevel;
-class CAdRotLevel;
-class CAdPathPoint;
-class CAdScene : public CBObject {
+class UIWindow;
+class AdObject;
+class AdRegion;
+class BaseViewport;
+class AdLayer;
+class BasePoint;
+class AdWaypointGroup;
+class AdPath;
+class AdScaleLevel;
+class AdRotLevel;
+class AdPathPoint;
+class AdScene : public BaseObject {
public:
- CBObject *getNextAccessObject(CBObject *CurrObject);
- CBObject *getPrevAccessObject(CBObject *CurrObject);
- bool getSceneObjects(CBArray<CAdObject *, CAdObject *> &Objects, bool InteractiveOnly);
- bool getRegionObjects(CAdRegion *Region, CBArray<CAdObject *, CAdObject *> &Objects, bool InteractiveOnly);
+ BaseObject *getNextAccessObject(BaseObject *CurrObject);
+ BaseObject *getPrevAccessObject(BaseObject *CurrObject);
+ bool getSceneObjects(BaseArray<AdObject *, AdObject *> &Objects, bool InteractiveOnly);
+ bool getRegionObjects(AdRegion *Region, BaseArray<AdObject *, AdObject *> &Objects, bool InteractiveOnly);
bool afterLoad();
- bool getRegionsAt(int X, int Y, CAdRegion **RegionList, int NumRegions);
+ bool getRegionsAt(int X, int Y, AdRegion **RegionList, int NumRegions);
bool handleItemAssociations(const char *ItemName, bool Show);
- CUIWindow *_shieldWindow;
+ UIWindow *_shieldWindow;
float getRotationAt(int X, int Y);
bool loadState();
bool saveState();
bool _persistentState;
bool _persistentStateSprites;
- CBObject *getNodeByName(const char *name);
+ BaseObject *getNodeByName(const char *name);
void setOffset(int OffsetLeft, int OffsetTop);
bool pointInViewport(int X, int Y);
int getOffsetTop();
int getOffsetLeft();
bool getViewportSize(int *Width = NULL, int *Height = NULL);
bool getViewportOffset(int *OffsetX = NULL, int *OffsetY = NULL);
- CBViewport *_viewport;
- CBFader *_fader;
+ BaseViewport *_viewport;
+ BaseFader *_fader;
int _pfPointsNum;
void pfPointsAdd(int X, int Y, int Distance);
void pfPointsStart();
bool _initialized;
- bool correctTargetPoint(int StartX, int StartY, int *X, int *Y, bool CheckFreeObjects = false, CBObject *Requester = NULL);
- bool correctTargetPoint2(int StartX, int StartY, int *TargetX, int *TargetY, bool CheckFreeObjects, CBObject *Requester);
- DECLARE_PERSISTENT(CAdScene, CBObject)
- bool displayRegionContent(CAdRegion *Region = NULL, bool Display3DOnly = false);
- bool displayRegionContentOld(CAdRegion *Region = NULL);
+ bool correctTargetPoint(int StartX, int StartY, int *X, int *Y, bool CheckFreeObjects = false, BaseObject *Requester = NULL);
+ bool correctTargetPoint2(int StartX, int StartY, int *TargetX, int *TargetY, bool CheckFreeObjects, BaseObject *Requester);
+ DECLARE_PERSISTENT(AdScene, BaseObject)
+ bool displayRegionContent(AdRegion *Region = NULL, bool Display3DOnly = false);
+ bool displayRegionContentOld(AdRegion *Region = NULL);
static int compareObjs(const void *Obj1, const void *Obj2);
bool updateFreeObjects();
@@ -87,14 +87,14 @@ public: float getScaleAt(int Y);
bool sortScaleLevels();
bool sortRotLevels();
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
uint32 getAlphaAt(int X, int Y, bool ColorCheck = false);
bool _paralaxScrolling;
void skipTo(int OffsetX, int OffsetY);
void setDefaults();
void cleanup();
- void skipToObject(CBObject *Object);
- void scrollToObject(CBObject *Object);
+ void skipToObject(BaseObject *Object);
+ void scrollToObject(BaseObject *Object);
void scrollTo(int OffsetX, int OffsetY);
virtual bool update();
bool _autoScroll;
@@ -113,22 +113,22 @@ public: uint32 _pfMaxTime;
bool initLoop();
void pathFinderStep();
- bool isBlockedAt(int X, int Y, bool CheckFreeObjects = false, CBObject *Requester = NULL);
- bool isWalkableAt(int X, int Y, bool CheckFreeObjects = false, CBObject *Requester = NULL);
- CAdLayer *_mainLayer;
+ bool isBlockedAt(int X, int Y, bool CheckFreeObjects = false, BaseObject *Requester = NULL);
+ bool isWalkableAt(int X, int Y, bool CheckFreeObjects = false, BaseObject *Requester = NULL);
+ AdLayer *_mainLayer;
float getZoomAt(int X, int Y);
- bool getPath(CBPoint source, CBPoint target, CAdPath *path, CBObject *requester = NULL);
- CAdScene(CBGame *inGame);
- virtual ~CAdScene();
- CBArray<CAdLayer *, CAdLayer *> _layers;
- CBArray<CAdObject *, CAdObject *> _objects;
- CBArray<CAdWaypointGroup *, CAdWaypointGroup *> _waypointGroups;
+ bool getPath(BasePoint source, BasePoint target, AdPath *path, BaseObject *requester = NULL);
+ AdScene(BaseGame *inGame);
+ virtual ~AdScene();
+ BaseArray<AdLayer *, AdLayer *> _layers;
+ BaseArray<AdObject *, AdObject *> _objects;
+ BaseArray<AdWaypointGroup *, AdWaypointGroup *> _waypointGroups;
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
int _width;
int _height;
- bool addObject(CAdObject *Object);
- bool removeObject(CAdObject *Object);
+ bool addObject(AdObject *Object);
+ bool removeObject(AdObject *Object);
int _editorMarginH;
int _editorMarginV;
uint32 _editorColFrame;
@@ -149,27 +149,27 @@ public: bool _editorShowDecor;
bool _editorShowEntities;
bool _editorShowScale;
- CBArray<CAdScaleLevel *, CAdScaleLevel *> _scaleLevels;
- CBArray<CAdRotLevel *, CAdRotLevel *> _rotLevels;
+ BaseArray<AdScaleLevel *, AdScaleLevel *> _scaleLevels;
+ BaseArray<AdRotLevel *, AdRotLevel *> _rotLevels;
virtual bool restoreDeviceObjects();
- int getPointsDist(CBPoint p1, CBPoint p2, CBObject *requester = NULL);
+ int getPointsDist(BasePoint p1, BasePoint p2, BaseObject *requester = NULL);
// 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:
bool persistState(bool Saving = true);
- void pfAddWaypointGroup(CAdWaypointGroup *Wpt, CBObject *Requester = NULL);
+ void pfAddWaypointGroup(AdWaypointGroup *Wpt, BaseObject *Requester = NULL);
bool _pfReady;
- CBPoint *_pfTarget;
- CAdPath *_pfTargetPath;
- CBObject *_pfRequester;
- CBArray<CAdPathPoint *, CAdPathPoint *> _pfPath;
+ BasePoint *_pfTarget;
+ AdPath *_pfTargetPath;
+ BaseObject *_pfRequester;
+ BaseArray<AdPathPoint *, AdPathPoint *> _pfPath;
int _offsetTop;
int _offsetLeft;
diff --git a/engines/wintermute/ad/ad_scene_node.cpp b/engines/wintermute/ad/ad_scene_node.cpp index da7082105f..dbf68ff0ca 100644 --- a/engines/wintermute/ad/ad_scene_node.cpp +++ b/engines/wintermute/ad/ad_scene_node.cpp @@ -32,10 +32,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdSceneNode, false)
+IMPLEMENT_PERSISTENT(AdSceneNode, false)
//////////////////////////////////////////////////////////////////////////
-CAdSceneNode::CAdSceneNode(CBGame *inGame): CBObject(inGame) {
+AdSceneNode::AdSceneNode(BaseGame *inGame): BaseObject(inGame) {
_type = OBJECT_NONE;
_region = NULL;
_entity = NULL;
@@ -43,7 +43,7 @@ CAdSceneNode::CAdSceneNode(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdSceneNode::~CAdSceneNode() {
+AdSceneNode::~AdSceneNode() {
_gameRef->unregisterObject(_region);
_region = NULL;
@@ -53,7 +53,7 @@ CAdSceneNode::~CAdSceneNode() { //////////////////////////////////////////////////////////////////////////
-bool CAdSceneNode::setEntity(CAdEntity *entity) {
+bool AdSceneNode::setEntity(AdEntity *entity) {
_type = OBJECT_ENTITY;
_entity = entity;
return _gameRef->registerObject(entity);
@@ -61,7 +61,7 @@ bool CAdSceneNode::setEntity(CAdEntity *entity) { //////////////////////////////////////////////////////////////////////////
-bool CAdSceneNode::setRegion(CAdRegion *region) {
+bool AdSceneNode::setRegion(AdRegion *region) {
_type = OBJECT_REGION;
_region = region;
return _gameRef->registerObject(region);
@@ -69,9 +69,9 @@ bool CAdSceneNode::setRegion(CAdRegion *region) { //////////////////////////////////////////////////////////////////////////
-bool CAdSceneNode::persist(CBPersistMgr *persistMgr) {
+bool AdSceneNode::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_entity));
persistMgr->transfer(TMEMBER(_region));
diff --git a/engines/wintermute/ad/ad_scene_node.h b/engines/wintermute/ad/ad_scene_node.h index 1c25f91a2d..b56c351bc8 100644 --- a/engines/wintermute/ad/ad_scene_node.h +++ b/engines/wintermute/ad/ad_scene_node.h @@ -36,16 +36,16 @@ namespace WinterMute {
-class CAdSceneNode : public CBObject {
+class AdSceneNode : public BaseObject {
public:
- DECLARE_PERSISTENT(CAdSceneNode, CBObject)
- bool setRegion(CAdRegion *region);
- bool setEntity(CAdEntity *entity);
- CAdEntity *_entity;
- CAdRegion *_region;
+ DECLARE_PERSISTENT(AdSceneNode, BaseObject)
+ bool setRegion(AdRegion *region);
+ bool setEntity(AdEntity *entity);
+ AdEntity *_entity;
+ AdRegion *_region;
TObjectType _type;
- CAdSceneNode(CBGame *inGame);
- virtual ~CAdSceneNode();
+ AdSceneNode(BaseGame *inGame);
+ virtual ~AdSceneNode();
};
diff --git a/engines/wintermute/ad/ad_scene_state.cpp b/engines/wintermute/ad/ad_scene_state.cpp index 2ac36054a5..da7b417470 100644 --- a/engines/wintermute/ad/ad_scene_state.cpp +++ b/engines/wintermute/ad/ad_scene_state.cpp @@ -35,16 +35,16 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdSceneState, false)
+IMPLEMENT_PERSISTENT(AdSceneState, false)
//////////////////////////////////////////////////////////////////////////
-CAdSceneState::CAdSceneState(CBGame *inGame): CBBase(inGame) {
+AdSceneState::AdSceneState(BaseGame *inGame): BaseClass(inGame) {
_filename = NULL;
}
//////////////////////////////////////////////////////////////////////////
-CAdSceneState::~CAdSceneState() {
+AdSceneState::~AdSceneState() {
delete[] _filename;
_filename = NULL;
@@ -54,7 +54,7 @@ CAdSceneState::~CAdSceneState() { //////////////////////////////////////////////////////////////////////////
-bool CAdSceneState::persist(CBPersistMgr *persistMgr) {
+bool AdSceneState::persist(BasePersistenceManager *persistMgr) {
persistMgr->transfer(TMEMBER(_filename));
_nodeStates.persist(persistMgr);
@@ -63,7 +63,7 @@ bool CAdSceneState::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-void CAdSceneState::setFilename(const char *filename) {
+void AdSceneState::setFilename(const char *filename) {
delete[] _filename;
_filename = new char [strlen(filename) + 1];
if (_filename) strcpy(_filename, filename);
@@ -71,13 +71,13 @@ void CAdSceneState::setFilename(const char *filename) { //////////////////////////////////////////////////////////////////////////
-CAdNodeState *CAdSceneState::getNodeState(char *name, bool saving) {
+AdNodeState *AdSceneState::getNodeState(char *name, bool saving) {
for (int i = 0; i < _nodeStates.getSize(); i++) {
if (scumm_stricmp(_nodeStates[i]->_name, name) == 0) return _nodeStates[i];
}
if (saving) {
- CAdNodeState *ret = new CAdNodeState(_gameRef);
+ AdNodeState *ret = new AdNodeState(_gameRef);
ret->setName(name);
_nodeStates.add(ret);
diff --git a/engines/wintermute/ad/ad_scene_state.h b/engines/wintermute/ad/ad_scene_state.h index 6df20e0578..7231ba52db 100644 --- a/engines/wintermute/ad/ad_scene_state.h +++ b/engines/wintermute/ad/ad_scene_state.h @@ -34,16 +34,16 @@ #include "engines/wintermute/coll_templ.h"
namespace WinterMute {
-class CAdNodeState;
-class CAdSceneState : public CBBase {
+class AdNodeState;
+class AdSceneState : public BaseClass {
public:
- CAdNodeState *getNodeState(char *name, bool saving);
+ AdNodeState *getNodeState(char *name, bool saving);
void setFilename(const char *filename);
- DECLARE_PERSISTENT(CAdSceneState, CBBase)
- CAdSceneState(CBGame *inGame);
- virtual ~CAdSceneState();
+ DECLARE_PERSISTENT(AdSceneState, BaseClass)
+ AdSceneState(BaseGame *inGame);
+ virtual ~AdSceneState();
char *_filename;
- CBArray<CAdNodeState *, CAdNodeState *> _nodeStates;
+ BaseArray<AdNodeState *, AdNodeState *> _nodeStates;
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_sentence.cpp b/engines/wintermute/ad/ad_sentence.cpp index 2607993aa0..ba59f57451 100644 --- a/engines/wintermute/ad/ad_sentence.cpp +++ b/engines/wintermute/ad/ad_sentence.cpp @@ -41,10 +41,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdSentence, false)
+IMPLEMENT_PERSISTENT(AdSentence, false)
//////////////////////////////////////////////////////////////////////////
-CAdSentence::CAdSentence(CBGame *inGame): CBBase(inGame) {
+AdSentence::AdSentence(BaseGame *inGame): BaseClass(inGame) {
_text = NULL;
_stances = NULL;
_tempStance = NULL;
@@ -72,7 +72,7 @@ CAdSentence::CAdSentence(CBGame *inGame): CBBase(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdSentence::~CAdSentence() {
+AdSentence::~AdSentence() {
delete _sound;
delete[] _text;
delete[] _stances;
@@ -91,7 +91,7 @@ CAdSentence::~CAdSentence() { //////////////////////////////////////////////////////////////////////////
-void CAdSentence::setText(const char *text) {
+void AdSentence::setText(const char *text) {
if (_text) delete [] _text;
_text = new char[strlen(text) + 1];
if (_text) strcpy(_text, text);
@@ -99,7 +99,7 @@ void CAdSentence::setText(const char *text) { //////////////////////////////////////////////////////////////////////////
-void CAdSentence::setStances(const char *stances) {
+void AdSentence::setStances(const char *stances) {
if (_stances) delete [] _stances;
if (stances) {
_stances = new char[strlen(stances) + 1];
@@ -109,20 +109,20 @@ void CAdSentence::setStances(const char *stances) { //////////////////////////////////////////////////////////////////////////
-char *CAdSentence::getCurrentStance() {
+char *AdSentence::getCurrentStance() {
return getStance(_currentStance);
}
//////////////////////////////////////////////////////////////////////////
-char *CAdSentence::getNextStance() {
+char *AdSentence::getNextStance() {
_currentStance++;
return getStance(_currentStance);
}
//////////////////////////////////////////////////////////////////////////
-char *CAdSentence::getStance(int stance) {
+char *AdSentence::getStance(int stance) {
if (_stances == NULL) return NULL;
if (_tempStance) delete [] _tempStance;
@@ -165,7 +165,7 @@ char *CAdSentence::getStance(int stance) { //////////////////////////////////////////////////////////////////////////
-bool CAdSentence::display() {
+bool AdSentence::display() {
if (!_font || !_text) return STATUS_FAILED;
if (_sound && !_soundStarted) {
@@ -178,8 +178,8 @@ bool CAdSentence::display() { int y = _pos.y;
if (!_fixedPos) {
- x = x - ((CAdGame *)_gameRef)->_scene->getOffsetLeft();
- y = y - ((CAdGame *)_gameRef)->_scene->getOffsetTop();
+ x = x - ((AdGame *)_gameRef)->_scene->getOffsetLeft();
+ y = y - ((AdGame *)_gameRef)->_scene->getOffsetTop();
}
@@ -195,7 +195,7 @@ bool CAdSentence::display() { //////////////////////////////////////////////////////////////////////////
-void CAdSentence::setSound(CBSound *sound) {
+void AdSentence::setSound(BaseSound *sound) {
if (!sound) return;
delete _sound;
_sound = sound;
@@ -204,14 +204,14 @@ void CAdSentence::setSound(CBSound *sound) { //////////////////////////////////////////////////////////////////////////
-bool CAdSentence::finish() {
+bool AdSentence::finish() {
if (_sound) _sound->stop();
return STATUS_OK;
}
//////////////////////////////////////////////////////////////////////////
-bool CAdSentence::persist(CBPersistMgr *persistMgr) {
+bool AdSentence::persist(BasePersistenceManager *persistMgr) {
persistMgr->transfer(TMEMBER(_gameRef));
@@ -238,7 +238,7 @@ bool CAdSentence::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdSentence::setupTalkFile(const char *soundFilename) {
+bool AdSentence::setupTalkFile(const char *soundFilename) {
delete _talkDef;
_talkDef = NULL;
_currentSprite = NULL;
@@ -257,7 +257,7 @@ bool CAdSentence::setupTalkFile(const char *soundFilename) { } else return STATUS_OK; // no talk def file found
- _talkDef = new CAdTalkDef(_gameRef);
+ _talkDef = new AdTalkDef(_gameRef);
if (!_talkDef || DID_FAIL(_talkDef->loadFile(talkDefFileName.c_str()))) {
delete _talkDef;
_talkDef = NULL;
@@ -270,7 +270,7 @@ bool CAdSentence::setupTalkFile(const char *soundFilename) { //////////////////////////////////////////////////////////////////////////
-bool CAdSentence::update(TDirection dir) {
+bool AdSentence::update(TDirection dir) {
if (!_talkDef) return STATUS_OK;
uint32 currentTime;
@@ -287,7 +287,7 @@ bool CAdSentence::update(TDirection dir) { if (_talkDef->_nodes[i]->isInTimeInterval(currentTime, dir)) {
talkNodeFound = true;
- CBSprite *newSprite = _talkDef->_nodes[i]->getSprite(dir);
+ BaseSprite *newSprite = _talkDef->_nodes[i]->getSprite(dir);
if (newSprite != _currentSprite) newSprite->reset();
_currentSprite = newSprite;
@@ -298,7 +298,7 @@ bool CAdSentence::update(TDirection dir) { // no talk node, try to use default sprite instead (if any)
if (!talkNodeFound) {
- CBSprite *newSprite = _talkDef->getDefaultSprite(dir);
+ BaseSprite *newSprite = _talkDef->getDefaultSprite(dir);
if (newSprite) {
if (newSprite != _currentSprite) newSprite->reset();
_currentSprite = newSprite;
@@ -309,7 +309,7 @@ bool CAdSentence::update(TDirection dir) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdSentence::CanSkip() {
+bool AdSentence::CanSkip() {
// prevent accidental sentence skipping (TODO make configurable)
return (_gameRef->_timer - _startTime) > 300;
}
diff --git a/engines/wintermute/ad/ad_sentence.h b/engines/wintermute/ad/ad_sentence.h index 40f99ea830..6883bd8893 100644 --- a/engines/wintermute/ad/ad_sentence.h +++ b/engines/wintermute/ad/ad_sentence.h @@ -37,28 +37,28 @@ #include "common/rect.h"
namespace WinterMute {
-class CAdTalkDef;
-class CBFont;
-class CBSprite;
-class CBSound;
-class CAdSentence : public CBBase {
+class AdTalkDef;
+class BaseFont;
+class BaseSprite;
+class BaseSound;
+class AdSentence : public BaseClass {
public:
bool _freezable;
bool _fixedPos;
- CBSprite *_currentSprite;
+ BaseSprite *_currentSprite;
char *_currentSkelAnim;
bool update(TDirection dir = DI_DOWN);
bool setupTalkFile(const char *soundFilename);
- DECLARE_PERSISTENT(CAdSentence, CBBase)
+ DECLARE_PERSISTENT(AdSentence, BaseClass)
bool finish();
- void setSound(CBSound *Sound);
+ void setSound(BaseSound *Sound);
bool _soundStarted;
- CBSound *_sound;
+ BaseSound *_sound;
TTextAlign _align;
bool display();
int _width;
Point32 _pos;
- CBFont *_font;
+ BaseFont *_font;
char *getNextStance();
char *getCurrentStance();
void setStances(const char *stances);
@@ -68,9 +68,9 @@ public: char *_stances;
char *_text;
uint32 _duration;
- CAdSentence(CBGame *inGame);
- virtual ~CAdSentence();
- CAdTalkDef *_talkDef;
+ AdSentence(BaseGame *inGame);
+ virtual ~AdSentence();
+ AdTalkDef *_talkDef;
bool CanSkip();
diff --git a/engines/wintermute/ad/ad_sprite_set.cpp b/engines/wintermute/ad/ad_sprite_set.cpp index f0925c6913..b594bd0467 100644 --- a/engines/wintermute/ad/ad_sprite_set.cpp +++ b/engines/wintermute/ad/ad_sprite_set.cpp @@ -35,10 +35,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdSpriteSet, false)
+IMPLEMENT_PERSISTENT(AdSpriteSet, false)
//////////////////////////////////////////////////////////////////////////
-CAdSpriteSet::CAdSpriteSet(CBGame *inGame, CBObject *owner): CBObject(inGame) {
+AdSpriteSet::AdSpriteSet(BaseGame *inGame, BaseObject *owner): BaseObject(inGame) {
_owner = owner;
for (int i = 0; i < NUM_DIRECTIONS; i++)
@@ -47,7 +47,7 @@ CAdSpriteSet::CAdSpriteSet(CBGame *inGame, CBObject *owner): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdSpriteSet::~CAdSpriteSet() {
+AdSpriteSet::~AdSpriteSet() {
for (int i = 0; i < NUM_DIRECTIONS; i++) {
delete _sprites[i];
_sprites[i] = NULL;
@@ -58,10 +58,10 @@ CAdSpriteSet::~CAdSpriteSet() { //////////////////////////////////////////////////////////////////////////
-bool CAdSpriteSet::loadFile(const char *filename, int lifeTime, TSpriteCacheType cacheType) {
+bool AdSpriteSet::loadFile(const char *filename, int lifeTime, TSpriteCacheType cacheType) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdSpriteSet::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdSpriteSet::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -90,7 +90,7 @@ TOKEN_DEF(TEMPLATE) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteCacheType CacheType) {
+bool AdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSpriteCacheType CacheType) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(SPRITESET)
TOKEN_TABLE(NAME)
@@ -108,7 +108,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_SPRITESET) {
@@ -118,7 +118,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite buffer = params;
}
- CBSprite *spr = NULL;
+ BaseSprite *spr = NULL;
while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_TEMPLATE:
@@ -132,7 +132,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_LEFT:
delete _sprites[DI_LEFT];
_sprites[DI_LEFT] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_LEFT] = spr;
break;
@@ -140,7 +140,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_RIGHT:
delete _sprites[DI_RIGHT];
_sprites[DI_RIGHT] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_RIGHT] = spr;
break;
@@ -148,7 +148,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_UP:
delete _sprites[DI_UP];
_sprites[DI_UP] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_UP] = spr;
break;
@@ -156,7 +156,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_DOWN:
delete _sprites[DI_DOWN];
_sprites[DI_DOWN] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_DOWN] = spr;
break;
@@ -164,7 +164,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_UP_LEFT:
delete _sprites[DI_UPLEFT];
_sprites[DI_UPLEFT] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_UPLEFT] = spr;
break;
@@ -172,7 +172,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_UP_RIGHT:
delete _sprites[DI_UPRIGHT];
_sprites[DI_UPRIGHT] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_UPRIGHT] = spr;
break;
@@ -180,7 +180,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_DOWN_LEFT:
delete _sprites[DI_DOWNLEFT];
_sprites[DI_DOWNLEFT] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_DOWNLEFT] = spr;
break;
@@ -188,7 +188,7 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite case TOKEN_DOWN_RIGHT:
delete _sprites[DI_DOWNRIGHT];
_sprites[DI_DOWNRIGHT] = NULL;
- spr = new CBSprite(_gameRef, _owner);
+ spr = new BaseSprite(_gameRef, _owner);
if (!spr || DID_FAIL(spr->loadFile((char *)params, lifeTime, CacheType))) cmd = PARSERR_GENERIC;
else _sprites[DI_DOWNRIGHT] = spr;
break;
@@ -214,9 +214,9 @@ bool CAdSpriteSet::loadBuffer(byte *buffer, bool complete, int lifeTime, TSprite //////////////////////////////////////////////////////////////////////////
-bool CAdSpriteSet::persist(CBPersistMgr *persistMgr) {
+bool AdSpriteSet::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_owner));
for (int i = 0; i < NUM_DIRECTIONS; i++) {
@@ -228,12 +228,12 @@ bool CAdSpriteSet::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-CBSprite *CAdSpriteSet::getSprite(TDirection direction) {
+BaseSprite *AdSpriteSet::getSprite(TDirection direction) {
int dir = (int)direction;
if (dir < 0) dir = 0;
if (dir >= NUM_DIRECTIONS) dir = NUM_DIRECTIONS - 1;
- CBSprite *ret = NULL;
+ BaseSprite *ret = NULL;
// find nearest set sprite
int numSteps = 0;
@@ -258,7 +258,7 @@ CBSprite *CAdSpriteSet::getSprite(TDirection direction) { //////////////////////////////////////////////////////////////////////////
-bool CAdSpriteSet::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdSpriteSet::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "SPRITESET {\n");
if (_name) buffer->putTextIndent(indent + 2, "NAME=\"%s\"\n", _name);
for (int i = 0; i < NUM_DIRECTIONS; i++) {
@@ -292,7 +292,7 @@ bool CAdSpriteSet::saveAsText(CBDynBuffer *buffer, int indent) { }
}
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
@@ -300,7 +300,7 @@ bool CAdSpriteSet::saveAsText(CBDynBuffer *buffer, int indent) { }
//////////////////////////////////////////////////////////////////////////
-bool CAdSpriteSet::containsSprite(CBSprite *sprite) {
+bool AdSpriteSet::containsSprite(BaseSprite *sprite) {
if (!sprite) return false;
for (int i = 0; i < NUM_DIRECTIONS; i++) {
diff --git a/engines/wintermute/ad/ad_sprite_set.h b/engines/wintermute/ad/ad_sprite_set.h index 993832cfa3..196d8a8e3a 100644 --- a/engines/wintermute/ad/ad_sprite_set.h +++ b/engines/wintermute/ad/ad_sprite_set.h @@ -35,18 +35,18 @@ namespace WinterMute {
-class CAdSpriteSet : public CBObject {
+class AdSpriteSet : public BaseObject {
public:
- bool containsSprite(CBSprite *sprite);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent = 0);
- CBSprite *getSprite(TDirection direction);
- DECLARE_PERSISTENT(CAdSpriteSet, CBObject)
- CBObject *_owner;
- CAdSpriteSet(CBGame *inGame, CBObject *owner = NULL);
- virtual ~CAdSpriteSet();
+ bool containsSprite(BaseSprite *sprite);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent = 0);
+ BaseSprite *getSprite(TDirection direction);
+ DECLARE_PERSISTENT(AdSpriteSet, BaseObject)
+ BaseObject *_owner;
+ AdSpriteSet(BaseGame *inGame, BaseObject *owner = NULL);
+ virtual ~AdSpriteSet();
bool loadFile(const char *filename, int lifeTime = -1, TSpriteCacheType cacheType = CACHE_ALL);
bool loadBuffer(byte *buffer, bool complete = true, int lifeTime = -1, TSpriteCacheType cacheType = CACHE_ALL);
- CBSprite *_sprites[NUM_DIRECTIONS];
+ BaseSprite *_sprites[NUM_DIRECTIONS];
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_talk_def.cpp b/engines/wintermute/ad/ad_talk_def.cpp index 0cd62df603..979e8b2698 100644 --- a/engines/wintermute/ad/ad_talk_def.cpp +++ b/engines/wintermute/ad/ad_talk_def.cpp @@ -39,10 +39,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdTalkDef, false)
+IMPLEMENT_PERSISTENT(AdTalkDef, false)
//////////////////////////////////////////////////////////////////////////
-CAdTalkDef::CAdTalkDef(CBGame *inGame): CBObject(inGame) {
+AdTalkDef::AdTalkDef(BaseGame *inGame): BaseObject(inGame) {
_defaultSpriteFilename = NULL;
_defaultSprite = NULL;
@@ -52,7 +52,7 @@ CAdTalkDef::CAdTalkDef(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdTalkDef::~CAdTalkDef() {
+AdTalkDef::~AdTalkDef() {
for (int i = 0; i < _nodes.getSize(); i++) delete _nodes[i];
_nodes.removeAll();
@@ -69,16 +69,16 @@ CAdTalkDef::~CAdTalkDef() { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkDef::loadFile(const char *filename) {
+bool AdTalkDef::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdTalkDef::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdTalkDef::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
bool ret;
- CBUtils::setString(&_filename, filename);
+ BaseUtils::setString(&_filename, filename);
if (DID_FAIL(ret = loadBuffer(buffer, true))) _gameRef->LOG(0, "Error parsing TALK file '%s'", filename);
@@ -98,7 +98,7 @@ TOKEN_DEF(DEFAULT_SPRITE) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdTalkDef::loadBuffer(byte *buffer, bool complete) {
+bool AdTalkDef::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(TALK)
TOKEN_TABLE(TEMPLATE)
@@ -111,7 +111,7 @@ bool CAdTalkDef::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_TALK) {
@@ -128,7 +128,7 @@ bool CAdTalkDef::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_ACTION: {
- CAdTalkNode *Node = new CAdTalkNode(_gameRef);
+ AdTalkNode *Node = new AdTalkNode(_gameRef);
if (Node && DID_SUCCEED(Node->loadBuffer(params, false))) _nodes.add(Node);
else {
delete Node;
@@ -139,16 +139,16 @@ bool CAdTalkDef::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_DEFAULT_SPRITE:
- CBUtils::setString(&_defaultSpriteFilename, (char *)params);
+ BaseUtils::setString(&_defaultSpriteFilename, (char *)params);
break;
case TOKEN_DEFAULT_SPRITESET_FILE:
- CBUtils::setString(&_defaultSpriteSetFilename, (char *)params);
+ BaseUtils::setString(&_defaultSpriteSetFilename, (char *)params);
break;
case TOKEN_DEFAULT_SPRITESET: {
delete _defaultSpriteSet;
- _defaultSpriteSet = new CAdSpriteSet(_gameRef);
+ _defaultSpriteSet = new AdSpriteSet(_gameRef);
if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadBuffer(params, false))) {
delete _defaultSpriteSet;
_defaultSpriteSet = NULL;
@@ -179,12 +179,12 @@ bool CAdTalkDef::loadBuffer(byte *buffer, bool complete) { _defaultSpriteSet = NULL;
if (_defaultSpriteFilename) {
- _defaultSprite = new CBSprite(_gameRef);
+ _defaultSprite = new BaseSprite(_gameRef);
if (!_defaultSprite || DID_FAIL(_defaultSprite->loadFile(_defaultSpriteFilename))) return STATUS_FAILED;
}
if (_defaultSpriteSetFilename) {
- _defaultSpriteSet = new CAdSpriteSet(_gameRef);
+ _defaultSpriteSet = new AdSpriteSet(_gameRef);
if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadFile(_defaultSpriteSetFilename))) return STATUS_FAILED;
}
@@ -194,9 +194,9 @@ bool CAdTalkDef::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkDef::persist(CBPersistMgr *persistMgr) {
+bool AdTalkDef::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_defaultSprite));
persistMgr->transfer(TMEMBER(_defaultSpriteFilename));
@@ -210,7 +210,7 @@ bool CAdTalkDef::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkDef::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdTalkDef::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "TALK {\n");
if (_defaultSpriteFilename) buffer->putTextIndent(indent + 2, "DEFAULT_SPRITE=\"%s\"\n", _defaultSpriteFilename);
@@ -221,7 +221,7 @@ bool CAdTalkDef::saveAsText(CBDynBuffer *buffer, int indent) { _nodes[i]->saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "\n");
}
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
@@ -230,16 +230,16 @@ bool CAdTalkDef::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkDef::loadDefaultSprite() {
+bool AdTalkDef::loadDefaultSprite() {
if (_defaultSpriteFilename && !_defaultSprite) {
- _defaultSprite = new CBSprite(_gameRef);
+ _defaultSprite = new BaseSprite(_gameRef);
if (!_defaultSprite || DID_FAIL(_defaultSprite->loadFile(_defaultSpriteFilename))) {
delete _defaultSprite;
_defaultSprite = NULL;
return STATUS_FAILED;
} else return STATUS_OK;
} else if (_defaultSpriteSetFilename && !_defaultSpriteSet) {
- _defaultSpriteSet = new CAdSpriteSet(_gameRef);
+ _defaultSpriteSet = new AdSpriteSet(_gameRef);
if (!_defaultSpriteSet || DID_FAIL(_defaultSpriteSet->loadFile(_defaultSpriteSetFilename))) {
delete _defaultSpriteSet;
_defaultSpriteSet = NULL;
@@ -250,7 +250,7 @@ bool CAdTalkDef::loadDefaultSprite() { //////////////////////////////////////////////////////////////////////////
-CBSprite *CAdTalkDef::getDefaultSprite(TDirection dir) {
+BaseSprite *AdTalkDef::getDefaultSprite(TDirection dir) {
loadDefaultSprite();
if (_defaultSprite) return _defaultSprite;
else if (_defaultSpriteSet) return _defaultSpriteSet->getSprite(dir);
diff --git a/engines/wintermute/ad/ad_talk_def.h b/engines/wintermute/ad/ad_talk_def.h index 0811f5b8f5..fa32a81041 100644 --- a/engines/wintermute/ad/ad_talk_def.h +++ b/engines/wintermute/ad/ad_talk_def.h @@ -33,24 +33,24 @@ #include "engines/wintermute/base/base_object.h"
namespace WinterMute {
-class CAdTalkNode;
-class CAdSpriteSet;
-class CAdTalkDef : public CBObject {
+class AdTalkNode;
+class AdSpriteSet;
+class AdTalkDef : public BaseObject {
public:
char *_defaultSpriteSetFilename;
- CAdSpriteSet *_defaultSpriteSet;
- CBSprite *getDefaultSprite(TDirection Dir);
+ AdSpriteSet *_defaultSpriteSet;
+ BaseSprite *getDefaultSprite(TDirection Dir);
bool loadDefaultSprite();
- DECLARE_PERSISTENT(CAdTalkDef, CBObject)
+ DECLARE_PERSISTENT(AdTalkDef, BaseObject)
- CAdTalkDef(CBGame *inGame);
- virtual ~CAdTalkDef();
+ AdTalkDef(BaseGame *inGame);
+ virtual ~AdTalkDef();
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
- CBArray<CAdTalkNode *, CAdTalkNode *> _nodes;
+ BaseArray<AdTalkNode *, AdTalkNode *> _nodes;
char *_defaultSpriteFilename;
- CBSprite *_defaultSprite;
- virtual bool saveAsText(CBDynBuffer *buffer, int indent = 0);
+ BaseSprite *_defaultSprite;
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent = 0);
};
} // end of namespace WinterMute
diff --git a/engines/wintermute/ad/ad_talk_holder.cpp b/engines/wintermute/ad/ad_talk_holder.cpp index 28e62798c2..bd48ac601c 100644 --- a/engines/wintermute/ad/ad_talk_holder.cpp +++ b/engines/wintermute/ad/ad_talk_holder.cpp @@ -40,16 +40,16 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdTalkHolder, false)
+IMPLEMENT_PERSISTENT(AdTalkHolder, false)
//////////////////////////////////////////////////////////////////////////
-CAdTalkHolder::CAdTalkHolder(CBGame *inGame): CAdObject(inGame) {
+AdTalkHolder::AdTalkHolder(BaseGame *inGame): AdObject(inGame) {
_sprite = NULL;
}
//////////////////////////////////////////////////////////////////////////
-CAdTalkHolder::~CAdTalkHolder() {
+AdTalkHolder::~AdTalkHolder() {
delete _sprite;
_sprite = NULL;
@@ -63,19 +63,19 @@ CAdTalkHolder::~CAdTalkHolder() { }
//////////////////////////////////////////////////////////////////////////
-CBSprite *CAdTalkHolder::getTalkStance(const char *stance) {
- CBSprite *ret = NULL;
+BaseSprite *AdTalkHolder::getTalkStance(const char *stance) {
+ BaseSprite *ret = NULL;
// forced stance?
if (_forcedTalkAnimName && !_forcedTalkAnimUsed) {
_forcedTalkAnimUsed = true;
delete _animSprite;
- _animSprite = new CBSprite(_gameRef, this);
+ _animSprite = new BaseSprite(_gameRef, this);
if (_animSprite) {
bool res = _animSprite->loadFile(_forcedTalkAnimName);
if (DID_FAIL(res)) {
- _gameRef->LOG(res, "CAdTalkHolder::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
+ _gameRef->LOG(res, "AdTalkHolder::GetTalkStance: error loading talk sprite (object:\"%s\" sprite:\"%s\")", _name, _forcedTalkAnimName);
delete _animSprite;
_animSprite = NULL;
} else return _animSprite;
@@ -119,14 +119,14 @@ CBSprite *CAdTalkHolder::getTalkStance(const char *stance) { //////////////////////////////////////////////////////////////////////////
// high level scripting interface
//////////////////////////////////////////////////////////////////////////
-bool CAdTalkHolder::scCallMethod(CScScript *script, CScStack *stack, CScStack *thisStack, const char *name) {
+bool AdTalkHolder::scCallMethod(ScScript *script, ScStack *stack, ScStack *thisStack, const char *name) {
//////////////////////////////////////////////////////////////////////////
// SetSprite
//////////////////////////////////////////////////////////////////////////
if (strcmp(name, "SetSprite") == 0) {
stack->correctParams(1);
- CScValue *val = stack->pop();
+ ScValue *val = stack->pop();
bool setCurrent = false;
if (_currentSprite && _currentSprite == _sprite) setCurrent = true;
@@ -140,7 +140,7 @@ bool CAdTalkHolder::scCallMethod(CScScript *script, CScStack *stack, CScStack *t stack->pushBool(true);
} else {
const char *filename = val->getString();
- CBSprite *spr = new CBSprite(_gameRef, this);
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
script->runtimeError("SetSprite method failed for file '%s'", filename);
stack->pushBool(false);
@@ -184,7 +184,7 @@ bool CAdTalkHolder::scCallMethod(CScScript *script, CScStack *stack, CScStack *t const char *filename = stack->pop()->getString();
bool Ex = stack->pop()->getBool();
- CBSprite *spr = new CBSprite(_gameRef, this);
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
stack->pushBool(false);
script->runtimeError("AddTalkSprite method failed for file '%s'", filename);
@@ -255,7 +255,7 @@ bool CAdTalkHolder::scCallMethod(CScScript *script, CScStack *stack, CScStack *t bool setCurrent = false;
bool setTemp2 = false;
- CBSprite *spr = new CBSprite(_gameRef, this);
+ BaseSprite *spr = new BaseSprite(_gameRef, this);
if (!spr || DID_FAIL(spr->loadFile(filename))) {
stack->pushBool(false);
script->runtimeError("SetTalkSprite method failed for file '%s'", filename);
@@ -295,12 +295,12 @@ bool CAdTalkHolder::scCallMethod(CScScript *script, CScStack *stack, CScStack *t return STATUS_OK;
}
- else return CAdObject::scCallMethod(script, stack, thisStack, name);
+ else return AdObject::scCallMethod(script, stack, thisStack, name);
}
//////////////////////////////////////////////////////////////////////////
-CScValue *CAdTalkHolder::scGetProperty(const char *name) {
+ScValue *AdTalkHolder::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -311,12 +311,12 @@ CScValue *CAdTalkHolder::scGetProperty(const char *name) { return _scValue;
}
- else return CAdObject::scGetProperty(name);
+ else return AdObject::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdTalkHolder::scSetProperty(const char *name, CScValue *value) {
+bool AdTalkHolder::scSetProperty(const char *name, ScValue *value) {
/*
//////////////////////////////////////////////////////////////////////////
// Item
@@ -326,18 +326,18 @@ bool CAdTalkHolder::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else*/ return CAdObject::scSetProperty(name, value);
+ else*/ return AdObject::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-const char *CAdTalkHolder::scToString() {
+const char *AdTalkHolder::scToString() {
return "[talk-holder object]";
}
//////////////////////////////////////////////////////////////////////////
-bool CAdTalkHolder::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdTalkHolder::saveAsText(BaseDynamicBuffer *buffer, int indent) {
for (int i = 0; i < _talkSprites.getSize(); i++) {
if (_talkSprites[i]->_filename)
buffer->putTextIndent(indent + 2, "TALK=\"%s\"\n", _talkSprites[i]->_filename);
@@ -353,8 +353,8 @@ bool CAdTalkHolder::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkHolder::persist(CBPersistMgr *persistMgr) {
- CAdObject::persist(persistMgr);
+bool AdTalkHolder::persist(BasePersistenceManager *persistMgr) {
+ AdObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_sprite));
_talkSprites.persist(persistMgr);
diff --git a/engines/wintermute/ad/ad_talk_holder.h b/engines/wintermute/ad/ad_talk_holder.h index 50c2f3504b..8ad8ae1e52 100644 --- a/engines/wintermute/ad/ad_talk_holder.h +++ b/engines/wintermute/ad/ad_talk_holder.h @@ -33,21 +33,21 @@ namespace WinterMute {
-class CAdTalkHolder : public CAdObject {
+class AdTalkHolder : public AdObject {
public:
- DECLARE_PERSISTENT(CAdTalkHolder, CAdObject)
- virtual CBSprite *getTalkStance(const char *stance);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
- CBSprite *_sprite;
- CBArray<CBSprite *, CBSprite *> _talkSprites;
- CBArray<CBSprite *, CBSprite *> _talkSpritesEx;
- CAdTalkHolder(CBGame *inGame);
- virtual ~CAdTalkHolder();
+ DECLARE_PERSISTENT(AdTalkHolder, AdObject)
+ virtual BaseSprite *getTalkStance(const char *stance);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
+ BaseSprite *_sprite;
+ BaseArray<BaseSprite *, BaseSprite *> _talkSprites;
+ BaseArray<BaseSprite *, BaseSprite *> _talkSpritesEx;
+ AdTalkHolder(BaseGame *inGame);
+ virtual ~AdTalkHolder();
// 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();
};
diff --git a/engines/wintermute/ad/ad_talk_node.cpp b/engines/wintermute/ad/ad_talk_node.cpp index 3b82d731c9..5325b1aeff 100644 --- a/engines/wintermute/ad/ad_talk_node.cpp +++ b/engines/wintermute/ad/ad_talk_node.cpp @@ -36,10 +36,10 @@ #include "engines/wintermute/utils/utils.h"
namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdTalkNode, false)
+IMPLEMENT_PERSISTENT(AdTalkNode, false)
//////////////////////////////////////////////////////////////////////////
-CAdTalkNode::CAdTalkNode(CBGame *inGame): CBBase(inGame) {
+AdTalkNode::AdTalkNode(BaseGame *inGame): BaseClass(inGame) {
_sprite = NULL;
_spriteFilename = NULL;
_spriteSet = NULL;
@@ -53,7 +53,7 @@ CAdTalkNode::CAdTalkNode(CBGame *inGame): CBBase(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdTalkNode::~CAdTalkNode() {
+AdTalkNode::~AdTalkNode() {
delete[] _spriteFilename;
delete _sprite;
delete[] _spriteSetFilename;
@@ -80,7 +80,7 @@ TOKEN_DEF(PRECACHE) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdTalkNode::loadBuffer(byte *buffer, bool complete) {
+bool AdTalkNode::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(ACTION)
TOKEN_TABLE(SPRITESET_FILE)
@@ -95,7 +95,7 @@ bool CAdTalkNode::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_ACTION) {
@@ -112,16 +112,16 @@ bool CAdTalkNode::loadBuffer(byte *buffer, bool complete) { while ((cmd = parser.getCommand((char **)&buffer, commands, (char **)¶ms)) > 0) {
switch (cmd) {
case TOKEN_SPRITE:
- CBUtils::setString(&_spriteFilename, (char *)params);
+ BaseUtils::setString(&_spriteFilename, (char *)params);
break;
case TOKEN_SPRITESET_FILE:
- CBUtils::setString(&_spriteSetFilename, (char *)params);
+ BaseUtils::setString(&_spriteSetFilename, (char *)params);
break;
case TOKEN_SPRITESET: {
delete _spriteSet;
- _spriteSet = new CAdSpriteSet(_gameRef);
+ _spriteSet = new AdSpriteSet(_gameRef);
if (!_spriteSet || DID_FAIL(_spriteSet->loadBuffer(params, false))) {
delete _spriteSet;
_spriteSet = NULL;
@@ -143,7 +143,7 @@ bool CAdTalkNode::loadBuffer(byte *buffer, bool complete) { break;
case TOKEN_COMMENT:
- if (_gameRef->_editorMode) CBUtils::setString(&_comment, (char *)params);
+ if (_gameRef->_editorMode) BaseUtils::setString(&_comment, (char *)params);
break;
case TOKEN_EDITOR_PROPERTY:
@@ -168,14 +168,14 @@ bool CAdTalkNode::loadBuffer(byte *buffer, bool complete) { if (_preCache && _spriteFilename) {
delete _sprite;
- _sprite = new CBSprite(_gameRef);
+ _sprite = new BaseSprite(_gameRef);
if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename)))
return STATUS_FAILED;
}
if (_preCache && _spriteSetFilename) {
delete _spriteSet;
- _spriteSet = new CAdSpriteSet(_gameRef);
+ _spriteSet = new AdSpriteSet(_gameRef);
if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename)))
return STATUS_FAILED;
}
@@ -186,7 +186,7 @@ bool CAdTalkNode::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkNode::persist(CBPersistMgr *persistMgr) {
+bool AdTalkNode::persist(BasePersistenceManager *persistMgr) {
persistMgr->transfer(TMEMBER(_comment));
persistMgr->transfer(TMEMBER(_startTime));
persistMgr->transfer(TMEMBER(_endTime));
@@ -201,7 +201,7 @@ bool CAdTalkNode::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkNode::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdTalkNode::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "ACTION {\n");
if (_comment) buffer->putTextIndent(indent + 2, "COMMENT=\"%s\"\n", _comment);
buffer->putTextIndent(indent + 2, "START_TIME=%d\n", _startTime);
@@ -211,7 +211,7 @@ bool CAdTalkNode::saveAsText(CBDynBuffer *buffer, int indent) { else if (_spriteSet) _spriteSet->saveAsText(buffer, indent + 2);
if (_preCache) buffer->putTextIndent(indent + 2, "PRECACHE=\"%s\"\n", _preCache ? "TRUE" : "FALSE");
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
buffer->putTextIndent(indent, "}\n");
@@ -220,9 +220,9 @@ bool CAdTalkNode::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkNode::loadSprite() {
+bool AdTalkNode::loadSprite() {
if (_spriteFilename && !_sprite) {
- _sprite = new CBSprite(_gameRef);
+ _sprite = new BaseSprite(_gameRef);
if (!_sprite || DID_FAIL(_sprite->loadFile(_spriteFilename))) {
delete _sprite;
_sprite = NULL;
@@ -231,7 +231,7 @@ bool CAdTalkNode::loadSprite() { }
else if (_spriteSetFilename && !_spriteSet) {
- _spriteSet = new CAdSpriteSet(_gameRef);
+ _spriteSet = new AdSpriteSet(_gameRef);
if (!_spriteSet || DID_FAIL(_spriteSet->loadFile(_spriteSetFilename))) {
delete _spriteSet;
_spriteSet = NULL;
@@ -244,7 +244,7 @@ bool CAdTalkNode::loadSprite() { //////////////////////////////////////////////////////////////////////////
-bool CAdTalkNode::isInTimeInterval(uint32 time, TDirection dir) {
+bool AdTalkNode::isInTimeInterval(uint32 time, TDirection dir) {
if (time >= _startTime) {
if (_playToEnd) {
if ((_spriteFilename && _sprite == NULL) || (_sprite && _sprite->_finished == false)) return true;
@@ -256,7 +256,7 @@ bool CAdTalkNode::isInTimeInterval(uint32 time, TDirection dir) { //////////////////////////////////////////////////////////////////////////
-CBSprite *CAdTalkNode::getSprite(TDirection dir) {
+BaseSprite *AdTalkNode::getSprite(TDirection dir) {
loadSprite();
if (_sprite) return _sprite;
else if (_spriteSet) return _spriteSet->getSprite(dir);
diff --git a/engines/wintermute/ad/ad_talk_node.h b/engines/wintermute/ad/ad_talk_node.h index 55adf88e83..9e599b6af2 100644 --- a/engines/wintermute/ad/ad_talk_node.h +++ b/engines/wintermute/ad/ad_talk_node.h @@ -33,23 +33,23 @@ #include "engines/wintermute/base/base.h"
namespace WinterMute {
-class CAdSpriteSet;
-class CBSprite;
-class CAdTalkNode : public CBBase {
+class AdSpriteSet;
+class BaseSprite;
+class AdTalkNode : public BaseClass {
public:
char *_spriteSetFilename;
- CAdSpriteSet *_spriteSet;
- CBSprite *getSprite(TDirection dir);
+ AdSpriteSet *_spriteSet;
+ BaseSprite *getSprite(TDirection dir);
bool isInTimeInterval(uint32 time, TDirection dir);
bool loadSprite();
- DECLARE_PERSISTENT(CAdTalkNode, CBBase)
+ DECLARE_PERSISTENT(AdTalkNode, BaseClass)
- CAdTalkNode(CBGame *inGame);
- virtual ~CAdTalkNode();
+ AdTalkNode(BaseGame *inGame);
+ virtual ~AdTalkNode();
bool loadBuffer(byte *buffer, bool complete = true);
- virtual bool saveAsText(CBDynBuffer *buffer, int indent = 0);
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent = 0);
char *_spriteFilename;
- CBSprite *_sprite;
+ BaseSprite *_sprite;
uint32 _startTime;
uint32 _endTime;
bool _playToEnd;
diff --git a/engines/wintermute/ad/ad_waypoint_group.cpp b/engines/wintermute/ad/ad_waypoint_group.cpp index 4a902266ac..25e5345ee7 100644 --- a/engines/wintermute/ad/ad_waypoint_group.cpp +++ b/engines/wintermute/ad/ad_waypoint_group.cpp @@ -37,10 +37,10 @@ namespace WinterMute {
-IMPLEMENT_PERSISTENT(CAdWaypointGroup, false)
+IMPLEMENT_PERSISTENT(AdWaypointGroup, false)
//////////////////////////////////////////////////////////////////////////
-CAdWaypointGroup::CAdWaypointGroup(CBGame *inGame): CBObject(inGame) {
+AdWaypointGroup::AdWaypointGroup(BaseGame *inGame): BaseObject(inGame) {
_active = true;
_editorSelectedPoint = -1;
_lastMimicScale = -1;
@@ -49,13 +49,13 @@ CAdWaypointGroup::CAdWaypointGroup(CBGame *inGame): CBObject(inGame) { //////////////////////////////////////////////////////////////////////////
-CAdWaypointGroup::~CAdWaypointGroup() {
+AdWaypointGroup::~AdWaypointGroup() {
cleanup();
}
//////////////////////////////////////////////////////////////////////////
-void CAdWaypointGroup::cleanup() {
+void AdWaypointGroup::cleanup() {
for (int i = 0; i < _points.getSize(); i++)
delete _points[i];
_points.removeAll();
@@ -64,10 +64,10 @@ void CAdWaypointGroup::cleanup() { //////////////////////////////////////////////////////////////////////////
-bool CAdWaypointGroup::loadFile(const char *filename) {
+bool AdWaypointGroup::loadFile(const char *filename) {
byte *buffer = _gameRef->_fileManager->readWholeFile(filename);
if (buffer == NULL) {
- _gameRef->LOG(0, "CAdWaypointGroup::LoadFile failed for file '%s'", filename);
+ _gameRef->LOG(0, "AdWaypointGroup::LoadFile failed for file '%s'", filename);
return STATUS_FAILED;
}
@@ -96,7 +96,7 @@ TOKEN_DEF(PROPERTY) TOKEN_DEF(EDITOR_PROPERTY)
TOKEN_DEF_END
//////////////////////////////////////////////////////////////////////////
-bool CAdWaypointGroup::loadBuffer(byte *buffer, bool complete) {
+bool AdWaypointGroup::loadBuffer(byte *buffer, bool complete) {
TOKEN_TABLE_START(commands)
TOKEN_TABLE(WAYPOINTS)
TOKEN_TABLE(TEMPLATE)
@@ -110,7 +110,7 @@ bool CAdWaypointGroup::loadBuffer(byte *buffer, bool complete) { byte *params;
int cmd;
- CBParser parser(_gameRef);
+ BaseParser parser(_gameRef);
if (complete) {
if (parser.getCommand((char **)&buffer, commands, (char **)¶ms) != TOKEN_WAYPOINTS) {
@@ -133,7 +133,7 @@ bool CAdWaypointGroup::loadBuffer(byte *buffer, bool complete) { case TOKEN_POINT: {
int x, y;
parser.scanStr((char *)params, "%d,%d", &x, &y);
- _points.add(new CBPoint(x, y));
+ _points.add(new BasePoint(x, y));
}
break;
@@ -164,7 +164,7 @@ bool CAdWaypointGroup::loadBuffer(byte *buffer, bool complete) { //////////////////////////////////////////////////////////////////////////
-bool CAdWaypointGroup::saveAsText(CBDynBuffer *buffer, int indent) {
+bool AdWaypointGroup::saveAsText(BaseDynamicBuffer *buffer, int indent) {
buffer->putTextIndent(indent, "WAYPOINTS {\n");
buffer->putTextIndent(indent + 2, "NAME=\"%s\"\n", _name);
buffer->putTextIndent(indent + 2, "EDITOR_SELECTED=%s\n", _editorSelected ? "TRUE" : "FALSE");
@@ -172,7 +172,7 @@ bool CAdWaypointGroup::saveAsText(CBDynBuffer *buffer, int indent) { if (_scProp)
_scProp->saveAsText(buffer, indent + 2);
- CBBase::saveAsText(buffer, indent + 2);
+ BaseClass::saveAsText(buffer, indent + 2);
for (int i = 0; i < _points.getSize(); i++) {
buffer->putTextIndent(indent + 2, "POINT {%d,%d}\n", _points[i]->x, _points[i]->y);
@@ -185,9 +185,9 @@ bool CAdWaypointGroup::saveAsText(CBDynBuffer *buffer, int indent) { //////////////////////////////////////////////////////////////////////////
-bool CAdWaypointGroup::persist(CBPersistMgr *persistMgr) {
+bool AdWaypointGroup::persist(BasePersistenceManager *persistMgr) {
- CBObject::persist(persistMgr);
+ BaseObject::persist(persistMgr);
persistMgr->transfer(TMEMBER(_active));
persistMgr->transfer(TMEMBER(_editorSelectedPoint));
@@ -201,7 +201,7 @@ bool CAdWaypointGroup::persist(CBPersistMgr *persistMgr) { //////////////////////////////////////////////////////////////////////////
-CScValue *CAdWaypointGroup::scGetProperty(const char *name) {
+ScValue *AdWaypointGroup::scGetProperty(const char *name) {
_scValue->setNULL();
//////////////////////////////////////////////////////////////////////////
@@ -220,12 +220,12 @@ CScValue *CAdWaypointGroup::scGetProperty(const char *name) { return _scValue;
}
- else return CBObject::scGetProperty(name);
+ else return BaseObject::scGetProperty(name);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdWaypointGroup::scSetProperty(const char *name, CScValue *value) {
+bool AdWaypointGroup::scSetProperty(const char *name, ScValue *value) {
//////////////////////////////////////////////////////////////////////////
// Active
//////////////////////////////////////////////////////////////////////////
@@ -234,12 +234,12 @@ bool CAdWaypointGroup::scSetProperty(const char *name, CScValue *value) { return STATUS_OK;
}
- else return CBObject::scSetProperty(name, value);
+ else return BaseObject::scSetProperty(name, value);
}
//////////////////////////////////////////////////////////////////////////
-bool CAdWaypointGroup::mimic(CAdWaypointGroup *wpt, float scale, int argX, int argY) {
+bool AdWaypointGroup::mimic(AdWaypointGroup *wpt, float scale, int argX, int argY) {
if (scale == _lastMimicScale && argX == _lastMimicX && argY == _lastMimicY) return STATUS_OK;
cleanup();
@@ -248,7 +248,7 @@ bool CAdWaypointGroup::mimic(CAdWaypointGroup *wpt, float scale, int argX, int a int x = (int)((float)wpt->_points[i]->x * scale / 100.0f);
int y = (int)((float)wpt->_points[i]->y * scale / 100.0f);
- _points.add(new CBPoint(x + argX, y + argY));
+ _points.add(new BasePoint(x + argX, y + argY));
}
_lastMimicScale = scale;
diff --git a/engines/wintermute/ad/ad_waypoint_group.h b/engines/wintermute/ad/ad_waypoint_group.h index 2cece9e88b..f23f7be859 100644 --- a/engines/wintermute/ad/ad_waypoint_group.h +++ b/engines/wintermute/ad/ad_waypoint_group.h @@ -32,25 +32,25 @@ #include "engines/wintermute/base/base_object.h"
namespace WinterMute {
-class CBPoint;
-class CAdWaypointGroup : public CBObject {
+class BasePoint;
+class AdWaypointGroup : public BaseObject {
public:
float _lastMimicScale;
int _lastMimicX;
int _lastMimicY;
void cleanup();
- bool mimic(CAdWaypointGroup *wpt, float scale = 100.0f, int x = 0, int y = 0);
- DECLARE_PERSISTENT(CAdWaypointGroup, CBObject)
- virtual bool saveAsText(CBDynBuffer *buffer, int indent);
+ bool mimic(AdWaypointGroup *wpt, float scale = 100.0f, int x = 0, int y = 0);
+ DECLARE_PERSISTENT(AdWaypointGroup, BaseObject)
+ virtual bool saveAsText(BaseDynamicBuffer *buffer, int indent);
bool _active;
- CAdWaypointGroup(CBGame *inGame);
+ AdWaypointGroup(BaseGame *inGame);
bool loadFile(const char *filename);
bool loadBuffer(byte *buffer, bool complete = true);
- virtual ~CAdWaypointGroup();
- CBArray<CBPoint *, CBPoint *> _points;
+ virtual ~AdWaypointGroup();
+ BaseArray<BasePoint *, BasePoint *> _points;
int _editorSelectedPoint;
- virtual CScValue *scGetProperty(const char *name);
- virtual bool scSetProperty(const char *name, CScValue *value);
+ virtual ScValue *scGetProperty(const char *name);
+ virtual bool scSetProperty(const char *name, ScValue *value);
};
} // end of namespace WinterMute
|